[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,
   kWasmMemArrayBuffer,
   kWasmGlobalsArrayBuffer,
   kWasmDebugInfo,
   kWasmModuleInternalFieldCount
 };
 
 enum WasmImportData {
   kImportKind,         // Smi. an ExternalKind
   kImportGlobalType,   // Smi. Type for globals.
   kImportIndex,        // Smi. index for the import.
@@ skipping 1170 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 runtime support for the new instance.
     //--------------------------------------------------------------------------
     Handle<WeakCell> weak_link = factory->NewWeakCell(instance);
 
     for (int i = num_imported_functions + FLAG_skip_compiling_wasm_funcs;
@@ skipping 298 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 426 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