Add Om1 lowering with no optimizations

crosstest/test_arith_main.cpp

+/* 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;
+}