Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Address assertion failure in the types fixup(): Dedup A TypeId that appears in multiple rec groups' member sets. (#12900)

Khagan (Khan) Karimov7e5d864393e9
diff --git a/crates/fuzzing/src/generators/gc_ops/types.rs b/crates/fuzzing/src/generators/gc_ops/types.rs
index 6917be0b6c..ce7ca24328 100644
--- a/crates/fuzzing/src/generators/gc_ops/types.rs
+++ b/crates/fuzzing/src/generators/gc_ops/types.rs
@@ -124,7 +124,7 @@ impl Types {
usize::try_from(limits.max_rec_groups).expect("max_rec_groups is too large");
let max_types = usize::try_from(limits.max_types).expect("max_types is too large");
- // 1. Trim excess types and remove them from rec group member sets, i.e.
+ // 1. Trim excess types.
while self.type_defs.len() > max_types {
if let Some((tid, _)) = self.type_defs.pop_last() {
for members in self.rec_groups.values_mut() {
@@ -133,42 +133,35 @@ impl Types {
}
}
- // 2. Drop dangling member set entries that reference types that do not exist.
+ // 2. Drop dangling references and deduplicate across groups.
+ let mut seen = BTreeSet::new();
for members in self.rec_groups.values_mut() {
- members.retain(|tid| self.type_defs.contains_key(tid));
+ members.retain(|tid| self.type_defs.contains_key(tid) && seen.insert(*tid));
}
- // 3. Trim excess rec groups and collect their members as orphans.
- let mut rec_group_orphans = BTreeSet::new();
+ // 3. Trim excess rec groups.
while self.rec_groups.len() > max_rec_groups {
- if let Some((_gid, members)) = self.rec_groups.pop_last() {
- rec_group_orphans.extend(members);
- }
- }
-
- // 4. Find corruption orphans that are not in any group.
- let mut all_members = BTreeSet::new();
- for members in self.rec_groups.values() {
- all_members.extend(members.iter().copied());
+ self.rec_groups.pop_last();
}
- // Exclude rec_group_orphans that are already accounted for in the step 3.
- let corruption_orphans: BTreeSet<TypeId> = self
+ // 4. Find all orphans (from trimmed groups or never in any group).
+ let housed: BTreeSet<TypeId> = self
+ .rec_groups
+ .values()
+ .flat_map(|m| m.iter().copied())
+ .collect();
+ let orphans: Vec<TypeId> = self
.type_defs
.keys()
- .filter(|tid| !all_members.contains(tid) && !rec_group_orphans.contains(tid))
+ .filter(|tid| !housed.contains(tid))
.copied()
.collect();
- // 5. Adopt into the first rec group: corruption orphans first,
- // then rec group orphans. Both are already within max_types from step 1.
- if let Some(gid) = self.rec_groups.keys().next().copied() {
- let members = self.rec_groups.get_mut(&gid).unwrap();
- members.extend(corruption_orphans);
- members.extend(rec_group_orphans);
+ // 5. Adopt orphans or drop them.
+ if let Some(first_members) = self.rec_groups.values_mut().next() {
+ first_members.extend(orphans);
} else {
- // No rec groups at all — drop everything.
- for tid in corruption_orphans.iter().chain(rec_group_orphans.iter()) {
+ for tid in &orphans {
self.type_defs.remove(tid);
}
}
@@ -184,24 +177,32 @@ impl Types {
if self.rec_groups.len()
> usize::try_from(limits.max_rec_groups).expect("max_rec_groups is too large")
{
+ log::debug!("[-] Failed: rec_groups.len() > max_rec_groups");
return false;
}
if self.type_defs.len() > usize::try_from(limits.max_types).expect("max_types is too large")
{
+ log::debug!("[-] Failed: type_defs.len() > max_types");
return false;
}
let mut all = BTreeSet::new();
for members in self.rec_groups.values() {
for tid in members {
if !self.type_defs.contains_key(tid) {
+ log::debug!("[-] Failed: type_defs.contains_key(tid) is false");
return false;
}
if !all.insert(*tid) {
+ log::debug!("[-] Failed: all.insert(tid) is false");
return false;
}
}
}
- self.type_defs.keys().all(|tid| all.contains(tid))
+ if !self.type_defs.keys().all(|tid| all.contains(tid)) {
+ log::debug!("[-] Failed: type_defs.keys().all(|tid| all.contains(tid)) is false");
+ return false;
+ }
+ true
}
}