[wasm] Get rid of extra wrappers when import another wasm export

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"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-debug.h"
 #include "src/wasm/wasm-function-name-table.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-result.h"
 
 #include "src/compiler/wasm-compiler.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
+enum JSFunctionExportInternalField {

[Mircea Trofin, 2016/08/03 22:52:16]

You could move this in the anonymous namespace below.

+  kInternalModuleInstance,
+  kInternalArity,
+  kInternalSignature
+};
+
 static const int kPlaceholderMarker = 1000000000;
 
 static const char* wasmSections[] = {
 #define F(enumerator, order, string) string,
     FOR_EACH_WASM_SECTION_TYPE(F)
 #undef F
         "<unknown>"  // entry for "Max"
 };
 
 static uint8_t wasmSectionsLengths[]{
@@ skipping 71 matching lines @@
       os << "+" << pair.function_->func_index;
     }
   } else {
     os << "?";
   }
   return os;
 }
 
 Handle<JSFunction> WrapExportCodeAsJSFunction(
     Isolate* isolate, Handle<Code> export_code, Handle<String> name, int arity,
-    Handle<JSObject> module_instance) {
+    MaybeHandle<ByteArray> maybe_signature, Handle<JSObject> module_instance) {
   Handle<SharedFunctionInfo> shared =
       isolate->factory()->NewSharedFunctionInfo(name, export_code, false);
   shared->set_length(arity);
   shared->set_internal_formal_parameter_count(arity);
   Handle<JSFunction> function = isolate->factory()->NewFunction(
       isolate->wasm_function_map(), name, export_code);
   function->set_shared(*shared);
 
-  function->SetInternalField(0, *module_instance);
+  function->SetInternalField(kInternalModuleInstance, *module_instance);
+  // add another Internal Field as the function arity
+  function->SetInternalField(kInternalArity, Smi::FromInt(arity));
+  // add another Internal Field as the signature of the foreign function
+  Handle<ByteArray> signature;
+  if (maybe_signature.ToHandle(&signature)) {
+    function->SetInternalField(kInternalSignature, *signature);
+  }
   return function;
 }
 
 namespace {
 // Internal constants for the layout of the module object.
 const int kWasmModuleFunctionTable = 0;
 const int kWasmModuleCodeTable = 1;
 const int kWasmMemArrayBuffer = 2;
 const int kWasmGlobalsArrayBuffer = 3;
 // TODO(clemensh): Remove function name array, extract names from module bytes.
@@ skipping 37 matching lines @@
   kOutputCount,             // Smi. an uint32_t
   kSignature,               // ByteArray. A copy of the data in FunctionSig
   kWasmImportDataTableSize  // Sentinel value.
 };
 
 enum WasmExportMetadata {
   kExportCode,                  // Code
   kExportName,                  // String
   kExportArity,                 // Smi, an int
   kExportedFunctionIndex,       // Smi, an uint32_t
+  kExportedSignature,           // ByteArray. A copy of the data in FunctionSig
   kWasmExportMetadataTableSize  // Sentinel value.
 };
 
 enum WasmSegmentInfo {
   kDestAddr,            // Smi. an uint32_t
   kSourceSize,          // Smi. an uint32_t
   kWasmSegmentInfoSize  // Sentinel value.
 };
 
 enum WasmIndirectFunctionTableMetadata {
@@ skipping 445 matching lines @@
       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(
           *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());
+      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;
+        }
+      }
+      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);
 
-        Handle<Code> code = compiler::CompileWasmToJSWrapper(
-            isolate, function.ToHandleChecked(), &sig, index, module_name,
-            function_name);
-
-        imports.push_back(code);
+        code = compiler::CompileWasmToJSWrapper(isolate, func, &sig, index,
+                                                module_name, function_name);
       }
