Don't increment invalid iterator.

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

diff --git a/lib/Transforms/Utils/DemoteRegToStack.cpp b/lib/Transforms/Utils/DemoteRegToStack.cpp
index a92a066469ca1e461dfec460302d754ed45dece2..95b28f134651aedf3747b4d1ec2bb8486e5b1f68 100644 (file)
--- a/lib/Transforms/Utils/DemoteRegToStack.cpp
+++ b/lib/Transforms/Utils/DemoteRegToStack.cpp
@@ -1,12 +1,12 @@
 //===- DemoteRegToStack.cpp - Move a virtual register to the stack --------===//
-// 
+//
 //                     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 provide the function DemoteRegToStack().  This function takes a
 // virtual register computed by an Instruction and replaces it with a slot in
 // the stack frame, allocated via alloca. It returns the pointer to the
@@ -19,6 +19,7 @@
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Function.h"
 #include "llvm/Instructions.h"
+#include "llvm/Type.h"
 #include <map>
 using namespace llvm;
 
@@ -28,7 +29,7 @@ using namespace llvm;
 /// invalidating the SSA information for the value.  It returns the pointer to
 /// the alloca inserted to create a stack slot for I.
 ///
-AllocaInst* llvm::DemoteRegToStack(Instruction &I) {
+AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads) {
   if (I.use_empty()) return 0;                // nothing to do!
 
   // Create a stack slot to hold the value.
@@ -56,7 +57,7 @@ AllocaInst* llvm::DemoteRegToStack(Instruction &I) {
           Value *&V = Loads[PN->getIncomingBlock(i)];
           if (V == 0) {
             // Insert the load into the predecessor block
-            V = new LoadInst(Slot, I.getName()+".reload",
+            V = new LoadInst(Slot, I.getName()+".reload", VolatileLoads, 
                              PN->getIncomingBlock(i)->getTerminator());
           }
           PN->setIncomingValue(i, V);
@@ -64,7 +65,7 @@ AllocaInst* llvm::DemoteRegToStack(Instruction &I) {
 
     } else {
       // If this is a normal instruction, just insert a load.
-      Value *V = new LoadInst(Slot, I.getName()+".reload", U);
+      Value *V = new LoadInst(Slot, I.getName()+".reload", VolatileLoads, U);
       U->replaceUsesOfWith(&I, V);
     }
   }
@@ -73,18 +74,61 @@ AllocaInst* llvm::DemoteRegToStack(Instruction &I) {
   // Insert stores of the computed value into the stack slot.  We have to be
   // careful is I is an invoke instruction though, because we can't insert the
   // store AFTER the terminator instruction.
+  BasicBlock::iterator InsertPt;
   if (!isa<TerminatorInst>(I)) {
-    BasicBlock::iterator InsertPt = &I;
-    for (++InsertPt; isa<PHINode>(InsertPt); ++InsertPt)
-      /* empty */;   // Don't insert before any PHI nodes.
-    new StoreInst(&I, Slot, InsertPt);
+    InsertPt = &I;
+    ++InsertPt;
   } else {
-    // FIXME: We cannot yet demote invoke instructions to the stack, because
-    // doing so would require breaking critical edges.  This should be fixed
-    // eventually.
-    assert(0 &&
-           "Cannot demote the value computed by an invoke instruction yet!");
+    // We cannot demote invoke instructions to the stack if their normal edge
+    // is critical.
+    InvokeInst &II = cast<InvokeInst>(I);
+    assert(II.getNormalDest()->getSinglePredecessor() &&
+           "Cannot demote invoke with a critical successor!");
+    InsertPt = II.getNormalDest()->begin();
   }
 
+  for (; isa<PHINode>(InsertPt); ++InsertPt)
+  /* empty */;   // Don't insert before any PHI nodes.
+  new StoreInst(&I, Slot, InsertPt);
+
+  return Slot;
+}
+
+
+/// DemotePHIToStack - This function takes a virtual register computed by a phi
+/// node and replaces it with a slot in the stack frame, allocated via alloca.
+/// The phi node is deleted and it returns the pointer to the alloca inserted.
+AllocaInst* llvm::DemotePHIToStack(PHINode *P) {
+  if (P->use_empty()) {
+    P->eraseFromParent();    
+    return 0;                
+  }
+  
+  // Create a stack slot to hold the value.
+  Function *F = P->getParent()->getParent();
+  AllocaInst *Slot = new AllocaInst(P->getType(), 0, P->getName(),
+                                    F->getEntryBlock().begin());
+  
+  // Iterate over each operand, insert store in each predecessor.
+  for (unsigned i = 0, e = P->getNumIncomingValues(); i < e; ++i) {
+    if (InvokeInst *II = dyn_cast<InvokeInst>(P->getIncomingValue(i))) {
+      assert(II->getParent() != P->getIncomingBlock(i) && 
+             "Invoke edge not supported yet");
+    }
+    new StoreInst(P->getIncomingValue(i), Slot, 
+                  P->getIncomingBlock(i)->getTerminator());
+  }
+  
+  // Insert load in place of the phi and replace all uses.
+  BasicBlock::iterator InsertPt;
+  for (InsertPt = P->getParent()->getInstList().begin(); 
+       isa<PHINode>(InsertPt); ++InsertPt)
+    ; /*noop */
+  Value *V = new LoadInst(Slot, P->getName()+".reload", P);
+  P->replaceAllUsesWith(V);
+  
+  // Delete phi.
+  P->eraseFromParent();
+  
   return Slot;
 }