Use ImportResolver for table imports (#8194)

Part of #8180. We currently replicate the existing behavior. In the
future, we can also change ctor-eval to really simulate tables, and only
use the EvallingRuntimeTable in the case of table imports. Removes
existing pointer chasing logic that we repeat for each table operation
(e.g. tableLoad, tableStore).

Allows us to fix spec tests where a table import becomes valid by
resizing it in #8222.

Author: stevenfontanella

src/interpreter/exception.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_interpreter_exception_h
+#define wasm_interpreter_exception_h
+
+namespace wasm {
+
+// An exception emitted when exit() is called.
+struct ExitException {};
+
+// An exception emitted when a wasm trap occurs.
+struct TrapException {};
+
+// An exception emitted when a host limitation is hit. (These are not wasm traps
+// as they are not in the spec; for example, the spec has no limit on how much
+// GC memory may be allocated, but hosts have limits.)
+struct HostLimitException {};
+
+} // namespace wasm
+
+#endif // wasm_interpreter_exception_h

src/ir/CMakeLists.txt

@@ -20,6 +20,7 @@ set(ir_SOURCES
   public-type-validator.cpp
   ReFinalize.cpp
   return-utils.cpp
+  runtime-table.cpp
   stack-utils.cpp
   table-utils.cpp
   type-updating.cpp

src/ir/import-utils.h

@@ -18,6 +18,7 @@
 #define wasm_ir_import_h
 
 #include "ir/import-name.h"
+#include "ir/runtime-table.h"
 #include "literal.h"
 #include "wasm.h"
 
@@ -131,6 +132,11 @@ class ImportResolver {
   // Returns null if the `name` wasn't found. The returned Literals* lives as
   // long as the ImportResolver instance.
   virtual Literals* getGlobalOrNull(ImportNames name, Type type) const = 0;
+
+  // Returns null if the `name` wasn't found. The returned RuntimeTable* lives
+  // as long as the ImportResolver instance.
+  virtual RuntimeTable* getTableOrNull(ImportNames name,
+                                       const Table& type) const = 0;
 };
 
 // Looks up imports from the given `linkedInstances`.
@@ -151,6 +157,17 @@ class LinkedInstancesImportResolver : public ImportResolver {
     return instance->getExportedGlobalOrNull(name.name);
   }
 
+  RuntimeTable* getTableOrNull(ImportNames name,
+                               const Table& type) const override {
+    auto it = linkedInstances.find(name.module);
+    if (it == linkedInstances.end()) {
+      return nullptr;
+    }
+
+    ModuleRunnerType* instance = it->second.get();
+    return instance->getExportedTableOrNull(name.name);
+  }
+
 private:
   const std::map<Name, std::shared_ptr<ModuleRunnerType>> linkedInstances;
 };

src/ir/runtime-table.cpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ir/runtime-table.h"
+#include "interpreter/exception.h"
+#include "support/stdckdint.h"
+#include "wasm-limits.h"
+
+namespace wasm {
+
+namespace {
+
+[[noreturn]] void trap(std::string_view reason) {
+  // Print so lit tests can check this.
+  std::cout << "[trap " << reason << "]\n";
+  throw TrapException{};
+}
+
+} // namespace
+
+void RealRuntimeTable::set(std::size_t i, Literal l) {
+  if (i >= table.size()) {
+    trap("RuntimeTable::set out of bounds");
+    WASM_UNREACHABLE("trapped");
+  }
+
+  table[i] = std::move(l);
+}
+
+Literal RealRuntimeTable::get(std::size_t i) const {
+  if (i >= table.size()) {
+    trap("out of bounds table access");
+    WASM_UNREACHABLE("trapped");
+  }
+
+  return table[i];
+}
+
+std::optional<std::size_t> RealRuntimeTable::grow(std::size_t delta,
+                                                  Literal fill) {
+  std::size_t newSize;
+  if (std::ckd_add(&newSize, table.size(), delta)) {
+    return std::nullopt;
+  }
+
+  if (newSize > WebLimitations::MaxTableSize || newSize > tableMeta_.max) {
+    return std::nullopt;
+  }
+
+  std::size_t oldSize = table.size();
+  table.resize(newSize, fill);
+  return oldSize;
+}
+
+} // namespace wasm

src/ir/runtime-table.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_ir_runtime_table_h
+#define wasm_ir_runtime_table_h
+
+#include <stddef.h>
+#include <vector>
+
+#include "literal.h"
+#include "wasm.h"
+
+namespace wasm {
+
+// Traps on out of bounds access
+class RuntimeTable {
+public:
+  RuntimeTable(Table table) : tableMeta_(table) {}
+  virtual ~RuntimeTable() = default;
+
+  virtual void set(std::size_t i, Literal l) = 0;
+
+  virtual Literal get(std::size_t i) const = 0;
+
+  // Returns nullopt if the table grew beyond the max possible size.
+  [[nodiscard]] virtual std::optional<std::size_t> grow(std::size_t delta,
+                                                        Literal fill) = 0;
+
+  virtual std::size_t size() const = 0;
+
+  virtual const Table* tableMeta() const { return &tableMeta_; }
+
+protected:
+  const Table tableMeta_;
+};
+
+class RealRuntimeTable : public RuntimeTable {
+public:
+  RealRuntimeTable(Literal initial, Table table_) : RuntimeTable(table_) {
+    table.resize(tableMeta_.initial, initial);
+  }
+
+  RealRuntimeTable(const RealRuntimeTable&) = delete;
+  RealRuntimeTable& operator=(const RealRuntimeTable&) = delete;
+
+  void set(std::size_t i, Literal l) override;
+
+  Literal get(std::size_t i) const override;
+
+  std::optional<std::size_t> grow(std::size_t delta, Literal fill) override;
+
+  std::size_t size() const override { return table.size(); }
+
+private:
+  std::vector<Literal> table;
+};
+
+} // namespace wasm
+
+#endif // wasm_ir_runtime_table_h

src/shell-interface.h

@@ -22,6 +22,7 @@
 #define wasm_shell_interface_h
 
 #include "asmjs/shared-constants.h"
+#include "interpreter/exception.h"
 #include "ir/module-utils.h"
 #include "shared-constants.h"
 #include "support/name.h"
@@ -31,17 +32,6 @@
 
 namespace wasm {
 
-// An exception emitted when exit() is called.
-struct ExitException {};
-
-// An exception emitted when a wasm trap occurs.
-struct TrapException {};
-
-// An exception emitted when a host limitation is hit. (These are not wasm traps
-// as they are not in the spec; for example, the spec has no limit on how much
-// GC memory may be allocated, but hosts have limits.)
-struct HostLimitException {};
-
 struct ShellExternalInterface : ModuleRunner::ExternalInterface {
   // The underlying memory can be accessed through unaligned pointers which
   // isn't well-behaved in C++. WebAssembly nonetheless expects it to behave
@@ -93,7 +83,6 @@ struct ShellExternalInterface : ModuleRunner::ExternalInterface {
   };
 
   std::map<Name, Memory> memories;
-  std::unordered_map<Name, std::vector<Literal>> tables;
   std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances;
 
   ShellExternalInterface(
@@ -125,8 +114,6 @@ struct ShellExternalInterface : ModuleRunner::ExternalInterface {
       shellMemory.resize(memory->initial * wasm::Memory::kPageSize);
       memories[memory->name] = shellMemory;
     });
-    ModuleUtils::iterDefinedTables(
-      wasm, [&](Table* table) { tables[table->name].resize(table->initial); });
   }
 
   Literal getImportedFunction(Function* import) override {
@@ -255,35 +242,6 @@ struct ShellExternalInterface : ModuleRunner::ExternalInterface {
     auto& memory = it->second;
     memory.set<std::array<uint8_t, 16>>(addr, value);
   }
-
-  Index tableSize(Name tableName) override {
-    return (Index)tables[tableName].size();
-  }
-
-  void
-  tableStore(Name tableName, Address index, const Literal& entry) override {
-    auto& table = tables[tableName];
-    if (index >= table.size()) {
-      trap("out of bounds table access");
-    } else {
-      table[index] = entry;
-    }
-  }
-
-  Literal tableLoad(Name tableName, Address index) override {
-    auto it = tables.find(tableName);
-    if (it == tables.end()) {
-      trap("tableGet on non-existing table");
-    }
-
-    auto& table = it->second;
-    if (index >= table.size()) {
-      trap("out of bounds table access");
-    }
-
-    return table[index];
-  }
-
   bool
   growMemory(Name memoryName, Address /*oldSize*/, Address newSize) override {
     // Apply a reasonable limit on memory size, 1GB, to avoid DOS on the
@@ -299,20 +257,6 @@ struct ShellExternalInterface : ModuleRunner::ExternalInterface {
     memory.resize(newSize);
     return true;
   }
-
-  bool growTable(Name name,
-                 const Literal& value,
-                 Index /*oldSize*/,
-                 Index newSize) override {
-    // Apply a reasonable limit on table size, 1GB, to avoid DOS on the
-    // interpreter.
-    if (newSize > 1024 * 1024 * 1024) {
-      return false;
-    }
-    tables[name].resize(newSize, value);
-    return true;
-  }
-
   void trap(std::string_view why) override {
     std::cout << "[trap " << why << "]\n";
     throw TrapException();

src/tools/execution-results.h

@@ -142,19 +142,21 @@ struct LoggingExternalInterface : public ShellExternalInterface {
             throwJSException();
           }
           auto index = arguments[0].getUnsigned();
-          if (index >= tables[exportedTable].size()) {
+          auto* table = instance->allTables[exportedTable];
+          if (index >= table->size()) {
             throwJSException();
           }
-          return {tableLoad(exportedTable, index)};
+          return table->get(index);
         } else if (import->base == "table-set") {
           if (!exportedTable) {
             throwJSException();
           }
           auto index = arguments[0].getUnsigned();
-          if (index >= tables[exportedTable].size()) {
+          auto* table = instance->allTables[exportedTable];
+          if (index >= table->size()) {
             throwJSException();
           }
-          tableStore(exportedTable, index, arguments[1]);
+          table->set(index, arguments[1]);
           return {};
         } else if (import->base == "call-export") {
           callExportAsJS(arguments[0].geti32());