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());
636 if (getOptLevel() !=
CodeGenOpt::None && !Opt.DisablePartialLibcallInlining)
652 addPass(SelectOptimizePass());
657template <
typename Derived>
661 assert(MCAI &&
"No MCAsmInfo");
670 addPass(SjLjEHPreparePass());
675 addPass(DwarfEHPass(getOptLevel()));
681 addPass(WinEHPass());
682 addPass(DwarfEHPass(getOptLevel()));
689 addPass(WinEHPass(
false));
690 addPass(WasmEHPass());
703template <
typename Derived>
706 addPass(CodeGenPreparePass());
713template <
typename Derived>
715 derived().addPreISel(addPass);
717 addPass(CallBrPrepare());
720 addPass(SafeStackPass());
721 addPass(StackProtectorPass());
723 if (Opt.PrintISelInput)
725 "\n\n*** Final LLVM Code input to ISel ***\n"));
729 if (!Opt.DisableVerify)
733template <
typename Derived>
737 TM.setO0WantsFastISel(Opt.EnableFastISelOption.value_or(
true));
741 SelectorType Selector;
743 if (Opt.EnableFastISelOption && *Opt.EnableFastISelOption ==
true)
744 Selector = SelectorType::FastISel;
745 else if ((Opt.EnableGlobalISelOption &&
746 *Opt.EnableGlobalISelOption ==
true) ||
747 (
TM.Options.EnableGlobalISel &&
748 (!Opt.EnableGlobalISelOption ||
749 *Opt.EnableGlobalISelOption ==
false)))
750 Selector = SelectorType::GlobalISel;
752 Selector = SelectorType::FastISel;
754 Selector = SelectorType::SelectionDAG;
757 if (Selector == SelectorType::FastISel) {
758 TM.setFastISel(
true);
759 TM.setGlobalISel(
false);
760 }
else if (Selector == SelectorType::GlobalISel) {
761 TM.setFastISel(
false);
762 TM.setGlobalISel(
true);
766 if (Selector == SelectorType::GlobalISel) {
767 if (
auto Err = derived().addIRTranslator(addPass))
768 return std::move(Err);
770 derived().addPreLegalizeMachineIR(addPass);
772 if (
auto Err = derived().addLegalizeMachineIR(addPass))
773 return std::move(Err);
777 derived().addPreRegBankSelect(addPass);
779 if (
auto Err = derived().addRegBankSelect(addPass))
780 return std::move(Err);
782 derived().addPreGlobalInstructionSelect(addPass);
784 if (
auto Err = derived().addGlobalInstructionSelect(addPass))
785 return std::move(Err);
788 addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
789 isGlobalISelAbortEnabled()));
793 if (!isGlobalISelAbortEnabled())
794 if (
auto Err = derived().addInstSelector(addPass))
795 return std::move(Err);
797 }
else if (
auto Err = derived().addInstSelector(addPass))
798 return std::move(Err);
802 addPass(FinalizeISelPass());
825template <
typename Derived>
830 derived().addMachineSSAOptimization(addPass);
834 addPass(LocalStackSlotPass());
837 if (
TM.Options.EnableIPRA)
838 addPass(RegUsageInfoPropagationPass());
841 derived().addPreRegAlloc(addPass);
845 if (*Opt.OptimizeRegAlloc) {
846 derived().addOptimizedRegAlloc(addPass);
848 if (
auto Err = derived().addFastRegAlloc(addPass))
853 derived().addPostRegAlloc(addPass);
855 addPass(RemoveRedundantDebugValuesPass());
859 addPass(PostRAMachineSinkingPass());
860 addPass(ShrinkWrapPass());
863 addPass(PrologEpilogInserterPass());
867 derived().addMachineLateOptimization(addPass);
870 addPass(ExpandPostRAPseudosPass());
873 derived().addPreSched2(addPass);
875 if (Opt.EnableImplicitNullChecks)
876 addPass(ImplicitNullChecksPass());
882 !
TM.targetSchedulesPostRAScheduling()) {
883 if (Opt.MISchedPostRA)
884 addPass(PostMachineSchedulerPass());
886 addPass(PostRASchedulerPass());
890 derived().addGCPasses(addPass);
894 derived().addBlockPlacement(addPass);
897 addPass(FEntryInserterPass());
899 addPass(XRayInstrumentationPass());
900 addPass(PatchableFunctionPass());
902 derived().addPreEmitPass(addPass);
904 if (
TM.Options.EnableIPRA)
907 addPass(RegUsageInfoCollectorPass());
909 addPass(FuncletLayoutPass());
911 addPass(StackMapLivenessPass());
912 addPass(LiveDebugValuesPass());
913 addPass(MachineSanitizerBinaryMetadata());
917 bool RunOnAllFunctions =
919 bool AddOutliner = RunOnAllFunctions ||
TM.Options.SupportsDefaultOutlining;
921 addPass(MachineOutlinerPass(RunOnAllFunctions));
925 derived().addPreEmitPass2(addPass);
931template <
typename Derived>
935 addPass(EarlyTailDuplicatePass());
939 addPass(OptimizePHIsPass());
943 addPass(StackColoringPass());
947 addPass(LocalStackSlotPass());
953 addPass(DeadMachineInstructionElimPass());
958 derived().addILPOpts(addPass);
960 addPass(EarlyMachineLICMPass());
961 addPass(MachineCSEPass());
963 addPass(MachineSinkingPass());
965 addPass(PeepholeOptimizerPass());
968 addPass(DeadMachineInstructionElimPass());
983template <
typename Derived>
987 addPass(RAGreedyPass());
989 addPass(RAFastPass());
995template <
typename Derived>
997 bool Optimized)
const {
1000 derived().addTargetRegisterAllocator(addPass, Optimized);
1002 addPass(RABasicPass());
1004 addPass(RAFastPass());
1006 addPass(RAGreedyPass());
1008 addPass(RAPBQPPass());
1013template <
typename Derived>
1018 return make_error<StringError>(
1019 "Must use fast (default) register allocator for unoptimized regalloc.",
1022 addRegAllocPass(addPass,
false);
1026template <
typename Derived>
1030 addRegAllocPass(addPass,
true);
1033 derived().addPreRewrite(addPass);
1036 addPass(VirtRegRewriterPass());
1041 addPass(StackSlotColoringPass());
1048template <
typename Derived>
1051 addPass(PHIEliminationPass());
1052 addPass(TwoAddressInstructionPass());
1053 return derived().addRegAssignmentFast(addPass);
1059template <
typename Derived>
1062 addPass(DetectDeadLanesPass());
1064 addPass(ProcessImplicitDefsPass());
1067 addPass(PHIEliminationPass());
1070 if (Opt.EarlyLiveIntervals)
1071 addPass(LiveIntervalsPass());
1073 addPass(TwoAddressInstructionPass());
1074 addPass(RegisterCoalescerPass());
1079 addPass(RenameIndependentSubregsPass());
1082 addPass(MachineSchedulerPass());
1084 if (derived().addRegAssignmentOptimized(addPass)) {
1087 derived().addPostRewrite(addPass);
1091 addPass(MachineCopyPropagationPass());
1096 addPass(MachineLICMPass());
1105template <
typename Derived>
1109 addPass(BranchFolderPass());
1115 if (!
TM.requiresStructuredCFG())
1116 addPass(TailDuplicatePass());
1119 addPass(MachineLateInstrsCleanupPass());
1122 addPass(MachineCopyPropagationPass());
1126template <
typename Derived>
1129 addPass(MachineBlockPlacementPass());
1131 if (Opt.EnableBlockPlacementStats)
1132 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.
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.
CodeGenOpt::Level getOptLevel() const
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.
CodeGenOpt::Level 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.
Level
Code generation optimization level.
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.
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