[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 437 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;
 
       {
         // 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(),
@@ skipping 927 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