Fix Win64 build of Dart VM.

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"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 #define __ assembler->
 
 
 ASSEMBLER_TEST_GENERATE(ReadArgument, assembler) {
-  __ pushq(RDI);  // First argument is passed in register rdi.
+  __ pushq(CallingConventions::kArg1Reg);
   __ movq(RAX, Address(RSP, 0));
   __ popq(RDX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ReadArgument, test) {
   typedef int64_t (*ReadArgumentCode)(int64_t n);
   ReadArgumentCode id = reinterpret_cast<ReadArgumentCode>(test->entry());
   EXPECT_EQ(42, id(42));
@@ skipping 1259 matching lines @@
 
 ASSEMBLER_TEST_GENERATE(CallSimpleLeaf, assembler) {
   ExternalLabel call1(reinterpret_cast<uword>(LeafReturn42));
   ExternalLabel call2(reinterpret_cast<uword>(LeafReturnArgument));
   int space = ComputeStackSpaceReservation(0, 8);
   __ subq(RSP, Immediate(space));
   __ call(&call1);
   __ addq(RSP, Immediate(space));
   space = ComputeStackSpaceReservation(0, 8);
   __ subq(RSP, Immediate(space));
-  __ movl(RDI, RAX);
+  __ movl(CallingConventions::kArg1Reg, RAX);
   __ call(&call2);
   __ addq(RSP, Immediate(space));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(CallSimpleLeaf, test) {
   typedef int (*CallSimpleLeafCode)();
   EXPECT_EQ(42 + 87, reinterpret_cast<CallSimpleLeafCode>(test->entry())());
 }
@@ skipping 1407 matching lines @@
       reinterpret_cast<SquareRootDoubleCode>(test->entry())(kDoubleConst);
   EXPECT_FLOAT_EQ(sqrt(kDoubleConst), res, 0.0001);
 }
 
 
 // Called from assembler_test.cc.
 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) {
   __ pushq(PP);  // Save caller's pool pointer and load a new one here.
   __ LoadPoolPointer(PP);
   __ pushq(CTX);
-  __ movq(CTX, RDI);
-  __ StoreIntoObject(RDX,
-                     FieldAddress(RDX, GrowableObjectArray::data_offset()),
-                     RSI);
+  __ movq(CTX, CallingConventions::kArg1Reg);
+  __ StoreIntoObject(CallingConventions::kArg3Reg,
+                     FieldAddress(CallingConventions::kArg3Reg,
+                                  GrowableObjectArray::data_offset()),
+                     CallingConventions::kArg2Reg);
   __ popq(CTX);
   __ popq(PP);  // Restore caller's pool pointer.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleFPUStackMoves, assembler) {
   int64_t l = bit_cast<int64_t, double>(1024.67);
   __ movq(RAX, Immediate(l));
   __ pushq(RAX);
@@ skipping 60 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(IntToDoubleConversion, test) {
   typedef double (*IntToDoubleConversionCode)();
   double res = reinterpret_cast<IntToDoubleConversionCode>(test->entry())();
   EXPECT_FLOAT_EQ(6.0, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(IntToDoubleConversion2, assembler) {
-  __ pushq(RDI);
+  __ pushq(CallingConventions::kArg1Reg);
   __ fildl(Address(RSP, 0));
   __ fstpl(Address(RSP, 0));
   __ movsd(XMM0, Address(RSP, 0));
   __ popq(RAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(IntToDoubleConversion2, test) {
   typedef double (*IntToDoubleConversion2Code)(int i);
@@ skipping 67 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(TestSetCC, test) {
   typedef uword (*TestSetCC)();
   uword res = reinterpret_cast<TestSetCC>(test->entry())();
   EXPECT_EQ(0xFFFFFF00, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(TestRepMovsBytes, assembler) {
-  // Save incoming arguments.
-  __ pushq(RDI);  // Arg0, from.
-  __ pushq(RSI);  // Arg1, to.
-  __ pushq(RDX);  // Arg2, count.
+  __ pushq(RSI);
+  __ pushq(RDI);
+  __ pushq(CallingConventions::kArg1Reg);  // from.
+  __ pushq(CallingConventions::kArg2Reg);  // to.
+  __ pushq(CallingConventions::kArg3Reg);  // count.
   __ movq(RSI, Address(RSP, 2 * kWordSize));  // from.
   __ movq(RDI, Address(RSP, 1 * kWordSize));  // to.
   __ movq(RCX, Address(RSP, 0 * kWordSize));  // count.
   __ rep_movsb();
   // Remove saved arguments.
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);
+  __ popq(RDI);
+  __ popq(RSI);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(TestRepMovsBytes, test) {
   const char* from = "0123456789";
   const char* to = new char[10];
   typedef void (*TestRepMovsBytes)(const char* from, const char* to, int count);
   reinterpret_cast<TestRepMovsBytes>(test->entry())(from, to, 10);
   EXPECT_EQ(to[0], '0');
   for (int i = 0; i < 10; i++) {
     EXPECT_EQ(from[i], to[i]);
   }
   delete [] to;
 }
 
 
 ASSEMBLER_TEST_GENERATE(ConditionalMovesCompare, assembler) {
-  // RDI: Arg0.
-  // RSI: Arg1.
+  __ cmpq(CallingConventions::kArg1Reg, CallingConventions::kArg2Reg);
   __ movq(RDX, Immediate(1));  // Greater equal.
   __ movq(RCX, Immediate(-1));  // Less
-  __ cmpq(RDI, RSI);
   __ cmovlessq(RAX, RCX);
   __ cmovgeq(RAX, RDX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ConditionalMovesCompare, test) {
   typedef int (*ConditionalMovesCompareCode)(int i, int j);
   int res = reinterpret_cast<ConditionalMovesCompareCode>(test->entry())(10, 5);
   EXPECT_EQ(1, res);  // Greater equal.
   res = reinterpret_cast<ConditionalMovesCompareCode>(test->entry())(5, 5);
   EXPECT_EQ(1, res);  // Greater equal.
   res = reinterpret_cast<ConditionalMovesCompareCode>(test->entry())(2, 5);
   EXPECT_EQ(-1, res);  // Less.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64