Don't call into JS from within stack trace generation

src/isolate.cc

 // Copyright 2012 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/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 385 matching lines @@
   Isolate* isolate_;
   Handle<Object> caller_;
 
   bool seen_caller_;
   int sloppy_frames_;
   bool encountered_strict_function_;
 };
 
 Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSReceiver> error_object,
                                                 Handle<Object> caller) {
+  DisallowJavascriptExecution no_js(this);
+
   // Get stack trace limit.
   Handle<JSObject> error = error_function();
   Handle<String> stackTraceLimit =
       factory()->InternalizeUtf8String("stackTraceLimit");
   DCHECK(!stackTraceLimit.is_null());
   Handle<Object> stack_trace_limit =
       JSReceiver::GetDataProperty(error, stackTraceLimit);
   if (!stack_trace_limit->IsNumber()) return factory()->undefined_value();
   int limit = FastD2IChecked(stack_trace_limit->Number());
   limit = Max(limit, 0);  // Ensure that limit is not negative.
@@ skipping 315 matching lines @@
     return Smi::cast(maybe_code)->value();
   } else {
     AbstractCode* abstract_code = AbstractCode::cast(maybe_code);
     int code_offset = Smi::cast(elements->get(index + 3))->value();
     return abstract_code->SourcePosition(code_offset);
   }
 }
 
 Handle<JSArray> Isolate::CaptureCurrentStackTrace(
     int frame_limit, StackTrace::StackTraceOptions options) {
+  DisallowJavascriptExecution no_js(this);
   CaptureStackTraceHelper helper(this, options);
 
   // Ensure no negative values.
   int limit = Max(frame_limit, 0);
   Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
   Handle<FixedArray> stack_trace_elems(
       FixedArray::cast(stack_trace->elements()), this);
 
   int frames_seen = 0;
   for (StackTraceFrameIterator it(this); !it.done() && (frames_seen < limit);
@@ skipping 163 matching lines @@
   {
     // Leaving JavaScript.
     VMState<EXTERNAL> state(this);
     return callback(v8::Utils::ToLocal(accessing_context),
                     v8::Utils::ToLocal(receiver), v8::Utils::ToLocal(data));
   }
 }
 
 
 Object* Isolate::StackOverflow() {
+  DisallowJavascriptExecution no_js(this);
   HandleScope scope(this);
   // At this point we cannot create an Error object using its javascript
   // constructor.  Instead, we copy the pre-constructed boilerplate and
   // attach the stack trace as a hidden property.
   Handle<Object> exception;
   if (bootstrapper()->IsActive()) {
     // There is no boilerplate to use during bootstrapping.
     exception = factory()->NewStringFromAsciiChecked(
         MessageTemplate::TemplateString(MessageTemplate::kStackOverflow));
   } else {
@@ skipping 2151 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8