Add support for non-nullable tables and init expressions

CHANGELOG.md

@@ -36,6 +36,11 @@ v127
    and `setValueI64`, previously took a hi/low pair but now take a single value
    which can be bigint or a number. Passing two values to these APIs will now
    trigger an assertion. (#7984)
+ - Add support for non-nullable table types and initialization expressions for
+   tables. This comes with a breaking change to C API: `BinaryenAddTable` takes
+   an additional `BinaryenExpressionRef` parameter to provide an initialization
+   expression. This may be set to NULL for tables without an initializer. In JS
+   this parameter is optional and so is not breaking. (#8405)
 
 v126
 ----

scripts/test/shared.py

@@ -419,29 +419,24 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'data.wast',    # Fail to parse data segment offset abbreviation
     'elem.wast',    # Requires modeling empty declarative segments
     'func.wast',    # Duplicate parameter names not properly rejected
-    'global.wast',  # Fail to parse table
     'if.wast',      # Requires more precise unreachable validation
     'imports.wast',  # Requires fixing handling of mutation to imported globals
     'proposals/threads/imports.wast',  # Missing memory type validation on instantiation
     'linking.wast',  # Missing function type validation on instantiation
     'proposals/threads/memory.wast',  # Missing memory type validation on instantiation
     'annotations.wast',  # String annotations IDs should be allowed
-    'instance.wast',  # Requires support for table default elements
     'table64.wast',   # Requires validations for table size
     'tag.wast',      # Non-empty tag results allowed by stack switching
     'local_init.wast',  # Requires local validation to respect unnamed blocks
     'ref_func.wast',   # Requires rejecting undeclared functions references
-    'ref_is_null.wast',  # Requires support for non-nullable reference types in tables
     'return_call_indirect.wast',  # Requires more precise unreachable validation
     'select.wast',  # Missing validation of type annotation on select
-    'table.wast',  # Requires support for table default elements
     'unreached-invalid.wast',  # Requires more precise unreachable validation
-    'array.wast',  # Requires support for table default elements
+    'array.wast',  # Failure to parse element segment item abbreviation
     'br_if.wast',  # Requires more precise branch validation
     'br_on_cast.wast',  # Requires host references to not be externalized i31refs
     'br_on_cast_fail.wast',  # Requires host references to not be externalized i31refs
     'extern.wast',    # Requires ref.host wast constants
-    'i31.wast',       # Requires support for table default elements
     'ref_cast.wast',  # Requires host references to not be externalized i31refs
     'ref_test.wast',  # Requires host references to not be externalized i31refs
     'struct.wast',    # Fails to roundtrip unnamed types e.g. `(ref 0)`

src/binaryen-c.cpp

@@ -5336,8 +5336,10 @@ BinaryenTableRef BinaryenAddTable(BinaryenModuleRef module,
                                   const char* name,
                                   BinaryenIndex initial,
                                   BinaryenIndex maximum,
-                                  BinaryenType tableType) {
+                                  BinaryenType tableType,
+                                  BinaryenExpressionRef init) {
   auto table = Builder::makeTable(name, Type(tableType), initial, maximum);
+  table->init = init;
   table->hasExplicitName = true;
   return ((Module*)module)->addTable(std::move(table));
 }

src/binaryen-c.h

@@ -2932,7 +2932,8 @@ BINARYEN_API BinaryenTableRef BinaryenAddTable(BinaryenModuleRef module,
                                                const char* table,
                                                BinaryenIndex initial,
                                                BinaryenIndex maximum,
-                                               BinaryenType tableType);
+                                               BinaryenType tableType,
+                                               BinaryenExpressionRef init);
 BINARYEN_API void BinaryenRemoveTable(BinaryenModuleRef module,
                                       const char* table);
 BINARYEN_API BinaryenIndex BinaryenGetNumTables(BinaryenModuleRef module);

src/ir/subtype-exprs.h

@@ -108,6 +108,11 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
       self()->noteSubtype(global->init, global->type);
     }
   }
