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

test/cctest/wasm/wasm-run-utils.h

 // Copyright 2016 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <setjmp.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 103 matching lines @@
   }
 
   template <typename T>
   T* AddMemoryElems(uint32_t count) {
     AddMemory(count * sizeof(T));
     return raw_mem_start<T>();
   }
 
   template <typename T>
   T* AddGlobal(
-      LocalType type = WasmOpcodes::LocalTypeFor(MachineTypeForC<T>())) {
+      ValueType type = WasmOpcodes::ValueTypeFor(MachineTypeForC<T>())) {
     const WasmGlobal* global = AddGlobal(type);
     return reinterpret_cast<T*>(instance->globals_start + global->offset);
   }
 
   byte AddSignature(FunctionSig* sig) {
     module_.signatures.push_back(sig);
     size_t size = module->signatures.size();
     CHECK(size < 127);
     return static_cast<byte>(size - 1);
   }
@@ skipping 155 matching lines @@
  private:
   WasmExecutionMode execution_mode_;
   WasmModule module_;
   WasmInstance instance_;
   Isolate* isolate_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
   WasmInterpreter* interpreter_;
   Handle<WasmInstanceObject> instance_object_;
 
-  const WasmGlobal* AddGlobal(LocalType type) {
+  const WasmGlobal* AddGlobal(ValueType type) {
     byte size = WasmOpcodes::MemSize(WasmOpcodes::MachineTypeFor(type));
     global_offset = (global_offset + size - 1) & ~(size - 1);  // align
     module_.globals.push_back(
         {type, true, WasmInitExpr(), global_offset, false, false});
     global_offset += size;
     // limit number of globals.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
 
@@ skipping 206 matching lines @@
       return;
     }
 
     // Build the TurboFan graph.
     TestBuildingGraph(zone(), &jsgraph, testing_module_, sig,
                       &source_position_table_, start, end);
     Handle<Code> code = Compile();
     testing_module_->SetFunctionCode(function_index(), code);
   }
 
-  byte AllocateLocal(LocalType type) {
+  byte AllocateLocal(ValueType type) {
     uint32_t index = local_decls.AddLocals(1, type);
     byte result = static_cast<byte>(index);
     DCHECK_EQ(index, result);
     return result;
   }
 
   void SetSigIndex(int sig_index) { function_->sig_index = sig_index; }
 
  private:
   friend class WasmRunnerBase;
@@ skipping 91 matching lines @@
   // Resets the state for building the next function.
   // The main function called will be the last generated function.
   // Returns the index of the previously built function.
   WasmFunctionCompiler& NewFunction(FunctionSig* sig,
                                     const char* name = nullptr) {
     functions_.emplace_back(
         new WasmFunctionCompiler(&zone_, sig, &module_, name));
     return *functions_.back();
   }
 
-  byte AllocateLocal(LocalType type) {
+  byte AllocateLocal(ValueType type) {
     return functions_[0]->AllocateLocal(type);
   }
 
   WasmFunction* function() { return functions_[0]->function_; }
   WasmInterpreter* interpreter() { return functions_[0]->interpreter_; }
   bool possible_nondeterminism() { return possible_nondeterminism_; }
   TestingModule& module() { return module_; }
   Zone* zone() { return &zone_; }
 
   // Set the context, such that e.g. runtime functions can be called.
   void SetModuleContext() {
     if (!module_.instance->context.is_null()) {
       CHECK(module_.instance->context.is_identical_to(
           main_isolate()->native_context()));
       return;
     }
     module_.instance->context = main_isolate()->native_context();
   }
 
  private:
   FunctionSig* CreateSig(MachineType return_type,
                          Vector<MachineType> param_types) {
     int return_count = return_type.IsNone() ? 0 : 1;
     int param_count = param_types.length();
 
     // Allocate storage array in zone.
-    LocalType* sig_types =
-        zone_.NewArray<LocalType>(return_count + param_count);
+    ValueType* sig_types =
+        zone_.NewArray<ValueType>(return_count + param_count);
 
     // Convert machine types to local types, and check that there are no
     // MachineType::None()'s in the parameters.
     int idx = 0;
-    if (return_count) sig_types[idx++] = WasmOpcodes::LocalTypeFor(return_type);
+    if (return_count) sig_types[idx++] = WasmOpcodes::ValueTypeFor(return_type);
     for (MachineType param : param_types) {
       CHECK_NE(MachineType::None(), param);
-      sig_types[idx++] = WasmOpcodes::LocalTypeFor(param);
+      sig_types[idx++] = WasmOpcodes::ValueTypeFor(param);
     }
     return new (&zone_) FunctionSig(return_count, param_count, sig_types);
   }
 
   template <typename ReturnType, typename... ParamTypes>
   FunctionSig* CreateSig() {
     std::array<MachineType, sizeof...(ParamTypes)> param_machine_types{
         {MachineTypeForC<ParamTypes>()...}};
     Vector<MachineType> param_vec(param_machine_types.data(),
                                   param_machine_types.size());
@@ skipping 110 matching lines @@
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 #define WASM_EXEC_COMPILED_TEST(name)                                \
   void RunWasm_##name(WasmExecutionMode execution_mode);             \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif