Subzero: Local variable splitting.

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 190 matching lines @@
   auto *V = new (CfgLocalAllocator<Variable>().allocate(One))
       Variable(Func, kVariable, Ty, Number);
   V->Name = Name;
   V->RegNum = NewRegNum.hasValue() ? NewRegNum : RegNum;
   V->StackOffset = StackOffset;
   V->LinkedTo = LinkedTo;
   return V;
 }
 
 RegWeight Variable::getWeight(const Cfg *Func) const {
-  VariablesMetadata *VMetadata = Func->getVMetadata();
-  return mustHaveReg() ? RegWeight(RegWeight::Inf)
-                       : mustNotHaveReg() ? RegWeight(RegWeight::Zero)
-                                          : VMetadata->getUseWeight(this);
+  if (mustHaveReg())
+    return RegWeight(RegWeight::Inf);
+  if (mustNotHaveReg())
+    return RegWeight(RegWeight::Zero);
+  return Func->getVMetadata()->getUseWeight(this);
 }
 
 void VariableTracking::markUse(MetadataKind TrackingKind, const Inst *Instr,
                                CfgNode *Node, bool IsImplicit) {
   (void)TrackingKind;
 
   // Increment the use weight depending on the loop nest depth. The weight is
   // exponential in the nest depth as inner loops are expected to be executed
   // an exponentially greater number of times.
   constexpr uint32_t LogLoopTripCountEstimate = 2; // 2^2 = 4
@@ skipping 308 matching lines @@
 void Variable::dump(const Cfg *Func, Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
   if (Func == nullptr) {
     Str << "%" << getName();
     return;
   }
   if (Func->isVerbose(IceV_RegOrigins) ||
       (!hasReg() && !Func->getTarget()->hasComputedFrame())) {
     Str << "%" << getName();
-    if (getLinkedTo() != nullptr)
-      Str << ":%" << getLinkedTo()->getName();
+    for (Variable *Link = getLinkedTo(); Link != nullptr;
+         Link = Link->getLinkedTo()) {
+      Str << ":%" << Link->getName();
+    }
   }
   if (hasReg()) {
     if (Func->isVerbose(IceV_RegOrigins))
       Str << ":";
     Str << Func->getTarget()->getRegName(RegNum, getType());
   } else if (Func->getTarget()->hasComputedFrame()) {
     if (Func->isVerbose(IceV_RegOrigins))
       Str << ":";
     const auto BaseRegisterNumber =
         hasReg() ? getBaseRegNum() : Func->getTarget()->getFrameOrStackReg();
     Str << "["
         << Func->getTarget()->getRegName(BaseRegisterNumber, IceType_i32);
-    if (hasStackOffset()) {
+    if (hasKnownStackOffset()) {
       int32_t Offset = getStackOffset();
       if (Offset) {
         if (Offset > 0)
           Str << "+";
         Str << Offset;
       }
     }
     Str << "]";
   }
 }
@@ skipping 81 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