Weight variables by their number of uses for register allocation.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 81 matching lines @@
   // register allocation since no overlap opportunities should be available and
   // it's more expensive to look for opportunities.
   FindOverlap = (Kind != RAK_Phi);
   const VarList &Vars = Func->getVariables();
   Unhandled.reserve(Vars.size());
   UnhandledPrecolored.reserve(Vars.size());
   // Gather the live ranges of all variables and add them to the Unhandled set.
   for (Variable *Var : Vars) {
     // Explicitly don't consider zero-weight variables, which are meant to be
     // spill slots.
-    if (Var->getWeight().isZero())
+    if (Var->mustNotHaveReg())
       continue;
     // Don't bother if the variable has a null live range, which means it was
     // never referenced.
     if (Var->getLiveRange().isEmpty())
       continue;
     Var->untrimLiveRange();
     Unhandled.push_back(Var);
     if (Var->hasReg()) {
       Var->setRegNumTmp(Var->getRegNum());
-      Var->setLiveRangeInfiniteWeight();
+      Var->setMustHaveReg();
       UnhandledPrecolored.push_back(Var);
     }
   }
 
   // Build the (ordered) list of FakeKill instruction numbers.
   Kills.clear();
   // Phi lowering should not be creating new call instructions, so there should
   // be no infinite-weight not-yet-colored live ranges that span a call
   // instruction, hence no need to construct the Kills list.
   if (Kind == RAK_Phi)
@@ skipping 43 matching lines @@
   // Iterate across all instructions and record the begin and end of the live
   // range for each variable that is pre-colored or infinite weight.
   std::vector<InstNumberT> LRBegin(Vars.size(), Inst::NumberSentinel);
   std::vector<InstNumberT> LREnd(Vars.size(), Inst::NumberSentinel);
   for (CfgNode *Node : Func->getNodes()) {
     for (Inst &Inst : Node->getInsts()) {
       if (Inst.isDeleted())
         continue;
       if (const Variable *Var = Inst.getDest()) {
         if (!Var->getIgnoreLiveness() &&
-            (Var->hasReg() || Var->getWeight().isInf())) {
+            (Var->hasReg() || Var->mustHaveReg())) {
           if (LRBegin[Var->getIndex()] == Inst::NumberSentinel) {
             LRBegin[Var->getIndex()] = Inst.getNumber();
             ++NumVars;
           }
         }
       }
       for (SizeT I = 0; I < Inst.getSrcSize(); ++I) {
         Operand *Src = Inst.getSrc(I);
         SizeT NumVars = Src->getNumVars();
         for (SizeT J = 0; J < NumVars; ++J) {
           const Variable *Var = Src->getVar(J);
           if (Var->getIgnoreLiveness())
             continue;
-          if (Var->hasReg() || Var->getWeight().isInf())
+          if (Var->hasReg() || Var->mustHaveReg())
             LREnd[Var->getIndex()] = Inst.getNumber();
         }
       }
     }
   }
 
   Unhandled.reserve(NumVars);
   UnhandledPrecolored.reserve(NumVars);
   for (SizeT i = 0; i < Vars.size(); ++i) {
     Variable *Var = Vars[i];
     if (LRBegin[i] != Inst::NumberSentinel) {
       assert(LREnd[i] != Inst::NumberSentinel);
       Unhandled.push_back(Var);
       Var->resetLiveRange();
-      constexpr uint32_t WeightDelta = 1;
-      Var->addLiveRange(LRBegin[i], LREnd[i], WeightDelta);
+      Var->addLiveRange(LRBegin[i], LREnd[i]);
       Var->untrimLiveRange();
       if (Var->hasReg()) {
         Var->setRegNumTmp(Var->getRegNum());
-        Var->setLiveRangeInfiniteWeight();
+        Var->setMustHaveReg();
         UnhandledPrecolored.push_back(Var);
       }
       --NumVars;
     }
   }
   // This isn't actually a fatal condition, but it would be nice to know if we
   // somehow pre-calculated Unhandled's size wrong.
   assert(NumVars == 0);
 
   // Don't build up the list of Kills because we know that no infinite-weight
@@ skipping 291 matching lines @@
   ++RegUses[RegNum];
   Active.push_back(Iter.Cur);
 }
 
 void LinearScan::handleNoFreeRegisters(IterationState &Iter) {
   // Check Active ranges.
   for (const Variable *Item : Active) {
     assert(Item->rangeOverlaps(Iter.Cur));
     int32_t RegNum = Item->getRegNumTmp();
     assert(Item->hasRegTmp());
-    Iter.Weights[RegNum].addWeight(Item->getLiveRange().getWeight());
+    Iter.Weights[RegNum].addWeight(Item->getWeight(Func));
   }
   // Same as above, but check Inactive ranges instead of Active.
   for (const Variable *Item : Inactive) {
     int32_t RegNum = Item->getRegNumTmp();
     assert(Item->hasRegTmp());
     if (Item->rangeOverlaps(Iter.Cur))
-      Iter.Weights[RegNum].addWeight(Item->getLiveRange().getWeight());
+      Iter.Weights[RegNum].addWeight(Item->getWeight(Func));
   }
 
   // All the weights are now calculated. Find the register with smallest
   // weight.
   int32_t MinWeightIndex = Iter.RegMask.find_first();
   // MinWeightIndex must be valid because of the initial RegMask.any() test.
   assert(MinWeightIndex >= 0);
   for (SizeT i = MinWeightIndex + 1; i < Iter.Weights.size(); ++i) {
     if (Iter.RegMask[i] && Iter.Weights[i] < Iter.Weights[MinWeightIndex])
       MinWeightIndex = i;
   }
 
-  if (Iter.Cur->getLiveRange().getWeight() <= Iter.Weights[MinWeightIndex]) {
+  if (Iter.Cur->getWeight(Func) <= Iter.Weights[MinWeightIndex]) {
     // Cur doesn't have priority over any other live ranges, so don't allocate
     // any register to it, and move it to the Handled state.
     Handled.push_back(Iter.Cur);
-    if (Iter.Cur->getLiveRange().getWeight().isInf()) {
+    if (Iter.Cur->mustHaveReg()) {
       if (Kind == RAK_Phi)
         addSpillFill(Iter);
       else
         Func->setError("Unable to find a physical register for an "
                        "infinite-weight live range");
     }
   } else {
     // Evict all live ranges in Active that register number MinWeightIndex is
     // assigned to.
     for (SizeT I = Active.size(); I > 0; --I) {
@@ skipping 281 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice