[x87] Keep x87 FPU stack empty when calling or return to natvie C++ function.

src/compiler/x87/code-generator-x87.cc

 // Copyright 2013 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/compiler/code-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 177 matching lines @@
 
 
 class OutOfLineLoadFloat final : public OutOfLineCode {
  public:
   OutOfLineLoadFloat(CodeGenerator* gen, X87Register result)
       : OutOfLineCode(gen), result_(result) {}
 
   void Generate() final {
     DCHECK(result_.code() == 0);
     USE(result_);
+    if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+      __ VerifyX87StackDepth(1);
+    }
     __ fstp(0);
     __ push(Immediate(0xffffffff));
     __ push(Immediate(0x7fffffff));
     __ fld_d(MemOperand(esp, 0));
     __ lea(esp, Operand(esp, kDoubleSize));
   }
 
  private:
   X87Register const result_;
 };
@@ skipping 149 matching lines @@
   frame_access_state()->SetFrameAccessToSP();
 }
 
 
 // Assembles an instruction after register allocation, producing machine code.
 void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
   X87OperandConverter i(this, instr);
 
   switch (ArchOpcodeField::decode(instr->opcode())) {
     case kArchCallCodeObject: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
+      __ fstp(0);
       EnsureSpaceForLazyDeopt();
       if (HasImmediateInput(instr, 0)) {
         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
         __ call(code, RelocInfo::CODE_TARGET);
       } else {
         Register reg = i.InputRegister(0);
         __ add(reg, Immediate(Code::kHeaderSize - kHeapObjectTag));
         __ call(reg);
       }
       RecordCallPosition(instr);
       bool double_result =
           instr->HasOutput() && instr->Output()->IsDoubleRegister();
       if (double_result) {
         __ lea(esp, Operand(esp, -kDoubleSize));
         __ fstp_d(Operand(esp, 0));
       }
       __ fninit();
       if (double_result) {
         __ fld_d(Operand(esp, 0));
         __ lea(esp, Operand(esp, kDoubleSize));
       } else {
         __ fld1();
       }
       frame_access_state()->ClearSPDelta();
       break;
     }
     case kArchTailCallCodeObject: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
+      __ fstp(0);
       int stack_param_delta = i.InputInt32(instr->InputCount() - 1);
       AssembleDeconstructActivationRecord(stack_param_delta);
       if (HasImmediateInput(instr, 0)) {
         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
         __ jmp(code, RelocInfo::CODE_TARGET);
       } else {
         Register reg = i.InputRegister(0);
         __ add(reg, Immediate(Code::kHeaderSize - kHeapObjectTag));
         __ jmp(reg);
       }
       frame_access_state()->ClearSPDelta();
       break;
     }
     case kArchCallJSFunction: {
       EnsureSpaceForLazyDeopt();
       Register func = i.InputRegister(0);
       if (FLAG_debug_code) {
         // Check the function's context matches the context argument.
         __ cmp(esi, FieldOperand(func, JSFunction::kContextOffset));
         __ Assert(equal, kWrongFunctionContext);
       }
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
+      __ fstp(0);
       __ call(FieldOperand(func, JSFunction::kCodeEntryOffset));
       RecordCallPosition(instr);
       bool double_result =
           instr->HasOutput() && instr->Output()->IsDoubleRegister();
       if (double_result) {
         __ lea(esp, Operand(esp, -kDoubleSize));
         __ fstp_d(Operand(esp, 0));
       }
       __ fninit();
       if (double_result) {
         __ fld_d(Operand(esp, 0));
         __ lea(esp, Operand(esp, kDoubleSize));
       } else {
         __ fld1();
       }
       frame_access_state()->ClearSPDelta();
       break;
     }
     case kArchTailCallJSFunction: {
       Register func = i.InputRegister(0);
       if (FLAG_debug_code) {
         // Check the function's context matches the context argument.
         __ cmp(esi, FieldOperand(func, JSFunction::kContextOffset));
         __ Assert(equal, kWrongFunctionContext);
       }
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
+      __ fstp(0);
       int stack_param_delta = i.InputInt32(instr->InputCount() - 1);
       AssembleDeconstructActivationRecord(stack_param_delta);
       __ jmp(FieldOperand(func, JSFunction::kCodeEntryOffset));
       frame_access_state()->ClearSPDelta();
       break;
     }
     case kArchLazyBailout: {
       EnsureSpaceForLazyDeopt();
       RecordCallPosition(instr);
+      // Lazy Bailout entry, need to re-initialize FPU state.
+      __ fninit();
+      __ fld1();
       break;
     }
     case kArchPrepareCallCFunction: {
       // Frame alignment requires using FP-relative frame addressing.
       frame_access_state()->SetFrameAccessToFP();
       int const num_parameters = MiscField::decode(instr->opcode());
       __ PrepareCallCFunction(num_parameters, i.TempRegister(0));
       break;
     }
     case kArchPrepareTailCall:
       AssemblePrepareTailCall(i.InputInt32(instr->InputCount() - 1));
       break;
     case kArchCallCFunction: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
