1 //===-- BasicBlockUtils.cpp - BasicBlock Utilities -------------------------==//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
10 // This family of functions perform manipulations on basic blocks, and
11 // instructions contained within basic blocks.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
16 #include "llvm/Function.h"
17 #include "llvm/Instructions.h"
18 #include "llvm/Constant.h"
19 #include "llvm/Type.h"
23 /// ReplaceInstWithValue - Replace all uses of an instruction (specified by BI)
24 /// with a value, then remove and delete the original instruction.
26 void llvm::ReplaceInstWithValue(BasicBlock::InstListType &BIL,
27 BasicBlock::iterator &BI, Value *V) {
29 // Replaces all of the uses of the instruction with uses of the value
30 I.replaceAllUsesWith(V);
32 // Make sure to propagate a name if there is one already.
33 if (I.hasName() && !V->hasName())
36 // Delete the unnecessary instruction now...
41 /// ReplaceInstWithInst - Replace the instruction specified by BI with the
42 /// instruction specified by I. The original instruction is deleted and BI is
43 /// updated to point to the new instruction.
45 void llvm::ReplaceInstWithInst(BasicBlock::InstListType &BIL,
46 BasicBlock::iterator &BI, Instruction *I) {
47 assert(I->getParent() == 0 &&
48 "ReplaceInstWithInst: Instruction already inserted into basic block!");
50 // Insert the new instruction into the basic block...
51 BasicBlock::iterator New = BIL.insert(BI, I);
53 // Replace all uses of the old instruction, and delete it.
54 ReplaceInstWithValue(BIL, BI, I);
56 // Move BI back to point to the newly inserted instruction
60 /// ReplaceInstWithInst - Replace the instruction specified by From with the
61 /// instruction specified by To.
63 void llvm::ReplaceInstWithInst(Instruction *From, Instruction *To) {
64 BasicBlock::iterator BI(From);
65 ReplaceInstWithInst(From->getParent()->getInstList(), BI, To);
68 /// RemoveSuccessor - Change the specified terminator instruction such that its
69 /// successor SuccNum no longer exists. Because this reduces the outgoing
70 /// degree of the current basic block, the actual terminator instruction itself
71 /// may have to be changed. In the case where the last successor of the block
72 /// is deleted, a return instruction is inserted in its place which can cause a
73 /// surprising change in program behavior if it is not expected.
75 void llvm::RemoveSuccessor(TerminatorInst *TI, unsigned SuccNum) {
76 assert(SuccNum < TI->getNumSuccessors() &&
77 "Trying to remove a nonexistant successor!");
79 // If our old successor block contains any PHI nodes, remove the entry in the
80 // PHI nodes that comes from this branch...
82 BasicBlock *BB = TI->getParent();
83 TI->getSuccessor(SuccNum)->removePredecessor(BB);
85 TerminatorInst *NewTI = 0;
86 switch (TI->getOpcode()) {
88 // If this is a conditional branch... convert to unconditional branch.
89 if (TI->getNumSuccessors() == 2) {
90 cast<BranchInst>(TI)->setUnconditionalDest(TI->getSuccessor(1-SuccNum));
91 } else { // Otherwise convert to a return instruction...
94 // Create a value to return... if the function doesn't return null...
95 if (BB->getParent()->getReturnType() != Type::VoidTy)
96 RetVal = Constant::getNullValue(BB->getParent()->getReturnType());
98 // Create the return...
99 NewTI = new ReturnInst(RetVal);
103 case Instruction::Invoke: // Should convert to call
104 case Instruction::Switch: // Should remove entry
106 case Instruction::Ret: // Cannot happen, has no successors!
107 assert(0 && "Unhandled terminator instruction type in RemoveSuccessor!");
111 if (NewTI) // If it's a different instruction, replace.
112 ReplaceInstWithInst(TI, NewTI);