[wasm] Avoid double-serializing the wire bytes

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/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 421 matching lines @@
       // Install the code into the linker table.
     functions[i] = code;
   }
 }
 
 void PatchDirectCalls(Handle<FixedArray> old_functions,
                       Handle<FixedArray> new_functions, int start) {
   DCHECK_EQ(new_functions->length(), old_functions->length());
 
   DisallowHeapAllocation no_gc;
-  std::map<Code*, Code*> old_to_new_code;
+  std::map<Code*, HeapObject*> old_to_new_code;
   for (int i = 0; i < new_functions->length(); ++i) {
-    old_to_new_code.insert(std::make_pair(Code::cast(old_functions->get(i)),
-                                          Code::cast(new_functions->get(i))));
+    old_to_new_code.insert(
+        std::make_pair(Code::cast(old_functions->get(i)),
+                       HeapObject::cast(new_functions->get(i))));
   }
   int mode_mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
   AllowDeferredHandleDereference embedding_raw_address;
   for (int i = start; i < new_functions->length(); ++i) {
     Code* wasm_function = Code::cast(new_functions->get(i));
     for (RelocIterator it(wasm_function, mode_mask); !it.done(); it.next()) {
       Code* old_code =
           Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
       if (old_code->kind() == Code::WASM_TO_JS_FUNCTION ||
           old_code->kind() == Code::WASM_FUNCTION) {
         auto found = old_to_new_code.find(old_code);
         DCHECK(found != old_to_new_code.end());
-        Code* new_code = found->second;
+        HeapObject* new_code = found->second;
         if (new_code != old_code) {
-          it.rinfo()->set_target_address(new_code->instruction_start(),
-                                         UPDATE_WRITE_BARRIER,
-                                         SKIP_ICACHE_FLUSH);
+          if (new_code->IsCode()) {
+            it.rinfo()->set_target_address(
+                Code::cast(new_code)->instruction_start(), UPDATE_WRITE_BARRIER,
+                SKIP_ICACHE_FLUSH);
+          } else {
+            DCHECK(new_code->IsForeign());
+            it.rinfo()->set_target_address(
+                ExternalReference(Foreign::cast(new_code)->foreign_address(),
+                                  it.rinfo()->isolate(),
+                                  ExternalReference::BUILTIN_FP_FP_CALL)
+                    .address(),
+                UPDATE_WRITE_BARRIER, SKIP_ICACHE_FLUSH);
+          }
         }
       }
     }
   }
 }
 
 static void ResetCompiledModule(Isolate* isolate, JSObject* owner,
                                 WasmCompiledModule* compiled_module) {
   TRACE("Resetting %d\n", compiled_module->instance_id());
   Object* undefined = *isolate->factory()->undefined_value();
@@ skipping 903 matching lines @@
 
       switch (import.kind) {
         case kExternalFunction: {
           // Function imports must be callable.
           Handle<Object> function = result.ToHandleChecked();
           if (!function->IsCallable()) {
             ReportFFIError("function import requires a callable", index,
                            module_name, function_name);
             return -1;
           }
-
-          Handle<Code> import_wrapper = CompileImportWrapper(
-              index, import, Handle<JSReceiver>::cast(function), module_name,
-              function_name);
-          code_table->set(num_imported_functions, *import_wrapper);
-          RecordStats(isolate_, *import_wrapper);
+          Handle<JSReceiver> function_as_receiver =
+              Handle<JSReceiver>::cast(function);
+          Handle<String> native_variant_key =
+              isolate_->factory()->InternalizeUtf8String("native_variant");
+          MaybeHandle<Object> maybeObj =
+              JSReceiver::GetProperty(function_as_receiver, native_variant_key);
+          Handle<Object> native_variant;
+          if (maybeObj.ToHandle(&native_variant) &&
+              native_variant->IsJSObject()) {
+            Handle<Foreign> foreign(Foreign::cast(
+                JSObject::cast(*native_variant)->GetInternalField(0)));
+            code_table->set(num_imported_functions, *foreign);
+          } else {
+            Handle<Code> import_wrapper =
+                CompileImportWrapper(index, import, function_as_receiver,
+                                     module_name, function_name);
+            code_table->set(num_imported_functions, *import_wrapper);
+            RecordStats(isolate_, *import_wrapper);
+          }
           num_imported_functions++;
           break;
         }
         case kExternalTable:
           // TODO(titzer): Table imports must be a WebAssembly.Table.
           break;
         case kExternalMemory: {
           Handle<Object> object = result.ToHandleChecked();
           if (!WasmJs::IsWasmMemoryObject(isolate_, object)) {
             ReportFFIError("memory import must be a WebAssembly.Memory object",
@@ skipping 579 matching lines @@
     CHECK_NOT_NULL(result.val);
     module = const_cast<WasmModule*>(result.val);
   }
 
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, module);
 
   compiled_module->set_module_wrapper(module_wrapper);
   DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));
 }