1 //===-- Local.cpp - Functions to perform local transformations ------------===// 2 // 3 // This family of functions perform various local transformations to the 4 // program. 5 // 6 //===----------------------------------------------------------------------===// 7 8 #include "llvm/Transforms/Utils/Local.h" 9 #include "llvm/iTerminators.h" 10 #include "llvm/ConstantHandling.h" 11 12 //===----------------------------------------------------------------------===// 13 // Local constant propogation... 14 // 15 16 // ConstantFoldInstruction - If an instruction references constants, try to fold 17 // them together... 18 // 19 bool doConstantPropogation(BasicBlock::iterator &II) { 20 Instruction *Inst = *II; 21 if (Constant *C = ConstantFoldInstruction(Inst)) { 22 // Replaces all of the uses of a variable with uses of the constant. 23 Inst->replaceAllUsesWith(C); 24 25 // Remove the instruction from the basic block... 26 delete Inst->getParent()->getInstList().remove(II); 27 return true; 28 } 29 30 return false; 31 } 32 33 // ConstantFoldTerminator - If a terminator instruction is predicated on a 34 // constant value, convert it into an unconditional branch to the constant 35 // destination. 36 // 37 bool ConstantFoldTerminator(BasicBlock *BB) { 38 TerminatorInst *T = BB->getTerminator(); 39 40 // Branch - See if we are conditional jumping on constant 41 if (BranchInst *BI = dyn_cast<BranchInst>(T)) { 42 if (BI->isUnconditional()) return false; // Can't optimize uncond branch 43 BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0)); 44 BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1)); 45 46 if (ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition())) { 47 // Are we branching on constant? 48 // YES. Change to unconditional branch... 49 BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2; 50 BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1; 51 52 //cerr << "Function: " << T->getParent()->getParent() 53 // << "\nRemoving branch from " << T->getParent() 54 // << "\n\nTo: " << OldDest << endl; 55 56 // Let the basic block know that we are letting go of it. Based on this, 57 // it will adjust it's PHI nodes. 58 assert(BI->getParent() && "Terminator not inserted in block!"); 59 OldDest->removePredecessor(BI->getParent()); 60 61 // Set the unconditional destination, and change the insn to be an 62 // unconditional branch. 63 BI->setUnconditionalDest(Destination); 64 return true; 65 } 66 #if 0 67 // FIXME: TODO: This doesn't work if the destination has PHI nodes with 68 // different incoming values on each branch! 69 // 70 else if (Dest2 == Dest1) { // Conditional branch to same location? 71 // This branch matches something like this: 72 // br bool %cond, label %Dest, label %Dest 73 // and changes it into: br label %Dest 74 75 // Let the basic block know that we are letting go of one copy of it. 76 assert(BI->getParent() && "Terminator not inserted in block!"); 77 Dest1->removePredecessor(BI->getParent()); 78 79 // Change a conditional branch to unconditional. 80 BI->setUnconditionalDest(Dest1); 81 return true; 82 } 83 #endif 84 } 85 return false; 86 } 87 88 89 90 //===----------------------------------------------------------------------===// 91 // Local dead code elimination... 92 // 93 94 bool isInstructionTriviallyDead(Instruction *I) { 95 return I->use_empty() && !I->hasSideEffects() && !isa<TerminatorInst>(I); 96 } 97 98 // dceInstruction - Inspect the instruction at *BBI and figure out if it's 99 // [trivially] dead. If so, remove the instruction and update the iterator 100 // to point to the instruction that immediately succeeded the original 101 // instruction. 102 // 103 bool dceInstruction(BasicBlock::iterator &BBI) { 104 // Look for un"used" definitions... 105 Instruction *I = *BBI; 106 if (isInstructionTriviallyDead(I)) { 107 delete I->getParent()->getInstList().remove(BBI); // Bye bye 108 return true; 109 } 110 return false; 111 } 112