Add support for XMM8..XMM15

runtime/vm/assembler_x64_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/os.h"
 #include "vm/unit_test.h"
@@ skipping 1226 matching lines @@
 ASSEMBLER_TEST_GENERATE(SingleFPMoves, assembler) {
   __ movq(RAX, Immediate(bit_cast<int32_t, float>(234.0f)));
   __ movd(XMM0, RAX);
   __ movss(XMM1, XMM0);
   __ movss(XMM2, XMM1);
   __ movss(XMM3, XMM2);
   __ movss(XMM4, XMM3);
   __ movss(XMM5, XMM4);
   __ movss(XMM6, XMM5);
   __ movss(XMM7, XMM6);
+  __ movss(XMM8, XMM7);
+  __ movss(XMM9, XMM8);
+  __ movss(XMM10, XMM9);
+  __ movss(XMM11, XMM10);
+  __ movss(XMM12, XMM11);
+  __ movss(XMM13, XMM12);
+  __ movss(XMM14, XMM13);
+  __ movss(XMM15, XMM14);
   __ pushq(R15);  // Callee saved.
   __ pushq(RAX);
   __ movq(Address(RSP, 0), Immediate(0));
   __ movss(XMM0, Address(RSP, 0));
   __ movss(Address(RSP, 0), XMM7);
   __ movss(XMM1, Address(RSP, 0));
   __ movq(R10, RSP);
   __ movss(Address(R10, 0), XMM1);
   __ movss(XMM2, Address(R10, 0));
   __ movq(R15, RSP);
   __ movss(Address(R15, 0), XMM2);
   __ movss(XMM3, Address(R15, 0));
   __ movq(RAX, RSP);
   __ movss(Address(RAX, 0), XMM3);
-  __ movss(XMM4, Address(RAX, 0));
-  __ movss(XMM0, Address(RAX, 0));
+  __ movss(XMM1, Address(RAX, 0));
+  __ movss(XMM15, Address(RAX, 0));
+  __ movss(XMM14, XMM15);
+  __ movss(XMM13, XMM14);
+  __ movss(XMM12, XMM13);
+  __ movss(XMM11, XMM12);
+  __ movss(XMM10, XMM11);
+  __ movss(XMM9, XMM10);
+  __ movss(XMM8, XMM9);
+  __ movss(XMM7, XMM8);
+  __ movss(XMM6, XMM7);
+  __ movss(XMM5, XMM6);
+  __ movss(XMM4, XMM5);
+  __ movss(XMM3, XMM4);
+  __ movss(XMM2, XMM3);
+  __ movss(XMM1, XMM2);
+  __ movss(XMM0, XMM1);
   __ popq(RAX);
   __ popq(R15);  // Callee saved.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SingleFPMoves, entry) {
   typedef float (*SingleFPMovesCode)();
   EXPECT_EQ(234, reinterpret_cast<SingleFPMovesCode>(entry)());
 }
 
 
 ASSEMBLER_TEST_GENERATE(SingleFPMoves2, assembler) {
   __ movq(RAX, Immediate(bit_cast<int32_t, float>(234.0f)));
   __ movd(XMM0, RAX);
-  __ movss(XMM1, XMM0);
+  __ movd(XMM8, RAX);
+  __ movss(XMM1, XMM8);
   __ pushq(RAX);
   __ movq(Address(RSP, 0), Immediate(0));
   __ movss(XMM0, Address(RSP, 0));
   __ movss(Address(RSP, 0), XMM1);
   __ movss(XMM0, Address(RSP, 0));
+  __ movq(Address(RSP, 0), Immediate(0));
+  __ movss(XMM9, XMM8);
+  __ movss(Address(RSP, 0), XMM9);
+  __ movss(XMM8, Address(RSP, 0));
+  __ movss(XMM0, XMM8);
   __ popq(RAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SingleFPMoves2, entry) {
   typedef float (*SingleFPMoves2Code)();
   EXPECT_EQ(234, reinterpret_cast<SingleFPMoves2Code>(entry)());
 }
 
 
 ASSEMBLER_TEST_GENERATE(SingleFPOperations, assembler) {
   __ pushq(RBX);
   __ pushq(RCX);
   __ movq(RBX, Immediate(bit_cast<int32_t, float>(12.3f)));
   __ movd(XMM0, RBX);
+  __ movd(XMM8, RBX);
   __ movq(RCX, Immediate(bit_cast<int32_t, float>(3.4f)));
   __ movd(XMM1, RCX);
+  __ movd(XMM9, RCX);
   __ addss(XMM0, XMM1);  // 15.7f
   __ mulss(XMM0, XMM1);  // 53.38f
   __ subss(XMM0, XMM1);  // 49.98f
   __ divss(XMM0, XMM1);  // 14.7f
+  __ addss(XMM8, XMM9);  // 15.7f
+  __ mulss(XMM8, XMM9);  // 53.38f
+  __ subss(XMM8, XMM9);  // 49.98f
+  __ divss(XMM8, XMM9);  // 14.7f
+  __ subss(XMM0, XMM8);  // 0.0f
   __ popq(RCX);
   __ popq(RBX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SingleFPOperations, entry) {
   typedef float (*SingleFPOperationsCode)();
   float res = reinterpret_cast<SingleFPOperationsCode>(entry)();
-  EXPECT_FLOAT_EQ(14.7f, res, 0.001f);
+  EXPECT_FLOAT_EQ(0.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleFPMoves, assembler) {
   __ movq(RAX, Immediate(bit_cast<int64_t, double>(1024.67)));
   __ pushq(R15);  // Callee saved.
   __ pushq(RAX);
   __ movsd(XMM0, Address(RSP, 0));
   __ movsd(XMM1, XMM0);
   __ movsd(XMM2, XMM1);
   __ movsd(XMM3, XMM2);
   __ movsd(XMM4, XMM3);
   __ movsd(XMM5, XMM4);
   __ movsd(XMM6, XMM5);
   __ movsd(XMM7, XMM6);
+  __ movsd(XMM8, XMM7);
+  __ movsd(XMM9, XMM8);
+  __ movsd(XMM10, XMM9);
+  __ movsd(XMM11, XMM10);
+  __ movsd(XMM12, XMM11);
+  __ movsd(XMM13, XMM12);
+  __ movsd(XMM14, XMM13);
+  __ movsd(XMM15, XMM14);
   __ movq(Address(RSP, 0), Immediate(0));
   __ movsd(XMM0, Address(RSP, 0));
-  __ movsd(Address(RSP, 0), XMM7);
+  __ movsd(Address(RSP, 0), XMM15);
   __ movsd(XMM1, Address(RSP, 0));
   __ movq(R10, RSP);
   __ movsd(Address(R10, 0), XMM1);
   __ movsd(XMM2, Address(R10, 0));
   __ movq(R15, RSP);
   __ movsd(Address(R15, 0), XMM2);
   __ movsd(XMM3, Address(R15, 0));
   __ movq(RAX, RSP);
   __ movsd(Address(RAX, 0), XMM3);
   __ movsd(XMM4, Address(RAX, 0));
-  __ movsd(XMM7, Address(RSP, 0));
+  __ movsd(XMM15, Address(RSP, 0));
+  __ movaps(XMM14, XMM15);
+  __ movaps(XMM13, XMM14);
+  __ movaps(XMM12, XMM13);
+  __ movaps(XMM11, XMM12);
+  __ movaps(XMM10, XMM11);
+  __ movaps(XMM9, XMM10);
+  __ movaps(XMM8, XMM9);
+  __ movaps(XMM7, XMM8);
   __ movaps(XMM6, XMM7);
   __ movaps(XMM5, XMM6);
   __ movaps(XMM4, XMM5);
   __ movaps(XMM3, XMM4);
   __ movaps(XMM2, XMM3);
   __ movaps(XMM1, XMM2);
   __ movaps(XMM0, XMM1);
   __ popq(RAX);
   __ popq(R15);  // Callee saved.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleFPMoves, entry) {
   typedef double (*DoubleFPMovesCode)();
   EXPECT_FLOAT_EQ(1024.67, reinterpret_cast<DoubleFPMovesCode>(entry)(), 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleFPOperations, assembler) {
   __ movq(RAX, Immediate(bit_cast<int64_t, double>(12.3)));
   __ pushq(RAX);
   __ movsd(XMM0, Address(RSP, 0));
+  __ movsd(XMM8, Address(RSP, 0));
   __ movq(RAX, Immediate(bit_cast<int64_t, double>(3.4)));
   __ movq(Address(RSP, 0), RAX);
+  __ movsd(XMM12, Address(RSP, 0));
+  __ addsd(XMM8, XMM12);  // 15.7
+  __ mulsd(XMM8, XMM12);  // 53.38
+  __ subsd(XMM8, XMM12);  // 49.98
+  __ divsd(XMM8, XMM12);  // 14.7
+  __ sqrtsd(XMM8, XMM8);  // 3.834
   __ movsd(XMM1, Address(RSP, 0));
   __ addsd(XMM0, XMM1);  // 15.7
   __ mulsd(XMM0, XMM1);  // 53.38
   __ subsd(XMM0, XMM1);  // 49.98
   __ divsd(XMM0, XMM1);  // 14.7
+  __ sqrtsd(XMM0, XMM0);  // 3.834057902
+  __ addsd(XMM0, XMM8);  // 7.6681
   __ popq(RAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleFPOperations, entry) {
   typedef double (*SingleFPOperationsCode)();
   double res = reinterpret_cast<SingleFPOperationsCode>(entry)();
-  EXPECT_FLOAT_EQ(14.7, res, 0.001);
+  EXPECT_FLOAT_EQ(7.668, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Int32ToDoubleConversion, assembler) {
   __ movl(RDX, Immediate(6));
   __ cvtsi2sd(XMM0, RDX);
+  __ movl(RDX, Immediate(8));
+  __ cvtsi2sd(XMM8, RDX);
+  __ subsd(XMM0, XMM8);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Int32ToDoubleConversion, entry) {
   typedef double (*IntToDoubleConversionCode)();
   double res = reinterpret_cast<IntToDoubleConversionCode>(entry)();
-  EXPECT_FLOAT_EQ(6.0, res, 0.001);
+  EXPECT_FLOAT_EQ(-2.0, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Int64ToDoubleConversion, assembler) {
   __ movq(RDX, Immediate(12LL << 32));
   __ cvtsi2sd(XMM0, RDX);
+  __ movsd(XMM15, XMM0);  // Move to high register
+  __ addsd(XMM0, XMM0);  // Stomp XMM0
+  __ movsd(XMM0, XMM15);  // Move back to XMM0
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Int64ToDoubleConversion, entry) {
   typedef double (*Int64ToDoubleConversionCode)();
   double res = reinterpret_cast<Int64ToDoubleConversionCode>(entry)();
   EXPECT_FLOAT_EQ(static_cast<double>(12LL << 32), res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleToInt64Conversion, assembler) {
   __ movq(RAX, Immediate(bit_cast<int64_t, double>(12.3)));
   __ pushq(RAX);
+  __ movsd(XMM9, Address(RSP, 0));
   __ movsd(XMM6, Address(RSP, 0));
   __ popq(RAX);
+  __ cvttsd2siq(R10, XMM6);
   __ cvttsd2siq(RDX, XMM6);
+  __ cvttsd2siq(R10, XMM9);
+  __ cvttsd2siq(RDX, XMM9);
+  __ subq(RDX, R10);
   __ movq(RAX, RDX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleToInt64Conversion, entry) {
   typedef int64_t (*DoubleToInt64ConversionCode)();
   int64_t res = reinterpret_cast<DoubleToInt64ConversionCode>(entry)();
-  EXPECT_EQ(12, res);
+  EXPECT_EQ(0, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(TestObjectCompare, assembler) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Object& obj = Object::ZoneHandle(object_store->smi_class());
   Label fail;
   __ LoadObject(RAX, obj);
   __ CompareObject(RAX, obj);
   __ j(NOT_EQUAL, &fail);
@@ skipping 158 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(XorpdZeroing, entry) {
   typedef double (*XorpdZeroingCode)(double d);
   double res = reinterpret_cast<XorpdZeroingCode>(entry)(12.56e3);
   EXPECT_FLOAT_EQ(0.0, res, 0.0001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(XorpdZeroing2, assembler) {
+  Label done;
+  __ xorpd(XMM15, XMM15);
   __ xorpd(XMM0, XMM0);
+  __ xorpd(XMM0, XMM15);
+  __ comisd(XMM0, XMM15);
+  __ j(ZERO, &done);
+  __ int3();
+  __ Bind(&done);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(XorpdZeroing2, entry) {
   typedef double (*XorpdZeroing2Code)(double d);
   double res = reinterpret_cast<XorpdZeroing2Code>(entry)(12.56e3);
   EXPECT_FLOAT_EQ(0.0, res, 0.0001);
 }
 
@@ skipping 127 matching lines @@
   EXPECT_EQ(0, res);
   res = reinterpret_cast<ExtractSignBits>(entry)(-1.0);
   EXPECT_EQ(1, res);
   res = reinterpret_cast<ExtractSignBits>(entry)(-0.0);
   EXPECT_EQ(1, res);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64