Added -mlink-init-bitcode-file option to pre-populate new module with IR loaded from specified file.

[tra]

Summary

• Added -mlink-init-bitcode-file option to pre-populate new module with IR loaded from specified file.
• Accept IR assembly as well as bitcode.
• Added test case.

The change is needed for upcoming CUDA-related changes that require linking with large device-specific library provided as bitcode. Initializing module with the library IR is faster than linking the library in after compilation. It also allows convenient way to run some cuda-specific passes on the library IR (NVVM reflect and Internalize) alone without affecting IR we generate during compilation.

[echristo]

Is there any reason not to purpose the existing option for this?

Maybe do some archaeology to find out who added it and ask if it's fine to make it just start with the module?

-eric

[pcc]

I was the person who originally introduced this flag in r143314. As I recall this flag was introduced in order to support linking a bitcode module containing an implementation of a runtime library for a GPU (e.g. libclc).

The reason I made the flag link the bitcode after compilation was that I wanted to avoid breaking any invariants that Clang's code generator might have (e.g. if both the bitcode file and the C source file define a weak symbol, Clang's IR generator may get confused by the presence of a duplicate symbol, whereas the IR linker already knows to discard one of them). If avoiding the IR linker provides a significant performance advantage, it does seem reasonable to make -mlink-bitcode-file pre-populate the module, and start fixing any assumptions we're currently making in the IR generator.

[echristo]

Cool. I think that's probably how we should go.

Thanks!

-eric

[tra]

In D9721#185342, @pcc wrote:

The reason I made the flag link the bitcode after compilation was that I wanted to avoid breaking any invariants that Clang's code generator might have (e.g. if both the bitcode file and the C source file define a weak symbol, Clang's IR generator may get confused by the presence of a duplicate symbol, whereas the IR linker already knows to discard one of them). If avoiding the IR linker provides a significant performance advantage, it does seem reasonable to make -mlink-bitcode-file pre-populate the module, and start fixing any assumptions we're currently making in the IR generator.

Thanks, Peter. Weak symbols indeed do not work with this patch -- compiler complains about two definitions with the same mangled name.
Time for plan C...

[tra]

Plan C: I'll reuse existing -mlink-bitcode-file.

[echristo]

Sounds good. :)

-eric

include/clang/CodeGen/ModuleBuilder.h

namespace clang {
 
   /// CreateLLVMCodeGen - Create a CodeGenerator instance.
   /// It is the responsibility of the caller to call delete on
   /// the allocated CodeGenerator instance.
   CodeGenerator *CreateLLVMCodeGen(DiagnosticsEngine &Diags,
                                    const std::string &ModuleName,
                                    const CodeGenOptions &CGO,
                                    llvm::LLVMContext& C,
+                                   llvm::Module *InitModule = nullptr,
                                    CoverageSourceInfo *CoverageInfo = nullptr);
 }
 
 #endif

include/clang/Driver/CC1Options.td

 def mrelocation_model : Separate<["-"], "mrelocation-model">,
   HelpText<"The relocation model to use">;
 def munwind_tables : Flag<["-"], "munwind-tables">,
   HelpText<"Generate unwinding tables for all functions">;
 def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">,
   HelpText<"Emit complete constructors and destructors as aliases when possible">;
 def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">,
   HelpText<"Link the given bitcode file before performing optimizations.">;
+def mlink_init_bitcode_file : Separate<["-"], "mlink-init-bitcode-file">,
+  HelpText<"Link given bitcode file before code generation.">;
 def vectorize_loops : Flag<["-"], "vectorize-loops">,
   HelpText<"Run the Loop vectorization passes">;
 def vectorize_slp : Flag<["-"], "vectorize-slp">,
   HelpText<"Run the SLP vectorization passes">;
 def vectorize_slp_aggressive : Flag<["-"], "vectorize-slp-aggressive">,
   HelpText<"Run the BB vectorization passes">;
 def dependent_lib : Joined<["--"], "dependent-lib=">,
   HelpText<"Add dependent library">;

include/clang/Frontend/CodeGenOptions.h

public:
   /// The ABI to use for passing floating point arguments.
   std::string FloatABI;
 
   /// The float precision limit to use, if non-empty.
   std::string LimitFloatPrecision;
 
   /// The name of the bitcode file to link before optzns.
   std::string LinkBitcodeFile;
+  /// The name of bitcode file to load on module init.
+  std::string LinkInitBitcodeFile;
 
   /// The user provided name for the "main file", if non-empty. This is useful
   /// in situations where the input file name does not match the original input
   /// file, for example with -save-temps.
   std::string MainFileName;
 
   /// The name for the split debug info file that we'll break out. This is used
   /// in the backend for setting the name in the skeleton cu.

lib/CodeGen/CodeGenAction.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/Timer.h"
class BackendConsumer : public ASTConsumer {
     std::unique_ptr<llvm::Module> TheModule, LinkModule;
 
