Print variable's display name in dwarf DIE.

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

diff --git a/lib/CodeGen/VirtRegMap.cpp b/lib/CodeGen/VirtRegMap.cpp
index 95cb0cf5bc19946071de611acd837feeb15f4c7b..e2dc636e69119c00377748613022631b4aada493 100644 (file)
--- a/lib/CodeGen/VirtRegMap.cpp
+++ b/lib/CodeGen/VirtRegMap.cpp
@@ -496,6 +496,12 @@ void AvailableSpills::AddAvailableRegsToLiveIn(MachineBasicBlock &MBB) {
          I = PhysRegsAvailable.begin(), E = PhysRegsAvailable.end();
        I != E; ++I) {
     unsigned Reg = (*I).first;
+    const TargetRegisterClass* RC = TRI->getPhysicalRegisterRegClass(Reg);
+    // FIXME: A temporary workaround. We can't reuse available value if it's
+    // not safe to move the def of the virtual register's class. e.g.
+    // X86::RFP* register classes. Do not add it as a live-in.
+    if (!TII->isSafeToMoveRegClassDefs(RC))
+      continue;
     if (!MBB.isLiveIn(Reg))
       MBB.addLiveIn(Reg);
   }
@@ -1047,7 +1053,7 @@ bool LocalSpiller::PrepForUnfoldOpti(MachineBasicBlock &MBB,
       NewMIs.clear();
       int Idx = NewMI->findRegisterUseOperandIdx(VirtReg, false);
       assert(Idx != -1);
-      SmallVector<unsigned, 2> Ops;
+      SmallVector<unsigned, 1> Ops;
       Ops.push_back(Idx);
       MachineInstr *FoldedMI = TII->foldMemoryOperand(MF, NewMI, Ops, SS);
       if (FoldedMI) {
@@ -1118,7 +1124,7 @@ bool LocalSpiller::CommuteToFoldReload(MachineBasicBlock &MBB,
     MachineInstr *CommutedMI = TII->commuteInstruction(DefMI, true);
     if (!CommutedMI)
       return false;
-    SmallVector<unsigned, 2> Ops;
+    SmallVector<unsigned, 1> Ops;
     Ops.push_back(NewDstIdx);
     MachineInstr *FoldedMI = TII->foldMemoryOperand(MF, CommutedMI, Ops, SS);
     // Not needed since foldMemoryOperand returns new MI.
@@ -1361,7 +1367,12 @@ void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, VirtRegMap &VRM,
         bool DoReMat = VRM.isReMaterialized(VirtReg);
         int SSorRMId = DoReMat
           ? VRM.getReMatId(VirtReg) : VRM.getStackSlot(VirtReg);
-        unsigned InReg = Spills.getSpillSlotOrReMatPhysReg(SSorRMId);
+        const TargetRegisterClass* RC = RegInfo->getRegClass(VirtReg);
+        // FIXME: A temporary workaround. Don't reuse available value if it's
+        // not safe to move the def of the virtual register's class. e.g.
+        // X86::RFP* register classes.
+        unsigned InReg = TII->isSafeToMoveRegClassDefs(RC) ?
+          Spills.getSpillSlotOrReMatPhysReg(SSorRMId) : 0;
         if (InReg == Phys) {
           // If the value is already available in the expected register, save
           // a reload / remat.
@@ -1387,7 +1398,6 @@ void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, VirtRegMap &VRM,
 
           // If the reloaded / remat value is available in another register,
           // copy it to the desired register.
-          const TargetRegisterClass* RC = RegInfo->getRegClass(VirtReg);
           TII->copyRegToReg(MBB, &MI, Phys, InReg, RC, RC);
 
           // This invalidates Phys.
@@ -1589,6 +1599,12 @@ void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, VirtRegMap &VRM,
 
             PotentialDeadStoreSlots.push_back(ReuseSlot);
           }
+
+          // Assumes this is the last use. IsKill will be unset if reg is reused
+          // unless it's a two-address operand.
+          if (ti == -1)
+            MI.getOperand(i).setIsKill();
+
           continue;
         }  // CanReuse
         
@@ -1754,6 +1770,11 @@ void LocalSpiller::RewriteMBB(MachineBasicBlock &MBB, VirtRegMap &VRM,
                 DefMO = NextMII->findRegisterDefOperand(DestReg);
                 DefMO->setSubReg(SubIdx);
               }
+
+              // Mark is killed.
+              MachineOperand *KillOpnd = NextMII->findRegisterUseOperand(InReg);
+              KillOpnd->setIsKill();
+
               BackTracked = true;
             } else {
               DOUT << "Removing now-noop copy: " << MI;