Adds an API for setting the stack limit per-thread.

test/cctest/test-api.cc

 // Copyright 2007-2008 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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "api.h"
 #include "compilation-cache.h"
+#include "execution.h"
 #include "snapshot.h"
 #include "platform.h"
 #include "top.h"
 #include "cctest.h"
 
+#if V8_TARGET_ARCH_IA32
+#include "ia32/simulator-ia32.h"
+#elif V8_TARGET_ARCH_X64
+#include "x64/simulator-x64.h"
+#elif V8_TARGET_ARCH_ARM
+#include "arm/simulator-arm.h"
+#else
+#error Unsupported target architecture.
+#endif
+
+
 static bool IsNaN(double x) {
 #ifdef WIN32
   return _isnan(x);
 #else
   return isnan(x);
 #endif
 }
 
 using ::v8::ObjectTemplate;
 using ::v8::Value;
@@ skipping 1670 matching lines @@
     "var a = new Array(); while(true) a.push(a);";
 
 
 // These tests run for a long time and prevent us from running tests
 // that come after them so they cannot run in parallel.
 TEST(OutOfMemory) {
   // It's not possible to read a snapshot into a heap with different dimensions.
   if (v8::internal::Snapshot::IsEnabled()) return;
   // Set heap limits.
   static const int K = 1024;
-  v8::ResourceConstraints constraints;
+  v8::HeapResourceConstraints constraints;
   constraints.set_max_young_space_size(256 * K);
   constraints.set_max_old_space_size(4 * K * K);
-  v8::SetResourceConstraints(&constraints);
+  v8::SetHeapResourceConstraints(&constraints);
 
   // Execute a script that causes out of memory.
   v8::HandleScope scope;
   LocalContext context;
   v8::V8::IgnoreOutOfMemoryException();
   Local<Script> script =
       Script::Compile(String::New(js_code_causing_out_of_memory));
   Local<Value> result = script->Run();
 
   // Check for out of memory state.
@@ skipping 17 matching lines @@
 
   return result;
 }
 
 
 TEST(OutOfMemoryNested) {
   // It's not possible to read a snapshot into a heap with different dimensions.
   if (v8::internal::Snapshot::IsEnabled()) return;
   // Set heap limits.
   static const int K = 1024;
-  v8::ResourceConstraints constraints;
+  v8::HeapResourceConstraints constraints;
   constraints.set_max_young_space_size(256 * K);
   constraints.set_max_old_space_size(4 * K * K);
-  v8::SetResourceConstraints(&constraints);
+  v8::SetHeapResourceConstraints(&constraints);
 
   v8::HandleScope scope;
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->Set(v8_str("ProvokeOutOfMemory"),
              v8::FunctionTemplate::New(ProvokeOutOfMemory));
   LocalContext context(0, templ);
   v8::V8::IgnoreOutOfMemoryException();
   Local<Value> result = CompileRun(
     "var thrown = false;"
     "try {"
     "  ProvokeOutOfMemory();"
     "} catch (e) {"
     "  thrown = true;"
     "}");
   // Check for out of memory state.
   CHECK(result.IsEmpty());
   CHECK(context->HasOutOfMemoryException());
 }
 
 
 TEST(HugeConsStringOutOfMemory) {
   // It's not possible to read a snapshot into a heap with different dimensions.
   if (v8::internal::Snapshot::IsEnabled()) return;
   v8::HandleScope scope;
   LocalContext context;
   // Set heap limits.
   static const int K = 1024;
-  v8::ResourceConstraints constraints;
+  v8::HeapResourceConstraints constraints;
   constraints.set_max_young_space_size(256 * K);
   constraints.set_max_old_space_size(2 * K * K);
-  v8::SetResourceConstraints(&constraints);
+  v8::SetHeapResourceConstraints(&constraints);
 
   // Execute a script that causes out of memory.
   v8::V8::IgnoreOutOfMemoryException();
 
   // Build huge string. This should fail with out of memory exception.
   Local<Value> result = CompileRun(
     "var str = Array.prototype.join.call({length: 513}, \"A\").toUpperCase();"
     "for (var i = 0; i < 21; i++) { str = str + str; }");
 
   // Check for out of memory state.
@@ skipping 4557 matching lines @@
     v8::HandleScope inner;
     v8::Handle<v8::ObjectTemplate> local = v8::ObjectTemplate::New();
     local->SetInternalFieldCount(1);
     templ = v8::Persistent<v8::ObjectTemplate>::New(inner.Close(local));
   }
   v8::Handle<v8::Object> result = templ->NewInstance();
   CHECK_EQ(1, result->InternalFieldCount());
 }
 
 
-// If part of the threaded tests, this test makes ThreadingTest fail
-// on mac.
-TEST(CatchStackOverflow) {
+THREADED_TEST(CatchStackOverflow) {
   v8::HandleScope scope;
   LocalContext context;
   v8::TryCatch try_catch;
   v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(
     "function f() {"
     "  return f();"
     "}"
     ""
     "f();"));
+
+  // the default thread stack size on OS X ia32/x64 is 512K/1M, which
+  // is too small for the 512K default V8 stack limit
+  static const int K = 1024;
+  uint32_t here;
+  v8::SetStackLimit(&here - 256 * K / sizeof(uint32_t*));
+
   v8::Handle<v8::Value> result = script->Run();
   CHECK(result.IsEmpty());
 }
 
 
 static void CheckTryCatchSourceInfo(v8::Handle<v8::Script> script,
                                     const char* resource_name,
                                     int line_offset) {
   v8::HandleScope scope;
   v8::TryCatch try_catch;
@@ skipping 1468 matching lines @@
   CHECK(strstr(*stack, "at foo (stack-trace-test") != NULL);
 }
 
 
 // Test that idle notification can be handled when V8 has not yet been
 // set up.
 THREADED_TEST(IdleNotification) {
   for (int i = 0; i < 100; i++) v8::V8::IdleNotification(true);
   for (int i = 0; i < 100; i++) v8::V8::IdleNotification(false);
 }
+
+
+static uintptr_t js_limit;
+
+
+static v8::Handle<Value> GetStackLimitCallback(const v8::Arguments& args) {
+  js_limit = i::StackGuard::jslimit();
+  return v8::Undefined();
+}
+
+
+THREADED_TEST(SetStackLimit) {
+  v8::HandleScope scope;
+  LocalContext env;
+  Local<v8::FunctionTemplate> fun_templ =
+      v8::FunctionTemplate::New(GetStackLimitCallback);
+  Local<Function> fun = fun_templ->GetFunction();
+  env->Global()->Set(v8_str("get_stack_limit"), fun);
+
+  // Set the stack limit.
+  static const int K = 1024;
+  uint32_t here;
+  uint32_t* limit = &here - 128 * K / sizeof(uint32_t*);
+  v8::SetStackLimit(limit);
+  CompileRun("get_stack_limit();");
+
+  // Must use GENERATED_CODE_STACK_LIMIT to run on the ARM simulator.
+  uintptr_t expected_limit =
+      GENERATED_CODE_STACK_LIMIT(reinterpret_cast<uintptr_t>(limit));
+  CHECK(expected_limit == js_limit);
+}