Remove `Push` (#2867)

Push and Pop have been superseded by tuples for their original
intended purpose of supporting multivalue. Pop is still used to
represent block arguments for exception handling, but there are no
plans to use Push for anything now or in the future.

20 files changed, 5 insertions, 141 deletions

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index be3b651f7..c94867032 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -269,7 +269,6 @@ BinaryenExpressionId BinaryenTupleMakeId(void) {
 BinaryenExpressionId BinaryenTupleExtractId(void) {
   return Expression::Id::TupleExtractId;
 }
-BinaryenExpressionId BinaryenPushId(void) { return Expression::Id::PushId; }
 BinaryenExpressionId BinaryenPopId(void) { return Expression::Id::PopId; }
 
 // External kinds
@@ -1249,11 +1248,6 @@ BinaryenExpressionRef BinaryenTupleExtract(BinaryenModuleRef module,
     Builder(*(Module*)module).makeTupleExtract((Expression*)tuple, index));
 }
 
-BinaryenExpressionRef BinaryenPush(BinaryenModuleRef module,
-                                   BinaryenExpressionRef value) {
-  return static_cast<Expression*>(
-    Builder(*(Module*)module).makePush((Expression*)value));
-}
 BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module, BinaryenType type) {
   return static_cast<Expression*>(
     Builder(*(Module*)module).makePop(Type(type)));
@@ -2033,12 +2027,6 @@ BinaryenIndex BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr) {
   assert(expression->is<TupleExtract>());
   return static_cast<TupleExtract*>(expression)->index;
 }
-// Push
-BinaryenExpressionRef BinaryenPushGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
-  assert(expression->is<Push>());
-  return static_cast<Push*>(expression)->value;
-}
 
 // Functions
 
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index b21a028ac..53fe69b92 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -169,7 +169,6 @@ BINARYEN_API BinaryenExpressionId BinaryenRethrowId(void);
 BINARYEN_API BinaryenExpressionId BinaryenBrOnExnId(void);
 BINARYEN_API BinaryenExpressionId BinaryenTupleMakeId(void);
 BINARYEN_API BinaryenExpressionId BinaryenTupleExtractId(void);
-BINARYEN_API BinaryenExpressionId BinaryenPushId(void);
 BINARYEN_API BinaryenExpressionId BinaryenPopId(void);
 
 // External kinds (call to get the value of each; you can cache them)
@@ -844,8 +843,6 @@ BinaryenTupleMake(BinaryenModuleRef module,
                   BinaryenIndex numOperands);
 BINARYEN_API BinaryenExpressionRef BinaryenTupleExtract(
   BinaryenModuleRef module, BinaryenExpressionRef tuple, BinaryenIndex index);
-BINARYEN_API BinaryenExpressionRef BinaryenPush(BinaryenModuleRef module,
-                                                BinaryenExpressionRef value);
 BINARYEN_API BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module,
                                                BinaryenType type);
 
@@ -1105,9 +1102,6 @@ BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr);
 BINARYEN_API BinaryenIndex
 BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr);
 
-BINARYEN_API BinaryenExpressionRef
-BinaryenPushGetValue(BinaryenExpressionRef expr);
-
 // Functions
 
 BINARYEN_REF(Function);
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 4c8e991c6..3a7569a61 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -2537,9 +2537,6 @@ switch (op[0]) {
       default: goto parse_error;
     }
   }