+      __ fstp(0);
       int const num_parameters = MiscField::decode(instr->opcode());
       if (HasImmediateInput(instr, 0)) {
         ExternalReference ref = i.InputExternalReference(0);
         __ CallCFunction(ref, num_parameters);
       } else {
         Register func = i.InputRegister(0);
         __ CallCFunction(func, num_parameters);
       }
+      bool double_result =
+          instr->HasOutput() && instr->Output()->IsDoubleRegister();
+      if (double_result) {
+        __ lea(esp, Operand(esp, -kDoubleSize));
+        __ fstp_d(Operand(esp, 0));
+      }
+      __ fninit();
+      if (double_result) {
+        __ fld_d(Operand(esp, 0));
+        __ lea(esp, Operand(esp, kDoubleSize));
+      } else {
+        __ fld1();
+      }
       frame_access_state()->SetFrameAccessToDefault();
       frame_access_state()->ClearSPDelta();
       break;
     }
     case kArchJmp:
       AssembleArchJump(i.InputRpo(0));
       break;
     case kArchLookupSwitch:
       AssembleArchLookupSwitch(instr);
       break;
@@ skipping 202 matching lines @@
       break;
     }
     case kX87Float32Cmp: {
       __ fld_s(MemOperand(esp, kFloatSize));
       __ fld_s(MemOperand(esp, 0));
       __ FCmp();
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       break;
     }
     case kX87Float32Add: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_s(MemOperand(esp, 0));
       __ fld_s(MemOperand(esp, kFloatSize));
       __ faddp();
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float32Sub: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_s(MemOperand(esp, kFloatSize));
       __ fld_s(MemOperand(esp, 0));
       __ fsubp();
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float32Mul: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_s(MemOperand(esp, kFloatSize));
       __ fld_s(MemOperand(esp, 0));
       __ fmulp();
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float32Div: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_s(MemOperand(esp, kFloatSize));
       __ fld_s(MemOperand(esp, 0));
       __ fdivp();
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float32Max: {
       Label check_nan_left, check_zero, return_left, return_right;
       Condition condition = below;
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_s(MemOperand(esp, kFloatSize));
       __ fld_s(MemOperand(esp, 0));
       __ fld(1);
       __ fld(1);
       __ FCmp();
 
       // At least one NaN.
       // Return the second operands if one of the two operands is NaN
       __ j(parity_even, &return_right, Label::kNear);
@@ skipping 14 matching lines @@
       __ fxch();
 
       __ bind(&return_left);
       __ fstp(0);
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       break;
     }
     case kX87Float32Min: {
       Label check_nan_left, check_zero, return_left, return_right;
       Condition condition = above;
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_s(MemOperand(esp, kFloatSize));
       __ fld_s(MemOperand(esp, 0));
       __ fld(1);
       __ fld(1);
       __ FCmp();
       // At least one NaN.
       // Return the second operands if one of the two operands is NaN
       __ j(parity_even, &return_right, Label::kNear);
       __ j(equal, &check_zero, Label::kNear);            // left == right.
@@ skipping 25 matching lines @@
 
       __ bind(&return_right);
       __ fxch();
 
       __ bind(&return_left);
       __ fstp(0);
       __ lea(esp, Operand(esp, 2 * kFloatSize));
       break;
     }
     case kX87Float32Sqrt: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_s(MemOperand(esp, 0));
       __ fsqrt();
       __ lea(esp, Operand(esp, kFloatSize));
       break;
     }
     case kX87Float32Abs: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_s(MemOperand(esp, 0));
       __ fabs();
       __ lea(esp, Operand(esp, kFloatSize));
       break;
     }
     case kX87Float32Round: {
       RoundingMode mode =
           static_cast<RoundingMode>(MiscField::decode(instr->opcode()));
       // Set the correct round mode in x87 control register
       __ X87SetRC((mode << 10));
 
       if (!instr->InputAt(0)->IsDoubleRegister()) {
         InstructionOperand* input = instr->InputAt(0);
         USE(input);
         DCHECK(input->IsDoubleStackSlot());
+        if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+          __ VerifyX87StackDepth(1);
+        }
         __ fstp(0);
         __ fld_s(i.InputOperand(0));
       }
       __ frndint();
       __ X87SetRC(0x0000);
       break;
     }
     case kX87Float64Add: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_d(MemOperand(esp, 0));
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ faddp();
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float64Sub: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fsub_d(MemOperand(esp, 0));
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float64Mul: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fmul_d(MemOperand(esp, 0));
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float64Div: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fdiv_d(MemOperand(esp, 0));
       // Clear stack.
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       // Restore the default value of control word.
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float64Mod: {
       FrameScope frame_scope(&masm_, StackFrame::MANUAL);
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ mov(eax, esp);
       __ PrepareCallCFunction(4, eax);
       __ fstp(0);
       __ fld_d(MemOperand(eax, 0));
       __ fstp_d(Operand(esp, 1 * kDoubleSize));
       __ fld_d(MemOperand(eax, kDoubleSize));
       __ fstp_d(Operand(esp, 0));
       __ CallCFunction(ExternalReference::mod_two_doubles_operation(isolate()),
                        4);
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       break;
     }
     case kX87Float64Max: {
       Label check_zero, return_left, return_right;
       Condition condition = below;
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fld_d(MemOperand(esp, 0));
       __ fld(1);
       __ fld(1);
       __ FCmp();
       __ j(parity_even, &return_right,
            Label::kNear);  // At least one NaN, Return right.
       __ j(equal, &check_zero, Label::kNear);  // left == right.
       __ j(condition, &return_left, Label::kNear);
       __ jmp(&return_right, Label::kNear);
 
       __ bind(&check_zero);
       __ fld(0);
       __ fldz();
       __ FCmp();
       __ j(not_equal, &return_left, Label::kNear);  // left == right != 0.
 
       __ bind(&return_right);
       __ fxch();
 
       __ bind(&return_left);
       __ fstp(0);
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       break;
     }
     case kX87Float64Min: {
       Label check_zero, return_left, return_right;
       Condition condition = above;
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fld_d(MemOperand(esp, 0));
       __ fld(1);
       __ fld(1);
       __ FCmp();
       __ j(parity_even, &return_right,
            Label::kNear);  // At least one NaN, return right value.
       __ j(equal, &check_zero, Label::kNear);  // left == right.
       __ j(condition, &return_left, Label::kNear);
       __ jmp(&return_right, Label::kNear);
 
       __ bind(&check_zero);
       __ fld(0);
       __ fldz();
       __ FCmp();
       __ j(not_equal, &return_left, Label::kNear);  // left == right != 0.
 
       __ bind(&return_right);
       __ fxch();
 
       __ bind(&return_left);
       __ fstp(0);
       __ lea(esp, Operand(esp, 2 * kDoubleSize));
       break;
     }
     case kX87Float64Abs: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ fld_d(MemOperand(esp, 0));
       __ fabs();
       __ lea(esp, Operand(esp, kDoubleSize));
       break;
     }
     case kX87Int32ToFloat32: {
       InstructionOperand* input = instr->InputAt(0);
       DCHECK(input->IsRegister() || input->IsStackSlot());
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       if (input->IsRegister()) {
         Register input_reg = i.InputRegister(0);
         __ push(input_reg);
         __ fild_s(Operand(esp, 0));
         __ pop(input_reg);
       } else {
         __ fild_s(i.InputOperand(0));
       }
       break;
     }
     case kX87Int32ToFloat64: {
       InstructionOperand* input = instr->InputAt(0);
       DCHECK(input->IsRegister() || input->IsStackSlot());
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       if (input->IsRegister()) {
         Register input_reg = i.InputRegister(0);
         __ push(input_reg);
         __ fild_s(Operand(esp, 0));
         __ pop(input_reg);
       } else {
         __ fild_s(i.InputOperand(0));
       }
       break;
     }
     case kX87Float32ToFloat64: {
       InstructionOperand* input = instr->InputAt(0);
       if (input->IsDoubleRegister()) {
         __ sub(esp, Immediate(kDoubleSize));
         __ fstp_d(MemOperand(esp, 0));
         __ fld_d(MemOperand(esp, 0));
         __ add(esp, Immediate(kDoubleSize));
       } else {
         DCHECK(input->IsDoubleStackSlot());
+        if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+          __ VerifyX87StackDepth(1);
+        }
         __ fstp(0);
         __ fld_s(i.InputOperand(0));
       }
       break;
     }
     case kX87Uint32ToFloat64: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       __ LoadUint32NoSSE2(i.InputRegister(0));
       break;
     }
     case kX87Float32ToInt32: {
       if (!instr->InputAt(0)->IsDoubleRegister()) {
         __ fld_s(i.InputOperand(0));
       }
       __ TruncateX87TOSToI(i.OutputRegister(0));
       if (!instr->InputAt(0)->IsDoubleRegister()) {
@@ skipping 13 matching lines @@
     }
     case kX87Float64ToFloat32: {
       InstructionOperand* input = instr->InputAt(0);
       if (input->IsDoubleRegister()) {
         __ sub(esp, Immediate(kDoubleSize));
         __ fstp_s(MemOperand(esp, 0));
         __ fld_s(MemOperand(esp, 0));
         __ add(esp, Immediate(kDoubleSize));
       } else {
         DCHECK(input->IsDoubleStackSlot());
+        if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+          __ VerifyX87StackDepth(1);
+        }
         __ fstp(0);
         __ fld_d(i.InputOperand(0));
         __ sub(esp, Immediate(kDoubleSize));
         __ fstp_s(MemOperand(esp, 0));
         __ fld_s(MemOperand(esp, 0));
         __ add(esp, Immediate(kDoubleSize));
       }
       break;
     }
     case kX87Float64ToUint32: {
@@ skipping 50 matching lines @@
     }
     case kX87Float64InsertLowWord32: {
       __ sub(esp, Immediate(kDoubleSize));
       __ fstp_d(MemOperand(esp, 0));
       __ mov(MemOperand(esp, 0), i.InputRegister(1));
       __ fld_d(MemOperand(esp, 0));
       __ add(esp, Immediate(kDoubleSize));
       break;
     }
     case kX87Float64Sqrt: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ X87SetFPUCW(0x027F);
       __ fstp(0);
       __ fld_d(MemOperand(esp, 0));
       __ fsqrt();
       __ lea(esp, Operand(esp, kDoubleSize));
       __ X87SetFPUCW(0x037F);
       break;
     }
     case kX87Float64Round: {
       RoundingMode mode =
           static_cast<RoundingMode>(MiscField::decode(instr->opcode()));
       // Set the correct round mode in x87 control register
       __ X87SetRC((mode << 10));
 
       if (!instr->InputAt(0)->IsDoubleRegister()) {
         InstructionOperand* input = instr->InputAt(0);
         USE(input);
         DCHECK(input->IsDoubleStackSlot());
+        if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+          __ VerifyX87StackDepth(1);
+        }
         __ fstp(0);
         __ fld_d(i.InputOperand(0));
       }
       __ frndint();
       __ X87SetRC(0x0000);
       break;
     }
     case kX87Float64Cmp: {
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fld_d(MemOperand(esp, 0));
@@ skipping 44 matching lines @@
         } else {
           __ mov(operand, i.InputRegister(index));
         }
       }
       break;
     case kX87Movsd: {
       if (instr->HasOutput()) {
         X87Register output = i.OutputDoubleRegister();
         USE(output);
         DCHECK(output.code() == 0);
+        if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+          __ VerifyX87StackDepth(1);
+        }
         __ fstp(0);
         __ fld_d(i.MemoryOperand());
       } else {
         size_t index = 0;
         Operand operand = i.MemoryOperand(&index);
         __ fst_d(operand);
       }
       break;
     }
     case kX87Movss: {
       if (instr->HasOutput()) {
         X87Register output = i.OutputDoubleRegister();
         USE(output);
         DCHECK(output.code() == 0);
+        if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+          __ VerifyX87StackDepth(1);
+        }
         __ fstp(0);
         __ fld_s(i.MemoryOperand());
       } else {
         size_t index = 0;
         Operand operand = i.MemoryOperand(&index);
         __ fst_s(operand);
       }
       break;
     }
     case kX87BitcastFI: {
       __ mov(i.OutputRegister(), MemOperand(esp, 0));
       __ lea(esp, Operand(esp, kFloatSize));
       break;
     }
     case kX87BitcastIF: {
+      if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+        __ VerifyX87StackDepth(1);
+      }
       __ fstp(0);
       if (instr->InputAt(0)->IsRegister()) {
         __ lea(esp, Operand(esp, -kFloatSize));
         __ mov(MemOperand(esp, 0), i.InputRegister(0));
         __ fld_s(MemOperand(esp, 0));
         __ lea(esp, Operand(esp, kFloatSize));
       } else {
         __ fld_s(i.InputOperand(0));
       }
       break;
