LLVM 19.0.0git
Go to the documentation of this file.
1//===-LTOBackend.cpp - LLVM Link Time Optimizer Backend -------------------===//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
9// This file implements the "backend" phase of LTO, i.e. it performs
10// optimization and code generation on a loaded module. It is generally used
11// internally by the LTO class but can also be used independently, for example
12// to implement a standalone ThinLTO backend.
16#include "llvm/LTO/LTOBackend.h"
25#include "llvm/IR/PassManager.h"
26#include "llvm/IR/Verifier.h"
27#include "llvm/LTO/LTO.h"
33#include "llvm/Support/Error.h"
36#include "llvm/Support/Path.h"
48#include <optional>
50using namespace llvm;
51using namespace lto;
53#define DEBUG_TYPE "lto-backend"
56 DoNotEmbed = 0,
62 "lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed),
64 "Do not embed"),
66 "Embed after all optimization passes"),
68 "post-merge-pre-opt",
69 "Embed post merge, but before optimizations")),
70 cl::desc("Embed LLVM bitcode in object files produced by LTO"));
73 "thinlto-assume-merged", cl::init(false),
74 cl::desc("Assume the input has already undergone ThinLTO function "
75 "importing and the other pre-optimization pipeline changes."));
77namespace llvm {
81[[noreturn]] static void reportOpenError(StringRef Path, Twine Msg) {
82 errs() << "failed to open " << Path << ": " << Msg << '\n';
83 errs().flush();
84 exit(1);
87Error Config::addSaveTemps(std::string OutputFileName, bool UseInputModulePath,
88 const DenseSet<StringRef> &SaveTempsArgs) {
91 std::error_code EC;
92 if (SaveTempsArgs.empty() || SaveTempsArgs.contains("resolution")) {
94 std::make_unique<raw_fd_ostream>(OutputFileName + "resolution.txt", EC,
96 if (EC) {
97 ResolutionFile.reset();
98 return errorCodeToError(EC);
99 }
100 }
102 auto setHook = [&](std::string PathSuffix, ModuleHookFn &Hook) {
103 // Keep track of the hook provided by the linker, which also needs to run.
104 ModuleHookFn LinkerHook = Hook;
105 Hook = [=](unsigned Task, const Module &M) {
106 // If the linker's hook returned false, we need to pass that result
107 // through.
108 if (LinkerHook && !LinkerHook(Task, M))
109 return false;
111 std::string PathPrefix;
112 // If this is the combined module (not a ThinLTO backend compile) or the
113 // user hasn't requested using the input module's path, emit to a file
114 // named from the provided OutputFileName with the Task ID appended.
115 if (M.getModuleIdentifier() == "ld-temp.o" || !UseInputModulePath) {
116 PathPrefix = OutputFileName;
117 if (Task != (unsigned)-1)
118 PathPrefix += utostr(Task) + ".";
119 } else
120 PathPrefix = M.getModuleIdentifier() + ".";
121 std::string Path = PathPrefix + PathSuffix + ".bc";
122 std::error_code EC;
124 // Because -save-temps is a debugging feature, we report the error
125 // directly and exit.
126 if (EC)
127 reportOpenError(Path, EC.message());
128 WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false);
129 return true;
130 };
131 };
133 auto SaveCombinedIndex =
134 [=](const ModuleSummaryIndex &Index,
135 const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
136 std::string Path = OutputFileName + "index.bc";
137 std::error_code EC;
139 // Because -save-temps is a debugging feature, we report the error
140 // directly and exit.
141 if (EC)
142 reportOpenError(Path, EC.message());
145 Path = OutputFileName + "index.dot";
147 if (EC)
148 reportOpenError(Path, EC.message());
149 Index.exportToDot(OSDot, GUIDPreservedSymbols);
150 return true;
151 };
153 if (SaveTempsArgs.empty()) {
154 setHook("0.preopt", PreOptModuleHook);
155 setHook("1.promote", PostPromoteModuleHook);
156 setHook("2.internalize", PostInternalizeModuleHook);
157 setHook("3.import", PostImportModuleHook);
158 setHook("4.opt", PostOptModuleHook);
159 setHook("5.precodegen", PreCodeGenModuleHook);
160 CombinedIndexHook = SaveCombinedIndex;
161 } else {
162 if (SaveTempsArgs.contains("preopt"))
163 setHook("0.preopt", PreOptModuleHook);
164 if (SaveTempsArgs.contains("promote"))
165 setHook("1.promote", PostPromoteModuleHook);
166 if (SaveTempsArgs.contains("internalize"))
167 setHook("2.internalize", PostInternalizeModuleHook);
168 if (SaveTempsArgs.contains("import"))
169 setHook("3.import", PostImportModuleHook);
170 if (SaveTempsArgs.contains("opt"))
171 setHook("4.opt", PostOptModuleHook);
172 if (SaveTempsArgs.contains("precodegen"))
173 setHook("5.precodegen", PreCodeGenModuleHook);
174 if (SaveTempsArgs.contains("combinedindex"))
175 CombinedIndexHook = SaveCombinedIndex;
176 }
178 return Error::success();
181#define HANDLE_EXTENSION(Ext) \
182 llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
183#include "llvm/Support/Extension.def"
186 PassBuilder &PB) {
187#define HANDLE_EXTENSION(Ext) \
188 get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
189#include "llvm/Support/Extension.def"
191 // Load requested pass plugins and let them register pass builder callbacks
192 for (auto &PluginFN : PassPlugins) {
193 auto PassPlugin = PassPlugin::Load(PluginFN);
194 if (!PassPlugin) {
195 errs() << "Failed to load passes from '" << PluginFN
196 << "'. Request ignored.\n";
197 continue;
198 }
201 }
204static std::unique_ptr<TargetMachine>
205createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
206 StringRef TheTriple = M.getTargetTriple();
207 SubtargetFeatures Features;
208 Features.getDefaultSubtargetFeatures(Triple(TheTriple));
209 for (const std::string &A : Conf.MAttrs)
210 Features.AddFeature(A);
212 std::optional<Reloc::Model> RelocModel;
213 if (Conf.RelocModel)
214 RelocModel = *Conf.RelocModel;
215 else if (M.getModuleFlag("PIC Level"))
216 RelocModel =
217 M.getPICLevel() == PICLevel::NotPIC ? Reloc::Static : Reloc::PIC_;
219 std::optional<CodeModel::Model> CodeModel;
220 if (Conf.CodeModel)
221 CodeModel = *Conf.CodeModel;
222 else
223 CodeModel = M.getCodeModel();
225 std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
226 TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
227 CodeModel, Conf.CGOptLevel));
229 assert(TM && "Failed to create target machine");
231 if (std::optional<uint64_t> LargeDataThreshold = M.getLargeDataThreshold())
232 TM->setLargeDataThreshold(*LargeDataThreshold);
234 return TM;
237static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
238 unsigned OptLevel, bool IsThinLTO,
239 ModuleSummaryIndex *ExportSummary,
240 const ModuleSummaryIndex *ImportSummary) {
241 auto FS = vfs::getRealFileSystem();
242 std::optional<PGOOptions> PGOOpt;
243 if (!Conf.SampleProfile.empty())
244 PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping,
245 /*MemoryProfile=*/"", FS, PGOOptions::SampleUse,
248 else if (Conf.RunCSIRInstr) {
249 PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
250 /*MemoryProfile=*/"", FS, PGOOptions::IRUse,
252 Conf.AddFSDiscriminator);
253 } else if (!Conf.CSIRProfile.empty()) {
254 PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping,
255 /*MemoryProfile=*/"", FS, PGOOptions::IRUse,
257 Conf.AddFSDiscriminator);
259 } else if (Conf.AddFSDiscriminator) {
260 PGOOpt = PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,
263 }
264 TM->setPGOOption(PGOOpt);
272 StandardInstrumentations SI(Mod.getContext(), Conf.DebugPassManager,
273 Conf.VerifyEach);
274 SI.registerCallbacks(PIC, &MAM);
275 PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
279 std::unique_ptr<TargetLibraryInfoImpl> TLII(
280 new TargetLibraryInfoImpl(Triple(TM->getTargetTriple())));
281 if (Conf.Freestanding)
282 TLII->disableAllFunctions();
283 FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
285 // Parse a custom AA pipeline if asked to.
286 if (!Conf.AAPipeline.empty()) {
287 AAManager AA;
288 if (auto Err = PB.parseAAPipeline(AA, Conf.AAPipeline)) {
289 report_fatal_error(Twine("unable to parse AA pipeline description '") +
290 Conf.AAPipeline + "': " + toString(std::move(Err)));
291 }
292 // Register the AA manager first so that our version is the one used.
293 FAM.registerPass([&] { return std::move(AA); });
294 }
296 // Register all the basic analyses with the managers.
305 if (!Conf.DisableVerify)
310 switch (OptLevel) {
311 default:
312 llvm_unreachable("Invalid optimization level");
313 case 0:
315 break;
316 case 1:
318 break;
319 case 2:
321 break;
322 case 3:
324 break;
325 }
327 // Parse a custom pipeline if asked to.
328 if (!Conf.OptPipeline.empty()) {
329 if (auto Err = PB.parsePassPipeline(MPM, Conf.OptPipeline)) {
330 report_fatal_error(Twine("unable to parse pass pipeline description '") +
331 Conf.OptPipeline + "': " + toString(std::move(Err)));
332 }
333 } else if (IsThinLTO) {
334 MPM.addPass(PB.buildThinLTODefaultPipeline(OL, ImportSummary));
335 } else {
336 MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
337 }
339 if (!Conf.DisableVerify)
342 MPM.run(Mod, MAM);
345bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
346 bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
347 const ModuleSummaryIndex *ImportSummary,
348 const std::vector<uint8_t> &CmdArgs) {
349 if (EmbedBitcode == LTOBitcodeEmbedding::EmbedPostMergePreOptimized) {
350 // FIXME: the motivation for capturing post-merge bitcode and command line
351 // is replicating the compilation environment from bitcode, without needing
352 // to understand the dependencies (the functions to be imported). This
353 // assumes a clang - based invocation, case in which we have the command
354 // line.
355 // It's not very clear how the above motivation would map in the
356 // linker-based case, so we currently don't plumb the command line args in
357 // that case.
358 if (CmdArgs.empty())
360 dbgs() << "Post-(Thin)LTO merge bitcode embedding was requested, but "
361 "command line arguments are not available");
363 /*EmbedBitcode*/ true, /*EmbedCmdline*/ true,
364 /*Cmdline*/ CmdArgs);
365 }
366 // FIXME: Plumb the combined index into the new pass manager.
367 runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
368 ImportSummary);
369 return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
372static void codegen(const Config &Conf, TargetMachine *TM,
373 AddStreamFn AddStream, unsigned Task, Module &Mod,
374 const ModuleSummaryIndex &CombinedIndex) {
375 if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
376 return;
378 if (EmbedBitcode == LTOBitcodeEmbedding::EmbedOptimized)
380 /*EmbedBitcode*/ true,
381 /*EmbedCmdline*/ false,
382 /*CmdArgs*/ std::vector<uint8_t>());
384 std::unique_ptr<ToolOutputFile> DwoOut;
386 if (!Conf.DwoDir.empty()) {
387 std::error_code EC;
388 if (auto EC = llvm::sys::fs::create_directories(Conf.DwoDir))
389 report_fatal_error(Twine("Failed to create directory ") + Conf.DwoDir +
390 ": " + EC.message());
392 DwoFile = Conf.DwoDir;
393 sys::path::append(DwoFile, std::to_string(Task) + ".dwo");
394 TM->Options.MCOptions.SplitDwarfFile = std::string(DwoFile);
395 } else
396 TM->Options.MCOptions.SplitDwarfFile = Conf.SplitDwarfFile;
398 if (!DwoFile.empty()) {
399 std::error_code EC;
400 DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
401 if (EC)
402 report_fatal_error(Twine("Failed to open ") + DwoFile + ": " +
403 EC.message());
404 }
407 AddStream(Task, Mod.getModuleIdentifier());
408 if (Error Err = StreamOrErr.takeError())
409 report_fatal_error(std::move(Err));
410 std::unique_ptr<CachedFileStream> &Stream = *StreamOrErr;
411 TM->Options.ObjectFilenameForDebug = Stream->ObjectPathName;
413 legacy::PassManager CodeGenPasses;
414 TargetLibraryInfoImpl TLII(Triple(Mod.getTargetTriple()));
415 CodeGenPasses.add(new TargetLibraryInfoWrapperPass(TLII));
416 CodeGenPasses.add(
418 if (Conf.PreCodeGenPassesHook)
419 Conf.PreCodeGenPassesHook(CodeGenPasses);
420 if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
421 DwoOut ? &DwoOut->os() : nullptr,
422 Conf.CGFileType))
423 report_fatal_error("Failed to setup codegen");
424 CodeGenPasses.run(Mod);
426 if (DwoOut)
427 DwoOut->keep();
430static void splitCodeGen(const Config &C, TargetMachine *TM,
431 AddStreamFn AddStream,
432 unsigned ParallelCodeGenParallelismLevel, Module &Mod,
433 const ModuleSummaryIndex &CombinedIndex) {
434 DefaultThreadPool CodegenThreadPool(
435 heavyweight_hardware_concurrency(ParallelCodeGenParallelismLevel));
436 unsigned ThreadCount = 0;
437 const Target *T = &TM->getTarget();
439 const auto HandleModulePartition =
440 [&](std::unique_ptr<Module> MPart) {
441 // We want to clone the module in a new context to multi-thread the
442 // codegen. We do it by serializing partition modules to bitcode
443 // (while still on the main thread, in order to avoid data races) and
444 // spinning up new threads which deserialize the partitions into
445 // separate contexts.
446 // FIXME: Provide a more direct way to do this in LLVM.
448 raw_svector_ostream BCOS(BC);
449 WriteBitcodeToFile(*MPart, BCOS);
451 // Enqueue the task
452 CodegenThreadPool.async(
453 [&](const SmallString<0> &BC, unsigned ThreadId) {
454 LTOLLVMContext Ctx(C);
456 MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"),
457 Ctx);
458 if (!MOrErr)
459 report_fatal_error("Failed to read bitcode");
460 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
462 std::unique_ptr<TargetMachine> TM =
463 createTargetMachine(C, T, *MPartInCtx);
465 codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx,
466 CombinedIndex);
467 },
468 // Pass BC using std::move to ensure that it get moved rather than
469 // copied into the thread's context.
470 std::move(BC), ThreadCount++);
471 };
473 // Try target-specific module splitting first, then fallback to the default.
474 if (!TM->splitModule(Mod, ParallelCodeGenParallelismLevel,
475 HandleModulePartition)) {
476 SplitModule(Mod, ParallelCodeGenParallelismLevel, HandleModulePartition,
477 false);
478 }
480 // Because the inner lambda (which runs in a worker thread) captures our local
481 // variables, we need to wait for the worker threads to terminate before we
482 // can leave the function scope.
483 CodegenThreadPool.wait();
487 Module &Mod) {
488 if (!C.OverrideTriple.empty())
489 Mod.setTargetTriple(C.OverrideTriple);
490 else if (Mod.getTargetTriple().empty())
491 Mod.setTargetTriple(C.DefaultTriple);
493 std::string Msg;
494 const Target *T = TargetRegistry::lookupTarget(Mod.getTargetTriple(), Msg);
495 if (!T)
496 return make_error<StringError>(Msg, inconvertibleErrorCode());
497 return T;
501 std::unique_ptr<ToolOutputFile> DiagOutputFile) {
502 // Make sure we flush the diagnostic remarks file in case the linker doesn't
503 // call the global destructors before exiting.
504 if (!DiagOutputFile)
505 return Error::success();
506 DiagOutputFile->keep();
507 DiagOutputFile->os().flush();
508 return Error::success();
512 unsigned ParallelCodeGenParallelismLevel, Module &Mod,
513 ModuleSummaryIndex &CombinedIndex) {
515 if (!TOrErr)
516 return TOrErr.takeError();
518 std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, Mod);
520 LLVM_DEBUG(dbgs() << "Running regular LTO\n");
521 if (!C.CodeGenOnly) {
522 if (!opt(C, TM.get(), 0, Mod, /*IsThinLTO=*/false,
523 /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
524 /*CmdArgs*/ std::vector<uint8_t>()))
525 return Error::success();
526 }
528 if (ParallelCodeGenParallelismLevel == 1) {
529 codegen(C, TM.get(), AddStream, 0, Mod, CombinedIndex);
530 } else {
531 splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel, Mod,
532 CombinedIndex);
533 }
534 return Error::success();
537static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
538 const ModuleSummaryIndex &Index) {
539 std::vector<GlobalValue*> DeadGVs;
540 for (auto &GV : Mod.global_values())
541 if (GlobalValueSummary *GVS = DefinedGlobals.lookup(GV.getGUID()))
542 if (!Index.isGlobalValueLive(GVS)) {
543 DeadGVs.push_back(&GV);
545 }
547 // Now that all dead bodies have been dropped, delete the actual objects
548 // themselves when possible.
549 for (GlobalValue *GV : DeadGVs) {
550 GV->removeDeadConstantUsers();
551 // Might reference something defined in native object (i.e. dropped a
552 // non-prevailing IR def, but we need to keep the declaration).
553 if (GV->use_empty())
554 GV->eraseFromParent();
555 }
558Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
559 Module &Mod, const ModuleSummaryIndex &CombinedIndex,
560 const FunctionImporter::ImportMapTy &ImportList,
561 const GVSummaryMapTy &DefinedGlobals,
563 const std::vector<uint8_t> &CmdArgs) {
565 if (!TOrErr)
566 return TOrErr.takeError();
568 std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
570 // Setup optimization remarks.
571 auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
572 Mod.getContext(), Conf.RemarksFilename, Conf.RemarksPasses,
574 Task);
575 if (!DiagFileOrErr)
576 return DiagFileOrErr.takeError();
577 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
579 // Set the partial sample profile ratio in the profile summary module flag of
580 // the module, if applicable.
581 Mod.setPartialSampleProfileRatio(CombinedIndex);
583 LLVM_DEBUG(dbgs() << "Running ThinLTO\n");
584 if (Conf.CodeGenOnly) {
585 codegen(Conf, TM.get(), AddStream, Task, Mod, CombinedIndex);
586 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
587 }
589 if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
590 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
592 auto OptimizeAndCodegen =
593 [&](Module &Mod, TargetMachine *TM,
594 std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
595 if (!opt(Conf, TM, Task, Mod, /*IsThinLTO=*/true,
596 /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex,
597 CmdArgs))
598 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
600 codegen(Conf, TM, AddStream, Task, Mod, CombinedIndex);
601 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
602 };
605 return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
607 // When linking an ELF shared object, dso_local should be dropped. We
608 // conservatively do this for -fpic.
609 bool ClearDSOLocalOnDeclarations =
610 TM->getTargetTriple().isOSBinFormatELF() &&
611 TM->getRelocationModel() != Reloc::Static &&
612 Mod.getPIELevel() == PIELevel::Default;
613 renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
615 dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
617 thinLTOFinalizeInModule(Mod, DefinedGlobals, /*PropagateAttrs=*/true);
619 if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
620 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
622 if (!DefinedGlobals.empty())
623 thinLTOInternalizeModule(Mod, DefinedGlobals);
625 if (Conf.PostInternalizeModuleHook &&
626 !Conf.PostInternalizeModuleHook(Task, Mod))
627 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
629 auto ModuleLoader = [&](StringRef Identifier) {
630 assert(Mod.getContext().isODRUniquingDebugTypes() &&
631 "ODR Type uniquing should be enabled on the context");
632 if (ModuleMap) {
633 auto I = ModuleMap->find(Identifier);
634 assert(I != ModuleMap->end());
635 return I->second.getLazyModule(Mod.getContext(),
636 /*ShouldLazyLoadMetadata=*/true,
637 /*IsImporting*/ true);
638 }
641 llvm::MemoryBuffer::getFile(Identifier);
642 if (!MBOrErr)
643 return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
644 Twine("Error loading imported file ") + Identifier + " : ",
645 MBOrErr.getError()));
647 Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
648 if (!BMOrErr)
649 return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
650 Twine("Error loading imported file ") + Identifier + " : " +
651 toString(BMOrErr.takeError()),
655 BMOrErr->getLazyModule(Mod.getContext(),
656 /*ShouldLazyLoadMetadata=*/true,
657 /*IsImporting*/ true);
658 if (MOrErr)
659 (*MOrErr)->setOwnedMemoryBuffer(std::move(*MBOrErr));
660 return MOrErr;
661 };
663 FunctionImporter Importer(CombinedIndex, ModuleLoader,
664 ClearDSOLocalOnDeclarations);
665 if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
666 return Err;
668 // Do this after any importing so that imported code is updated.
669 updateMemProfAttributes(Mod, CombinedIndex);
672 if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
673 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
675 return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
679 if (ThinLTOAssumeMerged && BMs.size() == 1)
680 return BMs.begin();
682 for (BitcodeModule &BM : BMs) {
683 Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
684 if (LTOInfo && LTOInfo->IsThinLTO)
685 return &BM;
686 }
687 return nullptr;
692 if (!BMsOrErr)
693 return BMsOrErr.takeError();
695 // The bitcode file may contain multiple modules, we want the one that is
696 // marked as being the ThinLTO module.
697 if (const BitcodeModule *Bm = lto::findThinLTOModule(*BMsOrErr))
698 return *Bm;
700 return make_error<StringError>("Could not find module summary",
705 const ModuleSummaryIndex &CombinedIndex,
706 FunctionImporter::ImportMapTy &ImportList) {
708 return true;
709 // We can simply import the values mentioned in the combined index, since
710 // we should only invoke this using the individual indexes written out
711 // via a WriteIndexesThinBackend.
712 for (const auto &GlobalList : CombinedIndex) {
713 // Ignore entries for undefined references.
714 if (GlobalList.second.SummaryList.empty())
715 continue;
717 auto GUID = GlobalList.first;
718 for (const auto &Summary : GlobalList.second.SummaryList) {
719 // Skip the summaries for the importing module. These are included to
720 // e.g. record required linkage changes.
721 if (Summary->modulePath() == M.getModuleIdentifier())
722 continue;
723 // Add an entry to provoke importing by thinBackend.
724 ImportList[Summary->modulePath()].insert(GUID);
725 }
726 }
727 return true;
arm prera ldst opt
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This header provides classes for managing passes over SCCs of the call graph.
Definition: CommandLine.h:693
#define LLVM_DEBUG(X)
Definition: Debug.h:101
static cl::opt< bool > ThinLTOAssumeMerged("thinlto-assume-merged", cl::init(false), cl::desc("Assume the input has already undergone ThinLTO function " "importing and the other pre-optimization pipeline changes."))
static void reportOpenError(StringRef Path, Twine Msg)
Definition: LTOBackend.cpp:81
Definition: LTOBackend.cpp:55
static cl::opt< LTOBitcodeEmbedding > EmbedBitcode("lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed), cl::values(clEnumValN(LTOBitcodeEmbedding::DoNotEmbed, "none", "Do not embed"), clEnumValN(LTOBitcodeEmbedding::EmbedOptimized, "optimized", "Embed after all optimization passes"), clEnumValN(LTOBitcodeEmbedding::EmbedPostMergePreOptimized, "post-merge-pre-opt", "Embed post merge, but before optimizations")), cl::desc("Embed LLVM bitcode in object files produced by LTO"))
static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals, const ModuleSummaryIndex &Index)
Definition: LTOBackend.cpp:537
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
Definition: LTOBackend.cpp:486
static void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream, unsigned Task, Module &Mod, const ModuleSummaryIndex &CombinedIndex)
Definition: LTOBackend.cpp:372
static void RegisterPassPlugins(ArrayRef< std::string > PassPlugins, PassBuilder &PB)
Definition: LTOBackend.cpp:185
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM, unsigned OptLevel, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
Definition: LTOBackend.cpp:237
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
#define I(x, y, z)
Definition: MD5.cpp:58
This is the interface to build a ModuleSummaryIndex for a module.
static std::unique_ptr< TargetMachine > createTargetMachine(Function *F, CodeGenOptLevel OptLevel)
Create the TargetMachine object to query the backend for optimization preferences.
CGSCCAnalysisManager CGAM
ModulePassManager MPM
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
const char LLVMTargetMachineRef TM
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This header defines a class that provides bookkeeping for all standard (i.e in-tree) pass instrumenta...
Defines the virtual file system interface vfs::FileSystem.
A manager for alias analyses.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:321
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:535
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
Represents a module in a bitcode file.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:202
bool empty() const
Definition: DenseMap.h:98
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Represents either an error or a value T.
Definition: ErrorOr.h:56
std::error_code getError() const
Definition: ErrorOr.h:152
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
reference get()
Returns a reference to the stored T value.
Definition: Error.h:571
The function importer is automatically importing function from other modules based on the provided su...
Expected< bool > importFunctions(Module &M, const ImportMapTy &ImportList)
Import functions in Module M based on the supplied import list.
Function and variable summary information to aid decisions and implementation of importing.
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:36
iterator end()
Definition: MapVector.h:71
iterator find(const KeyT &Key)
Definition: MapVector.h:167
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,...
Class to hold module path string table and global value map, and encapsulate methods for operating on...
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
iterator begin() const
Definition: ArrayRef.h:356
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.
Definition: PassBuilder.h:104
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
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.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
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 void addPass(PassT &&Pass)
Definition: PassManager.h:249
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
Definition: PassManager.h:201
A loaded pass plugin.
Definition: PassPlugin.h:60
static Expected< PassPlugin > Load(const std::string &Filename)
Attempts to load a pass plugin from a given file.
Definition: PassPlugin.cpp:16
void registerPassBuilderCallbacks(PassBuilder &PB) const
Invoke the PassBuilder callback registration.
Definition: PassPlugin.h:82
A non-threaded implementation.
Definition: ThreadPool.h:218
void wait() override
Blocking wait for all the tasks to execute first.
Definition: ThreadPool.cpp:201
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:299
This class provides an interface to register all the standard pass instrumentations and manages their...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
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.
void AddFeature(StringRef String, bool Enable=true)
Adds Features.
Analysis pass providing the TargetLibraryInfo.
Implementation of the target library information.
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
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.
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:78
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Create a verifier pass.
Definition: Verifier.h:132
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
Definition: DenseSet.h:185
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.
Definition: raw_ostream.h:470
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:690
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.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:718
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
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.
Definition: LTOBackend.cpp:558
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
Definition: LTOBackend.cpp:678
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:511
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
Definition: LTOBackend.cpp:500
bool initImportList(const Module &M, const ModuleSummaryIndex &CombinedIndex, FunctionImporter::ImportMapTy &ImportList)
Distributed ThinLTO: collect the referenced modules based on module summary and initialize ImportList...
Definition: LTOBackend.cpp:704
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.
Definition: LTO.cpp:1871
bool opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary, const std::vector< uint8_t > &CmdArgs)
Runs middle-end LTO optimizations on Mod.
Definition: LTOBackend.cpp:345
void updateMemProfAttributes(Module &Mod, const ModuleSummaryIndex &Index)
Updates MemProf attributes (and metadata) based on whether the index has recorded that we are linking...
Definition: LTO.cpp:1186
@ OF_TextWithCRLF
The file should be opened in text mode and use a carriage linefeed '\r '.
Definition: FileSystem.h:768
std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
Definition: Path.cpp:968
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:457
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
ThreadPoolStrategy heavyweight_hardware_concurrency(unsigned ThreadCount=0)
Returns a thread strategy for tasks requiring significant memory or other resources.
Definition: Threading.h:162
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, ParserCallbacks Callbacks={})
Read the specified bitcode file, returning the module.
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.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
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::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.
Definition: Caching.h:42
bool convertToDeclaration(GlobalValue &GV)
Converts value GV to declaration, or replaces with a declaration if it is an alias.
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 embedBitcodeInModule(Module &M, MemoryBufferRef Buf, bool EmbedBitcode, bool EmbedCmdline, const std::vector< uint8_t > &CmdArgs)
If EmbedBitcode is set, save a copy of the llvm IR as data in the __LLVM,__bitcode section (....
void updatePublicTypeTestCalls(Module &M, bool WholeProgramVisibilityEnabledInLTO)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
Expected< std::vector< BitcodeModule > > getBitcodeModuleList(MemoryBufferRef Buffer)
Returns a list of modules in the specified bitcode buffer.
cl::opt< bool > NoPGOWarnMismatch
Definition: MemProfiler.cpp:55
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Mod
The access may modify the value stored in memory.
void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Internalize TheModule based on the information recorded in the summaries during global summary-based ...
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
void SplitModule(Module &M, unsigned N, function_ref< void(std::unique_ptr< Module > MPart)> ModuleCallback, bool PreserveLocals=false)
Splits the module M into N linkable partitions.
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:103
void splitCodeGen(Module &M, ArrayRef< raw_pwrite_stream * > OSs, ArrayRef< llvm::raw_pwrite_stream * > BCOSs, const std::function< std::unique_ptr< TargetMachine >()> &TMFactory, CodeGenFileType FileType=CodeGenFileType::ObjectFile, bool PreserveLocals=false)
Split M into OSs.size() partitions, and generate code for each.
Definition: ParallelCG.cpp:38
void thinLTOFinalizeInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals, bool PropagateAttrs)
Based on the information recorded in the summaries during global summary-based analysis:
A struct capturing PGO tunables.
Definition: PGOOptions.h:27
static const Target * lookupTarget(StringRef Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
LTO configuration.
Definition: Config.h:41
std::function< bool(unsigned Task, const Module &)> ModuleHookFn
The following callbacks deal with tasks, which normally represent the entire optimization and code ge...
Definition: Config.h:219
bool DebugPassManager
Whether to emit the pass manager debuggging informations.
Definition: Config.h:166
bool AddFSDiscriminator
Add FSAFDO discriminators.
Definition: Config.h:184
std::optional< uint64_t > RemarksHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
Definition: Config.h:160
Error addSaveTemps(std::string OutputFileName, bool UseInputModulePath=false, const DenseSet< StringRef > &SaveTempsArgs={})
This is a convenience function that configures this Config object to write temporary files named afte...
Definition: LTOBackend.cpp:87
ModuleHookFn PreOptModuleHook
This module hook is called after linking (regular LTO) or loading (ThinLTO) the module,...
Definition: Config.h:223
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:255
std::optional< CodeModel::Model > CodeModel
Definition: Config.h:56
std::string AAPipeline
Definition: Config.h:105
std::function< void(legacy::PassManager &)> PreCodeGenPassesHook
For adding passes that run right before codegen.
Definition: Config.h:54
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
Definition: Config.h:68
bool DisableVerify
Definition: Config.h:61
std::vector< std::string > MAttrs
Definition: Config.h:50
bool VerifyEach
Definition: Config.h:60
CodeGenOptLevel CGOptLevel
Definition: Config.h:57
PipelineTuningOptions PTO
Tunable parameters for passes in the default pipelines.
Definition: Config.h:193
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...
Definition: Config.h:190
std::string CPU
Definition: Config.h:48
std::string DwoDir
The directory to store .dwo files.
Definition: Config.h:125
std::string RemarksFilename
Optimization remarks file path.
Definition: Config.h:139
ModuleHookFn PostPromoteModuleHook
This hook is called after promoting any internal functions (ThinLTO-specific).
Definition: Config.h:227
std::string ProfileRemapping
Name remapping file for profile data.
Definition: Config.h:122
TargetOptions Options
Definition: Config.h:49
std::string SplitDwarfFile
The name for the split debug info file used for the DW_AT_[GNU_]dwo_name attribute in the skeleton CU...
Definition: Config.h:131
std::string SplitDwarfOutput
The path to write a .dwo file to.
Definition: Config.h:136
ModuleHookFn PostOptModuleHook
This module hook is called after optimization is complete.
Definition: Config.h:236
std::string RemarksPasses
Optimization remarks pass filter.
Definition: Config.h:142
std::string OptPipeline
If this field is set, the set of passes run in the middle-end optimizer will be the one specified by ...
Definition: Config.h:100
bool RunCSIRInstr
Run PGO context sensitive IR instrumentation.
Definition: Config.h:71
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
Definition: Config.h:230
unsigned OptLevel
Definition: Config.h:59
ModuleHookFn PostImportModuleHook
This hook is called after importing from other modules (ThinLTO-specific).
Definition: Config.h:233
bool RemarksWithHotness
Whether to emit optimization remarks with hotness informations.
Definition: Config.h:145
std::vector< std::string > PassPlugins
Definition: Config.h:52
std::string CSIRProfile
Context Sensitive PGO profile path.
Definition: Config.h:116
ModuleHookFn PreCodeGenModuleHook
This module hook is called before code generation.
Definition: Config.h:241
std::optional< Reloc::Model > RelocModel
Definition: Config.h:55
bool ShouldDiscardValueNames
Definition: Config.h:180
bool PGOWarnMismatch
Turn on/off the warning about a hash mismatch in the PGO profile data.
Definition: Config.h:74
CodeGenFileType CGFileType
Definition: Config.h:58
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.
Definition: Config.h:65
std::string SampleProfile
Sample PGO profile path.
Definition: Config.h:119
std::string RemarksFormat
The format used for serializing remarks (default: YAML).
Definition: Config.h:163
A derived class of LLVMContext that initializes itself according to a given Config object.
Definition: Config.h:294