Revert of Use a custom Struct for stack trace storage

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 339 matching lines @@
         break;
       case SKIP_UNTIL_SEEN:
         DCHECK(caller_->IsJSFunction());
         skip_next_frame_ = true;
         break;
       case SKIP_NONE:
         skip_next_frame_ = false;
         break;
     }
     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.
-  bool IsStrictFrame(JSFunction* fun) {
+  // function. The number of sloppy frames is stored as first element in
+  // the result array.
+  void CountSloppyFrames(JSFunction* fun) {
     if (!encountered_strict_function_) {
-      encountered_strict_function_ = is_strict(fun->shared()->language_mode());
+      if (is_strict(fun->shared()->language_mode())) {
+        encountered_strict_function_ = true;
+      } else {
+        sloppy_frames_++;
+      }
     }
-    return encountered_strict_function_;
   }
 
   // Determines whether the given stack frame should be displayed in a stack
   // trace.
   bool IsVisibleInStackTrace(JSFunction* fun) {
     return ShouldIncludeFrame(fun) && IsNotInNativeScript(fun) &&
            IsInSameSecurityContext(fun);
   }
 
+  int sloppy_frames() const { return sloppy_frames_; }
+
  private:
   // This mechanism excludes a number of uninteresting frames from the stack
   // trace. This can be be the first frame (which will be a builtin-exit frame
   // for the error constructor builtin) or every frame until encountering a
   // user-specified function.
   bool ShouldIncludeFrame(JSFunction* fun) {
     switch (mode_) {
       case SKIP_NONE:
         return true;
       case SKIP_FIRST:
@@ skipping 25 matching lines @@
   bool IsInSameSecurityContext(JSFunction* fun) {
     return isolate_->context()->HasSameSecurityTokenAs(fun->context());
   }
 
   Isolate* isolate_;
 
   const FrameSkipMode mode_;
   const Handle<Object> caller_;
   bool skip_next_frame_;
 
+  int sloppy_frames_;
   bool encountered_strict_function_;
 };
 
 namespace {
 
 // TODO(jgruber): Fix all cases in which frames give us a hole value (e.g. the
 // receiver in RegExp constructor frames.
 Handle<Object> TheHoleToUndefined(Isolate* isolate, Handle<Object> in) {
   return (in->IsTheHole(isolate))
              ? Handle<Object>::cast(isolate->factory()->undefined_value())
              : in;
 }
-
-bool GetStackTraceLimit(Isolate* isolate, int* result) {
-  Handle<JSObject> error = isolate->error_function();
-  Handle<String> stackTraceLimit =
-      isolate->factory()->InternalizeUtf8String("stackTraceLimit");
-  DCHECK(!stackTraceLimit.is_null());
-
-  Handle<Object> stack_trace_limit =
-      JSReceiver::GetDataProperty(error, stackTraceLimit);
-  if (!stack_trace_limit->IsNumber()) return false;
-
-  // Ensure that limit is not negative.
-  *result = Max(FastD2IChecked(stack_trace_limit->Number()), 0);
-  return true;
 }
 
-}  // namespace
-
 Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSReceiver> error_object,
                                                 FrameSkipMode mode,
                                                 Handle<Object> caller) {
   DisallowJavascriptExecution no_js(this);
 
-  int limit;
-  if (!GetStackTraceLimit(this, &limit)) return factory()->undefined_value();
+  // 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);
+  Handle<FixedArray> elements =
+      factory()->NewFixedArrayWithHoles(initial_size * 4 + 1);
 
-  int cursor = 0;
   StackTraceHelper helper(this, mode, caller);
-  for (StackFrameIterator iter(this); !iter.done() && cursor < limit;
+
+  // 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:
       case StackFrame::OPTIMIZED:
       case StackFrame::INTERPRETED:
       case StackFrame::BUILTIN: {
         JavaScriptFrame* js_frame = JavaScriptFrame::cast(frame);
         // Set initial size to the maximum inlining level + 1 for the outermost
         // function.
         List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
         js_frame->Summarize(&frames);
         for (int i = frames.length() - 1; i >= 0; i--) {
           Handle<JSFunction> fun = frames[i].function();
 
           // Filter out internal frames that we do not want to show.
           if (!helper.IsVisibleInStackTrace(*fun)) continue;
+          helper.CountSloppyFrames(*fun);
 
           Handle<Object> recv = frames[i].receiver();
           Handle<AbstractCode> abstract_code = frames[i].abstract_code();
-          const int offset = frames[i].code_offset();
-
-          bool force_constructor = false;
           if (frame->type() == StackFrame::BUILTIN) {
             // Help CallSite::IsConstructor correctly detect hand-written
             // construct stubs.
-            if (Code::cast(*abstract_code)->is_construct_stub()) {
-              force_constructor = true;
+            Code* code = Code::cast(*abstract_code);
+            if (code->is_construct_stub()) {
+              recv = handle(heap()->call_site_constructor_symbol(), this);
             }
           }
+          Handle<Smi> offset(Smi::FromInt(frames[i].code_offset()), this);
 
-          int flags = 0;
-          if (helper.IsStrictFrame(*fun)) flags |= StackTraceFrame::kIsStrict;
-          if (force_constructor) flags |= StackTraceFrame::kForceConstructor;
-
-          Handle<StackTraceFrame> callsite = factory()->NewStackTraceFrame();
-          callsite->set_flags(flags);
-          callsite->set_receiver(*TheHoleToUndefined(this, recv));
-          callsite->set_function(*fun);
-          callsite->set_abstract_code(*abstract_code);
-          callsite->set_offset(offset);
-
-          elements = MaybeGrow(this, elements, cursor, cursor + 1);
-          elements->set(cursor++, *callsite);
+          elements = MaybeGrow(this, elements, cursor, cursor + 4);
+          elements->set(cursor++, *TheHoleToUndefined(this, recv));
+          elements->set(cursor++, *fun);
+          elements->set(cursor++, *abstract_code);
+          elements->set(cursor++, *offset);
+          frames_seen++;
         }
       } break;
 
       case StackFrame::BUILTIN_EXIT: {
         BuiltinExitFrame* exit_frame = BuiltinExitFrame::cast(frame);
         Handle<JSFunction> fun = handle(exit_frame->function(), this);
 
         // Filter out internal frames that we do not want to show.
         if (!helper.IsVisibleInStackTrace(*fun)) continue;
+        helper.CountSloppyFrames(*fun);
 
-        Handle<Object> recv = handle(exit_frame->receiver(), this);
         Handle<Code> code = handle(exit_frame->LookupCode(), this);
-        const int offset =
+        int offset =
             static_cast<int>(exit_frame->pc() - code->instruction_start());
 
-        int flags = 0;
-        if (helper.IsStrictFrame(*fun)) flags |= StackTraceFrame::kIsStrict;
-        if (exit_frame->IsConstructor())
-          flags |= StackTraceFrame::kForceConstructor;
+        // In order to help CallSite::IsConstructor detect builtin constructors,
+        // we reuse the receiver field to pass along a special symbol.
+        Handle<Object> recv;
+        if (exit_frame->IsConstructor()) {
+          recv = factory()->call_site_constructor_symbol();
+        } else {
+          recv = handle(exit_frame->receiver(), this);
+        }
 
-        Handle<StackTraceFrame> callsite = factory()->NewStackTraceFrame();
-        callsite->set_flags(flags);
-        callsite->set_receiver(*recv);
-        callsite->set_function(*fun);
-        callsite->set_abstract_code(AbstractCode::cast(*code));
-        callsite->set_offset(offset);
-
-        elements = MaybeGrow(this, elements, cursor, cursor + 1);
-        elements->set(cursor++, *callsite);
+        elements = MaybeGrow(this, elements, cursor, cursor + 4);
+        elements->set(cursor++, *recv);
+        elements->set(cursor++, *fun);
+        elements->set(cursor++, *code);
+        elements->set(cursor++, Smi::FromInt(offset));
+        frames_seen++;
       } break;
 
       case StackFrame::WASM: {
         WasmFrame* wasm_frame = WasmFrame::cast(frame);
         Code* code = wasm_frame->unchecked_code();
         Handle<AbstractCode> abstract_code =
             Handle<AbstractCode>(AbstractCode::cast(code), this);
-        const int offset =
+        int offset =
             static_cast<int>(wasm_frame->pc() - code->instruction_start());
-
-        // TODO(wasm): The wasm object returned by the WasmFrame should always
-        //             be a wasm object.
-        DCHECK(wasm::IsWasmObject(wasm_frame->wasm_obj()) ||
-               wasm_frame->wasm_obj()->IsUndefined(this));
-
-        Handle<StackTraceFrame> callsite = factory()->NewStackTraceFrame();
-        callsite->set_flags(StackTraceFrame::kIsWasmFrame);
-        callsite->set_wasm_object(wasm_frame->wasm_obj());
-        callsite->set_wasm_function_index(wasm_frame->function_index());
-        callsite->set_abstract_code(*abstract_code);
-        callsite->set_offset(offset);
-
-        elements = MaybeGrow(this, elements, cursor, cursor + 1);
-        elements->set(cursor++, *callsite);
+        elements = MaybeGrow(this, elements, cursor, cursor + 4);
+        elements->set(cursor++, wasm_frame->wasm_obj());
+        elements->set(cursor++, Smi::FromInt(wasm_frame->function_index()));
+        elements->set(cursor++, *abstract_code);
+        elements->set(cursor++, Smi::FromInt(offset));
+        frames_seen++;
       } break;
 
       default:
         break;
     }
   }
-
+  elements->set(0, Smi::FromInt(helper.sloppy_frames()));
   elements->Shrink(cursor);
   Handle<JSArray> result = factory()->NewJSArrayWithElements(elements);
   result->set_length(Smi::FromInt(cursor));
-
   // TODO(yangguo): Queue this structured stack trace for preprocessing on GC.
   return result;
 }
 
 MaybeHandle<JSReceiver> Isolate::CaptureAndSetDetailedStackTrace(
     Handle<JSReceiver> error_object) {
   if (capture_stack_trace_for_uncaught_exceptions_) {
     // Capture stack trace for a detailed exception message.
     Handle<Name> key = factory()->detailed_stack_trace_symbol();
     Handle<JSArray> stack_trace = CaptureCurrentStackTrace(
@@ skipping 188 matching lines @@
   Handle<String> column_key_;
   Handle<String> line_key_;
   Handle<String> script_id_key_;
   Handle<String> script_name_key_;
   Handle<String> script_name_or_source_url_key_;
   Handle<String> function_key_;
   Handle<String> eval_key_;
   Handle<String> constructor_key_;
 };
 
+
+int PositionFromStackTrace(Handle<FixedArray> elements, int index) {
+  DisallowHeapAllocation no_gc;
+  Object* maybe_code = elements->get(index + 2);
+  if (maybe_code->IsSmi()) {
+    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);
@@ skipping 624 matching lines @@
 
 Object* Isolate::PromoteScheduledException() {
   Object* thrown = scheduled_exception();
   clear_scheduled_exception();
   // Re-throw the exception to avoid getting repeated error reporting.
   return ReThrow(thrown);
 }
 
 
 void Isolate::PrintCurrentStackTrace(FILE* out) {
-  for (StackTraceFrameIterator it(this); !it.done(); it.Advance()) {
-    if (!it.is_javascript()) continue;
-
+  StackTraceFrameIterator it(this);
+  while (!it.done()) {
     HandleScope scope(this);
-    JavaScriptFrame* frame = it.javascript_frame();
-
     // Find code position if recorded in relocation info.
-    AbstractCode* abstract_code = AbstractCode::cast(frame->LookupCode());
-    const int code_offset =
-        static_cast<int>(frame->pc() - abstract_code->instruction_start());
-
-    Handle<StackTraceFrame> st_frame = factory()->NewStackTraceFrame();
-
-    st_frame->set_receiver(frame->receiver());
-    st_frame->set_function(frame->function());
-    st_frame->set_abstract_code(abstract_code);
-    st_frame->set_offset(code_offset);
-
+    StandardFrame* frame = it.frame();
+    AbstractCode* abstract_code;
+    int code_offset;
+    if (frame->is_interpreted()) {
+      InterpretedFrame* iframe = reinterpret_cast<InterpretedFrame*>(frame);
+      abstract_code = AbstractCode::cast(iframe->GetBytecodeArray());
+      code_offset = iframe->GetBytecodeOffset();
+    } else {
+      DCHECK(frame->is_java_script() || frame->is_wasm());
+      Code* code = frame->LookupCode();
+      abstract_code = AbstractCode::cast(code);
+      code_offset = static_cast<int>(frame->pc() - code->instruction_start());
+    }
+    int pos = abstract_code->SourcePosition(code_offset);
+    JavaScriptFrame* js_frame = JavaScriptFrame::cast(frame);
+    Handle<Object> pos_obj(Smi::FromInt(pos), this);
+    // Fetch function and receiver.
+    Handle<JSFunction> fun(js_frame->function(), this);
+    Handle<Object> recv(js_frame->receiver(), this);
+    // Advance to the next JavaScript frame and determine if the
+    // current frame is the top-level frame.
+    it.Advance();
+    Handle<Object> is_top_level = factory()->ToBoolean(it.done());
     // Generate and print stack trace line.
-    Handle<String> line = st_frame->ToString();
+    Handle<String> line =
+        Execution::GetStackTraceLine(recv, fun, pos_obj, is_top_level);
     if (line->length() > 0) {
       line->PrintOn(out);
       PrintF(out, "\n");
     }
   }
 }
 
 bool Isolate::ComputeLocation(MessageLocation* target) {
   StackTraceFrameIterator it(this);
   if (it.done()) return false;
@@ skipping 48 matching lines @@
 bool Isolate::ComputeLocationFromStackTrace(MessageLocation* target,
                                             Handle<Object> exception) {
   if (!exception->IsJSObject()) return false;
   Handle<Name> key = factory()->stack_trace_symbol();
   Handle<Object> property =
       JSReceiver::GetDataProperty(Handle<JSObject>::cast(exception), key);
   if (!property->IsJSArray()) return false;
   Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
 
   Handle<FixedArray> elements(FixedArray::cast(simple_stack_trace->elements()));
-  const int elements_limit = Smi::cast(simple_stack_trace->length())->value();
+  int elements_limit = Smi::cast(simple_stack_trace->length())->value();
 
-  for (int i = 0; i < elements_limit; i++) {
-    DCHECK(elements->get(i)->IsStackTraceFrame());
-    Handle<StackTraceFrame> frame(StackTraceFrame::cast(elements->get(i)));
-
-    if (frame->IsWasmFrame()) {
+  for (int i = 1; i < elements_limit; i += 4) {
+    Handle<Object> fun_obj = handle(elements->get(i + 1), this);
+    if (fun_obj->IsSmi()) {
       // TODO(clemensh): handle wasm frames
       return false;
     }
-
-    Handle<JSFunction> fun = handle(frame->function());
+    Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
     if (!fun->shared()->IsSubjectToDebugging()) continue;
 
     Object* script = fun->shared()->script();
     if (script->IsScript() &&
         !(Script::cast(script)->source()->IsUndefined(this))) {
-      const int pos = frame->GetPosition();
+      int pos = PositionFromStackTrace(elements, i);
       Handle<Script> casted_script(Script::cast(script));
       *target = MessageLocation(casted_script, pos, pos + 1);
       return true;
     }
   }
   return false;
 }
 
 
 Handle<JSMessageObject> Isolate::CreateMessage(Handle<Object> exception,
@@ skipping 1652 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8