LTO: Simplify merged module ownership.

[pcc]

Summary

This change moves LTOCodeGenerator's ownership of the merged module to a
field of type std::unique_ptr<Module>. This helps simplify parts of the code
and clears the way for the module to be consumed by LLVM CodeGen (see D12132
review comments).

This changes the C API semantics (lto_codegen_set_module now destroys its
argument) so I have incremented the API version.

[pcc]

• Restore and deprecate the old lto_codegen_set_module() behaviour until Apple can fix their linker
• Do not destroy the merged module after code generation
• clang-format

[pcc]

• Restore ownership semantics for lto_codegen_set_module
• Remove all remaining references to module via IRLinker

[pcc]

Rename OwnedModule to MergedModule; split out mechanical changes to r245874

include/llvm-c/lto.h

 
 /**
  * @defgroup LLVMCLTO LTO
  * @ingroup LLVMC
  *
  * @{
  */
 
-#define LTO_API_VERSION 17
+#define LTO_API_VERSION 18
 
 /**
  * \since prior to LTO_API_VERSION=3
  */
 typedef enum {
     LTO_SYMBOL_ALIGNMENT_MASK              = 0x0000001F, /* log2 of alignment */
     LTO_SYMBOL_PERMISSIONS_MASK            = 0x000000E0,
     LTO_SYMBOL_PERMISSIONS_CODE            = 0x000000A0,

  * lto_module_create_in_codegen_context().
  *
  * \since prior to LTO_API_VERSION=3
  */
 extern lto_bool_t
 lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod);
 
 /**
- * Sets the object module for code generation. This will transfer the ownship of
- * the module to code generator.
+ * Sets the object module for code generation. This will destroy the module.
  *
  * \c cg and \c mod must both be in the same context.
  *
  * \since LTO_API_VERSION=13
  */
 extern void
 lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod);
 

include/llvm/LTO/LTOCodeGenerator.h

struct LTOCodeGenerator {
   LTOCodeGenerator();
   LTOCodeGenerator(std::unique_ptr<LLVMContext> Context);
   ~LTOCodeGenerator();
 
   // Merge given module, return true on success.
   bool addModule(struct LTOModule *);
 
   // Set the destination module.
-  void setModule(struct LTOModule *);
+  void setModule(std::unique_ptr<LTOModule> M);
 
   void setTargetOptions(TargetOptions options);
   void setDebugInfo(lto_debug_model);
   void setCodePICModel(lto_codegen_model);
 
   void setCpu(const char *mCpu) { MCpu = mCpu; }
   void setAttr(const char *mAttr) { MAttr = mAttr; }
   void setOptLevel(unsigned optLevel) { OptLevel = optLevel; }
private:
   bool determineTarget(std::string &errMsg);
 
   static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context);
 
   void DiagnosticHandler2(const DiagnosticInfo &DI);
 
   typedef StringMap<uint8_t> StringSet;
 
-  void destroyMergedModule();
   std::unique_ptr<LLVMContext> OwnedContext;
   LLVMContext &Context;
+  std::unique_ptr<Module> OwnedModule;
   Linker IRLinker;
   TargetMachine *TargetMach = nullptr;
   bool EmitDwarfDebugInfo = false;
   bool ScopeRestrictionsDone = false;
   lto_codegen_model CodeModel = LTO_CODEGEN_PIC_MODEL_DEFAULT;
   StringSet MustPreserveSymbols;
   StringSet AsmUndefinedRefs;
   std::vector<char *> CodegenOptions;
   std::string MCpu;
   std::string MAttr;
   std::string NativeObjectPath;
   TargetOptions Options;
   unsigned OptLevel = 2;
   lto_diagnostic_handler_t DiagHandler = nullptr;
   void *DiagContext = nullptr;
-  LTOModule *OwnedModule = nullptr;
   bool ShouldInternalize = true;
   bool ShouldEmbedUselists = false;
 };
 }
 #endif

include/llvm/LTO/LTOModule.h

public:
 
   const Module &getModule() const {
     return const_cast<LTOModule*>(this)->getModule();
   }
   Module &getModule() {
     return IRFile->getModule();
   }
 
