6 files changed, 31 insertions, 21 deletions
diff --git a/src/ir/ExpressionAnalyzer.cpp b/src/ir/ExpressionAnalyzer.cpp
index d2f9611f9..37ba82e81 100644
--- a/src/ir/ExpressionAnalyzer.cpp
+++ b/src/ir/ExpressionAnalyzer.cpp
@@ -215,10 +215,8 @@ template<typename T> void visitImmediates(Expression* curr, T& visitor) {
     void visitSelect(Select* curr) {}
     void visitDrop(Drop* curr) {}
     void visitReturn(Return* curr) {}
-    void visitHost(Host* curr) {
-      visitor.visitInt(curr->op);
-      visitor.visitNonScopeName(curr->nameOperand);
-    }
+    void visitMemorySize(MemorySize* curr) {}
+    void visitMemoryGrow(MemoryGrow* curr) {}
     void visitRefNull(RefNull* curr) { visitor.visitType(curr->type); }
     void visitRefIsNull(RefIsNull* curr) {}
     void visitRefFunc(RefFunc* curr) { visitor.visitNonScopeName(curr->func); }
diff --git a/src/ir/ExpressionManipulator.cpp b/src/ir/ExpressionManipulator.cpp
index 6f64ec77b..e1264e96e 100644
--- a/src/ir/ExpressionManipulator.cpp
+++ b/src/ir/ExpressionManipulator.cpp
@@ -218,14 +218,11 @@ flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) {
     Expression* visitReturn(Return* curr) {
       return builder.makeReturn(copy(curr->value));
     }
-    Expression* visitHost(Host* curr) {
-      std::vector<Expression*> operands;
-      for (Index i = 0; i < curr->operands.size(); i++) {
-        operands.push_back(copy(curr->operands[i]));
-      }
-      auto* ret =
-        builder.makeHost(curr->op, curr->nameOperand, std::move(operands));
-      return ret;
+    Expression* visitMemorySize(MemorySize* curr) {
+      return builder.makeMemorySize();
+    }
+    Expression* visitMemoryGrow(MemoryGrow* curr) {
+      return builder.makeMemoryGrow(copy(curr->delta));
     }
     Expression* visitRefNull(RefNull* curr) {
       return builder.makeRefNull(curr->type);
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index 822fc5808..b6e2a1b59 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -119,7 +119,8 @@ void ReFinalize::visitBinary(Binary* curr) { curr->finalize(); }
 void ReFinalize::visitSelect(Select* curr) { curr->finalize(); }
 void ReFinalize::visitDrop(Drop* curr) { curr->finalize(); }
 void ReFinalize::visitReturn(Return* curr) { curr->finalize(); }
-void ReFinalize::visitHost(Host* curr) { curr->finalize(); }
+void ReFinalize::visitMemorySize(MemorySize* curr) { curr->finalize(); }
+void ReFinalize::visitMemoryGrow(MemoryGrow* curr) { curr->finalize(); }
 void ReFinalize::visitRefNull(RefNull* curr) { curr->finalize(); }
 void ReFinalize::visitRefIsNull(RefIsNull* curr) { curr->finalize(); }
 void ReFinalize::visitRefFunc(RefFunc* curr) { curr->finalize(); }
diff --git a/src/ir/cost.h b/src/ir/cost.h
index ea3e32909..056d51447 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -754,7 +754,8 @@ struct CostAnalyzer : public Visitor<CostAnalyzer, Index> {
   }
   Index visitDrop(Drop* curr) { return visit(curr->value); }
   Index visitReturn(Return* curr) { return maybeVisit(curr->value); }
-  Index visitHost(Host* curr) { return 100; }
+  Index visitMemorySize(MemorySize* curr) { return 1; }
+  Index visitMemoryGrow(MemoryGrow* curr) { return 100; }
   Index visitRefNull(RefNull* curr) { return 1; }
   Index visitRefIsNull(RefIsNull* curr) { return 1; }
   Index visitRefFunc(RefFunc* curr) { return 1; }
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 9d6e90936..b973d7446 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -428,7 +428,8 @@ struct EffectAnalyzer
           implicitTrap = true;
           break;
         }
-        default: {}
+        default: {
+        }
       }
     }
   }
@@ -446,17 +447,27 @@ struct EffectAnalyzer
           implicitTrap = true;
           break;
         }
-        default: {}
+        default: {
+        }
       }
     }
   }
   void visitSelect(Select* curr) {}
   void visitDrop(Drop* curr) {}
   void visitReturn(Return* curr) { branchesOut = true; }
-  void visitHost(Host* curr) {
+  void visitMemorySize(MemorySize* curr) {
+    // memory.size accesses the size of the memory, and thus can be modeled as
+    // reading memory
+    readsMemory = true;
+    // Atomics are sequentially consistent with memory.size.
+    isAtomic = true;
+  }
+  void visitMemoryGrow(MemoryGrow* curr) {
     calls = true;
-    // memory.grow modifies the set of valid addresses, and thus can be modeled
-    // as modifying memory
+    // memory.grow technically does a read-modify-write operation on the memory
+    // size in the successful case, modifying the set of valid addresses, and
+    // just a read operation in the failure case
+    readsMemory = true;
     writesMemory = true;
     // Atomics are also sequentially consistent with memory.grow.
     isAtomic = true;
diff --git a/src/ir/utils.h b/src/ir/utils.h
index 176699591..51fe4c9e7 100644
--- a/src/ir/utils.h
+++ b/src/ir/utils.h
@@ -145,7 +145,8 @@ struct ReFinalize
   void visitSelect(Select* curr);
   void visitDrop(Drop* curr);
   void visitReturn(Return* curr);
-  void visitHost(Host* curr);
+  void visitMemorySize(MemorySize* curr);
+  void visitMemoryGrow(MemoryGrow* curr);
   void visitRefNull(RefNull* curr);
   void visitRefIsNull(RefIsNull* curr);
   void visitRefFunc(RefFunc* curr);
@@ -213,7 +214,8 @@ struct ReFinalizeNode : public OverriddenVisitor<ReFinalizeNode> {
   void visitSelect(Select* curr) { curr->finalize(); }
   void visitDrop(Drop* curr) { curr->finalize(); }
   void visitReturn(Return* curr) { curr->finalize(); }
-  void visitHost(Host* curr) { curr->finalize(); }
+  void visitMemorySize(MemorySize* curr) { curr->finalize(); }
+  void visitMemoryGrow(MemoryGrow* curr) { curr->finalize(); }
   void visitRefNull(RefNull* curr) { curr->finalize(); }
   void visitRefIsNull(RefIsNull* curr) { curr->finalize(); }
   void visitRefFunc(RefFunc* curr) { curr->finalize(); }