Fix issue 493: Infinite loop when debug break is set when entering function.apply

src/ia32/builtins-ia32.cc

 // Copyright 2006-2009 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 504 matching lines @@
 }
 
 
 void Builtins::Generate_FunctionApply(MacroAssembler* masm) {
   __ EnterInternalFrame();
 
   __ push(Operand(ebp, 4 * kPointerSize));  // push this
   __ push(Operand(ebp, 2 * kPointerSize));  // push arguments
   __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
 
-  // Check the stack for overflow or a break request.
-  // We need to catch preemptions right here, otherwise an unlucky preemption
-  // could show up as a failed apply.
-  ExternalReference stack_guard_limit =
-      ExternalReference::address_of_stack_guard_limit();
-  Label retry_preemption;
-  Label no_preemption;
-  __ bind(&retry_preemption);
-  __ mov(edi, Operand::StaticVariable(stack_guard_limit));
-  __ cmp(esp, Operand(edi));
-  __ j(above, &no_preemption, taken);
-
-  // Preemption!
-  // Because builtins always remove the receiver from the stack, we
-  // have to fake one to avoid underflowing the stack.
-  __ push(eax);
-  __ push(Immediate(Smi::FromInt(0)));
-
-  // Do call to runtime routine.
-  __ CallRuntime(Runtime::kStackGuard, 1);
-  __ pop(eax);
-  __ jmp(&retry_preemption);
-
-  __ bind(&no_preemption);
-
+  // Check the stack for overflow. We are not trying need to catch
+  // interruptions (e.g. debug break and preemption) here, so the "real stack
+  // limit" is checked.
   Label okay;
-  // Make ecx the space we have left.
+  ExternalReference real_stack_limit =
+      ExternalReference::address_of_real_stack_limit();
+  __ mov(edi, Operand::StaticVariable(real_stack_limit));
+  // Make ecx the space we have left. The stack might already be overflowed
+  // here which will cause ecx to become negative.
   __ mov(ecx, Operand(esp));
   __ sub(ecx, Operand(edi));
   // Make edx the space we need for the array when it is unrolled onto the
   // stack.
   __ mov(edx, Operand(eax));
   __ shl(edx, kPointerSizeLog2 - kSmiTagSize);
+  // Check if the arguments will overflow the stack.
   __ cmp(ecx, Operand(edx));
-  __ j(greater, &okay, taken);
+  __ j(greater, &okay, taken);  // Signed comparison.
 
-  // Too bad: Out of stack space.
+  // Out of stack space.
   __ push(Operand(ebp, 4 * kPointerSize));  // push this
   __ push(eax);
   __ InvokeBuiltin(Builtins::APPLY_OVERFLOW, CALL_FUNCTION);
   __ bind(&okay);
   // End of stack check.
 
   // Push current index and limit.
   const int kLimitOffset =
       StandardFrameConstants::kExpressionsOffset - 1 * kPointerSize;
   const int kIndexOffset = kLimitOffset - 1 * kPointerSize;
@@ skipping 656 matching lines @@
   // Dont adapt arguments.
   // -------------------------------------------
   __ bind(&dont_adapt_arguments);
   __ jmp(Operand(edx));
 }
 
 
 #undef __
 
 } }  // namespace v8::internal