[wasm] Enable wasm frame inspection for debugging

src/debug/debug.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/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/global-handles.h"
 #include "src/interpreter/interpreter.h"
 #include "src/isolate-inl.h"
 #include "src/list.h"
 #include "src/log.h"
 #include "src/messages.h"
 #include "src/snapshot/natives.h"
+#include "src/wasm/wasm-debug.h"
+#include "src/wasm/wasm-module.h"
 
 #include "include/v8-debug.h"
 
 namespace v8 {
 namespace internal {
 
+namespace {
+
+int GetCodeOffset(StandardFrame* frame) {
+  if (frame->is_java_script()) {
+    return FrameSummary::GetFirst(JavaScriptFrame::cast(frame)).code_offset();

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

Is it not feasible to extend FrameSummary for wasm frames?

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

FrameSummary is very JS-specific, and it's only purpose is to encapsulate the
information for a frame with inlined functions.
It seemed inappropriate to try to put wasm information in there (I also
discussed this with Ben several weeks ago).

+  }
+  DCHECK(frame->is_wasm());
+  return static_cast<int>(frame->pc() -
+                          frame->unchecked_code()->instruction_start());
+}
+
+inline int CallOffsetFromCodeOffset(int code_offset, bool is_interpreted) {
+  // Code offset points to the instruction after the call. Subtract 1 to
+  // exclude that instruction from the search. For bytecode, the code offset
+  // still points to the call.
+  return is_interpreted ? code_offset : code_offset - 1;
+}
+
+}  // namespace
+
 Debug::Debug(Isolate* isolate)
     : debug_context_(Handle<Context>()),
       event_listener_(Handle<Object>()),
       event_listener_data_(Handle<Object>()),
       message_handler_(NULL),
       command_received_(0),
       command_queue_(isolate->logger(), kQueueInitialSize),
       is_active_(false),
       is_suppressed_(false),
       live_edit_enabled_(true),  // TODO(yangguo): set to false by default.
@@ skipping 212 matching lines @@
 
 // Find the break point at the supplied address, or the closest one before
 // the address.
 BreakLocation BreakLocation::FromCodeOffset(Handle<DebugInfo> debug_info,
                                             int offset) {
   base::SmartPointer<Iterator> it(GetIterator(debug_info));
   it->SkipTo(BreakIndexFromCodeOffset(debug_info, offset));
   return it->GetBreakLocation();
 }
 
-int CallOffsetFromCodeOffset(int code_offset, bool is_interpreted) {
-  // Code offset points to the instruction after the call. Subtract 1 to
-  // exclude that instruction from the search. For bytecode, the code offset
-  // still points to the call.
-  return is_interpreted ? code_offset : code_offset - 1;
-}
-
 BreakLocation BreakLocation::FromFrame(Handle<DebugInfo> debug_info,
-                                       JavaScriptFrame* frame) {
-  FrameSummary summary = FrameSummary::GetFirst(frame);
+                                       StandardFrame* frame) {
+  int code_offset = GetCodeOffset(frame);
   int call_offset =
-      CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());
+      CallOffsetFromCodeOffset(code_offset, frame->is_interpreted());
   return FromCodeOffset(debug_info, call_offset);
 }
 
 void BreakLocation::AllForStatementPosition(Handle<DebugInfo> debug_info,
                                             int statement_position,
                                             List<BreakLocation>* result_out) {
   for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !it->Done();
        it->Next()) {
     if (it->statement_position() == statement_position) {
       result_out->Add(it->GetBreakLocation());
@@ skipping 501 matching lines @@
 
   // At least one active break point now.
   return debug_info->GetBreakPointCount() > 0;
 }
 
 
 bool Debug::SetBreakPointForScript(Handle<Script> script,
                                    Handle<Object> break_point_object,
                                    int* source_position,
                                    BreakPositionAlignment alignment) {
+  if (script->type() == Script::TYPE_WASM) {
+    // TODO(clemensh): set breakpoint for wasm.
+  }
   HandleScope scope(isolate_);
 
   // Obtain shared function info for the function.
   Handle<Object> result =
       FindSharedFunctionInfoInScript(script, *source_position);
   if (result->IsUndefined(isolate_)) return false;
 
   // Make sure the function has set up the debug info.
   Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>::cast(result);
   if (!EnsureDebugInfo(shared, Handle<JSFunction>::null())) {
@@ skipping 788 matching lines @@
 }
 
 void Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
   after_break_target_ = NULL;
   if (!LiveEdit::SetAfterBreakTarget(this)) {
     // Continue just after the slot.
     after_break_target_ = frame->pc();
   }
 }
 
-
-bool Debug::IsBreakAtReturn(JavaScriptFrame* frame) {
+bool Debug::IsBreakAtReturn(StandardFrame* frame) {
   HandleScope scope(isolate_);
 
+  if (frame->is_wasm()) {
+    // TODO(clemensh): find out what we want to do for wasm
+    return false;
+  }
+
+  JavaScriptFrame* js_frame = JavaScriptFrame::cast(frame);
   // Get the executing function in which the debug break occurred.
-  Handle<JSFunction> function(JSFunction::cast(frame->function()));
-  Handle<SharedFunctionInfo> shared(function->shared());
+  Handle<SharedFunctionInfo> shared(js_frame->function()->shared());
 
   // With no debug info there are no break points, so we can't be at a return.
   if (!shared->HasDebugInfo()) return false;
 
   DCHECK(!frame->is_optimized());
-  FrameSummary summary = FrameSummary::GetFirst(frame);
-
+  int code_offset = GetCodeOffset(frame);

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

At this point the frame is already known to be a javascript frame, right?

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

Right, but calling the function we already have seemed clearer to me than to
duplicate code here.
I could extract a GetJavaScriptCodeOffset function, and use it here and from
GetCodeOffset. Would you prefer that?

   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   BreakLocation location =
-      BreakLocation::FromCodeOffset(debug_info, summary.code_offset());
+      BreakLocation::FromCodeOffset(debug_info, code_offset);
   return location.IsReturn() || location.IsTailCall();
 }
 
 
 void Debug::FramesHaveBeenDropped(StackFrame::Id new_break_frame_id,
                                   LiveEdit::FrameDropMode mode) {
   if (mode != LiveEdit::CURRENTLY_SET_MODE) {
     thread_local_.frame_drop_mode_ = mode;
   }
   thread_local_.break_frame_id_ = new_break_frame_id;
@@ skipping 667 matching lines @@
   base::NoBarrier_Store(&debug_->thread_local_.current_debug_scope_,
                         reinterpret_cast<base::AtomicWord>(this));
 
   // Store the previous break id, frame id and return value.
   break_id_ = debug_->break_id();
   break_frame_id_ = debug_->break_frame_id();
   return_value_ = debug_->return_value();
 
   // Create the new break info. If there is no JavaScript frames there is no
   // break frame id.
-  JavaScriptFrameIterator it(isolate());
-  bool has_js_frames = !it.done();
-  debug_->thread_local_.break_frame_id_ = has_js_frames ? it.frame()->id()
-                                                        : StackFrame::NO_ID;
+  StackTraceFrameIterator it(isolate());
+  bool has_frames = !it.done();
+  debug_->thread_local_.break_frame_id_ =
+      has_frames ? it.frame()->id() : StackFrame::NO_ID;
   debug_->SetNextBreakId();
 
   debug_->UpdateState();
   // Make sure that debugger is loaded and enter the debugger context.
   // The previous context is kept in save_.
   failed_ = !debug_->is_loaded();
   if (!failed_) isolate()->set_context(*debug->debug_context());
 }
 
 
@@ skipping 274 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8