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

Generated by: LCOV version 1.13