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

test/cctest/test-assembler-mips.cc

Index: test/cctest/test-assembler-mips.cc
diff --git a/test/cctest/test-assembler-mips.cc b/test/cctest/test-assembler-mips.cc
index e73b40e96b88782da35ff8840d97a4b82691808a..29370b2687647a130fc34a004568d8480227c60a 100644
--- a/test/cctest/test-assembler-mips.cc
+++ b/test/cctest/test-assembler-mips.cc
@@ -5386,4 +5386,297 @@ TEST(Trampoline) {
   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 __