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 (Conf.UseDefaultPipeline) {
335 } else if (IsThinLTO) {
336 MPM.addPass(PB.buildThinLTODefaultPipeline(OL, ImportSummary));
337 } else {
338 MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
339 }
341 if (!Conf.DisableVerify)
344 MPM.run(Mod, MAM);
347bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
348 bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
349 const ModuleSummaryIndex *ImportSummary,
350 const std::vector<uint8_t> &CmdArgs) {
351 if (EmbedBitcode == LTOBitcodeEmbedding::EmbedPostMergePreOptimized) {
352 // FIXME: the motivation for capturing post-merge bitcode and command line
353 // is replicating the compilation environment from bitcode, without needing
354 // to understand the dependencies (the functions to be imported). This
355 // assumes a clang - based invocation, case in which we have the command
356 // line.
357 // It's not very clear how the above motivation would map in the
358 // linker-based case, so we currently don't plumb the command line args in
359 // that case.
360 if (CmdArgs.empty())
362 dbgs() << "Post-(Thin)LTO merge bitcode embedding was requested, but "
363 "command line arguments are not available");
365 /*EmbedBitcode*/ true, /*EmbedCmdline*/ true,
366 /*Cmdline*/ CmdArgs);
367 }
368 // FIXME: Plumb the combined index into the new pass manager.
369 runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
370 ImportSummary);
371 return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
374static void codegen(const Config &Conf, TargetMachine *TM,
375 AddStreamFn AddStream, unsigned Task, Module &Mod,
376 const ModuleSummaryIndex &CombinedIndex) {
377 if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
378 return;
380 if (EmbedBitcode == LTOBitcodeEmbedding::EmbedOptimized)
382 /*EmbedBitcode*/ true,
383 /*EmbedCmdline*/ false,
384 /*CmdArgs*/ std::vector<uint8_t>());
386 std::unique_ptr<ToolOutputFile> DwoOut;
388 if (!Conf.DwoDir.empty()) {
389 std::error_code EC;
390 if (auto EC = llvm::sys::fs::create_directories(Conf.DwoDir))
391 report_fatal_error(Twine("Failed to create directory ") + Conf.DwoDir +
392 ": " + EC.message());
394 DwoFile = Conf.DwoDir;
395 sys::path::append(DwoFile, std::to_string(Task) + ".dwo");
396 TM->Options.MCOptions.SplitDwarfFile = std::string(DwoFile);
397 } else
398 TM->Options.MCOptions.SplitDwarfFile = Conf.SplitDwarfFile;
400 if (!DwoFile.empty()) {
401 std::error_code EC;
402 DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
403 if (EC)
404 report_fatal_error(Twine("Failed to open ") + DwoFile + ": " +
405 EC.message());
406 }
409 AddStream(Task, Mod.getModuleIdentifier());
410 if (Error Err = StreamOrErr.takeError())
411 report_fatal_error(std::move(Err));
412 std::unique_ptr<CachedFileStream> &Stream = *StreamOrErr;
413 TM->Options.ObjectFilenameForDebug = Stream->ObjectPathName;
415 legacy::PassManager CodeGenPasses;
416 TargetLibraryInfoImpl TLII(Triple(Mod.getTargetTriple()));
417 CodeGenPasses.add(new TargetLibraryInfoWrapperPass(TLII));
418 CodeGenPasses.add(
420 if (Conf.PreCodeGenPassesHook)
421 Conf.PreCodeGenPassesHook(CodeGenPasses);
422 if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
423 DwoOut ? &DwoOut->os() : nullptr,
424 Conf.CGFileType))
425 report_fatal_error("Failed to setup codegen");
426 CodeGenPasses.run(Mod);
428 if (DwoOut)
429 DwoOut->keep();
432static void splitCodeGen(const Config &C, TargetMachine *TM,
433 AddStreamFn AddStream,
434 unsigned ParallelCodeGenParallelismLevel, Module &Mod,
435 const ModuleSummaryIndex &CombinedIndex) {
436 ThreadPool CodegenThreadPool(
437 heavyweight_hardware_concurrency(ParallelCodeGenParallelismLevel));
438 unsigned ThreadCount = 0;
439 const Target *T = &TM->getTarget();
442 Mod, ParallelCodeGenParallelismLevel,
443 [&](std::unique_ptr<Module> MPart) {
444 // We want to clone the module in a new context to multi-thread the
445 // codegen. We do it by serializing partition modules to bitcode
446 // (while still on the main thread, in order to avoid data races) and
447 // spinning up new threads which deserialize the partitions into
448 // separate contexts.
449 // FIXME: Provide a more direct way to do this in LLVM.
451 raw_svector_ostream BCOS(BC);
452 WriteBitcodeToFile(*MPart, BCOS);
454 // Enqueue the task
455 CodegenThreadPool.async(
456 [&](const SmallString<0> &BC, unsigned ThreadId) {
457 LTOLLVMContext Ctx(C);
459 MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"),
460 Ctx);
461 if (!MOrErr)
462 report_fatal_error("Failed to read bitcode");
463 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
465 std::unique_ptr<TargetMachine> TM =
466 createTargetMachine(C, T, *MPartInCtx);
468 codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx,
469 CombinedIndex);
470 },
471 // Pass BC using std::move to ensure that it get moved rather than
472 // copied into the thread's context.
473 std::move(BC), ThreadCount++);
474 },
475 false);
477 // Because the inner lambda (which runs in a worker thread) captures our local
478 // variables, we need to wait for the worker threads to terminate before we
479 // can leave the function scope.
480 CodegenThreadPool.wait();
484 Module &Mod) {
485 if (!C.OverrideTriple.empty())
486 Mod.setTargetTriple(C.OverrideTriple);
487 else if (Mod.getTargetTriple().empty())
488 Mod.setTargetTriple(C.DefaultTriple);
490 std::string Msg;
491 const Target *T = TargetRegistry::lookupTarget(Mod.getTargetTriple(), Msg);
492 if (!T)
493 return make_error<StringError>(Msg, inconvertibleErrorCode());
494 return T;
498 std::unique_ptr<ToolOutputFile> DiagOutputFile) {
499 // Make sure we flush the diagnostic remarks file in case the linker doesn't
500 // call the global destructors before exiting.
501 if (!DiagOutputFile)
502 return Error::success();
503 DiagOutputFile->keep();
504 DiagOutputFile->os().flush();
505 return Error::success();
509 unsigned ParallelCodeGenParallelismLevel, Module &Mod,
510 ModuleSummaryIndex &CombinedIndex) {
512 if (!TOrErr)
513 return TOrErr.takeError();
515 std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, Mod);
517 LLVM_DEBUG(dbgs() << "Running regular LTO\n");
518 if (!C.CodeGenOnly) {
519 if (!opt(C, TM.get(), 0, Mod, /*IsThinLTO=*/false,
520 /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
521 /*CmdArgs*/ std::vector<uint8_t>()))
522 return Error::success();
523 }
525 if (ParallelCodeGenParallelismLevel == 1) {
526 codegen(C, TM.get(), AddStream, 0, Mod, CombinedIndex);
527 } else {
528 splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel, Mod,
529 CombinedIndex);
530 }
531 return Error::success();
534static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
535 const ModuleSummaryIndex &Index) {
536 std::vector<GlobalValue*> DeadGVs;
537 for (auto &GV : Mod.global_values())
538 if (GlobalValueSummary *GVS = DefinedGlobals.lookup(GV.getGUID()))
539 if (!Index.isGlobalValueLive(GVS)) {
540 DeadGVs.push_back(&GV);
542 }
544 // Now that all dead bodies have been dropped, delete the actual objects
545 // themselves when possible.
546 for (GlobalValue *GV : DeadGVs) {
547 GV->removeDeadConstantUsers();
548 // Might reference something defined in native object (i.e. dropped a
549 // non-prevailing IR def, but we need to keep the declaration).
550 if (GV->use_empty())
551 GV->eraseFromParent();
552 }
555Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
556 Module &Mod, const ModuleSummaryIndex &CombinedIndex,
557 const FunctionImporter::ImportMapTy &ImportList,
558 const GVSummaryMapTy &DefinedGlobals,
560 const std::vector<uint8_t> &CmdArgs) {
562 if (!TOrErr)
563 return TOrErr.takeError();
565 std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
567 // Setup optimization remarks.
568 auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
569 Mod.getContext(), Conf.RemarksFilename, Conf.RemarksPasses,
571 Task);
572 if (!DiagFileOrErr)
573 return DiagFileOrErr.takeError();
574 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
576 // Set the partial sample profile ratio in the profile summary module flag of
577 // the module, if applicable.
578 Mod.setPartialSampleProfileRatio(CombinedIndex);
580 LLVM_DEBUG(dbgs() << "Running ThinLTO\n");
581 if (Conf.CodeGenOnly) {
582 codegen(Conf, TM.get(), AddStream, Task, Mod, CombinedIndex);
583 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
584 }
586 if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
587 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
589 auto OptimizeAndCodegen =
590 [&](Module &Mod, TargetMachine *TM,
591 std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
592 if (!opt(Conf, TM, Task, Mod, /*IsThinLTO=*/true,
593 /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex,
594 CmdArgs))
595 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
597 codegen(Conf, TM, AddStream, Task, Mod, CombinedIndex);
598 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
599 };
602 return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
604 // When linking an ELF shared object, dso_local should be dropped. We
605 // conservatively do this for -fpic.
606 bool ClearDSOLocalOnDeclarations =
607 TM->getTargetTriple().isOSBinFormatELF() &&
608 TM->getRelocationModel() != Reloc::Static &&
609 Mod.getPIELevel() == PIELevel::Default;
610 renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
612 dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
614 thinLTOFinalizeInModule(Mod, DefinedGlobals, /*PropagateAttrs=*/true);
616 if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
617 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
619 if (!DefinedGlobals.empty())
620 thinLTOInternalizeModule(Mod, DefinedGlobals);
622 if (Conf.PostInternalizeModuleHook &&
623 !Conf.PostInternalizeModuleHook(Task, Mod))
624 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
626 auto ModuleLoader = [&](StringRef Identifier) {
627 assert(Mod.getContext().isODRUniquingDebugTypes() &&
628 "ODR Type uniquing should be enabled on the context");
629 if (ModuleMap) {
630 auto I = ModuleMap->find(Identifier);
631 assert(I != ModuleMap->end());
632 return I->second.getLazyModule(Mod.getContext(),
633 /*ShouldLazyLoadMetadata=*/true,
634 /*IsImporting*/ true);
635 }
638 llvm::MemoryBuffer::getFile(Identifier);
639 if (!MBOrErr)
640 return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
641 Twine("Error loading imported file ") + Identifier + " : ",
642 MBOrErr.getError()));
644 Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
645 if (!BMOrErr)
646 return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
647 Twine("Error loading imported file ") + Identifier + " : " +
648 toString(BMOrErr.takeError()),
652 BMOrErr->getLazyModule(Mod.getContext(),
653 /*ShouldLazyLoadMetadata=*/true,
654 /*IsImporting*/ true);
655 if (MOrErr)
656 (*MOrErr)->setOwnedMemoryBuffer(std::move(*MBOrErr));
657 return MOrErr;
658 };
660 FunctionImporter Importer(CombinedIndex, ModuleLoader,
661 ClearDSOLocalOnDeclarations);
662 if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
663 return Err;
665 // Do this after any importing so that imported code is updated.
666 updateMemProfAttributes(Mod, CombinedIndex);
669 if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
670 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
672 return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
676 if (ThinLTOAssumeMerged && BMs.size() == 1)
677 return BMs.begin();
679 for (BitcodeModule &BM : BMs) {
680 Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
681 if (LTOInfo && LTOInfo->IsThinLTO)
682 return &BM;
683 }
684 return nullptr;
689 if (!BMsOrErr)
690 return BMsOrErr.takeError();
692 // The bitcode file may contain multiple modules, we want the one that is
693 // marked as being the ThinLTO module.
694 if (const BitcodeModule *Bm = lto::findThinLTOModule(*BMsOrErr))
695 return *Bm;
697 return make_error<StringError>("Could not find module summary",
702 const ModuleSummaryIndex &CombinedIndex,
703 FunctionImporter::ImportMapTy &ImportList) {
705 return true;
706 // We can simply import the values mentioned in the combined index, since
707 // we should only invoke this using the individual indexes written out
708 // via a WriteIndexesThinBackend.
709 for (const auto &GlobalList : CombinedIndex) {
710 // Ignore entries for undefined references.
711 if (GlobalList.second.SummaryList.empty())
712 continue;
714 auto GUID = GlobalList.first;
715 for (const auto &Summary : GlobalList.second.SummaryList) {
716 // Skip the summaries for the importing module. These are included to
717 // e.g. record required linkage changes.
718 if (Summary->modulePath() == M.getModuleIdentifier())
719 continue;
720 // Add an entry to provoke importing by thinBackend.
721 ImportList[Summary->modulePath()].insert(GUID);
722 }
723 }
724 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:534
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
Definition: LTOBackend.cpp:483
static void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream, unsigned Task, Module &Mod, const ModuleSummaryIndex &CombinedIndex)
Definition: LTOBackend.cpp:374
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:348
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:562
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)
Cross register the analysis managers through their proxies.
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build a per-module default optimization pipeline.
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 an ThinLTO default optimization pipeline to a pass manager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
Definition: PassManager.h:273
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:218
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
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:78
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.
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:52
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
Definition: ThreadPool.cpp:202
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
Definition: ThreadPool.h:66
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:555
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
Definition: LTOBackend.cpp:675
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:508
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
Definition: LTOBackend.cpp:497
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:701
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:1854
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:347
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:1184
@ 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:969
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:458
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:222
bool DebugPassManager
Whether to emit the pass manager debuggging informations.
Definition: Config.h:169
bool AddFSDiscriminator
Add FSAFDO discriminators.
Definition: Config.h:187
std::optional< uint64_t > RemarksHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
Definition: Config.h:163
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:226
CombinedIndexHookFn CombinedIndexHook
Definition: Config.h:258
std::optional< CodeModel::Model > CodeModel
Definition: Config.h:56
std::string AAPipeline
Definition: Config.h:108
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:71
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:196
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:193
std::string CPU
Definition: Config.h:48
std::string DwoDir
The directory to store .dwo files.
Definition: Config.h:128
std::string RemarksFilename
Optimization remarks file path.
Definition: Config.h:142
bool UseDefaultPipeline
Use the standard optimization pipeline.
Definition: Config.h:64
ModuleHookFn PostPromoteModuleHook
This hook is called after promoting any internal functions (ThinLTO-specific).
Definition: Config.h:230
std::string ProfileRemapping
Name remapping file for profile data.
Definition: Config.h:125
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:134
std::string SplitDwarfOutput
The path to write a .dwo file to.
Definition: Config.h:139
ModuleHookFn PostOptModuleHook
This module hook is called after optimization is complete.
Definition: Config.h:239
std::string RemarksPasses
Optimization remarks pass filter.
Definition: Config.h:145
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:103
bool RunCSIRInstr
Run PGO context sensitive IR instrumentation.
Definition: Config.h:74
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
Definition: Config.h:233
unsigned OptLevel
Definition: Config.h:59
ModuleHookFn PostImportModuleHook
This hook is called after importing from other modules (ThinLTO-specific).
Definition: Config.h:236
bool RemarksWithHotness
Whether to emit optimization remarks with hotness informations.
Definition: Config.h:148
std::vector< std::string > PassPlugins
Definition: Config.h:52
std::string CSIRProfile
Context Sensitive PGO profile path.
Definition: Config.h:119
ModuleHookFn PreCodeGenModuleHook
This module hook is called before code generation.
Definition: Config.h:244
std::optional< Reloc::Model > RelocModel
Definition: Config.h:55
bool ShouldDiscardValueNames
Definition: Config.h:183
bool PGOWarnMismatch
Turn on/off the warning about a hash mismatch in the PGO profile data.
Definition: Config.h:77
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:68
std::string SampleProfile
Sample PGO profile path.
Definition: Config.h:122
std::string RemarksFormat
The format used for serializing remarks (default: YAML).
Definition: Config.h:166
A derived class of LLVMContext that initializes itself according to a given Config object.
Definition: Config.h:297