[wasm] Remove special memory type for (internal) globals and use local type instead.

test/unittests/wasm/module-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/handles.h"
 #include "src/objects-inl.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-macro-gen.h"
@@ skipping 159 matching lines @@
 TEST_F(WasmModuleVerifyTest, DecodeEmpty) {
   static const byte data[] = {SECTION(END, 0)};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, OneGlobal) {
   static const byte data[] = {
       SECTION(GLOBALS, 5),  // --
       1,
       NAME_LENGTH(1),
-      'g',      // name
-      kMemI32,  // memory type
-      0,        // exported
+      'g',        // name
+      kLocalI32,  // local type
+      0,          // exported
   };
 
   {
     // Should decode to exactly one global.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
     EXPECT_OK(result);
     EXPECT_EQ(1, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
 
     const WasmGlobal* global = &result.val->globals.back();
 
     EXPECT_EQ(1, global->name_length);
-    EXPECT_EQ(MachineType::Int32(), global->type);
+    EXPECT_EQ(kAstI32, global->type);
     EXPECT_EQ(0, global->offset);
     EXPECT_FALSE(global->exported);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, Global_invalid_type) {
@@ skipping 30 matching lines @@
       val = next;
     } else {
       buffer.push_back(static_cast<byte>(out));
       break;
     }
   }
 }
 
 TEST_F(WasmModuleVerifyTest, NGlobals) {
   static const byte data[] = {
-      NO_NAME,  // name length
-      kMemI32,  // memory type
-      0,        // exported
+      NO_NAME,    // name length
+      kLocalF32,  // memory type
+      0,          // exported
   };
 
   for (uint32_t i = 0; i < 1000000; i = i * 13 + 1) {
     std::vector<byte> buffer;
     size_t size = SizeOfVarInt(i) + i * sizeof(data);
     const byte globals[] = {WASM_SECTION_GLOBALS, U32V_5(size)};
     for (size_t g = 0; g != sizeof(globals); ++g) {
       buffer.push_back(globals[g]);
     }
     AppendUint32v(buffer, i);  // Number of globals.
@@ skipping 28 matching lines @@
       0,        // exported
   };
 
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, TwoGlobals) {
   static const byte data[] = {
       SECTION(GLOBALS, 7),
       2,
-      NO_NAME,  // #0: name length
-      kMemF32,  // memory type
-      0,        // exported
-      NO_NAME,  // #1: name length
-      kMemF64,  // memory type
-      1,        // exported
+      NO_NAME,    // #0: name length
+      kLocalF32,  // type
+      0,          // exported
+      NO_NAME,    // #1: name length
+      kLocalF64,  // type
+      1,          // exported
   };
 
   {
     // Should decode to exactly two globals.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
     EXPECT_OK(result);
     EXPECT_EQ(2, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
 
     const WasmGlobal* g0 = &result.val->globals[0];
     const WasmGlobal* g1 = &result.val->globals[1];
 
     EXPECT_EQ(0, g0->name_length);
-    EXPECT_EQ(MachineType::Float32(), g0->type);
+    EXPECT_EQ(kAstF32, g0->type);
     EXPECT_EQ(0, g0->offset);
     EXPECT_FALSE(g0->exported);
 
     EXPECT_EQ(0, g1->name_length);
-    EXPECT_EQ(MachineType::Float64(), g1->type);
+    EXPECT_EQ(kAstF64, g1->type);
     EXPECT_EQ(8, g1->offset);
     EXPECT_TRUE(g1->exported);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, OneSignature) {
@@ skipping 516 matching lines @@
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, UnknownSectionSkipped) {
   static const byte data[] = {
       UNKNOWN_EMPTY_SECTION_NAME,
       1,  // section size
       0,  // one byte section
       SECTION(GLOBALS, 4),
       1,
-      0,        // name length
-      kMemI32,  // memory type
-      0,        // exported
+      0,          // name length
+      kLocalI32,  // memory type
+      0,          // exported
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_OK(result);
 
   EXPECT_EQ(1, result.val->globals.size());
   EXPECT_EQ(0, result.val->functions.size());
   EXPECT_EQ(0, result.val->data_segments.size());
 
   const WasmGlobal* global = &result.val->globals.back();
 
   EXPECT_EQ(0, global->name_length);
-  EXPECT_EQ(MachineType::Int32(), global->type);
+  EXPECT_EQ(kAstI32, global->type);
   EXPECT_EQ(0, global->offset);
   EXPECT_FALSE(global->exported);
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_empty) {
   static const byte data[] = {SECTION(SIGNATURES, 1), 0,
                               SECTION(IMPORT_TABLE, 1), 0};
   EXPECT_VERIFIES(data);
@@ skipping 317 matching lines @@
       NO_LOCAL_NAMES,  // --
       FOO_STRING,
       NO_LOCAL_NAMES,  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8