Fix bug: Jello/2003-08-23-RegisterAllocatePhysReg.ll

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

diff --git a/lib/CodeGen/RegAllocLocal.cpp b/lib/CodeGen/RegAllocLocal.cpp
index 1b84b30f57f0970c5c02f017f663f69850d2f607..331a291753df7c76586ffd0a2ff8e5d91a38bb92 100644 (file)
--- a/lib/CodeGen/RegAllocLocal.cpp
+++ b/lib/CodeGen/RegAllocLocal.cpp
@@ -143,10 +143,12 @@ namespace {
                       unsigned VirtReg, unsigned PhysReg);
 
     /// spillPhysReg - This method spills the specified physical register into
-    /// the virtual register slot associated with it.
+    /// the virtual register slot associated with it.  If OnlyVirtRegs is set to
+    /// true, then the request is ignored if the physical register does not
+    /// contain a virtual register.
     ///
     void spillPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
-                      unsigned PhysReg);
+                      unsigned PhysReg, bool OnlyVirtRegs = false);
 
     /// assignVirtToPhysReg - This method updates local state so that we know
     /// that PhysReg is the proper container for VirtReg now.  The physical
@@ -259,20 +261,24 @@ void RA::spillVirtReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
 
 
 /// spillPhysReg - This method spills the specified physical register into the
-/// virtual register slot associated with it.
+/// virtual register slot associated with it.  If OnlyVirtRegs is set to true,
+/// then the request is ignored if the physical register does not contain a
+/// virtual register.
 ///
 void RA::spillPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
-                      unsigned PhysReg) {
+                      unsigned PhysReg, bool OnlyVirtRegs) {
   std::map<unsigned, unsigned>::iterator PI = PhysRegsUsed.find(PhysReg);
   if (PI != PhysRegsUsed.end()) {             // Only spill it if it's used!
-    spillVirtReg(MBB, I, PI->second, PhysReg);
+    if (PI->second || !OnlyVirtRegs)
+      spillVirtReg(MBB, I, PI->second, PhysReg);
   } else if (const unsigned *AliasSet = RegInfo->getAliasSet(PhysReg)) {
     // If the selected register aliases any other registers, we must make
     // sure that one of the aliases isn't alive...
     for (unsigned i = 0; AliasSet[i]; ++i) {
       PI = PhysRegsUsed.find(AliasSet[i]);
       if (PI != PhysRegsUsed.end())     // Spill aliased register...
-       spillVirtReg(MBB, I, PI->second, AliasSet[i]);
+        if (PI->second || !OnlyVirtRegs)
+          spillVirtReg(MBB, I, PI->second, AliasSet[i]);
     }
   }
 }
@@ -394,19 +400,27 @@ unsigned RA::getReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator &I,
              "Couldn't find a register of the appropriate class!");
       
       unsigned R = PhysRegsUseOrder[i];
-      // If the current register is compatible, use it.
-      if (RegInfo->getRegClass(R) == RC) {
-       PhysReg = R;
-       break;
-      } else {
-       // If one of the registers aliased to the current register is
-       // compatible, use it.
-       if (const unsigned *AliasSet = RegInfo->getAliasSet(R))
-         for (unsigned a = 0; AliasSet[a]; ++a)
-           if (RegInfo->getRegClass(AliasSet[a]) == RC) {
-             PhysReg = AliasSet[a];    // Take an aliased register
-             break;
-           }
+
+      // We can only use this register if it holds a virtual register (ie, it
+      // can be spilled).  Do not use it if it is an explicitly allocated
+      // physical register!
+      assert(PhysRegsUsed.count(R) &&
+             "PhysReg in PhysRegsUseOrder, but is not allocated?");
+      if (PhysRegsUsed[R]) {
+        // If the current register is compatible, use it.
+        if (RegInfo->getRegClass(R) == RC) {
+          PhysReg = R;
+          break;
+        } else {
+          // If one of the registers aliased to the current register is
+          // compatible, use it.
+          if (const unsigned *AliasSet = RegInfo->getAliasSet(R))
+            for (unsigned a = 0; AliasSet[a]; ++a)
+              if (RegInfo->getRegClass(AliasSet[a]) == RC) {
+                PhysReg = AliasSet[a];    // Take an aliased register
+                break;
+              }
+        }
       }
     }
 
@@ -475,7 +489,7 @@ void RA::AllocateBasicBlock(MachineBasicBlock &MBB) {
       for (unsigned i = 0; ImplicitUses[i]; ++i)
         MarkPhysRegRecentlyUsed(ImplicitUses[i]);
 
-    // Get the used operands into registers.  This has the potiential to spill
+    // Get the used operands into registers.  This has the potential to spill
     // incoming values if we are out of registers.  Note that we completely
     // ignore physical register uses here.  We assume that if an explicit
     // physical register is referenced by the instruction, that it is guaranteed
@@ -520,7 +534,7 @@ void RA::AllocateBasicBlock(MachineBasicBlock &MBB) {
            MI->getOperand(i).opIsDefAndUse()) &&
           MI->getOperand(i).isPhysicalRegister()) {
         unsigned Reg = MI->getOperand(i).getAllocatedRegNum();
-        spillPhysReg(MBB, I, Reg);        // Spill any existing value in the reg
+        spillPhysReg(MBB, I, Reg, true);  // Spill any existing value in the reg
         PhysRegsUsed[Reg] = 0;            // It is free and reserved now
         PhysRegsUseOrder.push_back(Reg);
       }
@@ -618,7 +632,11 @@ void RA::AllocateBasicBlock(MachineBasicBlock &MBB) {
               << I->second << "\n";
 
   assert(Virt2PhysRegMap.empty() && "Virtual registers still in phys regs?");
-  assert(PhysRegsUseOrder.empty() && "Physical regs still allocated?");
+  
+  // Clear any physical register which appear live at the end of the basic
+  // block, but which do not hold any virtual registers.  e.g., the stack
+  // pointer.
+  PhysRegsUseOrder.clear();
 }
 
 
@@ -643,6 +661,6 @@ bool RA::runOnMachineFunction(MachineFunction &Fn) {
   return true;
 }
 
-Pass *createLocalRegisterAllocator() {
+FunctionPass *createLocalRegisterAllocator() {
   return new RA();
 }