Fix the SPR field for MTLR, MFLR, MTCTR, and MFCTR instructions.

[oota-llvm.git] / lib / CodeGen / PHIElimination.cpp

diff --git a/lib/CodeGen/PHIElimination.cpp b/lib/CodeGen/PHIElimination.cpp
index 0cfeb2408a81fdd08918c47fd37d63adbdd787dd..0010ccd7e66fe0320c4df7c3f3d956514008aeea 100644 (file)
--- a/lib/CodeGen/PHIElimination.cpp
+++ b/lib/CodeGen/PHIElimination.cpp
@@ -20,8 +20,8 @@
 #include "llvm/CodeGen/LiveVariables.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
-#include "Support/DenseMap.h"
-#include "Support/STLExtras.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 using namespace llvm;
 
 namespace {
@@ -66,7 +66,7 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) {
     return false;   // Quick exit for normal case...
 
   LiveVariables *LV = getAnalysisToUpdate<LiveVariables>();
-  const TargetInstrInfo &MII = MF.getTarget().getInstrInfo();
+  const TargetInstrInfo &MII = *MF.getTarget().getInstrInfo();
   const MRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo();
 
   // VRegPHIUseCount - Keep track of the number of times each virtual register
@@ -95,13 +95,13 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) {
     ++AfterPHIsIt;    // Skip over all of the PHI nodes...
 
   while (MBB.front().getOpcode() == TargetInstrInfo::PHI) {
-    // Unlink the PHI node from the basic block... but don't delete the PHI yet
-    MachineInstr *MI = MBB.remove(MBB.begin());
+    // Unlink the PHI node from the basic block, but don't delete the PHI yet.
+    MachineInstr *MPhi = MBB.remove(MBB.begin());
     
-    assert(MRegisterInfo::isVirtualRegister(MI->getOperand(0).getReg()) &&
+    assert(MRegisterInfo::isVirtualRegister(MPhi->getOperand(0).getReg()) &&
            "PHI node doesn't write virt reg?");
 
-    unsigned DestReg = MI->getOperand(0).getReg();
+    unsigned DestReg = MPhi->getOperand(0).getReg();
     
     // Create a new register for the incoming PHI arguments
     const TargetRegisterClass *RC = MF.getSSARegMap()->getRegClass(DestReg);
@@ -122,51 +122,42 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) {
       // each for each incoming block), the "def" block and instruction fields
       // for the VarInfo is not filled in.
       //
-      LV->addVirtualRegisterKilled(IncomingReg, &MBB, PHICopy);
+      LV->addVirtualRegisterKilled(IncomingReg, PHICopy);
 
       // Since we are going to be deleting the PHI node, if it is the last use
       // of any registers, or if the value itself is dead, we need to move this
-      // information over to the new copy we just inserted...
+      // information over to the new copy we just inserted.
       //
       std::pair<LiveVariables::killed_iterator, LiveVariables::killed_iterator> 
-        RKs = LV->killed_range(MI);
+        RKs = LV->killed_range(MPhi);
       std::vector<std::pair<MachineInstr*, unsigned> > Range;
-      if (RKs.first != RKs.second) {
-        // Copy the range into a vector...
-        Range.assign(RKs.first, RKs.second);
-
-        // Delete the range...
+      if (RKs.first != RKs.second) // Delete the range.
         LV->removeVirtualRegistersKilled(RKs.first, RKs.second);
 
-        // Add all of the kills back, which will update the appropriate info...
-        for (unsigned i = 0, e = Range.size(); i != e; ++i)
-          LV->addVirtualRegisterKilled(Range[i].second, &MBB, PHICopy);
-      }
-
-      RKs = LV->dead_range(MI);
+      RKs = LV->dead_range(MPhi);
       if (RKs.first != RKs.second) {
         // Works as above...
         Range.assign(RKs.first, RKs.second);
         LV->removeVirtualRegistersDead(RKs.first, RKs.second);
         for (unsigned i = 0, e = Range.size(); i != e; ++i)
-          LV->addVirtualRegisterDead(Range[i].second, &MBB, PHICopy);
+          LV->addVirtualRegisterDead(Range[i].second, PHICopy);
       }
     }
 
     // Adjust the VRegPHIUseCount map to account for the removal of this PHI
     // node.
-    for (unsigned i = 1; i != MI->getNumOperands(); i += 2)
-      VRegPHIUseCount[MI->getOperand(i).getReg()] -= BBIsSuccOfPreds;
+    for (unsigned i = 1; i != MPhi->getNumOperands(); i += 2)
+      VRegPHIUseCount[MPhi->getOperand(i).getReg()] -= BBIsSuccOfPreds;
 
     // Now loop over all of the incoming arguments, changing them to copy into
     // the IncomingReg register in the corresponding predecessor basic block.
     //
-    for (int i = MI->getNumOperands() - 1; i >= 2; i-=2) {
-      MachineOperand &opVal = MI->getOperand(i-1);
+    for (int i = MPhi->getNumOperands() - 1; i >= 2; i-=2) {
+      MachineOperand &opVal = MPhi->getOperand(i-1);
       
       // Get the MachineBasicBlock equivalent of the BasicBlock that is the
       // source path the PHI.
-      MachineBasicBlock &opBlock = *MI->getOperand(i).getMachineBasicBlock();
+      MachineBasicBlock &opBlock = *MPhi->getOperand(i).getMachineBasicBlock();
 
       MachineBasicBlock::iterator I = opBlock.getFirstTerminator();
       
@@ -226,7 +217,7 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) {
             MachineBasicBlock *SuccMBB = *SI;
             
             // Is it alive in this successor?
-            unsigned SuccIdx = LV->getMachineBasicBlockIndex(SuccMBB);
+            unsigned SuccIdx = SuccMBB->getNumber();
             if (SuccIdx < InRegVI.AliveBlocks.size() &&
                 InRegVI.AliveBlocks[SuccIdx]) {
               ValueIsLive = true;
@@ -235,7 +226,7 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) {
             
             // Is it killed in this successor?
             for (unsigned i = 0, e = InRegVI.Kills.size(); i != e; ++i)
-              if (InRegVI.Kills[i].first == SuccMBB) {
+              if (InRegVI.Kills[i]->getParent() == SuccMBB) {
                 ValueIsLive = true;
                 break;
               }
@@ -251,14 +242,19 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) {
           //
           if (!ValueIsLive) {
             MachineBasicBlock::iterator Prev = prior(I);
-            LV->addVirtualRegisterKilled(SrcReg, &opBlock, Prev);
+            LV->addVirtualRegisterKilled(SrcReg, Prev);
+
+            // This vreg no longer lives all of the way through opBlock.
+            unsigned opBlockNum = opBlock.getNumber();
+            if (opBlockNum < InRegVI.AliveBlocks.size())
+              InRegVI.AliveBlocks[opBlockNum] = false;
           }
         }
       }
     }
     
-    // really delete the PHI instruction now!
-    delete MI;
+    // Really delete the PHI instruction now!
+    delete MPhi;
   }
   return true;
 }