1 //===-- GCSE.cpp - SSA based Global Common Subexpr Elimination ------------===//
3 // This pass is designed to be a very quick global transformation that
4 // eliminates global common subexpressions from a function. It does this by
5 // examining the SSA value graph of the function, instead of doing slow, dense,
6 // bit-vector computations.
8 // This pass works best if it is proceeded with a simple constant propogation
9 // pass and an instruction combination pass because this pass does not do any
10 // value numbering (in order to be speedy).
12 // This pass does not attempt to CSE load instructions, because it does not use
13 // pointer analysis to determine when it is safe.
15 //===----------------------------------------------------------------------===//
17 #include "llvm/Transforms/Scalar.h"
18 #include "llvm/InstrTypes.h"
19 #include "llvm/iMemory.h"
20 #include "llvm/Analysis/Dominators.h"
21 #include "llvm/Support/InstVisitor.h"
22 #include "llvm/Support/InstIterator.h"
23 #include "llvm/Support/CFG.h"
24 #include "Support/StatisticReporter.h"
27 static Statistic<> NumInstRemoved("gcse\t\t- Number of instructions removed");
28 static Statistic<> NumLoadRemoved("gcse\t\t- Number of loads removed");
31 class GCSE : public FunctionPass, public InstVisitor<GCSE, bool> {
32 set<Instruction*> WorkList;
33 DominatorSet *DomSetInfo;
34 ImmediateDominators *ImmDominator;
36 // BBContainsStore - Contains a value that indicates whether a basic block
37 // has a store or call instruction in it. This map is demand populated, so
38 // not having an entry means that the basic block has not been scanned yet.
40 map<BasicBlock*, bool> BBContainsStore;
42 const char *getPassName() const {
43 return "Global Common Subexpression Elimination";
46 virtual bool runOnFunction(Function &F);
48 // Visitation methods, these are invoked depending on the type of
49 // instruction being checked. They should return true if a common
50 // subexpression was folded.
52 bool visitUnaryOperator(Instruction &I);
53 bool visitBinaryOperator(Instruction &I);
54 bool visitGetElementPtrInst(GetElementPtrInst &I);
55 bool visitCastInst(CastInst &I){return visitUnaryOperator((Instruction&)I);}
56 bool visitShiftInst(ShiftInst &I) {
57 return visitBinaryOperator((Instruction&)I);
59 bool visitLoadInst(LoadInst &LI);
60 bool visitInstruction(Instruction &) { return false; }
63 void ReplaceInstWithInst(Instruction *First, BasicBlock::iterator SI);
64 void CommonSubExpressionFound(Instruction *I, Instruction *Other);
66 // TryToRemoveALoad - Try to remove one of L1 or L2. The problem with
67 // removing loads is that intervening stores might make otherwise identical
68 // load's yield different values. To ensure that this is not the case, we
69 // check that there are no intervening stores or calls between the
72 bool TryToRemoveALoad(LoadInst *L1, LoadInst *L2);
74 // CheckForInvalidatingInst - Return true if BB or any of the predecessors
75 // of BB (until DestBB) contain a store (or other invalidating) instruction.
77 bool CheckForInvalidatingInst(BasicBlock *BB, BasicBlock *DestBB,
78 set<BasicBlock*> &VisitedSet);
80 // This transformation requires dominator and immediate dominator info
81 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
83 AU.addRequired(DominatorSet::ID);
84 AU.addRequired(ImmediateDominators::ID);
89 // createGCSEPass - The public interface to this file...
90 Pass *createGCSEPass() { return new GCSE(); }
93 // GCSE::runOnFunction - This is the main transformation entry point for a
96 bool GCSE::runOnFunction(Function &F) {
99 DomSetInfo = &getAnalysis<DominatorSet>();
100 ImmDominator = &getAnalysis<ImmediateDominators>();
102 // Step #1: Add all instructions in the function to the worklist for
103 // processing. All of the instructions are considered to be our
104 // subexpressions to eliminate if possible.
106 WorkList.insert(inst_begin(F), inst_end(F));
108 // Step #2: WorkList processing. Iterate through all of the instructions,
109 // checking to see if there are any additionally defined subexpressions in the
110 // program. If so, eliminate them!
112 while (!WorkList.empty()) {
113 Instruction &I = **WorkList.begin(); // Get an instruction from the worklist
114 WorkList.erase(WorkList.begin());
116 // Visit the instruction, dispatching to the correct visit function based on
117 // the instruction type. This does the checking.
122 // Clear out data structure so that next function starts fresh
123 BBContainsStore.clear();
125 // When the worklist is empty, return whether or not we changed anything...
130 // ReplaceInstWithInst - Destroy the instruction pointed to by SI, making all
131 // uses of the instruction use First now instead.
133 void GCSE::ReplaceInstWithInst(Instruction *First, BasicBlock::iterator SI) {
134 Instruction &Second = *SI;
136 //cerr << "DEL " << (void*)Second << Second;
138 // Add the first instruction back to the worklist
139 WorkList.insert(First);
141 // Add all uses of the second instruction to the worklist
142 for (Value::use_iterator UI = Second.use_begin(), UE = Second.use_end();
144 WorkList.insert(cast<Instruction>(*UI));
146 // Make all users of 'Second' now use 'First'
147 Second.replaceAllUsesWith(First);
149 // Erase the second instruction from the program
150 Second.getParent()->getInstList().erase(SI);
153 // CommonSubExpressionFound - The two instruction I & Other have been found to
154 // be common subexpressions. This function is responsible for eliminating one
155 // of them, and for fixing the worklist to be correct.
157 void GCSE::CommonSubExpressionFound(Instruction *I, Instruction *Other) {
161 WorkList.erase(Other); // Other may not actually be on the worklist anymore...
163 ++NumInstRemoved; // Keep track of number of instructions eliminated
165 // Handle the easy case, where both instructions are in the same basic block
166 BasicBlock *BB1 = I->getParent(), *BB2 = Other->getParent();
168 // Eliminate the second occuring instruction. Add all uses of the second
169 // instruction to the worklist.
171 // Scan the basic block looking for the "first" instruction
172 BasicBlock::iterator BI = BB1->begin();
173 while (&*BI != I && &*BI != Other) {
175 assert(BI != BB1->end() && "Instructions not found in parent BB!");
178 // Keep track of which instructions occurred first & second
179 Instruction *First = BI;
180 Instruction *Second = I != First ? I : Other; // Get iterator to second inst
183 // Destroy Second, using First instead.
184 ReplaceInstWithInst(First, BI);
186 // Otherwise, the two instructions are in different basic blocks. If one
187 // dominates the other instruction, we can simply use it
189 } else if (DomSetInfo->dominates(BB1, BB2)) { // I dom Other?
190 ReplaceInstWithInst(I, Other);
191 } else if (DomSetInfo->dominates(BB2, BB1)) { // Other dom I?
192 ReplaceInstWithInst(Other, I);
194 // Handle the most general case now. In this case, neither I dom Other nor
195 // Other dom I. Because we are in SSA form, we are guaranteed that the
196 // operands of the two instructions both dominate the uses, so we _know_
197 // that there must exist a block that dominates both instructions (if the
198 // operands of the instructions are globals or constants, worst case we
199 // would get the entry node of the function). Search for this block now.
202 // Search up the immediate dominator chain of BB1 for the shared dominator
203 BasicBlock *SharedDom = (*ImmDominator)[BB1];
204 while (!DomSetInfo->dominates(SharedDom, BB2))
205 SharedDom = (*ImmDominator)[SharedDom];
207 // At this point, shared dom must dominate BOTH BB1 and BB2...
208 assert(SharedDom && DomSetInfo->dominates(SharedDom, BB1) &&
209 DomSetInfo->dominates(SharedDom, BB2) && "Dominators broken!");
211 // Rip 'I' out of BB1, and move it to the end of SharedDom.
212 BB1->getInstList().remove(I);
213 SharedDom->getInstList().insert(--SharedDom->end(), I);
215 // Eliminate 'Other' now.
216 ReplaceInstWithInst(I, Other);
220 //===----------------------------------------------------------------------===//
222 // Visitation methods, these are invoked depending on the type of instruction
223 // being checked. They should return true if a common subexpression was folded.
225 //===----------------------------------------------------------------------===//
227 bool GCSE::visitUnaryOperator(Instruction &I) {
228 Value *Op = I.getOperand(0);
229 Function *F = I.getParent()->getParent();
231 for (Value::use_iterator UI = Op->use_begin(), UE = Op->use_end();
233 if (Instruction *Other = dyn_cast<Instruction>(*UI))
234 // Check to see if this new binary operator is not I, but same operand...
235 if (Other != &I && Other->getOpcode() == I.getOpcode() &&
236 Other->getOperand(0) == Op && // Is the operand the same?
237 // Is it embeded in the same function? (This could be false if LHS
238 // is a constant or global!)
239 Other->getParent()->getParent() == F &&
241 // Check that the types are the same, since this code handles casts...
242 Other->getType() == I.getType()) {
244 // These instructions are identical. Handle the situation.
245 CommonSubExpressionFound(&I, Other);
246 return true; // One instruction eliminated!
252 // isIdenticalBinaryInst - Return true if the two binary instructions are
255 static inline bool isIdenticalBinaryInst(const Instruction &I1,
256 const Instruction *I2) {
257 // Is it embeded in the same function? (This could be false if LHS
258 // is a constant or global!)
259 if (I1.getOpcode() != I2->getOpcode() ||
260 I1.getParent()->getParent() != I2->getParent()->getParent())
263 // They are identical if both operands are the same!
264 if (I1.getOperand(0) == I2->getOperand(0) &&
265 I1.getOperand(1) == I2->getOperand(1))
268 // If the instruction is commutative and associative, the instruction can
269 // match if the operands are swapped!
271 if ((I1.getOperand(0) == I2->getOperand(1) &&
272 I1.getOperand(1) == I2->getOperand(0)) &&
273 (I1.getOpcode() == Instruction::Add ||
274 I1.getOpcode() == Instruction::Mul ||
275 I1.getOpcode() == Instruction::And ||
276 I1.getOpcode() == Instruction::Or ||
277 I1.getOpcode() == Instruction::Xor))
283 bool GCSE::visitBinaryOperator(Instruction &I) {
284 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
285 Function *F = I.getParent()->getParent();
287 for (Value::use_iterator UI = LHS->use_begin(), UE = LHS->use_end();
289 if (Instruction *Other = dyn_cast<Instruction>(*UI))
290 // Check to see if this new binary operator is not I, but same operand...
291 if (Other != &I && isIdenticalBinaryInst(I, Other)) {
292 // These instructions are identical. Handle the situation.
293 CommonSubExpressionFound(&I, Other);
294 return true; // One instruction eliminated!
300 // IdenticalComplexInst - Return true if the two instructions are the same, by
301 // using a brute force comparison.
303 static bool IdenticalComplexInst(const Instruction *I1, const Instruction *I2) {
304 assert(I1->getOpcode() == I2->getOpcode());
305 // Equal if they are in the same function...
306 return I1->getParent()->getParent() == I2->getParent()->getParent() &&
307 // And return the same type...
308 I1->getType() == I2->getType() &&
309 // And have the same number of operands...
310 I1->getNumOperands() == I2->getNumOperands() &&
311 // And all of the operands are equal.
312 std::equal(I1->op_begin(), I1->op_end(), I2->op_begin());
315 bool GCSE::visitGetElementPtrInst(GetElementPtrInst &I) {
316 Value *Op = I.getOperand(0);
317 Function *F = I.getParent()->getParent();
319 for (Value::use_iterator UI = Op->use_begin(), UE = Op->use_end();
321 if (GetElementPtrInst *Other = dyn_cast<GetElementPtrInst>(*UI))
322 // Check to see if this new getelementptr is not I, but same operand...
323 if (Other != &I && IdenticalComplexInst(&I, Other)) {
324 // These instructions are identical. Handle the situation.
325 CommonSubExpressionFound(&I, Other);
326 return true; // One instruction eliminated!
332 bool GCSE::visitLoadInst(LoadInst &LI) {
333 Value *Op = LI.getOperand(0);
334 Function *F = LI.getParent()->getParent();
336 for (Value::use_iterator UI = Op->use_begin(), UE = Op->use_end();
338 if (LoadInst *Other = dyn_cast<LoadInst>(*UI))
339 // Check to see if this new load is not LI, but has the same operands...
340 if (Other != &LI && IdenticalComplexInst(&LI, Other) &&
341 TryToRemoveALoad(&LI, Other))
342 return true; // An instruction was eliminated!
347 static inline bool isInvalidatingInst(const Instruction &I) {
348 return I.getOpcode() == Instruction::Store ||
349 I.getOpcode() == Instruction::Call ||
350 I.getOpcode() == Instruction::Invoke;
353 // TryToRemoveALoad - Try to remove one of L1 or L2. The problem with removing
354 // loads is that intervening stores might make otherwise identical load's yield
355 // different values. To ensure that this is not the case, we check that there
356 // are no intervening stores or calls between the instructions.
358 bool GCSE::TryToRemoveALoad(LoadInst *L1, LoadInst *L2) {
359 // Figure out which load dominates the other one. If neither dominates the
360 // other we cannot eliminate one...
362 if (DomSetInfo->dominates(L2, L1))
363 std::swap(L1, L2); // Make L1 dominate L2
364 else if (!DomSetInfo->dominates(L1, L2))
365 return false; // Neither instruction dominates the other one...
367 BasicBlock *BB1 = L1->getParent(), *BB2 = L2->getParent();
369 BasicBlock::iterator L1I = L1;
371 // L1 now dominates L2. Check to see if the intervening instructions between
372 // the two loads include a store or call...
374 if (BB1 == BB2) { // In same basic block?
375 // In this degenerate case, no checking of global basic blocks has to occur
376 // just check the instructions BETWEEN L1 & L2...
378 for (++L1I; &*L1I != L2; ++L1I)
379 if (isInvalidatingInst(*L1I))
380 return false; // Cannot eliminate load
383 CommonSubExpressionFound(L1, L2);
386 // Make sure that there are no store instructions between L1 and the end of
387 // it's basic block...
389 for (++L1I; L1I != BB1->end(); ++L1I)
390 if (isInvalidatingInst(*L1I)) {
391 BBContainsStore[BB1] = true;
392 return false; // Cannot eliminate load
395 // Make sure that there are no store instructions between the start of BB2
396 // and the second load instruction...
398 for (BasicBlock::iterator II = BB2->begin(); &*II != L2; ++II)
399 if (isInvalidatingInst(*II)) {
400 BBContainsStore[BB2] = true;
401 return false; // Cannot eliminate load
404 // Do a depth first traversal of the inverse CFG starting at L2's block,
405 // looking for L1's block. The inverse CFG is made up of the predecessor
406 // nodes of a block... so all of the edges in the graph are "backward".
408 set<BasicBlock*> VisitedSet;
409 for (pred_iterator PI = pred_begin(BB2), PE = pred_end(BB2); PI != PE; ++PI)
410 if (CheckForInvalidatingInst(*PI, BB1, VisitedSet))
414 CommonSubExpressionFound(L1, L2);
420 // CheckForInvalidatingInst - Return true if BB or any of the predecessors of BB
421 // (until DestBB) contain a store (or other invalidating) instruction.
423 bool GCSE::CheckForInvalidatingInst(BasicBlock *BB, BasicBlock *DestBB,
424 set<BasicBlock*> &VisitedSet) {
425 // Found the termination point!
426 if (BB == DestBB || VisitedSet.count(BB)) return false;
428 // Avoid infinite recursion!
429 VisitedSet.insert(BB);
431 // Have we already checked this block?
432 map<BasicBlock*, bool>::iterator MI = BBContainsStore.find(BB);
434 if (MI != BBContainsStore.end()) {
435 // If this block is known to contain a store, exit the recursion early...
436 if (MI->second) return true;
437 // Otherwise continue checking predecessors...
439 // We don't know if this basic block contains an invalidating instruction.
441 bool HasStore = std::find_if(BB->begin(), BB->end(),
442 isInvalidatingInst) != BB->end();
443 if ((BBContainsStore[BB] = HasStore)) // Update map
444 return true; // Exit recursion early...
447 // Check all of our predecessor blocks...
448 for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI)
449 if (CheckForInvalidatingInst(*PI, DestBB, VisitedSet))
452 // None of our predecessor blocks contain a store, and we don't either!