[wasm] prototype for breakpoint support.

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 <sstream>
 
 #include "src/ast/ast.h"
 #include "src/ast/scopeinfo.h"
@@ skipping 456 matching lines @@
             // linkage are actually generated with TurboFan currently, so
             // this is sound).
             return OPTIMIZED;
           }
           return BUILTIN;
         case Code::FUNCTION:
           return JAVA_SCRIPT;
         case Code::OPTIMIZED_FUNCTION:
           return OPTIMIZED;
         case Code::WASM_FUNCTION:
-          return WASM;
+          return WASM_COMPILED;
         case Code::WASM_TO_JS_FUNCTION:
           return WASM_TO_JS;
         case Code::JS_TO_WASM_FUNCTION:
           return JS_TO_WASM;
+        case Code::WASM_TO_INTERPRETER:
+          return WASM_INTERPRETED;
         default:
           // All other types should have an explicit marker
           break;
       }
     } else {
       return NONE;
     }
   }
 
   DCHECK(marker->IsSmi());
   StackFrame::Type candidate =
       static_cast<StackFrame::Type>(Smi::cast(marker)->value());
   switch (candidate) {
     case ENTRY:
     case ENTRY_CONSTRUCT:
     case EXIT:
     case STUB:
     case STUB_FAILURE_TRAMPOLINE:
     case INTERNAL:
     case CONSTRUCT:
     case ARGUMENTS_ADAPTOR:
     case WASM_TO_JS:
-    case WASM:
+    case WASM_COMPILED:
+    case WASM_INTERPRETED:
       return candidate;
     case JS_TO_WASM:
     case JAVA_SCRIPT:
     case OPTIMIZED:
     case INTERPRETED:
     default:
       // Unoptimized and optimized JavaScript frames, including
       // interpreted frames, should never have a StackFrame::Type
       // marker. If we find one, we're likely being called from the
       // profiler in a bogus stack frame.
@@ skipping 134 matching lines @@
 }
 
 Object* StandardFrame::receiver() const {
   return isolate()->heap()->undefined_value();
 }
 
 Object* StandardFrame::context() const {
   return isolate()->heap()->undefined_value();
 }
 
+Object* StandardFrame::debug_info(bool create) const {
+  // This should only be called on frames which override this method.
+  DCHECK(false);
+  return nullptr;
+}
+
 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.
   UNREACHABLE();
   return nullptr;
 }
 
 int StandardFrame::ComputeParametersCount() const { return 0; }
 
+void StandardFrame::Summarize(List<FrameSummary>* frames,
+                              FrameSummary::Mode mode) const {
+  // Default implementation: no frames.
+}
+
 void StandardFrame::ComputeCallerState(State* state) const {
   state->sp = caller_sp();
   state->fp = caller_fp();
   state->pc_address = ResolveReturnAddressLocation(
       reinterpret_cast<Address*>(ComputePCAddress(fp())));
   state->constant_pool_address =
       reinterpret_cast<Address*>(ComputeConstantPoolAddress(fp()));
 }
 
 
@@ skipping 27 matching lines @@
       case ENTRY:
       case ENTRY_CONSTRUCT:
       case EXIT:
       case STUB_FAILURE_TRAMPOLINE:
       case ARGUMENTS_ADAPTOR:
       case STUB:
       case INTERNAL:
       case CONSTRUCT:
       case JS_TO_WASM:
       case WASM_TO_JS:
-      case WASM:
+      case WASM_COMPILED:
+      case WASM_INTERPRETED:
         frame_header_size = TypedFrameConstants::kFixedFrameSizeFromFp;
         break;
       case JAVA_SCRIPT:
       case OPTIMIZED:
       case INTERPRETED:
       case BUILTIN:
         // These frame types have a context, but they are actually stored
         // in the place on the stack that one finds the frame type.
         UNREACHABLE();
         break;
@@ skipping 173 matching lines @@
   return Script::cast(function()->shared()->script());
 }
 
 Object* JavaScriptFrame::context() const {
   const int offset = StandardFrameConstants::kContextOffset;
   Object* maybe_result = Memory::Object_at(fp() + offset);
   DCHECK(!maybe_result->IsSmi());
   return maybe_result;
 }
 
+Object* JavaScriptFrame::debug_info(bool create) const {
+  Handle<JSFunction> fun(function(), isolate());
+  Handle<SharedFunctionInfo> shared(fun->shared(), isolate());
+  if (!create && !shared->HasDebugInfo()) {
+    return *isolate()->factory()->undefined_value();
+  }
+  if (create) isolate()->debug()->EnsureDebugInfo(shared, fun);
+  return shared->GetDebugInfo();
+}
+
 int JavaScriptFrame::LookupExceptionHandlerInTable(
     int* stack_depth, HandlerTable::CatchPrediction* prediction) {
   Code* code = LookupCode();
   DCHECK(!code->is_optimized_code());
   HandlerTable* table = HandlerTable::cast(code->handler_table());
   int pc_offset = static_cast<int>(pc() - code->entry());
   return table->LookupRange(pc_offset, stack_depth, prediction);
 }
 
 
