Subzero: Fix and clean up some cross tests.

crosstest/test_arith_main.cpp

 //===- subzero/crosstest/test_arith_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 arithmetic operations
@@ skipping 32 matching lines @@
   return false;
 }
 
 template <typename TypeUnsigned, typename TypeSigned>
 void testsInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   typedef TypeUnsigned (*FuncTypeUnsigned)(TypeUnsigned, TypeUnsigned);
   typedef TypeSigned (*FuncTypeSigned)(TypeSigned, TypeSigned);
   volatile unsigned Values[] = INT_VALUE_ARRAY;
   const static size_t NumValues = sizeof(Values) / sizeof(*Values);
   static struct {
+    // For functions that operate on unsigned values, the
+    // FuncLlcSigned and FuncSzSigned fields are NULL.  For functions
+    // that operate on signed values, the FuncLlcUnsigned and
+    // FuncSzUnsigned fields are NULL.
     const char *Name;
-    FuncTypeUnsigned FuncLlc;
-    FuncTypeUnsigned FuncSz;
+    FuncTypeUnsigned FuncLlcUnsigned;
+    FuncTypeUnsigned FuncSzUnsigned;
+    FuncTypeSigned FuncLlcSigned;
+    FuncTypeSigned FuncSzSigned;
     bool ExcludeDivExceptions; // for divide related tests
   } Funcs[] = {
 #define X(inst, op, isdiv)                                                     \
-  {                                                                            \
-    STR(inst), (FuncTypeUnsigned)test##inst,                                   \
-        (FuncTypeUnsigned)Subzero_::test##inst, isdiv                          \
-  }                                                                            \
+  { STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv }           \
   ,
       UINTOP_TABLE
 #undef X
 #define X(inst, op, isdiv)                                                     \
-  {                                                                            \
-    STR(inst), (FuncTypeUnsigned)(FuncTypeSigned)test##inst,                   \
-        (FuncTypeUnsigned)(FuncTypeSigned)Subzero_::test##inst, isdiv          \
-  }                                                                            \
+  { STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv }           \
   ,
       SINTOP_TABLE
 #undef X
   };
   const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
 
   if (sizeof(TypeUnsigned) <= sizeof(uint32_t)) {
     // This is the "normal" version of the loop nest, for 32-bit or
     // narrower types.
     for (size_t f = 0; f < NumFuncs; ++f) {
       for (size_t i = 0; i < NumValues; ++i) {
         for (size_t j = 0; j < NumValues; ++j) {
           TypeUnsigned Value1 = Values[i];
           TypeUnsigned Value2 = Values[j];
           // Avoid HW divide-by-zero exception.
           if (Funcs[f].ExcludeDivExceptions &&
               inputsMayTriggerException<TypeSigned>(Value1, Value2))
             continue;
           ++TotalTests;
-          TypeUnsigned ResultSz = Funcs[f].FuncSz(Value1, Value2);
-          TypeUnsigned ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
+          TypeUnsigned ResultSz, ResultLlc;
+          if (Funcs[f].FuncSzUnsigned) {
+            ResultSz = Funcs[f].FuncSzUnsigned(Value1, Value2);
+            ResultLlc = Funcs[f].FuncLlcUnsigned(Value1, Value2);
+          } else {
+            ResultSz = Funcs[f].FuncSzSigned(Value1, Value2);
+            ResultLlc = Funcs[f].FuncLlcSigned(Value1, Value2);
+          }
           if (ResultSz == ResultLlc) {
             ++Passes;
           } else {
             ++Failures;
             std::cout << "test" << Funcs[f].Name
                       << (CHAR_BIT * sizeof(TypeUnsigned)) << "(" << Value1
                       << ", " << Value2 << "): sz=" << (unsigned)ResultSz
-                      << " llc=" << (unsigned)ResultLlc << std::endl;
+                      << " llc=" << (unsigned)ResultLlc << "\n";
           }
         }
       }
     }
   } else {
     // This is the 64-bit version.  Test values are synthesized from
     // the 32-bit values in Values[].
     for (size_t f = 0; f < NumFuncs; ++f) {
       for (size_t iLo = 0; iLo < NumValues; ++iLo) {
         for (size_t iHi = 0; iHi < NumValues; ++iHi) {
           for (size_t jLo = 0; jLo < NumValues; ++jLo) {
             for (size_t jHi = 0; jHi < NumValues; ++jHi) {
               TypeUnsigned Value1 =
                   (((TypeUnsigned)Values[iHi]) << 32) + Values[iLo];
               TypeUnsigned Value2 =
                   (((TypeUnsigned)Values[jHi]) << 32) + Values[jLo];
               if (Funcs[f].ExcludeDivExceptions &&
                   inputsMayTriggerException<TypeSigned>(Value1, Value2))
                 continue;
               ++TotalTests;
-              TypeUnsigned ResultSz = Funcs[f].FuncSz(Value1, Value2);
-              TypeUnsigned ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
+              TypeUnsigned ResultSz, ResultLlc;
+              if (Funcs[f].FuncSzUnsigned) {
+                ResultSz = Funcs[f].FuncSzUnsigned(Value1, Value2);
+                ResultLlc = Funcs[f].FuncLlcUnsigned(Value1, Value2);
+              } else {
+                ResultSz = Funcs[f].FuncSzSigned(Value1, Value2);
+                ResultLlc = Funcs[f].FuncLlcSigned(Value1, Value2);
+              }
               if (ResultSz == ResultLlc) {
                 ++Passes;
               } else {
                 ++Failures;
                 std::cout << "test" << Funcs[f].Name
                           << (CHAR_BIT * sizeof(TypeUnsigned)) << "(" << Value1
                           << ", " << Value2 << "): sz=" << (unsigned)ResultSz
-                          << " llc=" << (unsigned)ResultLlc << std::endl;
+                          << " llc=" << (unsigned)ResultLlc << "\n";
               }
             }
           }
         }
       }
     }
   }
 }
 
 const static size_t MaxTestsPerFunc = 100000;
 
 template <typename TypeUnsignedLabel, typename TypeSignedLabel>
 void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   typedef typename Vectors<TypeUnsignedLabel>::Ty TypeUnsigned;
   typedef typename Vectors<TypeSignedLabel>::Ty TypeSigned;
   typedef typename Vectors<TypeUnsignedLabel>::ElementTy ElementTypeUnsigned;
   typedef typename Vectors<TypeSignedLabel>::ElementTy ElementTypeSigned;
 
   typedef TypeUnsigned (*FuncTypeUnsigned)(TypeUnsigned, TypeUnsigned);
   typedef TypeSigned (*FuncTypeSigned)(TypeSigned, TypeSigned);
   volatile unsigned Values[] = INT_VALUE_ARRAY;
   const static size_t NumValues = sizeof(Values) / sizeof(*Values);
   static struct {
+    // For functions that operate on unsigned values, the
+    // FuncLlcSigned and FuncSzSigned fields are NULL.  For functions
+    // that operate on signed values, the FuncLlcUnsigned and
+    // FuncSzUnsigned fields are NULL.
     const char *Name;
-    FuncTypeUnsigned FuncLlc;
-    FuncTypeUnsigned FuncSz;
+    FuncTypeUnsigned FuncLlcUnsigned;
+    FuncTypeUnsigned FuncSzUnsigned;
+    FuncTypeSigned FuncLlcSigned;
+    FuncTypeSigned FuncSzSigned;
     bool ExcludeDivExceptions; // for divide related tests
   } Funcs[] = {
 #define X(inst, op, isdiv)                                                     \
   {                                                                            \
-    STR(inst), (FuncTypeUnsigned)test##inst,                                   \
-        (FuncTypeUnsigned)Subzero_::test##inst, isdiv                          \
+    STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv             \
   }                                                                            \
   ,
         UINTOP_TABLE
 #undef X
 #define X(inst, op, isdiv)                                                     \
   {                                                                            \
-    STR(inst), (FuncTypeUnsigned)(FuncTypeSigned)test##inst,                   \
-        (FuncTypeUnsigned)(FuncTypeSigned)Subzero_::test##inst, isdiv          \
+    STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv             \
   }                                                                            \
   ,
         SINTOP_TABLE
 #undef X
   };
   const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
   const static size_t NumElementsInType = Vectors<TypeUnsigned>::NumElements;
   for (size_t f = 0; f < NumFuncs; ++f) {
     PRNG Index;
     for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
       // Initialize the test vectors.
       TypeUnsigned Value1, Value2;
       for (size_t j = 0; j < NumElementsInType;) {
         ElementTypeUnsigned Element1 = Values[Index() % NumValues];
         ElementTypeUnsigned Element2 = Values[Index() % NumValues];
         if (Funcs[f].ExcludeDivExceptions &&
             inputsMayTriggerException<ElementTypeSigned>(Element1, Element2))
           continue;
         Value1[j] = Element1;
         Value2[j] = Element2;
         ++j;
       }
       // Perform the test.
-      TypeUnsigned ResultSz = Funcs[f].FuncSz(Value1, Value2);
-      TypeUnsigned ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
+      TypeUnsigned ResultSz, ResultLlc;
       ++TotalTests;
+      if (Funcs[f].FuncSzUnsigned) {
+        ResultSz = Funcs[f].FuncSzUnsigned(Value1, Value2);
+        ResultLlc = Funcs[f].FuncLlcUnsigned(Value1, Value2);
+      } else {
+        ResultSz = Funcs[f].FuncSzSigned(Value1, Value2);
+        ResultLlc = Funcs[f].FuncLlcSigned(Value1, Value2);
+      }
       if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
         ++Passes;
       } else {
         ++Failures;
         std::cout << "test" << Funcs[f].Name << "v" << NumElementsInType << "i"
                   << (CHAR_BIT * sizeof(ElementTypeUnsigned)) << "("
                   << vectAsString<TypeUnsignedLabel>(Value1) << ","
                   << vectAsString<TypeUnsignedLabel>(Value2)
                   << "): sz=" << vectAsString<TypeUnsignedLabel>(ResultSz)
                   << " llc=" << vectAsString<TypeUnsignedLabel>(ResultLlc)
-                  << std::endl;
+                  << "\n";
       }
     }
   }
 }
 
 template <typename Type>
 void testsFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   static const Type NegInf = -1.0 / 0.0;
   static const Type PosInf = 1.0 / 0.0;
   static const Type Nan = 0.0 / 0.0;
