[Parser] Parse array.new_fixed (#6102)

5 files changed, 40 insertions, 5 deletions

diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index aa207fcd5..f6dd92063 100644
--- a/src/parser/contexts.h
+++ b/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_));
   }
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 610e2953a..2d90a7d27 100644
--- a/src/parser/parsers.h
+++ b/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>
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 9e2881145..1dd7a7e09 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -992,14 +992,19 @@ public:
     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,
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 24b430e25..4b6cacae9 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -162,7 +162,7 @@ public:
   [[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 @@ public:
   [[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<>
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index 843e0ed78..9b2a944dd 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/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;