A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
gc_ops: Mutator update (#12844)
Khagan (Khan) Karimovb1f69c05d50f
diff --git a/Cargo.toml b/Cargo.tomlindex c5bf9a3e01..149480a4eb 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -366,7 +366,7 @@ wasip2 = "1.0"arbitrary = "1.4.2"backtrace = "0.3.75"bumpalo = "3.20.0"-mutatis = "0.3.2"+mutatis = {version = "0.3.2", features = ["alloc"] }cc = "1.2.41"object = { version = "0.38.1", default-features = false, features = ['read_core', 'elf'] }gimli = { version = "0.33.0", default-features = false, features = ['read'] }diff --git a/crates/fuzzing/src/generators/gc_ops/mutator.rs b/crates/fuzzing/src/generators/gc_ops/mutator.rsindex 9ff1761777..7e2f821366 100644--- a/crates/fuzzing/src/generators/gc_ops/mutator.rs+++ b/crates/fuzzing/src/generators/gc_ops/mutator.rs@@ -1,411 +1,407 @@//! Mutators for the `gc` operations.-+use crate::generators::gc_ops::limits::GcOpsLimits;use crate::generators::gc_ops::ops::{GcOp, GcOps};-use crate::generators::gc_ops::types::{RecGroupId, TypeId};-use mutatis::{Candidates, Context, DefaultMutate, Generate, Mutate, Result as MutResult};+use crate::generators::gc_ops::types::{TypeId, Types};+use mutatis::{+ Candidates, Context, DefaultMutate, Generate, Mutate, Result as MutResult, mutators as m,+};use smallvec::SmallVec;-/// A mutator for the gc ops.-#[derive(Debug)]-pub struct GcOpsMutator;+/// Mutator for [`Types`]: handles adding/removing types and all rec-group+/// structural mutations (duplicate, remove, merge, split, move).+#[derive(Debug, Default)]+pub struct TypesMutator;-impl GcOpsMutator {- // Define a mutation that adds an operation to the ops list.- fn add_operation(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {- if c.shrink() {- return Ok(());- }- c.mutation(|ctx| {- if let Some(idx) = ctx.rng().gen_index(ops.ops.len() + 1) {- let op = GcOp::generate(ctx)?;- ops.ops.insert(idx, op);- log::debug!("Added operation {op:?} to ops list");- }- Ok(())- })?;- Ok(())- }-- // Define a mutation that removes an operation from the ops list.- fn remove_operation(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {- if ops.ops.is_empty() {- return Ok(());- }- c.mutation(|ctx| {- let idx = ctx.rng().gen_index(ops.ops.len()).expect("ops not empty");- let removed = ops.ops.remove(idx);- log::debug!("Removed operation {removed:?} from ops list");- Ok(())- })?;- Ok(())- }-- // Define a mutation that adds an empty struct type to an existing (rec ...) group.- fn add_new_struct_type_to_rec_group(+impl TypesMutator {+ /// Add an empty struct type to a random existing rec group.+ fn add_struct(&mut self,c: &mut Candidates<'_>,- ops: &mut GcOps,+ types: &mut Types,+ limits: &GcOpsLimits,) -> mutatis::Result<()> {if c.shrink()- || ops.types.rec_groups.is_empty()- || ops.types.type_defs.len() >= usize::try_from(ops.limits.max_types).unwrap()+ || types.rec_groups.is_empty()+ || types.type_defs.len()+ >= usize::try_from(limits.max_types).expect("max_types is too large"){return Ok(());}c.mutation(|ctx| {- let group_id = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");- let new_tid = ops.types.fresh_type_id(ctx.rng());- ops.types.insert_empty_struct(new_tid, group_id);- log::debug!("Added empty struct type {new_tid:?} to rec group {group_id:?}");+ let Some(gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };+ let tid = types.fresh_type_id(ctx.rng());+ types.insert_empty_struct(tid, gid);+ log::debug!("Added empty struct {tid:?} to rec group {gid:?}");Ok(())})?;Ok(())}- // Define a mutation that removes a struct type from an existing (rec ...).- // It may result in empty rec groups. Empty rec groups are allowed.- fn remove_struct_type_from_rec_group(- &mut self,- c: &mut Candidates<'_>,- ops: &mut GcOps,- ) -> mutatis::Result<()> {- if ops.types.type_defs.is_empty() {+ /// Remove a random type from its rec group.+ fn remove_struct(&mut self, c: &mut Candidates<'_>, types: &mut Types) -> mutatis::Result<()> {+ if types.type_defs.is_empty() {return Ok(());}c.mutation(|ctx| {- let tid = ctx- .rng()- .choose(ops.types.type_defs.keys())- .copied()- .expect("type_defs not empty");- ops.types.type_defs.remove(&tid);+ let Some(tid) = ctx.rng().choose(types.type_defs.keys()).copied() else {+ return Ok(());+ };+ types.remove_type(tid);log::debug!("Removed struct type {tid:?}");Ok(())})?;Ok(())}- // Define a mutation that moves a struct type within an existing rec group.- fn move_struct_type_within_rec_group(+ /// Swap two random types within a rec group.+ fn swap_within_group(&mut self,c: &mut Candidates<'_>,- ops: &mut GcOps,+ types: &mut Types,) -> mutatis::Result<()> {- if ops.types.rec_groups.is_empty() || ops.types.type_defs.len() < 2 {+ if types.rec_groups.is_empty() || types.type_defs.len() <= 2 {return Ok(());}c.mutation(|ctx| {- let mut chosen: Option<(RecGroupId, TypeId, TypeId)> = None;-- // Randomly choose a rec group.- for _ in 0..ops.limits.max_rec_groups {- let gid = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");-- // Collect member TypeIds of that rec group.- let mut members: SmallVec<[TypeId; 32]> = SmallVec::new();- for (tid, def) in ops.types.type_defs.iter() {- if def.rec_group == gid {- members.push(*tid);- }- }+ for _ in 0..16 {+ let Some(gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };- // If this is a singleton/empty group, try another rec group.+ let Some(member_set) = types.rec_groups.get(&gid) else {+ continue;+ };+ let members: SmallVec<[TypeId; 32]> = member_set.iter().copied().collect();if members.len() < 2 {continue;}- // Pick two distinct members randomly.- let tid_a = *ctx.rng().choose(&members).expect("len >= 2");- let mut tid_b = *ctx.rng().choose(&members).expect("len >= 2");+ let Some(tid_a) = ctx.rng().choose(&members).copied() else {+ return Ok(());+ };+ let Some(mut tid_b) = ctx.rng().choose(&members).copied() else {+ return Ok(());+ };for _ in 0..members.len() {if tid_a != tid_b {break;}- tid_b = *ctx.rng().choose(&members).unwrap();+ let Some(next_tid) = ctx.rng().choose(&members).copied() else {+ return Ok(());+ };+ tid_b = next_tid;}if tid_a == tid_b {continue;}- chosen = Some((gid, tid_a, tid_b));- break;- }- // Move within group - reorder for encoding by swapping map values.- if let Some((gid, tid_a, tid_b)) = chosen {- let a_def = ops.types.type_defs.remove(&tid_a).expect("tid_a present");- let b_def = ops.types.type_defs.remove(&tid_b).expect("tid_b present");- debug_assert!(a_def.rec_group == gid);- debug_assert!(b_def.rec_group == gid);- ops.types.type_defs.insert(tid_a, b_def);- ops.types.type_defs.insert(tid_b, a_def);- log::debug!("Reordered types {tid_a:?} and {tid_b:?} in rec group {gid:?}");+ let Some(a_def) = types.type_defs.remove(&tid_a) else {+ return Ok(());+ };+ let Some(b_def) = types.type_defs.remove(&tid_b) else {+ types.type_defs.insert(tid_a, a_def);+ return Ok(());+ };+ types.type_defs.insert(tid_a, b_def);+ types.type_defs.insert(tid_b, a_def);+ log::debug!("Swapped types {tid_a:?} and {tid_b:?} in rec group {gid:?}");+ return Ok(());}-Ok(())})?;Ok(())}- // Define a mutation that moves a struct type from one (rec ...) group to another.- // It will be a different rec group with high probability but it may try- // to move it to the same rec group.- fn move_struct_type_between_rec_groups(+ /// Move a random type from one rec group to another.+ fn move_between_groups(&mut self,c: &mut Candidates<'_>,- ops: &mut GcOps,+ types: &mut Types,) -> mutatis::Result<()> {- if ops.types.type_defs.is_empty() || ops.types.rec_groups.len() < 2 {+ if types.rec_groups.len() < 2 {return Ok(());}c.mutation(|ctx| {- let tid = ctx- .rng()- .choose(ops.types.type_defs.keys())- .copied()- .expect("type_defs not empty");- let new_gid = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");- let old_gid = ops.types.type_defs.get(&tid).unwrap().rec_group;- ops.types.type_defs.get_mut(&tid).unwrap().rec_group = new_gid;- log::debug!("Moved type {tid:?} from rec group {old_gid:?} to {new_gid:?}");+ let mut old_gid = None;+ for _ in 0..16 {+ let Some(gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };+ if types+ .rec_groups+ .get(&gid)+ .map(|s| !s.is_empty())+ .unwrap_or(false)+ {+ old_gid = Some(gid);+ break;+ }+ }+ let Some(old_gid) = old_gid else {+ return Ok(());+ };++ let Some(tid) = types+ .rec_groups+ .get(&old_gid)+ .and_then(|members| ctx.rng().choose(members.iter()).copied())+ else {+ return Ok(());+ };++ let Some(new_gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };++ let Some(old_members) = types.rec_groups.get_mut(&old_gid) else {+ return Ok(());+ };+ old_members.remove(&tid);+ let Some(new_members) = types.rec_groups.get_mut(&new_gid) else {+ return Ok(());+ };+ new_members.insert(tid);+ log::debug!("Moved type {tid:?} from {old_gid:?} to {new_gid:?}");Ok(())})?;Ok(())}- // Define a mutation that duplicates a (rec ...) group.- fn duplicate_rec_group(+ /// Duplicate a rec group (copy its structure with fresh type ids).+ fn duplicate_group(&mut self,c: &mut Candidates<'_>,- ops: &mut GcOps,+ types: &mut Types,+ limits: &GcOpsLimits,) -> mutatis::Result<()> {if c.shrink()- || ops.types.rec_groups.is_empty()- || ops.types.rec_groups.len() >= usize::try_from(ops.limits.max_rec_groups).unwrap()- || ops.types.type_defs.len() >= usize::try_from(ops.limits.max_types).unwrap()+ || types.rec_groups.is_empty()+ || types.rec_groups.len()+ >= usize::try_from(limits.max_rec_groups).expect("max_rec_groups is too large")+ || types.type_defs.len()+ >= usize::try_from(limits.max_types).expect("max_types is too large"){return Ok(());}c.mutation(|ctx| {- let source_gid = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");-- // Create a new rec group.- let new_gid = ops.types.fresh_rec_group_id(ctx.rng());- ops.types.insert_rec_group(new_gid);-- let count = ops- .types- .type_defs- .values()- .filter(|def| def.rec_group == source_gid)- .count();-- // Skip empty rec groups.+ let Some(src_gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };+ let Some(count) = types.rec_groups.get(&src_gid).map(|s| s.len()) else {+ return Ok(());+ };if count == 0 {return Ok(());}- // Since our structs are empty, we can just insert them into the new rec group.- // We will update mutators while adding new features to the fuzzer.+ let new_gid = types.fresh_rec_group_id(ctx.rng());+ types.insert_rec_group(new_gid);+for _ in 0..count {- ops.types- .insert_empty_struct(ops.types.fresh_type_id(ctx.rng()), new_gid);+ let tid = types.fresh_type_id(ctx.rng());+ types.insert_empty_struct(tid, new_gid);}- log::debug!(- "Duplicated rec group {source_gid:?} as new group {new_gid:?} ({count} types)"- );+ log::debug!("Duplicated rec group {src_gid:?} as {new_gid:?} ({count} types)");Ok(())})?;Ok(())}- // Define a mutation that removes a whole (rec ...) group.- fn remove_rec_group(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {- if ops.types.rec_groups.len() <= 2 {+ /// Remove a whole rec group and all its member types.+ fn remove_group(&mut self, c: &mut Candidates<'_>, types: &mut Types) -> mutatis::Result<()> {+ if types.rec_groups.len() <= 2 {return Ok(());}c.mutation(|ctx| {- let gid = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");-- ops.types.type_defs.retain(|_, def| def.rec_group != gid);- ops.types.rec_groups.remove(&gid);-- log::debug!("Removed rec group {gid:?} and its member types");+ let Some(gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };+ let Some(members) = types.rec_groups.remove(&gid) else {+ return Ok(());+ };+ for tid in &members {+ types.type_defs.remove(tid);+ }+ log::debug!(+ "Removed rec group {gid:?} and its {len} member types",+ len = members.len()+ );Ok(())})?;Ok(())}- // Define a mutation that merges two (rec ...) groups.- fn merge_rec_groups(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {- if ops.types.rec_groups.is_empty() || ops.types.rec_groups.len() <= 2 {+ /// Merge two rec groups into one.+ fn merge_groups(&mut self, c: &mut Candidates<'_>, types: &mut Types) -> mutatis::Result<()> {+ if types.rec_groups.len() <= 2 {return Ok(());}c.mutation(|ctx| {- let dst_gid = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");+ let Some(dst_gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };+ // Find a distinct source group.let mut src_gid = None;for _ in 0..16 {- let g = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");-+ let Some(g) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };if g != dst_gid {src_gid = Some(g);break;}}-let Some(src_gid) = src_gid else {- // Could not find a distinct group (should be very unlikely with len>2).return Ok(());};- // Collect all members of src_gid.- let mut members: SmallVec<[TypeId; 32]> = SmallVec::new();- for (tid, def) in ops.types.type_defs.iter() {- if def.rec_group == src_gid {- members.push(*tid);- }- }-- // Move all types from src_gid into dst_gid.- for tid in members {- if let Some(def) = ops.types.type_defs.get_mut(&tid) {- def.rec_group = dst_gid;- }- }-- // Remove the now-merged-away group id.- ops.types.rec_groups.remove(&src_gid);+ // Move all members from src into dst.+ let Some(src_members) = types.rec_groups.remove(&src_gid) else {+ return Ok(());+ };+ let Some(dst_members) = types.rec_groups.get_mut(&dst_gid) else {+ return Ok(());+ };+ dst_members.extend(src_members.iter());log::debug!("Merged rec group {src_gid:?} into {dst_gid:?}");-Ok(())})?;Ok(())}- // Define a mutation that splits a (rec ...) group in two, if possible.- fn split_rec_group(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {+ /// Split a rec group into two.+ fn split_group(+ &mut self,+ c: &mut Candidates<'_>,+ types: &mut Types,+ limits: &GcOpsLimits,+ ) -> mutatis::Result<()> {if c.shrink()- || ops.types.rec_groups.len() >= usize::try_from(ops.limits.max_rec_groups).unwrap()- || ops.types.type_defs.len() < 2+ || types.rec_groups.is_empty()+ || types.type_defs.len() < 2+ || types.rec_groups.len()+ >= usize::try_from(limits.max_rec_groups).expect("max_rec_groups is too large"){return Ok(());}c.mutation(|ctx| {- // Pick a rec group with at least 2 members.+ // Find a group with >= 2 members.let mut old_gid = None;- let mut members: SmallVec<[TypeId; 32]> = SmallVec::new();-for _ in 0..16 {- let gid = ctx- .rng()- .choose(&ops.types.rec_groups)- .copied()- .expect("rec_groups not empty");-- members.clear();- for (tid, def) in ops.types.type_defs.iter() {- if def.rec_group == gid {- members.push(*tid);- }- }-- if members.len() >= 2 {+ let Some(gid) = ctx.rng().choose(types.rec_groups.keys()).copied() else {+ return Ok(());+ };+ if types.rec_groups.get(&gid).map(|s| s.len()).unwrap_or(0) >= 2 {old_gid = Some(gid);break;}}-let Some(old_gid) = old_gid else {return Ok(());};- // Create a new rec group.- let new_gid = ops.types.fresh_rec_group_id(ctx.rng());- ops.types.insert_rec_group(new_gid);+ let new_gid = types.fresh_rec_group_id(ctx.rng());+ types.insert_rec_group(new_gid);- // Choose k in [1, len-1] (so both groups remain non-empty).+ // Collect members so we can pick from them.+ let Some(old_members) = types.rec_groups.get(&old_gid) else {+ return Ok(());+ };+ let mut members: SmallVec<[TypeId; 32]> = old_members.iter().copied().collect();let len = members.len();++ // Choose k in [1, len-1] so both groups stay non-empty.let Some(k_minus_1) = ctx.rng().gen_index(len - 1) else {return Ok(());};let k = k_minus_1 + 1;- // Move k distinct members by removing them from `members` as we pick.for _ in 0..k {let Some(i) = ctx.rng().gen_index(members.len()) else {break;};let tid = members.remove(i);- if let Some(def) = ops.types.type_defs.get_mut(&tid) {- def.rec_group = new_gid;- }+ let Some(old_members) = types.rec_groups.get_mut(&old_gid) else {+ return Ok(());+ };+ old_members.remove(&tid);+ let Some(new_members) = types.rec_groups.get_mut(&new_gid) else {+ return Ok(());+ };+ new_members.insert(tid);}- log::debug!(- "Split rec group {old_gid:?}: moved {k} of {len} members into new group {new_gid:?}"- );+ log::debug!("Split rec group {old_gid:?}: moved {k} of {len} members into {new_gid:?}");Ok(())})?;Ok(())}++ /// Run all type / rec-group mutations. [`GcOpsLimits`] come from [`GcOps`].+ fn mutate_with_limits(+ &mut self,+ c: &mut Candidates<'_>,+ types: &mut Types,+ limits: &GcOpsLimits,+ ) -> mutatis::Result<()> {+ self.add_struct(c, types, limits)?;+ self.remove_struct(c, types)?;+ self.swap_within_group(c, types)?;+ self.move_between_groups(c, types)?;+ self.duplicate_group(c, types, limits)?;+ self.remove_group(c, types)?;+ self.merge_groups(c, types)?;+ self.split_group(c, types, limits)?;+ Ok(())+ }}-impl Mutate<GcOps> for GcOpsMutator {- fn mutate(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {- self.add_operation(c, ops)?;- self.remove_operation(c, ops)?;- self.add_new_struct_type_to_rec_group(c, ops)?;- self.remove_struct_type_from_rec_group(c, ops)?;- self.move_struct_type_within_rec_group(c, ops)?;- self.move_struct_type_between_rec_groups(c, ops)?;- self.duplicate_rec_group(c, ops)?;- self.remove_rec_group(c, ops)?;- self.merge_rec_groups(c, ops)?;- self.split_rec_group(c, ops)?;+/// Mutator for [`GcOps`].+///+/// Also implements [`Mutate`] / [`Generate`] for [`GcOp`] so `m::vec` can mutate+/// `Vec<GcOp>` without a second struct.+#[derive(Debug, Default)]+pub struct GcOpsMutator {+ types_mutator: TypesMutator,+}+impl Mutate<GcOp> for GcOpsMutator {+ fn mutate(&mut self, c: &mut Candidates<'_>, value: &mut GcOp) -> MutResult<()> {+ c.mutation(|ctx| {+ *value = GcOp::generate(ctx)?;+ Ok(())+ })?;Ok(())}}-impl DefaultMutate for GcOps {+impl Generate<GcOp> for GcOpsMutator {+ fn generate(&mut self, context: &mut Context) -> MutResult<GcOp> {+ GcOp::generate(context)+ }+}++impl DefaultMutate for GcOp {type DefaultMutate = GcOpsMutator;}-impl Default for GcOpsMutator {- fn default() -> Self {- GcOpsMutator+impl Mutate<GcOps> for GcOpsMutator {+ fn mutate(&mut self, c: &mut Candidates<'_>, ops: &mut GcOps) -> mutatis::Result<()> {+ m::vec(GcOpsMutator::default()).mutate(c, &mut ops.ops)?;+ self.types_mutator+ .mutate_with_limits(c, &mut ops.types, &ops.limits)?;+ Ok(())}}+impl DefaultMutate for GcOps {+ type DefaultMutate = GcOpsMutator;+}+impl<'a> arbitrary::Arbitrary<'a> for GcOps {fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {let mut session = mutatis::Session::new().seed(u.arbitrary()?);diff --git a/crates/fuzzing/src/generators/gc_ops/ops.rs b/crates/fuzzing/src/generators/gc_ops/ops.rsindex 205b3dd956..9c81e82d10 100644--- a/crates/fuzzing/src/generators/gc_ops/ops.rs+++ b/crates/fuzzing/src/generators/gc_ops/ops.rs@@ -3,10 +3,9 @@use crate::generators::gc_ops::types::StackType;use crate::generators::gc_ops::{limits::GcOpsLimits,- types::{CompositeType, RecGroupId, StructType, TypeId, Types},+ types::{CompositeType, StructType, TypeId, Types},};use serde::{Deserialize, Serialize};-use std::collections::BTreeMap;use wasm_encoder::{CodeSection, ConstExpr, EntityType, ExportKind, ExportSection, Function, FunctionSection,GlobalSection, ImportSection, Instruction, Module, RefType, TableSection, TableType,@@ -69,7 +68,9 @@ impl GcOps {);// 1: "run"- let mut params: Vec<ValType> = Vec::with_capacity(self.limits.num_params as usize);+ let mut params: Vec<ValType> = Vec::with_capacity(+ usize::try_from(self.limits.num_params).expect("num_params is too large"),+ );for _i in 0..self.limits.num_params {params.push(ValType::EXTERNREF);}@@ -104,18 +105,6 @@ impl GcOps {let struct_type_base: u32 = types.len();- let mut rec_groups: BTreeMap<RecGroupId, Vec<TypeId>> = self- .types- .rec_groups- .iter()- .copied()- .map(|id| (id, Vec::new()))- .collect();-- for (id, ty) in self.types.type_defs.iter() {- rec_groups.entry(ty.rec_group).or_default().push(*id);- }-let encode_ty_id = |ty_id: &TypeId| -> wasm_encoder::SubType {let def = &self.types.type_defs[ty_id];match &def.composite_type {@@ -136,10 +125,13 @@ impl GcOps {let mut struct_count = 0;- for type_ids in rec_groups.values() {- let members: Vec<wasm_encoder::SubType> = type_ids.iter().map(encode_ty_id).collect();- types.ty().rec(members);- struct_count += type_ids.len() as u32;+ for member_set in self.types.rec_groups.values() {+ let member_types: Vec<wasm_encoder::SubType> =+ member_set.iter().map(|tid| encode_ty_id(tid)).collect();+ let member_count = u32::try_from(member_types.len())+ .expect("member_types len should be within u32 range");+ types.ty().rec(member_types);+ struct_count += member_count;}let typed_fn_type_base: u32 = struct_type_base + struct_count;diff --git a/crates/fuzzing/src/generators/gc_ops/types.rs b/crates/fuzzing/src/generators/gc_ops/types.rsindex c3e9a93512..6917be0b6c 100644--- a/crates/fuzzing/src/generators/gc_ops/types.rs+++ b/crates/fuzzing/src/generators/gc_ops/types.rs@@ -3,67 +3,68 @@use crate::generators::gc_ops::limits::GcOpsLimits;use crate::generators::gc_ops::ops::GcOp;use serde::{Deserialize, Serialize};+use std::collections::btree_map::Entry;use std::collections::{BTreeMap, BTreeSet};-/// RecGroup ID struct definition.+/// Identifies a `(rec ...)` group.#[derive(Debug, Copy, Clone, Eq, PartialOrd, PartialEq, Ord, Hash, Default, Serialize, Deserialize,)]pub struct RecGroupId(pub(crate) u32);-/// TypeID struct definition.+/// Identifies a type within a rec group.#[derive(Debug, Copy, Clone, Eq, PartialOrd, PartialEq, Ord, Hash, Default, Serialize, Deserialize,)]pub struct TypeId(pub(crate) u32);-/// StructType definition.+/// A struct type definition.#[derive(Debug, Default, Serialize, Deserialize)]-pub struct StructType {- // Empty for now; fields will come in a future PR.-}+pub struct StructType {}-/// CompositeType definition.+/// A composite type: currently only structs.#[derive(Debug, Serialize, Deserialize)]pub enum CompositeType {- /// Struct Type definition.+ /// A struct composite type.Struct(StructType),}-/// SubType definition+/// A sub-type definition (the per-type payload).#[derive(Debug, Serialize, Deserialize)]pub struct SubType {- pub(crate) rec_group: RecGroupId,pub(crate) composite_type: CompositeType,}-/// Struct types definition.++/// All type and rec-group state.+///+/// Rec groups own sets of [`TypeId`]s; moving a type between groups is+/// just a set remove + set insert with no cascading index fixups.#[derive(Debug, Default, Serialize, Deserialize)]pub struct Types {- pub(crate) rec_groups: BTreeSet<RecGroupId>,+ /// Map from rec-group id to the set of types it contains.+ pub(crate) rec_groups: BTreeMap<RecGroupId, BTreeSet<TypeId>>,+ /// Map from type id to its definition.pub(crate) type_defs: BTreeMap<TypeId, SubType>,}impl Types {- /// Create a fresh `Types` allocator with no recursive groups defined yet.+ /// Create empty type state.pub fn new() -> Self {- Self {- rec_groups: Default::default(),- type_defs: Default::default(),- }+ Self::default()}- /// Returns a fresh rec-group id that is not already in use.+ /// Return a fresh [`RecGroupId`] not already in use.pub fn fresh_rec_group_id(&self, rng: &mut mutatis::Rng) -> RecGroupId {for _ in 0..1000 {let id = RecGroupId(rng.gen_u32());- if !self.rec_groups.contains(&id) {+ if !self.rec_groups.contains_key(&id) {return id;}}- panic!("failed to generate a new RecGroupId in 1000 iterations; bad RNG?");+ panic!("failed to generate a new RecGroupId in 1000 iterations");}- /// Returns a fresh type id that is not already in use.+ /// Return a fresh [`TypeId`] not already in use.pub fn fresh_type_id(&self, rng: &mut mutatis::Rng) -> TypeId {for _ in 0..1000 {let id = TypeId(rng.gen_u32());@@ -71,60 +72,150 @@ impl Types {return id;}}- panic!("failed to generate a new TypeId in 1000 iterations; bad RNG?");+ panic!("failed to generate a new TypeId in 1000 iterations");}- /// Insert a rec-group id. Returns true if newly inserted, false if it already existed.+ /// Insert an empty rec group. Returns `true` if it was newly inserted.pub fn insert_rec_group(&mut self, id: RecGroupId) -> bool {- self.rec_groups.insert(id)+ match self.rec_groups.entry(id) {+ Entry::Vacant(e) => {+ e.insert(BTreeSet::new());+ true+ }+ Entry::Occupied(_) => false,+ }}- /// Insert a rec-group id.+ /// Insert an empty struct type into the given rec group.+ ///+ /// The rec group must already exist.pub fn insert_empty_struct(&mut self, id: TypeId, group: RecGroupId) {+ self.rec_groups+ .get_mut(&group)+ .expect("rec group must exist")+ .insert(id);self.type_defs.insert(id,SubType {- rec_group: group,composite_type: CompositeType::Struct(StructType::default()),},);}- /// Removes any entries beyond the given limit.+ /// Remove a type from its rec group and from `type_defs`.+ pub fn remove_type(&mut self, id: TypeId) {+ self.type_defs.remove(&id);+ for members in self.rec_groups.values_mut() {+ members.remove(&id);+ }+ }++ /// Find which rec group a type belongs to, if any.+ pub fn rec_group_of(&self, id: TypeId) -> Option<RecGroupId> {+ self.rec_groups+ .iter()+ .find(|(_, members)| members.contains(&id))+ .map(|(gid, _)| *gid)+ }++ /// Fix up the types to ensure they are within the limits.pub fn fixup(&mut self, limits: &GcOpsLimits) {- while self.rec_groups.len() > limits.max_rec_groups as usize {- self.rec_groups.pop_last();+ let max_rec_groups =+ 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.+ while self.type_defs.len() > max_types {+ if let Some((tid, _)) = self.type_defs.pop_last() {+ for members in self.rec_groups.values_mut() {+ members.remove(&tid);+ }+ }}- // Drop any types whose rec-group has been trimmed out.- self.type_defs- .retain(|_, ty| self.rec_groups.contains(&ty.rec_group));+ // 2. Drop dangling member set entries that reference types that do not exist.+ for members in self.rec_groups.values_mut() {+ members.retain(|tid| self.type_defs.contains_key(tid));+ }- // Then enforce the max types limit.- while self.type_defs.len() > limits.max_types as usize {- self.type_defs.pop_last();+ // 3. Trim excess rec groups and collect their members as orphans.+ let mut rec_group_orphans = BTreeSet::new();+ while self.rec_groups.len() > max_rec_groups {+ if let Some((_gid, members)) = self.rec_groups.pop_last() {+ rec_group_orphans.extend(members);+ }}- debug_assert!(- self.type_defs- .values()- .all(|ty| self.rec_groups.contains(&ty.rec_group)),- "type_defs must only reference existing rec_groups"- );+ // 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());+ }++ // Exclude rec_group_orphans that are already accounted for in the step 3.+ let corruption_orphans: BTreeSet<TypeId> = self+ .type_defs+ .keys()+ .filter(|tid| !all_members.contains(tid) && !rec_group_orphans.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);+ } else {+ // No rec groups at all — drop everything.+ for tid in corruption_orphans.iter().chain(rec_group_orphans.iter()) {+ self.type_defs.remove(tid);+ }+ }++ debug_assert!(self.is_well_formed(limits));+ }++ /// Check if the types are well-formed and within configured limits, i.e.+ /// rec/type counts are within limits,+ /// every type belongs to exactly one rec group,+ /// and every rec group member must exist in type_defs.+ fn is_well_formed(&self, limits: &GcOpsLimits) -> bool {+ if self.rec_groups.len()+ > usize::try_from(limits.max_rec_groups).expect("max_rec_groups is too large")+ {+ return false;+ }+ if self.type_defs.len() > usize::try_from(limits.max_types).expect("max_types is too large")+ {+ 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) {+ return false;+ }+ if !all.insert(*tid) {+ return false;+ }+ }+ }+ self.type_defs.keys().all(|tid| all.contains(tid))}}-/// This is used to track the requirements for the operands of an operation.+/// Tracks the required operand type on the abstract value stack.#[derive(Copy, Clone, Debug)]pub enum StackType {/// `externref`.ExternRef,- /// `(ref $*)`.+ /// `(ref $*)` — optionally with a concrete type index.Struct(Option<u32>),}impl StackType {- /// Fixes the stack type to match the given requirement.+ /// Ensure the top of `stack` satisfies `req`, emitting fixup ops as needed.pub fn fixup(req: Option<StackType>,stack: &mut Vec<StackType>,@@ -137,7 +228,7 @@ impl StackType {if stack.is_empty() {Self::emit(GcOp::NullExtern, stack, out, num_types, &mut result_types);}- stack.pop(); // always consume exactly one value+ stack.pop();}Some(Self::ExternRef) => match stack.last() {Some(Self::ExternRef) => {@@ -145,7 +236,7 @@ impl StackType {}_ => {Self::emit(GcOp::NullExtern, stack, out, num_types, &mut result_types);- stack.pop(); // consume just-synthesized externref+ stack.pop();}},Some(Self::Struct(wanted)) => {@@ -169,8 +260,6 @@ impl StackType {Self::emit(GcOp::NullStruct, stack, out, num_types, &mut result_types);stack.pop();}-- // Typed struct requirement: only satisfiable if we have concrete types.Some(t) => {debug_assert_ne!(num_types, 0,@@ -192,6 +281,7 @@ impl StackType {}}+ /// Emit an opcode and update the stack.pub(crate) fn emit(op: GcOp,stack: &mut Vec<Self>,@@ -211,6 +301,7 @@ impl StackType {}}+ /// Clamp a type index to the number of types.fn clamp(t: u32, n: u32) -> u32 {if n == 0 { 0 } else { t % n }}