[wasm] further simplification of WasmCompiledModule

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 833 matching lines @@
                                          SKIP_ICACHE_FLUSH);
         }
       }
     }
   }
 }
 
 static void ResetCompiledModule(Isolate* isolate, JSObject* owner,
                                 WasmCompiledModule* compiled_module) {
   Object* undefined = *isolate->factory()->undefined_value();
-  uint32_t old_mem_size = compiled_module->mem_size();
-  Object* mem_start = compiled_module->ptr_to_mem_start();
+  uint32_t old_mem_size = compiled_module->has_heap()
+                              ? compiled_module->mem_size()
+                              : compiled_module->default_mem_size();
+  uint32_t default_mem_size = compiled_module->default_mem_size();
+  Object* mem_start = compiled_module->ptr_to_heap();
   Address old_mem_address = nullptr;
   Address globals_start =
       GetGlobalStartAddressFromCodeTemplate(undefined, owner);
 
   if (old_mem_size > 0) {
     CHECK_NE(mem_start, undefined);
     old_mem_address =
         static_cast<Address>(JSArrayBuffer::cast(mem_start)->backing_store());
   }
   int mode_mask = RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
                   RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_SIZE_REFERENCE) |
                   RelocInfo::ModeMask(RelocInfo::WASM_GLOBAL_REFERENCE);
 
   Object* fct_obj = compiled_module->ptr_to_code_table();
   if (fct_obj != nullptr && fct_obj != undefined &&
       (old_mem_size > 0 || globals_start != nullptr)) {
     FixedArray* functions = FixedArray::cast(fct_obj);
     for (int i = 0; i < functions->length(); ++i) {
       Code* code = Code::cast(functions->get(i));
       bool changed = false;
       for (RelocIterator it(code, mode_mask); !it.done(); it.next()) {
         RelocInfo::Mode mode = it.rinfo()->rmode();
         if (RelocInfo::IsWasmMemoryReference(mode) ||
             RelocInfo::IsWasmMemorySizeReference(mode)) {
-          it.rinfo()->update_wasm_memory_reference(old_mem_address, nullptr,
-                                                   old_mem_size, old_mem_size);
+          it.rinfo()->update_wasm_memory_reference(
+              old_mem_address, nullptr, old_mem_size, default_mem_size);
           changed = true;
         } else {
           CHECK(RelocInfo::IsWasmGlobalReference(mode));
           it.rinfo()->update_wasm_global_reference(globals_start, nullptr);
           changed = true;
         }
       }
       if (changed) {
         Assembler::FlushICache(isolate, code->instruction_start(),
                                code->instruction_size());
       }
     }
   }
   compiled_module->reset_weak_owning_instance();
-  compiled_module->reset_mem_start();
+  compiled_module->reset_heap();
 }
 
 static void InstanceFinalizer(const v8::WeakCallbackInfo<void>& data) {
   JSObject** p = reinterpret_cast<JSObject**>(data.GetParameter());
   JSObject* owner = *p;
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(owner->GetInternalField(kWasmCompiledModule));
   Isolate* isolate = reinterpret_cast<Isolate*>(data.GetIsolate());
   DCHECK(compiled_module->has_weak_module_object());
   WeakCell* weak_module_obj = compiled_module->ptr_to_weak_module_object();
@@ skipping 136 matching lines @@
       // TODO(mtrofin): do we need to flush the cache here?
       Assembler::FlushICache(isolate, code->instruction_start(),
                              code->instruction_size());
     }
   }
 
   // Create the compiled module object, and populate with compiled functions
   // and information needed at instantiation time. This object needs to be
   // serializable. Instantiation may occur off a deserialized version of this
   // object.
-  Handle<WasmCompiledModule> ret = WasmCompiledModule::New(isolate);
+  Handle<WasmCompiledModule> ret = WasmCompiledModule::New(
+      isolate, min_mem_pages, globals_size, mem_export, origin);
   ret->set_code_table(code_table);
   if (!indirect_table.is_null()) {
     ret->set_indirect_function_tables(indirect_table.ToHandleChecked());
   }
   Handle<FixedArray> import_data = GetImportsData(factory, this);
   ret->set_import_data(import_data);
 
   // Compile exported function wrappers.
   int export_size = static_cast<int>(num_exported_functions);
   if (export_size > 0) {
@@ skipping 53 matching lines @@
                                            static_cast<int>(module_bytes_len));
     Handle<String> module_bytes_string =
         factory->NewStringFromOneByte(module_bytes_vec, TENURED)
             .ToHandleChecked();
     ret->set_module_bytes(module_bytes_string);
   }
 
   Handle<ByteArray> function_name_table =
       BuildFunctionNamesTable(isolate, module_env.module);
   ret->set_function_names(function_name_table);
-  ret->set_min_required_memory(min_mem_pages);
   if (data_segments.size() > 0) SaveDataSegmentInfo(factory, this, ret);
