wip

Author: stevenfontanella

src/ir/import-name.h src/ir/import-names.hsrc/ir/import-name.h renamed to src/ir/import-names.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef wasm_ir_import_name_h
-#define wasm_ir_import_name_h
+#ifndef wasm_ir_import_names_h
+#define wasm_ir_import_names_h
 
 #include <ostream>
 
@@ -47,4 +47,4 @@ template<> struct hash<wasm::ImportNames> {
 
 } // namespace std
 
-#endif // wasm_ir_import_name_h
+#endif // wasm_ir_import_names_h

src/ir/import-utils.h

@@ -17,7 +17,7 @@
 #ifndef wasm_ir_import_h
 #define wasm_ir_import_h
 
-#include "ir/import-name.h"
+#include "ir/import-names.h"
 #include "ir/runtime-table.h"
 #include "literal.h"
 #include "wasm.h"

src/tools/wasm-ctor-eval.cpp

@@ -68,40 +68,6 @@ bool isNullableAndMutable(Expression* ref, Index fieldIndex) {
 // the output.
 #define RECOMMENDATION "\n       recommendation: "
 
-class EvallingImportResolver : public ImportResolver {
-public:
-  EvallingImportResolver() : stubLiteral({Literal(0)}) {};
-
-  // Return an unused stub value. We throw FailToEvalException on reading any
-  // imported globals. We ignore the type and return an i32 literal since some
-  // types can't be created anyway (e.g. ref none).
-  Literals* getGlobalOrNull(ImportNames name, Type type) const override {
-    return &stubLiteral;
-  }
-
-  RuntimeTable* getTableOrNull(ImportNames name,
-                               const Table& type) const override {
-    throw FailToEvalException{"Imported table access."};
-  }
-
-  // We assume that each tag import is distinct. This is wrong if the same tag
-  // instantiation is imported twice with different import names.
-  Tag* getTagOrNull(ImportNames name,
-                    const Signature& signature) const override {
-    auto [it, inserted] = importedTags.try_emplace(name, Tag{});
-    if (inserted) {
-      auto& tag = it->second;
-      tag.type = HeapType(signature);
-    }
-
-    return &it->second;
-  }
-
-private:
-  mutable Literals stubLiteral;
-  mutable std::unordered_map<ImportNames, Tag> importedTags;
-};
-
 class EvallingRuntimeTable : public RuntimeTable {
 public:
   // TODO: putting EvallingModuleRunner into its own header would allow us to
@@ -180,6 +146,53 @@ class EvallingRuntimeTable : public RuntimeTable {
   const std::function<Literal(Name, Type)> makeFuncData;
 };
 
+class EvallingImportResolver : public ImportResolver {
+public:
+  EvallingImportResolver(const bool& instanceInitialized,
+                         const Module& wasm,
+                         std::function<Literal(Name, Type)> makeFuncData)
+    : stubLiteral({Literal(0)}), instanceInitialized(instanceInitialized),
+      wasm(wasm), makeFuncData(makeFuncData) {};
+
+  // Return an unused stub value. We throw FailToEvalException on reading any
+  // imported globals. We ignore the type and return an i32 literal since some
+  // types can't be created anyway (e.g. ref none).
+  Literals* getGlobalOrNull(ImportNames name, Type type) const override {
+    return &stubLiteral;
+  }
+
+  RuntimeTable* getTableOrNull(ImportNames name,
+                               const Table& type) const override {
+    auto [it, inserted] =
+      tables.emplace(name,
+                     std::make_unique<EvallingRuntimeTable>(
+                       type, instanceInitialized, wasm, makeFuncData));
+    return it->second.get();
+  }
+
+  // We assume that each tag import is distinct. This is wrong if the same tag
+  // instantiation is imported twice with different import names.
+  Tag* getTagOrNull(ImportNames name,
+                    const Signature& signature) const override {
+    auto [it, inserted] = importedTags.try_emplace(name, Tag{});
+    if (inserted) {
+      auto& tag = it->second;
+      tag.type = HeapType(signature);
+    }
+
+    return &it->second;
+  }
+
+private:
+  mutable Literals stubLiteral;
+  mutable std::unordered_map<ImportNames, std::unique_ptr<EvallingRuntimeTable>>
+    tables;
+  const bool& instanceInitialized;
+  const Module& wasm;
+  const std::function<Literal(Name, Type)> makeFuncData;
+  mutable std::unordered_map<ImportNames, Tag> importedTags;
+};
+
 class EvallingModuleRunner : public ModuleRunnerBase<EvallingModuleRunner> {
 public:
   EvallingModuleRunner(
@@ -190,17 +203,11 @@ class EvallingModuleRunner : public ModuleRunnerBase<EvallingModuleRunner> {
     : ModuleRunnerBase(
         wasm,
         externalInterface,
-        std::make_shared<EvallingImportResolver>(),
-        linkedInstances_,
-        // TODO: Only use EvallingRuntimeTable for table imports. We can use
-        // RealRuntimeTable for non-imported tables.
-        [this, &instanceInitialized](Literal initial, Table table) {
-          return std::make_unique<EvallingRuntimeTable>(
-            table,
-            instanceInitialized,
-            this->wasm,
-            [this](Name name, Type type) { return makeFuncData(name, type); });
-        }) {}
+        std::make_shared<EvallingImportResolver>(
+          instanceInitialized,
+          wasm,
+          [this](Name name, Type type) { return makeFuncData(name, type); }),
+        linkedInstances_) {}
 
   Flow visitGlobalGet(GlobalGet* curr) {
     // Error on reads of imported globals.
@@ -1166,6 +1173,10 @@ EvalCtorOutcome evalCtor(EvallingModuleRunner& instance,
           std::cout << "  ...stopping due to non-constant func\n";
         }
         break;
+      } catch (TrapException& trap) {
+        if (!quiet) {
+          std::cout << "  ...stopping due to trap\n";
+        }
       }
 
       if (flow.breakTo == NONCONSTANT_FLOW) {

src/wasm-interpreter.h

@@ -3167,25 +3167,15 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
 
   std::unordered_map<Name, Tag*> allTags;
 
-  using CreateTableFunc = std::unique_ptr<RuntimeTable>(Literal, Table);
-
   ModuleRunnerBase(
     Module& wasm,
     ExternalInterface* externalInterface,
     std::shared_ptr<ImportResolver> importResolver,
-    std::map<Name, std::shared_ptr<SubType>> linkedInstances_ = {},
-    std::function<CreateTableFunc> createTable = {})
+    std::map<Name, std::shared_ptr<SubType>> linkedInstances_ = {})
     : ExpressionRunner<SubType>(&wasm), wasm(wasm),
       externalInterface(externalInterface),
       linkedInstances(std::move(linkedInstances_)),
-      importResolver(std::move(importResolver)),
-      createTable(
-        createTable != nullptr
-          ? std::move(createTable)
-          : static_cast<std::function<CreateTableFunc>>(
-              [](Literal initial, Table t) -> std::unique_ptr<RuntimeTable> {
-                return std::make_unique<RealRuntimeTable>(initial, t);
-              })) {
+      importResolver(std::move(importResolver)) {
     // Set up a single shared CurrContinuations for all these linked instances,
     // reusing one if it exists.
     std::shared_ptr<ContinuationStore> shared;
@@ -3523,8 +3513,8 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
                "We only support nullable tables today");
 
         auto null = Literal::makeNull(table->type.getHeapType());
-        auto& runtimeTable =
-          definedTables.emplace_back(createTable(null, *table));
+        auto& runtimeTable = definedTables.emplace_back(
+          std::make_unique<RealRuntimeTable>(null, *table));
         [[maybe_unused]] auto [_, inserted] =
           allTables.try_emplace(table->name, runtimeTable.get());
         assert(inserted && "Unexpected repeated table name");
@@ -5235,7 +5225,6 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   ExternalInterface* externalInterface;
   std::map<Name, std::shared_ptr<SubType>> linkedInstances;
   std::shared_ptr<ImportResolver> importResolver;
-  std::function<CreateTableFunc> createTable;
 };
 
 class ModuleRunner : public ModuleRunnerBase<ModuleRunner> {

src/wasm.h

@@ -33,7 +33,7 @@
 #include <unordered_map>
 #include <vector>
 
-#include "ir/import-name.h"
+#include "ir/import-names.h"
 #include "literal.h"
 #include "support/index.h"
 #include "support/mixed_arena.h"