+      imports.push_back(code);
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); ++i) {
@@ skipping 284 matching lines @@
       for (int i = 0; i < exports_size; ++i) {
         if (thrower->error()) return false;
         Handle<FixedArray> export_metadata =
             exports->GetValueChecked<FixedArray>(isolate, i);
         Handle<Code> export_code =
             export_metadata->GetValueChecked<Code>(isolate, kExportCode);
         RecordStats(isolate, *export_code);
         Handle<String> name =
             export_metadata->GetValueChecked<String>(isolate, kExportName);
         int arity = Smi::cast(export_metadata->get(kExportArity))->value();
+        MaybeHandle<ByteArray> signature =
+            export_metadata->GetValue<ByteArray>(isolate, kExportedSignature);
         Handle<JSFunction> function = WrapExportCodeAsJSFunction(
-            isolate, export_code, name, arity, instance);
+            isolate, export_code, name, arity, signature, instance);
         desc.set_value(function);
         Maybe<bool> status = JSReceiver::DefineOwnProperty(
             isolate, exports_object, name, &desc, Object::THROW_ON_ERROR);
         if (!status.IsJust()) {
           thrower->Error("export of %.*s failed.", name->length(),
                          name->ToCString().get());
           return false;
         }
       }
     }
@@ skipping 89 matching lines @@
 
   // Compile export functions.
   int export_size = static_cast<int>(export_table.size());
   Handle<Code> startup_fct;
   if (export_size > 0) {
     Handle<FixedArray> exports = factory->NewFixedArray(export_size, TENURED);
     for (int i = 0; i < export_size; ++i) {
       Handle<FixedArray> export_metadata =
           factory->NewFixedArray(kWasmExportMetadataTableSize, TENURED);
       const WasmExport& exp = export_table[i];
+      FunctionSig* funcSig = functions[exp.func_index].sig;
+      Handle<ByteArray> exportedSig =
+          factory->NewByteArray(static_cast<int>(funcSig->parameter_count() +
+                                                 funcSig->return_count()),
+                                TENURED);
+      exportedSig->copy_in(0,
+                           reinterpret_cast<const byte*>(funcSig->raw_data()),
+                           exportedSig->length());
+      export_metadata->set(kExportedSignature, *exportedSig);
       WasmName str = GetName(exp.name_offset, exp.name_length);
       Handle<String> name = factory->InternalizeUtf8String(str);
       Handle<Code> code =
           temp_instance_for_compilation.function_code[exp.func_index];
       Handle<Code> export_code = compiler::CompileJSToWasmWrapper(
           isolate, &module_env, code, exp.func_index);
       if (thrower->error()) return nothing;
       export_metadata->set(kExportCode, *export_code);
       export_metadata->set(kExportName, *name);
       export_metadata->set(
@@ skipping 243 matching lines @@
 
   // Run the start function if one was specified.
   MaybeHandle<FixedArray> maybe_startup_fct =
       compiled_module->GetValue<FixedArray>(isolate, kStartupFunction);
   Handle<FixedArray> metadata;
   if (maybe_startup_fct.ToHandle(&metadata)) {
     HandleScope scope(isolate);
     Handle<Code> startup_code =
         metadata->GetValueChecked<Code>(isolate, kExportCode);
     int arity = Smi::cast(metadata->get(kExportArity))->value();
+    MaybeHandle<ByteArray> startup_signature =
+        metadata->GetValue<ByteArray>(isolate, kExportedSignature);
     Handle<JSFunction> startup_fct = WrapExportCodeAsJSFunction(
         isolate, startup_code, factory->InternalizeUtf8String("start"), arity,
-        js_object);
+        startup_signature, js_object);
     RecordStats(isolate, *startup_code);
     // Call the JS function.
     Handle<Object> undefined = isolate->factory()->undefined_value();
     MaybeHandle<Object> retval =
         Execution::Call(isolate, startup_fct, undefined, 0, nullptr);
 
     if (retval.is_null()) {
       thrower.Error("WASM.instantiateModule(): start function failed");
       return nothing;
     }
@@ skipping 237 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