[wasm] Enable wasm frame inspection for debugging

src/debug/debug-frames.cc

 // Copyright 2015 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/debug/debug-frames.h"
 
 #include "src/frames-inl.h"
+#include "src/wasm/wasm-debug.h"
+#include "src/wasm/wasm-module.h"
 
 namespace v8 {
 namespace internal {
 
-FrameInspector::FrameInspector(JavaScriptFrame* frame,
-                               int inlined_jsframe_index, Isolate* isolate)
+FrameInspector::FrameInspector(StandardFrame* frame, int inlined_jsframe_index,
+                               Isolate* isolate)
     : frame_(frame), deoptimized_frame_(NULL), isolate_(isolate) {
-  has_adapted_arguments_ = frame_->has_adapted_arguments();
+  JavaScriptFrame* js_frame =
+      frame->is_java_script() ? javascript_frame() : nullptr;
+  DCHECK(js_frame || frame->is_wasm());
+  has_adapted_arguments_ = js_frame && js_frame->has_adapted_arguments();
   is_bottommost_ = inlined_jsframe_index == 0;
   is_optimized_ = frame_->is_optimized();
   is_interpreted_ = frame_->is_interpreted();
   // Calculate the deoptimized frame.
   if (frame->is_optimized()) {
+    DCHECK(js_frame != nullptr);
     // TODO(turbofan): Revisit once we support deoptimization.
-    if (frame->LookupCode()->is_turbofanned() &&
-        frame->function()->shared()->asm_function() &&
+    if (js_frame->LookupCode()->is_turbofanned() &&
+        js_frame->function()->shared()->asm_function() &&
         !FLAG_turbo_asm_deoptimization) {
       is_optimized_ = false;
       return;
     }
 
     deoptimized_frame_ = Deoptimizer::DebuggerInspectableFrame(
-        frame, inlined_jsframe_index, isolate);
+        js_frame, inlined_jsframe_index, isolate);
   }
 }
 
 
 FrameInspector::~FrameInspector() {
   // Get rid of the calculated deoptimized frame if any.
   if (deoptimized_frame_ != NULL) {
     Deoptimizer::DeleteDebuggerInspectableFrame(deoptimized_frame_, isolate_);
   }
 }
 
 
 int FrameInspector::GetParametersCount() {
-  return is_optimized_ ? deoptimized_frame_->parameters_count()
-                       : frame_->ComputeParametersCount();
+  if (is_optimized_) return deoptimized_frame_->parameters_count();
+  if (frame_->is_wasm()) {
+    // TODO(clemensh): return real parameter count
+    return 0;
+  }
+  return javascript_frame()->ComputeParametersCount();

[Yang, 2016/06/16 14:10:41]

Can we make ComputeParameterCount a virtual method on StandardFrame that returns
0 for wasm frames?

[Clemens Hammacher, 2016/06/16 17:02:30]

Done.

 }
 
-Handle<Object> FrameInspector::GetFunction() {
+Handle<Script> FrameInspector::GetScript() {
+  if (frame_->is_wasm()) {
+    DCHECK(wasm_frame()->wasm_obj()->IsJSObject());

[Yang, 2016/06/16 14:10:41]

I wish we don't have to check against is_wasm everywhere. Can't we simply have
GetFunction return the correct function wrapper for the wasm code, from which we
can then get its SharedFunctionInfo and script?

[Clemens Hammacher, 2016/06/16 17:02:30]

We don't have a JSFunction for wasm frames, that's why we need to get the script
otherwise. But I pulled the script accessor up to the standard frame.

+    JSObject* wasm_obj = JSObject::cast(wasm_frame()->wasm_obj());
+    int func_index = wasm_frame()->function_index();
+    return handle(wasm::GetDebugInfo(wasm_obj)->GetFunctionScript(func_index),
+                  isolate_);
+  }
+  return handle(Script::cast(GetFunction()->shared()->script()), isolate_);
+}
+
+Handle<JSFunction> FrameInspector::GetFunction() {
+  DCHECK(!frame_->is_wasm());
   return is_optimized_ ? deoptimized_frame_->GetFunction()
-                       : handle(frame_->function(), isolate_);
+                       : handle(javascript_frame()->function(), isolate_);
 }
 
 Handle<Object> FrameInspector::GetParameter(int index) {
-  return is_optimized_ ? deoptimized_frame_->GetParameter(index)
-                       : handle(frame_->GetParameter(index), isolate_);
+  if (is_optimized_) return deoptimized_frame_->GetParameter(index);
+  if (frame_->is_wasm()) {
+    // TODO(clemensh): return real parameter value for debugged frame
+    return isolate_->factory()->undefined_value();
+  }
+  return handle(javascript_frame()->GetParameter(index), isolate_);

[Yang, 2016/06/16 14:10:41]

Same here. GetParameter could be a virtual method on StandardFrame.

[Clemens Hammacher, 2016/06/16 17:02:30]

Done.

 }
 
 Handle<Object> FrameInspector::GetExpression(int index) {
+  if (frame_->is_wasm()) {
+    // TODO(clemensh): find out what this function does, and whether we can do
+    // anything for wasm
+    return isolate_->factory()->undefined_value();
+  }
+
+  JavaScriptFrame* js_frame = javascript_frame();
   // TODO(turbofan): Revisit once we support deoptimization.
-  if (frame_->LookupCode()->is_turbofanned() &&
-      frame_->function()->shared()->asm_function() &&
+  if (js_frame->LookupCode()->is_turbofanned() &&
+      js_frame->function()->shared()->asm_function() &&
       !FLAG_turbo_asm_deoptimization) {
     return isolate_->factory()->undefined_value();
   }
   return is_optimized_ ? deoptimized_frame_->GetExpression(index)
-                       : handle(frame_->GetExpression(index), isolate_);
+                       : handle(js_frame->GetExpression(index), isolate_);
 }
 
 
 int FrameInspector::GetSourcePosition() {
   if (is_optimized_) {
     return deoptimized_frame_->GetSourcePosition();
   } else if (is_interpreted_) {
     InterpretedFrame* frame = reinterpret_cast<InterpretedFrame*>(frame_);
     BytecodeArray* bytecode_array = frame->GetBytecodeArray();
     return bytecode_array->SourcePosition(frame->GetBytecodeOffset());
   } else {
     Code* code = frame_->LookupCode();
     int offset = static_cast<int>(frame_->pc() - code->instruction_start());
     return code->SourcePosition(offset);
   }
 }
 
 
 bool FrameInspector::IsConstructor() {
+  if (frame_->is_wasm()) return false;
   return is_optimized_ && !is_bottommost_
              ? deoptimized_frame_->HasConstructStub()
-             : frame_->IsConstructor();
+             : javascript_frame()->IsConstructor();

[Yang, 2016/06/16 14:10:41]

Same here.

[Clemens Hammacher, 2016/06/16 17:02:31]

Done.

 }
 
 Handle<Object> FrameInspector::GetContext() {
-  return is_optimized_ ? deoptimized_frame_->GetContext()
-                       : handle(frame_->context(), isolate_);
+  if (frame_->is_wasm()) return isolate_->factory()->undefined_value();
+  if (is_optimized_) return deoptimized_frame_->GetContext();
+  return handle(javascript_frame()->context(), isolate_);

[Yang, 2016/06/16 14:10:41]

And here.

[Clemens Hammacher, 2016/06/16 17:02:30]

Done.

 }
 
 
 // To inspect all the provided arguments the frame might need to be
 // replaced with the arguments frame.
-void FrameInspector::SetArgumentsFrame(JavaScriptFrame* frame) {
+void FrameInspector::SetArgumentsFrame(StandardFrame* frame) {
   DCHECK(has_adapted_arguments_);
+  DCHECK(frame->is_arguments_adaptor());
   frame_ = frame;
   is_optimized_ = frame_->is_optimized();
   is_interpreted_ = frame_->is_interpreted();
   DCHECK(!is_optimized_);
 }
 
 
 // Create a plain JSObject which materializes the local scope for the specified
 // frame.
 void FrameInspector::MaterializeStackLocals(Handle<JSObject> target,
@@ skipping 38 matching lines @@
 void FrameInspector::MaterializeStackLocals(Handle<JSObject> target,
                                             Handle<JSFunction> function) {
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
   MaterializeStackLocals(target, scope_info);
 }
 
 
 void FrameInspector::UpdateStackLocalsFromMaterializedObject(
     Handle<JSObject> target, Handle<ScopeInfo> scope_info) {
-  if (is_optimized_) {
-    // Optimized frames are not supported. Simply give up.
-    return;
-  }
+  // Optimized frames and wasm frames are not supported. Simply give up.
+  if (is_optimized_ || frame_->is_wasm()) return;
 
   HandleScope scope(isolate_);
 
   // Parameters.
   for (int i = 0; i < scope_info->ParameterCount(); ++i) {
     // Shadowed parameters were not materialized.
     Handle<String> name(scope_info->ParameterName(i));
     if (ScopeInfo::VariableIsSynthetic(*name)) continue;
     if (ParameterIsShadowedByContextLocal(scope_info, name)) continue;
 
-    DCHECK(!frame_->GetParameter(i)->IsTheHole(isolate_));
+    DCHECK(!javascript_frame()->GetParameter(i)->IsTheHole(isolate_));
     Handle<Object> value =
         Object::GetPropertyOrElement(target, name).ToHandleChecked();
-    frame_->SetParameterValue(i, *value);
+    javascript_frame()->SetParameterValue(i, *value);
   }
 
   // Stack locals.
   for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
     Handle<String> name(scope_info->StackLocalName(i));
     if (ScopeInfo::VariableIsSynthetic(*name)) continue;
     int index = scope_info->StackLocalIndex(i);
     if (frame_->GetExpression(index)->IsTheHole(isolate_)) continue;
     Handle<Object> value =
         Object::GetPropertyOrElement(target, name).ToHandleChecked();
     frame_->SetExpression(index, *value);
   }
 }
 
 
 bool FrameInspector::ParameterIsShadowedByContextLocal(
     Handle<ScopeInfo> info, Handle<String> parameter_name) {
   VariableMode mode;
   InitializationFlag init_flag;
   MaybeAssignedFlag maybe_assigned_flag;
   return ScopeInfo::ContextSlotIndex(info, parameter_name, &mode, &init_flag,
                                      &maybe_assigned_flag) != -1;
 }
 
-
-SaveContext* DebugFrameHelper::FindSavedContextForFrame(
-    Isolate* isolate, JavaScriptFrame* frame) {
+SaveContext* DebugFrameHelper::FindSavedContextForFrame(Isolate* isolate,
+                                                        StandardFrame* frame) {
   SaveContext* save = isolate->save_context();
   while (save != NULL && !save->IsBelowFrame(frame)) {
     save = save->prev();
   }
   DCHECK(save != NULL);
   return save;
 }
 
-
-int DebugFrameHelper::FindIndexedNonNativeFrame(JavaScriptFrameIterator* it,
+int DebugFrameHelper::FindIndexedNonNativeFrame(StackTraceFrameIterator* it,
                                                 int index) {
   int count = -1;
   for (; !it->done(); it->Advance()) {
+    if (it->is_wasm()) {
+      if (++count == index) return 0;
+      continue;
+    }
     List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
-    it->frame()->Summarize(&frames);
+    it->javascript_frame()->Summarize(&frames);
     for (int i = frames.length() - 1; i >= 0; i--) {
       // Omit functions from native and extension scripts.
       if (!frames[i].function()->shared()->IsSubjectToDebugging()) continue;
       if (++count == index) return i;
     }
   }
   return -1;
 }
 
 
 }  // namespace internal
 }  // namespace v8