[wasm] Fix serialization after instantiation

src/wasm/wasm-objects.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/wasm/wasm-objects.h"
 #include "src/utils.h"
 
 #include "src/assembler-inl.h"
 #include "src/base/iterator.h"
 #include "src/compiler/wasm-compiler.h"
@@ skipping 754 matching lines @@
   // WasmCompiledModule::cast would fail since fields are not set yet.
   Handle<WasmCompiledModule> compiled_module(
       reinterpret_cast<WasmCompiledModule*>(*ret), isolate);
   compiled_module->InitId();
   compiled_module->set_num_imported_functions(0);
   compiled_module->set_shared(shared);
   compiled_module->set_native_context(isolate->native_context());
   return compiled_module;
 }
 
+Handle<WasmCompiledModule> WasmCompiledModule::Clone(
+    Isolate* isolate, Handle<WasmCompiledModule> module) {
+  Handle<WasmCompiledModule> ret = Handle<WasmCompiledModule>::cast(
+      isolate->factory()->CopyFixedArray(module));
+  ret->InitId();
+  ret->reset_weak_owning_instance();
+  ret->reset_weak_next_instance();
+  ret->reset_weak_prev_instance();
+  ret->reset_weak_exported_functions();
+  if (ret->has_embedded_mem_start()) {
+    WasmCompiledModule::recreate_embedded_mem_start(ret, isolate->factory(),
+                                                    ret->embedded_mem_start());
+  }
+  if (ret->has_globals_start()) {
+    WasmCompiledModule::recreate_globals_start(ret, isolate->factory(),
+                                               ret->globals_start());
+  }
+  if (ret->has_embedded_mem_size()) {
+    WasmCompiledModule::recreate_embedded_mem_size(ret, isolate->factory(),
+                                                   ret->embedded_mem_size());
+  }
+  return ret;
+}
+
+void WasmCompiledModule::Reset(Isolate* isolate,
+                               WasmCompiledModule* compiled_module) {
+  DisallowHeapAllocation no_gc;
+  TRACE("Resetting %d\n", compiled_module->instance_id());
+  Object* undefined = *isolate->factory()->undefined_value();
+  Object* fct_obj = compiled_module->ptr_to_code_table();
+  if (fct_obj != nullptr && fct_obj != undefined) {
+    uint32_t old_mem_size = compiled_module->mem_size();
+    uint32_t default_mem_size = compiled_module->default_mem_size();
+    Address old_mem_start = compiled_module->GetEmbeddedMemStartOrNull();
+
+    // Patch code to update memory references, global references, and function
+    // table references.
+    Zone specialization_zone(isolate->allocator(), ZONE_NAME);
+    CodeSpecialization code_specialization(isolate, &specialization_zone);
+
+    if (old_mem_size > 0 && old_mem_start != nullptr) {
+      code_specialization.RelocateMemoryReferences(old_mem_start, old_mem_size,
+                                                   nullptr, default_mem_size);
+    }
+
+    if (compiled_module->has_globals_start()) {
+      Address globals_start =
+          reinterpret_cast<Address>(compiled_module->globals_start());
+      code_specialization.RelocateGlobals(globals_start, nullptr);
+      compiled_module->set_globals_start(0);
+    }
+
+    // Reset function tables.
+    if (compiled_module->has_function_tables()) {
+      FixedArray* function_tables = compiled_module->ptr_to_function_tables();
+      FixedArray* empty_function_tables =
+          compiled_module->ptr_to_empty_function_tables();
+      if (function_tables != empty_function_tables) {
+        DCHECK_EQ(function_tables->length(), empty_function_tables->length());
+        for (int i = 0, e = function_tables->length(); i < e; ++i) {
+          code_specialization.RelocateObject(
+              handle(function_tables->get(i), isolate),
+              handle(empty_function_tables->get(i), isolate));
+        }
+        compiled_module->set_ptr_to_function_tables(empty_function_tables);
+      }
+    }
+
+    FixedArray* functions = FixedArray::cast(fct_obj);
+    for (int i = compiled_module->num_imported_functions(),
+             end = functions->length();
+         i < end; ++i) {
+      Code* code = Code::cast(functions->get(i));
+      // Skip lazy compile stubs.
+      if (code->builtin_index() == Builtins::kWasmCompileLazy) continue;
+      if (code->kind() != Code::WASM_FUNCTION) {
+        // From here on, there should only be wrappers for exported functions.
+        for (; i < end; ++i) {
+          DCHECK_EQ(Code::JS_TO_WASM_FUNCTION,
+                    Code::cast(functions->get(i))->kind());
+        }
+        break;
+      }
+      bool changed =
+          code_specialization.ApplyToWasmCode(code, SKIP_ICACHE_FLUSH);
+      // TODO(wasm): Check if this is faster than passing FLUSH_ICACHE_IF_NEEDED
+      // above.
+      if (changed) {
+        Assembler::FlushICache(isolate, code->instruction_start(),
+                               code->instruction_size());
+      }
+    }
+  }
+  compiled_module->ResetSpecializationMemInfoIfNeeded();
+}
+
 void WasmCompiledModule::InitId() {
 #if DEBUG
   static uint32_t instance_id_counter = 0;
   set(kID_instance_id, Smi::FromInt(instance_id_counter++));
   TRACE("New compiled module id: %d\n", instance_id());
 #endif
 }
 
