Updated waitqueue support

scripts/gen-s-parser.py

@@ -213,7 +213,8 @@
     # atomic instructions
     ("memory.atomic.notify",    "makeAtomicNotify()"),
     ("struct.wait",             "makeStructWait()"),
-    ("struct.notify",           "makeStructNotify()"),
+    ("waitqueue.new",           "makeWaitqueueNew()"),
+    ("waitqueue.notify",        "makeWaitqueueNotify()"),
     ("memory.atomic.wait32",    "makeAtomicWait(Type::i32)"),
     ("memory.atomic.wait64",    "makeAtomicWait(Type::i64)"),
     ("atomic.fence",            "makeAtomicFence()"),

src/binaryen-c.cpp

@@ -93,6 +93,9 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
         WASM_UNREACHABLE("invalid type");
       case HeapType::string:
         WASM_UNREACHABLE("TODO: string literals");
+      case HeapType::waitqueue:
+      case HeapType::nowaitqueue:
+        WASM_UNREACHABLE("TODO: waitqueue");
       case HeapType::none:
       case HeapType::noext:
       case HeapType::nofunc:
@@ -147,6 +150,9 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
         WASM_UNREACHABLE("invalid type");
       case HeapType::string:
         WASM_UNREACHABLE("TODO: string literals");
+      case HeapType::waitqueue:
+      case HeapType::nowaitqueue:
+        WASM_UNREACHABLE("TODO: waitqueue");
       case HeapType::none:
       case HeapType::noext:
       case HeapType::nofunc:

src/gen-s-parser.inc

