Raise StackOverflow during bootstrapping

test/cctest/test-api.cc

 // Copyright 2012 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 4968 matching lines @@
   v8::V8::AddMessageListener(receive_message);
   v8::TryCatch try_catch;
   try_catch.SetVerbose(true);
   Local<Value> result = CompileRun("function foo() { foo(); } foo();");
   CHECK(try_catch.HasCaught());
   CHECK(result.IsEmpty());
   CHECK(message_received);
   v8::V8::RemoveMessageListeners(receive_message);
 }
 
+void APIStackOverflowNestedContextsHelper(bool is_bottom_call);

[Jarin, 2014/03/25 15:28:33]

In v8, bools as arguments are normally frowned upon, enums are preferred.
However, since this is a test and the function decl, def and use are close to
each other, I think it is fine to leave as is.

+
+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();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(isolate, ThrowFromC));
   LocalContext context(0, templ);
 
   v8::TryCatch try_catch;
@@ skipping 17110 matching lines @@
 Local<Object> ApiCallOptimizationChecker::holder;
 Local<Object> ApiCallOptimizationChecker::callee;
 int ApiCallOptimizationChecker::count = 0;
 
 
 TEST(TestFunctionCallOptimization) {
   i::FLAG_allow_natives_syntax = true;
   ApiCallOptimizationChecker checker;
   checker.RunAll();
 }