[wasm] Add an export table.

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 "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
@@ skipping 265 matching lines @@
       min_mem_size_log2(0),
       max_mem_size_log2(0),
       mem_export(false),
       mem_external(false),
       start_function_index(-1),
       globals(nullptr),
       signatures(nullptr),
       functions(nullptr),
       data_segments(nullptr),
       function_table(nullptr),
-      import_table(nullptr) {}
+      import_table(nullptr),
+      export_table(nullptr) {}
 
 WasmModule::~WasmModule() {
   if (globals) delete globals;
   if (signatures) delete signatures;
   if (functions) delete functions;
   if (data_segments) delete data_segments;
   if (function_table) delete function_table;
   if (import_table) delete import_table;
+  if (export_table) delete export_table;
 }
 
 static MaybeHandle<JSFunction> LookupFunction(ErrorThrower& thrower,
                                               Handle<JSObject> ffi,
                                               uint32_t index,
                                               Handle<String> name,
                                               const char* cstr) {
   if (!ffi.is_null()) {
     MaybeHandle<Object> result = Object::GetProperty(ffi, name);
     if (!result.is_null()) {
@@ skipping 143 matching lines @@
       JSObject::AddProperty(instance.js_object, name, function, READ_ONLY);
     }
     index++;
   }
 
   // Second pass: patch all direct call sites.
   linker.Link(instance.function_table, this->function_table);
   instance.js_object->SetInternalField(kWasmModuleFunctionTable,
                                        Smi::FromInt(0));
 
+  //-------------------------------------------------------------------------
+  // Create and populate the exports object.
+  //-------------------------------------------------------------------------
+  if (export_table->size() > 0) {
+    index = 0;
+    // Create the "exports" object.
+    Handle<JSFunction> object_function = Handle<JSFunction>(
+        isolate->native_context()->object_function(), isolate);
+    Handle<JSObject> exports_object =
+        factory->NewJSObject(object_function, TENURED);
+    Handle<String> exports_name = factory->InternalizeUtf8String("exports");
+    JSObject::AddProperty(instance.js_object, exports_name, exports_object,
+                          READ_ONLY);
+
+    // Compile wrappers and add them to the exports object.
+    for (const WasmExport& exp : *export_table) {
+      if (thrower.error()) break;
+      const char* cstr = GetName(exp.name_offset);
+      Handle<String> name = factory->InternalizeUtf8String(cstr);
+      Handle<Code> code = linker.GetFunctionCode(exp.func_index);
+      Handle<JSFunction> function = compiler::CompileJSToWasmWrapper(
+          isolate, &module_env, name, code, instance.js_object, exp.func_index);
+      JSObject::AddProperty(exports_object, name, function, READ_ONLY);
+    }
+  }
+
   // Run the start function if one was specified.
   if (this->start_function_index >= 0) {
     HandleScope scope(isolate);
     uint32_t index = static_cast<uint32_t>(this->start_function_index);
     Handle<String> name = isolate->factory()->NewStringFromStaticChars("start");
     Handle<Code> code = linker.GetFunctionCode(index);
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
         isolate, &module_env, name, code, instance.js_object, index);
 
     // Call the JS function.
@@ skipping 136 matching lines @@
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8