@@ skipping 23 matching lines @@
         Type ResultSz = Funcs[f].FuncSz(Value1, Value2);
         Type ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
         // Compare results using memcmp() in case they are both NaN.
         if (!memcmp(&ResultSz, &ResultLlc, sizeof(Type))) {
           ++Passes;
         } else {
           ++Failures;
           std::cout << std::fixed << "test" << Funcs[f].Name
                     << (CHAR_BIT * sizeof(Type)) << "(" << Value1 << ", "
                     << Value2 << "): sz=" << ResultSz << " llc=" << ResultLlc
-                    << std::endl;
+                    << "\n";
         }
       }
     }
   }
   for (size_t i = 0; i < NumValues; ++i) {
     Type Value = Values[i];
     ++TotalTests;
     Type ResultSz = Subzero_::mySqrt(Value);
     Type ResultLlc = mySqrt(Value);
     // Compare results using memcmp() in case they are both NaN.
     if (!memcmp(&ResultSz, &ResultLlc, sizeof(Type))) {
       ++Passes;
     } else {
       ++Failures;
       std::cout << std::fixed << "test_sqrt" << (CHAR_BIT * sizeof(Type)) << "("
                 << Value << "): sz=" << ResultSz << " llc=" << ResultLlc
-                << std::endl;
+                << "\n";
     }
   }
 }
 
 void testsVecFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   static const float NegInf = -1.0 / 0.0;
   static const float PosInf = 1.0 / 0.0;
   static const float Nan = 0.0 / 0.0;
   static const float NegNan = -0.0 / 0.0;
   volatile float Values[] = FP_VALUE_ARRAY(NegInf, PosInf, NegNan, Nan);
