Use ImportResolver for table imports

Author: stevenfontanella

src/interpreter/exception.h

@@ -0,0 +1,19 @@
+#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,52 @@
+#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,56 @@
+#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:
+  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 = 0;
+};
+
+class RealRuntimeTable : public RuntimeTable {
+public:
+  RealRuntimeTable(Literal initial, Table table_) : tableMeta_(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(); }
+
+  const Table* tableMeta() const override { return &tableMeta_; }
+
+private:
+  const Table tableMeta_;
+  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());