   public:
     BackendConsumer(BackendAction action, DiagnosticsEngine &_Diags,
                     const CodeGenOptions &compopts,
                     const TargetOptions &targetopts,
                     const LangOptions &langopts, bool TimePasses,
                     const std::string &infile, llvm::Module *LinkModule,
-                    raw_pwrite_stream *OS, LLVMContext &C,
-                    CoverageSourceInfo *CoverageInfo = nullptr)
+                    llvm::Module *InitModule, raw_pwrite_stream *OS,
+                    LLVMContext &C, CoverageSourceInfo *CoverageInfo = nullptr)
         : Diags(_Diags), Action(action), CodeGenOpts(compopts),
           TargetOpts(targetopts), LangOpts(langopts), AsmOutStream(OS),
           Context(nullptr), LLVMIRGeneration("LLVM IR Generation Time"),
-          Gen(CreateLLVMCodeGen(Diags, infile, compopts, C, CoverageInfo)),
+          Gen(CreateLLVMCodeGen(Diags, infile, compopts, C, InitModule,
+                                CoverageInfo)),
           LinkModule(LinkModule) {
       llvm::TimePassesIsEnabled = TimePasses;
     }
 
     std::unique_ptr<llvm::Module> takeModule() { return std::move(TheModule); }
     llvm::Module *takeLinkModule() { return LinkModule.release(); }
 
     void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
case Backend_EmitMCNull:
     return CI.createNullOutputFile();
   case Backend_EmitObj:
     return CI.createDefaultOutputFile(true, InFile, "o");
   }
 
   llvm_unreachable("Invalid action!");
 }
 
+static llvm::Module *loadIRFromFile(CompilerInstance &CI,
+                                    llvm::LLVMContext *Context,
+                                    const std::string &IRFileName) {
+    SMDiagnostic Err;
+    std::unique_ptr<llvm::Module> M =
+        getLazyIRFileModule(IRFileName, Err, *Context);
+    if (!M)
+      CI.getDiagnostics().Report(diag::err_cannot_open_file)
+          << IRFileName << Err.getMessage();
+    return M.release();
+}
+
 std::unique_ptr<ASTConsumer>
 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   BackendAction BA = static_cast<BackendAction>(Act);
   raw_pwrite_stream *OS = GetOutputStream(CI, InFile, BA);
   if (BA != Backend_EmitNothing && !OS)
     return nullptr;
 
   llvm::Module *LinkModuleToUse = LinkModule;
 
   // If we were not given a link module, and the user requested that one be
   // loaded from bitcode, do so now.
   const std::string &LinkBCFile = CI.getCodeGenOpts().LinkBitcodeFile;
   if (!LinkModuleToUse && !LinkBCFile.empty()) {
-    auto BCBuf = CI.getFileManager().getBufferForFile(LinkBCFile);
-    if (!BCBuf) {
-      CI.getDiagnostics().Report(diag::err_cannot_open_file)
-          << LinkBCFile << BCBuf.getError().message();
+    LinkModuleToUse = loadIRFromFile(CI, VMContext, LinkBCFile);
+    if (!LinkModuleToUse)
       return nullptr;
-    }
 
-    ErrorOr<llvm::Module *> ModuleOrErr =
-        getLazyBitcodeModule(std::move(*BCBuf), *VMContext);
-    if (std::error_code EC = ModuleOrErr.getError()) {
-      CI.getDiagnostics().Report(diag::err_cannot_open_file)
-        << LinkBCFile << EC.message();
+  llvm::Module *LinkInitModuleToUse = nullptr;
+  const std::string &LinkInitBCFile = CI.getCodeGenOpts().LinkInitBitcodeFile;
+  if (!LinkInitBCFile.empty()) {
+    LinkInitModuleToUse = loadIRFromFile(CI, VMContext, LinkInitBCFile);
+    if (!LinkInitModuleToUse)
       return nullptr;
-    }
-    LinkModuleToUse = ModuleOrErr.get();
-  }
 
   CoverageSourceInfo *CoverageInfo = nullptr;
   // Add the preprocessor callback only when the coverage mapping is generated.
   if (CI.getCodeGenOpts().CoverageMapping) {
     CoverageInfo = new CoverageSourceInfo;
     CI.getPreprocessor().addPPCallbacks(
                                     std::unique_ptr<PPCallbacks>(CoverageInfo));
   }
   std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
       BA, CI.getDiagnostics(), CI.getCodeGenOpts(), CI.getTargetOpts(),
       CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, InFile,
-      LinkModuleToUse, OS, *VMContext, CoverageInfo));
+      LinkModuleToUse, LinkInitModuleToUse, OS, *VMContext, CoverageInfo));
   BEConsumer = Result.get();
   return std::move(Result);
 }
 
 static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
                                          void *Context,
                                          unsigned LocCookie) {
   SM.print(nullptr, llvm::errs());

lib/CodeGen/ModuleBuilder.cpp

namespace {
   protected:
     std::unique_ptr<llvm::Module> M;
     std::unique_ptr<CodeGen::CodeGenModule> Builder;
 
   private:
     SmallVector<CXXMethodDecl *, 8> DeferredInlineMethodDefinitions;
 
   public:
-    CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string& ModuleName,
-                      const CodeGenOptions &CGO, llvm::LLVMContext& C,
+    CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string &ModuleName,
+                      const CodeGenOptions &CGO, llvm::LLVMContext &C,
+                      llvm::Module *InitModule,
                       CoverageSourceInfo *CoverageInfo = nullptr)
-      : Diags(diags), Ctx(nullptr), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
-        CoverageInfo(CoverageInfo),
-        M(new llvm::Module(ModuleName, C)) {}
+        : Diags(diags), Ctx(nullptr), CodeGenOpts(CGO),
+          HandlingTopLevelDecls(0), CoverageInfo(CoverageInfo),
+          M(InitModule ? InitModule : new llvm::Module(ModuleName, C)) {}
 
     ~CodeGeneratorImpl() override {
       // There should normally not be any leftover inline method definitions.
       assert(DeferredInlineMethodDefinitions.empty() ||
              Diags.hasErrorOccurred());
     }
 
     llvm::Module* GetModule() override {
void HandleDependentLibrary(llvm::StringRef Lib) override {
       Builder->AddDependentLib(Lib);
     }
   };
 }
 
 void CodeGenerator::anchor() { }
 
 CodeGenerator *clang::CreateLLVMCodeGen(DiagnosticsEngine &Diags,
-                                        const std::string& ModuleName,
+                                        const std::string &ModuleName,
                                         const CodeGenOptions &CGO,
-                                        llvm::LLVMContext& C,
+                                        llvm::LLVMContext &C,
+                                        llvm::Module *InitModule,
                                         CoverageSourceInfo *CoverageInfo) {
-  return new CodeGeneratorImpl(Diags, ModuleName, CGO, C, CoverageInfo);
+  return new CodeGeneratorImpl(Diags, ModuleName, CGO, C, InitModule,
+                               CoverageInfo);
 }

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   }
 
   Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
   Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
   Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
   Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections);
   Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
   Opts.LinkBitcodeFile = Args.getLastArgValue(OPT_mlink_bitcode_file);
