Go to the documentation of this file.
25 #include "llvm/Config/llvm-config.h"
50 #include "llvm/Support/VCSRevision.h"
65 #define DEBUG_TYPE "lto"
69 cl::desc(
"Dump the SCCs in the ThinLTO index's callgraph"));
75 cl::desc(
"Enable global value internalization in LTO"));
85 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
87 const std::set<GlobalValue::GUID> &CfiFunctionDefs,
88 const std::set<GlobalValue::GUID> &CfiFunctionDecls) {
96 Hasher.
update(LLVM_VERSION_STRING);
98 Hasher.
update(LLVM_REVISION);
106 auto AddUnsigned = [&](
unsigned I) {
125 for (
auto &A : Conf.
MAttrs)
148 auto ModHash =
Index.getModuleHash(ModuleID);
151 std::vector<uint64_t> ExportsGUID;
152 ExportsGUID.reserve(ExportList.
size());
153 for (
const auto &
VI : ExportList) {
154 auto GUID =
VI.getGUID();
155 ExportsGUID.push_back(GUID);
169 std::vector<ImportMapIteratorTy> ImportModulesVector;
170 ImportModulesVector.reserve(ImportList.
size());
172 for (ImportMapIteratorTy It = ImportList.
begin(); It != ImportList.
end();
174 ImportModulesVector.push_back(It);
177 [](
const ImportMapIteratorTy &Lhs,
const ImportMapIteratorTy &Rhs)
178 ->
bool {
return Lhs->getKey() < Rhs->getKey(); });
179 for (
const ImportMapIteratorTy &EntryIt : ImportModulesVector) {
180 auto ModHash =
Index.getModuleHash(EntryIt->first());
183 AddUint64(EntryIt->second.size());
184 for (
auto &Fn : EntryIt->second)
189 for (
auto &Entry : ResolvedODR) {
198 std::set<GlobalValue::GUID> UsedCfiDefs;
199 std::set<GlobalValue::GUID> UsedCfiDecls;
202 std::set<GlobalValue::GUID> UsedTypeIds;
205 if (CfiFunctionDefs.count(ValueGUID))
206 UsedCfiDefs.insert(ValueGUID);
207 if (CfiFunctionDecls.count(ValueGUID))
208 UsedCfiDecls.insert(ValueGUID);
213 AddUnsigned(
GS->getVisibility());
214 AddUnsigned(
GS->isLive());
215 AddUnsigned(
GS->canAutoHide());
217 AddUnsigned(
VI.isDSOLocal(
Index.withDSOLocalPropagation()));
218 AddUsedCfiGlobal(
VI.getGUID());
220 if (
auto *GVS = dyn_cast<GlobalVarSummary>(
GS)) {
221 AddUnsigned(GVS->maybeReadOnly());
222 AddUnsigned(GVS->maybeWriteOnly());
224 if (
auto *
FS = dyn_cast<FunctionSummary>(
GS)) {
225 for (
auto &TT :
FS->type_tests())
226 UsedTypeIds.insert(TT);
227 for (
auto &TT :
FS->type_test_assume_vcalls())
228 UsedTypeIds.insert(TT.GUID);
229 for (
auto &TT :
FS->type_checked_load_vcalls())
230 UsedTypeIds.insert(TT.GUID);
231 for (
auto &TT :
FS->type_test_assume_const_vcalls())
232 UsedTypeIds.insert(TT.VFunc.GUID);
233 for (
auto &TT :
FS->type_checked_load_const_vcalls())
234 UsedTypeIds.insert(TT.VFunc.GUID);
235 for (
auto &ET :
FS->calls()) {
236 AddUnsigned(ET.first.isDSOLocal(
Index.withDSOLocalPropagation()));
237 AddUsedCfiGlobal(ET.first.getGUID());
244 for (
auto &
GS : DefinedGlobals) {
248 AddUsedCfiGlobal(
GS.first);
249 AddUsedThings(
GS.second);
254 for (
auto &ImpM : ImportList)
255 for (
auto &ImpF : ImpM.second) {
260 if (
auto *AS = dyn_cast_or_null<AliasSummary>(
S))
261 AddUsedThings(AS->getBaseObject());
267 AddUnsigned(
S.TTRes.TheKind);
268 AddUnsigned(
S.TTRes.SizeM1BitWidth);
270 AddUint64(
S.TTRes.AlignLog2);
271 AddUint64(
S.TTRes.SizeM1);
272 AddUint64(
S.TTRes.BitMask);
273 AddUint64(
S.TTRes.InlineBits);
275 AddUint64(
S.WPDRes.size());
276 for (
auto &WPD :
S.WPDRes) {
277 AddUnsigned(WPD.first);
278 AddUnsigned(WPD.second.TheKind);
279 AddString(WPD.second.SingleImplName);
281 AddUint64(WPD.second.ResByArg.size());
282 for (
auto &ByArg : WPD.second.ResByArg) {
283 AddUint64(ByArg.first.size());
286 AddUnsigned(ByArg.second.TheKind);
287 AddUint64(ByArg.second.Info);
288 AddUnsigned(ByArg.second.Byte);
289 AddUnsigned(ByArg.second.Bit);
296 auto TidIter =
Index.typeIds().equal_range(TId);
297 for (
auto It = TidIter.first; It != TidIter.second; ++It)
298 AddTypeIdSummary(It->second.first, It->second.second);
301 AddUnsigned(UsedCfiDefs.size());
302 for (
auto &V : UsedCfiDefs)
305 AddUnsigned(UsedCfiDecls.size());
306 for (
auto &V : UsedCfiDecls)
312 Hasher.
update(FileOrErr.get()->getBuffer());
317 Hasher.
update(FileOrErr.get()->getBuffer());
336 for (
auto &
S :
VI.getSummaryList()) {
351 if (isPrevailing(
VI.getGUID(),
S.get())) {
364 S->setCanAutoHide(
VI.canAutoHide() &&
365 !GUIDPreservedSymbols.
count(
VI.getGUID()));
368 Visibility =
S->getVisibility();
371 else if (!isa<AliasSummary>(
S.get()) &&
372 !GlobalInvolvedWithAlias.
count(
S.get()))
379 S->setVisibility(Visibility);
381 if (
S->linkage() != OriginalLinkage)
382 recordNewLinkage(
S->modulePath(),
VI.getGUID(),
S->linkage());
386 for (
auto &
S :
VI.getSummaryList()) {
391 S->setVisibility(Visibility);
414 for (
auto &
S :
I.second.SummaryList)
415 if (
auto AS = dyn_cast<AliasSummary>(
S.get()))
416 GlobalInvolvedWithAlias.
insert(&AS->getAliasee());
420 GlobalInvolvedWithAlias, isPrevailing,
421 recordNewLinkage, GUIDPreservedSymbols);
425 if (
auto *VarSummary = dyn_cast<GlobalVarSummary>(GVS->
getBaseObject()))
426 return !VarSummary->maybeReadOnly() && !VarSummary->maybeWriteOnly() &&
436 for (
auto &
S :
VI.getSummaryList()) {
437 if (isExported(
S->modulePath(),
VI)) {
445 isPrevailing(
VI.getGUID(),
S.get())) &&
476 std::unique_ptr<InputFile> File(
new InputFile);
482 File->TargetTriple = FOrErr->TheReader.getTargetTriple();
483 File->SourceFileName = FOrErr->TheReader.getSourceFileName();
484 File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
485 File->DependentLibraries = FOrErr->TheReader.getDependentLibraries();
486 File->ComdatTable = FOrErr->TheReader.getComdatTable();
488 for (
unsigned I = 0;
I != FOrErr->Mods.size(); ++
I) {
489 size_t Begin = File->Symbols.size();
491 FOrErr->TheReader.module_symbols(
I))
494 if (Sym.isGlobal() && !Sym.isFormatSpecific())
495 File->Symbols.push_back(Sym);
496 File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
499 File->Mods = FOrErr->Mods;
500 File->Strtab =
std::move(FOrErr->Strtab);
505 return Mods[0].getModuleIdentifier();
509 assert(Mods.size() == 1 &&
"Expect only one bitcode module");
513 LTO::RegularLTOState::RegularLTOState(
unsigned ParallelCodeGenParallelismLevel,
515 : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
516 Ctx(Conf), CombinedModule(
std::make_unique<
Module>(
"ld-temp.o", Ctx)),
517 Mover(
std::make_unique<
IRMover>(*CombinedModule)) {}
519 LTO::ThinLTOState::ThinLTOState(
ThinBackend Backend)
520 : Backend(Backend), CombinedIndex(
false) {
527 unsigned ParallelCodeGenParallelismLevel)
529 RegularLTO(ParallelCodeGenParallelismLevel,
this->Conf),
539 unsigned Partition,
bool InSummary) {
540 auto *ResI = Res.
begin();
541 auto *ResE = Res.
end();
543 const Triple TT(RegularLTO.CombinedModule->getTargetTriple());
552 if (TT.isOSBinFormatCOFF() && Name.startswith(
"__imp_"))
553 Name = Name.substr(strlen(
"__imp_"));
554 auto &GlobalRes = GlobalResolutions[Name];
555 GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
557 assert(!GlobalRes.Prevailing &&
558 "Multiple prevailing defs are not allowed");
559 GlobalRes.Prevailing =
true;
560 GlobalRes.IRName = std::string(Sym.getIRName());
561 }
else if (!GlobalRes.Prevailing && GlobalRes.IRName.empty()) {
568 GlobalRes.IRName = std::string(Sym.getIRName());
582 if (GlobalRes.IRName != Sym.getIRName()) {
583 GlobalRes.Partition = GlobalResolution::External;
584 GlobalRes.VisibleOutsideSummary =
true;
593 GlobalRes.Partition != Partition)) {
594 GlobalRes.Partition = GlobalResolution::External;
597 GlobalRes.Partition = Partition;
601 GlobalRes.VisibleOutsideSummary |=
612 auto ResI = Res.
begin();
617 OS <<
"-r=" << Path <<
',' << Sym.getName() <<
',';
634 assert(!CalledGetMaxTasks);
639 if (RegularLTO.CombinedModule->getTargetTriple().empty()) {
640 RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
646 for (
unsigned I = 0;
I != Input->Mods.size(); ++
I)
647 if (
Error Err = addModule(*Input,
I, ResI, Res.
end()))
661 if (EnableSplitLTOUnit) {
665 if (*EnableSplitLTOUnit != LTOInfo->EnableSplitLTOUnit)
666 ThinLTO.CombinedIndex.setPartiallySplitLTOUnits();
668 EnableSplitLTOUnit = LTOInfo->EnableSplitLTOUnit;
671 auto ModSyms = Input.module_symbols(ModI);
672 addModuleToGlobalRes(ModSyms, {ResI, ResE},
673 LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
674 LTOInfo->HasSummary);
676 if (LTOInfo->IsThinLTO)
677 return addThinLTO(BM, ModSyms, ResI, ResE);
679 RegularLTO.EmptyCombinedModule =
false;
681 addRegularLTO(BM, ModSyms, ResI, ResE);
685 if (!LTOInfo->HasSummary)
686 return linkRegularLTO(
std::move(*ModOrErr),
false);
692 RegularLTO.ModsWithSummaries.push_back(
std::move(*ModOrErr));
708 std::set<const Comdat *> &NonPrevailingComdats) {
713 if (!NonPrevailingComdats.count(
C))
722 if (
auto GO = dyn_cast<GlobalObject>(&GV))
723 GO->setComdat(
nullptr);
733 RegularLTOState::AddedModule
Mod;
742 if (
Error Err =
M.materializeMetadata())
750 if (GV.hasAppendingLinkage())
751 Mod.Keep.push_back(&GV);
754 for (
auto &GA :
M.aliases())
756 AliasedGlobals.
insert(GO);
765 auto MsymI = SymTab.
symbols().begin(), MsymE = SymTab.
symbols().end();
767 while (MsymI != MsymE) {
777 std::set<const Comdat *> NonPrevailingComdats;
789 if (Sym.isUndefined())
791 Mod.Keep.push_back(GV);
802 }
else if (isa<GlobalObject>(GV) &&
803 (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() ||
804 GV->hasAvailableExternallyLinkage()) &&
805 !AliasedGlobals.
count(cast<GlobalObject>(GV))) {
811 Mod.Keep.push_back(GV);
814 NonPrevailingComdats.insert(GV->getComdat());
815 cast<GlobalObject>(GV)->setComdat(
nullptr);
820 GV->setDSOLocal(
true);
821 if (GV->hasDLLImportStorageClass())
823 DefaultStorageClass);
828 NonPrevailingAsmSymbols.
insert(AS->first);
836 if (Sym.isCommon()) {
839 auto &CommonRes = RegularLTO.Commons[std::string(Sym.getIRName())];
840 CommonRes.Size =
std::max(CommonRes.Size, Sym.getCommonSize());
841 if (
uint32_t SymAlignValue = Sym.getCommonAlignment()) {
842 const Align SymAlign(SymAlignValue);
843 CommonRes.Align =
std::max(SymAlign, CommonRes.Align.valueOrOne());
849 if (!
M.getComdatSymbolTable().empty())
855 if (!
M.getModuleInlineAsm().empty()) {
856 std::string NewIA =
".lto_discard";
857 if (!NonPrevailingAsmSymbols.
empty()) {
861 if (!NonPrevailingAsmSymbols.
count(Alias))
862 NonPrevailingAsmSymbols.
erase(Name);
864 NewIA +=
" " + llvm::join(NonPrevailingAsmSymbols,
", ");
867 M.setModuleInlineAsm(NewIA +
M.getModuleInlineAsm());
874 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
875 bool LivenessFromIndex) {
876 std::vector<GlobalValue *>
Keep;
878 if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->
getGUID())) {
879 if (
Function *
F = dyn_cast<Function>(GV)) {
880 if (DiagnosticOutputFile) {
881 if (
Error Err =
F->materialize())
886 <<
" not added to the combined module ");
900 RegularLTO.CombinedModule->getNamedValue(GV->
getName());
907 return RegularLTO.Mover->move(
std::move(
Mod.M), Keep,
nullptr,
920 if (!Sym.getIRName().empty()) {
931 return ThinLTO.PrevailingModuleForGUID[GUID] ==
932 BM.getModuleIdentifier();
940 if (!Sym.getIRName().empty()) {
944 assert(ThinLTO.PrevailingModuleForGUID[GUID] ==
952 if (
auto S = ThinLTO.CombinedIndex.findSummaryInModule(
960 if (
auto S = ThinLTO.CombinedIndex.findSummaryInModule(
962 S->setDSOLocal(
true);
968 if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second)
969 return make_error<StringError>(
970 "Expected at most one ThinLTO module per bitcode file",
974 if (!ThinLTO.ModulesToCompile)
975 ThinLTO.ModulesToCompile = ModuleMapType();
991 CalledGetMaxTasks =
true;
992 auto ModuleCount = ThinLTO.ModulesToCompile ? ThinLTO.ModulesToCompile->size()
993 : ThinLTO.ModuleMap.size();
994 return RegularLTO.ParallelCodeGenParallelismLevel + ModuleCount;
999 Error LTO::checkPartiallySplit() {
1000 if (!ThinLTO.CombinedIndex.partiallySplitLTOUnits())
1003 Function *TypeTestFunc = RegularLTO.CombinedModule->getFunction(
1005 Function *TypeCheckedLoadFunc = RegularLTO.CombinedModule->getFunction(
1010 if ((TypeTestFunc && !TypeTestFunc->
use_empty()) ||
1011 (TypeCheckedLoadFunc && !TypeCheckedLoadFunc->
use_empty()))
1012 return make_error<StringError>(
1013 "inconsistent LTO Unit splitting (recompile with -fsplit-lto-unit)",
1018 for (
auto &
P : ThinLTO.CombinedIndex) {
1019 for (
auto &
S :
P.second.SummaryList) {
1020 auto *
FS = dyn_cast<FunctionSummary>(
S.get());
1023 if (!
FS->type_test_assume_vcalls().empty() ||
1024 !
FS->type_checked_load_vcalls().empty() ||
1025 !
FS->type_test_assume_const_vcalls().empty() ||
1026 !
FS->type_checked_load_const_vcalls().empty() ||
1027 !
FS->type_tests().empty())
1028 return make_error<StringError>(
1029 "inconsistent LTO Unit splitting (recompile with -fsplit-lto-unit)",
1040 for (
auto &Res : GlobalResolutions) {
1043 if (Res.second.IRName.empty())
1049 if (Res.second.VisibleOutsideSummary && Res.second.
Prevailing)
1050 GUIDPreservedSymbols.
insert(GUID);
1053 DynamicExportSymbols.insert(GUID);
1055 GUIDPrevailingResolutions[GUID] =
1060 auto It = GUIDPrevailingResolutions.
find(
G);
1061 if (It == GUIDPrevailingResolutions.
end())
1070 if (!StatsFileOrErr)
1071 return StatsFileOrErr.takeError();
1072 std::unique_ptr<ToolOutputFile> StatsFile =
std::move(StatsFileOrErr.get());
1074 Error Result = runRegularLTO(AddStream);
1076 Result = runThinLTO(AddStream, Cache, GUIDPreservedSymbols);
1091 return DiagFileOrErr.takeError();
1092 DiagnosticOutputFile =
std::move(*DiagFileOrErr);
1096 for (
auto &M : RegularLTO.ModsWithSummaries)
1105 if (
Error Err = checkPartiallySplit())
1110 const DataLayout &
DL = RegularLTO.CombinedModule->getDataLayout();
1111 for (
auto &
I : RegularLTO.Commons) {
1112 if (!
I.second.Prevailing)
1115 GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(
I.first);
1116 if (OldGV &&
DL.getTypeAllocSize(OldGV->
getValueType()) ==
I.second.Size) {
1124 auto *GV =
new GlobalVariable(*RegularLTO.CombinedModule, Ty,
false,
1127 GV->setAlignment(
I.second.Align);
1141 DynamicExportSymbols);
1150 for (
const auto &R : GlobalResolutions) {
1151 if (!
R.second.isPrevailingIRSymbol())
1153 if (
R.second.Partition != 0 &&
1154 R.second.Partition != GlobalResolution::External)
1158 RegularLTO.CombinedModule->getNamedValue(
R.second.IRName);
1169 RegularLTO.CombinedModule->addModuleFlag(
Module::Error,
"LTOPostLink", 1);
1178 backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
1179 *RegularLTO.CombinedModule, ThinLTO.CombinedIndex))
1187 #define HANDLE_LIBCALL(code, name) name,
1188 #include "llvm/IR/RuntimeLibcalls.def"
1189 #undef HANDLE_LIBCALL
1209 : Conf(Conf), CombinedIndex(CombinedIndex),
1210 ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries),
1211 OnWrite(OnWrite), ShouldEmitImportsFiles(ShouldEmitImportsFiles) {}
1214 virtual Error start(
1218 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1220 virtual Error wait() = 0;
1221 virtual unsigned getThreadCount() = 0;
1226 const std::string &NewModulePath) {
1227 std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
1230 ImportList, ModuleToSummariesForIndex);
1238 if (ShouldEmitImportsFiles) {
1240 ModuleToSummariesForIndex);
1253 std::set<GlobalValue::GUID> CfiFunctionDefs;
1254 std::set<GlobalValue::GUID> CfiFunctionDecls;
1256 std::optional<Error> Err;
1259 bool ShouldEmitIndexFiles;
1262 InProcessThinBackend(
1267 bool ShouldEmitIndexFiles,
bool ShouldEmitImportsFiles)
1269 OnWrite, ShouldEmitImportsFiles),
1270 BackendThreadPool(ThinLTOParallelism), AddStream(
std::
move(AddStream)),
1271 Cache(
std::
move(Cache)), ShouldEmitIndexFiles(ShouldEmitIndexFiles) {
1273 CfiFunctionDefs.insert(
1276 CfiFunctionDecls.insert(
1280 Error runThinLTOBackendThread(
1285 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1288 auto RunThinBackend = [&](
AddStreamFn AddStream) {
1294 return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
1295 ImportList, DefinedGlobals, &ModuleMap);
1300 if (ShouldEmitIndexFiles) {
1301 if (
auto E = emitFiles(ImportList, ModuleID, ModuleID.str()))
1307 [](
uint32_t V) { return V == 0; }))
1310 return RunThinBackend(AddStream);
1315 ExportList, ResolvedODR, DefinedGlobals, CfiFunctionDefs,
1320 AddStreamFn &CacheAddStream = *CacheAddStreamOrErr;
1322 return RunThinBackend(CacheAddStream);
1331 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1334 assert(ModuleToDefinedGVSummaries.
count(ModulePath));
1336 ModuleToDefinedGVSummaries.
find(ModulePath)->second;
1337 BackendThreadPool.
async(
1341 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
1348 Error E = runThinLTOBackendThread(
1349 AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
1350 ResolvedODR, DefinedGlobals, ModuleMap);
1352 std::unique_lock<std::mutex> L(ErrMu);
1361 BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
1362 std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap));
1365 OnWrite(std::string(ModulePath));
1369 Error wait()
override {
1370 BackendThreadPool.
wait();
1377 unsigned getThreadCount()
override {
1385 bool ShouldEmitIndexFiles,
1386 bool ShouldEmitImportsFiles) {
1390 return std::make_unique<InProcessThinBackend>(
1391 Conf, CombinedIndex, Parallelism, ModuleToDefinedGVSummaries, AddStream,
1392 Cache, OnWrite, ShouldEmitIndexFiles, ShouldEmitImportsFiles);
1400 const std::string &OldPrefix,
1401 const std::string &NewPrefix) {
1402 if (OldPrefix.empty() && NewPrefix.empty())
1407 if (!ParentPath.
empty()) {
1410 llvm::errs() <<
"warning: could not create directory '" << ParentPath
1411 <<
"': " << EC.message() <<
'\n';
1413 return std::string(NewPath.
str());
1418 std::string OldPrefix, NewPrefix;
1422 WriteIndexesThinBackend(
1425 std::string OldPrefix, std::string NewPrefix,
bool ShouldEmitImportsFiles,
1428 OnWrite, ShouldEmitImportsFiles),
1429 OldPrefix(OldPrefix), NewPrefix(NewPrefix),
1430 LinkedObjectsFile(LinkedObjectsFile) {}
1436 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
1439 std::string NewModulePath =
1442 if (LinkedObjectsFile)
1443 *LinkedObjectsFile << NewModulePath <<
'\n';
1445 if (
auto E = emitFiles(ImportList, ModulePath, NewModulePath))
1449 OnWrite(std::string(ModulePath));
1457 unsigned getThreadCount()
override {
return 1; }
1462 std::string OldPrefix, std::string NewPrefix,
bool ShouldEmitImportsFiles,
1467 return std::make_unique<WriteIndexesThinBackend>(
1468 Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
1469 ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite);
1475 ThinLTO.CombinedIndex.releaseTemporaryMemory();
1481 if (ThinLTO.ModuleMap.empty())
1484 if (ThinLTO.ModulesToCompile && ThinLTO.ModulesToCompile->empty()) {
1485 llvm::errs() <<
"warning: [ThinLTO] No module compiled\n";
1496 ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
1497 ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
1498 ModuleToDefinedGVSummaries);
1506 for (
auto &Mod : ThinLTO.ModuleMap)
1507 if (!ModuleToDefinedGVSummaries.
count(
Mod.first))
1514 ThinLTO.ModuleMap.size());
1516 ThinLTO.ModuleMap.size());
1520 ThinLTO.CombinedIndex.dumpSCCs(
outs());
1522 std::set<GlobalValue::GUID> ExportedGUIDs;
1525 ThinLTO.CombinedIndex.setWithWholeProgramVisibility();
1530 DynamicExportSymbols);
1535 std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
1537 LocalWPDTargetsMap);
1541 ImportLists, ExportLists);
1547 for (
auto &Res : GlobalResolutions) {
1550 if (Res.second.Partition != GlobalResolution::External ||
1551 !Res.second.isPrevailingIRSymbol())
1556 if (ThinLTO.CombinedIndex.isGUIDLive(GUID))
1557 ExportedGUIDs.insert(GUID);
1562 for (
auto &
Def : ThinLTO.CombinedIndex.cfiFunctionDefs())
1563 ExportedGUIDs.insert(
1565 for (
auto &Decl : ThinLTO.CombinedIndex.cfiFunctionDecls())
1566 ExportedGUIDs.insert(
1570 const auto &ExportList = ExportLists.
find(ModuleIdentifier);
1571 return (ExportList != ExportLists.end() && ExportList->second.
count(
VI)) ||
1572 ExportedGUIDs.count(
VI.getGUID());
1578 LocalWPDTargetsMap);
1582 return ThinLTO.PrevailingModuleForGUID[GUID] ==
S->modulePath();
1587 auto recordNewLinkage = [&](
StringRef ModuleIdentifier,
1590 ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
1593 recordNewLinkage, GUIDPreservedSymbols);
1602 TimeTraceScopeExit.release();
1604 std::unique_ptr<ThinBackendProc> BackendProc =
1605 ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
1609 ThinLTO.ModulesToCompile ? *ThinLTO.ModulesToCompile : ThinLTO.ModuleMap;
1611 auto ProcessOneModule = [&](
int I) ->
Error {
1615 return BackendProc->start(RegularLTO.ParallelCodeGenParallelismLevel +
I,
1616 Mod.second, ImportLists[
Mod.first],
1617 ExportLists[
Mod.first], ResolvedODR[
Mod.first],
1621 if (BackendProc->getThreadCount() == 1) {
1626 for (
int I = 0,
E = ModuleMap.
size();
I !=
E; ++
I)
1627 if (
Error E = ProcessOneModule(
I))
1634 std::vector<BitcodeModule *> ModulesVec;
1635 ModulesVec.reserve(ModuleMap.
size());
1636 for (
auto &Mod : ModuleMap)
1637 ModulesVec.push_back(&
Mod.second);
1639 if (
Error E = ProcessOneModule(
I))
1642 return BackendProc->wait();
1652 if (!Filename.empty() && Count != -1)
1660 if (
Error E = ResultOrErr.takeError())
1664 (*ResultOrErr)->keep();
1672 if (StatsFilename.
empty())
1690 auto Seq = llvm::seq<int>(0, R.size());
1691 std::vector<int> ModulesOrdering(Seq.begin(), Seq.end());
1692 llvm::sort(ModulesOrdering, [&](
int LeftIndex,
int RightIndex) {
1693 auto LSize = R[LeftIndex]->getBuffer().
size();
1694 auto RSize = R[RightIndex]->getBuffer().
size();
1695 return LSize > RSize;
1697 return ModulesOrdering;
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 eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
This is an optimization pass for GlobalISel generic memory operations.
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.
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
std::pair< std::string, uint32_t > AsmSymbol
bool replace_path_prefix(SmallVectorImpl< char > &Path, StringRef OldPrefix, StringRef NewPrefix, Style style=Style::native)
Replace matching path prefix with another path.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
A parsed version of the target data layout string in and methods for querying it.
std::string getGlobalIdentifier() const
Return the modified name for this global value suitable to be used as the key for a global lookup (e....
Expected< IRSymtabFile > readIRSymtab(MemoryBufferRef MBRef)
Reads a bitcode file, creating its irsymtab if necessary.
bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
cl::opt< bool > EnableLTOInternalization
Enable global value internalization in LTO.
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
A ThreadPool for asynchronous parallel execution on a defined number of threads.
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 ...
CodeGenOpt::Level CGOptLevel
Expected< std::unique_ptr< ToolOutputFile > > setupLLVMOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, std::optional< uint64_t > RemarksHotnessThreshold=0)
Setup optimization remarks that output to a file.
unsigned TimeTraceGranularity
Time trace granularity.
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
std::string RemarksFormat
The format used for serializing remarks (default: YAML).
ThinBackendProc(const Config &Conf, ModuleSummaryIndex &CombinedIndex, const StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, lto::IndexWriteCallback OnWrite, bool ShouldEmitImportsFiles)
bool RemarksWithHotness
Whether to emit optimization remarks with hotness informations.
static void handleNonPrevailingComdat(GlobalValue &GV, std::set< const Comdat * > &NonPrevailingComdats)
void write32le(void *P, uint32_t V)
static bool isLocalLinkage(LinkageTypes Linkage)
iterator find(const_arg_type_t< ValueT > V)
This tells how a thread pool will be used.
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.
cl::opt< std::string > RemarksFilename("lto-pass-remarks-output", cl::desc("Output filename for pass remarks"), cl::value_desc("filename"))
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
static ErrorSuccess success()
Create a success value.
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Triple - Helper class for working with autoconf configuration names.
std::vector< std::string > ThinLTOModulesToCompile
Specific thinLTO modules to compile.
ThreadPoolStrategy heavyweight_hardware_concurrency(unsigned ThreadCount=0)
Returns a thread strategy for tasks requiring significant memory or other resources.
Expected< std::unique_ptr< Module > > getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks={})
Read the bitcode module and prepare for lazy deserialization of function bodies.
std::function< std::unique_ptr< ThinBackendProc >(const Config &C, ModuleSummaryIndex &CombinedIndex, StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, AddStreamFn AddStream, FileCache Cache)> ThinBackend
A ThinBackend defines what happens after the thin-link phase during ThinLTO.
unsigned Prevailing
The linker has chosen this definition of the symbol.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.
@ DefaultVisibility
The GV is visible.
cl::opt< bool > RemarksWithHotness("lto-pass-remarks-with-hotness", cl::desc("With PGO, include profile count in optimization remarks"), cl::Hidden)
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Tagged union holding either a T or a Error.
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.
void setUnnamedAddr(UnnamedAddr Val)
LinkageTypes
An enumeration for the kinds of linkage for global values.
Class to represent array types.
iterator find(StringRef Key)
void gatherImportedSummariesForModule(StringRef ModulePath, const StringMap< 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.
static bool isLinkOnceODRLinkage(LinkageTypes Linkage)
void generateParamAccessSummary(ModuleSummaryIndex &Index)
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
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.
static IntegerType * getInt8Ty(LLVMContext &C)
void timeTraceProfilerFinishThread()
Finish a time trace profiler running on a worker thread.
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.
std::optional< uint64_t > RemarksHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
CombinedIndexHookFn CombinedIndexHook
Expected< std::unique_ptr< ToolOutputFile > > setupStatsFile(StringRef StatsFilename)
Setups the output file for saving statistics.
std::string getThinLTOOutputFile(const std::string &Path, const std::string &OldPrefix, const std::string &NewPrefix)
Given the original Path to an output file, replace any path prefix matching OldPrefix with NewPrefix.
void timeTraceProfilerInitialize(unsigned TimeTraceGranularity, StringRef ProcName)
Initialize the time trace profiler.
StringRef getModuleIdentifier() const
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Function and variable summary information to aid decisions and implementation of importing.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
VisibilityTypes
An enumeration for the kinds of visibility of global values.
raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
static bool isAppendingLinkage(LinkageTypes Linkage)
std::string SampleProfile
Sample PGO profile path.
A class that wrap the SHA1 algorithm.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void timeTraceProfilerBegin(StringRef Name, StringRef Detail)
Manually begin a time section, with the given Name and Detail.
(vector float) vec_cmpeq(*A, *B) C
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
std::array< uint8_t, 20 > result()
Return the current raw 160-bits SHA1 for the digested data since the last call to init().
VisScheme VisibilityScheme
Allows non-imported definitions to get the potentially more constraining visibility from the prevaili...
void computeSyntheticCounts(ModuleSummaryIndex &Index)
Compute synthetic function entry counts.
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...
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::unique_ptr< raw_ostream > ResolutionFile
If this field is set, LTO will write input file paths and symbol resolutions here in llvm-lto2 comman...
This class implements an extremely fast bulk output stream that can only output to a stream.
static void thinLTOResolvePrevailingGUID(const Config &C, ValueInfo VI, DenseSet< GlobalValueSummary * > &GlobalInvolvedWithAlias, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols)
void setName(const Twine &Name)
Change the name of the value.
unsigned RelaxELFRelocations
@ InternalLinkage
Rename collisions when linking (static functions).
This struct is a compact representation of a valid (non-zero power of two) alignment.
ArrayRef< Symbol > symbols() const
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
void addModule(Module *M)
unsigned getMaxTasks() const
Returns an upper bound on the number of tasks that the client may expect.
std::string StatsFile
Statistics output file path.
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
std::string OverrideTriple
Setting this field will replace target triples in input files with this triple.
unsigned getThreadCount() const
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Struct that holds a reference to a particular GUID in a global value summary.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
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"))
void updateVCallVisibilityInIndex(ModuleSummaryIndex &Index, bool WholeProgramVisibilityEnabledInLTO, const DenseSet< GlobalValue::GUID > &DynamicExportSymbols)
If whole program visibility asserted, then upgrade all public vcall visibility metadata on vtable def...
void sort(IteratorTy Start, IteratorTy End)
An efficient, type-erasing, non-owning reference to a callable.
constexpr bool empty() const
empty - Check if the string is empty.
Error emitFiles(const FunctionImporter::ImportMapTy &ImportList, llvm::StringRef ModulePath, const std::string &NewModulePath)
Implements a dense probed hash-table based set.
std::string RemarksFilename
Optimization remarks file path.
bool hasAvailableExternallyLinkage() const
std::string DefaultTriple
Setting this field will replace unspecified target triples in input files with this triple.
void PrintStatisticsJSON(raw_ostream &OS)
Print statistics in JSON format.
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Used in the streaming interface as the general argument type.
bar al al movzbl eax ret Missed when stored in a memory object
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
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.
std::string DwoDir
The directory to store .dwo files.
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
T dyn_cast() const
Returns the current pointer if it is of the specified pointer type, otherwise returns null.
static std::string toHex(uint64_t V)
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
This is an important class for using LLVM in a threaded context.
A derived class of LLVMContext that initializes itself according to a given Config object.
static ArrayRef< const char * > getRuntimeLibcallSymbols()
Static method that returns a list of libcall symbols that can be generated by LTO but might not be vi...
initializer< Ty > init(const Ty &Val)
Error joinErrors(Error E1, Error E2)
Concatenate errors.
void setLinkage(LinkageTypes LT)
void EnableStatistics(bool DoPrintOnExit=true)
Enable the collection and printing of statistics.
std::function< Expected< std::unique_ptr< CachedFileStream > >(unsigned Task, const Twine &ModuleName)> AddStreamFn
This type defines the callback to add a file that is generated on the fly.
iterator find(const_arg_type_t< KeyT > Val)
const StringMap< std::pair< uint64_t, ModuleHash > > & modulePaths() const
Table of modules, containing module hash and id.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
static void thinLTOInternalizeAndPromoteGUID(ValueInfo VI, function_ref< bool(StringRef, ValueInfo)> isExported, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Error readSummary(ModuleSummaryIndex &CombinedIndex, StringRef ModulePath, uint64_t ModuleId, std::function< bool(GlobalValue::GUID)> IsPrevailing=nullptr)
Parse the specified bitcode buffer and merge its module summary index into CombinedIndex.
bool hasLocalLinkage() const
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...
std::vector< std::string > MAttrs
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
A Module instance is used to store all the information related to an LLVM module.
std::set< std::string > & cfiFunctionDefs()
Expected< std::unique_ptr< Module > > parseModule(LLVMContext &Context, ParserCallbacks Callbacks={})
Read the entire bitcode module and return it.
std::optional< CodeModel::Model > CodeModel
std::string ProfileRemapping
Name remapping file for profile data.
@ AppendingLinkage
Special purpose, only applies to global arrays.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
void update(ArrayRef< uint8_t > Data)
Digest more data.
static LinkageTypes getWeakLinkage(bool ODR)
void updateVCallVisibilityInModule(Module &M, bool WholeProgramVisibilityEnabledInLTO, const DenseSet< GlobalValue::GUID > &DynamicExportSymbols)
If whole program visibility asserted, then upgrade all public vcall visibility metadata on vtable def...
bool HasWholeProgramVisibility
Asserts whether we can assume whole program visibility during the LTO link.
Error thinBackend(const Config &C, unsigned Task, AddStreamFn AddStream, Module &M, const ModuleSummaryIndex &CombinedIndex, const FunctionImporter::ImportMapTy &ImportList, const GVSummaryMapTy &DefinedGlobals, MapVector< StringRef, BitcodeModule > *ModuleMap, const std::vector< uint8_t > &CmdArgs=std::vector< uint8_t >())
Runs a ThinLTO backend.
StringRef - Represent a constant reference to a string, i.e.
Analysis the ScalarEvolution expression for r is this
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
bool TimeTraceEnabled
Time trace enabled.
@ WeakODRLinkage
Same, but only replaced by something equivalent.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
ThinBackend createWriteIndexesThinBackend(std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles, raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite)
This ThinBackend writes individual module indexes to files, instead of running the individual backend...
Error run(AddStreamFn AddStream, FileCache Cache=nullptr)
Runs the LTO pipeline.
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
bool AlwaysEmitRegularLTOObj
Always emit a Regular LTO object even when it is empty because no Regular LTO modules were linked.
std::string OptPipeline
If this field is set, the set of passes run in the middle-end optimizer will be the one specified by ...
std::set< std::string > & cfiFunctionDecls()
@ AvailableExternallyLinkage
Available for inspection, not emission.
const GlobalObject * getAliaseeObject() const
@ Error
Emits an error if two values disagree, otherwise the resulting value is that of the operands.
StringRef getName() const
Return a constant reference to the value's name.
A raw_ostream that writes to a file descriptor.
@ CommonLinkage
Tentative definitions.
std::optional< Reloc::Model > RelocModel
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
std::vector< std::string > MllvmArgs
uint32_t getSymbolFlags(Symbol S) const
static bool isLinkOnceLinkage(LinkageTypes Linkage)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LTO(Config Conf, ThinBackend Backend=nullptr, unsigned ParallelCodeGenParallelismLevel=1)
Create an LTO object.
DebuggerKind DebuggerTuning
Which debugger to tune for.
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 ...
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
static bool isInterposableLinkage(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time.
static void CollectAsmSymvers(const Module &M, function_ref< void(StringRef, StringRef)> AsmSymver)
Parse inline ASM and collect the symvers directives that are defined in the current module.
static bool isWeakObjectWithRWAccess(GlobalValueSummary *GVS)
Ephemeral symbols produced by Reader::symbols() and Reader::module_symbols().
Lightweight error class with error context and mandatory checking.
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.
bool timeTraceProfilerEnabled()
Is the time trace profiler enabled, i.e. initialized?
const Comdat * getComdat() const
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
unsigned FinalDefinitionInLinkageUnit
The definition of this symbol is unpreemptable at runtime and is known to be in this linkage unit.
unsigned DataSections
Emit data into separate sections.
std::function< void(const std::string &)> IndexWriteCallback
This ThinBackend runs the individual backend jobs in-process.
ModuleHookFn PreOptModuleHook
This module hook is called after linking (regular LTO) or loading (ThinLTO) the module,...
The resolution for a symbol.
const StringMap< GVSummaryMapTy > & ModuleToDefinedGVSummaries
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
ModuleSummaryIndex & CombinedIndex
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
StringRef str() const
Explicit conversion to StringRef.
@ Keep
No function return thunk.
static const char * libcallRoutineNames[]
unsigned VisibleToRegularObj
The definition of this symbol is visible outside of the LTO unit.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
@ ExternalLinkage
Externally visible function.
DLLStorageClassTypes
Storage classes of global values for PE targets.
Error takeError()
Take ownership of the stored error.
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
std::vector< int > generateModulesOrdering(ArrayRef< BitcodeModule * > R)
Produces a container ordering for optimal multi-threaded processing.
std::function< Expected< AddStreamFn >(unsigned Task, StringRef Key, const Twine &ModuleName)> FileCache
This is the type of a file cache.
CodeGenFileType CGFileType
void write64le(void *P, uint64_t V)
void updatePublicTypeTestCalls(Module &M, bool WholeProgramVisibilityEnabledInLTO)
GlobalValueSummary * getBaseObject()
If this is an alias summary, returns the summary of the aliased object (a global variable or function...
Class to hold module path string table and global value map, and encapsulate methods for operating on...
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)
void ComputeCrossModuleImport(const ModuleSummaryIndex &Index, const StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, StringMap< FunctionImporter::ImportMapTy > &ImportLists, StringMap< FunctionImporter::ExportSetTy > &ExportLists)
Compute all the imports and exports for every module in the Index.
PointerType * getType() const
Global values are always pointers.
void timeTraceProfilerEnd()
Manually end the last time section.
ArrayRef(const T &OneElt) -> ArrayRef< T >
Type * getValueType() const
std::pair< iterator, bool > try_emplace(StringRef Key, ArgsTy &&...Args)
Emplace a new element for the specified key into the map if the key isn't already in the map.
This class defines the interface to the ThinLTO backend.
Represents a module in a bitcode file.
unsigned FunctionSections
Emit functions into separate sections.
void takeName(Value *V)
Transfer the name from V to this value.
bool hasWholeProgramVisibility(bool WholeProgramVisibilityEnabledInLTO)
static cl::opt< bool > DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden, cl::desc("Dump the SCCs in the ThinLTO index's callgraph"))
Error add(std::unique_ptr< InputFile > Obj, ArrayRef< SymbolResolution > Res)
Add an input file to the LTO link, using the provided symbol resolutions.
void setAlignment(MaybeAlign Align)
unsigned ExportDynamic
The symbol was exported dynamically, and therefore could be referenced by a shared library not visibl...
StringMapConstIterator< ValueTy > const_iterator
ThinBackend createInProcessThinBackend(ThreadPoolStrategy Parallelism, IndexWriteCallback OnWrite=nullptr, bool ShouldEmitIndexFiles=false, bool ShouldEmitImportsFiles=false)
static ConstantAggregateZero * get(Type *Ty)
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
unsigned LinkerRedefined
Linker redefined version of the symbol which appeared in -wrap or -defsym linker option.
bool ShouldEmitImportsFiles
lto::IndexWriteCallback OnWrite
std::string RemarksPasses
Optimization remarks pass filter.
static void writeToResolutionFile(raw_ostream &OS, InputFile *Input, ArrayRef< SymbolResolution > Res)