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 noRegister() {return Value == NoRegisterValue;}

[Jim Stichnoth, 2016/02/12 02:20:15]

This seems OK.  I might change the name to something like "isNoReg" or
"isDefined" or "isSet" or "hasValue", to make it more clear that it's a
predicate function.

In any case, the method should be marked const.

A separate idea is to change all of these:
  auto RegNum = RegNumT::NoRegister;
to:
  RegNumT RegNum;

because of the RegNumT ctor.  Together, the somewhat clumsy explicit references
to NoRegister would be greatly reduced.  I'm not totally sold on this idea
though, because RegNumT looks an awful lot like a scalar type and we usually
need to explicitly initialize scalar types.

[rkotlerimgtec, 2016/02/12 03:00:16]

I've made the change to the predicate.

I think it's a good idea to just let the constructor take care of
initializing variables of type RegNumT. I'm usually for being more
concise. I think in general we want to eliminate all uses of int
and such for things that are not fundamentally numbers (a register number is not
really a number so in that case it should be of some
class type with an appropriate constructor).

+
 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 467 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H