+  std::unique_ptr<Module> takeModule() {
+    return IRFile->takeModule();
+  }
+
   /// Return the Module's target triple.
   const std::string &getTargetTriple() {
     return getModule().getTargetTriple();
   }
 
   /// Set the Module's target triple.
   void setTargetTriple(StringRef Triple) {
     getModule().setTargetTriple(Triple);

include/llvm/Linker/Linker.h

struct IdentifiedStructTypeSet {
     void switchToNonOpaque(StructType *Ty);
     void addOpaque(StructType *Ty);
     StructType *findNonOpaque(ArrayRef<Type *> ETypes, bool IsPacked);
     bool hasType(StructType *Ty);
   };
 
   Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
   Linker(Module *M);
-  ~Linker();
 
   Module *getModule() const { return Composite; }
   void deleteModule();
 
   /// \brief Link \p Src into the composite. The source is destroyed.
   /// Passing OverrideSymbols as true will have symbols from Src
   /// shadow those in the Dest.
   /// Returns true on error.

lib/LTO/LTOCodeGenerator.cpp

 #ifdef LLVM_VERSION_INFO
   return PACKAGE_NAME " version " PACKAGE_VERSION ", " LLVM_VERSION_INFO;
 #else
   return PACKAGE_NAME " version " PACKAGE_VERSION;
 #endif
 }
 
 LTOCodeGenerator::LTOCodeGenerator()
