Subzero: Fix and clean up some cross tests.

crosstest/test_icmp_main.cpp

 //===- subzero/crosstest/test_icmp_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 cross testing the icmp bitcode instruction
@@ skipping 63 matching lines @@
           ++TotalTests;
           bool ResultSz = Funcs[f].FuncSz(Value1, Value2);
           bool ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
           if (ResultSz == ResultLlc) {
             ++Passes;
           } else {
             ++Failures;
             std::cout << "icmp" << Funcs[f].Name
                       << (CHAR_BIT * sizeof(TypeUnsigned)) << "(" << Value1
                       << ", " << Value2 << "): sz=" << ResultSz
-                      << " llc=" << ResultLlc << std::endl;
+                      << " llc=" << 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];
               ++TotalTests;
               bool ResultSz = Funcs[f].FuncSz(Value1, Value2);
               bool ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
               if (ResultSz == ResultLlc) {
                 ++Passes;
               } else {
                 ++Failures;
                 std::cout << "icmp" << Funcs[f].Name
                           << (CHAR_BIT * sizeof(TypeUnsigned)) << "(" << Value1
                           << ", " << Value2 << "): sz=" << ResultSz
-                          << " llc=" << ResultLlc << std::endl;
+                          << " llc=" << ResultLlc << "\n";
               }
             }
           }
         }
       }
     }
   }
 }
 
 const static size_t MaxTestsPerFunc = 100000;
@@ skipping 45 matching lines @@
       if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
         ++Passes;
       } else {
         ++Failures;
         std::cout << "test" << Funcs[f].Name
                   << Vectors<TypeUnsignedLabel>::TypeName << "("
                   << vectAsString<TypeUnsignedLabel>(Value1) << ","
                   << vectAsString<TypeUnsignedLabel>(Value2)
                   << "): sz=" << vectAsString<TypeUnsignedLabel>(ResultSz)
                   << " llc=" << vectAsString<TypeUnsignedLabel>(ResultLlc)
-                  << std::endl;
+                  << "\n";
       }
     }
   }
 }
 
 // Return true on wraparound
 template <typename T> bool incrementI1Vector(typename Vectors<T>::Ty &Vect) {
   size_t Pos = 0;
   const static size_t NumElements = Vectors<T>::NumElements;
   for (Pos = 0; Pos < NumElements; ++Pos) {
@@ skipping 39 matching lines @@
           Ty ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
           ++TotalTests;
           if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
             ++Passes;
           } else {
             ++Failures;
             std::cout << "test" << Funcs[f].Name << Vectors<T>::TypeName << "("
                       << vectAsString<T>(Value1) << ","
                       << vectAsString<T>(Value2)
                       << "): sz=" << vectAsString<T>(ResultSz)
-                      << " llc=" << vectAsString<T>(ResultLlc) << std::endl;
+                      << " llc=" << vectAsString<T>(ResultLlc) << "\n";
           }
         }
       }
     }
   } else {
     for (size_t f = 0; f < NumFuncs; ++f) {
       PRNG Index;
       for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
         Ty Value1, Value2;
         // Initialize the test vectors.
         for (size_t j = 0; j < NumElements; ++j) {
           Value1[j] = Index() % 2;
           Value2[j] = Index() % 2;
         }
         // Perform the test.
         Ty ResultSz = Funcs[f].FuncSz(Value1, Value2);
         Ty ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
         ++TotalTests;
         if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
           ++Passes;
         } else {
           ++Failures;
           std::cout << "test" << Funcs[f].Name << Vectors<T>::TypeName << "("
                     << vectAsString<T>(Value1) << "," << vectAsString<T>(Value2)
                     << "): sz=" << vectAsString<T>(ResultSz)
-                    << " llc=" << vectAsString<T>(ResultLlc) << std::endl;
+                    << " llc=" << vectAsString<T>(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);
   testsVecI1<v4i1>(TotalTests, Passes, Failures);
   testsVecI1<v8i1>(TotalTests, Passes, Failures);
   testsVecI1<v16i1>(TotalTests, Passes, Failures);
 
   std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
             << " Failures=" << Failures << "\n";
   return Failures;
 }