MIPS: Tests for convert and truncate instructions.

test/cctest/test-macro-assembler-mips64.cc

 // Copyright 2013 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 23 matching lines @@
 #include "src/base/utils/random-number-generator.h"
 #include "src/macro-assembler.h"
 #include "src/mips64/macro-assembler-mips64.h"
 #include "src/mips64/simulator-mips64.h"
 
 
 using namespace v8::internal;
 
 typedef void* (*F)(int64_t x, int64_t y, int p2, int p3, int p4);
 typedef Object* (*F1)(int x, int p1, int p2, int p3, int p4);
+typedef float (*F2)(uint32_t x0, int x1, int x2, int x3, int x4);
+typedef float (*F3)(uint64_t x0, int x1, int x2, int x3, int x4);
+typedef double (*F4)(uint64_t x0, int x1, int x2, int x3, int x4);
 
 #define __ masm->
 
 
 static byte to_non_zero(int n) {
   return static_cast<unsigned>(n) % 255 + 1;
 }
 
 
 static bool all_zeroes(const byte* beg, const byte* end) {
@@ skipping 461 matching lines @@
   size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseLsa);
   for (size_t i = 0; i < nr_test_cases; ++i) {
     uint64_t res = run_dlsa(tc[i].rt, tc[i].rs, tc[i].sa);
     PrintF("0x%" PRIx64 " =? 0x%" PRIx64 " == Dlsa(v0, %" PRIx64 ", %" PRIx64
            ", %hhu)\n",
            tc[i].expected_res, res, tc[i].rt, tc[i].rs, tc[i].sa);
     CHECK_EQ(tc[i].expected_res, res);
   }
 }
 
+float run_Cvt_s_uw(uint32_t x) {
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+  MacroAssembler assembler(isolate, nullptr, 0,
+                           v8::internal::CodeObjectRequired::kYes);
+  MacroAssembler* masm = &assembler;
+
+  __ Cvt_s_uw(f0, a0);
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  assembler.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+  F2 f = FUNCTION_CAST<F2>(code->entry());
+
+  float res = CALL_GENERATED_CODE(isolate, f, x, 0, 0, 0, 0);
+
+  return res;
+}
+
+TEST(Cvt_s_uw) {
+  CcTest::InitializeVM();
+
+  struct TestCase {
+    uint32_t value;
+    float expected_res;
+  };
+
+  struct TestCase tc[] = {

[akos.palfi.imgtec, 2016/02/29 12:28:22]

Rename this const array to uint32_test_values and move outside of the function.
Instead of using a struct to store each exp/value pair, use a simple uint32_t
array and do the casting inside the for {} block.

[Ilija.Pavlovic1, 2016/02/29 15:00:27]

In all our test suites (test-assembler-mips*, test-macro-assebler-mips*)
following structure is used in most cases:

TEST(<test_name>) {
  <test structures>
  <test data>
  <test execution>
  <checking received results>
}

If I change the code according the comment, we will have test data outside the
test and we'll have a new style:

<test data>
TEST(<test_name>) {
  ...
}

Instead this change, I would like to introduce a macro above the TEST() similar
as in following example:
#define CVT_S_UW_SAMPLE(x) {x, static_cast<float>(x)}

On this way, we will avoid entering duplicated data and still follow existing
style. What is your opinion about this?

[Ilija.Pavlovic1, 2016/03/04 08:02:52]

Done.

+      // value,       expected_res
+      {0x00000000, static_cast<float>(0x00000000)},
+      {0x00000001, static_cast<float>(0x00000001)},
+      {0x7fffffff, static_cast<float>(0x7fffffff)},
+      {0x80000000, static_cast<float>(0x80000000)},
+      {0x8fffffff, static_cast<float>(0x8fffffff)},
+      {0xffffffff, static_cast<float>(0xffffffff)},
+  };
+
+  size_t nr_test_cases = sizeof(tc) / sizeof(TestCase);
+  for (size_t i = 0; i < nr_test_cases; ++i) {
+    CHECK_EQ(tc[i].expected_res, run_Cvt_s_uw(tc[i].value));
+  }
+}
+
+float run_Cvt_s_ul(uint64_t x) {
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+  MacroAssembler assembler(isolate, nullptr, 0,
+                           v8::internal::CodeObjectRequired::kYes);
+  MacroAssembler* masm = &assembler;
+
+  __ Cvt_s_ul(f0, a0);
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  assembler.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+  F3 f = FUNCTION_CAST<F3>(code->entry());
+
+  float res = CALL_GENERATED_CODE(isolate, f, x, 0, 0, 0, 0);
+
+  return res;
+}
+
+TEST(Cvt_s_ul) {
+  CcTest::InitializeVM();
+
+  struct TestCase {
+    uint64_t value;
+    float expected_res;
+  };
+
+  struct TestCase tc[] = {

[akos.palfi.imgtec, 2016/02/29 12:28:22]

Same here, call it uint64_test_values.

[Ilija.Pavlovic1, 2016/03/04 08:02:52]

Done.

+      // value,             expected_res
+      {0x0000000000000000, static_cast<float>(0x0000000000000000)},
+      {0x0000000000000001, static_cast<float>(0x0000000000000001)},
+      {0x7fffffffffffffff, static_cast<float>(0x7fffffffffffffff)},
+      {0x8000000000000000, static_cast<float>(0x8000000000000000)},
+      {0x8fffffffffffffff, static_cast<float>(0x8fffffffffffffff)},
+      {0xffffffffffffffff, static_cast<float>(0xffffffffffffffff)},
+  };
+
+  size_t nr_test_cases = sizeof(tc) / sizeof(TestCase);
+  for (size_t i = 0; i < nr_test_cases; ++i) {
+    CHECK_EQ(tc[i].expected_res, run_Cvt_s_ul(tc[i].value));
+  }
+}
+
+double run_Cvt_d_ul(uint64_t x) {
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+  MacroAssembler assembler(isolate, nullptr, 0,
+                           v8::internal::CodeObjectRequired::kYes);
+  MacroAssembler* masm = &assembler;
+
+  __ Cvt_d_ul(f0, a0);
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  assembler.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+  F4 f = FUNCTION_CAST<F4>(code->entry());
+
+  float res = CALL_GENERATED_CODE(isolate, f, x, 0, 0, 0, 0);
+
+  return res;
+}
+
+TEST(Cvt_d_ul) {
+  CcTest::InitializeVM();
+
+  struct TestCase {
+    uint64_t value;
+    double expected_res;
+  };
+
+  struct TestCase tc[] = {

[akos.palfi.imgtec, 2016/02/29 12:28:22]

Same here.

[Ilija.Pavlovic1, 2016/03/04 08:02:52]

Done.

+      // value,             expected_res
+      {0x0000000000000000, static_cast<double>(0x0000000000000000)},
+      {0x0000000000000001, static_cast<double>(0x0000000000000001)},
+      {0x7fffffffffffffff, static_cast<double>(0x7fffffffffffffff)},
+      {0x8000000000000000, static_cast<double>(0x8000000000000000)},
+      {0x8fffffffffffffff, static_cast<double>(0x8fffffffffffffff)},
+      {0xffffffffffffffff, static_cast<double>(0xffffffffffffffff)},
+  };
+
+  size_t nr_test_cases = sizeof(tc) / sizeof(TestCase);
+  for (size_t i = 0; i < nr_test_cases; ++i) {
+    CHECK_EQ(tc[i].expected_res, run_Cvt_d_ul(tc[i].value));
+  }
+}
+
 #undef __