[wasm] Implement importing of WebAssembly.Memory.

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 35 matching lines @@
   kInternalModuleInstance,
   kInternalArity,
   kInternalSignature
 };
 
 // Internal constants for the layout of the module object.
 enum WasmInstanceObjectFields {
   kWasmCompiledModule = 0,
   kWasmModuleFunctionTable,
   kWasmModuleCodeTable,
+  kWasmMemObject,

[Mircea Trofin, 2016/10/06 18:10:44]

Could this move on the compiled module object instead? I'd like to reduce
or eliminate the fields on the instance object. It seems like keeping 
information participating in instantiation, on this object, makes 
analysing and avoiding GC race conditions more difficult.

As an added benefit, we'd get strongly typed APIs.

   kWasmMemArrayBuffer,
   kWasmGlobalsArrayBuffer,
   // TODO(clemensh): Remove function name array, extract names from module
   // bytes.
   kWasmFunctionNamesArray,
   kWasmModuleBytesString,
   kWasmDebugInfo,
   kWasmNumImportedFunctions,
   kWasmModuleInternalFieldCount
 };
@@ skipping 1163 matching lines @@
     }
 
     //--------------------------------------------------------------------------
     // Allocate the instance object.
     //--------------------------------------------------------------------------
     Handle<Map> map = factory->NewMap(
         JS_OBJECT_TYPE,
         JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
     Handle<JSObject> instance = factory->NewJSObjectFromMap(map, TENURED);
     instance->SetInternalField(kWasmModuleCodeTable, *code_table);
+    instance->SetInternalField(kWasmMemObject, *factory->undefined_value());
+
+    //--------------------------------------------------------------------------
+    // Set up the globals for the new instance.
+    //--------------------------------------------------------------------------
+    MaybeHandle<JSArrayBuffer> old_globals;
+    MaybeHandle<JSArrayBuffer> globals;
+    uint32_t globals_size = compiled_module_->globals_size();
+    if (globals_size > 0) {
+      Handle<JSArrayBuffer> global_buffer =
+          NewArrayBuffer(isolate_, globals_size);
+      globals = global_buffer;
+      if (globals.is_null()) {
+        thrower_->Error("Out of memory: wasm globals");
+        return nothing;
+      }
+      Address old_address =
+          owner.is_null() ? nullptr : GetGlobalStartAddressFromCodeTemplate(
+                                          *factory->undefined_value(),
+                                          JSObject::cast(*owner));
+      RelocateGlobals(instance, old_address,
+                      static_cast<Address>(global_buffer->backing_store()));
+      instance->SetInternalField(kWasmGlobalsArrayBuffer, *global_buffer);
+    }
+
+    //--------------------------------------------------------------------------
+    // Process the imports for the module.
+    //--------------------------------------------------------------------------
+    int num_imported_functions = ProcessImports(globals, code_table, instance);
+    if (num_imported_functions < 0) return nothing;
 
     //--------------------------------------------------------------------------
     // Set up the memory for the new instance.
     //--------------------------------------------------------------------------
     MaybeHandle<JSArrayBuffer> old_memory;
     // TODO(titzer): handle imported memory properly.
 
     uint32_t min_mem_pages = compiled_module_->min_memory_pages();
     isolate_->counters()->wasm_min_mem_pages_count()->AddSample(min_mem_pages);
     // TODO(wasm): re-enable counter for max_mem_pages when we use that field.
@@ skipping 16 matching lines @@
       Address old_mem_start =
           compiled_module_->has_heap()
               ? static_cast<Address>(compiled_module_->heap()->backing_store())
               : nullptr;
       RelocateInstanceCode(instance, old_mem_start, mem_start, old_mem_size,
                            mem_size);
       compiled_module_->set_heap(memory_);
     }
 
     //--------------------------------------------------------------------------
