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/NumericalStabilitySanitizer.h"
80#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
81#include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
82#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
83#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
84#include "llvm/Transforms/ObjCARC.h"
85#include "llvm/Transforms/Scalar/EarlyCSE.h"
86#include "llvm/Transforms/Scalar/GVN.h"
87#include "llvm/Transforms/Scalar/JumpThreading.h"
88#include "llvm/Transforms/Utils/Debugify.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.Crel = CodeGenOpts.Crel;
474 Options.MCOptions.X86RelaxRelocations = CodeGenOpts.RelaxELFRelocations;
475 Options.MCOptions.CompressDebugSections =
476 CodeGenOpts.getCompressDebugSections();
477 Options.MCOptions.ABIName = TargetOpts.
ABI;
479 if (!Entry.IsFramework &&
480 (Entry.Group == frontend::IncludeDirGroup::Quoted ||
481 Entry.Group == frontend::IncludeDirGroup::Angled ||
482 Entry.Group == frontend::IncludeDirGroup::System))
483 Options.MCOptions.IASSearchPaths.push_back(
484 Entry.IgnoreSysRoot ? Entry.Path : HSOpts.
Sysroot + Entry.Path);
485 Options.MCOptions.Argv0 = CodeGenOpts.
Argv0;
488 Options.MCOptions.PPCUseFullRegisterNames =
489 CodeGenOpts.PPCUseFullRegisterNames;
490 Options.MisExpect = CodeGenOpts.MisExpect;
495static std::optional<GCOVOptions>
506 Options.NoRedZone = CodeGenOpts.DisableRedZone;
509 Options.Atomic = CodeGenOpts.AtomicProfileUpdate;
513static std::optional<InstrProfOptions>
518 InstrProfOptions Options;
519 Options.NoRedZone = CodeGenOpts.DisableRedZone;
521 Options.Atomic = CodeGenOpts.AtomicProfileUpdate;
527 BackendArgs.push_back(
"clang");
529 BackendArgs.push_back(
"-debug-pass");
530 BackendArgs.push_back(CodeGenOpts.
DebugPass.c_str());
533 BackendArgs.push_back(
"-limit-float-precision");
539 if (BackendArgs.size() == 1)
541 BackendArgs.push_back(
nullptr);
545 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
549void EmitAssemblyHelper::CreateTargetMachine(
bool MustCreateTM) {
552 std::string Triple = TheModule->getTargetTriple();
553 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
556 Diags.
Report(diag::err_fe_unable_to_create_target) <<
Error;
560 std::optional<llvm::CodeModel::Model> CM =
getCodeModel(CodeGenOpts);
561 std::string FeaturesStr =
564 std::optional<CodeGenOptLevel> OptLevelOrNone =
565 CodeGenOpt::getLevel(CodeGenOpts.OptimizationLevel);
566 assert(OptLevelOrNone &&
"Invalid optimization level!");
567 CodeGenOptLevel OptLevel = *OptLevelOrNone;
569 llvm::TargetOptions Options;
573 TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.
CPU, FeaturesStr,
574 Options, RM, CM, OptLevel));
578bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
580 raw_pwrite_stream &OS,
581 raw_pwrite_stream *DwoOS) {
583 std::unique_ptr<TargetLibraryInfoImpl> TLII(
584 llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
585 CodeGenPasses.add(
new TargetLibraryInfoWrapperPass(*TLII));
594 if (CodeGenOpts.OptimizationLevel > 0)
595 CodeGenPasses.add(createObjCARCContractPass());
597 if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
598 !CodeGenOpts.VerifyModule)) {
599 Diags.
Report(diag::err_fe_unable_to_interface_with_target);
607 switch (Opts.OptimizationLevel) {
609 llvm_unreachable(
"Invalid optimization level!");
612 return OptimizationLevel::O0;
615 return OptimizationLevel::O1;
618 switch (Opts.OptimizeSize) {
620 llvm_unreachable(
"Invalid optimization level for size!");
623 return OptimizationLevel::O2;
626 return OptimizationLevel::Os;
629 return OptimizationLevel::Oz;
633 return OptimizationLevel::O3;
640 if (TargetTriple.getArch() == llvm::Triple::x86_64 ||
641 TargetTriple.isAArch64(64) || TargetTriple.isRISCV())
645 PB.registerOptimizerLastEPCallback(
646 [&](ModulePassManager &MPM, OptimizationLevel Level) {
647 if (Level == OptimizationLevel::O0 &&
649 MPM.addPass(createModuleToFunctionPassAdaptor(KCFIPass()));
654 PB.registerPeepholeEPCallback(
655 [&](FunctionPassManager &FPM, OptimizationLevel Level) {
656 if (Level != OptimizationLevel::O0 &&
658 FPM.addPass(KCFIPass());
665 auto SanitizersCallback = [&](ModulePassManager &MPM,
666 OptimizationLevel Level) {
669 MPM.addPass(SanitizerCoveragePass(
675 MPM.addPass(SanitizerBinaryMetadataPass(
680 auto MSanPass = [&](
SanitizerMask Mask,
bool CompileKernel) {
682 int TrackOrigins = CodeGenOpts.SanitizeMemoryTrackOrigins;
685 MemorySanitizerOptions options(TrackOrigins, Recover, CompileKernel,
686 CodeGenOpts.SanitizeMemoryParamRetval);
687 MPM.addPass(MemorySanitizerPass(options));
688 if (Level != OptimizationLevel::O0) {
693 MPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());
694 FunctionPassManager FPM;
695 FPM.addPass(EarlyCSEPass(
true ));
696 FPM.addPass(InstCombinePass());
697 FPM.addPass(JumpThreadingPass());
698 FPM.addPass(GVNPass());
699 FPM.addPass(InstCombinePass());
700 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
704 MSanPass(SanitizerKind::Memory,
false);
705 MSanPass(SanitizerKind::KernelMemory,
true);
707 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread)) {
708 MPM.addPass(ModuleThreadSanitizerPass());
709 MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
712 if (LangOpts.
Sanitize.
has(SanitizerKind::NumericalStability))
713 MPM.addPass(NumericalStabilitySanitizerPass());
715 auto ASanPass = [&](
SanitizerMask Mask,
bool CompileKernel) {
718 bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;
719 llvm::AsanDtorKind DestructorKind =
720 CodeGenOpts.getSanitizeAddressDtor();
721 AddressSanitizerOptions Opts;
722 Opts.CompileKernel = CompileKernel;
724 Opts.UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
725 Opts.UseAfterReturn = CodeGenOpts.getSanitizeAddressUseAfterReturn();
726 MPM.addPass(AddressSanitizerPass(Opts, UseGlobalGC, UseOdrIndicator,
730 ASanPass(SanitizerKind::Address,
false);
731 ASanPass(SanitizerKind::KernelAddress,
true);
733 auto HWASanPass = [&](
SanitizerMask Mask,
bool CompileKernel) {
736 MPM.addPass(HWAddressSanitizerPass(
737 {CompileKernel, Recover,
738 CodeGenOpts.OptimizationLevel == 0}));
741 HWASanPass(SanitizerKind::HWAddress,
false);
742 HWASanPass(SanitizerKind::KernelHWAddress,
true);
744 if (LangOpts.
Sanitize.
has(SanitizerKind::DataFlow)) {
749 PB.registerOptimizerEarlyEPCallback(
750 [SanitizersCallback](ModulePassManager &MPM, OptimizationLevel Level) {
751 ModulePassManager NewMPM;
752 SanitizersCallback(NewMPM, Level);
753 if (!NewMPM.isEmpty()) {
755 NewMPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());
756 MPM.addPass(std::move(NewMPM));
761 PB.registerOptimizerLastEPCallback(SanitizersCallback);
764 if (LowerAllowCheckPass::IsRequested()) {
768 PB.registerScalarOptimizerLateEPCallback(
769 [](FunctionPassManager &FPM, OptimizationLevel Level) {
770 FPM.addPass(LowerAllowCheckPass());
775void EmitAssemblyHelper::RunOptimizationPipeline(
776 BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
777 std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS,
BackendConsumer *BC) {
778 std::optional<PGOOptions> PGOOpt;
787 CodeGenOpts.DebugInfoForProfiling,
788 false, CodeGenOpts.AtomicProfileUpdate);
792 : PGOOptions::NoCSAction;
797 CodeGenOpts.DebugInfoForProfiling);
804 CodeGenOpts.DebugInfoForProfiling, CodeGenOpts.PseudoProbeForProfiling);
808 PGOOptions::NoAction, PGOOptions::NoCSAction,
810 else if (CodeGenOpts.PseudoProbeForProfiling)
813 PGOOptions(
"",
"",
"",
"",
nullptr,
814 PGOOptions::NoAction, PGOOptions::NoCSAction,
816 else if (CodeGenOpts.DebugInfoForProfiling)
818 PGOOpt = PGOOptions(
"",
"",
"",
"",
nullptr,
819 PGOOptions::NoAction, PGOOptions::NoCSAction,
825 "Cannot have both CSProfileUse pass and CSProfileGen pass at "
828 assert(PGOOpt->Action != PGOOptions::IRInstr &&
829 PGOOpt->Action != PGOOptions::SampleUse &&
830 "Cannot run CSProfileGen pass with ProfileGen or SampleUse "
833 ? getDefaultProfileGenName()
834 : CodeGenOpts.InstrProfileOutput;
835 PGOOpt->CSAction = PGOOptions::CSIRInstr;
837 PGOOpt = PGOOptions(
"",
839 ? getDefaultProfileGenName()
842 PGOOptions::NoAction, PGOOptions::CSIRInstr,
846 TM->setPGOOption(PGOOpt);
848 PipelineTuningOptions PTO;
849 PTO.LoopUnrolling = CodeGenOpts.UnrollLoops;
852 PTO.LoopInterleaving = CodeGenOpts.UnrollLoops;
853 PTO.LoopVectorization = CodeGenOpts.VectorizeLoop;
854 PTO.SLPVectorization = CodeGenOpts.VectorizeSLP;
855 PTO.MergeFunctions = CodeGenOpts.MergeFunctions;
858 PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
859 PTO.UnifiedLTO = CodeGenOpts.UnifiedLTO;
861 LoopAnalysisManager LAM;
862 FunctionAnalysisManager FAM;
863 CGSCCAnalysisManager CGAM;
864 ModuleAnalysisManager MAM;
866 bool DebugPassStructure = CodeGenOpts.
DebugPass ==
"Structure";
867 PassInstrumentationCallbacks PIC;
868 PrintPassOptions PrintPassOpts;
869 PrintPassOpts.Indent = DebugPassStructure;
870 PrintPassOpts.SkipAnalyses = DebugPassStructure;
871 StandardInstrumentations SI(
872 TheModule->getContext(),
873 (CodeGenOpts.DebugPassManager || DebugPassStructure),
874 CodeGenOpts.VerifyEach, PrintPassOpts);
875 SI.registerCallbacks(PIC, &MAM);
876 PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
879 switch (CodeGenOpts.getAssignmentTrackingMode()) {
880 case CodeGenOptions::AssignmentTrackingOpts::Forced:
881 PB.registerPipelineStartEPCallback(
882 [&](ModulePassManager &MPM, OptimizationLevel Level) {
883 MPM.addPass(AssignmentTrackingPass());
886 case CodeGenOptions::AssignmentTrackingOpts::Enabled:
889 if (!CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.PrepareForLTO &&
890 CodeGenOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {
891 PB.registerPipelineStartEPCallback(
892 [&](ModulePassManager &MPM, OptimizationLevel Level) {
894 if (Level != OptimizationLevel::O0)
895 MPM.addPass(AssignmentTrackingPass());
899 case CodeGenOptions::AssignmentTrackingOpts::Disabled:
904 DebugifyEachInstrumentation Debugify;
905 DebugInfoPerPass DebugInfoBeforePass;
906 if (CodeGenOpts.EnableDIPreservationVerify) {
907 Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
908 Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);
911 Debugify.setOrigDIVerifyBugsReportFilePath(
913 Debugify.registerCallbacks(PIC, MAM);
917 auto PassPlugin = PassPlugin::Load(PluginFN);
919 PassPlugin->registerPassBuilderCallbacks(PB);
921 Diags.
Report(diag::err_fe_unable_to_load_plugin)
922 << PluginFN <<
toString(PassPlugin.takeError());
927#define HANDLE_EXTENSION(Ext) \
928 get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
929#include "llvm/Support/Extension.def"
933 std::unique_ptr<TargetLibraryInfoImpl> TLII(
934 llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
935 FAM.registerPass([&] {
return TargetLibraryAnalysis(*TLII); });
938 PB.registerModuleAnalyses(MAM);
939 PB.registerCGSCCAnalyses(CGAM);
940 PB.registerFunctionAnalyses(FAM);
941 PB.registerLoopAnalyses(LAM);
942 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
944 ModulePassManager MPM;
946 if (CodeGenOpts.VerifyModule)
947 MPM.addPass(VerifierPass());
949 if (!CodeGenOpts.DisableLLVMPasses) {
954 const bool PrepareForThinLTO = CodeGenOpts.PrepareForThinLTO;
955 const bool PrepareForLTO = CodeGenOpts.PrepareForLTO;
957 if (LangOpts.ObjCAutoRefCount) {
958 PB.registerPipelineStartEPCallback(
959 [](ModulePassManager &MPM, OptimizationLevel Level) {
960 if (Level != OptimizationLevel::O0)
962 createModuleToFunctionPassAdaptor(ObjCARCExpandPass()));
964 PB.registerPipelineEarlySimplificationEPCallback(
965 [](ModulePassManager &MPM, OptimizationLevel Level) {
966 if (Level != OptimizationLevel::O0)
967 MPM.addPass(ObjCARCAPElimPass());
969 PB.registerScalarOptimizerLateEPCallback(
970 [](FunctionPassManager &FPM, OptimizationLevel Level) {
971 if (Level != OptimizationLevel::O0)
972 FPM.addPass(ObjCARCOptPass());
982 if (IsThinLTOPostLink)
983 PB.registerPipelineStartEPCallback(
984 [](ModulePassManager &MPM, OptimizationLevel Level) {
985 MPM.addPass(LowerTypeTestsPass(
nullptr,
992 if (LangOpts.
Sanitize.
has(SanitizerKind::LocalBounds))
993 PB.registerScalarOptimizerLateEPCallback(
994 [](FunctionPassManager &FPM, OptimizationLevel Level) {
995 FPM.addPass(BoundsCheckingPass());
1000 if (!IsThinLTOPostLink) {
1005 if (std::optional<GCOVOptions> Options =
1007 PB.registerPipelineStartEPCallback(
1008 [Options](ModulePassManager &MPM, OptimizationLevel Level) {
1009 MPM.addPass(GCOVProfilerPass(*Options));
1011 if (std::optional<InstrProfOptions> Options =
1013 PB.registerPipelineStartEPCallback(
1014 [Options](ModulePassManager &MPM, OptimizationLevel Level) {
1015 MPM.addPass(InstrProfilingLoweringPass(*Options,
false));
1021 PB.registerOptimizerLastEPCallback(
1022 [](ModulePassManager &MPM, OptimizationLevel Level) {
1023 MPM.addPass(createModuleToFunctionPassAdaptor(MemProfilerPass()));
1024 MPM.addPass(ModuleMemProfilerPass());
1028 if (CodeGenOpts.FatLTO) {
1029 MPM.addPass(PB.buildFatLTODefaultPipeline(
1030 Level, PrepareForThinLTO,
1031 PrepareForThinLTO || shouldEmitRegularLTOSummary()));
1032 }
else if (PrepareForThinLTO) {
1033 MPM.addPass(PB.buildThinLTOPreLinkDefaultPipeline(Level));
1034 }
else if (PrepareForLTO) {
1035 MPM.addPass(PB.buildLTOPreLinkDefaultPipeline(Level));
1037 MPM.addPass(PB.buildPerModuleDefaultPipeline(Level));
1042 if (CodeGenOpts.LinkBitcodePostopt)
1051 MPM.addPass(VerifierPass());
1054 CodeGenOpts.FatLTO) {
1055 if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
1056 if (!TheModule->getModuleFlag(
"EnableSplitLTOUnit"))
1057 TheModule->addModuleFlag(llvm::Module::Error,
"EnableSplitLTOUnit",
1058 CodeGenOpts.EnableSplitLTOUnit);
1065 MPM.addPass(ThinLTOBitcodeWriterPass(
1066 *OS, ThinLinkOS ? &ThinLinkOS->os() :
nullptr));
1068 MPM.addPass(PrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists,
1074 bool EmitLTOSummary = shouldEmitRegularLTOSummary();
1075 if (EmitLTOSummary) {
1076 if (!TheModule->getModuleFlag(
"ThinLTO") && !CodeGenOpts.UnifiedLTO)
1077 TheModule->addModuleFlag(llvm::Module::Error,
"ThinLTO", uint32_t(0));
1078 if (!TheModule->getModuleFlag(
"EnableSplitLTOUnit"))
1079 TheModule->addModuleFlag(llvm::Module::Error,
"EnableSplitLTOUnit",
1083 MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
1086 MPM.addPass(PrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists,
1091 if (shouldEmitUnifiedLTOModueFlag())
1092 TheModule->addModuleFlag(llvm::Module::Error,
"UnifiedLTO", uint32_t(1));
1098 MPM.printPipeline(outs(), [&PIC](StringRef ClassName) {
1099 auto PassName = PIC.getPassNameForClassName(ClassName);
1100 return PassName.empty() ? ClassName : PassName;
1106 if (LangOpts.HIPStdPar && !LangOpts.CUDAIsDevice &&
1107 LangOpts.HIPStdParInterposeAlloc)
1108 MPM.addPass(HipStdParAllocationInterpositionPass());
1112 PrettyStackTraceString CrashInfo(
"Optimizer");
1113 llvm::TimeTraceScope TimeScope(
"Optimizer");
1114 MPM.run(*TheModule, MAM);
1118void EmitAssemblyHelper::RunCodegenPipeline(
1119 BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
1120 std::unique_ptr<llvm::ToolOutputFile> &DwoOS) {
1124 legacy::PassManager CodeGenPasses;
1132 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
1138 if (!AddEmitPasses(CodeGenPasses, Action, *OS,
1139 DwoOS ? &DwoOS->os() :
nullptr))
1155 PrettyStackTraceString CrashInfo(
"Code generation");
1156 llvm::TimeTraceScope TimeScope(
"CodeGenPasses");
1157 CodeGenPasses.run(*TheModule);
1162 std::unique_ptr<raw_pwrite_stream> OS,
1164 TimeRegion Region(CodeGenOpts.TimePasses ? &CodeGenerationTime :
nullptr);
1168 CreateTargetMachine(RequiresCodeGen);
1170 if (RequiresCodeGen && !TM)
1173 TheModule->setDataLayout(TM->createDataLayout());
1176 cl::PrintOptionValues();
1178 std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;
1179 RunOptimizationPipeline(Action, OS, ThinLinkOS, BC);
1180 RunCodegenPipeline(Action, OS, DwoOS);
1192 const LangOptions &LOpts, std::unique_ptr<raw_pwrite_stream> OS,
1193 std::string SampleProfile, std::string ProfileRemapping,
1195 DenseMap<StringRef, DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
1196 ModuleToDefinedGVSummaries;
1197 CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1204 FunctionImporter::ImportMapTy ImportList;
1205 if (!lto::initImportList(*M, *CombinedIndex, ImportList))
1208 auto AddStream = [&](
size_t Task,
const Twine &ModuleName) {
1209 return std::make_unique<CachedFileStream>(std::move(OS),
1216 handleAllErrors(std::move(
E), [&](ErrorInfoBase &EIB) {
1217 errs() <<
"Error setting up ThinLTO save-temps: " << EIB.message()
1222 Conf.CPU = TOpts.
CPU;
1226 std::optional<CodeGenOptLevel> OptLevelOrNone =
1227 CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
1228 assert(OptLevelOrNone &&
"Invalid optimization level!");
1229 Conf.CGOptLevel = *OptLevelOrNone;
1230 Conf.OptLevel = CGOpts.OptimizationLevel;
1232 Conf.SampleProfile = std::move(SampleProfile);
1233 Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
1236 Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
1237 Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;
1238 Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;
1241 Conf.PTO.CallGraphProfile = !CGOpts.DisableIntegratedAS;
1245 Conf.RunCSIRInstr =
true;
1248 Conf.RunCSIRInstr =
false;
1252 Conf.ProfileRemapping = std::move(ProfileRemapping);
1253 Conf.DebugPassManager = CGOpts.DebugPassManager;
1254 Conf.VerifyEach = CGOpts.VerifyEach;
1255 Conf.RemarksWithHotness = CGOpts.DiagnosticsWithHotness;
1263 Conf.PreCodeGenModuleHook = [](
size_t Task,
const llvm::Module &Mod) {
1268 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const llvm::Module &Mod) {
1269 M->print(*OS,
nullptr, CGOpts.EmitLLVMUseLists);
1274 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const llvm::Module &Mod) {
1275 WriteBitcodeToFile(*M, *OS, CGOpts.EmitLLVMUseLists);
1284 thinBackend(Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
1285 ModuleToDefinedGVSummaries[M->getModuleIdentifier()],
1287 handleAllErrors(std::move(
E), [&](ErrorInfoBase &EIB) {
1288 errs() <<
"Error running ThinLTO backend: " << EIB.message() <<
'\n';
1296 const LangOptions &LOpts, StringRef TDesc, llvm::Module *M,
1300 llvm::TimeTraceScope TimeScope(
"Backend");
1302 std::unique_ptr<llvm::Module> EmptyModule;
1307 std::unique_ptr<ModuleSummaryIndex> CombinedIndex;
1308 if (Error
E = llvm::getModuleSummaryIndexForFile(
1311 .moveInto(CombinedIndex)) {
1312 logAllUnhandledErrors(std::move(
E), errs(),
1313 "Error loading index file '" +
1321 if (CombinedIndex) {
1322 if (!CombinedIndex->skipModuleByDistributedBackend()) {
1334 EmptyModule = std::make_unique<llvm::Module>(
"empty", M->getContext());
1335 EmptyModule->setTargetTriple(M->getTargetTriple());
1336 M = EmptyModule.get();
1340 EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M, VFS);
1341 AsmHelper.EmitAssembly(Action, std::move(OS), BC);
1346 std::string DLDesc = M->getDataLayout().getStringRepresentation();
1347 if (DLDesc != TDesc) {
1350 "expected target description '%1'");
1351 Diags.
Report(DiagID) << DLDesc << TDesc;
1359 llvm::MemoryBufferRef Buf) {
1362 llvm::embedBitcodeInModule(
1374 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ObjectOrErr =
1375 llvm::MemoryBuffer::getFileOrSTDIN(OffloadObject);
1376 if (ObjectOrErr.getError()) {
1378 "could not open '%0' for embedding");
1379 Diags.
Report(DiagID) << OffloadObject;
1383 llvm::embedBufferInModule(*M, **ObjectOrErr,
".llvm.offloading",
1384 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.