LCOV - code coverage report
Current view: top level - lib/LTO - ThinLTOCodeGenerator.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 339 401 84.5 %
Date: 2018-02-20 16:54:40 Functions: 40 46 87.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-ThinLTOCodeGenerator.cpp - LLVM Link Time Optimizer -----------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the Thin Link Time Optimization library. This library is
      11             : // intended to be used by linker to optimize code at link time.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
      16             : 
      17             : #include "llvm/ADT/Statistic.h"
      18             : #include "llvm/ADT/StringExtras.h"
      19             : #include "llvm/Analysis/ModuleSummaryAnalysis.h"
      20             : #include "llvm/Analysis/ProfileSummaryInfo.h"
      21             : #include "llvm/Analysis/TargetLibraryInfo.h"
      22             : #include "llvm/Analysis/TargetTransformInfo.h"
      23             : #include "llvm/Bitcode/BitcodeReader.h"
      24             : #include "llvm/Bitcode/BitcodeWriter.h"
      25             : #include "llvm/Bitcode/BitcodeWriterPass.h"
      26             : #include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
      27             : #include "llvm/IR/DebugInfo.h"
      28             : #include "llvm/IR/DiagnosticPrinter.h"
      29             : #include "llvm/IR/LLVMContext.h"
      30             : #include "llvm/IR/LegacyPassManager.h"
      31             : #include "llvm/IR/Mangler.h"
      32             : #include "llvm/IR/Verifier.h"
      33             : #include "llvm/IRReader/IRReader.h"
      34             : #include "llvm/LTO/LTO.h"
      35             : #include "llvm/MC/SubtargetFeature.h"
      36             : #include "llvm/Object/IRObjectFile.h"
      37             : #include "llvm/Support/CachePruning.h"
      38             : #include "llvm/Support/Debug.h"
      39             : #include "llvm/Support/Error.h"
      40             : #include "llvm/Support/Path.h"
      41             : #include "llvm/Support/SHA1.h"
      42             : #include "llvm/Support/TargetRegistry.h"
      43             : #include "llvm/Support/ThreadPool.h"
      44             : #include "llvm/Support/Threading.h"
      45             : #include "llvm/Support/ToolOutputFile.h"
      46             : #include "llvm/Support/VCSRevision.h"
      47             : #include "llvm/Target/TargetMachine.h"
      48             : #include "llvm/Transforms/IPO.h"
      49             : #include "llvm/Transforms/IPO/FunctionImport.h"
      50             : #include "llvm/Transforms/IPO/Internalize.h"
      51             : #include "llvm/Transforms/IPO/PassManagerBuilder.h"
      52             : #include "llvm/Transforms/ObjCARC.h"
      53             : #include "llvm/Transforms/Utils/FunctionImportUtils.h"
      54             : 
      55             : #include <numeric>
      56             : 
      57             : using namespace llvm;
      58             : 
      59             : #define DEBUG_TYPE "thinlto"
      60             : 
      61             : namespace llvm {
      62             : // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
      63             : extern cl::opt<bool> LTODiscardValueNames;
      64             : extern cl::opt<std::string> LTORemarksFilename;
      65             : extern cl::opt<bool> LTOPassRemarksWithHotness;
      66             : }
      67             : 
      68             : namespace {
      69             : 
      70             : static cl::opt<int>
      71       97302 :     ThreadCount("threads", cl::init(llvm::heavyweight_hardware_concurrency()));
      72             : 
      73             : // Simple helper to save temporary files for debug.
      74         229 : static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
      75             :                             unsigned count, StringRef Suffix) {
      76         229 :   if (TempDir.empty())
      77         199 :     return;
      78             :   // User asked to save temps, let dump the bitcode file after import.
      79          30 :   std::string SaveTempPath = (TempDir + llvm::Twine(count) + Suffix).str();
      80             :   std::error_code EC;
      81          60 :   raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
      82          30 :   if (EC)
      83           0 :     report_fatal_error(Twine("Failed to open ") + SaveTempPath +
      84             :                        " to save optimized bitcode\n");
      85          30 :   WriteBitcodeToFile(TheModule, OS, /* ShouldPreserveUseListOrder */ true);
      86             : }
      87             : 
      88             : static const GlobalValueSummary *
      89          76 : getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
      90             :   // If there is any strong definition anywhere, get it.
      91             :   auto StrongDefForLinker = llvm::find_if(
      92             :       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
      93             :         auto Linkage = Summary->linkage();
      94         142 :         return !GlobalValue::isAvailableExternallyLinkage(Linkage) &&
      95             :                !GlobalValue::isWeakForLinker(Linkage);
      96             :       });
      97          76 :   if (StrongDefForLinker != GVSummaryList.end())
      98          10 :     return StrongDefForLinker->get();
      99             :   // Get the first *linker visible* definition for this global in the summary
     100             :   // list.
     101             :   auto FirstDefForLinker = llvm::find_if(
     102             :       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
     103             :         auto Linkage = Summary->linkage();
     104             :         return !GlobalValue::isAvailableExternallyLinkage(Linkage);
     105             :       });
     106             :   // Extern templates can be emitted as available_externally.
     107          66 :   if (FirstDefForLinker == GVSummaryList.end())
     108             :     return nullptr;
     109          66 :   return FirstDefForLinker->get();
     110             : }
     111             : 
     112             : // Populate map of GUID to the prevailing copy for any multiply defined
     113             : // symbols. Currently assume first copy is prevailing, or any strong
     114             : // definition. Can be refined with Linker information in the future.
     115          42 : static void computePrevailingCopies(
     116             :     const ModuleSummaryIndex &Index,
     117             :     DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy) {
     118             :   auto HasMultipleCopies = [&](const GlobalValueSummaryList &GVSummaryList) {
     119         324 :     return GVSummaryList.size() > 1;
     120             :   };
     121             : 
     122         366 :   for (auto &I : Index) {
     123         324 :     if (HasMultipleCopies(I.second.SummaryList))
     124         152 :       PrevailingCopy[I.first] =
     125         152 :           getFirstDefinitionForLinker(I.second.SummaryList);
     126             :   }
     127          42 : }
     128             : 
     129             : static StringMap<MemoryBufferRef>
     130          41 : generateModuleMap(const std::vector<ThinLTOBuffer> &Modules) {
     131             :   StringMap<MemoryBufferRef> ModuleMap;
     132          41 :   for (auto &ModuleBuffer : Modules) {
     133             :     assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
     134             :                ModuleMap.end() &&
     135             :            "Expect unique Buffer Identifier");
     136          80 :     ModuleMap[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer.getMemBuffer();
     137             :   }
     138          41 :   return ModuleMap;
     139             : }
     140             : 
     141          61 : static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) {
     142          61 :   if (renameModuleForThinLTO(TheModule, Index))
     143           0 :     report_fatal_error("renameModuleForThinLTO failed");
     144          61 : }
     145             : 
     146             : namespace {
     147           0 : class ThinLTODiagnosticInfo : public DiagnosticInfo {
     148             :   const Twine &Msg;
     149             : public:
     150             :   ThinLTODiagnosticInfo(const Twine &DiagMsg,
     151             :                         DiagnosticSeverity Severity = DS_Error)
     152           0 :       : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
     153           0 :   void print(DiagnosticPrinter &DP) const override { DP << Msg; }
     154             : };
     155             : }
     156             : 
     157             : /// Verify the module and strip broken debug info.
     158         109 : static void verifyLoadedModule(Module &TheModule) {
     159         109 :   bool BrokenDebugInfo = false;
     160         109 :   if (verifyModule(TheModule, &dbgs(), &BrokenDebugInfo))
     161           0 :     report_fatal_error("Broken module found, compilation aborted!");
     162         109 :   if (BrokenDebugInfo) {
     163           0 :     TheModule.getContext().diagnose(ThinLTODiagnosticInfo(
     164             :         "Invalid debug info found, debug info will be stripped", DS_Warning));
     165           0 :     StripDebugInfo(TheModule);
     166             :   }
     167         109 : }
     168             : 
     169             : static std::unique_ptr<Module>
     170          76 : loadModuleFromBuffer(const MemoryBufferRef &Buffer, LLVMContext &Context,
     171             :                      bool Lazy, bool IsImporting) {
     172          76 :   SMDiagnostic Err;
     173             :   Expected<std::unique_ptr<Module>> ModuleOrErr =
     174             :       Lazy
     175             :           ? getLazyBitcodeModule(Buffer, Context,
     176             :                                  /* ShouldLazyLoadMetadata */ true, IsImporting)
     177         152 :           : parseBitcodeFile(Buffer, Context);
     178          76 :   if (!ModuleOrErr) {
     179           0 :     handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
     180           0 :       SMDiagnostic Err = SMDiagnostic(Buffer.getBufferIdentifier(),
     181           0 :                                       SourceMgr::DK_Error, EIB.message());
     182           0 :       Err.print("ThinLTO", errs());
     183           0 :     });
     184           0 :     report_fatal_error("Can't load module, abort.");
     185             :   }
     186          76 :   if (!Lazy)
     187          49 :     verifyLoadedModule(*ModuleOrErr.get());
     188          76 :   return std::move(ModuleOrErr.get());
     189             : }
     190             : 
     191             : static void
     192          60 : crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
     193             :                       StringMap<MemoryBufferRef> &ModuleMap,
     194             :                       const FunctionImporter::ImportMapTy &ImportList) {
     195          27 :   auto Loader = [&](StringRef Identifier) {
     196          54 :     return loadModuleFromBuffer(ModuleMap[Identifier], TheModule.getContext(),
     197             :                                 /*Lazy=*/true, /*IsImporting*/ true);
     198          54 :   };
     199             : 
     200             :   FunctionImporter Importer(Index, Loader);
     201          60 :   Expected<bool> Result = Importer.importFunctions(TheModule, ImportList);
     202          60 :   if (!Result) {
     203           0 :     handleAllErrors(Result.takeError(), [&](ErrorInfoBase &EIB) {
     204           0 :       SMDiagnostic Err = SMDiagnostic(TheModule.getModuleIdentifier(),
     205           0 :                                       SourceMgr::DK_Error, EIB.message());
     206           0 :       Err.print("ThinLTO", errs());
     207           0 :     });
     208           0 :     report_fatal_error("importFunctions failed");
     209             :   }
     210             :   // Verify again after cross-importing.
     211          60 :   verifyLoadedModule(TheModule);
     212          60 : }
     213             : 
     214          51 : static void optimizeModule(Module &TheModule, TargetMachine &TM,
     215             :                            unsigned OptLevel, bool Freestanding) {
     216             :   // Populate the PassManager
     217         102 :   PassManagerBuilder PMB;
     218          51 :   PMB.LibraryInfo = new TargetLibraryInfoImpl(TM.getTargetTriple());
     219          51 :   if (Freestanding)
     220           1 :     PMB.LibraryInfo->disableAllFunctions();
     221          51 :   PMB.Inliner = createFunctionInliningPass();
     222             :   // FIXME: should get it from the bitcode?
     223          51 :   PMB.OptLevel = OptLevel;
     224          51 :   PMB.LoopVectorize = true;
     225          51 :   PMB.SLPVectorize = true;
     226             :   // Already did this in verifyLoadedModule().
     227          51 :   PMB.VerifyInput = false;
     228          51 :   PMB.VerifyOutput = false;
     229             : 
     230         102 :   legacy::PassManager PM;
     231             : 
     232             :   // Add the TTI (required to inform the vectorizer about register size for
     233             :   // instance)
     234         102 :   PM.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
     235             : 
     236             :   // Add optimizations
     237          51 :   PMB.populateThinLTOPassManager(PM);
     238             : 
     239          51 :   PM.run(TheModule);
     240          51 : }
     241             : 
     242             : // Convert the PreservedSymbols map from "Name" based to "GUID" based.
     243             : static DenseSet<GlobalValue::GUID>
     244          64 : computeGUIDPreservedSymbols(const StringSet<> &PreservedSymbols,
     245             :                             const Triple &TheTriple) {
     246          64 :   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols(PreservedSymbols.size());
     247         168 :   for (auto &Entry : PreservedSymbols) {
     248          40 :     StringRef Name = Entry.first();
     249          68 :     if (TheTriple.isOSBinFormatMachO() && Name.size() > 0 && Name[0] == '_')
     250          12 :       Name = Name.drop_front();
     251          80 :     GUIDPreservedSymbols.insert(GlobalValue::getGUID(Name));
     252             :   }
     253          64 :   return GUIDPreservedSymbols;
     254             : }
     255             : 
     256          48 : std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
     257             :                                             TargetMachine &TM) {
     258             :   SmallVector<char, 128> OutputBuffer;
     259             : 
     260             :   // CodeGen
     261             :   {
     262             :     raw_svector_ostream OS(OutputBuffer);
     263          97 :     legacy::PassManager PM;
     264             : 
     265             :     // If the bitcode files contain ARC code and were compiled with optimization,
     266             :     // the ObjCARCContractPass must be run, so do it unconditionally here.
     267          49 :     PM.add(createObjCARCContractPass());
     268             : 
     269             :     // Setup the codegen now.
     270          49 :     if (TM.addPassesToEmitFile(PM, OS, TargetMachine::CGFT_ObjectFile,
     271          49 :                                /* DisableVerify */ true))
     272           0 :       report_fatal_error("Failed to setup codegen");
     273             : 
     274             :     // Run codegen now. resulting binary is in OutputBuffer.
     275          49 :     PM.run(TheModule);
     276             :   }
     277          48 :   return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
     278             : }
     279             : 
     280             : /// Manage caching for a single Module.
     281             : class ModuleCacheEntry {
     282             :   SmallString<128> EntryPath;
     283             : 
     284             : public:
     285             :   // Create a cache entry. This compute a unique hash for the Module considering
     286             :   // the current list of export/import, and offer an interface to query to
     287             :   // access the content in the cache.
     288          47 :   ModuleCacheEntry(
     289             :       StringRef CachePath, const ModuleSummaryIndex &Index, StringRef ModuleID,
     290             :       const FunctionImporter::ImportMapTy &ImportList,
     291             :       const FunctionImporter::ExportSetTy &ExportList,
     292             :       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
     293             :       const GVSummaryMapTy &DefinedFunctions,
     294             :       const DenseSet<GlobalValue::GUID> &PreservedSymbols, unsigned OptLevel,
     295             :       bool Freestanding, const TargetMachineBuilder &TMBuilder) {
     296          47 :     if (CachePath.empty())
     297          31 :       return;
     298             : 
     299             :     if (!Index.modulePaths().count(ModuleID))
     300             :       // The module does not have an entry, it can't have a hash at all
     301             :       return;
     302             : 
     303             :     // Compute the unique hash for this entry
     304             :     // This is based on the current compiler version, the module itself, the
     305             :     // export list, the hash for every single module in the import list, the
     306             :     // list of ResolvedODR for the module, and the list of preserved symbols.
     307             : 
     308             :     // Include the hash for the current module
     309          19 :     auto ModHash = Index.getModuleHash(ModuleID);
     310             : 
     311          19 :     if (all_of(ModHash, [](uint32_t V) { return V == 0; }))
     312             :       // No hash entry, no caching!
     313             :       return;
     314             : 
     315             :     SHA1 Hasher;
     316             : 
     317             :     // Include the parts of the LTO configuration that affect code generation.
     318          32 :     auto AddString = [&](StringRef Str) {
     319          64 :       Hasher.update(Str);
     320          32 :       Hasher.update(ArrayRef<uint8_t>{0});
     321          48 :     };
     322         112 :     auto AddUnsigned = [&](unsigned I) {
     323             :       uint8_t Data[4];
     324         112 :       Data[0] = I;
     325         112 :       Data[1] = I >> 8;
     326         112 :       Data[2] = I >> 16;
     327         112 :       Data[3] = I >> 24;
     328         224 :       Hasher.update(ArrayRef<uint8_t>{Data, 4});
     329         128 :     };
     330             : 
     331             :     // Start with the compiler revision
     332             :     Hasher.update(LLVM_VERSION_STRING);
     333             : #ifdef LLVM_REVISION
     334             :     Hasher.update(LLVM_REVISION);
     335             : #endif
     336             : 
     337             :     // Hash the optimization level and the target machine settings.
     338          16 :     AddString(TMBuilder.MCpu);
     339             :     // FIXME: Hash more of Options. For now all clients initialize Options from
     340             :     // command-line flags (which is unsupported in production), but may set
     341             :     // RelaxELFRelocations. The clang driver can also pass FunctionSections,
     342             :     // DataSections and DebuggerTuning via command line flags.
     343          16 :     AddUnsigned(TMBuilder.Options.RelaxELFRelocations);
     344          16 :     AddUnsigned(TMBuilder.Options.FunctionSections);
     345          16 :     AddUnsigned(TMBuilder.Options.DataSections);
     346          16 :     AddUnsigned((unsigned)TMBuilder.Options.DebuggerTuning);
     347          16 :     AddString(TMBuilder.MAttr);
     348          16 :     if (TMBuilder.RelocModel)
     349           0 :       AddUnsigned(*TMBuilder.RelocModel);
     350          16 :     AddUnsigned(TMBuilder.CGOptLevel);
     351          16 :     AddUnsigned(OptLevel);
     352          16 :     AddUnsigned(Freestanding);
     353             : 
     354          16 :     Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
     355          18 :     for (auto F : ExportList)
     356             :       // The export list can impact the internalization, be conservative here
     357           2 :       Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
     358             : 
     359             :     // Include the hash for every module we import functions from
     360          34 :     for (auto &Entry : ImportList) {
     361           2 :       auto ModHash = Index.getModuleHash(Entry.first());
     362           2 :       Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
     363             :     }
     364             : 
     365             :     // Include the hash for the resolved ODR.
     366          16 :     for (auto &Entry : ResolvedODR) {
     367           0 :       Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
     368             :                                       sizeof(GlobalValue::GUID)));
     369           0 :       Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
     370             :                                       sizeof(GlobalValue::LinkageTypes)));
     371             :     }
     372             : 
     373             :     // Include the hash for the preserved symbols.
     374          32 :     for (auto &Entry : PreservedSymbols) {
     375             :       if (DefinedFunctions.count(Entry))
     376           8 :         Hasher.update(
     377             :             ArrayRef<uint8_t>((const uint8_t *)&Entry, sizeof(GlobalValue::GUID)));
     378             :     }
     379             : 
     380             :     // This choice of file name allows the cache to be pruned (see pruneCache()
     381             :     // in include/llvm/Support/CachePruning.h).
     382          32 :     sys::path::append(EntryPath, CachePath,
     383          48 :                       "llvmcache-" + toHex(Hasher.result()));
     384             :   }
     385             : 
     386             :   // Access the path to this entry in the cache.
     387             :   StringRef getEntryPath() { return EntryPath; }
     388             : 
     389             :   // Try loading the buffer for this cache entry.
     390          59 :   ErrorOr<std::unique_ptr<MemoryBuffer>> tryLoadingBuffer() {
     391          59 :     if (EntryPath.empty())
     392             :       return std::error_code();
     393          56 :     return MemoryBuffer::getFile(EntryPath);
     394             :   }
     395             : 
     396             :   // Cache the Produced object file
     397          47 :   void write(const MemoryBuffer &OutputBuffer) {
     398          47 :     if (EntryPath.empty())
     399          31 :       return;
     400             : 
     401             :     // Write to a temporary to avoid race condition
     402             :     SmallString<128> TempFilename;
     403             :     int TempFD;
     404             :     std::error_code EC =
     405          16 :         sys::fs::createTemporaryFile("Thin", "tmp.o", TempFD, TempFilename);
     406          16 :     if (EC) {
     407           0 :       errs() << "Error: " << EC.message() << "\n";
     408           0 :       report_fatal_error("ThinLTO: Can't get a temporary file");
     409             :     }
     410             :     {
     411          32 :       raw_fd_ostream OS(TempFD, /* ShouldClose */ true);
     412          16 :       OS << OutputBuffer.getBuffer();
     413             :     }
     414             :     // Rename to final destination (hopefully race condition won't matter here)
     415          32 :     EC = sys::fs::rename(TempFilename, EntryPath);
     416          16 :     if (EC) {
     417           0 :       sys::fs::remove(TempFilename);
     418           0 :       raw_fd_ostream OS(EntryPath, EC, sys::fs::F_None);
     419           0 :       if (EC)
     420           0 :         report_fatal_error(Twine("Failed to open ") + EntryPath +
     421             :                            " to save cached entry\n");
     422           0 :       OS << OutputBuffer.getBuffer();
     423             :     }
     424             :   }
     425             : };
     426             : 
     427             : static std::unique_ptr<MemoryBuffer>
     428          47 : ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
     429             :                      StringMap<MemoryBufferRef> &ModuleMap, TargetMachine &TM,
     430             :                      const FunctionImporter::ImportMapTy &ImportList,
     431             :                      const FunctionImporter::ExportSetTy &ExportList,
     432             :                      const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
     433             :                      const GVSummaryMapTy &DefinedGlobals,
     434             :                      const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
     435             :                      bool DisableCodeGen, StringRef SaveTempsDir,
     436             :                      bool Freestanding, unsigned OptLevel, unsigned count) {
     437             : 
     438             :   // "Benchmark"-like optimization: single-source case
     439          47 :   bool SingleModule = (ModuleMap.size() == 1);
     440             : 
     441          47 :   if (!SingleModule) {
     442          44 :     promoteModule(TheModule, Index);
     443             : 
     444             :     // Apply summary-based LinkOnce/Weak resolution decisions.
     445          44 :     thinLTOResolveWeakForLinkerModule(TheModule, DefinedGlobals);
     446             : 
     447             :     // Save temps: after promotion.
     448          44 :     saveTempBitcode(TheModule, SaveTempsDir, count, ".1.promoted.bc");
     449             :   }
     450             : 
     451             :   // Be friendly and don't nuke totally the module when the client didn't
     452             :   // supply anything to preserve.
     453          80 :   if (!ExportList.empty() || !GUIDPreservedSymbols.empty()) {
     454             :     // Apply summary-based internalization decisions.
     455          41 :     thinLTOInternalizeModule(TheModule, DefinedGlobals);
     456             :   }
     457             : 
     458             :   // Save internalized bitcode
     459          47 :   saveTempBitcode(TheModule, SaveTempsDir, count, ".2.internalized.bc");
     460             : 
     461          47 :   if (!SingleModule) {
     462          44 :     crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
     463             : 
     464             :     // Save temps: after cross-module import.
     465          44 :     saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
     466             :   }
     467             : 
     468          47 :   optimizeModule(TheModule, TM, OptLevel, Freestanding);
     469             : 
     470          47 :   saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
     471             : 
     472          47 :   if (DisableCodeGen) {
     473             :     // Configured to stop before CodeGen, serialize the bitcode and return.
     474             :     SmallVector<char, 128> OutputBuffer;
     475             :     {
     476             :       raw_svector_ostream OS(OutputBuffer);
     477             :       ProfileSummaryInfo PSI(TheModule);
     478           0 :       auto Index = buildModuleSummaryIndex(TheModule, nullptr, &PSI);
     479           0 :       WriteBitcodeToFile(TheModule, OS, true, &Index);
     480             :     }
     481             :     return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
     482             :   }
     483             : 
     484          47 :   return codegenModule(TheModule, TM);
     485             : }
     486             : 
     487             : /// Resolve LinkOnce/Weak symbols. Record resolutions in the \p ResolvedODR map
     488             : /// for caching, and in the \p Index for application during the ThinLTO
     489             : /// backends. This is needed for correctness for exported symbols (ensure
     490             : /// at least one copy kept) and a compile-time optimization (to drop duplicate
     491             : /// copies when possible).
     492          42 : static void resolveWeakForLinkerInIndex(
     493             :     ModuleSummaryIndex &Index,
     494             :     StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
     495             :         &ResolvedODR) {
     496             : 
     497             :   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
     498          42 :   computePrevailingCopies(Index, PrevailingCopy);
     499             : 
     500         209 :   auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
     501         209 :     const auto &Prevailing = PrevailingCopy.find(GUID);
     502             :     // Not in map means that there was only one copy, which must be prevailing.
     503         209 :     if (Prevailing == PrevailingCopy.end())
     504             :       return true;
     505         132 :     return Prevailing->second == S;
     506          42 :   };
     507             : 
     508             :   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
     509             :                               GlobalValue::GUID GUID,
     510          98 :                               GlobalValue::LinkageTypes NewLinkage) {
     511         196 :     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
     512         140 :   };
     513             : 
     514          42 :   thinLTOResolveWeakForLinkerInIndex(Index, isPrevailing, recordNewLinkage);
     515          42 : }
     516             : 
     517             : // Initialize the TargetMachine builder for a given Triple
     518          88 : static void initTMBuilder(TargetMachineBuilder &TMBuilder,
     519             :                           const Triple &TheTriple) {
     520             :   // Set a default CPU for Darwin triples (copied from LTOCodeGenerator).
     521             :   // FIXME this looks pretty terrible...
     522          88 :   if (TMBuilder.MCpu.empty() && TheTriple.isOSDarwin()) {
     523          45 :     if (TheTriple.getArch() == llvm::Triple::x86_64)
     524          45 :       TMBuilder.MCpu = "core2";
     525           0 :     else if (TheTriple.getArch() == llvm::Triple::x86)
     526           0 :       TMBuilder.MCpu = "yonah";
     527           0 :     else if (TheTriple.getArch() == llvm::Triple::aarch64)
     528           0 :       TMBuilder.MCpu = "cyclone";
     529             :   }
     530             :   TMBuilder.TheTriple = std::move(TheTriple);
     531          88 : }
     532             : 
     533             : } // end anonymous namespace
     534             : 
     535         141 : void ThinLTOCodeGenerator::addModule(StringRef Identifier, StringRef Data) {
     536             :   ThinLTOBuffer Buffer(Data, Identifier);
     537         282 :   LLVMContext Context;
     538         141 :   StringRef TripleStr;
     539             :   ErrorOr<std::string> TripleOrErr = expectedToErrorOrAndEmitErrors(
     540         141 :       Context, getBitcodeTargetTriple(Buffer.getMemBuffer()));
     541             : 
     542         141 :   if (TripleOrErr)
     543         141 :     TripleStr = *TripleOrErr;
     544             : 
     545         141 :   Triple TheTriple(TripleStr);
     546             : 
     547         141 :   if (Modules.empty())
     548         152 :     initTMBuilder(TMBuilder, Triple(TheTriple));
     549             :   else if (TMBuilder.TheTriple != TheTriple) {
     550           0 :     if (!TMBuilder.TheTriple.isCompatibleWith(TheTriple))
     551           0 :       report_fatal_error("ThinLTO modules with incompatible triples not "
     552             :                          "supported");
     553           0 :     initTMBuilder(TMBuilder, Triple(TMBuilder.TheTriple.merge(TheTriple)));
     554             :   }
     555             : 
     556         141 :   Modules.push_back(Buffer);
     557         141 : }
     558             : 
     559          40 : void ThinLTOCodeGenerator::preserveSymbol(StringRef Name) {
     560             :   PreservedSymbols.insert(Name);
     561          40 : }
     562             : 
     563           0 : void ThinLTOCodeGenerator::crossReferenceSymbol(StringRef Name) {
     564             :   // FIXME: At the moment, we don't take advantage of this extra information,
     565             :   // we're conservatively considering cross-references as preserved.
     566             :   //  CrossReferencedSymbols.insert(Name);
     567             :   PreservedSymbols.insert(Name);
     568           0 : }
     569             : 
     570             : // TargetMachine factory
     571          53 : std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
     572             :   std::string ErrMsg;
     573             :   const Target *TheTarget =
     574          53 :       TargetRegistry::lookupTarget(TheTriple.str(), ErrMsg);
     575          53 :   if (!TheTarget) {
     576           0 :     report_fatal_error("Can't load target for this Triple: " + ErrMsg);
     577             :   }
     578             : 
     579             :   // Use MAttr as the default set of features.
     580          53 :   SubtargetFeatures Features(MAttr);
     581          53 :   Features.getDefaultSubtargetFeatures(TheTriple);
     582          53 :   std::string FeatureStr = Features.getString();
     583             : 
     584             :   return std::unique_ptr<TargetMachine>(
     585             :       TheTarget->createTargetMachine(TheTriple.str(), MCpu, FeatureStr, Options,
     586         265 :                                      RelocModel, None, CGOptLevel));
     587             : }
     588             : 
     589             : /**
     590             :  * Produce the combined summary index from all the bitcode files:
     591             :  * "thin-link".
     592             :  */
     593          54 : std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
     594             :   std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
     595         108 :       llvm::make_unique<ModuleSummaryIndex>(/*IsPeformingAnalysis=*/false);
     596             :   uint64_t NextModuleId = 0;
     597         155 :   for (auto &ModuleBuffer : Modules) {
     598         101 :     if (Error Err = readModuleSummaryIndex(ModuleBuffer.getMemBuffer(),
     599         202 :                                            *CombinedIndex, NextModuleId++)) {
     600             :       // FIXME diagnose
     601           0 :       logAllUnhandledErrors(
     602             :           std::move(Err), errs(),
     603             :           "error: can't create module summary index for buffer: ");
     604             :       return nullptr;
     605             :     }
     606             :   }
     607             :   return CombinedIndex;
     608             : }
     609             : 
     610             : static void internalizeAndPromoteInIndex(
     611             :     const StringMap<FunctionImporter::ExportSetTy> &ExportLists,
     612             :     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
     613             :     ModuleSummaryIndex &Index) {
     614         430 :   auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
     615         430 :     const auto &ExportList = ExportLists.find(ModuleIdentifier);
     616         590 :     return (ExportList != ExportLists.end() &&
     617         590 :             ExportList->second.count(GUID)) ||
     618         777 :            GUIDPreservedSymbols.count(GUID);
     619          47 :   };
     620             : 
     621          47 :   thinLTOInternalizeAndPromoteInIndex(Index, isExported);
     622             : }
     623             : 
     624             : static void computeDeadSymbolsInIndex(
     625             :     ModuleSummaryIndex &Index,
     626             :     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
     627             :   // We have no symbols resolution available. And can't do any better now in the
     628             :   // case where the prevailing symbol is in a native object. It can be refined
     629             :   // with linker information in the future.
     630             :   auto isPrevailing = [&](GlobalValue::GUID G) {
     631             :     return PrevailingType::Unknown;
     632             :   };
     633          64 :   computeDeadSymbols(Index, GUIDPreservedSymbols, isPrevailing);
     634             : }
     635             : 
     636             : /**
     637             :  * Perform promotion and renaming of exported internal functions.
     638             :  * Index is updated to reflect linkage changes from weak resolution.
     639             :  */
     640          17 : void ThinLTOCodeGenerator::promote(Module &TheModule,
     641             :                                    ModuleSummaryIndex &Index) {
     642          17 :   auto ModuleCount = Index.modulePaths().size();
     643             :   auto ModuleIdentifier = TheModule.getModuleIdentifier();
     644             : 
     645             :   // Collect for each module the list of function it defines (GUID -> Summary).
     646          17 :   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
     647          17 :   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
     648             : 
     649             :   // Convert the preserved symbols set from string to GUID
     650             :   auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
     651          34 :       PreservedSymbols, Triple(TheModule.getTargetTriple()));
     652             : 
     653             :   // Compute "dead" symbols, we don't want to import/export these!
     654             :   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
     655             : 
     656             :   // Generate import/export list
     657          17 :   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
     658          17 :   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
     659          17 :   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
     660             :                            ExportLists);
     661             : 
     662             :   // Resolve LinkOnce/Weak symbols.
     663          17 :   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
     664          17 :   resolveWeakForLinkerInIndex(Index, ResolvedODR);
     665             : 
     666          17 :   thinLTOResolveWeakForLinkerModule(
     667             :       TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
     668             : 
     669             :   // Promote the exported values in the index, so that they are promoted
     670             :   // in the module.
     671             :   internalizeAndPromoteInIndex(ExportLists, GUIDPreservedSymbols, Index);
     672             : 
     673          17 :   promoteModule(TheModule, Index);
     674          17 : }
     675             : 
     676             : /**
     677             :  * Perform cross-module importing for the module identified by ModuleIdentifier.
     678             :  */
     679          16 : void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
     680             :                                              ModuleSummaryIndex &Index) {
     681          32 :   auto ModuleMap = generateModuleMap(Modules);
     682          16 :   auto ModuleCount = Index.modulePaths().size();
     683             : 
     684             :   // Collect for each module the list of function it defines (GUID -> Summary).
     685          16 :   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
     686          16 :   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
     687             : 
     688             :   // Convert the preserved symbols set from string to GUID
     689             :   auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
     690          32 :       PreservedSymbols, Triple(TheModule.getTargetTriple()));
     691             : 
     692             :   // Compute "dead" symbols, we don't want to import/export these!
     693             :   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
     694             : 
     695             :   // Generate import/export list
     696          16 :   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
     697          16 :   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
     698          16 :   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
     699             :                            ExportLists);
     700             :   auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
     701             : 
     702          16 :   crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
     703          16 : }
     704             : 
     705             : /**
     706             :  * Compute the list of summaries needed for importing into module.
     707             :  */
     708           3 : void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
     709             :     StringRef ModulePath, ModuleSummaryIndex &Index,
     710             :     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
     711           3 :   auto ModuleCount = Index.modulePaths().size();
     712             : 
     713             :   // Collect for each module the list of function it defines (GUID -> Summary).
     714           3 :   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
     715           3 :   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
     716             : 
     717             :   // Generate import/export list
     718           3 :   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
     719           3 :   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
     720           3 :   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
     721             :                            ExportLists);
     722             : 
     723           3 :   llvm::gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
     724             :                                          ImportLists[ModulePath],
     725             :                                          ModuleToSummariesForIndex);
     726           3 : }
     727             : 
     728             : /**
     729             :  * Emit the list of files needed for importing into module.
     730             :  */
     731           3 : void ThinLTOCodeGenerator::emitImports(StringRef ModulePath,
     732             :                                        StringRef OutputName,
     733             :                                        ModuleSummaryIndex &Index) {
     734           3 :   auto ModuleCount = Index.modulePaths().size();
     735             : 
     736             :   // Collect for each module the list of function it defines (GUID -> Summary).
     737           3 :   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
     738           3 :   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
     739             : 
     740             :   // Generate import/export list
     741           3 :   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
     742           3 :   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
     743           3 :   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
     744             :                            ExportLists);
     745             : 
     746             :   std::error_code EC;
     747           3 :   if ((EC = EmitImportsFiles(ModulePath, OutputName, ImportLists[ModulePath])))
     748           0 :     report_fatal_error(Twine("Failed to open ") + OutputName +
     749             :                        " to save imports lists\n");
     750           3 : }
     751             : 
     752             : /**
     753             :  * Perform internalization. Index is updated to reflect linkage changes.
     754             :  */
     755           6 : void ThinLTOCodeGenerator::internalize(Module &TheModule,
     756             :                                        ModuleSummaryIndex &Index) {
     757          12 :   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
     758           6 :   auto ModuleCount = Index.modulePaths().size();
     759             :   auto ModuleIdentifier = TheModule.getModuleIdentifier();
     760             : 
     761             :   // Convert the preserved symbols set from string to GUID
     762             :   auto GUIDPreservedSymbols =
     763           6 :       computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
     764             : 
     765             :   // Collect for each module the list of function it defines (GUID -> Summary).
     766           5 :   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
     767           6 :   Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
     768             : 
     769             :   // Compute "dead" symbols, we don't want to import/export these!
     770             :   computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
     771             : 
     772             :   // Generate import/export list
     773           5 :   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
     774           5 :   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
     775           6 :   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
     776             :                            ExportLists);
     777             :   auto &ExportList = ExportLists[ModuleIdentifier];
     778             : 
     779             :   // Be friendly and don't nuke totally the module when the client didn't
     780             :   // supply anything to preserve.
     781          11 :   if (ExportList.empty() && GUIDPreservedSymbols.empty())
     782           1 :     return;
     783             : 
     784             :   // Internalization
     785             :   internalizeAndPromoteInIndex(ExportLists, GUIDPreservedSymbols, Index);
     786           5 :   thinLTOInternalizeModule(TheModule,
     787             :                            ModuleToDefinedGVSummaries[ModuleIdentifier]);
     788             : }
     789             : 
     790             : /**
     791             :  * Perform post-importing ThinLTO optimizations.
     792             :  */
     793           4 : void ThinLTOCodeGenerator::optimize(Module &TheModule) {
     794           8 :   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
     795             : 
     796             :   // Optimize now
     797          12 :   optimizeModule(TheModule, *TMBuilder.create(), OptLevel, Freestanding);
     798           4 : }
     799             : 
     800             : /**
     801             :  * Perform ThinLTO CodeGen.
     802             :  */
     803           2 : std::unique_ptr<MemoryBuffer> ThinLTOCodeGenerator::codegen(Module &TheModule) {
     804           4 :   initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
     805           6 :   return codegenModule(TheModule, *TMBuilder.create());
     806             : }
     807             : 
     808             : /// Write out the generated object file, either from CacheEntryPath or from
     809             : /// OutputBuffer, preferring hard-link when possible.
     810             : /// Returns the path to the generated file in SavedObjectsDirectoryPath.
     811           6 : static std::string writeGeneratedObject(int count, StringRef CacheEntryPath,
     812             :                                         StringRef SavedObjectsDirectoryPath,
     813             :                                         const MemoryBuffer &OutputBuffer) {
     814             :   SmallString<128> OutputPath(SavedObjectsDirectoryPath);
     815           6 :   llvm::sys::path::append(OutputPath, Twine(count) + ".thinlto.o");
     816             :   OutputPath.c_str(); // Ensure the string is null terminated.
     817           6 :   if (sys::fs::exists(OutputPath))
     818           0 :     sys::fs::remove(OutputPath);
     819             : 
     820             :   // We don't return a memory buffer to the linker, just a list of files.
     821           6 :   if (!CacheEntryPath.empty()) {
     822             :     // Cache is enabled, hard-link the entry (or copy if hard-link fails).
     823           4 :     auto Err = sys::fs::create_hard_link(CacheEntryPath, OutputPath);
     824           4 :     if (!Err)
     825             :       return OutputPath.str();
     826             :     // Hard linking failed, try to copy.
     827           0 :     Err = sys::fs::copy_file(CacheEntryPath, OutputPath);
     828           0 :     if (!Err)
     829             :       return OutputPath.str();
     830             :     // Copy failed (could be because the CacheEntry was removed from the cache
     831             :     // in the meantime by another process), fall back and try to write down the
     832             :     // buffer to the output.
     833           0 :     errs() << "error: can't link or copy from cached entry '" << CacheEntryPath
     834           0 :            << "' to '" << OutputPath << "'\n";
     835             :   }
     836             :   // No cache entry, just write out the buffer.
     837             :   std::error_code Err;
     838           4 :   raw_fd_ostream OS(OutputPath, Err, sys::fs::F_None);
     839           2 :   if (Err)
     840           0 :     report_fatal_error("Can't open output '" + OutputPath + "'\n");
     841           2 :   OS << OutputBuffer.getBuffer();
     842             :   return OutputPath.str();
     843             : }
     844             : 
     845             : // Main entry point for the ThinLTO processing
     846          27 : void ThinLTOCodeGenerator::run() {
     847             :   // Prepare the resulting object vector
     848             :   assert(ProducedBinaries.empty() && "The generator should not be reused");
     849          27 :   if (SavedObjectsDirectoryPath.empty())
     850          48 :     ProducedBinaries.resize(Modules.size());
     851             :   else {
     852           6 :     sys::fs::create_directories(SavedObjectsDirectoryPath);
     853             :     bool IsDir;
     854           3 :     sys::fs::is_directory(SavedObjectsDirectoryPath, IsDir);
     855           3 :     if (!IsDir)
     856           0 :       report_fatal_error("Unexistent dir: '" + SavedObjectsDirectoryPath + "'");
     857           6 :     ProducedBinaryFiles.resize(Modules.size());
     858             :   }
     859             : 
     860          27 :   if (CodeGenOnly) {
     861             :     // Perform only parallel codegen and return.
     862           4 :     ThreadPool Pool;
     863             :     int count = 0;
     864           4 :     for (auto &ModuleBuffer : Modules) {
     865           6 :       Pool.async([&](int count) {
     866           4 :         LLVMContext Context;
     867           2 :         Context.setDiscardValueNames(LTODiscardValueNames);
     868             : 
     869             :         // Parse module now
     870             :         auto TheModule =
     871           4 :             loadModuleFromBuffer(ModuleBuffer.getMemBuffer(), Context, false,
     872           4 :                                  /*IsImporting*/ false);
     873             : 
     874             :         // CodeGen
     875           4 :         auto OutputBuffer = codegen(*TheModule);
     876           2 :         if (SavedObjectsDirectoryPath.empty())
     877           2 :           ProducedBinaries[count] = std::move(OutputBuffer);
     878             :         else
     879           0 :           ProducedBinaryFiles[count] = writeGeneratedObject(
     880             :               count, "", SavedObjectsDirectoryPath, *OutputBuffer);
     881           4 :       }, count++);
     882             :     }
     883             : 
     884             :     return;
     885             :   }
     886             : 
     887             :   // Sequential linking phase
     888          50 :   auto Index = linkCombinedIndex();
     889             : 
     890             :   // Save temps: index.
     891          25 :   if (!SaveTempsDir.empty()) {
     892           3 :     auto SaveTempPath = SaveTempsDir + "index.bc";
     893             :     std::error_code EC;
     894           6 :     raw_fd_ostream OS(SaveTempPath, EC, sys::fs::F_None);
     895           3 :     if (EC)
     896           0 :       report_fatal_error(Twine("Failed to open ") + SaveTempPath +
     897             :                          " to save optimized bitcode\n");
     898           3 :     WriteIndexToFile(*Index, OS);
     899             :   }
     900             : 
     901             : 
     902             :   // Prepare the module map.
     903          50 :   auto ModuleMap = generateModuleMap(Modules);
     904          25 :   auto ModuleCount = Modules.size();
     905             : 
     906             :   // Collect for each module the list of function it defines (GUID -> Summary).
     907          50 :   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
     908          25 :   Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
     909             : 
     910             :   // Convert the preserved symbols set from string to GUID, this is needed for
     911             :   // computing the caching hash and the internalization.
     912             :   auto GUIDPreservedSymbols =
     913          25 :       computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
     914             : 
     915             :   // Compute "dead" symbols, we don't want to import/export these!
     916             :   computeDeadSymbolsInIndex(*Index, GUIDPreservedSymbols);
     917             : 
     918             :   // Collect the import/export lists for all modules from the call-graph in the
     919             :   // combined index.
     920          25 :   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
     921          25 :   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
     922          25 :   ComputeCrossModuleImport(*Index, ModuleToDefinedGVSummaries, ImportLists,
     923             :                            ExportLists);
     924             : 
     925             :   // We use a std::map here to be able to have a defined ordering when
     926             :   // producing a hash for the cache entry.
     927             :   // FIXME: we should be able to compute the caching hash for the entry based
     928             :   // on the index, and nuke this map.
     929          25 :   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
     930             : 
     931             :   // Resolve LinkOnce/Weak symbols, this has to be computed early because it
     932             :   // impacts the caching.
     933          25 :   resolveWeakForLinkerInIndex(*Index, ResolvedODR);
     934             : 
     935             :   // Use global summary-based analysis to identify symbols that can be
     936             :   // internalized (because they aren't exported or preserved as per callback).
     937             :   // Changes are made in the index, consumed in the ThinLTO backends.
     938             :   internalizeAndPromoteInIndex(ExportLists, GUIDPreservedSymbols, *Index);
     939             : 
     940             :   // Make sure that every module has an entry in the ExportLists and
     941             :   // ResolvedODR maps to enable threaded access to these maps below.
     942          95 :   for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
     943             :     ExportLists[DefinedGVSummaries.first()];
     944             :     ResolvedODR[DefinedGVSummaries.first()];
     945             :   }
     946             : 
     947             :   // Compute the ordering we will process the inputs: the rough heuristic here
     948             :   // is to sort them per size so that the largest module get schedule as soon as
     949             :   // possible. This is purely a compile-time optimization.
     950             :   std::vector<int> ModulesOrdering;
     951          50 :   ModulesOrdering.resize(Modules.size());
     952             :   std::iota(ModulesOrdering.begin(), ModulesOrdering.end(), 0);
     953             :   std::sort(ModulesOrdering.begin(), ModulesOrdering.end(),
     954             :             [&](int LeftIndex, int RightIndex) {
     955          22 :               auto LSize = Modules[LeftIndex].getBuffer().size();
     956          40 :               auto RSize = Modules[RightIndex].getBuffer().size();
     957             :               return LSize > RSize;
     958             :             });
     959             : 
     960             :   // Parallel optimizer + codegen
     961             :   {
     962          50 :     ThreadPool Pool(ThreadCount);
     963          72 :     for (auto IndexCount : ModulesOrdering) {
     964          47 :       auto &ModuleBuffer = Modules[IndexCount];
     965         141 :       Pool.async([&](int count) {
     966          94 :         auto ModuleIdentifier = ModuleBuffer.getBufferIdentifier();
     967          47 :         auto &ExportList = ExportLists[ModuleIdentifier];
     968             : 
     969          94 :         auto &DefinedFunctions = ModuleToDefinedGVSummaries[ModuleIdentifier];
     970             : 
     971             :         // The module may be cached, this helps handling it.
     972         423 :         ModuleCacheEntry CacheEntry(CacheOptions.Path, *Index, ModuleIdentifier,
     973          94 :                                     ImportLists[ModuleIdentifier], ExportList,
     974          47 :                                     ResolvedODR[ModuleIdentifier],
     975          94 :                                     DefinedFunctions, GUIDPreservedSymbols,
     976          94 :                                     OptLevel, Freestanding, TMBuilder);
     977          47 :         auto CacheEntryPath = CacheEntry.getEntryPath();
     978             : 
     979             :         {
     980          47 :           auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
     981             :           DEBUG(dbgs() << "Cache " << (ErrOrBuffer ? "hit" : "miss") << " '"
     982             :                        << CacheEntryPath << "' for buffer " << count << " "
     983             :                        << ModuleIdentifier << "\n");
     984             : 
     985          47 :           if (ErrOrBuffer) {
     986             :             // Cache Hit!
     987           0 :             if (SavedObjectsDirectoryPath.empty())
     988           0 :               ProducedBinaries[count] = std::move(ErrOrBuffer.get());
     989             :             else
     990           0 :               ProducedBinaryFiles[count] = writeGeneratedObject(
     991             :                   count, CacheEntryPath, SavedObjectsDirectoryPath,
     992             :                   *ErrOrBuffer.get());
     993             :             return;
     994             :           }
     995             :         }
     996             : 
     997          53 :         LLVMContext Context;
     998          47 :         Context.setDiscardValueNames(LTODiscardValueNames);
     999          47 :         Context.enableDebugTypeODRUniquing();
    1000             :         auto DiagFileOrErr = lto::setupOptimizationRemarks(
    1001         100 :             Context, LTORemarksFilename, LTOPassRemarksWithHotness, count);
    1002          47 :         if (!DiagFileOrErr) {
    1003           0 :           errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
    1004           0 :           report_fatal_error("ThinLTO: Can't get an output file for the "
    1005             :                              "remarks");
    1006             :         }
    1007             : 
    1008             :         // Parse module now
    1009             :         auto TheModule =
    1010          47 :             loadModuleFromBuffer(ModuleBuffer.getMemBuffer(), Context, false,
    1011          53 :                                  /*IsImporting*/ false);
    1012             : 
    1013             :         // Save temps: original file.
    1014          94 :         saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
    1015             : 
    1016             :         auto &ImportList = ImportLists[ModuleIdentifier];
    1017             :         // Run the main process now, and generates a binary
    1018             :         auto OutputBuffer = ProcessThinLTOModule(
    1019         141 :             *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
    1020             :             ExportList, GUIDPreservedSymbols,
    1021             :             ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
    1022         188 :             DisableCodeGen, SaveTempsDir, Freestanding, OptLevel, count);
    1023             : 
    1024             :         // Commit to the cache (if enabled)
    1025          47 :         CacheEntry.write(*OutputBuffer);
    1026             : 
    1027          47 :         if (SavedObjectsDirectoryPath.empty()) {
    1028             :           // We need to generated a memory buffer for the linker.
    1029          41 :           if (!CacheEntryPath.empty()) {
    1030             :             // Cache is enabled, reload from the cache
    1031             :             // We do this to lower memory pressuree: the buffer is on the heap
    1032             :             // and releasing it frees memory that can be used for the next input
    1033             :             // file. The final binary link will read from the VFS cache
    1034             :             // (hopefully!) or from disk if the memory pressure wasn't too high.
    1035          12 :             auto ReloadedBufferOrErr = CacheEntry.tryLoadingBuffer();
    1036          12 :             if (auto EC = ReloadedBufferOrErr.getError()) {
    1037             :               // On error, keeping the preexisting buffer and printing a
    1038             :               // diagnostic is more friendly than just crashing.
    1039           0 :               errs() << "error: can't reload cached file '" << CacheEntryPath
    1040           0 :                      << "': " << EC.message() << "\n";
    1041             :             } else {
    1042             :               OutputBuffer = std::move(*ReloadedBufferOrErr);
    1043             :             }
    1044             :           }
    1045          82 :           ProducedBinaries[count] = std::move(OutputBuffer);
    1046             :           return;
    1047             :         }
    1048          24 :         ProducedBinaryFiles[count] = writeGeneratedObject(
    1049             :             count, CacheEntryPath, SavedObjectsDirectoryPath, *OutputBuffer);
    1050             :       }, IndexCount);
    1051             :     }
    1052             :   }
    1053             : 
    1054          25 :   pruneCache(CacheOptions.Path, CacheOptions.Policy);
    1055             : 
    1056             :   // If statistics were requested, print them out now.
    1057          25 :   if (llvm::AreStatisticsEnabled())
    1058           0 :     llvm::PrintStatistics();
    1059          25 :   reportAndResetTimings();
    1060      291906 : }

Generated by: LCOV version 1.13