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

test/cctest/wasm/test-run-wasm.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/utils.h"
@@ skipping 134 matching lines @@
 WASM_EXEC_TEST(Int32Add_P2) {
   FLAG_wasm_mv_prototype = true;
   static const byte code[] = {
       WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
   RunInt32AddTest(execution_mode, code, sizeof(code));
 }
 
 WASM_EXEC_TEST(Int32Add_block1) {
   FLAG_wasm_mv_prototype = true;
   static const byte code[] = {
-      WASM_BLOCK_TT(kAstI32, kAstI32, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)),
+      WASM_BLOCK_TT(kWasmI32, kWasmI32, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)),
       kExprI32Add};
   RunInt32AddTest(execution_mode, code, sizeof(code));
 }
 
 WASM_EXEC_TEST(Int32Add_block2) {
   FLAG_wasm_mv_prototype = true;
   static const byte code[] = {
-      WASM_BLOCK_TT(kAstI32, kAstI32, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
+      WASM_BLOCK_TT(kWasmI32, kWasmI32, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
                     kExprBr, DEPTH_0),
       kExprI32Add};
   RunInt32AddTest(execution_mode, code, sizeof(code));
 }
 
 WASM_EXEC_TEST(Int32Add_multi_if) {
   FLAG_wasm_mv_prototype = true;
   static const byte code[] = {
-      WASM_IF_ELSE_TT(kAstI32, kAstI32, WASM_GET_LOCAL(0),
+      WASM_IF_ELSE_TT(kWasmI32, kWasmI32, WASM_GET_LOCAL(0),
                       WASM_SEQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)),
                       WASM_SEQ(WASM_GET_LOCAL(1), WASM_GET_LOCAL(0))),
       kExprI32Add};
   RunInt32AddTest(execution_mode, code, sizeof(code));
 }
 
 WASM_EXEC_TEST(Float32Add) {
   WasmRunner<int32_t> r(execution_mode);
   // int(11.5f + 44.5f)
   BUILD(r,
@@ skipping 645 matching lines @@
   // select(a=0, a=1, a=2); return a
   BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(0, WASM_I8(0)),
                        WASM_TEE_LOCAL(0, WASM_I8(1)),
                        WASM_TEE_LOCAL(0, WASM_I8(2))),
         WASM_DROP, WASM_GET_LOCAL(0));
   FOR_INT32_INPUTS(i) { CHECK_EQ(2, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(Select_strict2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  r.AllocateLocal(kAstI32);
-  r.AllocateLocal(kAstI32);
+  r.AllocateLocal(kWasmI32);
+  r.AllocateLocal(kWasmI32);
   // select(b=5, c=6, a)
   BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I8(5)),
                        WASM_TEE_LOCAL(2, WASM_I8(6)), WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 5 : 6;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Select_strict3) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  r.AllocateLocal(kAstI32);
-  r.AllocateLocal(kAstI32);
+  r.AllocateLocal(kWasmI32);
+  r.AllocateLocal(kWasmI32);
   // select(b=5, c=6, a=b)
   BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I8(5)),
                        WASM_TEE_LOCAL(2, WASM_I8(6)),
                        WASM_TEE_LOCAL(0, WASM_GET_LOCAL(1))));
   FOR_INT32_INPUTS(i) {
     int32_t expected = 5;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
@@ skipping 796 matching lines @@
 
   for (int i = 0; i < kNumElems; ++i) {
     CHECK_EQ(r.module().ReadMemory(&memory[i]), r.Call(i * 4));
   }
 }
 
 WASM_EXEC_TEST(MemI32_Sum) {
   const int kNumElems = 20;
   WasmRunner<uint32_t, int32_t> r(execution_mode);
   uint32_t* memory = r.module().AddMemoryElems<uint32_t>(kNumElems);
-  const byte kSum = r.AllocateLocal(kAstI32);
+  const byte kSum = r.AllocateLocal(kWasmI32);
 
   BUILD(
       r,
       WASM_WHILE(
           WASM_GET_LOCAL(0),
           WASM_BLOCK(
               WASM_SET_LOCAL(kSum,
                              WASM_I32_ADD(WASM_GET_LOCAL(kSum),
                                           WASM_LOAD_MEM(MachineType::Int32(),
                                                         WASM_GET_LOCAL(0)))),
@@ skipping 43 matching lines @@
 WASM_EXEC_TEST(MemF32_Sum) {
   const int kSize = 5;
   WasmRunner<int32_t, int32_t> r(execution_mode);
   r.module().AddMemoryElems<float>(kSize);
   float* buffer = r.module().raw_mem_start<float>();
   r.module().WriteMemory(&buffer[0], -99.25f);
   r.module().WriteMemory(&buffer[1], -888.25f);
   r.module().WriteMemory(&buffer[2], -77.25f);
   r.module().WriteMemory(&buffer[3], 66666.25f);
   r.module().WriteMemory(&buffer[4], 5555.25f);
-  const byte kSum = r.AllocateLocal(kAstF32);
+  const byte kSum = r.AllocateLocal(kWasmF32);
 
   BUILD(
       r,
       WASM_WHILE(
           WASM_GET_LOCAL(0),
           WASM_BLOCK(
               WASM_SET_LOCAL(kSum,
                              WASM_F32_ADD(WASM_GET_LOCAL(kSum),
                                           WASM_LOAD_MEM(MachineType::Float32(),
                                                         WASM_GET_LOCAL(0)))),
               WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))),
       WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, WASM_GET_LOCAL(kSum)),
       WASM_GET_LOCAL(0));
 
   CHECK_EQ(0, r.Call(4 * (kSize - 1)));
   CHECK_NE(-99.25f, r.module().ReadMemory(&buffer[0]));
   CHECK_EQ(71256.0f, r.module().ReadMemory(&buffer[0]));
 }
 
 template <typename T>
 T GenerateAndRunFold(WasmExecutionMode execution_mode, WasmOpcode binop,
-                     T* buffer, uint32_t size, LocalType astType,
+                     T* buffer, uint32_t size, ValueType astType,
                      MachineType memType) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   T* memory = r.module().AddMemoryElems<T>(size);
   for (uint32_t i = 0; i < size; ++i) {
     r.module().WriteMemory(&memory[i], buffer[i]);
   }
   const byte kAccum = r.AllocateLocal(astType);
 
   BUILD(r, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)),
         WASM_WHILE(
             WASM_GET_LOCAL(0),
             WASM_BLOCK(WASM_SET_LOCAL(
                            kAccum, WASM_BINOP(binop, WASM_GET_LOCAL(kAccum),
                                               WASM_LOAD_MEM(
                                                   memType, WASM_GET_LOCAL(0)))),
                        WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
                                                       WASM_I8(sizeof(T)))))),
         WASM_STORE_MEM(memType, WASM_ZERO, WASM_GET_LOCAL(kAccum)),
         WASM_GET_LOCAL(0));
   r.Call(static_cast<int>(sizeof(T) * (size - 1)));
   return r.module().ReadMemory(&memory[0]);
 }
 
 WASM_EXEC_TEST(MemF64_Mul) {
   const size_t kSize = 6;
   double buffer[kSize] = {1, 2, 2, 2, 2, 2};
   double result =
       GenerateAndRunFold<double>(execution_mode, kExprF64Mul, buffer, kSize,
-                                 kAstF64, MachineType::Float64());
+                                 kWasmF64, MachineType::Float64());
   CHECK_EQ(32, result);
 }
 
 WASM_EXEC_TEST(Build_Wasm_Infinite_Loop) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // Only build the graph and compile, don't run.
   BUILD(r, WASM_INFINITE_LOOP);
 }
 
 WASM_EXEC_TEST(Build_Wasm_Infinite_Loop_effect) {
@@ skipping 292 matching lines @@
   BUILD(r, WASM_CALL_FUNCTION0(target_func.function_index()));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
 }
 
 WASM_EXEC_TEST(CallF32StackParameter) {
   WasmRunner<float> r(execution_mode);
 
   // Build the target function.
-  LocalType param_types[20];
-  for (int i = 0; i < 20; ++i) param_types[i] = kAstF32;
+  ValueType param_types[20];
+  for (int i = 0; i < 20; ++i) param_types[i] = kWasmF32;
   FunctionSig sig(1, 19, param_types);
   WasmFunctionCompiler& t = r.NewFunction(&sig);
   BUILD(t, WASM_GET_LOCAL(17));
 
   // Build the calling function.
   BUILD(r, WASM_CALL_FUNCTION(
                t.function_index(), WASM_F32(1.0f), WASM_F32(2.0f),
                WASM_F32(4.0f), WASM_F32(8.0f), WASM_F32(16.0f), WASM_F32(32.0f),
                WASM_F32(64.0f), WASM_F32(128.0f), WASM_F32(256.0f),
                WASM_F32(1.5f), WASM_F32(2.5f), WASM_F32(4.5f), WASM_F32(8.5f),
                WASM_F32(16.5f), WASM_F32(32.5f), WASM_F32(64.5f),
                WASM_F32(128.5f), WASM_F32(256.5f), WASM_F32(512.5f)));
 
   float result = r.Call();
   CHECK_EQ(256.5f, result);
 }
 
 WASM_EXEC_TEST(CallF64StackParameter) {
   WasmRunner<double> r(execution_mode);
 
   // Build the target function.
-  LocalType param_types[20];
-  for (int i = 0; i < 20; ++i) param_types[i] = kAstF64;
+  ValueType param_types[20];
+  for (int i = 0; i < 20; ++i) param_types[i] = kWasmF64;
   FunctionSig sig(1, 19, param_types);
   WasmFunctionCompiler& t = r.NewFunction(&sig);
   BUILD(t, WASM_GET_LOCAL(17));
 
   // Build the calling function.
   BUILD(r, WASM_CALL_FUNCTION(t.function_index(), WASM_F64(1.0), WASM_F64(2.0),
                               WASM_F64(4.0), WASM_F64(8.0), WASM_F64(16.0),
                               WASM_F64(32.0), WASM_F64(64.0), WASM_F64(128.0),
                               WASM_F64(256.0), WASM_F64(1.5), WASM_F64(2.5),
                               WASM_F64(4.5), WASM_F64(8.5), WASM_F64(16.5),
@@ skipping 115 matching lines @@
     Zone zone(&allocator, ZONE_NAME);
     WasmRunner<int32_t> r(execution_mode);
     r.module().AddMemory(1024);
     MachineType* memtypes = &mixed[start];
     MachineType result = memtypes[which];
 
     // =========================================================================
     // Build the selector function.
     // =========================================================================
     FunctionSig::Builder b(&zone, 1, num_params);
-    b.AddReturn(WasmOpcodes::LocalTypeFor(result));
+    b.AddReturn(WasmOpcodes::ValueTypeFor(result));
     for (int i = 0; i < num_params; ++i) {
-      b.AddParam(WasmOpcodes::LocalTypeFor(memtypes[i]));
+      b.AddParam(WasmOpcodes::ValueTypeFor(memtypes[i]));
     }
     WasmFunctionCompiler& t = r.NewFunction(b.Build());
     BUILD(t, WASM_GET_LOCAL(which));
 
     // =========================================================================
     // Build the calling function.
     // =========================================================================
     std::vector<byte> code;
 
     // Load the offset for the store.
@@ skipping 37 matching lines @@
 WASM_EXEC_TEST(MixedCall_0) { Run_WasmMixedCall_N(execution_mode, 0); }
 WASM_EXEC_TEST(MixedCall_1) { Run_WasmMixedCall_N(execution_mode, 1); }
 WASM_EXEC_TEST(MixedCall_2) { Run_WasmMixedCall_N(execution_mode, 2); }
 WASM_EXEC_TEST(MixedCall_3) { Run_WasmMixedCall_N(execution_mode, 3); }
 
 WASM_EXEC_TEST(AddCall) {
   WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
   WasmFunctionCompiler& t1 = r.NewFunction<int32_t, int32_t, int32_t>();
   BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
-  byte local = r.AllocateLocal(kAstI32);
+  byte local = r.AllocateLocal(kWasmI32);
   BUILD(r, WASM_SET_LOCAL(local, WASM_I8(99)),
         WASM_I32_ADD(WASM_CALL_FUNCTION(t1.function_index(), WASM_GET_LOCAL(0),
                                         WASM_GET_LOCAL(0)),
                      WASM_CALL_FUNCTION(t1.function_index(), WASM_GET_LOCAL(1),
                                         WASM_GET_LOCAL(local))));
 
   CHECK_EQ(198, r.Call(0));
   CHECK_EQ(200, r.Call(1));
   CHECK_EQ(100, r.Call(-49));
 }
 
 WASM_EXEC_TEST(MultiReturnSub) {
   FLAG_wasm_mv_prototype = true;
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
 
-  LocalType storage[] = {kAstI32, kAstI32, kAstI32, kAstI32};
+  ValueType storage[] = {kWasmI32, kWasmI32, kWasmI32, kWasmI32};
   FunctionSig sig_ii_ii(2, 2, storage);
   WasmFunctionCompiler& t1 = r.NewFunction(&sig_ii_ii);
   BUILD(t1, WASM_GET_LOCAL(1), WASM_GET_LOCAL(0));
 
   BUILD(r, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
         WASM_CALL_FUNCTION0(t1.function_index()), kExprI32Sub);
 
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*j) -
                                               static_cast<uint32_t>(*i));
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 template <typename T>
 void RunMultiReturnSelect(WasmExecutionMode execution_mode, const T* inputs) {
   FLAG_wasm_mv_prototype = true;
-  LocalType type = WasmOpcodes::LocalTypeFor(MachineTypeForC<T>());
-  LocalType storage[] = {type, type, type, type, type, type};
+  ValueType type = WasmOpcodes::ValueTypeFor(MachineTypeForC<T>());
+  ValueType storage[] = {type, type, type, type, type, type};
   const size_t kNumReturns = 2;
   const size_t kNumParams = arraysize(storage) - kNumReturns;
   FunctionSig sig(kNumReturns, kNumParams, storage);
 
   for (size_t i = 0; i < kNumParams; i++) {
     for (size_t j = 0; j < kNumParams; j++) {
       for (int k = 0; k < 2; k++) {
         WasmRunner<T, T, T, T, T> r(execution_mode);
         WasmFunctionCompiler& r1 = r.NewFunction(&sig);
 
@@ skipping 479 matching lines @@
 
 WASM_EXEC_TEST(F32CopySign) {
   WasmRunner<float, float, float> r(execution_mode);
   BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(copysignf(*i, *j), r.Call(*i, *j)); }
   }
 }
 
-static void CompileCallIndirectMany(LocalType param) {
+static void CompileCallIndirectMany(ValueType param) {
   // Make sure we don't run out of registers when compiling indirect calls
   // with many many parameters.
   TestSignatures sigs;
   for (byte num_params = 0; num_params < 40; ++num_params) {
     WasmRunner<void> r(kExecuteCompiled);
-    FunctionSig* sig = sigs.many(r.zone(), kAstStmt, param, num_params);
+    FunctionSig* sig = sigs.many(r.zone(), kWasmStmt, param, num_params);
 
     r.module().AddSignature(sig);
     r.module().AddSignature(sig);
     r.module().AddIndirectFunctionTable(nullptr, 0);
 
     WasmFunctionCompiler& t = r.NewFunction(sig);
 
     std::vector<byte> code;
     for (byte p = 0; p < num_params; ++p) {
       ADD_CODE(code, kExprGetLocal, p);
     }
     ADD_CODE(code, kExprI8Const, 0);
     ADD_CODE(code, kExprCallIndirect, 1, TABLE_ZERO);
 
     t.Build(&code[0], &code[0] + code.size());
   }
 }
 
-TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kAstI32); }
+TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kWasmI32); }
 
-TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
+TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kWasmF32); }
 
-TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }
+TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kWasmF64); }
 
 WASM_EXEC_TEST_WITH_TRAP(Int32RemS_dead) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_DROP,
         WASM_ZERO);
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_EQ(0, r.Call(133, 100));
   CHECK_EQ(0, r.Call(kMin, -1));
   CHECK_EQ(0, r.Call(0, 1));
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
 }