Subzero: Fix a signed/unsigned warning reported on the Mac.

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction implementation ---===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the InstX8632 and OperandX8632 classes,
@@ skipping 15 matching lines @@
 const struct InstX8632BrAttributes_ {
   const char *DisplayString;
   const char *EmitString;
 } InstX8632BrAttributes[] = {
 #define X(tag, dump, emit)                                                     \
   { dump, emit }                                                               \
   ,
     ICEINSTX8632BR_TABLE
 #undef X
   };
-const size_t InstX8632BrAttributesSize =
-    llvm::array_lengthof(InstX8632BrAttributes);
 
 const struct InstX8632CmppsAttributes_ {
   const char *EmitString;
 } InstX8632CmppsAttributes[] = {
 #define X(tag, emit)                                                           \
   { emit }                                                                     \
   ,
     ICEINSTX8632CMPPS_TABLE
 #undef X
   };
-const size_t InstX8632CmppsAttributesSize =
-    llvm::array_lengthof(InstX8632CmppsAttributes);
 
 const struct TypeX8632Attributes_ {
   const char *CvtString;   // i (integer), s (single FP), d (double FP)
   const char *SdSsString;  // ss, sd, or <blank>
   const char *PackString;  // b, w, d, or <blank>
   const char *WidthString; // {byte,word,dword,qword} ptr
 } TypeX8632Attributes[] = {
 #define X(tag, elementty, cvt, sdss, pack, width)                              \
   { cvt, "" sdss, pack, width }                                                \
   ,
     ICETYPEX8632_TABLE
 #undef X
   };
-const size_t TypeX8632AttributesSize =
-    llvm::array_lengthof(TypeX8632Attributes);
 
 const char *InstX8632SegmentRegNames[] = {
 #define X(val, name) name,
   SEG_REGX8632_TABLE
 #undef X
 };
-const size_t InstX8632SegmentRegNamesSize =
-    llvm::array_lengthof(InstX8632SegmentRegNames);
 
 } // end of anonymous namespace
 
 const char *InstX8632::getWidthString(Type Ty) {
   return TypeX8632Attributes[Ty].WidthString;
 }
 
 OperandX8632Mem::OperandX8632Mem(Cfg *Func, Type Ty, Variable *Base,
                                  Constant *Offset, Variable *Index,
                                  uint16_t Shift, SegmentRegisters SegmentReg)
@@ skipping 676 matching lines @@
   Str << "cmov" << InstX8632BrAttributes[Condition].DisplayString << ".";
   Str << getDest()->getType() << " ";
   dumpDest(Func);
   Str << ", ";
   dumpSources(Func);
 }
 
 void InstX8632Cmpps::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
-  assert(Condition < InstX8632CmppsAttributesSize);
+  assert(Condition < Cmpps_Invalid);
   Str << "\t";
   Str << "cmp" << InstX8632CmppsAttributes[Condition].EmitString << "ps"
       << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(1)->emit(Func);
   Str << "\n";
 }
 
 void InstX8632Cmpps::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
-  assert(Condition < InstX8632CmppsAttributesSize);
+  assert(Condition < Cmpps_Invalid);
   dumpDest(Func);
   Str << " = cmp" << InstX8632CmppsAttributes[Condition].EmitString << "ps"
       << "\t";
   dumpSources(Func);
 }
 
 void InstX8632Cmpxchg::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 3);
   if (Locked) {
@@ skipping 561 matching lines @@
 
 void OperandX8632::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "<OperandX8632>";
 }
 
 void OperandX8632Mem::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << TypeX8632Attributes[getType()].WidthString << " ";
   if (SegmentReg != DefaultSegment) {
-    assert(SegmentReg >= 0 &&
-           static_cast<size_t>(SegmentReg) < InstX8632SegmentRegNamesSize);
+    assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
     Str << InstX8632SegmentRegNames[SegmentReg] << ":";
   }
   // TODO: The following is an almost verbatim paste of dump().
   bool Dumped = false;
   Str << "[";
   if (Base) {
     Base->emit(Func);
     Dumped = true;
   }
   if (Index) {
@@ skipping 22 matching lines @@
   } else {
     // There is only the offset.
     Offset->emit(Func);
   }
   Str << "]";
 }
 
 void OperandX8632Mem::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   if (SegmentReg != DefaultSegment) {
-    assert(SegmentReg >= 0 &&
-           static_cast<size_t>(SegmentReg) < InstX8632SegmentRegNamesSize);
+    assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
     Str << InstX8632SegmentRegNames[SegmentReg] << ":";
   }
   bool Dumped = false;
   Str << "[";
   if (Base) {
     Base->dump(Func);
     Dumped = true;
   }
   if (Index) {
     assert(Base);
@@ skipping 58 matching lines @@
   default:
     Str << "???";
     break;
   }
   Str << "(";
   Var->dump(Func);
   Str << ")";
 }
 
 } // end of namespace Ice