Implement debug(function) helper for Wasm functions

Re-use set breakpoint logic for wasm script to set breakpoint to first
breakable position of given wasm function.

Bug: v8:9724
Change-Id: Ibd6b59d5b93c6895f71f0114291bf78db03aee0b
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2001564
Commit-Queue: Z Nguyen-Huu <duongn@microsoft.com>
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65827}

src/debug/debug.cc

@@ -751,6 +751,16 @@ bool Debug::SetBreakpointForFunction(Handle<SharedFunctionInfo> shared,
   Handle<BreakPoint> breakpoint =
       isolate_->factory()->NewBreakPoint(*id, condition);
   int source_position = 0;
+  // Handle wasm function.
+  if (shared->HasWasmExportedFunctionData()) {
+    int func_index = shared->wasm_exported_function_data().function_index();
+    Handle<WasmInstanceObject> wasm_instance(
+        shared->wasm_exported_function_data().instance(), isolate_);
+    Handle<Script> script(Script::cast(wasm_instance->module_object().script()),
+                          isolate_);
+    return WasmScript::SetBreakPointOnFirstBreakableForFunction(
+        script, func_index, breakpoint);
+  }
   return SetBreakpoint(shared, breakpoint, &source_position);
 }
 

src/wasm/wasm-debug.cc

