LLVM 24.0.0git
ThinLTOCodeGenerator.cpp
Go to the documentation of this file.
1//===-ThinLTOCodeGenerator.cpp - LLVM Link Time Optimizer -----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Thin Link Time Optimization library. This library is
10// intended to be used by linker to optimize code at link time.
11//
12//===----------------------------------------------------------------------===//
13
18
19#include "llvm/ADT/ScopeExit.h"
20#include "llvm/ADT/Statistic.h"
29#include "llvm/Config/llvm-config.h"
30#include "llvm/IR/DebugInfo.h"
32#include "llvm/IR/LLVMContext.h"
35#include "llvm/IR/Mangler.h"
37#include "llvm/IR/Verifier.h"
39#include "llvm/LTO/LTO.h"
46#include "llvm/Support/Debug.h"
47#include "llvm/Support/Error.h"
51#include "llvm/Support/Path.h"
52#include "llvm/Support/SHA1.h"
66
67#if !defined(_MSC_VER) && !defined(__MINGW32__)
68#include <unistd.h>
69#else
70#include <io.h>
71#endif
72
73using namespace llvm;
74using namespace ThinLTOCodeGeneratorImpl;
75
76#define DEBUG_TYPE "thinlto"
77
78namespace llvm {
79// Flags -discard-value-names, defined in LTOCodeGenerator.cpp
89}
90
91// Default to using all available threads in the system, but using only one
92// thred per core, as indicated by the usage of
93// heavyweight_hardware_concurrency() below.
94static cl::opt<int> ThreadCount("threads", cl::init(0));
95
96// Simple helper to save temporary files for debug.
97static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
98 unsigned count, StringRef Suffix) {
99 if (TempDir.empty())
100 return;
101 // User asked to save temps, let dump the bitcode file after import.
102 std::string SaveTempPath = (TempDir + llvm::Twine(count) + Suffix).str();
103 std::error_code EC;
104 raw_fd_ostream OS(SaveTempPath, EC, sys::fs::OF_None);
105 if (EC)
106 report_fatal_error(Twine("Failed to open ") + SaveTempPath +
107 " to save optimized bitcode\n");
108 WriteBitcodeToFile(TheModule, OS, /* ShouldPreserveUseListOrder */ true);
109}
110
112 ArrayRef<std::unique_ptr<GlobalValueSummary>> GVSummaryList) {
113 // If there is any strong definition anywhere, get it.
114 auto StrongDefForLinker = llvm::find_if(
115 GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
116 auto Linkage = Summary->linkage();
119 });
120 if (StrongDefForLinker != GVSummaryList.end())
121 return StrongDefForLinker->get();
122 // Get the first *linker visible* definition for this global in the summary
123 // list.
124 auto FirstDefForLinker = llvm::find_if(
125 GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
126 auto Linkage = Summary->linkage();
128 });
129 // Extern templates can be emitted as available_externally.
130 if (FirstDefForLinker == GVSummaryList.end())
131 return nullptr;
132 return FirstDefForLinker->get();
133}
134
135// Populate map of GUID to the prevailing copy for any multiply defined
136// symbols. Currently assume first copy is prevailing, or any strong
137// definition. Can be refined with Linker information in the future.
139 const ModuleSummaryIndex &Index,
141 auto HasMultipleCopies =
143 return GVSummaryList.size() > 1;
144 };
145
146 for (auto &I : Index) {
147 if (HasMultipleCopies(I.second.getSummaryList()))
148 PrevailingCopy[I.first] =
149 getFirstDefinitionForLinker(I.second.getSummaryList());
150 }
151}
152
154generateModuleMap(std::vector<std::unique_ptr<lto::InputFile>> &Modules) {
156 for (auto &M : Modules) {
157 LLVM_DEBUG(dbgs() << "Adding module " << M->getName() << " to ModuleMap\n");
158 assert(!ModuleMap.contains(M->getName()) &&
159 "Expect unique Buffer Identifier");
160 ModuleMap[M->getName()] = M.get();
161 }
162 return ModuleMap;
163}
164
165static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index,
166 bool ClearDSOLocalOnDeclarations) {
167 renameModuleForThinLTO(TheModule, Index, ClearDSOLocalOnDeclarations);
168}
169
170namespace {
171class ThinLTODiagnosticInfo : public DiagnosticInfo {
172 const Twine &Msg;
173public:
174 ThinLTODiagnosticInfo(const Twine &DiagMsg LLVM_LIFETIME_BOUND,
175 DiagnosticSeverity Severity = DS_Error)
176 : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
177 void print(DiagnosticPrinter &DP) const override { DP << Msg; }
178};
179}
180
181/// Verify the module and strip broken debug info.
182static void verifyLoadedModule(Module &TheModule) {
183 bool BrokenDebugInfo = false;
184 if (verifyModule(TheModule, &dbgs(), &BrokenDebugInfo))
185 report_fatal_error("Broken module found, compilation aborted!");
186 if (BrokenDebugInfo) {
187 TheModule.getContext().diagnose(ThinLTODiagnosticInfo(
188 "Invalid debug info found, debug info will be stripped", DS_Warning));
189 StripDebugInfo(TheModule);
190 }
191}
192
193static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile *Input,
194 LLVMContext &Context,
195 bool Lazy,
196 bool IsImporting) {
197 auto &Mod = Input->getSingleBitcodeModule();
199 Lazy ? Mod.getLazyModule(Context,
200 /* ShouldLazyLoadMetadata */ true, IsImporting)
201 : Mod.parseModule(Context);
202 if (!ModuleOrErr) {
203 handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
204 SMDiagnostic Err = SMDiagnostic(Mod.getModuleIdentifier(),
205 SourceMgr::DK_Error, EIB.message());
206 Err.print("ThinLTO", errs());
207 });
208 report_fatal_error("Can't load module, abort.");
209 }
210 if (!Lazy)
211 verifyLoadedModule(*ModuleOrErr.get());
212 return std::move(*ModuleOrErr);
213}
214
215static void
218 const FunctionImporter::ImportMapTy &ImportList,
219 bool ClearDSOLocalOnDeclarations) {
220 auto Loader = [&](StringRef Identifier) {
221 auto &Input = ModuleMap[Identifier];
222 return loadModuleFromInput(Input, TheModule.getContext(),
223 /*Lazy=*/true, /*IsImporting*/ true);
224 };
225
226 FunctionImporter Importer(Index, Loader, ClearDSOLocalOnDeclarations);
227 Expected<bool> Result = Importer.importFunctions(TheModule, ImportList);
228 if (!Result) {
229 handleAllErrors(Result.takeError(), [&](ErrorInfoBase &EIB) {
230 SMDiagnostic Err = SMDiagnostic(TheModule.getModuleIdentifier(),
231 SourceMgr::DK_Error, EIB.message());
232 Err.print("ThinLTO", errs());
233 });
234 report_fatal_error("importFunctions failed");
235 }
236 // Verify again after cross-importing.
237 verifyLoadedModule(TheModule);
238}
239
240static void optimizeModule(Module &TheModule, TargetMachine &TM,
241 unsigned OptLevel, bool Freestanding,
242 bool DebugPassManager, ModuleSummaryIndex *Index) {
243 std::optional<PGOOptions> PGOOpt;
244 if (LTORunCSIRInstr) {
245 PGOOpt =
247 /*MemoryProfile=*/"", PGOOptions::IRUse,
249 } else if (!LTOCSIRProfile.empty()) {
250 PGOOpt = PGOOptions(LTOCSIRProfile, "", "",
251 /*MemoryProfile=*/"", PGOOptions::IRUse,
253 } else if (StringRef SampleProfileFile =
255 TheModule.getContext());
256 !SampleProfileFile.empty()) {
257 PGOOpt =
258 PGOOptions(SampleProfileFile.str(), "", "",
259 /*MemoryProfile=*/"", PGOOptions::SampleUse,
261 }
266
268 StandardInstrumentations SI(TheModule.getContext(), DebugPassManager);
269 SI.registerCallbacks(PIC, &MAM);
271 PTO.LoopVectorization = true;
272 PTO.SLPVectorization = true;
273 PassBuilder PB(TheModule.getContext(), &TM, PTO, PGOOpt, &PIC);
274
275 std::unique_ptr<TargetLibraryInfoImpl> TLII(
277 if (Freestanding)
278 TLII->disableAllFunctions();
279 FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
280
281 // Register all the basic analyses with the managers.
282 PB.registerModuleAnalyses(MAM);
283 PB.registerCGSCCAnalyses(CGAM);
284 PB.registerFunctionAnalyses(FAM);
285 PB.registerLoopAnalyses(LAM);
286 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
287
289
291
292 switch (OptLevel) {
293 default:
294 llvm_unreachable("Invalid optimization level");
295 case 0:
297 break;
298 case 1:
300 break;
301 case 2:
303 break;
304 case 3:
306 break;
307 }
308
309 MPM.addPass(PB.buildThinLTODefaultPipeline(OL, Index));
310
311 MPM.run(TheModule, MAM);
312}
313
314static void
316 DenseSet<GlobalValue::GUID> &PreservedGUID) {
317 Triple TT(File.getTargetTriple());
318 RTLIB::RuntimeLibcallsInfo Libcalls(TT);
319 TargetLibraryInfoImpl TLII(TT);
321 for (const auto &Sym : File.symbols())
322 if (Sym.isUsed() || Sym.isLibcall(TLI, Libcalls))
323 PreservedGUID.insert(
325}
326
327// Convert the PreservedSymbols map from "Name" based to "GUID" based.
329 const StringSet<> &PreservedSymbols,
330 const Triple &TheTriple,
332 // Iterate the symbols in the input file and if the input has preserved symbol
333 // compute the GUID for the symbol.
334 for (const auto &Sym : File.symbols()) {
335 if (PreservedSymbols.count(Sym.getName()) && !Sym.getIRName().empty())
337 GlobalValue::getGlobalIdentifier(Sym.getIRName(),
339 }
340}
341
344 const StringSet<> &PreservedSymbols,
345 const Triple &TheTriple) {
346 DenseSet<GlobalValue::GUID> GUIDPreservedSymbols(PreservedSymbols.size());
347 computeGUIDPreservedSymbols(File, PreservedSymbols, TheTriple,
348 GUIDPreservedSymbols);
349 return GUIDPreservedSymbols;
350}
351
352static std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule,
353 TargetMachine &TM) {
355
356 // CodeGen
357 {
359 if (runCodeGenPipeline(TM, TheModule, OS, nullptr,
361 report_fatal_error("Failed to run codegen");
362 }
363 return std::make_unique<SmallVectorMemoryBuffer>(
364 std::move(OutputBuffer), /*RequiresNullTerminator=*/false);
365}
366
367namespace {
368/// Manage caching for a single Module.
369class ModuleCacheEntry {
370 SmallString<128> EntryPath;
371
372public:
373 // Create a cache entry. This compute a unique hash for the Module considering
374 // the current list of export/import, and offer an interface to query to
375 // access the content in the cache.
376 ModuleCacheEntry(
377 StringRef CachePath, const ModuleSummaryIndex &Index, StringRef ModuleID,
378 const FunctionImporter::ImportMapTy &ImportList,
379 const FunctionImporter::ExportSetTy &ExportList,
380 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
381 const GVSummaryMapTy &DefinedGVSummaries, unsigned OptLevel,
382 bool Freestanding, const TargetMachineBuilder &TMBuilder,
383 ArrayRef<std::string> MllvmArgs) {
384 if (CachePath.empty())
385 return;
386
387 if (!Index.modulePaths().count(ModuleID))
388 // The module does not have an entry, it can't have a hash at all
389 return;
390
391 if (all_of(Index.getModuleHash(ModuleID),
392 [](uint32_t V) { return V == 0; }))
393 // No hash entry, no caching!
394 return;
395
396 llvm::lto::Config Conf;
397 Conf.OptLevel = OptLevel;
398 Conf.Options = TMBuilder.Options;
399 Conf.CPU = TMBuilder.MCpu;
400 Conf.MAttrs.push_back(TMBuilder.MAttr);
401 Conf.RelocModel = TMBuilder.RelocModel;
402 Conf.CGOptLevel = TMBuilder.CGOptLevel;
403 Conf.Freestanding = Freestanding;
404 append_range(Conf.MllvmArgs, MllvmArgs);
405 std::string Key =
406 computeLTOCacheKey(Conf, Index, ModuleID, ImportList, ExportList,
407 ResolvedODR, DefinedGVSummaries);
408
409 // This choice of file name allows the cache to be pruned (see pruneCache()
410 // in include/llvm/Support/CachePruning.h).
411 sys::path::append(EntryPath, CachePath, Twine("llvmcache-", Key));
412 }
413
414 // Access the path to this entry in the cache.
415 StringRef getEntryPath() { return EntryPath; }
416
417 // Try loading the buffer for this cache entry.
418 ErrorOr<std::unique_ptr<MemoryBuffer>> tryLoadingBuffer() {
419 if (EntryPath.empty())
420 return std::error_code();
421 SmallString<64> ResultPath;
422 Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
423 Twine(EntryPath), sys::fs::OF_UpdateAtime, &ResultPath);
424 if (!FDOrErr)
425 return errorToErrorCode(FDOrErr.takeError());
426 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getOpenFile(
427 *FDOrErr, EntryPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
428 sys::fs::closeFile(*FDOrErr);
429 return MBOrErr;
430 }
431
432 // Cache the Produced object file
433 void write(const MemoryBuffer &OutputBuffer) {
434 if (EntryPath.empty())
435 return;
436
437 if (auto Err = llvm::writeToOutput(
438 EntryPath, [&OutputBuffer](llvm::raw_ostream &OS) -> llvm::Error {
439 OS << OutputBuffer.getBuffer();
440 return llvm::Error::success();
441 }))
442 report_fatal_error(llvm::formatv("ThinLTO: Can't write file {0}: {1}",
443 EntryPath,
444 toString(std::move(Err)).c_str()));
445 }
446};
447} // end anonymous namespace
448
449static std::unique_ptr<MemoryBuffer>
452 const FunctionImporter::ImportMapTy &ImportList,
453 const FunctionImporter::ExportSetTy &ExportList,
454 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
455 const GVSummaryMapTy &DefinedGlobals,
456 const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
457 bool DisableCodeGen, StringRef SaveTempsDir,
458 bool Freestanding, unsigned OptLevel, unsigned count,
459 bool DebugPassManager) {
460 // "Benchmark"-like optimization: single-source case
461 bool SingleModule = (ModuleMap.size() == 1);
462
463 // When linking an ELF shared object, dso_local should be dropped. We
464 // conservatively do this for -fpic.
465 bool ClearDSOLocalOnDeclarations =
466 TheModule.getTargetTriple().isOSBinFormatELF() &&
468 TheModule.getPIELevel() == PIELevel::Default;
469
470 if (!SingleModule) {
471 promoteModule(TheModule, Index, ClearDSOLocalOnDeclarations);
472
473 // Apply summary-based prevailing-symbol resolution decisions.
474 thinLTOFinalizeInModule(TheModule, DefinedGlobals, /*PropagateAttrs=*/true);
475
476 // Save temps: after promotion.
477 saveTempBitcode(TheModule, SaveTempsDir, count, ".1.promoted.bc");
478 }
479
480 // Be friendly and don't nuke totally the module when the client didn't
481 // supply anything to preserve.
482 if (!ExportList.empty() || !GUIDPreservedSymbols.empty()) {
483 // Apply summary-based internalization decisions.
484 thinLTOInternalizeModule(TheModule, DefinedGlobals);
485 }
486
487 // Save internalized bitcode
488 saveTempBitcode(TheModule, SaveTempsDir, count, ".2.internalized.bc");
489
490 if (!SingleModule)
491 crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
492 ClearDSOLocalOnDeclarations);
493
494 // Do this after any importing so that imported code is updated.
495 // See comment at call to updateVCallVisibilityInIndex() for why
496 // WholeProgramVisibilityEnabledInLTO is false.
498 /* WholeProgramVisibilityEnabledInLTO */ false);
499
500 // Save temps: after cross-module import.
501 saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
502
503 optimizeModule(TheModule, TM, OptLevel, Freestanding, DebugPassManager,
504 &Index);
505
506 saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
507
508 if (DisableCodeGen) {
509 // Configured to stop before CodeGen, serialize the bitcode and return.
511 {
513 ProfileSummaryInfo PSI(TheModule);
514 auto Index = buildModuleSummaryIndex(TheModule, nullptr, &PSI);
515 WriteBitcodeToFile(TheModule, OS, true, &Index);
516 }
517 return std::make_unique<SmallVectorMemoryBuffer>(
518 std::move(OutputBuffer), /*RequiresNullTerminator=*/false);
519 }
520
521 return codegenModule(TheModule, TM);
522}
523
524/// Resolve prevailing symbols. Record resolutions in the \p ResolvedODR map
525/// for caching, and in the \p Index for application during the ThinLTO
526/// backends. This is needed for correctness for exported symbols (ensure
527/// at least one copy kept) and a compile-time optimization (to drop duplicate
528/// copies when possible).
530 ModuleSummaryIndex &Index,
531 StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
532 &ResolvedODR,
533 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
535 &PrevailingCopy) {
536
537 auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
538 const auto &Prevailing = PrevailingCopy.find(GUID);
539 // Not in map means that there was only one copy, which must be prevailing.
540 if (Prevailing == PrevailingCopy.end())
541 return true;
542 return Prevailing->second == S;
543 };
544
545 auto recordNewLinkage = [&](StringRef ModuleIdentifier,
547 GlobalValue::LinkageTypes NewLinkage) {
548 ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
549 };
550
551 // TODO Conf.VisibilityScheme can be lto::Config::ELF for ELF.
552 lto::Config Conf;
553 thinLTOResolvePrevailingInIndex(Conf, Index, isPrevailing, recordNewLinkage,
554 GUIDPreservedSymbols);
555}
556
557// Initialize the TargetMachine builder for a given Triple
558static void initTMBuilder(const cl::LibraryOptionsContext &LibraryOptions,
559 TargetMachineBuilder &TMBuilder,
560 const Triple &TheTriple) {
561 if (TMBuilder.MCpu.empty())
562 TMBuilder.MCpu = lto::getThinLTODefaultCPU(TheTriple);
563 TMBuilder.TheTriple = std::move(TheTriple);
564 // If data-sections is not explicitly set or unset, set data-sections by
565 // default to match the behaviour of lld and gold plugin.
566 if (!codegen::getExplicitDataSections(LibraryOptions))
567 TMBuilder.Options.DataSections = true;
568}
569
571 MemoryBufferRef Buffer(Data, Identifier);
572
573 auto InputOrError = lto::InputFile::create(Buffer);
574 if (!InputOrError)
575 report_fatal_error(Twine("ThinLTO cannot create input file: ") +
576 toString(InputOrError.takeError()));
577
578 auto TripleStr = (*InputOrError)->getTargetTriple();
579 Triple TheTriple(TripleStr);
580
581 if (Modules.empty())
582 initTMBuilder(LibraryOptions, TMBuilder, Triple(TheTriple));
583 else if (TMBuilder.TheTriple != TheTriple) {
584 if (!TMBuilder.TheTriple.isCompatibleWith(TheTriple))
585 report_fatal_error("ThinLTO modules with incompatible triples not "
586 "supported");
587 initTMBuilder(LibraryOptions, TMBuilder,
588 Triple(TMBuilder.TheTriple.merge(TheTriple)));
589 }
590
591 Modules.emplace_back(std::move(*InputOrError));
592}
593
595 PreservedSymbols.insert(Name);
596}
597
599 // FIXME: At the moment, we don't take advantage of this extra information,
600 // we're conservatively considering cross-references as preserved.
601 // CrossReferencedSymbols.insert(Name);
602 PreservedSymbols.insert(Name);
603}
604
605// TargetMachine factory
606std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
607 std::string ErrMsg;
608 const Target *TheTarget = TargetRegistry::lookupTarget(TheTriple, ErrMsg);
609 if (!TheTarget) {
610 report_fatal_error(Twine("Can't load target for this Triple: ") + ErrMsg);
611 }
612
613 // Use MAttr as the default set of features.
614 SubtargetFeatures Features(MAttr);
616 std::string FeatureStr = Features.getString();
617
618 std::unique_ptr<TargetMachine> TM(
619 TheTarget->createTargetMachine(TheTriple, MCpu, FeatureStr, Options,
620 RelocModel, std::nullopt, CGOptLevel));
621 assert(TM && "Cannot create target machine");
622
623 return TM;
624}
625
626/**
627 * Produce the combined summary index from all the bitcode files:
628 * "thin-link".
629 */
630std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
631 std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
632 std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
633 for (auto &Mod : Modules) {
634 auto &M = Mod->getSingleBitcodeModule();
635 if (Error Err = M.readSummary(*CombinedIndex, Mod->getName())) {
636 // FIXME diagnose
638 std::move(Err), errs(),
639 "error: can't create module summary index for buffer: ");
640 return nullptr;
641 }
642 }
643 return CombinedIndex;
644}
645
646namespace {
647struct IsExported {
649 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols;
650
651 IsExported(
653 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols)
654 : ExportLists(ExportLists), GUIDPreservedSymbols(GUIDPreservedSymbols) {}
655
656 bool operator()(StringRef ModuleIdentifier, ValueInfo VI) const {
657 const auto &ExportList = ExportLists.find(ModuleIdentifier);
658 return (ExportList != ExportLists.end() && ExportList->second.count(VI)) ||
659 GUIDPreservedSymbols.count(VI.getGUID());
660 }
661};
662
663struct IsPrevailing {
664 const DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy;
665 IsPrevailing(const DenseMap<GlobalValue::GUID, const GlobalValueSummary *>
666 &PrevailingCopy)
667 : PrevailingCopy(PrevailingCopy) {}
668
669 bool operator()(GlobalValue::GUID GUID, const GlobalValueSummary *S) const {
670 const auto &Prevailing = PrevailingCopy.find(GUID);
671 // Not in map means that there was only one copy, which must be prevailing.
672 if (Prevailing == PrevailingCopy.end())
673 return true;
674 return Prevailing->second == S;
675 };
676};
677} // namespace
678
680 ModuleSummaryIndex &Index,
681 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
682 // We have no symbols resolution available. And can't do any better now in the
683 // case where the prevailing symbol is in a native object. It can be refined
684 // with linker information in the future.
685 auto isPrevailing = [&](GlobalValue::GUID G) {
687 };
688 computeDeadSymbolsWithConstProp(Index, GUIDPreservedSymbols, isPrevailing,
689 /* ImportEnabled = */ true);
690}
691
692/**
693 * Perform promotion and renaming of exported internal functions.
694 * Index is updated to reflect linkage changes from weak resolution.
695 */
697 const lto::InputFile &File) {
698 auto ModuleCount = Index.modulePaths().size();
699 auto ModuleIdentifier = TheModule.getModuleIdentifier();
700
701 // Collect for each module the list of function it defines (GUID -> Summary).
702 DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries;
703 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
704
705 // Convert the preserved symbols set from string to GUID
706 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
707 File, PreservedSymbols, TheModule.getTargetTriple());
708
709 // Add used symbol to the preserved symbols.
710 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
711
712 // Compute "dead" symbols, we don't want to import/export these!
713 computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
714
715 // Compute prevailing symbols
717 computePrevailingCopies(Index, PrevailingCopy);
718
719 // Generate import/export list
720 FunctionImporter::ImportListsTy ImportLists(ModuleCount);
722 ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries,
723 IsPrevailing(PrevailingCopy), ImportLists,
724 ExportLists);
725
726 // Resolve prevailing symbols
728 resolvePrevailingInIndex(Index, ResolvedODR, GUIDPreservedSymbols,
729 PrevailingCopy);
730
731 thinLTOFinalizeInModule(TheModule,
732 ModuleToDefinedGVSummaries[ModuleIdentifier],
733 /*PropagateAttrs=*/false);
734
735 // Promote the exported values in the index, so that they are promoted
736 // in the module.
738 Index, IsExported(ExportLists, GUIDPreservedSymbols),
739 IsPrevailing(PrevailingCopy));
740
741 // FIXME Set ClearDSOLocalOnDeclarations.
742 promoteModule(TheModule, Index, /*ClearDSOLocalOnDeclarations=*/false);
743}
744
745/**
746 * Perform cross-module importing for the module identified by ModuleIdentifier.
747 */
749 ModuleSummaryIndex &Index,
750 const lto::InputFile &File) {
751 auto ModuleMap = generateModuleMap(Modules);
752 auto ModuleCount = Index.modulePaths().size();
753
754 // Collect for each module the list of function it defines (GUID -> Summary).
755 DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
756 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
757
758 // Convert the preserved symbols set from string to GUID
759 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
760 File, PreservedSymbols, TheModule.getTargetTriple());
761
762 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
763
764 // Compute "dead" symbols, we don't want to import/export these!
765 computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
766
767 // Compute prevailing symbols
769 computePrevailingCopies(Index, PrevailingCopy);
770
771 // Generate import/export list
772 FunctionImporter::ImportListsTy ImportLists(ModuleCount);
774 ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries,
775 IsPrevailing(PrevailingCopy), ImportLists,
776 ExportLists);
777 auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
778
779 // FIXME Set ClearDSOLocalOnDeclarations.
780 crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
781 /*ClearDSOLocalOnDeclarations=*/false);
782}
783
784/**
785 * Compute the list of summaries needed for importing into module.
786 */
788 Module &TheModule, ModuleSummaryIndex &Index,
789 ModuleToSummariesForIndexTy &ModuleToSummariesForIndex,
790 GVSummaryPtrSet &DecSummaries, const lto::InputFile &File) {
791 auto ModuleCount = Index.modulePaths().size();
792 auto ModuleIdentifier = TheModule.getModuleIdentifier();
793
794 // Collect for each module the list of function it defines (GUID -> Summary).
795 DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
796 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
797
798 // Convert the preserved symbols set from string to GUID
799 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
800 File, PreservedSymbols, TheModule.getTargetTriple());
801
802 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
803
804 // Compute "dead" symbols, we don't want to import/export these!
805 computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
806
807 // Compute prevailing symbols
809 computePrevailingCopies(Index, PrevailingCopy);
810
811 // Generate import/export list
812 FunctionImporter::ImportListsTy ImportLists(ModuleCount);
814 ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries,
815 IsPrevailing(PrevailingCopy), ImportLists,
816 ExportLists);
817
819 ModuleIdentifier, ModuleToDefinedGVSummaries,
820 ImportLists[ModuleIdentifier], ModuleToSummariesForIndex, DecSummaries);
821}
822
823/**
824 * Emit the list of files needed for importing into module.
825 */
827 ModuleSummaryIndex &Index,
828 const lto::InputFile &File) {
829 auto ModuleCount = Index.modulePaths().size();
830 auto ModuleIdentifier = TheModule.getModuleIdentifier();
831
832 // Collect for each module the list of function it defines (GUID -> Summary).
833 DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
834 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
835
836 // Convert the preserved symbols set from string to GUID
837 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
838 File, PreservedSymbols, TheModule.getTargetTriple());
839
840 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
841
842 // Compute "dead" symbols, we don't want to import/export these!
843 computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
844
845 // Compute prevailing symbols
847 computePrevailingCopies(Index, PrevailingCopy);
848
849 // Generate import/export list
850 FunctionImporter::ImportListsTy ImportLists(ModuleCount);
852 ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries,
853 IsPrevailing(PrevailingCopy), ImportLists,
854 ExportLists);
855
856 // 'EmitImportsFiles' emits the list of modules from which to import from, and
857 // the set of keys in `ModuleToSummariesForIndex` should be a superset of keys
858 // in `DecSummaries`, so no need to use `DecSummaries` in `EmitImportsFiles`.
859 GVSummaryPtrSet DecSummaries;
860 ModuleToSummariesForIndexTy ModuleToSummariesForIndex;
862 ModuleIdentifier, ModuleToDefinedGVSummaries,
863 ImportLists[ModuleIdentifier], ModuleToSummariesForIndex, DecSummaries);
864
865 if (Error EC = EmitImportsFiles(ModuleIdentifier, OutputName,
866 ModuleToSummariesForIndex))
867 report_fatal_error(Twine("Failed to open ") + OutputName +
868 " to save imports lists\n");
869}
870
871/**
872 * Perform internalization. Runs promote and internalization together.
873 * Index is updated to reflect linkage changes.
874 */
876 ModuleSummaryIndex &Index,
877 const lto::InputFile &File) {
878 initTMBuilder(LibraryOptions, TMBuilder, TheModule.getTargetTriple());
879 auto ModuleCount = Index.modulePaths().size();
880 auto ModuleIdentifier = TheModule.getModuleIdentifier();
881
882 // Convert the preserved symbols set from string to GUID
883 auto GUIDPreservedSymbols =
884 computeGUIDPreservedSymbols(File, PreservedSymbols, TMBuilder.TheTriple);
885
886 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
887
888 // Collect for each module the list of function it defines (GUID -> Summary).
889 DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
890 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
891
892 // Compute "dead" symbols, we don't want to import/export these!
893 computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
894
895 // Compute prevailing symbols
897 computePrevailingCopies(Index, PrevailingCopy);
898
899 // Generate import/export list
900 FunctionImporter::ImportListsTy ImportLists(ModuleCount);
902 ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries,
903 IsPrevailing(PrevailingCopy), ImportLists,
904 ExportLists);
905 auto &ExportList = ExportLists[ModuleIdentifier];
906
907 // Be friendly and don't nuke totally the module when the client didn't
908 // supply anything to preserve.
909 if (ExportList.empty() && GUIDPreservedSymbols.empty())
910 return;
911
912 // Resolve prevailing symbols
914 resolvePrevailingInIndex(Index, ResolvedODR, GUIDPreservedSymbols,
915 PrevailingCopy);
916
917 // Promote the exported values in the index, so that they are promoted
918 // in the module.
920 Index, IsExported(ExportLists, GUIDPreservedSymbols),
921 IsPrevailing(PrevailingCopy));
922
923 // FIXME Set ClearDSOLocalOnDeclarations.
924 promoteModule(TheModule, Index, /*ClearDSOLocalOnDeclarations=*/false);
925
926 // Internalization
927 thinLTOFinalizeInModule(TheModule,
928 ModuleToDefinedGVSummaries[ModuleIdentifier],
929 /*PropagateAttrs=*/false);
930
931 thinLTOInternalizeModule(TheModule,
932 ModuleToDefinedGVSummaries[ModuleIdentifier]);
933}
934
935/**
936 * Perform post-importing ThinLTO optimizations.
937 */
939 initTMBuilder(LibraryOptions, TMBuilder, TheModule.getTargetTriple());
940
941 // Optimize now
942 optimizeModule(TheModule, *TMBuilder.create(), OptLevel, Freestanding,
943 DebugPassManager, nullptr);
944}
945
946/// Write out the generated object file, either from CacheEntryPath or from
947/// OutputBuffer, preferring hard-link when possible.
948/// Returns the path to the generated file in SavedObjectsDirectoryPath.
949std::string
951 const MemoryBuffer &OutputBuffer) {
952 auto ArchName = TMBuilder.TheTriple.getArchName();
953 SmallString<128> OutputPath(SavedObjectsDirectoryPath);
954 llvm::sys::path::append(OutputPath,
955 Twine(count) + "." + ArchName + ".thinlto.o");
956 OutputPath.c_str(); // Ensure the string is null terminated.
957 if (sys::fs::exists(OutputPath))
958 sys::fs::remove(OutputPath);
959
960 // We don't return a memory buffer to the linker, just a list of files.
961 if (!CacheEntryPath.empty()) {
962 // Cache is enabled, hard-link the entry (or copy if hard-link fails).
963 auto Err = sys::fs::create_hard_link(CacheEntryPath, OutputPath);
964 if (!Err)
965 return std::string(OutputPath);
966 // Hard linking failed, try to copy.
967 Err = sys::fs::copy_file(CacheEntryPath, OutputPath);
968 if (!Err)
969 return std::string(OutputPath);
970 // Copy failed (could be because the CacheEntry was removed from the cache
971 // in the meantime by another process), fall back and try to write down the
972 // buffer to the output.
973 errs() << "remark: can't link or copy from cached entry '" << CacheEntryPath
974 << "' to '" << OutputPath << "'\n";
975 }
976 // No cache entry, just write out the buffer.
977 std::error_code Err;
978 raw_fd_ostream OS(OutputPath, Err, sys::fs::OF_None);
979 if (Err)
980 report_fatal_error(Twine("Can't open output '") + OutputPath + "'\n");
981 OS << OutputBuffer.getBuffer();
982 return std::string(OutputPath);
983}
984
985// Main entry point for the ThinLTO processing
987 timeTraceProfilerBegin("ThinLink", StringRef(""));
988 llvm::scope_exit TimeTraceScopeExit([]() {
991 });
992 // Prepare the resulting object vector
993 assert(ProducedBinaries.empty() && "The generator should not be reused");
994 if (SavedObjectsDirectoryPath.empty())
995 ProducedBinaries.resize(Modules.size());
996 else {
997 sys::fs::create_directories(SavedObjectsDirectoryPath);
998 bool IsDir;
999 sys::fs::is_directory(SavedObjectsDirectoryPath, IsDir);
1000 if (!IsDir)
1001 report_fatal_error(Twine("Unexistent dir: '") + SavedObjectsDirectoryPath + "'");
1002 ProducedBinaryFiles.resize(Modules.size());
1003 }
1004
1005 if (CodeGenOnly) {
1006 // Perform only parallel codegen and return.
1007 DefaultThreadPool Pool;
1008 int count = 0;
1009 for (auto &Mod : Modules) {
1010 Pool.async([&](int count) {
1011 LLVMContext Context;
1012 Context.getLibraryOptions().assign(LibraryOptions);
1013 Context.setDiscardValueNames(LTODiscardValueNames);
1014
1015 // Parse module now
1016 auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
1017 /*IsImporting*/ false);
1018
1019 // CodeGen
1020 auto OutputBuffer = codegenModule(*TheModule, *TMBuilder.create());
1021 if (SavedObjectsDirectoryPath.empty())
1022 ProducedBinaries[count] = std::move(OutputBuffer);
1023 else
1024 ProducedBinaryFiles[count] =
1026 }, count++);
1027 }
1028
1029 return;
1030 }
1031
1032 // Sequential linking phase
1033 auto Index = linkCombinedIndex();
1034
1035 // Save temps: index.
1036 if (!SaveTempsDir.empty()) {
1037 auto SaveTempPath = SaveTempsDir + "index.bc";
1038 std::error_code EC;
1039 raw_fd_ostream OS(SaveTempPath, EC, sys::fs::OF_None);
1040 if (EC)
1041 report_fatal_error(Twine("Failed to open ") + SaveTempPath +
1042 " to save optimized bitcode\n");
1043 writeIndexToFile(*Index, OS);
1044 }
1045
1046
1047 // Prepare the module map.
1048 auto ModuleMap = generateModuleMap(Modules);
1049 auto ModuleCount = Modules.size();
1050
1051 // Collect for each module the list of function it defines (GUID -> Summary).
1052 DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
1053 Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1054
1055 // Convert the preserved symbols set from string to GUID, this is needed for
1056 // computing the caching hash and the internalization.
1057 DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
1058 for (const auto &M : Modules)
1059 computeGUIDPreservedSymbols(*M, PreservedSymbols, TMBuilder.TheTriple,
1060 GUIDPreservedSymbols);
1061
1062 // Add used symbol from inputs to the preserved symbols.
1063 for (const auto &M : Modules)
1064 addUsedSymbolToPreservedGUID(*M, GUIDPreservedSymbols);
1065
1066 // Compute "dead" symbols, we don't want to import/export these!
1067 computeDeadSymbolsInIndex(*Index, GUIDPreservedSymbols);
1068
1069 // Currently there is no support for enabling whole program visibility via a
1070 // linker option in the old LTO API, but this call allows it to be specified
1071 // via the internal option. Must be done before WPD below.
1072 if (hasWholeProgramVisibility(/* WholeProgramVisibilityEnabledInLTO */ false))
1073 Index->setWithWholeProgramVisibility();
1074
1075 // FIXME: This needs linker information via a TBD new interface
1077 /*WholeProgramVisibilityEnabledInLTO=*/false,
1078 // FIXME: These need linker information via a
1079 // TBD new interface.
1080 /*DynamicExportSymbols=*/{},
1081 /*VisibleToRegularObjSymbols=*/{});
1082
1083 // Perform index-based WPD. This will return immediately if there are
1084 // no index entries in the typeIdMetadata map (e.g. if we are instead
1085 // performing IR-based WPD in hybrid regular/thin LTO mode).
1086 std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
1087 std::set<GlobalValue::GUID> ExportedGUIDs;
1088 runWholeProgramDevirtOnIndex(*Index, ExportedGUIDs, LocalWPDTargetsMap,
1089 nullptr, nullptr);
1090 GUIDPreservedSymbols.insert_range(ExportedGUIDs);
1091
1092 // Compute prevailing symbols
1094 computePrevailingCopies(*Index, PrevailingCopy);
1095
1096 // Collect the import/export lists for all modules from the call-graph in the
1097 // combined index.
1098 FunctionImporter::ImportListsTy ImportLists(ModuleCount);
1100 ComputeCrossModuleImport(*Index, ModuleToDefinedGVSummaries,
1101 IsPrevailing(PrevailingCopy), ImportLists,
1102 ExportLists);
1103
1104 // We use a std::map here to be able to have a defined ordering when
1105 // producing a hash for the cache entry.
1106 // FIXME: we should be able to compute the caching hash for the entry based
1107 // on the index, and nuke this map.
1109
1110 // Resolve prevailing symbols, this has to be computed early because it
1111 // impacts the caching.
1112 resolvePrevailingInIndex(*Index, ResolvedODR, GUIDPreservedSymbols,
1113 PrevailingCopy);
1114
1115 // Use global summary-based analysis to identify symbols that can be
1116 // internalized (because they aren't exported or preserved as per callback).
1117 // Changes are made in the index, consumed in the ThinLTO backends.
1119 IsExported(ExportLists, GUIDPreservedSymbols),
1120 LocalWPDTargetsMap);
1122 *Index, IsExported(ExportLists, GUIDPreservedSymbols),
1123 IsPrevailing(PrevailingCopy));
1124
1125 thinLTOPropagateFunctionAttrs(*Index, IsPrevailing(PrevailingCopy));
1126
1127 // Make sure that every module has an entry in the ExportLists, ImportList,
1128 // GVSummary and ResolvedODR maps to enable threaded access to these maps
1129 // below.
1130 for (auto &Module : Modules) {
1131 auto ModuleIdentifier = Module->getName();
1132 ExportLists[ModuleIdentifier];
1133 ImportLists[ModuleIdentifier];
1134 ResolvedODR[ModuleIdentifier];
1135 ModuleToDefinedGVSummaries[ModuleIdentifier];
1136 }
1137
1138 std::vector<BitcodeModule *> ModulesVec;
1139 ModulesVec.reserve(Modules.size());
1140 for (auto &Mod : Modules)
1141 ModulesVec.push_back(&Mod->getSingleBitcodeModule());
1142 std::vector<int> ModulesOrdering = lto::generateModulesOrdering(ModulesVec);
1143
1146
1147 TimeTraceScopeExit.release();
1148
1149 // Parallel optimizer + codegen
1150 {
1152 for (auto IndexCount : ModulesOrdering) {
1153 auto &Mod = Modules[IndexCount];
1154 Pool.async([&](int count) {
1155 auto ModuleIdentifier = Mod->getName();
1156 auto &ExportList = ExportLists[ModuleIdentifier];
1157
1158 auto &DefinedGVSummaries = ModuleToDefinedGVSummaries[ModuleIdentifier];
1159
1160 // The module may be cached, this helps handling it.
1161 ModuleCacheEntry CacheEntry(CacheOptions.Path, *Index, ModuleIdentifier,
1162 ImportLists[ModuleIdentifier], ExportList,
1163 ResolvedODR[ModuleIdentifier],
1164 DefinedGVSummaries, OptLevel, Freestanding,
1165 TMBuilder, MllvmArgs);
1166 auto CacheEntryPath = CacheEntry.getEntryPath();
1167
1168 {
1169 auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
1170 LLVM_DEBUG(dbgs() << "Cache " << (ErrOrBuffer ? "hit" : "miss")
1171 << " '" << CacheEntryPath << "' for buffer "
1172 << count << " " << ModuleIdentifier << "\n");
1173
1174 if (ErrOrBuffer) {
1175 // Cache Hit!
1176 if (SavedObjectsDirectoryPath.empty())
1177 ProducedBinaries[count] = std::move(ErrOrBuffer.get());
1178 else
1179 ProducedBinaryFiles[count] = writeGeneratedObject(
1180 count, CacheEntryPath, *ErrOrBuffer.get());
1181 return;
1182 }
1183 }
1184
1185 LLVMContext Context;
1186 Context.getLibraryOptions().assign(LibraryOptions);
1187 Context.setDiscardValueNames(LTODiscardValueNames);
1188 Context.enableDebugTypeODRUniquing();
1189 auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
1192 if (!DiagFileOrErr) {
1193 errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
1194 report_fatal_error("ThinLTO: Can't get an output file for the "
1195 "remarks");
1196 }
1197
1198 // Parse module now
1199 auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
1200 /*IsImporting*/ false);
1201
1202 // Save temps: original file.
1203 saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
1204
1205 auto &ImportList = ImportLists[ModuleIdentifier];
1206 // Run the main process now, and generates a binary
1208 *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
1209 ExportList, GUIDPreservedSymbols,
1210 ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
1211 DisableCodeGen, SaveTempsDir, Freestanding, OptLevel, count,
1212 DebugPassManager);
1213
1214 // Commit to the cache (if enabled)
1215 CacheEntry.write(*OutputBuffer);
1216
1217 if (SavedObjectsDirectoryPath.empty()) {
1218 // We need to generated a memory buffer for the linker.
1219 if (!CacheEntryPath.empty()) {
1220 // When cache is enabled, reload from the cache if possible.
1221 // Releasing the buffer from the heap and reloading it from the
1222 // cache file with mmap helps us to lower memory pressure.
1223 // The freed memory can be used for the next input file.
1224 // The final binary link will read from the VFS cache (hopefully!)
1225 // or from disk (if the memory pressure was too high).
1226 auto ReloadedBufferOrErr = CacheEntry.tryLoadingBuffer();
1227 if (auto EC = ReloadedBufferOrErr.getError()) {
1228 // On error, keep the preexisting buffer and print a diagnostic.
1229 errs() << "remark: can't reload cached file '" << CacheEntryPath
1230 << "': " << EC.message() << "\n";
1231 } else {
1232 OutputBuffer = std::move(*ReloadedBufferOrErr);
1233 }
1234 }
1235 ProducedBinaries[count] = std::move(OutputBuffer);
1236 return;
1237 }
1238 ProducedBinaryFiles[count] = writeGeneratedObject(
1239 count, CacheEntryPath, *OutputBuffer);
1240 }, IndexCount);
1241 }
1242 }
1243
1244 Expected<bool> PrunedOrErr =
1245 pruneCache(CacheOptions.Path, CacheOptions.Policy, ProducedBinaries);
1246 if (!PrunedOrErr) {
1247 errs() << "Error: " << toString(PrunedOrErr.takeError()) << "\n";
1248 report_fatal_error("ThinLTO: failure to prune cache");
1249 }
1250
1251 // If statistics were requested, print them out now.
1255}
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file provides a bitcode writing pass.
#define LLVM_LIFETIME_BOUND
Definition Compiler.h:464
DXIL Finalize Linkage
Provides passes for computing function attributes based on interprocedural analyses.
This file implements a simple parser to decode commandline option for remarks hotness threshold that ...
#define I(x, y, z)
Definition MD5.cpp:57
#define G(x, y, z)
Definition MD5.cpp:55
This is the interface to build a ModuleSummaryIndex for a module.
CGSCCAnalysisManager CGAM
if(auto Err=PB.parsePassPipeline(MPM, Passes)) return wrap(std MPM run * Mod
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassBuilder PB(Mod->getContext(), Machine, PassOpts->PTO, std::nullopt, &PIC)
PassInstrumentationCallbacks PIC
This header defines classes/functions to handle pass execution timing information with interfaces for...
This file provides the interface for the sampled PGO loader pass.
This file defines the scope_exit class, which executes user-defined cleanup logic at scope exit.
This header defines a class that provides bookkeeping for all standard (i.e in-tree) pass instrumenta...
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
This file contains some functions that are useful when dealing with strings.
#define LLVM_DEBUG(...)
Definition Debug.h:119
static void crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index, StringMap< lto::InputFile * > &ModuleMap, const FunctionImporter::ImportMapTy &ImportList, bool ClearDSOLocalOnDeclarations)
static void computeDeadSymbolsInIndex(ModuleSummaryIndex &Index, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols)
static StringMap< lto::InputFile * > generateModuleMap(std::vector< std::unique_ptr< lto::InputFile > > &Modules)
static void resolvePrevailingInIndex(ModuleSummaryIndex &Index, StringMap< std::map< GlobalValue::GUID, GlobalValue::LinkageTypes > > &ResolvedODR, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols, const DenseMap< GlobalValue::GUID, const GlobalValueSummary * > &PrevailingCopy)
Resolve prevailing symbols.
static const GlobalValueSummary * getFirstDefinitionForLinker(ArrayRef< std::unique_ptr< GlobalValueSummary > > GVSummaryList)
static void computePrevailingCopies(const ModuleSummaryIndex &Index, DenseMap< GlobalValue::GUID, const GlobalValueSummary * > &PrevailingCopy)
static void saveTempBitcode(const Module &TheModule, StringRef TempDir, unsigned count, StringRef Suffix)
static void verifyLoadedModule(Module &TheModule)
Verify the module and strip broken debug info.
static void addUsedSymbolToPreservedGUID(const lto::InputFile &File, DenseSet< GlobalValue::GUID > &PreservedGUID)
static std::unique_ptr< MemoryBuffer > ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index, StringMap< lto::InputFile * > &ModuleMap, TargetMachine &TM, const FunctionImporter::ImportMapTy &ImportList, const FunctionImporter::ExportSetTy &ExportList, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols, const GVSummaryMapTy &DefinedGlobals, const ThinLTOCodeGenerator::CachingOptions &CacheOptions, bool DisableCodeGen, StringRef SaveTempsDir, bool Freestanding, unsigned OptLevel, unsigned count, bool DebugPassManager)
static cl::opt< int > ThreadCount("threads", cl::init(0))
static std::unique_ptr< MemoryBuffer > codegenModule(Module &TheModule, TargetMachine &TM)
static void initTMBuilder(const cl::LibraryOptionsContext &LibraryOptions, TargetMachineBuilder &TMBuilder, const Triple &TheTriple)
static void optimizeModule(Module &TheModule, TargetMachine &TM, unsigned OptLevel, bool Freestanding, bool DebugPassManager, ModuleSummaryIndex *Index)
static void computeGUIDPreservedSymbols(const lto::InputFile &File, const StringSet<> &PreservedSymbols, const Triple &TheTriple, DenseSet< GlobalValue::GUID > &GUIDs)
static std::unique_ptr< Module > loadModuleFromInput(lto::InputFile *Input, LLVMContext &Context, bool Lazy, bool IsImporting)
static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index, bool ClearDSOLocalOnDeclarations)
The Input class is used to parse a yaml document into in-memory structs and vectors.
char * getBuffer()
Definition Utility.h:220
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
iterator find(const_arg_type_t< KeyT > Val)
Definition DenseMap.h:766
iterator end()
Definition DenseMap.h:686
Implements a dense probed hash-table based set.
Definition DenseSet.h:283
This is the base abstract class for diagnostic reporting in the backend.
Base class for error info classes.
Definition Error.h:44
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
Tagged union holding either a T or a Error.
Definition Error.h:485
Error takeError()
Take ownership of the stored error.
Definition Error.h:612
reference get()
Returns a reference to the stored T value.
Definition Error.h:582
The map maintains the list of imports.
The function importer is automatically importing function from other modules based on the provided su...
LLVM_ABI Expected< bool > importFunctions(Module &M, const ImportMapTy &ImportList)
Import functions in Module M based on the supplied import list.
DenseSet< ValueInfo > ExportSetTy
The set contains an entry for every global value that the module exports.
Function and variable summary information to aid decisions and implementation of importing.
static LLVM_ABI GUID getGUIDAssumingExternalLinkage(StringRef GlobalName)
Return a 64-bit global unique ID constructed from the name of a global symbol.
Definition Globals.cpp:80
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
static bool isAvailableExternallyLinkage(LinkageTypes Linkage)
static LLVM_ABI std::string getGlobalIdentifier(StringRef Name, GlobalValue::LinkageTypes Linkage, StringRef FileName)
Return the modified name for a global value suitable to be used as the key for a global lookup (e....
Definition Globals.cpp:234
bool isWeakForLinker() const
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition GlobalValue.h:52
@ ExternalLinkage
Externally visible function.
Definition GlobalValue.h:53
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:76
LLVM_ABI cl::LibraryOptionsContext & getLibraryOptions() const
The library options this context reads in place of their process-wide values.
LLVM_ABI void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
This interface provides simple read-only access to a block of memory, and provides simple methods for...
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Given an already-open file descriptor, read the file and return a MemoryBuffer.
StringRef getBuffer() const
Class to hold module path string table and global value map, and encapsulate methods for operating on...
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
const Triple & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition Module.h:328
LLVMContext & getContext() const
Get the global data context.
Definition Module.h:332
StringRef getName() const
Get a short "name" for the module.
Definition Module.h:316
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition Module.h:299
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition Module.cpp:672
This class provides access to building LLVM's passes.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
Tunable parameters for passes in the default pipelines.
Definition PassBuilder.h:48
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition PassBuilder.h:63
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition PassBuilder.h:59
Analysis providing profile information.
static LLVM_ABI StringRef getSampleProfileFile(const LLVMContext &C)
Return -sample-profile-file.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:28
const char * c_str()
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This class provides an interface to register all the standard pass instrumentations and manages their...
unsigned size() const
Definition StringMap.h:104
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:129
bool contains(StringRef Key) const
contains - Return true if the element is in the map, false otherwise.
Definition StringMap.h:270
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition StringMap.h:275
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition StringSet.h:27
Manages the enabling and disabling of subtarget specific features.
LLVM_ABI void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
LLVM_ABI std::string getString() const
Returns features as a string.
Analysis pass providing the TargetLibraryInfo.
Implementation of the target library information.
Provides information about what library functions are available for the current target.
Primary interface to the complete machine description for the target machine.
const Triple & getTargetTriple() const
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
TargetOptions Options
VectorLibrary VecLib
Vector math library to use.
unsigned DataSections
Emit data into separate sections.
Target - Wrapper for Target specific information.
TargetMachine * createTargetMachine(const Triple &TT, StringRef CPU, StringRef Features, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM=std::nullopt, CodeGenOptLevel OL=CodeGenOptLevel::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple.
LLVM_ABI void preserveSymbol(StringRef Name)
Adds to a list of all global symbols that must exist in the final generated code.
LLVM_ABI void run()
Process all the modules that were added to the code generator in parallel.
LLVM_ABI void crossReferenceSymbol(StringRef Name)
Adds to a list of all global symbols that are cross-referenced between ThinLTO files.
LLVM_ABI void addModule(StringRef Identifier, StringRef Data)
Add given module to the code generator.
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition ThreadPool.h:80
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition Triple.h:869
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
void assign(const LibraryOptionsContext &Other)
std::pair< iterator, bool > insert(const ValueT &V)
Definition DenseSet.h:210
void insert_range(Range &&R)
Definition DenseSet.h:236
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition DenseSet.h:188
An input file.
Definition LTO.h:116
static LLVM_ABI Expected< std::unique_ptr< InputFile > > create(MemoryBufferRef Object)
Create an InputFile.
Definition LTO.cpp:628
A raw_ostream that writes to a file descriptor.
A raw_ostream that writes to an SmallVector or SmallString.
LLVM_ABI void optimize(Module &Module)
Perform post-importing ThinLTO optimizations.
LLVM_ABI std::unique_ptr< ModuleSummaryIndex > linkCombinedIndex()
Produce the combined summary index from all the bitcode files: "thin-link".
LLVM_ABI void crossModuleImport(Module &Module, ModuleSummaryIndex &Index, const lto::InputFile &File)
Perform cross-module importing for the module identified by ModuleIdentifier.
LLVM_ABI void emitImports(Module &Module, StringRef OutputName, ModuleSummaryIndex &Index, const lto::InputFile &File)
Compute and emit the imported files for module at ModulePath.
LLVM_ABI void internalize(Module &Module, ModuleSummaryIndex &Index, const lto::InputFile &File)
Perform internalization.
LLVM_ABI void gatherImportedSummariesForModule(Module &Module, ModuleSummaryIndex &Index, ModuleToSummariesForIndexTy &ModuleToSummariesForIndex, GVSummaryPtrSet &DecSummaries, const lto::InputFile &File)
Compute the list of summaries and the subset of declaration summaries needed for importing into modul...
LLVM_ABI void promote(Module &Module, ModuleSummaryIndex &Index, const lto::InputFile &File)
Perform promotion and renaming of exported internal functions, and additionally resolve weak and link...
LLVM_ABI std::string writeGeneratedObject(int count, StringRef CacheEntryPath, const MemoryBuffer &OutputBuffer)
Write temporary object file to SavedObjectDirectoryPath, write symlink to Cache directory if needed.
Interfaces for registering analysis passes, producing common pass manager configurations,...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
ThinLTOCodeGeneratorImpl - Namespace used for ThinLTOCodeGenerator implementation details.
initializer< Ty > init(const Ty &Val)
LLVM_ABI std::optional< bool > getExplicitDataSections(const cl::LibraryOptionsContext &C)
LLVM_ABI StringLiteral getThinLTODefaultCPU(const Triple &TheTriple)
Definition LTO.cpp:1952
LLVM_ABI Expected< LLVMRemarkFileHandle > setupLLVMOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, std::optional< uint64_t > RemarksHotnessThreshold=0, int Count=-1)
Setup optimization remarks.
Definition LTO.cpp:2383
LLVM_ABI std::vector< int > generateModulesOrdering(ArrayRef< BitcodeModule * > R)
Produces a container ordering for optimal multi-threaded processing.
Definition LTO.cpp:2427
LLVM_ABI std::error_code closeFile(file_t &F)
Close the file object.
LLVM_ABI std::error_code create_hard_link(const Twine &to, const Twine &from)
Create a hard link from from to to, or return an error.
LLVM_ABI bool exists(const basic_file_status &status)
Does file exist?
Definition Path.cpp:1107
@ OF_UpdateAtime
Force files Atime to be updated on access.
Definition FileSystem.h:817
LLVM_ABI std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
LLVM_ABI Expected< file_t > openNativeFileForRead(const Twine &Name, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
LLVM_ABI std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
Definition Path.cpp:993
LLVM_ABI std::error_code copy_file(const Twine &From, const Twine &To)
Copy the contents of From to To.
Definition Path.cpp:1042
LLVM_ABI bool is_directory(const basic_file_status &status)
Does status represent a directory?
Definition Path.cpp:1122
LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition Path.cpp:467
This is an optimization pass for GlobalISel generic memory operations.
ThreadPoolStrategy heavyweight_hardware_concurrency(unsigned ThreadCount=0)
Returns a thread strategy for tasks requiring significant memory or other resources.
Definition Threading.h:167
LLVM_ABI void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition Error.cpp:61
cl::opt< std::string > RemarksFormat("lto-pass-remarks-format", cl::desc("The format used for serializing remarks (default: YAML)"), cl::value_desc("format"), cl::init("yaml"))
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1755
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr, unsigned DynamicVGPRBlockSize=0)
cl::opt< bool > LTODiscardValueNames("lto-discard-value-names", cl::desc("Strip names from Value during LTO (other than GlobalValue)."), cl::init(false), cl::Hidden)
LLVM_ABI void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
cl::opt< std::string > RemarksPasses("lto-pass-remarks-filter", cl::desc("Only record optimization remarks from passes whose " "names match the given regular expression"), cl::value_desc("regex"))
LLVM_ABI void updatePublicTypeTestCalls(Module &M, bool WholeProgramVisibilityEnabledInLTO, bool DevirtSpeculativelyInIndex=false)
Convert llvm.public.type.test calls to llvm.type.test when whole program visibility is available,...
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition Error.h:1013
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
DenseMap< GlobalValue::GUID, GlobalValueSummary * > GVSummaryMapTy
Map of global value GUID to its summary, used to identify values defined in a particular module,...
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition STLExtras.h:2224
@ O1
Optimize quickly without destroying debuggability.
@ O0
Disable as many optimizations as possible.
@ O3
Optimize for fast execution as much as possible.
@ O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
LLVM_ABI bool thinLTOPropagateFunctionAttrs(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing)
Propagate function attributes for function summaries along the index's callgraph during thinlink.
LLVM_ABI void renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, bool ClearDSOLocalOnDeclarations, SetVector< GlobalValue * > *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
LLVM_ABI ModuleSummaryIndex buildModuleSummaryIndex(const Module &M, std::function< BlockFrequencyInfo *(const Function &F)> GetBFICallback, ProfileSummaryInfo *PSI, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback=[](const Function &F) -> const StackSafetyInfo *{ return nullptr;})
Direct function to compute a ModuleSummaryIndex from a given module.
LLVM_ABI void reportAndResetTimings(raw_ostream *OutStream=nullptr)
If -time-passes has been specified, report the timings immediately and then reset the timers to zero.
LLVM_ABI bool hasWholeProgramVisibility(bool WholeProgramVisibilityEnabledInLTO)
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
LLVM_ABI void writeIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out, const ModuleToSummariesForIndexTy *ModuleToSummariesForIndex=nullptr, const GVSummaryPtrSet *DecSummaries=nullptr)
Write the specified module summary index to the given raw output stream, where it will be written in ...
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
LLVM_ABI void ComputeCrossModuleImport(const ModuleSummaryIndex &Index, const DenseMap< StringRef, GVSummaryMapTy > &ModuleToDefinedGVSummaries, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, FunctionImporter::ImportListsTy &ImportLists, DenseMap< StringRef, FunctionImporter::ExportSetTy > &ExportLists)
Compute all the imports and exports for every module in the Index.
LLVM_ABI void updateIndexWPDForExports(ModuleSummaryIndex &Summary, function_ref< bool(StringRef, ValueInfo)> isExported, std::map< ValueInfo, std::vector< VTableSlotSummary > > &LocalWPDTargetsMap, DenseSet< StringRef > *ExternallyVisibleSymbolNamesPtr=nullptr)
Call after cross-module importing to update the recorded single impl devirt target names for any loca...
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
LLVM_ABI Error runCodeGenPipeline(TargetMachine &TM, Module &M, raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS, CodeGenFileType CGFT, bool DisableVerify=true, bool DisableSimplifyLibCalls=false, const ModuleSummaryIndex *MSI=nullptr, IntrusiveRefCntPtr< vfs::FileSystem > VFS=vfs::getRealFileSystem())
cl::opt< std::string > LTOCSIRProfile("cs-profile-path", cl::desc("Context sensitive profile file path"))
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
bool timeTraceProfilerEnabled()
Is the time trace profiler enabled, i.e. initialized?
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition Debug.cpp:209
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
LLVM_ABI Error writeToOutput(StringRef OutputFileName, std::function< Error(raw_ostream &)> Write)
This helper creates an output stream and then passes it to Write.
LLVM_ABI bool AreStatisticsEnabled()
Check if statistics are enabled.
std::map< std::string, GVSummaryMapTy, std::less<> > ModuleToSummariesForIndexTy
Map of a module name to the GUIDs and summaries we will import from that module.
cl::opt< bool > RemarksWithHotness("lto-pass-remarks-with-hotness", cl::desc("With PGO, include profile count in optimization remarks"), cl::Hidden)
LLVM_ABI void timeTraceProfilerEnd()
Manually end the last time section.
cl::opt< std::string > RemarksFilename("lto-pass-remarks-output", cl::desc("Output filename for pass remarks"), cl::value_desc("filename"))
LLVM_ABI void thinLTOResolvePrevailingInIndex(const lto::Config &C, ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols)
Resolve linkage for prevailing symbols in the Index.
Definition LTO.cpp:492
cl::opt< bool > LTORunCSIRInstr("cs-profile-generate", cl::desc("Perform context sensitive PGO instrumentation"))
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
LLVM_ABI bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
@ Mod
The access may modify the value stored in memory.
Definition ModRef.h:34
LLVM_ABI void runWholeProgramDevirtOnIndex(ModuleSummaryIndex &Summary, std::set< GlobalValue::GUID > &ExportedGUIDs, std::map< ValueInfo, std::vector< VTableSlotSummary > > &LocalWPDTargetsMap, DenseSet< StringRef > *ExternallyVisibleSymbolNamesPtr, const LLVMContext *Ctx)
Perform index-based whole program devirtualization on the Summary index.
LLVM_ABI void PrintStatistics()
Print statistics to the file returned by CreateInfoOutputFile().
LLVM_ABI void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Internalize TheModule based on the information recorded in the summaries during global summary-based ...
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition STLExtras.h:2028
SingleThreadExecutor DefaultThreadPool
Definition ThreadPool.h:262
LLVM_ABI void gatherImportedSummariesForModule(StringRef ModulePath, const DenseMap< StringRef, GVSummaryMapTy > &ModuleToDefinedGVSummaries, const FunctionImporter::ImportMapTy &ImportList, ModuleToSummariesForIndexTy &ModuleToSummariesForIndex, GVSummaryPtrSet &DecSummaries)
Compute the set of summaries needed for a ThinLTO backend compilation of ModulePath.
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
cl::opt< std::optional< uint64_t >, false, remarks::HotnessThresholdParser > RemarksHotnessThreshold("lto-pass-remarks-hotness-threshold", cl::desc("Minimum profile count required for an " "optimization remark to be output." " Use 'auto' to apply the threshold from profile summary."), cl::value_desc("uint or 'auto'"), cl::init(0), cl::Hidden)
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1788
LLVM_ABI std::string computeLTOCacheKey(const lto::Config &Conf, const ModuleSummaryIndex &Index, StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList, const FunctionImporter::ExportSetTy &ExportList, const std::map< GlobalValue::GUID, GlobalValue::LinkageTypes > &ResolvedODR, const GVSummaryMapTy &DefinedGlobals, const DenseSet< GlobalValue::GUID > &CfiFunctionDefs={}, const DenseSet< GlobalValue::GUID > &CfiFunctionDecls={})
Computes a unique hash for the Module considering the current list of export/import and other global ...
Definition LTO.cpp:137
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
SmallPtrSet< GlobalValueSummary *, 0 > GVSummaryPtrSet
A set of global value summary pointers.
LLVM_ABI Expected< bool > pruneCache(StringRef Path, CachePruningPolicy Policy, const std::vector< std::unique_ptr< MemoryBuffer > > &Files={})
Perform pruning using the supplied policy, returns true if pruning occurred, i.e.
LLVM_ABI std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition Error.cpp:113
LLVM_ABI void computeDeadSymbolsWithConstProp(ModuleSummaryIndex &Index, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols, function_ref< PrevailingType(GlobalValue::GUID)> isPrevailing, bool ImportEnabled)
Compute dead symbols and run constant propagation in combined index after that.
LLVM_ABI Error write(DWPWriter &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue, Dwarf64StrOffsetsPromotion StrOffsetsOptValue, raw_pwrite_stream *OS=nullptr)
Definition DWP.cpp:746
LLVM_ABI Error EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename, const ModuleToSummariesForIndexTy &ModuleToSummariesForIndex)
Emit into OutputFilename the files module ModulePath will import from.
LLVM_ABI bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39
LLVM_ABI TimeTraceProfilerEntry * timeTraceProfilerBegin(StringRef Name, StringRef Detail)
Manually begin a time section, with the given Name and Detail.
LLVM_ABI void thinLTOInternalizeAndPromoteInIndex(ModuleSummaryIndex &Index, function_ref< bool(StringRef, ValueInfo)> isExported, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, DenseSet< StringRef > *ExternallyVisibleSymbolNamesPtr=nullptr)
Update the linkages in the given Index to mark exported values as external and non-exported values as...
Definition LTO.cpp:610
LLVM_ABI void updateVCallVisibilityInIndex(ModuleSummaryIndex &Index, bool WholeProgramVisibilityEnabledInLTO, const DenseSet< GlobalValue::GUID > &DynamicExportSymbols, const DenseSet< GlobalValue::GUID > &VisibleToRegularObjSymbols)
If whole program visibility asserted, then upgrade all public vcall visibility metadata on vtable def...
LLVM_ABI void thinLTOFinalizeInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals, bool PropagateAttrs)
Based on the information recorded in the summaries during global summary-based analysis:
A struct capturing PGO tunables.
Definition PGOOptions.h:22
A simple container for information about the supported runtime calls.
static LLVM_ABI const Target * lookupTarget(const Triple &TheTriple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
Helper to gather options relevant to the target machine creation.
LLVM_ABI std::unique_ptr< TargetMachine > create() const
Struct that holds a reference to a particular GUID in a global value summary.
LTO configuration.
Definition Config.h:44
std::vector< std::string > MAttrs
Definition Config.h:56
std::vector< std::string > MllvmArgs
Definition Config.h:57
CodeGenOptLevel CGOptLevel
Definition Config.h:68
std::string CPU
Definition Config.h:54
TargetOptions Options
Definition Config.h:55
unsigned OptLevel
Definition Config.h:70
std::optional< Reloc::Model > RelocModel
Definition Config.h:66
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.
Definition Config.h:76