[dart2wasm] Add support for declaring functions as module elements.

Allows functions to be referenced in a constant context (via ref_func) without needing to bind the function to a global.

Uses format 3 supported by the element section:
https://webassembly.github.io/gc/core/binary/modules.html#element-section

Change-Id: Ifb68800c480b14acfa3432eae80396be4e9c8a6e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/400900
Commit-Queue: Nate Biggs <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>

Author: natebiggs

pkg/wasm_builder/lib/src/builder/functions.dart

@@ -13,6 +13,7 @@ class FunctionsBuilder with Builder<ir.Functions> {
   final ModuleBuilder _module;
   final _functionBuilders = <FunctionBuilder>[];
   final _importedFunctions = <ir.ImportedFunction>[];
+  final _declaredFunctions = <ir.BaseFunction>{};
   int _nameCount = 0;
   ir.BaseFunction? _start;
 
@@ -61,10 +62,17 @@ class FunctionsBuilder with Builder<ir.Functions> {
     return function;
   }
 
+  /// Declare [function] as a module element so it can be used in a constant
+  /// context.
+  void declare(ir.BaseFunction function) {
+    _declaredFunctions.add(function);
+  }
+
   @override
   ir.Functions forceBuild() {
     final built = finalizeImportsAndBuilders<ir.DefinedFunction>(
         _importedFunctions, _functionBuilders);
-    return ir.Functions(_start, _importedFunctions, built, _nameCount);
+    return ir.Functions(
+        _start, _importedFunctions, built, [..._declaredFunctions], _nameCount);
   }
 }

pkg/wasm_builder/lib/src/ir/functions.dart

@@ -19,8 +19,12 @@ class Functions {
   /// Defined functions.
   final List<DefinedFunction> defined;
 
+  /// Declared functions.
+  final List<BaseFunction> declared;
+
   /// Named functions.
   final int namedCount;
 
-  Functions(this.start, this.imported, this.defined, this.namedCount);
+  Functions(
+      this.start, this.imported, this.defined, this.declared, this.namedCount);
 }

pkg/wasm_builder/lib/src/ir/module.dart

@@ -51,7 +51,9 @@ class Module implements Serializable {
     GlobalSection(globals.defined, watchPoints).serialize(s);
     ExportSection(exports.exported, watchPoints).serialize(s);
     StartSection(functions.start, watchPoints).serialize(s);
-    ElementSection(tables.defined, tables.imported, watchPoints).serialize(s);
+    ElementSection(
+            tables.defined, tables.imported, functions.declared, watchPoints)
+        .serialize(s);
     DataCountSection(dataSegments.defined, watchPoints).serialize(s);
     CodeSection(functions.defined, watchPoints).serialize(s);
     DataSection(dataSegments.defined, watchPoints).serialize(s);

pkg/wasm_builder/lib/src/serialize/sections.dart

@@ -216,12 +216,14 @@ class StartSection extends Section {
   }
 }
 
-class _Element implements Serializable {
+sealed class _Element implements Serializable {}
+
+class _TableElement implements _Element {
   final ir.Table table;
   final int startIndex;
   final List<ir.BaseFunction> entries = [];
 
-  _Element(this.table, this.startIndex);
+  _TableElement(this.table, this.startIndex);
 
   @override
   void serialize(Serializer s) {
@@ -250,32 +252,53 @@ class _Element implements Serializable {
   }
 }
 
+class _DeclaredElement implements _Element {
+  final List<ir.BaseFunction> entries;
+
+  _DeclaredElement(this.entries);
+
+  @override
+  void serialize(Serializer s) {
+    if (entries.isEmpty) return;
+    s.writeByte(0x03);
+    s.writeByte(0x00);
+
+    s.writeUnsigned(entries.length);
+    for (final entry in entries) {
+      s.writeUnsigned(entry.index);
+    }
+  }
+}
+
 class ElementSection extends Section {
   final List<ir.DefinedTable> definedTables;
   final List<ir.ImportedTable> importedTables;
+  final List<ir.BaseFunction> declaredFunctions;
 
-  ElementSection(this.definedTables, this.importedTables, super.watchPoints);
+  ElementSection(this.definedTables, this.importedTables,
+      this.declaredFunctions, super.watchPoints);
 
   @override
   int get id => 9;
 
   @override
   bool get isNotEmpty =>
       definedTables.any((table) => table.elements.any((e) => e != null)) ||
-      importedTables.any((table) => table.setElements.isNotEmpty);
+      importedTables.any((table) => table.setElements.isNotEmpty) ||
+      declaredFunctions.isNotEmpty;
 
   @override
   void serializeContents(Serializer s) {
     // Group nonempty element entries into contiguous stretches and serialize
     // each stretch as an element.
     List<_Element> elements = [];
     for (final table in definedTables) {
-      _Element? current;
+      _TableElement? current;
       for (int i = 0; i < table.elements.length; i++) {
         ir.BaseFunction? function = table.elements[i];
         if (function != null) {
           if (current == null) {
-            current = _Element(table, i);
+            current = _TableElement(table, i);
             elements.add(current);
           }
           current.entries.add(function);
@@ -288,19 +311,22 @@ class ElementSection extends Section {
       final entries = [...table.setElements.entries]
         ..sort((a, b) => a.key.compareTo(b.key));
 
-      _Element? current;
+      _TableElement? current;
       int lastIndex = -2;
       for (final entry in entries) {
         final index = entry.key;
         final function = entry.value;
         if (index != lastIndex + 1) {
-          current = _Element(table, index);
+          current = _TableElement(table, index);
           elements.add(current);
         }
         current!.entries.add(function);
         lastIndex = index;
       }
     }
+    for (final func in declaredFunctions) {
+      elements.add(_DeclaredElement([func]));
+    }
     s.writeList(elements);
   }
 }