@@ skipping 80 matching lines @@
   return code->is_turbofanned() && function->shared()->asm_function() &&
          !FLAG_turbo_asm_deoptimization;
 }
 
 }  // namespace
 
 FrameSummary::FrameSummary(Object* receiver, JSFunction* function,
                            AbstractCode* abstract_code, int code_offset,
                            bool is_constructor, Mode mode)
     : receiver_(receiver, function->GetIsolate()),
-      function_(function),
+      function_(function, function->GetIsolate()),
       abstract_code_(abstract_code),
       code_offset_(code_offset),
-      is_constructor_(is_constructor) {
+      flags(is_constructor ? kIsConstructor : kNone) {
   DCHECK(abstract_code->IsBytecodeArray() ||
          Code::cast(abstract_code)->kind() != Code::OPTIMIZED_FUNCTION ||
          CannotDeoptFromAsmCode(Code::cast(abstract_code), function) ||
          mode == kApproximateSummary);
 }
 
-FrameSummary FrameSummary::GetFirst(JavaScriptFrame* frame) {
+FrameSummary::FrameSummary(Object* wasm_object, int func_index,
+                           AbstractCode* abstract_code, int code_offset,
+                           Mode mode)
+    : receiver_(wasm_object, abstract_code->GetIsolate()),
+      function_(Smi::FromInt(func_index), abstract_code->GetIsolate()),
+      abstract_code_(abstract_code),
+      code_offset_(code_offset),
+      flags(kIsWasm) {
+  DCHECK(abstract_code->IsCode() &&
+         abstract_code->GetCode()->kind() == Code::WASM_FUNCTION);
+}
+
+FrameSummary FrameSummary::GetFirst(StandardFrame* frame) {
   List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
   frame->Summarize(&frames);
   return frames.first();
 }
 
+FrameSummary FrameSummary::GetLast(StandardFrame* frame) {
+  List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+  frame->Summarize(&frames);
+  return frames.last();
+}
+
+Script* FrameSummary::script() {
+  if (is_javascript()) return Script::cast(function()->shared()->script());
+  // In testing, we sometimes don't have a wasm object.
+  if (!wasm_object()->IsJSObject()) return nullptr;
+  Handle<wasm::WasmDebugInfo> debug_info(
+      wasm::GetDebugInfo(Handle<JSObject>::cast(wasm_object())));
+  return wasm::WasmDebugInfo::GetFunctionScript(debug_info,
+                                                wasm_function_index());
+}
+
 void FrameSummary::Print() {
-  PrintF("receiver: ");
-  receiver_->ShortPrint();
-  PrintF("\nfunction: ");
-  function_->shared()->DebugName()->ShortPrint();
+  if (is_javascript()) {
+    PrintF("receiver: ");
+    receiver()->ShortPrint();
+    PrintF("\nfunction: ");
+    function()->shared()->DebugName()->ShortPrint();
+  } else {
+    DCHECK(is_wasm());
+    PrintF("wasm object: ");
+    wasm_object()->ShortPrint();
+    PrintF("\nfunction index: %d", wasm_function_index());
+  }
   PrintF("\ncode: ");
   abstract_code_->ShortPrint();
   if (abstract_code_->IsCode()) {
     Code* code = abstract_code_->GetCode();
-    if (code->kind() == Code::FUNCTION) PrintF(" UNOPT ");
-    if (code->kind() == Code::OPTIMIZED_FUNCTION) {
-      if (function()->shared()->asm_function()) {
-        DCHECK(CannotDeoptFromAsmCode(code, *function()));
-        PrintF(" ASM ");
-      } else {
-        PrintF(" OPT (approximate)");
-      }
+    switch (code->kind()) {
+      case Code::FUNCTION:
+        PrintF(" UNOPT ");
+        break;
+      case Code::OPTIMIZED_FUNCTION:
+        if (function()->shared()->asm_function()) {
+          DCHECK(CannotDeoptFromAsmCode(code, *function()));
+          PrintF(" ASM ");
+        } else {
+          PrintF(" OPT (approximate)");
+        }
+        break;
+      case Code::WASM_FUNCTION:
+        PrintF(" WASM ");
+        break;
+      default:
+        PrintF("UNKNOWN");
+        break;
     }
   } else {
     PrintF(" BYTECODE ");
   }
   PrintF("\npc: %d\n", code_offset_);
 }
 
 void OptimizedFrame::Summarize(List<FrameSummary>* frames,
                                FrameSummary::Mode mode) const {
   DCHECK(frames->length() == 0);
@@ skipping 330 matching lines @@
 Code* WasmFrame::unchecked_code() const {
   return static_cast<Code*>(isolate()->FindCodeObject(pc()));
 }
 
 void WasmFrame::Iterate(ObjectVisitor* v) const { IterateCompiledFrame(v); }
 
 Address WasmFrame::GetCallerStackPointer() const {
   return fp() + ExitFrameConstants::kCallerSPOffset;
 }
 
-Object* WasmFrame::wasm_obj() const {
+Object* WasmCompiledFrame::wasm_obj() const {
   FixedArray* deopt_data = LookupCode()->deoptimization_data();
-  DCHECK(deopt_data->length() == 2);
+  DCHECK_EQ(2, deopt_data->length());
   return deopt_data->get(0);
 }
 
-uint32_t WasmFrame::function_index() const {
+uint32_t WasmCompiledFrame::function_index() const {
   FixedArray* deopt_data = LookupCode()->deoptimization_data();
-  DCHECK(deopt_data->length() == 2);
+  DCHECK_EQ(2, deopt_data->length());
   return Smi::cast(deopt_data->get(1))->value();
 }
 
-Script* WasmFrame::script() const {
-  JSObject* wasm = JSObject::cast(wasm_obj());
+Script* WasmCompiledFrame::script() const {
+  Handle<JSObject> wasm(JSObject::cast(wasm_obj()), isolate());
   Handle<wasm::WasmDebugInfo> debug_info(wasm::GetDebugInfo(wasm), isolate());
   return wasm::WasmDebugInfo::GetFunctionScript(debug_info, function_index());
 }
 
+Object* WasmCompiledFrame::debug_info(bool create) const {
+  Handle<JSObject> wasm(JSObject::cast(wasm_obj()), isolate());
+  Handle<wasm::WasmDebugInfo> debug_info(wasm::GetDebugInfo(wasm), isolate());
+  return wasm::WasmDebugInfo::GetDebugInfo(debug_info, function_index());
+}
+
+void WasmCompiledFrame::Summarize(List<FrameSummary>* frames,
+                                  FrameSummary::Mode mode) const {
+  Code* code = LookupCode();
+  int offset = static_cast<int>(pc() - code->instruction_start());
+  // Check that we don't call this from testing, where we have no wasm object.
+  FrameSummary summary(wasm_obj(), function_index(), AbstractCode::cast(code),
+                       offset, mode);
+  frames->Add(summary);
+}
+
+Object* WasmInterpretedFrame::wasm_obj() const {
+  FixedArray* deopt_data = LookupCode()->deoptimization_data();
+  DCHECK_EQ(1, deopt_data->length());
+  return deopt_data->get(0);
+}
+
+Object* WasmInterpretedFrame::debug_info(bool /* create */) const {
+  Handle<JSObject> wasm(JSObject::cast(wasm_obj()), isolate());
+  Handle<wasm::WasmDebugInfo> wasm_debug(wasm::GetDebugInfo(wasm), isolate());
+  // Get the top-most function index.
+  auto it = wasm_debug->GetInterpreterFrameIterator();
+  while (it.Remaining() > 0) it.Next();
+  int func_index = it.GetFrameInfo().func_index();
+  return wasm_debug->GetDebugInfo(wasm_debug, func_index);
+}
+
+void WasmInterpretedFrame::Summarize(List<FrameSummary>* frames,
+                                     FrameSummary::Mode mode) const {
+  Handle<JSObject> wasm(JSObject::cast(wasm_obj()), isolate());
+  Handle<wasm::WasmDebugInfo> debug_info(wasm::GetDebugInfo(wasm), isolate());
+  wasm::InterpreterFrameIterator frame_it =
+      debug_info->GetInterpreterFrameIterator();
+
+  while (!frame_it.Done()) {
+    wasm::InterpreterFrameInfo frame_info = frame_it.GetFrameInfo();
+    AbstractCode* code = AbstractCode::cast(
+        wasm::GetWasmFunctionCode(*wasm, frame_info.func_index()));
+    FrameSummary summ(*wasm, frame_info.func_index(), code,
+                      frame_info.pc_offset());
+    frames->Add(summ);
+    frame_it.Next();
+  }
+}
+
 namespace {
 
 
 void PrintFunctionSource(StringStream* accumulator, SharedFunctionInfo* shared,
                          Code* code) {
   if (FLAG_max_stack_trace_source_length != 0 && code != NULL) {
     std::ostringstream os;
     os << "--------- s o u r c e   c o d e ---------\n"
        << SourceCodeOf(shared, FLAG_max_stack_trace_source_length)
        << "\n-----------------------------------------\n";
@@ skipping 417 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