Add target-specific pre-linking passes to Clang

[yaxunl]

Summary

Sometimes a backend needs to apply certain target-specific passes before linking. This patch attempts to add that.

It depends on a new virtual member function addPreLinkPasses to be added to TargetMachine. The corresponding patch is here:

http://reviews.llvm.org/D20682

The link to the discussion in cfe-dev about pre-linking passes is here:

http://lists.llvm.org/pipermail/cfe-dev/2016-May/048822.html

[• tstellarAMD]

Can you give some examples of what pre-link passes may be required?

[yaxunl]

+ Brian

[yaxunl]

+Jeff

To cite some of the previous discussions (http://lists.llvm.org/pipermail/cfe-dev/2016-May/048822.html )

Brian:

On our side, we use such pre-link passes to interface with the specifics of our built-in function library. For example, we transform printf calls into a form that interacts with our library. We also transform calls to pipe functions, kernel enqueue related functions, and transform calls to the atomic functions to corresponding LLVM atomic instructions (and keep track of the memory scope elsewhere currently). You may have noticed that we have a proposal out to enable the atomic instructions to directly carry a memory scope.

Jeff:

We have similar passes related to builtin functions but they are rather specific to our implementation and not too complex.

Thanks.

Sam

[Anastasia]

Do you think we could add any test for this change?

lib/CodeGen/BackendUtil.cpp

657

Remove the empty line please

lib/CodeGen/CodeGenAction.cpp

169

Is there any reason for having this as a callback now?

Could we just add a call to prelink passes here above instead without modifying much the original flow?

[yaxunl]

In D20681#448443, @Anastasia wrote:

Do you think we could add any test for this change?

We have prelinking passes in amdgpu backend but it requires the llvm change to be committed first. We can add a test for this after that.

lib/CodeGen/CodeGenAction.cpp

169

EmitBackendOutput does not set its own diagnostic handler. When linking error happens, the diagnostic handler of BackendConsumer is used, which requires the member variable CurLinkModule of BackendConsumer to be set to current module to be linked to emit correct error msg. Therefore the linking step of EmitBackendOutput needs to update a member of BackendConsumer, a lambda function can achieve that with minimal change to other parts of the code.

An alternative implementation can do without the lambda function, but needs to

1. define a diagnostic handler for EmitBackendOutput
2. at the begining of EmitBackendOutput, save the old diagnostic handler and set the new one
3. at the end of EmitBackendOutput, recover the old diagnostic handler
4. define a helper class for diagnostic handler for EmitBackendOutput to retain the states needed for emitting diagnostic msgs
5. move or copy the diagnostic handling required by EmitBackendOutput from the diagnostic handler of BackendConsumer to the helper class of diagnostic handler for EmitBackendOutput

Do we want to take this approach?

[Anastasia]

In D20681#450073, @yaxunl wrote:

In D20681#448443, @Anastasia wrote:

Do you think we could add any test for this change?

We have prelinking passes in amdgpu backend but it requires the llvm change to be committed first. We can add a test for this after that.

Sure. Could you subscribe me to the relevant backend reviews if possible please? Thanks!

lib/CodeGen/CodeGenAction.cpp

169

I see, seems complicated indeed. Would returning the module into CurLinkModule be possible instead?

[yaxunl]

We have prelinking passes in amdgpu backend but it requires the llvm change to be committed first. We can add a test for this after that.

Sure. Could you subscribe me to the relevant backend reviews if possible please? Thanks!

Sure, will do when we review such a pass.

lib/CodeGen/CodeGenAction.cpp

169

We can replace the lambda function argument with two arguments: the modules to be linked with, and a pointer to CurLinkModule. Then CurLinkModule can be updated during linking.

There may be a more elegant way. I will see if I can add a new function for performing pre-linking passes and call it from HandleTranslationUnit. Then we can keep the linking stage in HandleTranslationUnit unchanged.

[yaxunl]

Refactor to eliminate lambda function argument.

[Anastasia]

LGTM! Looks much cleaner now. Please, add me to related reviews later on.

Thanks!

include/clang/CodeGen/BackendUtil.h

 //===--- BackendUtil.h - LLVM Backend Utilities -----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_CODEGEN_BACKENDUTIL_H
 #define LLVM_CLANG_CODEGEN_BACKENDUTIL_H
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
+#include <functional>
 #include <memory>
 
 namespace llvm {
   class Module;
   class MemoryBufferRef;
 }
 
 namespace clang {
   class DiagnosticsEngine;
   class CodeGenOptions;
   class TargetOptions;
   class LangOptions;
 
   enum BackendAction {
     Backend_EmitAssembly,  ///< Emit native assembly files
     Backend_EmitBC,        ///< Emit LLVM bitcode files
     Backend_EmitLL,        ///< Emit human-readable LLVM assembly
     Backend_EmitNothing,   ///< Don't emit anything (benchmarking mode)
     Backend_EmitMCNull,    ///< Run CodeGen, but don't emit anything
     Backend_EmitObj        ///< Emit native object files
   };
 
-  void EmitBackendOutput(DiagnosticsEngine &Diags, const CodeGenOptions &CGOpts,
-                         const TargetOptions &TOpts, const LangOptions &LOpts,
-                         const llvm::DataLayout &TDesc, llvm::Module *M,
-                         BackendAction Action, raw_pwrite_stream *OS);
+  // LinkCallBack is a call back function for linking the input module with
+  // other modules.
+  void EmitBackendOutput(
+    DiagnosticsEngine &Diags, const CodeGenOptions &CGOpts,
+    BackendAction Action, raw_pwrite_stream *OS,
+    std::function<bool(llvm::Module *)> *LinkCallBack = nullptr);
 
   void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
                     llvm::MemoryBufferRef Buf);
 }
 
 #endif

