Implement elem.drop (#7658)

osa1 · web-flow · commit e73224ae2bb7 · 2025-06-17T11:06:34.000-07:00
Fixes #7209.
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -582,6 +582,7 @@
     ("table.fill",           "makeTableFill()"),
     ("table.copy",           "makeTableCopy()"),
     ("table.init",           "makeTableInit()"),
+    ("elem.drop",            "makeElemDrop()"),
     # exception handling instructions
     ("try",                  "makeTry()"),
     ("try_table",            "makeTryTable()"),
diff --git a/scripts/test/shared.py b/scripts/test/shared.py
@@ -416,7 +416,6 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'address.wast',  # 64-bit offset allowed by memory64
     'align.wast',    # Alignment bit 6 used by multi-memory
     'binary.wast',   # memory.grow reserved byte a LEB in multi-memory
-    'bulk.wast',     # Requires support for elem.drop
     'comments.wast',  # Issue with carriage returns being treated as newlines
     'const.wast',    # Hex float constant not recognized as out of range
     'conversions.wast',  # Promoted NaN should be canonical
@@ -450,7 +449,6 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'type-equivalence.wast',  # Recursive types allowed by GC
     'unreached-invalid.wast',  # Requires more precise unreachable validation
     'array.wast',  # Requires support for table default elements
-    'array_init_elem.wast',  # Requires support for elem.drop
     'br_if.wast',  # Requires more precise branch validation
     'br_on_cast.wast',  # Requires host references to not be externalized i31refs
     'br_on_cast_fail.wast',  # Requires host references to not be externalized i31refs
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -401,25 +401,36 @@ switch (buf[0]) {
     }
   }
   case 'e': {
-    switch (buf[7]) {
-      case 'c':
-        if (op == "extern.convert_any"sv) {
-          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
-          return Ok{};
-        }
-        goto parse_error;
-      case 'e':
-        if (op == "extern.externalize"sv) {
-          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
+    switch (buf[1]) {
+      case 'l':
+        if (op == "elem.drop"sv) {
+          CHECK_ERR(makeElemDrop(ctx, pos, annotations));
           return Ok{};
         }
         goto parse_error;
-      case 'i':
-        if (op == "extern.internalize"sv) {
-          CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern));
-          return Ok{};
+      case 'x': {
+        switch (buf[7]) {
+          case 'c':
+            if (op == "extern.convert_any"sv) {
+              CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
+              return Ok{};
+            }
+            goto parse_error;
+          case 'e':
+            if (op == "extern.externalize"sv) {
+              CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
+              return Ok{};
+            }
+            goto parse_error;
+          case 'i':
+            if (op == "extern.internalize"sv) {
+              CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern));
+              return Ok{};
+            }
+            goto parse_error;
+          default: goto parse_error;
         }
-        goto parse_error;
+      }
       default: goto parse_error;
     }
   }
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -233,6 +233,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitTableFill(TableFill* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitTableCopy(TableCopy* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitTableInit(TableInit* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitElemDrop(ElemDrop* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitTry(Try* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitTryTable(TryTable* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitThrow(Throw* curr) { WASM_UNREACHABLE("TODO"); }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -127,6 +127,7 @@ void ReFinalize::visitTableGrow(TableGrow* curr) { curr->finalize(); }
 void ReFinalize::visitTableFill(TableFill* curr) { curr->finalize(); }
 void ReFinalize::visitTableCopy(TableCopy* curr) { curr->finalize(); }
 void ReFinalize::visitTableInit(TableInit* curr) { curr->finalize(); }
+void ReFinalize::visitElemDrop(ElemDrop* curr) { curr->finalize(); }
 void ReFinalize::visitTry(Try* curr) { curr->finalize(); }
 void ReFinalize::visitTryTable(TryTable* curr) {
   curr->finalize();
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
@@ -804,6 +804,8 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->size, Type::i32);
   }
 
+  void visitElemDrop(ElemDrop* curr) {}
+
   void visitTry(Try* curr) {
     note(&curr->body, curr->type);
     for (auto& expr : curr->catchBodies) {
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -631,6 +631,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   CostType visitTableInit(TableInit* curr) {
     return 6 + visit(curr->dest) + visit(curr->offset) + visit(curr->size);
   }
+  CostType visitElemDrop(ElemDrop* curr) { return 6; }
   CostType visitTry(Try* curr) {
     // We assume no exception will be thrown in most cases
     return visit(curr->body);
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -782,6 +782,7 @@ class EffectAnalyzer {
       parent.writesTable = true;
       parent.implicitTrap = true;
     }
+    void visitElemDrop(ElemDrop* curr) { parent.writesTable = true; }
     void visitTry(Try* curr) {
       if (curr->delegateTarget.is()) {
         parent.delegateTargets.insert(curr->delegateTarget);
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -675,6 +675,7 @@ struct InfoCollector
   void visitTableFill(TableFill* curr) { addRoot(curr); }
   void visitTableCopy(TableCopy* curr) { addRoot(curr); }
   void visitTableInit(TableInit* curr) {}
+  void visitElemDrop(ElemDrop* curr) {}
 
   void visitNop(Nop* curr) {}
   void visitUnreachable(Unreachable* curr) {}
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
@@ -243,6 +243,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
     self()->noteSubtype(seg->type,
                         self()->getModule()->getTable(curr->table)->type);
   }
+  void visitElemDrop(ElemDrop* curr) {}
   void visitTry(Try* curr) {
     self()->noteSubtype(curr->body, curr);
     for (auto* body : curr->catchBodies) {
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -700,6 +700,9 @@ struct NullInstrParserCtx {
   makeTableInit(Index, const std::vector<Annotation>&, TableIdxT*, ElemIdxT) {
     return Ok{};
   }
+  Result<> makeElemDrop(Index, const std::vector<Annotation>&, ElemIdxT) {
+    return Ok{};
+  }
   Result<> makeThrow(Index, const std::vector<Annotation>&, TagIdxT) {
     return Ok{};
   }
@@ -2545,6 +2548,12 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeTableInit(elem, *t));
   }
 
+  Result<> makeElemDrop(Index pos,
+                        const std::vector<Annotation>& annotations,
+                        Name elem) {
+    return withLoc(pos, irBuilder.makeElemDrop(elem));
+  }
+
   Result<>
   makeThrow(Index pos, const std::vector<Annotation>& annotations, Name tag) {
     return withLoc(pos, irBuilder.makeThrow(tag));
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -209,6 +209,8 @@ Result<> makeTableCopy(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeTableInit(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
+Result<> makeElemDrop(Ctx&, Index, const std::vector<Annotation>&);
+template<typename Ctx>
 Result<> makeThrow(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeRethrow(Ctx&, Index, const std::vector<Annotation>&);
@@ -2160,6 +2162,14 @@ makeTableInit(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
   return ctx.makeTableInit(pos, annotations, table.getPtr(), *elem);
 }
 
+template<typename Ctx>
+Result<>
+makeElemDrop(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
+  auto elem = elemidx(ctx);
+  CHECK_ERR(elem);
+  return ctx.makeElemDrop(pos, annotations, *elem);
+}
+
 template<typename Ctx>
 Result<>
 makeThrow(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
diff --git a/src/passes/Memory64Lowering.cpp b/src/passes/Memory64Lowering.cpp
@@ -238,6 +238,8 @@ struct Memory64Lowering : public WalkerPass<PostWalker<Memory64Lowering>> {
     wrapTableAddress64(curr->dest, curr->table);
   }
 
+  void visitElemDrop(ElemDrop* curr) {}
+
   void visitCallIndirect(CallIndirect* curr) {
     wrapTableAddress64(curr->target, curr->table);
   }
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -2132,6 +2132,10 @@ struct PrintExpressionContents
     o << ' ';
     curr->segment.print(o);
   }
+  void visitElemDrop(ElemDrop* curr) {
+    printMedium(o, "elem.drop ");
+    curr->segment.print(o);
+  }
   void visitTry(Try* curr) {
     printMedium(o, "try");
     if (curr->name.is()) {
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -501,6 +501,8 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
 
   void visitTableInit(TableInit* curr) {}
 
+  void visitElemDrop(ElemDrop* curr) {}
+
   void visitTry(Try* curr) { WASM_UNREACHABLE("TODO"); }
   void visitTryTable(TryTable* curr) { WASM_UNREACHABLE("TODO"); }
   void visitThrow(Throw* curr) { WASM_UNREACHABLE("TODO"); }
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -1118,6 +1118,7 @@ enum ASTNodes {
   TableFill = 0x11,
   TableCopy = 0x0e,
   TableInit = 0x0c,
+  ElemDrop = 0x0d,
   RefNull = 0xd0,
   RefIsNull = 0xd1,
   RefFunc = 0xd2,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -768,6 +768,12 @@ class Builder {
     ret->finalize();
     return ret;
   }
+  ElemDrop* makeElemDrop(Name segment) {
+    auto* ret = wasm.allocator.alloc<ElemDrop>();
+    ret->segment = segment;
+    ret->finalize();
+    return ret;
+  }
 
 private:
   Try* makeTry(Name name,
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -582,6 +582,10 @@ DELEGATE_FIELD_NAME_KIND(TableInit, segment, ModuleItemKind::ElementSegment)
 DELEGATE_FIELD_NAME_KIND(TableInit, table, ModuleItemKind::Table)
 DELEGATE_FIELD_CASE_END(TableInit)
 
+DELEGATE_FIELD_CASE_START(ElemDrop)
+DELEGATE_FIELD_NAME_KIND(ElemDrop, segment, ModuleItemKind::ElementSegment)
+DELEGATE_FIELD_CASE_END(ElemDrop)
+
 DELEGATE_FIELD_CASE_START(Try)
 DELEGATE_FIELD_SCOPE_NAME_USE(Try, delegateTarget)
 DELEGATE_FIELD_CHILD_VECTOR(Try, catchBodies)
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -65,6 +65,7 @@ DELEGATE(TableGrow);
 DELEGATE(TableFill);
 DELEGATE(TableCopy);
 DELEGATE(TableInit);
+DELEGATE(ElemDrop);
 DELEGATE(Try);
 DELEGATE(TryTable);
 DELEGATE(Throw);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -1557,6 +1557,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
   Flow visitTableFill(TableFill* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitTableCopy(TableCopy* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitTableInit(TableInit* curr) { WASM_UNREACHABLE("unimp"); }
+  Flow visitElemDrop(ElemDrop* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitTry(Try* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitTryTable(TryTable* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitThrow(Throw* curr) {
@@ -2670,6 +2671,10 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
     NOTE_ENTER("TableInit");
     return Flow(NONCONSTANT_FLOW);
   }
+  Flow visitElemDrop(ElemDrop* curr) {
+    NOTE_ENTER("ElemDrop");
+    return Flow(NONCONSTANT_FLOW);
+  }
   Flow visitLoad(Load* curr) {
     NOTE_ENTER("Load");
     return Flow(NONCONSTANT_FLOW);
@@ -3648,6 +3653,13 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
     return {};
   }
 
+  Flow visitElemDrop(ElemDrop* curr) {
+    Module& wasm = *self()->getModule();
+    ElementSegment* seg = wasm.getElementSegment(curr->segment);
+    seg->data.clear();
+    return {};
+  }
+
   Flow visitLocalGet(LocalGet* curr) {
     NOTE_ENTER("LocalGet");
     auto index = curr->index;
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -202,6 +202,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeTableFill(Name table);
   Result<> makeTableCopy(Name destTable, Name srcTable);
   Result<> makeTableInit(Name elem, Name table);
+  Result<> makeElemDrop(Name elem);
   Result<> makeTry(Name label, Signature sig);
   Result<> makeTryTable(Name label,
                         Signature sig,
diff --git a/src/wasm.h b/src/wasm.h
@@ -708,6 +708,7 @@ class Expression {
     TableFillId,
     TableCopyId,
     TableInitId,
+    ElemDropId,
     TryId,
     TryTableId,
     ThrowId,
@@ -1471,6 +1472,16 @@ class TableInit : public SpecificExpression<Expression::TableInitId> {
   void finalize();
 };
 
+class ElemDrop : public SpecificExpression<Expression::ElemDropId> {
+public:
+  ElemDrop() = default;
+  ElemDrop(MixedArena& allocator) : ElemDrop() {}
+
+  Name segment;
+
+  void finalize();
+};
+
 // 'try' from the old (Phase 3) EH proposal
 class Try : public SpecificExpression<Expression::TryId> {
 public:
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -3856,6 +3856,10 @@ Result<> WasmBinaryReader::readInst() {
           auto table = getTableName(getU32LEB());
           return builder.makeTableInit(elem, table);
         }
+        case BinaryConsts::ElemDrop: {
+          auto elem = getElemName(getU32LEB());
+          return builder.makeElemDrop(elem);
+        }
         case BinaryConsts::F32_F16LoadMem: {
           auto [mem, align, offset] = getMemarg();
           return builder.makeLoad(2, false, offset, align, Type::f32, mem);
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -1901,6 +1901,11 @@ Result<> IRBuilder::makeTableInit(Name elem, Name table) {
   return Ok{};
 }
 
+Result<> IRBuilder::makeElemDrop(Name segment) {
+  push(builder.makeElemDrop(segment));
+  return Ok{};
+}
+
 Result<> IRBuilder::makeTry(Name label, Signature sig) {
   auto* tryy = wasm.allocator.alloc<Try>();
   tryy->type = sig.results;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
@@ -2128,6 +2128,11 @@ void BinaryInstWriter::visitTableInit(TableInit* curr) {
   o << U32LEB(parent.getTableIndex(curr->table));
 }
 
+void BinaryInstWriter::visitElemDrop(ElemDrop* curr) {
+  o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::ElemDrop);
+  o << U32LEB(parent.getElementSegmentIndex(curr->segment));
+}
+
 void BinaryInstWriter::visitTry(Try* curr) {
   breakStack.push_back(curr->name);
   o << int8_t(BinaryConsts::Try);
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
@@ -481,6 +481,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitTableFill(TableFill* curr);
   void visitTableCopy(TableCopy* curr);
   void visitTableInit(TableInit* curr);
+  void visitElemDrop(ElemDrop* curr);
   void noteDelegate(Name name, Expression* curr);
   void noteRethrow(Name name, Expression* curr);
   void visitTry(Try* curr);
@@ -2549,6 +2550,14 @@ void FunctionValidator::visitTableInit(TableInit* curr) {
     curr->size->type, Type(Type::i32), curr, "table.init size must be valid");
 }
 
+void FunctionValidator::visitElemDrop(ElemDrop* curr) {
+  shouldBeTrue(getModule()->features.hasBulkMemory(),
+               curr,
+               "elem.drop requires bulk-memory [--enable-bulk-memory]");
+  auto* segment = getModule()->getElementSegment(curr->segment);
+  shouldBeTrue(!!segment, curr, "elem.drop segment must exist");
+}
+
 void FunctionValidator::noteDelegate(Name name, Expression* curr) {
   if (name != DELEGATE_CALLER_TARGET) {
     shouldBeTrue(delegateTargetNames.count(name) != 0,
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
@@ -891,6 +891,8 @@ void TableInit::finalize() {
   }
 }
 
+void ElemDrop::finalize() { type = Type::none; }
+
 void Try::finalize(std::optional<Type> type_) {
   if (type_) {
     type = *type_;
diff --git a/src/wasm2js.h b/src/wasm2js.h
@@ -2252,6 +2252,10 @@ Ref Wasm2JSBuilder::processExpression(Expression* curr,
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
+    Ref visitElemDrop(ElemDrop* curr) {
+      unimplemented(curr);
+      WASM_UNREACHABLE("unimp");
+    }
     Ref visitTry(Try* curr) {
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
diff --git a/test/binaryen.js/exception-handling.js.txt b/test/binaryen.js/exception-handling.js.txt
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
diff --git a/test/lit/basic/elem-drop.wast b/test/lit/basic/elem-drop.wast

Original file line number	Diff line number	Diff line change
`@@ -804,6 +804,8 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {`
`804`	`804`	`note(&curr->size, Type::i32);`
`805`	`805`	`}`
`806`	`806`
	`807`	`+ void visitElemDrop(ElemDrop* curr) {}`
	`808`	`+`
`807`	`809`	`void visitTry(Try* curr) {`
`808`	`810`	`note(&curr->body, curr->type);`
`809`	`811`	`for (auto& expr : curr->catchBodies) {`
Original file line number	Diff line number	Diff line change
`@@ -631,6 +631,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {`
`631`	`631`	`CostType visitTableInit(TableInit* curr) {`
`632`	`632`	`return 6 + visit(curr->dest) + visit(curr->offset) + visit(curr->size);`
`633`	`633`	`}`
	`634`	`+ CostType visitElemDrop(ElemDrop* curr) { return 6; }`
`634`	`635`	`CostType visitTry(Try* curr) {`
`635`	`636`	`// We assume no exception will be thrown in most cases`
`636`	`637`	`return visit(curr->body);`
Original file line number	Diff line number	Diff line change
`@@ -782,6 +782,7 @@ class EffectAnalyzer {`
`782`	`782`	`parent.writesTable = true;`
`783`	`783`	`parent.implicitTrap = true;`
`784`	`784`	`}`
	`785`	`+ void visitElemDrop(ElemDrop* curr) { parent.writesTable = true; }`
`785`	`786`	`void visitTry(Try* curr) {`
`786`	`787`	`if (curr->delegateTarget.is()) {`
`787`	`788`	`parent.delegateTargets.insert(curr->delegateTarget);`
Original file line number	Diff line number	Diff line change
`@@ -243,6 +243,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {`
`243`	`243`	`self()->noteSubtype(seg->type,`
`244`	`244`	`self()->getModule()->getTable(curr->table)->type);`
`245`	`245`	`}`
	`246`	`+ void visitElemDrop(ElemDrop* curr) {}`
`246`	`247`	`void visitTry(Try* curr) {`
`247`	`248`	`self()->noteSubtype(curr->body, curr);`
`248`	`249`	`for (auto* body : curr->catchBodies) {`