Reflect instruction renaming in code (#2128)

- Reflected new renamed instruction names in code and tests:
  - `get_local` -> `local.get`
  - `set_local` -> `local.set`
  - `tee_local` -> `local.tee`
  - `get_global` -> `global.get`
  - `set_global` -> `global.set`
  - `current_memory` -> `memory.size`
  - `grow_memory` -> `memory.grow`

- Removed APIs related to old instruction names in Binaryen.js and added
  APIs with new names if they are missing.

- Renamed `typedef SortedVector LocalSet` to `SetsOfLocals` to prevent
  name clashes.

- Resolved several TODO renaming items in wasm-binary.h:
  - `TableSwitch` -> `BrTable`
  - `I32ConvertI64` -> `I32WrapI64`
  - `I64STruncI32` -> `I64SExtendI32`
  - `I64UTruncI32` -> `I64UExtendI32`
  - `F32ConvertF64` -> `F32DemoteI64`
  - `F64ConvertF32` -> `F64PromoteF32`

- Renamed `BinaryenGetFeatures` and `BinaryenSetFeatures` to
  `BinaryenModuleGetFeatures` and `BinaryenModuleSetFeatures` for
  consistency.

1 files changed, 27 insertions, 27 deletions

diff --git a/src/wasm2js.h b/src/wasm2js.h
index 2ed531b8d..259ef47f3 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -404,7 +404,7 @@ Ref Wasm2JSBuilder::processWasm(Module* wasm, Name funcName) {
                            std::move(params),
                            i32,
                            std::move(vars),
-                           builder.makeReturn(builder.makeGetGlobal(
+                           builder.makeReturn(builder.makeGlobalGet(
                              INT64_TO_32_HIGH_BITS, i32)))));
     auto e = new Export();
     e->name = WASM_FETCH_HIGH_BITS;
@@ -547,7 +547,7 @@ void Wasm2JSBuilder::addTable(Ref ast, Module* wasm) {
         Ref index;
         if (auto* c = offset->dynCast<Const>()) {
           index = ValueBuilder::makeInt(c->value.geti32() + i);
-        } else if (auto* get = offset->dynCast<GetGlobal>()) {
+        } else if (auto* get = offset->dynCast<GlobalGet>()) {
           index = ValueBuilder::makeBinary(
             ValueBuilder::makeName(stringToIString(asmangle(get->name.str))),
             PLUS,
@@ -578,7 +578,7 @@ void Wasm2JSBuilder::addExports(Ref ast, Module* wasm) {
       Ref growDesc = ValueBuilder::makeObject();
       ValueBuilder::appendToObjectWithQuotes(descs, IString("grow"), growDesc);
       ValueBuilder::appendToObjectWithQuotes(
-        growDesc, IString("value"), ValueBuilder::makeName(WASM_GROW_MEMORY));
+        growDesc, IString("value"), ValueBuilder::makeName(WASM_MEMORY_GROW));
       Ref bufferDesc = ValueBuilder::makeObject();
       Ref bufferGetter = ValueBuilder::makeFunction(IString(""));
       bufferGetter[3]->push_back(
@@ -630,7 +630,7 @@ void Wasm2JSBuilder::addGlobal(Ref ast, Global* global) {
     ast->push_back(theVar);
     ValueBuilder::appendToVar(
       theVar, fromName(global->name, NameScope::Top), theValue);
-  } else if (auto* get = global->init->dynCast<GetGlobal>()) {
+  } else if (auto* get = global->init->dynCast<GlobalGet>()) {
     Ref theVar = ValueBuilder::makeVar();
     ast->push_back(theVar);
     ValueBuilder::appendToVar(
@@ -991,23 +991,23 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
         visit(value, EXPRESSION_RESULT));
     }
 
-    Ref visitGetLocal(GetLocal* curr) {
+    Ref visitLocalGet(LocalGet* curr) {
       return ValueBuilder::makeName(
         fromName(func->getLocalNameOrGeneric(curr->index), NameScope::Local));
     }
 
-    Ref visitSetLocal(SetLocal* curr) {
+    Ref visitLocalSet(LocalSet* curr) {
       return makeSetVar(curr,
                         curr->value,
                         func->getLocalNameOrGeneric(curr->index),
                         NameScope::Local);
     }
 
-    Ref visitGetGlobal(GetGlobal* curr) {
+    Ref visitGlobalGet(GlobalGet* curr) {
       return ValueBuilder::makeName(fromName(curr->name, NameScope::Top));
     }
 
-    Ref visitSetGlobal(SetGlobal* curr) {
+    Ref visitGlobalSet(GlobalSet* curr) {
       return makeSetVar(curr, curr->value, curr->name, NameScope::Top);
     }
 
@@ -1092,10 +1092,10 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
           sequenceAppend(ret, visitAndAssign(curr->ptr, ptr));
           ScopedTemp value(curr->value->type, parent, func);
           sequenceAppend(ret, visitAndAssign(curr->value, value));
-          GetLocal getPtr;
+          LocalGet getPtr;
           getPtr.index = func->getLocalIndex(ptr.getName());
           getPtr.type = i32;
-          GetLocal getValue;
+          LocalGet getValue;
           getValue.index = func->getLocalIndex(value.getName());
           getValue.type = curr->value->type;
           Store fakeStore = *curr;
@@ -1584,18 +1584,18 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
     }
 
     Ref visitHost(Host* curr) {
-      if (curr->op == HostOp::GrowMemory) {
+      if (curr->op == HostOp::MemoryGrow) {
         if (module->memory.exists &&
             module->memory.max > module->memory.initial) {
           return ValueBuilder::makeCall(
-            WASM_GROW_MEMORY,
+            WASM_MEMORY_GROW,
             makeAsmCoercion(visit(curr->operands[0], EXPRESSION_RESULT),
                             wasmToAsmType(curr->operands[0]->type)));
         } else {
           return ValueBuilder::makeCall(ABORT_FUNC);
         }
-      } else if (curr->op == HostOp::CurrentMemory) {
-        return ValueBuilder::makeCall(WASM_CURRENT_MEMORY);
+      } else if (curr->op == HostOp::MemorySize) {
+        return ValueBuilder::makeCall(WASM_MEMORY_SIZE);
       }
       WASM_UNREACHABLE(); // TODO
     }
@@ -1623,10 +1623,10 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
 }
 
 void Wasm2JSBuilder::addMemoryGrowthFuncs(Ref ast, Module* wasm) {
-  Ref growMemoryFunc = ValueBuilder::makeFunction(WASM_GROW_MEMORY);
-  ValueBuilder::appendArgumentToFunction(growMemoryFunc, IString("pagesToAdd"));
+  Ref memoryGrowFunc = ValueBuilder::makeFunction(WASM_MEMORY_GROW);
+  ValueBuilder::appendArgumentToFunction(memoryGrowFunc, IString("pagesToAdd"));
 
-  growMemoryFunc[3]->push_back(
+  memoryGrowFunc[3]->push_back(
     ValueBuilder::makeStatement(ValueBuilder::makeBinary(
       ValueBuilder::makeName(IString("pagesToAdd")),
       SET,
@@ -1634,15 +1634,15 @@ void Wasm2JSBuilder::addMemoryGrowthFuncs(Ref ast, Module* wasm) {
                       AsmType::ASM_INT))));
 
   Ref oldPages = ValueBuilder::makeVar();
-  growMemoryFunc[3]->push_back(oldPages);
+  memoryGrowFunc[3]->push_back(oldPages);
   ValueBuilder::appendToVar(
     oldPages,
     IString("oldPages"),
-    makeAsmCoercion(ValueBuilder::makeCall(WASM_CURRENT_MEMORY),
+    makeAsmCoercion(ValueBuilder::makeCall(WASM_MEMORY_SIZE),
                     AsmType::ASM_INT));
 
   Ref newPages = ValueBuilder::makeVar();
-  growMemoryFunc[3]->push_back(newPages);
+  memoryGrowFunc[3]->push_back(newPages);
   ValueBuilder::appendToVar(
     newPages,
     IString("newPages"),
@@ -1653,7 +1653,7 @@ void Wasm2JSBuilder::addMemoryGrowthFuncs(Ref ast, Module* wasm) {
       AsmType::ASM_INT));
 
   Ref block = ValueBuilder::makeBlock();
-  growMemoryFunc[3]->push_back(ValueBuilder::makeIf(
+  memoryGrowFunc[3]->push_back(ValueBuilder::makeIf(
     ValueBuilder::makeBinary(
       ValueBuilder::makeBinary(ValueBuilder::makeName(IString("oldPages")),
                                LT,
@@ -1735,19 +1735,19 @@ void Wasm2JSBuilder::addMemoryGrowthFuncs(Ref ast, Module* wasm) {
         ValueBuilder::makeName(IString("newBuffer"))));
   }
 
-  growMemoryFunc[3]->push_back(
+  memoryGrowFunc[3]->push_back(
     ValueBuilder::makeReturn(ValueBuilder::makeName(IString("oldPages"))));
 
-  Ref currentMemoryFunc = ValueBuilder::makeFunction(WASM_CURRENT_MEMORY);
-  currentMemoryFunc[3]->push_back(ValueBuilder::makeReturn(
+  Ref memorySizeFunc = ValueBuilder::makeFunction(WASM_MEMORY_SIZE);
+  memorySizeFunc[3]->push_back(ValueBuilder::makeReturn(
     makeAsmCoercion(ValueBuilder::makeBinary(
                       ValueBuilder::makeDot(ValueBuilder::makeName(BUFFER),
                                             IString("byteLength")),
                       DIV,
                       ValueBuilder::makeInt(Memory::kPageSize)),
                     AsmType::ASM_INT)));
-  ast->push_back(growMemoryFunc);
-  ast->push_back(currentMemoryFunc);
+  ast->push_back(memoryGrowFunc);
+  ast->push_back(memorySizeFunc);
 }
 
 // Wasm2JSGlue emits the core of the module - the functions etc. that would
@@ -1973,7 +1973,7 @@ void Wasm2JSGlue::emitMemory(
       ;
       return std::to_string(c->value.getInteger());
     }
-    if (auto* get = segment.offset->template dynCast<GetGlobal>()) {
+    if (auto* get = segment.offset->template dynCast<GlobalGet>()) {
       auto internalName = get->name;
       auto importedName = wasm.getGlobal(internalName)->base;
       return accessGlobal(asmangle(importedName.str));