LLVM 19.0.0git
LTOBackend.cpp
Go to the documentation of this file.
1//===-LTOBackend.cpp - LLVM Link Time Optimizer Backend -------------------===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
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.
13//
14//===----------------------------------------------------------------------===//
15
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>
49
50using namespace llvm;
51using namespace lto;
52
53#define DEBUG_TYPE "lto-backend"
54
56 DoNotEmbed = 0,
59};
60
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"));
71
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."));
76
77namespace llvm {
79}
80
81[[noreturn]] static void reportOpenError(StringRef Path, Twine Msg) {
82 errs() << "failed to open " << Path << ": " << Msg << '\n';
83 errs().flush();
84 exit(1);
85}
86
87Error Config::addSaveTemps(std::string OutputFileName, bool UseInputModulePath,
88 const DenseSet<StringRef> &SaveTempsArgs) {
90
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 }
101
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;
110
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 };
132
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());
144
145 Path = OutputFileName + "index.dot";
147 if (EC)
148 reportOpenError(Path, EC.message());
149 Index.exportToDot(OSDot, GUIDPreservedSymbols);
150 return true;
151 };
152
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 }
177
178 return Error::success();
179}
180
181#define HANDLE_EXTENSION(Ext) \
182 llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
183#include "llvm/Support/Extension.def"
184
186 PassBuilder &PB) {
187#define HANDLE_EXTENSION(Ext) \
188 get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
189#include "llvm/Support/Extension.def"
190
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 }
199
201 }
202}
203
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);
211
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_;
218
219 std::optional<CodeModel::Model> CodeModel;
220 if (Conf.CodeModel)
221 CodeModel = *Conf.CodeModel;
222 else
223 CodeModel = M.getCodeModel();
224
225 std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
226 TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
227 CodeModel, Conf.CGOptLevel));
228
229 assert(TM && "Failed to create target machine");
230
231 if (std::optional<uint64_t> LargeDataThreshold = M.getLargeDataThreshold())
232 TM->setLargeDataThreshold(*LargeDataThreshold);
233
234 return TM;
235}
236
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);
265
270
272 StandardInstrumentations SI(Mod.getContext(), Conf.DebugPassManager,
273 Conf.VerifyEach);
274 SI.registerCallbacks(PIC, &MAM);
275 PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
276
278
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); });
284
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 }
295
296 // Register all the basic analyses with the managers.
302
304
305 if (!Conf.DisableVerify)
307
309
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 }
326
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 }
338
339 if (!Conf.DisableVerify)
341
342 MPM.run(Mod, MAM);
343}
344
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);
370}
371
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;
377
378 if (EmbedBitcode == LTOBitcodeEmbedding::EmbedOptimized)
380 /*EmbedBitcode*/ true,
381 /*EmbedCmdline*/ false,
382 /*CmdArgs*/ std::vector<uint8_t>());
383
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());
391
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;
397
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 }
405
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;
412
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);
425
426 if (DwoOut)
427 DwoOut->keep();
428}
429
430static void splitCodeGen(const Config &C, TargetMachine *TM,
431 AddStreamFn AddStream,
432 unsigned ParallelCodeGenParallelismLevel, Module &Mod,
433 const ModuleSummaryIndex &CombinedIndex) {
434 ThreadPool CodegenThreadPool(
435 heavyweight_hardware_concurrency(ParallelCodeGenParallelismLevel));
436 unsigned ThreadCount = 0;
437 const Target *T = &TM->getTarget();
438
440 Mod, ParallelCodeGenParallelismLevel,
441 [&](std::unique_ptr<Module> MPart) {
442 // We want to clone the module in a new context to multi-thread the
443 // codegen. We do it by serializing partition modules to bitcode
444 // (while still on the main thread, in order to avoid data races) and
445 // spinning up new threads which deserialize the partitions into
446 // separate contexts.
447 // FIXME: Provide a more direct way to do this in LLVM.
449 raw_svector_ostream BCOS(BC);
450 WriteBitcodeToFile(*MPart, BCOS);
451
452 // Enqueue the task
453 CodegenThreadPool.async(
454 [&](const SmallString<0> &BC, unsigned ThreadId) {
455 LTOLLVMContext Ctx(C);
457 MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"),
458 Ctx);
459 if (!MOrErr)
460 report_fatal_error("Failed to read bitcode");
461 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
462
463 std::unique_ptr<TargetMachine> TM =
464 createTargetMachine(C, T, *MPartInCtx);
465
466 codegen(C, TM.get(), AddStream, ThreadId, *MPartInCtx,
467 CombinedIndex);
468 },
469 // Pass BC using std::move to ensure that it get moved rather than
470 // copied into the thread's context.
471 std::move(BC), ThreadCount++);
472 },
473 false);
474
475 // Because the inner lambda (which runs in a worker thread) captures our local
476 // variables, we need to wait for the worker threads to terminate before we
477 // can leave the function scope.
478 CodegenThreadPool.wait();
479}
480
482 Module &Mod) {
483 if (!C.OverrideTriple.empty())
484 Mod.setTargetTriple(C.OverrideTriple);
485 else if (Mod.getTargetTriple().empty())
486 Mod.setTargetTriple(C.DefaultTriple);
487
488 std::string Msg;
489 const Target *T = TargetRegistry::lookupTarget(Mod.getTargetTriple(), Msg);
490 if (!T)
491 return make_error<StringError>(Msg, inconvertibleErrorCode());
492 return T;
493}
494
496 std::unique_ptr<ToolOutputFile> DiagOutputFile) {
497 // Make sure we flush the diagnostic remarks file in case the linker doesn't
498 // call the global destructors before exiting.
499 if (!DiagOutputFile)
500 return Error::success();
501 DiagOutputFile->keep();
502 DiagOutputFile->os().flush();
503 return Error::success();
504}
505
507 unsigned ParallelCodeGenParallelismLevel, Module &Mod,
508 ModuleSummaryIndex &CombinedIndex) {
510 if (!TOrErr)
511 return TOrErr.takeError();
512
513 std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, Mod);
514
515 LLVM_DEBUG(dbgs() << "Running regular LTO\n");
516 if (!C.CodeGenOnly) {
517 if (!opt(C, TM.get(), 0, Mod, /*IsThinLTO=*/false,
518 /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
519 /*CmdArgs*/ std::vector<uint8_t>()))
520 return Error::success();
521 }
522
523 if (ParallelCodeGenParallelismLevel == 1) {
524 codegen(C, TM.get(), AddStream, 0, Mod, CombinedIndex);
525 } else {
526 splitCodeGen(C, TM.get(), AddStream, ParallelCodeGenParallelismLevel, Mod,
527 CombinedIndex);
528 }
529 return Error::success();
530}
531
532static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals,
533 const ModuleSummaryIndex &Index) {
534 std::vector<GlobalValue*> DeadGVs;
535 for (auto &GV : Mod.global_values())
536 if (GlobalValueSummary *GVS = DefinedGlobals.lookup(GV.getGUID()))
537 if (!Index.isGlobalValueLive(GVS)) {
538 DeadGVs.push_back(&GV);
540 }
541
542 // Now that all dead bodies have been dropped, delete the actual objects
543 // themselves when possible.
544 for (GlobalValue *GV : DeadGVs) {
545 GV->removeDeadConstantUsers();
546 // Might reference something defined in native object (i.e. dropped a
547 // non-prevailing IR def, but we need to keep the declaration).
548 if (GV->use_empty())
549 GV->eraseFromParent();
550 }
551}
552
553Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
554 Module &Mod, const ModuleSummaryIndex &CombinedIndex,
555 const FunctionImporter::ImportMapTy &ImportList,
556 const GVSummaryMapTy &DefinedGlobals,
558 const std::vector<uint8_t> &CmdArgs) {
560 if (!TOrErr)
561 return TOrErr.takeError();
562
563 std::unique_ptr<TargetMachine> TM = createTargetMachine(Conf, *TOrErr, Mod);
564
565 // Setup optimization remarks.
566 auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
567 Mod.getContext(), Conf.RemarksFilename, Conf.RemarksPasses,
569 Task);
570 if (!DiagFileOrErr)
571 return DiagFileOrErr.takeError();
572 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
573
574 // Set the partial sample profile ratio in the profile summary module flag of
575 // the module, if applicable.
576 Mod.setPartialSampleProfileRatio(CombinedIndex);
577
578 LLVM_DEBUG(dbgs() << "Running ThinLTO\n");
579 if (Conf.CodeGenOnly) {
580 codegen(Conf, TM.get(), AddStream, Task, Mod, CombinedIndex);
581 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
582 }
583
584 if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
585 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
586
587 auto OptimizeAndCodegen =
588 [&](Module &Mod, TargetMachine *TM,
589 std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
590 if (!opt(Conf, TM, Task, Mod, /*IsThinLTO=*/true,
591 /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex,
592 CmdArgs))
593 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
594
595 codegen(Conf, TM, AddStream, Task, Mod, CombinedIndex);
596 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
597 };
598
600 return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
601
602 // When linking an ELF shared object, dso_local should be dropped. We
603 // conservatively do this for -fpic.
604 bool ClearDSOLocalOnDeclarations =
605 TM->getTargetTriple().isOSBinFormatELF() &&
606 TM->getRelocationModel() != Reloc::Static &&
607 Mod.getPIELevel() == PIELevel::Default;
608 renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
609
610 dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
611
612 thinLTOFinalizeInModule(Mod, DefinedGlobals, /*PropagateAttrs=*/true);
613
614 if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
615 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
616
617 if (!DefinedGlobals.empty())
618 thinLTOInternalizeModule(Mod, DefinedGlobals);
619
620 if (Conf.PostInternalizeModuleHook &&
621 !Conf.PostInternalizeModuleHook(Task, Mod))
622 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
623
624 auto ModuleLoader = [&](StringRef Identifier) {
625 assert(Mod.getContext().isODRUniquingDebugTypes() &&
626 "ODR Type uniquing should be enabled on the context");
627 if (ModuleMap) {
628 auto I = ModuleMap->find(Identifier);
629 assert(I != ModuleMap->end());
630 return I->second.getLazyModule(Mod.getContext(),
631 /*ShouldLazyLoadMetadata=*/true,
632 /*IsImporting*/ true);
633 }
634
636 llvm::MemoryBuffer::getFile(Identifier);
637 if (!MBOrErr)
638 return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
639 Twine("Error loading imported file ") + Identifier + " : ",
640 MBOrErr.getError()));
641
642 Expected<BitcodeModule> BMOrErr = findThinLTOModule(**MBOrErr);
643 if (!BMOrErr)
644 return Expected<std::unique_ptr<llvm::Module>>(make_error<StringError>(
645 Twine("Error loading imported file ") + Identifier + " : " +
646 toString(BMOrErr.takeError()),
648
650 BMOrErr->getLazyModule(Mod.getContext(),
651 /*ShouldLazyLoadMetadata=*/true,
652 /*IsImporting*/ true);
653 if (MOrErr)
654 (*MOrErr)->setOwnedMemoryBuffer(std::move(*MBOrErr));
655 return MOrErr;
656 };
657
658 FunctionImporter Importer(CombinedIndex, ModuleLoader,
659 ClearDSOLocalOnDeclarations);
660 if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
661 return Err;
662
663 // Do this after any importing so that imported code is updated.
664 updateMemProfAttributes(Mod, CombinedIndex);
666
667 if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
668 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
669
670 return OptimizeAndCodegen(Mod, TM.get(), std::move(DiagnosticOutputFile));
671}
672
674 if (ThinLTOAssumeMerged && BMs.size() == 1)
675 return BMs.begin();
676
677 for (BitcodeModule &BM : BMs) {
678 Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
679 if (LTOInfo && LTOInfo->IsThinLTO)
680 return &BM;
681 }
682 return nullptr;
683}
684
687 if (!BMsOrErr)
688 return BMsOrErr.takeError();
689
690 // The bitcode file may contain multiple modules, we want the one that is
691 // marked as being the ThinLTO module.
692 if (const BitcodeModule *Bm = lto::findThinLTOModule(*BMsOrErr))
693 return *Bm;
694
695 return make_error<StringError>("Could not find module summary",
697}
698
700 const ModuleSummaryIndex &CombinedIndex,
701 FunctionImporter::ImportMapTy &ImportList) {
703 return true;
704 // We can simply import the values mentioned in the combined index, since
705 // we should only invoke this using the individual indexes written out
706 // via a WriteIndexesThinBackend.
707 for (const auto &GlobalList : CombinedIndex) {
708 // Ignore entries for undefined references.
709 if (GlobalList.second.SummaryList.empty())
710 continue;
711
712 auto GUID = GlobalList.first;
713 for (const auto &Summary : GlobalList.second.SummaryList) {
714 // Skip the summaries for the importing module. These are included to
715 // e.g. record required linkage changes.
716 if (Summary->modulePath() == M.getModuleIdentifier())
717 continue;
718 // Add an entry to provoke importing by thinBackend.
719 ImportList[Summary->modulePath()].insert(GUID);
720 }
721 }
722 return true;
723}
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.
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
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
LTOBitcodeEmbedding
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:532
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
Definition: LTOBackend.cpp:481
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: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, 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 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: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.
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:553
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
Definition: LTOBackend.cpp:673
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
Definition: LTOBackend.cpp:506
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
Definition: LTOBackend.cpp:495
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:699
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:1869
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: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: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