MIPS: Fixing failures in cctest/test-assembler-mips/CVT

test/cctest/test-assembler-mips.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4022 matching lines @@
   __ ctc1(zero_reg, FCSR);
 
 #define GENERATE_CVT_TEST(x, y, z) \
   __ y##c1(f0, MemOperand(a0, offsetof(TestFloat, x##_in))); \
   __ x(f0, f0); \
   __ nop(); \
   __ z##c1(f0, MemOperand(a0, offsetof(TestFloat, x##_out)));
 
   GENERATE_CVT_TEST(cvt_d_s, lw, sd)
   GENERATE_CVT_TEST(cvt_d_w, lw, sd)
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     GENERATE_CVT_TEST(cvt_d_l, ld, sd)
   }
 
   if (IsFp64Mode()) {
     GENERATE_CVT_TEST(cvt_l_s, lw, sd)
     GENERATE_CVT_TEST(cvt_l_d, ld, sd)
   }
 
   GENERATE_CVT_TEST(cvt_s_d, ld, sw)
   GENERATE_CVT_TEST(cvt_s_w, lw, sw)
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     GENERATE_CVT_TEST(cvt_s_l, ld, sw)
   }
 
   GENERATE_CVT_TEST(cvt_w_s, lw, sw)
   GENERATE_CVT_TEST(cvt_w_d, ld, sw)
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
@@ skipping 12 matching lines @@
   test.cvt_l_d_in = -0.51;
   test.cvt_s_d_in = -0.51;
   test.cvt_s_w_in = -1;
   test.cvt_s_l_in = -1;
   test.cvt_w_s_in = -0.51;
   test.cvt_w_d_in = -0.51;
 
   (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   }
   if (IsFp64Mode()) {
     CHECK_EQ(test.cvt_l_s_out, -1);
     CHECK_EQ(test.cvt_l_d_out, -1);
   }
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   }
   CHECK_EQ(test.cvt_w_s_out, -1);
   CHECK_EQ(test.cvt_w_d_out, -1);
 
 
   test.cvt_d_s_in = 0.49;
   test.cvt_d_w_in = 1;
   test.cvt_d_l_in = 1;
   test.cvt_l_s_in = 0.49;
   test.cvt_l_d_in = 0.49;
   test.cvt_s_d_in = 0.49;
   test.cvt_s_w_in = 1;
   test.cvt_s_l_in = 1;
   test.cvt_w_s_in = 0.49;
   test.cvt_w_d_in = 0.49;
 
   (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   }
   if (IsFp64Mode()) {
     CHECK_EQ(test.cvt_l_s_out, 0);
     CHECK_EQ(test.cvt_l_d_out, 0);
   }
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   }
   CHECK_EQ(test.cvt_w_s_out, 0);
   CHECK_EQ(test.cvt_w_d_out, 0);
 
   test.cvt_d_s_in = std::numeric_limits<float>::max();
   test.cvt_d_w_in = std::numeric_limits<int32_t>::max();
   test.cvt_d_l_in = std::numeric_limits<int64_t>::max();
   test.cvt_l_s_in = std::numeric_limits<float>::max();
   test.cvt_l_d_in = std::numeric_limits<double>::max();
   test.cvt_s_d_in = std::numeric_limits<double>::max();
   test.cvt_s_w_in = std::numeric_limits<int32_t>::max();
   test.cvt_s_l_in = std::numeric_limits<int64_t>::max();
   test.cvt_w_s_in = std::numeric_limits<float>::max();
   test.cvt_w_d_in = std::numeric_limits<double>::max();
 
   (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   }
   if (IsFp64Mode()) {
     CHECK_EQ(test.cvt_l_s_out, std::numeric_limits<int64_t>::max());
     CHECK_EQ(test.cvt_l_d_out, std::numeric_limits<int64_t>::max());
   }
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   }
   CHECK_EQ(test.cvt_w_s_out, std::numeric_limits<int32_t>::max());
   CHECK_EQ(test.cvt_w_d_out, std::numeric_limits<int32_t>::max());
 
 
   test.cvt_d_s_in = -std::numeric_limits<float>::max();   // lowest()
   test.cvt_d_w_in = std::numeric_limits<int32_t>::min();  // lowest()
   test.cvt_d_l_in = std::numeric_limits<int64_t>::min();  // lowest()
   test.cvt_l_s_in = -std::numeric_limits<float>::max();   // lowest()
   test.cvt_l_d_in = -std::numeric_limits<double>::max();  // lowest()
   test.cvt_s_d_in = -std::numeric_limits<double>::max();  // lowest()
   test.cvt_s_w_in = std::numeric_limits<int32_t>::min();  // lowest()
   test.cvt_s_l_in = std::numeric_limits<int64_t>::min();  // lowest()
   test.cvt_w_s_in = -std::numeric_limits<float>::max();   // lowest()
   test.cvt_w_d_in = -std::numeric_limits<double>::max();  // lowest()
 
   (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   }
   // The returned value when converting from fixed-point to float-point
   // is not consistent between board, simulator and specification
   // in this test case, therefore modifying the test
   if (IsFp64Mode()) {
     CHECK(test.cvt_l_s_out == std::numeric_limits<int64_t>::min() ||
          test.cvt_l_s_out == std::numeric_limits<int64_t>::max());
     CHECK(test.cvt_l_d_out == std::numeric_limits<int64_t>::min() ||
           test.cvt_l_d_out == std::numeric_limits<int64_t>::max());
   }
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   }
   CHECK(test.cvt_w_s_out == std::numeric_limits<int32_t>::min() ||
         test.cvt_w_s_out == std::numeric_limits<int32_t>::max());
   CHECK(test.cvt_w_d_out == std::numeric_limits<int32_t>::min() ||
         test.cvt_w_d_out == std::numeric_limits<int32_t>::max());
 
 
   test.cvt_d_s_in = std::numeric_limits<float>::min();
   test.cvt_d_w_in = std::numeric_limits<int32_t>::min();
   test.cvt_d_l_in = std::numeric_limits<int64_t>::min();
   test.cvt_l_s_in = std::numeric_limits<float>::min();
   test.cvt_l_d_in = std::numeric_limits<double>::min();
   test.cvt_s_d_in = std::numeric_limits<double>::min();
   test.cvt_s_w_in = std::numeric_limits<int32_t>::min();
   test.cvt_s_l_in = std::numeric_limits<int64_t>::min();
   test.cvt_w_s_in = std::numeric_limits<float>::min();
   test.cvt_w_d_in = std::numeric_limits<double>::min();
 
   (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   }
   if (IsFp64Mode()) {
     CHECK_EQ(test.cvt_l_s_out, 0);
     CHECK_EQ(test.cvt_l_d_out, 0);
   }
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
-  if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+  if ((IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) &&
+         IsFp64Mode()) {
     CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   }
   CHECK_EQ(test.cvt_w_s_out, 0);
   CHECK_EQ(test.cvt_w_d_out, 0);
 }
 
 
 TEST(DIV_FMT) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 894 matching lines @@
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int32_t res =
       reinterpret_cast<int32_t>(CALL_GENERATED_CODE(f, 42, 42, 0, 0, 0));
   CHECK_EQ(res, 0);
 }
 
 
 #undef __