A64: Restore FP registers in Deoptimizer::EntryGenerator::Generate

src/a64/deoptimizer-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 364 matching lines @@
 
 void Deoptimizer::EntryGenerator::Generate() {
   GeneratePrologue();
 
   // TODO(all): This code needs to be revisited. We probably only need to save
   // caller-saved registers here. Callee-saved registers can be stored directly
   // in the input frame.
 
   // Save all allocatable floating point registers.
   CPURegList saved_fp_registers(CPURegister::kFPRegister, kDRegSize,
-                                0, FPRegister::NumAllocatableRegisters());
+                                0, FPRegister::NumAllocatableRegisters() - 1);
   __ PushCPURegList(saved_fp_registers);
 
   // We save all the registers expcept jssp, sp and lr.
   CPURegList saved_registers(CPURegister::kRegister, kXRegSize, 0, 27);
   saved_registers.Combine(fp);
   __ PushCPURegList(saved_registers);
 
   const int kSavedRegistersAreaSize =
       (saved_registers.Count() * kXRegSizeInBytes) +
       (saved_fp_registers.Count() * kDRegSizeInBytes);
@@ skipping 82 matching lines @@
 
   // Compute the output frame in the deoptimizer.
   __ Push(x0);  // Preserve deoptimizer object across call.
 
   {
     // Call Deoptimizer::ComputeOutputFrames().
     AllowExternalCallThatCantCauseGC scope(masm());
     __ CallCFunction(
         ExternalReference::compute_output_frames_function(isolate()), 1);
   }
-  __ Pop(x0);  // Restore deoptimizer object (class Deoptimizer).
+  __ Pop(x4);  // Restore deoptimizer object (class Deoptimizer).
 
   // Replace the current (input) frame with the output frames.
   Label outer_push_loop, inner_push_loop,
       outer_loop_header, inner_loop_header;
-  __ Ldrsw(x1, MemOperand(x0, Deoptimizer::output_count_offset()));
-  __ Ldr(x0, MemOperand(x0, Deoptimizer::output_offset()));
+  __ Ldrsw(x1, MemOperand(x4, Deoptimizer::output_count_offset()));
+  __ Ldr(x0, MemOperand(x4, Deoptimizer::output_offset()));
   __ Add(x1, x0, Operand(x1, LSL, kPointerSizeLog2));
   __ B(&outer_loop_header);
 
   __ Bind(&outer_push_loop);
   Register current_frame = x2;
   __ Ldr(current_frame, MemOperand(x0, 0));
   __ Ldr(x3, MemOperand(current_frame, FrameDescription::frame_size_offset()));
   __ B(&inner_loop_header);
 
   __ Bind(&inner_push_loop);
   __ Sub(x3, x3, kPointerSize);
   __ Add(x6, current_frame, x3);
   __ Ldr(x7, MemOperand(x6, FrameDescription::frame_content_offset()));
   __ Push(x7);
   __ Bind(&inner_loop_header);
   __ Cbnz(x3, &inner_push_loop);
 
   __ Add(x0, x0, kPointerSize);
   __ Bind(&outer_loop_header);
   __ Cmp(x0, x1);
   __ B(lt, &outer_push_loop);
 
-  // TODO(jbramley): The ARM code restores FP registers here.
-  TODO_UNIMPLEMENTED("EntryGenerator::Generate: Restore FP registers.");
+  __ Ldr(x1, MemOperand(x4, Deoptimizer::input_offset()));
+  ASSERT(!saved_fp_registers.IncludesAliasOf(crankshaft_fp_scratch) &&
+         !saved_fp_registers.IncludesAliasOf(fp_zero) &&
+         !saved_fp_registers.IncludesAliasOf(fp_scratch));
+  int src_offset = FrameDescription::double_registers_offset();
+  while (!saved_fp_registers.IsEmpty()) {
+    const CPURegister reg = saved_fp_registers.PopLowestIndex();
+    __ Ldr(reg, MemOperand(x1, src_offset));
+    src_offset += kDoubleSize;
+  }
 
   // Push state, pc, and continuation from the last output frame.
   if (type() != OSR) {
     __ Ldr(x6, MemOperand(current_frame, FrameDescription::state_offset()));
     __ Push(x6);
   }
 
   // TODO(all): This code needs to be revisited, We probably don't need to
   // restore all the registers as fullcodegen does not keep live values in
   // registers (note that at least fp must be restored though).
@@ skipping 65 matching lines @@
 
 
 void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
   SetFrameSlot(offset, value);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal