Fix core dumps for composed components

Signed-off-by: subotac <73706465+subotac@users.noreply.github.com>

Author: subotac

crates/wasmtime/src/runtime/coredump.rs

@@ -1,4 +1,5 @@
 use crate::hash_map::HashMap;
+use crate::hash_set::HashSet;
 use crate::prelude::*;
 use crate::{
     AsContextMut, FrameInfo, Global, HeapType, Instance, Memory, Module, StoreContextMut, Val,
@@ -48,8 +49,27 @@ impl WasmCoreDump {
         let store_memories: Vec<Memory> =
             store.all_memories().filter_map(|m| m.unshared()).collect();
 
-        let mut store_globals: Vec<Global> = vec![];
-        store.for_each_global(|_store, global| store_globals.push(global));
+        let mut store_globals = Vec::new();
+        let mut seen_globals = HashSet::new();
+        store.for_each_global(|store, global| {
+            seen_globals.insert(global.hash_key(store));
+            store_globals.push(global);
+        });
+
+        // Component adapters can import synthetic globals that aren't defined
+        // by a core instance and therefore aren't visited above. Include every
+        // global visible to an instance so serialization can reference it.
+        for instance in &instances {
+            let globals = instance
+                .all_globals(store)
+                .map(|(_, global)| global)
+                .collect::<Vec<_>>();
+            for global in globals {
+                if seen_globals.insert(global.hash_key(store)) {
+                    store_globals.push(global);
+                }
+            }
+        }
 
         WasmCoreDump {
             name: String::from("store_name"),

tests/all/coredump.rs

@@ -293,3 +293,52 @@ fn core_dump_with_shared_memory() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn coredump_with_composed_component_adapters() -> Result<()> {
+    use wasmtime::component::{Component, Linker};
+
+    let mut config = Config::new();
+    config.coredump_on_trap(true);
+    let engine = Engine::new(&config)?;
+    let component = Component::new(
+        &engine,
+        r#"
+            (component
+              (component $A
+                (core module $m
+                  (func (export "f") (param i32) (result i32) unreachable)
+                )
+                (core instance $i (instantiate $m))
+                (func (export "f") (param "x" u32) (result u32)
+                  (canon lift (core func $i "f")))
+              )
+              (component $B
+                (import "f" (func $f (param "x" u32) (result u32)))
+                (core func $fl (canon lower (func $f)))
+                (core module $m
+                  (import "" "f" (func $f (param i32) (result i32)))
+                  (func (export "run") (call $f (i32.const 1)) drop)
+                )
+                (core instance $i (instantiate $m
+                  (with "" (instance (export "f" (func $fl))))))
+                (func (export "run") (canon lift (core func $i "run")))
+              )
+              (instance $a (instantiate $A))
+              (instance $b (instantiate $B (with "f" (func $a "f"))))
+              (func (export "run") (alias export $b "run"))
+            )
+        "#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
+
+    let err = run.call(&mut store, ()).unwrap_err();
+    let coredump = err.downcast_ref::<WasmCoreDump>().unwrap();
+    let bytes = coredump.serialize(&mut store, "composed-component-adapters");
+    wasmparser::Validator::new().validate_all(&bytes)?;
+
+    Ok(())
+}