[wasm] Enable wasm frame inspection for debugging

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"
 #include "src/base/bits.h"
 #include "src/deoptimizer.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/register-configuration.h"
 #include "src/safepoint-table.h"
 #include "src/string-stream.h"
 #include "src/vm-state-inl.h"
+#include "src/wasm/wasm-debug.h"
+#include "src/wasm/wasm-module.h"
 
 namespace v8 {
 namespace internal {
 
 ReturnAddressLocationResolver
     StackFrame::return_address_location_resolver_ = NULL;
 
 
 // Iterator that supports traversing the stack handlers of a
 // particular frame. Needs to know the top of the handler chain.
@@ skipping 27 matching lines @@
 #define INITIALIZE_SINGLETON(type, field) field##_(this),
 StackFrameIteratorBase::StackFrameIteratorBase(Isolate* isolate,
                                                bool can_access_heap_objects)
     : isolate_(isolate),
       STACK_FRAME_TYPE_LIST(INITIALIZE_SINGLETON)
       frame_(NULL), handler_(NULL),
       can_access_heap_objects_(can_access_heap_objects) {
 }
 #undef INITIALIZE_SINGLETON
 
-
 StackFrameIterator::StackFrameIterator(Isolate* isolate)
-    : StackFrameIteratorBase(isolate, true) {
-  Reset(isolate->thread_local_top());
-}
-
+    : StackFrameIterator(isolate, isolate->thread_local_top()) {}
 
 StackFrameIterator::StackFrameIterator(Isolate* isolate, ThreadLocalTop* t)
     : StackFrameIteratorBase(isolate, true) {
   Reset(t);
 }
 
-
 void StackFrameIterator::Advance() {
   DCHECK(!done());
   // Compute the state of the calling frame before restoring
   // callee-saved registers and unwinding handlers. This allows the
   // frame code that computes the caller state to access the top
   // handler and the value of any callee-saved register if needed.
   StackFrame::State state;
   StackFrame::Type type = frame_->GetCallerState(&state);
 
   // Unwind handlers corresponding to the current frame.
@@ skipping 69 matching lines @@
 }
 
 
 // -------------------------------------------------------------------------
 
 StackTraceFrameIterator::StackTraceFrameIterator(Isolate* isolate)
     : iterator_(isolate) {
   if (!done() && !IsValidFrame(iterator_.frame())) Advance();
 }
 
+StackTraceFrameIterator::StackTraceFrameIterator(Isolate* isolate,
+                                                 StackFrame::Id id)
+    : StackTraceFrameIterator(isolate) {
+  while (!done() && frame()->id() != id) Advance();
+}
 
 void StackTraceFrameIterator::Advance() {
   do {
     iterator_.Advance();
   } while (!done() && !IsValidFrame(iterator_.frame()));
 }
 
 bool StackTraceFrameIterator::IsValidFrame(StackFrame* frame) const {
   if (frame->is_java_script()) {
     JavaScriptFrame* jsFrame = static_cast<JavaScriptFrame*>(frame);
     if (!jsFrame->function()->IsJSFunction()) return false;
     Object* script = jsFrame->function()->shared()->script();
     // Don't show functions from native scripts to user.
     return (script->IsScript() &&
             Script::TYPE_NATIVE != Script::cast(script)->type());
   }
   // apart from javascript, only wasm is valid
   return frame->is_wasm();
 }
 
+void StackTraceFrameIterator::AdvanceToArgumentsFrame() {
+  if (!is_javascript() || !javascript_frame()->has_adapted_arguments()) return;
+  iterator_.Advance();
+  DCHECK(iterator_.frame()->is_arguments_adaptor());
+}
 
 // -------------------------------------------------------------------------
 
 
 SafeStackFrameIterator::SafeStackFrameIterator(
     Isolate* isolate,
     Address fp, Address sp, Address js_entry_sp)
     : StackFrameIteratorBase(isolate, false),
       low_bound_(sp),
       high_bound_(js_entry_sp),
@@ skipping 425 matching lines @@
 Address StandardFrame::GetExpressionAddress(int n) const {
   const int offset = StandardFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
 Address InterpretedFrame::GetExpressionAddress(int n) const {
   const int offset = InterpreterFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
+Script* StandardFrame::script() const {
+  // This should only be called on frames which override this method.
+  DCHECK(false);
+  return nullptr;
+}
+
+Object* StandardFrame::receiver() const {
+  return isolate()->heap()->undefined_value();
+}
+
+Object* StandardFrame::context() const {
+  return isolate()->heap()->undefined_value();
+}
+
 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::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()));
 }
 
 
 void StandardFrame::SetCallerFp(Address caller_fp) {
   Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset) =
       caller_fp;
 }
 
