Factor out common vector crosstesting code.

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
+//
+//===----------------------------------------------------------------------===//
+
 /* crosstest.py --test=test_arith.cpp --test=test_arith_frem.ll \
    --test=test_arith_sqrt.ll --driver=test_arith_main.cpp \
    --prefix=Subzero_ --output=test_arith */
 
 #include <stdint.h>
 
 #include <climits> // CHAR_BIT
 #include <limits>
 #include <cfloat>
 #include <cmath>   // fmodf
@@ skipping 105 matching lines @@
                           << " llc=" << (unsigned)ResultLlc << std::endl;
               }
             }
           }
         }
       }
     }
   }
 }
 
-// Vectors are deterministically constructed by selecting elements from
-// a pool of scalar values based on a pseudorandom sequence.  Testing
-// all possible combinations of scalar values from the value table is
-// not tractable.
-// TODO: Replace with a portable PRNG from C++11.
-class PRNG {
-public:
-  PRNG(uint32_t Seed = 1) : State(Seed) {}
-
-  uint32_t operator()() {
-    // Lewis, Goodman, and Miller (1969)
-    State = (16807 * State) % 2147483647;
-    return State;
-  }
-
-private:
-  uint32_t State;
-};
-
 const static size_t MaxTestsPerFunc = 100000;
 
-template <typename Type, typename ElementType, typename CastType>
-void outputVector(const Type Vect) {
-  const static size_t NumElementsInType = sizeof(Type) / sizeof(ElementType);
-  for (size_t i = 0; i < NumElementsInType; ++i) {
-    if (i > 0)
-      std::cout << ", ";
-    std::cout << (CastType) Vect[i];
-  }
-}
+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;
 
-template <typename TypeUnsigned, typename TypeSigned,
-          typename ElementTypeUnsigned, typename ElementTypeSigned>
-void testsVecInt(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 {
     const char *Name;
     FuncTypeUnsigned FuncLlc;
     FuncTypeUnsigned FuncSz;
     bool ExcludeDivExceptions; // for divide related tests
   } Funcs[] = {
 #define X(inst, op, isdiv)                                                     \
   {                                                                            \
     STR(inst), (FuncTypeUnsigned)test##inst,                                   \
         (FuncTypeUnsigned)Subzero_::test##inst, isdiv                          \
   }                                                                            \
   ,
         UINTOP_TABLE
 #undef X
 #define X(inst, op, isdiv)                                                     \
   {                                                                            \
     STR(inst), (FuncTypeUnsigned)(FuncTypeSigned)test##inst,                   \
         (FuncTypeUnsigned)(FuncTypeSigned)Subzero_::test##inst, isdiv          \
   }                                                                            \
   ,
         SINTOP_TABLE
 #undef X
   };
   const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
-  const static size_t NumElementsInType =
-      sizeof(TypeUnsigned) / sizeof(ElementTypeUnsigned);
+  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);
       ++TotalTests;
       if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
         ++Passes;
       } else {
+        ++Failures;
         std::cout << "test" << Funcs[f].Name << "v" << NumElementsInType << "i"
-                  << (CHAR_BIT * sizeof(ElementTypeUnsigned)) << "(";
-         outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(Value1);
-         std::cout << ", ";
-         outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(Value2);
-         std::cout << "): sz=";
-         outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(ResultSz);
-         std::cout << " llc=";
-         outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(ResultLlc);
-         std::cout << std::endl;
+                  << (CHAR_BIT * sizeof(ElementTypeUnsigned)) << "("
+                  << vectAsString<TypeUnsignedLabel>(Value1) << ","
+                  << vectAsString<TypeUnsignedLabel>(Value2)
+                  << "): sz=" << vectAsString<TypeUnsignedLabel>(ResultSz)
+                  << " llc=" << vectAsString<TypeUnsignedLabel>(ResultLlc)
+                  << std::endl;
       }
     }
   }
 }
 
 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 83 matching lines @@
         Value2[j] = Values[Index() % NumValues];
       }
       // Perform the test.
       v4f32 ResultSz = Funcs[f].FuncSz(Value1, Value2);
       v4f32 ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
       ++TotalTests;
       if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
         ++Passes;
       } else {
         ++Failures;
-        std::cout << std::fixed << "test" << Funcs[f].Name << "v4f32"
-                  << "(";
-        outputVector<v4f32, float, float>(Value1);
-        std::cout << ", ";
-        outputVector<v4f32, float, float>(Value2);
-        std::cout << "): sz=";
-        outputVector<v4f32, float, float>(ResultSz);
-        std::cout << " llc=";
-        outputVector<v4f32, float, float>(ResultLlc);
-        std::cout << std::endl;
+        std::cout << "test" << Funcs[f].Name << "v4f32"
+                  << "(" << vectAsString<v4f32>(Value1) << ","
+                  << vectAsString<v4f32>(Value2)
+                  << "): sz=" << vectAsString<v4f32>(ResultSz) << " llc"
+                  << vectAsString<v4f32>(ResultLlc) << std::endl;
       }
     }
   }
 }
 
 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<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, uint32_t, int32_t>(TotalTests, Passes, Failures);
-  testsVecInt<v8ui16, v8si16, uint16_t, int16_t>(TotalTests, Passes, Failures);
-  testsVecInt<v16ui8, v16si8, uint8_t, int8_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);
 
   std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
             << " Failures=" << Failures << "\n";
   return Failures;
 }
 
 extern "C" {
@@ skipping 23 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;
   }
 }