Revert of Remove stack overflow boilerplate

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 311 matching lines @@
     for (int i = 0; i < cur_position; i++) {
       new_elements->set(i, elements->get(i));
     }
     elements = new_elements;
   }
   DCHECK(new_size <= elements->length());
   return elements;
 }
 
 class StackTraceHelper {
+ private:
+  enum FrameSkipMode {
+    SKIP_FIRST,
+    SKIP_UNTIL_SEEN,
+    SKIP_NONE,
+  };
+
  public:
-  StackTraceHelper(Isolate* isolate, FrameSkipMode mode, Handle<Object> caller)
-      : isolate_(isolate), mode_(mode), caller_(caller) {
+  StackTraceHelper(Isolate* isolate, Handle<Object> caller)
+      : isolate_(isolate), caller_(caller) {
     // The caller parameter can be used to skip a specific set of frames in the
     // stack trace. It can be:
     // * null, when called from a standard error constructor. We unconditionally
     //   skip the top frame, which is always a builtin-exit frame for the error
     //   constructor builtin.
     // * a JSFunction, when called by the user from Error.captureStackTrace().
     //   We skip each frame until encountering the caller function.
     // * For any other value, all frames are included in the trace.
-    switch (mode_) {
-      case SKIP_FIRST:
-        DCHECK(caller_.is_null());
-        skip_next_frame_ = true;
-        break;
-      case SKIP_UNTIL_SEEN:
-        DCHECK(caller_->IsJSFunction());
-        skip_next_frame_ = true;
-        break;
-      case SKIP_NONE:
-        skip_next_frame_ = false;
-        break;
+    if (caller_.is_null()) {
+      mode_ = SKIP_FIRST;
+      skip_next_frame_ = true;
+    } else if (caller_->IsJSFunction()) {
+      mode_ = SKIP_UNTIL_SEEN;
+      skip_next_frame_ = true;
+    } else {
+      mode_ = SKIP_NONE;
+      skip_next_frame_ = false;
     }
     encountered_strict_function_ = false;
     sloppy_frames_ = 0;
   }
 
   // The stack trace API should not expose receivers and function
   // objects on frames deeper than the top-most one with a strict mode
   // function. The number of sloppy frames is stored as first element in
   // the result array.
   void CountSloppyFrames(JSFunction* fun) {
@@ skipping 49 matching lines @@
     }
     return true;
   }
 
   bool IsInSameSecurityContext(JSFunction* fun) {
     return isolate_->context()->HasSameSecurityTokenAs(fun->context());
   }
 
   Isolate* isolate_;
 
-  const FrameSkipMode mode_;
-  const Handle<Object> caller_;
+  FrameSkipMode mode_;
+  Handle<Object> caller_;
   bool skip_next_frame_;
 
   int sloppy_frames_;
   bool encountered_strict_function_;
 };
 
 Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSReceiver> error_object,
-                                                FrameSkipMode mode,
                                                 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.
 
   int initial_size = Min(limit, 10);
   Handle<FixedArray> elements =
       factory()->NewFixedArrayWithHoles(initial_size * 4 + 1);
 
-  StackTraceHelper helper(this, mode, caller);
+  StackTraceHelper helper(this, caller);
 
   // First element is reserved to store the number of sloppy frames.
   int cursor = 1;
   int frames_seen = 0;
   for (StackFrameIterator iter(this); !iter.done() && frames_seen < limit;
        iter.Advance()) {
     StackFrame* frame = iter.frame();
 
     switch (frame->type()) {
       case StackFrame::JAVA_SCRIPT:
@@ skipping 99 matching lines @@
         stack_trace_for_uncaught_exceptions_options_);
     // TODO(jgruber): Set back to STRICT once we have eagerly formatted traces.
     RETURN_ON_EXCEPTION(
         this, JSReceiver::SetProperty(error_object, key, stack_trace, SLOPPY),
         JSReceiver);
   }
   return error_object;
 }
 
 MaybeHandle<JSReceiver> Isolate::CaptureAndSetSimpleStackTrace(
-    Handle<JSReceiver> error_object, FrameSkipMode mode,
-    Handle<Object> caller) {
+    Handle<JSReceiver> error_object, Handle<Object> caller) {
   // Capture stack trace for simple stack trace string formatting.
   Handle<Name> key = factory()->stack_trace_symbol();
-  Handle<Object> stack_trace =
-      CaptureSimpleStackTrace(error_object, mode, caller);
+  Handle<Object> stack_trace = CaptureSimpleStackTrace(error_object, caller);
   // TODO(jgruber): Set back to STRICT once we have eagerly formatted traces.
   RETURN_ON_EXCEPTION(
       this, JSReceiver::SetProperty(error_object, key, stack_trace, SLOPPY),
       JSReceiver);
   return error_object;
 }
 
 
 Handle<JSArray> Isolate::GetDetailedStackTrace(Handle<JSObject> error_object) {
   Handle<Name> key_detailed = factory()->detailed_stack_trace_symbol();
@@ skipping 364 matching lines @@
     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);
-
-  Handle<JSFunction> fun = range_error_function();
-  Handle<Object> msg = factory()->NewStringFromAsciiChecked(
-      MessageTemplate::TemplateString(MessageTemplate::kStackOverflow));
+  // 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;
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      this, exception, ConstructError(this, fun, fun, msg, SKIP_NONE, true));
-
+  if (bootstrapper()->IsActive()) {
+    // There is no boilerplate to use during bootstrapping.
+    exception = factory()->NewStringFromAsciiChecked(
+        MessageTemplate::TemplateString(MessageTemplate::kStackOverflow));
+  } else {
+    Handle<JSObject> boilerplate = stack_overflow_boilerplate();
+    Handle<JSObject> copy = factory()->CopyJSObject(boilerplate);
+    CaptureAndSetSimpleStackTrace(copy, factory()->undefined_value());
+    exception = copy;
+  }
   Throw(*exception, nullptr);
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap && FLAG_stress_compaction) {
     heap()->CollectAllGarbage(Heap::kNoGCFlags, "trigger compaction");
   }
 #endif  // VERIFY_HEAP
 
   return heap()->exception();
 }
@@ skipping 2139 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8