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);
@@ skipping 64 matching lines @@
   __ 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));
   __ 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, XMM12);  // 1.843

[Florian Schneider, 2012/11/19 10:34:33]

Maybe do sqrtsd(XMM8, XMM8) instead to include the result of the previous
operations.

[Cutch, 2012/11/19 23:28:58]

Done.

[Cutch, 2012/11/19 23:28:58]

Done, I also add the XMM0 and XMM8 values together at the end.
On 2012/11/19 10:34:33, Florian Schneider wrote:

   __ 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, XMM1);  // 1.843

[Florian Schneider, 2012/11/19 10:34:33]

Maybe do sqrtsd(XMM0, XMM0) instead to include the result of the previous
operations.

To check correctness of XMM8, you could do subsd(XMM0, XMM8) here and check the
expected result value against 0.0.

[Cutch, 2012/11/19 23:28:58]

I add them together. I use the subtraction op elsewhere.
On 2012/11/19 10:34:33, Florian Schneider wrote:

   __ 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(1.843, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Int32ToDoubleConversion, assembler) {
   __ movl(RDX, Immediate(6));
   __ cvtsi2sd(XMM0, RDX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Int32ToDoubleConversion, entry) {
   typedef double (*IntToDoubleConversionCode)();
   double res = reinterpret_cast<IntToDoubleConversionCode>(entry)();
   EXPECT_FLOAT_EQ(6.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);
 }
 
@@ skipping 184 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