-    // Set up the globals for the new instance.
-    //--------------------------------------------------------------------------
-    MaybeHandle<JSArrayBuffer> old_globals;
-    MaybeHandle<JSArrayBuffer> globals;
-    uint32_t globals_size = compiled_module_->globals_size();
-    if (globals_size > 0) {
-      Handle<JSArrayBuffer> global_buffer =
-          NewArrayBuffer(isolate_, globals_size);
-      globals = global_buffer;
-      if (globals.is_null()) {
-        thrower_->Error("Out of memory: wasm globals");
-        return nothing;
-      }
-      Address old_address =
-          owner.is_null() ? nullptr : GetGlobalStartAddressFromCodeTemplate(
-                                          *factory->undefined_value(),
-                                          JSObject::cast(*owner));
-      RelocateGlobals(instance, old_address,
-                      static_cast<Address>(global_buffer->backing_store()));
-      instance->SetInternalField(kWasmGlobalsArrayBuffer, *global_buffer);
-    }
-
-    //--------------------------------------------------------------------------
-    // Process the imports for the module.
-    //--------------------------------------------------------------------------
-    int num_imported_functions = ProcessImports(globals, code_table);
-    if (num_imported_functions < 0) return nothing;
-
-    //--------------------------------------------------------------------------
     // Process the initialization for the module's globals.
     //--------------------------------------------------------------------------
     ProcessInits(globals);
 
     //--------------------------------------------------------------------------
     // Set up the debug support for the new instance.
     //--------------------------------------------------------------------------
     // TODO(wasm): avoid referencing this stuff from the instance, use it off
     // the compiled module instead. See the following 3 assignments:
     if (compiled_module_->has_module_bytes()) {
@@ skipping 317 matching lines @@
         break;
       default:
         UNREACHABLE();
     }
   }
 
   // Process the imports, including functions, tables, globals, and memory, in
   // order, loading them from the {ffi_} object. Returns the number of imported
   // functions.
   int ProcessImports(MaybeHandle<JSArrayBuffer> globals,
-                     Handle<FixedArray> code_table) {
+                     Handle<FixedArray> code_table, Handle<JSObject> instance) {
     int num_imported_functions = 0;
     if (!compiled_module_->has_imports()) return num_imported_functions;
 
     Handle<FixedArray> imports = compiled_module_->imports();
     for (int index = 0; index < imports->length(); ++index) {
       Handle<FixedArray> data =
           imports->GetValueChecked<FixedArray>(isolate_, index);
 
       Handle<String> module_name =
           data->GetValueChecked<String>(isolate_, kModuleName);
@@ skipping 21 matching lines @@
               function_name);
           int func_index = Smi::cast(data->get(kImportIndex))->value();
           code_table->set(func_index, *import_wrapper);
           RecordStats(isolate_, *import_wrapper);
           num_imported_functions++;
           break;
         }
         case kExternalTable:
           // TODO(titzer): Table imports must be a WebAssembly.Table.
           break;
-        case kExternalMemory:
-          // TODO(titzer): Memory imports must be a WebAssembly.Memory.
+        case kExternalMemory: {
+          Handle<Object> object = result.ToHandleChecked();
+          if (!WasmJs::IsWasmMemoryObject(isolate_, object)) {
+            ReportFFIError("memory import must be a WebAssembly.Memory object",
+                           index, module_name, function_name);
+            return -1;
+          }
+          instance->SetInternalField(kWasmMemObject, *object);
+          memory_ = WasmJs::GetWasmMemoryArrayBuffer(isolate_, object);
           break;
+        }
         case kExternalGlobal: {
           // Global imports are converted to numbers and written into the
           // {globals} array buffer.
           Handle<Object> object = result.ToHandleChecked();
           MaybeHandle<Object> number = Object::ToNumber(object);
           if (number.is_null()) {
             ReportFFIError("global import could not be converted to number",
                            index, module_name, function_name);
             return -1;
           }
@@ skipping 96 matching lines @@
               export_data->GetValue<ByteArray>(isolate_, kExportedSignature);
           desc.set_value(WrapExportCodeAsJSFunction(
               isolate_, export_code, name, arity, signature, instance));
           break;
         }
         case kExternalTable:
           // TODO(titzer): create a WebAssembly.Table instance.
           // TODO(titzer): should it have the same identity as an import?
           break;
         case kExternalMemory: {
-          // TODO(titzer): should memory have the same identity as an
-          // import?
-          Handle<JSArrayBuffer> buffer =
-              Handle<JSArrayBuffer>(JSArrayBuffer::cast(
-                  instance->GetInternalField(kWasmMemArrayBuffer)));
-          desc.set_value(
-              WasmJs::CreateWasmMemoryObject(isolate_, buffer, false, 0));
+          // 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_);
+            memory_object =
+                WasmJs::CreateWasmMemoryObject(isolate_, buffer, false, 0);
+            instance->SetInternalField(kWasmMemObject, *memory_object);
+          }
+
+          desc.set_value(memory_object);
           break;
         }
         case kExternalGlobal: {
           // Export the value of the global variable as a number.
           int offset = Smi::cast(export_data->get(kExportIndex))->value();
           byte* ptr = raw_buffer_ptr(globals, offset);
           double num = 0;
           switch (Smi::cast(export_data->get(kExportGlobalType))->value()) {
             case kLocalI32:
               num = *reinterpret_cast<int32_t*>(ptr);
@@ skipping 405 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8