Add library API for waitqueue instructions

src/binaryen-c.cpp

@@ -1887,6 +1887,28 @@ BinaryenExpressionRef BinaryenStructSet(BinaryenModuleRef module,
       .makeStructSet(
         index, (Expression*)ref, (Expression*)value, MemoryOrder::Unordered));
 }
+BinaryenExpressionRef BinaryenStructWait(BinaryenModuleRef module,
+                                         BinaryenExpressionRef ref,
+                                         BinaryenIndex index,
+                                         BinaryenExpressionRef expected,
+                                         BinaryenExpressionRef timeout,
+                                         BinaryenExpressionRef waitqueue) {
+  return Builder(*(Module*)module)
+    .makeStructWait(index,
+                    (Expression*)ref,
+                    (Expression*)waitqueue,
+                    (Expression*)expected,
+                    (Expression*)timeout);
+}
+BinaryenExpressionRef BinaryenWaitqueueNew(BinaryenModuleRef module) {
+  return Builder(*(Module*)module).makeWaitqueueNew();
+}
+BinaryenExpressionRef BinaryenWaitqueueNotify(BinaryenModuleRef module,
+                                              BinaryenExpressionRef waitqueue,
+                                              BinaryenExpressionRef count) {
+  return Builder(*(Module*)module)
+    .makeWaitqueueNotify((Expression*)waitqueue, (Expression*)count);
+}
 BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
                                        BinaryenHeapType type,
                                        BinaryenExpressionRef size,
@@ -4512,6 +4534,101 @@ void BinaryenStructSetSetValue(BinaryenExpressionRef expr,
   assert(valueExpr);
   static_cast<StructSet*>(expression)->value = (Expression*)valueExpr;
 }
