23#ifndef LLVM_CODEGEN_MACHINEPASSMANAGER_H
24#define LLVM_CODEGEN_MACHINEPASSMANAGER_H
38extern template class AnalysisManager<MachineFunction>;
65 template <
typename PassT>
89 using Base::getResult;
96 using Base::getCachedResult;
138 bool RequireCodeGenSCCOrder =
false,
139 bool VerifyMachineFunction =
false)
140 : RequireCodeGenSCCOrder(RequireCodeGenSCCOrder),
141 VerifyMachineFunction(VerifyMachineFunction) {}
156 Base::addPass(std::forward<PassT>(
Pass));
158 addDoInitialization<PassT>(
P);
159 addDoFinalization<PassT>(
P);
162 addRunOnModule<PassT>(
P);
166 template <
typename PassT>
167 using has_init_t =
decltype(std::declval<PassT &>().doInitialization(
168 std::declval<Module &>(),
169 std::declval<MachineFunctionAnalysisManager &>()));
171 template <
typename PassT>
172 std::enable_if_t<!is_detected<has_init_t, PassT>::value>
173 addDoInitialization(PassConceptT *
Pass) {}
175 template <
typename PassT>
176 std::enable_if_t<is_detected<has_init_t, PassT>::value>
177 addDoInitialization(PassConceptT *
Pass) {
179 detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
180 MachineFunctionAnalysisManager>;
181 auto *
P =
static_cast<PassModelT *
>(
Pass);
182 InitializationFuncs.emplace_back(
183 [=](
Module &M, MachineFunctionAnalysisManager &MFAM) {
184 return P->Pass.doInitialization(M, MFAM);
188 template <
typename PassT>
189 using has_fini_t =
decltype(std::declval<PassT &>().doFinalization(
190 std::declval<Module &>(),
191 std::declval<MachineFunctionAnalysisManager &>()));
193 template <
typename PassT>
194 std::enable_if_t<!is_detected<has_fini_t, PassT>::value>
195 addDoFinalization(PassConceptT *
Pass) {}
197 template <
typename PassT>
198 std::enable_if_t<is_detected<has_fini_t, PassT>::value>
199 addDoFinalization(PassConceptT *
Pass) {
201 detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
202 MachineFunctionAnalysisManager>;
203 auto *
P =
static_cast<PassModelT *
>(
Pass);
204 FinalizationFuncs.emplace_back(
205 [=](
Module &M, MachineFunctionAnalysisManager &MFAM) {
206 return P->Pass.doFinalization(M, MFAM);
210 template <
typename PassT>
211 using is_machine_module_pass_t =
decltype(std::declval<PassT &>().run(
212 std::declval<Module &>(),
213 std::declval<MachineFunctionAnalysisManager &>()));
215 template <
typename PassT>
216 using is_machine_function_pass_t =
decltype(std::declval<PassT &>().run(
217 std::declval<MachineFunction &>(),
218 std::declval<MachineFunctionAnalysisManager &>()));
220 template <
typename PassT>
221 std::enable_if_t<!is_detected<is_machine_module_pass_t, PassT>::value>
222 addRunOnModule(PassConceptT *
Pass) {}
224 template <
typename PassT>
225 std::enable_if_t<is_detected<is_machine_module_pass_t, PassT>::value>
226 addRunOnModule(PassConceptT *
Pass) {
227 static_assert(is_detected<is_machine_function_pass_t, PassT>::value,
228 "machine module pass needs to define machine function pass "
232 detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
233 MachineFunctionAnalysisManager>;
234 auto *
P =
static_cast<PassModelT *
>(
Pass);
235 MachineModulePasses.emplace(
237 [=](
Module &
M, MachineFunctionAnalysisManager &MFAM) {
238 return P->Pass.run(M, MFAM);
242 using FuncTy =
Error(
Module &, MachineFunctionAnalysisManager &);
243 SmallVector<llvm::unique_function<FuncTy>, 4> InitializationFuncs;
244 SmallVector<llvm::unique_function<FuncTy>, 4> FinalizationFuncs;
246 using PassIndex =
decltype(
Passes)::size_type;
247 std::map<PassIndex, llvm::unique_function<FuncTy>> MachineModulePasses;
250 bool RequireCodeGenSCCOrder;
252 bool VerifyMachineFunction;
print lazy value Lazy Value Info Printer Pass
Machine Check Debug Module
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
This header defines various interfaces for pass management in LLVM.
This file defines the SmallVector class.
A container for analyses that lazily runs them and caches their results.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Lightweight error class with error context and mandatory checking.
An AnalysisManager<MachineFunction> that also exposes IR analysis results.
MachineFunctionAnalysisManager & operator=(MachineFunctionAnalysisManager &&)=default
PassT::Result * getCachedResult(Function &F)
Get the cached result of an analysis pass for a Function.
ModuleAnalysisManager * MAM
PassT::Result * getCachedResult(Module &M)
Get the cached result of an analysis pass for a Module.
MachineFunctionAnalysisManager(MachineFunctionAnalysisManager &&)=default
PassT::Result & getResult(Module &M)
Get the result of an analysis pass for a Module.
MachineFunctionAnalysisManager(FunctionAnalysisManager &FAM, ModuleAnalysisManager &MAM)
FunctionAnalysisManager * FAM
MachineFunctionAnalysisManager()
PassT::Result & getResult(Function &F)
Get the result of an analysis pass for a Function.
MachineFunctionPassManager adds/removes below features to/from the base PassManager template instanti...
void addPass(PassT &&Pass)
MachineFunctionPassManager & operator=(MachineFunctionPassManager &&)=default
MachineFunctionPassManager(bool DebugLogging=false, bool RequireCodeGenSCCOrder=false, bool VerifyMachineFunction=false)
MachineFunctionPassManager(MachineFunctionPassManager &&)=default
A Module instance is used to store all the information related to an LLVM module.
Manages a sequence of passes over a particular unit of IR.
Pass interface - Implemented by all 'passes'.
This is an optimization pass for GlobalISel generic memory operations.
Template for the abstract base class used to dispatch polymorphically over pass objects.