[llvm-commits] CVS: llvm/lib/CodeGen/LiveIntervals.h LiveIntervals.cpp

[Chris Lattner]

Changes in directory llvm/lib/CodeGen:

LiveIntervals.h updated: 1.29 -> 1.30
LiveIntervals.cpp updated: 1.102 -> 1.103

---
Log message:

Force coallescing of live ranges that have a single definition, even if they
interfere.  Because these intervals have a single definition, and one of them
is a copy instruction, they are always safe to merge even if their lifetimes
interfere.  This slightly reduces the amount of spill code, for example on
252.eon, from:

 12837 spiller               - Number of loads added
  7604 spiller               - Number of stores added
  5842 spiller               - Number of register spills
 18155 liveintervals         - Number of identity moves eliminated after coalescing

to:

  12754 spiller               - Number of loads added
   7585 spiller               - Number of stores added
   5803 spiller               - Number of register spills
  18262 liveintervals         - Number of identity moves eliminated after coalescing

The much much bigger win would be to merge intervals with multiple definitions
(aka phi nodes) but this is not that day.



---
Diffs of the changes:  (+30 -9)

Index: llvm/lib/CodeGen/LiveIntervals.h
diff -u llvm/lib/CodeGen/LiveIntervals.h:1.29 llvm/lib/CodeGen/LiveIntervals.h:1.30
--- llvm/lib/CodeGen/LiveIntervals.h:1.29	Mon Jul 19 09:08:10 2004
+++ llvm/lib/CodeGen/LiveIntervals.h	Fri Jul 23 00:26:05 2004
@@ -36,6 +36,7 @@
         float weight;   // weight of this interval:
                         //     (number of uses *10^loopDepth)
         Ranges ranges;  // the ranges in which this register is live
+        bool isDefinedOnce;  // True if there is one def of this register
 
         explicit LiveInterval(unsigned r);
 


Index: llvm/lib/CodeGen/LiveIntervals.cpp
diff -u llvm/lib/CodeGen/LiveIntervals.cpp:1.102 llvm/lib/CodeGen/LiveIntervals.cpp:1.103
--- llvm/lib/CodeGen/LiveIntervals.cpp:1.102	Thu Jul 22 16:54:22 2004
+++ llvm/lib/CodeGen/LiveIntervals.cpp	Fri Jul 23 00:26:05 2004
@@ -285,6 +285,9 @@
     // done once for the vreg.  We use an empty interval to detect the first 
     // time we see a vreg.
     if (interval.empty()) {
+       // Assume this interval is singly defined until we find otherwise.
+       interval.isDefinedOnce = true;
+
        // Get the Idx of the defining instructions.
        unsigned defIndex = getDefIndex(getInstructionIndex(mi));
 
@@ -357,6 +360,7 @@
          interval.addRange(defIndex, 
                            getInstructionIndex(&mbb->back()) + InstrSlots::NUM);
        }
+       interval.isDefinedOnce = false;
     }
 
     DEBUG(std::cerr << '\n');
@@ -524,6 +528,9 @@
             Intervals::iterator intA = r2iA->second;
             Intervals::iterator intB = r2iB->second;
 
+            DEBUG(std::cerr << "\t\tInspecting " << *intA << " and " << *intB 
+                            << ": ");
+
             // both A and B are virtual registers
             if (MRegisterInfo::isVirtualRegister(intA->reg) &&
                 MRegisterInfo::isVirtualRegister(intB->reg)) {
@@ -531,19 +538,26 @@
                 const TargetRegisterClass *rcA, *rcB;
                 rcA = mf_->getSSARegMap()->getRegClass(intA->reg);
                 rcB = mf_->getSSARegMap()->getRegClass(intB->reg);
+
                 // if they are not of the same register class we continue
-                if (rcA != rcB)
+                if (rcA != rcB) {
+                    DEBUG(std::cerr << "Differing reg classes.\n");
                     continue;
+                }
 
                 // if their intervals do not overlap we join them
-                if (!intB->overlaps(*intA)) {
+                if ((intA->isDefinedOnce && intB->isDefinedOnce) ||
+                    !intB->overlaps(*intA)) {
                     intA->join(*intB);
+                    DEBUG(std::cerr << "Joined.  Result = " << *intA << "\n");
                     r2iB->second = r2iA->second;
                     r2rMap_.insert(std::make_pair(intB->reg, intA->reg));
                     intervals_.erase(intB);
+                } else {
+                    DEBUG(std::cerr << "Interference!\n");
                 }
-            } else if (MRegisterInfo::isPhysicalRegister(intA->reg) ^
-                       MRegisterInfo::isPhysicalRegister(intB->reg)) {
+            } else if (!MRegisterInfo::isPhysicalRegister(intA->reg) ||
+                       !MRegisterInfo::isPhysicalRegister(intB->reg)) {
                 if (MRegisterInfo::isPhysicalRegister(intB->reg)) {
                     std::swap(regA, regB);
                     std::swap(intA, intB);
@@ -558,16 +572,23 @@
                 rcA = mri_->getRegClass(intA->reg);
                 rcB = mf_->getSSARegMap()->getRegClass(intB->reg);
                 // if they are not of the same register class we continue
-                if (rcA != rcB)
+                if (rcA != rcB) {
+                    DEBUG(std::cerr << "Differing reg classes.\n");
                     continue;
+                }
 
                 if (!intA->overlaps(*intB) &&
                     !overlapsAliases(*intA, *intB)) {
                     intA->join(*intB);
+                    DEBUG(std::cerr << "Joined.  Result = " << *intA << "\n");
                     r2iB->second = r2iA->second;
                     r2rMap_.insert(std::make_pair(intB->reg, intA->reg));
                     intervals_.erase(intB);
+                } else {
+                    DEBUG(std::cerr << "Interference!\n");
                 }
+            } else {
+                DEBUG(std::cerr << "Cannot join physregs.\n");
             }
         }
     }
@@ -642,8 +663,8 @@
 
 LiveInterval::LiveInterval(unsigned r)
     : reg(r),
-      weight((MRegisterInfo::isPhysicalRegister(r) ?  HUGE_VAL : 0.0F))
-{
+      weight((MRegisterInfo::isPhysicalRegister(r) ?  HUGE_VAL : 0.0F)),
+      isDefinedOnce(false) {
 }
 
 bool LiveInterval::spilled() const
@@ -740,8 +761,8 @@
 
 void LiveInterval::join(const LiveInterval& other)
 {
-    DEBUG(std::cerr << "\t\tjoining " << *this << " with " << other);
     Ranges::iterator cur = ranges.begin();
+    isDefinedOnce &= other.isDefinedOnce;
 
     for (Ranges::const_iterator i = other.ranges.begin(),
              e = other.ranges.end(); i != e; ++i) {
@@ -751,7 +772,6 @@
     }
     weight += other.weight;
     ++numJoins;
-    DEBUG(std::cerr << ".  Result = " << *this << "\n");
 }
 
 LiveInterval::Ranges::iterator LiveInterval::