@@ -5448,52 +5448,41 @@ switch (buf[0]) {
                 }
               }
               case 'n': {
-                switch (buf[8]) {
-                  case 'e': {
-                    switch (buf[10]) {
-                      case '\0':
-                        if (op == "struct.new"sv) {
-                          CHECK_ERR(makeStructNew(ctx, pos, annotations, false, false));
-                          return Ok{};
-                        }
-                        goto parse_error;
-                      case '_': {
-                        switch (buf[13]) {
-                          case 'f': {
-                            switch (buf[18]) {
-                              case '\0':
-                                if (op == "struct.new_default"sv) {
-                                  CHECK_ERR(makeStructNew(ctx, pos, annotations, true, false));
-                                  return Ok{};
-                                }
-                                goto parse_error;
-                              case '_':
-                                if (op == "struct.new_default_desc"sv) {
-                                  CHECK_ERR(makeStructNew(ctx, pos, annotations, true, true));
-                                  return Ok{};
-                                }
-                                goto parse_error;
-                              default: goto parse_error;
+                switch (buf[10]) {
+                  case '\0':
+                    if (op == "struct.new"sv) {
+                      CHECK_ERR(makeStructNew(ctx, pos, annotations, false, false));
+                      return Ok{};
+                    }
+                    goto parse_error;
+                  case '_': {
+                    switch (buf[13]) {
+                      case 'f': {
+                        switch (buf[18]) {
+                          case '\0':
+                            if (op == "struct.new_default"sv) {
+                              CHECK_ERR(makeStructNew(ctx, pos, annotations, true, false));
+                              return Ok{};
                             }
-                          }
-                          case 's':
-                            if (op == "struct.new_desc"sv) {
-                              CHECK_ERR(makeStructNew(ctx, pos, annotations, false, true));
+                            goto parse_error;
+                          case '_':
+                            if (op == "struct.new_default_desc"sv) {
+                              CHECK_ERR(makeStructNew(ctx, pos, annotations, true, true));
                               return Ok{};
                             }
                             goto parse_error;
                           default: goto parse_error;
                         }
                       }
+                      case 's':
+                        if (op == "struct.new_desc"sv) {
+                          CHECK_ERR(makeStructNew(ctx, pos, annotations, false, true));
+                          return Ok{};
+                        }
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
-                  case 'o':
-                    if (op == "struct.notify"sv) {
-                      CHECK_ERR(makeStructNotify(ctx, pos, annotations));
-                      return Ok{};
-                    }
-                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -5893,6 +5882,23 @@ switch (buf[0]) {
       default: goto parse_error;
     }
   }
+  case 'w': {
+    switch (buf[11]) {
+      case 'e':
+        if (op == "waitqueue.new"sv) {
+          CHECK_ERR(makeWaitqueueNew(ctx, pos, annotations));
+          return Ok{};
+        }
+        goto parse_error;
+      case 'o':
+        if (op == "waitqueue.notify"sv) {
+          CHECK_ERR(makeWaitqueueNotify(ctx, pos, annotations));
+          return Ok{};
+        }
+        goto parse_error;
+      default: goto parse_error;
+    }
+  }
   default: goto parse_error;
 }
 parse_error:

src/interpreter/interpreter.cpp

@@ -257,7 +257,8 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitStructRMW(StructRMW* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStructCmpxchg(StructCmpxchg* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStructWait(StructWait* curr) { WASM_UNREACHABLE("TODO"); }
-  Flow visitStructNotify(StructNotify* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitWaitqueueNew(WaitqueueNew* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitWaitqueueNotify(WaitqueueNotify* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitArrayNew(ArrayNew* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitArrayNewData(ArrayNewData* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitArrayNewElem(ArrayNewElem* curr) { WASM_UNREACHABLE("TODO"); }

src/ir/ReFinalize.cpp

@@ -166,7 +166,10 @@ void ReFinalize::visitStructSet(StructSet* curr) { curr->finalize(); }
 void ReFinalize::visitStructRMW(StructRMW* curr) { curr->finalize(); }
 void ReFinalize::visitStructCmpxchg(StructCmpxchg* curr) { curr->finalize(); }
 void ReFinalize::visitStructWait(StructWait* curr) { curr->finalize(); }
-void ReFinalize::visitStructNotify(StructNotify* curr) { curr->finalize(); }
+void ReFinalize::visitWaitqueueNew(WaitqueueNew* curr) { curr->finalize(); }
+void ReFinalize::visitWaitqueueNotify(WaitqueueNotify* curr) {
+  curr->finalize();
+}
 void ReFinalize::visitArrayNew(ArrayNew* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNewData(ArrayNewData* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNewElem(ArrayNewElem* curr) { curr->finalize(); }

src/ir/child-typer.h

@@ -1037,21 +1037,15 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     }
 
     note(&curr->ref, Type(*ht, Nullable));
+    note(&curr->waitqueue, Type(HeapType::waitqueue, Nullable));
     note(&curr->expected, Type(Type::BasicType::i32));
     note(&curr->timeout, Type(Type::BasicType::i64));
   }
 
-  void visitStructNotify(StructNotify* curr,
-                         std::optional<HeapType> ht = std::nullopt) {
-    if (!ht) {
-      if (!curr->ref->type.isStruct()) {
-        self().noteUnknown();
-        return;
-      }
-      ht = curr->ref->type.getHeapType();
-    }
+  void visitWaitqueueNew(WaitqueueNew* curr) {}
 
-    note(&curr->ref, Type(*ht, Nullable));
+  void visitWaitqueueNotify(WaitqueueNotify* curr) {
+    note(&curr->waitqueue, Type(HeapType::waitqueue, Nullable));
     note(&curr->count, Type(Type::BasicType::i32));
   }
 

src/ir/cost.h

@@ -120,11 +120,13 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   }
   CostType visitStructWait(StructWait* curr) {
     return AtomicCost + nullCheckCost(curr->ref) + visit(curr->ref) +
+           nullCheckCost(curr->waitqueue) + visit(curr->waitqueue) +
            visit(curr->expected) + visit(curr->timeout);
   }
-  CostType visitStructNotify(StructNotify* curr) {
-    return AtomicCost + nullCheckCost(curr->ref) + visit(curr->ref) +
-           visit(curr->count);
+  CostType visitWaitqueueNew(WaitqueueNew* curr) { return 1; }
+  CostType visitWaitqueueNotify(WaitqueueNotify* curr) {
+    return AtomicCost + nullCheckCost(curr->waitqueue) +
+           visit(curr->waitqueue) + visit(curr->count);
   }
   CostType visitAtomicNotify(AtomicNotify* curr) {
     return AtomicCost + visit(curr->ptr) + visit(curr->notifyCount);

src/ir/effects.h

@@ -1074,11 +1074,12 @@ class EffectAnalyzer {
     void visitStructRMW(StructRMW* curr) { visitStructRMWExpr(curr); }
     void visitStructCmpxchg(StructCmpxchg* curr) { visitStructRMWExpr(curr); }
     void visitStructWait(StructWait* curr) {
-      if (trapOnNull(curr->ref)) {
+      if (trapOnNull({curr->ref, curr->waitqueue})) {
         return;
       }
+
       // StructWait doesn't strictly write a struct, but it does modify the
-      // waiters list associated with the waitqueue field, which we can think
+      // waiters list associated with the waitqueue, which we can think
       // of as a write.
       parent.readsSharedMutableStruct = true;
       parent.writesSharedStruct = true;
@@ -1087,16 +1088,13 @@ class EffectAnalyzer {
       // If the timeout is negative and no-one wakes us.
       parent.mayNotReturn = true;
     }
-    void visitStructNotify(StructNotify* curr) {
-      if (trapOnNull(curr->ref)) {
-        return;
-      }
-      // Non-shared notifies just return 0.
-      if (curr->ref->type.getHeapType().isShared()) {
+    void visitWaitqueueNew(WaitqueueNew* curr) {}
+    void visitWaitqueueNotify(WaitqueueNotify* curr) {
+      if (trapOnNull(curr->waitqueue)) {
         return;
       }
-      // AtomicNotify doesn't strictly write the struct, but it does
-      // modify the waiters list associated with the waitqueue field, which we
+      // AtomicNotify doesn't strictly write anything, but it does
+      // modify the waiters list associated with the waitqueue, which we
       // can think of as a write.
       parent.readsSharedMutableStruct = true;
       parent.writesSharedStruct = true;

src/ir/module-utils.cpp

@@ -454,7 +454,10 @@ struct CodeScanner : PostWalker<CodeScanner> {
   void visitStructGet(StructGet* curr) { info.note(curr->ref->type); }
   void visitStructSet(StructSet* curr) { info.note(curr->ref->type); }
   void visitStructWait(StructWait* curr) { info.note(curr->ref->type); }
-  void visitStructNotify(StructNotify* curr) { info.note(curr->ref->type); }
+  void visitWaitqueueNew(WaitqueueNew* curr) { info.note(curr->type); }
+  void visitWaitqueueNotify(WaitqueueNotify* curr) {
+    info.note(curr->waitqueue->type);
+  }
   void visitArrayGet(ArrayGet* curr) { info.note(curr->ref->type); }
   void visitArraySet(ArraySet* curr) { info.note(curr->ref->type); }
   void visitContBind(ContBind* curr) {

src/ir/possible-constant.h

@@ -120,9 +120,6 @@ struct PossibleConstantValues {
           value = val.and_(Literal(uint32_t(0xffff)));
         }
         break;
-      case Field::WaitQueue:
-        value = val;
-        break;
       case Field::NotPacked:
         WASM_UNREACHABLE("unexpected packed type");
         break;

src/ir/possible-contents.cpp

@@ -1097,7 +1097,8 @@ struct InfoCollector
     addRoot(curr);
   }
   void visitStructWait(StructWait* curr) { addRoot(curr); }
-  void visitStructNotify(StructNotify* curr) { addRoot(curr); }
+  void visitWaitqueueNew(WaitqueueNew* curr) { addRoot(curr); }
+  void visitWaitqueueNotify(WaitqueueNotify* curr) { addRoot(curr); }
   // Array operations access the array's location, parallel to how structs work.
   void visitArrayGet(ArrayGet* curr) {
     if (!isRelevant(curr->ref)) {

src/ir/properties.cpp

@@ -47,6 +47,7 @@ struct GenerativityScanner : public PostWalker<GenerativityScanner> {
   void visitArrayNewElem(ArrayNewElem* curr) { generative = true; }
   void visitArrayNewFixed(ArrayNewFixed* curr) { generative = true; }
   void visitContNew(ContNew* curr) { generative = true; }
+  void visitWaitqueueNew(WaitqueueNew* curr) { generative = true; }
 };
 
 } // anonymous namespace
@@ -73,7 +74,7 @@ bool isShallowlyGenerative(Expression* curr, Function* func, Module& wasm) {
 static bool isValidInConstantExpression(Module& wasm, Expression* expr) {
   if (isSingleConstantExpression(expr) || expr->is<StructNew>() ||
       expr->is<ArrayNew>() || expr->is<ArrayNewFixed>() || expr->is<RefI31>() ||
-      expr->is<StringConst>()) {
+      expr->is<StringConst>() || expr->is<WaitqueueNew>()) {
     return true;
   }
 

src/ir/subtype-exprs.h

@@ -384,7 +384,8 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
     self()->noteSubtype(curr->replacement, type);
   }
   void visitStructWait(StructWait* curr) {}
-  void visitStructNotify(StructNotify* curr) {}
+  void visitWaitqueueNew(WaitqueueNew* curr) {}
+  void visitWaitqueueNotify(WaitqueueNotify* curr) {}
   void visitArrayNew(ArrayNew* curr) {
     if (!curr->type.isArray() || curr->isWithDefault()) {
       return;

src/literal.h

@@ -797,8 +797,8 @@ inline bool Literal::hasExternPayload() const {
   if (isNull()) {
     return false;
   }
-  assert(type.getHeapType().isMaybeShared(HeapType::ext));
-  return gcData->values[0].type == Type::i32;
+  return type.getHeapType().isMaybeShared(HeapType::ext) &&
+         gcData->values[0].type == Type::i32;
 }
 
 inline int32_t Literal::getExternPayload() const {

src/parser/contexts.h

@@ -122,6 +122,8 @@ struct NullTypeParserCtx {
   HeapTypeT makeNofuncType(Shareability) { return Ok{}; }
   HeapTypeT makeNoexnType(Shareability) { return Ok{}; }
   HeapTypeT makeNocontType(Shareability) { return Ok{}; }
+  HeapTypeT makeWaitqueueType(Shareability) { return Ok{}; }
+  HeapTypeT makeNowaitqueueType(Shareability) { return Ok{}; }
 
   TypeT makeI32() { return Ok{}; }
   TypeT makeI64() { return Ok{}; }
@@ -150,7 +152,6 @@ struct NullTypeParserCtx {
 
   StorageT makeI8() { return Ok{}; }
   StorageT makeI16() { return Ok{}; }
-  StorageT makeWaitQueue() { return Ok{}; }
   StorageT makeStorageType(TypeT) { return Ok{}; }
 
   FieldT makeFieldType(StorageT, Mutability) { return Ok{}; }
@@ -263,6 +264,12 @@ template<typename Ctx> struct TypeParserCtx {
   HeapTypeT makeNocontType(Shareability share) {
     return HeapTypes::nocont.getBasic(share);
   }
+  HeapTypeT makeWaitqueueType(Shareability share) {
+    return HeapType(HeapType::waitqueue).getBasic(share);
+  }
+  HeapTypeT makeNowaitqueueType(Shareability share) {
+    return HeapType(HeapType::nowaitqueue).getBasic(share);
+  }
 
   HeapTypeT makeExact(HeapTypeT type) {
     type.exactness = Exact;
@@ -308,7 +315,6 @@ template<typename Ctx> struct TypeParserCtx {
 
   StorageT makeI8() { return Field(Field::i8, Immutable); }
   StorageT makeI16() { return Field(Field::i16, Immutable); }
-  StorageT makeWaitQueue() { return Field(Field::WaitQueue, Immutable); }
   StorageT makeStorageType(TypeT type) { return Field(type, Immutable); }
 
   FieldT makeFieldType(FieldT field, Mutability mutability) {
@@ -825,11 +831,10 @@ struct NullInstrParserCtx {
   makeStructWait(Index, const std::vector<Annotation>&, HeapTypeT, FieldIdxT) {
     return Ok{};
   }
-  template<typename HeapTypeT>
-  Result<> makeStructNotify(Index,
-                            const std::vector<Annotation>&,
-                            HeapTypeT,
-                            FieldIdxT) {
+  Result<> makeWaitqueueNew(Index, const std::vector<Annotation>&) {
+    return Ok{};
+  }
+  Result<> makeWaitqueueNotify(Index, const std::vector<Annotation>&) {
     return Ok{};
   }
   template<typename HeapTypeT>
@@ -2819,11 +2824,14 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeStructWait(type, field));
   }
 
-  Result<> makeStructNotify(Index pos,
-                            const std::vector<Annotation>& annotations,
-                            HeapType type,
-                            Index field) {
-    return withLoc(pos, irBuilder.makeStructNotify(type, field));
+  Result<> makeWaitqueueNew(Index pos,
+                            const std::vector<Annotation>& annotations) {
+    return withLoc(pos, irBuilder.makeWaitqueueNew());
+  }
+
+  Result<> makeWaitqueueNotify(Index pos,
+                               const std::vector<Annotation>& annotations) {
+    return withLoc(pos, irBuilder.makeWaitqueueNotify());
   }
 
   Result<> makeArrayNew(Index pos,