[wasm] Make wasm info available on the stack trace

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 415 matching lines @@
           elements->set(cursor++, *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));
-        Handle<JSFunction> fun = factory()->NewFunction(
-            factory()->NewStringFromAsciiChecked("<WASM>"));
+        int offset =
+            static_cast<int>(wasm_frame->pc() - code->instruction_start());
         elements = MaybeGrow(this, elements, cursor, cursor + 4);
-        // TODO(jfb) Pass module object.
-        elements->set(cursor++, *factory()->undefined_value());
-        elements->set(cursor++, *fun);
+        elements->set(cursor++, wasm_frame->wasm_obj());
+        elements->set(cursor++, Smi::FromInt(wasm_frame->function_index()));
         elements->set(cursor++, *abstract_code);
-        elements->set(cursor++, Internals::IntToSmi(0));
+        elements->set(cursor++, Smi::FromInt(offset));
         frames_seen++;
       } break;
 
       default:
         break;
     }
   }
   elements->set(0, Smi::FromInt(sloppy_frames));
   elements->Shrink(cursor);
   Handle<JSArray> result = factory()->NewJSArrayWithElements(elements);
@@ skipping 79 matching lines @@
           STATIC_CHAR_VECTOR("functionName"));
     }
     if (options & StackTrace::kIsEval) {
       eval_key_ =
           factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isEval"));
     }
     if (options & StackTrace::kIsConstructor) {
       constructor_key_ = factory()->InternalizeOneByteString(
           STATIC_CHAR_VECTOR("isConstructor"));
     }
