[ThinLTO] Move ThinLTOCodeGenerator implementation to target the new LTO API.

[mehdi_amini]

Summary

Since the new LTO API does not expose the individual steps in a
convenient manner, it implies changing a bit how llvm-lto works
and there was some churns with the tests.

[mehdi_amini]

Update after running the test-suite

[tejohnson]

Sorry for the delay.

I didn't go through the test changes in any detail - what is the main reason the new API caused changes to the way llvm-lto worked and the resulting test behavior?

include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

208

Document callback here and in the other changed interfaces, and remove description of Index being updated since it is no longer passed.

lib/LTO/ThinLTOCodeGenerator.cpp

214

Comment needs update here and for other changed interfaces.

357

This variable never used.

363

I'm a little confused about what this interface is used for - why are we asserting if there is any stream requested?

418

s/only gets global symbol/only get global symbols/

425

early continue instead?

434

Maybe combine with earlier duplicated flag checks into a variable like IsWeak

444

I believe this loop nest can be merged with the above (since the first copy always selected as prevailing)

[mehdi_amini]

I didn't go through the test changes in any detail - what is the main reason the new API caused changes to the way llvm-lto worked and the resulting test behavior?

Mainly: the new LTO API does not allow to test the individual phases of the ThinLTO process without using "-save-temps". So you can't also run a later phase without running the earlier ones, which some tests were doing.

[mehdi_amini]

lib/LTO/ThinLTOCodeGenerator.cpp

363

I'll make it more clear. The ThinLTO code generator is not supposed to have any non-ThinLTO file at this point.
In the libLTO C API, the LTO and ThinLTO path are not unified at this time.

[pcc]

I suppose a higher level question is whether you want to reimplement the entire ThinLTOCodeGenerator or just the libLTO interface?

lib/LTO/ThinLTOCodeGenerator.cpp

361

*Output

363

I think this is because this output callback is being used in cases where a hook is aborting the pipeline early by returning false (see e.g. ThinLTOCodeGenerator::promote) so we would never expect to reach here. It would probably be clearer if this was spelt out explicitly.

[mehdi_amini]

In D23778#545093, @pcc wrote:

I suppose a higher level question is whether you want to reimplement the entire ThinLTOCodeGenerator or just the libLTO interface?

Interestingly, I see it the opposite way: I'm trying for now to reimplement only the ThinLTOCodegenerator and not the full libLTO interface :)

include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Target/TargetOptions.h"
 
 #include <string>
 
 namespace llvm {
 class StringRef;
-class LLVMContext;
 class TargetMachine;
+namespace lto {
+struct Config;
+class LTO;
+}
 
 /// Helper to gather options relevant to the target machine creation
 struct TargetMachineBuilder {
   Triple TheTriple;
   std::string MCpu;
   std::string MAttr;
   TargetOptions Options;
   Optional<Reloc::Model> RelocModel;
public:
    */
   std::unique_ptr<ModuleSummaryIndex> linkCombinedIndex();
 
   /**
    * Perform promotion and renaming of exported internal functions,
    * and additionally resolve weak and linkonce symbols.
    * Index is updated to reflect linkage changes from weak resolution.
    */
-  void promote(Module &Module, ModuleSummaryIndex &Index);
+  void promote(std::function<void(unsigned, const Module &)> Callback);
 
   /**
    * Compute and emit the imported files for module at \p ModulePath.
    */
   static void emitImports(StringRef ModulePath, StringRef OutputName,
                           ModuleSummaryIndex &Index);
 
   /**
    * Perform cross-module importing for the module identified by
    * ModuleIdentifier.
    */
-  void crossModuleImport(Module &Module, ModuleSummaryIndex &Index);
+  void
+  crossModuleImport(std::function<void(unsigned, const Module &)> Callback);
 
   /**
    * Compute the list of summaries needed for importing into module.
    */
   static void gatherImportedSummariesForModule(
       StringRef ModulePath, ModuleSummaryIndex &Index,
       std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
 
   /**
    * Perform internalization. Index is updated to reflect linkage changes.
    */
-  void internalize(Module &Module, ModuleSummaryIndex &Index);
+  void internalize(std::function<void(unsigned, const Module &)>);
 
   /**
    * Perform post-importing ThinLTO optimizations.
    */
   void optimize(Module &Module);
 
   /**
    * Perform ThinLTO CodeGen.
    */
   std::unique_ptr<MemoryBuffer> codegen(Module &Module);
 
   /**@}*/
 
 private:
+  /// Build the configuration for the LTO API
+  lto::Config getLTOConfig();
+
+  /// Go through the objects, build the resolutions, and add these to the LTO
+  /// Code Generator.
+  void populateCodeGenerator(lto::LTO &Codegen);
+
+  /// Run the LTO pipeline using the supplied configuration. This private method
+  /// is used by individual steps (internalize, promote, ...).
+  void runWithConfig(lto::Config Conf);
+
   /// Helper factory to build a TargetMachine
   TargetMachineBuilder TMBuilder;
 
   /// Vector holding the in-memory buffer containing the produced binaries.
   std::vector<std::unique_ptr<MemoryBuffer>> ProducedBinaries;
 
   /// Vector holding the input buffers containing the bitcode modules to
   /// process.

lib/LTO/ThinLTOCodeGenerator.cpp

 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IRReader/IRReader.h"
+#include "llvm/LTO/Caching.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"

 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 
 #include <numeric>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "thinlto"
 
-namespace llvm {
-// Flags -discard-value-names, defined in LTOCodeGenerator.cpp
-extern cl::opt<bool> LTODiscardValueNames;
-}
-
 namespace {
 
 static cl::opt<int> ThreadCount("threads",
                                 cl::init(std::thread::hardware_concurrency()));
 
 static void diagnosticHandler(const DiagnosticInfo &DI) {
   DiagnosticPrinterRawOStream DP(errs());
   DI.print(DP);
   errs() << '\n';
 }
 
-// Simple helper to save temporary files for debug.
-static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
-                            unsigned count, StringRef Suffix) {
-  if (TempDir.empty())
-    return;
-  // User asked to save temps, let dump the bitcode file after import.
-  std::string SaveTempPath = (TempDir + llvm::utostr(count) + Suffix).str();
-  std::error_code EC;
-  raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
-  if (EC)
-    report_fatal_error(Twine("Failed to open ") + SaveTempPath +
-                       " to save optimized bitcode\n");
-  WriteBitcodeToFile(&TheModule, OS, /* ShouldPreserveUseListOrder */ true);
-}
-
-static const GlobalValueSummary *
-getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
-  // If there is any strong definition anywhere, get it.
-  auto StrongDefForLinker = llvm::find_if(
-      GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
-        auto Linkage = Summary->linkage();
-        return !GlobalValue::isAvailableExternallyLinkage(Linkage) &&
-               !GlobalValue::isWeakForLinker(Linkage);
-      });
-  if (StrongDefForLinker != GVSummaryList.end())
-    return StrongDefForLinker->get();
-  // Get the first *linker visible* definition for this global in the summary
-  // list.
-  auto FirstDefForLinker = llvm::find_if(
-      GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
-        auto Linkage = Summary->linkage();
-        return !GlobalValue::isAvailableExternallyLinkage(Linkage);
-      });
-  // Extern templates can be emitted as available_externally.
-  if (FirstDefForLinker == GVSummaryList.end())
-    return nullptr;
-  return FirstDefForLinker->get();
-}
-
-// Populate map of GUID to the prevailing copy for any multiply defined
-// symbols. Currently assume first copy is prevailing, or any strong
-// definition. Can be refined with Linker information in the future.
-static void computePrevailingCopies(
-    const ModuleSummaryIndex &Index,
-    DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy) {
-  auto HasMultipleCopies = [&](const GlobalValueSummaryList &GVSummaryList) {
-    return GVSummaryList.size() > 1;
-  };
-
-  for (auto &I : Index) {
-    if (HasMultipleCopies(I.second))
-      PrevailingCopy[I.first] = getFirstDefinitionForLinker(I.second);
-  }
-}
-
-static StringMap<MemoryBufferRef>
-generateModuleMap(const std::vector<MemoryBufferRef> &Modules) {
-  StringMap<MemoryBufferRef> ModuleMap;
-  for (auto &ModuleBuffer : Modules) {
-    assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
-               ModuleMap.end() &&
-           "Expect unique Buffer Identifier");
-    ModuleMap[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer;
-  }
-  return ModuleMap;
-}
-
-static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) {
-  if (renameModuleForThinLTO(TheModule, Index))
-    report_fatal_error("renameModuleForThinLTO failed");
-}
-
-static void
-crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
-                      StringMap<MemoryBufferRef> &ModuleMap,
-                      const FunctionImporter::ImportMapTy &ImportList) {
-  ModuleLoader Loader(TheModule.getContext(), ModuleMap);
-  FunctionImporter Importer(Index, Loader);
-  Importer.importFunctions(TheModule, ImportList);
-}
-
 static void optimizeModule(Module &TheModule, TargetMachine &TM) {
   // Populate the PassManager
   PassManagerBuilder PMB;
   PMB.LibraryInfo = new TargetLibraryInfoImpl(TM.getTargetTriple());
   PMB.Inliner = createFunctionInliningPass();
   // FIXME: should get it from the bitcode?
   PMB.OptLevel = 3;
   PMB.LoopVectorize = true;
   PMB.SLPVectorize = true;
   PMB.VerifyInput = true;
   PMB.VerifyOutput = false;
 
   legacy::PassManager PM;
 
   // Add the TTI (required to inform the vectorizer about register size for
   // instance)
   PM.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
 
   // Add optimizations
   PMB.populateThinLTOPassManager(PM);
 
   PM.run(TheModule);
 }
 