lib/CodeGen/BackendUtil.cpp

 
 class EmitAssemblyHelper {
   DiagnosticsEngine &Diags;
   const CodeGenOptions &CodeGenOpts;
   const clang::TargetOptions &TargetOpts;
   const LangOptions &LangOpts;
   Module *TheModule;
 
+  Timer PreLinkTime;
   Timer CodeGenerationTime;
 
+  mutable legacy::PassManager *PreLinkPasses;
   mutable legacy::PassManager *CodeGenPasses;
   mutable legacy::PassManager *PerModulePasses;
   mutable legacy::FunctionPassManager *PerFunctionPasses;
 
 private:
   TargetIRAnalysis getTargetIRAnalysis() const {
     if (TM)
       return TM->getTargetIRAnalysis();
legacy::FunctionPassManager *getPerFunctionPasses() const {
     if (!PerFunctionPasses) {
       PerFunctionPasses = new legacy::FunctionPassManager(TheModule);
       PerFunctionPasses->add(
           createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
     }
     return PerFunctionPasses;
   }
 
-  /// Set LLVM command line options passed through -backend-option.
-  void setCommandLineOpts();
+  legacy::PassManager *getPreLinkPasses() const {
+    if (!PreLinkPasses) {
+      PreLinkPasses = new legacy::PassManager();
+      PreLinkPasses->add(
+          createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
+    }
+    return PreLinkPasses;
+  }
 
   void CreatePasses(ModuleSummaryIndex *ModuleSummary);
 
   /// Generates the TargetMachine.
   /// Returns Null if it is unable to create the target machine.
   /// Some of our clang tests specify triples which are not built
   /// into clang. This is okay because these tests check the generated
   /// IR, and they require DataLayout which depends on the triple.
   /// In this case, we allow this method to fail and not report an error.
   /// When MustCreateTM is used, we print an error if we are unable to load
   /// the requested target.
   TargetMachine *CreateTargetMachine(bool MustCreateTM);
 
   /// Add passes necessary to emit assembly or LLVM IR.
   ///
   /// \return True on success.
   bool AddEmitPasses(BackendAction Action, raw_pwrite_stream &OS);
 
+  /// Add target specific pre-linking passes.
+  void AddPreLinkPasses(raw_pwrite_stream &OS);
+
 public:
   EmitAssemblyHelper(DiagnosticsEngine &_Diags, const CodeGenOptions &CGOpts,
                      const clang::TargetOptions &TOpts,
                      const LangOptions &LOpts, Module *M)
       : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
-        TheModule(M), CodeGenerationTime("Code Generation Time"),
+        TheModule(M), PreLinkTime("Pre-Linking Passes Time"),
+        CodeGenerationTime("Code Generation Time"), PreLinkPasses(nullptr),
         CodeGenPasses(nullptr), PerModulePasses(nullptr),
         PerFunctionPasses(nullptr) {}
 
   ~EmitAssemblyHelper() {
+    delete PreLinkPasses;
     delete CodeGenPasses;
     delete PerModulePasses;
     delete PerFunctionPasses;
     if (CodeGenOpts.DisableFree)
       BuryPointer(std::move(TM));
   }
 
   std::unique_ptr<TargetMachine> TM;
 
   void EmitAssembly(BackendAction Action, raw_pwrite_stream *OS);
+  void DoPreLinkPasses(raw_pwrite_stream *OS);
+
+  /// Set LLVM command line options passed through -backend-option.
+  void setCommandLineOpts();
+
+  /// Set up target for target specific pre-linking passes and LLVM code
+  /// generation.
+  void setTarget(BackendAction Action);
 };
 
 // We need this wrapper to access LangOpts and CGOpts from extension functions
 // that we add to the PassManagerBuilder.
 class PassManagerBuilderWrapper : public PassManagerBuilder {
 public:
   PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
                             const LangOptions &LangOpts)
void EmitAssemblyHelper::setCommandLineOpts() {
   }
   for (const std::string &BackendOption : CodeGenOpts.BackendOptions)
     BackendArgs.push_back(BackendOption.c_str());
   BackendArgs.push_back(nullptr);
   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
                                     BackendArgs.data());
 }
 
+void EmitAssemblyHelper::setTarget(BackendAction Action) {
+  bool UsesCodeGen = (Action != Backend_EmitNothing &&
+                      Action != Backend_EmitBC &&
+                      Action != Backend_EmitLL);
+  if (!TM)
+    TM.reset(CreateTargetMachine(UsesCodeGen));
+}
+
 TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
   // Create the TargetMachine for generating code.
   std::string Error;
   std::string Triple = TheModule->getTargetTriple();
   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
   if (!TheTarget) {
     if (MustCreateTM)
       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
 
   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
                                                      FeaturesStr, Options,
                                                      RM, CM, OptLevel);
 
   return TM;
 }
 
