waitqueue notify

stevenfontanella · stevenfontanella · commit 577f9ed71351 · 2026-02-20T00:05:48.000Z
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -207,6 +207,7 @@
     # atomic instructions
     ("memory.atomic.notify",    "makeAtomicNotify()"),
     ("waitqueue.wait",          "makeWaitQueueWait()"),
+    ("waitqueue.notify",        "makeWaitQueueNotify()"),
     ("memory.atomic.wait32",    "makeAtomicWait(Type::i32)"),
     ("memory.atomic.wait64",    "makeAtomicWait(Type::i64)"),
     ("atomic.fence",            "makeAtomicFence()"),
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -5784,12 +5784,23 @@ switch (buf[0]) {
       default: goto parse_error;
     }
   }
-  case 'w':
-    if (op == "waitqueue.wait"sv) {
-      CHECK_ERR(makeWaitQueueWait(ctx, pos, annotations));
-      return Ok{};
+  case 'w': {
+    switch (buf[10]) {
+      case 'n':
+        if (op == "waitqueue.notify"sv) {
+          CHECK_ERR(makeWaitQueueNotify(ctx, pos, annotations));
+          return Ok{};
+        }
+        goto parse_error;
+      case 'w':
+        if (op == "waitqueue.wait"sv) {
+          CHECK_ERR(makeWaitQueueWait(ctx, pos, annotations));
+          return Ok{};
+        }
+        goto parse_error;
+      default: goto parse_error;
     }
-    goto parse_error;
+  }
   default: goto parse_error;
 }
 parse_error:
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -284,6 +284,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitResumeThrow(ResumeThrow* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStackSwitch(StackSwitch* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitWaitQueueWait(WaitQueueWait* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitWaitQueueNotify(WaitQueueNotify* curr) { WASM_UNREACHABLE("TODO"); }
 };
 
 } // anonymous namespace
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -203,6 +203,9 @@ void ReFinalize::visitResumeThrow(ResumeThrow* curr) {
 }
 void ReFinalize::visitStackSwitch(StackSwitch* curr) { curr->finalize(); }
 void ReFinalize::visitWaitQueueWait(WaitQueueWait* curr) { curr->finalize(); }
+void ReFinalize::visitWaitQueueNotify(WaitQueueNotify* curr) {
+  curr->finalize();
+}
 
 void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }
 void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
@@ -1366,6 +1366,14 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->value, Type(Type::BasicType::i32));
     note(&curr->timeout, Type(Type::BasicType::i64));
   }
+
+  void visitWaitQueueNotify(WaitQueueNotify* curr) {
+    note(&curr->waitqueue,
+         Type(HeapType(Struct(std::vector{
+                Field(Field::PackedType::WaitQueue, Mutability::Immutable)})),
+              NonNullable));
+    note(&curr->count, Type(Type::BasicType::i32));
+  }
 };
 
 } // namespace wasm
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -122,6 +122,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     return AtomicCost + visit(curr->waitqueue) + visit(curr->value) +
            visit(curr->timeout);
   }
+  CostType visitWaitQueueNotify(WaitQueueNotify* curr) {
+    return AtomicCost + visit(curr->waitqueue) + visit(curr->count);
+  }
   CostType visitAtomicNotify(AtomicNotify* curr) {
     return AtomicCost + visit(curr->ptr) + visit(curr->notifyCount);
   }
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -1172,6 +1172,18 @@ class EffectAnalyzer {
         parent.readsMutableStruct = true;
       }
     }
+
+    void visitWaitQueueNotify(WaitQueueNotify* curr) {
+      parent.isAtomic = true;
+
+      // field 0 must exist and be a packed waitqueue if this is valid Wasm.
+      if (curr->waitqueue->type.getHeapType()
+            .getStruct()
+            .fields.at(0)
+            .mutable_ == Mutable) {
+        parent.readsMutableStruct = true;
+      }
+    }
   };
 
 public:
diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp
@@ -449,6 +449,9 @@ struct CodeScanner : PostWalker<CodeScanner> {
   void visitWaitQueueWait(WaitQueueWait* curr) {
     info.note(curr->waitqueue->type);
   }
+  void visitWaitQueueNotify(WaitQueueNotify* curr) {
+    info.note(curr->waitqueue->type);
+  }
   void visitBlock(Block* curr) {
     info.noteControlFlow(Signature(Type::none, curr->type));
   }
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -1402,6 +1402,7 @@ struct InfoCollector
     addRoot(curr);
   }
   void visitWaitQueueWait(WaitQueueWait* curr) { addRoot(curr); }
+  void visitWaitQueueNotify(WaitQueueNotify* curr) { addRoot(curr); }
 
   void visitFunction(Function* func) {
     // Functions with a result can flow a value out from their body.
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
@@ -604,6 +604,12 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
                                Field::PackedType::WaitQueue, Immutable)})),
                              NonNullable));
   }
+  void visitWaitQueueNotify(WaitQueueNotify* curr) {
+    self()->noteSubtype(curr->waitqueue,
+                        Type(HeapType(Struct(std::vector{Field(
+                               Field::PackedType::WaitQueue, Immutable)})),
+                             NonNullable));
+  }
 };
 
 } // namespace wasm
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -960,6 +960,9 @@ struct NullInstrParserCtx {
   Result<> makeWaitQueueWait(Index, const std::vector<Annotation>&) {
     return Ok{};
   }
+  Result<> makeWaitQueueNotify(Index, const std::vector<Annotation>&) {
+    return Ok{};
+  }
 };
 
 struct NullCtx : NullTypeParserCtx, NullInstrParserCtx {
@@ -2956,6 +2959,11 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
                              const std::vector<Annotation>& annotations) {
     return withLoc(pos, irBuilder.makeWaitQueueWait());
   }
+
+  Result<> makeWaitQueueNotify(Index pos,
+                               const std::vector<Annotation>& annotations) {
+    return withLoc(pos, irBuilder.makeWaitQueueNotify());
+  }
 };
 
 } // namespace wasm::WATParser
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -2848,6 +2848,14 @@ Result<> makeWaitQueueWait(Ctx& ctx,
   return ctx.makeWaitQueueWait(pos, annotations);
 }
 
+// waitqueue.notify ::=
+template<typename Ctx>
+Result<> makeWaitQueueNotify(Ctx& ctx,
+                             Index pos,
+                             const std::vector<Annotation>& annotations) {
+  return ctx.makeWaitQueueNotify(pos, annotations);
+}
+
 // =======
 // Modules
 // =======
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -381,6 +381,11 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> {
       visitExpression(curr);
     }
   }
+  void visitWaitQueueNotify(WaitQueueNotify* curr) {
+    if (!maybePrintUnreachableReplacement(curr, curr->type)) {
+      visitExpression(curr);
+    }
+  }
 
   // Module-level visitors
   void handleSignature(Function* curr, bool printImplicitNames = false);
@@ -2667,6 +2672,10 @@ struct PrintExpressionContents
   void visitWaitQueueWait(WaitQueueWait* curr) {
     printMedium(o, "waitqueue.wait");
   }
+
+  void visitWaitQueueNotify(WaitQueueNotify* curr) {
+    printMedium(o, "waitqueue.notify");
+  }
 };
 
 void PrintSExpression::setModule(Module* module) {
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -900,6 +900,7 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
   void visitResumeThrow(ResumeThrow* curr) { WASM_UNREACHABLE("TODO"); }
   void visitStackSwitch(StackSwitch* curr) { WASM_UNREACHABLE("TODO"); }
   void visitWaitQueueWait(WaitQueueWait* curr) { WASM_UNREACHABLE("TODO"); }
+  void visitWaitQueueNotify(WaitQueueNotify* curr) { WASM_UNREACHABLE("TODO"); }
 };
 
 struct TypeGeneralizing : WalkerPass<PostWalker<TypeGeneralizing>> {
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -703,6 +703,7 @@ enum ASTNodes {
   AtomicFence = 0x03,
   Pause = 0x04,
   WaitQueueWait = 0x05,
+  WaitQueueNotify = 0x06,
 
   I32AtomicLoad = 0x10,
   I64AtomicLoad = 0x11,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -1374,6 +1374,15 @@ class Builder {
     return ret;
   }
 
+  WaitQueueNotify* makeWaitQueueNotify(Expression* waitqueue,
+                                       Expression* count) {
+    auto* ret = wasm.allocator.alloc<WaitQueueNotify>();
+    ret->waitqueue = waitqueue;
+    ret->count = count;
+    ret->finalize();
+    return ret;
+  }
+
   // Additional helpers
 
   Drop* makeDrop(Expression* value) {
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -893,6 +893,11 @@ DELEGATE_FIELD_CHILD(WaitQueueWait, value)
 DELEGATE_FIELD_CHILD(WaitQueueWait, waitqueue)
 DELEGATE_FIELD_CASE_END(WaitQueueWait)
 
+DELEGATE_FIELD_CASE_START(WaitQueueNotify)
+DELEGATE_FIELD_CHILD(WaitQueueNotify, count)
+DELEGATE_FIELD_CHILD(WaitQueueNotify, waitqueue)
+DELEGATE_FIELD_CASE_END(WaitQueueNotify)
+
 
 DELEGATE_FIELD_MAIN_END
 
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -116,5 +116,6 @@ DELEGATE(Resume);
 DELEGATE(ResumeThrow);
 DELEGATE(StackSwitch);
 DELEGATE(WaitQueueWait);
+DELEGATE(WaitQueueNotify);
 
 #undef DELEGATE
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -2935,6 +2935,9 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   Flow visitWaitQueueWait(WaitQueueWait* curr) {
     return Flow(NONCONSTANT_FLOW);
   }
+  Flow visitWaitQueueNotify(WaitQueueNotify* curr) {
+    return Flow(NONCONSTANT_FLOW);
+  }
 
   void trap(std::string_view why) override { throw NonconstantException(); }
 
@@ -4924,6 +4927,9 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   Flow visitWaitQueueWait(WaitQueueWait* curr) {
     WASM_UNREACHABLE("waitqueue not implemented");
   }
+  Flow visitWaitQueueNotify(WaitQueueNotify* curr) {
+    WASM_UNREACHABLE("waitqueue not implemented");
+  }
 
   void trap(std::string_view why) override {
     // Traps break all current continuations - they will never be resumable.
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -286,6 +286,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   }
   Result<> makeStackSwitch(HeapType ct, Name tag);
   Result<> makeWaitQueueWait();
+  Result<> makeWaitQueueNotify();
 
   // Private functions that must be public for technical reasons.
   Result<> visitExpression(Expression*);
diff --git a/src/wasm.h b/src/wasm.h
@@ -761,6 +761,7 @@ class Expression {
     // Id for the stack switching `switch`
     StackSwitchId,
     WaitQueueWaitId,
+    WaitQueueNotifyId,
     NumExpressionIds
   };
   Id _id;
@@ -2168,6 +2169,18 @@ class WaitQueueWait : public SpecificExpression<Expression::WaitQueueWaitId> {
   void finalize();
 };
 
+class WaitQueueNotify
+  : public SpecificExpression<Expression::WaitQueueNotifyId> {
+public:
+  WaitQueueNotify() = default;
+  WaitQueueNotify(MixedArena& allocator) : WaitQueueNotify() {}
+
+  Expression* waitqueue = nullptr;
+  Expression* count = nullptr;
+
+  void finalize();
+};
+
 // Globals
 
 struct Named {
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -3916,6 +3916,9 @@ Result<> WasmBinaryReader::readInst() {
         case BinaryConsts::WaitQueueWait: {
           return builder.makeWaitQueueWait();
         }
+        case BinaryConsts::WaitQueueNotify: {
+          return builder.makeWaitQueueNotify();
+        }
       }
       return Err{"unknown atomic operation " + std::to_string(op)};
     }
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -668,6 +668,12 @@ struct IRBuilder::ChildPopper
     ConstraintCollector{builder, children}.visitWaitQueueWait(curr);
     return popConstrainedChildren(children);
   }
+
+  Result<> visitWaitQueueNotify(WaitQueueNotify* curr) {
+    std::vector<Child> children;
+    ConstraintCollector{builder, children}.visitWaitQueueNotify(curr);
+    return popConstrainedChildren(children);
+  }
 };
 
 Result<> IRBuilder::visit(Expression* curr) {
@@ -2668,6 +2674,13 @@ Result<> IRBuilder::makeWaitQueueWait() {
   return Ok{};
 }
 
+Result<> IRBuilder::makeWaitQueueNotify() {
+  WaitQueueNotify curr(wasm.allocator);
+  CHECK_ERR(ChildPopper{*this}.visitWaitQueueNotify(&curr));
+  push(builder.makeWaitQueueNotify(curr.waitqueue, curr.count));
+  return Ok{};
+}
+
 void IRBuilder::applyAnnotations(Expression* expr,
                                  const CodeAnnotation& annotation) {
   if (annotation.branchLikely) {
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
@@ -2916,6 +2916,11 @@ void BinaryInstWriter::visitWaitQueueWait(WaitQueueWait* curr) {
     << static_cast<int8_t>(BinaryConsts::WaitQueueWait);
 }
 
+void BinaryInstWriter::visitWaitQueueNotify(WaitQueueNotify* curr) {
+  o << static_cast<int8_t>(BinaryConsts::AtomicPrefix)
+    << static_cast<int8_t>(BinaryConsts::WaitQueueNotify);
+}
+
 void BinaryInstWriter::emitScopeEnd(Expression* curr) {
   assert(!breakStack.empty());
   breakStack.pop_back();
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
@@ -570,6 +570,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitResumeThrow(ResumeThrow* curr);
   void visitStackSwitch(StackSwitch* curr);
   void visitWaitQueueWait(WaitQueueWait* curr);
+  void visitWaitQueueNotify(WaitQueueNotify* curr);
 
   void visitFunction(Function* curr);
 
@@ -4283,6 +4284,24 @@ void FunctionValidator::visitWaitQueueWait(WaitQueueWait* curr) {
                 "waitqueue.wait timeout must be an i64");
 }
 
+void FunctionValidator::visitWaitQueueNotify(WaitQueueNotify* curr) {
+  shouldBeTrue(
+    !getModule() || getModule()->features.hasSharedEverything(),
+    curr,
+    "waitqueue.notify requires shared-everything [--enable-shared-everything]");
+  shouldBeSubType(curr->waitqueue->type,
+                  Type(HeapType(Struct(std::vector{
+                         Field(Field::PackedType::WaitQueue, Immutable)})),
+                       NonNullable),
+                  curr,
+                  "waitqueue.notify waitqueue must be a subtype of (struct "
+                  "(field waitqueue))");
+  shouldBeEqual(curr->count->type,
+                Type(Type::BasicType::i32),
+                curr,
+                "waitqueue.notify count must be an i32");
+}
+
 void FunctionValidator::visitFunction(Function* curr) {
   FeatureSet features;
   // Check for things like having a rec group with GC enabled. The type we're
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
@@ -2019,4 +2019,6 @@ void Module::clearDebugInfo() {
 
 void WaitQueueWait::finalize() { type = Type::i32; }
 
+void WaitQueueNotify::finalize() { type = Type::i32; }
+
 } // namespace wasm
diff --git a/src/wasm2js.h b/src/wasm2js.h
@@ -2468,6 +2468,10 @@ Ref Wasm2JSBuilder::processExpression(Expression* curr,
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
+    Ref visitWaitQueueNotify(WaitQueueNotify* curr) {
+      unimplemented(curr);
+      WASM_UNREACHABLE("unimp");
+    }
 
   private:
     Ref makePointer(Expression* ptr, Address offset) {
diff --git a/test/lit/waitqueue.wast b/test/lit/waitqueue.wast
diff --git a/test/spec/waitqueue.wast b/test/spec/waitqueue.wast

Original file line number	Diff line number	Diff line change
`@@ -203,6 +203,9 @@ void ReFinalize::visitResumeThrow(ResumeThrow* curr) {`
`203`	`203`	`}`
`204`	`204`	`void ReFinalize::visitStackSwitch(StackSwitch* curr) { curr->finalize(); }`
`205`	`205`	`void ReFinalize::visitWaitQueueWait(WaitQueueWait* curr) { curr->finalize(); }`
	`206`	`+void ReFinalize::visitWaitQueueNotify(WaitQueueNotify* curr) {`
	`207`	`+ curr->finalize();`
	`208`	`+}`
`206`	`209`
`207`	`210`	`void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }`
`208`	`211`	`void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }`
Original file line number	Diff line number	Diff line change
`@@ -122,6 +122,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {`
`122`	`122`	`return AtomicCost + visit(curr->waitqueue) + visit(curr->value) +`
`123`	`123`	`visit(curr->timeout);`
`124`	`124`	`}`
	`125`	`+ CostType visitWaitQueueNotify(WaitQueueNotify* curr) {`
	`126`	`+ return AtomicCost + visit(curr->waitqueue) + visit(curr->count);`
	`127`	`+ }`
`125`	`128`	`CostType visitAtomicNotify(AtomicNotify* curr) {`
`126`	`129`	`return AtomicCost + visit(curr->ptr) + visit(curr->notifyCount);`
`127`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -449,6 +449,9 @@ struct CodeScanner : PostWalker<CodeScanner> {`
`449`	`449`	`void visitWaitQueueWait(WaitQueueWait* curr) {`
`450`	`450`	`info.note(curr->waitqueue->type);`
`451`	`451`	`}`
	`452`	`+ void visitWaitQueueNotify(WaitQueueNotify* curr) {`
	`453`	`+ info.note(curr->waitqueue->type);`
	`454`	`+ }`
`452`	`455`	`void visitBlock(Block* curr) {`
`453`	`456`	`info.noteControlFlow(Signature(Type::none, curr->type));`
`454`	`457`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1402,6 +1402,7 @@ struct InfoCollector`
`1402`	`1402`	`addRoot(curr);`
`1403`	`1403`	`}`
`1404`	`1404`	`void visitWaitQueueWait(WaitQueueWait* curr) { addRoot(curr); }`
	`1405`	`+ void visitWaitQueueNotify(WaitQueueNotify* curr) { addRoot(curr); }`
`1405`	`1406`
`1406`	`1407`	`void visitFunction(Function* func) {`
`1407`	`1408`	`// Functions with a result can flow a value out from their body.`