Re-commit my previous SSAUpdater changes. The previous version naively tried

[oota-llvm.git] / lib / Transforms / Utils / UnifyFunctionExitNodes.cpp

diff --git a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
index 977616378d04bf80874350f2c3923775fb5a5fc5..3fa8b70a8505a37e962f7e28d11e8d1b3f852035 100644 (file)
--- a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
+++ b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
@@ -1,10 +1,10 @@
 //===- UnifyFunctionExitNodes.cpp - Make all functions have a single exit -===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
 //===----------------------------------------------------------------------===//
 //
 // This pass is used to ensure that functions have at most one return
@@ -20,9 +20,11 @@
 #include "llvm/Function.h"
 #include "llvm/Instructions.h"
 #include "llvm/Type.h"
+#include "llvm/ADT/StringExtras.h"
 using namespace llvm;
 
-static RegisterOpt<UnifyFunctionExitNodes>
+char UnifyFunctionExitNodes::ID = 0;
+static RegisterPass<UnifyFunctionExitNodes>
 X("mergereturn", "Unify function exit nodes");
 
 Pass *llvm::createUnifyFunctionExitNodesPass() {
@@ -32,6 +34,9 @@ Pass *llvm::createUnifyFunctionExitNodesPass() {
 void UnifyFunctionExitNodes::getAnalysisUsage(AnalysisUsage &AU) const{
   // We preserve the non-critical-edgeness property
   AU.addPreservedID(BreakCriticalEdgesID);
+  // This is a cluster of orthogonal Transforms
+  AU.addPreservedID(PromoteMemoryToRegisterID);
+  AU.addPreservedID(LowerSwitchID);
 }
 
 // UnifyAllExitNodes - Unify all exit nodes of the CFG by creating a new
@@ -61,14 +66,14 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
   } else if (UnwindingBlocks.size() == 1) {
     UnwindBlock = UnwindingBlocks.front();
   } else {
-    UnwindBlock = new BasicBlock("UnifiedUnwindBlock", &F);
-    new UnwindInst(UnwindBlock);
+    UnwindBlock = BasicBlock::Create(F.getContext(), "UnifiedUnwindBlock", &F);
+    new UnwindInst(F.getContext(), UnwindBlock);
 
-    for (std::vector<BasicBlock*>::iterator I = UnwindingBlocks.begin(), 
+    for (std::vector<BasicBlock*>::iterator I = UnwindingBlocks.begin(),
            E = UnwindingBlocks.end(); I != E; ++I) {
       BasicBlock *BB = *I;
       BB->getInstList().pop_back();  // Remove the unwind insn
-      new BranchInst(UnwindBlock, BB);
+      BranchInst::Create(UnwindBlock, BB);
     }
   }
 
@@ -78,14 +83,15 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
   } else if (UnreachableBlocks.size() == 1) {
     UnreachableBlock = UnreachableBlocks.front();
   } else {
-    UnreachableBlock = new BasicBlock("UnifiedUnreachableBlock", &F);
-    new UnreachableInst(UnreachableBlock);
+    UnreachableBlock = BasicBlock::Create(F.getContext(), 
+                                          "UnifiedUnreachableBlock", &F);
+    new UnreachableInst(F.getContext(), UnreachableBlock);
 
-    for (std::vector<BasicBlock*>::iterator I = UnreachableBlocks.begin(), 
+    for (std::vector<BasicBlock*>::iterator I = UnreachableBlocks.begin(),
            E = UnreachableBlocks.end(); I != E; ++I) {
       BasicBlock *BB = *I;
       BB->getInstList().pop_back();  // Remove the unreachable inst.
-      new BranchInst(UnreachableBlock, BB);
+      BranchInst::Create(UnreachableBlock, BB);
     }
   }
 
@@ -99,32 +105,36 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
   }
 
   // Otherwise, we need to insert a new basic block into the function, add a PHI
-  // node (if the function returns a value), and convert all of the return 
+  // nodes (if the function returns values), and convert all of the return
   // instructions into unconditional branches.
   //
-  BasicBlock *NewRetBlock = new BasicBlock("UnifiedReturnBlock", &F);
+  BasicBlock *NewRetBlock = BasicBlock::Create(F.getContext(),
+                                               "UnifiedReturnBlock", &F);
 
   PHINode *PN = 0;
-  if (F.getReturnType() != Type::VoidTy) {
+  if (F.getReturnType()->isVoidTy()) {
+    ReturnInst::Create(F.getContext(), NULL, NewRetBlock);
+  } else {
     // If the function doesn't return void... add a PHI node to the block...
-    PN = new PHINode(F.getReturnType(), "UnifiedRetVal");
+    PN = PHINode::Create(F.getReturnType(), "UnifiedRetVal");
     NewRetBlock->getInstList().push_back(PN);
+    ReturnInst::Create(F.getContext(), PN, NewRetBlock);
   }
-  new ReturnInst(PN, NewRetBlock);
 
   // Loop over all of the blocks, replacing the return instruction with an
   // unconditional branch.
   //
-  for (std::vector<BasicBlock*>::iterator I = ReturningBlocks.begin(), 
+  for (std::vector<BasicBlock*>::iterator I = ReturningBlocks.begin(),
          E = ReturningBlocks.end(); I != E; ++I) {
     BasicBlock *BB = *I;
 
     // Add an incoming element to the PHI node for every return instruction that
     // is merging into this new block...
-    if (PN) PN->addIncoming(BB->getTerminator()->getOperand(0), BB);
+    if (PN)
+      PN->addIncoming(BB->getTerminator()->getOperand(0), BB);
 
     BB->getInstList().pop_back();  // Remove the return insn
-    new BranchInst(NewRetBlock, BB);
+    BranchInst::Create(NewRetBlock, BB);
   }
   ReturnBlock = NewRetBlock;
   return true;