Subzero: Prototype to make use of RegNumT::No Register more concise

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 385 matching lines @@
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
 
 private:
   ConstantUndef(Type Ty) : Constant(kConstUndef, Ty) {}
 };
 
 /// RegNumT is for holding target-specific register numbers, plus the sentinel
-/// value NoRegister.  Its public ctor allows direct use of enum values, such as
-/// RegNumT(Reg_eax), but not things like RegNumT(Reg_eax+1).  This is to try to
-/// prevent inappropriate assumptions about enum ordering.  If needed, the
-/// fromInt() method can be used, such as when a RegNumT is based on a bitvector
-/// index.
+/// value if no register is assigned. Its public ctor allows direct use of enum
+/// values, such as RegNumT(Reg_eax), but not things like RegNumT(Reg_eax+1).
+/// This is to try to prevent inappropriate assumptions about enum ordering. If
+/// needed, the fromInt() method can be used, such as when a RegNumT is based
+/// on a bitvector index.
 class RegNumT {
 public:
   using BaseType = uint32_t;
   RegNumT() = default;
   RegNumT(const RegNumT &) = default;
   template <typename AnyEnum>
   RegNumT(AnyEnum Value,
           typename std::enable_if<std::is_enum<AnyEnum>::value, int>::type = 0)
       : Value(Value) {
     validate(Value);
@@ skipping 13 matching lines @@
   /// upper bound of allowable values.
   static void setLimit(BaseType Value) {
     // Make sure it's only called once.
     assert(Limit == 0);
     assert(Value != 0);
     Limit = Value;
   }
   // Define NoRegisterValue as an enum value so that it can be used as an
   // argument for the public ctor if desired.
   enum { NoRegisterValue = std::numeric_limits<BaseType>::max() };
-  const static RegNumT NoRegister /* = NoRegisterValue */;
+
+  bool hasValue() const { return Value != NoRegisterValue; }
+  bool hasNoValue() const { return !hasValue(); }
 
 private:
   BaseType Value = NoRegisterValue;
   static BaseType Limit;
   /// Private ctor called only by fromInt() and fixme().
   RegNumT(BaseType Value) : Value(Value) { validate(Value); }
   /// The ctor calls this to validate against the target-supplied limit.
   static void validate(BaseType Value) {
     (void)Value;
     assert(Value == NoRegisterValue || Value < Limit);
@@ skipping 184 matching lines @@
   bool getIgnoreLiveness() const { return IgnoreLiveness; }
 
   int32_t getStackOffset() const { return StackOffset; }
   void setStackOffset(int32_t Offset) { StackOffset = Offset; }
   /// Returns the variable's stack offset in symbolic form, to improve
   /// readability in DecorateAsm mode.
   IceString getSymbolicStackOffset(const Cfg *Func) const {
     return "lv$" + getName(Func);
   }
 
-  bool hasReg() const { return getRegNum() != RegNumT::NoRegister; }
+  bool hasReg() const { return getRegNum().hasValue(); }
   RegNumT getRegNum() const { return RegNum; }
   void setRegNum(RegNumT NewRegNum) {
     // Regnum shouldn't be set more than once.
     assert(!hasReg() || RegNum == NewRegNum);
     RegNum = NewRegNum;
   }
-  bool hasRegTmp() const { return getRegNumTmp() != RegNumT::NoRegister; }
+  bool hasRegTmp() const { return getRegNumTmp().hasValue(); }
   RegNumT getRegNumTmp() const { return RegNumTmp; }
   void setRegNumTmp(RegNumT NewRegNum) { RegNumTmp = NewRegNum; }
 
   RegWeight getWeight(const Cfg *Func) const;
 
   void setMustHaveReg() { RegRequirement = RR_MustHaveRegister; }
   bool mustHaveReg() const { return RegRequirement == RR_MustHaveRegister; }
   void setMustNotHaveReg() { RegRequirement = RR_MustNotHaveRegister; }
   bool mustNotHaveReg() const {
     return RegRequirement == RR_MustNotHaveRegister;
@@ skipping 28 matching lines @@
   }
   bool rangeOverlapsStart(const Variable *Other) const {
     constexpr bool UseTrimmed = true;
     return Live.overlapsInst(Other->Live.getStart(), UseTrimmed);
   }
 
   /// Creates a temporary copy of the variable with a different type. Used
   /// primarily for syntactic correctness of textual assembly emission. Note
   /// that only basic information is copied, in particular not IsArgument,
   /// IsImplicitArgument, IgnoreLiveness, RegNumTmp, Live, LoVar, HiVar,
-  /// VarsReal.  If NewRegNum!=NoRegister, then that register assignment is made
+  /// VarsReal. If NewRegNum.hasValue(), then that register assignment is made
   /// instead of copying the existing assignment.
   const Variable *asType(Type Ty, RegNumT NewRegNum) const;
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   /// Return reg num of base register, if different from stack/frame register.
-  virtual RegNumT getBaseRegNum() const { return RegNumT::NoRegister; }
+  virtual RegNumT getBaseRegNum() const { return RegNumT(); }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Max;
   }
 
 protected:
   Variable(OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index),
         RegisterClass(static_cast<RegClass>(Ty)) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
   /// Number is unique across all variables, and is used as a (bit)vector index
   /// for liveness analysis.
   const SizeT Number;
   Cfg::IdentifierIndexType NameIndex = Cfg::IdentifierIndexInvalid;
   bool IsArgument = false;
   bool IsImplicitArgument = false;
   /// IgnoreLiveness means that the variable should be ignored when constructing
   /// and validating live ranges. This is usually reserved for the stack
   /// pointer and other physical registers specifically referenced by name.
   bool IgnoreLiveness = false;
   // If IsRematerializable, RegNum keeps track of which register (stack or frame
   // pointer), and StackOffset is the known offset from that register.
   bool IsRematerializable = false;
   RegRequirement RegRequirement = RR_MayHaveRegister;
   RegClass RegisterClass;
-  /// RegNum is the allocated register, or NoRegister if it isn't
-  /// register-allocated.
-  RegNumT RegNum = RegNumT::NoRegister;
+  /// RegNum is the allocated register, (as long as RegNum.hasValue() is true).
+  RegNumT RegNum;
   /// RegNumTmp is the tentative assignment during register allocation.
-  RegNumT RegNumTmp = RegNumT::NoRegister;
+  RegNumT RegNumTmp;
   /// StackOffset is the canonical location on stack (only if
-  /// RegNum==NoRegister || IsArgument).
+  /// RegNum.hasNoValue() || IsArgument).
   int32_t StackOffset = 0;
   LiveRange Live;
   /// VarsReal (and Operand::Vars) are set up such that Vars[0] == this.
   Variable *VarsReal[1];
 };
 
 // Variable64On32 represents a 64-bit variable on a 32-bit architecture. In
 // this situation the variable must be split into a low and a high word.
 class Variable64On32 : public Variable {
   Variable64On32() = delete;
@@ skipping 162 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H