Add ImportResolver interface and use it for global imports (#8166)

Add an ImportResolver interface with some implementations to handle the
spec interpreter and ctor-eval

* Removes coupling of imported names from the module they come from.
This will allows us to provide special imports like the spec test module
better which have some 'magic' e.g. for printing functions which can't
be implemented in Wasm (globals remain the same because they still come
from a real module which is better).
* Removes pointer chasing logic when resolving imported globals in both
cases.
* Also allows us to relax ctor-eval and allow programs that import
globals to be optimized more (as long as they don't try to evaluate
imports) #8168
* Fixes #8167
* Part of #8180

Author: stevenfontanella

src/ir/import-name.h

@@ -0,0 +1,33 @@
+/*
+ * 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_import_name_h
+#define wasm_ir_import_name_h
+
+#include <ostream>
+
+#include "support/name.h"
+
+namespace wasm {
+
+struct ImportNames {
+  Name module;
+  Name name;
+};
+
+} // namespace wasm
+
+#endif // wasm_ir_import_name_h

src/ir/import-utils.h

@@ -17,6 +17,7 @@
 #ifndef wasm_ir_import_h
 #define wasm_ir_import_h
 
+#include "ir/import-name.h"
 #include "literal.h"
 #include "wasm.h"
 
@@ -123,6 +124,37 @@ struct ImportInfo {
   Index getNumDefinedTags() { return wasm.tags.size() - getNumImportedTags(); }
 };
 
+class ImportResolver {
+public:
+  virtual ~ImportResolver() = default;
+
+  // 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;
+};
+
+// Looks up imports from the given `linkedInstances`.
+template<typename ModuleRunnerType>
+class LinkedInstancesImportResolver : public ImportResolver {
+public:
+  LinkedInstancesImportResolver(
+    std::map<Name, std::shared_ptr<ModuleRunnerType>> linkedInstances)
+    : linkedInstances(std::move(linkedInstances)) {}
+
+  Literals* getGlobalOrNull(ImportNames name, Type type) const override {
+    auto it = linkedInstances.find(name.module);
+    if (it == linkedInstances.end()) {
+      return nullptr;
+    }
+
+    ModuleRunnerType* instance = it->second.get();
+    return instance->getExportedGlobalOrNull(name.name);
+  }
+
+private:
+  const std::map<Name, std::shared_ptr<ModuleRunnerType>> linkedInstances;
+};
+
 } // namespace wasm
 
 #endif // wasm_ir_import_h

src/passes/Print.cpp

@@ -3944,4 +3944,9 @@ std::ostream& operator<<(std::ostream& o, wasm::ModuleHeapType pair) {
   return o << "(unnamed)";
 }
 
+std::ostream& operator<<(std::ostream& o,
+                         const wasm::ImportNames& importNames) {
+  return o << importNames.module << "." << importNames.name;
+}
+
 } // namespace std

src/shell-interface.h

@@ -129,20 +129,6 @@ struct ShellExternalInterface : ModuleRunner::ExternalInterface {
       wasm, [&](Table* table) { tables[table->name].resize(table->initial); });
   }
 
-  void importGlobals(std::map<Name, Literals>& globals, Module& wasm) override {
-    ModuleUtils::iterImportedGlobals(wasm, [&](Global* import) {
-      auto inst = getImportInstance(import);
-      auto* exportedGlobal = inst->wasm.getExportOrNull(import->base);
-      if (!exportedGlobal || exportedGlobal->kind != ExternalKind::Global) {
-        trap((std::stringstream()
-              << "importGlobals: unknown import: " << import->module.str << "."
-              << import->name.str)
-               .str());
-      }
-      globals[import->name] = inst->globals[*exportedGlobal->getInternalName()];
-    });
-  }
-
   Literal getImportedFunction(Function* import) override {
     // TODO: We should perhaps restrict the types with which the well-known
     // functions can be imported.

src/tools/wasm-ctor-eval.cpp

@@ -67,13 +67,27 @@ bool isNullableAndMutable(Expression* ref, Index fieldIndex) {
 // the output.
 #define RECOMMENDATION "\n       recommendation: "
 
+class EvallingModuleRunner;
+
+class EvallingImportResolver : public ImportResolver {
+public:
+  EvallingImportResolver() = default;
+
+  Literals* getGlobalOrNull(ImportNames name, Type type) const override {
+    throw FailToEvalException("Accessed imported global");
+  }
+};
+
 class EvallingModuleRunner : public ModuleRunnerBase<EvallingModuleRunner> {
 public:
   EvallingModuleRunner(
     Module& wasm,
     ExternalInterface* externalInterface,
     std::map<Name, std::shared_ptr<EvallingModuleRunner>> linkedInstances_ = {})
-    : ModuleRunnerBase(wasm, externalInterface, linkedInstances_) {}
+    : ModuleRunnerBase(wasm,
+                       externalInterface,
+                       std::make_shared<EvallingImportResolver>(),
+                       linkedInstances_) {}
 
   Flow visitGlobalGet(GlobalGet* curr) {
     // Error on reads of imported globals.
@@ -147,19 +161,6 @@ std::unique_ptr<Module> buildEnvModule(Module& wasm) {
     }
   });
 
-  ModuleUtils::iterImportedGlobals(wasm, [&](Global* global) {
-    if (global->module == env->name) {
-      auto* copied = ModuleUtils::copyGlobal(global, *env);
-      copied->module = Name();
-      copied->base = Name();
-
-      Builder builder(*env);
-      copied->init = builder.makeConst(Literal::makeZero(global->type));
-      env->addExport(
-        builder.makeExport(global->base, copied->name, ExternalKind::Global));
-    }
-  });
-
   // create an exported memory with the same initial and max size
   ModuleUtils::iterImportedMemories(wasm, [&](Memory* memory) {
     if (memory->module == env->name) {
@@ -231,26 +232,6 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
     }
   }
 
-  void importGlobals(GlobalValueSet& globals, Module& wasm_) override {
-    ModuleUtils::iterImportedGlobals(wasm_, [&](Global* global) {
-      auto it = linkedInstances.find(global->module);
-      if (it != linkedInstances.end()) {
-        auto* inst = it->second.get();
-        auto* globalExport = inst->wasm.getExportOrNull(global->base);
-        if (!globalExport || globalExport->kind != ExternalKind::Global) {
-          throw FailToEvalException(std::string("importGlobals: ") +
-                                    global->module.toString() + "." +
-                                    global->base.toString());
-        }
-        globals[global->name] = inst->globals[*globalExport->getInternalName()];
-      } else {
-        throw FailToEvalException(std::string("importGlobals: ") +
-                                  global->module.toString() + "." +
-                                  global->base.toString());
-      }
-    });
-  }
-
   Literal getImportedFunction(Function* import) override {
     auto f = [import, this](const Literals& arguments) -> Flow {
       Name WASI("wasi_snapshot_preview1");
@@ -558,8 +539,8 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
   void applyGlobalsToModule() {
     if (!wasm->features.hasGC()) {
       // Without GC, we can simply serialize the globals in place as they are.
-      for (const auto& [name, values] : instance->globals) {
-        wasm->getGlobal(name)->init = getSerialization(values);
+      for (const auto& [name, values] : instance->allGlobals) {
+        wasm->getGlobal(name)->init = getSerialization(*values);
       }
       return;
     }
@@ -590,9 +571,9 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
       // for it. (If there is no value, then this is a new global we've added
       // during execution, for whom we've already set up a proper serialized
       // value when we created it.)
-      auto iter = instance->globals.find(oldGlobal->name);
-      if (iter != instance->globals.end()) {
-        oldGlobal->init = getSerialization(iter->second, name);
+      auto iter = instance->allGlobals.find(oldGlobal->name);
+      if (iter != instance->allGlobals.end()) {
+        oldGlobal->init = getSerialization(*iter->second, name);
       }
 
       // Add the global back to the module.

src/tools/wasm-shell.cpp

@@ -280,7 +280,7 @@ struct Shell {
       }
       auto& instance = it->second;
       try {
-        return instance->getExportedGlobal(get->name);
+        return instance->getExportedGlobalOrTrap(get->name);
       } catch (TrapException&) {
         return TrapResult{};
       } catch (...) {