Validate global imports (#8487)

* Add a RuntimeGlobal class to wrap the global's runtime value as well
as its definition so we can check its type + mutability for import
validation
* Global imports are invariant for mutable globals and covariant for
immutable globals:
<img width="841" height="428" alt="image"
src="https://github.com/user-attachments/assets/748cb719-6de9-4dfd-9719-e4051dc31c45"
/>. Mutability must match as well.
* Fix old_import.wast to account for instantiations which should
correctly fail. This test is now mostly the same as
test/spec/imports.wast, but there are small differences so I plan to
keep it until the upstream testsuite imports.wast passes.


Example error message:

```
[trap Imported global Mref_ex.g-var-func with type: (mut (ref func)) isn't compatible with import declaration: (import "Mref_ex" "g-var-func" (global $gimport$0 (mut funcref)))
]
```

Part of #8261.

Author: stevenfontanella

scripts/test/shared.py

@@ -423,7 +423,7 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'if.wast',      # Requires more precise unreachable validation
     'imports.wast',  # Requires fixing handling of mutation to imported globals
     'proposals/threads/imports.wast',  # Missing memory type validation on instantiation
-    'linking.wast',  # Missing global type validation on instantiation
+    'linking.wast',  # Incorrectly allows covariant subtyping for table imports
     'proposals/threads/memory.wast',  # Missing memory type validation on instantiation
     'annotations.wast',  # String annotations IDs should be allowed
     'instance.wast',  # Requires support for table default elements

src/ir/CMakeLists.txt

@@ -20,6 +20,7 @@ set(ir_SOURCES
   public-type-validator.cpp
   ReFinalize.cpp
   return-utils.cpp
+  runtime-global.cpp
   runtime-table.cpp
   stack-utils.cpp
   table-utils.cpp

src/ir/import-utils.h

@@ -18,6 +18,7 @@
 #define wasm_ir_import_h
 
 #include "ir/import-names.h"
+#include "ir/runtime-global.h"
 #include "ir/runtime-table.h"
 #include "literal.h"
 #include "wasm-type.h"
@@ -130,11 +131,12 @@ class ImportResolver {
 public:
   virtual ~ImportResolver() = default;
 
-  // Returns null if the imported global does not exist. The returned Literals*
-  // lives as long as the ImportResolver instance. Takes name, type, and mut as
-  // parameters because these are parts of the global's externtype that the
-  // environment is allowed to reflect on when providing imports.
-  virtual Literals*
+  // Returns null if the imported global does not exist. The returned
+  // RuntimeGlobal* lives as long as the ImportResolver instance. Takes name,
+  // type, and mut as parameters because these are parts of the global's
+  // externtype that the environment is allowed to reflect on when providing
+  // imports.
+  virtual RuntimeGlobal*
   getGlobalOrNull(ImportNames name, Type type, bool mut) const = 0;
 
   // Returns null if the imported table does not exist. The returned
@@ -153,7 +155,7 @@ class LinkedInstancesImportResolver : public ImportResolver {
     std::map<Name, std::shared_ptr<ModuleRunnerType>> linkedInstances)
     : linkedInstances(std::move(linkedInstances)) {}
 
-  Literals*
+  RuntimeGlobal*
   getGlobalOrNull(ImportNames name, Type type, bool mut) const override {
     auto it = linkedInstances.find(name.module);
     if (it == linkedInstances.end()) {

src/ir/runtime-global.cpp

@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+#include "ir/runtime-global.h"
+
+namespace wasm {
+
+bool RuntimeGlobal::isSubType(const Global& global) const {
+  if (global.mutable_ != (mutable_ == Mutable)) {
+    return false;
+  }
+
+  return global.mutable_ ? global.type == type
+                         : Type::isSubType(type, global.type);
+}
+
+} // namespace wasm

src/ir/runtime-global.h

@@ -0,0 +1,45 @@
+/*
+ * 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_runtime_global_h
+#define wasm_ir_runtime_global_h
+
+#include "literal.h"
+#include "wasm-type.h"
+#include "wasm.h"
+
+namespace wasm {
+
+class RuntimeGlobal {
+public:
+  RuntimeGlobal(Type type, Mutability mutable_, Literals literals = {})
+    : literals(literals), type(type), mutable_(mutable_) {}
+
+  Literals literals;
+
+  Type getType() const { return type; }
+  Mutability getMutable() const { return mutable_; }
+
+  bool isSubType(const Global& global) const;
+
+private:
+  const Type type;
+  const Mutability mutable_;
+};
+
+} // namespace wasm
+
+#endif // wasm_ir_runtime_global_h

src/passes/Print.cpp

@@ -4037,4 +4037,11 @@ std::ostream& operator<<(std::ostream& o, const Table& table) {
   return o;
 }
 
+std::ostream& operator<<(std::ostream& o, const Global& global) {
+  wasm::PrintSExpression printer(o);
+  // TODO: visitGlobal should take a const Global*
+  printer.visitGlobal(const_cast<Global*>(&global));
+  return o;
+}
+
 } // namespace wasm

src/tools/execution-results.h

@@ -373,7 +373,7 @@ class FuzzerImportResolver
 
   // We can synthesize imported externref globals. Use a deque for stable
   // addresses.
-  mutable std::deque<Literals> synthesizedGlobals;
+  mutable std::deque<RuntimeGlobal> synthesizedGlobals;
 
   Tag* getTagOrNull(ImportNames name, const Signature& type) const override {
     if (name.module == "fuzzing-support") {
@@ -388,7 +388,7 @@ class FuzzerImportResolver
     return LinkedInstancesImportResolver::getTagOrNull(name, type);
   }
 
-  virtual Literals*
+  virtual RuntimeGlobal*
   getGlobalOrNull(ImportNames name, Type type, bool mut) const override {
     // First look for globals available from linked instances.
     if (auto* global =
@@ -413,7 +413,10 @@ class FuzzerImportResolver
         payload = (payload + static_cast<Index>(c)) % 251;
       }
     }
+
     synthesizedGlobals.emplace_back(
+      type,
+      mut ? Mutable : Immutable,
       Literals{Literal::makeExtern(payload, Unshared)});
     return &synthesizedGlobals.back();
   }
@@ -515,11 +518,11 @@ struct ExecutionResults {
       } else if (exp->kind == ExternalKind::Global) {
         // Log the global's value.
         std::cout << "[fuzz-exec] export " << exp->name << "\n";
-        Literals* value = instance.getExportedGlobalOrNull(exp->name);
-        assert(value);
-        assert(value->size() == 1);
+        RuntimeGlobal* global = instance.getExportedGlobalOrNull(exp->name);
+        assert(global);
+        assert(global->literals.size() == 1);
         std::cout << "[LoggingExternalInterface logging ";
-        printValue((*value)[0]);
+        printValue(global->literals[0]);
         std::cout << "]\n";
       }
       // Ignore other exports for now. TODO

src/tools/wasm-ctor-eval.cpp

@@ -68,14 +68,14 @@ bool isNullableAndMutable(Expression* ref, Index fieldIndex) {
 
 class EvallingImportResolver : public ImportResolver {
 public:
-  EvallingImportResolver() : stubLiteral({Literal(0)}) {};
+  EvallingImportResolver() : stubGlobal(Type::i32, Immutable, {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*
+  RuntimeGlobal*
   getGlobalOrNull(ImportNames name, Type type, bool mut) const override {
-    return &stubLiteral;
+    return &stubGlobal;
   }
 
   RuntimeTable* getTableOrNull(ImportNames name,
@@ -97,7 +97,7 @@ class EvallingImportResolver : public ImportResolver {
   }
 
 private:
-  mutable Literals stubLiteral;
+  mutable RuntimeGlobal stubGlobal;
   mutable std::unordered_map<ImportNames, Tag> importedTags;
 };
 
@@ -565,8 +565,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->allGlobals) {
-        wasm->getGlobal(name)->init = getSerialization(*values);
+      for (const auto& [name, global] : instance->allGlobals) {
+        wasm->getGlobal(name)->init = getSerialization(global->literals);
       }
       return;
     }
@@ -603,7 +603,7 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
       // value when we created it.)
       auto iter = instance->allGlobals.find(oldGlobal->name);
       if (iter != instance->allGlobals.end()) {
-        oldGlobal->init = getSerialization(*iter->second, name);
+        oldGlobal->init = getSerialization(iter->second->literals, name);
       }
 
       // Add the global back to the module.

src/wasm-interpreter.h

@@ -41,6 +41,7 @@
 #include "ir/memory-utils.h"
 #include "ir/module-utils.h"
 #include "ir/properties.h"
+#include "ir/runtime-global.h"
 #include "ir/runtime-table.h"
 #include "ir/table-utils.h"
 #include "support/bits.h"
@@ -3261,7 +3262,7 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   // Keyed by internal name. All globals in the module, including imports.
   // `definedGlobals` contains non-imported globals. Points to `definedGlobals`
   // of this instance and other instances.
-  std::unordered_map<Name, Literals*> allGlobals;
+  std::unordered_map<Name, RuntimeGlobal*> allGlobals;
 
   // Like `allGlobals`. Keyed by internal name. All tables including imports.
   std::unordered_map<Name, RuntimeTable*> allTables;
@@ -3355,7 +3356,7 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
                    func->type);
   }
 
-  Literals* getExportedGlobalOrNull(Name name) {
+  RuntimeGlobal* getExportedGlobalOrNull(Name name) {
     Export* export_ = wasm.getExportOrNull(name);
     if (!export_ || export_->kind != ExternalKind::Global) {
       return nullptr;
@@ -3389,7 +3390,7 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
                                << " not found.")
                                 .str());
     }
-    return *global;
+    return global->literals;
   }
 
   Tag* getExportedTagOrNull(Name name) {
@@ -3429,7 +3430,7 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   // Globals that were defined in this module and not from an import.
   // `allGlobals` contains these values + imported globals, keyed by their
   // internal name.
-  std::vector<Literals> definedGlobals;
+  std::vector<RuntimeGlobal> definedGlobals;
   std::vector<std::unique_ptr<RuntimeTable>> definedTables;
   std::vector<Tag> definedTags;
 
@@ -3539,9 +3540,27 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
                   << (*function)->type.getHeapType().getSignature().toString())
                    .str());
           }
+        } else if (auto** globalDecl = std::get_if<Global*>(&import)) {
+          auto* exportedGlobal =
+            importResolver->getGlobalOrNull(importable->importNames(),
+                                            (*globalDecl)->type,
+                                            (*globalDecl)->mutable_);
+          if (!exportedGlobal->isSubType(**globalDecl)) {
+            trap(
+              (std::stringstream()
+               << "Imported global " << importable->importNames()
+               << " with type: "
+               << (exportedGlobal->getMutable() == Mutability::Mutable ? "(mut "
+                                                                       : "")
+               << exportedGlobal->getType()
+               << (exportedGlobal->getMutable() == Mutability::Mutable ? ")"
+                                                                       : "")
+               << " isn't compatible with import declaration: " << **globalDecl)
+                .str());
+          }
         }
 
-        // TODO: remaining cases e.g. globals and tags.
+        // TODO: remaining cases e.g. tags.
       });
   }
 
@@ -3568,7 +3587,10 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
         assert(inserted && "Unexpected repeated global name");
       } else {
         Literals init = self()->visit(global->init).values;
-        auto& definedGlobal = definedGlobals.emplace_back(std::move(init));
+        auto& definedGlobal =
+          definedGlobals.emplace_back(global->type,
+                                      global->mutable_ ? Mutable : Immutable,
+                                      std::move(init));
 
         [[maybe_unused]] auto [_, inserted] =
           allGlobals.try_emplace(global->name, &definedGlobal);
@@ -4120,13 +4142,13 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
 
   Flow visitGlobalGet(GlobalGet* curr) {
     auto name = curr->name;
-    return *allGlobals.at(name);
+    return allGlobals.at(name)->literals;
   }
   Flow visitGlobalSet(GlobalSet* curr) {
     auto name = curr->name;
     VISIT(flow, curr->value)
 
-    *allGlobals.at(name) = flow.values;
+    allGlobals.at(name)->literals = flow.values;
     return Flow();
   }
 

src/wasm.h

@@ -2774,6 +2774,7 @@ std::ostream& operator<<(std::ostream& o, wasm::ModuleHeapType pair);
 std::ostream& operator<<(std::ostream& os, wasm::MemoryOrder mo);
 std::ostream& operator<<(std::ostream& o, const wasm::ImportNames& importNames);
 std::ostream& operator<<(std::ostream& o, const Table& table);
+std::ostream& operator<<(std::ostream& o, const wasm::Global& global);
 
 } // namespace wasm