+void WasmCompiledModule::ResetSpecializationMemInfoIfNeeded() {
+  DisallowHeapAllocation no_gc;
+  if (has_embedded_mem_start()) {
+    set_embedded_mem_size(0);
+    set_embedded_mem_start(0);
+  }
+}
+
+void WasmCompiledModule::SetSpecializationMemInfoFrom(
+    Factory* factory, Handle<WasmCompiledModule> compiled_module,
+    Handle<JSArrayBuffer> buffer) {
+  DCHECK(!buffer.is_null());
+  size_t start_address = reinterpret_cast<size_t>(buffer->backing_store());
+  uint32_t size = static_cast<uint32_t>(buffer->byte_length()->Number());
+  if (!compiled_module->has_embedded_mem_start()) {
+    DCHECK(!compiled_module->has_embedded_mem_size());
+    WasmCompiledModule::recreate_embedded_mem_start(compiled_module, factory,
+                                                    start_address);
+    WasmCompiledModule::recreate_embedded_mem_size(compiled_module, factory,
+                                                   size);
+  } else {
+    compiled_module->set_embedded_mem_start(start_address);
+    compiled_module->set_embedded_mem_size(size);
+  }
+}
+
+void WasmCompiledModule::SetGlobalsStartAddressFrom(
+    Factory* factory, Handle<WasmCompiledModule> compiled_module,
+    Handle<JSArrayBuffer> buffer) {
+  DCHECK(!buffer.is_null());
+  size_t start_address = reinterpret_cast<size_t>(buffer->backing_store());
+  if (!compiled_module->has_globals_start()) {
+    WasmCompiledModule::recreate_globals_start(compiled_module, factory,
+                                               start_address);
+  } else {
+    compiled_module->set_globals_start(start_address);
+  }
+}
+
 MaybeHandle<String> WasmCompiledModule::ExtractUtf8StringFromModuleBytes(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module,
     uint32_t offset, uint32_t size) {
   // TODO(wasm): cache strings from modules if it's a performance win.
   Handle<SeqOneByteString> module_bytes(compiled_module->module_bytes(),
                                         isolate);
   DCHECK_GE(module_bytes->length(), offset);
   DCHECK_GE(module_bytes->length() - offset, size);
   Address raw = module_bytes->GetCharsAddress() + offset;
   if (!unibrow::Utf8::Validate(reinterpret_cast<const byte*>(raw), size))
     return {};  // UTF8 decoding error for name.
   DCHECK_GE(kMaxInt, offset);
   DCHECK_GE(kMaxInt, size);
   return isolate->factory()->NewStringFromUtf8SubString(
       module_bytes, static_cast<int>(offset), static_cast<int>(size));
 }
 
 bool WasmCompiledModule::IsWasmCompiledModule(Object* obj) {
   if (!obj->IsFixedArray()) return false;
   FixedArray* arr = FixedArray::cast(obj);
   if (arr->length() != PropertyIndices::Count) return false;
   Isolate* isolate = arr->GetIsolate();
 #define WCM_CHECK_TYPE(NAME, TYPE_CHECK) \
   do {                                   \
     Object* obj = arr->get(kID_##NAME);  \
     if (!(TYPE_CHECK)) return false;     \
   } while (false);
+// We're OK with undefined, generally, because maybe we don't
+// have a value for that item. For example, we may not have a
+// memory, or globals.
+// We're not OK with the fixed numbers being undefined. We want
+// to set once all of them.
 #define WCM_CHECK_OBJECT(TYPE, NAME) \
   WCM_CHECK_TYPE(NAME, obj->IsUndefined(isolate) || obj->Is##TYPE())
 #define WCM_CHECK_WASM_OBJECT(TYPE, NAME) \
   WCM_CHECK_TYPE(NAME, TYPE::Is##TYPE(obj))
 #define WCM_CHECK_WEAK_LINK(TYPE, NAME) WCM_CHECK_OBJECT(WeakCell, NAME)
-#define WCM_CHECK_SMALL_NUMBER(TYPE, NAME) WCM_CHECK_TYPE(NAME, obj->IsSmi())
+#define WCM_CHECK_SMALL_NUMBER(TYPE, NAME) \
+  WCM_CHECK_TYPE(NAME, obj->IsUndefined(isolate) || obj->IsSmi())
 #define WCM_CHECK(KIND, TYPE, NAME) WCM_CHECK_##KIND(TYPE, NAME)
+#define WCM_CHECK_SMALL_FIXED_NUMBER(TYPE, NAME) \
+  WCM_CHECK_TYPE(NAME, obj->IsSmi())
+#define WCM_CHECK_LARGE_NUMBER(TYPE, NAME) \
+  WCM_CHECK_TYPE(NAME, obj->IsUndefined(isolate) || obj->IsMutableHeapNumber())
   WCM_PROPERTY_TABLE(WCM_CHECK)
 #undef WCM_CHECK
 
   // All checks passed.
   return true;
 }
 
 void WasmCompiledModule::PrintInstancesChain() {
 #if DEBUG
   if (!FLAG_trace_wasm_instances) return;
@@ skipping 11 matching lines @@
 void WasmCompiledModule::ReinitializeAfterDeserialization(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module) {
   // This method must only be called immediately after deserialization.
   // At this point, no module wrapper exists, so the shared module data is
   // incomplete.
   Handle<WasmSharedModuleData> shared(
       static_cast<WasmSharedModuleData*>(compiled_module->get(kID_shared)),
       isolate);
   DCHECK(!WasmSharedModuleData::IsWasmSharedModuleData(*shared));
   WasmSharedModuleData::ReinitializeAfterDeserialization(isolate, shared);
+  WasmCompiledModule::Reset(isolate, *compiled_module);
   DCHECK(WasmSharedModuleData::IsWasmSharedModuleData(*shared));
 }
 
 uint32_t WasmCompiledModule::mem_size() const {
-  return has_memory() ? memory()->byte_length()->Number() : default_mem_size();
+  DCHECK(has_embedded_mem_size() == has_embedded_mem_start());
+  return has_embedded_mem_start() ? embedded_mem_size() : default_mem_size();
 }
 
 uint32_t WasmCompiledModule::default_mem_size() const {
   return min_mem_pages() * WasmModule::kPageSize;
 }
 
 MaybeHandle<String> WasmCompiledModule::GetFunctionNameOrNull(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module,
     uint32_t func_index) {
   DCHECK_LT(func_index, compiled_module->module()->functions.size());
@@ skipping 351 matching lines @@
   if (!array->get(kWrapperInstanceObject)->IsWeakCell()) return false;
   Isolate* isolate = array->GetIsolate();
   if (!array->get(kNextInstanceWrapper)->IsUndefined(isolate) &&
       !array->get(kNextInstanceWrapper)->IsFixedArray())
     return false;
   if (!array->get(kPreviousInstanceWrapper)->IsUndefined(isolate) &&
       !array->get(kPreviousInstanceWrapper)->IsFixedArray())
     return false;
   return true;
 }