Subzero. Native 64-bit int arithmetic on x86-64.

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 \
    --test=test_cast_vectors.ll \
    --driver=test_cast_main.cpp --prefix=Subzero_ --output=test_cast */
 
 #include <cfloat>
 #include <cstring>
 #include <iostream>
 #include <stdint.h>
 
 #include "test_arith.def"
 #include "vectors.h"
+#include "xdefs.h"
 
 // Include test_cast.h twice - once normally, and once within the
 // Subzero_ namespace, corresponding to the llc and Subzero translated
 // object files, respectively.
 #include "test_cast.h"
 namespace Subzero_ {
 #include "test_cast.h"
 }
 
 #define XSTR(s) STR(s)
@@ skipping 40 matching lines @@
 template <typename FromType>
 void testValue(FromType Val, size_t &TotalTests, size_t &Passes,
                size_t &Failures, const char *FromTypeString) {
   COMPARE(cast, FromType, bool, Val, FromTypeString);
   COMPARE(cast, FromType, uint8_t, Val, FromTypeString);
   COMPARE(cast, FromType, myint8_t, Val, FromTypeString);
   COMPARE(cast, FromType, uint16_t, Val, FromTypeString);
   COMPARE(cast, FromType, int16_t, Val, FromTypeString);
   COMPARE(cast, FromType, uint32_t, Val, FromTypeString);
   COMPARE(cast, FromType, int32_t, Val, FromTypeString);
-  COMPARE(cast, FromType, uint64_t, Val, FromTypeString);
-  COMPARE(cast, FromType, int64_t, Val, FromTypeString);
+  COMPARE(cast, FromType, uint64, Val, FromTypeString);
+  COMPARE(cast, FromType, int64, Val, FromTypeString);
   COMPARE(cast, FromType, float, Val, FromTypeString);
   COMPARE(cast, FromType, double, Val, FromTypeString);
 }
 
 template <typename FromType, typename ToType>
 void testVector(size_t &TotalTests, size_t &Passes, size_t &Failures,
                 const char *FromTypeString, const char *ToTypeString) {
   const static size_t NumElementsInType = Vectors<FromType>::NumElements;
   PRNG Index;
   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);
   static const size_t NumValues = sizeof(Values) / sizeof(*Values);
   const size_t MaxTestsPerFunc = 20000;
   for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
     // Initialize the test vectors.
     FromType Value;
     for (size_t j = 0; j < NumElementsInType; ++j) {
       Value[j] = Values[Index() % NumValues];
     }
     COMPARE_VEC(cast, FromType, ToType, Value, FromTypeString, ToTypeString);
   }
 }
 
-int main(int argc, char **argv) {
+#ifdef X8664_STACK_HACK
+extern "C" int wrapped_main(int argc, char *argv[]) {
+#else  // !defined(X8664_STACK_HACK)
+int main(int argc, char *argv[]) {
+#endif // X8664_STACK_HACK
   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 myint8_t ValsSi8[] = {0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff};
@@ skipping 16 matching lines @@
                                 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
   static const size_t NumValsUi32 = sizeof(ValsUi32) / sizeof(*ValsUi32);
 
   volatile size_t ValsSi32[] = {0,          1,          0x7e,       0x7f,
                                 0x80,       0x81,       0xfe,       0xff,
                                 0x7ffe,     0x7fff,     0x8000,     0x8001,
                                 0xfffe,     0xffff,     0x7ffffffe, 0x7fffffff,
                                 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
   static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32);
 
-  volatile uint64_t ValsUi64[] = {
+  volatile uint64 ValsUi64[] = {
       0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
       0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff, 0x80000000, 0x80000001,
       0xfffffffe, 0xffffffff, 0x100000000ull, 0x100000001ull,
       0x7ffffffffffffffeull, 0x7fffffffffffffffull, 0x8000000000000000ull,
       0x8000000000000001ull, 0xfffffffffffffffeull, 0xffffffffffffffffull};
   static const size_t NumValsUi64 = sizeof(ValsUi64) / sizeof(*ValsUi64);
 
-  volatile int64_t ValsSi64[] = {
+  volatile int64 ValsSi64[] = {
       0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
       0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff, 0x80000000, 0x80000001,
       0xfffffffe, 0xffffffff, 0x100000000ll, 0x100000001ll,
       0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
       0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
   static const size_t NumValsSi64 = sizeof(ValsSi64) / sizeof(*ValsSi64);
 
   static const double NegInf = -1.0 / 0.0;
   static const double PosInf = 1.0 / 0.0;
   static const double Nan = 0.0 / 0.0;
@@ skipping 27 matching lines @@
   for (size_t i = 0; i < NumValsUi32; ++i) {
     uint32_t Val = ValsUi32[i];
     testValue<uint32_t>(Val, TotalTests, Passes, Failures, "uint32_t");
     COMPARE(castBits, uint32_t, float, Val, "uint32_t");
   }
   for (size_t i = 0; i < NumValsSi32; ++i) {
     int32_t Val = ValsSi32[i];
     testValue<int32_t>(Val, TotalTests, Passes, Failures, "int32_t");
   }
   for (size_t i = 0; i < NumValsUi64; ++i) {
-    uint64_t Val = ValsUi64[i];
-    testValue<uint64_t>(Val, TotalTests, Passes, Failures, "uint64_t");
-    COMPARE(castBits, uint64_t, double, Val, "uint64_t");
+    uint64 Val = ValsUi64[i];
+    testValue<uint64>(Val, TotalTests, Passes, Failures, "uint64");
+    COMPARE(castBits, uint64, double, Val, "uint64");
   }
   for (size_t i = 0; i < NumValsSi64; ++i) {
-    int64_t Val = ValsSi64[i];
-    testValue<int64_t>(Val, TotalTests, Passes, Failures, "int64_t");
+    int64 Val = ValsSi64[i];
+    testValue<int64>(Val, TotalTests, Passes, Failures, "int64");
   }
   for (size_t i = 0; i < NumValsF32; ++i) {
     for (unsigned j = 0; j < 2; ++j) {
       float Val = ValsF32[i];
       if (j > 0)
         Val = -Val;
       testValue<float>(Val, TotalTests, Passes, Failures, "float");
       COMPARE(castBits, float, uint32_t, Val, "float");
     }
   }
   for (size_t i = 0; i < NumValsF64; ++i) {
     for (unsigned j = 0; j < 2; ++j) {
       double Val = ValsF64[i];
       if (j > 0)
         Val = -Val;
       testValue<double>(Val, TotalTests, Passes, Failures, "double");
-      COMPARE(castBits, double, uint64_t, Val, "double");
+      COMPARE(castBits, double, uint64, Val, "double");
     }
   }
   testVector<v4ui32, v4f32>(TotalTests, Passes, Failures, "v4ui32", "v4f32");
   testVector<v4si32, v4f32>(TotalTests, Passes, Failures, "v4si32", "v4f32");
   testVector<v4f32, v4si32>(TotalTests, Passes, Failures, "v4f32", "v4si32");
   testVector<v4f32, v4ui32>(TotalTests, Passes, Failures, "v4f32", "v4ui32");
 
   std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
             << " Failures=" << Failures << "\n";
   return Failures;
 }