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

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/isolate-inl.h"
 
@@ skipping 3668 matching lines @@
   if (FLAG_trace_wasm_decode_time) {
     decode_timer.Start();
   }
   // Create a TF graph during decoding.
 
   Graph* graph = jsgraph_->graph();
   CommonOperatorBuilder* common = jsgraph_->common();
   MachineOperatorBuilder* machine = jsgraph_->machine();
   SourcePositionTable* source_position_table =
       new (jsgraph_->zone()) SourcePositionTable(graph);
-  WasmGraphBuilder builder(module_env_, jsgraph_->zone(), jsgraph_,
+  WasmGraphBuilder builder(&module_env_->module_env, jsgraph_->zone(), jsgraph_,
                            function_->sig, source_position_table);
-  const byte* module_start = module_env_->module_bytes.start();
+  const byte* module_start = module_env_->wire_bytes.start();
   wasm::FunctionBody body = {function_->sig, module_start,
                              module_start + function_->code_start_offset,
                              module_start + function_->code_end_offset};
   graph_construction_result_ =
       wasm::BuildTFGraph(isolate_->allocator(), &builder, body);
 
   if (graph_construction_result_.failed()) {
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compilation failed: " << graph_construction_result_ << std::endl;
     }
     return nullptr;
   }
 
   if (machine->Is32()) {
     Int64Lowering(graph, machine, common, jsgraph_->zone(), function_->sig)
         .LowerGraph();
   }
 
   if (builder.has_simd() && !CpuFeatures::SupportsSimd128()) {
     SimdScalarLowering(graph, machine, common, jsgraph_->zone(), function_->sig)
         .LowerGraph();
   }
 
   int index = static_cast<int>(function_->func_index);
 
   if (index >= FLAG_trace_wasm_ast_start && index < FLAG_trace_wasm_ast_end) {
     OFStream os(stdout);
-    PrintWasmCode(isolate_->allocator(), body, module_env_->module, os,
-                  nullptr);
+    PrintWasmCode(isolate_->allocator(), body, module_env_->module_env.module,
+                  os, nullptr);
   }
   if (index >= FLAG_trace_wasm_text_start && index < FLAG_trace_wasm_text_end) {
     OFStream os(stdout);
-    PrintWasmText(module_env_->module, *module_env_, function_->func_index, os,
-                  nullptr);
+    PrintWasmText(module_env_->module_env.module, module_env_->wire_bytes,
+                  function_->func_index, os, nullptr);
   }
   if (FLAG_trace_wasm_decode_time) {
     *decode_ms = decode_timer.Elapsed().InMillisecondsF();
   }
   return source_position_table;
 }
 
 WasmCompilationUnit::WasmCompilationUnit(wasm::ErrorThrower* thrower,
                                          Isolate* isolate,
                                          wasm::ModuleBytesEnv* module_env,
                                          const wasm::WasmFunction* function,
                                          uint32_t index)
     : thrower_(thrower),
       isolate_(isolate),
       module_env_(module_env),
-      function_(&module_env->module->functions[index]),
+      function_(&module_env->module_env.module->functions[index]),
       graph_zone_(new Zone(isolate->allocator(), ZONE_NAME)),
       jsgraph_(new (graph_zone()) JSGraph(
           isolate, new (graph_zone()) Graph(graph_zone()),
           new (graph_zone()) CommonOperatorBuilder(graph_zone()), nullptr,
           nullptr, new (graph_zone()) MachineOperatorBuilder(
                        graph_zone(), MachineType::PointerRepresentation(),
                        InstructionSelector::SupportedMachineOperatorFlags(),
                        InstructionSelector::AlignmentRequirements()))),
       compilation_zone_(isolate->allocator(), ZONE_NAME),