-  ret->set_globals_size(globals_size);
-  ret->set_export_memory(mem_export);
-  ret->set_origin(origin);
-  ret->set_mem_size(temp_instance.mem_size);
+  DCHECK_EQ(ret->default_mem_size(), temp_instance.mem_size);
   return ret;
 }
 
 void PatchJSWrapper(Isolate* isolate, Handle<Code> wrapper,
                     Handle<Code> new_target) {
   AllowDeferredHandleDereference embedding_raw_address;
   bool seen = false;
   for (RelocIterator it(*wrapper, 1 << RelocInfo::CODE_TARGET); !it.done();
        it.next()) {
     Code* target = Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
@@ skipping 99 matching lines @@
           case Code::JS_TO_WASM_FUNCTION:
           case Code::WASM_FUNCTION: {
             Handle<Code> code = factory->CopyCode(orig_code);
             code_table->set(i, *code);
             break;
           }
           default:
             UNREACHABLE();
         }
       }
-      compiled_module->set_mem_size(original->mem_size());
       RecordStats(isolate, code_table);
     } else {
       // There was no owner, so we can reuse the original.
       compiled_module = original;
     }
     compiled_module->set_code_table(code_table);
   }
 
   //--------------------------------------------------------------------------
   // 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);
 
   //--------------------------------------------------------------------------
   // 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_required_memory();
+  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.
 
   if (memory.is_null() && min_mem_pages > 0) {
     memory = AllocateMemory(thrower, isolate, min_mem_pages);
     if (memory.is_null()) return nothing;  // failed to allocate memory
   }
 
   if (!memory.is_null()) {
     instance->SetInternalField(kWasmMemArrayBuffer, *memory);
     Address mem_start = static_cast<Address>(memory->backing_store());
     uint32_t mem_size = static_cast<uint32_t>(memory->byte_length()->Number());
     LoadDataSegments(compiled_module, mem_start, mem_size);
 
-    uint32_t old_mem_size = compiled_module->mem_size();
+    uint32_t old_mem_size = compiled_module->has_heap()
+                                ? compiled_module->mem_size()
+                                : compiled_module->default_mem_size();
     Address old_mem_start =
-        compiled_module->has_mem_start()
-            ? static_cast<Address>(
-                  compiled_module->mem_start()->backing_store())
+        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_mem_size(mem_size);
-    compiled_module->set_mem_start(memory);
+    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);
@@ skipping 219 matching lines @@
       }
       GlobalHandles::MakeWeak(global_handle.location(),
                               global_handle.location(), &InstanceFinalizer,
                               v8::WeakCallbackType::kFinalizer);
     }
   }
 
   return instance;
 }
 
+Handle<WasmCompiledModule> WasmCompiledModule::New(Isolate* isolate,
+                                                   uint32_t min_memory_pages,
+                                                   uint32_t globals_size,
+                                                   bool export_memory,
+                                                   ModuleOrigin origin) {
+  Handle<FixedArray> ret =
+      isolate->factory()->NewFixedArray(PropertyIndices::Count, TENURED);
+  // Globals size is expected to fit into an int without overflow. This is not
+  // supported by the spec at the moment, however, we don't support array
+  // buffer sizes over 1g, so, for now, we avoid alocating a HeapNumber for
+  // the globals size. The CHECK guards this assumption.
+  CHECK_GE(static_cast<int>(globals_size), 0);
+  ret->set(kID_min_memory_pages,
+           Smi::FromInt(static_cast<int>(min_memory_pages)));
+  ret->set(kID_globals_size, Smi::FromInt(static_cast<int>(globals_size)));
+  ret->set(kID_export_memory, Smi::FromInt(static_cast<int>(export_memory)));
+  ret->set(kID_origin, Smi::FromInt(static_cast<int>(origin)));
+  return handle(WasmCompiledModule::cast(*ret));
+}
+
 compiler::CallDescriptor* ModuleEnv::GetCallDescriptor(Zone* zone,
                                                        uint32_t index) {
   DCHECK(IsValidFunction(index));
   // Always make a direct call to whatever is in the table at that location.
   // A wrapper will be generated for FFI calls.
   const WasmFunction* function = &module->functions[index];
   return GetWasmCallDescriptor(zone, function->sig);
 }
 
 Handle<Object> GetWasmFunctionNameOrNull(Isolate* isolate, Handle<Object> wasm,
@@ skipping 204 matching lines @@
   Object* mem = instance->GetInternalField(kWasmMemArrayBuffer);
   DCHECK(IsWasmObject(*instance));
   if (mem->IsUndefined(isolate)) return MaybeHandle<JSArrayBuffer>();
   return Handle<JSArrayBuffer>(JSArrayBuffer::cast(mem));
 }
 
 void SetInstanceMemory(Handle<JSObject> instance, JSArrayBuffer* buffer) {
   DisallowHeapAllocation no_gc;
   DCHECK(IsWasmObject(*instance));
   instance->SetInternalField(kWasmMemArrayBuffer, buffer);
-  Object* module = instance->GetInternalField(kWasmCompiledModule);
-  if (module->IsFixedArray()) {
-    WasmCompiledModule::cast(module)->set_mem_size(
-        buffer->byte_length()->Number());
-  }
+  WasmCompiledModule* module =
+      WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
+  module->set_ptr_to_heap(buffer);
 }
 
 namespace testing {
 
 void ValidateInstancesChain(Isolate* isolate, Handle<JSObject> module_obj,
                             int instance_count) {
   CHECK_GE(instance_count, 0);
   DisallowHeapAllocation no_gc;
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(module_obj->GetInternalField(0));
@@ skipping 36 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