UnifyFunctionExitNodes.cpp revision 208954 
1//===- UnifyFunctionExitNodes.cpp - Make all functions have a single exit -===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This pass is used to ensure that functions have at most one return
11// instruction in them.  Additionally, it keeps track of which node is the new
12// exit node of the CFG.  If there are no exit nodes in the CFG, the getExitNode
13// method will return a null pointer.
14//
15//===----------------------------------------------------------------------===//
16
17#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
18#include "llvm/Transforms/Scalar.h"
19#include "llvm/BasicBlock.h"
20#include "llvm/Function.h"
21#include "llvm/Instructions.h"
22#include "llvm/Type.h"
23#include "llvm/ADT/StringExtras.h"
24using namespace llvm;
25
26char UnifyFunctionExitNodes::ID = 0;
27static RegisterPass<UnifyFunctionExitNodes>
28X("mergereturn", "Unify function exit nodes");
29
30Pass *llvm::createUnifyFunctionExitNodesPass() {
31  return new UnifyFunctionExitNodes();
32}
33
34void UnifyFunctionExitNodes::getAnalysisUsage(AnalysisUsage &AU) const{
35  // We preserve the non-critical-edgeness property
36  AU.addPreservedID(BreakCriticalEdgesID);
37  // This is a cluster of orthogonal Transforms
38  AU.addPreservedID(PromoteMemoryToRegisterID);
39  AU.addPreservedID(LowerSwitchID);
40}
41
42// UnifyAllExitNodes - Unify all exit nodes of the CFG by creating a new
43// BasicBlock, and converting all returns to unconditional branches to this
44// new basic block.  The singular exit node is returned.
45//
46// If there are no return stmts in the Function, a null pointer is returned.
47//
48bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
49  // Loop over all of the blocks in a function, tracking all of the blocks that
50  // return.
51  //
52  std::vector<BasicBlock*> ReturningBlocks;
53  std::vector<BasicBlock*> UnwindingBlocks;
54  std::vector<BasicBlock*> UnreachableBlocks;
55  for(Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
56    if (isa<ReturnInst>(I->getTerminator()))
57      ReturningBlocks.push_back(I);
58    else if (isa<UnwindInst>(I->getTerminator()))
59      UnwindingBlocks.push_back(I);
60    else if (isa<UnreachableInst>(I->getTerminator()))
61      UnreachableBlocks.push_back(I);
62
63  // Handle unwinding blocks first.
64  if (UnwindingBlocks.empty()) {
65    UnwindBlock = 0;
66  } else if (UnwindingBlocks.size() == 1) {
67    UnwindBlock = UnwindingBlocks.front();
68  } else {
69    UnwindBlock = BasicBlock::Create(F.getContext(), "UnifiedUnwindBlock", &F);
70    new UnwindInst(F.getContext(), UnwindBlock);
71
72    for (std::vector<BasicBlock*>::iterator I = UnwindingBlocks.begin(),
73           E = UnwindingBlocks.end(); I != E; ++I) {
74      BasicBlock *BB = *I;
75      BB->getInstList().pop_back();  // Remove the unwind insn
76      BranchInst::Create(UnwindBlock, BB);
77    }
78  }
79
80  // Then unreachable blocks.
81  if (UnreachableBlocks.empty()) {
82    UnreachableBlock = 0;
83  } else if (UnreachableBlocks.size() == 1) {
84    UnreachableBlock = UnreachableBlocks.front();
85  } else {
86    UnreachableBlock = BasicBlock::Create(F.getContext(),
87                                          "UnifiedUnreachableBlock", &F);
88    new UnreachableInst(F.getContext(), UnreachableBlock);
89
90    for (std::vector<BasicBlock*>::iterator I = UnreachableBlocks.begin(),
91           E = UnreachableBlocks.end(); I != E; ++I) {
92      BasicBlock *BB = *I;
93      BB->getInstList().pop_back();  // Remove the unreachable inst.
94      BranchInst::Create(UnreachableBlock, BB);
95    }
96  }
97
98  // Now handle return blocks.
99  if (ReturningBlocks.empty()) {
100    ReturnBlock = 0;
101    return false;                          // No blocks return
102  } else if (ReturningBlocks.size() == 1) {
103    ReturnBlock = ReturningBlocks.front(); // Already has a single return block
104    return false;
105  }
106
107  // Otherwise, we need to insert a new basic block into the function, add a PHI
108  // nodes (if the function returns values), and convert all of the return
109  // instructions into unconditional branches.
110  //
111  BasicBlock *NewRetBlock = BasicBlock::Create(F.getContext(),
112                                               "UnifiedReturnBlock", &F);
113
114  PHINode *PN = 0;
115  if (F.getReturnType()->isVoidTy()) {
116    ReturnInst::Create(F.getContext(), NULL, NewRetBlock);
117  } else {
118    // If the function doesn't return void... add a PHI node to the block...
119    PN = PHINode::Create(F.getReturnType(), "UnifiedRetVal");
120    NewRetBlock->getInstList().push_back(PN);
121    ReturnInst::Create(F.getContext(), PN, NewRetBlock);
122  }
123
124  // Loop over all of the blocks, replacing the return instruction with an
125  // unconditional branch.
126  //
127  for (std::vector<BasicBlock*>::iterator I = ReturningBlocks.begin(),
128         E = ReturningBlocks.end(); I != E; ++I) {
129    BasicBlock *BB = *I;
130
131    // Add an incoming element to the PHI node for every return instruction that
132    // is merging into this new block...
133    if (PN)
134      PN->addIncoming(BB->getTerminator()->getOperand(0), BB);
135
136    BB->getInstList().pop_back();  // Remove the return insn
137    BranchInst::Create(NewRetBlock, BB);
138  }
139  ReturnBlock = NewRetBlock;
140  return true;
141}
142