[Parser] Parse array.new_fixed

src/parser/contexts.h

@@ -432,6 +432,10 @@ struct NullInstrParserCtx {
   Result<> makeArrayNewElem(Index, HeapTypeT, DataIdxT) {
     return Ok{};
   }
+  template<typename HeapTypeT>
+  Result<> makeArrayNewFixed(Index, HeapTypeT, uint32_t) {
+    return Ok{};
+  }
   template<typename HeapTypeT> Result<> makeArrayGet(Index, HeapTypeT, bool) {
     return Ok{};
   }
@@ -1334,6 +1338,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return withLoc(pos, irBuilder.makeArrayNewElem(type, elem));
   }
 
+  Result<> makeArrayNewFixed(Index pos, HeapType type, uint32_t arity) {
+    return withLoc(pos, irBuilder.makeArrayNewFixed(type, arity));
+  }
+
   Result<> makeArrayGet(Index pos, HeapType type, bool signed_) {
     return withLoc(pos, irBuilder.makeArrayGet(type, signed_));
   }

src/parser/parsers.h

@@ -1382,7 +1382,13 @@ template<typename Ctx> Result<> makeArrayNewElem(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx> Result<> makeArrayNewFixed(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto arity = ctx.in.takeU32();
+  if (!arity) {
+    return ctx.in.err(pos, "expected array.new_fixed arity");
+  }
+  return ctx.makeArrayNewFixed(pos, *type, *arity);
 }
 
 template<typename Ctx>

src/wasm-builder.h

@@ -992,14 +992,19 @@ class Builder {
     ret->finalize();
     return ret;
   }
-  ArrayNewFixed* makeArrayNewFixed(HeapType type,
-                                   const std::vector<Expression*>& values) {
+  template<typename T>
+  ArrayNewFixed* makeArrayNewFixed(HeapType type, const T& values) {
     auto* ret = wasm.allocator.alloc<ArrayNewFixed>();
     ret->values.set(values);
     ret->type = Type(type, NonNullable);
     ret->finalize();
     return ret;
   }
+  ArrayNewFixed*
+  makeArrayNewFixed(HeapType type,
+                    std::initializer_list<Expression*>&& values) {
+    return makeArrayNewFixed(type, values);
+  }
   ArrayGet* makeArrayGet(Expression* ref,
                          Expression* index,
                          Type type,

src/wasm-ir-builder.h

@@ -162,7 +162,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   [[nodiscard]] Result<> makeArrayNewDefault(HeapType type);
   [[nodiscard]] Result<> makeArrayNewData(HeapType type, Name data);
   [[nodiscard]] Result<> makeArrayNewElem(HeapType type, Name elem);
-  // [[nodiscard]] Result<> makeArrayNewFixed();
+  [[nodiscard]] Result<> makeArrayNewFixed(HeapType type, uint32_t arity);
   [[nodiscard]] Result<> makeArrayGet(HeapType type, bool signed_);
   [[nodiscard]] Result<> makeArraySet(HeapType type);
   [[nodiscard]] Result<> makeArrayLen();
@@ -191,6 +191,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   [[nodiscard]] Result<> visitReturn(Return*);
   [[nodiscard]] Result<> visitStructNew(StructNew*);
   [[nodiscard]] Result<> visitArrayNew(ArrayNew*);
+  [[nodiscard]] Result<> visitArrayNewFixed(ArrayNewFixed*);
   [[nodiscard]] Result<> visitBreak(Break*,
                                     std::optional<Index> label = std::nullopt);
   [[nodiscard]] Result<>

src/wasm/wasm-ir-builder.cpp

@@ -287,6 +287,15 @@ Result<> IRBuilder::visitArrayNew(ArrayNew* curr) {
   return Ok{};
 }
 
+Result<> IRBuilder::visitArrayNewFixed(ArrayNewFixed* curr) {
+  for (size_t i = 0, size = curr->values.size(); i < size; ++i) {
+    auto val = pop();
+    CHECK_ERR(val);
+    curr->values[size - i - 1] = *val;
+  }
+  return Ok{};
+}
+
 Result<Expression*> IRBuilder::getBranchValue(Name labelName,
                                               std::optional<Index> label) {
   if (!label) {
@@ -1000,7 +1009,13 @@ Result<> IRBuilder::makeArrayNewElem(HeapType type, Name elem) {
   return Ok{};
 }
 
-// Result<> IRBuilder::makeArrayNewFixed() {}
+Result<> IRBuilder::makeArrayNewFixed(HeapType type, uint32_t arity) {
+  ArrayNewFixed curr(wasm.allocator);
+  curr.values.resize(arity);
+  CHECK_ERR(visitArrayNewFixed(&curr));
+  push(builder.makeArrayNewFixed(type, curr.values));
+  return Ok{};
+}
 
 Result<> IRBuilder::makeArrayGet(HeapType type, bool signed_) {
   ArrayGet curr;