@@ skipping 26 matching lines @@
       v4f32 ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
       ++TotalTests;
       if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
         ++Passes;
       } else {
         ++Failures;
         std::cout << "test" << Funcs[f].Name << "v4f32"
                   << "(" << vectAsString<v4f32>(Value1) << ","
                   << vectAsString<v4f32>(Value2)
                   << "): sz=" << vectAsString<v4f32>(ResultSz) << " llc"
-                  << vectAsString<v4f32>(ResultLlc) << std::endl;
+                  << vectAsString<v4f32>(ResultLlc) << "\n";
       }
     }
   }
 }
 
 int main(int argc, char **argv) {
   size_t TotalTests = 0;
   size_t Passes = 0;
   size_t Failures = 0;
 
-  testsInt<uint8_t, int8_t>(TotalTests, Passes, Failures);
+  testsInt<uint8_t, myint8_t>(TotalTests, Passes, Failures);
   testsInt<uint16_t, int16_t>(TotalTests, Passes, Failures);
   testsInt<uint32_t, int32_t>(TotalTests, Passes, Failures);
   testsInt<uint64_t, int64_t>(TotalTests, Passes, Failures);
   testsVecInt<v4ui32, v4si32>(TotalTests, Passes, Failures);
   testsVecInt<v8ui16, v8si16>(TotalTests, Passes, Failures);
   testsVecInt<v16ui8, v16si8>(TotalTests, Passes, Failures);
   testsFp<float>(TotalTests, Passes, Failures);
   testsFp<double>(TotalTests, Passes, Failures);
   testsVecFp(TotalTests, Passes, Failures);
 
@@ skipping 29 matching lines @@
   v16si8 Sz_srem_v16i8(v16si8 a, v16si8 b) { return a % b; }
   v16ui8 Sz_urem_v16i8(v16ui8 a, v16ui8 b) { return a % b; }
 
   v4f32 Sz_frem_v4f32(v4f32 a, v4f32 b) {
     v4f32 Result;
     for (int i = 0; i < 4; ++i)
       Result[i] = fmodf(a[i], b[i]);
     return Result;
   }
 }