[wasm] Remove raw byte pointers from WasmModule

src/wasm/wasm-module.h

Index: src/wasm/wasm-module.h
diff --git a/src/wasm/wasm-module.h b/src/wasm/wasm-module.h
index 3dc58b8448660831542b9bce58389d3f8428fcba..dabdf0858037d560a657986866d512ecf90aff08 100644
--- a/src/wasm/wasm-module.h
+++ b/src/wasm/wasm-module.h
@@ -177,6 +177,7 @@ struct WasmExport {
 };
 
 enum ModuleOrigin { kWasmOrigin, kAsmJsOrigin };
+struct ModuleStorage;

[titzer, 2016/11/30 13:13:42]

Can we call this ModuleWireBytes? or ModuleRawBytes? The idea is that this
represents the bytes we get over the wire or from disk.

[Clemens Hammacher, 2016/11/30 14:28:45]

I renamed ModuleStorage to ModuleWireBytes and ModuleStorageEnv to
ModuleBytesEnv.

 
 // Static representation of a module.
 struct V8_EXPORT_PRIVATE WasmModule {
@@ -187,8 +188,6 @@ struct V8_EXPORT_PRIVATE WasmModule {
   static const size_t kV8MaxTableSize = 16 * 1024 * 1024;
 
   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 has_memory = false;     // true if the memory was defined or imported
@@ -220,46 +219,12 @@ struct V8_EXPORT_PRIVATE WasmModule {
   // switch to libc-2.21 or higher.
   std::unique_ptr<base::Semaphore> pending_tasks;
 
-  WasmModule() : WasmModule(nullptr, nullptr) {}
-  WasmModule(Zone* owned_zone, const byte* module_start);
+  WasmModule() : WasmModule(nullptr) {}
+  WasmModule(Zone* owned_zone);
   ~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)};
-  }
-
-  // Get a string stored in the module bytes representing a function name.
-  WasmName GetName(WasmFunction* function) const {
-    return GetName(function->name_offset, function->name_length);
-  }
-
-  // Get a string stored in the module bytes representing a name.
-  WasmName GetNameOrNull(uint32_t offset, uint32_t length) const {
-    if (offset == 0 && length == 0) return {NULL, 0};  // 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)};
-  }
-
-  // Get a string stored in the module bytes representing a function name.
-  WasmName GetNameOrNull(const WasmFunction* function) const {
-    return GetNameOrNull(function->name_offset, function->name_length);
-  }
-
-  // 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.
   static MaybeHandle<WasmInstanceObject> Instantiate(
       Isolate* isolate, ErrorThrower* thrower, Handle<JSObject> wasm_module,
@@ -267,7 +232,7 @@ struct V8_EXPORT_PRIVATE WasmModule {
 
   MaybeHandle<WasmCompiledModule> CompileFunctions(
       Isolate* isolate, Handle<Managed<WasmModule>> module_wrapper,
-      ErrorThrower* thrower) const;
+      ErrorThrower* thrower, const ModuleStorage& storage) const;
 };
 
 typedef Managed<WasmModule> WasmModuleWrapper;
@@ -294,12 +259,62 @@ struct WasmInstance {
         function_code(m->functions.size()) {}
 };
 
+// Interface to the storage (wire bytes) of a wasm module.
+// It is illegal for anyone receiving a ModuleStorage to store pointers based on
+// module_bytes, as this storage is only guaranteed to be alive as long as this
+// struct is alive.
+struct V8_EXPORT_PRIVATE ModuleStorage {
+  ModuleStorage(Vector<const byte> module_bytes) : module_bytes(module_bytes) {}
+  ModuleStorage(const byte* start, const byte* end)
+      : module_bytes(start, static_cast<int>(end - start)) {
+    DCHECK_GE(kMaxInt, end - start);
+  }
+
+  const Vector<const byte> module_bytes;
+
+  // 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, length));
+    DCHECK_GE(static_cast<int>(length), 0);
+    return Vector<const char>::cast(
+        module_bytes.SubVector(offset, offset + length));
+  }
+
+  // Get a string stored in the module bytes representing a function name.
+  WasmName GetName(const WasmFunction* function) const {
+    return GetName(function->name_offset, function->name_length);
+  }
+
+  // Get a string stored in the module bytes representing a name.
+  WasmName GetNameOrNull(uint32_t offset, uint32_t length) const {
+    if (offset == 0 && length == 0) return {NULL, 0};  // no name.
+    CHECK(BoundsCheck(offset, length));
+    DCHECK_GE(static_cast<int>(length), 0);
+    return Vector<const char>::cast(
+        module_bytes.SubVector(offset, offset + length));
+  }
+
+  // Get a string stored in the module bytes representing a function name.
+  WasmName GetNameOrNull(const WasmFunction* function) const {
+    return GetNameOrNull(function->name_offset, function->name_length);
+  }
+
+  // Checks the given offset range is contained within the module bytes.
+  bool BoundsCheck(uint32_t offset, uint32_t length) const {
+    uint32_t size = static_cast<uint32_t>(module_bytes.length());
+    return offset <= size && length <= size - offset;
+  }
+};
+
 // Interface provided to the decoder/graph builder which contains only
 // minimal information about the globals, functions, and function tables.
 struct V8_EXPORT_PRIVATE ModuleEnv {
+  ModuleEnv(const WasmModule* module, WasmInstance* instance)
+      : module(module), instance(instance) {}
+
   const WasmModule* module;
   WasmInstance* instance;
-  ModuleOrigin origin;
 
   bool IsValidGlobal(uint32_t index) const {
     return module && index < module->globals.size();
@@ -330,7 +345,7 @@ struct V8_EXPORT_PRIVATE ModuleEnv {
     return &module->function_tables[index];
   }
 
-  bool asm_js() { return origin == kAsmJsOrigin; }
+  bool asm_js() { return module->origin == kAsmJsOrigin; }
 
   Handle<Code> GetFunctionCode(uint32_t index) {
     DCHECK_NOT_NULL(instance);
@@ -345,12 +360,23 @@ struct V8_EXPORT_PRIVATE ModuleEnv {
       Zone* zone, compiler::CallDescriptor* descriptor);
 };
 
+// A ModuleEnv together with ModuleStorage.
+struct ModuleStorageEnv : public ModuleEnv, public ModuleStorage {
+  ModuleStorageEnv(const WasmModule* module, WasmInstance* instance,
+                   Vector<const byte> module_bytes)
+      : ModuleEnv(module, instance), ModuleStorage(module_bytes) {}
+  ModuleStorageEnv(const WasmModule* module, WasmInstance* instance,
+                   const ModuleStorage& storage)
+      : ModuleEnv(module, instance), ModuleStorage(storage) {}
+};
+
 // A helper for printing out the names of functions.
 struct WasmFunctionName {
+  WasmFunctionName(const WasmFunction* function, ModuleStorageEnv* module_env)
+      : function_(function), name_(module_env->GetNameOrNull(function)) {}
+
   const WasmFunction* function_;
-  const WasmModule* module_;
-  WasmFunctionName(const WasmFunction* function, const ModuleEnv* menv)
-      : function_(function), module_(menv ? menv->module : nullptr) {}
+  WasmName name_;
 };
 
 std::ostream& operator<<(std::ostream& os, const WasmModule& module);