@@ -894,8 +894,6 @@ int FindNextBreakablePosition(wasm::NativeModule* native_module, int func_index,
 // static
 bool WasmScript::SetBreakPoint(Handle<Script> script, int* position,
                                Handle<BreakPoint> break_point) {
-  Isolate* isolate = script->GetIsolate();
-
   // Find the function for this breakpoint.
   const wasm::WasmModule* module = script->wasm_native_module()->module();
   int func_index = GetContainingWasmFunction(module, *position);
@@ -908,8 +906,39 @@ bool WasmScript::SetBreakPoint(Handle<Script> script, int* position,
   if (breakable_offset == 0) return false;
   *position = func.code.offset() + breakable_offset;
 
+  return WasmScript::SetBreakPointForFunction(script, func_index,
+                                              breakable_offset, break_point);
+}
+
+// static
+bool WasmScript::SetBreakPointOnFirstBreakableForFunction(
+    Handle<Script> script, int func_index, Handle<BreakPoint> break_point) {
+  if (func_index < 0) return false;
+  int offset_in_func = 0;
+
+  int breakable_offset = FindNextBreakablePosition(script->wasm_native_module(),
+                                                   func_index, offset_in_func);
+  if (breakable_offset == 0) return false;
+  return WasmScript::SetBreakPointForFunction(script, func_index,
+                                              breakable_offset, break_point);
+}
+
+// static
+bool WasmScript::SetBreakPointForFunction(Handle<Script> script, int func_index,
+                                          int breakable_offset,
+                                          Handle<BreakPoint> break_point) {
+  Isolate* isolate = script->GetIsolate();
+
+  DCHECK_LE(0, func_index);
+  DCHECK_NE(0, breakable_offset);
+
+  // Find the function for this breakpoint.
+  const wasm::WasmModule* module = script->wasm_native_module()->module();
+  const wasm::WasmFunction& func = module->functions[func_index];
+
   // Insert new break point into break_positions of module object.
-  WasmScript::AddBreakpointToInfo(script, *position, break_point);
+  WasmScript::AddBreakpointToInfo(script, func.code.offset() + breakable_offset,
+                                  break_point);
 
   // Iterate over all instances and tell them to set this new breakpoint.
   // We do this using the weak list of all instances from the script.

src/wasm/wasm-objects.h

@@ -905,6 +905,19 @@ class WasmScript : public AllStatic {
   V8_EXPORT_PRIVATE static bool SetBreakPoint(Handle<Script>, int* position,
                                               Handle<BreakPoint> break_point);
 
+  // Set a breakpoint on first breakable position of the given function index
+  // inside the given module. This will affect all live and future instances of
+  // the module.
+  V8_EXPORT_PRIVATE static bool SetBreakPointOnFirstBreakableForFunction(
+      Handle<Script>, int function_index, Handle<BreakPoint> break_point);
+
+  // Set a breakpoint at the breakable offset of the given function index
+  // inside the given module. This will affect all live and future instances of
+  // the module.
+  V8_EXPORT_PRIVATE static bool SetBreakPointForFunction(
+      Handle<Script>, int function_index, int breakable_offset,
+      Handle<BreakPoint> break_point);
+
   // Remove a previously set breakpoint at the given byte position inside the
   // given module. If this breakpoint is not found this function returns false.
   V8_EXPORT_PRIVATE static bool ClearBreakPoint(Handle<Script>, int position,

test/inspector/debugger/wasm-debug-command-expected.txt

+Tests debug command for wasm
+Installing code and global variable.
+Calling instantiate function.
+Waiting for wasm scripts to be parsed.
+Ignoring script with url v8://test/callInstantiate
+Got wasm script: wasm://wasm/fa045c1e
+paused No 1
+Script wasm://wasm/fa045c1e byte offset 35: Wasm opcode 0x20
+Debugger.resume
+exports.main returned!
+Finished!

test/inspector/debugger/wasm-debug-command.js

+// Copyright 2020 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.
+
+let {session, contextGroup, Protocol} = InspectorTest.start('Tests debug command for wasm');
+session.setupScriptMap();
+
+utils.load('test/mjsunit/wasm/wasm-module-builder.js');
+
+let builder = new WasmModuleBuilder();
+
+// wasm_A
+builder.addFunction('wasm_A', kSig_i_i)
+    .addBody([
+      // clang-format off
+      kExprLocalGet, 0,              // Line 1: get input
+      kExprI32Const, 1,              // Line 2: get constant 1
+      kExprI32Sub                    // Line 3: decrease
+      // clang-format on
+    ])
+    .exportAs('main');
+
+let module_bytes = builder.toArray();
+
+function instantiate(bytes) {
+  let buffer = new ArrayBuffer(bytes.length);
+  let view = new Uint8Array(buffer);
+  for (let i = 0; i < bytes.length; ++i) {
+    view[i] = bytes[i] | 0;
+  }
+
+  let module = new WebAssembly.Module(buffer);
+  // Set global variable.
+  instance = new WebAssembly.Instance(module);
+}
+
+let evalWithUrl = (code, url) => Protocol.Runtime.evaluate(
+    {'expression': code + '\n//# sourceURL=v8://test/' + url});
+
+let breakCount;
+
+Protocol.Debugger.onPaused(async message => {
+  breakCount++;
+  InspectorTest.log("paused No " + breakCount);
+  var frames = message.params.callFrames;
+  await session.logSourceLocation(frames[0].location);
+  let action= 'resume';
+  InspectorTest.log('Debugger.' + action)
+  await Protocol.Debugger[action]();
+})
+
+let breakpointId;
+
+contextGroup.addScript(`
+function test() {
+  debug(instance.exports.main);
+  instance.exports.main(3, 2);
+}
+//# sourceURL=test.js`);
+
+(async function Test() {
+  breakCount = 0;
+  breakpointId = 0;
+  await Protocol.Debugger.enable();
+  InspectorTest.log('Installing code and global variable.');
+  await evalWithUrl('var instance;\n' + instantiate.toString(), 'setup');
+  InspectorTest.log('Calling instantiate function.');
+  evalWithUrl(
+      'instantiate(' + JSON.stringify(module_bytes) + ')', 'callInstantiate');
+  const scriptId = await waitForWasmScript();
+  await Protocol.Runtime.evaluate({ expression: 'test()', includeCommandLineAPI: true});
+  InspectorTest.log('exports.main returned!');
+  InspectorTest.log('Finished!');
+  InspectorTest.completeTest();
+})();
+
+function printFailure(message) {
+  if (!message.result) {
+    InspectorTest.logMessage(message);
+  }
+  return message;
+}
+
+async function waitForWasmScript() {
+  InspectorTest.log('Waiting for wasm scripts to be parsed.');
+  while (true) {
+    let msg = await Protocol.Debugger.onceScriptParsed();
+    let url = msg.params.url;
+    if (!url.startsWith('wasm://')) {
+      InspectorTest.log('Ignoring script with url ' + url);
+      continue;
+    }
+    let scriptId = msg.params.scriptId;
+    InspectorTest.log('Got wasm script: ' + url);
+    return scriptId;
+  }
+}