Index: crosstest/test_arith_main.cpp |
diff --git a/crosstest/test_arith_main.cpp b/crosstest/test_arith_main.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..745da61671ec4f7c3b006ba73c752d78a1036fe0 |
--- /dev/null |
+++ b/crosstest/test_arith_main.cpp |
@@ -0,0 +1,193 @@ |
+/* crosstest.py --test=test_arith.cpp --test=test_arith_frem.ll \ |
+ --driver=test_arith_main.cpp --prefix=Subzero_ --output=test_arith */ |
+ |
+#include <stdint.h> |
+ |
+#include <cfloat> |
+#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[] = { 0x0, 0x1, 0x7ffffffe, 0x7fffffff, |
+ 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, |
+ 0x7e, 0x7f, 0x80, 0x81, |
+ 0xfe, 0xff, 0x100, 0x101, |
+ 0x7ffe, 0x7fff, 0x8000, 0x8001, |
+ 0xfffe, 0xffff, 0x10000, 0x10001, }; |
+const static size_t NumValues = sizeof(Values) / sizeof(*Values); |
+ |
+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); |
+ 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); |
+ |
+ 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 && Value2 == 0) |
+ continue; |
+ // Avoid HW overflow exception (on x86-32). TODO: adjust |
+ // for other architectures. |
+ if (Funcs[f].ExcludeDivExceptions && Value1 == 0x80000000 && |
+ Value2 == 0xffffffff) |
+ continue; |
+ ++TotalTests; |
+ TypeUnsigned ResultSz = Funcs[f].FuncSz(Value1, Value2); |
+ TypeUnsigned ResultLlc = Funcs[f].FuncLlc(Value1, Value2); |
+ if (ResultSz == ResultLlc) { |
+ ++Passes; |
+ } else { |
+ ++Failures; |
+ std::cout << "test" << Funcs[f].Name << (8 * sizeof(TypeUnsigned)) |
+ << "(" << Value1 << ", " << Value2 |
+ << "): sz=" << (unsigned)ResultSz |
+ << " llc=" << (unsigned)ResultLlc << std::endl; |
+ } |
+ } |
+ } |
+ } |
+ } 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]; |
+ // Avoid HW divide-by-zero exception. |
+ if (Funcs[f].ExcludeDivExceptions && Value2 == 0) |
+ continue; |
+ ++TotalTests; |
+ TypeUnsigned ResultSz = Funcs[f].FuncSz(Value1, Value2); |
+ TypeUnsigned ResultLlc = Funcs[f].FuncLlc(Value1, Value2); |
+ if (ResultSz == ResultLlc) { |
+ ++Passes; |
+ } else { |
+ ++Failures; |
+ std::cout << "test" << Funcs[f].Name |
+ << (8 * sizeof(TypeUnsigned)) << "(" << Value1 << ", " |
+ << Value2 << "): sz=" << (unsigned)ResultSz |
+ << " llc=" << (unsigned)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; |
+ volatile Type Values[] = { |
+ 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, NegInf, PosInf, |
+ Nan, FLT_MIN, FLT_MAX, |
+ DBL_MIN, DBL_MAX |
+ }; |
+ const static size_t NumValues = sizeof(Values) / sizeof(*Values); |
+ typedef Type (*FuncType)(Type, Type); |
+ static struct { |
+ const char *Name; |
+ FuncType FuncLlc; |
+ FuncType FuncSz; |
+ } Funcs[] = { |
+#define X(inst, op, func) \ |
+ { STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst } \ |
+ , |
+ FPOP_TABLE |
+#undef X |
+ }; |
+ const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs); |
+ |
+ for (size_t f = 0; f < NumFuncs; ++f) { |
+ for (size_t i = 0; i < NumValues; ++i) { |
+ for (size_t j = 0; j < NumValues; ++j) { |
+ Type Value1 = Values[i]; |
+ Type Value2 = Values[j]; |
+ ++TotalTests; |
+ 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 |
+ << (8 * sizeof(Type)) << "(" << Value1 << ", " << Value2 |
+ << "): sz=" << ResultSz << " llc=" << 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); |
+ testsFp<float>(TotalTests, Passes, Failures); |
+ testsFp<double>(TotalTests, Passes, Failures); |
+ |
+ std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes |
+ << " Failures=" << Failures << "\n"; |
+ return Failures; |
+} |