MIPS: Fix mina_maxa for proper NaN handling.

test/cctest/test-assembler-mips64.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 1886 matching lines @@
         (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.b, outputs[j][i]);
       }
     }
   }
 }
 
 
 TEST(mina_maxa) {
   if (kArchVariant == kMips64r6) {
-    const int tableLength = 12;
+    const int tableLength = 15;

[paul.l..., 2015/08/07 04:48:14]

Same comment as in 32-bit versionL kTableLength, double_nan, and float_nan.

[Djordje.Pesic, 2015/08/07 06:31:42]

Done. Also changed tableLength to kTableLength in other assembler tests. I added
some changes in class_fmt, actually NaN checks

     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
     MacroAssembler assm(isolate, NULL, 0);
+    const double dblNaN = std::numeric_limits<double>::quiet_NaN();
+    const float  fltNaN = std::numeric_limits<float>::quiet_NaN();
 
     typedef struct test_float {
       double a;
       double b;
       double resd;
       double resd1;
       float c;
       float d;
       float resf;
       float resf1;
     }TestFloat;
 
     TestFloat test;
     double inputsa[tableLength] = {
-      5.3, 4.8, 6.1,
-      9.8, 9.8, 9.8,
-      -10.0, -8.9, -9.8,
-      -10.0, -8.9, -9.8
+      5.3, 4.8, 6.1, 9.8, 9.8, 9.8, -10.0, -8.9,
+      -9.8, -10.0, -8.9, -9.8, dblNaN, 3.0, dblNaN
     };
     double inputsb[tableLength] = {
-      4.8, 5.3, 6.1,
-      -10.0, -8.9, -9.8,
-      9.8, 9.8, 9.8,
-      -9.8, -11.2, -9.8
+      4.8, 5.3, 6.1, -10.0, -8.9, -9.8, 9.8, 9.8,
+      9.8, -9.8, -11.2, -9.8, 3.0, dblNaN, dblNaN
     };
     double resd[tableLength] = {
-      4.8, 4.8, 6.1,
-      9.8, -8.9, 9.8,
-      9.8, -8.9, 9.8,
-      -9.8, -8.9, -9.8
+      4.8, 4.8, 6.1, 9.8, -8.9, -9.8, 9.8, -8.9,
+      -9.8, -9.8, -8.9, -9.8, 3.0, 3.0, dblNaN
     };
     double resd1[tableLength] = {
-      5.3, 5.3, 6.1,
-      -10.0, 9.8, 9.8,
-      -10.0, 9.8, 9.8,
-      -10.0, -11.2, -9.8
+      5.3, 5.3, 6.1, -10.0, 9.8, 9.8, -10.0, 9.8,
+      9.8, -10.0, -11.2, -9.8, 3.0, 3.0, dblNaN
     };
     float inputsc[tableLength] = {
-      5.3, 4.8, 6.1,
-      9.8, 9.8, 9.8,
-      -10.0, -8.9, -9.8,
-      -10.0, -8.9, -9.8
+      5.3, 4.8, 6.1, 9.8, 9.8, 9.8, -10.0, -8.9,
+      -9.8, -10.0, -8.9, -9.8, fltNaN, 3.0, fltNaN
     };
     float inputsd[tableLength] = {
-      4.8, 5.3, 6.1,
-      -10.0, -8.9, -9.8,
-      9.8, 9.8, 9.8,
-      -9.8, -11.2, -9.8
+      4.8, 5.3, 6.1, -10.0, -8.9, -9.8, 9.8, 9.8,
+      9.8, -9.8, -11.2, -9.8, 3.0, fltNaN, fltNaN
     };
     float resf[tableLength] = {
-      4.8, 4.8, 6.1,
-      9.8, -8.9, 9.8,
-      9.8, -8.9, 9.8,
-      -9.8, -8.9, -9.8
+      4.8, 4.8, 6.1, 9.8, -8.9, -9.8, 9.8, -8.9,
+      -9.8, -9.8, -8.9, -9.8, 3.0, 3.0, fltNaN
     };
     float resf1[tableLength] = {
-      5.3, 5.3, 6.1,
-      -10.0, 9.8, 9.8,
-      -10.0, 9.8, 9.8,
-      -10.0, -11.2, -9.8
+      5.3, 5.3, 6.1, -10.0, 9.8, 9.8, -10.0, 9.8,
+      9.8, -10.0, -11.2, -9.8, 3.0, 3.0, fltNaN
     };
 
     __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
     __ ldc1(f4, MemOperand(a0, offsetof(TestFloat, b)) );
     __ lwc1(f8, MemOperand(a0, offsetof(TestFloat, c)) );
     __ lwc1(f10, MemOperand(a0, offsetof(TestFloat, d)) );
     __ mina_d(f6, f2, f4);
     __ mina_s(f12, f8, f10);
     __ maxa_d(f14, f2, f4);
     __ maxa_s(f16, f8, f10);
     __ swc1(f12, MemOperand(a0, offsetof(TestFloat, resf)) );
     __ sdc1(f6, MemOperand(a0, offsetof(TestFloat, resd)) );
     __ swc1(f16, MemOperand(a0, offsetof(TestFloat, resf1)) );
     __ sdc1(f14, MemOperand(a0, offsetof(TestFloat, resd1)) );
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < tableLength; i++) {
       test.a = inputsa[i];
       test.b = inputsb[i];
       test.c = inputsc[i];
       test.d = inputsd[i];
       (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
 
-      CHECK_EQ(test.resd, resd[i]);
-      CHECK_EQ(test.resf, resf[i]);
-      CHECK_EQ(test.resd1, resd1[i]);
-      CHECK_EQ(test.resf1, resf1[i]);
+      if (i < tableLength - 1) {
+        CHECK_EQ(test.resd, resd[i]);
+        CHECK_EQ(test.resf, resf[i]);
+        CHECK_EQ(test.resd1, resd1[i]);
+        CHECK_EQ(test.resf1, resf1[i]);
+      } else {
+        DCHECK(std::isnan(test.resd));
+        DCHECK(std::isnan(test.resf));
+        DCHECK(std::isnan(test.resd1));
+        DCHECK(std::isnan(test.resf1));
+      }
     }
   }
 }
 
 
 
 // ----------------------mips32r2 specific tests----------------------
 TEST(trunc_l) {
   if (kArchVariant == kMips64r2) {
     CcTest::InitializeVM();
@@ skipping 1495 matching lines @@
     t.fNegSubnorm   = -FLT_MIN / 1.5;
     t.fNegZero      = -0.0;
     t.fPosInf       = 100000.0 / 0.0;
     t.fPosNorm      = FLT_MAX;
     t.fPosSubnorm   = FLT_MIN / 20.0;
     t.fPosZero      = +0.0;
 
     Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
     USE(dummy);
     // Expected double results.
+    CHECK_EQ(bit_cast<int64_t>(t.dSignalingNan), 0x001);
+    CHECK_EQ(bit_cast<int64_t>(t.dQuietNan),     0x002);
     CHECK_EQ(bit_cast<int64_t>(t.dNegInf),       0x004);
     CHECK_EQ(bit_cast<int64_t>(t.dNegNorm),      0x008);
     CHECK_EQ(bit_cast<int64_t>(t.dNegSubnorm),   0x010);
     CHECK_EQ(bit_cast<int64_t>(t.dNegZero),      0x020);
     CHECK_EQ(bit_cast<int64_t>(t.dPosInf),       0x040);
     CHECK_EQ(bit_cast<int64_t>(t.dPosNorm),      0x080);
     CHECK_EQ(bit_cast<int64_t>(t.dPosSubnorm),   0x100);
     CHECK_EQ(bit_cast<int64_t>(t.dPosZero),      0x200);
 
     // Expected float results.
+    CHECK_EQ(bit_cast<int32_t>(t.fSignalingNan), 0x001);
+    CHECK_EQ(bit_cast<int32_t>(t.fQuietNan),     0x002);
     CHECK_EQ(bit_cast<int32_t>(t.fNegInf),       0x004);
     CHECK_EQ(bit_cast<int32_t>(t.fNegNorm),      0x008);
     CHECK_EQ(bit_cast<int32_t>(t.fNegSubnorm),   0x010);
     CHECK_EQ(bit_cast<int32_t>(t.fNegZero),      0x020);
     CHECK_EQ(bit_cast<int32_t>(t.fPosInf),       0x040);
     CHECK_EQ(bit_cast<int32_t>(t.fPosNorm),      0x080);
     CHECK_EQ(bit_cast<int32_t>(t.fPosSubnorm),   0x100);
     CHECK_EQ(bit_cast<int32_t>(t.fPosZero),      0x200);
   }
 }
@@ skipping 1920 matching lines @@
   };
 
   size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBal);
   for (size_t i = 0; i < nr_test_cases; ++i) {
     CHECK_EQ(tc[i].expected_res, run_bal(tc[i].offset));
   }
 }
 
 
 #undef __