Chris Lattner | 184b298 | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 1 | //===-- BasicBlock.cpp - Implement BasicBlock related methods -------------===// |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 482202a | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | f3ebc3f | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 482202a | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 9 | // |
Chris Lattner | f739fa8 | 2002-04-08 22:03:57 +0000 | [diff] [blame] | 10 | // This file implements the BasicBlock class for the VMCore library. |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Gabor Greif | a3de9e4 | 2008-05-27 17:26:02 +0000 | [diff] [blame] | 14 | #include "llvm/BasicBlock.h" |
Chris Lattner | 9daef35 | 2005-04-12 18:52:14 +0000 | [diff] [blame] | 15 | #include "llvm/Constants.h" |
Misha Brukman | 2d3fa9e | 2004-07-29 16:53:53 +0000 | [diff] [blame] | 16 | #include "llvm/Instructions.h" |
Owen Anderson | 155dccd8 | 2009-07-07 23:43:39 +0000 | [diff] [blame] | 17 | #include "llvm/LLVMContext.h" |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 18 | #include "llvm/Type.h" |
Dan Gohman | 804c95d | 2008-07-28 21:51:04 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/STLExtras.h" |
Chris Lattner | 83d485b | 2002-02-12 22:39:50 +0000 | [diff] [blame] | 20 | #include "llvm/Support/CFG.h" |
Reid Spencer | 7c16caa | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 21 | #include "llvm/Support/LeakDetector.h" |
Chris Lattner | 3d27be1 | 2006-08-27 12:54:02 +0000 | [diff] [blame] | 22 | #include "llvm/Support/Compiler.h" |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 23 | #include "SymbolTableListTraitsImpl.h" |
| 24 | #include <algorithm> |
Chris Lattner | a296000 | 2003-11-21 16:52:05 +0000 | [diff] [blame] | 25 | using namespace llvm; |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 26 | |
Gabor Greif | 51bbcf8 | 2009-03-07 12:33:24 +0000 | [diff] [blame] | 27 | ValueSymbolTable *BasicBlock::getValueSymbolTable() { |
| 28 | if (Function *F = getParent()) |
| 29 | return &F->getValueSymbolTable(); |
Chris Lattner | b47aa54 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 30 | return 0; |
| 31 | } |
| 32 | |
Owen Anderson | 47db941 | 2009-07-22 00:24:57 +0000 | [diff] [blame] | 33 | LLVMContext &BasicBlock::getContext() const { |
| 34 | return getType()->getContext(); |
Owen Anderson | e70b637 | 2009-07-05 22:41:43 +0000 | [diff] [blame] | 35 | } |
| 36 | |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 37 | // Explicit instantiation of SymbolTableListTraits since some of the methods |
| 38 | // are not in the public header file... |
Chris Lattner | b47aa54 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 39 | template class SymbolTableListTraits<Instruction, BasicBlock>; |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 40 | |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 41 | |
Daniel Dunbar | 4975db6 | 2009-07-25 04:41:11 +0000 | [diff] [blame^] | 42 | BasicBlock::BasicBlock(const Twine &Name, Function *NewParent, |
Nick Lewycky | 4d43d3c | 2008-04-25 16:53:59 +0000 | [diff] [blame] | 43 | BasicBlock *InsertBefore) |
| 44 | : Value(Type::LabelTy, Value::BasicBlockVal), Parent(0) { |
Chris Lattner | 4dfede8 | 2002-09-26 05:03:22 +0000 | [diff] [blame] | 45 | |
| 46 | // Make sure that we get added to a function |
| 47 | LeakDetector::addGarbageObject(this); |
| 48 | |
| 49 | if (InsertBefore) { |
Chris Lattner | b47aa54 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 50 | assert(NewParent && |
Chris Lattner | bb5f0db | 2004-02-04 03:57:50 +0000 | [diff] [blame] | 51 | "Cannot insert block before another block with no function!"); |
Chris Lattner | b47aa54 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 52 | NewParent->getBasicBlockList().insert(InsertBefore, this); |
| 53 | } else if (NewParent) { |
| 54 | NewParent->getBasicBlockList().push_back(this); |
Chris Lattner | 4dfede8 | 2002-09-26 05:03:22 +0000 | [diff] [blame] | 55 | } |
Chris Lattner | 32ab643 | 2007-02-12 05:18:08 +0000 | [diff] [blame] | 56 | |
| 57 | setName(Name); |
Chris Lattner | 4dfede8 | 2002-09-26 05:03:22 +0000 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | |
Gordon Henriksen | 14a5569 | 2007-12-10 02:14:30 +0000 | [diff] [blame] | 61 | BasicBlock::~BasicBlock() { |
| 62 | assert(getParent() == 0 && "BasicBlock still linked into the program!"); |
| 63 | dropAllReferences(); |
| 64 | InstList.clear(); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 65 | } |
| 66 | |
Chris Lattner | 9ed7aef | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 67 | void BasicBlock::setParent(Function *parent) { |
Chris Lattner | 184b298 | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 68 | if (getParent()) |
| 69 | LeakDetector::addGarbageObject(this); |
| 70 | |
Chris Lattner | b47aa54 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 71 | // Set Parent=parent, updating instruction symtab entries as appropriate. |
| 72 | InstList.setSymTabObject(&Parent, parent); |
Chris Lattner | 184b298 | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 73 | |
| 74 | if (getParent()) |
| 75 | LeakDetector::removeGarbageObject(this); |
Chris Lattner | 9ed7aef | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 76 | } |
| 77 | |
Chris Lattner | 02a71e7 | 2004-10-11 22:21:39 +0000 | [diff] [blame] | 78 | void BasicBlock::removeFromParent() { |
| 79 | getParent()->getBasicBlockList().remove(this); |
| 80 | } |
| 81 | |
| 82 | void BasicBlock::eraseFromParent() { |
| 83 | getParent()->getBasicBlockList().erase(this); |
| 84 | } |
| 85 | |
Chris Lattner | 4091f46 | 2006-09-23 04:03:45 +0000 | [diff] [blame] | 86 | /// moveBefore - Unlink this basic block from its current function and |
| 87 | /// insert it into the function that MovePos lives in, right before MovePos. |
Chris Lattner | e09bbc8 | 2005-08-12 22:14:06 +0000 | [diff] [blame] | 88 | void BasicBlock::moveBefore(BasicBlock *MovePos) { |
| 89 | MovePos->getParent()->getBasicBlockList().splice(MovePos, |
| 90 | getParent()->getBasicBlockList(), this); |
| 91 | } |
| 92 | |
Chris Lattner | 4091f46 | 2006-09-23 04:03:45 +0000 | [diff] [blame] | 93 | /// moveAfter - Unlink this basic block from its current function and |
| 94 | /// insert it into the function that MovePos lives in, right after MovePos. |
| 95 | void BasicBlock::moveAfter(BasicBlock *MovePos) { |
| 96 | Function::iterator I = MovePos; |
| 97 | MovePos->getParent()->getBasicBlockList().splice(++I, |
| 98 | getParent()->getBasicBlockList(), this); |
| 99 | } |
| 100 | |
Chris Lattner | 02a71e7 | 2004-10-11 22:21:39 +0000 | [diff] [blame] | 101 | |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 102 | TerminatorInst *BasicBlock::getTerminator() { |
| 103 | if (InstList.empty()) return 0; |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 104 | return dyn_cast<TerminatorInst>(&InstList.back()); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 105 | } |
| 106 | |
Dan Gohman | aad83c8 | 2007-11-19 20:46:23 +0000 | [diff] [blame] | 107 | const TerminatorInst *BasicBlock::getTerminator() const { |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 108 | if (InstList.empty()) return 0; |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 109 | return dyn_cast<TerminatorInst>(&InstList.back()); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 110 | } |
| 111 | |
Dan Gohman | f96e137 | 2008-05-23 21:05:58 +0000 | [diff] [blame] | 112 | Instruction* BasicBlock::getFirstNonPHI() { |
| 113 | BasicBlock::iterator i = begin(); |
| 114 | // All valid basic blocks should have a terminator, |
| 115 | // which is not a PHINode. If we have an invalid basic |
| 116 | // block we'll get an assertion failure when dereferencing |
| 117 | // a past-the-end iterator. |
| 118 | while (isa<PHINode>(i)) ++i; |
| 119 | return &*i; |
Vladimir Prus | b5b6dc4 | 2006-06-08 15:46:18 +0000 | [diff] [blame] | 120 | } |
| 121 | |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 122 | void BasicBlock::dropAllReferences() { |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 123 | for(iterator I = begin(), E = end(); I != E; ++I) |
| 124 | I->dropAllReferences(); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 125 | } |
| 126 | |
Chris Lattner | ce046ac | 2005-02-24 02:37:26 +0000 | [diff] [blame] | 127 | /// getSinglePredecessor - If this basic block has a single predecessor block, |
| 128 | /// return the block, otherwise return a null pointer. |
| 129 | BasicBlock *BasicBlock::getSinglePredecessor() { |
| 130 | pred_iterator PI = pred_begin(this), E = pred_end(this); |
| 131 | if (PI == E) return 0; // No preds. |
| 132 | BasicBlock *ThePred = *PI; |
| 133 | ++PI; |
| 134 | return (PI == E) ? ThePred : 0 /*multiple preds*/; |
| 135 | } |
| 136 | |
Torok Edwin | c808012 | 2008-12-11 10:36:07 +0000 | [diff] [blame] | 137 | /// getUniquePredecessor - If this basic block has a unique predecessor block, |
| 138 | /// return the block, otherwise return a null pointer. |
| 139 | /// Note that unique predecessor doesn't mean single edge, there can be |
Torok Edwin | 32bfb5d | 2008-12-11 11:44:49 +0000 | [diff] [blame] | 140 | /// multiple edges from the unique predecessor to this block (for example |
| 141 | /// a switch statement with multiple cases having the same destination). |
Torok Edwin | c808012 | 2008-12-11 10:36:07 +0000 | [diff] [blame] | 142 | BasicBlock *BasicBlock::getUniquePredecessor() { |
| 143 | pred_iterator PI = pred_begin(this), E = pred_end(this); |
| 144 | if (PI == E) return 0; // No preds. |
| 145 | BasicBlock *PredBB = *PI; |
| 146 | ++PI; |
| 147 | for (;PI != E; ++PI) { |
| 148 | if (*PI != PredBB) |
| 149 | return 0; |
Torok Edwin | 32bfb5d | 2008-12-11 11:44:49 +0000 | [diff] [blame] | 150 | // The same predecessor appears multiple times in the predecessor list. |
| 151 | // This is OK. |
Torok Edwin | c808012 | 2008-12-11 10:36:07 +0000 | [diff] [blame] | 152 | } |
| 153 | return PredBB; |
| 154 | } |
| 155 | |
Chris Lattner | 954c64d | 2005-04-21 16:06:03 +0000 | [diff] [blame] | 156 | /// removePredecessor - This method is used to notify a BasicBlock that the |
| 157 | /// specified Predecessor of the block is no longer able to reach it. This is |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 158 | /// actually not used to update the Predecessor list, but is actually used to |
Chris Lattner | 954c64d | 2005-04-21 16:06:03 +0000 | [diff] [blame] | 159 | /// update the PHI nodes that reside in the block. Note that this should be |
| 160 | /// called while the predecessor still refers to this block. |
| 161 | /// |
Chris Lattner | 9daef35 | 2005-04-12 18:52:14 +0000 | [diff] [blame] | 162 | void BasicBlock::removePredecessor(BasicBlock *Pred, |
Nick Lewycky | 4d43d3c | 2008-04-25 16:53:59 +0000 | [diff] [blame] | 163 | bool DontDeleteUselessPHIs) { |
Chris Lattner | 25169ca | 2005-02-23 16:53:04 +0000 | [diff] [blame] | 164 | assert((hasNUsesOrMore(16)||// Reduce cost of this assertion for complex CFGs. |
Chris Lattner | cf08c21 | 2005-02-23 07:09:08 +0000 | [diff] [blame] | 165 | find(pred_begin(this), pred_end(this), Pred) != pred_end(this)) && |
Jeff Cohen | 8263985 | 2005-04-23 21:38:35 +0000 | [diff] [blame] | 166 | "removePredecessor: BB is not a predecessor!"); |
Chris Lattner | cf08c21 | 2005-02-23 07:09:08 +0000 | [diff] [blame] | 167 | |
Chris Lattner | 8d0b1b2 | 2004-12-11 22:10:29 +0000 | [diff] [blame] | 168 | if (InstList.empty()) return; |
Chris Lattner | bea7247 | 2004-07-06 17:44:17 +0000 | [diff] [blame] | 169 | PHINode *APN = dyn_cast<PHINode>(&front()); |
| 170 | if (!APN) return; // Quick exit. |
Chris Lattner | 615d3cf | 2001-06-29 05:25:23 +0000 | [diff] [blame] | 171 | |
| 172 | // If there are exactly two predecessors, then we want to nuke the PHI nodes |
Chris Lattner | bea7247 | 2004-07-06 17:44:17 +0000 | [diff] [blame] | 173 | // altogether. However, we cannot do this, if this in this case: |
Chris Lattner | f7373e4 | 2002-05-21 19:52:49 +0000 | [diff] [blame] | 174 | // |
| 175 | // Loop: |
| 176 | // %x = phi [X, Loop] |
| 177 | // %x2 = add %x, 1 ;; This would become %x2 = add %x2, 1 |
| 178 | // br Loop ;; %x2 does not dominate all uses |
| 179 | // |
| 180 | // This is because the PHI node input is actually taken from the predecessor |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 181 | // basic block. The only case this can happen is with a self loop, so we |
Chris Lattner | f7373e4 | 2002-05-21 19:52:49 +0000 | [diff] [blame] | 182 | // check for this case explicitly now. |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 183 | // |
Chris Lattner | bea7247 | 2004-07-06 17:44:17 +0000 | [diff] [blame] | 184 | unsigned max_idx = APN->getNumIncomingValues(); |
Chris Lattner | 615d3cf | 2001-06-29 05:25:23 +0000 | [diff] [blame] | 185 | assert(max_idx != 0 && "PHI Node in block with 0 predecessors!?!?!"); |
Chris Lattner | f7373e4 | 2002-05-21 19:52:49 +0000 | [diff] [blame] | 186 | if (max_idx == 2) { |
Chris Lattner | bea7247 | 2004-07-06 17:44:17 +0000 | [diff] [blame] | 187 | BasicBlock *Other = APN->getIncomingBlock(APN->getIncomingBlock(0) == Pred); |
Chris Lattner | f7373e4 | 2002-05-21 19:52:49 +0000 | [diff] [blame] | 188 | |
| 189 | // Disable PHI elimination! |
| 190 | if (this == Other) max_idx = 3; |
| 191 | } |
| 192 | |
Chris Lattner | 9daef35 | 2005-04-12 18:52:14 +0000 | [diff] [blame] | 193 | // <= Two predecessors BEFORE I remove one? |
| 194 | if (max_idx <= 2 && !DontDeleteUselessPHIs) { |
Chris Lattner | da55810 | 2001-10-02 03:41:24 +0000 | [diff] [blame] | 195 | // Yup, loop through and nuke the PHI nodes |
Chris Lattner | 113f4f4 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 196 | while (PHINode *PN = dyn_cast<PHINode>(&front())) { |
Chris Lattner | 9daef35 | 2005-04-12 18:52:14 +0000 | [diff] [blame] | 197 | // Remove the predecessor first. |
Nick Lewycky | 4d43d3c | 2008-04-25 16:53:59 +0000 | [diff] [blame] | 198 | PN->removeIncomingValue(Pred, !DontDeleteUselessPHIs); |
Chris Lattner | 615d3cf | 2001-06-29 05:25:23 +0000 | [diff] [blame] | 199 | |
| 200 | // If the PHI _HAD_ two uses, replace PHI node with its now *single* value |
Chris Lattner | caf5b50 | 2002-10-08 21:36:34 +0000 | [diff] [blame] | 201 | if (max_idx == 2) { |
Chris Lattner | ef8c833 | 2003-04-25 23:14:19 +0000 | [diff] [blame] | 202 | if (PN->getOperand(0) != PN) |
| 203 | PN->replaceAllUsesWith(PN->getOperand(0)); |
| 204 | else |
| 205 | // We are left with an infinite loop with no entries: kill the PHI. |
Owen Anderson | 47db941 | 2009-07-22 00:24:57 +0000 | [diff] [blame] | 206 | PN->replaceAllUsesWith(getContext().getUndef(PN->getType())); |
Chris Lattner | caf5b50 | 2002-10-08 21:36:34 +0000 | [diff] [blame] | 207 | getInstList().pop_front(); // Remove the PHI node |
| 208 | } |
| 209 | |
| 210 | // If the PHI node already only had one entry, it got deleted by |
| 211 | // removeIncomingValue. |
Chris Lattner | 615d3cf | 2001-06-29 05:25:23 +0000 | [diff] [blame] | 212 | } |
| 213 | } else { |
| 214 | // Okay, now we know that we need to remove predecessor #pred_idx from all |
| 215 | // PHI nodes. Iterate over each PHI node fixing them up |
Chris Lattner | 708ee9d | 2004-06-05 00:11:27 +0000 | [diff] [blame] | 216 | PHINode *PN; |
Chris Lattner | 1749aaa | 2005-08-05 15:34:10 +0000 | [diff] [blame] | 217 | for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ) { |
| 218 | ++II; |
Nick Lewycky | 4d43d3c | 2008-04-25 16:53:59 +0000 | [diff] [blame] | 219 | PN->removeIncomingValue(Pred, false); |
Nate Begeman | b392321 | 2005-08-04 23:24:19 +0000 | [diff] [blame] | 220 | // If all incoming values to the Phi are the same, we can replace the Phi |
| 221 | // with that value. |
Owen Anderson | 4e744af | 2006-06-14 04:43:14 +0000 | [diff] [blame] | 222 | Value* PNV = 0; |
| 223 | if (!DontDeleteUselessPHIs && (PNV = PN->hasConstantValue())) { |
Chris Lattner | 6f58350 | 2005-08-05 01:02:04 +0000 | [diff] [blame] | 224 | PN->replaceAllUsesWith(PNV); |
| 225 | PN->eraseFromParent(); |
| 226 | } |
Nate Begeman | b392321 | 2005-08-04 23:24:19 +0000 | [diff] [blame] | 227 | } |
Chris Lattner | 615d3cf | 2001-06-29 05:25:23 +0000 | [diff] [blame] | 228 | } |
| 229 | } |
| 230 | |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 231 | |
Chris Lattner | 7ceb081 | 2005-04-21 16:04:49 +0000 | [diff] [blame] | 232 | /// splitBasicBlock - This splits a basic block into two at the specified |
| 233 | /// instruction. Note that all instructions BEFORE the specified iterator stay |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 234 | /// as part of the original basic block, an unconditional branch is added to |
Chris Lattner | 7ceb081 | 2005-04-21 16:04:49 +0000 | [diff] [blame] | 235 | /// the new BB, and the rest of the instructions in the BB are moved to the new |
| 236 | /// BB, including the old terminator. This invalidates the iterator. |
| 237 | /// |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 238 | /// Note that this only works on well formed basic blocks (must have a |
Chris Lattner | 7ceb081 | 2005-04-21 16:04:49 +0000 | [diff] [blame] | 239 | /// terminator), and 'I' must not be the end of instruction list (which would |
| 240 | /// cause a degenerate basic block to be formed, having a terminator inside of |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 241 | /// the basic block). |
Chris Lattner | 7ceb081 | 2005-04-21 16:04:49 +0000 | [diff] [blame] | 242 | /// |
Daniel Dunbar | 4975db6 | 2009-07-25 04:41:11 +0000 | [diff] [blame^] | 243 | BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName) { |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 244 | assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!"); |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 245 | assert(I != InstList.end() && |
Jeff Cohen | 8263985 | 2005-04-23 21:38:35 +0000 | [diff] [blame] | 246 | "Trying to get me to create degenerate basic block!"); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 247 | |
Dan Gohman | 804c95d | 2008-07-28 21:51:04 +0000 | [diff] [blame] | 248 | BasicBlock *InsertBefore = next(Function::iterator(this)) |
| 249 | .getNodePtrUnchecked(); |
| 250 | BasicBlock *New = BasicBlock::Create(BBName, getParent(), InsertBefore); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 251 | |
Chris Lattner | c4c7ea5 | 2004-02-03 23:11:21 +0000 | [diff] [blame] | 252 | // Move all of the specified instructions from the original basic block into |
| 253 | // the new basic block. |
| 254 | New->getInstList().splice(New->end(), this->getInstList(), I, end()); |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 255 | |
| 256 | // Add a branch instruction to the newly formed basic block. |
Gabor Greif | e9ecc68 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 257 | BranchInst::Create(New, this); |
Chris Lattner | 4eed0b8 | 2002-02-25 00:35:07 +0000 | [diff] [blame] | 258 | |
| 259 | // Now we must loop through all of the successors of the New block (which |
| 260 | // _were_ the successors of the 'this' block), and update any PHI nodes in |
| 261 | // successors. If there were PHI nodes in the successors, then they need to |
| 262 | // know that incoming branches will be from New, not from Old. |
| 263 | // |
Chris Lattner | 64d88bc | 2003-09-24 22:03:22 +0000 | [diff] [blame] | 264 | for (succ_iterator I = succ_begin(New), E = succ_end(New); I != E; ++I) { |
Chris Lattner | 4eed0b8 | 2002-02-25 00:35:07 +0000 | [diff] [blame] | 265 | // Loop over any phi nodes in the basic block, updating the BB field of |
| 266 | // incoming values... |
| 267 | BasicBlock *Successor = *I; |
Chris Lattner | 708ee9d | 2004-06-05 00:11:27 +0000 | [diff] [blame] | 268 | PHINode *PN; |
Chris Lattner | 4eed0b8 | 2002-02-25 00:35:07 +0000 | [diff] [blame] | 269 | for (BasicBlock::iterator II = Successor->begin(); |
Chris Lattner | 08d1b9d | 2004-06-05 17:43:52 +0000 | [diff] [blame] | 270 | (PN = dyn_cast<PHINode>(II)); ++II) { |
Chris Lattner | 4eed0b8 | 2002-02-25 00:35:07 +0000 | [diff] [blame] | 271 | int IDX = PN->getBasicBlockIndex(this); |
| 272 | while (IDX != -1) { |
| 273 | PN->setIncomingBlock((unsigned)IDX, New); |
| 274 | IDX = PN->getBasicBlockIndex(this); |
| 275 | } |
| 276 | } |
| 277 | } |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 278 | return New; |
| 279 | } |