[wasm] Rename wasm::LocalType to wasm::ValueType and kAst* to kWasm*

test/cctest/wasm/test-run-wasm-module.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 <stdlib.h>
 #include <string.h>
 
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
 #include "src/wasm/module-decoder.h"
@@ skipping 121 matching lines @@
 TEST(Run_WasmModule_CheckMemoryIsZero) {
   {
     static const int kCheckSize = 16 * 1024;
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
     TestSignatures sigs;
 
     WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
     WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
 
-    uint16_t localIndex = f->AddLocal(kAstI32);
+    uint16_t localIndex = f->AddLocal(kWasmI32);
     ExportAsMain(f);
     byte code[] = {WASM_BLOCK_I(
         WASM_WHILE(
             WASM_I32_LTS(WASM_GET_LOCAL(localIndex), WASM_I32V_3(kCheckSize)),
             WASM_IF_ELSE(
                 WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(localIndex)),
                 WASM_BRV(3, WASM_I8(-1)), WASM_INC_LOCAL_BY(localIndex, 4))),
         WASM_I8(11))};
     f->EmitCode(code, sizeof(code));
     TestModule(&zone, builder, 11);
   }
   Cleanup();
 }
 
 TEST(Run_WasmModule_CallMain_recursive) {
   {
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
     TestSignatures sigs;
 
     WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
     WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
 
-    uint16_t localIndex = f->AddLocal(kAstI32);
+    uint16_t localIndex = f->AddLocal(kWasmI32);
     ExportAsMain(f);
     byte code[] = {
         WASM_SET_LOCAL(localIndex,
                        WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)),
         WASM_IF_ELSE_I(WASM_I32_LTS(WASM_GET_LOCAL(localIndex), WASM_I8(5)),
                        WASM_SEQ(WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO,
                                                WASM_INC_LOCAL(localIndex)),
                                 WASM_CALL_FUNCTION0(0)),
                        WASM_I8(55))};
     f->EmitCode(code, sizeof(code));
     TestModule(&zone, builder, 55);
   }
   Cleanup();
 }
 
 TEST(Run_WasmModule_Global) {
   {
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
     TestSignatures sigs;
 
     WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-    uint32_t global1 = builder->AddGlobal(kAstI32, 0);
-    uint32_t global2 = builder->AddGlobal(kAstI32, 0);
+    uint32_t global1 = builder->AddGlobal(kWasmI32, 0);
+    uint32_t global2 = builder->AddGlobal(kWasmI32, 0);
     WasmFunctionBuilder* f1 = builder->AddFunction(sigs.i_v());
     byte code1[] = {
         WASM_I32_ADD(WASM_GET_GLOBAL(global1), WASM_GET_GLOBAL(global2))};
     f1->EmitCode(code1, sizeof(code1));
     WasmFunctionBuilder* f2 = builder->AddFunction(sigs.i_v());
     ExportAsMain(f2);
     byte code2[] = {WASM_SET_GLOBAL(global1, WASM_I32V_1(56)),
                     WASM_SET_GLOBAL(global2, WASM_I32V_1(41)),
                     WASM_RETURN1(WASM_CALL_FUNCTION0(f1->func_index()))};
     f2->EmitCode(code2, sizeof(code2));
@@ skipping 508 matching lines @@
 }
 
 TEST(Run_WasmModule_Global_init) {
   {
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
     TestSignatures sigs;
 
     WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
     uint32_t global1 =
-        builder->AddGlobal(kAstI32, false, false, WasmInitExpr(777777));
+        builder->AddGlobal(kWasmI32, false, false, WasmInitExpr(777777));
     uint32_t global2 =
-        builder->AddGlobal(kAstI32, false, false, WasmInitExpr(222222));
+        builder->AddGlobal(kWasmI32, false, false, WasmInitExpr(222222));
     WasmFunctionBuilder* f1 = builder->AddFunction(sigs.i_v());
     byte code[] = {
         WASM_I32_ADD(WASM_GET_GLOBAL(global1), WASM_GET_GLOBAL(global2))};
     f1->EmitCode(code, sizeof(code));
     ExportAsMain(f1);
     TestModule(&zone, builder, 999999);
   }
   Cleanup();
 }
 
 template <typename CType>
-static void RunWasmModuleGlobalInitTest(LocalType type, CType expected) {
+static void RunWasmModuleGlobalInitTest(ValueType type, CType expected) {
   {
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
     TestSignatures sigs;
 
-    LocalType types[] = {type};
+    ValueType types[] = {type};
     FunctionSig sig(1, 0, types);
 
     for (int padding = 0; padding < 5; padding++) {
       // Test with a simple initializer
       WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
 
       for (int i = 0; i < padding; i++) {  // pad global before
-        builder->AddGlobal(kAstI32, false, false, WasmInitExpr(i + 20000));
+        builder->AddGlobal(kWasmI32, false, false, WasmInitExpr(i + 20000));
       }
       uint32_t global =
           builder->AddGlobal(type, false, false, WasmInitExpr(expected));
       for (int i = 0; i < padding; i++) {  // pad global after
-        builder->AddGlobal(kAstI32, false, false, WasmInitExpr(i + 30000));
+        builder->AddGlobal(kWasmI32, false, false, WasmInitExpr(i + 30000));
       }
 
       WasmFunctionBuilder* f1 = builder->AddFunction(&sig);
       byte code[] = {WASM_GET_GLOBAL(global)};
       f1->EmitCode(code, sizeof(code));
       ExportAsMain(f1);
       TestModule(&zone, builder, expected);
     }
   }
   Cleanup();
 }
 
 TEST(Run_WasmModule_Global_i32) {
-  RunWasmModuleGlobalInitTest<int32_t>(kAstI32, -983489);
-  RunWasmModuleGlobalInitTest<int32_t>(kAstI32, 11223344);
+  RunWasmModuleGlobalInitTest<int32_t>(kWasmI32, -983489);
+  RunWasmModuleGlobalInitTest<int32_t>(kWasmI32, 11223344);
 }
 
 TEST(Run_WasmModule_Global_f32) {
-  RunWasmModuleGlobalInitTest<float>(kAstF32, -983.9f);
-  RunWasmModuleGlobalInitTest<float>(kAstF32, 1122.99f);
+  RunWasmModuleGlobalInitTest<float>(kWasmF32, -983.9f);
+  RunWasmModuleGlobalInitTest<float>(kWasmF32, 1122.99f);
 }
 
 TEST(Run_WasmModule_Global_f64) {
-  RunWasmModuleGlobalInitTest<double>(kAstF64, -833.9);
-  RunWasmModuleGlobalInitTest<double>(kAstF64, 86374.25);
+  RunWasmModuleGlobalInitTest<double>(kWasmF64, -833.9);
+  RunWasmModuleGlobalInitTest<double>(kWasmF64, 86374.25);
 }
 
 TEST(InitDataAtTheUpperLimit) {
   {
     Isolate* isolate = CcTest::InitIsolateOnce();
     HandleScope scope(isolate);
     testing::SetupIsolateForWasmModule(isolate);
 
     ErrorThrower thrower(isolate, "Run_WasmModule_InitDataAtTheUpperLimit");
 
@@ skipping 121 matching lines @@
     };
 
     testing::CompileInstantiateWasmModuleForTesting(isolate, &thrower, data,
                                                     data + arraysize(data),
                                                     ModuleOrigin::kWasmOrigin);
     // It should be possible to instantiate this module.
     CHECK(!thrower.error());
   }
   Cleanup();
 }