Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 1 | //===-- Local.cpp - Functions to perform local transformations ------------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file was developed by the LLVM research group and is distributed under |
| 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 9 | // |
| 10 | // This family of functions perform various local transformations to the |
| 11 | // program. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "llvm/Transforms/Utils/Local.h" |
Chris Lattner | 81ebc30 | 2004-01-12 18:35:03 +0000 | [diff] [blame] | 16 | #include "llvm/Constants.h" |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 17 | #include "llvm/DerivedTypes.h" |
Chris Lattner | 7822c2a | 2004-01-12 19:56:36 +0000 | [diff] [blame] | 18 | #include "llvm/Instructions.h" |
Chris Lattner | cf11035 | 2004-06-11 06:16:23 +0000 | [diff] [blame] | 19 | #include "llvm/Intrinsics.h" |
Chris Lattner | cbbc6b7 | 2005-10-27 16:34:00 +0000 | [diff] [blame] | 20 | #include "llvm/Analysis/ConstantFolding.h" |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 21 | #include "llvm/Target/TargetData.h" |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 22 | #include "llvm/Support/GetElementPtrTypeIterator.h" |
| 23 | #include "llvm/Support/MathExtras.h" |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 24 | #include "llvm/ADT/SmallVector.h" |
Alkis Evlogimenos | 09233fb | 2004-04-21 16:11:40 +0000 | [diff] [blame] | 25 | #include <cerrno> |
Chris Lattner | abbc2dd | 2003-12-19 05:56:28 +0000 | [diff] [blame] | 26 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 27 | |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 28 | //===----------------------------------------------------------------------===// |
Misha Brukman | 82c89b9 | 2003-05-20 21:01:22 +0000 | [diff] [blame] | 29 | // Local constant propagation... |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 30 | // |
| 31 | |
Chris Lattner | abbc2dd | 2003-12-19 05:56:28 +0000 | [diff] [blame] | 32 | /// doConstantPropagation - If an instruction references constants, try to fold |
| 33 | /// them together... |
| 34 | /// |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 35 | bool llvm::doConstantPropagation(BasicBlock::iterator &II, |
| 36 | const TargetData *TD) { |
| 37 | if (Constant *C = ConstantFoldInstruction(II, TD)) { |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 38 | // Replaces all of the uses of a variable with uses of the constant. |
Chris Lattner | 1896150 | 2002-06-25 16:12:52 +0000 | [diff] [blame] | 39 | II->replaceAllUsesWith(C); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 40 | |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 41 | // Remove the instruction from the basic block... |
Chris Lattner | 1896150 | 2002-06-25 16:12:52 +0000 | [diff] [blame] | 42 | II = II->getParent()->getInstList().erase(II); |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 43 | return true; |
| 44 | } |
| 45 | |
| 46 | return false; |
| 47 | } |
| 48 | |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 49 | /// ConstantFoldInstruction - Attempt to constant fold the specified |
| 50 | /// instruction. If successful, the constant result is returned, if not, null |
| 51 | /// is returned. Note that this function can only fail when attempting to fold |
| 52 | /// instructions like loads and stores, which have no constant expression form. |
| 53 | /// |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 54 | Constant *llvm::ConstantFoldInstruction(Instruction *I, const TargetData *TD) { |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 55 | if (PHINode *PN = dyn_cast<PHINode>(I)) { |
| 56 | if (PN->getNumIncomingValues() == 0) |
| 57 | return Constant::getNullValue(PN->getType()); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 58 | |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 59 | Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0)); |
| 60 | if (Result == 0) return 0; |
| 61 | |
| 62 | // Handle PHI nodes specially here... |
| 63 | for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) |
| 64 | if (PN->getIncomingValue(i) != Result && PN->getIncomingValue(i) != PN) |
| 65 | return 0; // Not all the same incoming constants... |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 66 | |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 67 | // If we reach here, all incoming values are the same constant. |
| 68 | return Result; |
| 69 | } |
| 70 | |
| 71 | Constant *Op0 = 0, *Op1 = 0; |
| 72 | switch (I->getNumOperands()) { |
| 73 | default: |
| 74 | case 2: |
| 75 | Op1 = dyn_cast<Constant>(I->getOperand(1)); |
| 76 | if (Op1 == 0) return 0; // Not a constant?, can't fold |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 77 | /* FALL THROUGH */ |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 78 | case 1: |
| 79 | Op0 = dyn_cast<Constant>(I->getOperand(0)); |
| 80 | if (Op0 == 0) return 0; // Not a constant?, can't fold |
| 81 | break; |
| 82 | case 0: return 0; |
| 83 | } |
| 84 | |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 85 | // Scan the operand list, checking to see if they are all constants, if so, |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 86 | // hand off to ConstantFoldInstOperands. |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 87 | SmallVector<Constant*, 8> Ops; |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 88 | for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) |
| 89 | if (Constant *Op = dyn_cast<Constant>(I->getOperand(i))) |
| 90 | Ops.push_back(Op); |
| 91 | else |
| 92 | return 0; // All operands not constant! |
| 93 | |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 94 | return ConstantFoldInstOperands(I, &Ops[0], Ops.size()); |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the |
| 98 | /// specified opcode and operands. If successful, the constant result is |
| 99 | /// returned, if not, null is returned. Note that this function can fail when |
| 100 | /// attempting to fold instructions like loads and stores, which have no |
| 101 | /// constant expression form. |
| 102 | /// |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 103 | Constant *llvm::ConstantFoldInstOperands(const Instruction* I, |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 104 | Constant** Ops, unsigned NumOps, |
| 105 | const TargetData *TD) { |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 106 | unsigned Opc = I->getOpcode(); |
| 107 | const Type *DestTy = I->getType(); |
| 108 | |
| 109 | // Handle easy binops first |
| 110 | if (isa<BinaryOperator>(I)) |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 111 | return ConstantExpr::get(Opc, Ops[0], Ops[1]); |
| 112 | |
| 113 | switch (Opc) { |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 114 | default: return 0; |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 115 | case Instruction::Call: |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 116 | if (Function *F = dyn_cast<Function>(Ops[0])) |
| 117 | if (canConstantFoldCallTo(F)) |
| 118 | return ConstantFoldCall(F, Ops+1, NumOps); |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 119 | return 0; |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 120 | case Instruction::ICmp: |
| 121 | case Instruction::FCmp: |
| 122 | return ConstantExpr::getCompare(cast<CmpInst>(I)->getPredicate(), Ops[0], |
| 123 | Ops[1]); |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 124 | case Instruction::Shl: |
Reid Spencer | 3822ff5 | 2006-11-08 06:47:33 +0000 | [diff] [blame] | 125 | case Instruction::LShr: |
| 126 | case Instruction::AShr: |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 127 | return ConstantExpr::get(Opc, Ops[0], Ops[1]); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 128 | case Instruction::Trunc: |
| 129 | case Instruction::ZExt: |
| 130 | case Instruction::SExt: |
| 131 | case Instruction::FPTrunc: |
| 132 | case Instruction::FPExt: |
| 133 | case Instruction::UIToFP: |
| 134 | case Instruction::SIToFP: |
| 135 | case Instruction::FPToUI: |
| 136 | case Instruction::FPToSI: |
| 137 | case Instruction::PtrToInt: |
| 138 | case Instruction::IntToPtr: |
| 139 | case Instruction::BitCast: |
| 140 | return ConstantExpr::getCast(Opc, Ops[0], DestTy); |
Chris Lattner | 17fd273 | 2004-03-12 05:53:03 +0000 | [diff] [blame] | 141 | case Instruction::Select: |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 142 | return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); |
Robert Bocchino | b52ee7f | 2006-01-10 19:05:34 +0000 | [diff] [blame] | 143 | case Instruction::ExtractElement: |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 144 | return ConstantExpr::getExtractElement(Ops[0], Ops[1]); |
Robert Bocchino | 956fd72 | 2006-01-17 20:07:07 +0000 | [diff] [blame] | 145 | case Instruction::InsertElement: |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 146 | return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]); |
Chris Lattner | 543abdf | 2006-04-08 01:19:12 +0000 | [diff] [blame] | 147 | case Instruction::ShuffleVector: |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 148 | return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 149 | case Instruction::GetElementPtr: |
Chris Lattner | 4b30fcb | 2006-05-27 01:18:04 +0000 | [diff] [blame] | 150 | return ConstantExpr::getGetElementPtr(Ops[0], |
Chris Lattner | 9fa038d | 2007-01-30 23:13:49 +0000 | [diff] [blame^] | 151 | std::vector<Constant*>(Ops+1, |
| 152 | Ops+NumOps)); |
Chris Lattner | 8f90b00 | 2004-01-12 18:25:22 +0000 | [diff] [blame] | 153 | } |
| 154 | } |
| 155 | |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 156 | // ConstantFoldTerminator - If a terminator instruction is predicated on a |
| 157 | // constant value, convert it into an unconditional branch to the constant |
| 158 | // destination. |
| 159 | // |
Chris Lattner | abbc2dd | 2003-12-19 05:56:28 +0000 | [diff] [blame] | 160 | bool llvm::ConstantFoldTerminator(BasicBlock *BB) { |
Chris Lattner | 76ae344 | 2002-05-21 20:04:50 +0000 | [diff] [blame] | 161 | TerminatorInst *T = BB->getTerminator(); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 162 | |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 163 | // Branch - See if we are conditional jumping on constant |
| 164 | if (BranchInst *BI = dyn_cast<BranchInst>(T)) { |
| 165 | if (BI->isUnconditional()) return false; // Can't optimize uncond branch |
| 166 | BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0)); |
| 167 | BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1)); |
| 168 | |
Zhou Sheng | 6b6b6ef | 2007-01-11 12:24:14 +0000 | [diff] [blame] | 169 | if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) { |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 170 | // Are we branching on constant? |
| 171 | // YES. Change to unconditional branch... |
Reid Spencer | 579dca1 | 2007-01-12 04:24:46 +0000 | [diff] [blame] | 172 | BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2; |
| 173 | BasicBlock *OldDest = Cond->getZExtValue() ? Dest2 : Dest1; |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 174 | |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 175 | //cerr << "Function: " << T->getParent()->getParent() |
| 176 | // << "\nRemoving branch from " << T->getParent() |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 177 | // << "\n\nTo: " << OldDest << endl; |
| 178 | |
| 179 | // Let the basic block know that we are letting go of it. Based on this, |
| 180 | // it will adjust it's PHI nodes. |
| 181 | assert(BI->getParent() && "Terminator not inserted in block!"); |
| 182 | OldDest->removePredecessor(BI->getParent()); |
| 183 | |
| 184 | // Set the unconditional destination, and change the insn to be an |
| 185 | // unconditional branch. |
| 186 | BI->setUnconditionalDest(Destination); |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 187 | return true; |
Chris Lattner | 342a9d1 | 2003-08-17 19:34:55 +0000 | [diff] [blame] | 188 | } else if (Dest2 == Dest1) { // Conditional branch to same location? |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 189 | // This branch matches something like this: |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 190 | // br bool %cond, label %Dest, label %Dest |
| 191 | // and changes it into: br label %Dest |
| 192 | |
| 193 | // Let the basic block know that we are letting go of one copy of it. |
| 194 | assert(BI->getParent() && "Terminator not inserted in block!"); |
| 195 | Dest1->removePredecessor(BI->getParent()); |
| 196 | |
| 197 | // Change a conditional branch to unconditional. |
| 198 | BI->setUnconditionalDest(Dest1); |
| 199 | return true; |
| 200 | } |
Chris Lattner | 10b1f5a | 2003-08-17 20:21:14 +0000 | [diff] [blame] | 201 | } else if (SwitchInst *SI = dyn_cast<SwitchInst>(T)) { |
| 202 | // If we are switching on a constant, we can convert the switch into a |
| 203 | // single branch instruction! |
| 204 | ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition()); |
| 205 | BasicBlock *TheOnlyDest = SI->getSuccessor(0); // The default dest |
Chris Lattner | 7d6c24c | 2003-08-23 23:18:19 +0000 | [diff] [blame] | 206 | BasicBlock *DefaultDest = TheOnlyDest; |
| 207 | assert(TheOnlyDest == SI->getDefaultDest() && |
| 208 | "Default destination is not successor #0?"); |
Chris Lattner | 694e37f | 2003-08-17 19:41:53 +0000 | [diff] [blame] | 209 | |
Chris Lattner | 10b1f5a | 2003-08-17 20:21:14 +0000 | [diff] [blame] | 210 | // Figure out which case it goes to... |
| 211 | for (unsigned i = 1, e = SI->getNumSuccessors(); i != e; ++i) { |
| 212 | // Found case matching a constant operand? |
| 213 | if (SI->getSuccessorValue(i) == CI) { |
| 214 | TheOnlyDest = SI->getSuccessor(i); |
| 215 | break; |
| 216 | } |
Chris Lattner | 694e37f | 2003-08-17 19:41:53 +0000 | [diff] [blame] | 217 | |
Chris Lattner | 7d6c24c | 2003-08-23 23:18:19 +0000 | [diff] [blame] | 218 | // Check to see if this branch is going to the same place as the default |
| 219 | // dest. If so, eliminate it as an explicit compare. |
| 220 | if (SI->getSuccessor(i) == DefaultDest) { |
| 221 | // Remove this entry... |
| 222 | DefaultDest->removePredecessor(SI->getParent()); |
| 223 | SI->removeCase(i); |
| 224 | --i; --e; // Don't skip an entry... |
| 225 | continue; |
| 226 | } |
| 227 | |
Chris Lattner | 10b1f5a | 2003-08-17 20:21:14 +0000 | [diff] [blame] | 228 | // Otherwise, check to see if the switch only branches to one destination. |
| 229 | // We do this by reseting "TheOnlyDest" to null when we find two non-equal |
| 230 | // destinations. |
| 231 | if (SI->getSuccessor(i) != TheOnlyDest) TheOnlyDest = 0; |
Chris Lattner | 694e37f | 2003-08-17 19:41:53 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Chris Lattner | 10b1f5a | 2003-08-17 20:21:14 +0000 | [diff] [blame] | 234 | if (CI && !TheOnlyDest) { |
| 235 | // Branching on a constant, but not any of the cases, go to the default |
| 236 | // successor. |
| 237 | TheOnlyDest = SI->getDefaultDest(); |
| 238 | } |
| 239 | |
| 240 | // If we found a single destination that we can fold the switch into, do so |
| 241 | // now. |
| 242 | if (TheOnlyDest) { |
| 243 | // Insert the new branch.. |
| 244 | new BranchInst(TheOnlyDest, SI); |
| 245 | BasicBlock *BB = SI->getParent(); |
| 246 | |
| 247 | // Remove entries from PHI nodes which we no longer branch to... |
| 248 | for (unsigned i = 0, e = SI->getNumSuccessors(); i != e; ++i) { |
| 249 | // Found case matching a constant operand? |
| 250 | BasicBlock *Succ = SI->getSuccessor(i); |
| 251 | if (Succ == TheOnlyDest) |
| 252 | TheOnlyDest = 0; // Don't modify the first branch to TheOnlyDest |
| 253 | else |
| 254 | Succ->removePredecessor(BB); |
| 255 | } |
| 256 | |
| 257 | // Delete the old switch... |
| 258 | BB->getInstList().erase(SI); |
| 259 | return true; |
| 260 | } else if (SI->getNumSuccessors() == 2) { |
| 261 | // Otherwise, we can fold this switch into a conditional branch |
| 262 | // instruction if it has only one non-default destination. |
Reid Spencer | e4d87aa | 2006-12-23 06:05:41 +0000 | [diff] [blame] | 263 | Value *Cond = new ICmpInst(ICmpInst::ICMP_EQ, SI->getCondition(), |
| 264 | SI->getSuccessorValue(1), "cond", SI); |
Chris Lattner | 10b1f5a | 2003-08-17 20:21:14 +0000 | [diff] [blame] | 265 | // Insert the new branch... |
| 266 | new BranchInst(SI->getSuccessor(1), SI->getSuccessor(0), Cond, SI); |
| 267 | |
| 268 | // Delete the old switch... |
| 269 | SI->getParent()->getInstList().erase(SI); |
| 270 | return true; |
| 271 | } |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 272 | } |
| 273 | return false; |
| 274 | } |
| 275 | |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 276 | /// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a |
| 277 | /// getelementptr constantexpr, return the constant value being addressed by the |
| 278 | /// constant expression, or null if something is funny and we can't decide. |
| 279 | Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, |
| 280 | ConstantExpr *CE) { |
| 281 | if (CE->getOperand(1) != Constant::getNullValue(CE->getOperand(1)->getType())) |
| 282 | return 0; // Do not allow stepping over the value! |
| 283 | |
| 284 | // Loop over all of the operands, tracking down which value we are |
| 285 | // addressing... |
| 286 | gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE); |
| 287 | for (++I; I != E; ++I) |
| 288 | if (const StructType *STy = dyn_cast<StructType>(*I)) { |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 289 | ConstantInt *CU = cast<ConstantInt>(I.getOperand()); |
| 290 | assert(CU->getZExtValue() < STy->getNumElements() && |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 291 | "Struct index out of range!"); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 292 | unsigned El = (unsigned)CU->getZExtValue(); |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 293 | if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) { |
| 294 | C = CS->getOperand(El); |
| 295 | } else if (isa<ConstantAggregateZero>(C)) { |
| 296 | C = Constant::getNullValue(STy->getElementType(El)); |
| 297 | } else if (isa<UndefValue>(C)) { |
| 298 | C = UndefValue::get(STy->getElementType(El)); |
| 299 | } else { |
| 300 | return 0; |
| 301 | } |
| 302 | } else if (ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand())) { |
Robert Bocchino | d900c6a | 2006-01-19 23:53:23 +0000 | [diff] [blame] | 303 | if (const ArrayType *ATy = dyn_cast<ArrayType>(*I)) { |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 304 | if (CI->getZExtValue() >= ATy->getNumElements()) |
Chris Lattner | 99f2af2 | 2006-05-25 21:25:12 +0000 | [diff] [blame] | 305 | return 0; |
Robert Bocchino | d900c6a | 2006-01-19 23:53:23 +0000 | [diff] [blame] | 306 | if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 307 | C = CA->getOperand(CI->getZExtValue()); |
Robert Bocchino | d900c6a | 2006-01-19 23:53:23 +0000 | [diff] [blame] | 308 | else if (isa<ConstantAggregateZero>(C)) |
| 309 | C = Constant::getNullValue(ATy->getElementType()); |
| 310 | else if (isa<UndefValue>(C)) |
| 311 | C = UndefValue::get(ATy->getElementType()); |
| 312 | else |
| 313 | return 0; |
| 314 | } else if (const PackedType *PTy = dyn_cast<PackedType>(*I)) { |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 315 | if (CI->getZExtValue() >= PTy->getNumElements()) |
Chris Lattner | 99f2af2 | 2006-05-25 21:25:12 +0000 | [diff] [blame] | 316 | return 0; |
Robert Bocchino | d900c6a | 2006-01-19 23:53:23 +0000 | [diff] [blame] | 317 | if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 318 | C = CP->getOperand(CI->getZExtValue()); |
Robert Bocchino | d900c6a | 2006-01-19 23:53:23 +0000 | [diff] [blame] | 319 | else if (isa<ConstantAggregateZero>(C)) |
| 320 | C = Constant::getNullValue(PTy->getElementType()); |
| 321 | else if (isa<UndefValue>(C)) |
| 322 | C = UndefValue::get(PTy->getElementType()); |
| 323 | else |
| 324 | return 0; |
| 325 | } else { |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 326 | return 0; |
Robert Bocchino | d900c6a | 2006-01-19 23:53:23 +0000 | [diff] [blame] | 327 | } |
Chris Lattner | c5f52e6 | 2005-09-26 05:27:10 +0000 | [diff] [blame] | 328 | } else { |
| 329 | return 0; |
| 330 | } |
| 331 | return C; |
| 332 | } |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 333 | |
| 334 | |
| 335 | //===----------------------------------------------------------------------===// |
| 336 | // Local dead code elimination... |
| 337 | // |
| 338 | |
Chris Lattner | abbc2dd | 2003-12-19 05:56:28 +0000 | [diff] [blame] | 339 | bool llvm::isInstructionTriviallyDead(Instruction *I) { |
Chris Lattner | ec710c5 | 2005-05-06 05:27:34 +0000 | [diff] [blame] | 340 | if (!I->use_empty() || isa<TerminatorInst>(I)) return false; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 341 | |
Chris Lattner | ec710c5 | 2005-05-06 05:27:34 +0000 | [diff] [blame] | 342 | if (!I->mayWriteToMemory()) return true; |
| 343 | |
| 344 | if (CallInst *CI = dyn_cast<CallInst>(I)) |
Chris Lattner | aeebe7f | 2006-03-09 22:38:10 +0000 | [diff] [blame] | 345 | if (Function *F = CI->getCalledFunction()) { |
Chris Lattner | 7224f84 | 2006-04-02 03:35:01 +0000 | [diff] [blame] | 346 | unsigned IntrinsicID = F->getIntrinsicID(); |
Chris Lattner | aeebe7f | 2006-03-09 22:38:10 +0000 | [diff] [blame] | 347 | #define GET_SIDE_EFFECT_INFO |
| 348 | #include "llvm/Intrinsics.gen" |
| 349 | #undef GET_SIDE_EFFECT_INFO |
| 350 | } |
Chris Lattner | ec710c5 | 2005-05-06 05:27:34 +0000 | [diff] [blame] | 351 | return false; |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | // dceInstruction - Inspect the instruction at *BBI and figure out if it's |
| 355 | // [trivially] dead. If so, remove the instruction and update the iterator |
| 356 | // to point to the instruction that immediately succeeded the original |
| 357 | // instruction. |
| 358 | // |
Chris Lattner | abbc2dd | 2003-12-19 05:56:28 +0000 | [diff] [blame] | 359 | bool llvm::dceInstruction(BasicBlock::iterator &BBI) { |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 360 | // Look for un"used" definitions... |
Chris Lattner | 1896150 | 2002-06-25 16:12:52 +0000 | [diff] [blame] | 361 | if (isInstructionTriviallyDead(BBI)) { |
| 362 | BBI = BBI->getParent()->getInstList().erase(BBI); // Bye bye |
Chris Lattner | 4d1e46e | 2002-05-07 18:07:59 +0000 | [diff] [blame] | 363 | return true; |
| 364 | } |
| 365 | return false; |
| 366 | } |