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

src/IceInstX86Base.h

 //===- subzero/src/IceInstX86Base.h - Generic x86 instructions -*- C++ -*--===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 481 matching lines @@
 
   static void emitIASRegOpTyXMM(const Cfg *Func, Type Ty, const Variable *Var,
                                 const Operand *Src,
                                 const XmmEmitterRegOp &Emitter);
 
   static void emitIASGPRShiftDouble(const Cfg *Func, const Variable *Dest,
                                     const Operand *Src1Op,
                                     const Operand *Src2Op,
                                     const GPREmitterShiftD &Emitter);
 
-  template <typename DReg_t, typename SReg_t, DReg_t (*destEnc)(int32_t),
-            SReg_t (*srcEnc)(int32_t)>
+  template <typename DReg_t, typename SReg_t, DReg_t (*destEnc)(RegNumT),
+            SReg_t (*srcEnc)(RegNumT)>
   static void emitIASCastRegOp(const Cfg *Func, Type DestTy,
                                const Variable *Dest, Type SrcTy,
                                const Operand *Src,
                                const CastEmitterRegOp<DReg_t, SReg_t> &Emitter);
 
-  template <typename DReg_t, typename SReg_t, DReg_t (*destEnc)(int32_t),
-            SReg_t (*srcEnc)(int32_t)>
+  template <typename DReg_t, typename SReg_t, DReg_t (*destEnc)(RegNumT),
+            SReg_t (*srcEnc)(RegNumT)>
   static void
   emitIASThreeOpImmOps(const Cfg *Func, Type DispatchTy, const Variable *Dest,
                        const Operand *Src0, const Operand *Src1,
                        const ThreeOpImmEmitter<DReg_t, SReg_t> Emitter);
 
   static void emitIASMovlikeXMM(const Cfg *Func, const Variable *Dest,
                                 const Operand *Src,
                                 const XmmEmitterMovOps Emitter);
 
   static void emitVariableBlendInst(const char *Opcode, const Inst *Instr,
@@ skipping 517 matching lines @@
       if (const auto *SrcVar =
               llvm::dyn_cast<const Variable>(this->getSrc(0))) {
         if (SrcVar->hasReg() && this->Dest->hasReg()) {
           // An assignment between physical registers is considered redundant if
           // they have the same base register and the same encoding. E.g.:
           //   mov cl, ecx ==> redundant
           //   mov ch, ecx ==> not redundant due to different encodings
           //   mov ch, ebp ==> not redundant due to different base registers
           //   mov ecx, ecx ==> redundant, and dangerous in x86-64. i64 zexting
           //                    is handled by Inst86Zext.
-          const int32_t SrcReg = SrcVar->getRegNum();
-          const int32_t DestReg = this->Dest->getRegNum();
+          const RegNumT SrcReg = SrcVar->getRegNum();
+          const RegNumT DestReg = this->Dest->getRegNum();
           return (Traits::getEncoding(SrcReg) ==
                   Traits::getEncoding(DestReg)) &&
                  (Traits::getBaseReg(SrcReg) == Traits::getBaseReg(DestReg));
         }
       }
       return checkForRedundantAssign(this->getDest(), this->getSrc(0));
     }
     bool isVarAssign() const override {
       return llvm::isa<Variable>(this->getSrc(0));
     }
@@ skipping 2468 matching lines @@
           &InstImpl<TraitsType>::Assembler::psrl};                             \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H