[wasm] No need to use multiple inheritance for `ModuleBytesEnv`

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"
@@ skipping 241 matching lines @@
         signature_tables(m->function_tables.size()),
         function_code(m->functions.size()) {}
 };
 
 // Interface to the storage (wire bytes) of a wasm module.
 // It is illegal for anyone receiving a ModuleWireBytes 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 ModuleWireBytes {
   ModuleWireBytes(Vector<const byte> module_bytes)
-      : module_bytes(module_bytes) {}
+      : module_bytes_(module_bytes) {}
   ModuleWireBytes(const byte* start, const byte* end)
-      : module_bytes(start, static_cast<int>(end - start)) {
+      : 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(length, 0);
     return Vector<const char>::cast(
-        module_bytes.SubVector(offset, offset + length));
+        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(length, 0);
     return Vector<const char>::cast(
-        module_bytes.SubVector(offset, offset + length));
+        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());
+    uint32_t size = static_cast<uint32_t>(module_bytes_.length());
     return offset <= size && length <= size - offset;
   }
+
+  Vector<const byte> GetFunctionBytes(const WasmFunction* function) const {
+    return module_bytes_.SubVector(function->code_start_offset,
+                                   function->code_end_offset);
+  }
+
+  const byte* start() const { return module_bytes_.start(); }
+  const byte* end() const { return module_bytes_.end(); }
+  int length() const { return module_bytes_.length(); }
+
+ private:
+  const Vector<const byte> module_bytes_;
 };
 
 // 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;
@@ skipping 36 matching lines @@
 
   static compiler::CallDescriptor* GetWasmCallDescriptor(Zone* zone,
                                                          FunctionSig* sig);
   static compiler::CallDescriptor* GetI32WasmCallDescriptor(
       Zone* zone, compiler::CallDescriptor* descriptor);
   static compiler::CallDescriptor* GetI32WasmCallDescriptorForSimd(
       Zone* zone, compiler::CallDescriptor* descriptor);
 };
 
 // A ModuleEnv together with ModuleWireBytes.
-struct ModuleBytesEnv : public ModuleEnv, public ModuleWireBytes {
+struct ModuleBytesEnv {
   ModuleBytesEnv(const WasmModule* module, WasmInstance* instance,
                  Vector<const byte> module_bytes)
-      : ModuleEnv(module, instance), ModuleWireBytes(module_bytes) {}
+      : module_env(module, instance), wire_bytes(module_bytes) {}
   ModuleBytesEnv(const WasmModule* module, WasmInstance* instance,
                  const ModuleWireBytes& wire_bytes)
-      : ModuleEnv(module, instance), ModuleWireBytes(wire_bytes) {}
+      : module_env(module, instance), wire_bytes(wire_bytes) {}
+
+  ModuleEnv module_env;
+  ModuleWireBytes wire_bytes;
 };
 
 // A helper for printing out the names of functions.
 struct WasmFunctionName {
-  WasmFunctionName(const WasmFunction* function, ModuleBytesEnv* module_env)
-      : function_(function), name_(module_env->GetNameOrNull(function)) {}
+  WasmFunctionName(const WasmFunction* function, WasmName name)
+      : function_(function), name_(name) {}
 
   const WasmFunction* function_;
   WasmName name_;
 };
 
 std::ostream& operator<<(std::ostream& os, const WasmModule& module);
 std::ostream& operator<<(std::ostream& os, const WasmFunction& function);
 std::ostream& operator<<(std::ostream& os, const WasmFunctionName& name);
 
 // Get the debug info associated with the given wasm object.
@@ skipping 75 matching lines @@
 void ValidateModuleState(Isolate* isolate, Handle<WasmModuleObject> module_obj);
 void ValidateOrphanedInstance(Isolate* isolate,
                               Handle<WasmInstanceObject> instance);
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_H_