[wasm] Use a Managed<WasmModule> to hold metadata about modules.

src/wasm/wasm-module.h

 // 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.
 
 #ifndef V8_WASM_MODULE_H_
 #define V8_WASM_MODULE_H_
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/handles.h"
 #include "src/parsing/preparse-data.h"
 
+#include "src/wasm/managed.h"
 #include "src/wasm/signature-map.h"
 #include "src/wasm/wasm-opcodes.h"
 
 namespace v8 {
 namespace internal {
 
 namespace compiler {
 class CallDescriptor;
 class WasmCompilationUnit;
 }
@@ skipping 144 matching lines @@
 
 class WasmCompiledModule;
 
 // Static representation of a module.
 struct WasmModule {
   static const uint32_t kPageSize = 0x10000;    // Page size, 64kb.
   static const uint32_t kMaxLegalPages = 65536;  // Maximum legal pages
   static const uint32_t kMinMemPages = 1;       // Minimum memory size = 64kb
   static const uint32_t kMaxMemPages = 16384;   // Maximum memory size =  1gb
 
-  const byte* module_start;   // starting address for the module bytes.
-  const byte* module_end;     // end address for the module bytes.
-  uint32_t min_mem_pages;     // minimum size of the memory in 64k pages.
-  uint32_t max_mem_pages;     // maximum size of the memory in 64k pages.
-  bool mem_export;            // true if the memory is exported.
+  Zone* owned_zone;
+  const byte* module_start = nullptr;  // starting address for the module bytes
+  const byte* module_end = nullptr;    // end address for the module bytes
+  uint32_t min_mem_pages = 0;  // minimum size of the memory in 64k pages
+  uint32_t max_mem_pages = 0;  // maximum size of the memory in 64k pages
+  bool mem_export = false;     // true if the memory is exported
   // TODO(wasm): reconcile start function index being an int with
   // the fact that we index on uint32_t, so we may technically not be
   // able to represent some start_function_index -es.
-  int start_function_index;   // start function, if any.
-  ModuleOrigin origin;        // origin of the module
+  int start_function_index = -1;      // start function, if any
+  ModuleOrigin origin = kWasmOrigin;  // origin of the module
 
   std::vector<WasmGlobal> globals;             // globals in this module.
-  uint32_t globals_size;                       // size of globals table.
-  uint32_t num_imported_functions;             // number of imported functions.
-  uint32_t num_declared_functions;             // number of declared functions.
-  uint32_t num_exported_functions;             // number of exported functions.
+  uint32_t globals_size = 0;                   // size of globals table.
+  uint32_t num_imported_functions = 0;         // number of imported functions.
+  uint32_t num_declared_functions = 0;         // number of declared functions.
+  uint32_t num_exported_functions = 0;         // number of exported functions.
   std::vector<FunctionSig*> signatures;        // signatures in this module.
   std::vector<WasmFunction> functions;         // functions in this module.
   std::vector<WasmDataSegment> data_segments;  // data segments in this module.
   std::vector<WasmIndirectFunctionTable> function_tables;  // function tables.
   std::vector<WasmImport> import_table;        // import table.
   std::vector<WasmExport> export_table;        // export table.
   std::vector<WasmTableInit> table_inits;      // initializations of tables
   // We store the semaphore here to extend its lifetime. In <libc-2.21, which we
   // use on the try bots, semaphore::Wait() can return while some compilation
   // tasks are still executing semaphore::Signal(). If the semaphore is cleaned
   // up right after semaphore::Wait() returns, then this can cause an
   // invalid-semaphore error in the compilation tasks.
   // TODO(wasm): Move this semaphore back to CompileInParallel when the try bots
   // switch to libc-2.21 or higher.
   std::unique_ptr<base::Semaphore> pending_tasks;
 
-  WasmModule() : WasmModule(nullptr) {}
-  explicit WasmModule(byte* module_start);
+  WasmModule() : WasmModule(nullptr, nullptr) {}
+  WasmModule(Zone* owned_zone, const byte* module_start);
+  ~WasmModule() {
+    if (owned_zone) delete owned_zone;
+  }
 
   // Get a string stored in the module bytes representing a name.
   WasmName GetName(uint32_t offset, uint32_t length) const {
     if (length == 0) return {"<?>", 3};  // no name.
     CHECK(BoundsCheck(offset, offset + length));
     DCHECK_GE(static_cast<int>(length), 0);
     return {reinterpret_cast<const char*>(module_start + offset),
             static_cast<int>(length)};
   }
 
@@ skipping 17 matching lines @@
   }
 
   // Checks the given offset range is contained within the module bytes.
   bool BoundsCheck(uint32_t start, uint32_t end) const {
     size_t size = module_end - module_start;
     return start <= size && end <= size;
   }
 
   // Creates a new instantiation of the module in the given isolate.
   V8_EXPORT_PRIVATE static MaybeHandle<JSObject> Instantiate(
-      Isolate* isolate, ErrorThrower* thrower, Handle<JSObject> module_object,
+      Isolate* isolate, ErrorThrower* thrower, Handle<JSObject> wasm_module,
       Handle<JSReceiver> ffi, Handle<JSArrayBuffer> memory);
 
-  MaybeHandle<WasmCompiledModule> CompileFunctions(Isolate* isolate,
-                                                   ErrorThrower* thrower) const;
+  MaybeHandle<WasmCompiledModule> CompileFunctions(
+      Isolate* isolate, Handle<Managed<WasmModule>> module_wrapper,
+      ErrorThrower* thrower) const;
+};
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(WasmModule);
-};
+typedef Managed<WasmModule> WasmModuleWrapper;
 
 // An instantiated WASM module, including memory, function table, etc.
 struct WasmInstance {
   const WasmModule* module;  // static representation of the module.
   // -- Heap allocated --------------------------------------------------------
   Handle<JSObject> js_object;            // JavaScript module object.
   Handle<Context> context;               // JavaScript native context.
   Handle<JSArrayBuffer> mem_buffer;      // Handle to array buffer of memory.
   Handle<JSArrayBuffer> globals_buffer;  // Handle to array buffer of globals.
   std::vector<Handle<FixedArray>> function_tables;  // indirect function tables.
   std::vector<Handle<Code>> function_code;  // code objects for each function.
   // -- raw memory ------------------------------------------------------------
-  byte* mem_start;  // start of linear memory.
-  uint32_t mem_size;  // size of the linear memory.
+  byte* mem_start = nullptr;  // start of linear memory.
+  uint32_t mem_size = 0;      // size of the linear memory.
   // -- raw globals -----------------------------------------------------------
-  byte* globals_start;  // start of the globals area.
+  byte* globals_start = nullptr;  // start of the globals area.
 
   explicit WasmInstance(const WasmModule* m)
       : module(m),
         function_tables(m->function_tables.size()),
-        function_code(m->functions.size()),
-        mem_start(nullptr),
-        mem_size(0),
-        globals_start(nullptr) {}
+        function_code(m->functions.size()) {}
 };
 
 // Interface provided to the decoder/graph builder which contains only
 // minimal information about the globals, functions, and function tables.
 struct ModuleEnv {
   const WasmModule* module;
   WasmInstance* instance;
   ModuleOrigin origin;
 
   bool IsValidGlobal(uint32_t index) const {
@@ skipping 88 matching lines @@
 
 #define WCM_WEAK_LINK(TYPE, NAME)                        \
   WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, kID_##NAME); \
                                                          \
   Handle<TYPE> NAME() const {                            \
     return handle(TYPE::cast(weak_##NAME()->value()));   \
   }
 
 #define CORE_WCM_PROPERTY_TABLE(MACRO)                \
   MACRO(OBJECT, FixedArray, code_table)               \
-  MACRO(OBJECT, FixedArray, imports)                  \
-  MACRO(OBJECT, FixedArray, exports)                  \
-  MACRO(OBJECT, FixedArray, inits)                    \
-  MACRO(OBJECT, FixedArray, startup_function)         \
-  MACRO(OBJECT, FixedArray, indirect_function_tables) \
+  MACRO(OBJECT, Foreign, module_wrapper)              \

[Mircea Trofin, 2016/10/15 17:38:41]

I assume the pointer held by the Foreign is deleted when the Foreign object is
collected?

   MACRO(OBJECT, SeqOneByteString, module_bytes)       \
-  MACRO(OBJECT, ByteArray, function_names)            \
   MACRO(OBJECT, Script, asm_js_script)                \
+  MACRO(OBJECT, FixedArray, function_tables)          \

[Mircea Trofin, 2016/10/15 17:38:41]

Why drop the "indirect" prefix?

   MACRO(OBJECT, ByteArray, asm_js_offset_tables)      \
-  MACRO(SMALL_NUMBER, uint32_t, min_memory_pages)     \
-  MACRO(OBJECT, FixedArray, data_segments_info)       \
-  MACRO(OBJECT, ByteArray, data_segments)             \
-  MACRO(SMALL_NUMBER, uint32_t, globals_size)         \
-  MACRO(OBJECT, JSArrayBuffer, heap)                  \
-  MACRO(SMALL_NUMBER, ModuleOrigin, origin)           \
+  MACRO(OBJECT, JSArrayBuffer, memory)                \
   MACRO(WEAK_LINK, WasmCompiledModule, next_instance) \
   MACRO(WEAK_LINK, WasmCompiledModule, prev_instance) \
   MACRO(WEAK_LINK, JSObject, owning_instance)         \
-  MACRO(WEAK_LINK, JSObject, module_object)
+  MACRO(WEAK_LINK, JSObject, 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 -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,
-                                        uint32_t min_memory_pages,
-                                        uint32_t globals_size,
-                                        ModuleOrigin origin);
+  static Handle<WasmCompiledModule> New(
+      Isolate* isolate, Handle<Managed<WasmModule>> module_wrapper);
 
   static Handle<WasmCompiledModule> Clone(Isolate* isolate,
                                           Handle<WasmCompiledModule> module) {
     Handle<WasmCompiledModule> ret = Handle<WasmCompiledModule>::cast(
         isolate->factory()->CopyFixedArray(module));
-    ret->Init();
+    ret->InitId();
     ret->reset_weak_owning_instance();
     ret->reset_weak_next_instance();
     ret->reset_weak_prev_instance();
     return ret;
   }
 
+  void clear_module_wrapper(Isolate* isolate) {
+    set(kID_module_wrapper, *isolate->factory()->null_value());
+  }
+
+  uint32_t min_memory_pages() const;
+
   uint32_t mem_size() const {
-    DCHECK(has_heap());
-    return heap()->byte_length()->Number();
+    DCHECK(has_memory());
+    return memory()->byte_length()->Number();
   }
 
   uint32_t default_mem_size() const {
     return min_memory_pages() * WasmModule::kPageSize;
   }
 
 #define DECLARATION(KIND, TYPE, NAME) WCM_##KIND(TYPE, NAME)
   WCM_PROPERTY_TABLE(DECLARATION)
 #undef DECLARATION
 
   static bool IsWasmCompiledModule(Object* obj);
 
   void PrintInstancesChain();
 
+  static void RecreateModuleWrapper(Isolate* isolate,
+                                    Handle<FixedArray> compiled_module);
+
  private:
-  void Init();
+  void InitId();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WasmCompiledModule);
 };
 
 // Extract a function name from the given wasm object.
 // Returns "<WASM UNNAMED>" if the function is unnamed or the name is not a
 // valid UTF-8 string.
 Handle<String> GetWasmFunctionName(Isolate* isolate, Handle<Object> wasm,
                                    uint32_t func_index);
 
 // Extract a function name from the given wasm object.
 // Returns a null handle if the function is unnamed or the name is not a valid
 // UTF-8 string.
 Handle<Object> GetWasmFunctionNameOrNull(Isolate* isolate, Handle<Object> wasm,
                                          uint32_t func_index);
 
 // Return the binary source bytes of a wasm module.
 Handle<SeqOneByteString> GetWasmBytes(Handle<JSObject> wasm);
 
 // Get the debug info associated with the given wasm object.
 // If no debug info exists yet, it is created automatically.
 Handle<WasmDebugInfo> GetDebugInfo(Handle<JSObject> wasm);
 
 // Return the number of functions in the given wasm object.
 int GetNumberOfFunctions(Handle<JSObject> wasm);
 
 // Create and export JSFunction
 Handle<JSFunction> WrapExportCodeAsJSFunction(Isolate* isolate,
                                               Handle<Code> export_code,
-                                              Handle<String> name, int arity,
-                                              MaybeHandle<ByteArray> signature,
+                                              Handle<String> name,
+                                              FunctionSig* sig,
                                               Handle<JSObject> module_instance);
 
-// Check whether the given object is a wasm object.
+// Check whether the given object represents a WebAssembly.Module instance.
 // This checks the number and type of internal fields, so it's not 100 percent
 // secure. If it turns out that we need more complete checks, we could add a
 // special marker as internal field, which will definitely never occur anywhere
 // else.
-bool IsWasmObject(Object* object);
+bool IsWasmModule(Object* wasm_module);

[Mircea Trofin, 2016/10/15 17:38:41]

I also think "WasmModule" is a better name than "WasmObject", however, our code
has 2 types of objects that are "WasmModules": an instance of the native
WasmModule struct; and an instance of WebAssembly.Module.

Separately, we have the compiled data, currently referred to
"WasmCompiledModule", which is also talking about "WasmModule".

(While we're at it) we also have the wire bytes, and I think we landed on
"WasmWireBytes" as a term to refer to them.

Separate from this CL, I think we should take a look at all these concepts and
come up with a terminology we can use consistently internally. Opened
https://bugs.chromium.org/p/v8/issues/detail?id=5521 to track.

 
-// Return the compiled module object for this wasm object.
-WasmCompiledModule* GetCompiledModule(JSObject* wasm);
+// Return the compiled module object for this WASM module.
+WasmCompiledModule* GetCompiledModule(Object* wasm_module);
 
 // Check whether the wasm module was generated from asm.js code.
-bool WasmIsAsmJs(Object* wasm, Isolate* isolate);
+bool WasmIsAsmJs(Object* instance, Isolate* isolate);
 
 // Get the script for the asm.js origin of the wasm module.
 Handle<Script> GetAsmWasmScript(Handle<JSObject> wasm);
 
 // Get the asm.js source position for the given byte offset in the given
 // function.
 int GetAsmWasmSourcePosition(Handle<JSObject> wasm, int func_index,
                              int byte_offset);
 
 // Update memory references of code objects associated with the module
 bool UpdateWasmModuleMemory(Handle<JSObject> object, Address old_start,
                             Address new_start, uint32_t old_size,
                             uint32_t new_size);
 
 // Constructs a single function table as a FixedArray of double size,
 // populating it with function signature indices and function indices.
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate, uint32_t index,
                                       const WasmModule* module);
 
 // Populates a function table by replacing function indices with handles to
 // the compiled code.
 void PopulateFunctionTable(Handle<FixedArray> table, uint32_t table_size,
                            const std::vector<Handle<Code>>* code_table);
 
-Handle<JSObject> CreateCompiledModuleObject(
+Handle<JSObject> CreateWasmModuleObject(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module,
     ModuleOrigin origin);
 
 V8_EXPORT_PRIVATE MaybeHandle<JSObject> CreateModuleObjectFromBytes(
     Isolate* isolate, const byte* start, const byte* end, ErrorThrower* thrower,
     ModuleOrigin origin, Handle<Script> asm_js_script,
     const byte* asm_offset_tables_start, const byte* asm_offset_tables_end);
 
 V8_EXPORT_PRIVATE bool ValidateModuleBytes(Isolate* isolate, const byte* start,
                                            const byte* end,
@@ skipping 11 matching lines @@
 MaybeHandle<JSArrayBuffer> GetInstanceMemory(Isolate* isolate,
                                              Handle<JSObject> instance);
 
 int32_t GetInstanceMemorySize(Isolate* isolate, Handle<JSObject> instance);
 
 int32_t GrowInstanceMemory(Isolate* isolate, Handle<JSObject> instance,
                            uint32_t pages);
 
 namespace testing {
 
-void ValidateInstancesChain(Isolate* isolate, Handle<JSObject> module_obj,
+void ValidateInstancesChain(Isolate* isolate, Handle<JSObject> wasm_module,
                             int instance_count);
-void ValidateModuleState(Isolate* isolate, Handle<JSObject> module_obj);
+void ValidateModuleState(Isolate* isolate, Handle<JSObject> wasm_module);
 void ValidateOrphanedInstance(Isolate* isolate, Handle<JSObject> instance);
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_H_