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 425 matching lines @@
     // 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 hasNoValue() const { return !hasValue(); }

[Jim Stichnoth, 2016/02/12 18:29:54]

Nit: I would reverse the order of these two definitions.

[rkotlerimgtec, 2016/02/12 22:02:01]

Done.

+  bool hasValue() const { return Value != NoRegisterValue; }
+
 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 183 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 256 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H