[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"
@@ skipping 98 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) {
+    Handle<ByteArray> 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);
+  // add another Internal Field as the shared function
+  function->SetInternalField(1, *shared);
+  // add another Internal Field as the signature of the foreign function
+  function->SetInternalField(2, *signature);

[Mircea Trofin, 2016/08/01 23:38:32]

This might fail, because we only specified a grand total of 2 internal fields to
the wasm_function_map (as per your change in wasm-js.cc)

   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.
 };
 
 uint32_t GetMinModuleMemSize(const WasmModule* module) {
@@ skipping 468 matching lines @@
       CHECK(ret_count >= 0);
       Handle<ByteArray> sig_data = data->GetValueChecked<ByteArray>(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 = true;
+      if (export_wrapper_code->kind() == Code::JS_TO_WASM_FUNCTION) {
+        Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>(
+            SharedFunctionInfo::cast(func->GetInternalField(1)));
+        int exported_param_count = shared->length();
+        // check whether two functions have same param count

[Mircea Trofin, 2016/08/01 23:38:32]

You should get the parameter count from the wasm function signature (we save the
arity earlier on - see kExportArity). Maybe you can just point to the entire
WasmExportMetadata, rather than just the ByteArray with the signature?

SharedFunctionInfo is a JS concept, while the wasm function signature is a WASM
concept.

+        if (exported_param_count != param_count) isMatch = false;
+        Handle<ByteArray> exportedSig =
+            Handle<ByteArray>(ByteArray::cast(func->GetInternalField(2)));

[Mircea Trofin, 2016/08/01 23:38:32]

why continue computing exportedSig if isMatch=false?

+        // check whether two functions have same signature
+        if (exportedSig->length() == sig_data->length()) {
+          for (int i = 0; i < exportedSig->length(); i++) {
+            if (exportedSig->get(i) != sig_data->get(i)) {
+              isMatch = false;
+              break;
+            }
+          }
+        } else {
+          isMatch = false;
+        }
+        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++;

[Mircea Trofin, 2016/08/01 23:38:32]

++wasm_count

+              code = handle(target);
+            }
+          }
+          CHECK(wasm_count == 1);

[Mircea Trofin, 2016/08/01 23:38:32]

DCHECK

+        }
+      }
+      if (export_wrapper_code->kind() != Code::JS_TO_WASM_FUNCTION ||
+          !isMatch) {
         // 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 283 matching lines @@
       for (int i = 0; i < exports_size; ++i) {
         if (thrower->error()) return false;
         Handle<FixedArray> export_metadata =
             exports->GetValueChecked<FixedArray>(i);
         Handle<Code> export_code =
             export_metadata->GetValueChecked<Code>(kExportCode);
         RecordStats(isolate, *export_code);
         Handle<String> name =
             export_metadata->GetValueChecked<String>(kExportName);
         int arity = Smi::cast(export_metadata->get(kExportArity))->value();
+        Handle<ByteArray> signature =
+            export_metadata->GetValueChecked<ByteArray>(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 83 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 216 matching lines @@
   }
 
   // Run the start function if one was specified.
   MaybeHandle<FixedArray> maybe_startup_fct =
       compiled_module->GetValue<FixedArray>(kStartupFunction);
   Handle<FixedArray> metadata;
   if (maybe_startup_fct.ToHandle(&metadata)) {
     HandleScope scope(isolate);
     Handle<Code> startup_code = metadata->GetValueChecked<Code>(kExportCode);
     int arity = Smi::cast(metadata->get(kExportArity))->value();
+    Handle<ByteArray> startup_signature =
+        metadata->GetValueChecked<ByteArray>(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 203 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