[wasm] Add support for exporting WebAssembly.Table instances.

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 1020 matching lines @@
         deopt_data->set_length(2);
         code->set_deoptimization_data(*deopt_data);
       }
     }
 
     //--------------------------------------------------------------------------
     // Set up the indirect function tables for the new instance.
     //--------------------------------------------------------------------------
     int function_table_count =
         static_cast<int>(module_->function_tables.size());
+    std::vector<InitializedTable> inited_tables;
+    inited_tables.reserve(module_->function_tables.size());
     if (function_table_count > 0) {
       Handle<FixedArray> old_function_tables =
           compiled_module_->function_tables();
       Handle<FixedArray> new_function_tables =
           factory->NewFixedArray(function_table_count);
       for (int index = 0; index < function_table_count; ++index) {
         WasmIndirectFunctionTable& table = module_->function_tables[index];
-        uint32_t size = table.max_size > 0 ? table.max_size : table.size;
-        Handle<FixedArray> new_table = factory->NewFixedArray(size * 2);
+        uint32_t table_size = table.size;
+        Handle<FixedArray> new_table = factory->NewFixedArray(table_size * 2);
+
+        inited_tables.push_back({Handle<JSObject>::null(),
+                                 Handle<FixedArray>::null(), new_table,
+                                 std::vector<WasmFunction*>()});
+        InitializedTable& init_table = inited_tables.back();
+        if (table.exported) {
+          init_table.new_entries.insert(init_table.new_entries.begin(),
+                                        table_size, nullptr);
+        }
+
         for (int i = 0; i < new_table->length(); ++i) {
           static const int kInvalidSigIndex = -1;
           // Fill the table with invalid signature indexes so that uninitialized
           // entries will always fail the signature check.
           new_table->set(i, Smi::FromInt(kInvalidSigIndex));
         }
         for (auto table_init : module_->table_inits) {
           uint32_t base = EvalUint32InitExpr(globals, table_init.offset);
-          uint32_t table_size = static_cast<uint32_t>(new_table->length());
           if (base > table_size ||
               (base + table_init.entries.size() > table_size)) {
             thrower_->CompileError("table initializer is out of bounds");
             continue;
           }
           for (size_t i = 0; i < table_init.entries.size(); ++i) {
-            FunctionSig* sig = module_->functions[table_init.entries[i]].sig;
+            WasmFunction* func = &module_->functions[table_init.entries[i]];
+            if (table.exported) {
+              init_table.new_entries[i + base] = func;
+            }
+            FunctionSig* sig = func->sig;
             int32_t sig_index = table.map.Find(sig);
             new_table->set(static_cast<int>(i + base), Smi::FromInt(sig_index));
-            new_table->set(static_cast<int>(i + base + size),
+            new_table->set(static_cast<int>(i + base + table_size),
                            code_table->get(table_init.entries[i]));
           }
         }
         new_function_tables->set(static_cast<int>(index), *new_table);
       }
       // Patch all code that has references to the old indirect table.
       for (int i = 0; i < code_table->length(); ++i) {
         if (!code_table->get(i)->IsCode()) continue;
         Handle<Code> code(Code::cast(code_table->get(i)), isolate_);
         for (int j = 0; j < function_table_count; ++j) {
           ReplaceReferenceInCode(
               code, Handle<Object>(old_function_tables->get(j), isolate_),
               Handle<Object>(new_function_tables->get(j), isolate_));
         }
       }
       compiled_module_->set_function_tables(new_function_tables);
     }
 
     //--------------------------------------------------------------------------
     // Set up the exports object for the new instance.
     //--------------------------------------------------------------------------
-    ProcessExports(globals, code_table, instance);
+    ProcessExports(globals, inited_tables, code_table, instance);
 
     if (num_imported_functions > 0 || !owner.is_null()) {
       // If the code was cloned, or new imports were compiled, patch.
       PatchDirectCalls(old_code_table, code_table, num_imported_functions);
     }
 
     FlushICache(isolate_, code_table);
 
     //--------------------------------------------------------------------------
     // Set up and link the new instance.
@@ skipping 67 matching lines @@
       }
     }
 
     DCHECK(!isolate_->has_pending_exception());
     TRACE("Finishing instance %d\n", compiled_module_->instance_id());
     TRACE_CHAIN(WasmCompiledModule::cast(module_object_->GetInternalField(0)));
     return instance;
   }
 
  private:
+  // Represents the initialized state of a table.
+  struct InitializedTable {
+    Handle<JSObject> table_object;           // WebAssembly.Table instance
+    Handle<FixedArray> js_functions;         // JSFunctions exported
+    Handle<FixedArray> dispatch_table;       // internal (code, sig) pairs
+    std::vector<WasmFunction*> new_entries;  // overwriting entries
+  };
+
   Isolate* isolate_;
   WasmModule* module_;
   ErrorThrower* thrower_;
   Handle<JSObject> module_object_;
   Handle<JSReceiver> ffi_;
   Handle<JSArrayBuffer> memory_;
   Handle<WasmCompiledModule> compiled_module_;
 
   // Helper routine to print out errors with imports (FFI).
   MaybeHandle<JSFunction> ReportFFIError(const char* error, uint32_t index,
@@ skipping 301 matching lines @@
 
     if (mem_buffer.is_null()) {
       thrower_->RangeError("Out of memory: wasm memory");
     }
     return mem_buffer;
   }
 
   // Process the exports, creating wrappers for functions, tables, memories,
   // and globals.
   void ProcessExports(MaybeHandle<JSArrayBuffer> globals,
+                      std::vector<InitializedTable>& inited_tables,
                       Handle<FixedArray> code_table,
                       Handle<JSObject> instance) {
     if (module_->export_table.size() == 0) return;
 
+    // Allocate a table to cache the exported JSFunctions if needed.
+    bool has_exported_functions = module_->num_exported_functions > 0;
+    if (!has_exported_functions) {
+      for (auto table : module_->function_tables) {
+        if (table.exported) {
+          has_exported_functions = true;
+          break;
+        }
+      }
+    }
+    Handle<FixedArray> exported_functions =
+        has_exported_functions
+            ? isolate_->factory()->NewFixedArray(
+                  static_cast<int>(module_->functions.size()))
+            : Handle<FixedArray>::null();
+
     Handle<JSObject> exports_object = instance;
     if (module_->origin == kWasmOrigin) {
       // Create the "exports" object.
       Handle<JSFunction> object_function = Handle<JSFunction>(
           isolate_->native_context()->object_function(), isolate_);
       exports_object =
           isolate_->factory()->NewJSObject(object_function, TENURED);
       Handle<String> exports_name =
           isolate_->factory()->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance, exports_name, exports_object, READ_ONLY);
     }
 
     PropertyDescriptor desc;
     desc.set_writable(false);
 
     int func_index = 0;
     for (auto exp : module_->export_table) {
       Handle<String> name =
           ExtractStringFromModuleBytes(isolate_, compiled_module_,
                                        exp.name_offset, exp.name_length)
               .ToHandleChecked();
       switch (exp.kind) {
         case kExternalFunction: {
           // Wrap and export the code as a JSFunction.
           WasmFunction& function = module_->functions[exp.index];
           int export_index =
               static_cast<int>(module_->functions.size() + func_index);
-          Handle<Code> export_code =
-              code_table->GetValueChecked<Code>(isolate_, export_index);
-          desc.set_value(WrapExportCodeAsJSFunction(
-              isolate_, export_code, name, function.sig, func_index, instance));
+          Handle<Object> value(exported_functions->get(exp.index), isolate_);
+          Handle<JSFunction> js_function;
+          if (value->IsJSFunction()) {
+            // There already is a JSFunction for this WASM function.
+            js_function = Handle<JSFunction>::cast(value);
+          } else {
+            // Wrap the exported code as a JSFunction.
+            Handle<Code> export_code =
+                code_table->GetValueChecked<Code>(isolate_, export_index);
+            js_function =
+                WrapExportCodeAsJSFunction(isolate_, export_code, name,
+                                           function.sig, func_index, instance);
+            exported_functions->set(exp.index, *js_function);
+          }
+          desc.set_value(js_function);
           func_index++;
           break;
         }
-        case kExternalTable:
-          // TODO(titzer): create a WebAssembly.Table instance.
-          // TODO(titzer): should it have the same identity as an import?
+        case kExternalTable: {
+          InitializedTable& init_table = inited_tables[exp.index];
+          WasmIndirectFunctionTable& table =
+              module_->function_tables[exp.index];
+          if (init_table.table_object.is_null()) {
+            init_table.table_object = WasmJs::CreateWasmTableObject(
+                isolate_, table.size, table.max_size != 0, table.max_size,
+                &init_table.js_functions);
+          }
+          desc.set_value(init_table.table_object);
           break;
+        }
         case kExternalMemory: {
           // Export the memory as a WebAssembly.Memory object.
           Handle<Object> memory_object(
               instance->GetInternalField(kWasmMemObject), isolate_);
           if (memory_object->IsUndefined(isolate_)) {
             // If there was no imported WebAssembly.Memory object, create one.
             Handle<JSArrayBuffer> buffer(
                 JSArrayBuffer::cast(
                     instance->GetInternalField(kWasmMemArrayBuffer)),
                 isolate_);
@@ skipping 31 matching lines @@
       }
 
       v8::Maybe<bool> status = JSReceiver::DefineOwnProperty(
           isolate_, exports_object, name, &desc, Object::THROW_ON_ERROR);
       if (!status.IsJust()) {
         thrower_->TypeError("export of %.*s failed.", name->length(),
                             name->ToCString().get());
         return;
       }
     }
+
+    // Fill out the contents of WebAssembly.Table instances.
+    if (!exported_functions.is_null()) {
+      // TODO(titzer): We compile JS->WASM wrappers for any function that is a
+      // member of an exported indirect table that is not itself exported. This
+      // should be done at compile time and cached instead.
+      WasmInstance temp_instance(module_);
+      temp_instance.context = isolate_->native_context();
+      temp_instance.mem_size = 0;
+      temp_instance.mem_start = nullptr;
+      temp_instance.globals_start = nullptr;
+
+      ModuleEnv module_env;
+      module_env.module = module_;
+      module_env.instance = &temp_instance;
+      module_env.origin = module_->origin;
+
+      // Fill the exported tables with JSFunctions.
+      for (auto inited_table : inited_tables) {
+        if (inited_table.js_functions.is_null()) continue;
+        for (int i = 0; i < static_cast<int>(inited_table.new_entries.size());
+             i++) {
+          if (inited_table.new_entries[i] == nullptr) continue;
+          int func_index =
+              static_cast<int>(inited_table.new_entries[i]->func_index);
+          if (!exported_functions->get(func_index)->IsJSFunction()) {
+            // No JSFunction entry yet exists for this function. Create one.
+            Handle<Code> wasm_code(Code::cast(code_table->get(func_index)),
+                                   isolate_);
+            Handle<Code> wrapper_code = compiler::CompileJSToWasmWrapper(
+                isolate_, &module_env, wasm_code, func_index);
+            Handle<JSFunction> js_function = WrapExportCodeAsJSFunction(
+                isolate_, wrapper_code, isolate_->factory()->empty_string(),
+                module_->functions[func_index].sig, func_index, instance);
+            exported_functions->set(func_index, *js_function);
+          }
+          inited_table.js_functions->set(i,
+                                         exported_functions->get(func_index));
+        }
+      }
+    }
   }
 };
 
 // Instantiates a WASM module, creating a WebAssembly.Instance from a
 // WebAssembly.Module.
 MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
                                               ErrorThrower* thrower,
                                               Handle<JSObject> wasm_module,
                                               Handle<JSReceiver> ffi,
                                               Handle<JSArrayBuffer> memory) {
@@ skipping 388 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));
 }