LLVM 17.0.0git
MergedLoadStoreMotion.cpp
Go to the documentation of this file.
1//===- MergedLoadStoreMotion.cpp - merge and hoist/sink load/stores -------===//
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//! \file
10//! This pass performs merges of loads and stores on both sides of a
11// diamond (hammock). It hoists the loads and sinks the stores.
12//
13// The algorithm iteratively hoists two loads to the same address out of a
14// diamond (hammock) and merges them into a single load in the header. Similar
15// it sinks and merges two stores to the tail block (footer). The algorithm
16// iterates over the instructions of one side of the diamond and attempts to
17// find a matching load/store on the other side. New tail/footer block may be
18// insterted if the tail/footer block has more predecessors (not only the two
19// predecessors that are forming the diamond). It hoists / sinks when it thinks
20// it safe to do so. This optimization helps with eg. hiding load latencies,
21// triggering if-conversion, and reducing static code size.
22//
23// NOTE: This code no longer performs load hoisting, it is subsumed by GVNHoist.
24//
25//===----------------------------------------------------------------------===//
26//
27//
28// Example:
29// Diamond shaped code before merge:
30//
31// header:
32// br %cond, label %if.then, label %if.else
33// + +
34// + +
35// + +
36// if.then: if.else:
37// %lt = load %addr_l %le = load %addr_l
38// <use %lt> <use %le>
39// <...> <...>
40// store %st, %addr_s store %se, %addr_s
41// br label %if.end br label %if.end
42// + +
43// + +
44// + +
45// if.end ("footer"):
46// <...>
47//
48// Diamond shaped code after merge:
49//
50// header:
51// %l = load %addr_l
52// br %cond, label %if.then, label %if.else
53// + +
54// + +
55// + +
56// if.then: if.else:
57// <use %l> <use %l>
58// <...> <...>
59// br label %if.end br label %if.end
60// + +
61// + +
62// + +
63// if.end ("footer"):
64// %s.sink = phi [%st, if.then], [%se, if.else]
65// <...>
66// store %s.sink, %addr_s
67// <...>
68//
69//
70//===----------------------- TODO -----------------------------------------===//
71//
72// 1) Generalize to regions other than diamonds
73// 2) Be more aggressive merging memory operations
74// Note that both changes require register pressure control
75//
76//===----------------------------------------------------------------------===//
77
83#include "llvm/Support/Debug.h"
87
88using namespace llvm;
89
90#define DEBUG_TYPE "mldst-motion"
91
92namespace {
93//===----------------------------------------------------------------------===//
94// MergedLoadStoreMotion Pass
95//===----------------------------------------------------------------------===//
97 AliasAnalysis *AA = nullptr;
98
99 // The mergeLoad/Store algorithms could have Size0 * Size1 complexity,
100 // where Size0 and Size1 are the #instructions on the two sides of
101 // the diamond. The constant chosen here is arbitrary. Compiler Time
102 // Control is enforced by the check Size0 * Size1 < MagicCompileTimeControl.
103 const int MagicCompileTimeControl = 250;
104
105 const bool SplitFooterBB;
106public:
107 MergedLoadStoreMotion(bool SplitFooterBB) : SplitFooterBB(SplitFooterBB) {}
108 bool run(Function &F, AliasAnalysis &AA);
109
110private:
111 BasicBlock *getDiamondTail(BasicBlock *BB);
112 bool isDiamondHead(BasicBlock *BB);
113 // Routines for sinking stores
114 StoreInst *canSinkFromBlock(BasicBlock *BB, StoreInst *SI);
115 PHINode *getPHIOperand(BasicBlock *BB, StoreInst *S0, StoreInst *S1);
116 bool isStoreSinkBarrierInRange(const Instruction &Start,
117 const Instruction &End, MemoryLocation Loc);
118 bool canSinkStoresAndGEPs(StoreInst *S0, StoreInst *S1) const;
119 void sinkStoresAndGEPs(BasicBlock *BB, StoreInst *SinkCand,
120 StoreInst *ElseInst);
121 bool mergeStores(BasicBlock *BB);
122};
123} // end anonymous namespace
124
125///
126/// Return tail block of a diamond.
127///
128BasicBlock *MergedLoadStoreMotion::getDiamondTail(BasicBlock *BB) {
129 assert(isDiamondHead(BB) && "Basic block is not head of a diamond");
131}
132
133///
134/// True when BB is the head of a diamond (hammock)
135///
136bool MergedLoadStoreMotion::isDiamondHead(BasicBlock *BB) {
137 if (!BB)
138 return false;
139 auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
140 if (!BI || !BI->isConditional())
141 return false;
142
143 BasicBlock *Succ0 = BI->getSuccessor(0);
144 BasicBlock *Succ1 = BI->getSuccessor(1);
145
146 if (!Succ0->getSinglePredecessor())
147 return false;
148 if (!Succ1->getSinglePredecessor())
149 return false;
150
151 BasicBlock *Succ0Succ = Succ0->getSingleSuccessor();
152 BasicBlock *Succ1Succ = Succ1->getSingleSuccessor();
153 // Ignore triangles.
154 if (!Succ0Succ || !Succ1Succ || Succ0Succ != Succ1Succ)
155 return false;
156 return true;
157}
158
159
160///
161/// True when instruction is a sink barrier for a store
162/// located in Loc
163///
164/// Whenever an instruction could possibly read or modify the
165/// value being stored or protect against the store from
166/// happening it is considered a sink barrier.
167///
168bool MergedLoadStoreMotion::isStoreSinkBarrierInRange(const Instruction &Start,
169 const Instruction &End,
170 MemoryLocation Loc) {
171 for (const Instruction &Inst :
172 make_range(Start.getIterator(), End.getIterator()))
173 if (Inst.mayThrow())
174 return true;
175 return AA->canInstructionRangeModRef(Start, End, Loc, ModRefInfo::ModRef);
176}
177
178///
179/// Check if \p BB contains a store to the same address as \p SI
180///
181/// \return The store in \p when it is safe to sink. Otherwise return Null.
182///
183StoreInst *MergedLoadStoreMotion::canSinkFromBlock(BasicBlock *BB1,
184 StoreInst *Store0) {
185 LLVM_DEBUG(dbgs() << "can Sink? : "; Store0->dump(); dbgs() << "\n");
186 BasicBlock *BB0 = Store0->getParent();
187 for (Instruction &Inst : reverse(*BB1)) {
188 auto *Store1 = dyn_cast<StoreInst>(&Inst);
189 if (!Store1)
190 continue;
191
192 MemoryLocation Loc0 = MemoryLocation::get(Store0);
193 MemoryLocation Loc1 = MemoryLocation::get(Store1);
194 if (AA->isMustAlias(Loc0, Loc1) && Store0->isSameOperationAs(Store1) &&
195 !isStoreSinkBarrierInRange(*Store1->getNextNode(), BB1->back(), Loc1) &&
196 !isStoreSinkBarrierInRange(*Store0->getNextNode(), BB0->back(), Loc0)) {
197 return Store1;
198 }
199 }
200 return nullptr;
201}
202
203///
204/// Create a PHI node in BB for the operands of S0 and S1
205///
206PHINode *MergedLoadStoreMotion::getPHIOperand(BasicBlock *BB, StoreInst *S0,
207 StoreInst *S1) {
208 // Create a phi if the values mismatch.
209 Value *Opd1 = S0->getValueOperand();
210 Value *Opd2 = S1->getValueOperand();
211 if (Opd1 == Opd2)
212 return nullptr;
213
214 auto *NewPN = PHINode::Create(Opd1->getType(), 2, Opd2->getName() + ".sink",
215 &BB->front());
216 NewPN->applyMergedLocation(S0->getDebugLoc(), S1->getDebugLoc());
217 NewPN->addIncoming(Opd1, S0->getParent());
218 NewPN->addIncoming(Opd2, S1->getParent());
219 return NewPN;
220}
221
222///
223/// Check if 2 stores can be sunk, optionally together with corresponding GEPs.
224///
225bool MergedLoadStoreMotion::canSinkStoresAndGEPs(StoreInst *S0,
226 StoreInst *S1) const {
227 if (S0->getPointerOperand() == S1->getPointerOperand())
228 return true;
229 auto *GEP0 = dyn_cast<GetElementPtrInst>(S0->getPointerOperand());
230 auto *GEP1 = dyn_cast<GetElementPtrInst>(S1->getPointerOperand());
231 return GEP0 && GEP1 && GEP0->isIdenticalTo(GEP1) && GEP0->hasOneUse() &&
232 (GEP0->getParent() == S0->getParent()) && GEP1->hasOneUse() &&
233 (GEP1->getParent() == S1->getParent());
234}
235
236///
237/// Merge two stores to same address and sink into \p BB
238///
239/// Optionally also sinks GEP instruction computing the store address
240///
241void MergedLoadStoreMotion::sinkStoresAndGEPs(BasicBlock *BB, StoreInst *S0,
242 StoreInst *S1) {
243 Value *Ptr0 = S0->getPointerOperand();
244 Value *Ptr1 = S1->getPointerOperand();
245 // Only one definition?
246 LLVM_DEBUG(dbgs() << "Sink Instruction into BB \n"; BB->dump();
247 dbgs() << "Instruction Left\n"; S0->dump(); dbgs() << "\n";
248 dbgs() << "Instruction Right\n"; S1->dump(); dbgs() << "\n");
249 // Hoist the instruction.
251 // Intersect optional metadata.
252 S0->andIRFlags(S1);
255 S0->mergeDIAssignID(S1);
256
257 // Create the new store to be inserted at the join point.
258 StoreInst *SNew = cast<StoreInst>(S0->clone());
259 SNew->insertBefore(&*InsertPt);
260 // New PHI operand? Use it.
261 if (PHINode *NewPN = getPHIOperand(BB, S0, S1))
262 SNew->setOperand(0, NewPN);
263 S0->eraseFromParent();
264 S1->eraseFromParent();
265
266 if (Ptr0 != Ptr1) {
267 auto *GEP0 = cast<GetElementPtrInst>(Ptr0);
268 auto *GEP1 = cast<GetElementPtrInst>(Ptr1);
269 Instruction *GEPNew = GEP0->clone();
270 GEPNew->insertBefore(SNew);
271 GEPNew->applyMergedLocation(GEP0->getDebugLoc(), GEP1->getDebugLoc());
272 SNew->setOperand(1, GEPNew);
273 GEP0->replaceAllUsesWith(GEPNew);
274 GEP0->eraseFromParent();
275 GEP1->replaceAllUsesWith(GEPNew);
276 GEP1->eraseFromParent();
277 }
278}
279
280///
281/// True when two stores are equivalent and can sink into the footer
282///
283/// Starting from a diamond head block, iterate over the instructions in one
284/// successor block and try to match a store in the second successor.
285///
286bool MergedLoadStoreMotion::mergeStores(BasicBlock *HeadBB) {
287
288 bool MergedStores = false;
289 BasicBlock *TailBB = getDiamondTail(HeadBB);
290 BasicBlock *SinkBB = TailBB;
291 assert(SinkBB && "Footer of a diamond cannot be empty");
292
293 succ_iterator SI = succ_begin(HeadBB);
294 assert(SI != succ_end(HeadBB) && "Diamond head cannot have zero successors");
295 BasicBlock *Pred0 = *SI;
296 ++SI;
297 assert(SI != succ_end(HeadBB) && "Diamond head cannot have single successor");
298 BasicBlock *Pred1 = *SI;
299 // tail block of a diamond/hammock?
300 if (Pred0 == Pred1)
301 return false; // No.
302 // bail out early if we can not merge into the footer BB
303 if (!SplitFooterBB && TailBB->hasNPredecessorsOrMore(3))
304 return false;
305 // #Instructions in Pred1 for Compile Time Control
306 auto InstsNoDbg = Pred1->instructionsWithoutDebug();
307 int Size1 = std::distance(InstsNoDbg.begin(), InstsNoDbg.end());
308 int NStores = 0;
309
310 for (BasicBlock::reverse_iterator RBI = Pred0->rbegin(), RBE = Pred0->rend();
311 RBI != RBE;) {
312
313 Instruction *I = &*RBI;
314 ++RBI;
315
316 // Don't sink non-simple (atomic, volatile) stores.
317 auto *S0 = dyn_cast<StoreInst>(I);
318 if (!S0 || !S0->isSimple())
319 continue;
320
321 ++NStores;
322 if (NStores * Size1 >= MagicCompileTimeControl)
323 break;
324 if (StoreInst *S1 = canSinkFromBlock(Pred1, S0)) {
325 if (!canSinkStoresAndGEPs(S0, S1))
326 // Don't attempt to sink below stores that had to stick around
327 // But after removal of a store and some of its feeding
328 // instruction search again from the beginning since the iterator
329 // is likely stale at this point.
330 break;
331
332 if (SinkBB == TailBB && TailBB->hasNPredecessorsOrMore(3)) {
333 // We have more than 2 predecessors. Insert a new block
334 // postdominating 2 predecessors we're going to sink from.
335 SinkBB = SplitBlockPredecessors(TailBB, {Pred0, Pred1}, ".sink.split");
336 if (!SinkBB)
337 break;
338 }
339
340 MergedStores = true;
341 sinkStoresAndGEPs(SinkBB, S0, S1);
342 RBI = Pred0->rbegin();
343 RBE = Pred0->rend();
344 LLVM_DEBUG(dbgs() << "Search again\n"; Instruction *I = &*RBI; I->dump());
345 }
346 }
347 return MergedStores;
348}
349
350bool MergedLoadStoreMotion::run(Function &F, AliasAnalysis &AA) {
351 this->AA = &AA;
352
353 bool Changed = false;
354 LLVM_DEBUG(dbgs() << "Instruction Merger\n");
355
356 // Merge unconditional branches, allowing PRE to catch more
357 // optimization opportunities.
358 // This loop doesn't care about newly inserted/split blocks
359 // since they never will be diamond heads.
361 // Hoist equivalent loads and sink stores
362 // outside diamonds when possible
363 if (isDiamondHead(&BB))
364 Changed |= mergeStores(&BB);
365 return Changed;
366}
367
368namespace {
369class MergedLoadStoreMotionLegacyPass : public FunctionPass {
370 const bool SplitFooterBB;
371public:
372 static char ID; // Pass identification, replacement for typeid
373 MergedLoadStoreMotionLegacyPass(bool SplitFooterBB = false)
374 : FunctionPass(ID), SplitFooterBB(SplitFooterBB) {
377 }
378
379 ///
380 /// Run the transformation for each function
381 ///
382 bool runOnFunction(Function &F) override {
383 if (skipFunction(F))
384 return false;
385 MergedLoadStoreMotion Impl(SplitFooterBB);
386 return Impl.run(F, getAnalysis<AAResultsWrapperPass>().getAAResults());
387 }
388
389private:
390 void getAnalysisUsage(AnalysisUsage &AU) const override {
391 if (!SplitFooterBB)
392 AU.setPreservesCFG();
395 }
396};
397
398char MergedLoadStoreMotionLegacyPass::ID = 0;
399} // anonymous namespace
400
401///
402/// createMergedLoadStoreMotionPass - The public interface to this file.
403///
405 return new MergedLoadStoreMotionLegacyPass(SplitFooterBB);
406}
407
408INITIALIZE_PASS_BEGIN(MergedLoadStoreMotionLegacyPass, "mldst-motion",
409 "MergedLoadStoreMotion", false, false)
411INITIALIZE_PASS_END(MergedLoadStoreMotionLegacyPass, "mldst-motion",
412 "MergedLoadStoreMotion", false, false)
413
416 MergedLoadStoreMotion Impl(Options.SplitFooterBB);
417 auto &AA = AM.getResult<AAManager>(F);
418 if (!Impl.run(F, AA))
419 return PreservedAnalyses::all();
420
422 if (!Options.SplitFooterBB)
424 return PA;
425}
426
428 raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
430 OS, MapClassName2PassName);
431 OS << "<";
432 OS << (Options.SplitFooterBB ? "" : "no-") << "split-footer-bb";
433 OS << ">";
434}
#define LLVM_DEBUG(X)
Definition: Debug.h:101
This is the interface for a simple mod/ref and alias analysis over globals.
static LVOptions Options
Definition: LVOptions.cpp:25
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
mldst MergedLoadStoreMotion
mldst motion
This pass performs merges of loads and stores on both sides of a.
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
@ SI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A manager for alias analyses.
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:265
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:245
reverse_iterator rbegin()
Definition: BasicBlock.h:319
iterator_range< filter_iterator< BasicBlock::const_iterator, std::function< bool(const Instruction &)> > > instructionsWithoutDebug(bool SkipPseudoOp=true) const
Return a const iterator range over the instructions in the block, skipping any debug instructions.
Definition: BasicBlock.cpp:103
const Instruction & front() const
Definition: BasicBlock.h:326
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:284
InstListType::reverse_iterator reverse_iterator
Definition: BasicBlock.h:89
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
Definition: BasicBlock.cpp:314
reverse_iterator rend()
Definition: BasicBlock.h:321
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:87
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.h:127
bool hasNPredecessorsOrMore(unsigned N) const
Return true if this block has N predecessors or more.
Definition: BasicBlock.cpp:310
const Instruction & back() const
Definition: BasicBlock.h:328
Represents analyses that only rely on functions' control flow.
Definition: PassManager.h:113
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
bool skipFunction(const Function &F) const
Optional passes call this function to check whether the pass should be skipped.
Definition: Pass.cpp:174
Legacy wrapper pass to provide the GlobalsAAResult object.
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const LLVM_READONLY
This function determines if the specified instruction executes the same operation as the current one.
void mergeDIAssignID(ArrayRef< const Instruction * > SourceInstructions)
Merge the DIAssignID metadata from this instruction and those attached to instructions in SourceInstr...
Definition: DebugInfo.cpp:901
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
Definition: Instruction.cpp:88
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:358
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
const BasicBlock * getParent() const
Definition: Instruction.h:90
BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY
Return the specified successor. This instruction must be a terminator.
void applyMergedLocation(const DILocation *LocA, const DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
Definition: DebugInfo.cpp:896
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:82
void dropUnknownNonDebugMetadata(ArrayRef< unsigned > KnownIDs)
Drop all unknown metadata except for debug locations.
Definition: Metadata.cpp:1401
Representation for a specific memory location.
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:98
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
void preserveSet()
Mark an analysis set as preserved.
Definition: PassManager.h:188
An instruction for storing to memory.
Definition: Instructions.h:301
bool isSimple() const
Definition: Instructions.h:382
Value * getValueOperand()
Definition: Instructions.h:390
Value * getPointerOperand()
Definition: Instructions.h:393
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4938
An efficient, type-erasing, non-owning reference to a callable.
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:289
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:102
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:99
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:721
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:484
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
BasicBlock * SplitBlockPredecessors(BasicBlock *BB, ArrayRef< BasicBlock * > Preds, const char *Suffix, DominatorTree *DT, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, bool PreserveLCSSA=false)
This method introduces at least one new basic block into the function and moves some of the predecess...
void initializeMergedLoadStoreMotionLegacyPassPass(PassRegistry &)
FunctionPass * createMergedLoadStoreMotionPass(bool SplitFooterBB=false)
createMergedLoadStoreMotionPass - The public interface to this file.
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371