-// Convert the PreservedSymbols map from "Name" based to "GUID" based.
-static DenseSet<GlobalValue::GUID>
-computeGUIDPreservedSymbols(const StringSet<> &PreservedSymbols,
-                            const Triple &TheTriple) {
-  DenseSet<GlobalValue::GUID> GUIDPreservedSymbols(PreservedSymbols.size());
-  for (auto &Entry : PreservedSymbols) {
-    StringRef Name = Entry.first();
-    if (TheTriple.isOSBinFormatMachO() && Name.size() > 0 && Name[0] == '_')
-      Name = Name.drop_front();
-    GUIDPreservedSymbols.insert(GlobalValue::getGUID(Name));
-  }
-  return GUIDPreservedSymbols;
-}
-
 std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
                                             TargetMachine &TM) {
   SmallVector<char, 128> OutputBuffer;
 
   // CodeGen
   {
     raw_svector_ostream OS(OutputBuffer);
     legacy::PassManager PM;
 
     // If the bitcode files contain ARC code and were compiled with optimization,
     // the ObjCARCContractPass must be run, so do it unconditionally here.
     PM.add(createObjCARCContractPass());
 
     // Setup the codegen now.
     if (TM.addPassesToEmitFile(PM, OS, TargetMachine::CGFT_ObjectFile,
                                /* DisableVerify */ true))
       report_fatal_error("Failed to setup codegen");
 
     // Run codegen now. resulting binary is in OutputBuffer.
     PM.run(TheModule);
   }
   return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
 }
 
-/// Manage caching for a single Module.
-class ModuleCacheEntry {
-  SmallString<128> EntryPath;
-
-public:
-  // Create a cache entry. This compute a unique hash for the Module considering
-  // the current list of export/import, and offer an interface to query to
-  // access the content in the cache.
-  ModuleCacheEntry(
-      StringRef CachePath, const ModuleSummaryIndex &Index, StringRef ModuleID,
-      const FunctionImporter::ImportMapTy &ImportList,
-      const FunctionImporter::ExportSetTy &ExportList,
-      const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
-      const GVSummaryMapTy &DefinedFunctions,
-      const DenseSet<GlobalValue::GUID> &PreservedSymbols) {
-    if (CachePath.empty())
-      return;
-
-    // Compute the unique hash for this entry
-    // This is based on the current compiler version, the module itself, the
-    // export list, the hash for every single module in the import list, the
-    // list of ResolvedODR for the module, and the list of preserved symbols.
-
-    SHA1 Hasher;
-
-    // Start with the compiler revision
-    Hasher.update(LLVM_VERSION_STRING);
-#ifdef HAVE_LLVM_REVISION
-    Hasher.update(LLVM_REVISION);
-#endif
-
-    // Include the hash for the current module
-    auto ModHash = Index.getModuleHash(ModuleID);
-    Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
-    for (auto F : ExportList)
-      // The export list can impact the internalization, be conservative here
-      Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
-
-    // Include the hash for every module we import functions from
-    for (auto &Entry : ImportList) {
-      auto ModHash = Index.getModuleHash(Entry.first());
-      Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
-    }
-
-    // Include the hash for the resolved ODR.
-    for (auto &Entry : ResolvedODR) {
-      Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
-                                      sizeof(GlobalValue::GUID)));
-      Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
-                                      sizeof(GlobalValue::LinkageTypes)));
-    }
-
-    // Include the hash for the preserved symbols.
-    for (auto &Entry : PreservedSymbols) {
-      if (DefinedFunctions.count(Entry))
-        Hasher.update(
-            ArrayRef<uint8_t>((const uint8_t *)&Entry, sizeof(GlobalValue::GUID)));
-    }
-
-    sys::path::append(EntryPath, CachePath, toHex(Hasher.result()));
-  }
-
-  // Access the path to this entry in the cache.
-  StringRef getEntryPath() { return EntryPath; }
-
-  // Try loading the buffer for this cache entry.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> tryLoadingBuffer() {
-    if (EntryPath.empty())
-      return std::error_code();
-    return MemoryBuffer::getFile(EntryPath);
-  }
-
-  // Cache the Produced object file
-  std::unique_ptr<MemoryBuffer>
-  write(std::unique_ptr<MemoryBuffer> OutputBuffer) {
-    if (EntryPath.empty())
-      return OutputBuffer;
-
-    // Write to a temporary to avoid race condition
-    SmallString<128> TempFilename;
-    int TempFD;
-    std::error_code EC =
-        sys::fs::createTemporaryFile("Thin", "tmp.o", TempFD, TempFilename);
-    if (EC) {
-      errs() << "Error: " << EC.message() << "\n";
-      report_fatal_error("ThinLTO: Can't get a temporary file");
-    }
-    {
-      raw_fd_ostream OS(TempFD, /* ShouldClose */ true);
-      OS << OutputBuffer->getBuffer();
-    }
-    // Rename to final destination (hopefully race condition won't matter here)
-    EC = sys::fs::rename(TempFilename, EntryPath);
-    if (EC) {
-      sys::fs::remove(TempFilename);
-      raw_fd_ostream OS(EntryPath, EC, sys::fs::F_None);
-      if (EC)
-        report_fatal_error(Twine("Failed to open ") + EntryPath +
-                           " to save cached entry\n");
-      OS << OutputBuffer->getBuffer();
-    }
-    auto ReloadedBufferOrErr = MemoryBuffer::getFile(EntryPath);
-    if (auto EC = ReloadedBufferOrErr.getError()) {
-      // FIXME diagnose
-      errs() << "error: can't reload cached file '" << EntryPath
-             << "': " << EC.message() << "\n";
-      return OutputBuffer;
-    }
-    return std::move(*ReloadedBufferOrErr);
-  }
-};
-
-static std::unique_ptr<MemoryBuffer>
-ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
-                     StringMap<MemoryBufferRef> &ModuleMap, TargetMachine &TM,
-                     const FunctionImporter::ImportMapTy &ImportList,
-                     const FunctionImporter::ExportSetTy &ExportList,
-                     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
-                     const GVSummaryMapTy &DefinedGlobals,
-                     const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
-                     bool DisableCodeGen, StringRef SaveTempsDir,
-                     unsigned count) {
-
-  // "Benchmark"-like optimization: single-source case
-  bool SingleModule = (ModuleMap.size() == 1);
-
-  if (!SingleModule) {
-    promoteModule(TheModule, Index);
-
-    // Apply summary-based LinkOnce/Weak resolution decisions.
-    thinLTOResolveWeakForLinkerModule(TheModule, DefinedGlobals);
-
-    // Save temps: after promotion.
-    saveTempBitcode(TheModule, SaveTempsDir, count, ".1.promoted.bc");
-  }
-
-  // Be friendly and don't nuke totally the module when the client didn't
-  // supply anything to preserve.
-  if (!ExportList.empty() || !GUIDPreservedSymbols.empty()) {
-    // Apply summary-based internalization decisions.
-    thinLTOInternalizeModule(TheModule, DefinedGlobals);
-  }
-
-  // Save internalized bitcode
-  saveTempBitcode(TheModule, SaveTempsDir, count, ".2.internalized.bc");
-
-  if (!SingleModule) {
-    crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
-
-    // Save temps: after cross-module import.
-    saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
-  }
-
-  optimizeModule(TheModule, TM);
-
-  saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
-
-  if (DisableCodeGen) {
-    // Configured to stop before CodeGen, serialize the bitcode and return.
-    SmallVector<char, 128> OutputBuffer;
-    {
-      raw_svector_ostream OS(OutputBuffer);
-      auto Index = buildModuleSummaryIndex(TheModule);
-      WriteBitcodeToFile(&TheModule, OS, true, &Index);
-    }
-    return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
-  }
-
-  return codegenModule(TheModule, TM);
-}
-
-/// Resolve LinkOnce/Weak symbols. Record resolutions in the \p ResolvedODR map
-/// for caching, and in the \p Index for application during the ThinLTO
-/// backends. This is needed for correctness for exported symbols (ensure
-/// at least one copy kept) and a compile-time optimization (to drop duplicate
-/// copies when possible).
-static void resolveWeakForLinkerInIndex(
-    ModuleSummaryIndex &Index,
-    StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
-        &ResolvedODR) {
-
-  DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
-  computePrevailingCopies(Index, PrevailingCopy);
-
-  auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
-    const auto &Prevailing = PrevailingCopy.find(GUID);
-    // Not in map means that there was only one copy, which must be prevailing.
-    if (Prevailing == PrevailingCopy.end())
-      return true;
-    return Prevailing->second == S;
-  };
-
-  auto recordNewLinkage = [&](StringRef ModuleIdentifier,
-                              GlobalValue::GUID GUID,
-                              GlobalValue::LinkageTypes NewLinkage) {
-    ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
-  };
-
-  thinLTOResolveWeakForLinkerInIndex(Index, isPrevailing, recordNewLinkage);
-}
-
 // Initialize the TargetMachine builder for a given Triple
 static void initTMBuilder(TargetMachineBuilder &TMBuilder,
                           const Triple &TheTriple) {
   // Set a default CPU for Darwin triples (copied from LTOCodeGenerator).
   // FIXME this looks pretty terrible...
   if (TMBuilder.MCpu.empty() && TheTriple.isOSDarwin()) {
     if (TheTriple.getArch() == llvm::Triple::x86_64)
       TMBuilder.MCpu = "core2";
if (CombinedIndex) {
       CombinedIndex = std::move(Index);
     }
   }
   return CombinedIndex;
 }
 
 /**
  * Perform promotion and renaming of exported internal functions.
  * Index is updated to reflect linkage changes from weak resolution.
  */
