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"
53 // The values are (type identifier, summary) pairs.
56 TinyPtrVector<const std::pair<const std::string, TypeIdSummary> *>>
57 TypeIdSummariesByGuidTy;
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 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 // Compute the unique hash for this entry.
70 // This is based on the current compiler version, the module itself, the
71 // export list, the hash for every single module in the import list, the
72 // list of ResolvedODR for the module, and the list of preserved symbols.
75 // Start with the compiler revision
76 Hasher.update(LLVM_VERSION_STRING);
78 Hasher.update(LLVM_REVISION);
81 // Include the parts of the LTO configuration that affect code generation.
82 auto AddString = [&](StringRef Str) {
84 Hasher.update(ArrayRef<uint8_t>{0});
86 auto AddUnsigned = [&](unsigned I) {
92 Hasher.update(ArrayRef<uint8_t>{Data, 4});
94 auto AddUint64 = [&](uint64_t I) {
104 Hasher.update(ArrayRef<uint8_t>{Data, 8});
107 // FIXME: Hash more of Options. For now all clients initialize Options from
108 // command-line flags (which is unsupported in production), but may set
109 // RelaxELFRelocations. The clang driver can also pass FunctionSections,
110 // DataSections and DebuggerTuning via command line flags.
111 AddUnsigned(Conf.Options.RelaxELFRelocations);
112 AddUnsigned(Conf.Options.FunctionSections);
113 AddUnsigned(Conf.Options.DataSections);
114 AddUnsigned((unsigned)Conf.Options.DebuggerTuning);
115 for (auto &A : Conf.MAttrs)
118 AddUnsigned(*Conf.RelocModel);
121 AddUnsigned(Conf.CodeModel);
122 AddUnsigned(Conf.CGOptLevel);
123 AddUnsigned(Conf.CGFileType);
124 AddUnsigned(Conf.OptLevel);
125 AddUnsigned(Conf.UseNewPM);
126 AddString(Conf.OptPipeline);
127 AddString(Conf.AAPipeline);
128 AddString(Conf.OverrideTriple);
129 AddString(Conf.DefaultTriple);
131 // Include the hash for the current module
132 auto ModHash = Index.getModuleHash(ModuleID);
133 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
134 for (auto F : ExportList)
135 // The export list can impact the internalization, be conservative here
136 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F)));
138 // Include the hash for every module we import functions from. The set of
139 // imported symbols for each module may affect code generation and is
140 // sensitive to link order, so include that as well.
141 for (auto &Entry : ImportList) {
142 auto ModHash = Index.getModuleHash(Entry.first());
143 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash)));
145 AddUint64(Entry.second.size());
146 for (auto &Fn : Entry.second)
150 // Include the hash for the resolved ODR.
151 for (auto &Entry : ResolvedODR) {
152 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first,
153 sizeof(GlobalValue::GUID)));
154 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second,
155 sizeof(GlobalValue::LinkageTypes)));
158 std::set<GlobalValue::GUID> UsedTypeIds;
160 auto AddUsedTypeIds = [&](GlobalValueSummary *GS) {
161 auto *FS = dyn_cast_or_null<FunctionSummary>(GS);
164 for (auto &TT : FS->type_tests())
165 UsedTypeIds.insert(TT);
166 for (auto &TT : FS->type_test_assume_vcalls())
167 UsedTypeIds.insert(TT.GUID);
168 for (auto &TT : FS->type_checked_load_vcalls())
169 UsedTypeIds.insert(TT.GUID);
170 for (auto &TT : FS->type_test_assume_const_vcalls())
171 UsedTypeIds.insert(TT.VFunc.GUID);
172 for (auto &TT : FS->type_checked_load_const_vcalls())
173 UsedTypeIds.insert(TT.VFunc.GUID);
176 // Include the hash for the linkage type to reflect internalization and weak
177 // resolution, and collect any used type identifier resolutions.
178 for (auto &GS : DefinedGlobals) {
179 GlobalValue::LinkageTypes Linkage = GS.second->linkage();
181 ArrayRef<uint8_t>((const uint8_t *)&Linkage, sizeof(Linkage)));
182 AddUsedTypeIds(GS.second);
185 // Imported functions may introduce new uses of type identifier resolutions,
186 // so we need to collect their used resolutions as well.
187 for (auto &ImpM : ImportList)
188 for (auto &ImpF : ImpM.second)
189 AddUsedTypeIds(Index.findSummaryInModule(ImpF.first, ImpM.first()));
191 auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) {
194 AddUnsigned(S.TTRes.TheKind);
195 AddUnsigned(S.TTRes.SizeM1BitWidth);
197 AddUint64(S.WPDRes.size());
198 for (auto &WPD : S.WPDRes) {
199 AddUnsigned(WPD.first);
200 AddUnsigned(WPD.second.TheKind);
201 AddString(WPD.second.SingleImplName);
203 AddUint64(WPD.second.ResByArg.size());
204 for (auto &ByArg : WPD.second.ResByArg) {
205 AddUint64(ByArg.first.size());
206 for (uint64_t Arg : ByArg.first)
208 AddUnsigned(ByArg.second.TheKind);
209 AddUint64(ByArg.second.Info);
214 // Include the hash for all type identifiers used by this module.
215 for (GlobalValue::GUID TId : UsedTypeIds) {
216 auto SummariesI = TypeIdSummariesByGuid.find(TId);
217 if (SummariesI != TypeIdSummariesByGuid.end())
218 for (auto *Summary : SummariesI->second)
219 AddTypeIdSummary(Summary->first, Summary->second);
222 if (!Conf.SampleProfile.empty()) {
223 auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile);
225 Hasher.update(FileOrErr.get()->getBuffer());
228 Key = toHex(Hasher.result());
231 static void thinLTOResolveWeakForLinkerGUID(
232 GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
233 DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias,
234 function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
236 function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
238 for (auto &S : GVSummaryList) {
239 GlobalValue::LinkageTypes OriginalLinkage = S->linkage();
240 if (!GlobalValue::isWeakForLinker(OriginalLinkage))
242 // We need to emit only one of these. The prevailing module will keep it,
243 // but turned into a weak, while the others will drop it when possible.
244 // This is both a compile-time optimization and a correctness
245 // transformation. This is necessary for correctness when we have exported
246 // a reference - we need to convert the linkonce to weak to
247 // ensure a copy is kept to satisfy the exported reference.
248 // FIXME: We may want to split the compile time and correctness
249 // aspects into separate routines.
250 if (isPrevailing(GUID, S.get())) {
251 if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
252 S->setLinkage(GlobalValue::getWeakLinkage(
253 GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
255 // Alias and aliasee can't be turned into available_externally.
256 else if (!isa<AliasSummary>(S.get()) &&
257 !GlobalInvolvedWithAlias.count(S.get()))
258 S->setLinkage(GlobalValue::AvailableExternallyLinkage);
259 if (S->linkage() != OriginalLinkage)
260 recordNewLinkage(S->modulePath(), GUID, S->linkage());
264 // Resolve Weak and LinkOnce values in the \p Index.
266 // We'd like to drop these functions if they are no longer referenced in the
267 // current module. However there is a chance that another module is still
268 // referencing them because of the import. We make sure we always emit at least
270 void llvm::thinLTOResolveWeakForLinkerInIndex(
271 ModuleSummaryIndex &Index,
272 function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
274 function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
276 // We won't optimize the globals that are referenced by an alias for now
277 // Ideally we should turn the alias into a global and duplicate the definition
279 DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
280 for (auto &I : Index)
281 for (auto &S : I.second.SummaryList)
282 if (auto AS = dyn_cast<AliasSummary>(S.get()))
283 GlobalInvolvedWithAlias.insert(&AS->getAliasee());
285 for (auto &I : Index)
286 thinLTOResolveWeakForLinkerGUID(I.second.SummaryList, I.first,
287 GlobalInvolvedWithAlias, isPrevailing,
291 static void thinLTOInternalizeAndPromoteGUID(
292 GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID,
293 function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
294 for (auto &S : GVSummaryList) {
295 if (isExported(S->modulePath(), GUID)) {
296 if (GlobalValue::isLocalLinkage(S->linkage()))
297 S->setLinkage(GlobalValue::ExternalLinkage);
298 } else if (!GlobalValue::isLocalLinkage(S->linkage()))
299 S->setLinkage(GlobalValue::InternalLinkage);
303 // Update the linkages in the given \p Index to mark exported values
304 // as external and non-exported values as internal.
305 void llvm::thinLTOInternalizeAndPromoteInIndex(
306 ModuleSummaryIndex &Index,
307 function_ref<bool(StringRef, GlobalValue::GUID)> isExported) {
308 for (auto &I : Index)
309 thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported);
312 // Requires a destructor for std::vector<InputModule>.
313 InputFile::~InputFile() = default;
315 Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) {
316 std::unique_ptr<InputFile> File(new InputFile);
318 Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
320 return FOrErr.takeError();
322 File->TargetTriple = FOrErr->TheReader.getTargetTriple();
323 File->SourceFileName = FOrErr->TheReader.getSourceFileName();
324 File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
325 File->ComdatTable = FOrErr->TheReader.getComdatTable();
327 for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
328 size_t Begin = File->Symbols.size();
329 for (const irsymtab::Reader::SymbolRef &Sym :
330 FOrErr->TheReader.module_symbols(I))
331 // Skip symbols that are irrelevant to LTO. Note that this condition needs
332 // to match the one in Skip() in LTO::addRegularLTO().
333 if (Sym.isGlobal() && !Sym.isFormatSpecific())
334 File->Symbols.push_back(Sym);
335 File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
338 File->Mods = FOrErr->Mods;
339 File->Strtab = std::move(FOrErr->Strtab);
340 return std::move(File);
343 StringRef InputFile::getName() const {
344 return Mods[0].getModuleIdentifier();
347 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
349 : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
352 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend) : Backend(Backend) {
355 createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
358 LTO::LTO(Config Conf, ThinBackend Backend,
359 unsigned ParallelCodeGenParallelismLevel)
360 : Conf(std::move(Conf)),
361 RegularLTO(ParallelCodeGenParallelismLevel, this->Conf),
362 ThinLTO(std::move(Backend)) {}
364 // Requires a destructor for MapVector<BitcodeModule>.
365 LTO::~LTO() = default;
367 // Add the symbols in the given module to the GlobalResolutions map, and resolve
369 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms,
370 ArrayRef<SymbolResolution> Res,
371 unsigned Partition, bool InSummary) {
372 auto *ResI = Res.begin();
373 auto *ResE = Res.end();
375 for (const InputFile::Symbol &Sym : Syms) {
376 assert(ResI != ResE);
377 SymbolResolution Res = *ResI++;
379 auto &GlobalRes = GlobalResolutions[Sym.getName()];
380 GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
382 GlobalRes.IRName = Sym.getIRName();
384 // Set the partition to external if we know it is re-defined by the linker
385 // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a
386 // regular object, is referenced from llvm.compiler_used, or was already
387 // recorded as being referenced from a different partition.
388 if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() ||
389 (GlobalRes.Partition != GlobalResolution::Unknown &&
390 GlobalRes.Partition != Partition)) {
391 GlobalRes.Partition = GlobalResolution::External;
393 // First recorded reference, save the current partition.
394 GlobalRes.Partition = Partition;
396 // Flag as visible outside of summary if visible from a regular object or
397 // from a module that does not have a summary.
398 GlobalRes.VisibleOutsideSummary |=
399 (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary);
403 static void writeToResolutionFile(raw_ostream &OS, InputFile *Input,
404 ArrayRef<SymbolResolution> Res) {
405 StringRef Path = Input->getName();
407 auto ResI = Res.begin();
408 for (const InputFile::Symbol &Sym : Input->symbols()) {
409 assert(ResI != Res.end());
410 SymbolResolution Res = *ResI++;
412 OS << "-r=" << Path << ',' << Sym.getName() << ',';
415 if (Res.FinalDefinitionInLinkageUnit)
417 if (Res.VisibleToRegularObj)
419 if (Res.LinkerRedefined)
424 assert(ResI == Res.end());
427 Error LTO::add(std::unique_ptr<InputFile> Input,
428 ArrayRef<SymbolResolution> Res) {
429 assert(!CalledGetMaxTasks);
431 if (Conf.ResolutionFile)
432 writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
434 const SymbolResolution *ResI = Res.begin();
435 for (unsigned I = 0; I != Input->Mods.size(); ++I)
436 if (Error Err = addModule(*Input, I, ResI, Res.end()))
439 assert(ResI == Res.end());
440 return Error::success();
443 Error LTO::addModule(InputFile &Input, unsigned ModI,
444 const SymbolResolution *&ResI,
445 const SymbolResolution *ResE) {
446 Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo();
448 return LTOInfo.takeError();
450 BitcodeModule BM = Input.Mods[ModI];
451 auto ModSyms = Input.module_symbols(ModI);
452 addModuleToGlobalRes(ModSyms, {ResI, ResE},
453 LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
454 LTOInfo->HasSummary);
456 if (LTOInfo->IsThinLTO)
457 return addThinLTO(BM, ModSyms, ResI, ResE);
459 Expected<RegularLTOState::AddedModule> ModOrErr =
460 addRegularLTO(BM, ModSyms, ResI, ResE);
462 return ModOrErr.takeError();
464 if (!LTOInfo->HasSummary)
465 return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
467 // Regular LTO module summaries are added to a dummy module that represents
468 // the combined regular LTO module.
469 if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull))
471 RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
472 return Error::success();
475 // Checks whether the given global value is in a non-prevailing comdat
476 // (comdat containing values the linker indicated were not prevailing,
477 // which we then dropped to available_externally), and if so, removes
478 // it from the comdat. This is called for all global values to ensure the
479 // comdat is empty rather than leaving an incomplete comdat. It is needed for
480 // regular LTO modules, in case we are in a mixed-LTO mode (both regular
481 // and thin LTO modules) compilation. Since the regular LTO module will be
482 // linked first in the final native link, we want to make sure the linker
483 // doesn't select any of these incomplete comdats that would be left
484 // in the regular LTO module without this cleanup.
486 handleNonPrevailingComdat(GlobalValue &GV,
487 std::set<const Comdat *> &NonPrevailingComdats) {
488 Comdat *C = GV.getComdat();
492 if (!NonPrevailingComdats.count(C))
495 // Additionally need to drop externally visible global values from the comdat
496 // to available_externally, so that there aren't multiply defined linker
498 if (!GV.hasLocalLinkage())
499 GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
501 if (auto GO = dyn_cast<GlobalObject>(&GV))
502 GO->setComdat(nullptr);
505 // Add a regular LTO object to the link.
506 // The resulting module needs to be linked into the combined LTO module with
508 Expected<LTO::RegularLTOState::AddedModule>
509 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
510 const SymbolResolution *&ResI,
511 const SymbolResolution *ResE) {
512 RegularLTOState::AddedModule Mod;
513 Expected<std::unique_ptr<Module>> MOrErr =
514 BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true,
515 /*IsImporting*/ false);
517 return MOrErr.takeError();
518 Module &M = **MOrErr;
519 Mod.M = std::move(*MOrErr);
521 if (Error Err = M.materializeMetadata())
522 return std::move(Err);
525 ModuleSymbolTable SymTab;
526 SymTab.addModule(&M);
528 for (GlobalVariable &GV : M.globals())
529 if (GV.hasAppendingLinkage())
530 Mod.Keep.push_back(&GV);
532 DenseSet<GlobalObject *> AliasedGlobals;
533 for (auto &GA : M.aliases())
534 if (GlobalObject *GO = GA.getBaseObject())
535 AliasedGlobals.insert(GO);
537 // In this function we need IR GlobalValues matching the symbols in Syms
538 // (which is not backed by a module), so we need to enumerate them in the same
539 // order. The symbol enumeration order of a ModuleSymbolTable intentionally
540 // matches the order of an irsymtab, but when we read the irsymtab in
541 // InputFile::create we omit some symbols that are irrelevant to LTO. The
542 // Skip() function skips the same symbols from the module as InputFile does
543 // from the symbol table.
544 auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end();
546 while (MsymI != MsymE) {
547 auto Flags = SymTab.getSymbolFlags(*MsymI);
548 if ((Flags & object::BasicSymbolRef::SF_Global) &&
549 !(Flags & object::BasicSymbolRef::SF_FormatSpecific))
556 std::set<const Comdat *> NonPrevailingComdats;
557 for (const InputFile::Symbol &Sym : Syms) {
558 assert(ResI != ResE);
559 SymbolResolution Res = *ResI++;
561 assert(MsymI != MsymE);
562 ModuleSymbolTable::Symbol Msym = *MsymI++;
565 if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
566 if (Res.Prevailing) {
567 if (Sym.isUndefined())
569 Mod.Keep.push_back(GV);
570 // For symbols re-defined with linker -wrap and -defsym options,
571 // set the linkage to weak to inhibit IPO. The linkage will be
572 // restored by the linker.
573 if (Res.LinkerRedefined)
574 GV->setLinkage(GlobalValue::WeakAnyLinkage);
576 GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();
577 if (GlobalValue::isLinkOnceLinkage(OriginalLinkage))
578 GV->setLinkage(GlobalValue::getWeakLinkage(
579 GlobalValue::isLinkOnceODRLinkage(OriginalLinkage)));
580 } else if (isa<GlobalObject>(GV) &&
581 (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
582 GV->hasAvailableExternallyLinkage()) &&
583 !AliasedGlobals.count(cast<GlobalObject>(GV))) {
584 // Any of the above three types of linkage indicates that the
585 // chosen prevailing symbol will have the same semantics as this copy of
586 // the symbol, so we may be able to link it with available_externally
587 // linkage. We will decide later whether to do that when we link this
588 // module (in linkRegularLTO), based on whether it is undefined.
589 Mod.Keep.push_back(GV);
590 GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
592 NonPrevailingComdats.insert(GV->getComdat());
593 cast<GlobalObject>(GV)->setComdat(nullptr);
596 // Common resolution: collect the maximum size/alignment over all commons.
597 // We also record if we see an instance of a common as prevailing, so that
598 // if none is prevailing we can ignore it later.
599 if (Sym.isCommon()) {
600 // FIXME: We should figure out what to do about commons defined by asm.
601 // For now they aren't reported correctly by ModuleSymbolTable.
602 auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
603 CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
604 CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
605 CommonRes.Prevailing |= Res.Prevailing;
608 // FIXME: use proposed local attribute for FinalDefinitionInLinkageUnit.
610 if (!M.getComdatSymbolTable().empty())
611 for (GlobalValue &GV : M.global_values())
612 handleNonPrevailingComdat(GV, NonPrevailingComdats);
613 assert(MsymI == MsymE);
614 return std::move(Mod);
617 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
618 bool LivenessFromIndex) {
619 if (!RegularLTO.CombinedModule) {
620 RegularLTO.CombinedModule =
621 llvm::make_unique<Module>("ld-temp.o", RegularLTO.Ctx);
622 RegularLTO.Mover = llvm::make_unique<IRMover>(*RegularLTO.CombinedModule);
625 std::vector<GlobalValue *> Keep;
626 for (GlobalValue *GV : Mod.Keep) {
627 if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
630 if (!GV->hasAvailableExternallyLinkage()) {
635 // Only link available_externally definitions if we don't already have a
637 GlobalValue *CombinedGV =
638 RegularLTO.CombinedModule->getNamedValue(GV->getName());
639 if (CombinedGV && !CombinedGV->isDeclaration())
645 return RegularLTO.Mover->move(std::move(Mod.M), Keep,
646 [](GlobalValue &, IRMover::ValueAdder) {},
647 /* IsPerformingImport */ false);
650 // Add a ThinLTO module to the link.
651 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
652 const SymbolResolution *&ResI,
653 const SymbolResolution *ResE) {
655 BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(),
656 ThinLTO.ModuleMap.size()))
659 for (const InputFile::Symbol &Sym : Syms) {
660 assert(ResI != ResE);
661 SymbolResolution Res = *ResI++;
663 if (Res.Prevailing) {
664 if (!Sym.getIRName().empty()) {
665 auto GUID = GlobalValue::getGUID(GlobalValue::getGlobalIdentifier(
666 Sym.getIRName(), GlobalValue::ExternalLinkage, ""));
667 ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
672 if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
673 return make_error<StringError>(
674 "Expected at most one ThinLTO module per bitcode file",
675 inconvertibleErrorCode());
677 return Error::success();
680 unsigned LTO::getMaxTasks() const {
681 CalledGetMaxTasks = true;
682 return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
685 Error LTO::run(AddStreamFn AddStream, NativeObjectCache Cache) {
686 // Compute "dead" symbols, we don't want to import/export these!
687 DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
688 for (auto &Res : GlobalResolutions) {
689 if (Res.second.VisibleOutsideSummary &&
690 // IRName will be defined if we have seen the prevailing copy of
691 // this value. If not, no need to preserve any ThinLTO copies.
692 !Res.second.IRName.empty())
693 GUIDPreservedSymbols.insert(GlobalValue::getGUID(
694 GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
697 computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols);
699 // Save the status of having a regularLTO combined module, as
700 // this is needed for generating the ThinLTO Task ID, and
701 // the CombinedModule will be moved at the end of runRegularLTO.
702 bool HasRegularLTO = RegularLTO.CombinedModule != nullptr ||
703 !RegularLTO.ModsWithSummaries.empty();
704 // Invoke regular LTO if there was a regular LTO module to start with.
706 if (auto E = runRegularLTO(AddStream))
708 return runThinLTO(AddStream, Cache, HasRegularLTO);
711 Error LTO::runRegularLTO(AddStreamFn AddStream) {
712 for (auto &M : RegularLTO.ModsWithSummaries)
713 if (Error Err = linkRegularLTO(std::move(M),
714 /*LivenessFromIndex=*/true))
717 // Make sure commons have the right size/alignment: we kept the largest from
718 // all the prevailing when adding the inputs, and we apply it here.
719 const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
720 for (auto &I : RegularLTO.Commons) {
721 if (!I.second.Prevailing)
722 // Don't do anything if no instance of this common was prevailing.
724 GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
725 if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
726 // Don't create a new global if the type is already correct, just make
727 // sure the alignment is correct.
728 OldGV->setAlignment(I.second.Align);
732 ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
733 auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false,
734 GlobalValue::CommonLinkage,
735 ConstantAggregateZero::get(Ty), "");
736 GV->setAlignment(I.second.Align);
738 OldGV->replaceAllUsesWith(ConstantExpr::getBitCast(GV, OldGV->getType()));
740 OldGV->eraseFromParent();
742 GV->setName(I.first);
746 if (Conf.PreOptModuleHook &&
747 !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule))
748 return Error::success();
750 if (!Conf.CodeGenOnly) {
751 for (const auto &R : GlobalResolutions) {
752 if (R.second.IRName.empty())
754 if (R.second.Partition != 0 &&
755 R.second.Partition != GlobalResolution::External)
759 RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
760 // Ignore symbols defined in other partitions.
761 if (!GV || GV->hasLocalLinkage())
763 GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
764 : GlobalValue::UnnamedAddr::None);
765 if (R.second.Partition == 0)
766 GV->setLinkage(GlobalValue::InternalLinkage);
769 if (Conf.PostInternalizeModuleHook &&
770 !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
771 return Error::success();
773 return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
774 std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
777 /// This class defines the interface to the ThinLTO backend.
778 class lto::ThinBackendProc {
781 ModuleSummaryIndex &CombinedIndex;
782 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries;
785 ThinBackendProc(Config &Conf, ModuleSummaryIndex &CombinedIndex,
786 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries)
787 : Conf(Conf), CombinedIndex(CombinedIndex),
788 ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {}
790 virtual ~ThinBackendProc() {}
792 unsigned Task, BitcodeModule BM,
793 const FunctionImporter::ImportMapTy &ImportList,
794 const FunctionImporter::ExportSetTy &ExportList,
795 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
796 MapVector<StringRef, BitcodeModule> &ModuleMap) = 0;
797 virtual Error wait() = 0;
801 class InProcessThinBackend : public ThinBackendProc {
802 ThreadPool BackendThreadPool;
803 AddStreamFn AddStream;
804 NativeObjectCache Cache;
805 TypeIdSummariesByGuidTy TypeIdSummariesByGuid;
811 InProcessThinBackend(
812 Config &Conf, ModuleSummaryIndex &CombinedIndex,
813 unsigned ThinLTOParallelismLevel,
814 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
815 AddStreamFn AddStream, NativeObjectCache Cache)
816 : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
817 BackendThreadPool(ThinLTOParallelismLevel),
818 AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
819 // Create a mapping from type identifier GUIDs to type identifier summaries.
820 // This allows backends to use the type identifier GUIDs stored in the
821 // function summaries to determine which type identifier summaries affect
822 // each function without needing to compute GUIDs in each backend.
823 for (auto &TId : CombinedIndex.typeIds())
824 TypeIdSummariesByGuid[GlobalValue::getGUID(TId.first)].push_back(&TId);
827 Error runThinLTOBackendThread(
828 AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
829 BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
830 const FunctionImporter::ImportMapTy &ImportList,
831 const FunctionImporter::ExportSetTy &ExportList,
832 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
833 const GVSummaryMapTy &DefinedGlobals,
834 MapVector<StringRef, BitcodeModule> &ModuleMap,
835 const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
836 auto RunThinBackend = [&](AddStreamFn AddStream) {
837 LTOLLVMContext BackendContext(Conf);
838 Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext);
840 return MOrErr.takeError();
842 return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
843 ImportList, DefinedGlobals, ModuleMap);
846 auto ModuleID = BM.getModuleIdentifier();
848 if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) ||
849 all_of(CombinedIndex.getModuleHash(ModuleID),
850 [](uint32_t V) { return V == 0; }))
851 // Cache disabled or no entry for this module in the combined index or
853 return RunThinBackend(AddStream);
856 // The module may be cached, this helps handling it.
857 computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList,
858 ResolvedODR, DefinedGlobals, TypeIdSummariesByGuid);
859 if (AddStreamFn CacheAddStream = Cache(Task, Key))
860 return RunThinBackend(CacheAddStream);
862 return Error::success();
866 unsigned Task, BitcodeModule BM,
867 const FunctionImporter::ImportMapTy &ImportList,
868 const FunctionImporter::ExportSetTy &ExportList,
869 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
870 MapVector<StringRef, BitcodeModule> &ModuleMap) override {
871 StringRef ModulePath = BM.getModuleIdentifier();
872 assert(ModuleToDefinedGVSummaries.count(ModulePath));
873 const GVSummaryMapTy &DefinedGlobals =
874 ModuleToDefinedGVSummaries.find(ModulePath)->second;
875 BackendThreadPool.async(
876 [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
877 const FunctionImporter::ImportMapTy &ImportList,
878 const FunctionImporter::ExportSetTy &ExportList,
879 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
881 const GVSummaryMapTy &DefinedGlobals,
882 MapVector<StringRef, BitcodeModule> &ModuleMap,
883 const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) {
884 Error E = runThinLTOBackendThread(
885 AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
886 ResolvedODR, DefinedGlobals, ModuleMap, TypeIdSummariesByGuid);
888 std::unique_lock<std::mutex> L(ErrMu);
890 Err = joinErrors(std::move(*Err), std::move(E));
895 BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
896 std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap),
897 std::ref(TypeIdSummariesByGuid));
898 return Error::success();
901 Error wait() override {
902 BackendThreadPool.wait();
904 return std::move(*Err);
906 return Error::success();
909 } // end anonymous namespace
911 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) {
912 return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
913 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
914 AddStreamFn AddStream, NativeObjectCache Cache) {
915 return llvm::make_unique<InProcessThinBackend>(
916 Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries,
921 // Given the original \p Path to an output file, replace any path
922 // prefix matching \p OldPrefix with \p NewPrefix. Also, create the
923 // resulting directory if it does not yet exist.
924 std::string lto::getThinLTOOutputFile(const std::string &Path,
925 const std::string &OldPrefix,
926 const std::string &NewPrefix) {
927 if (OldPrefix.empty() && NewPrefix.empty())
929 SmallString<128> NewPath(Path);
930 llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
931 StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
932 if (!ParentPath.empty()) {
933 // Make sure the new directory exists, creating it if necessary.
934 if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
935 llvm::errs() << "warning: could not create directory '" << ParentPath
936 << "': " << EC.message() << '\n';
938 return NewPath.str();
942 class WriteIndexesThinBackend : public ThinBackendProc {
943 std::string OldPrefix, NewPrefix;
944 bool ShouldEmitImportsFiles;
946 std::string LinkedObjectsFileName;
947 std::unique_ptr<llvm::raw_fd_ostream> LinkedObjectsFile;
950 WriteIndexesThinBackend(
951 Config &Conf, ModuleSummaryIndex &CombinedIndex,
952 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
953 std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
954 std::string LinkedObjectsFileName)
955 : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
956 OldPrefix(OldPrefix), NewPrefix(NewPrefix),
957 ShouldEmitImportsFiles(ShouldEmitImportsFiles),
958 LinkedObjectsFileName(LinkedObjectsFileName) {}
961 unsigned Task, BitcodeModule BM,
962 const FunctionImporter::ImportMapTy &ImportList,
963 const FunctionImporter::ExportSetTy &ExportList,
964 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
965 MapVector<StringRef, BitcodeModule> &ModuleMap) override {
966 StringRef ModulePath = BM.getModuleIdentifier();
967 std::string NewModulePath =
968 getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix);
971 if (!LinkedObjectsFileName.empty()) {
972 if (!LinkedObjectsFile) {
973 LinkedObjectsFile = llvm::make_unique<raw_fd_ostream>(
974 LinkedObjectsFileName, EC, sys::fs::OpenFlags::F_None);
976 return errorCodeToError(EC);
978 *LinkedObjectsFile << NewModulePath << '\n';
981 std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
982 gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries,
983 ImportList, ModuleToSummariesForIndex);
985 raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
986 sys::fs::OpenFlags::F_None);
988 return errorCodeToError(EC);
989 WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
991 if (ShouldEmitImportsFiles)
992 return errorCodeToError(
993 EmitImportsFiles(ModulePath, NewModulePath + ".imports", ImportList));
994 return Error::success();
997 Error wait() override { return Error::success(); }
999 } // end anonymous namespace
1001 ThinBackend lto::createWriteIndexesThinBackend(std::string OldPrefix,
1002 std::string NewPrefix,
1003 bool ShouldEmitImportsFiles,
1004 std::string LinkedObjectsFile) {
1005 return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
1006 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
1007 AddStreamFn AddStream, NativeObjectCache Cache) {
1008 return llvm::make_unique<WriteIndexesThinBackend>(
1009 Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1010 ShouldEmitImportsFiles, LinkedObjectsFile);
1014 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
1015 bool HasRegularLTO) {
1016 if (ThinLTO.ModuleMap.empty())
1017 return Error::success();
1019 if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
1020 return Error::success();
1022 // Collect for each module the list of function it defines (GUID ->
1024 StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
1025 ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1026 ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1027 ModuleToDefinedGVSummaries);
1028 // Create entries for any modules that didn't have any GV summaries
1029 // (either they didn't have any GVs to start with, or we suppressed
1030 // generation of the summaries because they e.g. had inline assembly
1031 // uses that couldn't be promoted/renamed on export). This is so
1032 // InProcessThinBackend::start can still launch a backend thread, which
1033 // is passed the map of summaries for the module, without any special
1034 // handling for this case.
1035 for (auto &Mod : ThinLTO.ModuleMap)
1036 if (!ModuleToDefinedGVSummaries.count(Mod.first))
1037 ModuleToDefinedGVSummaries.try_emplace(Mod.first);
1039 StringMap<FunctionImporter::ImportMapTy> ImportLists(
1040 ThinLTO.ModuleMap.size());
1041 StringMap<FunctionImporter::ExportSetTy> ExportLists(
1042 ThinLTO.ModuleMap.size());
1043 StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
1045 if (Conf.OptLevel > 0) {
1046 ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1047 ImportLists, ExportLists);
1049 std::set<GlobalValue::GUID> ExportedGUIDs;
1050 for (auto &Res : GlobalResolutions) {
1051 // First check if the symbol was flagged as having external references.
1052 if (Res.second.Partition != GlobalResolution::External)
1054 // IRName will be defined if we have seen the prevailing copy of
1055 // this value. If not, no need to mark as exported from a ThinLTO
1056 // partition (and we can't get the GUID).
1057 if (Res.second.IRName.empty())
1059 auto GUID = GlobalValue::getGUID(
1060 GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
1061 // Mark exported unless index-based analysis determined it to be dead.
1062 if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1063 ExportedGUIDs.insert(GUID);
1066 auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
1067 const auto &ExportList = ExportLists.find(ModuleIdentifier);
1068 return (ExportList != ExportLists.end() &&
1069 ExportList->second.count(GUID)) ||
1070 ExportedGUIDs.count(GUID);
1072 thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported);
1075 auto isPrevailing = [&](GlobalValue::GUID GUID,
1076 const GlobalValueSummary *S) {
1077 return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
1079 auto recordNewLinkage = [&](StringRef ModuleIdentifier,
1080 GlobalValue::GUID GUID,
1081 GlobalValue::LinkageTypes NewLinkage) {
1082 ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1084 thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing,
1087 std::unique_ptr<ThinBackendProc> BackendProc =
1088 ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1091 // Task numbers start at ParallelCodeGenParallelismLevel if an LTO
1092 // module is present, as tasks 0 through ParallelCodeGenParallelismLevel-1
1093 // are reserved for parallel code generation partitions.
1095 HasRegularLTO ? RegularLTO.ParallelCodeGenParallelismLevel : 0;
1096 for (auto &Mod : ThinLTO.ModuleMap) {
1097 if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
1098 ExportLists[Mod.first],
1099 ResolvedODR[Mod.first], ThinLTO.ModuleMap))
1104 return BackendProc->wait();
1107 Expected<std::unique_ptr<tool_output_file>>
1108 lto::setupOptimizationRemarks(LLVMContext &Context,
1109 StringRef LTORemarksFilename,
1110 bool LTOPassRemarksWithHotness, int Count) {
1111 if (LTORemarksFilename.empty())
1114 std::string Filename = LTORemarksFilename;
1116 Filename += ".thin." + llvm::utostr(Count) + ".yaml";
1119 auto DiagnosticFile =
1120 llvm::make_unique<tool_output_file>(Filename, EC, sys::fs::F_None);
1122 return errorCodeToError(EC);
1123 Context.setDiagnosticsOutputFile(
1124 llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
1125 if (LTOPassRemarksWithHotness)
1126 Context.setDiagnosticsHotnessRequested(true);
1127 DiagnosticFile->keep();
1128 return std::move(DiagnosticFile);