Fix spellnig error

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

diff --git a/lib/CodeGen/StrongPHIElimination.cpp b/lib/CodeGen/StrongPHIElimination.cpp
index 0c785367168c270f338656c9b69607749cd4ec9e..449ef38a3a1da3e9fb7ba655b946a14b1d6a2eb3 100644 (file)
--- a/lib/CodeGen/StrongPHIElimination.cpp
+++ b/lib/CodeGen/StrongPHIElimination.cpp
@@ -27,6 +27,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/RegisterCoalescer.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/ADT/DepthFirstIterator.h"
@@ -34,7 +35,6 @@
 #include "llvm/Support/Compiler.h"
 using namespace llvm;
 
-
 namespace {
   struct VISIBILITY_HIDDEN StrongPHIElimination : public MachineFunctionPass {
     static char ID; // Pass identification, replacement for typeid
@@ -74,6 +74,7 @@ namespace {
       
       // TODO: Actually make this true.
       AU.addPreserved<LiveIntervals>();
+      AU.addPreserved<RegisterCoalescer>();
       MachineFunctionPass::getAnalysisUsage(AU);
     }
     
@@ -140,13 +141,14 @@ namespace {
                       SmallPtrSet<MachineBasicBlock*, 16>& v);
     void mergeLiveIntervals(unsigned primary, unsigned secondary, unsigned VN);
   };
-
-  char StrongPHIElimination::ID = 0;
-  RegisterPass<StrongPHIElimination> X("strong-phi-node-elimination",
-                  "Eliminate PHI nodes for register allocation, intelligently");
 }
 
-const PassInfo *llvm::StrongPHIEliminationID = X.getPassInfo();
+char StrongPHIElimination::ID = 0;
+static RegisterPass<StrongPHIElimination>
+X("strong-phi-node-elimination",
+  "Eliminate PHI nodes for register allocation, intelligently");
+
+const PassInfo *const llvm::StrongPHIEliminationID = &X;
 
 /// computeDFS - Computes the DFS-in and DFS-out numbers of the dominator tree
 /// of the given MachineFunction.  These numbers are then used in other parts
@@ -192,6 +194,8 @@ void StrongPHIElimination::computeDFS(MachineFunction& MF) {
   }
 }
 
+namespace {
+
 /// PreorderSorter - a helper class that is used to sort registers
 /// according to the preorder number of their defining blocks
 class PreorderSorter {
@@ -219,6 +223,8 @@ public:
   }
 };
 
+}
+
 /// computeDomForest - compute the subforest of the DomTree corresponding
 /// to the defining blocks of the registers in question
 std::vector<StrongPHIElimination::DomForestNode*>
@@ -408,7 +414,7 @@ void StrongPHIElimination::processBlock(MachineBasicBlock* MBB) {
   
   // Iterate over all the PHI nodes in this block
   MachineBasicBlock::iterator P = MBB->begin();
-  while (P->getOpcode() == TargetInstrInfo::PHI) {
+  while (P != MBB->end() && P->getOpcode() == TargetInstrInfo::PHI) {
     unsigned DestReg = P->getOperand(0).getReg();
 
     // Don't both doing PHI elimination for dead PHI's.
@@ -483,8 +489,17 @@ void StrongPHIElimination::processBlock(MachineBasicBlock* MBB) {
     std::vector<std::pair<unsigned, unsigned> > localInterferences;
     processPHIUnion(P, PHIUnion, DF, localInterferences);
     
+    // If one of the inputs is defined in the same block as the current PHI
+    // then we need to check for a local interference between that input and
+    // the PHI.
+    for (std::map<unsigned, unsigned>::iterator I = PHIUnion.begin(),
+         E = PHIUnion.end(); I != E; ++I)
+      if (MRI.getVRegDef(I->first)->getParent() == P->getParent())
+        localInterferences.push_back(std::make_pair(I->first,
+                                                    P->getOperand(0).getReg()));
+    
     // The dominator forest walk may have returned some register pairs whose
-    // interference cannot be determines from dominator analysis.  We now 
+    // interference cannot be determined from dominator analysis.  We now 
     // examine these pairs for local interferences.
     for (std::vector<std::pair<unsigned, unsigned> >::iterator I =
         localInterferences.begin(), E = localInterferences.end(); I != E; ++I) {
@@ -527,7 +542,7 @@ void StrongPHIElimination::processBlock(MachineBasicBlock* MBB) {
       }
     }
     
-    // Add the renaming set for this PHI node to our overal renaming information
+    // Add the renaming set for this PHI node to our overall renaming information
     RenameSets.insert(std::make_pair(P->getOperand(0).getReg(), PHIUnion));
     
     // Remember which registers are already renamed, so that we don't try to 
@@ -845,7 +860,6 @@ void StrongPHIElimination::mergeLiveIntervals(unsigned primary,
 }
 
 bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) {
-  
   LiveIntervals& LI = getAnalysis<LiveIntervals>();
   
   // Compute DFS numbers of each block
@@ -889,20 +903,26 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) {
     
     // If this is a dead PHI node, then remove it from LiveIntervals.
     unsigned DestReg = PInstr->getOperand(0).getReg();
+    LiveInterval& PI = LI.getInterval(DestReg);
     if (PInstr->registerDefIsDead(DestReg)) {
-      LiveInterval& PI = LI.getInterval(DestReg);
-      
       if (PI.containsOneValue()) {
         LI.removeInterval(DestReg);
       } else {
         unsigned idx = LI.getDefIndex(LI.getInstructionIndex(PInstr));
         PI.removeRange(*PI.getLiveRangeContaining(idx), true);
       }
+    } else {
+      // If the PHI is not dead, then the valno defined by the PHI
+      // now has an unknown def.
+      unsigned idx = LI.getDefIndex(LI.getInstructionIndex(PInstr));
+      PI.getLiveRangeContaining(idx)->valno->def = ~0U;
     }
-      
+    
     LI.RemoveMachineInstrFromMaps(PInstr);
     PInstr->eraseFromParent();
   }
   
+  LI.computeNumbering();
+  
   return true;
 }