Add WasmFrame, backtraces reflect wasm's presence

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 320 matching lines @@
   // Functions defined in native scripts are not visible unless directly
   // exposed, in which case the native flag is set.
   // The --builtins-in-stack-traces command line flag allows including
   // internal call sites in the stack trace for debugging purposes.
   if (!FLAG_builtins_in_stack_traces && fun->shared()->IsBuiltin()) {
     return fun->shared()->native();
   }
   return true;
 }
 
+static Handle<FixedArray> maybeGrow(Isolate* isolate,

[Michael Starzinger, 2016/02/19 21:15:27]

nit: Function name is not following V8 style.

[JF, 2016/02/19 21:43:51]

Done.

+                                    Handle<FixedArray> elements,
+                                    int cur_position, int new_size) {
+  if (new_size > elements->length()) {
+    int new_capacity = JSObject::NewElementsCapacity(elements->length());
+    Handle<FixedArray> new_elements =
+        isolate->factory()->NewFixedArrayWithHoles(new_capacity);
+    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;
+}
 
 Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSObject> error_object,
                                                 Handle<Object> caller) {
   // 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);
 
   // If the caller parameter is a function we skip frames until we're
   // under it before starting to collect.
   bool seen_caller = !caller->IsJSFunction();
   // First element is reserved to store the number of sloppy frames.
   int cursor = 1;
   int frames_seen = 0;
   int sloppy_frames = 0;
   bool encountered_strict_function = false;
-  for (JavaScriptFrameIterator iter(this);
-       !iter.done() && frames_seen < limit;
+  for (VisibleFrameIterator iter(this); !iter.done() && frames_seen < limit;
        iter.Advance()) {
-    JavaScriptFrame* frame = iter.frame();
-    // Set initial size to the maximum inlining level + 1 for the outermost
-    // function.
-    List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
-    frame->Summarize(&frames);
-    for (int i = frames.length() - 1; i >= 0; i--) {
-      Handle<JSFunction> fun = frames[i].function();
-      Handle<Object> recv = frames[i].receiver();
-      // Filter out internal frames that we do not want to show.
-      if (!IsVisibleInStackTrace(*fun, *caller, *recv, &seen_caller)) continue;
-      // Filter out frames from other security contexts.
-      if (!this->context()->HasSameSecurityTokenAs(fun->context())) continue;
-      if (cursor + 4 > elements->length()) {
-        int new_capacity = JSObject::NewElementsCapacity(elements->length());
-        Handle<FixedArray> new_elements =
-            factory()->NewFixedArrayWithHoles(new_capacity);
-        for (int i = 0; i < cursor; i++) {
-          new_elements->set(i, elements->get(i));
+    VisibleFrame* frame = iter.frame();
+
+    switch (frame->type()) {
+      case StackFrame::JAVA_SCRIPT:
+      case StackFrame::OPTIMIZED:
+      case StackFrame::INTERPRETED: {
+        // Set initial size to the maximum inlining level + 1 for the outermost
+        // function.
+        List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+        frame->Summarize(&frames);
+        for (int i = frames.length() - 1; i >= 0; i--) {
+          Handle<JSFunction> fun = frames[i].function();
+          Handle<Object> recv = frames[i].receiver();
+          // Filter out internal frames that we do not want to show.
+          if (!IsVisibleInStackTrace(*fun, *caller, *recv, &seen_caller))
+            continue;

[Michael Starzinger, 2016/02/19 21:15:27]

nit: Please put curly braces around body if conditional statement spans more
than one line.

[JF, 2016/02/19 21:43:51]

Done. Auto-format doesn't auto-curl :-(

+          // Filter out frames from other security contexts.
+          if (!this->context()->HasSameSecurityTokenAs(fun->context()))
+            continue;

[Michael Starzinger, 2016/02/19 21:15:27]

nit: Please put curly braces around body if conditional statement spans more
than one line.

[JF, 2016/02/19 21:43:51]

Done.

+          elements = maybeGrow(this, elements, cursor, cursor + 4);
+
+          Handle<AbstractCode> abstract_code = frames[i].abstract_code();
+
+          Handle<Smi> offset(Smi::FromInt(frames[i].code_offset()), this);
+          // 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.
+          if (!encountered_strict_function) {
+            if (is_strict(fun->shared()->language_mode())) {
+              encountered_strict_function = true;
+            } else {
+              sloppy_frames++;
+            }
+          }
+          elements->set(cursor++, *factory()->undefined_value());

[Michael Starzinger, 2016/02/19 21:15:27]

I don't think it is OK to pass undefined as the receiver here, this is
accessible through CallSiteGetTypeName and CallSiteGetThis in the messages.js
file.

[JF, 2016/02/19 21:43:51]

What would be OK instead?

[Michael Starzinger, 2016/02/19 21:55:23]

The "recv" value, as it was before. I am on referring to the "normal" JavaScript
frames (i.e. StackFrame::JAVA_SCRIPT, OPTIMIZED and INTERPRETED) here.

[titzer, 2016/02/21 09:01:54]

In a previous comment I had advised passing "undefined" but I meant the below,
WASM case, not this case.

[JF, 2016/02/22 18:29:40]

Oh right, sorry about that! Too much look-alike code. Fixed now.

+          elements->set(cursor++, *fun);
+          elements->set(cursor++, *abstract_code);
+          elements->set(cursor++, *offset);
+          frames_seen++;
         }
-        elements = new_elements;
-      }
-      DCHECK(cursor + 4 <= elements->length());
+      } break;
 
-      Handle<AbstractCode> abstract_code = frames[i].abstract_code();
+      case StackFrame::WASM: {
+        elements = maybeGrow(this, elements, cursor, cursor + 4);
+        elements->set(cursor++, *caller);  // TODO(jfb) Pass module object.
+        elements->set(cursor++,
+                      *factory()->NewFunction(
+                          factory()->NewStringFromAsciiChecked("<WASM>")));
+        elements->set(cursor++, Internals::IntToSmi(0));
+        elements->set(cursor++, Internals::IntToSmi(0));
+        frames_seen++;
+      } break;
 
-      Handle<Smi> offset(Smi::FromInt(frames[i].code_offset()), this);
-      // 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.
-      if (!encountered_strict_function) {
-        if (is_strict(fun->shared()->language_mode())) {
-          encountered_strict_function = true;
-        } else {
-          sloppy_frames++;
-        }
-      }
-      elements->set(cursor++, *recv);
-      elements->set(cursor++, *fun);
-      elements->set(cursor++, *abstract_code);
-      elements->set(cursor++, *offset);
-      frames_seen++;
+      default:
+        UNREACHABLE();
     }
   }
   elements->set(0, Smi::FromInt(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;
 }
 
@@ skipping 2435 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8