@@ skipping 505 matching lines @@
 
   // Initailize FPU state.
   __ fninit();
   __ fld1();
 }
 
 
 void CodeGenerator::AssembleReturn() {
   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
 
+  // Clear the FPU stack only if there is no return value in the stack.
+  if (FLAG_debug_code && FLAG_enable_slow_asserts) {
+    __ VerifyX87StackDepth(1);
+  }
+  bool clear_stack = true;
+  for (int i = 0; i < descriptor->ReturnCount(); i++) {
+    MachineRepresentation rep = descriptor->GetReturnType(i).representation();
+    LinkageLocation loc = descriptor->GetReturnLocation(i);
+    if (IsFloatingPoint(rep) && loc == LinkageLocation::ForRegister(0)) {
+      clear_stack = false;
+      break;
+    }
+  }
+  if (clear_stack) __ fstp(0);
+
   int pop_count = static_cast<int>(descriptor->StackParameterCount());
   const RegList saves = descriptor->CalleeSavedRegisters();
   // Restore registers.
   if (saves != 0) {
     for (int i = 0; i < Register::kNumRegisters; i++) {
       if (!((1 << i) & saves)) continue;
       __ pop(Register::from_code(i));
     }
   }
 
@@ skipping 254 matching lines @@
     int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
     __ Nop(padding_size);
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8