LLVM 18.0.0git
MachinePassManager.cpp
Go to the documentation of this file.
1//===---------- MachinePassManager.cpp ------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the pass management machinery for machine functions.
10//
11//===----------------------------------------------------------------------===//
12
17
18using namespace llvm;
19
20namespace llvm {
23template class PassManager<MachineFunction>;
24
27 // MachineModuleAnalysis is a module analysis pass that is never invalidated
28 // because we don't run any module pass in codegen pipeline. This is very
29 // important because the codegen state is stored in MMI which is the analysis
30 // result of MachineModuleAnalysis. MMI should not be recomputed.
31 auto &MMI = MFAM.getResult<MachineModuleAnalysis>(M);
32
33 (void)RequireCodeGenSCCOrder;
34 assert(!RequireCodeGenSCCOrder && "not implemented");
35
36 // Add a PIC to verify machine functions.
37 if (VerifyMachineFunction) {
39
40 // No need to pop this callback later since MIR pipeline is flat which means
41 // current pipeline is the top-level pipeline. Callbacks are not used after
42 // current pipeline.
44 assert(llvm::any_cast<const MachineFunction *>(&IR));
45 const MachineFunction *MF = llvm::any_cast<const MachineFunction *>(IR);
46 assert(MF && "Machine function should be valid for printing");
47 std::string Banner = std::string("After ") + std::string(PassID);
48 verifyMachineFunction(&MFAM, Banner, *MF);
49 });
50 }
51
52 for (auto &F : InitializationFuncs) {
53 if (auto Err = F(M, MFAM))
54 return Err;
55 }
56
57 unsigned Idx = 0;
58 size_t Size = Passes.size();
59 do {
60 // Run machine module passes
61 for (; MachineModulePasses.count(Idx) && Idx != Size; ++Idx) {
62 if (auto Err = MachineModulePasses.at(Idx)(M, MFAM))
63 return Err;
64 }
65
66 // Finish running all passes.
67 if (Idx == Size)
68 break;
69
70 // Run machine function passes
71
72 // Get index range of machine function passes.
73 unsigned Begin = Idx;
74 for (; !MachineModulePasses.count(Idx) && Idx != Size; ++Idx)
75 ;
76
77 for (Function &F : M) {
78 // Do not codegen any 'available_externally' functions at all, they have
79 // definitions outside the translation unit.
80 if (F.hasAvailableExternallyLinkage())
81 continue;
82
83 MachineFunction &MF = MMI.getOrCreateMachineFunction(F);
85
86 for (unsigned I = Begin, E = Idx; I != E; ++I) {
87 auto *P = Passes[I].get();
88
89 if (!PI.runBeforePass<MachineFunction>(*P, MF))
90 continue;
91
92 // TODO: EmitSizeRemarks
93 PreservedAnalyses PassPA = P->run(MF, MFAM);
94 MFAM.invalidate(MF, PassPA);
95 PI.runAfterPass(*P, MF, PassPA);
96 }
97 }
98 } while (true);
99
100 for (auto &F : FinalizationFuncs) {
101 if (auto Err = F(M, MFAM))
102 return Err;
103 }
104
105 return Error::success();
106}
107
108} // namespace llvm
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
uint64_t Size
Legalize the Machine IR a function s Machine IR
Definition: Legalizer.cpp:81
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define P(N)
Provides implementations for PassManager and AnalysisManager template methods.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: PassManager.h:110
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:649
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
Definition: Any.h:28
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
An AnalysisManager<MachineFunction> that also exposes IR analysis results.
PassT::Result & getResult(Function &F)
Get the result of an analysis pass for a Function.
Error run(Module &M, MachineFunctionAnalysisManager &MFAM)
Run machine passes for a Module.
An analysis that produces MachineInfo for a module.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Pseudo-analysis pass that exposes the PassInstrumentation to pass managers.
Definition: PassManager.h:624
This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...
void pushBeforeNonSkippedPassCallback(CallableT C)
void runAfterPass(const PassT &Pass, const IRUnitT &IR, const PreservedAnalyses &PA) const
AfterPass instrumentation point - takes Pass instance that has just been executed and constant refere...
bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const
BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...
Manages a sequence of passes over a particular unit of IR.
Definition: PassManager.h:490
std::vector< std::unique_ptr< PassConceptT > > Passes
Definition: PassManager.h:605
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:172
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void verifyMachineFunction(MachineFunctionAnalysisManager *, const std::string &Banner, const MachineFunction &MF)