LCOV - code coverage report
Current view: top level - lib/LTO - LTO.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 499 517 96.5 %
Date: 2018-07-13 00:08:38 Functions: 55 55 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-LTO.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 functions and classes used to support LTO.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/LTO/LTO.h"
      15             : #include "llvm/ADT/Statistic.h"
      16             : #include "llvm/Analysis/TargetLibraryInfo.h"
      17             : #include "llvm/Analysis/TargetTransformInfo.h"
      18             : #include "llvm/Bitcode/BitcodeReader.h"
      19             : #include "llvm/Bitcode/BitcodeWriter.h"
      20             : #include "llvm/CodeGen/Analysis.h"
      21             : #include "llvm/Config/llvm-config.h"
      22             : #include "llvm/IR/AutoUpgrade.h"
      23             : #include "llvm/IR/DiagnosticPrinter.h"
      24             : #include "llvm/IR/LegacyPassManager.h"
      25             : #include "llvm/IR/Mangler.h"
      26             : #include "llvm/IR/Metadata.h"
      27             : #include "llvm/LTO/LTOBackend.h"
      28             : #include "llvm/Linker/IRMover.h"
      29             : #include "llvm/Object/IRObjectFile.h"
      30             : #include "llvm/Support/Error.h"
      31             : #include "llvm/Support/ManagedStatic.h"
      32             : #include "llvm/Support/MemoryBuffer.h"
      33             : #include "llvm/Support/Path.h"
      34             : #include "llvm/Support/SHA1.h"
      35             : #include "llvm/Support/SourceMgr.h"
      36             : #include "llvm/Support/TargetRegistry.h"
      37             : #include "llvm/Support/ThreadPool.h"
      38             : #include "llvm/Support/Threading.h"
      39             : #include "llvm/Support/VCSRevision.h"
      40             : #include "llvm/Support/raw_ostream.h"
      41             : #include "llvm/Target/TargetMachine.h"
      42             : #include "llvm/Target/TargetOptions.h"
      43             : #include "llvm/Transforms/IPO.h"
      44             : #include "llvm/Transforms/IPO/PassManagerBuilder.h"
      45             : #include "llvm/Transforms/Utils/SplitModule.h"
      46             : 
      47             : #include <set>
      48             : 
      49             : using namespace llvm;
      50             : using namespace lto;
      51             : using namespace object;
      52             : 
      53             : #define DEBUG_TYPE "lto"
      54             : 
      55             : static cl::opt<bool>
      56      299229 :     DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden,
      57      299229 :                    cl::desc("Dump the SCCs in the ThinLTO index's callgraph"));
      58             : 
      59             : // The values are (type identifier, summary) pairs.
      60             : typedef DenseMap<
      61             :     GlobalValue::GUID,
      62             :     TinyPtrVector<const std::pair<const std::string, TypeIdSummary> *>>
      63             :     TypeIdSummariesByGuidTy;
      64             : 
      65             : // Returns a unique hash for the Module considering the current list of
      66             : // export/import and other global analysis results.
      67             : // The hash is produced in \p Key.
      68          78 : static void computeCacheKey(
      69             :     SmallString<40> &Key, const Config &Conf, const ModuleSummaryIndex &Index,
      70             :     StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList,
      71             :     const FunctionImporter::ExportSetTy &ExportList,
      72             :     const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
      73             :     const GVSummaryMapTy &DefinedGlobals,
      74             :     const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid,
      75             :     const std::set<GlobalValue::GUID> &CfiFunctionDefs,
      76             :     const std::set<GlobalValue::GUID> &CfiFunctionDecls) {
      77             :   // Compute the unique hash for this entry.
      78             :   // This is based on the current compiler version, the module itself, the
      79             :   // export list, the hash for every single module in the import list, the
      80             :   // list of ResolvedODR for the module, and the list of preserved symbols.
      81             :   SHA1 Hasher;
      82             : 
      83             :   // Start with the compiler revision
      84             :   Hasher.update(LLVM_VERSION_STRING);
      85             : #ifdef LLVM_REVISION
      86             :   Hasher.update(LLVM_REVISION);
      87             : #endif
      88             : 
      89             :   // Include the parts of the LTO configuration that affect code generation.
      90         481 :   auto AddString = [&](StringRef Str) {
      91         962 :     Hasher.update(Str);
      92         481 :     Hasher.update(ArrayRef<uint8_t>{0});
      93         559 :   };
      94        1068 :   auto AddUnsigned = [&](unsigned I) {
      95             :     uint8_t Data[4];
      96        1145 :     Data[0] = I;
      97        1145 :     Data[1] = I >> 8;
      98        1145 :     Data[2] = I >> 16;
      99        1145 :     Data[3] = I >> 24;
     100        2290 :     Hasher.update(ArrayRef<uint8_t>{Data, 4});
     101        1146 :   };
     102         112 :   auto AddUint64 = [&](uint64_t I) {
     103             :     uint8_t Data[8];
     104         112 :     Data[0] = I;
     105         112 :     Data[1] = I >> 8;
     106         112 :     Data[2] = I >> 16;
     107         112 :     Data[3] = I >> 24;
     108         112 :     Data[4] = I >> 32;
     109         112 :     Data[5] = I >> 40;
     110         112 :     Data[6] = I >> 48;
     111         112 :     Data[7] = I >> 56;
     112         224 :     Hasher.update(ArrayRef<uint8_t>{Data, 8});
     113         190 :   };
     114          78 :   AddString(Conf.CPU);
     115             :   // FIXME: Hash more of Options. For now all clients initialize Options from
     116             :   // command-line flags (which is unsupported in production), but may set
     117             :   // RelaxELFRelocations. The clang driver can also pass FunctionSections,
     118             :   // DataSections and DebuggerTuning via command line flags.
     119          78 :   AddUnsigned(Conf.Options.RelaxELFRelocations);
     120          78 :   AddUnsigned(Conf.Options.FunctionSections);
     121          78 :   AddUnsigned(Conf.Options.DataSections);
     122          78 :   AddUnsigned((unsigned)Conf.Options.DebuggerTuning);
     123          78 :   for (auto &A : Conf.MAttrs)
     124           1 :     AddString(A);
     125          78 :   if (Conf.RelocModel)
     126          78 :     AddUnsigned(*Conf.RelocModel);
     127             :   else
     128             :     AddUnsigned(-1);
     129          78 :   if (Conf.CodeModel)
     130           1 :     AddUnsigned(*Conf.CodeModel);
     131             :   else
     132             :     AddUnsigned(-1);
     133          78 :   AddUnsigned(Conf.CGOptLevel);
     134          78 :   AddUnsigned(Conf.CGFileType);
     135          78 :   AddUnsigned(Conf.OptLevel);
     136          78 :   AddUnsigned(Conf.UseNewPM);
     137          78 :   AddString(Conf.OptPipeline);
     138          78 :   AddString(Conf.AAPipeline);
     139          78 :   AddString(Conf.OverrideTriple);
     140          78 :   AddString(Conf.DefaultTriple);
     141          78 :   AddString(Conf.DwoDir);
     142             : 
     143             :   // Include the hash for the current module
     144          78 :   auto ModHash = Index.getModuleHash(ModuleID);
     145          78 :   Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
     146         114 :   for (auto F : ExportList)
     147             :     // The export list can impact the internalization, be conservative here
     148          36 :     Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
     149             : 
     150             :   // Include the hash for every module we import functions from. The set of
     151             :   // imported symbols for each module may affect code generation and is
     152             :   // sensitive to link order, so include that as well.
     153         183 :   for (auto &Entry : ImportList) {
     154          27 :     auto ModHash = Index.getModuleHash(Entry.first());
     155          27 :     Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
     156             : 
     157          27 :     AddUint64(Entry.second.size());
     158          61 :     for (auto &Fn : Entry.second)
     159          34 :       AddUint64(Fn.first);
     160             :   }
     161             : 
     162             :   // Include the hash for the resolved ODR.
     163          82 :   for (auto &Entry : ResolvedODR) {
     164           8 :     Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
     165             :                                     sizeof(GlobalValue::GUID)));
     166           8 :     Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
     167             :                                     sizeof(GlobalValue::LinkageTypes)));
     168             :   }
     169             : 
     170             :   // Members of CfiFunctionDefs and CfiFunctionDecls that are referenced or
     171             :   // defined in this module.
     172             :   std::set<GlobalValue::GUID> UsedCfiDefs;
     173             :   std::set<GlobalValue::GUID> UsedCfiDecls;
     174             : 
     175             :   // Typeids used in this module.
     176             :   std::set<GlobalValue::GUID> UsedTypeIds;
     177             : 
     178         145 :   auto AddUsedCfiGlobal = [&](GlobalValue::GUID ValueGUID) {
     179         145 :     if (CfiFunctionDefs.count(ValueGUID))
     180           2 :       UsedCfiDefs.insert(ValueGUID);
     181         145 :     if (CfiFunctionDecls.count(ValueGUID))
     182           1 :       UsedCfiDecls.insert(ValueGUID);
     183         223 :   };
     184             : 
     185         131 :   auto AddUsedThings = [&](GlobalValueSummary *GS) {
     186         131 :     if (!GS) return;
     187         310 :     AddUnsigned(GS->isLive());
     188         143 :     for (const ValueInfo &VI : GS->refs()) {
     189           6 :       AddUnsigned(VI.isDSOLocal());
     190          54 :       AddUsedCfiGlobal(VI.getGUID());
     191             :     }
     192             :     if (auto *FS = dyn_cast<FunctionSummary>(GS)) {
     193         153 :       for (auto &TT : FS->type_tests())
     194          22 :         UsedTypeIds.insert(TT);
     195         129 :       for (auto &TT : FS->type_test_assume_vcalls())
     196           0 :         UsedTypeIds.insert(TT.GUID);
     197         129 :       for (auto &TT : FS->type_checked_load_vcalls())
     198           0 :         UsedTypeIds.insert(TT.GUID);
     199         149 :       for (auto &TT : FS->type_test_assume_const_vcalls())
     200          10 :         UsedTypeIds.insert(TT.VFunc.GUID);
     201         129 :       for (auto &TT : FS->type_checked_load_const_vcalls())
     202           0 :         UsedTypeIds.insert(TT.VFunc.GUID);
     203         213 :       for (auto &ET : FS->calls()) {
     204          42 :         AddUnsigned(ET.first.isDSOLocal());
     205          42 :         AddUsedCfiGlobal(ET.first.getGUID());
     206             :       }
     207             :     }
     208          78 :   };
     209             : 
     210             :   // Include the hash for the linkage type to reflect internalization and weak
     211             :   // resolution, and collect any used type identifier resolutions.
     212         253 :   for (auto &GS : DefinedGlobals) {
     213         194 :     GlobalValue::LinkageTypes Linkage = GS.second->linkage();
     214          97 :     Hasher.update(
     215             :         ArrayRef<uint8_t>((const uint8_t *)&Linkage, sizeof(Linkage)));
     216          97 :     AddUsedCfiGlobal(GS.first);
     217          97 :     AddUsedThings(GS.second);
     218             :   }
     219             : 
     220             :   // Imported functions may introduce new uses of type identifier resolutions,
     221             :   // so we need to collect their used resolutions as well.
     222         183 :   for (auto &ImpM : ImportList)
     223          61 :     for (auto &ImpF : ImpM.second)
     224          34 :       AddUsedThings(Index.findSummaryInModule(ImpF.first, ImpM.first()));
     225             : 
     226           8 :   auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) {
     227          12 :     AddString(TId);
     228             : 
     229          22 :     AddUnsigned(S.TTRes.TheKind);
     230           8 :     AddUnsigned(S.TTRes.SizeM1BitWidth);
     231             : 
     232          40 :     AddUint64(S.TTRes.AlignLog2);
     233           8 :     AddUint64(S.TTRes.SizeM1);
     234           8 :     AddUint64(S.TTRes.BitMask);
     235           8 :     AddUint64(S.TTRes.InlineBits);
     236             : 
     237           8 :     AddUint64(S.WPDRes.size());
     238          12 :     for (auto &WPD : S.WPDRes) {
     239           4 :       AddUnsigned(WPD.first);
     240           4 :       AddUnsigned(WPD.second.TheKind);
     241           4 :       AddString(WPD.second.SingleImplName);
     242             : 
     243           4 :       AddUint64(WPD.second.ResByArg.size());
     244           6 :       for (auto &ByArg : WPD.second.ResByArg) {
     245           4 :         AddUint64(ByArg.first.size());
     246           2 :         for (uint64_t Arg : ByArg.first)
     247           0 :           AddUint64(Arg);
     248           2 :         AddUnsigned(ByArg.second.TheKind);
     249           2 :         AddUint64(ByArg.second.Info);
     250           2 :         AddUnsigned(ByArg.second.Byte);
     251           2 :         AddUnsigned(ByArg.second.Bit);
     252             :       }
     253             :     }
     254          86 :   };
     255             : 
     256             :   // Include the hash for all type identifiers used by this module.
     257         100 :   for (GlobalValue::GUID TId : UsedTypeIds) {
     258          22 :     auto SummariesI = TypeIdSummariesByGuid.find(TId);
     259          22 :     if (SummariesI != TypeIdSummariesByGuid.end())
     260          24 :       for (auto *Summary : SummariesI->second)
     261          16 :         AddTypeIdSummary(Summary->first, Summary->second);
     262             :   }
     263             : 
     264          78 :   AddUnsigned(UsedCfiDefs.size());
     265          80 :   for (auto &V : UsedCfiDefs)
     266           2 :     AddUint64(V);
     267             : 
     268          78 :   AddUnsigned(UsedCfiDecls.size());
     269          79 :   for (auto &V : UsedCfiDecls)
     270           1 :     AddUint64(V);
     271             : 
     272          78 :   if (!Conf.SampleProfile.empty()) {
     273           0 :     auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile);
     274           0 :     if (FileOrErr)
     275             :       Hasher.update(FileOrErr.get()->getBuffer());
     276             :   }
     277             : 
     278         156 :   Key = toHex(Hasher.result());
     279          78 : }
     280             : 
     281         777 : static void thinLTOResolveWeakForLinkerGUID(
     282             :     GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
     283             :     DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias,
     284             :     function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
     285             :         isPrevailing,
     286             :     function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
     287             :         recordNewLinkage) {
     288        1588 :   for (auto &S : GVSummaryList) {
     289             :     GlobalValue::LinkageTypes OriginalLinkage = S->linkage();
     290         551 :     if (!GlobalValue::isWeakForLinker(OriginalLinkage))
     291         551 :       continue;
     292             :     // We need to emit only one of these. The prevailing module will keep it,
     293             :     // but turned into a weak, while the others will drop it when possible.
     294             :     // This is both a compile-time optimization and a correctness
     295             :     // transformation. This is necessary for correctness when we have exported
     296             :     // a reference - we need to convert the linkonce to weak to
     297             :     // ensure a copy is kept to satisfy the exported reference.
     298             :     // FIXME: We may want to split the compile time and correctness
     299             :     // aspects into separate routines.
     300         260 :     if (isPrevailing(GUID, S.get())) {
     301         179 :       if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
     302             :         S->setLinkage(GlobalValue::getWeakLinkage(
     303             :             GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
     304             :     }
     305             :     // Alias and aliasee can't be turned into available_externally.
     306          81 :     else if (!isa<AliasSummary>(S.get()) &&
     307             :              !GlobalInvolvedWithAlias.count(S.get()))
     308             :       S->setLinkage(GlobalValue::AvailableExternallyLinkage);
     309         260 :     if (S->linkage() != OriginalLinkage)
     310             :       recordNewLinkage(S->modulePath(), GUID, S->linkage());
     311             :   }
     312         777 : }
     313             : 
     314             : // Resolve Weak and LinkOnce values in the \p Index.
     315             : //
     316             : // We'd like to drop these functions if they are no longer referenced in the
     317             : // current module. However there is a chance that another module is still
     318             : // referencing them because of the import. We make sure we always emit at least
     319             : // one copy.
     320         218 : void llvm::thinLTOResolveWeakForLinkerInIndex(
     321             :     ModuleSummaryIndex &Index,
     322             :     function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
     323             :         isPrevailing,
     324             :     function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
     325             :         recordNewLinkage) {
     326             :   // We won't optimize the globals that are referenced by an alias for now
     327             :   // Ideally we should turn the alias into a global and duplicate the definition
     328             :   // when needed.
     329             :   DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
     330         995 :   for (auto &I : Index)
     331        1588 :     for (auto &S : I.second.SummaryList)
     332             :       if (auto AS = dyn_cast<AliasSummary>(S.get()))
     333         336 :         GlobalInvolvedWithAlias.insert(&AS->getAliasee());
     334             : 
     335         995 :   for (auto &I : Index)
     336         777 :     thinLTOResolveWeakForLinkerGUID(I.second.SummaryList, I.first,
     337             :                                     GlobalInvolvedWithAlias, isPrevailing,
     338             :                                     recordNewLinkage);
     339         218 : }
     340             : 
     341         790 : static void thinLTOInternalizeAndPromoteGUID(
     342             :     GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
     343             :     function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
     344        1622 :   for (auto &S : GVSummaryList) {
     345         832 :     if (isExported(S->modulePath(), GUID)) {
     346             :       if (GlobalValue::isLocalLinkage(S->linkage()))
     347             :         S->setLinkage(GlobalValue::ExternalLinkage);
     348             :     } else if (!GlobalValue::isLocalLinkage(S->linkage()))
     349             :       S->setLinkage(GlobalValue::InternalLinkage);
     350             :   }
     351         790 : }
     352             : 
     353             : // Update the linkages in the given \p Index to mark exported values
     354             : // as external and non-exported values as internal.
     355         221 : void llvm::thinLTOInternalizeAndPromoteInIndex(
     356             :     ModuleSummaryIndex &Index,
     357             :     function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
     358        1011 :   for (auto &I : Index)
     359         790 :     thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported);
     360         221 : }
     361             : 
     362             : // Requires a destructor for std::vector<InputModule>.
     363             : InputFile::~InputFile() = default;
     364             : 
     365         867 : Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) {
     366        1734 :   std::unique_ptr<InputFile> File(new InputFile);
     367             : 
     368        1734 :   Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
     369         867 :   if (!FOrErr)
     370             :     return FOrErr.takeError();
     371             : 
     372         856 :   File->TargetTriple = FOrErr->TheReader.getTargetTriple();
     373         856 :   File->SourceFileName = FOrErr->TheReader.getSourceFileName();
     374         856 :   File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
     375        2568 :   File->ComdatTable = FOrErr->TheReader.getComdatTable();
     376             : 
     377        4313 :   for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
     378         867 :     size_t Begin = File->Symbols.size();
     379             :     for (const irsymtab::Reader::SymbolRef &Sym :
     380        3585 :          FOrErr->TheReader.module_symbols(I))
     381             :       // Skip symbols that are irrelevant to LTO. Note that this condition needs
     382             :       // to match the one in Skip() in LTO::addRegularLTO().
     383        5451 :       if (Sym.isGlobal() && !Sym.isFormatSpecific())
     384        3390 :         File->Symbols.push_back(Sym);
     385        1734 :     File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
     386             :   }
     387             : 
     388         856 :   File->Mods = FOrErr->Mods;
     389             :   File->Strtab = std::move(FOrErr->Strtab);
     390             :   return std::move(File);
     391             : }
     392             : 
     393         271 : StringRef InputFile::getName() const {
     394         271 :   return Mods[0].getModuleIdentifier();
     395             : }
     396             : 
     397         451 : LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
     398         451 :                                       Config &Conf)
     399             :     : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
     400             :       Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
     401         902 :       Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
     402             : 
     403         451 : LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
     404        1353 :     : Backend(Backend), CombinedIndex(/*HaveGVs*/ false) {
     405         451 :   if (!Backend)
     406         287 :     this->Backend =
     407         574 :         createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
     408         451 : }
     409             : 
     410         451 : LTO::LTO(Config Conf, ThinBackend Backend,
     411         451 :          unsigned ParallelCodeGenParallelismLevel)
     412             :     : Conf(std::move(Conf)),
     413             :       RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
     414        1804 :       ThinLTO(std::move(Backend)) {}
     415             : 
     416             : // Requires a destructor for MapVector<BitcodeModule>.
     417             : LTO::~LTO() = default;
     418             : 
     419             : // Add the symbols in the given module to the GlobalResolutions map, and resolve
     420             : // their partitions.
     421         673 : void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
     422             :                                ArrayRef<SymbolResolution> Res,
     423             :                                unsigned Partition, bool InSummary) {
     424             :   auto *ResI = Res.begin();
     425             :   auto *ResE = Res.end();
     426             :   (void)ResE;
     427        3245 :   for (const InputFile::Symbol &Sym : Syms) {
     428             :     assert(ResI != ResE);
     429        1286 :     SymbolResolution Res = *ResI++;
     430             : 
     431        1286 :     auto &GlobalRes = GlobalResolutions[Sym.getName()];
     432        2572 :     GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
     433        1286 :     if (Res.Prevailing) {
     434             :       assert(!GlobalRes.Prevailing &&
     435             :              "Multiple prevailing defs are not allowed");
     436         903 :       GlobalRes.Prevailing = true;
     437        1806 :       GlobalRes.IRName = Sym.getIRName();
     438         673 :     } else if (!GlobalRes.Prevailing && GlobalRes.IRName.empty()) {
     439             :       // Sometimes it can be two copies of symbol in a module and prevailing
     440             :       // symbol can have no IR name. That might happen if symbol is defined in
     441             :       // module level inline asm block. In case we have multiple modules with
     442             :       // the same symbol we want to use IR name of the prevailing symbol.
     443             :       // Otherwise, if we haven't seen a prevailing symbol, set the name so that
     444             :       // we can later use it to check if there is any prevailing copy in IR.
     445         552 :       GlobalRes.IRName = Sym.getIRName();
     446             :     }
     447             : 
     448             :     // Set the partition to external if we know it is re-defined by the linker
     449             :     // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a
     450             :     // regular object, is referenced from llvm.compiler_used, or was already
     451             :     // recorded as being referenced from a different partition.
     452        2256 :     if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
     453         621 :         (GlobalRes.Partition != GlobalResolution::Unknown &&
     454             :          GlobalRes.Partition != Partition)) {
     455         914 :       GlobalRes.Partition = GlobalResolution::External;
     456             :     } else
     457             :       // First recorded reference, save the current partition.
     458         372 :       GlobalRes.Partition = Partition;
     459             : 
     460             :     // Flag as visible outside of summary if visible from a regular object or
     461             :     // from a module that does not have a summary.
     462        1286 :     GlobalRes.VisibleOutsideSummary |=
     463        1782 :         (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
     464             :   }
     465         673 : }
     466             : 
     467         246 : static void writeToResolutionFile(raw_ostream &OS, InputFile *Input,
     468             :                                   ArrayRef<SymbolResolution> Res) {
     469         246 :   StringRef Path = Input->getName();
     470         246 :   OS << Path << '\n';
     471         246 :   auto ResI = Res.begin();
     472        1424 :   for (const InputFile::Symbol &Sym : Input->symbols()) {
     473             :     assert(ResI != Res.end());
     474         589 :     SymbolResolution Res = *ResI++;
     475             : 
     476        1178 :     OS << "-r=" << Path << ',' << Sym.getName() << ',';
     477         589 :     if (Res.Prevailing)
     478             :       OS << 'p';
     479         589 :     if (Res.FinalDefinitionInLinkageUnit)
     480             :       OS << 'l';
     481         589 :     if (Res.VisibleToRegularObj)
     482             :       OS << 'x';
     483         589 :     if (Res.LinkerRedefined)
     484             :       OS << 'r';
     485             :     OS << '\n';
     486             :   }
     487             :   OS.flush();
     488             :   assert(ResI == Res.end());
     489         246 : }
     490             : 
     491         662 : Error LTO::add(std::unique_ptr<InputFile> Input,
     492             :                ArrayRef<SymbolResolution> Res) {
     493             :   assert(!CalledGetMaxTasks);
     494             : 
     495         662 :   if (Conf.ResolutionFile)
     496         246 :     writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
     497             : 
     498         662 :   if (RegularLTO.CombinedModule->getTargetTriple().empty())
     499         461 :     RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
     500             : 
     501         662 :   const SymbolResolution *ResI = Res.begin();
     502        4666 :   for (unsigned I = 0; I != Input->Mods.size(); ++I)
     503        1346 :     if (Error Err = addModule(*Input, I, ResI, Res.end()))
     504             :       return Err;
     505             : 
     506             :   assert(ResI == Res.end());
     507             :   return Error::success();
     508             : }
     509             : 
     510         673 : Error LTO::addModule(InputFile &Input, unsigned ModI,
     511             :                      const SymbolResolution *&ResI,
     512             :                      const SymbolResolution *ResE) {
     513        1346 :   Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
     514         673 :   if (!LTOInfo)
     515             :     return LTOInfo.takeError();
     516             : 
     517        1346 :   BitcodeModule BM = Input.Mods[ModI];
     518         673 :   auto ModSyms = Input.module_symbols(ModI);
     519        2315 :   addModuleToGlobalRes(ModSyms, {ResI, ResE},
     520         969 :                        LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
     521         673 :                        LTOInfo->HasSummary);
     522             : 
     523         673 :   if (LTOInfo->IsThinLTO)
     524         296 :     return addThinLTO(BM, ModSyms, ResI, ResE);
     525             : 
     526             :   Expected<RegularLTOState::AddedModule> ModOrErr =
     527         754 :       addRegularLTO(BM, ModSyms, ResI, ResE);
     528         377 :   if (!ModOrErr)
     529             :     return ModOrErr.takeError();
     530             : 
     531         377 :   if (!LTOInfo->HasSummary)
     532         364 :     return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
     533             : 
     534             :   // Regular LTO module summaries are added to a dummy module that represents
     535             :   // the combined regular LTO module.
     536          26 :   if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
     537             :     return Err;
     538          13 :   RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
     539             :   return Error::success();
     540             : }
     541             : 
     542             : // Checks whether the given global value is in a non-prevailing comdat
     543             : // (comdat containing values the linker indicated were not prevailing,
     544             : // which we then dropped to available_externally), and if so, removes
     545             : // it from the comdat. This is called for all global values to ensure the
     546             : // comdat is empty rather than leaving an incomplete comdat. It is needed for
     547             : // regular LTO modules, in case we are in a mixed-LTO mode (both regular
     548             : // and thin LTO modules) compilation. Since the regular LTO module will be
     549             : // linked first in the final native link, we want to make sure the linker
     550             : // doesn't select any of these incomplete comdats that would be left
     551             : // in the regular LTO module without this cleanup.
     552             : static void
     553         111 : handleNonPrevailingComdat(GlobalValue &GV,
     554             :                           std::set<const Comdat *> &NonPrevailingComdats) {
     555             :   Comdat *C = GV.getComdat();
     556         111 :   if (!C)
     557             :     return;
     558             : 
     559             :   if (!NonPrevailingComdats.count(C))
     560             :     return;
     561             : 
     562             :   // Additionally need to drop externally visible global values from the comdat
     563             :   // to available_externally, so that there aren't multiply defined linker
     564             :   // errors.
     565             :   if (!GV.hasLocalLinkage())
     566             :     GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
     567             : 
     568             :   if (auto GO = dyn_cast<GlobalObject>(&GV))
     569             :     GO->setComdat(nullptr);
     570             : }
     571             : 
     572             : // Add a regular LTO object to the link.
     573             : // The resulting module needs to be linked into the combined LTO module with
     574             : // linkRegularLTO.
     575             : Expected<LTO::RegularLTOState::AddedModule>
     576         377 : LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
     577             :                    const SymbolResolution *&ResI,
     578             :                    const SymbolResolution *ResE) {
     579         377 :   RegularLTOState::AddedModule Mod;
     580             :   Expected<std::unique_ptr<Module>> MOrErr =
     581             :       BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
     582         754 :                        /*IsImporting*/ false);
     583         377 :   if (!MOrErr)
     584             :     return MOrErr.takeError();
     585             :   Module &M = **MOrErr;
     586         377 :   Mod.M = std::move(*MOrErr);
     587             : 
     588         754 :   if (Error Err = M.materializeMetadata())
     589             :     return std::move(Err);
     590         377 :   UpgradeDebugInfo(M);
     591             : 
     592         754 :   ModuleSymbolTable SymTab;
     593         377 :   SymTab.addModule(&M);
     594             : 
     595         560 :   for (GlobalVariable &GV : M.globals())
     596         183 :     if (GV.hasAppendingLinkage())
     597          26 :       Mod.Keep.push_back(&GV);
     598             : 
     599             :   DenseSet<GlobalObject *> AliasedGlobals;
     600         405 :   for (auto &GA : M.aliases())
     601          56 :     if (GlobalObject *GO = GA.getBaseObject())
     602             :       AliasedGlobals.insert(GO);
     603             : 
     604             :   // In this function we need IR GlobalValues matching the symbols in Syms
     605             :   // (which is not backed by a module), so we need to enumerate them in the same
     606             :   // order. The symbol enumeration order of a ModuleSymbolTable intentionally
     607             :   // matches the order of an irsymtab, but when we read the irsymtab in
     608             :   // InputFile::create we omit some symbols that are irrelevant to LTO. The
     609             :   // Skip() function skips the same symbols from the module as InputFile does
     610             :   // from the symbol table.
     611         754 :   auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
     612        1099 :   auto Skip = [&]() {
     613        1315 :     while (MsymI != MsymE) {
     614         794 :       auto Flags = SymTab.getSymbolFlags(*MsymI);
     615         794 :       if ((Flags & object::BasicSymbolRef::SF_Global) &&
     616             :           !(Flags & object::BasicSymbolRef::SF_FormatSpecific))
     617             :         return;
     618          72 :       ++MsymI;
     619             :     }
     620         377 :   };
     621         377 :   Skip();
     622             : 
     623             :   std::set<const Comdat *> NonPrevailingComdats;
     624        1821 :   for (const InputFile::Symbol &Sym : Syms) {
     625             :     assert(ResI != ResE);
     626         722 :     SymbolResolution Res = *ResI++;
     627             : 
     628             :     assert(MsymI != MsymE);
     629         722 :     ModuleSymbolTable::Symbol Msym = *MsymI++;
     630         722 :     Skip();
     631             : 
     632         722 :     if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
     633         702 :       if (Res.Prevailing) {
     634        1044 :         if (Sym.isUndefined())
     635           5 :           continue;
     636         517 :         Mod.Keep.push_back(GV);
     637             :         // For symbols re-defined with linker -wrap and -defsym options,
     638             :         // set the linkage to weak to inhibit IPO. The linkage will be
     639             :         // restored by the linker.
     640         517 :         if (Res.LinkerRedefined)
     641           5 :           GV->setLinkage(GlobalValue::WeakAnyLinkage);
     642             : 
     643         517 :         GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
     644         517 :         if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
     645             :           GV->setLinkage(GlobalValue::getWeakLinkage(
     646             :               GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
     647         175 :       } else if (isa<GlobalObject>(GV) &&
     648         159 :                  (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
     649             :                   GV->hasAvailableExternallyLinkage()) &&
     650             :                  !AliasedGlobals.count(cast<GlobalObject>(GV))) {
     651             :         // Any of the above three types of linkage indicates that the
     652             :         // chosen prevailing symbol will have the same semantics as this copy of
     653             :         // the symbol, so we may be able to link it with available_externally
     654             :         // linkage. We will decide later whether to do that when we link this
     655             :         // module (in linkRegularLTO), based on whether it is undefined.
     656          30 :         Mod.Keep.push_back(GV);
     657          30 :         GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
     658          30 :         if (GV->hasComdat())
     659          30 :           NonPrevailingComdats.insert(GV->getComdat());
     660          30 :         cast<GlobalObject>(GV)->setComdat(nullptr);
     661             :       }
     662             : 
     663             :       // Set the 'local' flag based on the linker resolution for this symbol.
     664         697 :       if (Res.FinalDefinitionInLinkageUnit)
     665         174 :         GV->setDSOLocal(true);
     666             :     }
     667             :     // Common resolution: collect the maximum size/alignment over all commons.
     668             :     // We also record if we see an instance of a common as prevailing, so that
     669             :     // if none is prevailing we can ignore it later.
     670        1434 :     if (Sym.isCommon()) {
     671             :       // FIXME: We should figure out what to do about commons defined by asm.
     672             :       // For now they aren't reported correctly by ModuleSymbolTable.
     673          58 :       auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
     674          87 :       CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
     675          58 :       CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
     676          29 :       CommonRes.Prevailing |= Res.Prevailing;
     677             :     }
     678             : 
     679             :   }
     680         377 :   if (!M.getComdatSymbolTable().empty())
     681         143 :     for (GlobalValue &GV : M.global_values())
     682         111 :       handleNonPrevailingComdat(GV, NonPrevailingComdats);
     683             :   assert(MsymI == MsymE);
     684             :   return std::move(Mod);
     685             : }
     686             : 
     687         377 : Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
     688             :                           bool LivenessFromIndex) {
     689             :   std::vector<GlobalValue *> Keep;
     690         937 :   for (GlobalValue *GV : Mod.Keep) {
     691         560 :     if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
     692           4 :       continue;
     693             : 
     694        1638 :     if (!GV->hasAvailableExternallyLinkage()) {
     695         526 :       Keep.push_back(GV);
     696         526 :       continue;
     697             :     }
     698             : 
     699             :     // Only link available_externally definitions if we don't already have a
     700             :     // definition.
     701             :     GlobalValue *CombinedGV =
     702          30 :         RegularLTO.CombinedModule->getNamedValue(GV->getName());
     703          46 :     if (CombinedGV && !CombinedGV->isDeclaration())
     704          16 :       continue;
     705             : 
     706          14 :     Keep.push_back(GV);
     707             :   }
     708             : 
     709             :   return RegularLTO.Mover->move(std::move(Mod.M), Keep,
     710             :                                 [](GlobalValue &, IRMover::ValueAdder) {},
     711        1131 :                                 /* IsPerformingImport */ false);
     712             : }
     713             : 
     714             : // Add a ThinLTO module to the link.
     715         296 : Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
     716             :                       const SymbolResolution *&ResI,
     717             :                       const SymbolResolution *ResE) {
     718         296 :   if (Error Err =
     719             :           BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
     720         296 :                          ThinLTO.ModuleMap.size()))
     721             :     return Err;
     722             : 
     723        1424 :   for (const InputFile::Symbol &Sym : Syms) {
     724             :     assert(ResI != ResE);
     725         564 :     SymbolResolution Res = *ResI++;
     726             : 
     727         564 :     if (!Sym.getIRName().empty()) {
     728        1112 :       auto GUID = GlobalValue::getGUID(GlobalValue::getGlobalIdentifier(
     729         556 :           Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
     730         556 :       if (Res.Prevailing) {
     731         732 :         ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
     732             : 
     733             :         // For linker redefined symbols (via --wrap or --defsym) we want to
     734             :         // switch the linkage to `weak` to prevent IPOs from happening.
     735             :         // Find the summary in the module for this very GV and record the new
     736             :         // linkage so that we can switch it when we import the GV.
     737         366 :         if (Res.LinkerRedefined)
     738          14 :           if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
     739           7 :                   GUID, BM.getModuleIdentifier()))
     740             :             S->setLinkage(GlobalValue::WeakAnyLinkage);
     741             :       }
     742             : 
     743             :       // If the linker resolved the symbol to a local definition then mark it
     744             :       // as local in the summary for the module we are adding.
     745         556 :       if (Res.FinalDefinitionInLinkageUnit) {
     746         566 :         if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
     747         283 :                 GUID, BM.getModuleIdentifier())) {
     748             :           S->setDSOLocal(true);
     749             :         }
     750             :       }
     751             :     }
     752             :   }
     753             : 
     754         592 :   if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
     755             :     return make_error<StringError>(
     756             :         "Expected at most one ThinLTO module per bitcode file",
     757           2 :         inconvertibleErrorCode());
     758             : 
     759             :   return Error::success();
     760             : }
     761             : 
     762         319 : unsigned LTO::getMaxTasks() const {
     763         319 :   CalledGetMaxTasks = true;
     764         638 :   return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
     765             : }
     766             : 
     767         445 : Error LTO::run(AddStreamFn AddStream, NativeObjectCache Cache) {
     768             :   // Compute "dead" symbols, we don't want to import/export these!
     769             :   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
     770             :   DenseMap<GlobalValue::GUID, PrevailingType> GUIDPrevailingResolutions;
     771        1918 :   for (auto &Res : GlobalResolutions) {
     772             :     // Normally resolution have IR name of symbol. We can do nothing here
     773             :     // otherwise. See comments in GlobalResolution struct for more details.
     774        1028 :     if (Res.second.IRName.empty())
     775          19 :       continue;
     776             : 
     777        2018 :     GlobalValue::GUID GUID = GlobalValue::getGUID(
     778        1009 :         GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
     779             : 
     780        1009 :     if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
     781        2325 :       GUIDPreservedSymbols.insert(GlobalValue::getGUID(
     782             :           GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
     783             : 
     784        1009 :     GUIDPrevailingResolutions[GUID] =
     785        1009 :         Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No;
     786             :   }
     787             : 
     788          80 :   auto isPrevailing = [&](GlobalValue::GUID G) {
     789          80 :     auto It = GUIDPrevailingResolutions.find(G);
     790          80 :     if (It == GUIDPrevailingResolutions.end())
     791             :       return PrevailingType::Unknown;
     792          63 :     return It->second;
     793         445 :   };
     794         445 :   computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols, isPrevailing);
     795             : 
     796             :   // Setup output file to emit statistics.
     797             :   std::unique_ptr<ToolOutputFile> StatsFile = nullptr;
     798         444 :   if (!Conf.StatsFile.empty()) {
     799           0 :     EnableStatistics(false);
     800             :     std::error_code EC;
     801             :     StatsFile =
     802           0 :         llvm::make_unique<ToolOutputFile>(Conf.StatsFile, EC, sys::fs::F_None);
     803           0 :     if (EC)
     804           0 :       return errorCodeToError(EC);
     805             :     StatsFile->keep();
     806             :   }
     807             : 
     808         883 :   Error Result = runRegularLTO(AddStream);
     809         439 :   if (!Result)
     810        1756 :     Result = runThinLTO(AddStream, Cache);
     811             : 
     812         439 :   if (StatsFile)
     813           0 :     PrintStatisticsJSON(StatsFile->os());
     814             : 
     815             :   return Result;
     816             : }
     817             : 
     818         444 : Error LTO::runRegularLTO(AddStreamFn AddStream) {
     819         457 :   for (auto &M : RegularLTO.ModsWithSummaries)
     820          13 :     if (Error Err = linkRegularLTO(std::move(M),
     821          13 :                                    /*LivenessFromIndex=*/true))
     822             :       return Err;
     823             : 
     824             :   // Make sure commons have the right size/alignment: we kept the largest from
     825             :   // all the prevailing when adding the inputs, and we apply it here.
     826         444 :   const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
     827         462 :   for (auto &I : RegularLTO.Commons) {
     828          18 :     if (!I.second.Prevailing)
     829             :       // Don't do anything if no instance of this common was prevailing.
     830           4 :       continue;
     831             :     GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
     832          24 :     if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
     833             :       // Don't create a new global if the type is already correct, just make
     834             :       // sure the alignment is correct.
     835          10 :       OldGV->setAlignment(I.second.Align);
     836          10 :       continue;
     837             :     }
     838             :     ArrayType *Ty =
     839           4 :         ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
     840             :     auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
     841             :                                   GlobalValue::CommonLinkage,
     842           8 :                                   ConstantAggregateZero::get(Ty), "");
     843           4 :     GV->setAlignment(I.second.Align);
     844           4 :     if (OldGV) {
     845           8 :       OldGV->replaceAllUsesWith(ConstantExpr::getBitCast(GV, OldGV->getType()));
     846           4 :       GV->takeName(OldGV);
     847           4 :       OldGV->eraseFromParent();
     848             :     } else {
     849           0 :       GV->setName(I.first);
     850             :     }
     851             :   }
     852             : 
     853         602 :   if (Conf.PreOptModuleHook &&
     854             :       !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
     855             :     return Error::success();
     856             : 
     857         443 :   if (!Conf.CodeGenOnly) {
     858        1894 :     for (const auto &R : GlobalResolutions) {
     859         138 :       if (!R.second.isPrevailingIRSymbol())
     860         138 :         continue;
     861         914 :       if (R.second.Partition != 0 &&
     862             :           R.second.Partition != GlobalResolution::External)
     863          44 :         continue;
     864             : 
     865             :       GlobalValue *GV =
     866         826 :           RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
     867             :       // Ignore symbols defined in other partitions.
     868        1146 :       if (!GV || GV->hasLocalLinkage())
     869         320 :         continue;
     870         506 :       GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
     871             :                                               : GlobalValue::UnnamedAddr::None);
     872         506 :       if (R.second.Partition == 0)
     873             :         GV->setLinkage(GlobalValue::InternalLinkage);
     874             :     }
     875             : 
     876         629 :     if (Conf.PostInternalizeModuleHook &&
     877             :         !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
     878             :       return Error::success();
     879             :   }
     880             :   return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
     881        1651 :                  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
     882             : }
     883             : 
     884             : /// This class defines the interface to the ThinLTO backend.
     885             : class lto::ThinBackendProc {
     886             : protected:
     887             :   Config &Conf;
     888             :   ModuleSummaryIndex &CombinedIndex;
     889             :   const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries;
     890             : 
     891             : public:
     892             :   ThinBackendProc(Config &Conf, ModuleSummaryIndex &CombinedIndex,
     893             :                   const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
     894         173 :       : Conf(Conf), CombinedIndex(CombinedIndex),
     895         173 :         ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
     896             : 
     897             :   virtual ~ThinBackendProc() {}
     898             :   virtual Error start(
     899             :       unsigned Task, BitcodeModule BM,
     900             :       const FunctionImporter::ImportMapTy &ImportList,
     901             :       const FunctionImporter::ExportSetTy &ExportList,
     902             :       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
     903             :       MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
     904             :   virtual Error wait() = 0;
     905             : };
     906             : 
     907             : namespace {
     908         568 : class InProcessThinBackend : public ThinBackendProc {
     909             :   ThreadPool BackendThreadPool;
     910             :   AddStreamFn AddStream;
     911             :   NativeObjectCache Cache;
     912             :   TypeIdSummariesByGuidTy TypeIdSummariesByGuid;
     913             :   std::set<GlobalValue::GUID> CfiFunctionDefs;
     914             :   std::set<GlobalValue::GUID> CfiFunctionDecls;
     915             : 
     916             :   Optional<Error> Err;
     917             :   std::mutex ErrMu;
     918             : 
     919             : public:
     920         142 :   InProcessThinBackend(
     921             :       Config &Conf, ModuleSummaryIndex &CombinedIndex,
     922             :       unsigned ThinLTOParallelismLevel,
     923             :       const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
     924             :       AddStreamFn AddStream, NativeObjectCache Cache)
     925         142 :       : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
     926             :         BackendThreadPool(ThinLTOParallelismLevel),
     927         284 :         AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
     928             :     // Create a mapping from type identifier GUIDs to type identifier summaries.
     929             :     // This allows backends to use the type identifier GUIDs stored in the
     930             :     // function summaries to determine which type identifier summaries affect
     931             :     // each function without needing to compute GUIDs in each backend.
     932         150 :     for (auto &TId : CombinedIndex.typeIds())
     933          16 :       TypeIdSummariesByGuid[GlobalValue::getGUID(TId.first)].push_back(&TId);
     934         144 :     for (auto &Name : CombinedIndex.cfiFunctionDefs())
     935             :       CfiFunctionDefs.insert(
     936           6 :           GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
     937         143 :     for (auto &Name : CombinedIndex.cfiFunctionDecls())
     938             :       CfiFunctionDecls.insert(
     939           3 :           GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
     940         142 :   }
     941             : 
     942         241 :   Error runThinLTOBackendThread(
     943             :       AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
     944             :       BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
     945             :       const FunctionImporter::ImportMapTy &ImportList,
     946             :       const FunctionImporter::ExportSetTy &ExportList,
     947             :       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
     948             :       const GVSummaryMapTy &DefinedGlobals,
     949             :       MapVector<StringRef, BitcodeModule> &ModuleMap,
     950             :       const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
     951         217 :     auto RunThinBackend = [&](AddStreamFn AddStream) {
     952         651 :       LTOLLVMContext BackendContext(Conf);
     953         434 :       Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
     954         217 :       if (!MOrErr)
     955             :         return MOrErr.takeError();
     956             : 
     957         434 :       return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
     958         868 :                          ImportList, DefinedGlobals, ModuleMap);
     959         241 :     };
     960             : 
     961             :     auto ModuleID = BM.getModuleIdentifier();
     962             : 
     963         326 :     if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) ||
     964             :         all_of(CombinedIndex.getModuleHash(ModuleID),
     965             :                [](uint32_t V) { return V == 0; }))
     966             :       // Cache disabled or no entry for this module in the combined index or
     967             :       // no module hash.
     968         326 :       return RunThinBackend(AddStream);
     969             : 
     970             :     SmallString<40> Key;
     971             :     // The module may be cached, this helps handling it.
     972          78 :     computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList,
     973             :                     ResolvedODR, DefinedGlobals, TypeIdSummariesByGuid,
     974             :                     CfiFunctionDefs, CfiFunctionDecls);
     975         156 :     if (AddStreamFn CacheAddStream = Cache(Task, Key))
     976         108 :       return RunThinBackend(CacheAddStream);
     977             : 
     978             :     return Error::success();
     979             :   }
     980             : 
     981         241 :   Error start(
     982             :       unsigned Task, BitcodeModule BM,
     983             :       const FunctionImporter::ImportMapTy &ImportList,
     984             :       const FunctionImporter::ExportSetTy &ExportList,
     985             :       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
     986             :       MapVector<StringRef, BitcodeModule> &ModuleMap) override {
     987         241 :     StringRef ModulePath = BM.getModuleIdentifier();
     988             :     assert(ModuleToDefinedGVSummaries.count(ModulePath));
     989             :     const GVSummaryMapTy &DefinedGlobals =
     990         482 :         ModuleToDefinedGVSummaries.find(ModulePath)->second;
     991         723 :     BackendThreadPool.async(
     992             :         [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
     993             :             const FunctionImporter::ImportMapTy &ImportList,
     994             :             const FunctionImporter::ExportSetTy &ExportList,
     995             :             const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
     996             :                 &ResolvedODR,
     997             :             const GVSummaryMapTy &DefinedGlobals,
     998             :             MapVector<StringRef, BitcodeModule> &ModuleMap,
     999         241 :             const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
    1000             :           Error E = runThinLTOBackendThread(
    1001         482 :               AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
    1002         723 :               ResolvedODR, DefinedGlobals, ModuleMap, TypeIdSummariesByGuid);
    1003         241 :           if (E) {
    1004           0 :             std::unique_lock<std::mutex> L(ErrMu);
    1005           0 :             if (Err)
    1006           0 :               Err = joinErrors(std::move(*Err), std::move(E));
    1007             :             else
    1008             :               Err = std::move(E);
    1009             :           }
    1010         241 :         },
    1011         482 :         BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
    1012         482 :         std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap),
    1013         482 :         std::ref(TypeIdSummariesByGuid));
    1014         241 :     return Error::success();
    1015             :   }
    1016             : 
    1017         142 :   Error wait() override {
    1018         142 :     BackendThreadPool.wait();
    1019         142 :     if (Err)
    1020             :       return std::move(*Err);
    1021             :     else
    1022             :       return Error::success();
    1023             :   }
    1024             : };
    1025             : } // end anonymous namespace
    1026             : 
    1027         418 : ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
    1028             :   return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
    1029             :              const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
    1030             :              AddStreamFn AddStream, NativeObjectCache Cache) {
    1031             :     return llvm::make_unique<InProcessThinBackend>(
    1032             :         Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries,
    1033             :         AddStream, Cache);
    1034         560 :   };
    1035             : }
    1036             : 
    1037             : // Given the original \p Path to an output file, replace any path
    1038             : // prefix matching \p OldPrefix with \p NewPrefix. Also, create the
    1039             : // resulting directory if it does not yet exist.
    1040          62 : std::string lto::getThinLTOOutputFile(const std::string &Path,
    1041             :                                       const std::string &OldPrefix,
    1042             :                                       const std::string &NewPrefix) {
    1043         122 :   if (OldPrefix.empty() && NewPrefix.empty())
    1044             :     return Path;
    1045             :   SmallString<128> NewPath(Path);
    1046           2 :   llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
    1047           2 :   StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
    1048           2 :   if (!ParentPath.empty()) {
    1049             :     // Make sure the new directory exists, creating it if necessary.
    1050           2 :     if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
    1051           0 :       llvm::errs() << "warning: could not create directory '" << ParentPath
    1052           0 :                    << "': " << EC.message() << '\n';
    1053             :   }
    1054             :   return NewPath.str();
    1055             : }
    1056             : 
    1057             : namespace {
    1058          93 : class WriteIndexesThinBackend : public ThinBackendProc {
    1059             :   std::string OldPrefix, NewPrefix;
    1060             :   bool ShouldEmitImportsFiles;
    1061             :   raw_fd_ostream *LinkedObjectsFile;
    1062             :   lto::IndexWriteCallback OnWrite;
    1063             : 
    1064             : public:
    1065          31 :   WriteIndexesThinBackend(
    1066             :       Config &Conf, ModuleSummaryIndex &CombinedIndex,
    1067             :       const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
    1068             :       std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
    1069             :       raw_fd_ostream *LinkedObjectsFile, lto::IndexWriteCallback OnWrite)
    1070          31 :       : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
    1071             :         OldPrefix(OldPrefix), NewPrefix(NewPrefix),
    1072             :         ShouldEmitImportsFiles(ShouldEmitImportsFiles),
    1073         124 :         LinkedObjectsFile(LinkedObjectsFile), OnWrite(OnWrite) {}
    1074             : 
    1075          51 :   Error start(
    1076             :       unsigned Task, BitcodeModule BM,
    1077             :       const FunctionImporter::ImportMapTy &ImportList,
    1078             :       const FunctionImporter::ExportSetTy &ExportList,
    1079             :       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
    1080             :       MapVector<StringRef, BitcodeModule> &ModuleMap) override {
    1081             :     StringRef ModulePath = BM.getModuleIdentifier();
    1082             :     std::string NewModulePath =
    1083         153 :         getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
    1084             : 
    1085          51 :     if (LinkedObjectsFile)
    1086           6 :       *LinkedObjectsFile << NewModulePath << '\n';
    1087             : 
    1088             :     std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
    1089          51 :     gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
    1090             :                                      ImportList, ModuleToSummariesForIndex);
    1091             : 
    1092             :     std::error_code EC;
    1093         102 :     raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
    1094         102 :                       sys::fs::OpenFlags::F_None);
    1095          51 :     if (EC)
    1096           1 :       return errorCodeToError(EC);
    1097          50 :     WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
    1098             : 
    1099          50 :     if (ShouldEmitImportsFiles) {
    1100          78 :       EC = EmitImportsFiles(ModulePath, NewModulePath + ".imports", ImportList);
    1101          26 :       if (EC)
    1102           1 :         return errorCodeToError(EC);
    1103             :     }
    1104             : 
    1105          49 :     if (OnWrite)
    1106          34 :       OnWrite(ModulePath);
    1107             :     return Error::success();
    1108             :   }
    1109             : 
    1110          58 :   Error wait() override { return Error::success(); }
    1111             : };
    1112             : } // end anonymous namespace
    1113             : 
    1114          34 : ThinBackend lto::createWriteIndexesThinBackend(
    1115             :     std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
    1116             :     raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite) {
    1117         580 :   return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
    1118             :              const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
    1119             :              AddStreamFn AddStream, NativeObjectCache Cache) {
    1120             :     return llvm::make_unique<WriteIndexesThinBackend>(
    1121             :         Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
    1122             :         ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite);
    1123          99 :   };
    1124             : }
    1125             : 
    1126         439 : Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
    1127         439 :   if (ThinLTO.ModuleMap.empty())
    1128             :     return Error::success();
    1129             : 
    1130         234 :   if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
    1131             :     return Error::success();
    1132             : 
    1133             :   // Collect for each module the list of function it defines (GUID ->
    1134             :   // Summary).
    1135             :   StringMap<GVSummaryMapTy>
    1136         346 :       ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
    1137         173 :   ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
    1138             :       ModuleToDefinedGVSummaries);
    1139             :   // Create entries for any modules that didn't have any GV summaries
    1140             :   // (either they didn't have any GVs to start with, or we suppressed
    1141             :   // generation of the summaries because they e.g. had inline assembly
    1142             :   // uses that couldn't be promoted/renamed on export). This is so
    1143             :   // InProcessThinBackend::start can still launch a backend thread, which
    1144             :   // is passed the map of summaries for the module, without any special
    1145             :   // handling for this case.
    1146         465 :   for (auto &Mod : ThinLTO.ModuleMap)
    1147             :     if (!ModuleToDefinedGVSummaries.count(Mod.first))
    1148          15 :       ModuleToDefinedGVSummaries.try_emplace(Mod.first);
    1149             : 
    1150             :   StringMap<FunctionImporter::ImportMapTy> ImportLists(
    1151         346 :       ThinLTO.ModuleMap.size());
    1152             :   StringMap<FunctionImporter::ExportSetTy> ExportLists(
    1153         346 :       ThinLTO.ModuleMap.size());
    1154         173 :   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
    1155             : 
    1156         173 :   if (DumpThinCGSCCs)
    1157           1 :     ThinLTO.CombinedIndex.dumpSCCs(outs());
    1158             : 
    1159         173 :   if (Conf.OptLevel > 0)
    1160         169 :     ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
    1161             :                              ImportLists, ExportLists);
    1162             : 
    1163             :   // Figure out which symbols need to be internalized. This also needs to happen
    1164             :   // at -O0 because summary-based DCE is implemented using internalization, and
    1165             :   // we must apply DCE consistently with the full LTO module in order to avoid
    1166             :   // undefined references during the final link.
    1167             :   std::set<GlobalValue::GUID> ExportedGUIDs;
    1168         770 :   for (auto &Res : GlobalResolutions) {
    1169             :     // If the symbol does not have external references or it is not prevailing,
    1170             :     // then not need to mark it as exported from a ThinLTO partition.
    1171         505 :     if (Res.second.Partition != GlobalResolution::External ||
    1172             :         !Res.second.isPrevailingIRSymbol())
    1173          81 :       continue;
    1174         686 :     auto GUID = GlobalValue::getGUID(
    1175         343 :         GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
    1176             :     // Mark exported unless index-based analysis determined it to be dead.
    1177         343 :     if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
    1178             :       ExportedGUIDs.insert(GUID);
    1179             :   }
    1180             : 
    1181             :   // Any functions referenced by the jump table in the regular LTO object must
    1182             :   // be exported.
    1183         176 :   for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
    1184             :     ExportedGUIDs.insert(
    1185           9 :         GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Def)));
    1186             : 
    1187         429 :   auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
    1188         429 :     const auto &ExportList = ExportLists.find(ModuleIdentifier);
    1189         573 :     return (ExportList != ExportLists.end() &&
    1190         429 :             ExportList->second.count(GUID)) ||
    1191         741 :            ExportedGUIDs.count(GUID);
    1192         173 :   };
    1193         173 :   thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
    1194             : 
    1195             :   auto isPrevailing = [&](GlobalValue::GUID GUID,
    1196          47 :                           const GlobalValueSummary *S) {
    1197          47 :     return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
    1198         220 :   };
    1199             :   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
    1200             :                               GlobalValue::GUID GUID,
    1201          22 :                               GlobalValue::LinkageTypes NewLinkage) {
    1202          44 :     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
    1203         195 :   };
    1204         173 :   thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing,
    1205             :                                      recordNewLinkage);
    1206             : 
    1207             :   std::unique_ptr<ThinBackendProc> BackendProc =
    1208             :       ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
    1209         519 :                       AddStream, Cache);
    1210             : 
    1211             :   // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
    1212             :   // module and parallel code generation partitions.
    1213         173 :   unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
    1214         463 :   for (auto &Mod : ThinLTO.ModuleMap) {
    1215         292 :     if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
    1216             :                                      ExportLists[Mod.first],
    1217         584 :                                      ResolvedODR[Mod.first], ThinLTO.ModuleMap))
    1218             :       return E;
    1219         290 :     ++Task;
    1220             :   }
    1221             : 
    1222         171 :   return BackendProc->wait();
    1223             : }
    1224             : 
    1225             : Expected<std::unique_ptr<ToolOutputFile>>
    1226         741 : lto::setupOptimizationRemarks(LLVMContext &Context,
    1227             :                               StringRef LTORemarksFilename,
    1228             :                               bool LTOPassRemarksWithHotness, int Count) {
    1229         741 :   if (LTOPassRemarksWithHotness)
    1230           9 :     Context.setDiagnosticsHotnessRequested(true);
    1231         741 :   if (LTORemarksFilename.empty())
    1232             :     return nullptr;
    1233             : 
    1234             :   std::string Filename = LTORemarksFilename;
    1235          15 :   if (Count != -1)
    1236          20 :     Filename += ".thin." + llvm::utostr(Count) + ".yaml";
    1237             : 
    1238             :   std::error_code EC;
    1239             :   auto DiagnosticFile =
    1240          15 :       llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
    1241          15 :   if (EC)
    1242           0 :     return errorCodeToError(EC);
    1243          15 :   Context.setDiagnosticsOutputFile(
    1244          30 :       llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
    1245             :   DiagnosticFile->keep();
    1246             :   return std::move(DiagnosticFile);
    1247      299229 : }

Generated by: LCOV version 1.13