[wasm] Remove raw byte pointers from WasmModule

test/unittests/wasm/ast-decoder-unittest.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 "test/unittests/test-utils.h"
 
 #include "src/v8.h"
 
 #include "test/common/wasm/test-signatures.h"
 
@@ skipping 1261 matching lines @@
       }
     }
   }
 }
 
 namespace {
 // A helper for tests that require a module environment for functions and
 // globals.
 class TestModuleEnv : public ModuleEnv {
  public:
-  TestModuleEnv() {
-    instance = nullptr;
-    module = &mod;
+  explicit TestModuleEnv(ModuleOrigin origin = kWasmOrigin)
+      : ModuleEnv(&mod, nullptr) {
+    mod.origin = origin;
   }
   byte AddGlobal(LocalType type, bool mutability = true) {
     mod.globals.push_back({type, mutability, WasmInitExpr(), 0, false, false});
     CHECK(mod.globals.size() <= 127);
     return static_cast<byte>(mod.globals.size() - 1);
   }
   byte AddSignature(FunctionSig* sig) {
     mod.signatures.push_back(sig);
     CHECK(mod.signatures.size() <= 127);
     return static_cast<byte>(mod.signatures.size() - 1);
@@ skipping 352 matching lines @@
       } else {
         EXPECT_FAILURE_S(&sig, WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0)));
       }
     }
   }
 }
 
 TEST_F(AstDecoderTest, WasmGrowMemory) {
   TestModuleEnv module_env;
   module = &module_env;
-  module->origin = kWasmOrigin;
 
   byte code[] = {WASM_GET_LOCAL(0), kExprGrowMemory, 0};
   EXPECT_VERIFIES_C(i_i, code);
   EXPECT_FAILURE_C(i_d, code);
 }
 
 TEST_F(AstDecoderTest, AsmJsGrowMemory) {
-  TestModuleEnv module_env;
+  TestModuleEnv module_env(kAsmJsOrigin);
   module = &module_env;
-  module->origin = kAsmJsOrigin;
 
   byte code[] = {WASM_GET_LOCAL(0), kExprGrowMemory, 0};
   EXPECT_FAILURE_C(i_i, code);
 }
 
 TEST_F(AstDecoderTest, AsmJsBinOpsCheckOrigin) {
   LocalType float32int32float32[] = {kAstF32, kAstI32, kAstF32};
   FunctionSig sig_f_if(1, 2, float32int32float32);
   LocalType float64int32float64[] = {kAstF64, kAstI32, kAstF64};
   FunctionSig sig_d_id(1, 2, float64int32float64);
   struct {
     WasmOpcode op;
     FunctionSig* sig;
   } AsmJsBinOps[] = {
       {kExprF64Atan2, sigs.d_dd()},
       {kExprF64Pow, sigs.d_dd()},
       {kExprF64Mod, sigs.d_dd()},
       {kExprI32AsmjsDivS, sigs.i_ii()},
       {kExprI32AsmjsDivU, sigs.i_ii()},
       {kExprI32AsmjsRemS, sigs.i_ii()},
       {kExprI32AsmjsRemU, sigs.i_ii()},
       {kExprI32AsmjsStoreMem8, sigs.i_ii()},
       {kExprI32AsmjsStoreMem16, sigs.i_ii()},
       {kExprI32AsmjsStoreMem, sigs.i_ii()},
       {kExprF32AsmjsStoreMem, &sig_f_if},
       {kExprF64AsmjsStoreMem, &sig_d_id},
   };
 
   {
-    TestModuleEnv module_env;
+    TestModuleEnv module_env(kAsmJsOrigin);
     module = &module_env;
-    module->origin = kAsmJsOrigin;
     for (size_t i = 0; i < arraysize(AsmJsBinOps); i++) {
       TestBinop(AsmJsBinOps[i].op, AsmJsBinOps[i].sig);
     }
   }
 
   {
     TestModuleEnv module_env;
     module = &module_env;
-    module->origin = kWasmOrigin;
     for (size_t i = 0; i < arraysize(AsmJsBinOps); i++) {
       byte code[] = {
           WASM_BINOP(AsmJsBinOps[i].op, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
       EXPECT_FAILURE_SC(AsmJsBinOps[i].sig, code);
     }
   }
 }
 
 TEST_F(AstDecoderTest, AsmJsUnOpsCheckOrigin) {
   LocalType float32int32[] = {kAstF32, kAstI32};
@@ skipping 16 matching lines @@
                     {kExprI32AsmjsLoadMem16S, sigs.i_i()},
                     {kExprI32AsmjsLoadMem16U, sigs.i_i()},
                     {kExprI32AsmjsLoadMem, sigs.i_i()},
                     {kExprF32AsmjsLoadMem, &sig_f_i},
                     {kExprF64AsmjsLoadMem, &sig_d_i},
                     {kExprI32AsmjsSConvertF32, sigs.i_f()},
                     {kExprI32AsmjsUConvertF32, sigs.i_f()},
                     {kExprI32AsmjsSConvertF64, sigs.i_d()},
                     {kExprI32AsmjsUConvertF64, sigs.i_d()}};
   {
-    TestModuleEnv module_env;
+    TestModuleEnv module_env(kAsmJsOrigin);
     module = &module_env;
-    module->origin = kAsmJsOrigin;
     for (size_t i = 0; i < arraysize(AsmJsUnOps); i++) {
       TestUnop(AsmJsUnOps[i].op, AsmJsUnOps[i].sig);
     }
   }
 
   {
     TestModuleEnv module_env;
     module = &module_env;
-    module->origin = kWasmOrigin;
     for (size_t i = 0; i < arraysize(AsmJsUnOps); i++) {
       byte code[] = {WASM_UNOP(AsmJsUnOps[i].op, WASM_GET_LOCAL(0))};
       EXPECT_FAILURE_SC(AsmJsUnOps[i].sig, code);
     }
   }
 }
 
 TEST_F(AstDecoderTest, BreakEnd) {
   EXPECT_VERIFIES(
       i_i, WASM_BLOCK_I(WASM_I32_ADD(WASM_BRV(0, WASM_ZERO), WASM_ZERO)));
@@ skipping 942 matching lines @@
   iter.next();
   EXPECT_TRUE(iter.has_next());
   EXPECT_EQ(kExprI8Const, iter.current());
   iter.next();
   EXPECT_FALSE(iter.has_next());
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8