+  Opts.LinkInitBitcodeFile = Args.getLastArgValue(OPT_mlink_init_bitcode_file);
   Opts.SanitizeCoverageType =
       getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
   Opts.SanitizeCoverageIndirectCalls =
       Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
   Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
   Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
   Opts.SanitizeCoverage8bitCounters =
       Args.hasArg(OPT_fsanitize_coverage_8bit_counters);

test/CodeGen/link-bitcode-file.c

 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -DBITCODE -emit-llvm-bc -o %t.bc %s
-// RUN: %clang_cc1 -triple i386-pc-linux-gnu -mlink-bitcode-file %t.bc -O3 -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-NO-BC %s
+// RUN: %clang_cc1 -triple i386-pc-linux-gnu -mlink-bitcode-file %t.bc -O3 -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-F-BC -check-prefix=CHECK-G %s
 // RUN: not %clang_cc1 -triple i386-pc-linux-gnu -DBITCODE -mlink-bitcode-file %t.bc -O3 -emit-llvm -o - %s 2>&1 | FileCheck -check-prefix=CHECK-BC %s
+// RUN: %clang_cc1 -triple i386-pc-linux-gnu -mlink-init-bitcode-file %t.bc -O3 -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-F-IBC -check-prefix=CHECK-G %s
+// RUN: not %clang_cc1 -triple i386-pc-linux-gnu -DBITCODE -mlink-init-bitcode-file %t.bc -O3 -emit-llvm -o - %s 2>&1 | FileCheck -check-prefix=CHECK-IBC %s
 // Make sure we deal with failure to load the file.
 // RUN: not %clang_cc1 -triple i386-pc-linux-gnu -mlink-bitcode-file no-such-file.bc \
 // RUN:    -emit-llvm -o - %s 2>&1 | FileCheck -check-prefix=CHECK-NO-FILE %s
+// RUN: not %clang_cc1 -triple i386-pc-linux-gnu -mlink-init-bitcode-file no-such-file.bc \
+// RUN:    -emit-llvm -o - %s 2>&1 | FileCheck -check-prefix=CHECK-NO-FILE %s
 
 int f(void);
 
 #ifdef BITCODE
 
+// Check for symbol conflicts between the file and loaded bitcode.
 // CHECK-BC: fatal error: cannot link module {{.*}}'f': symbol multiply defined
+// CHECK-IBC: error: definition with same mangled name as another definition
 int f(void) {
   return 42;
 }
 
 #else
 
-// CHECK-NO-BC-LABEL: define i32 @g
-// CHECK-NO-BC: ret i32 42
+// Init bitcode gets loaded first.
+// CHECK-F-IBC-LABEL: define i32 @f
+
+// CHECK-G-LABEL: define i32 @g
+// CHECK-G: ret i32 42
 int g(void) {
   return f();
 }
 
-// CHECK-NO-BC-LABEL: define i32 @f
+// regular bitcode gets linked in at the end.
+// CHECK-F-BC-LABEL: define i32 @f
 
 #endif
 
 // CHECK-NO-FILE: fatal error: cannot open file 'no-such-file.bc'