-      info_(function->name_length != 0 ? module_env->GetNameOrNull(function)
-                                       : ArrayVector("wasm"),
+      info_(function->name_length != 0
+                ? module_env->wire_bytes.GetNameOrNull(function)
+                : ArrayVector("wasm"),
             isolate, &compilation_zone_,
             Code::ComputeFlags(Code::WASM_FUNCTION)),
       job_(),
       index_(index),
       ok_(true),
       protected_instructions_(&compilation_zone_) {
   // Create and cache this node in the main thread.
   jsgraph_->CEntryStubConstant(1);
 }
 
 void WasmCompilationUnit::ExecuteCompilation() {
   // TODO(ahaas): The counters are not thread-safe at the moment.
   //    HistogramTimerScope wasm_compile_function_time_scope(
   //        isolate_->counters()->wasm_compile_function_time());
   if (FLAG_trace_wasm_compiler) {
     OFStream os(stdout);
     os << "Compiling WASM function "
-       << wasm::WasmFunctionName(function_, module_env_) << std::endl;
+       << wasm::WasmFunctionName(
+              function_, module_env_->wire_bytes.GetNameOrNull(function_))
+       << std::endl;
     os << std::endl;
   }
 
   double decode_ms = 0;
   size_t node_count = 0;
 
   std::unique_ptr<Zone> graph_zone(graph_zone_.release());
   SourcePositionTable* source_positions = BuildGraphForWasmFunction(&decode_ms);
 
   if (graph_construction_result_.failed()) {
     ok_ = false;
     return;
   }
 
   base::ElapsedTimer pipeline_timer;
   if (FLAG_trace_wasm_decode_time) {
     node_count = jsgraph_->graph()->NodeCount();
     pipeline_timer.Start();
   }
 
   // Run the compiler pipeline to generate machine code.
   CallDescriptor* descriptor = wasm::ModuleEnv::GetWasmCallDescriptor(
       &compilation_zone_, function_->sig);
   if (jsgraph_->machine()->Is32()) {
-    descriptor =
-        module_env_->GetI32WasmCallDescriptor(&compilation_zone_, descriptor);
+    descriptor = module_env_->module_env.GetI32WasmCallDescriptor(
+        &compilation_zone_, descriptor);
   }
   job_.reset(Pipeline::NewWasmCompilationJob(&info_, jsgraph_, descriptor,
                                              source_positions,
                                              &protected_instructions_));
   ok_ = job_->ExecuteJob() == CompilationJob::SUCCEEDED;
   // TODO(bradnelson): Improve histogram handling of size_t.
   // TODO(ahaas): The counters are not thread-safe at the moment.
   //    isolate_->counters()->wasm_compile_function_peak_memory_bytes()
   // ->AddSample(
   //        static_cast<int>(jsgraph->graph()->zone()->allocation_size()));
 
   if (FLAG_trace_wasm_decode_time) {
     double pipeline_ms = pipeline_timer.Elapsed().InMillisecondsF();
     PrintF(
         "wasm-compilation phase 1 ok: %d bytes, %0.3f ms decode, %zu nodes, "
         "%0.3f ms pipeline\n",
         static_cast<int>(function_->code_end_offset -
                          function_->code_start_offset),
         decode_ms, node_count, pipeline_ms);
   }
 }
 
 Handle<Code> WasmCompilationUnit::FinishCompilation() {
   if (!ok_) {
     if (graph_construction_result_.failed()) {
       // Add the function as another context for the exception
       ScopedVector<char> buffer(128);
-      wasm::WasmName name = module_env_->GetName(function_);
+      wasm::WasmName name = module_env_->wire_bytes.GetName(function_);
       SNPrintF(buffer, "Compiling WASM function #%d:%.*s failed:",
                function_->func_index, name.length(), name.start());
       thrower_->CompileFailed(buffer.start(), graph_construction_result_);
     }
 
     return Handle<Code>::null();
   }
   if (job_->FinalizeJob() != CompilationJob::SUCCEEDED) {
     return Handle<Code>::null();
   }
   base::ElapsedTimer compile_timer;
   if (FLAG_trace_wasm_decode_time) {
     compile_timer.Start();
   }
   Handle<Code> code = info_.code();
   DCHECK(!code.is_null());
 
   if (isolate_->logger()->is_logging_code_events() ||
       isolate_->is_profiling()) {
     RecordFunctionCompilation(CodeEventListener::FUNCTION_TAG, isolate_, code,
                               "WASM_function", function_->func_index,
                               wasm::WasmName("module"),
-                              module_env_->GetName(function_));
+                              module_env_->wire_bytes.GetName(function_));
   }
 
   if (FLAG_trace_wasm_decode_time) {
     double compile_ms = compile_timer.Elapsed().InMillisecondsF();
     PrintF("wasm-code-generation ok: %d bytes, %0.3f ms code generation\n",
            static_cast<int>(function_->code_end_offset -
                             function_->code_start_offset),
            compile_ms);
   }
 
@@ skipping 14 matching lines @@
                       Smi::FromInt(instruction.instr_offset));
     fn_protected->set(Code::kTrapDataSize * i + Code::kTrapLandingOffset,
                       Smi::FromInt(instruction.landing_offset));
   }
   return fn_protected;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8