MIPS64: Add/fix bit insertion/extraction instrs.

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 6039 matching lines @@
 TEST(maddf_msubf_d) {
   if (kArchVariant != kMips64r6) return;
   helper_madd_msub_maddf_msubf<double>([](MacroAssembler& assm) {
     __ maddf_d(f4, f6, f8);
     __ Sdc1(f4, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_add)));
     __ msubf_d(f16, f6, f8);
     __ Sdc1(f16, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_sub)));
   });
 }
 
+uint64_t run_Dins(uint64_t imm, uint64_t source, uint16_t pos, uint16_t size) {
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
+
+  __ li(v0, imm);
+  __ li(t0, source);
+  __ Dins(v0, t0, pos, size);
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+  F2 f = FUNCTION_CAST<F2>(code->entry());
+
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
+
+  return res;
+}
+
+TEST(Dins) {
+  CcTest::InitializeVM();
+
+  // Test Dins macro-instruction.
+
+  struct TestCaseDins {
+    uint64_t imm;

[Ilija.Pavlovic1, 2017/05/09 09:17:46]

Instead "imm" maybe more suitable name is "res".

[miran.karic, 2017/05/09 13:52:43]

This is initial value of target register, not result, I think it can stay as it
is.

+    uint64_t source;
+    uint16_t pos;
+    uint16_t size;
+    uint64_t expected_res;
+  };
+
+  // We load imm to v0 and source to t0 and then call
+  // Dins(v0, t0, pos, size) to test cases listed below.
+  struct TestCaseDins tc[] = {
+      // imm, source, pos, size, expected_res
+      {0x0, 0x1FABCDEFF, 31, 1, 0x80000000},

[Ilija.Pavlovic1, 2017/05/09 09:17:46]

Instead 0x0, use another value (for example 0xAAAAAAAA) which will show that
operation is performed on expected way.

[miran.karic, 2017/05/09 13:52:43]

Yes I think that will be better, I adjusted test cases to cover this.

+      {0x0, 0x1FABCDEFF, 30, 2, 0xc0000000},
+      {0x0, 0x1FABCDEFF, 0, 32, 0xFABCDEFF},
+      {0x0, 0x7FABCDEFF, 31, 2, 0x180000000},
+      {0x0, 0x7FABCDEFF, 0, 33, 0x1FABCDEFF},
+      {0x0, 0xABCDABCDABCDABCD, 0, 64, 0xABCDABCDABCDABCD},
+      {0x0, 0xABCEABCFABCEABCF, 32, 1, 0x100000000},
+      {0x0, 0xABCEABCFABCEABCF, 63, 1, 0x8000000000000000},
+      {0x0, 0xABCEABCFABCEABCF, 32, 32, 0xABCEABCF00000000},
+  };
+
+  size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseDins);
+  for (size_t i = 0; i < nr_test_cases; ++i) {
+    CHECK_EQ(tc[i].expected_res,
+             run_Dins(tc[i].imm, tc[i].source, tc[i].pos, tc[i].size));
+  }
+}
+
+uint64_t getExpectedValueDINS(uint64_t rt, uint64_t rs, int pos, int size) {
+  uint64_t res = rt;
+  int i;
+  uint64_t bitVal;
+  for (i = 0; i < size; i++) {
+    bitVal = rs & (1 << i);
+    if (bitVal > 0) bitVal = 1;
+    res = res | bitVal << (i + pos);  // Works only for rs equals all ones!
+  }
+  return res;
+}
+
+TEST(Dins_all) {

[Ilija.Pavlovic1, 2017/05/09 09:17:46]

Maybe not needed to go through all combinations.

[miran.karic, 2017/05/09 13:52:43]

I agree, I removed this test and only left Dins test that covers a number of
cases.

+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
+
+  // Test Dins macro-instruction.
+
+  const uint64_t rt = 0;
+  const uint64_t rs = std::numeric_limits<uint64_t>::max();
+  Label exit, error;
+  uint64_t result;
+
+  int iPos, iSize;
+  // Run through all possible Dins pos and size inputs.
+  for (iPos = 0; iPos < 64; ++iPos) {
+    for (iSize = 1; iSize <= 64 - iPos; ++iSize) {
+      result = getExpectedValueDINS(rt, rs, iPos, iSize);
+      __ li(a0, rt);
+      __ li(a1, rs);
+      __ Dins(a0, a1, iPos, iSize);
+      __ Branch(&error, ne, a0, Operand(result));
+      __ nop();
+    }
+  }
+
+  // Everything was correctly executed. Load the expected result.
+  __ li(v0, 0x31415926);
+  __ b(&exit);
+  __ nop();
+
+  __ bind(&error);
+  // Got an error. Return a wrong result.
+  __ li(v0, 666);
+
+  __ bind(&exit);
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+  F2 f = FUNCTION_CAST<F2>(code->entry());
+  int64_t res =
+      reinterpret_cast<int64_t>(CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
+
+  CHECK_EQ(0x31415926L, res);
+}
+
 #undef __