+
 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
                                        raw_pwrite_stream &OS) {
 
   // Create the code generator passes.
   legacy::PassManager *PM = getCodeGenPasses();
 
   // Add LibraryInfo.
   llvm::Triple TargetTriple(TheModule->getTargetTriple());
if (TM->addPassesToEmitFile(*PM, OS, CGFT,
                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
     Diags.Report(diag::err_fe_unable_to_interface_with_target);
     return false;
   }
 
   return true;
 }
 
+void EmitAssemblyHelper::AddPreLinkPasses(raw_pwrite_stream &OS) {
+  legacy::PassManager *PM = getPreLinkPasses();
+  TM->addPreLinkPasses(*PM, OS);
+}
+
 void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
                                       raw_pwrite_stream *OS) {
   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
 
-  setCommandLineOpts();
-
   bool UsesCodeGen = (Action != Backend_EmitNothing &&
                       Action != Backend_EmitBC &&
                       Action != Backend_EmitLL);
-  if (!TM)
-    TM.reset(CreateTargetMachine(UsesCodeGen));
 
   if (UsesCodeGen && !TM)
     return;
   if (TM)
     TheModule->setDataLayout(TM->createDataLayout());
 
   // If we are performing a ThinLTO importing compile, load the function
   // index into memory and pass it into CreatePasses, which will add it
void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
   }
 
   if (CodeGenPasses) {
     PrettyStackTraceString CrashInfo("Code generation");
     CodeGenPasses->run(*TheModule);
   }
 }
 
