lib/Transforms/Utils/BasicBlockUtils.cpp

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