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

src/IceDefs.h

 //===- subzero/src/IceDefs.h - Common Subzero declarations ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 164 matching lines @@
 
 /// SizeT is for holding small-ish limits like number of source operands in an
 /// instruction. It is used instead of size_t (which may be 64-bits wide) when
 /// we want to save space.
 using SizeT = uint32_t;
 
 /// InstNumberT is for holding an instruction number. Instruction numbers are
 /// used for representing Variable live ranges.
 using InstNumberT = int32_t;
 
+/// RegNumT is for holding target-specific register numbers, plus the sentinel
+/// value NoRegister.
+class RegNumT {
+public:
+  using BaseType = uint32_t;
+  // TODO(stichnot): This ctor is explicitly not "explicit".  Find a way to make
+  // it explicit without imposing an undue burden on its users.
+  RegNumT(BaseType Value) : Value(Value) {}

[Eric Holk, 2016/02/08 19:37:09]

Should this check that Value is a legal register value?

[Jim Stichnoth, 2016/02/09 19:33:39]

I don't really think it's possible to check for validity, since this is a
high-level ICE construct and the specific values supplied will be
target-specific.  Or did you have another idea?

[Eric Holk, 2016/02/10 01:11:30]

Hmm, good point. I guess you'd have to do something like have a RegNumARM32T,
RegNumX86T, etc and have each of them handle validating. You could do it with a
protected constructor to prevent rogue register numbers from being created, but
it might make it hard to create new registers variables and such in the
target-independent code.

+  RegNumT() = default;
+  RegNumT(const RegNumT &) = default;
+  RegNumT &operator=(const RegNumT &) = default;
+  operator unsigned() const { return Value; }
+  /// Marks cases that inappropriately add/subtract RegNumT values, and
+  /// therefore need to be fixed because they make assumptions about register
+  /// enum value ordering.
+  static RegNumT fixme(BaseType Value) { return RegNumT(Value); }

[Eric Holk, 2016/02/08 19:37:09]

Is the idea that eventually we won't do any conversion to and from integers and
then fixme will go away?

[Jim Stichnoth, 2016/02/09 19:33:39]

Yes - added a TODO to remove the method when all uses are fixed.

[Eric Holk, 2016/02/10 01:11:30]

Sounds good.

+  static constexpr BaseType NoRegister = std::numeric_limits<BaseType>::max();
+
+private:
+  BaseType Value = NoRegister;
+  /// Disallow operators that inappropriately make assumptions about register
+  /// enum value ordering.
+  bool operator<(const RegNumT &) = delete;
+  bool operator<=(const RegNumT &) = delete;
+  bool operator>(const RegNumT &) = delete;
+  bool operator>=(const RegNumT &) = delete;
+};
+
 /// A LiveBeginEndMapEntry maps a Variable::Number value to an Inst::Number
 /// value, giving the instruction number that begins or ends a variable's live
 /// range.
 using LiveBeginEndMapEntry = std::pair<SizeT, InstNumberT>;
 using LiveBeginEndMap = CfgVector<LiveBeginEndMapEntry>;
 using LivenessBV = llvm::BitVector;
 
 using TimerStackIdT = uint32_t;
 using TimerIdT = uint32_t;
 
@@ skipping 114 matching lines @@
   RPE_PooledConstantReordering,
   RPE_RegAllocRandomization,
   RPE_num
 };
 
 using RelocOffsetArray = llvm::SmallVector<class RelocOffset *, 4>;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H