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 504 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);
   }
 }
 
+static const std::vector<uint32_t> uint32_test_values() {

[ivica.bogosavljevic, 2016/03/04 16:28:28]

should be renamed to cvt_test_values or similar, since these test vectors are
used for cvt instructions

[Ilija.Pavlovic1, 2016/03/07 08:21:07]

The model for this form of input values is similar with input values defined in
the file "value-helper.h". This name "uint32_test_values" is left intentionally.
The main aim is to have one set of input values which cane be used in another
tests also - not just in these "cvt" tests.

[Ilija.Pavlovic1, 2016/03/07 08:21:07]

The model for this form of input values is similar with input values defined in
the file "value-helper.h". This name "uint32_test_values" is left intentionally.
The main aim is to have one set of input values which cane be used in another
tests also - not just in these "cvt" tests.

[Ilija.Pavlovic1, 2016/03/07 08:21:07]

Acknowledged.

+  static const uint32_t kValues[] = {0x00000000, 0x00000001, 0x00ffff00,
+                                     0x7fffffff, 0x80000000, 0x80000001,
+                                     0x80ffff00, 0x8fffffff, 0xffffffff};
+  return std::vector<uint32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<uint64_t> uint64_test_values() {

[ivica.bogosavljevic, 2016/03/04 16:28:28]

Same as above

[Ilija.Pavlovic1, 2016/03/07 08:21:07]

Acknowledged.

See previous comment.

+  static const uint64_t kValues[] = {
+      0x0000000000000000, 0x0000000000000001, 0x0000ffffffff0000,
+      0x7fffffffffffffff, 0x8000000000000000, 0x8000000000000001,
+      0x8000ffffffff0000, 0x8fffffffffffffff, 0xffffffffffffffff};
+  return std::vector<uint64_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+// Helper macros that can be used in FOR_INT32_INPUTS(i) { ... *i ... }
+#define FOR_INPUTS(ctype, itype, var)                        \
+  std::vector<ctype> var##_vec = itype##_test_values();      \
+  for (std::vector<ctype>::iterator var = var##_vec.begin(); \
+       var != var##_vec.end(); ++var)
+
+#define FOR_UINT32_INPUTS(var) FOR_INPUTS(uint32_t, uint32, var)
+#define FOR_UINT64_INPUTS(var) FOR_INPUTS(uint64_t, uint64, var)
+
+template <typename RET_TYPE, typename IN_TYPE, typename Func>
+RET_TYPE run_Cvt(IN_TYPE x, Func GenerateConvertInstructionFunc) {

[ivica.bogosavljevic, 2016/03/04 16:28:28]

Very interesting. Leaner code, although more difficult to understand. This looks
good from the point of what is being tested.

[Ilija.Pavlovic1, 2016/03/07 08:21:07]

Acknowledged.

+  typedef RET_TYPE (*F_CVT)(IN_TYPE x0, int x1, int x2, int x3, int x4);
+
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+  MacroAssembler assm(isolate, nullptr, 0,
+                      v8::internal::CodeObjectRequired::kYes);
+  MacroAssembler* masm = &assm;
+
+  GenerateConvertInstructionFunc(masm);
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+  F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
+
+  return CALL_GENERATED_CODE(isolate, f, x, 0, 0, 0, 0);
+}
+
+TEST(Cvt_s_uw) {
+  CcTest::InitializeVM();
+  FOR_UINT32_INPUTS(i) {
+    uint32_t input = *i;
+    CHECK_EQ(static_cast<float>(input),
+             run_Cvt<float>(
+                 input, [](MacroAssembler* masm) { masm->Cvt_s_uw(f0, a0); }));
+  }
+}
+
+TEST(Cvt_s_ul) {
+  CcTest::InitializeVM();
+  FOR_UINT64_INPUTS(i) {
+    uint64_t input = *i;
+    CHECK_EQ(static_cast<float>(input),
+             run_Cvt<float>(
+                 input, [](MacroAssembler* masm) { masm->Cvt_s_ul(f0, a0); }));
+  }
+}
+
+TEST(Cvt_d_ul) {
+  CcTest::InitializeVM();
+  FOR_UINT64_INPUTS(i) {
+    uint64_t input = *i;
+    CHECK_EQ(static_cast<double>(input),
+             run_Cvt<double>(
+                 input, [](MacroAssembler* masm) { masm->Cvt_d_ul(f0, a0); }));
+  }
+}
+
 #undef __