14#ifndef LLVM_PASSES_CODEGENPASSBUILDER_H
15#define LLVM_PASSES_CODEGENPASSBUILDER_H
86#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME) \
87 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
88 template <typename... Ts> PASS_NAME(Ts &&...) {} \
89 PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
90 return PreservedAnalyses::all(); \
93#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME) \
94 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
95 template <typename... Ts> PASS_NAME(Ts &&...) {} \
96 PreservedAnalyses run(Module &, ModuleAnalysisManager &) { \
97 return PreservedAnalyses::all(); \
100#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME) \
101 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
102 template <typename... Ts> PASS_NAME(Ts &&...) {} \
103 PreservedAnalyses run(MachineFunction &, \
104 MachineFunctionAnalysisManager &) { \
105 return PreservedAnalyses::all(); \
108#include "llvm/Passes/MachinePassRegistry.def"
146 template <
typename PassT>
149 template <
typename PassT>
151 std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
153 template <
typename PassT>
155 std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
157 template <
typename PassT>
159 std::declval<MachineFunction &>(),
160 std::declval<MachineFunctionAnalysisManager &>()));
174 template <
typename PassT>
178 "Only module pass and function pass are supported.");
179 bool Required =
false;
181 Required = PassT::isRequired();
182 if (!PB.runBeforeAdding(
Name) && !Required)
220 template <
typename PassT>
225 "Only module pass and function pass are supported.");
227 if (!Force && !PB.runBeforeAdding(
Name))
244 for (
auto &
C : PB.AfterCallbacks)
258 template <
typename TMC> TMC &
getTM()
const {
return static_cast<TMC &
>(
TM); }
278 return make_error<StringError>(
"addInstSelector is not overridden",
346 return make_error<StringError>(
"addIRTranslator is not overridden",
357 return make_error<StringError>(
"addLegalizeMachineIR is not overridden",
369 return make_error<StringError>(
"addRegBankSelect is not overridden",
382 return make_error<StringError>(
383 "addGlobalInstructionSelect is not overridden",
448 std::function<Expected<std::unique_ptr<MCStreamer>>(
MCContext &)>;
472 BeforeCallbacks.emplace_back(
478 template <
typename TargetPassT,
typename InsertedPassT>
480 AfterCallbacks.emplace_back(
482 if (
Name == TargetPassT::name())
488 DerivedT &derived() {
return static_cast<DerivedT &
>(*this); }
489 const DerivedT &derived()
const {
490 return static_cast<const DerivedT &
>(*this);
493 bool runBeforeAdding(StringRef
Name)
const {
494 bool ShouldAdd =
true;
495 for (
auto &
C : BeforeCallbacks)
496 ShouldAdd &=
C(
Name);
500 void setStartStopPasses(
const TargetPassConfig::StartStopInfo &
Info)
const;
502 Error verifyStartStop(
const TargetPassConfig::StartStopInfo &
Info)
const;
511 mutable bool Started =
true;
512 mutable bool Stopped =
true;
515template <
typename Derived,
typename TargetMachineT>
521 return StartStopInfo.takeError();
522 setStartStopPasses(*StartStopInfo);
532 addISelPasses(addIRPass);
540 if (
auto Err = addCoreISelPasses(addPass))
541 return std::move(Err);
543 if (
auto Err = derived().addMachinePasses(addPass))
544 return std::move(Err);
547 derived().addAsmPrinter(
548 addPass, [
this, &Out, DwoOut, FileType](
MCContext &Ctx) {
549 return this->TM.createMCStreamer(Out, DwoOut, FileType, Ctx);
556 return verifyStartStop(*StartStopInfo);
559template <
typename Derived,
typename TargetMachineT>
562 if (!
Info.StartPass.empty()) {
564 BeforeCallbacks.emplace_back([
this, &
Info, AfterFlag =
Info.StartAfter,
565 Count = 0u](
StringRef ClassName)
mutable {
566 if (Count == Info.StartInstanceNum) {
576 Started = !
Info.StartAfter;
582 if (!
Info.StopPass.empty()) {
584 BeforeCallbacks.emplace_back([
this, &
Info, AfterFlag =
Info.StopAfter,
585 Count = 0u](StringRef ClassName)
mutable {
586 if (Count == Info.StopInstanceNum) {
596 Stopped = !
Info.StopAfter;
602template <
typename Derived,
typename TargetMachineT>
603Error CodeGenPassBuilder<Derived, TargetMachineT>::verifyStartStop(
604 const TargetPassConfig::StartStopInfo &
Info)
const {
605 if (Started && Stopped)
606 return Error::success();
609 return make_error<StringError>(
610 "Can't find start pass \"" +
611 PIC->getPassNameForClassName(
Info.StartPass) +
"\".",
612 std::make_error_code(std::errc::invalid_argument));
614 return make_error<StringError>(
615 "Can't find stop pass \"" +
616 PIC->getPassNameForClassName(
Info.StopPass) +
"\".",
617 std::make_error_code(std::errc::invalid_argument));
618 return Error::success();
621template <
typename Derived,
typename TargetMachineT>
625 if (
TM.useEmulatedTLS())
630 derived().addIRPasses(addPass);
631 derived().addCodeGenPrepare(addPass);
632 addPassesToHandleExceptions(addPass);
633 derived().addISelPrepare(addPass);
638template <
typename Derived,
typename TargetMachineT>
647 if (getOptLevel() != CodeGenOptLevel::None && !Opt.
DisableLSR) {
655 if (getOptLevel() != CodeGenOptLevel::None) {
680 if (getOptLevel() != CodeGenOptLevel::None)
683 if (getOptLevel() != CodeGenOptLevel::None &&
705template <
typename Derived,
typename TargetMachineT>
709 assert(MCAI &&
"No MCAsmInfo");
711 case ExceptionHandling::SjLj:
720 case ExceptionHandling::DwarfCFI:
721 case ExceptionHandling::ARM:
722 case ExceptionHandling::AIX:
723 case ExceptionHandling::ZOS:
726 case ExceptionHandling::WinEH:
733 case ExceptionHandling::Wasm:
741 case ExceptionHandling::None:
752template <
typename Derived,
typename TargetMachineT>
755 if (getOptLevel() != CodeGenOptLevel::None && !Opt.
DisableCGP)
763template <
typename Derived,
typename TargetMachineT>
776 "\n\n*** Final LLVM Code input to ISel ***\n"));
784template <
typename Derived,
typename TargetMachineT>
792 SelectorType Selector;
795 Selector = SelectorType::FastISel;
798 (
TM.Options.EnableGlobalISel &&
801 Selector = SelectorType::GlobalISel;
802 else if (
TM.getOptLevel() == CodeGenOptLevel::None &&
TM.getO0WantsFastISel())
803 Selector = SelectorType::FastISel;
805 Selector = SelectorType::SelectionDAG;
808 if (Selector == SelectorType::FastISel) {
809 TM.setFastISel(
true);
810 TM.setGlobalISel(
false);
811 }
else if (Selector == SelectorType::GlobalISel) {
812 TM.setFastISel(
false);
813 TM.setGlobalISel(
true);
817 if (Selector == SelectorType::GlobalISel) {
818 if (
auto Err = derived().addIRTranslator(addPass))
819 return std::move(Err);
821 derived().addPreLegalizeMachineIR(addPass);
823 if (
auto Err = derived().addLegalizeMachineIR(addPass))
824 return std::move(Err);
828 derived().addPreRegBankSelect(addPass);
830 if (
auto Err = derived().addRegBankSelect(addPass))
831 return std::move(Err);
833 derived().addPreGlobalInstructionSelect(addPass);
835 if (
auto Err = derived().addGlobalInstructionSelect(addPass))
836 return std::move(Err);
839 addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
840 isGlobalISelAbortEnabled()));
844 if (!isGlobalISelAbortEnabled())
845 if (
auto Err = derived().addInstSelector(addPass))
846 return std::move(Err);
848 }
else if (
auto Err = derived().addInstSelector(addPass))
849 return std::move(Err);
858 return Error::success();
877template <
typename Derived,
typename TargetMachineT>
881 if (getOptLevel() != CodeGenOptLevel::None) {
889 if (
TM.Options.EnableIPRA)
890 addPass(RegUsageInfoPropagationPass());
893 derived().addPreRegAlloc(addPass);
898 derived().addOptimizedRegAlloc(addPass);
900 if (
auto Err = derived().addFastRegAlloc(addPass))
905 derived().addPostRegAlloc(addPass);
907 addPass(RemoveRedundantDebugValuesPass());
910 if (getOptLevel() != CodeGenOptLevel::None) {
911 addPass(PostRAMachineSinkingPass());
912 addPass(ShrinkWrapPass());
915 addPass(PrologEpilogInserterPass());
918 if (getOptLevel() != CodeGenOptLevel::None)
919 derived().addMachineLateOptimization(addPass);
922 addPass(ExpandPostRAPseudosPass());
925 derived().addPreSched2(addPass);
928 addPass(ImplicitNullChecksPass());
933 if (getOptLevel() != CodeGenOptLevel::None &&
934 !
TM.targetSchedulesPostRAScheduling()) {
936 addPass(PostMachineSchedulerPass());
938 addPass(PostRASchedulerPass());
942 derived().addGCPasses(addPass);
945 if (getOptLevel() != CodeGenOptLevel::None)
946 derived().addBlockPlacement(addPass);
949 addPass(FEntryInserterPass());
951 addPass(XRayInstrumentationPass());
952 addPass(PatchableFunctionPass());
954 derived().addPreEmitPass(addPass);
956 if (
TM.Options.EnableIPRA)
959 addPass(RegUsageInfoCollectorPass());
961 addPass(FuncletLayoutPass());
963 addPass(StackMapLivenessPass());
964 addPass(LiveDebugValuesPass());
965 addPass(MachineSanitizerBinaryMetadata());
967 if (
TM.Options.EnableMachineOutliner &&
968 getOptLevel() != CodeGenOptLevel::None &&
970 bool RunOnAllFunctions =
972 bool AddOutliner = RunOnAllFunctions ||
TM.Options.SupportsDefaultOutlining;
974 addPass(MachineOutlinerPass(RunOnAllFunctions));
978 derived().addPreEmitPass2(addPass);
980 return Error::success();
984template <
typename Derived,
typename TargetMachineT>
988 addPass(EarlyTailDuplicatePass());
992 addPass(OptimizePHIsPass());
996 addPass(StackColoringPass());
1011 derived().addILPOpts(addPass);
1013 addPass(EarlyMachineLICMPass());
1014 addPass(MachineCSEPass());
1016 addPass(MachineSinkingPass());
1018 addPass(PeepholeOptimizerPass());
1036template <
typename Derived,
typename TargetMachineT>
1040 addPass(RAGreedyPass());
1048template <
typename Derived,
typename TargetMachineT>
1054template <
typename Derived,
typename TargetMachineT>
1058 addRegAllocPass(addPass,
false);
1059 return Error::success();
1062template <
typename Derived,
typename TargetMachineT>
1066 addRegAllocPass(addPass,
true);
1069 derived().addPreRewrite(addPass);
1072 addPass(VirtRegRewriterPass());
1077 addPass(StackSlotColoringPass());
1079 return Error::success();
1084template <
typename Derived,
typename TargetMachineT>
1087 addPass(PHIEliminationPass());
1088 addPass(TwoAddressInstructionPass());
1089 return derived().addRegAssignmentFast(addPass);
1095template <
typename Derived,
typename TargetMachineT>
1098 addPass(DetectDeadLanesPass());
1100 addPass(InitUndefPass());
1102 addPass(ProcessImplicitDefsPass());
1105 addPass(PHIEliminationPass());
1109 addPass(LiveIntervalsPass());
1111 addPass(TwoAddressInstructionPass());
1112 addPass(RegisterCoalescerPass());
1117 addPass(RenameIndependentSubregsPass());
1120 addPass(MachineSchedulerPass());
1122 if (derived().addRegAssignmentOptimized(addPass)) {
1125 derived().addPostRewrite(addPass);
1129 addPass(MachineCopyPropagationPass());
1134 addPass(MachineLICMPass());
1143template <
typename Derived,
typename TargetMachineT>
1147 addPass(BranchFolderPass());
1153 if (!
TM.requiresStructuredCFG())
1154 addPass(TailDuplicatePass());
1157 addPass(MachineLateInstrsCleanupPass());
1160 addPass(MachineCopyPropagationPass());
1164template <
typename Derived,
typename TargetMachineT>
1167 addPass(MachineBlockPlacementPass());
1170 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 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.
const char LLVMTargetMachineRef TM
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
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 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.
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.
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
std::optional< bool > EnableFastISelOption
std::optional< GlobalISelAbortMode > EnableGlobalISelAbort
bool EnableImplicitNullChecks
bool EnableBlockPlacementStats
bool DisableSelectOptimize
A no-op pass template which simply forces a specific analysis result to be invalidated.
A utility pass template to force an analysis result to be available.