BasicBlockUtils.cpp revision f7703df4968084c18c248c1feea9961c19a32e6a 
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/iTerminators.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.size() && !V->hasName())
39    V->setName(OldName, &BIL.getParent()->getSymbolTable());
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