WIP fixing lit test

Author: stevenfontanella

src/ir/import-utils.h

@@ -138,6 +138,8 @@ class ImportResolver {
   virtual RuntimeTable* getTableOrNull(ImportNames name,
                                        const Table& type) const = 0;
 
+  // TODO: this should probably be a const Tag
+  // or maybe the member in the tag should be const.
   virtual Tag* getTagOrNull(ImportNames name, const Signature& type) const = 0;
 };
 

src/tools/execution-results.h

@@ -25,6 +25,31 @@ namespace wasm {
 
 using Loggings = std::vector<Literal>;
 
+const Tag& getWasmTag() {
+  static const Tag tag = []() {
+    Tag tag;
+    tag.module = "fuzzing-support";
+    tag.base = "wasmtag";
+    tag.name = "imported-wasm-tag";
+    tag.type = Signature(Type::i32, Type::none);
+
+    return tag;
+  }();
+  return tag;
+}
+
+const Tag& getJsTag() {
+  static const Tag tag = []() {
+    Tag tag;
+    tag.module = "fuzzing-support";
+    tag.base = "jstag";
+    tag.name = "imported-js-tag";
+    tag.type = Signature(Type(HeapType::ext, Nullable), Type::none);
+    return tag;
+  }();
+  return tag;
+}
+
 // Logs every relevant import call parameter.
 struct LoggingExternalInterface : public ShellExternalInterface {
 private:
@@ -290,6 +315,27 @@ struct LoggingExternalInterface : public ShellExternalInterface {
   void setModuleRunner(ModuleRunner* instance_) { instance = instance_; }
 };
 
+class FuzzerImportResolver
+  : public LinkedInstancesImportResolver<ModuleRunner> {
+  using LinkedInstancesImportResolver::LinkedInstancesImportResolver;
+  Tag* getTagOrNull(ImportNames name, const Signature& type) const override {
+    if (name.module != "fuzzing-support") {
+      return nullptr;
+    }
+    if (name.name == "wasmtag") {
+      return &wasmTag;
+    }
+    if (name.name == "jstag") {
+      return &jsTag;
+    }
+    return nullptr;
+  }
+
+private:
+  mutable Tag wasmTag = getWasmTag();
+  mutable Tag jsTag = getJsTag();
+};
+
 // gets execution results from a wasm module. this is useful for fuzzing
 //
 // we can only get results when there are no imports. we then call each method
@@ -310,7 +356,11 @@ struct ExecutionResults {
     try {
       // Instantiate the first module.
       LoggingExternalInterface interface(loggings, wasm);
-      auto instance = std::make_shared<ModuleRunner>(wasm, &interface);
+      // auto a = std::make_shared<FuzzerImportResolver>(std::map<Name,
+      // std::shared_ptr<ModuleRunner>>());
+      auto l = std::map<Name, std::shared_ptr<ModuleRunner>>();
+      auto instance = std::make_shared<ModuleRunner>(
+        wasm, &interface, l, std::make_shared<FuzzerImportResolver>(l));
       instantiate(*instance, interface);
 
       // Instantiate the second, if there is one (we instantiate both before

src/wasm-interpreter.h

@@ -5230,12 +5230,15 @@ class ModuleRunner : public ModuleRunnerBase<ModuleRunner> {
   ModuleRunner(
     Module& wasm,
     ExternalInterface* externalInterface,
-    std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances = {})
+    std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances = {},
+    std::shared_ptr<ImportResolver> importResolver = nullptr)
     : ModuleRunnerBase(
         wasm,
         externalInterface,
-        std::make_shared<LinkedInstancesImportResolver<ModuleRunner>>(
-          linkedInstances),
+        importResolver
+          ? importResolver
+          : std::make_shared<LinkedInstancesImportResolver<ModuleRunner>>(
+              linkedInstances),
         linkedInstances) {}
 
   Literal makeFuncData(Name name, Type type) {