Subzero: Fix and clean up some cross tests.

crosstest/test_cast_main.cpp

+//===- subzero/crosstest/test_cast_main.cpp - Driver for tests ------------===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Driver for crosstesting cast operations.
+//
+//===----------------------------------------------------------------------===//
+
 /* crosstest.py --test=test_cast.cpp --test=test_cast_to_u1.ll \
    --driver=test_cast_main.cpp --prefix=Subzero_ --output=test_cast */
 
 #include <cstring>
 #include <iostream>
 #include <stdint.h>
 
 // Include test_cast.h twice - once normally, and once within the
 // Subzero_ namespace, corresponding to the llc and Subzero translated
 // object files, respectively.
@@ skipping 18 matching lines @@
                 << "<" XSTR(FromCName) ", " XSTR(ToCName) ">(" << Input        \
                 << "): sz=" << ResultSz << " llc=" << ResultLlc << "\n";       \
     }                                                                          \
   } while (0)
 
 template <typename FromType>
 void testValue(FromType Val, size_t &TotalTests, size_t &Passes,
                size_t &Failures) {
   COMPARE(cast, FromType, bool, Val);
   COMPARE(cast, FromType, uint8_t, Val);
-  COMPARE(cast, FromType, int8_t, Val);
+  COMPARE(cast, FromType, myint8_t, Val);
   COMPARE(cast, FromType, uint16_t, Val);
   COMPARE(cast, FromType, int16_t, Val);
   COMPARE(cast, FromType, uint32_t, Val);
   COMPARE(cast, FromType, int32_t, Val);
   COMPARE(cast, FromType, uint64_t, Val);
   COMPARE(cast, FromType, int64_t, Val);
   COMPARE(cast, FromType, float, Val);
   COMPARE(cast, FromType, double, Val);
 }
 
 int main(int argc, char **argv) {
   size_t TotalTests = 0;
   size_t Passes = 0;
   size_t Failures = 0;
 
   volatile bool ValsUi1[] = { false, true };
   static const size_t NumValsUi1 = sizeof(ValsUi1) / sizeof(*ValsUi1);
   volatile uint8_t ValsUi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff };
   static const size_t NumValsUi8 = sizeof(ValsUi8) / sizeof(*ValsUi8);
 
-  volatile int8_t ValsSi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff };
+  volatile myint8_t ValsSi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff };
   static const size_t NumValsSi8 = sizeof(ValsSi8) / sizeof(*ValsSi8);
 
   volatile uint16_t ValsUi16[] = { 0,      1,      0x7e,   0x7f,   0x80,
                                    0x81,   0xfe,   0xff,   0x7ffe, 0x7fff,
                                    0x8000, 0x8001, 0xfffe, 0xffff };
   static const size_t NumValsUi16 = sizeof(ValsUi16) / sizeof(*ValsUi16);
 
   volatile int16_t ValsSi16[] = { 0,      1,      0x7e,   0x7f,   0x80,
                                   0x81,   0xfe,   0xff,   0x7ffe, 0x7fff,
                                   0x8000, 0x8001, 0xfffe, 0xffff };
@@ skipping 73 matching lines @@
 
   for (size_t i = 0; i < NumValsUi1; ++i) {
     bool Val = ValsUi1[i];
     testValue<bool>(Val, TotalTests, Passes, Failures);
   }
   for (size_t i = 0; i < NumValsUi8; ++i) {
     uint8_t Val = ValsUi8[i];
     testValue<uint8_t>(Val, TotalTests, Passes, Failures);
   }
   for (size_t i = 0; i < NumValsSi8; ++i) {
-    int8_t Val = ValsSi8[i];
-    testValue<int8_t>(Val, TotalTests, Passes, Failures);
+    myint8_t Val = ValsSi8[i];
+    testValue<myint8_t>(Val, TotalTests, Passes, Failures);
   }
   for (size_t i = 0; i < NumValsUi16; ++i) {
     uint16_t Val = ValsUi16[i];
     testValue<uint16_t>(Val, TotalTests, Passes, Failures);
   }
   for (size_t i = 0; i < NumValsSi16; ++i) {
     int16_t Val = ValsSi16[i];
     testValue<int16_t>(Val, TotalTests, Passes, Failures);
   }
   for (size_t i = 0; i < NumValsUi32; ++i) {
@@ skipping 50 matching lines @@
 int64_t cvtftosi64(float a) { return (int64_t)a; }
 uint64_t cvtdtoui64(double a) { return (uint64_t)a; }
 uint64_t cvtftoui64(float a) { return (uint64_t)a; }
 float cvtui64tof(uint64_t a) { return (float)a; }
 double cvtui64tod(uint64_t a) { return (double)a; }
 float cvtsi64tof(int64_t a) { return (float)a; }
 float cvtui32tof(uint32_t a) { return (float)a; }
 double cvtui32tod(uint32_t a) { return (double)a; }
 double cvtsi64tod(int64_t a) { return (double)a; }
 }