27#include "llvm/Config/llvm-config.h"
66#if !defined(_MSC_VER) && !defined(__MINGW32__)
74#define DEBUG_TYPE "thinlto"
105 " to save optimized bitcode\n");
113 GVSummaryList, [](
const std::unique_ptr<GlobalValueSummary> &Summary) {
118 if (StrongDefForLinker != GVSummaryList.end())
119 return StrongDefForLinker->get();
123 GVSummaryList, [](
const std::unique_ptr<GlobalValueSummary> &Summary) {
128 if (FirstDefForLinker == GVSummaryList.end())
130 return FirstDefForLinker->get();
136static void computePrevailingCopies(
140 return GVSummaryList.size() > 1;
144 if (HasMultipleCopies(
I.second.SummaryList))
145 PrevailingCopy[
I.first] =
146 getFirstDefinitionForLinker(
I.second.SummaryList);
151generateModuleMap(std::vector<std::unique_ptr<lto::InputFile>> &Modules) {
153 for (
auto &M : Modules) {
154 LLVM_DEBUG(
dbgs() <<
"Adding module " <<
M->getName() <<
" to ModuleMap\n");
156 "Expect unique Buffer Identifier");
157 ModuleMap[
M->getName()] =
M.get();
163 bool ClearDSOLocalOnDeclarations) {
172 ThinLTODiagnosticInfo(
const Twine &DiagMsg,
180static void verifyLoadedModule(
Module &TheModule) {
181 bool BrokenDebugInfo =
false;
184 if (BrokenDebugInfo) {
186 "Invalid debug info found, debug info will be stripped",
DS_Warning));
191static std::unique_ptr<Module> loadModuleFromInput(
lto::InputFile *Input,
198 Lazy ?
Mod.getLazyModule(Context,
200 :
Mod.parseModule(Context);
203 SMDiagnostic Err = SMDiagnostic(Mod.getModuleIdentifier(),
204 SourceMgr::DK_Error, EIB.message());
205 Err.print(
"ThinLTO", errs());
210 verifyLoadedModule(*ModuleOrErr.
get());
211 return std::move(*ModuleOrErr);
218 bool ClearDSOLocalOnDeclarations) {
221 return loadModuleFromInput(Input, TheModule.
getContext(),
229 SMDiagnostic Err = SMDiagnostic(TheModule.getModuleIdentifier(),
230 SourceMgr::DK_Error, EIB.message());
231 Err.print(
"ThinLTO", errs());
236 verifyLoadedModule(TheModule);
240 unsigned OptLevel,
bool Freestanding,
242 std::optional<PGOOptions> PGOOpt;
256 std::unique_ptr<TargetLibraryInfoImpl> TLII(
259 TLII->disableAllFunctions();
298 for (
const auto &
Sym :
File.symbols()) {
305static void computeGUIDPreservedSymbols(
const lto::InputFile &File,
311 for (
const auto &
Sym :
File.symbols()) {
321 const Triple &TheTriple) {
324 GUIDPreservedSymbols);
325 return GUIDPreservedSymbols;
328std::unique_ptr<MemoryBuffer> codegenModule(
Module &TheModule,
342 if (
TM.addPassesToEmitFile(PM,
OS,
nullptr, CodeGenFileType::ObjectFile,
349 return std::make_unique<SmallVectorMemoryBuffer>(
354class ModuleCacheEntry {
365 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
368 if (CachePath.
empty())
371 if (!
Index.modulePaths().count(ModuleID))
390 ResolvedODR, DefinedGVSummaries);
398 StringRef getEntryPath() {
return EntryPath; }
402 if (EntryPath.
empty())
403 return std::error_code();
410 *FDOrErr, EntryPath, -1,
false);
417 if (EntryPath.
empty())
431static std::unique_ptr<MemoryBuffer>
439 bool DisableCodeGen,
StringRef SaveTempsDir,
440 bool Freestanding,
unsigned OptLevel,
unsigned count,
441 bool DebugPassManager) {
443 bool SingleModule = (ModuleMap.
size() == 1);
447 bool ClearDSOLocalOnDeclarations =
448 TM.getTargetTriple().isOSBinFormatELF() &&
453 promoteModule(TheModule,
Index, ClearDSOLocalOnDeclarations);
459 saveTempBitcode(TheModule, SaveTempsDir,
count,
".1.promoted.bc");
464 if (!ExportList.
empty() || !GUIDPreservedSymbols.
empty()) {
470 saveTempBitcode(TheModule, SaveTempsDir,
count,
".2.internalized.bc");
473 crossImportIntoModule(TheModule,
Index, ModuleMap, ImportList,
474 ClearDSOLocalOnDeclarations);
483 saveTempBitcode(TheModule, SaveTempsDir,
count,
".3.imported.bc");
485 optimizeModule(TheModule,
TM, OptLevel, Freestanding, DebugPassManager,
488 saveTempBitcode(TheModule, SaveTempsDir,
count,
".4.opt.bc");
490 if (DisableCodeGen) {
499 return std::make_unique<SmallVectorMemoryBuffer>(
503 return codegenModule(TheModule,
TM);
511static void resolvePrevailingInIndex(
513 StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>>
520 const auto &Prevailing = PrevailingCopy.
find(GUID);
522 if (Prevailing == PrevailingCopy.
end())
524 return Prevailing->second == S;
527 auto recordNewLinkage = [&](
StringRef ModuleIdentifier,
530 ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
536 GUIDPreservedSymbols);
541 const Triple &TheTriple) {
542 if (TMBuilder.
MCpu.empty())
544 TMBuilder.
TheTriple = std::move(TheTriple);
555 toString(InputOrError.takeError()));
557 auto TripleStr = (*InputOrError)->getTargetTriple();
558 Triple TheTriple(TripleStr);
561 initTMBuilder(TMBuilder,
Triple(TheTriple));
562 else if (TMBuilder.
TheTriple != TheTriple) {
569 Modules.emplace_back(std::move(*InputOrError));
595 std::string FeatureStr = Features.
getString();
597 std::unique_ptr<TargetMachine>
TM(
600 assert(
TM &&
"Cannot create target machine");
610 std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
611 std::make_unique<ModuleSummaryIndex>(
false);
612 for (
auto &
Mod : Modules) {
613 auto &M =
Mod->getSingleBitcodeModule();
614 if (
Error Err = M.readSummary(*CombinedIndex,
Mod->getName())) {
617 std::move(Err),
errs(),
618 "error: can't create module summary index for buffer: ");
622 return CombinedIndex;
633 : ExportLists(ExportLists), GUIDPreservedSymbols(GUIDPreservedSymbols) {}
636 const auto &ExportList = ExportLists.
find(ModuleIdentifier);
637 return (ExportList != ExportLists.
end() && ExportList->second.
count(VI)) ||
638 GUIDPreservedSymbols.
count(VI.getGUID());
646 : PrevailingCopy(PrevailingCopy) {}
649 const auto &Prevailing = PrevailingCopy.
find(GUID);
651 if (Prevailing == PrevailingCopy.
end())
653 return Prevailing->second == S;
677 auto ModuleCount =
Index.modulePaths().size();
682 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
685 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
689 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
696 computePrevailingCopies(
Index, PrevailingCopy);
702 IsPrevailing(PrevailingCopy), ImportLists,
707 resolvePrevailingInIndex(
Index, ResolvedODR, GUIDPreservedSymbols,
711 ModuleToDefinedGVSummaries[ModuleIdentifier],
717 Index, IsExported(ExportLists, GUIDPreservedSymbols),
718 IsPrevailing(PrevailingCopy));
721 promoteModule(TheModule,
Index,
false);
730 auto ModuleMap = generateModuleMap(Modules);
731 auto ModuleCount =
Index.modulePaths().size();
735 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
738 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
741 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
748 computePrevailingCopies(
Index, PrevailingCopy);
754 IsPrevailing(PrevailingCopy), ImportLists,
759 crossImportIntoModule(TheModule,
Index, ModuleMap, ImportList,
768 std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
770 auto ModuleCount =
Index.modulePaths().size();
775 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
778 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
781 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
788 computePrevailingCopies(
Index, PrevailingCopy);
794 IsPrevailing(PrevailingCopy), ImportLists,
798 ModuleIdentifier, ModuleToDefinedGVSummaries,
799 ImportLists[ModuleIdentifier], ModuleToSummariesForIndex);
808 auto ModuleCount =
Index.modulePaths().size();
813 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
816 auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
819 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
826 computePrevailingCopies(
Index, PrevailingCopy);
832 IsPrevailing(PrevailingCopy), ImportLists,
835 std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
837 ModuleIdentifier, ModuleToDefinedGVSummaries,
838 ImportLists[ModuleIdentifier], ModuleToSummariesForIndex);
842 ModuleToSummariesForIndex)))
844 " to save imports lists\n");
855 auto ModuleCount =
Index.modulePaths().size();
859 auto GUIDPreservedSymbols =
860 computeGUIDPreservedSymbols(File, PreservedSymbols, TMBuilder.
TheTriple);
862 addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
866 Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
873 computePrevailingCopies(
Index, PrevailingCopy);
879 IsPrevailing(PrevailingCopy), ImportLists,
881 auto &ExportList = ExportLists[ModuleIdentifier];
885 if (ExportList.
empty() && GUIDPreservedSymbols.
empty())
890 resolvePrevailingInIndex(
Index, ResolvedODR, GUIDPreservedSymbols,
896 Index, IsExported(ExportLists, GUIDPreservedSymbols),
897 IsPrevailing(PrevailingCopy));
900 promoteModule(TheModule,
Index,
false);
904 ModuleToDefinedGVSummaries[ModuleIdentifier],
908 ModuleToDefinedGVSummaries[ModuleIdentifier]);
918 optimizeModule(TheModule, *TMBuilder.
create(), OptLevel, Freestanding,
919 DebugPassManager,
nullptr);
931 Twine(
count) +
"." + ArchName +
".thinlto.o");
937 if (!CacheEntryPath.
empty()) {
941 return std::string(OutputPath);
945 return std::string(OutputPath);
949 errs() <<
"remark: can't link or copy from cached entry '" << CacheEntryPath
950 <<
"' to '" << OutputPath <<
"'\n";
958 return std::string(OutputPath);
969 assert(ProducedBinaries.empty() &&
"The generator should not be reused");
970 if (SavedObjectsDirectoryPath.empty())
971 ProducedBinaries.resize(Modules.size());
978 ProducedBinaryFiles.resize(Modules.size());
985 for (
auto &
Mod : Modules) {
991 auto TheModule = loadModuleFromInput(
Mod.get(),
Context,
false,
995 auto OutputBuffer = codegenModule(*TheModule, *TMBuilder.
create());
996 if (SavedObjectsDirectoryPath.empty())
997 ProducedBinaries[
count] = std::move(OutputBuffer);
999 ProducedBinaryFiles[
count] =
1011 if (!SaveTempsDir.
empty()) {
1012 auto SaveTempPath = SaveTempsDir +
"index.bc";
1017 " to save optimized bitcode\n");
1023 auto ModuleMap = generateModuleMap(Modules);
1024 auto ModuleCount = Modules.size();
1028 Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1033 for (
const auto &M : Modules)
1034 computeGUIDPreservedSymbols(*M, PreservedSymbols, TMBuilder.
TheTriple,
1035 GUIDPreservedSymbols);
1038 for (
const auto &M : Modules)
1039 addUsedSymbolToPreservedGUID(*M, GUIDPreservedSymbols);
1051 Index->setWithWholeProgramVisibility();
1064 std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
1065 std::set<GlobalValue::GUID> ExportedGUIDs;
1067 for (
auto GUID : ExportedGUIDs)
1068 GUIDPreservedSymbols.
insert(GUID);
1072 computePrevailingCopies(*
Index, PrevailingCopy);
1079 IsPrevailing(PrevailingCopy), ImportLists,
1090 resolvePrevailingInIndex(*
Index, ResolvedODR, GUIDPreservedSymbols,
1097 IsExported(ExportLists, GUIDPreservedSymbols),
1098 LocalWPDTargetsMap);
1100 *
Index, IsExported(ExportLists, GUIDPreservedSymbols),
1101 IsPrevailing(PrevailingCopy));
1108 for (
auto &
Module : Modules) {
1110 ExportLists[ModuleIdentifier];
1111 ImportLists[ModuleIdentifier];
1112 ResolvedODR[ModuleIdentifier];
1113 ModuleToDefinedGVSummaries[ModuleIdentifier];
1116 std::vector<BitcodeModule *> ModulesVec;
1117 ModulesVec.
reserve(Modules.size());
1118 for (
auto &
Mod : Modules)
1119 ModulesVec.push_back(&
Mod->getSingleBitcodeModule());
1125 TimeTraceScopeExit.release();
1130 for (
auto IndexCount : ModulesOrdering) {
1131 auto &
Mod = Modules[IndexCount];
1133 auto ModuleIdentifier =
Mod->getName();
1134 auto &ExportList = ExportLists[ModuleIdentifier];
1136 auto &DefinedGVSummaries = ModuleToDefinedGVSummaries[ModuleIdentifier];
1139 ModuleCacheEntry CacheEntry(CacheOptions.
Path, *
Index, ModuleIdentifier,
1140 ImportLists[ModuleIdentifier], ExportList,
1141 ResolvedODR[ModuleIdentifier],
1142 DefinedGVSummaries, OptLevel, Freestanding,
1144 auto CacheEntryPath = CacheEntry.getEntryPath();
1147 auto ErrOrBuffer = CacheEntry.tryLoadingBuffer();
1149 <<
" '" << CacheEntryPath <<
"' for buffer "
1150 <<
count <<
" " << ModuleIdentifier <<
"\n");
1154 if (SavedObjectsDirectoryPath.empty())
1155 ProducedBinaries[
count] = std::move(ErrOrBuffer.get());
1158 count, CacheEntryPath, *ErrOrBuffer.get());
1169 if (!DiagFileOrErr) {
1170 errs() <<
"Error: " <<
toString(DiagFileOrErr.takeError()) <<
"\n";
1176 auto TheModule = loadModuleFromInput(
Mod.get(),
Context,
false,
1180 saveTempBitcode(*TheModule, SaveTempsDir,
count,
".0.original.bc");
1182 auto &ImportList = ImportLists[ModuleIdentifier];
1184 auto OutputBuffer = ProcessThinLTOModule(
1185 *TheModule, *
Index, ModuleMap, *TMBuilder.
create(), ImportList,
1186 ExportList, GUIDPreservedSymbols,
1187 ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
1188 DisableCodeGen, SaveTempsDir, Freestanding, OptLevel,
count,
1192 CacheEntry.write(*OutputBuffer);
1194 if (SavedObjectsDirectoryPath.empty()) {
1196 if (!CacheEntryPath.empty()) {
1203 auto ReloadedBufferOrErr = CacheEntry.tryLoadingBuffer();
1204 if (
auto EC = ReloadedBufferOrErr.getError()) {
1206 errs() <<
"remark: can't reload cached file '" << CacheEntryPath
1207 <<
"': " << EC.message() <<
"\n";
1209 OutputBuffer = std::move(*ReloadedBufferOrErr);
1212 ProducedBinaries[
count] = std::move(OutputBuffer);
1216 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
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
const char LLVMTargetMachineRef TM
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 an 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< PassT, PassManager >::value > 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.
void add(Pass *P) override
Add a pass to the queue of passes to run.
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 emitImports(Module &Module, StringRef OutputName, ModuleSummaryIndex &Index, const lto::InputFile &File)
Compute and emit the imported files for module at ModulePath.
void gatherImportedSummariesForModule(Module &Module, ModuleSummaryIndex &Index, std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex, const lto::InputFile &File)
Compute the list of summaries needed for importing into module.
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.
const CustomOperand< const MCSubtargetInfo & > Msg[]
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.
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
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 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...
void writeIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex=nullptr)
Write the specified module summary index to the given raw output stream, where it will be written in ...
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
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 computeLTOCacheKey(SmallString< 40 > &Key, 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 std::set< GlobalValue::GUID > &CfiFunctionDefs={}, const std::set< GlobalValue::GUID > &CfiFunctionDecls={})
Computes a unique hash for the Module considering the current list of export/import and other global ...
void updatePublicTypeTestCalls(Module &M, bool WholeProgramVisibilityEnabledInLTO)
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)
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
void gatherImportedSummariesForModule(StringRef ModulePath, const DenseMap< StringRef, GVSummaryMapTy > &ModuleToDefinedGVSummaries, const FunctionImporter::ImportMapTy &ImportList, std::map< std::string, GVSummaryMapTy > &ModuleToSummariesForIndex)
Compute the set of summaries needed for a ThinLTO backend compilation of ModulePath.
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 ...
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.
Pass * createObjCARCContractPass()
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.