Subzero: Use a proper RegNumT type instead of int32_t/SizeT.

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 68 matching lines @@
       }
     } else if (RelocOffsetA != RelocOffsetB) {
       // or, if they are undefined, then the RelocOffsets must be the same.
       return false;
     }
   }
 
   return true;
 }
 
+RegNumT::BaseType RegNumT::Limit = 0;
+
 bool operator<(const RegWeight &A, const RegWeight &B) {
   return A.getWeight() < B.getWeight();
 }
 bool operator<=(const RegWeight &A, const RegWeight &B) { return !(B < A); }
 bool operator==(const RegWeight &A, const RegWeight &B) {
   return !(B < A) && !(A < B);
 }
 
 void LiveRange::addSegment(InstNumberT Start, InstNumberT End) {
   if (!Range.empty()) {
@@ skipping 84 matching lines @@
   while (TrimmedBegin != Range.end() && TrimmedBegin->second <= Lower)
     ++TrimmedBegin;
 }
 
 IceString Variable::getName(const Cfg *Func) const {
   if (Func && NameIndex >= 0)
     return Func->getIdentifierName(NameIndex);
   return "__" + std::to_string(getIndex());
 }
 
-const Variable *Variable::asType(Type Ty, int32_t NewRegNum) const {
+const Variable *Variable::asType(Type Ty, RegNumT NewRegNum) const {
   // Note: This returns a Variable, even if the "this" object is a subclass of
   // Variable.
   if (!BuildDefs::dump() || getType() == Ty)
     return this;
   Variable *V = new (getCurrentCfgAllocator()->Allocate<Variable>())
       Variable(kVariable, Ty, Number);
   V->NameIndex = NameIndex;
-  V->RegNum = NewRegNum == NoRegister ? RegNum : NewRegNum;
+  V->RegNum = NewRegNum == RegNumT::NoRegister ? RegNum : NewRegNum;
   V->StackOffset = StackOffset;
   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);
 }
@@ skipping 292 matching lines @@
   if (Func->isVerbose(IceV_RegOrigins) ||
       (!hasReg() && !Func->getTarget()->hasComputedFrame()))
     Str << "%" << getName(Func);
   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 << ":";
-    int32_t BaseRegisterNumber = getBaseRegNum();
-    if (BaseRegisterNumber == NoRegister)
+    auto BaseRegisterNumber = getBaseRegNum();
+    if (BaseRegisterNumber == RegNumT::NoRegister)
       BaseRegisterNumber = Func->getTarget()->getFrameOrStackReg();
     Str << "["
         << Func->getTarget()->getRegName(BaseRegisterNumber, IceType_i32);
     int32_t Offset = getStackOffset();
     if (Offset) {
       if (Offset > 0)
         Str << "+";
       Str << Offset;
     }
     Str << "]";
@@ skipping 85 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