Subzero: Register allocator performance improvements and simplifications.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the CfgNode class, including the complexities
@@ skipping 339 matching lines @@
   LivenessBV &LiveIn = Liveness->getLiveIn(this);
   // Add in current LiveIn
   Live |= LiveIn;
   // Check result, set LiveIn=Live
   Changed = (Live != LiveIn);
   if (Changed)
     LiveIn = Live;
   return Changed;
 }
 
-#ifndef NDEBUG
-namespace {
-
-bool comparePair(const LiveBeginEndMapEntry &A, const LiveBeginEndMapEntry &B) {
-  return A.first == B.first;
-}
-
-} // end of anonymous namespace
-#endif // NDEBUG
-
 // Now that basic liveness is complete, remove dead instructions that
 // were tentatively marked as dead, and compute actual live ranges.
 // It is assumed that within a single basic block, a live range begins
 // at most once and ends at most once.  This is certainly true for
 // pure SSA form.  It is also true once phis are lowered, since each
 // assignment to the phi-based temporary is in a different basic
 // block, and there is a single read that ends the live in the basic
 // block that contained the actual phi instruction.
 void CfgNode::livenessPostprocess(LivenessMode Mode, Liveness *Liveness) {
   InstNumberT FirstInstNum = Inst::NumberSentinel;
@@ skipping 19 matching lines @@
     LastInstNum = I->getNumber();
     // Create fake live ranges for a Kill instruction, but only if the
     // linked instruction is still alive.
     if (Mode == Liveness_Intervals) {
       if (InstFakeKill *Kill = llvm::dyn_cast<InstFakeKill>(I)) {
         if (!Kill->getLinked()->isDeleted()) {
           SizeT NumSrcs = I->getSrcSize();
           for (SizeT Src = 0; Src < NumSrcs; ++Src) {
             Variable *Var = llvm::cast<Variable>(I->getSrc(Src));
             InstNumberT InstNumber = I->getNumber();
-            Liveness->addLiveRange(Var, InstNumber, InstNumber, 1);
+            Var->addLiveRange(InstNumber, InstNumber, 1);
           }
         }
       }
     }
   }
   if (Mode != Liveness_Intervals)
     return;
   TimerMarker T1(TimerStack::TT_liveRangeCtor, Func);
 
   SizeT NumVars = Liveness->getNumVarsInNode(this);
   LivenessBV &LiveIn = Liveness->getLiveIn(this);
   LivenessBV &LiveOut = Liveness->getLiveOut(this);
   LiveBeginEndMap &MapBegin = *Liveness->getLiveBegin(this);
   LiveBeginEndMap &MapEnd = *Liveness->getLiveEnd(this);
   std::sort(MapBegin.begin(), MapBegin.end());
   std::sort(MapEnd.begin(), MapEnd.end());
   // Verify there are no duplicates.
-  assert(std::adjacent_find(MapBegin.begin(), MapBegin.end(), comparePair) ==
+  struct ComparePair {
+    bool operator()(const LiveBeginEndMapEntry &A,
+                    const LiveBeginEndMapEntry &B) {
+      return A.first == B.first;
+    }
+  };
+  assert(std::adjacent_find(MapBegin.begin(), MapBegin.end(), ComparePair()) ==
          MapBegin.end());
-  assert(std::adjacent_find(MapEnd.begin(), MapEnd.end(), comparePair) ==
+  assert(std::adjacent_find(MapEnd.begin(), MapEnd.end(), ComparePair()) ==
          MapEnd.end());
 
   LivenessBV LiveInAndOut = LiveIn;
   LiveInAndOut &= LiveOut;
 
   // Iterate in parallel across the sorted MapBegin[] and MapEnd[].
   auto IBB = MapBegin.begin(), IEB = MapEnd.begin();
   auto IBE = MapBegin.end(), IEE = MapEnd.end();
   while (IBB != IBE || IEB != IEE) {
     SizeT i1 = IBB == IBE ? NumVars : IBB->first;
     SizeT i2 = IEB == IEE ? NumVars : IEB->first;
     SizeT i = std::min(i1, i2);
     // i1 is the Variable number of the next MapBegin entry, and i2 is
     // the Variable number of the next MapEnd entry.  If i1==i2, then
     // the Variable's live range begins and ends in this block.  If
     // i1<i2, then i1's live range begins at instruction IBB->second
     // and extends through the end of the block.  If i1>i2, then i2's
     // live range begins at the first instruction of the block and
     // ends at IEB->second.  In any case, we choose the lesser of i1
     // and i2 and proceed accordingly.
     InstNumberT LB = i == i1 ? IBB->second : FirstInstNum;
     InstNumberT LE = i == i2 ? IEB->second : LastInstNum + 1;
 
     Variable *Var = Liveness->getVariable(i, this);
     if (!Var->getIgnoreLiveness()) {
       if (LB > LE) {
-        Liveness->addLiveRange(Var, FirstInstNum, LE, 1);
-        Liveness->addLiveRange(Var, LB, LastInstNum + 1, 1);
+        Var->addLiveRange(FirstInstNum, LE, 1);
+        Var->addLiveRange(LB, LastInstNum + 1, 1);
         // Assert that Var is a global variable by checking that its
         // liveness index is less than the number of globals.  This
         // ensures that the LiveInAndOut[] access is valid.
         assert(i < Liveness->getNumGlobalVars());
         LiveInAndOut[i] = false;
       } else {
-        Liveness->addLiveRange(Var, LB, LE, 1);
+        Var->addLiveRange(LB, LE, 1);
       }
     }
     if (i == i1)
       ++IBB;
     if (i == i2)
       ++IEB;
   }
   // Process the variables that are live across the entire block.
   for (int i = LiveInAndOut.find_first(); i != -1;
        i = LiveInAndOut.find_next(i)) {
     Variable *Var = Liveness->getVariable(i, this);
-    Liveness->addLiveRange(Var, FirstInstNum, LastInstNum + 1, 1);
+    Var->addLiveRange(FirstInstNum, LastInstNum + 1, 1);
   }
 }
 
 void CfgNode::doBranchOpt(const CfgNode *NextNode) {
   TargetLowering *Target = Func->getTarget();
   // Check every instruction for a branch optimization opportunity.
   // It may be more efficient to iterate in reverse and stop after the
   // first opportunity, unless there is some target lowering where we
   // have the possibility of multiple such optimizations per block
   // (currently not the case for x86 lowering).
@@ skipping 107 matching lines @@
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice