waitqueue.wait

stevenfontanella · stevenfontanella · commit bd62ca8564e1 · 2026-02-19T23:00:59.000Z
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -608,6 +608,7 @@
     ("resume_throw",         "makeResumeThrow()"),
     ("resume_throw_ref",     "makeResumeThrowRef()"),
     ("switch",               "makeStackSwitch()"),
+    ("waitqueue.wait",       "makeWaitQueueWait()"),
     # GC
     ("ref.i31",              "makeRefI31(Unshared)"),
     ("ref.i31_shared",       "makeRefI31(Shared)"),
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -5784,6 +5784,12 @@ switch (buf[0]) {
       default: 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;
 }
 parse_error:
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -283,6 +283,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitResume(Resume* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitResumeThrow(ResumeThrow* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStackSwitch(StackSwitch* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitWaitQueueWait(WaitQueueWait* curr) { WASM_UNREACHABLE("TODO"); }
 };
 
 } // anonymous namespace
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -202,6 +202,7 @@ void ReFinalize::visitResumeThrow(ResumeThrow* curr) {
   }
 }
 void ReFinalize::visitStackSwitch(StackSwitch* curr) { curr->finalize(); }
+void ReFinalize::visitWaitQueueWait(WaitQueueWait* 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
@@ -1357,6 +1357,15 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     }
     note(&curr->cont, Type(*ct, Nullable));
   }
+
+  void visitWaitQueueWait(WaitQueueWait* curr) {
+    note(&curr->waitqueue,
+         Type(HeapType(Struct(std::vector{
+                Field(Field::PackedType::WaitQueue, Mutability::Immutable)})),
+              NonNullable));
+    note(&curr->value, Type(Type::BasicType::i32));
+    note(&curr->timeout, Type(Type::BasicType::i64));
+  }
 };
 
 } // namespace wasm
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -118,6 +118,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     return AtomicCost + visit(curr->ptr) + visit(curr->expected) +
            visit(curr->timeout);
   }
+  CostType visitWaitQueueWait(WaitQueueWait* curr) {
+    return AtomicCost + visit(curr->waitqueue) + visit(curr->value) +
+           visit(curr->timeout);
+  }
   CostType visitAtomicNotify(AtomicNotify* curr) {
     return AtomicCost + visit(curr->ptr) + visit(curr->notifyCount);
   }
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -1159,6 +1159,19 @@ class EffectAnalyzer {
         parent.throws_ = true;
       }
     }
+
+    void visitWaitQueueWait(WaitQueueWait* curr) {
+      parent.isAtomic = true;
+      parent.mayNotReturn = 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
@@ -446,6 +446,9 @@ struct CodeScanner : PostWalker<CodeScanner> {
     info.note(curr->cont->type);
     info.note(curr->type);
   }
+  void visitWaitQueueWait(WaitQueueWait* 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
@@ -1401,6 +1401,9 @@ struct InfoCollector
     // TODO: optimize when possible
     addRoot(curr);
   }
+  void visitWaitQueueWait(WaitQueueWait* curr) {
+    // todo
+  }
 
   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
@@ -598,6 +598,8 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
                     .type.getSignature();
     self()->noteSubtype(currResult, retSig.results);
   }
+  // todo?
+  void visitWaitQueueWait(WaitQueueWait* curr) {}
 };
 
 } // namespace wasm
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -956,6 +956,10 @@ struct NullInstrParserCtx {
   makeStackSwitch(Index, const std::vector<Annotation>&, HeapTypeT, TagIdxT) {
     return Ok{};
   }
+
+  Result<> makeWaitQueueWait(Index, const std::vector<Annotation>&) {
+    return Ok{};
+  }
 };
 
 struct NullCtx : NullTypeParserCtx, NullInstrParserCtx {
@@ -2947,6 +2951,11 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
                            Name tag) {
     return withLoc(pos, irBuilder.makeStackSwitch(type, tag));
   }
+
+  Result<> makeWaitQueueWait(Index pos,
+                             const std::vector<Annotation>& annotations) {
+    return withLoc(pos, irBuilder.makeWaitQueueWait());
+  }
 };
 
 } // namespace wasm::WATParser
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -2840,6 +2840,14 @@ Result<> makeStackSwitch(Ctx& ctx,
   return ctx.makeStackSwitch(pos, annotations, *type, *tag);
 }
 
+// waitqueue.wait ::=
+template<typename Ctx>
+Result<> makeWaitQueueWait(Ctx& ctx,
+                           Index pos,
+                           const std::vector<Annotation>& annotations) {
+  return ctx.makeWaitQueueWait(pos, annotations);
+}
+
 // =======
 // Modules
 // =======
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -376,6 +376,11 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> {
       visitExpression(curr);
     }
   }
+  void visitWaitQueueWait(WaitQueueWait* curr) {
+    if (!maybePrintUnreachableReplacement(curr, curr->type)) {
+      visitExpression(curr);
+    }
+  }
 
   // Module-level visitors
   void handleSignature(Function* curr, bool printImplicitNames = false);
@@ -2658,6 +2663,10 @@ struct PrintExpressionContents
     o << ' ';
     curr->tag.print(o);
   }
+
+  void visitWaitQueueWait(WaitQueueWait* curr) {
+    printMedium(o, "waitqueue.wait");
+  }
 };
 
 void PrintSExpression::setModule(Module* module) {
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -899,6 +899,7 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
   void visitResume(Resume* curr) { WASM_UNREACHABLE("TODO"); }
   void visitResumeThrow(ResumeThrow* curr) { WASM_UNREACHABLE("TODO"); }
   void visitStackSwitch(StackSwitch* curr) { WASM_UNREACHABLE("TODO"); }
+  void visitWaitQueueWait(WaitQueueWait* curr) { WASM_UNREACHABLE("TODO"); }
 };
 
 struct TypeGeneralizing : WalkerPass<PostWalker<TypeGeneralizing>> {
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -702,6 +702,7 @@ enum ASTNodes {
   I64AtomicWait = 0x02,
   AtomicFence = 0x03,
   Pause = 0x04,
+  WaitQueueWait = 0x05,
 
   I32AtomicLoad = 0x10,
   I64AtomicLoad = 0x11,
@@ -1252,9 +1253,10 @@ enum ASTNodes {
   Resume = 0xe3,
   ResumeThrow = 0xe4,
   ResumeThrowRef = 0xe5,
-  Switch = 0xe6,  // NOTE(dhil): the internal class is known as
-                  // StackSwitch to avoid conflict with the existing
-                  // 'switch table'.
+  Switch = 0xe6, // NOTE(dhil): the internal class is known as
+                 // StackSwitch to avoid conflict with the existing
+                 // 'switch table'.
+
   OnLabel = 0x00, // (on $tag $label)
   OnSwitch = 0x01 // (on $tag switch)
 };
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -1363,6 +1363,17 @@ class Builder {
     return ret;
   }
 
+  WaitQueueWait* makeWaitQueueWait(Expression* waitqueue,
+                                   Expression* value,
+                                   Expression* timeout) {
+    auto* ret = wasm.allocator.alloc<WaitQueueWait>();
+    ret->waitqueue = waitqueue;
+    ret->value = value;
+    ret->timeout = timeout;
+    ret->finalize();
+    return ret;
+  }
+
   // Additional helpers
 
   Drop* makeDrop(Expression* value) {
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -887,6 +887,12 @@ DELEGATE_FIELD_CHILD_VECTOR(StackSwitch, operands)
 DELEGATE_FIELD_NAME_KIND(StackSwitch, tag, ModuleItemKind::Tag)
 DELEGATE_FIELD_CASE_END(StackSwitch)
 
+DELEGATE_FIELD_CASE_START(WaitQueueWait)
+DELEGATE_FIELD_CHILD(WaitQueueWait, timeout)
+DELEGATE_FIELD_CHILD(WaitQueueWait, value)
+DELEGATE_FIELD_CHILD(WaitQueueWait, waitqueue)
+DELEGATE_FIELD_CASE_END(WaitQueueWait)
+
 
 DELEGATE_FIELD_MAIN_END
 
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -115,5 +115,6 @@ DELEGATE(Suspend);
 DELEGATE(Resume);
 DELEGATE(ResumeThrow);
 DELEGATE(StackSwitch);
+DELEGATE(WaitQueueWait);
 
 #undef DELEGATE
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -2932,6 +2932,9 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   Flow visitResume(Resume* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitResumeThrow(ResumeThrow* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitStackSwitch(StackSwitch* curr) { return Flow(NONCONSTANT_FLOW); }
+  Flow visitWaitQueueWait(WaitQueueWait* curr) {
+    return Flow(NONCONSTANT_FLOW);
+  }
 
   void trap(std::string_view why) override { throw NonconstantException(); }
 
@@ -4918,6 +4921,9 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   Flow visitResume(Resume* curr) { return doResume(curr); }
   Flow visitResumeThrow(ResumeThrow* curr) { return doResume(curr); }
   Flow visitStackSwitch(StackSwitch* curr) { return Flow(NONCONSTANT_FLOW); }
+  Flow visitWaitQueueWait(WaitQueueWait* 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
@@ -285,6 +285,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
     return makeResumeThrow(ct, Name(), tags, labels);
   }
   Result<> makeStackSwitch(HeapType ct, Name tag);
+  Result<> makeWaitQueueWait();
 
   // Private functions that must be public for technical reasons.
   Result<> visitExpression(Expression*);
diff --git a/src/wasm.h b/src/wasm.h
@@ -760,6 +760,7 @@ class Expression {
     ResumeThrowId,
     // Id for the stack switching `switch`
     StackSwitchId,
+    WaitQueueWaitId,
     NumExpressionIds
   };
   Id _id;
@@ -2155,6 +2156,18 @@ class StackSwitch : public SpecificExpression<Expression::StackSwitchId> {
   void finalize();
 };
 
+class WaitQueueWait : public SpecificExpression<Expression::WaitQueueWaitId> {
+public:
+  WaitQueueWait() = default;
+  WaitQueueWait(MixedArena& allocator) : WaitQueueWait() {}
+
+  Expression* waitqueue = nullptr;
+  Expression* value = nullptr;
+  Expression* timeout = nullptr;
+
+  void finalize();
+};
+
 // Globals
 
 struct Named {
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -3913,6 +3913,9 @@ Result<> WasmBinaryReader::readInst() {
           auto type = getIndexedHeapType();
           return builder.makeArrayCmpxchg(type, order);
         }
+        case BinaryConsts::WaitQueueWait: {
+          return builder.makeWaitQueueWait();
+        }
       }
       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
@@ -662,6 +662,12 @@ struct IRBuilder::ChildPopper
     ConstraintCollector{builder, children}.visitStackSwitch(curr, ct);
     return popConstrainedChildren(children);
   }
+
+  Result<> visitWaitQueueWait(WaitQueueWait* curr) {
+    std::vector<Child> children;
+    ConstraintCollector{builder, children}.visitWaitQueueWait(curr);
+    return popConstrainedChildren(children);
+  }
 };
 
 Result<> IRBuilder::visit(Expression* curr) {
@@ -2655,6 +2661,13 @@ Result<> IRBuilder::makeStackSwitch(HeapType ct, Name tag) {
   return Ok{};
 }
 
+Result<> IRBuilder::makeWaitQueueWait() {
+  WaitQueueWait curr(wasm.allocator);
+  CHECK_ERR(ChildPopper{*this}.visitWaitQueueWait(&curr));
+  push(builder.makeWaitQueueWait(curr.waitqueue, curr.value, curr.timeout));
+  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
@@ -2911,6 +2911,11 @@ void BinaryInstWriter::visitStackSwitch(StackSwitch* curr) {
   o << U32LEB(parent.getTagIndex(curr->tag));
 }
 
+void BinaryInstWriter::visitWaitQueueWait(WaitQueueWait* curr) {
+  o << static_cast<int8_t>(BinaryConsts::AtomicPrefix)
+    << static_cast<int8_t>(BinaryConsts::WaitQueueWait);
+}
+
 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
@@ -569,6 +569,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitResume(Resume* curr);
   void visitResumeThrow(ResumeThrow* curr);
   void visitStackSwitch(StackSwitch* curr);
+  void visitWaitQueueWait(WaitQueueWait* curr);
 
   void visitFunction(Function* curr);
 
@@ -4260,6 +4261,28 @@ void FunctionValidator::visitStackSwitch(StackSwitch* curr) {
     "switch must be annotated with a continuation type");
 }
 
+void FunctionValidator::visitWaitQueueWait(WaitQueueWait* curr) {
+  shouldBeTrue(
+    !getModule() || getModule()->features.hasStackSwitching(),
+    curr,
+    "waitqueue.wait requires shared-everything [--enable-shared-everything]");
+  shouldBeSubType(
+    curr->waitqueue->type,
+    Type(HeapType(
+           Struct(std::vector{Field(Field::PackedType::WaitQueue, Immutable)})),
+         NonNullable),
+    curr,
+    "waitqueue.wait waitqueue must be a subtype of (struct (field waitqueue))");
+  shouldBeEqual(curr->value->type,
+                Type(Type::BasicType::i32),
+                curr,
+                "waitqueue.wait value must be an i32");
+  shouldBeEqual(curr->timeout->type,
+                Type(Type::BasicType::i64),
+                curr,
+                "waitqueue.wait timeout must be an i64");
+}
+
 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
@@ -2017,4 +2017,6 @@ void Module::clearDebugInfo() {
   debugInfoSymbolNames.clear();
 }
 
+void WaitQueueWait::finalize() { type = Type::i32; }
+
 } // namespace wasm
diff --git a/src/wasm2js.h b/src/wasm2js.h
diff --git a/test/lit/validation/waitqueue.wast b/test/lit/validation/waitqueue.wast
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
`@@ -5784,6 +5784,12 @@ switch (buf[0]) {`
`5784`	`5784`	`default: goto parse_error;`
`5785`	`5785`	`}`
`5786`	`5786`	`}`
	`5787`	`+ case 'w':`
	`5788`	`+ if (op == "waitqueue.wait"sv) {`
	`5789`	`+ CHECK_ERR(makeWaitQueueWait(ctx, pos, annotations));`
	`5790`	`+ return Ok{};`
	`5791`	`+ }`
	`5792`	`+ goto parse_error;`
`5787`	`5793`	`default: goto parse_error;`
`5788`	`5794`	`}`
`5789`	`5795`	`parse_error:`
Original file line number	Diff line number	Diff line change
`@@ -202,6 +202,7 @@ void ReFinalize::visitResumeThrow(ResumeThrow* curr) {`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`	`void ReFinalize::visitStackSwitch(StackSwitch* curr) { curr->finalize(); }`
	`205`	`+void ReFinalize::visitWaitQueueWait(WaitQueueWait* curr) { curr->finalize(); }`
`205`	`206`
`206`	`207`	`void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }`
`207`	`208`	`void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }`
Original file line number	Diff line number	Diff line change
`@@ -118,6 +118,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {`
`118`	`118`	`return AtomicCost + visit(curr->ptr) + visit(curr->expected) +`
`119`	`119`	`visit(curr->timeout);`
`120`	`120`	`}`
	`121`	`+ CostType visitWaitQueueWait(WaitQueueWait* curr) {`
	`122`	`+ return AtomicCost + visit(curr->waitqueue) + visit(curr->value) +`
	`123`	`+ visit(curr->timeout);`
	`124`	`+ }`
`121`	`125`	`CostType visitAtomicNotify(AtomicNotify* curr) {`
`122`	`126`	`return AtomicCost + visit(curr->ptr) + visit(curr->notifyCount);`
`123`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -446,6 +446,9 @@ struct CodeScanner : PostWalker<CodeScanner> {`
`446`	`446`	`info.note(curr->cont->type);`
`447`	`447`	`info.note(curr->type);`
`448`	`448`	`}`
	`449`	`+ void visitWaitQueueWait(WaitQueueWait* curr) {`
	`450`	`+ info.note(curr->waitqueue->type);`
	`451`	`+ }`
`449`	`452`	`void visitBlock(Block* curr) {`
`450`	`453`	`info.noteControlFlow(Signature(Type::none, curr->type));`
`451`	`454`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1401,6 +1401,9 @@ struct InfoCollector`
`1401`	`1401`	`// TODO: optimize when possible`
`1402`	`1402`	`addRoot(curr);`
`1403`	`1403`	`}`
	`1404`	`+ void visitWaitQueueWait(WaitQueueWait* curr) {`
	`1405`	`+ // todo`
	`1406`	`+ }`
`1404`	`1407`
`1405`	`1408`	`void visitFunction(Function* func) {`
`1406`	`1409`	`// Functions with a result can flow a value out from their body.`
Original file line number	Diff line number	Diff line change
`@@ -598,6 +598,8 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {`
`598`	`598`	`.type.getSignature();`
`599`	`599`	`self()->noteSubtype(currResult, retSig.results);`
`600`	`600`	`}`
	`601`	`+ // todo?`
	`602`	`+ void visitWaitQueueWait(WaitQueueWait* curr) {}`
`601`	`603`	`};`
`602`	`604`
`603`	`605`	`} // namespace wasm`