+    if (options & StackTrace::kIsWasm) {
+      wasm_key_ =
+          factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isWasm"));
+    }
+    if (options & StackTrace::kWasmByteOffset) {
+      wasm_offset_key_ = factory()->InternalizeOneByteString(
+          STATIC_CHAR_VECTOR("wasmByteOffset"));
+    }
+    if (options & StackTrace::kWasmObject) {
+      wasm_object_key_ =
+          factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("wasmObject"));
+    }
+  }
+
+  Handle<JSObject> NewStackFrameObject(FrameSummary& summ) {
+    int position = summ.abstract_code()->SourcePosition(summ.code_offset());
+    return NewStackFrameObject(summ.function(), position,
+                               summ.is_constructor());
   }
 
   Handle<JSObject> NewStackFrameObject(Handle<JSFunction> fun, int position,
                                        bool is_constructor) {
     Handle<JSObject> stack_frame =
         factory()->NewJSObject(isolate_->object_function());
+    Handle<Script> script(Script::cast(fun->shared()->script()));
 
-    // TODO(clemensh): this can be changed to a DCHECK once also WASM frames
-    // define a script
-    if (!fun->shared()->script()->IsUndefined()) {
-      Handle<Script> script(Script::cast(fun->shared()->script()));
-
-      if (!line_key_.is_null()) {
-        int script_line_offset = script->line_offset();
-        int line_number = Script::GetLineNumber(script, position);
-        // line_number is already shifted by the script_line_offset.
-        int relative_line_number = line_number - script_line_offset;
-        if (!column_key_.is_null() && relative_line_number >= 0) {
-          Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
-          int start = (relative_line_number == 0)
-                          ? 0
-                          : Smi::cast(line_ends->get(relative_line_number - 1))
-                                    ->value() +
-                                1;
-          int column_offset = position - start;
-          if (relative_line_number == 0) {
-            // For the case where the code is on the same line as the script
-            // tag.
-            column_offset += script->column_offset();
-          }
-          JSObject::AddProperty(
-              stack_frame, column_key_,
-              handle(Smi::FromInt(column_offset + 1), isolate_), NONE);
+    if (!line_key_.is_null()) {
+      int script_line_offset = script->line_offset();
+      int line_number = Script::GetLineNumber(script, position);
+      // line_number is already shifted by the script_line_offset.
+      int relative_line_number = line_number - script_line_offset;
+      if (!column_key_.is_null() && relative_line_number >= 0) {
+        Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
+        int start =
+            (relative_line_number == 0)
+                ? 0
+                : Smi::cast(line_ends->get(relative_line_number - 1))->value() +
+                      1;
+        int column_offset = position - start;
+        if (relative_line_number == 0) {
+          // For the case where the code is on the same line as the script
+          // tag.
+          column_offset += script->column_offset();
         }
-        JSObject::AddProperty(stack_frame, line_key_,
-                              handle(Smi::FromInt(line_number + 1), isolate_),
+        JSObject::AddProperty(stack_frame, column_key_,
+                              handle(Smi::FromInt(column_offset + 1), isolate_),
                               NONE);
       }
+      JSObject::AddProperty(stack_frame, line_key_,
+                            handle(Smi::FromInt(line_number + 1), isolate_),
+                            NONE);
+    }
 
-      if (!script_id_key_.is_null()) {
-        JSObject::AddProperty(stack_frame, script_id_key_,
-                              handle(Smi::FromInt(script->id()), isolate_),
-                              NONE);
-      }
+    if (!script_id_key_.is_null()) {
+      JSObject::AddProperty(stack_frame, script_id_key_,
+                            handle(Smi::FromInt(script->id()), isolate_), NONE);
+    }
 
-      if (!script_name_key_.is_null()) {
-        JSObject::AddProperty(stack_frame, script_name_key_,
-                              handle(script->name(), isolate_), NONE);
-      }
+    if (!script_name_key_.is_null()) {
+      JSObject::AddProperty(stack_frame, script_name_key_,
+                            handle(script->name(), isolate_), NONE);
+    }
 
-      if (!script_name_or_source_url_key_.is_null()) {
-        Handle<Object> result = Script::GetNameOrSourceURL(script);
-        JSObject::AddProperty(stack_frame, script_name_or_source_url_key_,
-                              result, NONE);
-      }
+    if (!script_name_or_source_url_key_.is_null()) {
+      Handle<Object> result = Script::GetNameOrSourceURL(script);
+      JSObject::AddProperty(stack_frame, script_name_or_source_url_key_, result,
+                            NONE);
+    }
 
-      if (!eval_key_.is_null()) {
-        Handle<Object> is_eval = factory()->ToBoolean(
-            script->compilation_type() == Script::COMPILATION_TYPE_EVAL);
-        JSObject::AddProperty(stack_frame, eval_key_, is_eval, NONE);
-      }
+    if (!eval_key_.is_null()) {
+      Handle<Object> is_eval = factory()->ToBoolean(
+          script->compilation_type() == Script::COMPILATION_TYPE_EVAL);
+      JSObject::AddProperty(stack_frame, eval_key_, is_eval, NONE);
     }
 
     if (!function_key_.is_null()) {
       Handle<Object> fun_name = JSFunction::GetDebugName(fun);
       JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
     }
 
     if (!constructor_key_.is_null()) {
       Handle<Object> is_constructor_obj = factory()->ToBoolean(is_constructor);
       JSObject::AddProperty(stack_frame, constructor_key_, is_constructor_obj,
                             NONE);
     }
 
+    if (!wasm_key_.is_null()) {
+      JSObject::AddProperty(stack_frame, wasm_key_,
+                            isolate_->factory()->false_value(), NONE);
+    }
+    return stack_frame;
+  }
+
+  Handle<JSObject> NewStackFrameObject(WasmFrame* frame) {
+    Handle<JSObject> stack_frame =
+        factory()->NewJSObject(isolate_->object_function());
+
+    Handle<Code> code;
+    auto get_code = [&code, frame, this] {
+      if (code.is_null()) code = handle(frame->LookupCode(), isolate_);
+      return code;
+    };
+    if (!function_key_.is_null()) {
+      Handle<Object> fun_name =
+          handle(frame->function_name(get_code()), isolate_);
+      if (fun_name->IsUndefined())
+        fun_name = isolate_->factory()->InternalizeUtf8String(
+            Vector<const char>("<WASM>"));
+      JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
+    }
+    if (!wasm_key_.is_null()) {
+      JSObject::AddProperty(stack_frame, wasm_key_,
+                            isolate_->factory()->true_value(), NONE);
+    }
+    if (!wasm_offset_key_.is_null()) {
+      int offset = static_cast<int>(frame->pc() - code->instruction_start());
+      int position = get_code()->SourcePosition(offset);
+      JSObject::AddProperty(stack_frame, wasm_offset_key_,
+                            isolate_->factory()->NewNumberFromInt(position),
+                            NONE);
+    }
+    if (!wasm_object_key_.is_null()) {
+      JSObject::AddProperty(stack_frame, wasm_object_key_,
+                            handle(frame->wasm_obj(get_code()), isolate_),
+                            NONE);
+    }
+
     return stack_frame;
   }
 
  private:
   inline Factory* factory() { return isolate_->factory(); }
 
   Isolate* isolate_;
   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_;
+  Handle<String> wasm_key_;
+  Handle<String> wasm_offset_key_;
+  Handle<String> wasm_object_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);
@@ skipping 42 matching lines @@
 }
 
 
 Handle<JSArray> Isolate::CaptureCurrentStackTrace(
     int frame_limit, StackTrace::StackTraceOptions options) {
   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);
 
-  StackTraceFrameIterator it(this);
   int frames_seen = 0;
-  while (!it.done() && (frames_seen < limit)) {
+  for (StackTraceFrameIterator it(this); !it.done() && (frames_seen < limit);
+       it.Advance()) {
     StandardFrame* frame = it.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 && frames_seen < limit; i--) {
-      Handle<JSFunction> fun = frames[i].function();
-      // Filter frames from other security contexts.
-      if (!(options & StackTrace::kExposeFramesAcrossSecurityOrigins) &&
-          !this->context()->HasSameSecurityTokenAs(fun->context())) continue;
-      int position =
-          frames[i].abstract_code()->SourcePosition(frames[i].code_offset());
-      Handle<JSObject> stack_frame =
-          helper.NewStackFrameObject(fun, position, frames[i].is_constructor());
-
-      FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
+    if (frame->is_java_script()) {
+      // Set initial size to the maximum inlining level + 1 for the outermost
+      // function.
+      List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+      JavaScriptFrame::cast(frame)->Summarize(&frames);
+      for (int i = frames.length() - 1; i >= 0 && frames_seen < limit; i--) {
+        Handle<JSFunction> fun = frames[i].function();
+        // Filter frames from other security contexts.
+        if (!(options & StackTrace::kExposeFramesAcrossSecurityOrigins) &&
+            !this->context()->HasSameSecurityTokenAs(fun->context()))
+          continue;
+        Handle<JSObject> new_frame_obj = helper.NewStackFrameObject(frames[i]);
+        stack_trace_elems->set(frames_seen, *new_frame_obj);
+        frames_seen++;
+      }
+    } else if (frame->is_wasm()) {
+      WasmFrame* wasm_frame = WasmFrame::cast(frame);
+      Handle<JSObject> new_frame_obj = helper.NewStackFrameObject(wasm_frame);
+      stack_trace_elems->set(frames_seen, *new_frame_obj);
       frames_seen++;
     }
-    it.Advance();
   }
 
   stack_trace->set_length(Smi::FromInt(frames_seen));
   return stack_trace;
 }
 
 
 void Isolate::PrintStack(FILE* out, PrintStackMode mode) {
   if (stack_trace_nesting_level_ == 0) {
     stack_trace_nesting_level_++;
@@ skipping 598 matching lines @@
   StackTraceFrameIterator it(this);
   while (!it.done()) {
     HandleScope scope(this);
     // Find code position if recorded in relocation info.
     StandardFrame* frame = it.frame();
     int pos;
     if (frame->is_interpreted()) {
       InterpretedFrame* iframe = reinterpret_cast<InterpretedFrame*>(frame);
       pos = iframe->GetBytecodeArray()->SourcePosition(
           iframe->GetBytecodeOffset());
-    } else {
+    } else if (frame->is_java_script()) {
       Code* code = frame->LookupCode();
       int offset = static_cast<int>(frame->pc() - code->instruction_start());
       pos = frame->LookupCode()->SourcePosition(offset);
+    } else {
+      // TODO(clemensh): include wasm frames here
+      continue;
     }
+    JavaScriptFrame* js_frame = JavaScriptFrame::cast(frame);
     Handle<Object> pos_obj(Smi::FromInt(pos), this);
     // Fetch function and receiver.
-    Handle<JSFunction> fun(frame->function());
-    Handle<Object> recv(frame->receiver(), this);
+    Handle<JSFunction> fun(js_frame->function());
+    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 =
         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()) {
-    StandardFrame* frame = it.frame();
-    JSFunction* fun = frame->function();
-    Object* script = fun->shared()->script();
-    if (script->IsScript() &&
-        !(Script::cast(script)->source()->IsUndefined())) {
-      Handle<Script> casted_script(Script::cast(script));
-      // Compute the location from the function and the relocation info of the
-      // baseline code. For optimized code this will use the deoptimization
-      // information to get canonical location information.
-      List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
-      frame->Summarize(&frames);
-      FrameSummary& summary = frames.last();
-      int pos = summary.abstract_code()->SourcePosition(summary.code_offset());
-      *target = MessageLocation(casted_script, pos, pos + 1, handle(fun));
-      return true;
-    }
-  }
-  return false;
+  if (it.done()) return false;
+  StandardFrame* frame = it.frame();
+  // TODO(clemensh): handle wasm frames
+  if (!frame->is_java_script()) return false;
+  JSFunction* fun = JavaScriptFrame::cast(frame)->function();
+  Object* script = fun->shared()->script();
+  if (!script->IsScript() || (Script::cast(script)->source()->IsUndefined()))
+    return false;
+  Handle<Script> casted_script(Script::cast(script));
+  // Compute the location from the function and the relocation info of the
+  // baseline code. For optimized code this will use the deoptimization
+  // information to get canonical location information.
+  List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+  JavaScriptFrame::cast(frame)->Summarize(&frames);
+  FrameSummary& summary = frames.last();
+  int pos = summary.abstract_code()->SourcePosition(summary.code_offset());
+  *target = MessageLocation(casted_script, pos, pos + 1, handle(fun));
+  return true;
 }
 
-
 bool Isolate::ComputeLocationFromException(MessageLocation* target,
                                            Handle<Object> exception) {
   if (!exception->IsJSObject()) return false;
 
   Handle<Name> start_pos_symbol = factory()->error_start_pos_symbol();
   Handle<Object> start_pos = JSReceiver::GetDataProperty(
       Handle<JSObject>::cast(exception), start_pos_symbol);
   if (!start_pos->IsSmi()) return false;
   int start_pos_value = Handle<Smi>::cast(start_pos)->value();
 
@@ skipping 20 matching lines @@
   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()));
   int elements_limit = Smi::cast(simple_stack_trace->length())->value();
 
   for (int i = 1; i < elements_limit; i += 4) {
-    Handle<JSFunction> fun =
-        handle(JSFunction::cast(elements->get(i + 1)), this);
+    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<JSFunction>::cast(fun_obj);
     if (!fun->shared()->IsSubjectToDebugging()) continue;
 
     Object* script = fun->shared()->script();
     if (script->IsScript() &&
         !(Script::cast(script)->source()->IsUndefined())) {
       int pos = PositionFromStackTrace(elements, i);
       Handle<Script> casted_script(Script::cast(script));
       *target = MessageLocation(casted_script, pos, pos + 1);
       return true;
     }
@@ skipping 1564 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8