-void ThinLTOCodeGenerator::promote(Module &TheModule,
-                                   ModuleSummaryIndex &Index) {
-  auto ModuleCount = Index.modulePaths().size();
-  auto ModuleIdentifier = TheModule.getModuleIdentifier();
-  // Collect for each module the list of function it defines (GUID -> Summary).
-  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
-  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
-
-  // Convert the preserved symbols set from string to GUID
-  auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
-      PreservedSymbols, Triple(TheModule.getTargetTriple()));
-
-  // Compute "dead" symbols, we don't want to import/export these!
-  auto DeadSymbols = computeDeadSymbols(Index, GUIDPreservedSymbols);
-
-  // Generate import/export list
-  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
-  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
-  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
-                           ExportLists, &DeadSymbols);
-
-  // Resolve LinkOnce/Weak symbols.
-  StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
-  resolveWeakForLinkerInIndex(Index, ResolvedODR);
-
-  thinLTOResolveWeakForLinkerModule(
-      TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
+void ThinLTOCodeGenerator::promote(
+    std::function<void(unsigned, const Module &)> Callback) {
+  // Initial configuration
+  auto Conf = getLTOConfig();
+
+  // Setup the client hook.
+  Conf.PostPromoteModuleHook = [&](unsigned Task, const Module &M) {
+    Callback(Task, M);
+    return false;
+  };
 
-  promoteModule(TheModule, Index);
+  runWithConfig(std::move(Conf));
 }
 
 /**
  * Perform cross-module importing for the module identified by ModuleIdentifier.
  */
-void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
-                                             ModuleSummaryIndex &Index) {
-  auto ModuleMap = generateModuleMap(Modules);
-  auto ModuleCount = Index.modulePaths().size();
-
-  // Collect for each module the list of function it defines (GUID -> Summary).
-  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
-  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
-
-  // Convert the preserved symbols set from string to GUID
-  auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
-      PreservedSymbols, Triple(TheModule.getTargetTriple()));
-
-  // Compute "dead" symbols, we don't want to import/export these!
-  auto DeadSymbols = computeDeadSymbols(Index, GUIDPreservedSymbols);
-
-  // Generate import/export list
-  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
-  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
-  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
-                           ExportLists, &DeadSymbols);
-  auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
+void ThinLTOCodeGenerator::crossModuleImport(
+    std::function<void(unsigned, const Module &)> Callback) {
+  // Initial configuration
+  auto Conf = getLTOConfig();
+
+  // Setup the client hook.
+  Conf.PostImportModuleHook = [&](unsigned Task, const Module &M) {
+    Callback(Task, M);
+    return false;
+  };
 
-  crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
+  runWithConfig(std::move(Conf));
 }
 
 /**
  * Compute the list of summaries needed for importing into module.
  */
 void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
     StringRef ModulePath, ModuleSummaryIndex &Index,
     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
void ThinLTOCodeGenerator::emitImports(StringRef ModulePath,
   if ((EC = EmitImportsFiles(ModulePath, OutputName, ImportLists[ModulePath])))
     report_fatal_error(Twine("Failed to open ") + OutputName +
                        " to save imports lists\n");
 }
 
 /**
  * Perform internalization. Index is updated to reflect linkage changes.
  */
-void ThinLTOCodeGenerator::internalize(Module &TheModule,
-                                       ModuleSummaryIndex &Index) {
-  initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
-  auto ModuleCount = Index.modulePaths().size();
-  auto ModuleIdentifier = TheModule.getModuleIdentifier();
-
-  // Convert the preserved symbols set from string to GUID
-  auto GUIDPreservedSymbols =
-      computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
-
-  // Collect for each module the list of function it defines (GUID -> Summary).
-  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
-  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
-
-  // Compute "dead" symbols, we don't want to import/export these!
-  auto DeadSymbols = computeDeadSymbols(Index, GUIDPreservedSymbols);
-
-  // Generate import/export list
-  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
-  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
-  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
-                           ExportLists, &DeadSymbols);
-  auto &ExportList = ExportLists[ModuleIdentifier];
-
-  // Be friendly and don't nuke totally the module when the client didn't
-  // supply anything to preserve.
-  if (ExportList.empty() && GUIDPreservedSymbols.empty())
-    return;
-
-  // Internalization
-  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
-    const auto &ExportList = ExportLists.find(ModuleIdentifier);
-    return (ExportList != ExportLists.end() &&
-            ExportList->second.count(GUID)) ||
-           GUIDPreservedSymbols.count(GUID);
+void ThinLTOCodeGenerator::internalize(
+    std::function<void(unsigned, const Module &)> Callback) {
+  // Initial configuration
+  auto Conf = getLTOConfig();
+
+  // Setup the client hook.
+  Conf.PostInternalizeModuleHook = [&](unsigned Task, const Module &M) {
+    Callback(Task, M);
+    return false;
   };
-  thinLTOInternalizeAndPromoteInIndex(Index, isExported);
-  thinLTOInternalizeModule(TheModule,
-                           ModuleToDefinedGVSummaries[ModuleIdentifier]);
+
+  runWithConfig(std::move(Conf));
 }
 
 /**
  * Perform post-importing ThinLTO optimizations.
  */
 void ThinLTOCodeGenerator::optimize(Module &TheModule) {
   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
 
   // Optimize now
   optimizeModule(TheModule, *TMBuilder.create());
 }
 
 /**
  * Perform ThinLTO CodeGen.
  */
 std::unique_ptr<MemoryBuffer> ThinLTOCodeGenerator::codegen(Module &TheModule) {
   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
   return codegenModule(TheModule, *TMBuilder.create());
 }
 
