14#ifndef LLVM_PASSES_CODEGENPASSBUILDER_H
15#define LLVM_PASSES_CODEGENPASSBUILDER_H
103#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME) \
104 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
105 template <typename... Ts> PASS_NAME(Ts &&...) {} \
106 PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
107 return PreservedAnalyses::all(); \
110#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME) \
111 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
112 template <typename... Ts> PASS_NAME(Ts &&...) {} \
113 PreservedAnalyses run(Module &, ModuleAnalysisManager &) { \
114 return PreservedAnalyses::all(); \
117#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME) \
118 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
119 template <typename... Ts> PASS_NAME(Ts &&...) {} \
120 PreservedAnalyses run(MachineFunction &, \
121 MachineFunctionAnalysisManager &) { \
122 return PreservedAnalyses::all(); \
125#include "llvm/Passes/MachinePassRegistry.def"
163 template <
typename PassT>
166 template <
typename PassT>
168 std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
170 template <
typename PassT>
172 std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
174 template <
typename PassT>
176 std::declval<MachineFunction &>(),
177 std::declval<MachineFunctionAnalysisManager &>()));
191 template <
typename PassT>
195 "Only module pass and function pass are supported.");
196 bool Required =
false;
198 Required = PassT::isRequired();
199 if (!PB.runBeforeAdding(
Name) && !Required)
226 : MPM(MPM),
PB(
PB) {}
237 template <
typename PassT>
242 "Only module pass and function pass are supported.");
244 if (!Force && !PB.runBeforeAdding(
Name))
261 for (
auto &
C : PB.AfterCallbacks)
275 template <
typename TMC> TMC &
getTM()
const {
return static_cast<TMC &
>(
TM); }
295 return make_error<StringError>(
"addInstSelector is not overridden",
363 return make_error<StringError>(
"addIRTranslator is not overridden",
374 return make_error<StringError>(
"addLegalizeMachineIR is not overridden",
386 return make_error<StringError>(
"addRegBankSelect is not overridden",
399 return make_error<StringError>(
400 "addGlobalInstructionSelect is not overridden",
466 std::function<Expected<std::unique_ptr<MCStreamer>>(
MCContext &)>;
490 BeforeCallbacks.emplace_back(
496 template <
typename TargetPassT,
typename InsertedPassT>
498 AfterCallbacks.emplace_back(
500 if (
Name == TargetPassT::name())
506 DerivedT &derived() {
return static_cast<DerivedT &
>(*this); }
507 const DerivedT &derived()
const {
508 return static_cast<const DerivedT &
>(*this);
511 bool runBeforeAdding(StringRef
Name)
const {
512 bool ShouldAdd =
true;
513 for (
auto &
C : BeforeCallbacks)
514 ShouldAdd &=
C(
Name);
518 void setStartStopPasses(
const TargetPassConfig::StartStopInfo &
Info)
const;
520 Error verifyStartStop(
const TargetPassConfig::StartStopInfo &
Info)
const;
529 mutable bool Started =
true;
530 mutable bool Stopped =
true;
533template <
typename Derived,
typename TargetMachineT>
539 return StartStopInfo.takeError();
540 setStartStopPasses(*StartStopInfo);
550 addISelPasses(addIRPass);
558 if (
auto Err = addCoreISelPasses(addPass))
559 return std::move(Err);
561 if (
auto Err = derived().addMachinePasses(addPass))
562 return std::move(Err);
568 derived().addAsmPrinter(
569 addPass, [
this, &Out, DwoOut, FileType](
MCContext &Ctx) {
570 return this->TM.createMCStreamer(Out, DwoOut, FileType, Ctx);
577 return verifyStartStop(*StartStopInfo);
580template <
typename Derived,
typename TargetMachineT>
583 if (!
Info.StartPass.empty()) {
585 BeforeCallbacks.emplace_back([
this, &
Info, AfterFlag =
Info.StartAfter,
586 Count = 0u](
StringRef ClassName)
mutable {
587 if (Count == Info.StartInstanceNum) {
597 Started = !
Info.StartAfter;
603 if (!
Info.StopPass.empty()) {
605 BeforeCallbacks.emplace_back([
this, &
Info, AfterFlag =
Info.StopAfter,
606 Count = 0u](StringRef ClassName)
mutable {
607 if (Count == Info.StopInstanceNum) {
617 Stopped = !
Info.StopAfter;
623template <
typename Derived,
typename TargetMachineT>
624Error CodeGenPassBuilder<Derived, TargetMachineT>::verifyStartStop(
625 const TargetPassConfig::StartStopInfo &
Info)
const {
626 if (Started && Stopped)
627 return Error::success();
630 return make_error<StringError>(
631 "Can't find start pass \"" +
Info.StartPass +
"\".",
632 std::make_error_code(std::errc::invalid_argument));
634 return make_error<StringError>(
635 "Can't find stop pass \"" +
Info.StopPass +
"\".",
636 std::make_error_code(std::errc::invalid_argument));
637 return Error::success();
640template <
typename Derived,
typename TargetMachineT>
644 if (TM.useEmulatedTLS())
651 derived().addIRPasses(addPass);
652 derived().addCodeGenPrepare(addPass);
653 addPassesToHandleExceptions(addPass);
654 derived().addISelPrepare(addPass);
659template <
typename Derived,
typename TargetMachineT>
668 if (getOptLevel() != CodeGenOptLevel::None && !Opt.
DisableLSR) {
673 if (getOptLevel() != CodeGenOptLevel::None) {
698 if (getOptLevel() != CodeGenOptLevel::None)
701 if (getOptLevel() != CodeGenOptLevel::None &&
726template <
typename Derived,
typename TargetMachineT>
729 const MCAsmInfo *MCAI = TM.getMCAsmInfo();
730 assert(MCAI &&
"No MCAsmInfo");
732 case ExceptionHandling::SjLj:
741 case ExceptionHandling::DwarfCFI:
742 case ExceptionHandling::ARM:
743 case ExceptionHandling::AIX:
744 case ExceptionHandling::ZOS:
747 case ExceptionHandling::WinEH:
754 case ExceptionHandling::Wasm:
762 case ExceptionHandling::None:
773template <
typename Derived,
typename TargetMachineT>
776 if (getOptLevel() != CodeGenOptLevel::None && !Opt.
DisableCGP)
784template <
typename Derived,
typename TargetMachineT>
797 "\n\n*** Final LLVM Code input to ISel ***\n"));
805template <
typename Derived,
typename TargetMachineT>
813 SelectorType Selector;
816 Selector = SelectorType::FastISel;
819 (TM.Options.EnableGlobalISel &&
822 Selector = SelectorType::GlobalISel;
823 else if (TM.getOptLevel() == CodeGenOptLevel::None && TM.getO0WantsFastISel())
824 Selector = SelectorType::FastISel;
826 Selector = SelectorType::SelectionDAG;
829 if (Selector == SelectorType::FastISel) {
830 TM.setFastISel(
true);
831 TM.setGlobalISel(
false);
832 }
else if (Selector == SelectorType::GlobalISel) {
833 TM.setFastISel(
false);
834 TM.setGlobalISel(
true);
838 if (Selector == SelectorType::GlobalISel) {
839 if (
auto Err = derived().addIRTranslator(addPass))
840 return std::move(Err);
842 derived().addPreLegalizeMachineIR(addPass);
844 if (
auto Err = derived().addLegalizeMachineIR(addPass))
845 return std::move(Err);
849 derived().addPreRegBankSelect(addPass);
851 if (
auto Err = derived().addRegBankSelect(addPass))
852 return std::move(Err);
854 derived().addPreGlobalInstructionSelect(addPass);
856 if (
auto Err = derived().addGlobalInstructionSelect(addPass))
857 return std::move(Err);
860 addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
861 isGlobalISelAbortEnabled()));
865 if (!isGlobalISelAbortEnabled())
866 if (
auto Err = derived().addInstSelector(addPass))
867 return std::move(Err);
869 }
else if (
auto Err = derived().addInstSelector(addPass))
870 return std::move(Err);
879 return Error::success();
898template <
typename Derived,
typename TargetMachineT>
902 if (getOptLevel() != CodeGenOptLevel::None) {
910 if (TM.Options.EnableIPRA) {
915 derived().addPreRegAlloc(addPass);
920 derived().addOptimizedRegAlloc(addPass);
922 if (
auto Err = derived().addFastRegAlloc(addPass))
927 derived().addPostRegAlloc(addPass);
929 addPass(RemoveRedundantDebugValuesPass());
932 if (getOptLevel() != CodeGenOptLevel::None) {
933 addPass(PostRAMachineSinkingPass());
934 addPass(ShrinkWrapPass());
937 addPass(PrologEpilogInserterPass());
940 if (getOptLevel() != CodeGenOptLevel::None)
941 derived().addMachineLateOptimization(addPass);
944 addPass(ExpandPostRAPseudosPass());
947 derived().addPreSched2(addPass);
950 addPass(ImplicitNullChecksPass());
955 if (getOptLevel() != CodeGenOptLevel::None &&
956 !TM.targetSchedulesPostRAScheduling()) {
958 addPass(PostMachineSchedulerPass());
960 addPass(PostRASchedulerPass());
964 derived().addGCPasses(addPass);
967 if (getOptLevel() != CodeGenOptLevel::None)
968 derived().addBlockPlacement(addPass);
971 addPass(FEntryInserterPass());
973 addPass(XRayInstrumentationPass());
974 addPass(PatchableFunctionPass());
976 derived().addPreEmitPass(addPass);
978 if (TM.Options.EnableIPRA)
983 addPass(FuncletLayoutPass());
985 addPass(StackMapLivenessPass());
986 addPass(LiveDebugValuesPass());
987 addPass(MachineSanitizerBinaryMetadata());
989 if (TM.Options.EnableMachineOutliner &&
990 getOptLevel() != CodeGenOptLevel::None &&
992 bool RunOnAllFunctions =
994 bool AddOutliner = RunOnAllFunctions || TM.Options.SupportsDefaultOutlining;
996 addPass(MachineOutlinerPass(RunOnAllFunctions));
1000 derived().addPreEmitPass2(addPass);
1002 return Error::success();
1006template <
typename Derived,
typename TargetMachineT>
1033 derived().addILPOpts(addPass);
1038 addPass(MachineSinkingPass());
1058template <
typename Derived,
typename TargetMachineT>
1062 addPass(RAGreedyPass());
1070template <
typename Derived,
typename TargetMachineT>
1076template <
typename Derived,
typename TargetMachineT>
1080 addRegAllocPass(addPass,
false);
1081 return Error::success();
1084template <
typename Derived,
typename TargetMachineT>
1088 addRegAllocPass(addPass,
true);
1091 derived().addPreRewrite(addPass);
1094 addPass(VirtRegRewriterPass());
1099 addPass(StackSlotColoringPass());
1101 return Error::success();
1106template <
typename Derived,
typename TargetMachineT>
1111 return derived().addRegAssignmentFast(addPass);
1117template <
typename Derived,
typename TargetMachineT>
1120 addPass(DetectDeadLanesPass());
1122 addPass(InitUndefPass());
1124 addPass(ProcessImplicitDefsPass());
1134 addPass(RegisterCoalescerPass());
1139 addPass(RenameIndependentSubregsPass());
1142 addPass(MachineSchedulerPass());
1144 if (derived().addRegAssignmentOptimized(addPass)) {
1147 derived().addPostRewrite(addPass);
1151 addPass(MachineCopyPropagationPass());
1165template <
typename Derived,
typename TargetMachineT>
1169 addPass(BranchFolderPass());
1175 if (!TM.requiresStructuredCFG())
1179 addPass(MachineLateInstrsCleanupPass());
1182 addPass(MachineCopyPropagationPass());
1186template <
typename Derived,
typename TargetMachineT>
1189 addPass(MachineBlockPlacementPass());
1192 addPass(MachineBlockPlacementStatsPass());
This is the interface for LLVM's primary stateless and local alias analysis.
Analysis containing CSE Info
Defines an IR pass for CodeGen Prepare.
This file defines passes to print out IR in various granularities.
This header defines various interfaces for pass management in LLVM.
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
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.
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
This pass is required to take advantage of the interprocedural register allocation infrastructure.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This is the interface for a metadata-based scoped no-alias analysis.
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
This file defines the SmallVector class.
Target-Independent Code Generator Pass Configuration Options pass.
This is the interface for a metadata-based TBAA.
static const char PassName[]
AddIRPass(ModulePassManager &MPM, const DerivedT &PB)
void operator()(PassT &&Pass, StringRef Name=PassT::name())
AddMachinePass(ModulePassManager &MPM, const DerivedT &PB)
void operator()(PassT &&Pass, bool Force=false, StringRef Name=PassT::name())
This class provides access to building LLVM's passes.
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...
void insertPass(InsertedPassT &&Pass)
Insert InsertedPass pass after TargetPass pass.
void addPreGlobalInstructionSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the (global) ins...
Error addRegAssignmentFast(AddMachinePass &) const
Add core register alloator passes which do the actual register assignment and rewriting.
Error addFastRegAlloc(AddMachinePass &) const
addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast registe...
Error addIRTranslator(AddMachinePass &) const
This method should install an IR translator pass, which converts from LLVM code to machine instructio...
void addILPOpts(AddMachinePass &) const
Add passes that optimize instruction level parallelism for out-of-order targets.
void addRegAllocPass(AddMachinePass &, bool Optimized) const
addMachinePasses helper to create the target-selected or overriden regalloc pass.
void addPreSched2(AddMachinePass &) const
This method may be implemented by targets that want to run passes after prolog-epilog insertion and b...
std::function< Expected< std::unique_ptr< MCStreamer > >(MCContext &)> CreateMCStreamer
Error addRegBankSelect(AddMachinePass &) const
This method should install a register bank selector pass, which assigns register banks to virtual reg...
decltype(std::declval< PassT & >().isRequired()) has_required_t
bool isGlobalISelAbortEnabled() const
Check whether or not GlobalISel should abort on error.
void addPreRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before register allocat...
void addGCPasses(AddMachinePass &) const
addGCPasses - Add late codegen passes that analyze code for garbage collection.
Error buildPipeline(ModulePassManager &MPM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType) const
void addGlobalMergePass(AddIRPass &) const
Target can override this to add GlobalMergePass before all IR passes.
Error addLegalizeMachineIR(AddMachinePass &) const
This method should install a legalize pass, which converts the instruction sequence into one that can...
Error addCoreISelPasses(AddMachinePass &) const
Add the actual instruction selection passes.
void addOptimizedRegAlloc(AddMachinePass &) const
addOptimizedRegAlloc - Add passes related to register allocation.
void addISelPasses(AddIRPass &) const
High level function that adds all passes necessary to go from llvm IR representation to the MI repres...
PassInstrumentationCallbacks * PIC
void addMachineSSAOptimization(AddMachinePass &) const
Methods with trivial inline returns are convenient points in the common codegen pass pipeline where t...
decltype(std::declval< PassT & >().run(std::declval< Module & >(), std::declval< ModuleAnalysisManager & >())) is_module_pass_t
CodeGenPassBuilder(TargetMachineT &TM, const CGPassBuilderOption &Opts, PassInstrumentationCallbacks *PIC)
Error addRegAssignmentOptimized(AddMachinePass &) const
void addCodeGenPrepare(AddIRPass &) const
Add pass to prepare the LLVM IR for code generation.
Error addMachinePasses(AddMachinePass &) const
Add the complete, standard set of LLVM CodeGen passes.
void addISelPrepare(AddIRPass &) const
Add common passes that perform LLVM IR to IR transforms in preparation for instruction selection.
void disablePass()
Allow the target to disable a specific pass by default.
void addBlockPlacement(AddMachinePass &) const
Add standard basic block placement passes.
Error addInstSelector(AddMachinePass &) const
addInstSelector - This method should install an instruction selector pass, which converts from LLVM c...
void addTargetRegisterAllocator(AddMachinePass &, bool Optimized) const
Utilities for targets to add passes to the pass manager.
void addPreEmitPass2(AddMachinePass &) const
Targets may add passes immediately before machine code is emitted in this callback.
void addPostRewrite(AddMachinePass &) const
Add passes to be run immediately after virtual registers are rewritten to physical registers.
void addPreRegBankSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the register ban...
void addPreEmitPass(AddMachinePass &) const
This pass may be implemented by targets that want to run passes immediately before machine code is em...
Error addGlobalInstructionSelect(AddMachinePass &) const
This method should install a (global) instruction selector pass, which converts possibly generic inst...
void addMachineLateOptimization(AddMachinePass &) const
Add passes that optimize machine instructions after register allocation.
void addIRPasses(AddIRPass &) const
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
decltype(std::declval< PassT & >().run(std::declval< Function & >(), std::declval< FunctionAnalysisManager & >())) is_function_pass_t
decltype(std::declval< PassT & >().run(std::declval< MachineFunction & >(), std::declval< MachineFunctionAnalysisManager & >())) is_machine_function_pass_t
void addPreLegalizeMachineIR(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before legalization.
CodeGenOptLevel getOptLevel() const
void addPassesToHandleExceptions(AddIRPass &) const
Add passes to lower exception handling for the code generator.
PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const
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 addAsmPrinter(AddMachinePass &, CreateMCStreamer) const
Lightweight error class with error context and mandatory checking.
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
LowerIntrinsics - This pass rewrites calls to the llvm.gcread or llvm.gcwrite intrinsics,...
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.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
bool isEmpty() const
Returns if the pass manager contains any passes.
Pass interface - Implemented by all 'passes'.
Pass (for the new pass manager) for printing a Function as LLVM's text IR assembly.
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
StringRef - Represent a constant reference to a string, i.e.
static Expected< StartStopInfo > getStartStopInfo(PassInstrumentationCallbacks &PIC)
Returns pass name in -stop-before or -stop-after NOTE: New pass manager migration only.
static bool willCompleteCodeGenPipeline()
Returns true if none of the -stop-before and -stop-after options is set.
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.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
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...
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
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,...
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
CodeGenOptLevel
Code generation optimization level.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
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.
bool DisablePartialLibcallInlining
std::optional< bool > EnableGlobalISelOption
std::optional< bool > EnableIPRA
bool DisableConstantHoisting
std::optional< bool > OptimizeRegAlloc
RunOutliner EnableMachineOutliner
bool EnableGlobalMergeFunc
std::optional< bool > EnableFastISelOption
std::optional< GlobalISelAbortMode > EnableGlobalISelAbort
bool EnableImplicitNullChecks
bool EnableBlockPlacementStats
bool DisableSelectOptimize
Global function merging pass for new pass manager.
A no-op pass template which simply forces a specific analysis result to be invalidated.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
StringRef getPassNameForClassName(StringRef ClassName)
Get the pass name for a given pass class name.
A utility pass template to force an analysis result to be available.