Raise StackOverflow during bootstrapping

See https://github.com/joyent/node/issues/7120

R=jarin@chromium.org
BUG=

Review URL: https://codereview.chromium.org/178073002

Patch from Alexis Campailla <alexis@janeasystems.com>.

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20335 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 6496e26..ce625b7 100644 (file)
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1476,11 +1476,6 @@ bool Genesis::CompileNative(Isolate* isolate,
 #ifdef ENABLE_DEBUGGER_SUPPORT
   isolate->debugger()->set_compiling_natives(true);
 #endif
-  // During genesis, the boilerplate for stack overflow won't work until the
-  // environment has been at least partially initialized. Add a stack check
-  // before entering JS code to catch overflow early.
-  StackLimitCheck check(isolate);
-  if (check.HasOverflowed()) return false;
 
   bool result = CompileScriptCached(isolate,
                                     name,
@@ -2614,8 +2609,16 @@ Genesis::Genesis(Isolate* isolate,
   // During genesis, the boilerplate for stack overflow won't work until the
   // environment has been at least partially initialized. Add a stack check
   // before entering JS code to catch overflow early.
+  const uint32_t stack_to_get_through_genesis = 3500 * sizeof(intptr_t);
   StackLimitCheck check(isolate);
-  if (check.HasOverflowed()) return;
+  if (check.WillOverflow(stack_to_get_through_genesis)) {
+    // Only raise a StackOverflow if there is a valid current context
+    if (isolate->context() != NULL) {
+      isolate->StackOverflow();
+      isolate->OptionalRescheduleException(true);
+    }
+    return;
+  }
 
   // We can only de-serialize a context if the isolate was initialized from
   // a snapshot. Otherwise we have to build the context from scratch.

diff --git a/src/isolate.h b/src/isolate.h
index b471378..bcb7cd4 100644 (file)
--- a/src/isolate.h
+++ b/src/isolate.h
@@ -1438,6 +1438,11 @@ class StackLimitCheck BASE_EMBEDDED {
     StackGuard* stack_guard = isolate_->stack_guard();
     return (reinterpret_cast<uintptr_t>(this) < stack_guard->real_climit());
   }
+  bool WillOverflow(uint32_t additionalUsage) const {
+    StackGuard* stack_guard = isolate_->stack_guard();
+    return (reinterpret_cast<uintptr_t>(this) < stack_guard->real_climit() +
+        additionalUsage);
+  }
  private:
   Isolate* isolate_;
 };

diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index 276663a..ed0a2fb 100644 (file)
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -5023,6 +5023,67 @@ TEST(APIStackOverflowAndVerboseTryCatch) {
   v8::V8::RemoveMessageListeners(receive_message);
 }
 
+void APIStackOverflowNestedContextsHelper(bool is_bottom_call);
+
+void APIStackOverflowNestedContextsCallback(
+  const v8::FunctionCallbackInfo<Value>& args) {
+  APIStackOverflowNestedContextsHelper(false);
+}
+
+
+void APIStackOverflowNestedContextsHelper(bool is_bottom_call) {
+  v8::Isolate* isolate = CcTest::isolate();
+  TryCatch try_catch;
+
+  Local<ObjectTemplate> global = ObjectTemplate::New();
+  global->Set(String::NewFromUtf8(isolate, "recur"),
+  FunctionTemplate::New(isolate, APIStackOverflowNestedContextsCallback));
+
+  Local<Context> innerContext = Context::New(isolate, NULL, global);
+  if (try_catch.HasCaught()) {
+    try_catch.ReThrow();
+    return;
+  }
+  if (innerContext.IsEmpty()) return;
+
+  Context::Scope context_scope(innerContext);
+  Local<Script> script = v8::Script::Compile(v8::String::NewFromUtf8(
+      isolate,
+      "function f() {                             "
+      "  try { recur(); } catch(e) { throw e; }   "
+      "  return 'bad';                            "
+      "} f();                                     "));
+
+  Local<Value> result = script->Run();
+  CHECK(result.IsEmpty());
+  if (try_catch.HasCaught()) {
+    if (is_bottom_call) {
+      String::Utf8Value ex_value(try_catch.Exception());
+      CHECK_EQ("RangeError: Maximum call stack size exceeded", *ex_value);
+    }
+    try_catch.ReThrow();
+  }
+}
+
+
+void APIStackOverflowNestedContexts(int extra_stack_bytes) {
+  if (extra_stack_bytes) alloca(extra_stack_bytes);
+  LocalContext context;
+  v8::HandleScope scope(context->GetIsolate());
+  v8::TryCatch try_catch;
+  APIStackOverflowNestedContextsHelper(true);
+  CHECK(try_catch.HasCaught());
+}
+
+
+TEST(APIStackOverflowNestedContexts) {
+  // The place where a stack overflow can occur is not completely deterministic
+  // so probe a few different depths
+  APIStackOverflowNestedContexts(2500);
+  APIStackOverflowNestedContexts(2800);
+  APIStackOverflowNestedContexts(30000);
+}
+
 
 THREADED_TEST(ExternalScriptException) {
   v8::Isolate* isolate = CcTest::isolate();