[llvm] r223892 - VirtRegMap: No implicit defs/uses for super registers with subreg liveness tracking.

[Matthias Braun]

Author: matze
Date: Tue Dec  9 19:13:04 2014
New Revision: 223892

URL: http://llvm.org/viewvc/llvm-project?rev=223892&view=rev
Log:
VirtRegMap: No implicit defs/uses for super registers with subreg liveness tracking.

Adding the implicit defs/uses to the superregisters is semantically questionable
but was not dangerous before as the register allocator never assigned the same
register to two overlapping LiveIntervals even when the actually live
subregisters do not overlap. With subregister liveness tracking enabled this
does actually happen and leads to subsequent bugs if we don't stop adding
the superregister defs/uses.

Modified:
    llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp
    llvm/trunk/lib/CodeGen/VirtRegMap.cpp

Modified: llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp?rev=223892&r1=223891&r2=223892&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp (original)
+++ llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp Tue Dec  9 19:13:04 2014
@@ -671,6 +671,30 @@ void LiveIntervals::addKillFlags(const V
         CancelKill = true;
         break;
       }
+
+      // If an instruction writes to a subregister, a new segment starts in the
+      // LiveInterval. In this case adding Kill-Flags is incorrect if no
+      // super registers defs/uses are appended to the instruction which is
+      // what we do when subregister liveness tracking is enabled.
+      if (MRI->tracksSubRegLiveness()) {
+        // Next segment has to be adjacent in the subregister write case.
+        LiveRange::iterator N = std::next(RI);
+        if (N != LI->end() && N->start == RI->end) {
+          // See if we have a partial write operand
+          bool IsFullWrite = false;
+          for (MachineInstr::const_mop_iterator MOp = MI->operands_begin(),
+               MOpE = MI->operands_end(); MOp != MOpE; ++MOp) {
+            if (MOp->isReg() && !MOp->isDef() && MOp->getReg() == Reg
+                && MOp->getSubReg() == 0) {
+              IsFullWrite = true;
+              break;
+            }
+          }
+          if (!IsFullWrite)
+            CancelKill = true;
+        }
+      }
+
       if (CancelKill)
         MI->clearRegisterKills(Reg, nullptr);
       else

Modified: llvm/trunk/lib/CodeGen/VirtRegMap.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/VirtRegMap.cpp?rev=223892&r1=223891&r2=223892&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/VirtRegMap.cpp (original)
+++ llvm/trunk/lib/CodeGen/VirtRegMap.cpp Tue Dec  9 19:13:04 2014
@@ -266,6 +266,7 @@ void VirtRegRewriter::addMBBLiveIns() {
 }
 
 void VirtRegRewriter::rewrite() {
+  bool NoSubRegLiveness = !MRI->tracksSubRegLiveness();
   SmallVector<unsigned, 8> SuperDeads;
   SmallVector<unsigned, 8> SuperDefs;
   SmallVector<unsigned, 8> SuperKills;
@@ -347,7 +348,8 @@ void VirtRegRewriter::rewrite() {
           // A virtual register kill refers to the whole register, so we may
           // have to add <imp-use,kill> operands for the super-register.  A
           // partial redef always kills and redefines the super-register.
-          if (MO.readsReg() && (MO.isDef() || MO.isKill()))
+          if (NoSubRegLiveness && MO.readsReg()
+              && (MO.isDef() || MO.isKill()))
             SuperKills.push_back(PhysReg);
 
           if (MO.isDef()) {
@@ -358,10 +360,12 @@ void VirtRegRewriter::rewrite() {
             MO.setIsUndef(false);
 
             // Also add implicit defs for the super-register.
-            if (MO.isDead())
-              SuperDeads.push_back(PhysReg);
-            else
-              SuperDefs.push_back(PhysReg);
+            if (NoSubRegLiveness) {
+              if (MO.isDead())
+                SuperDeads.push_back(PhysReg);
+              else
+                SuperDefs.push_back(PhysReg);
+            }
           }
 
           // PhysReg operands cannot have subregister indexes.