yolo

src/parser/parsers.h

@@ -292,6 +292,10 @@ Result<> makeArrayInitData(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeArrayInitElem(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
+template<typename Ctx>
+Result<> makeArrayRMW(AtomicRMWOp, const std::vector<Annotation>&);
+template<typename Ctx>
+Result<> makeArrayCmpxchg(const std::vector<Annotation>&);
 Result<> makeRefAs(Ctx&, Index, const std::vector<Annotation>&, RefAsOp op);
 template<typename Ctx>
 Result<>
@@ -2499,6 +2503,41 @@ Result<> makeArrayInitElem(Ctx& ctx,
   return ctx.makeArrayInitElem(pos, annotations, *type, *elem);
 }
 
+template<typename Ctx>
+Result<> makeArrayRMW(Ctx& ctx,
+                       const std::vector<Annotation>& annotations,
+                       AtomicRMWOp op) {
+  auto order1 = memorder(ctx);
+  CHECK_ERR(order1);
+  auto order2 = memorder(ctx);
+  CHECK_ERR(order2);
+  if (*order1 != *order2) {
+    return ctx.in.err(pos, "array.atomic.rmw memory orders must be identical");
+  }
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto field = fieldidx(ctx, *type);
+  CHECK_ERR(field);
+  return ctx.makeArrayRMW(annotations, op, *type, *field, *order1);
+}
+
+template<typename Ctx>
+Result<> makeArrayCmpxchg(Ctx& ctx,
+                           const std::vector<Annotation>& annotations) {
+  auto order1 = memorder(ctx);
+  CHECK_ERR(order1);
+  auto order2 = memorder(ctx);
+  CHECK_ERR(order2);
+  if (*order1 != *order2) {
+    return ctx.in.err(pos, "array.atomic.rmw memory orders must be identical");
+  }
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto field = fieldidx(ctx, *type);
+  CHECK_ERR(field);
+  return ctx.makeArrayCmpxchg(annotations, *type, *field, *order1);
+}
+
 template<typename Ctx>
 Result<> makeRefAs(Ctx& ctx,
                    Index pos,

src/wasm-builder.h

@@ -1128,6 +1128,34 @@ class Builder {
     ret->finalize();
     return ret;
   }
+  ArrayRMW* makeArrayRMW(AtomicRMWOp op,
+                           Expression* ref,
+                           Expression* index,
+                           Expression* value,
+                           MemoryOrder order) {
+    auto* ret = wasm.allocator.alloc<ArrayRMW>();
+    ret->op = op;
+    ret->ref = ref;
+    ret->index = index;
+    ret->value = value;
+    ret->order = order;
+    ret->finalize();
+    return ret;
+  }
+  ArrayCmpxchg* makeArrayCmpxchg(Expression* ref,
+                           Expression* index,
+                                   Expression* expected,
+                                   Expression* replacement,
+                                   MemoryOrder order) {
+    auto* ret = wasm.allocator.alloc<ArrayCmpxchg>();
+    ret->ref = ref;
+    ret->index = index;
+    ret->expected = expected;
+    ret->replacement = replacement;
+    ret->order = order;
+    ret->finalize();
+    return ret;
+  }
   RefAs* makeRefAs(RefAsOp op, Expression* value) {
     auto* ret = wasm.allocator.alloc<RefAs>();
     ret->op = op;

src/wasm-ir-builder.h

@@ -235,6 +235,9 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeArrayFill(HeapType type);
   Result<> makeArrayInitData(HeapType type, Name data);
   Result<> makeArrayInitElem(HeapType type, Name elem);
+  Result<>
+  makeArrayRMW(AtomicRMWOp op, HeapType type, MemoryOrder order);
+  Result<> makeArrayCmpxchg(HeapType type, MemoryOrder order);
   Result<> makeRefAs(RefAsOp op);
   Result<> makeStringNew(StringNewOp op);
   Result<> makeStringConst(Name string);