[wasm] Fix serialization after instantiation

src/wasm/wasm-objects.h

 // Copyright 2016 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.
 
 #ifndef V8_WASM_OBJECTS_H_
 #define V8_WASM_OBJECTS_H_
 
 #include "src/debug/debug.h"
 #include "src/debug/interface-types.h"
 #include "src/objects.h"
@@ skipping 203 matching lines @@
   static void SetBreakpointsOnNewInstance(Handle<WasmSharedModuleData>,
                                           Handle<WasmInstanceObject>);
 
   static void PrepareForLazyCompilation(Handle<WasmSharedModuleData>);
 
  private:
   DECLARE_OPTIONAL_GETTER(lazy_compilation_orchestrator, Foreign);
   friend class WasmCompiledModule;
 };
 
+// This represents the set of wasm compiled functions, together
+// with all the information necessary for re-specializing them.
+//
+// We specialize wasm functions to their instance by embedding:
+//   - raw interior pointers into the backing store of the array buffer
+//     used as memory of a particular WebAssembly.Instance object.
+//   - bounds check limits, computed at compile time, relative to the
+//     size of the memory.
+//   - the objects representing the function tables and signature tables
+//   - raw pointer to the globals buffer.
+//
+// Even without instantiating, we need values for all of these parameters.
+// We need to track these values to be able to create new instances and
+// to be able to serialize/deserialize.
+// The design decisions for how we track these values is not too immediate,
+// and it deserves a summary. The "tricky" ones are: memory, globals, and
+// the tables (signature and functions).
+// The first 2 (memory & globals) are embedded as raw pointers to native
+// buffers. All we need to track them is the start addresses and, in the
+// case of memory, the size. We model all of them as HeapNumbers, because
+// we need to store size_t values (for addresses), and potentially full
+// 32 bit unsigned values for the size. Smis are 31 bits.
+// For tables, we need to hold a reference to the JS Heap object, because
+// we embed them as objects, and they may move.
 class WasmCompiledModule : public FixedArray {
  public:
   enum Fields { kFieldCount };
 
   static WasmCompiledModule* cast(Object* fixed_array) {
     SLOW_DCHECK(IsWasmCompiledModule(fixed_array));
     return reinterpret_cast<WasmCompiledModule*>(fixed_array);
   }
 
 #define WCM_OBJECT_OR_WEAK(TYPE, NAME, ID, TYPE_CHECK)               \
@@ skipping 26 matching lines @@
   }                                                                  \
                                                                      \
   void reset_##NAME() { set_undefined(ID); }
 
 #define WCM_OBJECT(TYPE, NAME) \
   WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, obj->Is##TYPE())
 
 #define WCM_WASM_OBJECT(TYPE, NAME) \
   WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, TYPE::Is##TYPE(obj))
 