+  void visitTable(Table* table) {
+    if (table->init) {
+      self()->noteSubtype(table->init, table->type);
+    }
+  }
   void visitElementSegment(ElementSegment* seg) {
     if (seg->offset) {
       self()->noteSubtype(seg->type,

src/js/binaryen.js-post.js

@@ -2613,8 +2613,8 @@ function wrapModule(module, self = {}) {
   self['getGlobal'] = function(name) {
     return preserveStack(() => Module['_BinaryenGetGlobal'](module, strToStack(name)));
   };
-  self['addTable'] = function(table, initial, maximum, type = Module['_BinaryenTypeFuncref']()) {
-    return preserveStack(() => Module['_BinaryenAddTable'](module, strToStack(table), initial, maximum, type));
+  self['addTable'] = function(table, initial, maximum, type = Module['_BinaryenTypeFuncref'](), init = null) {
+    return preserveStack(() => Module['_BinaryenAddTable'](module, strToStack(table), initial, maximum, type, init));
   }
   self['getTable'] = function(name) {
     return preserveStack(() => Module['_BinaryenGetTable'](module, strToStack(name)));

src/parser/context-decls.cpp

@@ -108,6 +108,7 @@ Result<> ParseDeclsCtx::addTable(Name name,
                                  const std::vector<Name>& exports,
                                  ImportNames* import,
                                  TableType type,
+                                 std::optional<ExprT>,
                                  Index pos) {
   CHECK_ERR(checkImport(pos, import));
   auto t = addTableDecl(pos, name, import, type);

src/parser/context-defs.cpp

@@ -62,6 +62,18 @@ Result<> ParseDefsCtx::addGlobal(Name,
   return Ok{};
 }
 
+Result<> ParseDefsCtx::addTable(Name,
+                                const std::vector<Name>&,
+                                ImportNames*,
+                                TableTypeT,
+                                std::optional<ExprT> init,
+                                Index) {
+  if (init) {
+    wasm.tables[index]->init = *init;
+  }
+  return Ok{};
+}
+
 Result<> ParseDefsCtx::addImplicitElems(Type,
                                         std::vector<Expression*>&& elems) {
   auto& e = wasm.elementSegments[implicitElemIndices.at(index)];

src/parser/contexts.h

@@ -1120,8 +1120,12 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
                               Name name,
                               ImportNames* importNames,
                               TableType limits);
-  Result<>
-  addTable(Name, const std::vector<Name>&, ImportNames*, TableType, Index);
+  Result<> addTable(Name,
+                    const std::vector<Name>&,
+                    ImportNames*,
+                    TableType,
+                    std::optional<ExprT>,
+                    Index);
 
   // TODO: Record index of implicit elem for use when parsing types and instrs.
   Result<> addImplicitElems(TypeT, ElemListT&& elems);
@@ -1512,8 +1516,12 @@ struct ParseModuleTypesCtx : TypeParserCtx<ParseModuleTypesCtx>,
     return Ok{};
   }
 
-  Result<> addTable(
-    Name, const std::vector<Name>&, ImportNames*, Type ttype, Index pos) {
+  Result<> addTable(Name,
+                    const std::vector<Name>&,
+                    ImportNames*,
+                    Type ttype,
+                    std::optional<ExprT> init,
+                    Index pos) {
     auto& t = wasm.tables[index];
     if (!ttype.isRef()) {
       return in.err(pos, "expected reference type");
@@ -1877,10 +1885,12 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return Ok{};
   }
 
-  Result<>
-  addTable(Name, const std::vector<Name>&, ImportNames*, TableTypeT, Index) {
-    return Ok{};
-  }
+  Result<> addTable(Name,
+                    const std::vector<Name>&,
+                    ImportNames*,
+                    TableTypeT,
+                    std::optional<ExprT>,
+                    Index);
 
   Result<>
   addMemory(Name, const std::vector<Name>&, ImportNames*, TableTypeT, Index) {

src/parser/parsers.h

@@ -3411,7 +3411,8 @@ template<typename Ctx> MaybeResult<> import_(Ctx& ctx) {
     auto name = ctx.in.takeID();
     auto type = tabletype(ctx);
     CHECK_ERR(type);
-    CHECK_ERR(ctx.addTable(name ? *name : Name{}, {}, &names, *type, pos));
+    CHECK_ERR(ctx.addTable(
+      name ? *name : Name{}, {}, &names, *type, std::nullopt, pos));
   } else if (ctx.in.takeSExprStart("memory"sv)) {
     auto name = ctx.in.takeID();
     auto type = memtype(ctx);
@@ -3504,7 +3505,11 @@ template<typename Ctx> MaybeResult<> func(Ctx& ctx) {
 }
 
 // table ::= '(' 'table' id? ('(' 'export' name ')')*
-//               '(' 'import' mod:name nm:name ')'? index_type? tabletype ')'
+//               index_type? tabletype expr?
+//               ')'
+//         | '(' 'table' id? ('(' 'export' name ')')*
+//               '(' 'import' mod:name nm:name ')' index_type? tabletype
+//               ')'
 //         | '(' 'table' id? ('(' 'export' name ')')* index_type?
 //               reftype '(' 'elem' (elemexpr* | funcidx*) ')' ')'
 template<typename Ctx> MaybeResult<> table(Ctx& ctx) {
@@ -3537,6 +3542,7 @@ template<typename Ctx> MaybeResult<> table(Ctx& ctx) {
 
   std::optional<typename Ctx::TableTypeT> ttype;
   std::optional<typename Ctx::ElemListT> elems;
+  std::optional<typename Ctx::ExprT> init;
   if (type) {
     // We should have inline elements.
     if (!ctx.in.takeSExprStart("elem"sv)) {
@@ -3571,13 +3577,19 @@ template<typename Ctx> MaybeResult<> table(Ctx& ctx) {
     auto tabtype = tabletypeContinued(ctx, addressType);
     CHECK_ERR(tabtype);
     ttype = *tabtype;
+    if (ctx.in.peekLParen() && !import) {
+      // imported tables cannot have initialization expression
+      auto e = expr(ctx);
+      CHECK_ERR(e);
+      init = *e;
+    }
   }
 
   if (!ctx.in.takeRParen()) {
     return ctx.in.err("expected end of table declaration");
   }
 
-  CHECK_ERR(ctx.addTable(name, *exports, import.getPtr(), *ttype, pos));
+  CHECK_ERR(ctx.addTable(name, *exports, import.getPtr(), *ttype, init, pos));
 
   if (elems) {
     CHECK_ERR(ctx.addImplicitElems(*type, std::move(*elems)));

src/passes/Print.cpp

@@ -3409,7 +3409,12 @@ void PrintSExpression::printTableHeader(Table* curr) {
     o << ' ' << curr->max;
   }
   o << ' ';
-  printType(curr->type) << ')';
+  printType(curr->type);
+  if (curr->init) {
+    o << ' ';
+    visit(curr->init);
+  }
+  o << ')';
 }
 
 void PrintSExpression::visitTable(Table* curr) {

src/passes/RemoveUnusedModuleElements.cpp

@@ -538,14 +538,19 @@ struct Analyzer {
               }
             });
           break;
-        case ModuleElementKind::Table:
+        case ModuleElementKind::Table: {
           ModuleUtils::iterTableSegments(
             *module, value, [&](ElementSegment* segment) {
               if (!segment->data.empty()) {
                 use({ModuleElementKind::ElementSegment, segment->name});
               }
             });
+          auto* table = module->getTable(value);
+          if (table->init) {
+            use(table->init);
+          }
           break;
+        }
         case ModuleElementKind::DataSegment: {
           auto* segment = module->getDataSegment(value);
           if (segment->offset) {
@@ -759,6 +764,13 @@ struct Analyzer {
       for (auto* item : segment->data) {
         addReferences(item);
       }
+    } else if (kind == ModuleElementKind::Table) {
+      auto* table = module->getTable(value);
+      if (table->init) {
+        // TODO: might be possible to remove the init expression if the type is
+        // nullable
+        addReferences(table->init);
+      }
     }
   }
 };

src/passes/Unsubtyping.cpp

@@ -820,6 +820,9 @@ struct Unsubtyping : Pass, Noter<Unsubtyping> {
     for (auto& global : wasm.globals) {
       collector.visitGlobal(global.get());
     }
+    for (auto& table : wasm.tables) {
+      collector.visitTable(table.get());
+    }
     for (auto& segment : wasm.elementSegments) {
       collector.visitElementSegment(segment.get());
     }

src/tools/fuzzing/fuzzing.cpp

@@ -619,12 +619,17 @@ void TranslateToFuzzReader::setupTables() {
     if (wasm.features.hasMemory64() && oneIn(2)) {
       addressType = Type::i64;
     }
+    Expression* init = nullptr;
+    if (wasm.features.hasGC() && oneIn(2)) {
+      init = builder.makeConstantExpression(Literal::makeNull(HeapType::func));
+    }
     auto tablePtr =
       builder.makeTable(Names::getValidTableName(wasm, "fuzzing_table"),
                         funcref,
                         initial,
                         max,
-                        addressType);
+                        addressType,
+                        init);
     tablePtr->hasExplicitName = true;
     table = wasm.addTable(std::move(tablePtr));
   }
@@ -928,6 +933,22 @@ void TranslateToFuzzReader::finalizeTable() {
         table->initial = std::max(table->initial, maxOffset);
       });
 
+    if (table->init) {
+      bool hasNonImported = false;
+      for ([[maybe_unused]] auto* get : FindAll<GlobalGet>(table->init).list) {
+        if (!wasm.getGlobal(get->name)->imported()) {
+          hasNonImported = true;
+          break;
+        }
+      }
+      if (hasNonImported) {
+        // table initializers can't reference module-defined globals.
+        // TODO: use makeConst if it can be made to work without crashing?
+        table->type = table->type.with(Nullable);
+        table->init = builder.makeRefNull(table->type.getHeapType());
+      }
+    }
+
     // The code above raises table->initial to a size large enough to accomodate
     // all of its segments, with the intention of avoiding a trap during
     // startup. However a single segment of (say) size 4GB would have a table of
@@ -949,6 +970,13 @@ void TranslateToFuzzReader::finalizeTable() {
     if (!preserveImportsAndExports) {
       // Avoid an imported table (which the fuzz harness would need to handle).
       table->module = table->base = Name();
+      if (table->type.isNonNullable()) {
+        // imported tables can have nullable types without an initializer,
+        // but this is not the case for module-defined tables, so make it
+        // nullable.
+        // TODO: use makeConst to provide an initializer of the correct type?
+        table->type = table->type.with(Nullable);
+      }
     }
   }
 }

src/wasm-binary.h

@@ -362,6 +362,9 @@ constexpr uint32_t ExactImport = 1 << 5;
 constexpr uint32_t HasMemoryOrderMask = 1 << 5;
 constexpr uint32_t HasMemoryIndexMask = 1 << 6;
 
+constexpr uint8_t HasTableInitializer = 0x40;
+constexpr uint8_t TableReservedByte = 0x00;
+
 enum EncodedType {
   // value types
   i32 = -0x1,  // 0x7f

src/wasm-builder.h

@@ -107,13 +107,15 @@ class Builder {
                                                            Nullable),
                                           Address initial = 0,
                                           Address max = Table::kMaxSize,
-                                          Type addressType = Type::i32) {
+                                          Type addressType = Type::i32,
+                                          Expression* init = nullptr) {
     auto table = std::make_unique<Table>();
     table->name = name;
     table->type = type;
     table->addressType = addressType;
     table->initial = initial;
     table->max = max;
+    table->init = init;
     return table;
   }
 

src/wasm-interpreter.h

@@ -3559,12 +3559,17 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
         // parsing/validation checked this already.
         assert(inserted && "Unexpected repeated table name");
       } else {
-        assert(table->type.isNullable() &&
-               "We only support nullable tables today");
-
-        auto null = Literal::makeNull(table->type.getHeapType());
+        Literal initVal;
+        if (table->init) {
+          initVal =
+            ExpressionRunner<SubType>::visit(table->init).getSingleValue();
+        } else {
+          assert(table->type.isNullable() &&
+                 "Non-nullable table must have an init expressions");
+          initVal = Literal::makeNull(table->type.getHeapType());
+        }
         auto& runtimeTable =
-          definedTables.emplace_back(createTable(null, *table));
+          definedTables.emplace_back(createTable(initVal, *table));
         [[maybe_unused]] auto [_, inserted] =
           allTables.try_emplace(table->name, runtimeTable.get());
         assert(inserted && "Unexpected repeated table name");