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, Handle<FixedArray> e,
+                                    int cur_position, int new_size) {
+  if (new_size > e->length()) {
+    int new_capacity = JSObject::NewElementsCapacity(e->length());
+    Handle<FixedArray> new_e =

[titzer, 2016/02/19 10:50:30]

I guess it's ok to spell out new_elements here, since the old code did as well.

[JF, 2016/02/19 16:53:58]

Done.

+        isolate->factory()->NewFixedArrayWithHoles(new_capacity);
+    for (int i = 0; i < cur_position; i++) {
+      new_e->set(i, e->get(i));
+    }
+    e = new_e;
+  }
+  DCHECK(new_size <= e->length());
+  return e;
+}
 
 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;
+          // Filter out frames from other security contexts.
+          if (!this->context()->HasSameSecurityTokenAs(fun->context()))
+            continue;
+          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++, *recv);
+          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);

[titzer, 2016/02/19 10:50:30]

I'm not sure it's OK to put in the caller as the receiver here. Probably
undefined is best. In the future we will probably want to put in the module
object, but currently there is no way to get to it.

[JF, 2016/02/19 16:53:58]

I wasn't sure about that :-)
I left as-is for now, but added a TODO.

[titzer, 2016/02/19 17:00:41]

Please make it undefined; it will explode more readily under misuse.

[JF, 2016/02/19 20:57:42]

Ah I had misunderstood what you meant by "undefined" earlier. Done.

+        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:
+        DCHECK(false && "unknown frame type");

[titzer, 2016/02/19 10:50:30]

We usually just use UNREACHABLE();

[JF, 2016/02/19 16:53:58]

Done.

     }
   }
   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