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

src/IceRegistersARM32.h

Index: src/IceRegistersARM32.h
diff --git a/src/IceRegistersARM32.h b/src/IceRegistersARM32.h
index 94f45c137557cb8b03329330ccb0ae547ca1ea76..a6601e204e9e6d1bde54d82b390bc3e2650bdb6b 100644
--- a/src/IceRegistersARM32.h
+++ b/src/IceRegistersARM32.h
@@ -102,9 +102,14 @@ extern struct RegTableType {
 #undef NUM_ALIASES_BITS
 } RegTable[Reg_NUM];
 
-static inline bool isGPRegister(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline void assertValidRegNum(RegNumT RegNum) {
+  (void)RegNum;
+  assert(RegNum != RegNumT::NoRegister);
+  assert(unsigned(RegNum) < Reg_NUM);

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

Isn't this the sort of thing fixme is supposed to flag?

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

fixme() is really to flag inappropriate arithmetic operations on enum values. 
Since RegNumT is high-level ICE without knowledge of target-specific register
values, the check ends up being here.

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

Sounds good.

Yeah, I guess this isn't really making any decisions based on register ordering
(like I did to determine QtoS registers), so there's no harm in this comparison.

+}
+
+static inline bool isGPRegister(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].IsGPR;
 }
 
@@ -118,9 +123,8 @@ static constexpr inline SizeT getNumGPRegs() {
       ;
 }
 
-static inline GPRRegister getEncodedGPR(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline GPRRegister getEncodedGPR(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return GPRRegister(RegTable[RegNum].Encoding);
 }
 
@@ -134,33 +138,28 @@ static constexpr inline SizeT getNumGPRs() {
       ;
 }
 
-static inline bool isGPR(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline bool isGPR(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].IsGPR;
 }
 
-static inline GPRRegister getI64PairFirstGPRNum(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline GPRRegister getI64PairFirstGPRNum(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return GPRRegister(RegTable[RegNum].Encoding);
 }
 
-static inline GPRRegister getI64PairSecondGPRNum(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline GPRRegister getI64PairSecondGPRNum(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return GPRRegister(RegTable[RegNum].Encoding + 1);
 }
 
-static inline bool isI64RegisterPair(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline bool isI64RegisterPair(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].IsI64Pair;
 }
 
-static inline bool isEncodedSReg(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline bool isEncodedSReg(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].IsFP32;
 }
 
@@ -174,15 +173,13 @@ static constexpr inline SizeT getNumSRegs() {
       ;
 }
 
-static inline SRegister getEncodedSReg(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline SRegister getEncodedSReg(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return SRegister(RegTable[RegNum].Encoding);
 }
 
-static inline bool isEncodedDReg(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline bool isEncodedDReg(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].IsFP64;
 }
 
@@ -196,26 +193,23 @@ static constexpr inline SizeT getNumDRegs() {
       ;
 }
 
-static inline DRegister getEncodedDReg(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline DRegister getEncodedDReg(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return DRegister(RegTable[RegNum].Encoding);
 }
 
-static inline bool isEncodedQReg(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline bool isEncodedQReg(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].IsVec128;
 }
 
-static inline QRegister getEncodedQReg(int32_t RegNum) {
+static inline QRegister getEncodedQReg(RegNumT RegNum) {
   assert(isEncodedQReg(RegNum));
   return QRegister(RegTable[RegNum].Encoding);
 }
 
-static inline IceString getRegName(int32_t RegNum) {
-  assert(RegNum >= 0);
-  assert(RegNum < Reg_NUM);
+static inline IceString getRegName(RegNumT RegNum) {
+  assertValidRegNum(RegNum);
   return RegTable[RegNum].Name;
 }