Fix

Require GC for waitqueues

Fix destructor issue

Author: stevenfontanella

src/tools/fuzzing/fuzzing.cpp

@@ -2894,7 +2894,8 @@ Expression* TranslateToFuzzReader::_makeConcrete(Type type) {
                 &Self::makeStringEq,
                 &Self::makeStringMeasure,
                 &Self::makeStringGet);
-    options.add(FeatureSet::ReferenceTypes | FeatureSet::SharedEverything,
+    options.add(FeatureSet::ReferenceTypes | FeatureSet::GC |
+                  FeatureSet::SharedEverything,
                 &Self::makeWaitqueueNotify);
     if (!structWaitFields.empty()) {
       options.add(FeatureSet::ReferenceTypes | FeatureSet::GC |

src/tools/wasm-ctor-eval.cpp

@@ -956,6 +956,9 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
       } else if (heapType.isArray()) {
         // TODO: for repeated identical values, can use ArrayNew
         init = builder.makeArrayNewFixed(heapType, args);
+      } else if (heapType == HeapTypes::sharedWaitqueue) {
+        // TODO: what about non-shared or null waitqueue?
+        init = builder.makeWaitqueueNew();
       } else {
         WASM_UNREACHABLE("bad gc type");
       }

src/wasm-type.h

@@ -1194,8 +1194,8 @@ inline bool HeapType::isFunction() const {
 
 inline bool HeapType::isData() const {
   auto kind = getKind();
-  return isMaybeShared(string) || kind == HeapTypeKind::Struct ||
-         kind == HeapTypeKind::Array;
+  return isMaybeShared(string) || isMaybeShared(waitqueue) ||
+         kind == HeapTypeKind::Struct || kind == HeapTypeKind::Array;
 }
 
 inline bool HeapType::isSignature() const {

src/wasm/literal.cpp

@@ -73,6 +73,9 @@ Literal::Literal(Type type) : type(type) {
 
   if (type.isRef() && type.getHeapType().isMaybeShared(HeapType::waitqueue)) {
     assert(type.isNonNullable());
+    // See ~Literal and isData(). isData() is true for waitqueues so we expect
+    // gcData to be present even if null.
+    new (&gcData) std::shared_ptr<GCData>();
     return;
   }
 
@@ -113,7 +116,6 @@ Literal::Literal(std::shared_ptr<GCData> gcData, HeapType type)
   assert((isData() && gcData) ||
          (type.isMaybeShared(HeapType::ext) && gcData) ||
          (type.isMaybeShared(HeapType::string) && gcData) ||
-         (type.isMaybeShared(HeapType::waitqueue) && gcData) ||
          (type.isMaybeShared(HeapType::any) && gcData) ||
          (type.isBottom() && !gcData));
 }
@@ -189,7 +191,6 @@ Literal::Literal(const Literal& other) : type(other.type) {
       return;
     case HeapType::ext:
     case HeapType::any:
-    case HeapType::waitqueue:
       // Externalized or internalized reference/payload.
       new (&gcData) std::shared_ptr<GCData>(other.gcData);
       return;
@@ -371,10 +372,8 @@ std::shared_ptr<FuncData> Literal::getFuncData() const {
 }
 
 std::shared_ptr<GCData> Literal::getGCData() const {
-  assert(
-    isNull() || isData() ||
-    (type.isRef() && (type.getHeapType().isMaybeShared(HeapType::ext) ||
-                      type.getHeapType().isMaybeShared(HeapType::waitqueue))));
+  assert(isNull() || isData() ||
+         (type.isRef() && (type.getHeapType().isMaybeShared(HeapType::ext))));
   return gcData;
 }
 

src/wasm/wasm-type.cpp

@@ -1294,7 +1294,8 @@ FeatureSet HeapType::getFeatures() const {
             return;
           case HeapType::waitqueue:
           case HeapType::nowaitqueue:
-            feats |= FeatureSet::ReferenceTypes | FeatureSet::SharedEverything;
+            feats |= FeatureSet::ReferenceTypes | FeatureSet::GC |
+                     FeatureSet::SharedEverything;
             return;
           case HeapType::noext:
           case HeapType::nofunc:

src/wasm/wasm-validator.cpp

@@ -3700,6 +3700,9 @@ void FunctionValidator::visitStructWait(StructWait* curr) {
     !getModule() || getModule()->features.hasSharedEverything(),
     curr,
     "struct.wait requires shared-everything [--enable-shared-everything]");
+  shouldBeTrue(!getModule() || getModule()->features.hasGC(),
+               curr,
+               "struct.wait requires gc [--enable-gc]");
 
   shouldBeSubType(curr->waitqueue->type,
                   Type(HeapTypes::sharedWaitqueue, Nullable),
@@ -3751,13 +3754,19 @@ void FunctionValidator::visitWaitqueueNew(WaitqueueNew* curr) {
     !getModule() || getModule()->features.hasSharedEverything(),
     curr,
     "waitqueue.new requires shared-everything [--enable-shared-everything]");
+  shouldBeTrue(!getModule() || getModule()->features.hasGC(),
+               curr,
+               "waitqueue.new requires gc [--enable-gc]");
 }
 
 void FunctionValidator::visitWaitqueueNotify(WaitqueueNotify* curr) {
   shouldBeTrue(
     !getModule() || getModule()->features.hasSharedEverything(),
     curr,
     "waitqueue.notify requires shared-everything [--enable-shared-everything]");
+  shouldBeTrue(!getModule() || getModule()->features.hasGC(),
+               curr,
+               "waitqueue.notify requires gc [--enable-gc]");
 
   shouldBeSubType(
     curr->waitqueue->type,

test/lit/validation/waitqueue.wast

@@ -1,14 +1,22 @@
-;; RUN: not wasm-opt --enable-reference-types --enable-gc %s 2>&1 | filecheck %s
+;; RUN: not wasm-opt --enable-reference-types --enable-gc %s 2>&1 | filecheck %s --check-prefix=NO-SHARED
+;; RUN: not wasm-opt --enable-reference-types --enable-shared-everything %s 2>&1 | filecheck %s --check-prefix=NO-GC
 
 ;; Tests feature-related validations.
 ;; Other validations are in the spec test spec/waitqueue.wast.
 (module
   (type $struct (struct (field i32)))
-  ;; CHECK:      waitqueue.new requires shared-everything [--enable-shared-everything]
+  ;; NO-SHARED: waitqueue.new requires shared-everything [--enable-shared-everything]
+  ;; NO-GC:     waitqueue.new requires gc [--enable-gc]
   (func $new
     (drop (waitqueue.new))
   )
-  ;; CHECK:      struct.wait requires shared-everything [--enable-shared-everything]
+  ;; NO-SHARED: waitqueue.notify requires shared-everything [--enable-shared-everything]
+  ;; NO-GC:     waitqueue.notify requires gc [--enable-gc]
+  (func $notify (param $wq (ref null (shared waitqueue)))
+    (drop (waitqueue.notify (local.get $wq) (i32.const 1)))
+  )
+  ;; NO-SHARED: struct.wait requires shared-everything [--enable-shared-everything]
+  ;; NO-GC:     struct.wait requires gc [--enable-gc]
   (func $wait-no-feature (param $ref (ref $struct)) (param $wq (ref null (shared waitqueue)))
     (drop (struct.wait $struct 0 (local.get $ref) (local.get $wq) (i32.const 0) (i64.const 0)))
   )