diff --git a/lib/CodeGen/LiveIntervalAnalysis.cpp b/lib/CodeGen/LiveIntervalAnalysis.cpp
index c6dc2b92d44..8c28c97b0ac 100644
--- a/lib/CodeGen/LiveIntervalAnalysis.cpp
+++ b/lib/CodeGen/LiveIntervalAnalysis.cpp
@@ -272,9 +272,7 @@ addIntervalsForSpills(const LiveInterval &li, VirtRegMap &vrm, int slot) {
             if (lv_)
               lv_->instructionChanged(MI, fmi);
             MachineBasicBlock &MBB = *MI->getParent();
-            bool LiveOut = li.liveAt(getInstructionIndex(&MBB.back()) +
-                                     InstrSlots::NUM);
-            vrm.virtFolded(li.reg, MI, i, fmi, LiveOut);
+            vrm.virtFolded(li.reg, MI, i, fmi);
             mi2iMap_.erase(MI);
             i2miMap_[index/InstrSlots::NUM] = fmi;
             mi2iMap_[fmi] = index;
diff --git a/lib/CodeGen/VirtRegMap.cpp b/lib/CodeGen/VirtRegMap.cpp
index ae4f1fccc63..7523d73c2e6 100644
--- a/lib/CodeGen/VirtRegMap.cpp
+++ b/lib/CodeGen/VirtRegMap.cpp
@@ -81,8 +81,7 @@ void VirtRegMap::assignVirt2StackSlot(unsigned virtReg, int frameIndex) {
 }
 
 void VirtRegMap::virtFolded(unsigned VirtReg, MachineInstr *OldMI,
-                            unsigned OpNo, MachineInstr *NewMI,
-                            bool LiveOut) {
+                            unsigned OpNo, MachineInstr *NewMI) {
   // Move previous memory references folded to new instruction.
   MI2VirtMapTy::iterator IP = MI2VirtMap.lower_bound(NewMI);
   for (MI2VirtMapTy::iterator I = MI2VirtMap.lower_bound(OldMI),
@@ -97,7 +96,6 @@ void VirtRegMap::virtFolded(unsigned VirtReg, MachineInstr *OldMI,
     MRInfo = isRef;
   } else {
     MRInfo = OldMI->getOperand(OpNo).isUse() ? isModRef : isMod;
-    if (LiveOut) MRInfo = (ModRef)(MRInfo | isLiveOut);
   }
 
   // add new memory reference
@@ -133,12 +131,11 @@ Spiller::~Spiller() {}
 
 namespace {
   struct SimpleSpiller : public Spiller {
-    bool runOnMachineFunction(MachineFunction& mf, const VirtRegMap &VRM);
+    bool runOnMachineFunction(MachineFunction& mf, VirtRegMap &VRM);
   };
 }
 
-bool SimpleSpiller::runOnMachineFunction(MachineFunction &MF,
-                                         const VirtRegMap &VRM) {
+bool SimpleSpiller::runOnMachineFunction(MachineFunction &MF, VirtRegMap &VRM) {
   DEBUG(std::cerr << "********** REWRITE MACHINE CODE **********\n");
   DEBUG(std::cerr << "********** Function: "
                   << MF.getFunction()->getName() << '\n');
@@ -211,7 +208,7 @@ namespace {
     const MRegisterInfo *MRI;
     const TargetInstrInfo *TII;
   public:
-    bool runOnMachineFunction(MachineFunction &MF, const VirtRegMap &VRM) {
+    bool runOnMachineFunction(MachineFunction &MF, VirtRegMap &VRM) {
       MRI = MF.getTarget().getRegisterInfo();
       TII = MF.getTarget().getInstrInfo();
       DEBUG(std::cerr << "\n**** Local spiller rewriting function '"
@@ -223,7 +220,7 @@ namespace {
       return true;
     }
   private:
-    void RewriteMBB(MachineBasicBlock &MBB, const VirtRegMap &VRM);
+    void RewriteMBB(MachineBasicBlock &MBB, VirtRegMap &VRM);
     void ClobberPhysReg(unsigned PR, std::map<int, unsigned> &SpillSlots,
                         std::multimap<unsigned, int> &PhysRegs);
     void ClobberPhysRegOnly(unsigned PR, std::map<int, unsigned> &SpillSlots,
@@ -484,7 +481,7 @@ namespace {
 
 /// rewriteMBB - Keep track of which spills are available even after the
 /// register allocator is done with them.  If possible, avoid reloading vregs.
-void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, const VirtRegMap &VRM) {
+void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, VirtRegMap &VRM) {
 
   DEBUG(std::cerr << MBB.getBasicBlock()->getName() << ":\n");
 
@@ -729,14 +726,11 @@ void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, const VirtRegMap &VRM) {
           MaybeDeadStores.erase(MDSI);
         else {
           // If we get here, the store is dead, nuke it now.
-          assert(!(MR & VirtRegMap::isRef) && "Can't be modref!");
-          // Don't nuke it if the value is needed in another block.
-          if (!(MR & VirtRegMap::isLiveOut)) {
-            DEBUG(std::cerr << " Killed store:\t" << *MDSI->second);
-            MBB.erase(MDSI->second);
-            MaybeDeadStores.erase(MDSI);
-            ++NumDSE;
-          }
+          assert(VirtRegMap::isMod && "Can't be modref!");
+          DEBUG(std::cerr << "Removed dead store:\t" << *MDSI->second);
+          MBB.erase(MDSI->second);
+          MaybeDeadStores.erase(MDSI);
+          ++NumDSE;
         }
       }
 
@@ -837,7 +831,7 @@ void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, const VirtRegMap &VRM) {
         // If there is a dead store to this stack slot, nuke it now.
         MachineInstr *&LastStore = MaybeDeadStores[StackSlot];
         if (LastStore) {
-          DEBUG(std::cerr << " Killed store:\t" << *LastStore);
+          DEBUG(std::cerr << "Removed dead store:\t" << *LastStore);
           ++NumDSE;
           MBB.erase(LastStore);
         }
diff --git a/lib/CodeGen/VirtRegMap.h b/lib/CodeGen/VirtRegMap.h
index 343a4e066aa..898677e8f92 100644
--- a/lib/CodeGen/VirtRegMap.h
+++ b/lib/CodeGen/VirtRegMap.h
@@ -26,7 +26,7 @@ namespace llvm {
 
   class VirtRegMap {
   public:
-    enum ModRef { isRef = 1, isMod = 2, isModRef = 3, isLiveOut = 4 };
+    enum ModRef { isRef = 1, isMod = 2, isModRef = 3 };
     typedef std::multimap<MachineInstr*,
                           std::pair<unsigned, ModRef> > MI2VirtMapTy;
 
@@ -128,7 +128,7 @@ namespace llvm {
     /// folded into newMI machine instruction.  The OpNum argument indicates the
     /// operand number of OldMI that is folded.
     void virtFolded(unsigned VirtReg, MachineInstr *OldMI, unsigned OpNum,
-                    MachineInstr *NewMI, bool LiveOut);
+                    MachineInstr *NewMI);
 
     /// @brief returns the virtual registers' values folded in memory
     /// operands of this instruction
@@ -136,6 +136,13 @@ namespace llvm {
     getFoldedVirts(MachineInstr* MI) const {
       return MI2VirtMap.equal_range(MI);
     }
+    
+    /// RemoveFromFoldedVirtMap - Given a machine instruction in the folded
+    /// instruction map, remove the entry in the folded instruction map.
+    void RemoveFromFoldedVirtMap(MachineInstr *MI) {
+      bool ErasedAny = MI2VirtMap.erase(MI);
+      assert(ErasedAny && "Machine instr not in folded vreg map!");
+    }
 
     void print(std::ostream &OS) const;
     void dump() const;
@@ -151,7 +158,7 @@ namespace llvm {
   struct Spiller {
     virtual ~Spiller();
     virtual bool runOnMachineFunction(MachineFunction &MF,
-                                      const VirtRegMap &VRM) = 0;
+                                      VirtRegMap &VRM) = 0;
   };
 
   /// createSpiller - Create an return a spiller object, as specified on the