[arm] Add support for SMMLA, SMMLS and SMMUL.

test/cctest/test-assembler-arm.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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#include <iostream>  // NOLINT(readability/streams)
+
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/arm/assembler-arm-inl.h"
 #include "src/arm/simulator-arm.h"
 #include "src/disassembler.h"
 #include "src/factory.h"
 #include "src/ostreams.h"
 
 using namespace v8::internal;
@@ skipping 1450 matching lines @@
     TEST_SDIV(5, -10, -2);
     TEST_SDIV(3, -10, -3);
     USE(dummy);
   }
 }
 
 
 #undef TEST_SDIV
 
 
+#define TEST_SMMUL(f, x, y)                                      \

[Benedikt Meurer, 2014/10/13 18:25:48]

Move all the new tests to test/unittests/arm/assembler-arm-unittests.cc instead?

[Benedikt Meurer, 2014/10/14 04:49:43]

Maybe later...

+  do {                                                           \
+    int32_t actual;                                              \
+    Object* dummy = CALL_GENERATED_CODE(f, &actual, x, y, 0, 0); \
+    CHECK_EQ(v8::base::bits::SignedMulHigh32(x, y), actual);     \
+    USE(dummy);                                                  \
+  } while (0)
+
+
+TEST(19) {
+  // Test smmul.
+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+
+  Assembler assm(isolate, nullptr, 0);
+
+  __ smmul(r1, r1, r2);
+  __ str(r1, MemOperand(r0));
+  __ bx(lr);
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef DEBUG
+  code->Print(std::cout);
+#endif
+  F3 f = FUNCTION_CAST<F3>(code->entry());
+  TEST_SMMUL(f, kMinInt, kMinInt);
+  TEST_SMMUL(f, kMinInt, -1);
+  TEST_SMMUL(f, -1, kMinInt);
+  TEST_SMMUL(f, kMinInt, kMaxInt);
+  TEST_SMMUL(f, kMaxInt, kMinInt);
+  TEST_SMMUL(f, 0, 1);
+  TEST_SMMUL(f, 1, 0);
+  TEST_SMMUL(f, 42, -1);
+}
+
+
+#undef TEST_SMMUL
+
+
+#define TEST_SMMLA(f, x, y, z)                                        \
+  do {                                                                \
+    int32_t actual;                                                   \
+    Object* dummy = CALL_GENERATED_CODE(f, &actual, x, y, z, 0);      \
+    CHECK_EQ(v8::base::bits::SignedMulHighAndAdd32(x, y, z), actual); \
+    USE(dummy);                                                       \
+  } while (0)
+
+
+TEST(20) {
+  // Test smmla.
+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+
+  Assembler assm(isolate, nullptr, 0);
+
+  __ smmla(r1, r1, r2, r3);
+  __ str(r1, MemOperand(r0));
+  __ bx(lr);
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef DEBUG
+  code->Print(std::cout);
+#endif
+  F3 f = FUNCTION_CAST<F3>(code->entry());
+  TEST_SMMLA(f, kMinInt, kMinInt, 123456);
+  TEST_SMMLA(f, kMinInt, -1, 0);
+  TEST_SMMLA(f, -1, kMinInt, -1);
+  TEST_SMMLA(f, kMinInt, kMaxInt, 1);
+  TEST_SMMLA(f, kMaxInt, kMinInt, 0);
+  TEST_SMMLA(f, 0, 1, kMinInt);
+  TEST_SMMLA(f, 1, 0, kMaxInt - 1);
+  TEST_SMMLA(f, 42, -1, 0);
+}
+
+
+#undef TEST_SMMLA
+
+
+#define TEST_SMMLS(f, x, y, z)                                        \
+  do {                                                                \
+    int32_t actual;                                                   \
+    Object* dummy = CALL_GENERATED_CODE(f, &actual, x, y, z, 0);      \
+    CHECK_EQ(v8::base::bits::SignedMulHighAndSub32(x, y, z), actual); \
+    USE(dummy);                                                       \
+  } while (0)
+
+
+TEST(21) {
+  // Test smmls.
+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  HandleScope scope(isolate);
+
+  Assembler assm(isolate, nullptr, 0);
+
+  __ smmls(r1, r1, r2, r3);
+  __ str(r1, MemOperand(r0));
+  __ bx(lr);
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef DEBUG
+  code->Print(std::cout);
+#endif
+  F3 f = FUNCTION_CAST<F3>(code->entry());
+  TEST_SMMLS(f, kMinInt, kMinInt, 123456);
+  TEST_SMMLS(f, kMinInt, -1, 0);
+  TEST_SMMLS(f, -1, kMinInt, -1);
+  TEST_SMMLS(f, kMinInt, kMaxInt, 1);
+  TEST_SMMLS(f, kMaxInt, kMinInt, 0);
+  TEST_SMMLS(f, 0, 1, kMinInt);
+  TEST_SMMLS(f, 1, 0, kMaxInt - 1);
+  TEST_SMMLS(f, 42, -1, 0);
+}
+
+
+#undef TEST_SMMLS
+
+
 TEST(code_relative_offset) {
   // Test extracting the offset of a label from the beginning of the code
   // in a register.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   // Initialize a code object that will contain the code.
   Handle<Object> code_object(isolate->heap()->undefined_value(), isolate);
 
   Assembler assm(isolate, NULL, 0);
@@ skipping 51 matching lines @@
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), code_object);
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 21, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
   CHECK_EQ(42, res);
 }
 
 #undef __