-    : Context(getGlobalContext()), IRLinker(new Module("ld-temp.o", Context)) {
+    : Context(getGlobalContext()),
+      OwnedModule(new Module("ld-temp.o", Context)),
+      IRLinker(OwnedModule.get()) {
   initializeLTOPasses();
 }
 
 LTOCodeGenerator::LTOCodeGenerator(std::unique_ptr<LLVMContext> Context)
     : OwnedContext(std::move(Context)), Context(*OwnedContext),
-      IRLinker(new Module("ld-temp.o", *OwnedContext)) {
+      OwnedModule(new Module("ld-temp.o", *OwnedContext)),
+      IRLinker(OwnedModule.get()) {
   initializeLTOPasses();
 }
 
-void LTOCodeGenerator::destroyMergedModule() {
-  if (OwnedModule) {
-    assert(IRLinker.getModule() == &OwnedModule->getModule() &&
-           "The linker's module should be the same as the owned module");
-    delete OwnedModule;
-    OwnedModule = nullptr;
-  } else if (IRLinker.getModule())
-    IRLinker.deleteModule();
-}
-
 LTOCodeGenerator::~LTOCodeGenerator() {
-  destroyMergedModule();
-
   delete TargetMach;
   TargetMach = nullptr;
 
   for (std::vector<char *>::iterator I = CodegenOptions.begin(),
                                      E = CodegenOptions.end();
        I != E; ++I)
     free(*I);
 }
bool LTOCodeGenerator::addModule(LTOModule *mod) {
 
   const std::vector<const char*> &undefs = mod->getAsmUndefinedRefs();
   for (int i = 0, e = undefs.size(); i != e; ++i)
     AsmUndefinedRefs[undefs[i]] = 1;
 
   return !ret;
 }
 
-void LTOCodeGenerator::setModule(LTOModule *Mod) {
+void LTOCodeGenerator::setModule(std::unique_ptr<LTOModule> Mod) {
   assert(&Mod->getModule().getContext() == &Context &&
          "Expected module in same context");
 
-  // Delete the old merged module.
-  destroyMergedModule();
   AsmUndefinedRefs.clear();
 
-  OwnedModule = Mod;
-  IRLinker.setModule(&Mod->getModule());
+  OwnedModule = Mod->takeModule();
+  IRLinker.setModule(OwnedModule.get());
 
   const std::vector<const char*> &Undefs = Mod->getAsmUndefinedRefs();
   for (int I = 0, E = Undefs.size(); I != E; ++I)
     AsmUndefinedRefs[Undefs[I]] = 1;
 }
 
 void LTOCodeGenerator::setTargetOptions(TargetOptions options) {
   Options = options;
bool LTOCodeGenerator::optimize(bool DisableInline,
   return true;
 }
 
 bool LTOCodeGenerator::compileOptimized(raw_pwrite_stream &out,
                                         std::string &errMsg) {
   if (!this->determineTarget(errMsg))
     return false;
 
-  Module *mergedModule = IRLinker.getModule();
-
   legacy::PassManager codeGenPasses;
 
   // If the bitcode files contain ARC code and were compiled with optimization,
   // the ObjCARCContractPass must be run, so do it unconditionally here.
   codeGenPasses.add(createObjCARCContractPass());
 
   if (TargetMach->addPassesToEmitFile(codeGenPasses, out,
                                       TargetMachine::CGFT_ObjectFile)) {
     errMsg = "target file type not supported";
     return false;
   }
 
   // Run the code generator, and write assembly file
-  codeGenPasses.run(*mergedModule);
+  codeGenPasses.run(*OwnedModule.get());
+
+  // Finally destroy the module as we no longer need it
+  OwnedModule.reset();
 
   return true;
 }
 
 /// setCodeGenDebugOptions - Set codegen debugging options to aid in debugging
 /// LTO problems.
 void LTOCodeGenerator::setCodeGenDebugOptions(const char *options) {
   for (std::pair<StringRef, StringRef> o = getToken(options);

lib/Linker/LinkModules.cpp

 }
 
 Linker::Linker(Module *M) {
   init(M, [this](const DiagnosticInfo &DI) {
     Composite->getContext().diagnose(DI);
   });
 }
 
-Linker::~Linker() {
-}
-
 void Linker::deleteModule() {
   delete Composite;
   Composite = nullptr;
 }
 
 bool Linker::linkInModule(Module *Src, bool OverrideSymbols) {
   ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src,
                          DiagnosticHandler, OverrideSymbols);

tools/llvm-lto/llvm-lto.cpp

for (unsigned i = BaseArg; i < InputFilenames.size(); ++i) {
     std::unique_ptr<LTOModule> Module(
         LTOModule::createFromFile(InputFilenames[i].c_str(), Options, error));
     if (!error.empty()) {
       errs() << argv[0] << ": error loading file '" << InputFilenames[i]
              << "': " << error << "\n";
       return 1;
     }
 
-    LTOModule *LTOMod = Module.get();
-
-    // We use the first input module as the destination module when
-    // SetMergedModule is true.
-    if (SetMergedModule && i == BaseArg) {
-      // Transfer ownership to the code generator.
-      CodeGen.setModule(Module.release());
-    } else if (!CodeGen.addModule(Module.get()))
-      return 1;
-
-    unsigned NumSyms = LTOMod->getSymbolCount();
+    unsigned NumSyms = Module->getSymbolCount();
     for (unsigned I = 0; I < NumSyms; ++I) {
-      StringRef Name = LTOMod->getSymbolName(I);
+      StringRef Name = Module->getSymbolName(I);
       if (!DSOSymbolsSet.count(Name))
         continue;
-      lto_symbol_attributes Attrs = LTOMod->getSymbolAttributes(I);
+      lto_symbol_attributes Attrs = Module->getSymbolAttributes(I);
       unsigned Scope = Attrs & LTO_SYMBOL_SCOPE_MASK;
       if (Scope != LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN)
         KeptDSOSyms.push_back(Name);
     }
+
+    // We use the first input module as the destination module when
+    // SetMergedModule is true.
+    if (SetMergedModule && i == BaseArg) {
+      // Transfer ownership to the code generator.
+      CodeGen.setModule(std::move(Module));
+    } else if (!CodeGen.addModule(Module.get()))
+      return 1;
   }
 
   // Add all the exported symbols to the table of symbols to preserve.
   for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
     CodeGen.addMustPreserveSymbol(ExportedSymbols[i].c_str());
 
   // Add all the dso symbols to the table of symbols to expose.
   for (unsigned i = 0; i < KeptDSOSyms.size(); ++i)

tools/lto/lto.cpp

 
 void lto_codegen_dispose(lto_code_gen_t cg) { delete unwrap(cg); }
 
 bool lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod) {
   return !unwrap(cg)->addModule(unwrap(mod));
 }
 
 void lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod) {
-  unwrap(cg)->setModule(unwrap(mod));
+  unwrap(cg)->setModule(std::unique_ptr<LTOModule>(unwrap(mod)));
 }
 
 bool lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model debug) {
   unwrap(cg)->setDebugInfo(debug);
   return false;
 }
 
 bool lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model model) {