15#ifndef LLVM_CODEGEN_CODEGENPASSBUILDER_H
16#define LLVM_CODEGEN_CODEGENPASSBUILDER_H
58#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
59 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
60 template <typename... Ts> PASS_NAME(Ts &&...) {} \
61 PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
62 return PreservedAnalyses::all(); \
65#define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
66 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
67 template <typename... Ts> PASS_NAME(Ts &&...) {} \
68 PreservedAnalyses run(Module &, ModuleAnalysisManager &) { \
69 return PreservedAnalyses::all(); \
72#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
73 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
74 template <typename... Ts> PASS_NAME(Ts &&...) {} \
75 Error run(Module &, MachineFunctionAnalysisManager &) { \
76 return Error::success(); \
78 PreservedAnalyses run(MachineFunction &, \
79 MachineFunctionAnalysisManager &) { \
80 llvm_unreachable("this api is to make new PM api happy"); \
82 static AnalysisKey Key; \
84#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
85 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
86 template <typename... Ts> PASS_NAME(Ts &&...) {} \
87 PreservedAnalyses run(MachineFunction &, \
88 MachineFunctionAnalysisManager &) { \
89 return PreservedAnalyses::all(); \
91 static AnalysisKey Key; \
93#include "MachinePassRegistry.def"
141 template <
typename PassT>
using has_key_t =
decltype(PassT::Key);
143 template <
typename PassT>
145 std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
147 template <
typename PassT>
149 std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
157 AddingFunctionPasses =
false;
164 template <
typename PassT>
165 std::enable_if_t<is_detected<is_function_pass_t, PassT>::value>
167 if (AddingFunctionPasses && !*AddingFunctionPasses)
168 AddingFunctionPasses =
true;
173 template <
typename PassT>
174 std::enable_if_t<is_detected<is_module_pass_t, PassT>::value &&
177 assert((!AddingFunctionPasses || !*AddingFunctionPasses) &&
178 "could not add module pass after adding function pass");
192 std::optional<bool> AddingFunctionPasses;
203 "Machine function pass must define a static member variable `Key`.");
204 for (
auto &
C : BeforeCallbacks)
208 for (
auto &
C : AfterCallbacks)
213 AfterCallbacks.emplace_back(
221 BeforeCallbacks.emplace_back(
245 template <
typename TMC> TMC &
getTM()
const {
return static_cast<TMC &
>(
TM); }
265 return make_error<StringError>(
"addInstSelector is not overridden",
330 return make_error<StringError>(
"addIRTranslator is not overridden",
341 return make_error<StringError>(
"addLegalizeMachineIR is not overridden",
353 return make_error<StringError>(
"addRegBankSelect is not overridden",
366 return make_error<StringError>(
367 "addGlobalInstructionSelect is not overridden",
432 std::function<Expected<std::unique_ptr<MCStreamer>>(
MCContext &)>;
454 DerivedT &derived() {
return static_cast<DerivedT &
>(*this); }
455 const DerivedT &derived()
const {
456 return static_cast<const DerivedT &
>(*this);
460template <
typename Derived>
466 addISelPasses(addIRPass);
469 if (
auto Err = addCoreISelPasses(addPass))
470 return std::move(Err);
472 if (
auto Err = derived().addMachinePasses(addPass))
473 return std::move(Err);
475 derived().addAsmPrinter(
476 addPass, [
this, &Out, DwoOut, FileType](
MCContext &Ctx) {
477 return this->
TM.createMCStreamer(Out, DwoOut, FileType, Ctx);
480 addPass(FreeMachineFunctionPass());
501template <
typename Derived>
504#define MODULE_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
505 MAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
506#include "MachinePassRegistry.def"
507 derived().registerTargetAnalysis(
MAM);
510template <
typename Derived>
515#define FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
516 FAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
517#include "MachinePassRegistry.def"
518 derived().registerTargetAnalysis(
FAM);
521template <
typename Derived>
524#define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
525 MFAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
526#include "MachinePassRegistry.def"
527 derived().registerTargetAnalysis(MFAM);
534template <
typename Derived>
535std::pair<StringRef, bool>
537 std::pair<StringRef, bool> Ret;
541#define FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
543 Ret = {#PASS_NAME, false};
544#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
546 Ret = {#PASS_NAME, false};
547#define MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
549 Ret = {#PASS_NAME, false};
550#define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
552 Ret = {#PASS_NAME, false};
553#define MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
555 Ret = {#PASS_NAME, true};
556#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
558 Ret = {#PASS_NAME, true};
559#define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
561 Ret = {#PASS_NAME, true};
562#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
564 Ret = {#PASS_NAME, true};
565#include "llvm/CodeGen/MachinePassRegistry.def"
567 if (Ret.first.empty())
568 Ret = derived().getTargetPassNameFromLegacyName(
Name);
570 if (Ret.first.empty())
572 Twine(
"\" pass could not be found."));
577template <
typename Derived>
579 if (
TM.useEmulatedTLS())
580 addPass(LowerEmuTLSPass());
584 derived().addIRPasses(addPass);
585 derived().addCodeGenPrepare(addPass);
586 addPassesToHandleExceptions(addPass);
587 derived().addISelPrepare(addPass);
592template <
typename Derived>
596 if (!Opt.DisableVerify)
613 if (!Opt.DisableMergeICmps)
615 addPass(ExpandMemCmpPass());
620 addPass(GCLoweringPass());
621 addPass(ShadowStackGCLoweringPass());
637 !Opt.DisablePartialLibcallInlining)
653 addPass(SelectOptimizePass());
658template <
typename Derived>
662 assert(MCAI &&
"No MCAsmInfo");
671 addPass(SjLjEHPreparePass());
676 addPass(DwarfEHPass(getOptLevel()));
682 addPass(WinEHPass());
683 addPass(DwarfEHPass(getOptLevel()));
690 addPass(WinEHPass(
false));
691 addPass(WasmEHPass());
704template <
typename Derived>
707 addPass(CodeGenPreparePass());
714template <
typename Derived>
716 derived().addPreISel(addPass);
718 addPass(CallBrPrepare());
721 addPass(SafeStackPass());
722 addPass(StackProtectorPass());
724 if (Opt.PrintISelInput)
726 "\n\n*** Final LLVM Code input to ISel ***\n"));
730 if (!Opt.DisableVerify)
734template <
typename Derived>
738 TM.setO0WantsFastISel(Opt.EnableFastISelOption.value_or(
true));
742 SelectorType Selector;
744 if (Opt.EnableFastISelOption && *Opt.EnableFastISelOption ==
true)
745 Selector = SelectorType::FastISel;
746 else if ((Opt.EnableGlobalISelOption &&
747 *Opt.EnableGlobalISelOption ==
true) ||
748 (
TM.Options.EnableGlobalISel &&
749 (!Opt.EnableGlobalISelOption ||
750 *Opt.EnableGlobalISelOption ==
false)))
751 Selector = SelectorType::GlobalISel;
753 Selector = SelectorType::FastISel;
755 Selector = SelectorType::SelectionDAG;
758 if (Selector == SelectorType::FastISel) {
759 TM.setFastISel(
true);
760 TM.setGlobalISel(
false);
761 }
else if (Selector == SelectorType::GlobalISel) {
762 TM.setFastISel(
false);
763 TM.setGlobalISel(
true);
767 if (Selector == SelectorType::GlobalISel) {
768 if (
auto Err = derived().addIRTranslator(addPass))
769 return std::move(Err);
771 derived().addPreLegalizeMachineIR(addPass);
773 if (
auto Err = derived().addLegalizeMachineIR(addPass))
774 return std::move(Err);
778 derived().addPreRegBankSelect(addPass);
780 if (
auto Err = derived().addRegBankSelect(addPass))
781 return std::move(Err);
783 derived().addPreGlobalInstructionSelect(addPass);
785 if (
auto Err = derived().addGlobalInstructionSelect(addPass))
786 return std::move(Err);
789 addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
790 isGlobalISelAbortEnabled()));
794 if (!isGlobalISelAbortEnabled())
795 if (
auto Err = derived().addInstSelector(addPass))
796 return std::move(Err);
798 }
else if (
auto Err = derived().addInstSelector(addPass))
799 return std::move(Err);
803 addPass(FinalizeISelPass());
826template <
typename Derived>
831 derived().addMachineSSAOptimization(addPass);
835 addPass(LocalStackSlotPass());
838 if (
TM.Options.EnableIPRA)
839 addPass(RegUsageInfoPropagationPass());
842 derived().addPreRegAlloc(addPass);
846 if (*Opt.OptimizeRegAlloc) {
847 derived().addOptimizedRegAlloc(addPass);
849 if (
auto Err = derived().addFastRegAlloc(addPass))
854 derived().addPostRegAlloc(addPass);
856 addPass(RemoveRedundantDebugValuesPass());
860 addPass(PostRAMachineSinkingPass());
861 addPass(ShrinkWrapPass());
864 addPass(PrologEpilogInserterPass());
868 derived().addMachineLateOptimization(addPass);
871 addPass(ExpandPostRAPseudosPass());
874 derived().addPreSched2(addPass);
876 if (Opt.EnableImplicitNullChecks)
877 addPass(ImplicitNullChecksPass());
883 !
TM.targetSchedulesPostRAScheduling()) {
884 if (Opt.MISchedPostRA)
885 addPass(PostMachineSchedulerPass());
887 addPass(PostRASchedulerPass());
891 derived().addGCPasses(addPass);
895 derived().addBlockPlacement(addPass);
898 addPass(FEntryInserterPass());
900 addPass(XRayInstrumentationPass());
901 addPass(PatchableFunctionPass());
903 derived().addPreEmitPass(addPass);
905 if (
TM.Options.EnableIPRA)
908 addPass(RegUsageInfoCollectorPass());
910 addPass(FuncletLayoutPass());
912 addPass(StackMapLivenessPass());
913 addPass(LiveDebugValuesPass());
914 addPass(MachineSanitizerBinaryMetadata());
916 if (
TM.Options.EnableMachineOutliner &&
919 bool RunOnAllFunctions =
921 bool AddOutliner = RunOnAllFunctions ||
TM.Options.SupportsDefaultOutlining;
923 addPass(MachineOutlinerPass(RunOnAllFunctions));
927 derived().addPreEmitPass2(addPass);
933template <
typename Derived>
937 addPass(EarlyTailDuplicatePass());
941 addPass(OptimizePHIsPass());
945 addPass(StackColoringPass());
949 addPass(LocalStackSlotPass());
955 addPass(DeadMachineInstructionElimPass());
960 derived().addILPOpts(addPass);
962 addPass(EarlyMachineLICMPass());
963 addPass(MachineCSEPass());
965 addPass(MachineSinkingPass());
967 addPass(PeepholeOptimizerPass());
970 addPass(DeadMachineInstructionElimPass());
985template <
typename Derived>
989 addPass(RAGreedyPass());
991 addPass(RAFastPass());
997template <
typename Derived>
999 bool Optimized)
const {
1002 derived().addTargetRegisterAllocator(addPass, Optimized);
1004 addPass(RABasicPass());
1006 addPass(RAFastPass());
1008 addPass(RAGreedyPass());
1010 addPass(RAPBQPPass());
1015template <
typename Derived>
1020 return make_error<StringError>(
1021 "Must use fast (default) register allocator for unoptimized regalloc.",
1024 addRegAllocPass(addPass,
false);
1028template <
typename Derived>
1032 addRegAllocPass(addPass,
true);
1035 derived().addPreRewrite(addPass);
1038 addPass(VirtRegRewriterPass());
1043 addPass(StackSlotColoringPass());
1050template <
typename Derived>
1053 addPass(PHIEliminationPass());
1054 addPass(TwoAddressInstructionPass());
1055 return derived().addRegAssignmentFast(addPass);
1061template <
typename Derived>
1064 addPass(DetectDeadLanesPass());
1066 addPass(ProcessImplicitDefsPass());
1069 addPass(PHIEliminationPass());
1072 if (Opt.EarlyLiveIntervals)
1073 addPass(LiveIntervalsPass());
1075 addPass(TwoAddressInstructionPass());
1076 addPass(RegisterCoalescerPass());
1081 addPass(RenameIndependentSubregsPass());
1084 addPass(MachineSchedulerPass());
1086 if (derived().addRegAssignmentOptimized(addPass)) {
1089 derived().addPostRewrite(addPass);
1093 addPass(MachineCopyPropagationPass());
1098 addPass(MachineLICMPass());
1107template <
typename Derived>
1111 addPass(BranchFolderPass());
1117 if (!
TM.requiresStructuredCFG())
1118 addPass(TailDuplicatePass());
1121 addPass(MachineLateInstrsCleanupPass());
1124 addPass(MachineCopyPropagationPass());
1128template <
typename Derived>
1131 addPass(MachineBlockPlacementPass());
1133 if (Opt.EnableBlockPlacementStats)
1134 addPass(MachineBlockPlacementStatsPass());
This is the interface for LLVM's primary stateless and local alias analysis.
This file defines passes to print out IR in various granularities.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
const char LLVMTargetMachineRef TM
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This is the interface for a metadata-based scoped no-alias analysis.
This file defines the SmallVector class.
This is the interface for a metadata-based TBAA.
A manager for alias analyses.
void registerFunctionAnalysis()
Register a specific AA result.
A container for analyses that lazily runs them and caches their results.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Analysis pass providing a never-invalidated alias analysis result.
std::enable_if_t< is_detected< is_module_pass_t, PassT >::value &&!is_detected< is_function_pass_t, PassT >::value > operator()(PassT &&Pass)
AddIRPass(ModulePassManager &MPM, bool DebugPM, bool Check=true)
std::enable_if_t< is_detected< is_function_pass_t, PassT >::value > operator()(PassT &&Pass)
void disablePass(AnalysisKey *ID)
AddMachinePass(MachineFunctionPassManager &PM)
void insertPass(AnalysisKey *ID, PassT Pass)
void operator()(PassT &&Pass)
MachineFunctionPassManager releasePM()
This class provides access to building LLVM's passes.
Error addLegalizeMachineIR(AddMachinePass &) const
This method should install a legalize pass, which converts the instruction sequence into one that can...
void addAsmPrinter(AddMachinePass &, CreateMCStreamer) const
void addISelPasses(AddIRPass &) const
High level function that adds all passes necessary to go from llvm IR representation to the MI repres...
Error addInstSelector(AddMachinePass &) const
addInstSelector - This method should install an instruction selector pass, which converts from LLVM c...
PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const
Error buildPipeline(ModulePassManager &MPM, MachineFunctionPassManager &MFPM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType) const
void addPreEmitPass(AddMachinePass &) const
This pass may be implemented by targets that want to run passes immediately before machine code is em...
Error addIRTranslator(AddMachinePass &) const
This method should install an IR translator pass, which converts from LLVM code to machine instructio...
Error addGlobalInstructionSelect(AddMachinePass &) const
This method should install a (global) instruction selector pass, which converts possibly generic inst...
void addPostRewrite(AddMachinePass &) const
Add passes to be run immediately after virtual registers are rewritten to physical registers.
Error addRegBankSelect(AddMachinePass &) const
This method should install a register bank selector pass, which assigns register banks to virtual reg...
void registerTargetAnalysis(ModuleAnalysisManager &) const
Target override these hooks to parse target-specific analyses.
void registerAnalyses(MachineFunctionAnalysisManager &MFAM) const
void addPreSched2(AddMachinePass &) const
This method may be implemented by targets that want to run passes after prolog-epilog insertion and b...
void addPreLegalizeMachineIR(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before legalization.
void addOptimizedRegAlloc(AddMachinePass &) const
addOptimizedRegAlloc - Add passes related to register allocation.
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &) const
decltype(std::declval< PassT & >().run(std::declval< Function & >(), std::declval< FunctionAnalysisManager & >())) is_function_pass_t
void addGCPasses(AddMachinePass &) const
addGCPasses - Add late codegen passes that analyze code for garbage collection.
void addMachineSSAOptimization(AddMachinePass &) const
Methods with trivial inline returns are convenient points in the common codegen pass pipeline where t...
Error addRegAssignmentOptimized(AddMachinePass &) const
void registerModuleAnalyses(ModuleAnalysisManager &) const
Error addCoreISelPasses(AddMachinePass &) const
Add the actual instruction selection passes.
PassInstrumentationCallbacks * PIC
void addPassesToHandleExceptions(AddIRPass &) const
Add passes to lower exception handling for the code generator.
void addPreGlobalInstructionSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the (global) ins...
void addMachineLateOptimization(AddMachinePass &) const
Add passes that optimize machine instructions after register allocation.
void addISelPrepare(AddIRPass &) const
Add common passes that perform LLVM IR to IR transforms in preparation for instruction selection.
void addPostRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes after register allocation pass pipe...
std::pair< StringRef, bool > getPassNameFromLegacyName(StringRef) const
void addCodeGenPrepare(AddIRPass &) const
Add pass to prepare the LLVM IR for code generation.
bool reportDiagnosticWhenGlobalISelFallback() const
Check whether or not a diagnostic should be emitted when GlobalISel uses the fallback path.
void addPreISel(AddIRPass &) const
{{@ For GlobalISel
void addPreRegBankSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the register ban...
decltype(std::declval< PassT & >().run(std::declval< Module & >(), std::declval< ModuleAnalysisManager & >())) is_module_pass_t
void addBlockPlacement(AddMachinePass &) const
Add standard basic block placement passes.
void registerTargetAnalysis(MachineFunctionAnalysisManager &) const
bool isGlobalISelAbortEnabled() const
Check whether or not GlobalISel should abort on error.
CodeGenOptLevel getOptLevel() const
void addPreEmitPass2(AddMachinePass &) const
Targets may add passes immediately before machine code is emitted in this callback.
std::function< Expected< std::unique_ptr< MCStreamer > >(MCContext &)> CreateMCStreamer
std::pair< StringRef, bool > getTargetPassNameFromLegacyName(StringRef) const
void addIRPasses(AddIRPass &) const
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
void addRegAllocPass(AddMachinePass &, bool Optimized) const
addMachinePasses helper to create the target-selected or overriden regalloc pass.
void registerTargetAnalysis(FunctionAnalysisManager &) const
void addILPOpts(AddMachinePass &) const
Add passes that optimize instruction level parallelism for out-of-order targets.
Error addRegAssignmentFast(AddMachinePass &) const
Add core register alloator passes which do the actual register assignment and rewriting.
void addPreRewrite(AddMachinePass &) const
addPreRewrite - Add passes to the optimized register allocation pipeline after register allocation is...
decltype(PassT::Key) has_key_t
Error addMachinePasses(AddMachinePass &) const
Add the complete, standard set of LLVM CodeGen passes.
CodeGenPassBuilder(LLVMTargetMachine &TM, CGPassBuilderOption Opts, PassInstrumentationCallbacks *PIC)
void addPreRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before register allocat...
void registerFunctionAnalyses(FunctionAnalysisManager &) const
void addTargetRegisterAllocator(AddMachinePass &, bool Optimized) const
Utilities for targets to add passes to the pass manager.
Error addFastRegAlloc(AddMachinePass &) const
addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast registe...
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Performs Loop Strength Reduce Pass.
This class is intended to be used as a base class for asm properties and features specific to the tar...
ExceptionHandling getExceptionHandlingType() const
Context object for machine code objects.
An AnalysisManager<MachineFunction> that also exposes IR analysis results.
ModuleAnalysisManager * MAM
FunctionAnalysisManager * FAM
MachineFunctionPassManager adds/removes below features to/from the base PassManager template instanti...
void addPass(PassT &&Pass)
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)
Pass interface - Implemented by all 'passes'.
Pass (for the new pass manager) for printing a Function as LLVM's text IR assembly.
Analysis pass providing a never-invalidated alias analysis result.
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
GlobalISelAbortMode GlobalISelAbort
EnableGlobalISelAbort - Control abort behaviour when global instruction selection fails to lower/sele...
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Analysis pass providing a never-invalidated alias analysis result.
An abstract base class for streams implementations that also support a pwrite operation.
unique_function is a type-erasing functor similar to std::function.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
static AAManager registerAAAnalyses()
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
@ SjLj
setjmp/longjmp based exceptions
@ None
No exception support.
@ AIX
AIX Exception Handling.
@ DwarfCFI
DWARF-like instruction based exceptions.
@ WinEH
Windows Exception Handling.
@ Wasm
WebAssembly Exception Handling.
typename detail::detector< void, Op, Args... >::value_t is_detected
Detects if a given trait holds for some set of arguments 'Args'.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
CodeGenOptLevel
Code generation optimization level.
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
A special type used by analysis passes to provide an address that identifies that particular analysis...
std::optional< bool > EnableIPRA
std::optional< bool > OptimizeRegAlloc
std::optional< GlobalISelAbortMode > EnableGlobalISelAbort