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

Generated by: LCOV version 1.13