+
+// StructWait
+
+BinaryenExpressionRef BinaryenStructWaitGetRef(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  return static_cast<StructWait*>(expression)->ref;
+}
+void BinaryenStructWaitSetRef(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef refExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  assert(refExpr);
+  static_cast<StructWait*>(expression)->ref = (Expression*)refExpr;
+}
+BinaryenIndex BinaryenStructWaitGetIndex(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  return static_cast<StructWait*>(expression)->index;
+}
+void BinaryenStructWaitSetIndex(BinaryenExpressionRef expr,
+                                BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  static_cast<StructWait*>(expression)->index = index;
+}
+BinaryenExpressionRef
+BinaryenStructWaitGetExpected(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  return static_cast<StructWait*>(expression)->expected;
+}
+void BinaryenStructWaitSetExpected(BinaryenExpressionRef expr,
+                                   BinaryenExpressionRef expectedExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  assert(expectedExpr);
+  static_cast<StructWait*>(expression)->expected = (Expression*)expectedExpr;
+}
+BinaryenExpressionRef BinaryenStructWaitGetTimeout(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  return static_cast<StructWait*>(expression)->timeout;
+}
+void BinaryenStructWaitSetTimeout(BinaryenExpressionRef expr,
+                                  BinaryenExpressionRef timeoutExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  assert(timeoutExpr);
+  static_cast<StructWait*>(expression)->timeout = (Expression*)timeoutExpr;
+}
+BinaryenExpressionRef
+BinaryenStructWaitGetWaitqueue(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  return static_cast<StructWait*>(expression)->waitqueue;
+}
+void BinaryenStructWaitSetWaitqueue(BinaryenExpressionRef expr,
+                                    BinaryenExpressionRef waitqueueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<StructWait>());
+  assert(waitqueueExpr);
+  static_cast<StructWait*>(expression)->waitqueue = (Expression*)waitqueueExpr;
+}
+
+// WaitqueueNotify
+
+BinaryenExpressionRef
+BinaryenWaitqueueNotifyGetWaitqueue(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<WaitqueueNotify>());
+  return static_cast<WaitqueueNotify*>(expression)->waitqueue;
+}
+void BinaryenWaitqueueNotifySetWaitqueue(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef waitqueueExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<WaitqueueNotify>());
+  assert(waitqueueExpr);
+  static_cast<WaitqueueNotify*>(expression)->waitqueue =
+    (Expression*)waitqueueExpr;
+}
+BinaryenExpressionRef
+BinaryenWaitqueueNotifyGetCount(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<WaitqueueNotify>());
+  return static_cast<WaitqueueNotify*>(expression)->count;
+}
+void BinaryenWaitqueueNotifySetCount(BinaryenExpressionRef expr,
+                                     BinaryenExpressionRef countExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<WaitqueueNotify>());
+  assert(countExpr);
+  static_cast<WaitqueueNotify*>(expression)->count = (Expression*)countExpr;
+}
+
 // ArrayNew
 BinaryenExpressionRef BinaryenArrayNewGetInit(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;

src/binaryen-c.h

@@ -1097,6 +1097,19 @@ BinaryenStructSet(BinaryenModuleRef module,
                   BinaryenIndex index,
                   BinaryenExpressionRef ref,
                   BinaryenExpressionRef value);
+BINARYEN_API BinaryenExpressionRef
+BinaryenStructWait(BinaryenModuleRef module,
+                   BinaryenExpressionRef ref,
+                   BinaryenIndex index,
+                   BinaryenExpressionRef expected,
+                   BinaryenExpressionRef timeout,
+                   BinaryenExpressionRef waitqueue);
+BINARYEN_API BinaryenExpressionRef
+BinaryenWaitqueueNew(BinaryenModuleRef module);
+BINARYEN_API BinaryenExpressionRef
+BinaryenWaitqueueNotify(BinaryenModuleRef module,
+                        BinaryenExpressionRef waitqueue,
+                        BinaryenExpressionRef count);
 BINARYEN_API BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
                                                     BinaryenHeapType type,
                                                     BinaryenExpressionRef size,
@@ -2566,6 +2579,45 @@ BinaryenStructSetGetValue(BinaryenExpressionRef expr);
 BINARYEN_API void BinaryenStructSetSetValue(BinaryenExpressionRef expr,
                                             BinaryenExpressionRef valueExpr);
 
+// StructWait
+
+BINARYEN_API BinaryenExpressionRef
+BinaryenStructWaitGetRef(BinaryenExpressionRef expr);
+BINARYEN_API void BinaryenStructWaitSetRef(BinaryenExpressionRef expr,
+                                           BinaryenExpressionRef refExpr);
+BINARYEN_API BinaryenIndex
+BinaryenStructWaitGetIndex(BinaryenExpressionRef expr);
+BINARYEN_API void BinaryenStructWaitSetIndex(BinaryenExpressionRef expr,
+                                             BinaryenIndex index);
+BINARYEN_API BinaryenExpressionRef
+BinaryenStructWaitGetExpected(BinaryenExpressionRef expr);
+BINARYEN_API void
+BinaryenStructWaitSetExpected(BinaryenExpressionRef expr,
+                              BinaryenExpressionRef expectedExpr);
+BINARYEN_API BinaryenExpressionRef
+BinaryenStructWaitGetTimeout(BinaryenExpressionRef expr);
+BINARYEN_API void
+BinaryenStructWaitSetTimeout(BinaryenExpressionRef expr,
+                             BinaryenExpressionRef timeoutExpr);
+BINARYEN_API BinaryenExpressionRef
+BinaryenStructWaitGetWaitqueue(BinaryenExpressionRef expr);
+BINARYEN_API void
+BinaryenStructWaitSetWaitqueue(BinaryenExpressionRef expr,
+                               BinaryenExpressionRef waitqueueExpr);
+
+// WaitqueueNotify
+
+BINARYEN_API BinaryenExpressionRef
+BinaryenWaitqueueNotifyGetWaitqueue(BinaryenExpressionRef expr);
+BINARYEN_API void
+BinaryenWaitqueueNotifySetWaitqueue(BinaryenExpressionRef expr,
+                                    BinaryenExpressionRef waitqueueExpr);
+BINARYEN_API BinaryenExpressionRef
+BinaryenWaitqueueNotifyGetCount(BinaryenExpressionRef expr);
+BINARYEN_API void
+BinaryenWaitqueueNotifySetCount(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef countExpr);
+
 // ArrayNew
 
 BINARYEN_API BinaryenExpressionRef

src/js/binaryen.js-post.js

@@ -2591,6 +2591,18 @@ function wrapModule(module, self = {}) {
     },
     'set'(index, ref, value) {
       return Module['_BinaryenStructSet'](module, index, ref, value);
+    },
+    'wait'(ref, index, expected, timeout, waitqueue) {
+      return Module['_BinaryenStructWait'](module, ref, index, expected, timeout, waitqueue);
+    }
+  };
+
+  self['waitqueue'] = {
+    'new'() {
+      return Module['_BinaryenWaitqueueNew'](module);
+    },
+    'notify'(waitqueue, count) {
+      return Module['_BinaryenWaitqueueNotify'](module, waitqueue, count);
     }
   };
 
