[wasm] Stack inspection support for asm.js frames

src/frames.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/frames.h"
 
 #include <memory>
 #include <sstream>
 
 #include "src/base/bits.h"
@@ skipping 702 matching lines @@
 }
 
 Object* StandardFrame::receiver() const {
   return isolate()->heap()->undefined_value();
 }
 
 Object* StandardFrame::context() const {
   return isolate()->heap()->undefined_value();
 }
 
+int StandardFrame::position() const {
+  AbstractCode* code = AbstractCode::cast(LookupCode());
+  int code_offset = static_cast<int>(pc() - code->instruction_start());
+  return code->SourcePosition(code_offset);
+}
+
 int StandardFrame::ComputeExpressionsCount() const {
   Address base = GetExpressionAddress(0);
   Address limit = sp() - kPointerSize;
   DCHECK(base >= limit);  // stack grows downwards
   // Include register-allocated locals in number of expressions.
   return static_cast<int>((base - limit) / kPointerSize);
 }
 
 Object* StandardFrame::GetParameter(int index) const {
   // StandardFrame does not define any parameters.
@@ skipping 595 matching lines @@
 int OptimizedFrame::StackSlotOffsetRelativeToFp(int slot_index) {
   return StandardFrameConstants::kCallerSPOffset -
          ((slot_index + 1) * kPointerSize);
 }
 
 
 Object* OptimizedFrame::StackSlotAt(int index) const {
   return Memory::Object_at(fp() + StackSlotOffsetRelativeToFp(index));
 }
 
+int InterpretedFrame::position() const {
+  AbstractCode* code = AbstractCode::cast(GetBytecodeArray());
+  int code_offset = GetBytecodeOffset();
+  return code->SourcePosition(code_offset);
+}
+
 int InterpretedFrame::LookupExceptionHandlerInTable(
     int* context_register, HandlerTable::CatchPrediction* prediction) {
   BytecodeArray* bytecode = function()->shared()->bytecode_array();
   return bytecode->LookupRangeInHandlerTable(GetBytecodeOffset(),
                                              context_register, prediction);
 }
 
 int InterpretedFrame::GetBytecodeOffset() const {
   const int index = InterpreterFrameConstants::kBytecodeOffsetExpressionIndex;
   DCHECK_EQ(
@@ skipping 119 matching lines @@
 }
 
 uint32_t WasmFrame::function_index() const {
   FixedArray* deopt_data = LookupCode()->deoptimization_data();
   DCHECK(deopt_data->length() == 2);
   return Smi::cast(deopt_data->get(1))->value();
 }
 
 Script* WasmFrame::script() const {
   Handle<JSObject> wasm(JSObject::cast(wasm_obj()), isolate());
+  if (wasm::WasmIsAsmJs(*wasm, isolate())) {
+    return *wasm::GetAsmWasmScript(wasm);
+  }
   Handle<wasm::WasmDebugInfo> debug_info = wasm::GetDebugInfo(wasm);
   return wasm::WasmDebugInfo::GetFunctionScript(debug_info, function_index());
 }
 
+int WasmFrame::position() const {
+  int position = StandardFrame::position();
+  if (wasm::WasmIsAsmJs(wasm_obj(), isolate())) {
+    Handle<JSObject> wasm(JSObject::cast(wasm_obj()), isolate());
+    position = wasm::GetAsmWasmSourcePosition(wasm, function_index(), position);
+  }
+  return position;
+}
+
 int WasmFrame::LookupExceptionHandlerInTable(int* stack_slots) {
   DCHECK_NOT_NULL(stack_slots);
   Code* code = LookupCode();
   HandlerTable* table = HandlerTable::cast(code->handler_table());
   int pc_offset = static_cast<int>(pc() - code->entry());
   *stack_slots = code->stack_slots();
   return table->LookupReturn(pc_offset);
 }
 
 namespace {
@@ skipping 427 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8