1 //===-LTO.cpp - LLVM Link Time Optimizer ----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements functions and classes used to support LTO.
12 //===----------------------------------------------------------------------===//
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"
49 using namespace object;
51 #define DEBUG_TYPE "lto"
54 DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden,
55 cl::desc("Dump the SCCs in the ThinLTO index's callgraph"));
57 // The values are (type identifier, summary) pairs.
60 TinyPtrVector<const std::pair<const std::string, TypeIdSummary> *>>
61 TypeIdSummariesByGuidTy;
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 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.
81 // Start with the compiler revision
82 Hasher.update(LLVM_VERSION_STRING);
84 Hasher.update(LLVM_REVISION);
87 // Include the parts of the LTO configuration that affect code generation.
88 auto AddString = [&](StringRef Str) {
90 Hasher.update(ArrayRef<uint8_t>{0});
92 auto AddUnsigned = [&](unsigned I) {
98 Hasher.update(ArrayRef<uint8_t>{Data, 4});
100 auto AddUint64 = [&](uint64_t I) {
110 Hasher.update(ArrayRef<uint8_t>{Data, 8});
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 AddUnsigned(Conf.Options.RelaxELFRelocations);
118 AddUnsigned(Conf.Options.FunctionSections);
119 AddUnsigned(Conf.Options.DataSections);
120 AddUnsigned((unsigned)Conf.Options.DebuggerTuning);
121 for (auto &A : Conf.MAttrs)
124 AddUnsigned(*Conf.RelocModel);
128 AddUnsigned(*Conf.CodeModel);
131 AddUnsigned(Conf.CGOptLevel);
132 AddUnsigned(Conf.CGFileType);
133 AddUnsigned(Conf.OptLevel);
134 AddUnsigned(Conf.UseNewPM);
135 AddString(Conf.OptPipeline);
136 AddString(Conf.AAPipeline);
137 AddString(Conf.OverrideTriple);
138 AddString(Conf.DefaultTriple);
140 // Include the hash for the current module
141 auto ModHash = Index.getModuleHash(ModuleID);
142 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
143 for (auto F : ExportList)
144 // The export list can impact the internalization, be conservative here
145 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
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 for (auto &Entry : ImportList) {
151 auto ModHash = Index.getModuleHash(Entry.first());
152 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
154 AddUint64(Entry.second.size());
155 for (auto &Fn : Entry.second)
159 // Include the hash for the resolved ODR.
160 for (auto &Entry : ResolvedODR) {
161 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
162 sizeof(GlobalValue::GUID)));
163 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
164 sizeof(GlobalValue::LinkageTypes)));
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;
172 // Typeids used in this module.
173 std::set<GlobalValue::GUID> UsedTypeIds;
175 auto AddUsedCfiGlobal = [&](GlobalValue::GUID ValueGUID) {
176 if (CfiFunctionDefs.count(ValueGUID))
177 UsedCfiDefs.insert(ValueGUID);
178 if (CfiFunctionDecls.count(ValueGUID))
179 UsedCfiDecls.insert(ValueGUID);
182 auto AddUsedThings = [&](GlobalValueSummary *GS) {
184 AddUnsigned(GS->isLive());
185 for (const ValueInfo &VI : GS->refs()) {
186 AddUnsigned(VI.isDSOLocal());
187 AddUsedCfiGlobal(VI.getGUID());
189 if (auto *FS = dyn_cast<FunctionSummary>(GS)) {
190 for (auto &TT : FS->type_tests())
191 UsedTypeIds.insert(TT);
192 for (auto &TT : FS->type_test_assume_vcalls())
193 UsedTypeIds.insert(TT.GUID);
194 for (auto &TT : FS->type_checked_load_vcalls())
195 UsedTypeIds.insert(TT.GUID);
196 for (auto &TT : FS->type_test_assume_const_vcalls())
197 UsedTypeIds.insert(TT.VFunc.GUID);
198 for (auto &TT : FS->type_checked_load_const_vcalls())
199 UsedTypeIds.insert(TT.VFunc.GUID);
200 for (auto &ET : FS->calls()) {
201 AddUnsigned(ET.first.isDSOLocal());
202 AddUsedCfiGlobal(ET.first.getGUID());
207 // Include the hash for the linkage type to reflect internalization and weak
208 // resolution, and collect any used type identifier resolutions.
209 for (auto &GS : DefinedGlobals) {
210 GlobalValue::LinkageTypes Linkage = GS.second->linkage();
212 ArrayRef<uint8_t>((const uint8_t *)&Linkage, sizeof(Linkage)));
213 AddUsedCfiGlobal(GS.first);
214 AddUsedThings(GS.second);
217 // Imported functions may introduce new uses of type identifier resolutions,
218 // so we need to collect their used resolutions as well.
219 for (auto &ImpM : ImportList)
220 for (auto &ImpF : ImpM.second)
221 AddUsedThings(Index.findSummaryInModule(ImpF.first, ImpM.first()));
223 auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) {
226 AddUnsigned(S.TTRes.TheKind);
227 AddUnsigned(S.TTRes.SizeM1BitWidth);
229 AddUint64(S.TTRes.AlignLog2);
230 AddUint64(S.TTRes.SizeM1);
231 AddUint64(S.TTRes.BitMask);
232 AddUint64(S.TTRes.InlineBits);
234 AddUint64(S.WPDRes.size());
235 for (auto &WPD : S.WPDRes) {
236 AddUnsigned(WPD.first);
237 AddUnsigned(WPD.second.TheKind);
238 AddString(WPD.second.SingleImplName);
240 AddUint64(WPD.second.ResByArg.size());
241 for (auto &ByArg : WPD.second.ResByArg) {
242 AddUint64(ByArg.first.size());
243 for (uint64_t Arg : ByArg.first)
245 AddUnsigned(ByArg.second.TheKind);
246 AddUint64(ByArg.second.Info);
247 AddUnsigned(ByArg.second.Byte);
248 AddUnsigned(ByArg.second.Bit);
253 // Include the hash for all type identifiers used by this module.
254 for (GlobalValue::GUID TId : UsedTypeIds) {
255 auto SummariesI = TypeIdSummariesByGuid.find(TId);
256 if (SummariesI != TypeIdSummariesByGuid.end())
257 for (auto *Summary : SummariesI->second)
258 AddTypeIdSummary(Summary->first, Summary->second);
261 AddUnsigned(UsedCfiDefs.size());
262 for (auto &V : UsedCfiDefs)
265 AddUnsigned(UsedCfiDecls.size());
266 for (auto &V : UsedCfiDecls)
269 if (!Conf.SampleProfile.empty()) {
270 auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile);
272 Hasher.update(FileOrErr.get()->getBuffer());
275 Key = toHex(Hasher.result());
278 static void thinLTOResolveWeakForLinkerGUID(
279 GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
280 DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias,
281 function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
283 function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
285 for (auto &S : GVSummaryList) {
286 GlobalValue::LinkageTypes OriginalLinkage = S->linkage();
287 if (!GlobalValue::isWeakForLinker(OriginalLinkage))
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 if (isPrevailing(GUID, S.get())) {
298 if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
299 S->setLinkage(GlobalValue::getWeakLinkage(
300 GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
302 // Alias and aliasee can't be turned into available_externally.
303 else if (!isa<AliasSummary>(S.get()) &&
304 !GlobalInvolvedWithAlias.count(S.get()))
305 S->setLinkage(GlobalValue::AvailableExternallyLinkage);
306 if (S->linkage() != OriginalLinkage)
307 recordNewLinkage(S->modulePath(), GUID, S->linkage());
311 // Resolve Weak and LinkOnce values in the \p Index.
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
317 void llvm::thinLTOResolveWeakForLinkerInIndex(
318 ModuleSummaryIndex &Index,
319 function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
321 function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
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
326 DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
327 for (auto &I : Index)
328 for (auto &S : I.second.SummaryList)
329 if (auto AS = dyn_cast<AliasSummary>(S.get()))
330 GlobalInvolvedWithAlias.insert(&AS->getAliasee());
332 for (auto &I : Index)
333 thinLTOResolveWeakForLinkerGUID(I.second.SummaryList, I.first,
334 GlobalInvolvedWithAlias, isPrevailing,
338 static void thinLTOInternalizeAndPromoteGUID(
339 GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
340 function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
341 for (auto &S : GVSummaryList) {
342 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);
350 // Update the linkages in the given \p Index to mark exported values
351 // as external and non-exported values as internal.
352 void llvm::thinLTOInternalizeAndPromoteInIndex(
353 ModuleSummaryIndex &Index,
354 function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
355 for (auto &I : Index)
356 thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported);
359 // Requires a destructor for std::vector<InputModule>.
360 InputFile::~InputFile() = default;
362 Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) {
363 std::unique_ptr<InputFile> File(new InputFile);
365 Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
367 return FOrErr.takeError();
369 File->TargetTriple = FOrErr->TheReader.getTargetTriple();
370 File->SourceFileName = FOrErr->TheReader.getSourceFileName();
371 File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
372 File->ComdatTable = FOrErr->TheReader.getComdatTable();
374 for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
375 size_t Begin = File->Symbols.size();
376 for (const irsymtab::Reader::SymbolRef &Sym :
377 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 if (Sym.isGlobal() && !Sym.isFormatSpecific())
381 File->Symbols.push_back(Sym);
382 File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
385 File->Mods = FOrErr->Mods;
386 File->Strtab = std::move(FOrErr->Strtab);
387 return std::move(File);
390 StringRef InputFile::getName() const {
391 return Mods[0].getModuleIdentifier();
394 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
396 : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
397 Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
398 Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
400 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
401 : Backend(Backend), CombinedIndex(/*IsPeformingAnalysis*/ false) {
404 createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
407 LTO::LTO(Config Conf, ThinBackend Backend,
408 unsigned ParallelCodeGenParallelismLevel)
409 : Conf(std::move(Conf)),
410 RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
411 ThinLTO(std::move(Backend)) {}
413 // Requires a destructor for MapVector<BitcodeModule>.
414 LTO::~LTO() = default;
416 // Add the symbols in the given module to the GlobalResolutions map, and resolve
418 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();
424 for (const InputFile::Symbol &Sym : Syms) {
425 assert(ResI != ResE);
426 SymbolResolution Res = *ResI++;
428 auto &GlobalRes = GlobalResolutions[Sym.getName()];
429 GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
430 if (Res.Prevailing) {
431 assert(!GlobalRes.Prevailing &&
432 "Multiple prevailing defs are not allowed");
433 GlobalRes.Prevailing = true;
434 GlobalRes.IRName = Sym.getIRName();
435 } 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 GlobalRes.IRName = Sym.getIRName();
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 if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
450 (GlobalRes.Partition != GlobalResolution::Unknown &&
451 GlobalRes.Partition != Partition)) {
452 GlobalRes.Partition = GlobalResolution::External;
454 // First recorded reference, save the current partition.
455 GlobalRes.Partition = Partition;
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 GlobalRes.VisibleOutsideSummary |=
460 (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
464 static void writeToResolutionFile(raw_ostream &OS, InputFile *Input,
465 ArrayRef<SymbolResolution> Res) {
466 StringRef Path = Input->getName();
468 auto ResI = Res.begin();
469 for (const InputFile::Symbol &Sym : Input->symbols()) {
470 assert(ResI != Res.end());
471 SymbolResolution Res = *ResI++;
473 OS << "-r=" << Path << ',' << Sym.getName() << ',';
476 if (Res.FinalDefinitionInLinkageUnit)
478 if (Res.VisibleToRegularObj)
480 if (Res.LinkerRedefined)
485 assert(ResI == Res.end());
488 Error LTO::add(std::unique_ptr<InputFile> Input,
489 ArrayRef<SymbolResolution> Res) {
490 assert(!CalledGetMaxTasks);
492 if (Conf.ResolutionFile)
493 writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
495 if (RegularLTO.CombinedModule->getTargetTriple().empty())
496 RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
498 const SymbolResolution *ResI = Res.begin();
499 for (unsigned I = 0; I != Input->Mods.size(); ++I)
500 if (Error Err = addModule(*Input, I, ResI, Res.end()))
503 assert(ResI == Res.end());
504 return Error::success();
507 Error LTO::addModule(InputFile &Input, unsigned ModI,
508 const SymbolResolution *&ResI,
509 const SymbolResolution *ResE) {
510 Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
512 return LTOInfo.takeError();
514 BitcodeModule BM = Input.Mods[ModI];
515 auto ModSyms = Input.module_symbols(ModI);
516 addModuleToGlobalRes(ModSyms, {ResI, ResE},
517 LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
518 LTOInfo->HasSummary);
520 if (LTOInfo->IsThinLTO)
521 return addThinLTO(BM, ModSyms, ResI, ResE);
523 Expected<RegularLTOState::AddedModule> ModOrErr =
524 addRegularLTO(BM, ModSyms, ResI, ResE);
526 return ModOrErr.takeError();
528 if (!LTOInfo->HasSummary)
529 return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
531 // Regular LTO module summaries are added to a dummy module that represents
532 // the combined regular LTO module.
533 if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
535 RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
536 return Error::success();
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.
550 handleNonPrevailingComdat(GlobalValue &GV,
551 std::set<const Comdat *> &NonPrevailingComdats) {
552 Comdat *C = GV.getComdat();
556 if (!NonPrevailingComdats.count(C))
559 // Additionally need to drop externally visible global values from the comdat
560 // to available_externally, so that there aren't multiply defined linker
562 if (!GV.hasLocalLinkage())
563 GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
565 if (auto GO = dyn_cast<GlobalObject>(&GV))
566 GO->setComdat(nullptr);
569 // Add a regular LTO object to the link.
570 // The resulting module needs to be linked into the combined LTO module with
572 Expected<LTO::RegularLTOState::AddedModule>
573 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
574 const SymbolResolution *&ResI,
575 const SymbolResolution *ResE) {
576 RegularLTOState::AddedModule Mod;
577 Expected<std::unique_ptr<Module>> MOrErr =
578 BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
579 /*IsImporting*/ false);
581 return MOrErr.takeError();
582 Module &M = **MOrErr;
583 Mod.M = std::move(*MOrErr);
585 if (Error Err = M.materializeMetadata())
586 return std::move(Err);
589 ModuleSymbolTable SymTab;
590 SymTab.addModule(&M);
592 for (GlobalVariable &GV : M.globals())
593 if (GV.hasAppendingLinkage())
594 Mod.Keep.push_back(&GV);
596 DenseSet<GlobalObject *> AliasedGlobals;
597 for (auto &GA : M.aliases())
598 if (GlobalObject *GO = GA.getBaseObject())
599 AliasedGlobals.insert(GO);
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 auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
610 while (MsymI != MsymE) {
611 auto Flags = SymTab.getSymbolFlags(*MsymI);
612 if ((Flags & object::BasicSymbolRef::SF_Global) &&
613 !(Flags & object::BasicSymbolRef::SF_FormatSpecific))
620 std::set<const Comdat *> NonPrevailingComdats;
621 for (const InputFile::Symbol &Sym : Syms) {
622 assert(ResI != ResE);
623 SymbolResolution Res = *ResI++;
625 assert(MsymI != MsymE);
626 ModuleSymbolTable::Symbol Msym = *MsymI++;
629 if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
630 if (Res.Prevailing) {
631 if (Sym.isUndefined())
633 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 if (Res.LinkerRedefined)
638 GV->setLinkage(GlobalValue::WeakAnyLinkage);
640 GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
641 if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
642 GV->setLinkage(GlobalValue::getWeakLinkage(
643 GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
644 } else if (isa<GlobalObject>(GV) &&
645 (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 Mod.Keep.push_back(GV);
654 GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
656 NonPrevailingComdats.insert(GV->getComdat());
657 cast<GlobalObject>(GV)->setComdat(nullptr);
660 // Set the 'local' flag based on the linker resolution for this symbol.
661 if (Res.FinalDefinitionInLinkageUnit)
662 GV->setDSOLocal(true);
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 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 auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
671 CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
672 CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
673 CommonRes.Prevailing |= Res.Prevailing;
677 if (!M.getComdatSymbolTable().empty())
678 for (GlobalValue &GV : M.global_values())
679 handleNonPrevailingComdat(GV, NonPrevailingComdats);
680 assert(MsymI == MsymE);
681 return std::move(Mod);
684 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
685 bool LivenessFromIndex) {
686 std::vector<GlobalValue *> Keep;
687 for (GlobalValue *GV : Mod.Keep) {
688 if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
691 if (!GV->hasAvailableExternallyLinkage()) {
696 // Only link available_externally definitions if we don't already have a
698 GlobalValue *CombinedGV =
699 RegularLTO.CombinedModule->getNamedValue(GV->getName());
700 if (CombinedGV && !CombinedGV->isDeclaration())
706 return RegularLTO.Mover->move(std::move(Mod.M), Keep,
707 [](GlobalValue &, IRMover::ValueAdder) {},
708 /* IsPerformingImport */ false);
711 // Add a ThinLTO module to the link.
712 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
713 const SymbolResolution *&ResI,
714 const SymbolResolution *ResE) {
716 BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
717 ThinLTO.ModuleMap.size()))
720 for (const InputFile::Symbol &Sym : Syms) {
721 assert(ResI != ResE);
722 SymbolResolution Res = *ResI++;
724 if (!Sym.getIRName().empty()) {
725 auto GUID = GlobalValue::getGUID(GlobalValue::getGlobalIdentifier(
726 Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
727 if (Res.Prevailing) {
728 ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
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 if (Res.LinkerRedefined)
735 if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
736 GUID, BM.getModuleIdentifier()))
737 S->setLinkage(GlobalValue::WeakAnyLinkage);
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 if (Res.FinalDefinitionInLinkageUnit) {
743 if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
744 GUID, BM.getModuleIdentifier())) {
745 S->setDSOLocal(true);
751 if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
752 return make_error<StringError>(
753 "Expected at most one ThinLTO module per bitcode file",
754 inconvertibleErrorCode());
756 return Error::success();
759 unsigned LTO::getMaxTasks() const {
760 CalledGetMaxTasks = true;
761 return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
764 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 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 if (Res.second.IRName.empty())
774 GlobalValue::GUID GUID = GlobalValue::getGUID(
775 GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
777 if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
778 GUIDPreservedSymbols.insert(GlobalValue::getGUID(
779 GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
781 GUIDPrevailingResolutions[GUID] =
782 Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No;
785 auto isPrevailing = [&](GlobalValue::GUID G) {
786 auto It = GUIDPrevailingResolutions.find(G);
787 if (It == GUIDPrevailingResolutions.end())
788 return PrevailingType::Unknown;
791 computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols, isPrevailing);
793 if (auto E = runRegularLTO(AddStream))
795 return runThinLTO(AddStream, Cache);
798 Error LTO::runRegularLTO(AddStreamFn AddStream) {
799 for (auto &M : RegularLTO.ModsWithSummaries)
800 if (Error Err = linkRegularLTO(std::move(M),
801 /*LivenessFromIndex=*/true))
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 const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
807 for (auto &I : RegularLTO.Commons) {
808 if (!I.second.Prevailing)
809 // Don't do anything if no instance of this common was prevailing.
811 GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
812 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 OldGV->setAlignment(I.second.Align);
819 ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
820 auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
821 GlobalValue::CommonLinkage,
822 ConstantAggregateZero::get(Ty), "");
823 GV->setAlignment(I.second.Align);
825 OldGV->replaceAllUsesWith(ConstantExpr::getBitCast(GV, OldGV->getType()));
827 OldGV->eraseFromParent();
829 GV->setName(I.first);
833 if (Conf.PreOptModuleHook &&
834 !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
835 return Error::success();
837 if (!Conf.CodeGenOnly) {
838 for (const auto &R : GlobalResolutions) {
839 if (!R.second.isPrevailingIRSymbol())
841 if (R.second.Partition != 0 &&
842 R.second.Partition != GlobalResolution::External)
846 RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
847 // Ignore symbols defined in other partitions.
848 if (!GV || GV->hasLocalLinkage())
850 GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
851 : GlobalValue::UnnamedAddr::None);
852 if (R.second.Partition == 0)
853 GV->setLinkage(GlobalValue::InternalLinkage);
856 if (Conf.PostInternalizeModuleHook &&
857 !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
858 return Error::success();
860 return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
861 std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
864 /// This class defines the interface to the ThinLTO backend.
865 class lto::ThinBackendProc {
868 ModuleSummaryIndex &CombinedIndex;
869 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries;
872 ThinBackendProc(Config &Conf, ModuleSummaryIndex &CombinedIndex,
873 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
874 : Conf(Conf), CombinedIndex(CombinedIndex),
875 ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
877 virtual ~ThinBackendProc() {}
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;
888 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;
900 InProcessThinBackend(
901 Config &Conf, ModuleSummaryIndex &CombinedIndex,
902 unsigned ThinLTOParallelismLevel,
903 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
904 AddStreamFn AddStream, NativeObjectCache Cache)
905 : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
906 BackendThreadPool(ThinLTOParallelismLevel),
907 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 for (auto &TId : CombinedIndex.typeIds())
913 TypeIdSummariesByGuid[GlobalValue::getGUID(TId.first)].push_back(&TId);
914 for (auto &Name : CombinedIndex.cfiFunctionDefs())
915 CfiFunctionDefs.insert(
916 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
917 for (auto &Name : CombinedIndex.cfiFunctionDecls())
918 CfiFunctionDecls.insert(
919 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
922 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 auto RunThinBackend = [&](AddStreamFn AddStream) {
932 LTOLLVMContext BackendContext(Conf);
933 Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
935 return MOrErr.takeError();
937 return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
938 ImportList, DefinedGlobals, ModuleMap);
941 auto ModuleID = BM.getModuleIdentifier();
943 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
948 return RunThinBackend(AddStream);
951 // The module may be cached, this helps handling it.
952 computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList,
953 ResolvedODR, DefinedGlobals, TypeIdSummariesByGuid,
954 CfiFunctionDefs, CfiFunctionDecls);
955 if (AddStreamFn CacheAddStream = Cache(Task, Key))
956 return RunThinBackend(CacheAddStream);
958 return Error::success();
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 StringRef ModulePath = BM.getModuleIdentifier();
968 assert(ModuleToDefinedGVSummaries.count(ModulePath));
969 const GVSummaryMapTy &DefinedGlobals =
970 ModuleToDefinedGVSummaries.find(ModulePath)->second;
971 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>
977 const GVSummaryMapTy &DefinedGlobals,
978 MapVector<StringRef, BitcodeModule> &ModuleMap,
979 const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
980 Error E = runThinLTOBackendThread(
981 AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
982 ResolvedODR, DefinedGlobals, ModuleMap, TypeIdSummariesByGuid);
984 std::unique_lock<std::mutex> L(ErrMu);
986 Err = joinErrors(std::move(*Err), std::move(E));
991 BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
992 std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap),
993 std::ref(TypeIdSummariesByGuid));
994 return Error::success();
997 Error wait() override {
998 BackendThreadPool.wait();
1000 return std::move(*Err);
1002 return Error::success();
1005 } // end anonymous namespace
1007 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,
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 std::string lto::getThinLTOOutputFile(const std::string &Path,
1021 const std::string &OldPrefix,
1022 const std::string &NewPrefix) {
1023 if (OldPrefix.empty() && NewPrefix.empty())
1025 SmallString<128> NewPath(Path);
1026 llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
1027 StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
1028 if (!ParentPath.empty()) {
1029 // Make sure the new directory exists, creating it if necessary.
1030 if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
1031 llvm::errs() << "warning: could not create directory '" << ParentPath
1032 << "': " << EC.message() << '\n';
1034 return NewPath.str();
1038 class WriteIndexesThinBackend : public ThinBackendProc {
1039 std::string OldPrefix, NewPrefix;
1040 bool ShouldEmitImportsFiles;
1041 raw_fd_ostream *LinkedObjectsFile;
1042 lto::IndexWriteCallback OnWrite;
1045 WriteIndexesThinBackend(
1046 Config &Conf, ModuleSummaryIndex &CombinedIndex,
1047 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1048 std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1049 raw_fd_ostream *LinkedObjectsFile, lto::IndexWriteCallback OnWrite)
1050 : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
1051 OldPrefix(OldPrefix), NewPrefix(NewPrefix),
1052 ShouldEmitImportsFiles(ShouldEmitImportsFiles),
1053 LinkedObjectsFile(LinkedObjectsFile), OnWrite(OnWrite) {}
1056 unsigned Task, BitcodeModule BM,
1057 const FunctionImporter::ImportMapTy &ImportList,
1058 const FunctionImporter::ExportSetTy &ExportList,
1059 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1060 MapVector<StringRef, BitcodeModule> &ModuleMap) override {
1061 StringRef ModulePath = BM.getModuleIdentifier();
1062 std::string NewModulePath =
1063 getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
1065 if (LinkedObjectsFile)
1066 *LinkedObjectsFile << NewModulePath << '\n';
1068 std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
1069 gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
1070 ImportList, ModuleToSummariesForIndex);
1073 raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
1074 sys::fs::OpenFlags::F_None);
1076 return errorCodeToError(EC);
1077 WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
1079 if (ShouldEmitImportsFiles) {
1080 EC = EmitImportsFiles(ModulePath, NewModulePath + ".imports", ImportList);
1082 return errorCodeToError(EC);
1086 OnWrite(ModulePath);
1087 return Error::success();
1090 Error wait() override { return Error::success(); }
1092 } // end anonymous namespace
1094 ThinBackend lto::createWriteIndexesThinBackend(
1095 std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
1096 raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite) {
1097 return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1098 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1099 AddStreamFn AddStream, NativeObjectCache Cache) {
1100 return llvm::make_unique<WriteIndexesThinBackend>(
1101 Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1102 ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite);
1106 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
1107 if (ThinLTO.ModuleMap.empty())
1108 return Error::success();
1110 if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
1111 return Error::success();
1113 // Collect for each module the list of function it defines (GUID ->
1115 StringMap<GVSummaryMapTy>
1116 ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1117 ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1118 ModuleToDefinedGVSummaries);
1119 // Create entries for any modules that didn't have any GV summaries
1120 // (either they didn't have any GVs to start with, or we suppressed
1121 // generation of the summaries because they e.g. had inline assembly
1122 // uses that couldn't be promoted/renamed on export). This is so
1123 // InProcessThinBackend::start can still launch a backend thread, which
1124 // is passed the map of summaries for the module, without any special
1125 // handling for this case.
1126 for (auto &Mod : ThinLTO.ModuleMap)
1127 if (!ModuleToDefinedGVSummaries.count(Mod.first))
1128 ModuleToDefinedGVSummaries.try_emplace(Mod.first);
1130 StringMap<FunctionImporter::ImportMapTy> ImportLists(
1131 ThinLTO.ModuleMap.size());
1132 StringMap<FunctionImporter::ExportSetTy> ExportLists(
1133 ThinLTO.ModuleMap.size());
1134 StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
1137 ThinLTO.CombinedIndex.dumpSCCs(outs());
1139 if (Conf.OptLevel > 0)
1140 ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1141 ImportLists, ExportLists);
1143 // Figure out which symbols need to be internalized. This also needs to happen
1144 // at -O0 because summary-based DCE is implemented using internalization, and
1145 // we must apply DCE consistently with the full LTO module in order to avoid
1146 // undefined references during the final link.
1147 std::set<GlobalValue::GUID> ExportedGUIDs;
1148 for (auto &Res : GlobalResolutions) {
1149 // If the symbol does not have external references or it is not prevailing,
1150 // then not need to mark it as exported from a ThinLTO partition.
1151 if (Res.second.Partition != GlobalResolution::External ||
1152 !Res.second.isPrevailingIRSymbol())
1154 auto GUID = GlobalValue::getGUID(
1155 GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
1156 // Mark exported unless index-based analysis determined it to be dead.
1157 if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1158 ExportedGUIDs.insert(GUID);
1161 // Any functions referenced by the jump table in the regular LTO object must
1163 for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
1164 ExportedGUIDs.insert(
1165 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Def)));
1167 auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
1168 const auto &ExportList = ExportLists.find(ModuleIdentifier);
1169 return (ExportList != ExportLists.end() &&
1170 ExportList->second.count(GUID)) ||
1171 ExportedGUIDs.count(GUID);
1173 thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
1175 auto isPrevailing = [&](GlobalValue::GUID GUID,
1176 const GlobalValueSummary *S) {
1177 return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
1179 auto recordNewLinkage = [&](StringRef ModuleIdentifier,
1180 GlobalValue::GUID GUID,
1181 GlobalValue::LinkageTypes NewLinkage) {
1182 ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1184 thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing,
1187 std::unique_ptr<ThinBackendProc> BackendProc =
1188 ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1191 // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
1192 // module and parallel code generation partitions.
1193 unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
1194 for (auto &Mod : ThinLTO.ModuleMap) {
1195 if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
1196 ExportLists[Mod.first],
1197 ResolvedODR[Mod.first], ThinLTO.ModuleMap))
1202 return BackendProc->wait();
1205 Expected<std::unique_ptr<ToolOutputFile>> lto::setupOptimizationRemarks(
1206 LLVMContext &Context, StringRef LTORemarksFilename,
1207 bool LTOPassRemarksWithHotness, unsigned LTOPassRemarksHotnessThreshold,
1209 if (LTORemarksFilename.empty())
1212 std::string Filename = LTORemarksFilename;
1214 Filename += ".thin." + llvm::utostr(Count) + ".yaml";
1217 auto DiagnosticFile =
1218 llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
1220 return errorCodeToError(EC);
1221 Context.setDiagnosticsOutputFile(
1222 llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
1223 if (LTOPassRemarksWithHotness)
1224 Context.setDiagnosticsHotnessRequested(true);
1225 if (LTOPassRemarksHotnessThreshold)
1226 Context.setDiagnosticsHotnessThreshold(LTOPassRemarksHotnessThreshold);
1227 DiagnosticFile->keep();
1228 return std::move(DiagnosticFile);