[wasm] Rename GrowMemory to MemoryGrow

The "grow_memory" opcode was renamed to "memory.grow", and the spec
repo was updated to use kExprMemoryGrow internally instead of
kExprGrowMemory (https://github.com/WebAssembly/spec/pull/720).
This CL does the same change for v8.

Drive-by: Rename "current_size" to "memory.size", and a minor cleanup
in wasm-graph-builder.js to bring it in line with the version in the
js-api tests in the spec repo.

R=titzer@chromium.org

Change-Id: If525dba898b2c248890a616d3392c22b45f698ef
Reviewed-on: https://chromium-review.googlesource.com/c/1302057Reviewed-by: Ben Titzer <titzer@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57089}

src/builtins/builtins-definitions.h

@@ -1217,7 +1217,7 @@ namespace internal {
   ASM(WasmCompileLazy)                                                         \
   TFC(WasmAllocateHeapNumber, AllocateHeapNumber, 1)                           \
   TFC(WasmCallJavaScript, CallTrampoline, 1)                                   \
-  TFC(WasmGrowMemory, WasmGrowMemory, 1)                                       \
+  TFC(WasmMemoryGrow, WasmMemoryGrow, 1)                                       \
   TFC(WasmRecordWrite, RecordWrite, 1)                                         \
   TFC(WasmStackGuard, NoContext, 1)                                            \
   TFC(WasmToNumber, TypeConversion, 1)                                         \
@@ -1512,7 +1512,7 @@ namespace internal {
   FOREACH_WASM_TRAPREASON(VTRAP)         \
   V(WasmAllocateHeapNumber)              \
   V(WasmCallJavaScript)                  \
-  V(WasmGrowMemory)                      \
+  V(WasmMemoryGrow)                      \
   V(WasmRecordWrite)                     \
   V(WasmStackGuard)                      \
   V(WasmToNumber)                        \

src/builtins/builtins-wasm-gen.cc

@@ -98,7 +98,7 @@ TF_BUILTIN(WasmThrow, WasmBuiltinsAssembler) {
   TailCallRuntimeWithCEntry(Runtime::kThrow, centry, context, exception);
 }
 
-TF_BUILTIN(WasmGrowMemory, WasmBuiltinsAssembler) {
+TF_BUILTIN(WasmMemoryGrow, WasmBuiltinsAssembler) {
   TNode<Int32T> num_pages =
       UncheckedCast<Int32T>(Parameter(Descriptor::kNumPages));
   Label num_pages_out_of_range(this, Label::kDeferred);
@@ -112,7 +112,7 @@ TF_BUILTIN(WasmGrowMemory, WasmBuiltinsAssembler) {
   TNode<Code> centry = LoadCEntryFromInstance(instance);
   TNode<Object> context = LoadContextFromInstance(instance);
   TNode<Smi> ret_smi = UncheckedCast<Smi>(CallRuntimeWithCEntry(
-      Runtime::kWasmGrowMemory, centry, context, instance, num_pages_smi));
+      Runtime::kWasmMemoryGrow, centry, context, instance, num_pages_smi));
   TNode<Int32T> ret = SmiToInt32(ret_smi);
   ReturnRaw(ret);
 

src/compiler/wasm-compiler.cc

@@ -2028,10 +2028,10 @@ Node* WasmGraphBuilder::BuildCcallConvertFloat(Node* input,
   return tl_d.Phi(int_ty.representation(), nan_val, load);
 }
 
-Node* WasmGraphBuilder::GrowMemory(Node* input) {
+Node* WasmGraphBuilder::MemoryGrow(Node* input) {
   needs_stack_check_ = true;
 
-  WasmGrowMemoryDescriptor interface_descriptor;
+  WasmMemoryGrowDescriptor interface_descriptor;
   auto call_descriptor = Linkage::GetStubCallDescriptor(
       mcgraph()->zone(),                              // zone
       interface_descriptor,                           // descriptor
@@ -2042,7 +2042,7 @@ Node* WasmGraphBuilder::GrowMemory(Node* input) {
   // A direct call to a wasm runtime stub defined in this module.
   // Just encode the stub index. This will be patched at relocation.
   Node* call_target = mcgraph()->RelocatableIntPtrConstant(
-      wasm::WasmCode::kWasmGrowMemory, RelocInfo::WASM_STUB_CALL);
+      wasm::WasmCode::kWasmMemoryGrow, RelocInfo::WASM_STUB_CALL);
   return SetEffect(
       SetControl(graph()->NewNode(mcgraph()->common()->Call(call_descriptor),
                                   call_target, input, Effect(), Control())));

src/compiler/wasm-compiler.h

@@ -177,7 +177,7 @@ class WasmGraphBuilder {
               wasm::WasmCodePosition position = wasm::kNoCodePosition);
   Node* Unop(wasm::WasmOpcode opcode, Node* input,
              wasm::WasmCodePosition position = wasm::kNoCodePosition);
-  Node* GrowMemory(Node* input);
+  Node* MemoryGrow(Node* input);
   Node* Throw(uint32_t exception_index, const wasm::WasmException* exception,
               const Vector<Node*> values);
   Node* Rethrow(Node* except_obj);

src/interface-descriptors.cc

@@ -344,7 +344,7 @@ void ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void WasmGrowMemoryDescriptor::InitializePlatformSpecific(
+void WasmMemoryGrowDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   DefaultInitializePlatformSpecific(data, kParameterCount);
 }

src/interface-descriptors.h

@@ -74,7 +74,7 @@ namespace internal {
   V(ResumeGenerator)                  \
   V(FrameDropperTrampoline)           \
   V(RunMicrotasks)                    \
-  V(WasmGrowMemory)                   \
+  V(WasmMemoryGrow)                   \
   V(WasmThrow)                        \
   V(CloneObjectWithVector)            \
   BUILTIN_LIST_TFS(V)
@@ -1088,12 +1088,12 @@ class RunMicrotasksDescriptor final : public CallInterfaceDescriptor {
   DECLARE_DEFAULT_DESCRIPTOR(RunMicrotasksDescriptor, CallInterfaceDescriptor)
 };
 
-class WasmGrowMemoryDescriptor final : public CallInterfaceDescriptor {
+class WasmMemoryGrowDescriptor final : public CallInterfaceDescriptor {
  public:
   DEFINE_PARAMETERS_NO_CONTEXT(kNumPages)
   DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int32(),  // result 1
                                     MachineType::Int32())  // kNumPages
-  DECLARE_DESCRIPTOR(WasmGrowMemoryDescriptor, CallInterfaceDescriptor)
+  DECLARE_DESCRIPTOR(WasmMemoryGrowDescriptor, CallInterfaceDescriptor)
 };
 
 class WasmThrowDescriptor final : public CallInterfaceDescriptor {

src/runtime/runtime-wasm.cc

@@ -51,11 +51,11 @@ class ClearThreadInWasmScope {
 
 }  // namespace
 
-RUNTIME_FUNCTION(Runtime_WasmGrowMemory) {
+RUNTIME_FUNCTION(Runtime_WasmMemoryGrow) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   CONVERT_ARG_HANDLE_CHECKED(WasmInstanceObject, instance, 0);
-  // {delta_pages} is checked to be a positive smi in the WasmGrowMemory builtin
+  // {delta_pages} is checked to be a positive smi in the WasmMemoryGrow builtin
   // which calls this runtime function.
   CONVERT_UINT32_ARG_CHECKED(delta_pages, 1);
 
@@ -64,7 +64,7 @@ RUNTIME_FUNCTION(Runtime_WasmGrowMemory) {
 
   int ret = WasmMemoryObject::Grow(
       isolate, handle(instance->memory_object(), isolate), delta_pages);
-  // The WasmGrowMemory builtin which calls this runtime function expects us to
+  // The WasmMemoryGrow builtin which calls this runtime function expects us to
   // always return a Smi.
   return Smi::FromInt(ret);
 }

src/runtime/runtime.h

@@ -539,7 +539,7 @@ namespace internal {
   F(ThrowWasmStackOverflow, 0, 1)     \
   F(WasmExceptionGetValues, 1, 1)     \
   F(WasmExceptionGetTag, 1, 1)        \
-  F(WasmGrowMemory, 2, 1)             \
+  F(WasmMemoryGrow, 2, 1)             \
   F(WasmRunInterpreter, 2, 1)         \
   F(WasmStackGuard, 0, 1)             \
   F(WasmThrowCreate, 2, 1)            \

src/wasm/baseline/liftoff-compiler.cc

@@ -1575,7 +1575,7 @@ class LiftoffCompiler {
     __ PushRegister(kWasmI32, LiftoffRegister(mem_size));
   }
 
-  void GrowMemory(FullDecoder* decoder, const Value& value, Value* result_val) {
+  void MemoryGrow(FullDecoder* decoder, const Value& value, Value* result_val) {
     // Pop the input, then spill all cache registers to make the runtime call.
     LiftoffRegList pinned;
     LiftoffRegister input = pinned.set(__ PopToRegister());
@@ -1587,7 +1587,7 @@ class LiftoffCompiler {
                   "complex code here otherwise)");
     LiftoffRegister result = pinned.set(LiftoffRegister(kGpReturnReg));
 
-    WasmGrowMemoryDescriptor descriptor;
+    WasmMemoryGrowDescriptor descriptor;
     DCHECK_EQ(0, descriptor.GetStackParameterCount());
     DCHECK_EQ(1, descriptor.GetRegisterParameterCount());
     DCHECK_EQ(ValueTypes::MachineTypeFor(kWasmI32),
@@ -1596,7 +1596,7 @@ class LiftoffCompiler {
     Register param_reg = descriptor.GetRegisterParameter(0);
     if (input.gp() != param_reg) __ Move(param_reg, input.gp(), kWasmI32);
 
-    __ CallRuntimeStub(WasmCode::kWasmGrowMemory);
+    __ CallRuntimeStub(WasmCode::kWasmMemoryGrow);
     safepoint_table_builder_.DefineSafepoint(&asm_, Safepoint::kSimple, 0,
                                              Safepoint::kNoLazyDeopt);
 

src/wasm/function-body-decoder-impl.h

@@ -647,7 +647,7 @@ struct ControlWithNamedConstructors : public ControlBase<Value> {
   F(StoreMem, StoreType type, const MemoryAccessImmediate<validate>& imm,     \
     const Value& index, const Value& value)                                   \
   F(CurrentMemoryPages, Value* result)                                        \
-  F(GrowMemory, const Value& value, Value* result)                            \
+  F(MemoryGrow, const Value& value, Value* result)                            \
   F(CallDirect, const CallFunctionImmediate<validate>& imm,                   \
     const Value args[], Value returns[])                                      \
   F(CallIndirect, const Value& index,                                         \
@@ -798,7 +798,7 @@ class WasmDecoder : public Decoder {
           length = 1 + imm.length;
           break;
         }
-        case kExprGrowMemory:
+        case kExprMemoryGrow:
         case kExprCallFunction:
         case kExprCallIndirect:
           // Add instance cache nodes to the assigned set.
@@ -1066,7 +1066,7 @@ class WasmDecoder : public Decoder {
       case kExprRefNull: {
         return 1;
       }
-      case kExprGrowMemory:
+      case kExprMemoryGrow:
       case kExprMemorySize: {
         MemoryIndexImmediate<validate> imm(decoder, pc);
         return 1 + imm.length;
@@ -1143,7 +1143,7 @@ class WasmDecoder : public Decoder {
         return {2, 0};
       FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
       case kExprTeeLocal:
-      case kExprGrowMemory:
+      case kExprMemoryGrow:
         return {1, 1};
       case kExprSetLocal:
       case kExprSetGlobal:
@@ -1900,7 +1900,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
           case kExprF64StoreMem:
             len = 1 + DecodeStoreMem(StoreType::kF64Store);
             break;
-          case kExprGrowMemory: {
+          case kExprMemoryGrow: {
             if (!CheckHasMemory()) break;
             MemoryIndexImmediate<validate> imm(this, this->pc_);
             len = 1 + imm.length;
@@ -1911,7 +1911,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
             }
             auto value = Pop(0, kWasmI32);
             auto* result = Push(kWasmI32);
-            CALL_INTERFACE_IF_REACHABLE(GrowMemory, value, result);
+            CALL_INTERFACE_IF_REACHABLE(MemoryGrow, value, result);
             break;
           }
           case kExprMemorySize: {

src/wasm/graph-builder-interface.cc

@@ -360,8 +360,8 @@ class WasmGraphBuildingInterface {
     result->node = BUILD(CurrentMemoryPages);
   }
 
-  void GrowMemory(FullDecoder* decoder, const Value& value, Value* result) {
-    result->node = BUILD(GrowMemory, value.node);
+  void MemoryGrow(FullDecoder* decoder, const Value& value, Value* result) {
+    result->node = BUILD(MemoryGrow, value.node);
     // Always reload the instance cache after growing memory.
     LoadContextIntoSsa(ssa_env_);
   }

src/wasm/wasm-interpreter.cc

@@ -2475,7 +2475,7 @@ class ThreadImpl {
           ASMJS_STORE_CASE(F32AsmjsStoreMem, float, float);
           ASMJS_STORE_CASE(F64AsmjsStoreMem, double, double);
 #undef ASMJS_STORE_CASE
-        case kExprGrowMemory: {
+        case kExprMemoryGrow: {
           MemoryIndexImmediate<Decoder::kNoValidate> imm(&decoder,
                                                          code->at(pc));
           uint32_t delta_pages = Pop().to<uint32_t>();

src/wasm/wasm-objects.cc

@@ -873,7 +873,7 @@ void WasmTableObject::ClearDispatchTables(Isolate* isolate,
 }
 
 namespace {
-MaybeHandle<JSArrayBuffer> GrowMemoryBuffer(Isolate* isolate,
+MaybeHandle<JSArrayBuffer> MemoryGrowBuffer(Isolate* isolate,
                                             Handle<JSArrayBuffer> old_buffer,
                                             uint32_t pages,
                                             uint32_t maximum_pages) {
@@ -1055,7 +1055,7 @@ int32_t WasmMemoryObject::Grow(Isolate* isolate,
     maximum_pages = Min(FLAG_wasm_max_mem_pages,
                         static_cast<uint32_t>(memory_object->maximum_pages()));
   }
-  if (!GrowMemoryBuffer(isolate, old_buffer, pages, maximum_pages)
+  if (!MemoryGrowBuffer(isolate, old_buffer, pages, maximum_pages)
            .ToHandle(&new_buffer)) {
     return -1;
   }

src/wasm/wasm-opcodes.cc

@@ -151,8 +151,8 @@ const char* WasmOpcodes::OpcodeName(WasmOpcode opcode) {
     CASE_OP(GetGlobal, "get_global")
     CASE_OP(SetGlobal, "set_global")
     CASE_ALL_OP(Const, "const")
-    CASE_OP(MemorySize, "current_memory")
-    CASE_OP(GrowMemory, "grow_memory")
+    CASE_OP(MemorySize, "memory.size")
+    CASE_OP(MemoryGrow, "memory.grow")
     CASE_ALL_OP(LoadMem, "load")
     CASE_SIGN_OP(INT, LoadMem8, "load8")
     CASE_SIGN_OP(INT, LoadMem16, "load16")

src/wasm/wasm-opcodes.h

@@ -86,7 +86,7 @@ bool IsJSCompatibleSignature(const FunctionSig* sig);
 // Miscellaneous memory expressions
 #define FOREACH_MISC_MEM_OPCODE(V) \
   V(MemorySize, 0x3f, i_v)         \
-  V(GrowMemory, 0x40, i_i)
+  V(MemoryGrow, 0x40, i_i)
 
 // Expressions with signatures.
 #define FOREACH_SIMPLE_OPCODE(V)  \

src/wasm/wasm-text.cc

@@ -188,7 +188,7 @@ void PrintWasmText(const WasmModule* module, const ModuleWireBytes& wire_bytes,
       case kExprNop:
       case kExprReturn:
       case kExprMemorySize:
-      case kExprGrowMemory:
+      case kExprMemoryGrow:
       case kExprDrop:
       case kExprSelect:
         os << WasmOpcodes::OpcodeName(opcode);

test/cctest/wasm/test-run-wasm-interpreter.cc

@@ -291,7 +291,7 @@ TEST(Breakpoint_I32And_disable) {
   }
 }
 
-TEST(GrowMemory) {
+TEST(MemoryGrow) {
   {
     WasmRunner<int32_t, uint32_t> r(ExecutionTier::kInterpreter);
     r.builder().AddMemory(kWasmPageSize);
@@ -308,7 +308,7 @@ TEST(GrowMemory) {
   }
 }
 
-TEST(GrowMemoryPreservesData) {
+TEST(MemoryGrowPreservesData) {
   int32_t index = 16;
   int32_t value = 2335;
   WasmRunner<int32_t, uint32_t> r(ExecutionTier::kInterpreter);
@@ -320,7 +320,7 @@ TEST(GrowMemoryPreservesData) {
   CHECK_EQ(value, r.Call(1));
 }
 
-TEST(GrowMemoryInvalidSize) {
+TEST(MemoryGrowInvalidSize) {
   // Grow memory by an invalid amount without initial memory.
   WasmRunner<int32_t, uint32_t> r(ExecutionTier::kInterpreter);
   r.builder().AddMemory(kWasmPageSize);

test/cctest/wasm/test-run-wasm-module.cc

@@ -235,7 +235,7 @@ TEST(MemorySize) {
 
 TEST(Run_WasmModule_MemSize_GrowMem) {
   {
-    // Initial memory size = 16 + GrowMemory(10)
+    // Initial memory size = 16 + MemoryGrow(10)
     static const int kExpectedValue = 26;
     TestSignatures sigs;
     v8::internal::AccountingAllocator allocator;
@@ -252,7 +252,7 @@ TEST(Run_WasmModule_MemSize_GrowMem) {
   Cleanup();
 }
 
-TEST(GrowMemoryZero) {
+TEST(MemoryGrowZero) {
   {
     // Initial memory size is 16, see wasm-module-builder.cc
     static const int kExpectedValue = 16;
@@ -362,7 +362,7 @@ TEST(TestInterruptLoop) {
   Cleanup();
 }
 
-TEST(Run_WasmModule_GrowMemoryInIf) {
+TEST(Run_WasmModule_MemoryGrowInIf) {
   {
     TestSignatures sigs;
     v8::internal::AccountingAllocator allocator;
@@ -381,7 +381,7 @@ TEST(Run_WasmModule_GrowMemoryInIf) {
 TEST(Run_WasmModule_GrowMemOobOffset) {
   {
     static const int kPageSize = 0x10000;
-    // Initial memory size = 16 + GrowMemory(10)
+    // Initial memory size = 16 + MemoryGrow(10)
     static const int index = kPageSize * 17 + 4;
     int value = 0xACED;
     TestSignatures sigs;
@@ -403,7 +403,7 @@ TEST(Run_WasmModule_GrowMemOobOffset) {
 TEST(Run_WasmModule_GrowMemOobFixedIndex) {
   {
     static const int kPageSize = 0x10000;
-    // Initial memory size = 16 + GrowMemory(10)
+    // Initial memory size = 16 + MemoryGrow(10)
     static const int index = kPageSize * 26 + 4;
     int value = 0xACED;
     TestSignatures sigs;

test/common/wasm/wasm-macro-gen.h

@@ -575,7 +575,7 @@ inline WasmOpcode LoadStoreOpcodeOf(MachineType type, bool store) {
 //------------------------------------------------------------------------------
 // Memory Operations.
 //------------------------------------------------------------------------------
-#define WASM_GROW_MEMORY(x) x, kExprGrowMemory, 0
+#define WASM_GROW_MEMORY(x) x, kExprMemoryGrow, 0
 #define WASM_MEMORY_SIZE kExprMemorySize, 0
 
 #define SIG_ENTRY_v_v kWasmFunctionTypeCode, 0, 0

test/fuzzer/wasm-compile.cc

@@ -720,7 +720,7 @@ void WasmGenerator::Generate<kWasmF64>(DataRange& data) {
 
 void WasmGenerator::grow_memory(DataRange& data) {
   Generate<kWasmI32>(data);
-  builder_->EmitWithU8(kExprGrowMemory, 0);
+  builder_->EmitWithU8(kExprMemoryGrow, 0);
 }
 
 void WasmGenerator::Generate(ValueType type, DataRange& data) {

test/mjsunit/regress/wasm/regress-02256.js

@@ -274,7 +274,7 @@ try {
 function __f_16() {
     var __v_1 = new WasmModuleBuilder();
     __v_1.addFunction("grow_memory", kSig_i_i)
-        .addBody([kExprGetLocal, 0, kExprGrowMemory])
+        .addBody([kExprGetLocal, 0, kExprMemoryGrow])
         .exportFunc();
     __v_1.addFunction("load", kSig_i_i)
         .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0])

test/mjsunit/regress/wasm/regress-651961.js

@@ -14,7 +14,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
     .addBody([
               kExprMemorySize, kMemoryZero,
               kExprI32Const, 0x10,
-              kExprGrowMemory, kMemoryZero,
+              kExprMemoryGrow, kMemoryZero,
               kExprI32Mul,
               ])
               .exportFunc();

test/mjsunit/regress/wasm/regress-688876.js

@@ -26,7 +26,7 @@ load('test/mjsunit/wasm/wasm-module-builder.js');
    kExprI32And,
   kExprI32Eqz,
  kExprI32And,
-kExprGrowMemory, 0x00,
+kExprMemoryGrow, 0x00,
    kExprI32Const, 0x55,
   kExprI32LoadMem8S, 0x00, 0x3a,
    kExprI32LoadMem16U, 0x00, 0x71,

test/mjsunit/regress/wasm/regress-699485.js

@@ -15,7 +15,7 @@ builder.addFunction("regression_699485", kSig_i_v)
   .addBody([
       kExprI32Const, 0x04,
       kExprNop,
-      kExprGrowMemory, 0x00,
+      kExprMemoryGrow, 0x00,
       ]).exportFunc();
 let module = builder.instantiate();
 assertEquals(0, module.exports.regression_699485());

test/mjsunit/regress/wasm/regress-702460.js

@@ -18,34 +18,34 @@ let kExprS128LoadMem = 0xc0;
         kExprI32Const, 0x41,
         kExprI32Const, 0x3c,
         kExprI32Const, 0xdc, 0x01,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
         kExprSetLocal, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
-        kExprGrowMemory, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
+        kExprMemoryGrow, 0x00,
         kExprS128LoadMem, 0x00, 0x40,
         kExprUnreachable,
-        kExprGrowMemory, 0x00
+        kExprMemoryGrow, 0x00
         ]).exportFunc();
   assertThrows(() => builder.instantiate());
 })();

test/mjsunit/regress/wasm/regress-710844.js

@@ -13,7 +13,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
     .addBody([
         kExprI32Const, 0x03,
         kExprNop,
-        kExprGrowMemory, 0x00,
+        kExprMemoryGrow, 0x00,
         kExprI32Const, 0x13,
         kExprNop,
         kExprI32StoreMem8, 0x00, 0x10

test/mjsunit/regress/wasm/regress-7353.js

@@ -11,7 +11,7 @@ const builder = new WasmModuleBuilder();
 builder.addMemory(16, 32);
 builder.addFunction('grow', kSig_i_i).addBody([
   kExprGetLocal, 0,
-  kExprGrowMemory, 0,
+  kExprMemoryGrow, 0,
 ]).exportFunc();
 builder.addFunction('main', kSig_i_i).addBody([
   ...wasmI32Const(0x41),

test/mjsunit/regress/wasm/regress-763439.js

@@ -10,7 +10,7 @@ builder.addMemory(0, 1234, false);
 builder.addFunction('f', kSig_i_v)
     .addBody([
       kExprI32Const, 0x1d,                       // --
-      kExprGrowMemory, 0x00,                     // --
+      kExprMemoryGrow, 0x00,                     // --
       kExprI32LoadMem, 0x00, 0xff, 0xff, 0x45,  // --
     ])
     .exportFunc();

test/mjsunit/regress/wasm/regress-7914.js

@@ -10,7 +10,7 @@ builder.addMemory(16, 32, false);
 builder.addFunction('main', kSig_i_v)
     .addBody([
       ...wasmI32Const(10000),  // i32.const 10000
-      kExprGrowMemory, 0,      // grow_memory --> -1
+      kExprMemoryGrow, 0,      // grow_memory --> -1
       kExprI32Popcnt,          // i32.popcnt  --> 32
     ])
     .exportFunc();

test/mjsunit/regress/wasm/regress-834693.js

@@ -13,7 +13,7 @@ module.addFunction("main", kSig_v_v)
   .addBody([
     kExprI32Const, 20,
     kExprI32Const, 29,
-    kExprGrowMemory, kMemoryZero,
+    kExprMemoryGrow, kMemoryZero,
     kExprI32StoreMem, 0, 0xFF, 0xFF, 0x7A])
   .exportAs("main");
 var instance = module.instantiate();

test/mjsunit/wasm/grow-memory-detaching.js

@@ -11,7 +11,7 @@ let module = (() => {
   let builder = new WasmModuleBuilder();
   builder.addMemory(1, undefined, false);
   builder.addFunction("grow_memory", kSig_i_i)
-              .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+              .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   builder.exportMemoryAs("memory");
   return builder.toModule();

test/mjsunit/wasm/grow-memory-in-branch.js

@@ -27,8 +27,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an if branch
 // affect the result of current_memory when the branch is merged.
-(function TestGrowMemoryInIfBranchNoElse() {
-  print('TestGrowMemoryInIfBranchNoElse ...');
+(function TestMemoryGrowInIfBranchNoElse() {
+  print('TestMemoryGrowInIfBranchNoElse ...');
   let deltaPages = 4;
   let builder = generateBuilder();
   builder.addFunction('main', kSig_i_i)
@@ -36,7 +36,7 @@ function generateBuilder() {
         kExprGetLocal, 0,                       // get condition parameter
         kExprIf, kWasmStmt,                     // if it's 1 then enter if
           kExprI32Const, deltaPages,            // put deltaPages on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
         kExprEnd,
         kExprMemorySize, kMemoryZero            // get the memory size
@@ -51,8 +51,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an if branch are
 // retained when the branch is merged even when an else branch exists.
-(function TestGrowMemoryInIfBranchWithElse() {
-  print('TestGrowMemoryInIfBranchWithElse ...');
+(function TestMemoryGrowInIfBranchWithElse() {
+  print('TestMemoryGrowInIfBranchWithElse ...');
   let index = 0;
   let oldValue = 21;
   let newValue = 42;
@@ -63,7 +63,7 @@ function generateBuilder() {
         kExprGetLocal, 0,                       // get condition parameter
         kExprIf, kWasmStmt,                     // if it's 1 then enter if
           kExprI32Const, deltaPages,            // put deltaPages on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
         kExprElse,
           kExprI32Const, index,                 // put index on stack
@@ -86,8 +86,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an else branch
 // affect the result of current_memory when the branch is merged.
-(function TestGrowMemoryInElseBranch() {
-  print('TestGrowMemoryInElseBranch ...');
+(function TestMemoryGrowInElseBranch() {
+  print('TestMemoryGrowInElseBranch ...');
   let index = 0;
   let oldValue = 21;
   let newValue = 42;
@@ -102,7 +102,7 @@ function generateBuilder() {
           kExprI32StoreMem, 0, 0,               // store
         kExprElse,
           kExprI32Const, deltaPages,            // put deltaPages on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
         kExprEnd,
         kExprMemorySize, kMemoryZero            // get the memory size
@@ -121,8 +121,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an if/else
 // branch affect the result of current_memory when the branches are merged.
-(function TestGrowMemoryInBothIfAndElse() {
-  print('TestGrowMemoryInBothIfAndElse ...');
+(function TestMemoryGrowInBothIfAndElse() {
+  print('TestMemoryGrowInBothIfAndElse ...');
   let deltaPagesIf = 1;
   let deltaPagesElse = 2;
   let builder = generateBuilder();
@@ -131,11 +131,11 @@ function generateBuilder() {
         kExprGetLocal, 0,                       // get condition parameter
         kExprIf, kWasmStmt,                     // if it's 1 then enter if
           kExprI32Const, deltaPagesIf,          // put deltaPagesIf on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
         kExprElse,
           kExprI32Const, deltaPagesElse,        // put deltaPagesElse on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
         kExprEnd,
         kExprMemorySize, kMemoryZero            // get the memory size
@@ -152,8 +152,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an if branch are
 // retained when the branch is merged.
-(function TestGrowMemoryAndStoreInIfBranchNoElse() {
-  print('TestGrowMemoryAndStoreInIfBranchNoElse ...');
+(function TestMemoryGrowAndStoreInIfBranchNoElse() {
+  print('TestMemoryGrowAndStoreInIfBranchNoElse ...');
   let index = 2 * kPageSize - 4;
   let value = 42;
   let deltaPages = 1;
@@ -163,7 +163,7 @@ function generateBuilder() {
         kExprGetLocal, 0,                       // get condition parameter
         kExprIf, kWasmStmt,                     // if it's 1 then enter if
           kExprI32Const, deltaPages,            // put deltaPages on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
           kExprGetLocal, 1,                     // get index parameter
           kExprI32Const, value,                 // put the value on stack
@@ -184,8 +184,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an if branch are
 // retained when the branch is merged even when  an else branch exists.
-(function TestGrowMemoryAndStoreInIfBranchWithElse() {
-  print('TestGrowMemoryAndStoreInIfBranchWithElse ...');
+(function TestMemoryGrowAndStoreInIfBranchWithElse() {
+  print('TestMemoryGrowAndStoreInIfBranchWithElse ...');
   let index = 2 * kPageSize - 4;
   let value = 42;
   let deltaPages = 1;
@@ -195,7 +195,7 @@ function generateBuilder() {
         kExprGetLocal, 0,                       // get condition parameter
         kExprIf, kWasmStmt,                     // if it's 1 then enter if
           kExprI32Const, deltaPages,            // put deltaPages on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
           kExprGetLocal, 1,                     // get index parameter
           kExprI32Const, value,                 // put the value on stack
@@ -219,8 +219,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an else branch are
 // retained when the branch is merged.
-(function TestGrowMemoryAndStoreInElseBranch() {
-  print('TestGrowMemoryAndStoreInElseBranch ...');
+(function TestMemoryGrowAndStoreInElseBranch() {
+  print('TestMemoryGrowAndStoreInElseBranch ...');
   let index = 2 * kPageSize - 4;
   let value = 42;
   let deltaPages = 1;
@@ -234,7 +234,7 @@ function generateBuilder() {
           kExprI32StoreMem, 0, 0,               // store
         kExprElse,
           kExprI32Const, deltaPages,            // put deltaPages on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
           kExprGetLocal, 1,                     // get index parameter
           kExprI32Const, value,                 // put the value on stack
@@ -254,8 +254,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory in an if/else branch
 // are retained when the branch is merged.
-(function TestGrowMemoryAndStoreInBothIfAndElse() {
-  print('TestGrowMemoryAndStoreInBothIfAndElse ...');
+(function TestMemoryGrowAndStoreInBothIfAndElse() {
+  print('TestMemoryGrowAndStoreInBothIfAndElse ...');
   let index = 0;
   let valueIf = 21;
   let valueElse = 42;
@@ -267,14 +267,14 @@ function generateBuilder() {
         kExprGetLocal, 0,                       // get condition parameter
         kExprIf, kWasmStmt,                     // if it's 1 then enter if
           kExprI32Const, deltaPagesIf,          // put deltaPagesIf on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
           kExprGetLocal, 1,                     // get index parameter
           kExprI32Const, valueIf,               // put valueIf on stack
           kExprI32StoreMem, 0, 0,               // store
         kExprElse,
           kExprI32Const, deltaPagesElse,        // put deltaPagesElse on stack
-          kExprGrowMemory, kMemoryZero,         // grow memory
+          kExprMemoryGrow, kMemoryZero,         // grow memory
           kExprDrop,                            // drop the result of grow
           kExprGetLocal, 1,                     // get index parameter
           kExprI32Const, valueElse,             // put valueElse on stack

test/mjsunit/wasm/grow-memory-in-call.js

@@ -15,13 +15,13 @@ print('=== grow_memory in direct calls ===');
 
 // This test verifies that the current_memory instruction returns the correct
 // value after returning from a function (direct call) that grew memory.
-(function TestGrowMemoryInFunction() {
-  print('TestGrowMemoryInFunction ...');
+(function TestMemoryGrowInFunction() {
+  print('TestMemoryGrowInFunction ...');
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('main', kSig_i_i)
@@ -41,14 +41,14 @@ print('=== grow_memory in direct calls ===');
 
 // This test verifies that accessing a memory page that has been created inside
 // a function (direct call) does not trap in the caller.
-(function TestGrowMemoryAndAccessInFunction() {
-  print('TestGrowMemoryAndAccessInFunction ...');
+(function TestMemoryGrowAndAccessInFunction() {
+  print('TestMemoryGrowAndAccessInFunction ...');
   let index = 2 * kPageSize - 4;
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('load', kSig_i_i)
@@ -75,8 +75,8 @@ print('=== grow_memory in direct calls ===');
 // This test verifies that when a function (direct call) grows and store
 // something in the grown memory, the caller always reads from the grown
 // memory. This checks that the memory start address gets updated in the caller.
-(function TestGrowMemoryAndStoreInFunction() {
-  print('TestGrowMemoryAndStoreInFunction ...');
+(function TestMemoryGrowAndStoreInFunction() {
+  print('TestMemoryGrowAndStoreInFunction ...');
   let index = 0;
   let oldValue = 21;
   let newValue = 42;
@@ -87,7 +87,7 @@ print('=== grow_memory in direct calls ===');
       builder.addFunction('grow', kSig_v_v)
           .addBody([
             kExprI32Const, deltaPages,     // always grow memory by deltaPages
-            kExprGrowMemory, kMemoryZero,  // grow memory
+            kExprMemoryGrow, kMemoryZero,  // grow memory
             kExprDrop,                     // drop the result of grow
             kExprI32Const, index,          // put index on stack
             kExprI32Const, newValue,       // put new value on stack
@@ -113,13 +113,13 @@ print('=== grow_memory in direct calls ===');
 // This test verifies that the effects of growing memory in an directly
 // called function inside a loop affect the result of current_memory when
 // the loop is over.
-(function TestGrowMemoryInFunctionInsideLoop() {
-  print('TestGrowMemoryInFunctionInsideLoop ...');
+(function TestMemoryGrowInFunctionInsideLoop() {
+  print('TestMemoryGrowInFunctionInsideLoop ...');
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('main', kSig_i_ii)
@@ -156,8 +156,8 @@ print('=== grow_memory in direct calls ===');
 
 // This test verifies that the effects of writing to memory grown in an
 // directly called function inside a loop are retained when the loop is over.
-(function TestGrowMemoryAndStoreInFunctionInsideLoop() {
-  print('TestGrowMemoryAndStoreInFunctionInsideLoop ...');
+(function TestMemoryGrowAndStoreInFunctionInsideLoop() {
+  print('TestMemoryGrowAndStoreInFunctionInsideLoop ...');
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   builder.addFunction('store', kSig_i_ii)
@@ -168,7 +168,7 @@ print('=== grow_memory in direct calls ===');
       .exportFunc();
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   // parameters:  iterations, deltaPages, index
@@ -220,13 +220,13 @@ print('\n=== grow_memory in indirect calls ===');
 
 // This test verifies that the current_memory instruction returns the correct
 // value after returning from a function (indirect call) that grew memory.
-(function TestGrowMemoryInIndirectCall() {
-  print('TestGrowMemoryInIndirectCall ...');
+(function TestMemoryGrowInIndirectCall() {
+  print('TestMemoryGrowInIndirectCall ...');
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('main', kSig_i_ii)
@@ -249,14 +249,14 @@ print('\n=== grow_memory in indirect calls ===');
 
 // This test verifies that accessing a memory page that has been created inside
 // a function (indirect call) does not trap in the caller.
-(function TestGrowMemoryAndAccessInIndirectCall() {
-  print('TestGrowMemoryAndAccessInIndirectCall ...');
+(function TestMemoryGrowAndAccessInIndirectCall() {
+  print('TestMemoryGrowAndAccessInIndirectCall ...');
   let index = 2 * kPageSize - 4;
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('load', kSig_i_i)
@@ -287,8 +287,8 @@ print('\n=== grow_memory in indirect calls ===');
 // This test verifies that when a function (indirect call) grows and store
 // something in the grown memory, the caller always reads from the grown
 // memory. This checks that the memory start address gets updated in the caller.
-(function TestGrowMemoryAndStoreInIndirectCall() {
-  print('TestGrowMemoryAndStoreInIndirectCall ...');
+(function TestMemoryGrowAndStoreInIndirectCall() {
+  print('TestMemoryGrowAndStoreInIndirectCall ...');
   let index = 0;
   let oldValue = 21;
   let newValue = 42;
@@ -299,7 +299,7 @@ print('\n=== grow_memory in indirect calls ===');
       builder.addFunction('grow', kSig_v_v)
           .addBody([
             kExprI32Const, deltaPages,     // always grow memory by deltaPages
-            kExprGrowMemory, kMemoryZero,  // grow memory
+            kExprMemoryGrow, kMemoryZero,  // grow memory
             kExprDrop,                     // drop the result of grow
             kExprI32Const, index,          // put index on stack
             kExprI32Const, newValue,       // put new value on stack
@@ -327,13 +327,13 @@ print('\n=== grow_memory in indirect calls ===');
 // This test verifies that the effects of growing memory in an indirectly
 // called function inside a loop affect the result of current_memory when
 // the loop is over.
-(function TestGrowMemoryInIndirectCallInsideLoop() {
-  print('TestGrowMemoryInIndirectCallInsideLoop ...');
+(function TestMemoryGrowInIndirectCallInsideLoop() {
+  print('TestMemoryGrowInIndirectCallInsideLoop ...');
   let builder = new WasmModuleBuilder();
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('main', kSig_i_iii)
@@ -372,14 +372,14 @@ print('\n=== grow_memory in indirect calls ===');
 
 // This test verifies that the effects of writing to memory grown in an
 // indirectly called function inside a loop are retained when the loop is over.
-(function TestGrowMemoryAndStoreInIndirectCallInsideLoop() {
-  print('TestGrowMemoryAndStoreInIndirectCallInsideLoop ...');
+(function TestMemoryGrowAndStoreInIndirectCallInsideLoop() {
+  print('TestMemoryGrowAndStoreInIndirectCallInsideLoop ...');
   let builder = new WasmModuleBuilder();
   let deltaPages = 1;
   builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
   let kGrowFunction =
       builder.addFunction('grow', kSig_i_i)
-          .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+          .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
           .exportFunc()
           .index;
   builder.addFunction('store', kSig_i_ii)

test/mjsunit/wasm/grow-memory-in-loop.js

@@ -24,8 +24,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of growing memory inside a loop
 // affect the result of current_memory when the loop is over.
-(function TestGrowMemoryInsideLoop() {
-  print('TestGrowMemoryInsideLoop ...');
+(function TestMemoryGrowInsideLoop() {
+  print('TestMemoryGrowInsideLoop ...');
   let deltaPages = 1;
   let builder = generateBuilder();
   builder.addFunction('main', kSig_i_i)
@@ -36,7 +36,7 @@ function generateBuilder() {
           kExprIf, kWasmStmt,                   // if <param0> != 0
             // Grow memory.
             kExprI32Const, deltaPages,          // -
-            kExprGrowMemory, kMemoryZero,       // grow memory
+            kExprMemoryGrow, kMemoryZero,       // grow memory
             kExprDrop,                          // drop the result of grow
             // Decrease loop variable.
             kExprGetLocal, 0,                   // -
@@ -71,8 +71,8 @@ function generateBuilder() {
 
 // This test verifies that a loop does not affect the result of current_memory
 // when the memory is grown both inside and outside the loop.
-(function TestGrowMemoryInsideAndOutsideLoop() {
-  print('TestGrowMemoryInsideAndOutsideLoop ...');
+(function TestMemoryGrowInsideAndOutsideLoop() {
+  print('TestMemoryGrowInsideAndOutsideLoop ...');
   let deltaPagesIn = 1;
   let deltaPagesOut = 2;
   let builder = generateBuilder();
@@ -81,14 +81,14 @@ function generateBuilder() {
         // clang-format off
         // Grow memory.
         kExprI32Const, deltaPagesOut,           // -
-        kExprGrowMemory, kMemoryZero,           // grow memory
+        kExprMemoryGrow, kMemoryZero,           // grow memory
         kExprDrop,                              // drop the result of grow
         kExprLoop, kWasmStmt,                   // while
           kExprGetLocal, 0,                     // -
           kExprIf, kWasmStmt,                   // if <param0> != 0
             // Grow memory.
             kExprI32Const, deltaPagesIn,        // -
-            kExprGrowMemory, kMemoryZero,       // grow memory
+            kExprMemoryGrow, kMemoryZero,       // grow memory
             kExprDrop,                          // drop the result of grow
             // Decrease loop variable.
             kExprGetLocal, 0,                   // -
@@ -125,8 +125,8 @@ function generateBuilder() {
 
 // This test verifies that the effects of writing to memory grown inside a loop
 // are retained when the loop is over.
-(function TestGrowMemoryAndStoreInsideLoop() {
-  print('TestGrowMemoryAndStoreInsideLoop ...');
+(function TestMemoryGrowAndStoreInsideLoop() {
+  print('TestMemoryGrowAndStoreInsideLoop ...');
   let deltaPages = 1;
   let builder = generateBuilder();
   builder.addFunction('main', kSig_i_ii)
@@ -137,7 +137,7 @@ function generateBuilder() {
           kExprIf, kWasmStmt,                   // if <param0> != 0
             // Grow memory.
             kExprI32Const, deltaPages,          // -
-            kExprGrowMemory, kMemoryZero,       // grow memory
+            kExprMemoryGrow, kMemoryZero,       // grow memory
             kExprDrop,                          // drop the result of grow
             // Increase counter in memory.
             kExprGetLocal, 1,                   // put index (for store)
@@ -183,8 +183,8 @@ function generateBuilder() {
 
 // This test verifies that a loop does not affect the memory when the
 // memory is grown both inside and outside the loop.
-(function TestGrowMemoryAndStoreInsideAndOutsideLoop() {
-  print('TestGrowMemoryAndStoreInsideAndOutsideLoop ...');
+(function TestMemoryGrowAndStoreInsideAndOutsideLoop() {
+  print('TestMemoryGrowAndStoreInsideAndOutsideLoop ...');
   let deltaPagesIn = 1;
   let deltaPagesOut = 2;
   let builder = generateBuilder();
@@ -193,7 +193,7 @@ function generateBuilder() {
         // clang-format off
         // Grow memory.
         kExprI32Const, deltaPagesOut,           // -
-        kExprGrowMemory, kMemoryZero,           // grow memory
+        kExprMemoryGrow, kMemoryZero,           // grow memory
         kExprDrop,                              // drop the result of grow
         // Increase counter in memory.
         kExprGetLocal, 1,                       // put index (for store)
@@ -208,7 +208,7 @@ function generateBuilder() {
           kExprIf, kWasmStmt,                   // if <param0> != 0
             // Grow memory.
             kExprI32Const, deltaPagesIn,        // -
-            kExprGrowMemory, kMemoryZero,       // grow memory
+            kExprMemoryGrow, kMemoryZero,       // grow memory
             kExprDrop,                          // drop the result of grow
             // Increase counter in memory.
             kExprGetLocal, 1,                   // put index (for store)

test/mjsunit/wasm/grow-memory.js

@@ -8,10 +8,10 @@ load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 
-function genGrowMemoryBuilder() {
+function genMemoryGrowBuilder() {
   var builder = new WasmModuleBuilder();
   builder.addFunction("grow_memory", kSig_i_i)
-      .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+      .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
       .exportFunc();
   builder.addFunction("load", kSig_i_i)
       .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0])
@@ -43,8 +43,8 @@ var kV8MaxPages = 32767;
 
 // TODO(gdeepti): Generate tests programatically for all the sizes instead of
 // current implementation.
-function testGrowMemoryReadWrite32() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowReadWrite32() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -88,10 +88,10 @@ function testGrowMemoryReadWrite32() {
   }
 }
 
-testGrowMemoryReadWrite32();
+testMemoryGrowReadWrite32();
 
-function testGrowMemoryReadWrite16() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowReadWrite16() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -135,10 +135,10 @@ function testGrowMemoryReadWrite16() {
   }
 }
 
-testGrowMemoryReadWrite16();
+testMemoryGrowReadWrite16();
 
-function testGrowMemoryReadWrite8() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowReadWrite8() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -182,10 +182,10 @@ function testGrowMemoryReadWrite8() {
   }
 }
 
-testGrowMemoryReadWrite8();
+testMemoryGrowReadWrite8();
 
-function testGrowMemoryZeroInitialSize() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowZeroInitialSize() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(0, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -216,10 +216,10 @@ function testGrowMemoryZeroInitialSize() {
   assertEquals(20, peek());
 }
 
-testGrowMemoryZeroInitialSize();
+testMemoryGrowZeroInitialSize();
 
-function testGrowMemoryZeroInitialSize32() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowZeroInitialSize32() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(0, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -242,10 +242,10 @@ function testGrowMemoryZeroInitialSize32() {
   }
 }
 
-testGrowMemoryZeroInitialSize32();
+testMemoryGrowZeroInitialSize32();
 
-function testGrowMemoryZeroInitialSize16() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowZeroInitialSize16() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(0, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -268,10 +268,10 @@ function testGrowMemoryZeroInitialSize16() {
   }
 }
 
-testGrowMemoryZeroInitialSize16();
+testMemoryGrowZeroInitialSize16();
 
-function testGrowMemoryZeroInitialSize8() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowZeroInitialSize8() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(0, undefined, false);
   var module = builder.instantiate();
   var offset;
@@ -294,30 +294,30 @@ function testGrowMemoryZeroInitialSize8() {
   }
 }
 
-testGrowMemoryZeroInitialSize8();
+testMemoryGrowZeroInitialSize8();
 
-function testGrowMemoryTrapMaxPagesZeroInitialMemory() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowTrapMaxPagesZeroInitialMemory() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(0, undefined, false);
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
   assertEquals(-1, growMem(kV8MaxPages + 1));
 }
 
-testGrowMemoryTrapMaxPagesZeroInitialMemory();
+testMemoryGrowTrapMaxPagesZeroInitialMemory();
 
-function testGrowMemoryTrapMaxPages() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowTrapMaxPages() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, 1, false);
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
   assertEquals(-1, growMem(kV8MaxPages));
 }
 
-testGrowMemoryTrapMaxPages();
+testMemoryGrowTrapMaxPages();
 
-function testGrowMemoryTrapsWithNonSmiInput() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowTrapsWithNonSmiInput() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(0, undefined, false);
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
@@ -326,10 +326,10 @@ function testGrowMemoryTrapsWithNonSmiInput() {
   assertEquals(-1, growMem(-1));
 };
 
-testGrowMemoryTrapsWithNonSmiInput();
+testMemoryGrowTrapsWithNonSmiInput();
 
-function testGrowMemoryCurrentMemory() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowCurrentMemory() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   builder.addFunction("memory_size", kSig_i_v)
       .addBody([kExprMemorySize, kMemoryZero])
@@ -342,10 +342,10 @@ function testGrowMemoryCurrentMemory() {
   assertEquals(2, MemSize());
 }
 
-testGrowMemoryCurrentMemory();
+testMemoryGrowCurrentMemory();
 
-function testGrowMemoryPreservesDataMemOp32() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowPreservesDataMemOp32() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset, val;
@@ -365,10 +365,10 @@ function testGrowMemoryPreservesDataMemOp32() {
   }
 }
 
-testGrowMemoryPreservesDataMemOp32();
+testMemoryGrowPreservesDataMemOp32();
 
-function testGrowMemoryPreservesDataMemOp16() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowPreservesDataMemOp16() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset, val;
@@ -388,10 +388,10 @@ function testGrowMemoryPreservesDataMemOp16() {
   }
 }
 
-testGrowMemoryPreservesDataMemOp16();
+testMemoryGrowPreservesDataMemOp16();
 
-function testGrowMemoryPreservesDataMemOp8() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowPreservesDataMemOp8() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset, val = 0;
@@ -415,10 +415,10 @@ function testGrowMemoryPreservesDataMemOp8() {
   }
 }
 
-testGrowMemoryPreservesDataMemOp8();
+testMemoryGrowPreservesDataMemOp8();
 
-function testGrowMemoryOutOfBoundsOffset() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowOutOfBoundsOffset() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset, val;
@@ -447,16 +447,16 @@ function testGrowMemoryOutOfBoundsOffset() {
   }
 }
 
-testGrowMemoryOutOfBoundsOffset();
+testMemoryGrowOutOfBoundsOffset();
 
-function testGrowMemoryOutOfBoundsOffset2() {
+function testMemoryGrowOutOfBoundsOffset2() {
   var builder = new WasmModuleBuilder();
   builder.addMemory(16, 128, false);
   builder.addFunction("main", kSig_v_v)
       .addBody([
           kExprI32Const, 20,
           kExprI32Const, 29,
-          kExprGrowMemory, kMemoryZero,
+          kExprMemoryGrow, kMemoryZero,
           kExprI32StoreMem, 0, 0xFF, 0xFF, 0xFF, 0x3a
           ])
       .exportAs("main");
@@ -464,10 +464,10 @@ function testGrowMemoryOutOfBoundsOffset2() {
   assertTraps(kTrapMemOutOfBounds, module.exports.main);
 }
 
-testGrowMemoryOutOfBoundsOffset2();
+testMemoryGrowOutOfBoundsOffset2();
 
-function testGrowMemoryDeclaredMaxTraps() {
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrowDeclaredMaxTraps() {
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, 16, false);
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
@@ -476,13 +476,13 @@ function testGrowMemoryDeclaredMaxTraps() {
   assertEquals(-1, growMem(6));
 }
 
-testGrowMemoryDeclaredMaxTraps();
+testMemoryGrowDeclaredMaxTraps();
 
-function testGrowMemoryDeclaredSpecMaxTraps() {
+function testMemoryGrowDeclaredSpecMaxTraps() {
   // The spec maximum is higher than the internal V8 maximum. This test only
   // checks that grow_memory does not grow past the internally defined maximum
   // to reflect the current implementation.
-  var builder = genGrowMemoryBuilder();
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, kSpecMaxPages, false);
   var module = builder.instantiate();
   function poke(value) { return module.exports.store(offset, value); }
@@ -491,11 +491,11 @@ function testGrowMemoryDeclaredSpecMaxTraps() {
   assertEquals(-1, growMem(kV8MaxPages - 20));
 }
 
-testGrowMemoryDeclaredSpecMaxTraps();
+testMemoryGrowDeclaredSpecMaxTraps();
 
-function testGrowMemory2Gb() {
-  print("testGrowMemory2Gb");
-  var builder = genGrowMemoryBuilder();
+function testMemoryGrow2Gb() {
+  print("testMemoryGrow2Gb");
+  var builder = genMemoryGrowBuilder();
   builder.addMemory(1, undefined, false);
   var module = builder.instantiate();
   var offset, val;
@@ -542,4 +542,4 @@ function testGrowMemory2Gb() {
   }
 }
 
-testGrowMemory2Gb();
+testMemoryGrow2Gb();

test/mjsunit/wasm/import-memory.js

@@ -112,7 +112,7 @@ var kV8MaxPages = 32767;
   }
 })();
 
-(function TestGrowMemoryMaxDesc() {
+(function TestMemoryGrowMaxDesc() {
   print("MaximumDescriptor");
   let memory = new WebAssembly.Memory({initial: 1, maximum: 5});
   assertEquals(kPageSize, memory.buffer.byteLength);
@@ -150,7 +150,7 @@ var kV8MaxPages = 32767;
   assertThrows(() => memory.grow(1));
 })();
 
-(function TestGrowMemoryZeroInitialMemory() {
+(function TestMemoryGrowZeroInitialMemory() {
   print("ZeroInitialMemory");
   let memory = new WebAssembly.Memory({initial: 0});
   assertEquals(0, memory.buffer.byteLength);
@@ -188,7 +188,7 @@ var kV8MaxPages = 32767;
   assertEquals(2*kPageSize, memory.buffer.byteLength);
   let builder = new WasmModuleBuilder();
   builder.addFunction("grow", kSig_i_i)
-      .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+      .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
       .exportFunc();
   builder.addImportedMemory("cat", "mine");
   let instance = builder.instantiate({cat: {mine: memory}});
@@ -200,8 +200,8 @@ var kV8MaxPages = 32767;
   assertThrows(() => memory.grow(1));
 })();
 
-(function TestGrowMemoryExportedMaximum() {
-  print("TestGrowMemoryExportedMaximum");
+(function TestMemoryGrowExportedMaximum() {
+  print("TestMemoryGrowExportedMaximum");
   let initial_size = 1, maximum_size = 10;
   var exp_instance;
   {
@@ -218,7 +218,7 @@ var kV8MaxPages = 32767;
       .addBody([kExprMemorySize, kMemoryZero])
       .exportFunc();
     builder.addFunction("grow", kSig_i_i)
-      .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+      .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
       .exportFunc();
     instance = builder.instantiate({fur: {
       imported_mem: exp_instance.exports.exported_mem}});
@@ -239,7 +239,7 @@ var kV8MaxPages = 32767;
     .addBody([kExprMemorySize, kMemoryZero])
     .exportAs("mem_size");
   builder.addFunction("grow", kSig_i_i)
-    .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+    .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   var module = new WebAssembly.Module(builder.toBuffer());
   var instances = [];
@@ -258,7 +258,7 @@ var kV8MaxPages = 32767;
   verify_mem_size(1);
 
   // Verify memory size with interleaving calls to Memory.grow,
-  // GrowMemory opcode.
+  // MemoryGrow opcode.
   var current_mem_size = 1;
   for (var i = 0; i < 5; i++) {
     function grow(pages) { return instances[i].exports.grow(pages); }
@@ -280,7 +280,7 @@ var kV8MaxPages = 32767;
     .addBody([kExprMemorySize, kMemoryZero])
     .exportFunc();
   builder.addFunction("grow", kSig_i_i)
-    .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+    .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   var instances = [];
   for (var i = 0; i < 5; i++) {
@@ -345,7 +345,7 @@ var kV8MaxPages = 32767;
     .addBody([kExprMemorySize, kMemoryZero])
     .exportFunc();
   builder.addFunction("grow", kSig_i_i)
-    .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+    .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   var instances = [];
   for (var i = 0; i < 10; i++) {
@@ -380,7 +380,7 @@ var kV8MaxPages = 32767;
     builder.addMemory(1, kSpecMaxPages, true);
     builder.exportMemoryAs("exported_mem");
     builder.addFunction("grow", kSig_i_i)
-      .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+      .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
       .exportFunc();
     instance_1 = builder.instantiate();
   }
@@ -388,7 +388,7 @@ var kV8MaxPages = 32767;
     let builder = new WasmModuleBuilder();
     builder.addImportedMemory("doo", "imported_mem");
     builder.addFunction("grow", kSig_i_i)
-      .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+      .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
       .exportFunc();
     instance_2 = builder.instantiate({
       doo: {imported_mem: instance_1.exports.exported_mem}});
@@ -408,7 +408,7 @@ var kV8MaxPages = 32767;
     .addBody([kExprMemorySize, kMemoryZero])
     .exportFunc();
   builder.addFunction("grow", kSig_i_i)
-    .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+    .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   instance = builder.instantiate();
   assertEquals(kPageSize, instance.exports.exported_mem.buffer.byteLength);

test/mjsunit/wasm/instance-memory-gc-stress.js

@@ -18,7 +18,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
     .addBody([kExprMemorySize, kMemoryZero])
     .exportFunc();
   builder.addFunction("grow", kSig_i_i)
-    .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+    .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   var instances = [];
   for (var i = 0; i < 5; i++) {

test/mjsunit/wasm/interpreter-mixed.js

@@ -26,11 +26,11 @@ function checkStack(stack, expected_lines) {
   }
 }
 
-(function testGrowMemoryBetweenInterpretedAndCompiled() {
+(function testMemoryGrowBetweenInterpretedAndCompiled() {
   // grow_memory can be called from interpreted or compiled code, and changes
   // should be reflected in either execution.
   var builder = new WasmModuleBuilder();
-  var grow_body = [kExprGetLocal, 0, kExprGrowMemory, kMemoryZero];
+  var grow_body = [kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero];
   var load_body = [kExprGetLocal, 0, kExprI32LoadMem, 0, 0];
   var store_body = [kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0];
   builder.addFunction('grow_memory', kSig_i_i).addBody(grow_body).exportFunc();

test/mjsunit/wasm/large-offset.js

@@ -5,15 +5,15 @@
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
-function testGrowMemoryOutOfBoundsOffset() {
-  print("testGrowMemoryOutOfBoundsOffset2");
+function testMemoryGrowOutOfBoundsOffset() {
+  print("testMemoryGrowOutOfBoundsOffset2");
   var builder = new WasmModuleBuilder();
   builder.addMemory(16, 128, false);
   builder.addFunction("main", kSig_v_v)
       .addBody([
           kExprI32Const, 20,
           kExprI32Const, 29,
-          kExprGrowMemory, kMemoryZero,
+          kExprMemoryGrow, kMemoryZero,
           // Assembly equivalent Move <reg>,0xf5fffff
           // with wasm memory reference relocation information
           kExprI32StoreMem, 0, 0xFF, 0xFF, 0xFF, 0x7A
@@ -23,4 +23,4 @@ function testGrowMemoryOutOfBoundsOffset() {
   assertTraps(kTrapMemOutOfBounds, module.exports.main);
 }
 
-testGrowMemoryOutOfBoundsOffset();
+testMemoryGrowOutOfBoundsOffset();

test/mjsunit/wasm/memory-instance-validation.js

@@ -18,7 +18,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
     .addBody([kExprMemorySize, kMemoryZero])
     .exportFunc();
   builder.addFunction("grow", kSig_i_i)
-    .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero])
+    .addBody([kExprGetLocal, 0, kExprMemoryGrow, kMemoryZero])
     .exportFunc();
   var instances = [];
   for (var i = 0; i < 5; i++) {

test/mjsunit/wasm/wasm-constants.js

@@ -220,7 +220,7 @@ let kExprI64StoreMem8 = 0x3c;
 let kExprI64StoreMem16 = 0x3d;
 let kExprI64StoreMem32 = 0x3e;
 let kExprMemorySize = 0x3f;
-let kExprGrowMemory = 0x40;
+let kExprMemoryGrow = 0x40;
 let kExprI32Eqz = 0x45;
 let kExprI32Eq = 0x46;
 let kExprI32Ne = 0x47;

test/mjsunit/wasm/wasm-module-builder.js

@@ -69,12 +69,12 @@ class Binary extends Array {
     // Emit section name.
     this.emit_u8(section_code);
     // Emit the section to a temporary buffer: its full length isn't know yet.
-    let section = new Binary;
+    const section = new Binary;
     content_generator(section);
     // Emit section length.
     this.emit_u32v(section.length);
     // Copy the temporary buffer.
-    for (var i = 0; i < section.length; i++) this.push(section[i]);
+    this.push(...section);
   }
 }
 

test/unittests/wasm/function-body-decoder-unittest.cc

@@ -1798,22 +1798,22 @@ TEST_F(FunctionBodyDecoderTest, AllSetGlobalCombinations) {
   }
 }
 
-TEST_F(FunctionBodyDecoderTest, WasmGrowMemory) {
+TEST_F(FunctionBodyDecoderTest, WasmMemoryGrow) {
   TestModuleBuilder builder;
   module = builder.module();
   builder.InitializeMemory();
 
-  byte code[] = {WASM_GET_LOCAL(0), kExprGrowMemory, 0};
+  byte code[] = {WASM_GET_LOCAL(0), kExprMemoryGrow, 0};
   EXPECT_VERIFIES_C(i_i, code);
   EXPECT_FAILURE_C(i_d, code);
 }
 
-TEST_F(FunctionBodyDecoderTest, AsmJsGrowMemory) {
+TEST_F(FunctionBodyDecoderTest, AsmJsMemoryGrow) {
   TestModuleBuilder builder(kAsmJsOrigin);
   module = builder.module();
   builder.InitializeMemory();
 
-  byte code[] = {WASM_GET_LOCAL(0), kExprGrowMemory, 0};
+  byte code[] = {WASM_GET_LOCAL(0), kExprMemoryGrow, 0};
   EXPECT_FAILURE_C(i_i, code);
 }
 
@@ -2895,7 +2895,7 @@ TEST_F(WasmOpcodeLengthTest, LoadsAndStores) {
 
 TEST_F(WasmOpcodeLengthTest, MiscMemExpressions) {
   EXPECT_LENGTH(2, kExprMemorySize);
-  EXPECT_LENGTH(2, kExprGrowMemory);
+  EXPECT_LENGTH(2, kExprMemoryGrow);
 }
 
 TEST_F(WasmOpcodeLengthTest, SimpleExpressions) {