[wasm] Allow import function to be any kind of callables.

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/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
@@ skipping 451 matching lines @@
                   function_name_handle->length(),
                   function_name_handle->ToCString().get(), error);
   } else {
     thrower.Error("Import #%d module=\"%.*s\" error: %s", index,
                   module_name->length(), module_name->ToCString().get(), error);
   }
   thrower.Error("Import ");
   return MaybeHandle<JSFunction>();
 }
 
-static MaybeHandle<JSFunction> LookupFunction(
+static MaybeHandle<JSReceiver> LookupFunction(
     ErrorThrower& thrower, Factory* factory, Handle<JSReceiver> ffi,
     uint32_t index, Handle<String> module_name,
     MaybeHandle<String> function_name) {
   if (ffi.is_null()) {
     return ReportFFIError(thrower, "FFI is not an object", index, module_name,
                           function_name);
   }
 
   // Look up the module first.
   MaybeHandle<Object> result = Object::GetProperty(ffi, module_name);
@@ skipping 17 matching lines @@
     if (result.is_null()) {
       return ReportFFIError(thrower, "function not found", index, module_name,
                             function_name);
     }
     function = result.ToHandleChecked();
   } else {
     // No function specified. Use the "default export".
     function = module;
   }
 
-  if (!function->IsJSFunction()) {
-    return ReportFFIError(thrower, "not a function", index, module_name,
+  if (!function->IsCallable()) {
+    return ReportFFIError(thrower, "not a callable", index, module_name,
                           function_name);
   }
 
-  return Handle<JSFunction>::cast(function);
+  return Handle<JSReceiver>::cast(function);
 }
 
 namespace {
 // Fetches the compilation unit of a wasm function and executes its parallel
 // phase.
 bool FetchAndExecuteCompilationUnit(
     Isolate* isolate,
     std::vector<compiler::WasmCompilationUnit*>* compilation_units,
     std::queue<compiler::WasmCompilationUnit*>* executed_units,
     base::Mutex* result_mutex, base::AtomicNumber<size_t>* next_unit) {
@@ skipping 126 matching lines @@
       // TODO(mtrofin): this is an uint32_t, actually. We should rationalize
       // it when we rationalize signed/unsigned stuff.
       int ret_count = Smi::cast(data->get(kOutputCount))->value();
       CHECK(ret_count >= 0);
       Handle<ByteArray> sig_data =
           data->GetValueChecked<ByteArray>(isolate, kSignature);
       int sig_data_size = sig_data->length();
       int param_count = sig_data_size - ret_count;
       CHECK(param_count >= 0);
 
-      MaybeHandle<JSFunction> function = LookupFunction(
+      MaybeHandle<JSReceiver> function = LookupFunction(
           *thrower, isolate->factory(), ffi, index, module_name, function_name);
       if (function.is_null()) return false;
       Handle<Code> code;
-      Handle<JSFunction> func = function.ToHandleChecked();
-      Handle<Code> export_wrapper_code = handle(func->code());
+      Handle<JSReceiver> target = function.ToHandleChecked();
       bool isMatch = false;
-      if (export_wrapper_code->kind() == Code::JS_TO_WASM_FUNCTION) {
-        int exported_param_count =
-            Smi::cast(func->GetInternalField(kInternalArity))->value();
-        Handle<ByteArray> exportedSig = Handle<ByteArray>(
-            ByteArray::cast(func->GetInternalField(kInternalSignature)));
-        if (exported_param_count == param_count &&
-            exportedSig->length() == sig_data->length() &&
-            memcmp(exportedSig->data(), sig_data->data(),
-                   exportedSig->length()) == 0) {
-          isMatch = true;
+      Handle<Code> export_wrapper_code;
+      if (target->IsJSFunction()) {
+        Handle<JSFunction> func = Handle<JSFunction>::cast(target);
+        export_wrapper_code = handle(func->code());
+        if (export_wrapper_code->kind() == Code::JS_TO_WASM_FUNCTION) {
+          int exported_param_count =
+              Smi::cast(func->GetInternalField(kInternalArity))->value();
+          Handle<ByteArray> exportedSig = Handle<ByteArray>(
+              ByteArray::cast(func->GetInternalField(kInternalSignature)));
+          if (exported_param_count == param_count &&
+              exportedSig->length() == sig_data->length() &&
+              memcmp(exportedSig->data(), sig_data->data(),
+                     exportedSig->length()) == 0) {
+            isMatch = true;
+          }
         }
       }
       if (isMatch) {
         int wasm_count = 0;
         int const mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
         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) {
             ++wasm_count;
             code = handle(target);
           }
         }
         DCHECK(wasm_count == 1);
       } else {
         // Copy the signature to avoid a raw pointer into a heap object when
         // GC can happen.
         Zone zone(isolate->allocator());
         MachineRepresentation* reps =
             zone.NewArray<MachineRepresentation>(sig_data_size);
         memcpy(reps, sig_data->data(),
                sizeof(MachineRepresentation) * sig_data_size);
         FunctionSig sig(ret_count, param_count, reps);
 
-        code = compiler::CompileWasmToJSWrapper(isolate, func, &sig, index,
+        code = compiler::CompileWasmToJSWrapper(isolate, target, &sig, index,
                                                 module_name, function_name);
       }
       imports.push_back(code);
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
@@ skipping 924 matching lines @@
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8