[wasm] Move {WasmModuleObject::GetFunctionOffset}.

This introduces {GetWasmFunctionOffset} to replace the above method,
since calculating offsets into the wire bytes is independent of the
concrete module object and hence only needs the shared decoded module.

R=clemensh@chromium.org
BUG=v8:6847

Change-Id: I6818de4589e26dd8f69dfb71d15bbca127c7ee3e
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1809368Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Commit-Queue: Michael Starzinger <mstarzinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#63862}

src/api/api.cc

@@ -9237,8 +9237,9 @@ int debug::Script::GetSourceOffset(const debug::Location& location) const {
   i::Handle<i::Script> script = Utils::OpenHandle(this);
   if (script->type() == i::Script::TYPE_WASM) {
     if (this->SourceMappingURL().IsEmpty()) {
-      return i::WasmModuleObject::cast(script->wasm_module_object())
-                 .GetFunctionOffset(location.GetLineNumber()) +
+      i::wasm::NativeModule* native_module = script->wasm_native_module();
+      const i::wasm::WasmModule* module = native_module->module();
+      return i::wasm::GetWasmFunctionOffset(module, location.GetLineNumber()) +
              location.GetColumnNumber();
     }
     DCHECK_EQ(0, location.GetLineNumber());

src/execution/messages.cc

@@ -603,7 +603,7 @@ int WasmStackFrame::GetColumnNumber() { return GetModuleOffset(); }
 
 int WasmStackFrame::GetModuleOffset() const {
   const int function_offset =
-      wasm_instance_->module_object().GetFunctionOffset(wasm_func_index_);
+      GetWasmFunctionOffset(wasm_instance_->module(), wasm_func_index_);
   return function_offset + GetPosition();
 }
 

src/runtime/runtime-debug.cc

@@ -491,8 +491,7 @@ int ScriptLinePosition(Handle<Script> script, int line) {
   if (line < 0) return -1;
 
   if (script->type() == Script::TYPE_WASM) {
-    return WasmModuleObject::cast(script->wasm_module_object())
-        .GetFunctionOffset(line);
+    return GetWasmFunctionOffset(script->wasm_native_module()->module(), line);
   }
 
   Script::InitLineEnds(script);

src/wasm/wasm-debug.cc

@@ -318,7 +318,8 @@ class InterpreterHandle {
     DCHECK_LT(0, thread->GetFrameCount());
 
     auto frame = thread->GetFrame(thread->GetFrameCount() - 1);
-    return module_object->GetFunctionOffset(frame->function()->func_index) +
+    return GetWasmFunctionOffset(module_object->module(),
+                                 frame->function()->func_index) +
            frame->pc();
   }
 

src/wasm/wasm-module.cc

@@ -59,6 +59,14 @@ int GetExportWrapperIndex(const WasmModule* module, const FunctionSig* sig,
   return result;
 }
 
+// static
+int GetWasmFunctionOffset(const WasmModule* module, uint32_t func_index) {
+  const std::vector<WasmFunction>& functions = module->functions;
+  if (static_cast<uint32_t>(func_index) >= functions.size()) return -1;
+  DCHECK_GE(kMaxInt, functions[func_index].code.offset());
+  return static_cast<int>(functions[func_index].code.offset());
+}
+
 // static
 v8::debug::WasmDisassembly DisassembleWasmFunction(
     const WasmModule* module, const ModuleWireBytes& wire_bytes,

src/wasm/wasm-module.h

@@ -245,6 +245,11 @@ V8_EXPORT_PRIVATE int MaxNumExportWrappers(const WasmModule* module);
 int GetExportWrapperIndex(const WasmModule* module, const FunctionSig* sig,
                           bool is_import);
 
+// Return the byte offset of the function identified by the given index.
+// The offset will be relative to the start of the module bytes.
+// Returns -1 if the function index is invalid.
+int GetWasmFunctionOffset(const WasmModule* module, uint32_t func_index);
+
 // Compute the disassembly of a wasm function.
 // Returns the disassembly string and a list of <byte_offset, line, column>
 // entries, mapping wasm byte offsets to line and column in the disassembly.

src/wasm/wasm-objects.cc

@@ -496,7 +496,7 @@ int WasmModuleObject::GetSourcePosition(Handle<WasmModuleObject> module_object,
   if (module->origin == wasm::kWasmOrigin) {
     // for non-asm.js modules, we just add the function's start offset
     // to make a module-relative position.
-    return byte_offset + module_object->GetFunctionOffset(func_index);
+    return byte_offset + GetWasmFunctionOffset(module, func_index);
   }
 
   // asm.js modules have an additional offset table that must be searched.
@@ -689,13 +689,6 @@ Vector<const uint8_t> WasmModuleObject::GetRawFunctionName(
   return Vector<const uint8_t>::cast(name);
 }
 
-int WasmModuleObject::GetFunctionOffset(uint32_t func_index) {
-  const std::vector<WasmFunction>& functions = module()->functions;
-  if (static_cast<uint32_t>(func_index) >= functions.size()) return -1;
-  DCHECK_GE(kMaxInt, functions[func_index].code.offset());
-  return static_cast<int>(functions[func_index].code.offset());
-}
-
 int WasmModuleObject::GetContainingFunction(uint32_t byte_offset) {
   const std::vector<WasmFunction>& functions = module()->functions;
 

src/wasm/wasm-objects.h

@@ -198,11 +198,6 @@ class WasmModuleObject : public JSObject {
   // Does not allocate, hence gc-safe.
   Vector<const uint8_t> GetRawFunctionName(uint32_t func_index);
 
-  // Return the byte offset of the function identified by the given index.
-  // The offset will be relative to the start of the module bytes.
-  // Returns -1 if the function index is invalid.
-  int GetFunctionOffset(uint32_t func_index);
-
   // Returns the function containing the given byte offset.
   // Returns -1 if the byte offset is not contained in any function of this
   // module.