MIPS: Implement MADD.S, MSUB, MADDF and MSUBF.

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 5368 matching lines @@
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int32_t res = reinterpret_cast<int32_t>(
       CALL_GENERATED_CODE(isolate, f, 42, 42, 0, 0, 0));
   CHECK_EQ(res, 0);
 }
 
+TEST(madd_s_msub_s) {
+  if (IsMipsArchVariant(kMips32r2)) {

[balazs.kilvady, 2016/09/07 18:32:47]

In this kind of cases I prefer if (!cond) return; to save one block-nesting
level, but it is matter of taste.

[Ilija.Pavlovic1, 2016/09/09 12:35:18]

The test is made as template so the logic (and checking) is now different.

Done.

+    CcTest::InitializeVM();
+    Isolate* isolate = CcTest::i_isolate();
+    HandleScope scope(isolate);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
+
+    struct TestCase {
+      float fr, fs, ft, fd_add, fd_sub;
+    };
+

[balazs.kilvady, 2016/09/07 18:32:47]

If you use the same test values for all the 4 variants then you could create a
helper function - a template which works for floats and doubles. (BTW in pure C
there are sqrt() for doubles and sqrtf() for floats but in c++ you can use
std::sqrt() of <cmath> which is always good:
http://en.cppreference.com/w/cpp/numeric/math/sqrt).

[Ilija.Pavlovic1, 2016/09/09 12:35:18]

Used std::sqrt().

Done.

+    float x = sqrtf(2.0);
+    float y = sqrtf(3.0);
+    float z = sqrtf(5.0);
+    float x2 = 11.11, y2 = 22.22, z2 = 33.33;
+    TestCase test_cases[] = {
+        {x, y, z, 0.0, 0.0},
+        {x, y, -z, 0.0, 0.0},
+        {x, -y, z, 0.0, 0.0},
+        {x, -y, -z, 0.0, 0.0},
+        {-x, y, z, 0.0, 0.0},
+        {-x, y, -z, 0.0, 0.0},
+        {-x, -y, z, 0.0, 0.0},
+        {-x, -y, -z, 0.0, 0.0},
+        {-3.14, 0.2345, -123.000056, 0.0, 0.0},
+        {7.3, -23.257, -357.1357, 0.0, 0.0},
+        {x2, y2, z2, 0.0, 0.0},
+        {x2, y2, -z2, 0.0, 0.0},
+        {x2, -y2, z2, 0.0, 0.0},
+        {x2, -y2, -z2, 0.0, 0.0},
+        {-x2, y2, z2, 0.0, 0.0},
+        {-x2, y2, -z2, 0.0, 0.0},
+        {-x2, -y2, z2, 0.0, 0.0},
+        {-x2, -y2, -z2, 0.0, 0.0},
+    };
+
+    __ lwc1(f4, MemOperand(a0, offsetof(TestCase, fr)));
+    __ lwc1(f6, MemOperand(a0, offsetof(TestCase, fs)));
+    __ lwc1(f8, MemOperand(a0, offsetof(TestCase, ft)));
+    __ lwc1(f16, MemOperand(a0, offsetof(TestCase, fr)));
+
+    __ madd_s(f10, f4, f6, f8);
+    __ swc1(f10, MemOperand(a0, offsetof(TestCase, fd_add)));
+    __ msub_s(f16, f4, f6, f8);
+    __ swc1(f16, MemOperand(a0, offsetof(TestCase, fd_sub)));
+
+    __ 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());
+
+    const size_t kTableLength = sizeof(test_cases) / sizeof(TestCase);
+    TestCase tc;
+    for (size_t i = 0; i < kTableLength; i++) {
+      tc.fr = test_cases[i].fr;
+      tc.fs = test_cases[i].fs;
+      tc.ft = test_cases[i].ft;
+
+      (CALL_GENERATED_CODE(isolate, f, &tc, 0, 0, 0, 0));
+
+      float res_add = tc.fr + (tc.fs * tc.ft);
+      float res_sub = (tc.fs * tc.ft) - tc.fr;
+
+      CHECK_EQ(tc.fd_add, res_add);
+      CHECK_EQ(tc.fd_sub, res_sub);
+    }
+  }
+}
+
+TEST(maddf_s_msubf_s) {
+  if (IsMipsArchVariant(kMips32r6)) {
+    CcTest::InitializeVM();
+    Isolate* isolate = CcTest::i_isolate();
+    HandleScope scope(isolate);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
+
+    struct TestCase {
+      float fr, fs, ft, fd_add, fd_sub;
+    };
+
+    float x = sqrtf(2.0);
+    float y = sqrtf(3.0);
+    float z = sqrtf(5.0);
+    float x2 = 11.11, y2 = 22.22, z2 = 33.33;
+    TestCase test_cases[] = {
+        {x, y, z, 0.0, 0.0},
+        {x, y, -z, 0.0, 0.0},
+        {x, -y, z, 0.0, 0.0},
+        {x, -y, -z, 0.0, 0.0},
+        {-x, y, z, 0.0, 0.0},
+        {-x, y, -z, 0.0, 0.0},
+        {-x, -y, z, 0.0, 0.0},
+        {-x, -y, -z, 0.0, 0.0},
+        {-3.14, 0.2345, -123.000056, 0.0, 0.0},
+        {7.3, -23.257, -357.1357, 0.0, 0.0},
+        {x2, y2, z2, 0.0, 0.0},
+        {x2, y2, -z2, 0.0, 0.0},
+        {x2, -y2, z2, 0.0, 0.0},
+        {x2, -y2, -z2, 0.0, 0.0},
+        {-x2, y2, z2, 0.0, 0.0},
+        {-x2, y2, -z2, 0.0, 0.0},
+        {-x2, -y2, z2, 0.0, 0.0},
+        {-x2, -y2, -z2, 0.0, 0.0},
+    };
+
+    __ lwc1(f4, MemOperand(a0, offsetof(TestCase, fr)));
+    __ lwc1(f6, MemOperand(a0, offsetof(TestCase, fs)));
+    __ lwc1(f8, MemOperand(a0, offsetof(TestCase, ft)));
+    __ lwc1(f16, MemOperand(a0, offsetof(TestCase, fr)));
+
+    __ maddf_s(f4, f6, f8);
+    __ swc1(f4, MemOperand(a0, offsetof(TestCase, fd_add)));
+    __ msubf_s(f16, f6, f8);
+    __ swc1(f16, MemOperand(a0, offsetof(TestCase, fd_sub)));
+
+    __ 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());
+
+    const size_t kTableLength = sizeof(test_cases) / sizeof(TestCase);
+    TestCase tc;
+    for (size_t i = 0; i < kTableLength; i++) {
+      tc.fr = test_cases[i].fr;
+      tc.fs = test_cases[i].fs;
+      tc.ft = test_cases[i].ft;
+
+      (CALL_GENERATED_CODE(isolate, f, &tc, 0, 0, 0, 0));
+
+      float res_add = tc.fr + (tc.fs * tc.ft);
+      float res_sub = tc.fr - (tc.fs * tc.ft);

[balazs.kilvady, 2016/09/07 18:32:47]

Looks good, but could you check the compiled code of the above two lines? If the
generated code also uses maddf.fmt and subf.mft then the test is quite useless
and alway passed. I am thinking about an expected result table but then we
should create two versions: one for boards and one for simulators. As simulator
uses the same code to calculate maddf.fmt's result I don't know if it worst too
much to run these tests on sims. But anyway, syntax, and call parameters will be
checked. 

[Ilija.Pavlovic1, 2016/09/09 12:35:18]

The test is now template.
The formula is used for creating expected results. On this way, control value is
calculated and rounded on the way which is used on the test system (simulator or
board). Using hard-coded values would not be practical.

Done.

+      CHECK_EQ(tc.fd_add, res_add);
+      CHECK_EQ(tc.fd_sub, res_sub);
+    }
+  }
+}
+
+TEST(madd_d_msub_d) {
+  if (IsMipsArchVariant(kMips32r2)) {
+    CcTest::InitializeVM();
+    Isolate* isolate = CcTest::i_isolate();
+    HandleScope scope(isolate);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
+
+    struct TestCase {
+      double fr, fs, ft, fd_add, fd_sub;
+    };
+
+    double x = sqrt(2.0);
+    double y = sqrt(3.0);
+    double z = sqrt(5.0);
+    double x2 = 11.11, y2 = 22.22, z2 = 33.33;
+    TestCase test_cases[] = {
+        {x, y, z, 0.0, 0.0},
+        {x, y, -z, 0.0, 0.0},
+        {x, -y, z, 0.0, 0.0},
+        {x, -y, -z, 0.0, 0.0},
+        {-x, y, z, 0.0, 0.0},
+        {-x, y, -z, 0.0, 0.0},
+        {-x, -y, z, 0.0, 0.0},
+        {-x, -y, -z, 0.0, 0.0},
+        {-3.14, 0.2345, -123.000056, 0.0, 0.0},
+        {7.3, -23.257, -357.1357, 0.0, 0.0},
+        {x2, y2, z2, 0.0, 0.0},
+        {x2, y2, -z2, 0.0, 0.0},
+        {x2, -y2, z2, 0.0, 0.0},
+        {x2, -y2, -z2, 0.0, 0.0},
+        {-x2, y2, z2, 0.0, 0.0},
+        {-x2, y2, -z2, 0.0, 0.0},
+        {-x2, -y2, z2, 0.0, 0.0},
+        {-x2, -y2, -z2, 0.0, 0.0},
+    };
+
+    __ ldc1(f4, MemOperand(a0, offsetof(TestCase, fr)));
+    __ ldc1(f6, MemOperand(a0, offsetof(TestCase, fs)));
+    __ ldc1(f8, MemOperand(a0, offsetof(TestCase, ft)));
+    __ ldc1(f16, MemOperand(a0, offsetof(TestCase, fr)));
+
+    __ madd_d(f10, f4, f6, f8);
+    __ sdc1(f10, MemOperand(a0, offsetof(TestCase, fd_add)));
+    __ msub_d(f16, f4, f6, f8);
+    __ sdc1(f16, MemOperand(a0, offsetof(TestCase, fd_sub)));
+
+    __ 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());
+
+    const size_t kTableLength = sizeof(test_cases) / sizeof(TestCase);
+    TestCase tc;
+    for (size_t i = 0; i < kTableLength; i++) {
+      tc.fr = test_cases[i].fr;
+      tc.fs = test_cases[i].fs;
+      tc.ft = test_cases[i].ft;
+
+      (CALL_GENERATED_CODE(isolate, f, &tc, 0, 0, 0, 0));
+
+      double res_add = tc.fr + (tc.fs * tc.ft);
+      double res_sub = (tc.fs * tc.ft) - tc.fr;
+      CHECK_EQ(tc.fd_add, res_add);
+      CHECK_EQ(tc.fd_sub, res_sub);
+    }
+  }
+}
+
+TEST(maddf_d_msubf_d) {
+  if (IsMipsArchVariant(kMips32r6)) {
+    CcTest::InitializeVM();
+    Isolate* isolate = CcTest::i_isolate();
+    HandleScope scope(isolate);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
+
+    struct TestCase {
+      double fr, fs, ft, fd_add, fd_sub;
+    };
+
+    double x = sqrt(2.0);
+    double y = sqrt(3.0);
+    double z = sqrt(5.0);
+    double x2 = 11.11, y2 = 22.22, z2 = 33.33;
+    TestCase test_cases[] = {
+        {x, y, z, 0.0, 0.0},
+        {x, y, -z, 0.0, 0.0},
+        {x, -y, z, 0.0, 0.0},
+        {x, -y, -z, 0.0, 0.0},
+        {-x, y, z, 0.0, 0.0},
+        {-x, y, -z, 0.0, 0.0},
+        {-x, -y, z, 0.0, 0.0},
+        {-x, -y, -z, 0.0, 0.0},
+        {-3.14, 0.2345, -123.000056, 0.0, 0.0},
+        {7.3, -23.257, -357.1357, 0.0, 0.0},
+        {x2, y2, z2, 0.0, 0.0},
+        {x2, y2, -z2, 0.0, 0.0},
+        {x2, -y2, z2, 0.0, 0.0},
+        {x2, -y2, -z2, 0.0, 0.0},
+        {-x2, y2, z2, 0.0, 0.0},
+        {-x2, y2, -z2, 0.0, 0.0},
+        {-x2, -y2, z2, 0.0, 0.0},
+        {-x2, -y2, -z2, 0.0, 0.0},
+    };
+
+    __ ldc1(f4, MemOperand(a0, offsetof(TestCase, fr)));
+    __ ldc1(f6, MemOperand(a0, offsetof(TestCase, fs)));
+    __ ldc1(f8, MemOperand(a0, offsetof(TestCase, ft)));
+    __ ldc1(f16, MemOperand(a0, offsetof(TestCase, fr)));
+
+    __ maddf_d(f4, f6, f8);
+    __ sdc1(f4, MemOperand(a0, offsetof(TestCase, fd_add)));
+    __ msubf_d(f16, f6, f8);
+    __ sdc1(f16, MemOperand(a0, offsetof(TestCase, fd_sub)));
+
+    __ 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());
+
+    const size_t kTableLength = sizeof(test_cases) / sizeof(TestCase);
+    TestCase tc;
+    for (size_t i = 0; i < kTableLength; i++) {
+      tc.fr = test_cases[i].fr;
+      tc.fs = test_cases[i].fs;
+      tc.ft = test_cases[i].ft;
+
+      (CALL_GENERATED_CODE(isolate, f, &tc, 0, 0, 0, 0));
+
+      double res_add = tc.fr + (tc.fs * tc.ft);
+      double res_sub = tc.fr - (tc.fs * tc.ft);
+      CHECK_EQ(tc.fd_add, res_add);
+      CHECK_EQ(tc.fd_sub, res_sub);
+    }
+  }
+}
+
 #undef __