[wasm] Fix importing wasm functions which are being debugged

src/wasm/wasm-module.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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 856 matching lines @@
   int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
   Handle<Code> code;
   for (RelocIterator it(*export_wrapper_code, mask); !it.done(); it.next()) {
     RelocInfo* rinfo = it.rinfo();
     Address target_address = rinfo->target_address();
     Code* target = Code::GetCodeFromTargetAddress(target_address);
     if (target->kind() == Code::WASM_FUNCTION ||
         target->kind() == Code::WASM_TO_JS_FUNCTION) {
       ++found;
       code = handle(target);
+    } else if (target->kind() == Code::WASM_INTERPRETER_ENTRY) {
+      // Don't call the interpreter entry directly, otherwise we cannot disable
+      // the breakpoint later by patching the exported code.
+      return Handle<Code>::null();
     }
   }
   DCHECK_EQ(1, found);
   return code;
 }
 
 static Handle<Code> CompileImportWrapper(Isolate* isolate, int index,
                                          FunctionSig* sig,
                                          Handle<JSReceiver> target,
                                          Handle<String> module_name,
                                          MaybeHandle<String> import_name,
                                          ModuleOrigin origin) {
   WasmFunction* other_func = GetWasmFunctionForImportWrapper(isolate, target);
   if (other_func) {
-    if (sig->Equals(other_func->sig)) {
-      // Signature matched. Unwrap the JS->WASM wrapper and return the raw
-      // WASM function code.
-      return UnwrapImportWrapper(target);
-    } else {
-      return Handle<Code>::null();
-    }
-  } else {
-    // Signature mismatch. Compile a new wrapper for the new signature.
-    return compiler::CompileWasmToJSWrapper(isolate, target, sig, index,
-                                            module_name, import_name, origin);
+    if (!sig->Equals(other_func->sig)) return Handle<Code>::null();
+    // Signature matched. Unwrap the JS->WASM wrapper and return the raw
+    // WASM function code.
+    Handle<Code> code = UnwrapImportWrapper(target);
+    // If we got no code (imported function is being debugged), fall through
+    // to CompileWasmToJSWrapper.
+    if (!code.is_null()) return code;
   }
+  // No wasm function or being debugged. Compile a new wrapper for the new
+  // signature.
+  return compiler::CompileWasmToJSWrapper(isolate, target, sig, index,
+                                          module_name, import_name, origin);
 }
 
 static void UpdateDispatchTablesInternal(Isolate* isolate,
                                          Handle<FixedArray> dispatch_tables,
                                          int index, WasmFunction* function,
                                          Handle<Code> code) {
   DCHECK_EQ(0, dispatch_tables->length() % 4);
   for (int i = 0; i < dispatch_tables->length(); i += 4) {
     int table_index = Smi::cast(dispatch_tables->get(i + 1))->value();
     Handle<FixedArray> function_table(
@@ skipping 1797 matching lines @@
   Handle<String> module_property_name =
       isolate->factory()->InternalizeUtf8String("module");
   Handle<String> instance_property_name =
       isolate->factory()->InternalizeUtf8String("instance");
   JSObject::AddProperty(ret, module_property_name, module, NONE);
   JSObject::AddProperty(ret, instance_property_name,
                         instance_object.ToHandleChecked(), NONE);
 
   ResolvePromise(isolate, promise, ret);
 }