Implements include/exclude register lists for translation.

src/IceRegistersARM32.h

 //===- subzero/src/IceRegistersARM32.h - Register information ---*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 31 matching lines @@
     static constexpr std::size_t value = 1 + __length<U...>::value;
   };
 
   template <typename T> struct __length<T> {
     static constexpr std::size_t value = 1;
   };
 
   const std::size_t Size;
 };
 
+// TODO(kschimpf) Change this class to a namespace.

[Jim Stichnoth, 2016/01/14 22:04:19]

I think you should just revert this file entirely, since there are really no
changes directly related to this CL.

I suppose the TODO could stay, or just keep a mental note.

[Karl, 2016/01/14 23:54:51]

Reverted.

 class RegARM32 {
 private:
   RegARM32() = delete;
   RegARM32(const RegARM32 &) = delete;
   RegARM32 &operator=(const RegARM32 &) = delete;
   ~RegARM32() = delete;
 
 public:
   /// An enum of every register. The enum value may not match the encoding used
   /// to binary encode register operands in instructions.
@@ skipping 77 matching lines @@
   {                                                                            \
     name, encode, cc_arg, scratch, preserved, stackptr, frameptr, isGPR,       \
         isInt, isI64Pair, isFP32, isFP64, isVec128,                            \
         (SizeOf alias_init).size(), alias_init                                 \
   }                                                                            \
   ,
       REGARM32_TABLE
 #undef X
   };
 
-  static inline void assertRegisterDefined(int32_t RegNum) {
+  static void assertRegisterDefined(int32_t RegNum) {
     (void)RegNum;
     assert(RegNum >= 0);
     assert(RegNum < Reg_NUM);
   }
 
-  static inline bool isGPRegister(int32_t RegNum) {
+  static bool isGPRegister(int32_t RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].IsGPR;
   }
 
   static constexpr SizeT getNumGPRegs() {
     return 0
 #define X(val, encode, name, cc_arg, scratch, preserved, stackptr, frameptr,   \
           isGPR, isInt, isI64Pair, isFP32, isFP64, isVec128, alias_init)       \
   +(isGPR)
         REGARM32_TABLE
 #undef X
         ;
   }
 
-  static inline GPRRegister getEncodedGPR(int32_t RegNum) {
+  static GPRRegister getEncodedGPR(int32_t RegNum) {
     assert(isGPRegister(RegNum));
     return GPRRegister(Table[RegNum].Encoding);
   }
 
   static constexpr SizeT getNumGPRs() {
     return 0
 #define X(val, encode, name, cc_arg, scratch, preserved, stackptr, frameptr,   \
           isGPR, isInt, isI64Pair, isFP32, isFP64, isVec128, alias_init)       \
   +(isGPR)
         REGARM32_TABLE
 #undef X
         ;
   }
 
-  static inline bool isGPR(SizeT RegNum) {
+  static bool isGPR(SizeT RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].IsGPR;
   }
 
-  static inline IceString getGPRName(SizeT RegNum) {
+  static IceString getGPRName(SizeT RegNum) {

[Jim Stichnoth, 2016/01/14 22:04:19]

This would more accurately be named getRegName(), right?

(but maybe left for a separate CL per the comment above?)

[Karl, 2016/01/14 23:54:51]

Acknowledged.

     assert(isGPR(RegNum));
     return Table[RegNum].Name;
   }
 
-  static inline GPRRegister getI64PairFirstGPRNum(int32_t RegNum) {
+  static GPRRegister getI64PairFirstGPRNum(int32_t RegNum) {
     assert(isI64RegisterPair(RegNum));
     return GPRRegister(Table[RegNum].Encoding);
   }
 
-  static inline GPRRegister getI64PairSecondGPRNum(int32_t RegNum) {
+  static GPRRegister getI64PairSecondGPRNum(int32_t RegNum) {
     assert(isI64RegisterPair(RegNum));
     return GPRRegister(Table[RegNum].Encoding + 1);
   }
 
-  static inline bool isI64RegisterPair(int32_t RegNum) {
+  static bool isI64RegisterPair(int32_t RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].IsI64Pair;
   }
 
-  static inline bool isEncodedSReg(int32_t RegNum) {
+  static bool isEncodedSReg(int32_t RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].IsFP32;
   }
 
   static constexpr SizeT getNumSRegs() {
     return 0
 #define X(val, encode, name, cc_arg, scratch, preserved, stackptr, frameptr,   \
           isGPR, isInt, isI64Pair, isFP32, isFP64, isVec128, alias_init)       \
   +(isFP32)
         REGARM32_TABLE
 #undef X
         ;
   }
 
-  static inline IceString getSRegName(SizeT RegNum) {
+  static IceString getSRegName(SizeT RegNum) {
     assert(isEncodedSReg(RegNum));
     return Table[RegNum].Name;
   }
 
-  static inline SRegister getEncodedSReg(int32_t RegNum) {
+  static SRegister getEncodedSReg(int32_t RegNum) {
     assert(isEncodedSReg(RegNum));
     return SRegister(Table[RegNum].Encoding);
   }
 
-  static inline bool isEncodedDReg(int32_t RegNum) {
+  static bool isEncodedDReg(int32_t RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].IsFP64;
   }
 
-  static constexpr inline SizeT getNumDRegs() {
+  static constexpr SizeT getNumDRegs() {
     return 0
 #define X(val, encode, name, cc_arg, scratch, preserved, stackptr, frameptr,   \
           isGPR, isInt, isI64Pair, isFP32, isFP64, isVec128, alias_init)       \
   +(isFP64)
         REGARM32_TABLE
 #undef X
         ;
   }
 
-  static inline DRegister getEncodedDReg(int32_t RegNum) {
+  static DRegister getEncodedDReg(int32_t RegNum) {
     assert(isEncodedDReg(RegNum));
     return DRegister(Table[RegNum].Encoding);
   }
 
-  static inline bool isEncodedQReg(int32_t RegNum) {
+  static bool isEncodedQReg(int32_t RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].IsVec128;
   }
 
-  static inline QRegister getEncodedQReg(int32_t RegNum) {
+  static QRegister getEncodedQReg(int32_t RegNum) {
     assert(isEncodedQReg(RegNum));
     return QRegister(Table[RegNum].Encoding);
   }
 
-  static inline IceString getRegName(int32_t RegNum) {
+  static IceString getRegName(int32_t RegNum) {
     assertRegisterDefined(RegNum);
     return Table[RegNum].Name;
   }
 };
 
 // Extend enum RegClass with ARM32-specific register classes (if any).
 enum RegClassARM32 : uint8_t { RCARM32_NUM = RC_Target };
 
 } // end of namespace ARM32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEREGISTERSARM32_H