Weight variables by their number of uses for register allocation.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 127 matching lines @@
   if (!BuildDefs::dump() || getType() == Ty)
     return this;
   Variable *V = new (getCurrentCfgAllocator()->Allocate<Variable>())
       Variable(kVariable, Ty, Number);
   V->NameIndex = NameIndex;
   V->RegNum = RegNum;
   V->StackOffset = StackOffset;
   return V;
 }
 
+RegWeight Variable::getWeight(const Cfg *Func) const {
+  VariablesMetadata *VMetadata = Func->getVMetadata();
+  return RegWeight(mustHaveReg()
+                       ? RegWeight::Inf
+                       : mustNotHaveReg() ? RegWeight::Zero
+                                          : VMetadata->getUseWeight(this));
+}
+
 void VariableTracking::markUse(MetadataKind TrackingKind, const Inst *Instr,
                                CfgNode *Node, bool IsImplicit) {
   (void)TrackingKind;
+
+  // TODO(ascull): get the loop nest depth from CfgNode
+  UseWeight += 1;
+
   if (MultiBlock == MBS_MultiBlock)
     return;
   // TODO(stichnot): If the use occurs as a source operand in the
   // first instruction of the block, and its definition is in this
   // block's only predecessor, we might consider not marking this as a
   // separate use.  This may also apply if it's the first instruction
   // of the block that actually uses a Variable.
   assert(Node);
   bool MakeMulti = false;
   if (IsImplicit)
@@ skipping 215 matching lines @@
   return Metadata[VarNum].getLatterDefinitions();
 }
 
 CfgNode *VariablesMetadata::getLocalUseNode(const Variable *Var) const {
   if (!isTracked(Var))
     return nullptr; // conservative answer
   SizeT VarNum = Var->getIndex();
   return Metadata[VarNum].getNode();
 }
 
+uint32_t VariablesMetadata::getUseWeight(const Variable *Var) const {
+  if (!isTracked(Var))
+    return 1; // conservative answer
+  SizeT VarNum = Var->getIndex();
+  return Metadata[VarNum].getUseWeight();
+}
+
 const InstDefList VariablesMetadata::NoDefinitions;
 
 // ======================== dump routines ======================== //
 
 void Variable::emit(const Cfg *Func) const {
   if (BuildDefs::dump())
     Func->getTarget()->emitVariable(this);
 }
 
 void Variable::dump(const Cfg *Func, Ostream &Str) const {
@@ skipping 63 matching lines @@
   }
   if (Offset)
     Str << "+" << Offset;
 }
 
 void ConstantUndef::emit(TargetLowering *Target) const { Target->emit(this); }
 
 void LiveRange::dump(Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
-  Str << "(weight=" << Weight << ") ";
   bool First = true;
   for (const RangeElementType &I : Range) {
     if (!First)
       Str << ", ";
     First = false;
     Str << "[" << I.first << ":" << I.second << ")";
   }
 }
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L) {
@@ skipping 25 matching lines @@
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice