Go to the documentation of this file.
15 #ifndef LLVM_CODEGEN_CODEGENPASSBUILDER_H
16 #define LLVM_CODEGEN_CODEGENPASSBUILDER_H
53 #include <type_traits>
60 #define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
61 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
62 template <typename... Ts> PASS_NAME(Ts &&...) {} \
63 PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
64 return PreservedAnalyses::all(); \
67 #define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
68 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
69 template <typename... Ts> PASS_NAME(Ts &&...) {} \
70 PreservedAnalyses run(Module &, ModuleAnalysisManager &) { \
71 return PreservedAnalyses::all(); \
74 #define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
75 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
76 template <typename... Ts> PASS_NAME(Ts &&...) {} \
77 Error run(Module &, MachineFunctionAnalysisManager &) { \
78 return Error::success(); \
80 PreservedAnalyses run(MachineFunction &, \
81 MachineFunctionAnalysisManager &) { \
82 llvm_unreachable("this api is to make new PM api happy"); \
84 static AnalysisKey Key; \
86 #define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
87 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
88 template <typename... Ts> PASS_NAME(Ts &&...) {} \
89 PreservedAnalyses run(MachineFunction &, \
90 MachineFunctionAnalysisManager &) { \
91 return PreservedAnalyses::all(); \
93 static AnalysisKey Key; \
95 #include "MachinePassRegistry.def"
145 template <
typename PassT>
147 std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
149 template <
typename PassT>
151 std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
159 AddingFunctionPasses =
false;
166 template <
typename PassT>
167 std::enable_if_t<is_detected<is_function_pass_t, PassT>::value>
169 if (AddingFunctionPasses && !*AddingFunctionPasses)
170 AddingFunctionPasses =
true;
175 template <
typename PassT>
176 std::enable_if_t<is_detected<is_module_pass_t, PassT>::value &&
179 assert((!AddingFunctionPasses || !*AddingFunctionPasses) &&
180 "could not add module pass after adding function pass");
205 "Machine function pass must define a static member variable `Key`.");
206 for (
auto &
C : BeforeCallbacks)
210 for (
auto &
C : AfterCallbacks)
215 AfterCallbacks.emplace_back(
223 BeforeCallbacks.emplace_back(
247 template <
typename TMC> TMC &
getTM()
const {
return static_cast<TMC &
>(
TM); }
267 return make_error<StringError>(
"addInstSelector is not overridden",
332 return make_error<StringError>(
"addIRTranslator is not overridden",
343 return make_error<StringError>(
"addLegalizeMachineIR is not overridden",
355 return make_error<StringError>(
"addRegBankSelect is not overridden",
368 return make_error<StringError>(
369 "addGlobalInstructionSelect is not overridden",
434 std::function<Expected<std::unique_ptr<MCStreamer>>(
MCContext &)>;
456 DerivedT &derived() {
return static_cast<DerivedT &
>(*this); }
457 const DerivedT &derived()
const {
458 return static_cast<const DerivedT &
>(*this);
462 template <
typename Derived>
468 addISelPasses(addIRPass);
471 if (
auto Err = addCoreISelPasses(addPass))
474 if (
auto Err = derived().addMachinePasses(addPass))
477 derived().addAsmPrinter(
479 return this->
TM.createMCStreamer(Out, DwoOut,
FileType, Ctx);
482 addPass(FreeMachineFunctionPass());
518 template <
typename Derived>
521 #define MODULE_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
522 MAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
523 #include "MachinePassRegistry.def"
524 derived().registerTargetAnalysis(
MAM);
527 template <
typename Derived>
532 #define FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
533 FAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
534 #include "MachinePassRegistry.def"
535 derived().registerTargetAnalysis(
FAM);
538 template <
typename Derived>
541 #define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
542 MFAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
543 #include "MachinePassRegistry.def"
544 derived().registerTargetAnalysis(MFAM);
551 template <
typename Derived>
552 std::pair<StringRef, bool>
554 std::pair<StringRef, bool>
Ret;
558 #define FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
560 Ret = {#PASS_NAME, false};
561 #define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
563 Ret = {#PASS_NAME, false};
564 #define MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
566 Ret = {#PASS_NAME, false};
567 #define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
569 Ret = {#PASS_NAME, false};
570 #define MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
572 Ret = {#PASS_NAME, true};
573 #define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
575 Ret = {#PASS_NAME, true};
576 #define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
578 Ret = {#PASS_NAME, true};
579 #define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
581 Ret = {#PASS_NAME, true};
582 #include "llvm/CodeGen/MachinePassRegistry.def"
584 if (
Ret.first.empty())
585 Ret = derived().getTargetPassNameFromLegacyName(
Name);
587 if (
Ret.first.empty())
589 Twine(
"\" pass could not be found."));
594 template <
typename Derived>
596 if (
TM.useEmulatedTLS())
597 addPass(LowerEmuTLSPass());
601 derived().addIRPasses(addPass);
602 derived().addCodeGenPrepare(addPass);
603 addPassesToHandleExceptions(addPass);
604 derived().addISelPrepare(addPass);
609 template <
typename Derived>
613 if (!Opt.DisableVerify)
630 if (!Opt.DisableMergeICmps)
632 addPass(ExpandMemCmpPass());
637 addPass(GCLoweringPass());
638 addPass(ShadowStackGCLoweringPass());
653 if (getOptLevel() !=
CodeGenOpt::None && !Opt.DisablePartialLibcallInlining)
669 addPass(SelectOptimizePass());
674 template <
typename Derived>
678 assert(MCAI &&
"No MCAsmInfo");
687 addPass(SjLjEHPreparePass());
692 addPass(DwarfEHPass(getOptLevel()));
698 addPass(WinEHPass());
699 addPass(DwarfEHPass(getOptLevel()));
706 addPass(WinEHPass(
false));
707 addPass(WasmEHPass());
720 template <
typename Derived>
723 addPass(CodeGenPreparePass());
730 template <
typename Derived>
732 derived().addPreISel(addPass);
736 addPass(SafeStackPass());
737 addPass(StackProtectorPass());
739 if (Opt.PrintISelInput)
741 "\n\n*** Final LLVM Code input to ISel ***\n"));
745 if (!Opt.DisableVerify)
749 template <
typename Derived>
753 TM.setO0WantsFastISel(Opt.EnableFastISelOption.value_or(
true));
757 SelectorType Selector;
759 if (Opt.EnableFastISelOption && *Opt.EnableFastISelOption ==
true)
760 Selector = SelectorType::FastISel;
761 else if ((Opt.EnableGlobalISelOption &&
762 *Opt.EnableGlobalISelOption ==
true) ||
763 (
TM.Options.EnableGlobalISel &&
764 (!Opt.EnableGlobalISelOption ||
765 *Opt.EnableGlobalISelOption ==
false)))
766 Selector = SelectorType::GlobalISel;
768 Selector = SelectorType::FastISel;
770 Selector = SelectorType::SelectionDAG;
773 if (Selector == SelectorType::FastISel) {
774 TM.setFastISel(
true);
775 TM.setGlobalISel(
false);
776 }
else if (Selector == SelectorType::GlobalISel) {
777 TM.setFastISel(
false);
778 TM.setGlobalISel(
true);
782 if (Selector == SelectorType::GlobalISel) {
783 if (
auto Err = derived().addIRTranslator(addPass))
786 derived().addPreLegalizeMachineIR(addPass);
788 if (
auto Err = derived().addLegalizeMachineIR(addPass))
793 derived().addPreRegBankSelect(addPass);
795 if (
auto Err = derived().addRegBankSelect(addPass))
798 derived().addPreGlobalInstructionSelect(addPass);
800 if (
auto Err = derived().addGlobalInstructionSelect(addPass))
804 addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
805 isGlobalISelAbortEnabled()));
809 if (!isGlobalISelAbortEnabled())
810 if (
auto Err = derived().addInstSelector(addPass))
813 }
else if (
auto Err = derived().addInstSelector(addPass))
818 addPass(FinalizeISelPass());
841 template <
typename Derived>
846 derived().addMachineSSAOptimization(addPass);
850 addPass(LocalStackSlotPass());
853 if (
TM.Options.EnableIPRA)
854 addPass(RegUsageInfoPropagationPass());
857 derived().addPreRegAlloc(addPass);
861 if (*Opt.OptimizeRegAlloc) {
862 derived().addOptimizedRegAlloc(addPass);
864 if (
auto Err = derived().addFastRegAlloc(addPass))
869 derived().addPostRegAlloc(addPass);
871 addPass(RemoveRedundantDebugValuesPass());
875 addPass(PostRAMachineSinkingPass());
876 addPass(ShrinkWrapPass());
879 addPass(PrologEpilogInserterPass());
883 derived().addMachineLateOptimization(addPass);
886 addPass(ExpandPostRAPseudosPass());
889 derived().addPreSched2(addPass);
891 if (Opt.EnableImplicitNullChecks)
892 addPass(ImplicitNullChecksPass());
898 !
TM.targetSchedulesPostRAScheduling()) {
899 if (Opt.MISchedPostRA)
900 addPass(PostMachineSchedulerPass());
902 addPass(PostRASchedulerPass());
906 derived().addGCPasses(addPass);
910 derived().addBlockPlacement(addPass);
913 addPass(FEntryInserterPass());
915 addPass(XRayInstrumentationPass());
916 addPass(PatchableFunctionPass());
918 derived().addPreEmitPass(addPass);
920 if (
TM.Options.EnableIPRA)
923 addPass(RegUsageInfoCollectorPass());
925 addPass(FuncletLayoutPass());
927 addPass(StackMapLivenessPass());
928 addPass(LiveDebugValuesPass());
932 bool RunOnAllFunctions =
934 bool AddOutliner = RunOnAllFunctions ||
TM.Options.SupportsDefaultOutlining;
936 addPass(MachineOutlinerPass(RunOnAllFunctions));
940 derived().addPreEmitPass2(addPass);
946 template <
typename Derived>
950 addPass(EarlyTailDuplicatePass());
954 addPass(OptimizePHIsPass());
958 addPass(StackColoringPass());
962 addPass(LocalStackSlotPass());
968 addPass(DeadMachineInstructionElimPass());
973 derived().addILPOpts(addPass);
975 addPass(EarlyMachineLICMPass());
976 addPass(MachineCSEPass());
978 addPass(MachineSinkingPass());
980 addPass(PeepholeOptimizerPass());
983 addPass(DeadMachineInstructionElimPass());
998 template <
typename Derived>
1002 addPass(RAGreedyPass());
1004 addPass(RAFastPass());
1010 template <
typename Derived>
1012 bool Optimized)
const {
1015 derived().addTargetRegisterAllocator(addPass, Optimized);
1017 addPass(RABasicPass());
1019 addPass(RAFastPass());
1021 addPass(RAGreedyPass());
1023 addPass(RAPBQPPass());
1028 template <
typename Derived>
1033 return make_error<StringError>(
1034 "Must use fast (default) register allocator for unoptimized regalloc.",
1037 addRegAllocPass(addPass,
false);
1041 template <
typename Derived>
1045 addRegAllocPass(addPass,
true);
1048 derived().addPreRewrite(addPass);
1051 addPass(VirtRegRewriterPass());
1056 addPass(StackSlotColoringPass());
1063 template <
typename Derived>
1066 addPass(PHIEliminationPass());
1067 addPass(TwoAddressInstructionPass());
1068 return derived().addRegAssignmentFast(addPass);
1074 template <
typename Derived>
1077 addPass(DetectDeadLanesPass());
1079 addPass(ProcessImplicitDefsPass());
1082 addPass(PHIEliminationPass());
1085 if (Opt.EarlyLiveIntervals)
1086 addPass(LiveIntervalsPass());
1088 addPass(TwoAddressInstructionPass());
1089 addPass(RegisterCoalescerPass());
1094 addPass(RenameIndependentSubregsPass());
1097 addPass(MachineSchedulerPass());
1099 if (derived().addRegAssignmentOptimized(addPass)) {
1102 derived().addPostRewrite(addPass);
1106 addPass(MachineCopyPropagationPass());
1111 addPass(MachineLICMPass());
1120 template <
typename Derived>
1124 addPass(BranchFolderPass());
1130 if (!
TM.requiresStructuredCFG())
1131 addPass(TailDuplicatePass());
1134 addPass(MachineCopyPropagationPass());
1138 template <
typename Derived>
1141 addPass(MachineBlockPlacementPass());
1143 if (Opt.EnableBlockPlacementStats)
1144 addPass(MachineBlockPlacementStatsPass());
1149 #endif // LLVM_CODEGEN_CODEGENPASSBUILDER_H
CodeGenOpt::Level getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
Analysis pass providing a never-invalidated alias analysis result.
Analysis pass providing a never-invalidated alias analysis result.
A manager for alias analyses.
Pass for printing a Function as LLVM's text IR assembly.
This is an optimization pass for GlobalISel generic memory operations.
PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const
bool isGlobalISelAbortEnabled() const
Check whether or not GlobalISel should abort on error.
This class provides access to building LLVM's passes.
void addTargetRegisterAllocator(AddMachinePass &, bool Optimized) const
Utilities for targets to add passes to the pass manager.
void insertPass(AnalysisKey *ID, PassT Pass)
void addGCPasses(AddMachinePass &) const
addGCPasses - Add late codegen passes that analyze code for garbage collection.
unique_function is a type-erasing functor similar to std::function.
@ SjLj
setjmp/longjmp based exceptions
void addILPOpts(AddMachinePass &) const
Add passes that optimize instruction level parallelism for out-of-order targets.
Context object for machine code objects.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
CodeGenPassBuilder(LLVMTargetMachine &TM, CGPassBuilderOption Opts, PassInstrumentationCallbacks *PIC)
std::function< Expected< std::unique_ptr< MCStreamer > >(MCContext &)> CreateMCStreamer
Error addInstSelector(AddMachinePass &) const
addInstSelector - This method should install an instruction selector pass, which converts from LLVM c...
This class is intended to be used as a base class for asm properties and features specific to the tar...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void addPostRewrite(AddMachinePass &) const
Add passes to be run immediately after virtual registers are rewritten to physical registers.
static ErrorSuccess success()
Create a success value.
void registerTargetAnalysis(ModuleAnalysisManager &) const
Target override these hooks to parse target-specific analyses.
FunctionAnalysisManager FAM
void addISelPrepare(AddIRPass &) const
Add common passes that perform LLVM IR to IR transforms in preparation for instruction selection.
Error addIRTranslator(AddMachinePass &) const
This method should install an IR translator pass, which converts from LLVM code to machine instructio...
Error addMachinePasses(AddMachinePass &) const
Add the complete, standard set of LLVM CodeGen passes.
void addOptimizedRegAlloc(AddMachinePass &) const
addOptimizedRegAlloc - Add passes related to register allocation.
std::enable_if_t< is_detected< is_module_pass_t, PassT >::value &&!is_detected< is_function_pass_t, PassT >::value > operator()(PassT &&Pass)
static cl::opt<::CFLAAType > UseCFLAA("use-cfl-aa", cl::init(::CFLAAType::None), cl::Hidden, cl::desc("Enable the new, experimental CFL alias analysis"), cl::values(clEnumValN(::CFLAAType::None, "none", "Disable CFL-AA"), clEnumValN(::CFLAAType::Steensgaard, "steens", "Enable unification-based CFL-AA"), clEnumValN(::CFLAAType::Andersen, "anders", "Enable inclusion-based CFL-AA"), clEnumValN(::CFLAAType::Both, "both", "Enable both variants of CFL-AA")))
CodeGenOpt::Level getOptLevel() const
Performs Loop Strength Reduce Pass.
typename detail::detector< void, Op, Args... >::value_t is_detected
Detects if a given trait holds for some set of arguments 'Args'.
@ AIX
AIX Exception Handling.
Analysis pass providing a never-invalidated alias analysis result.
void addCodeGenPrepare(AddIRPass &) const
Add pass to prepare the LLVM IR for code generation.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void addPreLegalizeMachineIR(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before legalization.
void addPreEmitPass2(AddMachinePass &) const
Targets may add passes immediately before machine code is emitted in this callback.
static AAManager registerAAAnalyses(CFLAAType UseCFLAA)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
(vector float) vec_cmpeq(*A, *B) C
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
ModuleAnalysisManager MAM
void registerTargetAnalysis(FunctionAnalysisManager &) const
void registerFunctionAnalyses(FunctionAnalysisManager &) const
FunctionAnalysisManager * FAM
void registerAnalyses(MachineFunctionAnalysisManager &MFAM) const
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
@ Wasm
WebAssembly Exception Handling.
decltype(std::declval< PassT & >().run(std::declval< Function & >(), std::declval< FunctionAnalysisManager & >())) is_function_pass_t
void addIRPasses(AddIRPass &) const
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
void addPassesToHandleExceptions(AddIRPass &) const
Add passes to lower exception handling for the code generator.
decltype(std::declval< PassT & >().run(std::declval< Module & >(), std::declval< ModuleAnalysisManager & >())) is_module_pass_t
Analysis pass providing a never-invalidated alias analysis result.
An AnalysisManager<MachineFunction> that also exposes IR analysis results.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
AddIRPass(ModulePassManager &MPM, bool DebugPM, bool Check=true)
Error addRegAssignmentOptimized(AddMachinePass &) const
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
FileType
Defines the file type this file represents.
Error addFastRegAlloc(AddMachinePass &) const
addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast registe...
AddMachinePass(MachineFunctionPassManager &PM)
void registerTargetAnalysis(MachineFunctionAnalysisManager &) const
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
decltype(PassT::Key) has_key_t
Error addGlobalInstructionSelect(AddMachinePass &) const
This method should install a (global) instruction selector pass, which converts possibly generic inst...
An abstract base class for streams implementations that also support a pwrite operation.
bool reportDiagnosticWhenGlobalISelFallback() const
Check whether or not a diagnostic should be emitted when GlobalISel uses the fallback path.
std::pair< StringRef, bool > getTargetPassNameFromLegacyName(StringRef) const
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
ModuleAnalysisManager * MAM
A special type used by analysis passes to provide an address that identifies that particular analysis...
Error addRegAssignmentFast(AddMachinePass &) const
Add core register alloator passes which do the actual register assignment and rewriting.
void addISelPasses(AddIRPass &) const
High level function that adds all passes necessary to go from llvm IR representation to the MI repres...
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.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Optional< GlobalISelAbortMode > EnableGlobalISelAbort
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
void registerModuleAnalyses(ModuleAnalysisManager &) const
Error buildPipeline(ModulePassManager &MPM, MachineFunctionPassManager &MFPM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType) const
void addBlockPlacement(AddMachinePass &) const
Add standard basic block placement passes.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
StringRef - Represent a constant reference to a string, i.e.
void addPreEmitPass(AddMachinePass &) const
This pass may be implemented by targets that want to run passes immediately before machine code is em...
void addPreGlobalInstructionSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the (global) ins...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void addAsmPrinter(AddMachinePass &, CreateMCStreamer) const
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Error addLegalizeMachineIR(AddMachinePass &) const
This method should install a legalize pass, which converts the instruction sequence into one that can...
void operator()(PassT &&Pass)
void addPreRewrite(AddMachinePass &) const
addPreRewrite - Add passes to the optimized register allocation pipeline after register allocation is...
void addPostRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes after register allocation pass pipe...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
PassInstrumentationCallbacks * PIC
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &) const
Optional< bool > OptimizeRegAlloc
Error addRegBankSelect(AddMachinePass &) const
This method should install a register bank selector pass, which assigns register banks to virtual reg...
GlobalISelAbortMode GlobalISelAbort
EnableGlobalISelAbort - Control abort behaviour when global instruction selection fails to lower/sele...
Lightweight error class with error context and mandatory checking.
@ WinEH
Windows Exception Handling.
MachineFunctionPassManager releasePM()
void addPass(PassT &&Pass)
This class describes a target machine that is implemented with the LLVM target-independent code gener...
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
MachineFunctionPassManager adds/removes below features to/from the base PassManager template instanti...
Error addCoreISelPasses(AddMachinePass &) const
Add the actual instruction selection passes.
@ None
No exception support.
ExceptionHandling getExceptionHandlingType() const
Pass interface - Implemented by all 'passes'.
void addPreRegBankSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the register ban...
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
void addMachineSSAOptimization(AddMachinePass &) const
Methods with trivial inline returns are convenient points in the common codegen pass pipeline where t...
std::enable_if_t< is_detected< is_function_pass_t, PassT >::value > operator()(PassT &&Pass)
void addRegAllocPass(AddMachinePass &, bool Optimized) const
addMachinePasses helper to create the target-selected or overriden regalloc pass.
A container for analyses that lazily runs them and caches their results.
Analysis pass providing a never-invalidated alias analysis result.
const char LLVMTargetMachineRef TM
void addPreISel(AddIRPass &) const
{{@ For GlobalISel
void addMachineLateOptimization(AddMachinePass &) const
Add passes that optimize machine instructions after register allocation.
Optional< bool > EnableIPRA
void disablePass(AnalysisKey *ID)
void addPreRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before register allocat...
@ DwarfCFI
DWARF-like instruction based exceptions.
void addPreSched2(AddMachinePass &) const
This method may be implemented by targets that want to run passes after prolog-epilog insertion and b...
std::pair< StringRef, bool > getPassNameFromLegacyName(StringRef) const