-void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
-                              const CodeGenOptions &CGOpts,
-                              const clang::TargetOptions &TOpts,
-                              const LangOptions &LOpts, const llvm::DataLayout &TDesc,
-                              Module *M, BackendAction Action,
-                              raw_pwrite_stream *OS) {
+void EmitAssemblyHelper::DoPreLinkPasses(raw_pwrite_stream *OS) {
+  TimeRegion Region(llvm::TimePassesIsEnabled ? &PreLinkTime : nullptr);
+
+  if (!TM)
+    return;
+
+  AddPreLinkPasses(*OS);
+
+  // Before executing passes, print the final values of the LLVM options.
+  cl::PrintOptionValues();
+
+  if (PreLinkPasses) {
+    PrettyStackTraceString CrashInfo("Pre-linking passes");
+    PreLinkPasses->run(*TheModule);
+  }
+}
+
+void clang::EmitBackendOutput(
+  DiagnosticsEngine &Diags, const CodeGenOptions &CGOpts,
+  const clang::TargetOptions &TOpts, const LangOptions &LOpts,
+  const llvm::DataLayout &TDesc, Module *M,
+  BackendAction Action, raw_pwrite_stream *OS,
+  std::function<bool(Module *)> *LinkCallBack) {
   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
 
+  AsmHelper.setCommandLineOpts();
+  AsmHelper.setTarget(Action);
+
+  if (LinkCallBack) {
+    AsmHelper.DoPreLinkPasses(OS);
+    if ((*LinkCallBack)(M))
+      return;
+  }
+
+  EmbedBitcode(M, CGOpts, llvm::MemoryBufferRef());
+
   AsmHelper.EmitAssembly(Action, OS);
 
   // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
   // DataLayout.
   if (AsmHelper.TM) {
     std::string DLDesc = M->getDataLayout().getStringRepresentation();
     if (DLDesc != TDesc.getStringRepresentation()) {
       unsigned DiagID = Diags.getCustomDiagID(

lib/CodeGen/CodeGenAction.cpp

void HandleTranslationUnit(ASTContext &C) override {
       void *OldContext = Ctx.getInlineAsmDiagnosticContext();
       Ctx.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, this);
 
       LLVMContext::DiagnosticHandlerTy OldDiagnosticHandler =
           Ctx.getDiagnosticHandler();
       void *OldDiagnosticContext = Ctx.getDiagnosticContext();
       Ctx.setDiagnosticHandler(DiagnosticHandler, this);
 
+      std::function<bool(llvm::Module*)>
+        LinkCallBack = [=](llvm::Module *M)->bool {
         // Link LinkModule into this module if present, preserving its validity.
         for (auto &I : LinkModules) {
           unsigned LinkFlags = I.first;
           CurLinkModule = I.second.get();
           if (Linker::linkModules(*getModule(), std::move(I.second), LinkFlags))
-          return;
+            return true;
         }
-
-      EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef());
-
+        return false;
+      };
       EmitBackendOutput(Diags, CodeGenOpts, TargetOpts, LangOpts,
                         C.getTargetInfo().getDataLayout(),
-                        getModule(), Action, AsmOutStream);
+                        getModule(), Action, AsmOutStream, &LinkCallBack);
 
       Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
 
       Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext);
     }
 
     void HandleTagDeclDefinition(TagDecl *D) override {
       PrettyStackTraceDecl CrashInfo(D, SourceLocation(),