-// Main entry point for the ThinLTO processing
-void ThinLTOCodeGenerator::run() {
-  if (CodeGenOnly) {
-    // Perform only parallel codegen and return.
-    ThreadPool Pool;
-    assert(ProducedBinaries.empty() && "The generator should not be reused");
-    ProducedBinaries.resize(Modules.size());
-    int count = 0;
-    for (auto &ModuleBuffer : Modules) {
-      Pool.async([&](int count) {
-        LLVMContext Context;
-        Context.setDiscardValueNames(LTODiscardValueNames);
-
-        // Parse module now
-        auto TheModule = loadModuleFromBuffer(ModuleBuffer, Context, false);
+namespace {
+// Define the LTOOutput handling
+class LTOOutput : public lto::NativeObjectOutput {
+  SmallVector<char, 0> OutputBuffer;
+  std::unique_ptr<MemoryBuffer> &Output;
 
-        // CodeGen
-        ProducedBinaries[count] = codegen(*TheModule);
-      }, count++);
-    }
-
-    return;
+public:
+  LTOOutput(std::unique_ptr<MemoryBuffer> &Output) : Output(Output) {}
+  ~LTOOutput() {
+    Output = make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
+  std::unique_ptr<raw_pwrite_stream> getStream() override {
+    return make_unique<raw_svector_ostream>(OutputBuffer);
   }
-
-  // Sequential linking phase
-  auto Index = linkCombinedIndex();
-
-  // Save temps: index.
-  if (!SaveTempsDir.empty()) {
-    auto SaveTempPath = SaveTempsDir + "index.bc";
-    std::error_code EC;
-    raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
-    if (EC)
-      report_fatal_error(Twine("Failed to open ") + SaveTempPath +
-                         " to save optimized bitcode\n");
-    WriteIndexToFile(*Index, OS);
-  }
+};
 
-  // Prepare the resulting object vector
-  assert(ProducedBinaries.empty() && "The generator should not be reused");
-  ProducedBinaries.resize(Modules.size());
-
-  // Prepare the module map.
-  auto ModuleMap = generateModuleMap(Modules);
-  auto ModuleCount = Modules.size();
-
-  // Collect for each module the list of function it defines (GUID -> Summary).
-  StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
-  Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
-
-  // Convert the preserved symbols set from string to GUID, this is needed for
-  // computing the caching hash and the internalization.
-  auto GUIDPreservedSymbols =
-      computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
-
-  // Compute "dead" symbols, we don't want to import/export these!
-  auto DeadSymbols = computeDeadSymbols(*Index, GUIDPreservedSymbols);
-
-  // Collect the import/export lists for all modules from the call-graph in the
-  // combined index.
-  StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
-  StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
-  ComputeCrossModuleImport(*Index, ModuleToDefinedGVSummaries, ImportLists,
-                           ExportLists, &DeadSymbols);
-
-  // We use a std::map here to be able to have a defined ordering when
-  // producing a hash for the cache entry.
-  // FIXME: we should be able to compute the caching hash for the entry based
-  // on the index, and nuke this map.
-  StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
-
-  // Resolve LinkOnce/Weak symbols, this has to be computed early because it
-  // impacts the caching.
-  resolveWeakForLinkerInIndex(*Index, ResolvedODR);
-
-  auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
-    const auto &ExportList = ExportLists.find(ModuleIdentifier);
-    return (ExportList != ExportLists.end() &&
-            ExportList->second.count(GUID)) ||
-           GUIDPreservedSymbols.count(GUID);
+void ThinLTOCodeGenerator::runWithConfig(lto::Config Conf) {
+  // Create the code generator
+  lto::ThinBackend Backend = lto::createInProcessThinBackend(ThreadCount);
+  lto::LTO Codegen(std::move(Conf), Backend);
+
+  // Add inputs to the CodeGenerator and get it ready for processing.
+  populateCodeGenerator(Codegen);
+
+  // We have no guarantee that all Tasks will feed an output buffer. So we use
+  // an intermediate vector to store each possible output.
+  std::vector<std::unique_ptr<MemoryBuffer>> OutputBuffers;
+  OutputBuffers.resize(Codegen.getMaxTasks());
+  // Callback for the LTO API.
+  auto AddOutput =
+      [&](unsigned Task) -> std::unique_ptr<lto::NativeObjectOutput> {
+    struct AssertingLTOOuput : public lto::NativeObjectOutput {
+      std::unique_ptr<raw_pwrite_stream> getStream() override {
+        report_fatal_error("Unexpected");
+      }
+    };
+    return make_unique<AssertingLTOOuput>();
   };
 
-  // Use global summary-based analysis to identify symbols that can be
-  // internalized (because they aren't exported or preserved as per callback).
-  // Changes are made in the index, consumed in the ThinLTO backends.
-  thinLTOInternalizeAndPromoteInIndex(*Index, isExported);
-
-  // Make sure that every module has an entry in the ExportLists and
-  // ResolvedODR maps to enable threaded access to these maps below.
-  for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
-    ExportLists[DefinedGVSummaries.first()];
-    ResolvedODR[DefinedGVSummaries.first()];
-  }
-
-  // Compute the ordering we will process the inputs: the rough heuristic here
-  // is to sort them per size so that the largest module get schedule as soon as
-  // possible. This is purely a compile-time optimization.
-  std::vector<int> ModulesOrdering;
-  ModulesOrdering.resize(Modules.size());
-  std::iota(ModulesOrdering.begin(), ModulesOrdering.end(), 0);
-  std::sort(ModulesOrdering.begin(), ModulesOrdering.end(),
-            [&](int LeftIndex, int RightIndex) {
-              auto LSize = Modules[LeftIndex].getBufferSize();
-              auto RSize = Modules[RightIndex].getBufferSize();
-              return LSize > RSize;
-            });
+  // Run the actual optimizations/codegen now.
+  auto Err = Codegen.run(AddOutput);
+  if (Err)
+    report_fatal_error("FATAL: Codegen.run error: " + toString(std::move(Err)));
+}
+
+lto::Config ThinLTOCodeGenerator::getLTOConfig() {
+  lto::Config Conf;
+  // Initialize the LTO options
+  Conf.DiagHandler = diagnosticHandler;
+  Conf.CPU = TMBuilder.MCpu;
+  Conf.Options = TMBuilder.Options;
+  StringRef MAttrs = TMBuilder.MAttr;
+  while (!MAttrs.empty()) {
+    StringRef MAttr;
+    std::tie(MAttr, MAttrs) = MAttrs.split(",");
+    Conf.MAttrs.push_back(MAttr);
+  }
+  if (TMBuilder.RelocModel)
+    Conf.RelocModel = *TMBuilder.RelocModel;
+  Conf.CGOptLevel = TMBuilder.CGOptLevel;
+  Conf.DisableVerify = true;
+  Conf.OptLevel = 3; // FIXME parameter...
+  Conf.CodeGenOnly = CodeGenOnly;
+
+  if (!SaveTempsDir.empty())
+    if (auto EC = Conf.addSaveTemps(SaveTempsDir))
+      report_fatal_error("Can add save temps dir");
+
+  return Conf;
+}
+
+void ThinLTOCodeGenerator::populateCodeGenerator(lto::LTO &Codegen) {
+  // Perform symbol resolution first, preparing all the lto::Input to feed to
+  // the LTO API.
+  std::vector<std::unique_ptr<lto::InputFile>> Inputs;
+  Inputs.reserve(Modules.size());
 
-  // Parallel optimizer + codegen
-  {
-    ThreadPool Pool(ThreadCount);
-    for (auto IndexCount : ModulesOrdering) {
-      auto &ModuleBuffer = Modules[IndexCount];
-      Pool.async([&](int count) {
-        auto ModuleIdentifier = ModuleBuffer.getBufferIdentifier();
-        auto &ExportList = ExportLists[ModuleIdentifier];
-
-        auto &DefinedFunctions = ModuleToDefinedGVSummaries[ModuleIdentifier];
-
-        // The module may be cached, this helps handling it.
-        ModuleCacheEntry CacheEntry(CacheOptions.Path, *Index, ModuleIdentifier,
-                                    ImportLists[ModuleIdentifier], ExportList,
-                                    ResolvedODR[ModuleIdentifier],
-                                    DefinedFunctions, GUIDPreservedSymbols);
+  // Keep a map from symbol name to the input that defines it.
+  StringMap<std::pair<lto::InputFile *, bool /* IsWeak */>> PrevailingSymbols;
 
-        {
-          auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
-          DEBUG(dbgs() << "Cache " << (ErrOrBuffer ? "hit" : "miss") << " '"
-                       << CacheEntry.getEntryPath() << "' for buffer " << count
-                       << " " << ModuleIdentifier << "\n");
-
-          if (ErrOrBuffer) {
-            // Cache Hit!
-            ProducedBinaries[count] = std::move(ErrOrBuffer.get());
-            return;
-          }
-        }
-
-        LLVMContext Context;
-        Context.setDiscardValueNames(LTODiscardValueNames);
-        Context.enableDebugTypeODRUniquing();
-
-        // Parse module now
-        auto TheModule = loadModuleFromBuffer(ModuleBuffer, Context, false);
-
-        // Save temps: original file.
-        saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
-
-        auto &ImportList = ImportLists[ModuleIdentifier];
-        // Run the main process now, and generates a binary
-        auto OutputBuffer = ProcessThinLTOModule(
-            *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
-            ExportList, GUIDPreservedSymbols,
-            ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
-            DisableCodeGen, SaveTempsDir, count);
-
-        OutputBuffer = CacheEntry.write(std::move(OutputBuffer));
-        ProducedBinaries[count] = std::move(OutputBuffer);
-      }, IndexCount);
-    }
-  }
+  // First create all the InputFile and go through all the symbols, keeping
+  // track of prevailing copies.
+  for (auto &ModuleBuffer : Modules) {
+    auto InputOrErr = lto::InputFile::create(ModuleBuffer);
+    if (!InputOrErr)
+      report_fatal_error("Can't load input? '" +
+                         ModuleBuffer.getBufferIdentifier() + "'");
+    std::unique_ptr<lto::InputFile> Input = std::move(*InputOrErr);
+    // Iterate symbols in the input file. We only gets global symbol here, so
+    // the only logic we need is to mark prevailing the first copy of a weak
+    // symbol.
+    for (const lto::InputFile::Symbol &Sym : Input->symbols()) {
+      if (Sym.getName().empty())
+        report_fatal_error("Unexpected Unnamed LTO symbol");
+
+      if (!(Sym.getFlags() & object::BasicSymbolRef::SF_Undefined)) {
+        auto &Entry = PrevailingSymbols[Sym.getName()];
+        if (Entry.first && !Entry.second &&
+            !(Sym.getFlags() & (object::BasicSymbolRef::SF_Weak |
+                                object::BasicSymbolRef::SF_Common)))
+          // Non-weak duplicate symbol definitions are not allowed
+          report_fatal_error(Twine("Duplicated symbol:") + Sym.getName());
+        if (!Entry.first) {
+          Entry.first = Input.get();
+          Entry.second = (Sym.getFlags() & (object::BasicSymbolRef::SF_Weak |
+                                            object::BasicSymbolRef::SF_Common));
+    }
+    Inputs.push_back(std::move(Input));
+  }
+
+  // For each input, build the actual Resolution vector, and add the input to
+  // the CodeGen.
+  for (auto &Input : Inputs) {
+    std::vector<lto::SymbolResolution> Resolutions;
+    for (const lto::InputFile::Symbol &Sym : Input->symbols()) {
+      assert(!Sym.getName().empty());
+
+      lto::SymbolResolution Resolution;
+
+      auto PrevailingInput = PrevailingSymbols.find(Sym.getName());
+      if (PrevailingInput != PrevailingSymbols.end()) {
+        // If this symbol is in the map, we know for sure that the final
+        // definition
+        // is in the linkage unit. With better linker information, we could have
+        // the list of symbol defined in non-LTO files...
+        Resolution.FinalDefinitionInLinkageUnit = true;
+
+        // If this occurence of the symbol is the prevailing one, mark it.
+        if (PrevailingInput->second.first == Input.get())
+          Resolution.Prevailing = true;
+      }
+
+      // If the linker asked the symbol to be preserved, it needs to be marked
+      // as visible outside the LTO unit / to regular objects.
+      if (PreservedSymbols.empty() || PreservedSymbols.count(Sym.getName()))
+        Resolution.VisibleToRegularObj = true;
+
+      Resolutions.push_back(Resolution);
+    }
+
+    Error Err = Codegen.add(std::move(Input), Resolutions);
+    if (Err)
+      report_fatal_error("FATAL");
 
+// Main entry point for the ThinLTO processing
+void ThinLTOCodeGenerator::run() {
+  auto Conf = getLTOConfig();
+  lto::ThinBackend Backend = lto::createInProcessThinBackend(ThreadCount);
+  lto::LTO Codegen(std::move(Conf), Backend);
+
+  // Add inputs to the CodeGenerator and get it ready for processing.
+  populateCodeGenerator(Codegen);
+
+  // We have no guarantee that all Tasks will feed an output buffer. So we use
+  // an intermediate vector to store each possible output.
+  std::vector<std::unique_ptr<MemoryBuffer>> OutputBuffers;
+  OutputBuffers.resize(Codegen.getMaxTasks());
+  // Callback for the LTO API.
+  auto AddOutput =
+      [&](unsigned Task) -> std::unique_ptr<lto::NativeObjectOutput> {
+    if (Task > OutputBuffers.size())
+      report_fatal_error("Got an output for out-of-bound task");
+    if (CacheOptions.Path.empty())
+      return llvm::make_unique<LTOOutput>(OutputBuffers[Task]);
+    return llvm::make_unique<lto::CacheObjectOutput>(
+        CacheOptions.Path, [&OutputBuffers, Task](std::string EntryPath) {
+          // Load the entry from the cache now.
+          auto BufferOrErr = MemoryBuffer::getFile(EntryPath);
+          if (auto EC = BufferOrErr.getError())
+            report_fatal_error(Twine("Can't reload cached file '") + EntryPath +
+                               "': " + EC.message() + "\n");
+          OutputBuffers[Task] = std::move(*BufferOrErr);
+        });
+  };
+
+  // Run the actual optimizations/codegen now.
+  auto Err = Codegen.run(AddOutput);
+  if (Err)
+    report_fatal_error("FATAL: Codegen.run error: " + toString(std::move(Err)));
+
+  // Gather all the outputs, and generates the ProducedBinaries outputs.
+  for (auto &Buffer : OutputBuffers)
+    if (Buffer)
+      ProducedBinaries.push_back(std::move(Buffer));
+
+  // This is pedantic for now, and could be lifted.
+  if (ProducedBinaries.size() != Modules.size())
+    report_fatal_error(Twine("FATAL: inconsistent number of outputs: got ") +
+                       Twine(ProducedBinaries.size()) + " outputs but had " +
+                       Twine(Modules.size()) + " inputs");
+
+  // Prune the cache directory
   CachePruning(CacheOptions.Path)
       .setPruningInterval(CacheOptions.PruningInterval)
       .setEntryExpiration(CacheOptions.Expiration)
       .setMaxSize(CacheOptions.MaxPercentageOfAvailableSpace)
       .prune();
 
   // If statistics were requested, print them out now.
   if (llvm::AreStatisticsEnabled())
     llvm::PrintStatistics();
 }

test/ThinLTO/X86/Inputs/alias_import.ll

-
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
 
 
 
 @globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)

test/ThinLTO/X86/Inputs/alias_resolution.ll

-
-
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
 
 
 @globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 @globalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 define void @globalfunc() {
 entry:
   ret void
 }
 
 @internalfuncAlias = alias void (...), bitcast (void ()* @internalfunc to void (...)*)
 @internalfuncWeakAlias = weak alias void (...), bitcast (void ()* @internalfunc to void (...)*)
 @internalfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @internalfunc to void (...)*)
 @internalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @internalfunc to void (...)*)
 @internalfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @internalfunc to void (...)*)
 define internal void @internalfunc() {
 entry:
   ret void
 }
 
-@linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 @linkonceODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 @linkonceODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 @linkonceODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 define linkonce_odr void @linkonceODRfunc() {
 entry:
   ret void
 }
 
-@weakODRfuncAlias = alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 @weakODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 @weakODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 @weakODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 @weakODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 define weak_odr void @weakODRfunc() {
 entry:
   ret void
 }
 
-@linkoncefuncAlias = alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 @linkoncefuncWeakAlias = weak alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 @linkoncefuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 @linkoncefuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 @linkoncefuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 define linkonce void @linkoncefunc() {
 entry:
   ret void
 }
 
-@weakfuncAlias = alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 @weakfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 @weakfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 @weakfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 define weak void @weakfunc() {
 entry:
   ret void
 }
 

test/ThinLTO/X86/Inputs/section.ll

+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
 ; An internal global variable that can't be renamed because it has a section
 @var_with_section = internal global i32 0, section "some_section"
 
 ; @reference_gv_with_section() can't be imported
 define i32 @reference_gv_with_section() {
     %res = load i32, i32* @var_with_section
     ret i32 %res
 }
 
 ; canary
 define void @foo() {
     ret void
 }

test/ThinLTO/X86/Inputs/select_right_alias_definition1.ll

+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
 
 @foo = weak alias i32 (...), bitcast (i32 ()* @foo1 to i32 (...)*)
 
 define i32 @foo1() {
     ret i32 42
 }
 No newline at end of file

test/ThinLTO/X86/Inputs/select_right_alias_definition2.ll

+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
 
 @foo = alias i32 (...), bitcast (i32 ()* @foo2 to i32 (...)*)
 
 define linkonce_odr i32 @foo2() {
     %ret = add i32 42, 42
     ret i32 %ret
 }
 No newline at end of file

test/ThinLTO/X86/alias_import.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/alias_import.ll -o %t2.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc %t2.bc
-; RUN: llvm-lto -thinlto-action=promote -thinlto-index %t.index.bc %t2.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE
-; RUN: llvm-lto -thinlto-action=promote -thinlto-index %t.index.bc %t2.bc -o - | llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc -thinlto-module-id=%t2.bc - -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE-INTERNALIZE
-; RUN: llvm-lto -thinlto-action=import -thinlto-index %t.index.bc %t1.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
+; RUN: llvm-lto -thinlto-action=promote -exported-symbol=_main  %t1.bc %t2.bc
+; RUN: llvm-dis %t2.bc.thinlto.promote.bc -o - | FileCheck %s --check-prefix=PROMOTE
+; RUN: llvm-lto -thinlto-action=internalize -exported-symbol=_main  %t1.bc %t2.bc
+; RUN: llvm-dis %t2.bc.thinlto.internalize.bc -o - | FileCheck %s --check-prefix=PROMOTE-INTERNALIZE
+; RUN: llvm-lto -thinlto-action=import -exported-symbol=_main %t1.bc %t2.bc
+; RUN: llvm-dis %t1.bc.thinlto.import.bc -o - | FileCheck %s --check-prefix=IMPORT
 
 ;
 ; Alias can't point to "available_externally", so we can only import an alias
 ; when we can import the aliasee with a linkage that won't be
 ; available_externally, i.e linkOnceODR. (FIXME this limitation could be lifted)
 ; PROMOTE-DAG: @globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 ; PROMOTE-DAG: @globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
 ; PROMOTE-DAG: @globalfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)

 ; PROMOTE-DAG: @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; Amongst these that are imported, check that we promote only linkonce->weak
 ; PROMOTE-DAG: @linkonceODRfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; PROMOTE-DAG: @linkonceODRfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 
 ; These will be imported, check the linkage/renaming after promotion
 ; PROMOTE-DAG: define void @globalfunc()
 ; PROMOTE-DAG: define hidden void @internalfunc.llvm.0()
-; PROMOTE-DAG: define linkonce_odr void @linkonceODRfunc()
-; PROMOTE-DAG: define weak_odr void @weakODRfunc()
-; PROMOTE-DAG: define linkonce void @linkoncefunc()
-; PROMOTE-DAG: define weak void @weakfunc()
+; PROMOTE-DAG: define internal void @linkonceODRfunc()
+; PROMOTE-DAG: define internal void @weakODRfunc()
+; PROMOTE-DAG: define internal void @linkoncefunc()
+; PROMOTE-DAG: define internal void @weakfunc()
 
 ; On the import side now, verify that aliases to a linkonce_odr are imported, but the weak/linkonce (we can't inline them)
 ; IMPORT-DAG:  declare void @linkonceODRfuncWeakAlias
 ; IMPORT-DAG: declare void @linkonceODRfuncLinkonceAlias
 ; IMPORT-DAG:  @linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; IMPORT-DAG:  @linkonceODRfuncWeakODRAlias = alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; IMPORT-DAG:  @linkonceODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; IMPORT-DAG:  define linkonce_odr void @linkonceODRfunc()

 ; IMPORT-DAG: declare void @linkoncefuncWeakODRAlias()
 ; IMPORT-DAG: declare void @linkoncefuncLinkonceODRAlias()
 ; IMPORT-DAG: declare void @weakfuncAlias()
 ; IMPORT-DAG: declare void @weakfuncWeakAlias()
 ; IMPORT-DAG: declare void @weakfuncLinkonceAlias()
 ; IMPORT-DAG: declare void @weakfuncWeakODRAlias()
 ; IMPORT-DAG: declare void @weakfuncLinkonceODRAlias()
 
-; Promotion + internalization should internalize all of these, except for aliases of
-; linkonce_odr functions, because alias to linkonce_odr are the only aliases we will
-; import (see selectCallee() in FunctionImport.cpp).
-; PROMOTE-INTERNALIZE-DAG: @globalfuncAlias = internal alias void (...), bitcast (void ()* @globalfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @globalfuncWeakAlias = internal alias void (...), bitcast (void ()* @globalfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @globalfuncLinkonceAlias = internal alias void (...), bitcast (void ()* @globalfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @globalfuncWeakODRAlias = internal alias void (...), bitcast (void ()* @globalfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @globalfuncLinkonceODRAlias = internal alias void (...), bitcast (void ()* @globalfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @internalfuncAlias = internal alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @internalfuncWeakAlias = internal alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @internalfuncLinkonceAlias = internal alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @internalfuncWeakODRAlias = internal alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @internalfuncLinkonceODRAlias = internal alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
+; Promotion + internalization should not internalize the functions called from main.
+; PROMOTE-INTERNALIZE-DAG: @globalfuncAlias = alias void (...), bitcast (void ()* @globalfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @globalfuncWeakAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @globalfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @globalfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @globalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @globalfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @globalfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @internalfuncAlias = alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @internalfuncWeakAlias = weak alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @internalfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @internalfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @internalfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @internalfunc.llvm.0 to void (...)*)
 ; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncWeakAlias = internal alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncLinkonceAlias = internal alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; PROMOTE-INTERNALIZE-DAG: @linkonceODRfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakODRfuncAlias = internal alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakODRfuncWeakAlias = internal alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakODRfuncLinkonceAlias = internal alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakODRfuncWeakODRAlias = internal alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakODRfuncLinkonceODRAlias = internal alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkoncefuncAlias = internal alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkoncefuncWeakAlias = internal alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkoncefuncLinkonceAlias = internal alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkoncefuncWeakODRAlias = internal alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @linkoncefuncLinkonceODRAlias = internal alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakfuncAlias = internal alias void (...), bitcast (void ()* @weakfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakfuncWeakAlias = internal alias void (...), bitcast (void ()* @weakfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakfuncLinkonceAlias = internal alias void (...), bitcast (void ()* @weakfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakfuncWeakODRAlias = internal alias void (...), bitcast (void ()* @weakfunc to void (...)*)
-; PROMOTE-INTERNALIZE-DAG: @weakfuncLinkonceODRAlias = internal alias void (...), bitcast (void ()* @weakfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakODRfuncAlias = alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakODRfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakODRfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkoncefuncAlias = alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkoncefuncWeakAlias = weak alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkoncefuncLinkonceAlias = weak alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkoncefuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @linkoncefuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakfuncAlias = alias void (...), bitcast (void ()* @weakfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @weakfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
+; PROMOTE-INTERNALIZE-DAG: @weakfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 ; PROMOTE-INTERNALIZE-DAG: define internal void @globalfunc()
 ; PROMOTE-INTERNALIZE-DAG: define internal void @internalfunc.llvm.0()
 ; PROMOTE-INTERNALIZE-DAG: define internal void @linkonceODRfunc()
 ; PROMOTE-INTERNALIZE-DAG: define internal void @weakODRfunc()
 ; PROMOTE-INTERNALIZE-DAG: define internal void @linkoncefunc()
 ; PROMOTE-INTERNALIZE-DAG: define internal void @weakfunc()
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
+
 define i32 @main() #0 {
 entry:
   call void @globalfuncAlias()
   call void @globalfuncWeakAlias()
   call void @globalfuncLinkonceAlias()
   call void @globalfuncWeakODRAlias()
   call void @globalfuncLinkonceODRAlias()
 

test/ThinLTO/X86/alias_resolution.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/alias_resolution.ll -o %t2.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc %t2.bc
-; RUN: llvm-lto -thinlto-action=promote -thinlto-index %t.index.bc %t2.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE_MOD2 --check-prefix=NOTPROMOTED
-; RUN: llvm-lto -thinlto-action=promote -thinlto-index %t.index.bc %t1.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE_MOD1 --check-prefix=NOTPROMOTED
+; RUN: llvm-lto -thinlto-action=promote %t1.bc %t2.bc
+; RUN: llvm-dis %t1.bc.thinlto.promote.bc -o - | FileCheck %s --check-prefix=PROMOTE_MOD1 --check-prefix=NOTPROMOTED
+; RUN: llvm-dis %t2.bc.thinlto.promote.bc -o - | FileCheck %s --check-prefix=PROMOTE_MOD2 --check-prefix=NOTPROMOTED
 
 ; There is no importing going on with this IR, but let's check the ODR resolution for compile time
 
-; NOTPROMOTED: @linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc{{.*}} to void (...)*)
-; NOTPROMOTED: @linkonceODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @linkonceODRfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD2: @linkonceODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkonceODRfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 ; PROMOTE_MOD1: @linkonceODRfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @linkonceODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkonceODRfunc to void (...)*)
 
-; NOTPROMOTED: @weakODRfuncAlias = alias void (...), bitcast (void ()* @weakODRfunc{{.*}} to void (...)*)
 ; NOTPROMOTED: @weakODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakODRfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @weakODRfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @weakODRfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD2: @weakODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakODRfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @weakODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @weakODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 ; PROMOTE_MOD1: @weakODRfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @weakODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakODRfunc to void (...)*)
 
-; NOTPROMOTED: @linkoncefuncAlias = alias void (...), bitcast (void ()* @linkoncefunc{{.*}} to void (...)*)
 ; NOTPROMOTED: @linkoncefuncWeakAlias = weak alias void (...), bitcast (void ()* @linkoncefunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @linkoncefuncLinkonceAlias = weak alias void (...), bitcast (void ()* @linkoncefunc{{.*}} to void (...)*)
 ; PROMOTE_MOD2: @linkoncefuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkoncefunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @linkoncefuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @linkoncefuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 ; PROMOTE_MOD1: @linkoncefuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @linkoncefuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
 
-; NOTPROMOTED: @weakfuncAlias = alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*)
 ; NOTPROMOTED: @weakfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD1: @weakfuncLinkonceAlias = weak alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*)
 ; PROMOTE_MOD2: @weakfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakfunc{{.*}} to void (...)*)
 ; FIXME: The "resolution" should turn one of these to linkonce_odr
 ; PROMOTE_MOD1: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 ; PROMOTE_MOD1: @weakfuncLinkonceODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 ; PROMOTE_MOD2: @weakfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakfunc to void (...)*)
 
 
-@linkonceODRfuncAlias = alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
 @linkonceODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
 @linkonceODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
 @linkonceODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
 @linkonceODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkonceODRfunc.mod1 to void (...)*)
 define linkonce_odr void @linkonceODRfunc.mod1() {
 entry:
   ret void
 }
 
-@weakODRfuncAlias = alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 @weakODRfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 @weakODRfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 @weakODRfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 @weakODRfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakODRfunc.mod1 to void (...)*)
 define weak_odr void @weakODRfunc.mod1() {
 entry:
   ret void
 }
 
-@linkoncefuncAlias = alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 @linkoncefuncWeakAlias = weak alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 @linkoncefuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 @linkoncefuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 @linkoncefuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @linkoncefunc.mod1 to void (...)*)
 define linkonce void @linkoncefunc.mod1() {
 entry:
   ret void
 }
 
-@weakfuncAlias = alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 @weakfuncWeakAlias = weak alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 @weakfuncLinkonceAlias = linkonce alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 @weakfuncWeakODRAlias = weak_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 @weakfuncLinkonceODRAlias = linkonce_odr alias void (...), bitcast (void ()* @weakfunc.mod1 to void (...)*)
 define weak void @weakfunc.mod1() {
 entry:
   ret void
 }
 

test/ThinLTO/X86/autoupgrade.ll

 ; Verify that auto-upgrading intrinsics works with Lazy loaded bitcode
 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %p/Inputs/autoupgrade.bc
-
-; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-bcanalyzer -dump | FileCheck %s
+; RUN: llvm-lto -thinlto-action=import %t.bc %p/Inputs/autoupgrade.bc
+; RUN: llvm-bcanalyzer -dump %t.bc.thinlto.import.bc | FileCheck %s
 
 ; We can't use llvm-dis here, because it would do the autoupgrade itself.
 
 ; CHECK-NOT: 'llvm.invariant.start'
 ; CHECK: record string = 'llvm.invariant.start.p0i8'
 ; CHECK-NOT: 'llvm.invariant.start'
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"

test/ThinLTO/X86/deadstrip.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/deadstrip.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc %t2.bc
 
-; RUN: llvm-lto -exported-symbol=_main -thinlto-action=promote %t1.bc -thinlto-index=%t.index.bc -o - | llvm-lto -exported-symbol=_main -thinlto-action=internalize -thinlto-index %t.index.bc -thinlto-module-id=%t1.bc - -o - | llvm-dis -o - | FileCheck %s
+; RUN: llvm-lto -exported-symbol=_main -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc
+; RUN: llvm-dis %t1.bc.thinlto.internalize.bc -o - | FileCheck %s
 
 ; RUN: llvm-lto -exported-symbol=_main -thinlto-action=run %t1.bc %t2.bc
 ; RUN: llvm-nm %t1.bc.thinlto.o | FileCheck %s --check-prefix=CHECK-NM
 
 ; RUN: llvm-lto2 %t1.bc %t2.bc -o %t.out -save-temps \
 ; RUN:   -r %t1.bc,_main,plx \
 ; RUN:   -r %t1.bc,_bar,pl \
 ; RUN:   -r %t1.bc,_dead_func,pl \

test/ThinLTO/X86/drop-debug-info.ll

 ; RUN: opt -module-summary %s -o %t.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t.bc %p/Inputs/drop-debug-info.bc
 
 ; The imported module has out-of-date debug information, let's make sure we can
 ; drop them without crashing when materializing later.
-; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t.index.bc -o - | llvm-dis -o - | FileCheck %s
+; RUN: llvm-lto -thinlto-action=import %t.bc
+; RUNL llvm-dis %t.bc.thinlto.import.bc -o - | FileCheck %s
 ; CHECK: define available_externally void @globalfunc
 ; CHECK-NOT: llvm.dbg.value
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 
 define i32 @main() #0 {
 entry:
   call void (...) @globalfunc()
   ret i32 0
 }
 
 declare void @globalfunc(...)
 No newline at end of file

test/ThinLTO/X86/funcimport.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/funcimport.ll -o %t2.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
 ; Ensure statics are promoted/renamed correctly from this file (all but
 ; constant variable need promotion).
 ; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTSTATIC
 ; EXPORTSTATIC-DAG: @staticvar.llvm.0 = hidden global
 ; EXPORTSTATIC-DAG: @staticconstvar = internal unnamed_addr constant
 ; EXPORTSTATIC-DAG: @P.llvm.0 = hidden global void ()* null
 ; EXPORTSTATIC-DAG: define hidden i32 @staticfunc.llvm.0
 ; EXPORTSTATIC-DAG: define hidden void @staticfunc2.llvm.0
 
 ; Ensure that both weak alias to an imported function and strong alias to a
 ; non-imported function are correctly turned into declarations.
 ; Also ensures that alias to a linkonce function is turned into a declaration
 ; and that the associated linkonce function is not in the output, as it is
 ; lazily linked and never referenced/materialized.
-; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORTGLOB1
+; RUN: llvm-lto -thinlto-action=import %t.bc %t2.bc 
+; RUN: llvm-dis %t2.bc.thinlto.import.bc -o - | FileCheck %s --check-prefix=IMPORTGLOB1
 ; IMPORTGLOB1-DAG: define available_externally void @globalfunc1
 ; IMPORTGLOB1-DAG: declare void @weakalias
 ; IMPORTGLOB1-DAG: declare void @analias
 ; IMPORTGLOB1-NOT: @linkoncealias
 ; IMPORTGLOB1-NOT: @linkoncefunc
 ; IMPORTGLOB1-NOT: declare void @globalfunc2
 
 ; Verify that the optimizer run

test/ThinLTO/X86/internalize.ll

-;; RUN: opt -module-summary %s -o %t1.bc
+; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=REGULAR
-; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o -  --exported-symbol=foo | llvm-dis -o - | FileCheck %s --check-prefix=INTERNALIZE
+; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o -  --exported-symbol=_foo | llvm-dis -o - | FileCheck %s --check-prefix=INTERNALIZE
 
 ; RUN: llvm-lto2 %t1.bc -o %t.o -save-temps \
 ; RUN:     -r=%t1.bc,_foo,pxl \
 ; RUN:     -r=%t1.bc,_bar,pl \
 ; RUN:     -r=%t1.bc,_linkonce_func,pl
 ; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck  %s --check-prefix=INTERNALIZE
 
 
 ; REGULAR: define void @foo
 ; REGULAR: define void @bar
-; REGULAR: define linkonce void @linkonce_func()
+; REGULAR: define weak void @linkonce_func()
 ; INTERNALIZE: define void @foo
 ; INTERNALIZE: define internal void @bar
 ; INTERNALIZE: define internal void @linkonce_func()
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @foo() {
     ret void
 }
 define void @bar() {
     call void @linkonce_func()
   ret void
 }
 define linkonce void @linkonce_func() {
     ret void
 }
 No newline at end of file

test/ThinLTO/X86/linkonce_resolution_comdat.ll

 ; This test ensures that we drop the preempted copy of @f from %t2.bc from its
 ; comdat after making it available_externally. If not we would get a
 ; verification error.
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/linkonce_resolution_comdat.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=run %t1.bc %t2.bc -exported-symbol=f -exported-symbol=g -thinlto-save-temps=%t3.
 
-; RUN: llvm-dis %t3.0.3.imported.bc -o - | FileCheck %s --check-prefix=IMPORT1
-; RUN: llvm-dis %t3.1.3.imported.bc -o - | FileCheck %s --check-prefix=IMPORT2
+; RUN: llvm-dis %t3.0.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT1
+; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT2
 ; Copy from first module is prevailing and converted to weak_odr, copy
 ; from second module is preempted and converted to available_externally and
 ; removed from comdat.
 ; IMPORT1: define weak_odr i32 @f(i8*) unnamed_addr comdat($c1) {
 ; IMPORT2: define available_externally i32 @f(i8*) unnamed_addr {
 
 ; RUN: llvm-nm -o - < %t1.bc.thinlto.o | FileCheck %s --check-prefix=NM1
 ; NM1: W f

test/ThinLTO/X86/llvm.used.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/llvm.used.ll -o %t2.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
-
-; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s
+; RUN: llvm-lto -thinlto-action=import %t.bc %t2.bc
+; RUN: llvm-dis %t2.bc.thinlto.import.bc -o - | FileCheck %s
 ; CHECK: define available_externally void @globalfunc
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 
 

test/ThinLTO/X86/referenced_by_constant.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/referenced_by_constant.ll -o %t2.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
 ; Check the import side: we import bar() and @someglobal, but not @referencedbyglobal()
-; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o -   | FileCheck %s --check-prefix=IMPORT
+; RUN: llvm-lto -thinlto-action=import %t.bc %t2.bc
+; RUN: llvm-dis %t.bc.thinlto.import.bc -o -   | FileCheck %s --check-prefix=IMPORT
 ; IMPORT: @someglobal.llvm.0 =
 ; IMPORT: define available_externally void @bar()
 ; IMPORT: declare void @referencedbyglobal()
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @bar()
 
 define void @foo() {
     call void @bar()
     ret void
 }
 

test/ThinLTO/X86/section.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/section.ll -o %t2.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
 ; Check that we don't promote 'var_with_section'
-; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=PROMOTE
+; RUN: llvm-lto -thinlto-action=promote %t.bc %t2.bc
+; RUN: llvm-dis %t2.bc.thinlto.promote.bc -o - | FileCheck %s --check-prefix=PROMOTE
 ; PROMOTE: @var_with_section = internal global i32 0, section "some_section"
 
-; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
+; RUN: llvm-lto -thinlto-action=import %t.bc %t2.bc
+; RUN: llvm-dis %t.bc.thinlto.import.bc -o - | FileCheck %s --check-prefix=IMPORT
 ; Check that section prevent import of @reference_gv_with_section.
 ; IMPORT: declare void @reference_gv_with_section()
 ; Canary to check that importing is correctly set up.
 ; IMPORT: define available_externally void @foo()
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
 
 define i32 @main() {
     call void @reference_gv_with_section()
     call void @foo()
     ret i32 42
 }
 
 
 declare void @reference_gv_with_section()
 declare void @foo()

test/ThinLTO/X86/select_right_alias_definition.ll

 ; RUN: opt -module-summary %s -o %t_main.bc
 ; RUN: opt -module-summary %p/Inputs/select_right_alias_definition1.ll -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/select_right_alias_definition2.ll -o %t2.bc
 
 ; Make sure that we always select the right definition for alia foo, whatever
 ; order the files are linked in.
 
 ; Try with one order
-; RUN: llvm-lto -thinlto-action=thinlink -o %t.index1.bc %t_main.bc %t1.bc %t2.bc
-; RUN: llvm-lto -thinlto-action=import -thinlto-index %t.index1.bc %t_main.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
+; RUN: llvm-lto -thinlto-action=import %t_main.bc %t1.bc %t2.bc
+; RUN: llvm-dis %t_main.bc.thinlto.import.bc -o - | FileCheck %s --check-prefix=IMPORT
 
 ; Try with the other order (reversing %t1.bc and %t2.bc)
-; RUN: llvm-lto -thinlto-action=thinlink -o %t.index2.bc %t_main.bc %t2.bc %t1.bc
-; RUN: llvm-lto -thinlto-action=import -thinlto-index %t.index2.bc %t_main.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
+; RUN: llvm-lto -thinlto-action=import %t_main.bc %t2.bc %t1.bc
+; RUN: llvm-dis %t_main.bc.thinlto.import.bc -o - | FileCheck %s --check-prefix=IMPORT
 
 ; IMPORT: @foo = alias i32 (...), bitcast (i32 ()* @foo2 to i32 (...)*)
 ; IMPORT: define linkonce_odr i32 @foo2() {
 ; IMPORT-NEXT:  %ret = add i32 42, 42
 ; IMPORT-NEXT:  ret i32 %ret
 ; IMPORT-NEXT: }
 
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
 declare i32 @foo()
 
 define i32 @main() {
     %ret = call i32 @foo()
     ret i32 %ret
 }
 No newline at end of file

test/ThinLTO/X86/weak_resolution.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/weak_resolution.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
 ; Verify that prevailing weak for linker symbol is selected across modules,
 ; non-prevailing ODR are not kept when possible, but non-ODR non-prevailing
 ; are not affected.
-; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1
-; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -exported-symbol=linkoncefunc -o - | llvm-lto -thinlto-action=internalize -thinlto-module-id=%t.bc - -thinlto-index=%t3.bc -exported-symbol=linkoncefunc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1-INT
-; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD2
+; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o %t.promote.bc
+; RUN: llvm-dis %t.promote.bc -o - | FileCheck %s --check-prefix=MOD1
+; RUN: llvm-lto -thinlto-action=internalize %t.bc %t2.bc -exported-symbol=_main 
+; RUN: llvm-dis %t.bc.thinlto.internalize.bc -o - | FileCheck %s --check-prefix=MOD1-INT
+; RUN: llvm-lto -thinlto-action=promote %t.bc %t2.bc
+; RUN: llvm-dis %t2.bc.thinlto.promote.bc -o - | FileCheck %s --check-prefix=MOD2
 ; When exported, we always preserve a linkonce
-; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - --exported-symbol=linkonceodrfuncInSingleModule | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTED
+; RUN: llvm-lto -thinlto-action=internalize %t.bc %t2.bc -exported-symbol=_linkoncefunc --exported-symbol=_linkonceodrfuncInSingleModule
+; RUN: llvm-dis %t.bc.thinlto.internalize.bc -o - | FileCheck %s --check-prefix=EXPORTED
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; Alias are resolved, but can't be turned into "available_externally"
 ; MOD1: @linkonceodralias = weak_odr alias void (), void ()* @linkonceodrfuncwithalias
 ; MOD2: @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias
 @linkonceodralias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias

test/ThinLTO/X86/weak_resolution_single.ll

 ; RUN: opt -module-summary %s -o %t.bc
-; RUN: llvm-lto -thinlto-action=thinlink -o %t2.bc %t.bc
+; RUN: llvm-lto -thinlto-action=internalize %t.bc -thinlto-index=%t2.bc -exported-symbol=_foo -o %t.internalize.bc
+; RUN: llvm-dis %t.internalize.bc -o - | FileCheck %s
 
-; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t2.bc -exported-symbol=foo -o - | llvm-lto -thinlto-action=internalize -thinlto-module-id=%t.bc - -thinlto-index=%t2.bc -exported-symbol=foo -o - | llvm-dis -o - | FileCheck %s
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
 
 ; CHECK: define weak_odr void @foo()
 define linkonce_odr void @foo() {
   ret void
 }

tools/llvm-lto/llvm-lto.cpp

static std::unique_ptr<Module> loadModule(StringRef Filename,
   if (ThinLTOModuleId.getNumOccurrences()) {
     if (InputFilenames.size() != 1)
       report_fatal_error("Can't override the module id for multiple files");
     M->setModuleIdentifier(ThinLTOModuleId);
   }
   return M;
 }
 
-static void writeModuleToFile(Module &TheModule, StringRef Filename) {
+static void writeModuleToFile(const Module &TheModule, StringRef Filename) {
   std::error_code EC;
   raw_fd_ostream OS(Filename, EC, sys::fs::OpenFlags::F_None);
   error(EC, "error opening the file '" + Filename + "'");
   maybeVerifyModule(TheModule);
   WriteBitcodeToFile(&TheModule, OS, /* ShouldPreserveUseListOrder */ true);
 }
 
 class ThinLTOProcessing {
 public:
   ThinLTOCodeGenerator ThinGenerator;
+  std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers;
 
   ThinLTOProcessing(const TargetOptions &Options) {
     ThinGenerator.setCodePICModel(getRelocModel());
     ThinGenerator.setTargetOptions(Options);
     ThinGenerator.setCacheDir(ThinLTOCacheDir);
 
     // Add all the exported symbols to the table of symbols to preserve.
     for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
void run() {
     case THINCODEGEN:
       return codegen();
     case THINALL:
       return runAll();
     }
   }
 
 private:
+  void loadInputs() {
+    for (unsigned i = 0; i < InputFilenames.size(); ++i) {
+      auto &Filename = InputFilenames[i];
+      StringRef CurrentActivity = "loading file '" + Filename + "'";
+      auto InputOrErr = MemoryBuffer::getFile(Filename);
+      error(InputOrErr, "error " + CurrentActivity);
+      InputBuffers.push_back(std::move(*InputOrErr));
+      ThinGenerator.addModule(Filename, InputBuffers.back()->getBuffer());
+    }
+  }
+
   /// Load the input files, create the combined index, and write it out.
   void thinLink() {
     // Perform "ThinLink": just produce the index
     if (OutputFilename.empty())
       report_fatal_error(
           "OutputFilename is necessary to store the combined index.\n");
 
     LLVMContext Ctx;
private:
   /// content).
   void promote() {
     if (InputFilenames.size() != 1 && !OutputFilename.empty())
       report_fatal_error("Can't handle a single output filename and multiple "
                          "input files, do not provide an output filename and "
                          "the output files will be suffixed from the input "
                          "ones.");
 
-    auto Index = loadCombinedIndex();
-    for (auto &Filename : InputFilenames) {
-      LLVMContext Ctx;
-      auto TheModule = loadModule(Filename, Ctx);
-
-      ThinGenerator.promote(*TheModule, *Index);
+    loadInputs();
 
+    ThinGenerator.promote([&](unsigned Id, const Module &TheModule) {
       std::string OutputName = OutputFilename;
       if (OutputName.empty()) {
-        OutputName = Filename + ".thinlto.promoted.bc";
-      }
-      writeModuleToFile(*TheModule, OutputName);
+        OutputName = TheModule.getModuleIdentifier();
+        OutputName += ".thinlto.promote.bc";
       }
+      writeModuleToFile(TheModule, OutputName);
+    });
   }
 
   /// Load the combined index from disk, then load every file referenced by
   /// the index and add them to the generator, then performs the promotion and
   /// cross module importing on the files mentioned on the command line
   /// (these must match the index content).
   void import() {
     if (InputFilenames.size() != 1 && !OutputFilename.empty())
       report_fatal_error("Can't handle a single output filename and multiple "
                          "input files, do not provide an output filename and "
                          "the output files will be suffixed from the input "
                          "ones.");
 
-    auto Index = loadCombinedIndex();
-    auto InputBuffers = loadAllFilesForIndex(*Index);
-    for (auto &MemBuffer : InputBuffers)
-      ThinGenerator.addModule(MemBuffer->getBufferIdentifier(),
-                              MemBuffer->getBuffer());
-
-    for (auto &Filename : InputFilenames) {
-      LLVMContext Ctx;
-      auto TheModule = loadModule(Filename, Ctx);
-
-      ThinGenerator.crossModuleImport(*TheModule, *Index);
+    loadInputs();
 
+    ThinGenerator.crossModuleImport([&](unsigned Id, const Module &TheModule) {
       std::string OutputName = OutputFilename;
       if (OutputName.empty()) {
-        OutputName = Filename + ".thinlto.imported.bc";
-      }
-      writeModuleToFile(*TheModule, OutputName);
+        OutputName = TheModule.getModuleIdentifier();
+        OutputName += ".thinlto.import.bc";
       }
+      writeModuleToFile(TheModule, OutputName);
+    });
   }
 
   void internalize() {
     if (InputFilenames.size() != 1 && !OutputFilename.empty())
       report_fatal_error("Can't handle a single output filename and multiple "
                          "input files, do not provide an output filename and "
                          "the output files will be suffixed from the input "
                          "ones.");
 
     if (ExportedSymbols.empty())
       errs() << "Warning: -internalize will not perform without "
                 "-exported-symbol\n";
 
-    auto Index = loadCombinedIndex();
-    auto InputBuffers = loadAllFilesForIndex(*Index);
-    for (auto &MemBuffer : InputBuffers)
-      ThinGenerator.addModule(MemBuffer->getBufferIdentifier(),
-                              MemBuffer->getBuffer());
-
-    for (auto &Filename : InputFilenames) {
-      LLVMContext Ctx;
-      auto TheModule = loadModule(Filename, Ctx);
-
-      ThinGenerator.internalize(*TheModule, *Index);
+    loadInputs();
 
+    ThinGenerator.internalize([&](unsigned Id, const Module &TheModule) {
       std::string OutputName = OutputFilename;
       if (OutputName.empty()) {
-        OutputName = Filename + ".thinlto.internalized.bc";
-      }
-      writeModuleToFile(*TheModule, OutputName);
+        OutputName = TheModule.getModuleIdentifier();
+        OutputName += ".thinlto.internalize.bc";
       }
+      writeModuleToFile(TheModule, OutputName);
+    });
   }
 
   void optimize() {
     if (InputFilenames.size() != 1 && !OutputFilename.empty())
       report_fatal_error("Can't handle a single output filename and multiple "
                          "input files, do not provide an output filename and "
                          "the output files will be suffixed from the input "
                          "ones.");