A64: Preserve/restore the FP registers in the exit frame when required.

src/a64/macro-assembler-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1257 matching lines @@
 }
 
 
 void MacroAssembler::CallRuntimeSaveDoubles(Runtime::FunctionId id) {
   const Runtime::Function* function = Runtime::FunctionForId(id);
 
   // Place the necessary arguments.
   Mov(x0, function->nargs);
   Mov(x1, Operand(ExternalReference(function, isolate())));
 
-  // TODO(all): Here we should ask CEntryStub to save floating point registers
-  // but this is not supported at the moment.
-  CEntryStub stub(1);
+  CEntryStub stub(1, kSaveFPRegs);
   CallStub(&stub);
 }
 
 
 static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
   return ref0.address() - ref1.address();
 }
 
 
 void MacroAssembler::CallApiFunctionAndReturn(ExternalReference function,
@@ skipping 1331 matching lines @@
 void MacroAssembler::LeaveFrame(StackFrame::Type type) {
   ASSERT(jssp.Is(StackPointer()));
   // Drop the execution stack down to the frame pointer and restore
   // the caller frame pointer and return address.
   Mov(jssp, fp);
   AssertStackConsistency();
   Pop(fp, lr);
 }
 
 
+void MacroAssembler::ExitFramePreserveFPRegs() {
+  PushCPURegList(kCallerSavedFP);
+}
+
+
+void MacroAssembler::ExitFrameRestoreFPRegs() {
+  // Read the registers from the stack without popping them. The stack pointer
+  // will be reset as part of the unwinding process.
+  CPURegList saved_fp_regs = kCallerSavedFP;
+  ASSERT(saved_fp_regs.Count() % 2 == 0);
+
+  int offset = ExitFrameConstants::kLastExitFrameField;
+  while (!saved_fp_regs.IsEmpty()) {
+    const CPURegister& dst0 = saved_fp_regs.PopHighestIndex();
+    const CPURegister& dst1 = saved_fp_regs.PopHighestIndex();
+    offset -= 2 * kDRegSizeInBytes;
+    Ldp(dst1, dst0, MemOperand(fp, offset));
+  }
+}
+
+
 // TODO(jbramley): Check that we're handling FP correctly [GOOGJSE-33].
 void MacroAssembler::EnterExitFrame(bool save_doubles,
                                     const Register& scratch,
                                     int extra_space) {
   ASSERT(jssp.Is(StackPointer()));
 
   // Set up the new stack frame.
   Mov(scratch, Operand(CodeObject()));
   Push(lr, fp);
   Mov(fp, StackPointer());
@@ skipping 10 matching lines @@
   STATIC_ASSERT((-2 * kPointerSize) == ExitFrameConstants::kCodeOffset);
 
   // Save the frame pointer and context pointer in the top frame.
   Mov(scratch, Operand(ExternalReference(Isolate::kCEntryFPAddress,
                                          isolate())));
   Str(fp, MemOperand(scratch));
   Mov(scratch, Operand(ExternalReference(Isolate::kContextAddress,
                                          isolate())));
   Str(cp, MemOperand(scratch));
 
+  STATIC_ASSERT((-2 * kPointerSize) ==
+                ExitFrameConstants::kLastExitFrameField);
   if (save_doubles) {
-    // TODO(jbramley): Implement kSaveFPRegs. It is only used by Lithium.
-    TODO_UNIMPLEMENTED("EnterExitFrame: save_doubles");
+    ExitFramePreserveFPRegs();
   }
 
   // Reserve space for the return address and for user requested memory.
   // We do this before aligning to make sure that we end up correctly
   // aligned with the minimum of wasted space.
   Claim(extra_space + 1, kXRegSizeInBytes);
   //         fp[8]: CallerPC (lr)
   //   fp -> fp[0]: CallerFP (old fp)
   //         fp[-8]: Space reserved for SPOffset.
   //         fp[-16]: CodeObject()
-  //         jssp[8 + extra_space * 8]: Saved doubles (if save_doubles is true).
+  //         jssp[-16 - fp_size]: Saved doubles (if save_doubles is true).
   //         jssp[8]: Extra space reserved for caller (if extra_space != 0).
   // jssp -> jssp[0]: Space reserved for the return address.
-  STATIC_ASSERT((-3 * kPointerSize) ==
-                ExitFrameConstants::kCallerSavedRegsOffset);
 
   // Align and synchronize the system stack pointer with jssp.
   AlignAndSetCSPForFrame();
   ASSERT(csp.Is(StackPointer()));
 
   //         fp[8]: CallerPC (lr)
   //   fp -> fp[0]: CallerFP (old fp)
   //         fp[-8]: Space reserved for SPOffset.
   //         fp[-16]: CodeObject()
   //         csp[...]: Saved doubles, if saved_doubles is true.
   //         csp[8]: Memory reserved for the caller if extra_space != 0.
   //                 Alignment padding, if necessary.
   //  csp -> csp[0]: Space reserved for the return address.
 
   // ExitFrame::GetStateForFramePointer expects to find the return address at
   // the memory address immediately below the pointer stored in SPOffset.
   // It is not safe to derive much else from SPOffset, because the size of the
   // padding can vary.
   Add(scratch, csp, kXRegSizeInBytes);
   Str(scratch, MemOperand(fp, ExitFrameConstants::kSPOffset));
 }
 
 
 // Leave the current exit frame.
 void MacroAssembler::LeaveExitFrame(bool restore_doubles,
                                     const Register& scratch) {
   ASSERT(csp.Is(StackPointer()));
 
   if (restore_doubles) {
-    // TODO(jbramley): Implement kSaveFPRegs. It is only used by Lithium.
-    TODO_UNIMPLEMENTED("LeaveExitFrame: restore_doubles");
+    ExitFrameRestoreFPRegs();
   }
 
   // Restore the context pointer from the top frame.
   Mov(scratch, Operand(ExternalReference(Isolate::kContextAddress,
                                          isolate())));
   Ldr(cp, MemOperand(scratch));
   if (emit_debug_code()) {
     // Also emit debug code to clear the cp in the top frame.
     Str(xzr, MemOperand(scratch));
   }
@@ skipping 1955 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64