-#define WCM_SMALL_NUMBER(TYPE, NAME)                               \
+#define WCM_SMALL_FIXED_NUMBER(TYPE, NAME)                         \
   TYPE NAME() const {                                              \
     return static_cast<TYPE>(Smi::cast(get(kID_##NAME))->value()); \
   }                                                                \
   void set_##NAME(TYPE value) { set(kID_##NAME, Smi::FromInt(value)); }
 
+#define WCM_SMALL_NUMBER(TYPE, NAME)                                    \
+  TYPE NAME() const {                                                   \
+    return static_cast<TYPE>(Smi::cast(get(kID_##NAME))->value());      \
+  }                                                                     \
+  void set_##NAME(TYPE value) { set(kID_##NAME, Smi::FromInt(value)); } \
+  bool has_##NAME() const { return get(kID_##NAME)->IsSmi(); }
+
 #define WCM_WEAK_LINK(TYPE, NAME)                                           \
   WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, kID_##NAME, obj->IsWeakCell()); \
                                                                             \
   Handle<TYPE> NAME() const {                                               \
     return handle(TYPE::cast(weak_##NAME()->value()));                      \
   }
 
-#define CORE_WCM_PROPERTY_TABLE(MACRO)                  \
-  MACRO(WASM_OBJECT, WasmSharedModuleData, shared)      \
-  MACRO(OBJECT, Context, native_context)                \
-  MACRO(SMALL_NUMBER, uint32_t, num_imported_functions) \
-  MACRO(OBJECT, FixedArray, code_table)                 \
-  MACRO(OBJECT, FixedArray, weak_exported_functions)    \
-  MACRO(OBJECT, FixedArray, function_tables)            \
-  MACRO(OBJECT, FixedArray, signature_tables)           \
-  MACRO(OBJECT, FixedArray, empty_function_tables)      \
-  MACRO(OBJECT, JSArrayBuffer, memory)                  \
-  MACRO(SMALL_NUMBER, uint32_t, min_mem_pages)          \
-  MACRO(SMALL_NUMBER, uint32_t, max_mem_pages)          \
-  MACRO(WEAK_LINK, WasmCompiledModule, next_instance)   \
-  MACRO(WEAK_LINK, WasmCompiledModule, prev_instance)   \
-  MACRO(WEAK_LINK, JSObject, owning_instance)           \
+#define WCM_LARGE_NUMBER(TYPE, NAME)                                   \
+  TYPE NAME() const {                                                  \
+    Object* value = get(kID_##NAME);                                   \
+    DCHECK(value->IsMutableHeapNumber());                              \
+    return static_cast<TYPE>(HeapNumber::cast(value)->value());        \
+  }                                                                    \
+                                                                       \
+  void set_##NAME(TYPE value) {                                        \
+    Object* number = get(kID_##NAME);                                  \
+    DCHECK(number->IsMutableHeapNumber());                             \
+    HeapNumber::cast(number)->set_value(static_cast<double>(value));   \
+  }                                                                    \
+                                                                       \
+  static void recreate_##NAME(Handle<WasmCompiledModule> obj,          \
+                              Factory* factory, TYPE init_val) {       \
+    Handle<HeapNumber> number = factory->NewHeapNumber(                \
+        static_cast<double>(init_val), MutableMode::MUTABLE, TENURED); \
+    obj->set(kID_##NAME, *number);                                     \
+  }                                                                    \
+  bool has_##NAME() const { return get(kID_##NAME)->IsMutableHeapNumber(); }
+
+#define CORE_WCM_PROPERTY_TABLE(MACRO)                        \
+  MACRO(WASM_OBJECT, WasmSharedModuleData, shared)            \
+  MACRO(OBJECT, Context, native_context)                      \
+  MACRO(SMALL_FIXED_NUMBER, uint32_t, num_imported_functions) \
+  MACRO(OBJECT, FixedArray, code_table)                       \
+  MACRO(OBJECT, FixedArray, weak_exported_functions)          \
+  MACRO(OBJECT, FixedArray, function_tables)                  \
+  MACRO(OBJECT, FixedArray, signature_tables)                 \
+  MACRO(OBJECT, FixedArray, empty_function_tables)            \
+  MACRO(LARGE_NUMBER, size_t, embedded_mem_start)             \
+  MACRO(LARGE_NUMBER, size_t, globals_start)                  \
+  MACRO(LARGE_NUMBER, uint32_t, embedded_mem_size)            \
+  MACRO(SMALL_FIXED_NUMBER, uint32_t, min_mem_pages)          \
+  MACRO(SMALL_FIXED_NUMBER, uint32_t, max_mem_pages)          \
+  MACRO(WEAK_LINK, WasmCompiledModule, next_instance)         \
+  MACRO(WEAK_LINK, WasmCompiledModule, prev_instance)         \
+  MACRO(WEAK_LINK, JSObject, owning_instance)                 \
   MACRO(WEAK_LINK, WasmModuleObject, wasm_module)
 
 #if DEBUG
 #define DEBUG_ONLY_TABLE(MACRO) MACRO(SMALL_NUMBER, uint32_t, instance_id)
 #else
 #define DEBUG_ONLY_TABLE(IGNORE)
   uint32_t instance_id() const { return static_cast<uint32_t>(-1); }
 #endif
 
 #define WCM_PROPERTY_TABLE(MACRO) \
   CORE_WCM_PROPERTY_TABLE(MACRO)  \
   DEBUG_ONLY_TABLE(MACRO)
 
  private:
   enum PropertyIndices {
 #define INDICES(IGNORE1, IGNORE2, NAME) kID_##NAME,
     WCM_PROPERTY_TABLE(INDICES) Count
 #undef INDICES
   };
 
  public:
   static Handle<WasmCompiledModule> New(Isolate* isolate,
                                         Handle<WasmSharedModuleData> shared);
 
   static Handle<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();
-    return ret;
+                                          Handle<WasmCompiledModule> module);
+  static void Reset(Isolate* isolate, WasmCompiledModule* module);
+
+  Address GetEmbeddedMemStartOrNull() const {
+    DisallowHeapAllocation no_gc;
+    if (has_embedded_mem_start()) {
+      return reinterpret_cast<Address>(embedded_mem_start());
+    }
+    return nullptr;
+  }
+
+  Address GetGlobalsStartOrNull() const {
+    DisallowHeapAllocation no_gc;
+    if (has_globals_start()) {
+      return reinterpret_cast<Address>(globals_start());
+    }
+    return nullptr;
   }
 
   uint32_t mem_size() const;
   uint32_t default_mem_size() const;
 
+  void ResetSpecializationMemInfoIfNeeded();
+  static void SetSpecializationMemInfoFrom(
+      Factory* factory, Handle<WasmCompiledModule> compiled_module,
+      Handle<JSArrayBuffer> buffer);
+  static void SetGlobalsStartAddressFrom(
+      Factory* factory, Handle<WasmCompiledModule> compiled_module,
+      Handle<JSArrayBuffer> buffer);
+
 #define DECLARATION(KIND, TYPE, NAME) WCM_##KIND(TYPE, NAME)
   WCM_PROPERTY_TABLE(DECLARATION)
 #undef DECLARATION
 
 // Allow to call method on WasmSharedModuleData also on this object.
 #define FORWARD_SHARED(type, name) \
   type name() { return shared()->name(); }
   FORWARD_SHARED(SeqOneByteString*, module_bytes)
   FORWARD_SHARED(wasm::WasmModule*, module)
   FORWARD_SHARED(Script*, script)
@@ skipping 208 matching lines @@
   };
 };
 
 #undef DECLARE_ACCESSORS
 #undef DECLARE_OPTIONAL_ACCESSORS
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_OBJECTS_H_