Add WasmFrame, backtraces reflect wasm's presence

src/isolate.cc

Index: src/isolate.cc
diff --git a/src/isolate.cc b/src/isolate.cc
index e9a237b412c7434c5ac30313c4b4e81c8e1987f2..c60c161a7585cfccea72198ffa19647d04cfb8ab 100644
--- a/src/isolate.cc
+++ b/src/isolate.cc
@@ -338,6 +338,20 @@ static bool IsVisibleInStackTrace(JSFunction* fun,
   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) {
@@ -364,51 +378,64 @@ Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSObject> error_object,
   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));
-        }
-        elements = new_elements;
-      }
-      DCHECK(cursor + 4 <= elements->length());
-
-      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++;
+    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->set(cursor++, *recv);
-      elements->set(cursor++, *fun);
-      elements->set(cursor++, *abstract_code);
-      elements->set(cursor++, *offset);
-      frames_seen++;
+      } break;
+
+      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;
+
+      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));