27#include "llvm/Config/llvm-config.h"
67#if !defined(_MSC_VER) && !defined(__MINGW32__)
75#define DEBUG_TYPE "thinlto"
106 " to save optimized bitcode\n");
114 GVSummaryList, [](
const std::unique_ptr<GlobalValueSummary> &Summary) {
119 if (StrongDefForLinker != GVSummaryList.end())
120 return StrongDefForLinker->get();
124 GVSummaryList, [](
const std::unique_ptr<GlobalValueSummary> &Summary) {
129 if (FirstDefForLinker == GVSummaryList.end())
131 return FirstDefForLinker->get();
137static void computePrevailingCopies(
141 return GVSummaryList.size() > 1;
145 if (HasMultipleCopies(
I.second.SummaryList))
146 PrevailingCopy[
I.first] =
147 getFirstDefinitionForLinker(
I.second.SummaryList);
152generateModuleMap(std::vector<std::unique_ptr<lto::InputFile>> &Modules) {
154 for (
auto &M : Modules) {
155 LLVM_DEBUG(
dbgs() <<
"Adding module " <<
M->getName() <<
" to ModuleMap\n");
157 "Expect unique Buffer Identifier");
158 ModuleMap[
M->getName()] =
M.get();
164 bool ClearDSOLocalOnDeclarations) {
173 ThinLTODiagnosticInfo(
const Twine &DiagMsg,
181static void verifyLoadedModule(
Module &TheModule) {
182 bool BrokenDebugInfo =
false;
185 if (BrokenDebugInfo) {
187 "Invalid debug info found, debug info will be stripped",
DS_Warning));
192static std::unique_ptr<Module> loadModuleFromInput(
lto::InputFile *Input,
199 Lazy ?
Mod.getLazyModule(Context,
201 :
Mod.parseModule(Context);
204 SMDiagnostic Err = SMDiagnostic(Mod.getModuleIdentifier(),
205 SourceMgr::DK_Error, EIB.message());
206 Err.print(
"ThinLTO", errs());
211 verifyLoadedModule(*ModuleOrErr.
get());
212 return std::move(*ModuleOrErr);
219 bool ClearDSOLocalOnDeclarations) {
222 return loadModuleFromInput(Input, TheModule.
getContext(),
230 SMDiagnostic Err = SMDiagnostic(TheModule.getModuleIdentifier(),
231 SourceMgr::DK_Error, EIB.message());
232 Err.print(
"ThinLTO", errs());
237 verifyLoadedModule(TheModule);
241 unsigned OptLevel,
bool Freestanding,
243 std::optional<PGOOptions> PGOOpt;
257 std::unique_ptr<TargetLibraryInfoImpl> TLII(
260 TLII->disableAllFunctions();
299 for (
const auto &
Sym :
File.symbols()) {
306static void computeGUIDPreservedSymbols(
const lto::InputFile &File,
312 for (
const auto &
Sym :
File.symbols()) {
322 const Triple &TheTriple) {
325 GUIDPreservedSymbols);
326 return GUIDPreservedSymbols;
329std::unique_ptr<MemoryBuffer> codegenModule(
Module &TheModule,
339 if (
TM.addPassesToEmitFile(PM,
OS,
nullptr, CodeGenFileType::ObjectFile,
346 return std::make_unique<SmallVectorMemoryBuffer>(
351class ModuleCacheEntry {
362 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
365 if (CachePath.
empty())
368 if (!
Index.modulePaths().count(ModuleID))
387 ResolvedODR, DefinedGVSummaries);
395 StringRef getEntryPath() {
return EntryPath; }
399 if (EntryPath.
empty())
400 return std::error_code();
407 *FDOrErr, EntryPath, -1,
false);
414 if (EntryPath.
empty())
428static std::unique_ptr<MemoryBuffer>
436 bool DisableCodeGen,
StringRef SaveTempsDir,
437 bool Freestanding,
unsigned OptLevel,
unsigned count,
438 bool DebugPassManager) {
440 bool SingleModule = (ModuleMap.
size() == 1);
444 bool ClearDSOLocalOnDeclarations =
445 TM.getTargetTriple().isOSBinFormatELF() &&
450 promoteModule(TheModule,
Index, ClearDSOLocalOnDeclarations);
456 saveTempBitcode(TheModule, SaveTempsDir,
count,
".1.promoted.bc");
461 if (!ExportList.
empty() || !GUIDPreservedSymbols.
empty()) {
467 saveTempBitcode(TheModule, SaveTempsDir,
count,
".2.internalized.bc");
470 crossImportIntoModule(TheModule,
Index, ModuleMap, ImportList,
471 ClearDSOLocalOnDeclarations);
480 saveTempBitcode(TheModule, SaveTempsDir,
count,
".3.imported.bc");
482 optimizeModule(TheModule, TM, OptLevel, Freestanding, DebugPassManager,
485 saveTempBitcode(TheModule, SaveTempsDir,
count,
".4.opt.bc");
487 if (DisableCodeGen) {
496 return std::make_unique<SmallVectorMemoryBuffer>(
500 return codegenModule(TheModule, TM);
508static void resolvePrevailingInIndex(
510 StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
517 const auto &Prevailing = PrevailingCopy.
find(GUID);
519 if (Prevailing == PrevailingCopy.
end())
521 return Prevailing->second == S;
524 auto recordNewLinkage = [&](
StringRef ModuleIdentifier,
527 ResolvedODR[ModuleIdentifier][
GUID] = NewLinkage;
533 GUIDPreservedSymbols);
538 const Triple &TheTriple) {
539 if (TMBuilder.
MCpu.empty())
541 TMBuilder.
TheTriple = std::move(TheTriple);
552 toString(InputOrError.takeError()));
554 auto TripleStr = (*InputOrError)->getTargetTriple();
555 Triple TheTriple(TripleStr);
558 initTMBuilder(TMBuilder,
Triple(TheTriple));
559 else if (TMBuilder.
TheTriple != TheTriple) {
566 Modules.emplace_back(std::move(*InputOrError));
592 std::string FeatureStr = Features.
getString();
594 std::unique_ptr<TargetMachine> TM(
597 assert(TM &&
"Cannot create target machine");
607 std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
608 std::make_unique<ModuleSummaryIndex>(
false);
609 for (
auto &
Mod : Modules) {
610 auto &M =
Mod->getSingleBitcodeModule();
611 if (
Error Err = M.readSummary(*CombinedIndex,
Mod->getName())) {
614 std::move(Err),
errs(),
615 "error: can't create module summary index for buffer: ");
619 return CombinedIndex;
630 : ExportLists(ExportLists), GUIDPreservedSymbols(GUIDPreservedSymbols) {}
633 const auto &ExportList = ExportLists.
find(ModuleIdentifier);
634 return (ExportList != ExportLists.
end() && ExportList->second.
count(VI)) ||
635 GUIDPreservedSymbols.
count(VI.getGUID());
643 : PrevailingCopy(PrevailingCopy) {}
646 const auto &Prevailing = PrevailingCopy.
find(GUID);
648 if (Prevailing == PrevailingCopy.
end())
650 return Prevailing->second == S;
674 auto ModuleCount =
Index.modulePaths().size();
679 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
682 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
686 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
693 computePrevailingCopies(
Index, PrevailingCopy);
699 IsPrevailing(PrevailingCopy), ImportLists,
704 resolvePrevailingInIndex(
Index, ResolvedODR, GUIDPreservedSymbols,
708 ModuleToDefinedGVSummaries[ModuleIdentifier],
714 Index, IsExported(ExportLists, GUIDPreservedSymbols),
715 IsPrevailing(PrevailingCopy));
718 promoteModule(TheModule,
Index,
false);
727 auto ModuleMap = generateModuleMap(Modules);
728 auto ModuleCount =
Index.modulePaths().size();
732 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
735 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
738 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
745 computePrevailingCopies(
Index, PrevailingCopy);
751 IsPrevailing(PrevailingCopy), ImportLists,
756 crossImportIntoModule(TheModule,
Index, ModuleMap, ImportList,
765 std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
767 auto ModuleCount =
Index.modulePaths().size();
772 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
775 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
778 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
785 computePrevailingCopies(
Index, PrevailingCopy);
791 IsPrevailing(PrevailingCopy), ImportLists,
795 ModuleIdentifier, ModuleToDefinedGVSummaries,
796 ImportLists[ModuleIdentifier], ModuleToSummariesForIndex, DecSummaries);
805 auto ModuleCount =
Index.modulePaths().size();
810 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
813 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
816 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
823 computePrevailingCopies(
Index, PrevailingCopy);
829 IsPrevailing(PrevailingCopy), ImportLists,
836 std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
838 ModuleIdentifier, ModuleToDefinedGVSummaries,
839 ImportLists[ModuleIdentifier], ModuleToSummariesForIndex, DecSummaries);
843 ModuleToSummariesForIndex)))
845 " to save imports lists\n");
856 auto ModuleCount =
Index.modulePaths().size();
860 auto GUIDPreservedSymbols =
861 computeGUIDPreservedSymbols(File, PreservedSymbols, TMBuilder.
TheTriple);
863 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
867 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
874 computePrevailingCopies(
Index, PrevailingCopy);
880 IsPrevailing(PrevailingCopy), ImportLists,
882 auto &ExportList = ExportLists[ModuleIdentifier];
886 if (ExportList.
empty() && GUIDPreservedSymbols.
empty())
891 resolvePrevailingInIndex(
Index, ResolvedODR, GUIDPreservedSymbols,
897 Index, IsExported(ExportLists, GUIDPreservedSymbols),
898 IsPrevailing(PrevailingCopy));
901 promoteModule(TheModule,
Index,
false);
905 ModuleToDefinedGVSummaries[ModuleIdentifier],
909 ModuleToDefinedGVSummaries[ModuleIdentifier]);
919 optimizeModule(TheModule, *TMBuilder.
create(), OptLevel, Freestanding,
920 DebugPassManager,
nullptr);
932 Twine(
count) +
"." + ArchName +
".thinlto.o");
938 if (!CacheEntryPath.
empty()) {
942 return std::string(OutputPath);
946 return std::string(OutputPath);
950 errs() <<
"remark: can't link or copy from cached entry '" << CacheEntryPath
951 <<
"' to '" << OutputPath <<
"'\n";
959 return std::string(OutputPath);
970 assert(ProducedBinaries.empty() &&
"The generator should not be reused");
971 if (SavedObjectsDirectoryPath.empty())
972 ProducedBinaries.resize(Modules.size());
979 ProducedBinaryFiles.resize(Modules.size());
986 for (
auto &
Mod : Modules) {
992 auto TheModule = loadModuleFromInput(
Mod.get(), Context,
false,
996 auto OutputBuffer = codegenModule(*TheModule, *TMBuilder.
create());
997 if (SavedObjectsDirectoryPath.empty())
998 ProducedBinaries[
count] = std::move(OutputBuffer);
1000 ProducedBinaryFiles[
count] =
1012 if (!SaveTempsDir.
empty()) {
1013 auto SaveTempPath = SaveTempsDir +
"index.bc";
1018 " to save optimized bitcode\n");
1024 auto ModuleMap = generateModuleMap(Modules);
1025 auto ModuleCount = Modules.size();
1029 Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1034 for (
const auto &M : Modules)
1035 computeGUIDPreservedSymbols(*M, PreservedSymbols, TMBuilder.
TheTriple,
1036 GUIDPreservedSymbols);
1039 for (
const auto &M : Modules)
1040 addUsedSymbolToPreservedGUID(*M, GUIDPreservedSymbols);
1052 Index->setWithWholeProgramVisibility();
1065 std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
1066 std::set<GlobalValue::GUID> ExportedGUIDs;
1068 for (
auto GUID : ExportedGUIDs)
1069 GUIDPreservedSymbols.
insert(GUID);
1073 computePrevailingCopies(*
Index, PrevailingCopy);
1080 IsPrevailing(PrevailingCopy), ImportLists,
1091 resolvePrevailingInIndex(*
Index, ResolvedODR, GUIDPreservedSymbols,
1098 IsExported(ExportLists, GUIDPreservedSymbols),
1099 LocalWPDTargetsMap);
1101 *
Index, IsExported(ExportLists, GUIDPreservedSymbols),
1102 IsPrevailing(PrevailingCopy));
1109 for (
auto &
Module : Modules) {
1111 ExportLists[ModuleIdentifier];
1112 ImportLists[ModuleIdentifier];
1113 ResolvedODR[ModuleIdentifier];
1114 ModuleToDefinedGVSummaries[ModuleIdentifier];
1117 std::vector<BitcodeModule *> ModulesVec;
1118 ModulesVec.
reserve(Modules.size());
1119 for (
auto &
Mod : Modules)
1120 ModulesVec.push_back(&
Mod->getSingleBitcodeModule());
1126 TimeTraceScopeExit.release();
1131 for (
auto IndexCount : ModulesOrdering) {
1132 auto &
Mod = Modules[IndexCount];
1134 auto ModuleIdentifier =
Mod->getName();
1135 auto &ExportList = ExportLists[ModuleIdentifier];
1137 auto &DefinedGVSummaries = ModuleToDefinedGVSummaries[ModuleIdentifier];
1140 ModuleCacheEntry CacheEntry(CacheOptions.
Path, *
Index, ModuleIdentifier,
1141 ImportLists[ModuleIdentifier], ExportList,
1142 ResolvedODR[ModuleIdentifier],
1143 DefinedGVSummaries, OptLevel, Freestanding,
1145 auto CacheEntryPath = CacheEntry.getEntryPath();
1148 auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
1150 <<
" '" << CacheEntryPath <<
"' for buffer "
1151 <<
count <<
" " << ModuleIdentifier <<
"\n");
1155 if (SavedObjectsDirectoryPath.empty())
1156 ProducedBinaries[
count] = std::move(ErrOrBuffer.get());
1159 count, CacheEntryPath, *ErrOrBuffer.get());
1170 if (!DiagFileOrErr) {
1171 errs() <<
"Error: " <<
toString(DiagFileOrErr.takeError()) <<
"\n";
1177 auto TheModule = loadModuleFromInput(
Mod.get(), Context,
false,
1181 saveTempBitcode(*TheModule, SaveTempsDir,
count,
".0.original.bc");
1183 auto &ImportList = ImportLists[ModuleIdentifier];
1185 auto OutputBuffer = ProcessThinLTOModule(
1186 *TheModule, *
Index, ModuleMap, *TMBuilder.
create(), ImportList,
1187 ExportList, GUIDPreservedSymbols,
1188 ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
1189 DisableCodeGen, SaveTempsDir, Freestanding, OptLevel,
count,
1193 CacheEntry.write(*OutputBuffer);
1195 if (SavedObjectsDirectoryPath.empty()) {
1197 if (!CacheEntryPath.empty()) {
1204 auto ReloadedBufferOrErr = CacheEntry.tryLoadingBuffer();
1205 if (
auto EC = ReloadedBufferOrErr.getError()) {
1207 errs() <<
"remark: can't reload cached file '" << CacheEntryPath
1208 <<
"': " << EC.message() <<
"\n";
1210 OutputBuffer = std::move(*ReloadedBufferOrErr);
1213 ProducedBinaries[
count] = std::move(OutputBuffer);
1217 count, CacheEntryPath, *OutputBuffer);
This file provides a bitcode writing pass.
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 ...
static const char * PreservedSymbols[]
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
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
This header defines classes/functions to handle pass execution timing information with interfaces for...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...
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...
static void computeDeadSymbolsInIndex(ModuleSummaryIndex &Index, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols)
A container for analyses that lazily runs them and caches their results.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
iterator find(const_arg_type_t< KeyT > Val)
void reserve(size_type NumEntries)
Grow the densemap so that it can contain at least NumEntries items before resizing again.
Implements a dense probed hash-table based set.
This is the base abstract class for diagnostic reporting in the backend.
virtual void print(DiagnosticPrinter &DP) const =0
Print using the given DP a user-friendly message.
Interface for custom diagnostic printing.
Base class for error info classes.
Represents either an error or a value T.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
reference get()
Returns a reference to the stored T value.
The function importer is automatically importing function from other modules based on the provided su...
Function and variable summary information to aid decisions and implementation of importing.
static bool isAvailableExternallyLinkage(LinkageTypes Linkage)
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
bool isWeakForLinker() const
std::string getGlobalIdentifier() const
Return the modified name for this global value suitable to be used as the key for a global lookup (e....
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ ExternalLinkage
Externally visible function.
This is an important class for using LLVM in a threaded context.
void enableDebugTypeODRUniquing()
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
void setDiscardValueNames(bool Discard)
Set the Context runtime configuration to discard all value name (but GlobalValue).
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.
LLVMContext & getContext() const
Get the global data context.
StringRef getName() const
Get a short "name" for the module.
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
This class provides access to building LLVM's passes.
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build a ThinLTO default optimization pipeline to a pass manager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis 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.
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Analysis providing profile information.
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
A non-threaded implementation.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
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...
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
bool contains(StringRef Key) const
contains - Return true if the element is in the map, false otherwise.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
StringSet - A wrapper for StringMap that provides set-like functionality.
std::pair< typename Base::iterator, bool > insert(StringRef key)
Manages the enabling and disabling of subtarget specific features.
void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
std::string getString() const
Returns features as a string.
Analysis pass providing the TargetLibraryInfo.
Implementation of the target library information.
Primary interface to the complete machine description for the target machine.
Target - Wrapper for Target specific information.
TargetMachine * createTargetMachine(StringRef 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.
void preserveSymbol(StringRef Name)
Adds to a list of all global symbols that must exist in the final generated code.
void run()
Process all the modules that were added to the code generator in parallel.
void crossReferenceSymbol(StringRef Name)
Adds to a list of all global symbols that are cross-referenced between ThinLTO files.
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.
Triple - Helper class for working with autoconf configuration names.
const std::string & str() const
std::string merge(const Triple &Other) const
Merge target triples.
StringRef getArchName() const
Get the architecture (first) component of the triple.
bool isCompatibleWith(const Triple &Other) const
Test whether target triples are compatible.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
std::pair< iterator, bool > insert(const ValueT &V)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
PassManager manages ModulePassManagers.
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
A raw_ostream that writes to a file descriptor.
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an SmallVector or SmallString.
void optimize(Module &Module)
Perform post-importing ThinLTO optimizations.
std::unique_ptr< ModuleSummaryIndex > linkCombinedIndex()
Produce the combined summary index from all the bitcode files: "thin-link".
void crossModuleImport(Module &Module, ModuleSummaryIndex &Index, const lto::InputFile &File)
Perform cross-module importing for the module identified by ModuleIdentifier.
void gatherImportedSummariesForModule(Module &Module, ModuleSummaryIndex &Index, std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex, GVSummaryPtrSet &DecSummaries, const lto::InputFile &File)
Compute the list of summaries and the subset of declaration summaries needed for importing into modul...
void emitImports(Module &Module, StringRef OutputName, ModuleSummaryIndex &Index, const lto::InputFile &File)
Compute and emit the imported files for module at ModulePath.
void internalize(Module &Module, ModuleSummaryIndex &Index, const lto::InputFile &File)
Perform internalization.
void promote(Module &Module, ModuleSummaryIndex &Index, const lto::InputFile &File)
Perform promotion and renaming of exported internal functions, and additionally resolve weak and link...
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.
initializer< Ty > init(const Ty &Val)
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
Linkage
Describes symbol linkage. This can be used to resolve definition clashes.
StringLiteral getThinLTODefaultCPU(const Triple &TheTriple)
std::vector< int > generateModulesOrdering(ArrayRef< BitcodeModule * > R)
Produces a container ordering for optimal multi-threaded processing.
Expected< std::unique_ptr< ToolOutputFile > > setupLLVMOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, std::optional< uint64_t > RemarksHotnessThreshold=0, int Count=-1)
Setup optimization remarks.
std::error_code closeFile(file_t &F)
Close the file object.
bool exists(const basic_file_status &status)
Does file exist?
@ OF_UpdateAtime
Force files Atime to be updated on access.
std::error_code create_hard_link(const Twine &to, const Twine &from)
Create a hard link from from to to, or return an error.
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
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.
std::error_code copy_file(const Twine &From, const Twine &To)
Copy the contents of From to To.
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.
bool is_directory(const basic_file_status &status)
Does status represent a directory?
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
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.
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
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.
void gatherImportedSummariesForModule(StringRef ModulePath, const DenseMap< StringRef, GVSummaryMapTy > &ModuleToDefinedGVSummaries, const FunctionImporter::ImportMapTy &ImportList, std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex, GVSummaryPtrSet &DecSummaries)
Compute the set of summaries needed for a ThinLTO backend compilation of ModulePath.
void ComputeCrossModuleImport(const ModuleSummaryIndex &Index, const DenseMap< StringRef, GVSummaryMapTy > &ModuleToDefinedGVSummaries, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, DenseMap< StringRef, FunctionImporter::ImportMapTy > &ImportLists, DenseMap< StringRef, FunctionImporter::ExportSetTy > &ExportLists)
Compute all the imports and exports for every module in the Index.
cl::opt< bool > LTODiscardValueNames("lto-discard-value-names", cl::desc("Strip names from Value during LTO (other than GlobalValue)."), cl::init(false), cl::Hidden)
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.
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
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"))
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::error_code EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename, const std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex)
Emit into OutputFilename the files module ModulePath will import from.
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.
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.
void reportAndResetTimings(raw_ostream *OutStream=nullptr)
If -time-passes has been specified, report the timings immediately and then reset the timers to zero.
bool hasWholeProgramVisibility(bool WholeProgramVisibilityEnabledInLTO)
bool 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...
void thinLTOInternalizeAndPromoteInIndex(ModuleSummaryIndex &Index, function_ref< bool(StringRef, ValueInfo)> isExported, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing)
Update the linkages in the given Index to mark exported values as external and non-exported values as...
void updatePublicTypeTestCalls(Module &M, bool WholeProgramVisibilityEnabledInLTO)
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)
void writeIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex=nullptr, const GVSummaryPtrSet *DecSummaries=nullptr)
Write the specified module summary index to the given raw output stream, where it will be written in ...
bool timeTraceProfilerEnabled()
Is the time trace profiler enabled, i.e. initialized?
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Error writeToOutput(StringRef OutputFileName, std::function< Error(raw_ostream &)> Write)
This helper creates an output stream and then passes it to Write.
bool AreStatisticsEnabled()
Check if statistics are enabled.
cl::opt< bool > RemarksWithHotness("lto-pass-remarks-with-hotness", cl::desc("With PGO, include profile count in optimization remarks"), cl::Hidden)
void computeSyntheticCounts(ModuleSummaryIndex &Index)
Compute synthetic function entry counts.
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"))
void updateIndexWPDForExports(ModuleSummaryIndex &Summary, function_ref< bool(StringRef, ValueInfo)> isExported, std::map< ValueInfo, std::vector< VTableSlotSummary > > &LocalWPDTargetsMap)
Call after cross-module importing to update the recorded single impl devirt target names for any loca...
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.
std::vector< std::unique_ptr< GlobalValueSummary > > GlobalValueSummaryList
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
@ Mod
The access may modify the value stored in memory.
void PrintStatistics()
Print statistics to the file returned by CreateInfoOutputFile().
void runWholeProgramDevirtOnIndex(ModuleSummaryIndex &Summary, std::set< GlobalValue::GUID > &ExportedGUIDs, std::map< ValueInfo, std::vector< VTableSlotSummary > > &LocalWPDTargetsMap)
Perform index-based whole program devirtualization on the Summary index.
bool pruneCache(StringRef Path, CachePruningPolicy Policy, const std::vector< std::unique_ptr< MemoryBuffer > > &Files={})
Peform pruning using the supplied policy, returns true if pruning occurred, i.e.
void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Internalize TheModule based on the information recorded in the summaries during global summary-based ...
std::unordered_set< GlobalValueSummary * > GVSummaryPtrSet
A set of global value summary pointers.
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...
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.
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 ...
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
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.
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
TimeTraceProfilerEntry * timeTraceProfilerBegin(StringRef Name, StringRef Detail)
Manually begin a time section, with the given Name and Detail.
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...
void thinLTOFinalizeInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals, bool PropagateAttrs)
Based on the information recorded in the summaries during global summary-based analysis:
Helper to gather options relevant to the target machine creation.
std::unique_ptr< TargetMachine > create() const
CodeGenOptLevel CGOptLevel
std::optional< Reloc::Model > RelocModel
static const Target * lookupTarget(StringRef Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
CachePruningPolicy Policy
Struct that holds a reference to a particular GUID in a global value summary.
std::vector< std::string > MAttrs
CodeGenOptLevel CGOptLevel
std::optional< Reloc::Model > RelocModel
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.