Use ImportResolver for tag imports

src/ir/import-utils.h

@@ -137,6 +137,8 @@ class ImportResolver {
   // as long as the ImportResolver instance.
   virtual RuntimeTable* getTableOrNull(ImportNames name,
                                        const Table& type) const = 0;
+
+  virtual Tag* getTagOrNull(ImportNames name, const Signature& type) const = 0;
 };
 
 // Looks up imports from the given `linkedInstances`.
@@ -168,6 +170,16 @@ class LinkedInstancesImportResolver : public ImportResolver {
     return instance->getExportedTableOrNull(name.name);
   }
 
+  Tag* getTagOrNull(ImportNames name, const Signature& type) const override {
+    auto it = linkedInstances.find(name.module);
+    if (it == linkedInstances.end()) {
+      return nullptr;
+    }
+
+    ModuleRunnerType* instance = it->second.get();
+    return instance->getExportedTagOrNull(name.name);
+  }
+
 private:
   const std::map<Name, std::shared_ptr<ModuleRunnerType>> linkedInstances;
 };

src/shell-interface.h

@@ -151,10 +151,6 @@ struct ShellExternalInterface : ModuleRunner::ExternalInterface {
     return Literal::makeFunc(import->name, import->type);
   }
 
-  Tag* getImportedTag(Tag* tag) override {
-    WASM_UNREACHABLE("missing imported tag");
-  }
-
   int8_t load8s(Address addr, Name memoryName) override {
     auto it = memories.find(memoryName);
     assert(it != memories.end());

src/tools/execution-results.h

@@ -23,8 +23,37 @@
 
 namespace wasm {
 
+namespace {
+
 using Loggings = std::vector<Literal>;
 
+Tag& getWasmTag() {
+  static 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;
+}
+
+Tag& getJsTag() {
+  static 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;
+}
+
+} // namespace
+
 // Logs every relevant import call parameter.
 struct LoggingExternalInterface : public ShellExternalInterface {
 private:
@@ -43,10 +72,10 @@ struct LoggingExternalInterface : public ShellExternalInterface {
   Module& wasm;
 
   // The imported fuzzing tag for wasm.
-  Tag wasmTag;
+  const Tag& wasmTag;
 
   // The imported tag for js exceptions.
-  Tag jsTag;
+  const Tag& jsTag;
 
   // The ModuleRunner and this ExternalInterface end up needing links both ways,
   // so we cannot init this in the constructor.
@@ -57,34 +86,14 @@ struct LoggingExternalInterface : public ShellExternalInterface {
     Loggings& loggings,
     Module& wasm,
     std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances_ = {})
-    : ShellExternalInterface(linkedInstances_), loggings(loggings), wasm(wasm) {
+    : ShellExternalInterface(linkedInstances_), loggings(loggings), wasm(wasm),
+      wasmTag(getWasmTag()), jsTag(getJsTag()) {
     for (auto& exp : wasm.exports) {
       if (exp->kind == ExternalKind::Table && exp->name == "table") {
         exportedTable = *exp->getInternalName();
         break;
       }
     }
-
-    // Set up tags. (Setting these values is useful for debugging - making the
-    // Tag objects valid - and also appears in fuzz-exec logging.)
-    wasmTag.module = "fuzzing-support";
-    wasmTag.base = "wasmtag";
-    wasmTag.name = "imported-wasm-tag";
-    wasmTag.type = Signature(Type::i32, Type::none);
-
-    jsTag.module = "fuzzing-support";
-    jsTag.base = "jstag";
-    jsTag.name = "imported-js-tag";
-    jsTag.type = Signature(Type(HeapType::ext, Nullable), Type::none);
-  }
-
-  Tag* getImportedTag(Tag* tag) override {
-    for (auto* imported : {&wasmTag, &jsTag}) {
-      if (imported->module == tag->module && imported->base == tag->base) {
-        return imported;
-      }
-    }
-    Fatal() << "missing host tag " << tag->module << '.' << tag->base;
   }
 
   Literal getImportedFunction(Function* import) override {
@@ -299,6 +308,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") {
+      if (name.name == "wasmtag") {
+        return &wasmTag;
+      }
+      if (name.name == "jstag") {
+        return &jsTag;
+      }
+    }
+
+    return LinkedInstancesImportResolver::getTagOrNull(name, type);
+  }
+
+private:
+  Tag& wasmTag = getWasmTag();
+  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
@@ -319,12 +349,19 @@ struct ExecutionResults {
     try {
       // Instantiate the first module.
       LoggingExternalInterface interface(loggings, wasm);
-      auto instance = std::make_shared<ModuleRunner>(wasm, &interface);
+
+      // `linkedInstances` is empty at this point and the below constructors
+      // make copies.
+      std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances;
+      auto instance = std::make_shared<ModuleRunner>(
+        wasm,
+        &interface,
+        linkedInstances,
+        std::make_shared<FuzzerImportResolver>(linkedInstances));
       instantiate(*instance, interface);
 
       // Instantiate the second, if there is one (we instantiate both before
       // running anything, so that we match the behavior of fuzz_shell.js).
-      std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances;
       std::unique_ptr<LoggingExternalInterface> secondInterface;
       std::shared_ptr<ModuleRunner> secondInstance;
       if (second) {

src/tools/wasm-ctor-eval.cpp

@@ -84,6 +84,12 @@ class EvallingImportResolver : public ImportResolver {
     throw FailToEvalException{"Imported table access."};
   }
 
+  Tag* getTagOrNull(ImportNames name,
+                    const Signature& signature) const override {
+    Fatal() << "Not implemented.";
+    return nullptr;
+  }
+
 private:
   mutable Literals stubLiteral;
 };
@@ -393,10 +399,6 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
                    import->type);
   }
 
-  Tag* getImportedTag(Tag* tag) override {
-    WASM_UNREACHABLE("missing imported tag");
-  }
-
   int8_t load8s(Address addr, Name memoryName) override {
     return doLoad<int8_t>(addr, memoryName);
   }