Fix array index in test initialization.

crosstest/test_arith_main.cpp

 /* 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
 #include <cstring> // memcmp
 #include <iostream>
 
 // Include test_arith.h twice - once normally, and once within the
 // Subzero_ namespace, corresponding to the llc and Subzero translated
 // object files, respectively.
 #include "test_arith.h"
 namespace Subzero_ {
 #include "test_arith.h"
 }
 
-volatile unsigned Values[] = INT_VALUE_ARRAY;
-const static size_t NumValues = sizeof(Values) / sizeof(*Values);
-
 template <class T> bool inputsMayTriggerException(T Value1, T Value2) {
   // Avoid HW divide-by-zero exception.
   if (Value2 == 0)
     return true;
   // Avoid HW overflow exception (on x86-32).  TODO: adjust
   // for other architecture.
   if (Value1 == std::numeric_limits<T>::min() && Value2 == -1)
     return true;
   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 {
     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                          \
@@ skipping 103 matching lines @@
       std::cout << ", ";
     std::cout << (CastType) Vect[i];
   }
 }
 
 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                          \
@@ skipping 12 matching lines @@
   };
   const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
   const static size_t NumElementsInType =
       sizeof(TypeUnsigned) / sizeof(ElementTypeUnsigned);
   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() % NumElementsInType];
-        ElementTypeUnsigned Element2 = Values[Index() % 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);
@@ skipping 96 matching lines @@
 #undef X
   };
   const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
   const static size_t NumElementsInType = 4;
   for (size_t f = 0; f < NumFuncs; ++f) {
     PRNG Index;
     for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
       // Initialize the test vectors.
       v4f32 Value1, Value2;
       for (size_t j = 0; j < NumElementsInType; ++j) {
-        Value1[j] = Values[Index() % NumElementsInType];
-        Value2[j] = Values[Index() % NumElementsInType];
+        Value1[j] = Values[Index() % NumValues];
+        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"
@@ skipping 59 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;
   }
 }