+bool StandardFrame::IsConstructor() const { return false; }
 
 void StandardFrame::IterateCompiledFrame(ObjectVisitor* v) const {
   // Make sure that we're not doing "safe" stack frame iteration. We cannot
   // possibly find pointers in optimized frames in that state.
   DCHECK(can_access_heap_objects());
 
   // Compute the safepoint information.
   unsigned stack_slots = 0;
   SafepointEntry safepoint_entry;
   Code* code = StackFrame::GetSafepointData(
@@ skipping 193 matching lines @@
                        IsConstructor(), mode);
   functions->Add(summary);
 }
 
 JSFunction* JavaScriptFrame::function() const {
   return JSFunction::cast(function_slot_object());
 }
 
 Object* JavaScriptFrame::receiver() const { return GetParameter(-1); }
 
+Script* JavaScriptFrame::script() const {
+  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;
+}
+
 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 59 matching lines @@
 
 
 void JavaScriptFrame::SaveOperandStack(FixedArray* store) const {
   int operands_count = store->length();
   DCHECK_LE(operands_count, ComputeOperandsCount());
   for (int i = 0; i < operands_count; i++) {
     store->set(i, GetOperand(i));
   }
 }
 
+Object* JavaScriptFrame::GetParameter(int index) const {
+  return Memory::Object_at(GetParameterSlot(index));
+}
+
+int JavaScriptFrame::ComputeParametersCount() const {
+  return GetNumberOfIncomingArguments();
+}
+
 namespace {
 
 bool CannotDeoptFromAsmCode(Code* code, JSFunction* function) {
   return code->is_turbofanned() && function->shared()->asm_function() &&
          !FLAG_turbo_asm_deoptimization;
 }
 
 }  // namespace
 
 FrameSummary::FrameSummary(Object* receiver, JSFunction* function,
@@ skipping 376 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() {
+Object* WasmFrame::wasm_obj() const {
   FixedArray* deopt_data = LookupCode()->deoptimization_data();
   DCHECK(deopt_data->length() == 2);
   return deopt_data->get(0);
 }
 
-uint32_t WasmFrame::function_index() {
+uint32_t WasmFrame::function_index() const {
   FixedArray* deopt_data = LookupCode()->deoptimization_data();
   DCHECK(deopt_data->length() == 2);
-  Object* func_index_obj = deopt_data->get(1);
-  if (func_index_obj->IsUndefined(isolate())) return static_cast<uint32_t>(-1);
-  if (func_index_obj->IsSmi()) return Smi::cast(func_index_obj)->value();
-  DCHECK(func_index_obj->IsHeapNumber());
-  uint32_t val = static_cast<uint32_t>(-1);
-  func_index_obj->ToUint32(&val);
-  DCHECK(val != static_cast<uint32_t>(-1));
-  return val;
+  return Smi::cast(deopt_data->get(1))->value();
+}
+
+Script* WasmFrame::script() const {
+  JSObject* wasm = JSObject::cast(wasm_obj());
+  Handle<wasm::WasmDebugInfo> debug_info(wasm::GetDebugInfo(wasm), isolate());
+  return wasm::WasmDebugInfo::GetFunctionScript(debug_info, function_index());
 }
 
 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"
@@ skipping 419 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