PPC/s390: [deoptimizer] Fill the single precision registers in the deoptimizer entry stub.

src/s390/deoptimizer-s390.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/deoptimizer.h"
 #include "src/codegen.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/register-configuration.h"
 #include "src/safepoint-table.h"
 
@@ skipping 95 matching lines @@
 // easily ported.
 void Deoptimizer::TableEntryGenerator::Generate() {
   GeneratePrologue();
 
   // Save all the registers onto the stack
   const int kNumberOfRegisters = Register::kNumRegisters;
 
   RegList restored_regs = kJSCallerSaved | kCalleeSaved;
 
   const int kDoubleRegsSize = kDoubleSize * DoubleRegister::kNumRegisters;
+  const int kFloatRegsSize = kFloatSize * FloatRegister::kNumRegisters;
 
   // Save all double registers before messing with them.
   __ lay(sp, MemOperand(sp, -kDoubleRegsSize));
   const RegisterConfiguration* config = RegisterConfiguration::Crankshaft();
   for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
     int code = config->GetAllocatableDoubleCode(i);
     const DoubleRegister dreg = DoubleRegister::from_code(code);
     int offset = code * kDoubleSize;
     __ StoreDouble(dreg, MemOperand(sp, offset));
   }
+  // Save all float registers before messing with them.
+  __ lay(sp, MemOperand(sp, -kFloatRegsSize));
+  for (int i = 0; i < config->num_allocatable_float_registers(); ++i) {
+    int code = config->GetAllocatableFloatCode(i);
+    const FloatRegister dreg = FloatRegister::from_code(code);
+    int offset = code * kFloatSize;
+    __ StoreFloat32(dreg, MemOperand(sp, offset));
+  }
 
   // Push all GPRs onto the stack
   __ lay(sp, MemOperand(sp, -kNumberOfRegisters * kPointerSize));
   __ StoreMultipleP(r0, sp, MemOperand(sp));  // Save all 16 registers
 
   __ mov(ip, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate())));
   __ StoreP(fp, MemOperand(ip));
 
   const int kSavedRegistersAreaSize =
-      (kNumberOfRegisters * kPointerSize) + kDoubleRegsSize;
+      (kNumberOfRegisters * kPointerSize) + kDoubleRegsSize + kFloatRegsSize;
 
   // Get the bailout id from the stack.
   __ LoadP(r4, MemOperand(sp, kSavedRegistersAreaSize));
 
   // Cleanse the Return address for 31-bit
   __ CleanseP(r14);
 
   // Get the address of the location in the code object (r5)(return
   // address for lazy deoptimization) and compute the fp-to-sp delta in
   // register r6.
@@ skipping 40 matching lines @@
     __ LoadP(r4, MemOperand(sp, i * kPointerSize));
     __ StoreP(r4, MemOperand(r3, offset));
   }
 
   int double_regs_offset = FrameDescription::double_registers_offset();
   // Copy double registers to
   // double_registers_[DoubleRegister::kNumRegisters]
   for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
     int code = config->GetAllocatableDoubleCode(i);
     int dst_offset = code * kDoubleSize + double_regs_offset;
-    int src_offset = code * kDoubleSize + kNumberOfRegisters * kPointerSize;
+    int src_offset =
+        code * kDoubleSize + kNumberOfRegisters * kPointerSize + kFloatRegsSize;
     // TODO(joransiu): MVC opportunity
     __ LoadDouble(d0, MemOperand(sp, src_offset));
     __ StoreDouble(d0, MemOperand(r3, dst_offset));
   }
 
+  int float_regs_offset = FrameDescription::float_registers_offset();
+  // Copy float registers to
+  // float_registers_[FloatRegister::kNumRegisters]
+  for (int i = 0; i < config->num_allocatable_float_registers(); ++i) {
+    int code = config->GetAllocatableFloatCode(i);
+    int dst_offset = code * kFloatSize + float_regs_offset;
+    int src_offset = code * kFloatSize + kNumberOfRegisters * kPointerSize;
+    // TODO(joransiu): MVC opportunity
+    __ LoadFloat32(d0, MemOperand(sp, src_offset));
+    __ StoreFloat32(d0, MemOperand(r3, dst_offset));
+  }
   // Remove the bailout id and the saved registers from the stack.
   __ la(sp, MemOperand(sp, kSavedRegistersAreaSize + (1 * kPointerSize)));
 
   // Compute a pointer to the unwinding limit in register r4; that is
   // the first stack slot not part of the input frame.
   __ LoadP(r4, MemOperand(r3, FrameDescription::frame_size_offset()));
   __ AddP(r4, sp);
 
   // Unwind the stack down to - but not including - the unwinding
   // limit and copy the contents of the activation frame to the input
@@ skipping 116 matching lines @@
 
 void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
   // No out-of-line constant pool support.
   UNREACHABLE();
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8