-  case 'p':
-    if (strcmp(op, "push") == 0) { return makePush(s); }
-    goto parse_error;
   case 'r': {
     switch (op[2]) {
       case 'f': {
diff --git a/src/ir/ExpressionAnalyzer.cpp b/src/ir/ExpressionAnalyzer.cpp
index 4c87bae28..a6f4b601f 100644
--- a/src/ir/ExpressionAnalyzer.cpp
+++ b/src/ir/ExpressionAnalyzer.cpp
@@ -231,7 +231,6 @@ template<typename T> void visitImmediates(Expression* curr, T& visitor) {
     }
     void visitNop(Nop* curr) {}
     void visitUnreachable(Unreachable* curr) {}
-    void visitPush(Push* curr) {}
     void visitPop(Pop* curr) {}
     void visitTupleMake(TupleMake* curr) {}
     void visitTupleExtract(TupleExtract* curr) {
diff --git a/src/ir/ExpressionManipulator.cpp b/src/ir/ExpressionManipulator.cpp
index 590d0c1ba..a9fd3c599 100644
--- a/src/ir/ExpressionManipulator.cpp
+++ b/src/ir/ExpressionManipulator.cpp
@@ -257,9 +257,6 @@ flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) {
     Expression* visitUnreachable(Unreachable* curr) {
       return builder.makeUnreachable();
     }
-    Expression* visitPush(Push* curr) {
-      return builder.makePush(copy(curr->value));
-    }
     Expression* visitPop(Pop* curr) { return builder.makePop(curr->type); }
     Expression* visitTupleMake(TupleMake* curr) {
       std::vector<Expression*> operands;
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index 1de2e97a6..41bca48d4 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -136,7 +136,6 @@ void ReFinalize::visitBrOnExn(BrOnExn* curr) {
 }
 void ReFinalize::visitNop(Nop* curr) { curr->finalize(); }
 void ReFinalize::visitUnreachable(Unreachable* curr) { curr->finalize(); }
-void ReFinalize::visitPush(Push* curr) { curr->finalize(); }
 void ReFinalize::visitPop(Pop* curr) { curr->finalize(); }
 void ReFinalize::visitTupleMake(TupleMake* curr) { curr->finalize(); }
 void ReFinalize::visitTupleExtract(TupleExtract* curr) { curr->finalize(); }
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 55c78f05a..79233e6a8 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -458,7 +458,6 @@ struct EffectAnalyzer
   }
   void visitNop(Nop* curr) {}
   void visitUnreachable(Unreachable* curr) { branches = true; }
-  void visitPush(Push* curr) { calls = true; }
   void visitPop(Pop* curr) { calls = true; }
   void visitTupleMake(TupleMake* curr) {}
   void visitTupleExtract(TupleExtract* curr) {}
diff --git a/src/ir/utils.h b/src/ir/utils.h
index ded7059ca..a06598095 100644
--- a/src/ir/utils.h
+++ b/src/ir/utils.h
@@ -155,7 +155,6 @@ struct ReFinalize
   void visitBrOnExn(BrOnExn* curr);
   void visitNop(Nop* curr);
   void visitUnreachable(Unreachable* curr);
-  void visitPush(Push* curr);
   void visitPop(Pop* curr);
   void visitTupleMake(TupleMake* curr);
   void visitTupleExtract(TupleExtract* curr);
@@ -224,7 +223,6 @@ struct ReFinalizeNode : public OverriddenVisitor<ReFinalizeNode> {
   void visitBrOnExn(BrOnExn* curr) { curr->finalize(); }
   void visitNop(Nop* curr) { curr->finalize(); }
   void visitUnreachable(Unreachable* curr) { curr->finalize(); }
-  void visitPush(Push* curr) { curr->finalize(); }
   void visitPop(Pop* curr) { curr->finalize(); }
   void visitTupleMake(TupleMake* curr) { curr->finalize(); }
   void visitTupleExtract(TupleExtract* curr) { curr->finalize(); }
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 1902bddfa..8a2d60a2f 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -97,7 +97,6 @@ function initializeConstants() {
     'BrOnExn',
     'TupleMake',
     'TupleExtract',
-    'Push',
     'Pop'
   ].forEach(function(name) {
     Module['ExpressionIds'][name] = Module[name + 'Id'] = Module['_Binaryen' + name + 'Id']();
@@ -2119,9 +2118,6 @@ function wrapModule(module, self) {
       return Module['_BinaryenBrOnExn'](module, strToStack(label), strToStack(event_), exnref);
     });
   };
-  self['push'] = function(value) {
-    return Module['_BinaryenPush'](module, value);
-  };
 
   self['tuple'] = {
     'make': function(elements) {
@@ -2869,11 +2865,6 @@ Module['getExpressionInfo'] = function(expr) {
         'tuple': Module['_BinaryenTupleExtractGetTuple'](expr),
         'index': Module['_BinaryenTupleExtractGetIndex'](expr)
       };
-    case Module['PushId']:
-      return {
-        'id': id,
-        'value': Module['_BinaryenPushGetValue'](expr)
-      };
 
     default:
       throw Error('unexpected id: ' + id);
diff --git a/src/passes/DeadCodeElimination.cpp b/src/passes/DeadCodeElimination.cpp
index 400252e8f..9e2e194cb 100644
--- a/src/passes/DeadCodeElimination.cpp
+++ b/src/passes/DeadCodeElimination.cpp
@@ -351,8 +351,6 @@ struct DeadCodeElimination
           DELEGATE(MemoryCopy);
         case Expression::Id::MemoryFillId:
           DELEGATE(MemoryFill);
-        case Expression::Id::PushId:
-          DELEGATE(Push);
         case Expression::Id::PopId:
           DELEGATE(Pop);
         case Expression::Id::RefNullId:
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 62eac9b06..efa31cac0 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1436,7 +1436,6 @@ struct PrintExpressionContents
   }
   void visitNop(Nop* curr) { printMinor(o, "nop"); }
   void visitUnreachable(Unreachable* curr) { printMinor(o, "unreachable"); }
-  void visitPush(Push* curr) { prepareColor(o) << "push"; }
   void visitPop(Pop* curr) {
     prepareColor(o) << curr->type;
     o << ".pop";
@@ -2008,13 +2007,6 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
     PrintExpressionContents(currFunction, o).visit(curr);
     o << ')';
   }
-  void visitPush(Push* curr) {
-    o << '(';
-    PrintExpressionContents(currFunction, o).visit(curr);
-    incIndent();
-    printFullLine(curr->value);
-    decIndent();
-  }
   void visitPop(Pop* curr) {
     o << '(';
     PrintExpressionContents(currFunction, o).visit(curr);
@@ -2600,9 +2592,9 @@ WasmPrinter::printStackIR(StackIR* ir, std::ostream& o, Function* func) {
     switch (inst->op) {
       case StackInst::Basic: {
         doIndent();
-        // push and pop are pseudo instructions and should not be printed in the
-        // stack IR format to make it valid wat form.
-        if (inst->origin->is<Push>() || inst->origin->is<Pop>()) {
+        // Pop is a pseudo instruction and should not be printed in the stack IR
+        // format to make it valid wat form.
+        if (inst->origin->is<Pop>()) {
           break;
         }
         PrintExpressionContents(func, o).visit(inst->origin);
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 6d57ae438..5df512745 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -589,12 +589,6 @@ public:
     return ret;
   }
   Unreachable* makeUnreachable() { return allocator.alloc<Unreachable>(); }
-  Push* makePush(Expression* value) {
-    auto* ret = allocator.alloc<Push>();
-    ret->value = value;
-    ret->finalize();
-    return ret;
-  }
   Pop* makePop(Type type) {
     auto* ret = allocator.alloc<Pop>();
     ret->type = type;
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 56e453b64..c47786a08 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1222,7 +1222,6 @@ public:
   Flow visitSIMDLoad(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitSIMDLoadSplat(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitSIMDLoadExtend(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); }
-  Flow visitPush(Push* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitPop(Pop* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitRefNull(RefNull* curr) {
     NOTE_ENTER("RefNull");
@@ -1521,10 +1520,6 @@ public:
     NOTE_ENTER("SIMDLoadExtend");
     return Flow(NONCONSTANT_FLOW);
   }
-  Flow visitPush(Push* curr) {
-    NOTE_ENTER("Push");
-    return Flow(NONCONSTANT_FLOW);
-  }
   Flow visitPop(Pop* curr) {
     NOTE_ENTER("Pop");
     return Flow(NONCONSTANT_FLOW);
@@ -2425,15 +2420,6 @@ private:
         return this->visit(curr->catchBody);
       }
     }
-    Flow visitPush(Push* curr) {
-      NOTE_ENTER("Push");
-      Flow value = this->visit(curr->value);
-      if (value.breaking()) {
-        return value;
-      }
-      instance.multiValues.push_back(value.getSingleValue());
-      return Flow();
-    }
     Flow visitPop(Pop* curr) {
       NOTE_ENTER("Pop");
       assert(!instance.multiValues.empty());
diff --git a/src/wasm-stack.h b/src/wasm-stack.h
index e00fde5eb..09c8589b0 100644
--- a/src/wasm-stack.h
+++ b/src/wasm-stack.h
@@ -141,7 +141,6 @@ public:
   void visitNop(Nop* curr);
   void visitUnreachable(Unreachable* curr);
   void visitDrop(Drop* curr);
-  void visitPush(Push* curr);
   void visitPop(Pop* curr);
   void visitTupleMake(TupleMake* curr);
   void visitTupleExtract(TupleExtract* curr);
@@ -234,7 +233,6 @@ public:
   void visitNop(Nop* curr);
   void visitUnreachable(Unreachable* curr);
   void visitDrop(Drop* curr);
-  void visitPush(Push* curr);
   void visitPop(Pop* curr);
   void visitTupleMake(TupleMake* curr);
   void visitTupleExtract(TupleExtract* curr);
@@ -794,12 +792,6 @@ void BinaryenIRWriter<SubType>::visitDrop(Drop* curr) {
   emit(curr);
 }
 
-template<typename SubType>
-void BinaryenIRWriter<SubType>::visitPush(Push* curr) {
-  visit(curr->value);
-  emit(curr);
-}
-
 template<typename SubType> void BinaryenIRWriter<SubType>::visitPop(Pop* curr) {
   emit(curr);
 }
diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h
index 4cf318db9..fc6b1cbb8 100644
--- a/src/wasm-traversal.h
+++ b/src/wasm-traversal.h
@@ -81,7 +81,6 @@ template<typename SubType, typename ReturnType = void> struct Visitor {
   ReturnType visitBrOnExn(BrOnExn* curr) { return ReturnType(); }
   ReturnType visitNop(Nop* curr) { return ReturnType(); }
   ReturnType visitUnreachable(Unreachable* curr) { return ReturnType(); }
-  ReturnType visitPush(Push* curr) { return ReturnType(); }
   ReturnType visitPop(Pop* curr) { return ReturnType(); }
   ReturnType visitTupleMake(TupleMake* curr) { return ReturnType(); }
   ReturnType visitTupleExtract(TupleExtract* curr) { return ReturnType(); }
@@ -190,8 +189,6 @@ template<typename SubType, typename ReturnType = void> struct Visitor {
         DELEGATE(Nop);
       case Expression::Id::UnreachableId:
         DELEGATE(Unreachable);
-      case Expression::Id::PushId:
-        DELEGATE(Push);
       case Expression::Id::PopId:
         DELEGATE(Pop);
       case Expression::Id::TupleMakeId:
@@ -265,7 +262,6 @@ struct OverriddenVisitor {
   UNIMPLEMENTED(BrOnExn);
   UNIMPLEMENTED(Nop);
   UNIMPLEMENTED(Unreachable);
-  UNIMPLEMENTED(Push);
   UNIMPLEMENTED(Pop);
   UNIMPLEMENTED(TupleMake);
   UNIMPLEMENTED(TupleExtract);
@@ -375,8 +371,6 @@ struct OverriddenVisitor {
         DELEGATE(Nop);
       case Expression::Id::UnreachableId:
         DELEGATE(Unreachable);
-      case Expression::Id::PushId:
-        DELEGATE(Push);
       case Expression::Id::PopId:
         DELEGATE(Pop);
       case Expression::Id::TupleMakeId:
@@ -533,9 +527,6 @@ struct UnifiedExpressionVisitor : public Visitor<SubType, ReturnType> {
   ReturnType visitUnreachable(Unreachable* curr) {
     return static_cast<SubType*>(this)->visitExpression(curr);
   }
-  ReturnType visitPush(Push* curr) {
-    return static_cast<SubType*>(this)->visitExpression(curr);
-  }
   ReturnType visitPop(Pop* curr) {
     return static_cast<SubType*>(this)->visitExpression(curr);
   }
@@ -850,9 +841,6 @@ struct Walker : public VisitorType {
   static void doVisitUnreachable(SubType* self, Expression** currp) {
     self->visitUnreachable((*currp)->cast<Unreachable>());
   }
-  static void doVisitPush(SubType* self, Expression** currp) {
-    self->visitPush((*currp)->cast<Push>());
-  }
   static void doVisitPop(SubType* self, Expression** currp) {
     self->visitPop((*currp)->cast<Pop>());
   }
@@ -1141,11 +1129,6 @@ struct PostWalker : public Walker<SubType, VisitorType> {
         self->pushTask(SubType::doVisitUnreachable, currp);
         break;
       }
-      case Expression::Id::PushId: {
-        self->pushTask(SubType::doVisitPush, currp);
-        self->pushTask(SubType::scan, &curr->cast<Push>()->value);
-        break;
-      }
       case Expression::Id::PopId: {
         self->pushTask(SubType::doVisitPop, currp);
         break;
diff --git a/src/wasm.h b/src/wasm.h
index c43544cc1..0afe5ab28 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -540,7 +540,6 @@ public:
     DataDropId,
     MemoryCopyId,
     MemoryFillId,
-    PushId,
     PopId,
     RefNullId,
     RefIsNullId,
@@ -1067,25 +1066,8 @@ public:
   Unreachable(MixedArena& allocator) : Unreachable() {}
 };
 
-// A multivalue push. This represents a push of a value, which will be
-// used in the next return. That is, a multivalue return is done by
-// pushing some values, then doing a return (with a value as well).
-// For more on this design, see the readme.
-class Push : public SpecificExpression<Expression::PushId> {
-public:
-  Push() = default;
-  Push(MixedArena& allocator) {}
-
-  Expression* value;
-
-  void finalize();
-};
-
-// A multivalue pop. This represents a pop of a value, which arrived
-// from a multivalue call or other situation where there are things on
-// the stack. That is, a multivalue-returning call is done by doing
-// the call, receiving the first value normally, and receiving the others
-// via calls to pop.
+// Represents a pop of a value that arrives as an implicit argument to the
+// current block. Currently used in exception handling.
 class Pop : public SpecificExpression<Expression::PopId> {
 public:
   Pop() = default;
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 65351fe99..7ca8dd131 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -1581,13 +1581,6 @@ Expression* SExpressionWasmBuilder::makeMemoryFill(Element& s) {
   return ret;
 }
 
-Expression* SExpressionWasmBuilder::makePush(Element& s) {
-  auto ret = allocator.alloc<Push>();
-  ret->value = parseExpression(s[1]);
-  ret->finalize();
-  return ret;
-}
-
 Expression* SExpressionWasmBuilder::makePop(Type type) {
   auto ret = allocator.alloc<Pop>();
   ret->type = type;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 3c5122c10..58fa3f2ef 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -1707,10 +1707,6 @@ void BinaryInstWriter::visitDrop(Drop* curr) {
   }
 }
 
-void BinaryInstWriter::visitPush(Push* curr) {
-  // Turns into nothing in the binary format
-}
-
 void BinaryInstWriter::visitPop(Pop* curr) {
   // Turns into nothing in the binary format
 }
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index bce1aa4de..704e48e88 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -171,8 +171,6 @@ const char* getExpressionName(Expression* curr) {
       return "memory_copy";
     case Expression::Id::MemoryFillId:
       return "memory_fill";
-    case Expression::Id::PushId:
-      return "push";
     case Expression::Id::PopId:
       return "pop";
     case Expression::Id::RefNullId:
@@ -913,14 +911,6 @@ void BrOnExn::finalize() {
   }
 }
 
-void Push::finalize() {
-  if (value->type == Type::unreachable) {
-    type = Type::unreachable;
-  } else {
-    type = Type::none;
-  }
-}
-
 void TupleMake::finalize() {
   std::vector<Type> types;
   for (auto* op : operands) {
diff --git a/src/wasm2js.h b/src/wasm2js.h
index 1d8003323..e5f473e21 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -1889,10 +1889,6 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
-    Ref visitPush(Push* curr) {
-      unimplemented(curr);
-      WASM_UNREACHABLE("unimp");
-    }
     Ref visitPop(Pop* curr) {
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");