Implement hardfloat calling convention in macro assembler and simulator.

src/arm/macro-assembler-arm.cc

Index: src/arm/macro-assembler-arm.cc
diff --git a/src/arm/macro-assembler-arm.cc b/src/arm/macro-assembler-arm.cc
index 20dd0b4320dda538a3434df81d857a87686eb053..0d0e581ae407991e411aebffcbf36eeb52c0c5ba 100644
--- a/src/arm/macro-assembler-arm.cc
+++ b/src/arm/macro-assembler-arm.cc
@@ -839,7 +839,11 @@ void MacroAssembler::LeaveExitFrame(bool save_doubles,
 }
 
 void MacroAssembler::GetCFunctionDoubleResult(const DoubleRegister dst) {
-  vmov(dst, r0, r1);
+  if (FLAG_hardfloat) {

[Søren Thygesen Gjesse, 2011/04/27 08:19:01]

Please check whether dst is d0.

[Karl Klose, 2011/04/27 12:54:13]

I replaced the vmov with the new MacroAssembler::Move.

+    vmov(dst, d0);
+  } else {
+    vmov(dst, r0, r1);
+  }
 }
 
 
@@ -2794,12 +2798,29 @@ void MacroAssembler::JumpIfInstanceTypeIsNotSequentialAscii(Register type,
 
 static const int kRegisterPassedArguments = 4;
 
-void MacroAssembler::PrepareCallCFunction(int num_arguments, Register scratch) {
+
+void MacroAssembler::PrepareCallCFunction(int num_reg_arguments,
+                                          int num_double_arguments,
+                                          Register scratch) {
   int frame_alignment = ActivationFrameAlignment();
 
+  int stack_passed_arguments = 0;

[Søren Thygesen Gjesse, 2011/04/27 08:19:01]

I am not sure this calculation is 100% correct. If double arguments are
interleaved with integer arguments then more space is needed as each double
argument on the stack needs to be 8-byte aligned. To make this calculation I
think we need some signature information.

For now maybe just update the comment in the .h file to state that double
aguments are always expected to be before core register arguments.

[Karl Klose, 2011/04/27 12:54:13]

I have added the comment.

+  if (FLAG_hardfloat) {
+    // In the hard floating point calling convention, we can use
+    // all double registers to pass doubles.
+    if (num_double_arguments > DoubleRegister::kNumRegisters) {
+      stack_passed_arguments +=
+          2 * (num_double_arguments - DoubleRegister::kNumRegisters);
+    }
+  } else {
+    // In the soft floating point calling convention, every double
+    // argument is passed using two registers.
+    num_reg_arguments += 2 * num_double_arguments;
+  }
   // Up to four simple arguments are passed in registers r0..r3.
-  int stack_passed_arguments = (num_arguments <= kRegisterPassedArguments) ?
-                               0 : num_arguments - kRegisterPassedArguments;
+  if (num_reg_arguments > kRegisterPassedArguments) {
+    stack_passed_arguments += num_reg_arguments - kRegisterPassedArguments;
+  }
   if (frame_alignment > kPointerSize) {
     // Make stack end at alignment and make room for num_arguments - 4 words
     // and the original value of sp.
@@ -2814,11 +2835,51 @@ void MacroAssembler::PrepareCallCFunction(int num_arguments, Register scratch) {
 }
 
 
+void MacroAssembler::PrepareCallCFunction(int num_reg_arguments,
+                                          Register scratch) {
+  PrepareCallCFunction(num_reg_arguments, 0, scratch);
+}
+
+
+void MacroAssembler::SetCallCDoubleArguments(DoubleRegister dreg) {
+  if (FLAG_hardfloat) {

[Søren Thygesen Gjesse, 2011/04/27 08:19:01]

Please check if dreg is d0. Maybe add VMove to the macro assembler like Move for
core registers.

[Karl Klose, 2011/04/27 12:54:13]

Used Move.

+    vmov(d0, dreg);
+  } else {
+    vmov(r0, r1, dreg);
+  }
+}
+
+
+void MacroAssembler::SetCallCDoubleArguments(DoubleRegister dreg1,
+                                             DoubleRegister dreg2) {
+  if (FLAG_hardfloat) {

[Søren Thygesen Gjesse, 2011/04/27 08:19:01]

Ditto.

[Karl Klose, 2011/04/27 12:54:13]

Done.

+    vmov(d0, dreg1);
+    vmov(d1, dreg2);
+  } else {
+    vmov(r0, r1, dreg1);
+    vmov(r2, r3, dreg2);
+  }
+}
+
+
+void MacroAssembler::SetCallCDoubleArguments(DoubleRegister dreg,
+                                             Register reg) {
+  if (FLAG_hardfloat) {

[Søren Thygesen Gjesse, 2011/04/27 08:19:01]

Ditto (also mov -> Move).

[Karl Klose, 2011/04/27 12:54:13]

Done.

+    vmov(d0, dreg);
+    mov(r0, reg);
+  } else {
+    mov(r2, reg);
+    vmov(r0, r1, dreg);
+  }
+}
+
+
 void MacroAssembler::CallCFunction(ExternalReference function,
                                    int num_arguments) {
   CallCFunctionHelper(no_reg, function, ip, num_arguments);
 }
 
+
 void MacroAssembler::CallCFunction(Register function,
                                    Register scratch,
                                    int num_arguments) {