[SubZero] Fix f64 to/from i64 moves

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.
@@ skipping 36 matching lines @@
       std::cout << std::fixed << XSTR(Func) << "<" << FromString               \
                 << ", " XSTR(ToCName) ">(" << Input << "): ";                  \
       if (sizeof(ToCName) == 1)                                                \
         std::cout << "sz=" << (int)ResultSz << " llc=" << (int)ResultLlc;      \
       else                                                                     \
         std::cout << "sz=" << ResultSz << " llc=" << ResultLlc;                \
       std::cout << "\n";                                                       \
     }                                                                          \
   } while (0)
 
+#ifdef MIPS32
+#define COMPARE_MIPS(Func, FromCName, ToCName, Input, FromString)              \
+  do {                                                                         \
+    ToCName ResultSz, ResultLlc;                                               \
+    ResultLlc = Func<FromCName, ToCName>(1, Input);                            \
+    ResultSz = Subzero_::Func<FromCName, ToCName>(1, Input);                   \
+    ++TotalTests;                                                              \
+    if (!memcmp(&ResultLlc, &ResultSz, sizeof(ToCName))) {                     \
+      ++Passes;                                                                \
+    } else {                                                                   \
+      ++Failures;                                                              \
+      std::cout << std::fixed << XSTR(Func) << "<" << FromString               \
+                << ", " XSTR(ToCName) ">(" << Input << "): ";                  \
+      if (sizeof(ToCName) == 1)                                                \
+        std::cout << "sz=" << (int)ResultSz << " llc=" << (int)ResultLlc;      \
+      else                                                                     \
+        std::cout << "sz=" << ResultSz << " llc=" << ResultLlc;                \
+      std::cout << "\n";                                                       \
+    }                                                                          \
+  } while (0)
+#endif
+
 #define COMPARE_VEC(Func, FromCName, ToCName, Input, FromString, ToString)     \
   do {                                                                         \
     ToCName ResultSz, ResultLlc;                                               \
     ResultLlc = Func<FromCName, ToCName>(Input);                               \
     ResultSz = Subzero_::Func<FromCName, ToCName>(Input);                      \
     ++TotalTests;                                                              \
     if (!memcmp(&ResultLlc, &ResultSz, sizeof(ToCName))) {                     \
       ++Passes;                                                                \
     } else {                                                                   \
       ++Failures;                                                              \
@@ skipping 15 matching lines @@
   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, Val, FromTypeString);
   COMPARE(cast, FromType, int64, Val, FromTypeString);
   COMPARE(cast, FromType, float, Val, FromTypeString);
   COMPARE(cast, FromType, double, Val, FromTypeString);
 }
 
+#ifdef MIPS32
+template <typename FromType>
+void testValueMIPS(FromType Val, size_t &TotalTests, size_t &Passes,
+               size_t &Failures, const char *FromTypeString) {
+  COMPARE_MIPS(cast, FromType, uint8_t, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, myint8_t, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, uint16_t, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, int16_t, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, uint32_t, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, int32_t, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, uint64, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, int64, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, float, Val, FromTypeString);
+  COMPARE_MIPS(cast, FromType, double, Val, FromTypeString);
+}
+#endif
+
 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);
@@ skipping 121 matching lines @@
   }
   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, Val, "double");
     }
   }
+#ifdef MIPS32
+  for (size_t i = 0; i < NumValsUi8; ++i) {
+    uint8_t Val = ValsUi8[i];
+    testValueMIPS<uint8_t>(Val, TotalTests, Passes, Failures, "uint8_t");
+  }
+  for (size_t i = 0; i < NumValsSi8; ++i) {
+    myint8_t Val = ValsSi8[i];
+    testValueMIPS<myint8_t>(Val, TotalTests, Passes, Failures, "int8_t");
+  }
+  for (size_t i = 0; i < NumValsUi16; ++i) {
+    uint16_t Val = ValsUi16[i];
+    testValueMIPS<uint16_t>(Val, TotalTests, Passes, Failures, "uint16_t");
+  }
+  for (size_t i = 0; i < NumValsSi16; ++i) {
+    int16_t Val = ValsSi16[i];
+    testValueMIPS<int16_t>(Val, TotalTests, Passes, Failures, "int16_t");
+  }
+  for (size_t i = 0; i < NumValsUi32; ++i) {
+    uint32_t Val = ValsUi32[i];
+    testValueMIPS<uint32_t>(Val, TotalTests, Passes, Failures, "uint32_t");
+    COMPARE_MIPS(castBits, uint32_t, float, Val, "uint32_t");
+  }
+  for (size_t i = 0; i < NumValsSi32; ++i) {
+    int32_t Val = ValsSi32[i];
+    testValueMIPS<int32_t>(Val, TotalTests, Passes, Failures, "int32_t");
+  }
+  for (size_t i = 0; i < NumValsUi64; ++i) {
+    uint64 Val = ValsUi64[i];
+    testValueMIPS<uint64>(Val, TotalTests, Passes, Failures, "uint64");
+    COMPARE_MIPS(castBits, uint64, double, Val, "uint64");
+  }
+  for (size_t i = 0; i < NumValsSi64; ++i) {
+    int64 Val = ValsSi64[i];
+    testValueMIPS<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;
+      testValueMIPS<float>(Val, TotalTests, Passes, Failures, "float");
+      COMPARE_MIPS(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;
+      testValueMIPS<double>(Val, TotalTests, Passes, Failures, "double");
+      COMPARE_MIPS(castBits, double, uint64, Val, "double");
+    }
+  }
+#endif
   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;
 }