[Parser] Fix Table64 parsing (#7298)

We had some hardcoded i32 indexes, but the table might be table64.

Also fix some IRBuilder calls of ChildTyper, that now need to know
the table name.

Author: kripken

src/ir/child-typer.h

@@ -81,6 +81,10 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(ptrp, wasm.getMemory(mem)->addressType);
   }
 
+  void noteTableIndex(Expression** indexp, Name table) {
+    note(indexp, wasm.getTable(table)->addressType);
+  }
+
   void noteAny(Expression** childp) { self().noteAnyType(childp); }
 
   void noteAnyReference(Expression** childp) {
@@ -746,35 +750,43 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->right, eqref);
   }
 
-  void visitTableGet(TableGet* curr) { note(&curr->index, Type::i32); }
+  void visitTableGet(TableGet* curr) {
+    noteTableIndex(&curr->index, curr->table);
+  }
 
   void visitTableSet(TableSet* curr) {
-    note(&curr->index, Type::i32);
+    noteTableIndex(&curr->index, curr->table);
     note(&curr->value, wasm.getTable(curr->table)->type);
   }
 
   void visitTableSize(TableSize* curr) {}
 
   void visitTableGrow(TableGrow* curr) {
     note(&curr->value, wasm.getTable(curr->table)->type);
-    note(&curr->delta, Type::i32);
+    noteTableIndex(&curr->delta, curr->table);
   }
 
   void visitTableFill(TableFill* curr) {
     auto type = wasm.getTable(curr->table)->type;
-    note(&curr->dest, Type::i32);
+    noteTableIndex(&curr->dest, curr->table);
     note(&curr->value, type);
-    note(&curr->size, Type::i32);
+    noteTableIndex(&curr->size, curr->table);
   }
 
   void visitTableCopy(TableCopy* curr) {
-    note(&curr->dest, Type::i32);
-    note(&curr->source, Type::i32);
-    note(&curr->size, Type::i32);
+    noteTableIndex(&curr->dest, curr->destTable);
+    noteTableIndex(&curr->source, curr->sourceTable);
+
+    // The size depends on both dest and source.
+    auto* sourceTable = wasm.getTable(curr->sourceTable);
+    auto* destTable = wasm.getTable(curr->destTable);
+    Type sizeType =
+      sourceTable->is64() && destTable->is64() ? Type::i64 : Type::i32;
+    note(&curr->size, sizeType);
   }
 
   void visitTableInit(TableInit* curr) {
-    note(&curr->dest, wasm.getTable(curr->table)->addressType);
+    noteTableIndex(&curr->dest, curr->table);
     note(&curr->offset, Type::i32);
     note(&curr->size, Type::i32);
   }

src/wasm/wasm-ir-builder.cpp

@@ -1769,6 +1769,7 @@ Result<> IRBuilder::makeRefEq() {
 
 Result<> IRBuilder::makeTableGet(Name table) {
   TableGet curr;
+  curr.table = table;
   CHECK_ERR(visitTableGet(&curr));
   auto type = wasm.getTable(table)->type;
   push(builder.makeTableGet(table, curr.index, type));
@@ -1806,6 +1807,8 @@ Result<> IRBuilder::makeTableFill(Name table) {
 
 Result<> IRBuilder::makeTableCopy(Name destTable, Name srcTable) {
   TableCopy curr;
+  curr.destTable = destTable;
+  curr.sourceTable = srcTable;
   CHECK_ERR(visitTableCopy(&curr));
   push(builder.makeTableCopy(
     curr.dest, curr.source, curr.size, destTable, srcTable));

test/lit/passes/roundtrip-table.wast

@@ -1,11 +1,47 @@
-;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
-;; RUN: wasm-opt %s -all --roundtrip -S -o -
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+;; RUN: wasm-opt %s -all --roundtrip -S -o - | filecheck %s
 
 (module
+ ;; CHECK:      (type $functype (func))
  (type $functype (func))
- (table $0 48 funcref)
+
+ ;; CHECK:      (table $table 48 funcref)
+ (table $table 48 funcref)
+ ;; CHECK:      (table $table64 i64 96 funcref)
+ (table $table64 i64 96 funcref)
+
  ;; a type that appears in the table and nowhere else. this test checks that
  ;; we do not crash during the roundtrip on seeing an unexpected type that
  ;; collectHeapTypes() did not scan.
- (elem (table $0) (i32.const 0) funcref (ref.null $functype))
+ (elem (table $table) (i32.const 0) funcref (ref.null $functype))
+
+ ;; CHECK:      (elem $0 (table $table) (i32.const 0) funcref (item (ref.null nofunc)))
+
+ ;; CHECK:      (func $set (type $functype)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (i64.const 0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (i32.const 0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (table.set $table64
+ ;; CHECK-NEXT:   (unreachable)
+ ;; CHECK-NEXT:   (unreachable)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $set
+  (table.set $table64
+   (i64.const 0)
+   (block (result funcref)
+    ;; This unreachable code must not confuse the parser. Specifically the
+    ;; index should not be replaced with the i32, which would not validate.
+    (i32.lt_u
+     (i32.const 0)
+     (unreachable)
+    )
+    (ref.null nofunc)
+   )
+  )
+ )
 )
+