A64 support for DoubleToIStub (truncating).

test/cctest/test-code-stubs-a64.cc

Index: test/cctest/test-code-stubs-a64.cc
diff --git a/test/cctest/test-code-stubs-arm.cc b/test/cctest/test-code-stubs-a64.cc
similarity index 79%
copy from test/cctest/test-code-stubs-arm.cc
copy to test/cctest/test-code-stubs-a64.cc
index 53cdd161308b903ea92bdf6a25b03c3cfdaaee49..533447db5932c50895c024efb8e0b446059aba9c 100644
--- a/test/cctest/test-code-stubs-arm.cc
+++ b/test/cctest/test-code-stubs-a64.cc
@@ -58,19 +58,15 @@ ConvertDToIFunc MakeConvertDToIFuncTrampoline(Isolate* isolate,
   byte* start = stub.GetCode(isolate)->instruction_start();
   Label done;
 
-  // Save callee save registers.
-  __ Push(r7, r6, r5, r4);
-  __ Push(lr);
+  __ SetStackPointer(csp);
+  __ PushCalleeSavedRegisters();
+  __ Mov(jssp, csp);
+  __ SetStackPointer(jssp);
 
-  // For softfp, move the input value into d0.
-  if (!masm.use_eabi_hardfloat()) {
-    __ vmov(d0, r0, r1);
-  }
   // Push the double argument.
-  __ sub(sp, sp, Operand(kDoubleSize));
-  __ vstr(d0, sp, 0);
-  if (!source_reg.is(sp)) {
-    __ mov(source_reg, sp);
+  __ Push(d0);
+  if (!source_reg.is(jssp)) {
+    __ Mov(source_reg, jssp);
   }
 
   // Save registers make sure they don't get clobbered.
@@ -79,50 +75,49 @@ ConvertDToIFunc MakeConvertDToIFuncTrampoline(Isolate* isolate,
   for (;reg_num < Register::NumAllocatableRegisters(); ++reg_num) {
     Register reg = Register::from_code(reg_num);
     if (!reg.is(destination_reg)) {
-      __ push(reg);
+      __ Push(reg);
       source_reg_offset += kPointerSize;
     }
   }
 
   // Re-push the double argument.
-  __ sub(sp, sp, Operand(kDoubleSize));
-  __ vstr(d0, sp, 0);
+  __ Push(d0);
 
   // Call through to the actual stub
   if (inline_fastpath) {
-    __ vldr(d0, MemOperand(source_reg));
+    __ Ldr(d0, MemOperand(source_reg));
     __ TryInlineTruncateDoubleToI(destination_reg, d0, &done);
-    if (destination_reg.is(source_reg) && !source_reg.is(sp)) {
+    if (destination_reg.is(source_reg)) {
       // Restore clobbered source_reg.
-      __ add(source_reg, sp, Operand(source_reg_offset));
+      __ add(source_reg, jssp, Operand(source_reg_offset));
     }
   }
   __ Call(start, RelocInfo::EXTERNAL_REFERENCE);
   __ bind(&done);
 
-  __ add(sp, sp, Operand(kDoubleSize));
+  __ Drop(1, kDoubleSize);
 
-  // Make sure no registers have been unexpectedly clobbered
+  // // Make sure no registers have been unexpectedly clobbered

[jbramley, 2014/02/13 14:20:14]

Double comment.

   for (--reg_num; reg_num >= 0; --reg_num) {
     Register reg = Register::from_code(reg_num);
     if (!reg.is(destination_reg)) {
-      __ ldr(ip, MemOperand(sp, 0));
-      __ cmp(reg, ip);
+      __ Pop(ip0);
+      __ cmp(reg, ip0);
       __ Assert(eq, kRegisterWasClobbered);
-      __ add(sp, sp, Operand(kPointerSize));
     }
   }
 
-  __ add(sp, sp, Operand(kDoubleSize));
+  __ Drop(1, kDoubleSize);
 
-  if (!destination_reg.is(r0))
-    __ mov(r0, destination_reg);
+  if (!destination_reg.is(x0))
+    __ Mov(x0, destination_reg);

[jbramley, 2014/02/13 14:20:14]

The 'if' isn't necessary; A64's Mov emits no code if the source and destination
are the same.

 
   // Restore callee save registers.
-  __ Pop(lr);
-  __ Pop(r7, r6, r5, r4);
+  __ Mov(csp, jssp);
+  __ SetStackPointer(csp);
+  __ PopCalleeSavedRegisters();
 
-  __ Ret(0);
+  __ Ret();
 
   CodeDesc desc;
   masm.GetCode(&desc);
@@ -142,7 +137,9 @@ static Isolate* GetIsolateFrom(LocalContext* context) {
 int32_t RunGeneratedCodeCallWrapper(ConvertDToIFunc func,

[jbramley, 2014/02/13 14:20:14]

Does this need to return int64_t? If not, the result of CallInt64 should
probably be filtered through is_int32 or something similar.

                                     double from) {
 #ifdef USE_SIMULATOR
-  return CALL_GENERATED_FP_INT(func, from, 0);
+  return Simulator::current(Isolate::Current())->CallInt64(
+      FUNCTION_ADDR(func), Simulator::CallArgument(from),
+      Simulator::CallArgument::End());
 #else
   return (*func)(from);
 #endif
@@ -159,11 +156,15 @@ TEST(ConvertDToI) {
   // Verify that the tests actually work with the C version. In the release
   // code, the compiler optimizes it away because it's all constant, but does it
   // wrong, triggering an assert on gcc.
-  RunAllTruncationTests(&ConvertDToICVersion);
+  // RunAllTruncationTests(&ConvertDToICVersion);
 #endif
 
-  Register source_registers[] = {sp, r0, r1, r2, r3, r4, r5, r6, r7};
-  Register dest_registers[] = {r0, r1, r2, r3, r4, r5, r6, r7};
+  Register source_registers[] = {jssp, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9,
+                                 x10, x11, x12, x13, x14, x15, x18, x19, x20,
+                                 x21, x22, x23, x24};
+  Register dest_registers[] = {x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11,
+                               x12, x13, x14, x15, x18, x19, x20, x21, x22, x23,
+                               x24};
 
   for (size_t s = 0; s < sizeof(source_registers) / sizeof(Register); s++) {
     for (size_t d = 0; d < sizeof(dest_registers) / sizeof(Register); d++) {