[wasm] Also unwrap exported debugged functions

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 851 matching lines @@
   return nullptr;
 }
 
 static Handle<Code> UnwrapImportWrapper(Handle<Object> import_wrapper) {
   Handle<JSFunction> func = Handle<JSFunction>::cast(import_wrapper);
   Handle<Code> export_wrapper_code = handle(func->code());
   int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
   for (RelocIterator it(*export_wrapper_code, mask);; it.next()) {
     DCHECK(!it.done());
     Code* target = Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
-    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();
-    }
     if (target->kind() != Code::WASM_FUNCTION &&
-        target->kind() != Code::WASM_TO_JS_FUNCTION)
+        target->kind() != Code::WASM_TO_JS_FUNCTION &&
+        target->kind() != Code::WASM_INTERPRETER_ENTRY)
       continue;
 // There should only be this one call to wasm code.
 #ifdef DEBUG
     for (it.next(); !it.done(); it.next()) {
       Code* code = Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
       DCHECK(code->kind() != Code::WASM_FUNCTION &&
-             code->kind() != Code::WASM_TO_JS_FUNCTION);
+             code->kind() != Code::WASM_TO_JS_FUNCTION &&
+             code->kind() != Code::WASM_INTERPRETER_ENTRY);
     }
 #endif
     return handle(target);
   }
   UNREACHABLE();
   return Handle<Code>::null();
 }
 
 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)) 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;
+    return UnwrapImportWrapper(target);
   }
   // 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);
 }
 
 void UpdateDispatchTablesInternal(Isolate* isolate,
                                   Handle<FixedArray> dispatch_tables, int index,
                                   WasmFunction* function, Handle<Code> code) {
@@ skipping 1805 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);
 }