ARM: Add support for DoMathAbs with double inputs....

src/arm/macro-assembler-arm.cc

Index: src/arm/macro-assembler-arm.cc
===================================================================
--- src/arm/macro-assembler-arm.cc	(revision 6500)
+++ src/arm/macro-assembler-arm.cc	(working copy)
@@ -467,29 +467,39 @@
 
 
 void MacroAssembler::PushSafepointRegistersAndDoubles() {
-  PushSafepointRegisters();
   sub(sp, sp, Operand(DwVfpRegister::kNumAllocatableRegisters *
                       kDoubleSize));
   for (int i = 0; i < DwVfpRegister::kNumAllocatableRegisters; i++) {
     vstr(DwVfpRegister::FromAllocationIndex(i), sp, i * kDoubleSize);
   }
+  PushSafepointRegisters();

[Mads Ager (chromium), 2011/01/27 08:27:56]

What is the motivation for changing this? Please undo this change. This will
break stack-traversal at safepoints because the traversal code expects the
registers that can contain pointers to be pushed first.

[Alexandre, 2011/01/28 13:57:59]

Reversed.

We usually want to patch general purpose registers on the stack and don't touch
double registers. I thought having them last on the stack would make it easier
to patch them, as they would always (with or without double regs) lie just
before sp.

I thought there might be some issue, but it did not break the tests. I don't
know if that would be easy to do, but it may be worth adding a test for this.

On 2011/01/27 08:27:56, Mads Ager wrote:

 }
 
 
 void MacroAssembler::PopSafepointRegistersAndDoubles() {
+  PopSafepointRegisters();

[Mads Ager (chromium), 2011/01/27 08:27:56]

Undo please. :)

[Alexandre, 2011/01/28 13:57:59]

Done.

   for (int i = 0; i < DwVfpRegister::kNumAllocatableRegisters; i++) {
     vldr(DwVfpRegister::FromAllocationIndex(i), sp, i * kDoubleSize);
   }
   add(sp, sp, Operand(DwVfpRegister::kNumAllocatableRegisters *
                       kDoubleSize));
-  PopSafepointRegisters();
 }
 
+void MacroAssembler::StoreToSafepointRegistersAndDoublesSlot(Register reg) {
+  str(reg, SafepointRegistersAndDoublesSlot(reg));
+}
+
+
 void MacroAssembler::StoreToSafepointRegisterSlot(Register reg) {
   str(reg, SafepointRegisterSlot(reg));
 }
 
 
+void MacroAssembler::LoadFromSafepointRegisterSlot(Register reg) {
+  ldr(reg, SafepointRegisterSlot(reg));
+}
+
+
 int MacroAssembler::SafepointRegisterStackIndex(int reg_code) {
   // The registers are pushed starting with the highest encoding,
   // which means that lowest encodings are closest to the stack pointer.
@@ -503,6 +513,12 @@
 }
 
 
+MemOperand MacroAssembler::SafepointRegistersAndDoublesSlot(Register reg) {
+  // General purpose registers are pushed last on the stack.
+  return MemOperand(sp, SafepointRegisterStackIndex(reg.code()) * kInstrSize);

[Mads Ager (chromium), 2011/01/27 08:27:56]

kInstrSize -> kPointerSize. This is an index into the stack and not the
instruction stream. Also, please undo your changes to where the doubles are
pushed and take that into account here when computing the offset instead.

[Alexandre, 2011/01/28 13:57:59]

Done.

+}
+
+
 void MacroAssembler::Ldrd(Register dst1, Register dst2,
                           const MemOperand& src, Condition cond) {
   ASSERT(src.rm().is(no_reg));