@@ -4929,6 +4941,56 @@ Module['StructSet'] = makeExpressionWrapper(Module['_BinaryenStructSetId'](), {
   }
 });
 
+Module['StructWait'] = makeExpressionWrapper(Module['_BinaryenStructWaitId'](), {
+  'getRef'(expr) {
+    return Module['_BinaryenStructWaitGetRef'](expr);
+  },
+  'setRef'(expr, ref) {
+    Module['_BinaryenStructWaitSetRef'](expr, ref);
+  },
+  'getIndex'(expr) {
+    return Module['_BinaryenStructWaitGetIndex'](expr);
+  },
+  'setIndex'(expr, index) {
+    Module['_BinaryenStructWaitSetIndex'](expr, index);
+  },
+  'getExpected'(expr) {
+    return Module['_BinaryenStructWaitGetExpected'](expr);
+  },
+  'setExpected'(expr, expectedExpr) {
+    Module['_BinaryenStructWaitSetExpected'](expr, expectedExpr);
+  },
+  'getTimeout'(expr) {
+    return Module['_BinaryenStructWaitGetTimeout'](expr);
+  },
+  'setTimeout'(expr, timeoutExpr) {
+    Module['_BinaryenStructWaitSetTimeout'](expr, timeoutExpr);
+  },
+  'getWaitqueue'(expr) {
+    return Module['_BinaryenStructWaitGetWaitqueue'](expr);
+  },
+  'setWaitqueue'(expr, waitqueueExpr) {
+    Module['_BinaryenStructWaitSetWaitqueue'](expr, waitqueueExpr);
+  }
+});
+
+Module['WaitqueueNew'] = makeExpressionWrapper(Module['_BinaryenWaitqueueNewId'](), {});
+
+Module['WaitqueueNotify'] = makeExpressionWrapper(Module['_BinaryenWaitqueueNotifyId'](), {
+  'getWaitqueue'(expr) {
+    return Module['_BinaryenWaitqueueNotifyGetWaitqueue'](expr);
+  },
+  'setWaitqueue'(expr, waitqueueExpr) {
+    Module['_BinaryenWaitqueueNotifySetWaitqueue'](expr, waitqueueExpr);
+  },
+  'getCount'(expr) {
+    return Module['_BinaryenWaitqueueNotifyGetCount'](expr);
+  },
+  'setCount'(expr, countExpr) {
+    Module['_BinaryenWaitqueueNotifySetCount'](expr, countExpr);
+  }
+});
+
 Module['ArrayNew'] = makeExpressionWrapper(Module['_BinaryenArrayNewId'](), {
   'getInit'(expr) {
     return Module['_BinaryenArrayNewGetInit'](expr);

test/binaryen.js/expressions.js

@@ -2446,6 +2446,87 @@ console.log("# StructSet");
   module.dispose();
 })();
 
+console.log("# StructWait");
+(function testStructWait() {
+  const builder = new binaryen.TypeBuilder(1);
+  builder.setStructType(0, [
+    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+  ]);
+  var [
+    struct0Type
+  ] = builder.buildAndDispose();
+
+  const module = new binaryen.Module();
+
+  var ref = module.local.get(0, struct0Type);
+  var index = 0;
+  var expected = module.local.get(1, binaryen.i32);
+  var timeout = module.local.get(2, binaryen.i64);
+  var waitqueue = module.local.get(3, binaryen.anyref);
+  const theStructWait = binaryen.StructWait(module.struct.wait(ref, index, expected, timeout, waitqueue));
+  assert(theStructWait instanceof binaryen.StructWait);
+  assert(theStructWait instanceof binaryen.Expression);
+  assert(theStructWait.ref === ref);
+  assert(theStructWait.index === index);
+  assert(theStructWait.expected === expected);
+  assert(theStructWait.timeout === timeout);
+  assert(theStructWait.waitqueue === waitqueue);
+  assert(theStructWait.type === binaryen.i32);
+
+  var info = binaryen.getExpressionInfo(theStructWait);
+  assert(info.id === theStructWait.id);
+  assert(info.type === theStructWait.type);
+  assert(info.ref === theStructWait.ref);
+  assert(info.index === theStructWait.index);
+  assert(info.expected === theStructWait.expected);
+  assert(info.timeout === theStructWait.timeout);
+  assert(info.waitqueue === theStructWait.waitqueue);
+
+  console.log(theStructWait.toText());
+
+  module.dispose();
+})();
+
+console.log("# WaitqueueNew");
+(function testWaitqueueNew() {
+  const module = new binaryen.Module();
+
+  const theWaitqueueNew = binaryen.WaitqueueNew(module.waitqueue.new());
+  assert(theWaitqueueNew instanceof binaryen.WaitqueueNew);
+  assert(theWaitqueueNew instanceof binaryen.Expression);
+
+  var info = binaryen.getExpressionInfo(theWaitqueueNew);
+  assert(info.id === theWaitqueueNew.id);
+  assert(info.type === theWaitqueueNew.type);
+
+  console.log(theWaitqueueNew.toText());
+
+  module.dispose();
+})();
+
+console.log("# WaitqueueNotify");
+(function testWaitqueueNotify() {
+  const module = new binaryen.Module();
+
+  var waitqueue = module.local.get(0, binaryen.anyref);
+  var count = module.local.get(1, binaryen.i32);
+  const theWaitqueueNotify = binaryen.WaitqueueNotify(module.waitqueue.notify(waitqueue, count));
+  assert(theWaitqueueNotify instanceof binaryen.WaitqueueNotify);
+  assert(theWaitqueueNotify instanceof binaryen.Expression);
+  assert(theWaitqueueNotify.waitqueue === waitqueue);
+  assert(theWaitqueueNotify.count === count);
+
+  var info = binaryen.getExpressionInfo(theWaitqueueNotify);
+  assert(info.id === theWaitqueueNotify.id);
+  assert(info.type === theWaitqueueNotify.type);
+  assert(info.waitqueue === theWaitqueueNotify.waitqueue);
+  assert(info.count === theWaitqueueNotify.count);
+
+  console.log(theWaitqueueNotify.toText());
+
+  module.dispose();
+})();
+
 console.log("# ArrayNew");
 (function testArrayNew() {
   const builder = new binaryen.TypeBuilder(2);

test/binaryen.js/expressions.js.txt

@@ -285,6 +285,23 @@
  (local.get $3)
 )
 
+# StructWait
+(struct.wait $struct.0 0
+ (local.get $0)
+ (local.get $3)
+ (local.get $1)
+ (local.get $2)
+)
+
+# WaitqueueNew
+(waitqueue.new)
+
+# WaitqueueNotify
+(waitqueue.notify
+ (local.get $0)
+ (local.get $1)
+)
+
 # ArrayNew
 (array.new $array.0
  (i32.const 3)

test/example/c-api-kitchen-sink.c

@@ -1168,6 +1168,14 @@ void test_core() {
                       0,
                       BinaryenGlobalGet(module, "i32Struct-global", i32Struct),
                       makeInt32(module, 0)),
+    BinaryenStructWait(module,
+                       BinaryenGlobalGet(module, "i32Struct-global", i32Struct),
+                       0,
+                       makeInt32(module, 0),
+                       makeInt64(module, 0),
+                       BinaryenWaitqueueNew(module)),
+    BinaryenWaitqueueNotify(
+      module, BinaryenWaitqueueNew(module), makeInt32(module, 0)),
     BinaryenArrayNew(
       module, BinaryenTypeGetHeapType(i8Array), makeInt32(module, 3), 0),
     BinaryenArrayNew(module,