19#include "llvm/ADT/SmallSet.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/ADT/StringSwitch.h"
22#include "llvm/Analysis/AliasAnalysis.h"
23#include "llvm/Analysis/GlobalsModRef.h"
24#include "llvm/Analysis/TargetLibraryInfo.h"
25#include "llvm/Analysis/TargetTransformInfo.h"
26#include "llvm/Bitcode/BitcodeReader.h"
27#include "llvm/Bitcode/BitcodeWriter.h"
28#include "llvm/Bitcode/BitcodeWriterPass.h"
29#include "llvm/CodeGen/RegAllocRegistry.h"
30#include "llvm/CodeGen/SchedulerRegistry.h"
31#include "llvm/CodeGen/TargetSubtargetInfo.h"
32#include "llvm/Frontend/Driver/CodeGenOptions.h"
33#include "llvm/IR/DataLayout.h"
34#include "llvm/IR/DebugInfo.h"
35#include "llvm/IR/LegacyPassManager.h"
36#include "llvm/IR/Module.h"
37#include "llvm/IR/ModuleSummaryIndex.h"
38#include "llvm/IR/PassManager.h"
39#include "llvm/IR/Verifier.h"
40#include "llvm/IRPrinter/IRPrintingPasses.h"
41#include "llvm/LTO/LTOBackend.h"
42#include "llvm/MC/MCAsmInfo.h"
43#include "llvm/MC/TargetRegistry.h"
44#include "llvm/Object/OffloadBinary.h"
45#include "llvm/Passes/PassBuilder.h"
46#include "llvm/Passes/PassPlugin.h"
47#include "llvm/Passes/StandardInstrumentations.h"
48#include "llvm/ProfileData/InstrProfCorrelator.h"
49#include "llvm/Support/BuryPointer.h"
50#include "llvm/Support/CommandLine.h"
51#include "llvm/Support/MemoryBuffer.h"
52#include "llvm/Support/PrettyStackTrace.h"
53#include "llvm/Support/TimeProfiler.h"
54#include "llvm/Support/Timer.h"
55#include "llvm/Support/ToolOutputFile.h"
56#include "llvm/Support/VirtualFileSystem.h"
57#include "llvm/Support/raw_ostream.h"
58#include "llvm/Target/TargetMachine.h"
59#include "llvm/Target/TargetOptions.h"
60#include "llvm/TargetParser/SubtargetFeature.h"
61#include "llvm/TargetParser/Triple.h"
62#include "llvm/Transforms/HipStdPar/HipStdPar.h"
63#include "llvm/Transforms/IPO/EmbedBitcodePass.h"
64#include "llvm/Transforms/IPO/LowerTypeTests.h"
65#include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
66#include "llvm/Transforms/InstCombine/InstCombine.h"
67#include "llvm/Transforms/Instrumentation.h"
68#include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
69#include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
70#include "llvm/Transforms/Instrumentation/BoundsChecking.h"
71#include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
72#include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
73#include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
74#include "llvm/Transforms/Instrumentation/InstrProfiling.h"
75#include "llvm/Transforms/Instrumentation/KCFI.h"
76#include "llvm/Transforms/Instrumentation/LowerAllowCheckPass.h"
77#include "llvm/Transforms/Instrumentation/MemProfiler.h"
78#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
79#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
80#include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
81#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
82#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
83#include "llvm/Transforms/ObjCARC.h"
84#include "llvm/Transforms/Scalar/EarlyCSE.h"
85#include "llvm/Transforms/Scalar/GVN.h"
86#include "llvm/Transforms/Scalar/JumpThreading.h"
87#include "llvm/Transforms/Utils/Debugify.h"
88#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
89#include "llvm/Transforms/Utils/ModuleUtils.h"
95#define HANDLE_EXTENSION(Ext) \
96 llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
97#include "llvm/Support/Extension.def"
104 "sanitizer-early-opt-ep", cl::Optional,
105 cl::desc(
"Insert sanitizers on OptimizerEarlyEP."));
110 "pgo-cold-func-opt", cl::init(PGOOptions::ColdFuncOpt::Default), cl::Hidden,
112 "Function attribute to apply to cold functions as determined by PGO"),
113 cl::values(clEnumValN(PGOOptions::ColdFuncOpt::Default,
"default",
114 "Default (no attribute)"),
115 clEnumValN(PGOOptions::ColdFuncOpt::OptSize,
"optsize",
116 "Mark cold functions with optsize."),
117 clEnumValN(PGOOptions::ColdFuncOpt::MinSize,
"minsize",
118 "Mark cold functions with minsize."),
119 clEnumValN(PGOOptions::ColdFuncOpt::OptNone,
"optnone",
120 "Mark cold functions with optnone.")));
128std::string getDefaultProfileGenName() {
130 ?
"default_%m.proflite"
131 :
"default_%m.profraw";
134class EmitAssemblyHelper {
140 llvm::Module *TheModule;
143 Timer CodeGenerationTime;
145 std::unique_ptr<raw_pwrite_stream> OS;
149 TargetIRAnalysis getTargetIRAnalysis()
const {
151 return TM->getTargetIRAnalysis();
153 return TargetIRAnalysis();
164 void CreateTargetMachine(
bool MustCreateTM);
169 bool AddEmitPasses(legacy::PassManager &CodeGenPasses,
BackendAction Action,
170 raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);
172 std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {
174 auto F = std::make_unique<llvm::ToolOutputFile>(Path, EC,
175 llvm::sys::fs::OF_None);
177 Diags.
Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
183 void RunOptimizationPipeline(
184 BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
185 std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS,
BackendConsumer *BC);
187 std::unique_ptr<raw_pwrite_stream> &OS,
188 std::unique_ptr<llvm::ToolOutputFile> &DwoOS);
195 bool shouldEmitRegularLTOSummary()
const {
196 return CodeGenOpts.PrepareForLTO && !CodeGenOpts.DisableLLVMPasses &&
197 TargetTriple.getVendor() != llvm::Triple::Apple;
203 bool shouldEmitUnifiedLTOModueFlag()
const {
204 return CodeGenOpts.UnifiedLTO &&
205 (CodeGenOpts.PrepareForThinLTO || shouldEmitRegularLTOSummary());
215 : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
216 TargetOpts(TOpts), LangOpts(LOpts), TheModule(M),
VFS(
std::move(
VFS)),
217 CodeGenerationTime(
"codegen",
"Code Generation Time"),
218 TargetTriple(TheModule->getTargetTriple()) {}
220 ~EmitAssemblyHelper() {
221 if (CodeGenOpts.DisableFree)
222 BuryPointer(std::move(TM));
225 std::unique_ptr<TargetMachine> TM;
233static SanitizerCoverageOptions
235 SanitizerCoverageOptions Opts;
237 static_cast<SanitizerCoverageOptions::Type
>(CGOpts.SanitizeCoverageType);
238 Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
239 Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
240 Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
241 Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
242 Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
243 Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
244 Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
245 Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
246 Opts.NoPrune = CGOpts.SanitizeCoverageNoPrune;
247 Opts.Inline8bitCounters = CGOpts.SanitizeCoverageInline8bitCounters;
248 Opts.InlineBoolFlag = CGOpts.SanitizeCoverageInlineBoolFlag;
249 Opts.PCTable = CGOpts.SanitizeCoveragePCTable;
250 Opts.StackDepth = CGOpts.SanitizeCoverageStackDepth;
251 Opts.TraceLoads = CGOpts.SanitizeCoverageTraceLoads;
252 Opts.TraceStores = CGOpts.SanitizeCoverageTraceStores;
253 Opts.CollectControlFlow = CGOpts.SanitizeCoverageControlFlow;
257static SanitizerBinaryMetadataOptions
259 SanitizerBinaryMetadataOptions Opts;
260 Opts.Covered = CGOpts.SanitizeBinaryMetadataCovered;
261 Opts.Atomics = CGOpts.SanitizeBinaryMetadataAtomics;
262 Opts.UAR = CGOpts.SanitizeBinaryMetadataUAR;
271 if (!CGOpts.SanitizeAddressGlobalsDeadStripping)
273 switch (
T.getObjectFormat()) {
278 return !CGOpts.DisableIntegratedAS;
280 llvm::report_fatal_error(
"ASan not implemented for GOFF");
282 llvm::report_fatal_error(
"ASan not implemented for XCOFF.");
284 case Triple::DXContainer:
286 case Triple::UnknownObjectFormat:
292static std::optional<llvm::CodeModel::Model>
294 unsigned CodeModel = llvm::StringSwitch<unsigned>(CodeGenOpts.
CodeModel)
295 .Case(
"tiny", llvm::CodeModel::Tiny)
296 .Case(
"small", llvm::CodeModel::Small)
297 .Case(
"kernel", llvm::CodeModel::Kernel)
298 .Case(
"medium", llvm::CodeModel::Medium)
299 .Case(
"large", llvm::CodeModel::Large)
300 .Case(
"default", ~1u)
302 assert(CodeModel != ~0u &&
"invalid code model!");
303 if (CodeModel == ~1u)
305 return static_cast<llvm::CodeModel::Model
>(CodeModel);
310 return CodeGenFileType::ObjectFile;
312 return CodeGenFileType::Null;
315 return CodeGenFileType::AssemblyFile;
325 llvm::TargetOptions &Options,
330 switch (LangOpts.getThreadModel()) {
331 case LangOptions::ThreadModelKind::POSIX:
332 Options.ThreadModel = llvm::ThreadModel::POSIX;
334 case LangOptions::ThreadModelKind::Single:
335 Options.ThreadModel = llvm::ThreadModel::Single;
340 assert((CodeGenOpts.
FloatABI ==
"soft" || CodeGenOpts.
FloatABI ==
"softfp" ||
342 "Invalid Floating Point ABI!");
343 Options.FloatABIType =
344 llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.
FloatABI)
345 .Case(
"soft", llvm::FloatABI::Soft)
346 .Case(
"softfp", llvm::FloatABI::Soft)
347 .Case(
"hard", llvm::FloatABI::Hard)
348 .Default(llvm::FloatABI::Default);
351 switch (LangOpts.getDefaultFPContractMode()) {
352 case LangOptions::FPM_Off:
355 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
357 case LangOptions::FPM_On:
358 case LangOptions::FPM_FastHonorPragmas:
359 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
361 case LangOptions::FPM_Fast:
362 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
366 Options.BinutilsVersion =
367 llvm::TargetMachine::parseBinutilsVersion(CodeGenOpts.
BinutilsVersion);
368 Options.UseInitArray = CodeGenOpts.UseInitArray;
369 Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
375 Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
377 Options.ExceptionModel = llvm::ExceptionHandling::WinEH;
379 Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
381 Options.ExceptionModel = llvm::ExceptionHandling::Wasm;
383 Options.NoInfsFPMath = LangOpts.NoHonorInfs;
384 Options.NoNaNsFPMath = LangOpts.NoHonorNaNs;
385 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
386 Options.UnsafeFPMath = LangOpts.AllowFPReassoc && LangOpts.AllowRecip &&
387 LangOpts.NoSignedZero && LangOpts.ApproxFunc &&
388 (LangOpts.getDefaultFPContractMode() ==
389 LangOptions::FPModeKind::FPM_Fast ||
390 LangOpts.getDefaultFPContractMode() ==
391 LangOptions::FPModeKind::FPM_FastHonorPragmas);
392 Options.ApproxFuncFPMath = LangOpts.ApproxFunc;
394 Options.BBAddrMap = CodeGenOpts.BBAddrMap;
396 llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.
BBSections)
397 .Case(
"all", llvm::BasicBlockSection::All)
398 .Case(
"labels", llvm::BasicBlockSection::Labels)
399 .StartsWith(
"list=", llvm::BasicBlockSection::List)
400 .Case(
"none", llvm::BasicBlockSection::None)
401 .Default(llvm::BasicBlockSection::None);
403 if (Options.BBSections == llvm::BasicBlockSection::List) {
404 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
405 MemoryBuffer::getFile(CodeGenOpts.
BBSections.substr(5));
407 Diags.
Report(diag::err_fe_unable_to_load_basic_block_sections_file)
408 << MBOrErr.getError().message();
411 Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
414 Options.EnableMachineFunctionSplitter = CodeGenOpts.SplitMachineFunctions;
415 Options.FunctionSections = CodeGenOpts.FunctionSections;
416 Options.DataSections = CodeGenOpts.DataSections;
417 Options.IgnoreXCOFFVisibility = LangOpts.IgnoreXCOFFVisibility;
418 Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
419 Options.UniqueBasicBlockSectionNames =
420 CodeGenOpts.UniqueBasicBlockSectionNames;
421 Options.SeparateNamedSections = CodeGenOpts.SeparateNamedSections;
422 Options.TLSSize = CodeGenOpts.TLSSize;
423 Options.EnableTLSDESC = CodeGenOpts.EnableTLSDESC;
424 Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
425 Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
426 Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
428 Options.EmitAddrsig = CodeGenOpts.Addrsig;
429 Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
430 Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
431 Options.EnableAIXExtendedAltivecABI = LangOpts.EnableAIXExtendedAltivecABI;
432 Options.XRayFunctionIndex = CodeGenOpts.XRayFunctionIndex;
433 Options.LoopAlignment = CodeGenOpts.LoopAlignment;
434 Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;
436 Options.Hotpatch = CodeGenOpts.HotPatch;
437 Options.JMCInstrument = CodeGenOpts.JMCInstrument;
438 Options.XCOFFReadOnlyPointers = CodeGenOpts.XCOFFReadOnlyPointers;
440 switch (CodeGenOpts.getSwiftAsyncFramePointer()) {
441 case CodeGenOptions::SwiftAsyncFramePointerKind::Auto:
442 Options.SwiftAsyncFramePointer =
443 SwiftAsyncFramePointerMode::DeploymentBased;
446 case CodeGenOptions::SwiftAsyncFramePointerKind::Always:
447 Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Always;
450 case CodeGenOptions::SwiftAsyncFramePointerKind::Never:
451 Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Never;
456 Options.MCOptions.EmitDwarfUnwind = CodeGenOpts.getEmitDwarfUnwind();
457 Options.MCOptions.EmitCompactUnwindNonCanonical =
458 CodeGenOpts.EmitCompactUnwindNonCanonical;
459 Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
460 Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
461 Options.MCOptions.MCUseDwarfDirectory =
462 CodeGenOpts.NoDwarfDirectoryAsm
463 ? llvm::MCTargetOptions::DisableDwarfDirectory
464 : llvm::MCTargetOptions::EnableDwarfDirectory;
465 Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
466 Options.MCOptions.MCIncrementalLinkerCompatible =
467 CodeGenOpts.IncrementalLinkerCompatible;
468 Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
469 Options.MCOptions.MCNoWarn = CodeGenOpts.NoWarn;
470 Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
471 Options.MCOptions.Dwarf64 = CodeGenOpts.Dwarf64;
472 Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
473 Options.MCOptions.X86RelaxRelocations = CodeGenOpts.RelaxELFRelocations;
474 Options.MCOptions.CompressDebugSections =
475 CodeGenOpts.getCompressDebugSections();
476 Options.MCOptions.ABIName = TargetOpts.
ABI;
478 if (!Entry.IsFramework &&
479 (Entry.Group == frontend::IncludeDirGroup::Quoted ||
480 Entry.Group == frontend::IncludeDirGroup::Angled ||
481 Entry.Group == frontend::IncludeDirGroup::System))
482 Options.MCOptions.IASSearchPaths.push_back(
483 Entry.IgnoreSysRoot ? Entry.Path : HSOpts.
Sysroot + Entry.Path);
484 Options.MCOptions.Argv0 = CodeGenOpts.
Argv0;
487 Options.MCOptions.PPCUseFullRegisterNames =
488 CodeGenOpts.PPCUseFullRegisterNames;
489 Options.MisExpect = CodeGenOpts.MisExpect;
494static std::optional<GCOVOptions>
505 Options.NoRedZone = CodeGenOpts.DisableRedZone;
508 Options.Atomic = CodeGenOpts.AtomicProfileUpdate;
512static std::optional<InstrProfOptions>
517 InstrProfOptions Options;
518 Options.NoRedZone = CodeGenOpts.DisableRedZone;
520 Options.Atomic = CodeGenOpts.AtomicProfileUpdate;
526 BackendArgs.push_back(
"clang");
528 BackendArgs.push_back(
"-debug-pass");
529 BackendArgs.push_back(CodeGenOpts.
DebugPass.c_str());
532 BackendArgs.push_back(
"-limit-float-precision");
538 if (BackendArgs.size() == 1)
540 BackendArgs.push_back(
nullptr);
544 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
548void EmitAssemblyHelper::CreateTargetMachine(
bool MustCreateTM) {
551 std::string Triple = TheModule->getTargetTriple();
552 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
555 Diags.
Report(diag::err_fe_unable_to_create_target) <<
Error;
559 std::optional<llvm::CodeModel::Model> CM =
getCodeModel(CodeGenOpts);
560 std::string FeaturesStr =
563 std::optional<CodeGenOptLevel> OptLevelOrNone =
564 CodeGenOpt::getLevel(CodeGenOpts.OptimizationLevel);
565 assert(OptLevelOrNone &&
"Invalid optimization level!");
566 CodeGenOptLevel OptLevel = *OptLevelOrNone;
568 llvm::TargetOptions Options;
572 TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.
CPU, FeaturesStr,
573 Options, RM, CM, OptLevel));
577bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
579 raw_pwrite_stream &OS,
580 raw_pwrite_stream *DwoOS) {
582 std::unique_ptr<TargetLibraryInfoImpl> TLII(
583 llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
584 CodeGenPasses.add(
new TargetLibraryInfoWrapperPass(*TLII));
593 if (CodeGenOpts.OptimizationLevel > 0)
594 CodeGenPasses.add(createObjCARCContractPass());
596 if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
597 !CodeGenOpts.VerifyModule)) {
598 Diags.
Report(diag::err_fe_unable_to_interface_with_target);
606 switch (Opts.OptimizationLevel) {
608 llvm_unreachable(
"Invalid optimization level!");
611 return OptimizationLevel::O0;
614 return OptimizationLevel::O1;
617 switch (Opts.OptimizeSize) {
619 llvm_unreachable(
"Invalid optimization level for size!");
622 return OptimizationLevel::O2;
625 return OptimizationLevel::Os;
628 return OptimizationLevel::Oz;
632 return OptimizationLevel::O3;
639 if (TargetTriple.getArch() == llvm::Triple::x86_64 ||
640 TargetTriple.isAArch64(64) || TargetTriple.isRISCV())
644 PB.registerOptimizerLastEPCallback(
645 [&](ModulePassManager &MPM, OptimizationLevel Level) {
646 if (Level == OptimizationLevel::O0 &&
648 MPM.addPass(createModuleToFunctionPassAdaptor(KCFIPass()));
653 PB.registerPeepholeEPCallback(
654 [&](FunctionPassManager &FPM, OptimizationLevel Level) {
655 if (Level != OptimizationLevel::O0 &&
657 FPM.addPass(KCFIPass());
664 auto SanitizersCallback = [&](ModulePassManager &MPM,
665 OptimizationLevel Level) {
668 MPM.addPass(SanitizerCoveragePass(
674 MPM.addPass(SanitizerBinaryMetadataPass(
679 auto MSanPass = [&](
SanitizerMask Mask,
bool CompileKernel) {
681 int TrackOrigins = CodeGenOpts.SanitizeMemoryTrackOrigins;
684 MemorySanitizerOptions options(TrackOrigins, Recover, CompileKernel,
685 CodeGenOpts.SanitizeMemoryParamRetval);
686 MPM.addPass(MemorySanitizerPass(options));
687 if (Level != OptimizationLevel::O0) {
692 MPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());
693 FunctionPassManager FPM;
694 FPM.addPass(EarlyCSEPass(
true ));
695 FPM.addPass(InstCombinePass());
696 FPM.addPass(JumpThreadingPass());
697 FPM.addPass(GVNPass());
698 FPM.addPass(InstCombinePass());
699 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
703 MSanPass(SanitizerKind::Memory,
false);
704 MSanPass(SanitizerKind::KernelMemory,
true);
706 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread)) {
707 MPM.addPass(ModuleThreadSanitizerPass());
708 MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
711 auto ASanPass = [&](
SanitizerMask Mask,
bool CompileKernel) {
714 bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;
715 llvm::AsanDtorKind DestructorKind =
716 CodeGenOpts.getSanitizeAddressDtor();
717 AddressSanitizerOptions Opts;
718 Opts.CompileKernel = CompileKernel;
720 Opts.UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
721 Opts.UseAfterReturn = CodeGenOpts.getSanitizeAddressUseAfterReturn();
722 MPM.addPass(AddressSanitizerPass(Opts, UseGlobalGC, UseOdrIndicator,
726 ASanPass(SanitizerKind::Address,
false);
727 ASanPass(SanitizerKind::KernelAddress,
true);
729 auto HWASanPass = [&](
SanitizerMask Mask,
bool CompileKernel) {
732 MPM.addPass(HWAddressSanitizerPass(
733 {CompileKernel, Recover,
734 CodeGenOpts.OptimizationLevel == 0}));
737 HWASanPass(SanitizerKind::HWAddress,
false);
738 HWASanPass(SanitizerKind::KernelHWAddress,
true);
740 if (LangOpts.
Sanitize.
has(SanitizerKind::DataFlow)) {
745 PB.registerOptimizerEarlyEPCallback(
746 [SanitizersCallback](ModulePassManager &MPM, OptimizationLevel Level) {
747 ModulePassManager NewMPM;
748 SanitizersCallback(NewMPM, Level);
749 if (!NewMPM.isEmpty()) {
751 NewMPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());
752 MPM.addPass(std::move(NewMPM));
757 PB.registerOptimizerLastEPCallback(SanitizersCallback);
760 if (LowerAllowCheckPass::IsRequested()) {
764 PB.registerScalarOptimizerLateEPCallback(
765 [](FunctionPassManager &FPM, OptimizationLevel Level) {
766 FPM.addPass(LowerAllowCheckPass());
771void EmitAssemblyHelper::RunOptimizationPipeline(
772 BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
773 std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS,
BackendConsumer *BC) {
774 std::optional<PGOOptions> PGOOpt;
783 CodeGenOpts.DebugInfoForProfiling,
784 false, CodeGenOpts.AtomicProfileUpdate);
788 : PGOOptions::NoCSAction;
793 CodeGenOpts.DebugInfoForProfiling);
800 CodeGenOpts.DebugInfoForProfiling, CodeGenOpts.PseudoProbeForProfiling);
804 PGOOptions::NoAction, PGOOptions::NoCSAction,
806 else if (CodeGenOpts.PseudoProbeForProfiling)
809 PGOOptions(
"",
"",
"",
"",
nullptr,
810 PGOOptions::NoAction, PGOOptions::NoCSAction,
812 else if (CodeGenOpts.DebugInfoForProfiling)
814 PGOOpt = PGOOptions(
"",
"",
"",
"",
nullptr,
815 PGOOptions::NoAction, PGOOptions::NoCSAction,
821 "Cannot have both CSProfileUse pass and CSProfileGen pass at "
824 assert(PGOOpt->Action != PGOOptions::IRInstr &&
825 PGOOpt->Action != PGOOptions::SampleUse &&
826 "Cannot run CSProfileGen pass with ProfileGen or SampleUse "
829 ? getDefaultProfileGenName()
830 : CodeGenOpts.InstrProfileOutput;
831 PGOOpt->CSAction = PGOOptions::CSIRInstr;
833 PGOOpt = PGOOptions(
"",
835 ? getDefaultProfileGenName()
838 PGOOptions::NoAction, PGOOptions::CSIRInstr,
842 TM->setPGOOption(PGOOpt);
844 PipelineTuningOptions PTO;
845 PTO.LoopUnrolling = CodeGenOpts.UnrollLoops;
848 PTO.LoopInterleaving = CodeGenOpts.UnrollLoops;
849 PTO.LoopVectorization = CodeGenOpts.VectorizeLoop;
850 PTO.SLPVectorization = CodeGenOpts.VectorizeSLP;
851 PTO.MergeFunctions = CodeGenOpts.MergeFunctions;
854 PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
855 PTO.UnifiedLTO = CodeGenOpts.UnifiedLTO;
857 LoopAnalysisManager LAM;
858 FunctionAnalysisManager FAM;
859 CGSCCAnalysisManager CGAM;
860 ModuleAnalysisManager MAM;
862 bool DebugPassStructure = CodeGenOpts.
DebugPass ==
"Structure";
863 PassInstrumentationCallbacks PIC;
864 PrintPassOptions PrintPassOpts;
865 PrintPassOpts.Indent = DebugPassStructure;
866 PrintPassOpts.SkipAnalyses = DebugPassStructure;
867 StandardInstrumentations SI(
868 TheModule->getContext(),
869 (CodeGenOpts.DebugPassManager || DebugPassStructure),
870 CodeGenOpts.VerifyEach, PrintPassOpts);
871 SI.registerCallbacks(PIC, &MAM);
872 PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
875 switch (CodeGenOpts.getAssignmentTrackingMode()) {
876 case CodeGenOptions::AssignmentTrackingOpts::Forced:
877 PB.registerPipelineStartEPCallback(
878 [&](ModulePassManager &MPM, OptimizationLevel Level) {
879 MPM.addPass(AssignmentTrackingPass());
882 case CodeGenOptions::AssignmentTrackingOpts::Enabled:
885 if (!CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.PrepareForLTO &&
886 CodeGenOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {
887 PB.registerPipelineStartEPCallback(
888 [&](ModulePassManager &MPM, OptimizationLevel Level) {
890 if (Level != OptimizationLevel::O0)
891 MPM.addPass(AssignmentTrackingPass());
895 case CodeGenOptions::AssignmentTrackingOpts::Disabled:
900 DebugifyEachInstrumentation Debugify;
901 DebugInfoPerPass DebugInfoBeforePass;
902 if (CodeGenOpts.EnableDIPreservationVerify) {
903 Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
904 Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);
907 Debugify.setOrigDIVerifyBugsReportFilePath(
909 Debugify.registerCallbacks(PIC, MAM);
913 auto PassPlugin = PassPlugin::Load(PluginFN);
915 PassPlugin->registerPassBuilderCallbacks(PB);
917 Diags.
Report(diag::err_fe_unable_to_load_plugin)
918 << PluginFN <<
toString(PassPlugin.takeError());
923#define HANDLE_EXTENSION(Ext) \
924 get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
925#include "llvm/Support/Extension.def"
929 std::unique_ptr<TargetLibraryInfoImpl> TLII(
930 llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
931 FAM.registerPass([&] {
return TargetLibraryAnalysis(*TLII); });
934 PB.registerModuleAnalyses(MAM);
935 PB.registerCGSCCAnalyses(CGAM);
936 PB.registerFunctionAnalyses(FAM);
937 PB.registerLoopAnalyses(LAM);
938 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
940 ModulePassManager MPM;
942 if (CodeGenOpts.VerifyModule)
943 MPM.addPass(VerifierPass());
945 if (!CodeGenOpts.DisableLLVMPasses) {
950 const bool PrepareForThinLTO = CodeGenOpts.PrepareForThinLTO;
951 const bool PrepareForLTO = CodeGenOpts.PrepareForLTO;
953 if (LangOpts.ObjCAutoRefCount) {
954 PB.registerPipelineStartEPCallback(
955 [](ModulePassManager &MPM, OptimizationLevel Level) {
956 if (Level != OptimizationLevel::O0)
958 createModuleToFunctionPassAdaptor(ObjCARCExpandPass()));
960 PB.registerPipelineEarlySimplificationEPCallback(
961 [](ModulePassManager &MPM, OptimizationLevel Level) {
962 if (Level != OptimizationLevel::O0)
963 MPM.addPass(ObjCARCAPElimPass());
965 PB.registerScalarOptimizerLateEPCallback(
966 [](FunctionPassManager &FPM, OptimizationLevel Level) {
967 if (Level != OptimizationLevel::O0)
968 FPM.addPass(ObjCARCOptPass());
978 if (IsThinLTOPostLink)
979 PB.registerPipelineStartEPCallback(
980 [](ModulePassManager &MPM, OptimizationLevel Level) {
981 MPM.addPass(LowerTypeTestsPass(
nullptr,
986 if (CodeGenOpts.InstrumentFunctions ||
987 CodeGenOpts.InstrumentFunctionEntryBare ||
988 CodeGenOpts.InstrumentFunctionsAfterInlining ||
989 CodeGenOpts.InstrumentForProfiling) {
990 PB.registerPipelineStartEPCallback(
991 [](ModulePassManager &MPM, OptimizationLevel Level) {
992 MPM.addPass(createModuleToFunctionPassAdaptor(
993 EntryExitInstrumenterPass(
false)));
995 PB.registerOptimizerLastEPCallback(
996 [](ModulePassManager &MPM, OptimizationLevel Level) {
997 MPM.addPass(createModuleToFunctionPassAdaptor(
998 EntryExitInstrumenterPass(
true)));
1004 if (LangOpts.
Sanitize.
has(SanitizerKind::LocalBounds))
1005 PB.registerScalarOptimizerLateEPCallback(
1006 [](FunctionPassManager &FPM, OptimizationLevel Level) {
1007 FPM.addPass(BoundsCheckingPass());
1012 if (!IsThinLTOPostLink) {
1017 if (std::optional<GCOVOptions> Options =
1019 PB.registerPipelineStartEPCallback(
1020 [Options](ModulePassManager &MPM, OptimizationLevel Level) {
1021 MPM.addPass(GCOVProfilerPass(*Options));
1023 if (std::optional<InstrProfOptions> Options =
1025 PB.registerPipelineStartEPCallback(
1026 [Options](ModulePassManager &MPM, OptimizationLevel Level) {
1027 MPM.addPass(InstrProfilingLoweringPass(*Options,
false));
1033 PB.registerOptimizerLastEPCallback(
1034 [](ModulePassManager &MPM, OptimizationLevel Level) {
1035 MPM.addPass(createModuleToFunctionPassAdaptor(MemProfilerPass()));
1036 MPM.addPass(ModuleMemProfilerPass());
1040 if (CodeGenOpts.FatLTO) {
1041 MPM.addPass(PB.buildFatLTODefaultPipeline(
1042 Level, PrepareForThinLTO,
1043 PrepareForThinLTO || shouldEmitRegularLTOSummary()));
1044 }
else if (PrepareForThinLTO) {
1045 MPM.addPass(PB.buildThinLTOPreLinkDefaultPipeline(Level));
1046 }
else if (PrepareForLTO) {
1047 MPM.addPass(PB.buildLTOPreLinkDefaultPipeline(Level));
1049 MPM.addPass(PB.buildPerModuleDefaultPipeline(Level));
1054 if (CodeGenOpts.LinkBitcodePostopt)
1063 MPM.addPass(VerifierPass());
1066 CodeGenOpts.FatLTO) {
1067 if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
1068 if (!TheModule->getModuleFlag(
"EnableSplitLTOUnit"))
1069 TheModule->addModuleFlag(llvm::Module::Error,
"EnableSplitLTOUnit",
1070 CodeGenOpts.EnableSplitLTOUnit);
1077 MPM.addPass(ThinLTOBitcodeWriterPass(
1078 *OS, ThinLinkOS ? &ThinLinkOS->os() :
nullptr));
1080 MPM.addPass(PrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists,
1086 bool EmitLTOSummary = shouldEmitRegularLTOSummary();
1087 if (EmitLTOSummary) {
1088 if (!TheModule->getModuleFlag(
"ThinLTO") && !CodeGenOpts.UnifiedLTO)
1089 TheModule->addModuleFlag(llvm::Module::Error,
"ThinLTO", uint32_t(0));
1090 if (!TheModule->getModuleFlag(
"EnableSplitLTOUnit"))
1091 TheModule->addModuleFlag(llvm::Module::Error,
"EnableSplitLTOUnit",
1095 MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
1098 MPM.addPass(PrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists,
1103 if (shouldEmitUnifiedLTOModueFlag())
1104 TheModule->addModuleFlag(llvm::Module::Error,
"UnifiedLTO", uint32_t(1));
1110 MPM.printPipeline(outs(), [&PIC](StringRef ClassName) {
1111 auto PassName = PIC.getPassNameForClassName(ClassName);
1112 return PassName.empty() ? ClassName : PassName;
1118 if (LangOpts.HIPStdPar && !LangOpts.CUDAIsDevice &&
1119 LangOpts.HIPStdParInterposeAlloc)
1120 MPM.addPass(HipStdParAllocationInterpositionPass());
1124 PrettyStackTraceString CrashInfo(
"Optimizer");
1125 llvm::TimeTraceScope TimeScope(
"Optimizer");
1126 MPM.run(*TheModule, MAM);
1130void EmitAssemblyHelper::RunCodegenPipeline(
1131 BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
1132 std::unique_ptr<llvm::ToolOutputFile> &DwoOS) {
1136 legacy::PassManager CodeGenPasses;
1144 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
1150 if (!AddEmitPasses(CodeGenPasses, Action, *OS,
1151 DwoOS ? &DwoOS->os() :
nullptr))
1167 PrettyStackTraceString CrashInfo(
"Code generation");
1168 llvm::TimeTraceScope TimeScope(
"CodeGenPasses");
1169 CodeGenPasses.run(*TheModule);
1174 std::unique_ptr<raw_pwrite_stream> OS,
1176 TimeRegion Region(CodeGenOpts.TimePasses ? &CodeGenerationTime :
nullptr);
1180 CreateTargetMachine(RequiresCodeGen);
1182 if (RequiresCodeGen && !TM)
1185 TheModule->setDataLayout(TM->createDataLayout());
1188 cl::PrintOptionValues();
1190 std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;
1191 RunOptimizationPipeline(Action, OS, ThinLinkOS, BC);
1192 RunCodegenPipeline(Action, OS, DwoOS);
1204 const LangOptions &LOpts, std::unique_ptr<raw_pwrite_stream> OS,
1205 std::string SampleProfile, std::string ProfileRemapping,
1207 DenseMap<StringRef, DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
1208 ModuleToDefinedGVSummaries;
1209 CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1216 FunctionImporter::ImportMapTy ImportList;
1217 if (!lto::initImportList(*M, *CombinedIndex, ImportList))
1220 auto AddStream = [&](
size_t Task,
const Twine &ModuleName) {
1221 return std::make_unique<CachedFileStream>(std::move(OS),
1228 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1229 errs() <<
"Error setting up ThinLTO save-temps: " << EIB.message()
1234 Conf.CPU = TOpts.
CPU;
1238 std::optional<CodeGenOptLevel> OptLevelOrNone =
1239 CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
1240 assert(OptLevelOrNone &&
"Invalid optimization level!");
1241 Conf.CGOptLevel = *OptLevelOrNone;
1242 Conf.OptLevel = CGOpts.OptimizationLevel;
1244 Conf.SampleProfile = std::move(SampleProfile);
1245 Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
1248 Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
1249 Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;
1250 Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;
1253 Conf.PTO.CallGraphProfile = !CGOpts.DisableIntegratedAS;
1257 Conf.RunCSIRInstr =
true;
1260 Conf.RunCSIRInstr =
false;
1264 Conf.ProfileRemapping = std::move(ProfileRemapping);
1265 Conf.DebugPassManager = CGOpts.DebugPassManager;
1266 Conf.VerifyEach = CGOpts.VerifyEach;
1267 Conf.RemarksWithHotness = CGOpts.DiagnosticsWithHotness;
1275 Conf.PreCodeGenModuleHook = [](
size_t Task,
const llvm::Module &Mod) {
1280 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const llvm::Module &Mod) {
1281 M->print(*OS,
nullptr, CGOpts.EmitLLVMUseLists);
1286 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const llvm::Module &Mod) {
1287 WriteBitcodeToFile(*M, *OS, CGOpts.EmitLLVMUseLists);
1296 thinBackend(Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
1297 ModuleToDefinedGVSummaries[M->getModuleIdentifier()],
1299 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1300 errs() <<
"Error running ThinLTO backend: " << EIB.message() <<
'\n';
1308 const LangOptions &LOpts, StringRef TDesc, llvm::Module *M,
1312 llvm::TimeTraceScope TimeScope(
"Backend");
1314 std::unique_ptr<llvm::Module> EmptyModule;
1319 std::unique_ptr<ModuleSummaryIndex> CombinedIndex;
1320 if (Error E = llvm::getModuleSummaryIndexForFile(
1323 .moveInto(CombinedIndex)) {
1324 logAllUnhandledErrors(std::move(E), errs(),
1325 "Error loading index file '" +
1333 if (CombinedIndex) {
1334 if (!CombinedIndex->skipModuleByDistributedBackend()) {
1346 EmptyModule = std::make_unique<llvm::Module>(
"empty", M->getContext());
1347 EmptyModule->setTargetTriple(M->getTargetTriple());
1348 M = EmptyModule.get();
1352 EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M, VFS);
1353 AsmHelper.EmitAssembly(Action, std::move(OS), BC);
1358 std::string DLDesc = M->getDataLayout().getStringRepresentation();
1359 if (DLDesc != TDesc) {
1362 "expected target description '%1'");
1363 Diags.
Report(DiagID) << DLDesc << TDesc;
1371 llvm::MemoryBufferRef Buf) {
1374 llvm::embedBitcodeInModule(
1386 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ObjectOrErr =
1387 llvm::MemoryBuffer::getFileOrSTDIN(OffloadObject);
1388 if (ObjectOrErr.getError()) {
1390 "could not open '%0' for embedding");
1391 Diags.
Report(DiagID) << OffloadObject;
1395 llvm::embedBufferInModule(*M, **ObjectOrErr,
".llvm.offloading",
1396 Align(object::OffloadBinary::getAlignment()));
static bool actionRequiresCodeGen(BackendAction Action)
static void addSanitizers(const Triple &TargetTriple, const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts, PassBuilder &PB)
static std::optional< llvm::CodeModel::Model > getCodeModel(const CodeGenOptions &CodeGenOpts)
static SanitizerBinaryMetadataOptions getSanitizerBinaryMetadataOptions(const CodeGenOptions &CGOpts)
static std::optional< GCOVOptions > getGCOVOptions(const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts)
static bool initTargetOptions(DiagnosticsEngine &Diags, llvm::TargetOptions &Options, const CodeGenOptions &CodeGenOpts, const clang::TargetOptions &TargetOpts, const LangOptions &LangOpts, const HeaderSearchOptions &HSOpts)
static void addKCFIPass(const Triple &TargetTriple, const LangOptions &LangOpts, PassBuilder &PB)
static void runThinLTOBackend(DiagnosticsEngine &Diags, ModuleSummaryIndex *CombinedIndex, llvm::Module *M, const HeaderSearchOptions &HeaderOpts, const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts, const LangOptions &LOpts, std::unique_ptr< raw_pwrite_stream > OS, std::string SampleProfile, std::string ProfileRemapping, BackendAction Action)
static SanitizerCoverageOptions getSancovOptsFromCGOpts(const CodeGenOptions &CGOpts)
static OptimizationLevel mapToLevel(const CodeGenOptions &Opts)
static std::optional< InstrProfOptions > getInstrProfOptions(const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts)
static bool asanUseGlobalsGC(const Triple &T, const CodeGenOptions &CGOpts)
static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts)
static CodeGenFileType getCodeGenFileType(BackendAction Action)
Defines the Diagnostic-related interfaces.
Defines the clang::LangOptions interface.
This file provides a pass to link in Modules from a provided BackendConsumer.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::TargetOptions class.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string InstrProfileOutput
Name of the profile file to use as output for -fprofile-instr-generate, -fprofile-generate,...
std::string BinutilsVersion
bool hasProfileIRUse() const
Check if IR level profile use is on.
char CoverageVersion[4]
The version string to put into coverage files.
std::string FloatABI
The ABI to use for passing floating point arguments.
std::string ThinLinkBitcodeFile
Name of a file that can optionally be written with minimized bitcode to be used as input for the Thin...
bool hasProfileCSIRInstr() const
Check if CS IR level profile instrumentation is on.
std::string DebugPass
Enable additional debugging information.
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
uint64_t LargeDataThreshold
The code model-specific large data threshold to use (-mlarge-data-threshold).
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::vector< std::function< void(llvm::PassBuilder &)> > PassBuilderCallbacks
List of pass builder callbacks.
std::string LimitFloatPrecision
The float precision limit to use, if non-empty.
std::string CodeModel
The code model to use (-mcmodel).
std::string CoverageDataFile
The filename with path we use for coverage data files.
std::vector< std::string > PassPlugins
List of dynamic shared object files to be loaded as pass plugins.
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
std::string StackUsageOutput
Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.
std::string OptRecordPasses
The regex that filters the passes that should be saved to the optimization records.
std::vector< std::string > SanitizeCoverageAllowlistFiles
Path to allowlist file specifying which objects (files, functions) should exclusively be instrumented...
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
std::vector< std::string > SanitizeCoverageIgnorelistFiles
Path to ignorelist file specifying which objects (files, functions) listed for instrumentation by san...
bool hasSanitizeCoverage() const
bool hasProfileIRInstr() const
Check if IR level profile instrumentation is on.
bool hasProfileCSIRUse() const
Check if CSIR profile use is on.
std::vector< std::string > SanitizeMetadataIgnorelistFiles
Path to ignorelist file specifying which objects (files, functions) listed for instrumentation by san...
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
std::string ProfileExcludeFiles
Regexes separated by a semi-colon to filter the files to not instrument.
std::string AsSecureLogFile
The name of a file to use with .secure_log_unique directives.
std::string ProfileRemappingFile
Name of the profile remapping file to apply to the profile data supplied by -fprofile-sample-use or -...
bool hasSanitizeBinaryMetadata() const
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
const char * Argv0
Executable and command-line used to create a given CompilerInvocation.
std::string SplitDwarfFile
The name for the split debug info file used for the DW_AT_[GNU_]dwo_name attribute in the skeleton CU...
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
std::vector< std::string > CommandLineArgs
std::string MemoryProfileUsePath
Name of the profile file to use as input for -fmemory-profile-use.
std::string OptRecordFormat
The format used for serializing remarks (default: YAML)
std::vector< std::string > OffloadObjects
List of filenames passed in using the -fembed-offload-object option.
std::string ProfileFilterFiles
Regexes separated by a semi-colon to filter the files to instrument.
std::string ObjectFilenameForDebug
Output filename used in the COFF debug information.
std::string SplitDwarfOutput
Output filename for the split debug info, not used in the skeleton CU.
std::string DIBugsReportFilePath
The file to use for dumping bug report by Debugify for original debug info.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool hasWasmExceptions() const
bool hasSjLjExceptions() const
SanitizerSet Sanitize
Set of enabled sanitizers.
bool hasDWARFExceptions() const
bool hasSEHExceptions() const
std::vector< std::string > NoSanitizeFiles
Paths to files specifying which objects (files, functions, variables) should not be instrumented.
Options for controlling the target.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string ABI
If given, the name of the target ABI to use.
std::string CPU
If given, the name of the target CPU to generate code for.
llvm::EABI EABIVersion
The EABI version to use.
Create and return a pass that links in Moduels from a provided BackendConsumer to a given primary Mod...
@ EmitAssembly
Emit a .s file.
The JSON file list parser is used to communicate input to InstallAPI.
void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, DiagnosticsEngine &Diags)
void EmitBackendOutput(DiagnosticsEngine &Diags, const HeaderSearchOptions &, const CodeGenOptions &CGOpts, const TargetOptions &TOpts, const LangOptions &LOpts, StringRef TDesc, llvm::Module *M, BackendAction Action, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS, std::unique_ptr< raw_pwrite_stream > OS, BackendConsumer *BC=nullptr)
void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)
@ Backend_EmitAssembly
Emit native assembly files.
@ Backend_EmitLL
Emit human-readable LLVM assembly.
@ Backend_EmitBC
Emit LLVM bitcode files.
@ Backend_EmitObj
Emit native object files.
@ Backend_EmitMCNull
Run CodeGen, but don't emit anything.
@ Backend_EmitNothing
Don't emit anything (benchmarking mode)
const FunctionProtoType * T
Diagnostic wrappers for TextAPI types for error reporting.
cl::opt< bool > PrintPipelinePasses
cl::opt< InstrProfCorrelator::ProfCorrelatorKind > ProfileCorrelate
static cl::opt< PGOOptions::ColdFuncOpt > ClPGOColdFuncAttr("pgo-cold-func-opt", cl::init(PGOOptions::ColdFuncOpt::Default), cl::Hidden, cl::desc("Function attribute to apply to cold functions as determined by PGO"), cl::values(clEnumValN(PGOOptions::ColdFuncOpt::Default, "default", "Default (no attribute)"), clEnumValN(PGOOptions::ColdFuncOpt::OptSize, "optsize", "Mark cold functions with optsize."), clEnumValN(PGOOptions::ColdFuncOpt::MinSize, "minsize", "Mark cold functions with minsize."), clEnumValN(PGOOptions::ColdFuncOpt::OptNone, "optnone", "Mark cold functions with optnone.")))
static cl::opt< bool > ClSanitizeOnOptimizerEarlyEP("sanitizer-early-opt-ep", cl::Optional, cl::desc("Insert sanitizers on OptimizerEarlyEP."))
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.