BasicBlockUtils.cpp revision 0f67dd6237eb7227aa58e9b77cd95f354989b891
1//===-- BasicBlockUtils.cpp - BasicBlock Utilities -------------------------==// 2// 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. 7// 8//===----------------------------------------------------------------------===// 9// 10// This family of functions perform manipulations on basic blocks, and 11// instructions contained within basic blocks. 12// 13//===----------------------------------------------------------------------===// 14 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" 20#include <algorithm> 21using namespace llvm; 22 23/// ReplaceInstWithValue - Replace all uses of an instruction (specified by BI) 24/// with a value, then remove and delete the original instruction. 25/// 26void llvm::ReplaceInstWithValue(BasicBlock::InstListType &BIL, 27 BasicBlock::iterator &BI, Value *V) { 28 Instruction &I = *BI; 29 // Replaces all of the uses of the instruction with uses of the value 30 I.replaceAllUsesWith(V); 31 32 std::string OldName = I.getName(); 33 34 // Delete the unnecessary instruction now... 35 BI = BIL.erase(BI); 36 37 // Make sure to propagate a name if there is one already. 38 if (!OldName.empty() && !V->hasName()) 39 V->setName(OldName); 40} 41 42 43/// ReplaceInstWithInst - Replace the instruction specified by BI with the 44/// instruction specified by I. The original instruction is deleted and BI is 45/// updated to point to the new instruction. 46/// 47void llvm::ReplaceInstWithInst(BasicBlock::InstListType &BIL, 48 BasicBlock::iterator &BI, Instruction *I) { 49 assert(I->getParent() == 0 && 50 "ReplaceInstWithInst: Instruction already inserted into basic block!"); 51 52 // Insert the new instruction into the basic block... 53 BasicBlock::iterator New = BIL.insert(BI, I); 54 55 // Replace all uses of the old instruction, and delete it. 56 ReplaceInstWithValue(BIL, BI, I); 57 58 // Move BI back to point to the newly inserted instruction 59 BI = New; 60} 61 62/// ReplaceInstWithInst - Replace the instruction specified by From with the 63/// instruction specified by To. 64/// 65void llvm::ReplaceInstWithInst(Instruction *From, Instruction *To) { 66 BasicBlock::iterator BI(From); 67 ReplaceInstWithInst(From->getParent()->getInstList(), BI, To); 68} 69 70/// RemoveSuccessor - Change the specified terminator instruction such that its 71/// successor #SuccNum no longer exists. Because this reduces the outgoing 72/// degree of the current basic block, the actual terminator instruction itself 73/// may have to be changed. In the case where the last successor of the block is 74/// deleted, a return instruction is inserted in its place which can cause a 75/// surprising change in program behavior if it is not expected. 76/// 77void llvm::RemoveSuccessor(TerminatorInst *TI, unsigned SuccNum) { 78 assert(SuccNum < TI->getNumSuccessors() && 79 "Trying to remove a nonexistant successor!"); 80 81 // If our old successor block contains any PHI nodes, remove the entry in the 82 // PHI nodes that comes from this branch... 83 // 84 BasicBlock *BB = TI->getParent(); 85 TI->getSuccessor(SuccNum)->removePredecessor(BB); 86 87 TerminatorInst *NewTI = 0; 88 switch (TI->getOpcode()) { 89 case Instruction::Br: 90 // If this is a conditional branch... convert to unconditional branch. 91 if (TI->getNumSuccessors() == 2) { 92 cast<BranchInst>(TI)->setUnconditionalDest(TI->getSuccessor(1-SuccNum)); 93 } else { // Otherwise convert to a return instruction... 94 Value *RetVal = 0; 95 96 // Create a value to return... if the function doesn't return null... 97 if (BB->getParent()->getReturnType() != Type::VoidTy) 98 RetVal = Constant::getNullValue(BB->getParent()->getReturnType()); 99 100 // Create the return... 101 NewTI = new ReturnInst(RetVal); 102 } 103 break; 104 105 case Instruction::Invoke: // Should convert to call 106 case Instruction::Switch: // Should remove entry 107 default: 108 case Instruction::Ret: // Cannot happen, has no successors! 109 assert(0 && "Unhandled terminator instruction type in RemoveSuccessor!"); 110 abort(); 111 } 112 113 if (NewTI) // If it's a different instruction, replace. 114 ReplaceInstWithInst(TI, NewTI); 115} 116 117