[Wasm GC] ArrayInit support (#4138)

array.init is like array.new_with_rtt except that it takes
as arguments the values to initialize the array with (as opposed to
a size and an optional initial value).

Spec: https://docs.google.com/document/d/1afthjsL_B9UaMqCA5ekgVmOm75BVFu6duHNsN9-gnXw/edit#

Author: kripken

scripts/gen-s-parser.py

@@ -559,19 +559,20 @@
     ("struct.set",           "makeStructSet(s)"),
     ("array.new_with_rtt",   "makeArrayNew(s, false)"),
     ("array.new_default_with_rtt", "makeArrayNew(s, true)"),
-    ("array.get",           "makeArrayGet(s)"),
-    ("array.get_s",         "makeArrayGet(s, true)"),
-    ("array.get_u",         "makeArrayGet(s, false)"),
-    ("array.set",           "makeArraySet(s)"),
-    ("array.len",           "makeArrayLen(s)"),
-    ("array.copy",          "makeArrayCopy(s)"),
-    ("ref.is_func",         "makeRefIs(s, RefIsFunc)"),
-    ("ref.is_data",         "makeRefIs(s, RefIsData)"),
-    ("ref.is_i31",          "makeRefIs(s, RefIsI31)"),
-    ("ref.as_non_null",     "makeRefAs(s, RefAsNonNull)"),
-    ("ref.as_func",         "makeRefAs(s, RefAsFunc)"),
-    ("ref.as_data",         "makeRefAs(s, RefAsData)"),
-    ("ref.as_i31",          "makeRefAs(s, RefAsI31)"),
+    ("array.init",           "makeArrayInit(s)"),
+    ("array.get",            "makeArrayGet(s)"),
+    ("array.get_s",          "makeArrayGet(s, true)"),
+    ("array.get_u",          "makeArrayGet(s, false)"),
+    ("array.set",            "makeArraySet(s)"),
+    ("array.len",            "makeArrayLen(s)"),
+    ("array.copy",           "makeArrayCopy(s)"),
+    ("ref.is_func",          "makeRefIs(s, RefIsFunc)"),
+    ("ref.is_data",          "makeRefIs(s, RefIsData)"),
+    ("ref.is_i31",           "makeRefIs(s, RefIsI31)"),
+    ("ref.as_non_null",      "makeRefAs(s, RefAsNonNull)"),
+    ("ref.as_func",          "makeRefAs(s, RefAsFunc)"),
+    ("ref.as_data",          "makeRefAs(s, RefAsData)"),
+    ("ref.as_i31",           "makeRefAs(s, RefAsI31)"),
 ]
 
 

src/gen-s-parser.inc

@@ -33,6 +33,9 @@ switch (op[0]) {
               default: goto parse_error;
             }
           }
+          case 'i':
+            if (strcmp(op, "array.init") == 0) { return makeArrayInit(s); }
+            goto parse_error;
           case 'l':
             if (strcmp(op, "array.len") == 0) { return makeArrayLen(s); }
             goto parse_error;

src/ir/ReFinalize.cpp

@@ -162,6 +162,7 @@ void ReFinalize::visitStructNew(StructNew* curr) { curr->finalize(); }
 void ReFinalize::visitStructGet(StructGet* curr) { curr->finalize(); }
 void ReFinalize::visitStructSet(StructSet* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNew(ArrayNew* curr) { curr->finalize(); }
+void ReFinalize::visitArrayInit(ArrayInit* curr) { curr->finalize(); }
 void ReFinalize::visitArrayGet(ArrayGet* curr) { curr->finalize(); }
 void ReFinalize::visitArraySet(ArraySet* curr) { curr->finalize(); }
 void ReFinalize::visitArrayLen(ArrayLen* curr) { curr->finalize(); }

src/ir/cost.h

@@ -606,6 +606,13 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   CostType visitArrayNew(ArrayNew* curr) {
     return 4 + visit(curr->rtt) + visit(curr->size) + maybeVisit(curr->init);
   }
+  CostType visitArrayInit(ArrayInit* curr) {
+    CostType ret = 4 + visit(curr->rtt);
+    for (auto* child : curr->values) {
+      ret += visit(child);
+    }
+    return ret;
+  }
   CostType visitArrayGet(ArrayGet* curr) {
     return 1 + nullCheckCost(curr->ref) + visit(curr->ref) + visit(curr->index);
   }

src/ir/effects.h

@@ -642,6 +642,7 @@ class EffectAnalyzer {
       }
     }
     void visitArrayNew(ArrayNew* curr) {}
+    void visitArrayInit(ArrayInit* curr) {}
     void visitArrayGet(ArrayGet* curr) {
       parent.readsArray = true;
       // traps when the arg is null or the index out of bounds

src/ir/global-utils.h

@@ -65,7 +65,7 @@ inline bool canInitializeGlobal(Expression* curr) {
   }
   if (Properties::isSingleConstantExpression(curr) || curr->is<GlobalGet>() ||
       curr->is<RttCanon>() || curr->is<RttSub>() || curr->is<StructNew>() ||
-      curr->is<ArrayNew>() || curr->is<I31New>()) {
+      curr->is<ArrayNew>() || curr->is<ArrayInit>() || curr->is<I31New>()) {
     for (auto* child : ChildIterator(curr)) {
       if (!canInitializeGlobal(child)) {
         return false;

src/ir/properties.cpp

@@ -32,6 +32,7 @@ bool isGenerative(Expression* curr, FeatureSet features) {
     bool generative = false;
     void visitStructNew(StructNew* curr) { generative = true; }
     void visitArrayNew(ArrayNew* curr) { generative = true; }
+    void visitArrayInit(ArrayInit* curr) { generative = true; }
   } scanner;
   scanner.walk(curr);
   return scanner.generative;

src/js/binaryen.js-post.js

@@ -109,6 +109,7 @@ function initializeConstants() {
     'StructGet',
     'StructSet',
     'ArrayNew',
+    'ArrayInit',
     'ArrayGet',
     'ArraySet',
     'ArrayLen'

src/passes/Precompute.cpp

@@ -94,6 +94,7 @@ class PrecomputingExpressionRunner
   Flow visitStructNew(StructNew* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitStructGet(StructGet* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitArrayNew(ArrayNew* curr) { return Flow(NONCONSTANT_FLOW); }
+  Flow visitArrayInit(ArrayInit* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitArrayGet(ArrayGet* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitArrayLen(ArrayLen* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitArrayCopy(ArrayCopy* curr) { return Flow(NONCONSTANT_FLOW); }

src/passes/Print.cpp

@@ -2006,6 +2006,10 @@ struct PrintExpressionContents
     o << "with_rtt ";
     TypeNamePrinter(o, wasm).print(curr->rtt->type.getHeapType());
   }
+  void visitArrayInit(ArrayInit* curr) {
+    printMedium(o, "array.init ");
+    TypeNamePrinter(o, wasm).print(curr->rtt->type.getHeapType());
+  }
   void visitArrayGet(ArrayGet* curr) {
     if (printUnreachableReplacement(curr->ref)) {
       return;