Skip to content

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.toml
index 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.rs
index 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.rs
index 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.rs
index 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 }
}