Skip to content

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

Add advanced table operation coverage to the public API fuzzer (#13453)

Nick Fitzgeraldd40cdc2ca3a5
diff --git a/crates/fuzzing/src/generators/api.rs b/crates/fuzzing/src/generators/api.rs
index f3ac9a728e..1eceea3455 100644
--- a/crates/fuzzing/src/generators/api.rs
+++ b/crates/fuzzing/src/generators/api.rs
@@ -103,6 +103,8 @@ struct Swarm {
module_name: bool,
module_validate: bool,
module_serialize_deserialize: bool,
+ table_copy: bool,
+ table_fill: bool,
}
/// A call to one of Wasmtime's public APIs.
@@ -333,6 +335,18 @@ pub enum ApiCall {
src_id: usize,
dst_id: usize,
},
+ TableCopy {
+ dst_table: usize,
+ dst_index: u64,
+ src_table: usize,
+ src_index: u64,
+ len: u64,
+ },
+ TableFill {
+ table: usize,
+ dst: u64,
+ len: u64,
+ },
}
use ApiCall::*;
@@ -996,6 +1010,59 @@ impl<'a> Arbitrary<'a> for ApiCalls {
Ok(ModuleSerializeDeserialize { src_id, dst_id })
});
}
+ if swarm.table_copy && scope.tables.len() >= 2 {
+ choices.push(|input, scope| {
+ // Find two table ids that map to the same store.
+ let by_store: std::collections::BTreeMap<usize, Vec<usize>> = scope
+ .tables
+ .iter()
+ .fold(Default::default(), |mut m, (&tid, &sid)| {
+ m.entry(sid).or_default().push(tid);
+ m
+ });
+ // Only proceed if at least one store has 2+ tables.
+ let valid_stores: Vec<_> =
+ by_store.iter().filter(|(_, ts)| ts.len() >= 2).collect();
+ if valid_stores.is_empty() {
+ // Fall back: pick any two tables (may be different stores; oracle skips).
+ let tables: Vec<_> = scope.tables.keys().collect();
+ let dst_table = **input.choose(&tables)?;
+ let src_table = **input.choose(&tables)?;
+ let dst_index = u64::arbitrary(input)?;
+ let src_index = u64::arbitrary(input)?;
+ let len = u64::arbitrary(input)? % 8;
+ return Ok(TableCopy {
+ dst_table,
+ dst_index,
+ src_table,
+ src_index,
+ len,
+ });
+ }
+ let (_, store_tables) = *input.choose(&valid_stores)?;
+ let dst_table = *input.choose(store_tables)?;
+ let src_table = *input.choose(store_tables)?;
+ let dst_index = u64::arbitrary(input)?;
+ let src_index = u64::arbitrary(input)?;
+ let len = u64::arbitrary(input)? % 8;
+ Ok(TableCopy {
+ dst_table,
+ dst_index,
+ src_table,
+ src_index,
+ len,
+ })
+ });
+ }
+ if swarm.table_fill && !scope.tables.is_empty() {
+ choices.push(|input, scope| {
+ let tables: Vec<_> = scope.tables.keys().collect();
+ let table = **input.choose(&tables)?;
+ let dst = u64::arbitrary(input)?;
+ let len = u64::arbitrary(input)? % 8;
+ Ok(TableFill { table, dst, len })
+ });
+ }
if choices.is_empty() {
break;
diff --git a/crates/fuzzing/src/oracles/api.rs b/crates/fuzzing/src/oracles/api.rs
index 672802ae8b..e39210fbb4 100644
--- a/crates/fuzzing/src/oracles/api.rs
+++ b/crates/fuzzing/src/oracles/api.rs
@@ -821,6 +821,51 @@ pub fn make_api_calls(api: ApiCalls) {
Err(_) => continue,
}
}
+
+ ApiCall::TableCopy {
+ dst_table,
+ dst_index,
+ src_table,
+ src_index,
+ len,
+ } => {
+ log::trace!(
+ "copying table {src_table}[{src_index}..+{len}] to {dst_table}[{dst_index}]"
+ );
+ let (dt, dst_store_id) = match tables.get(&dst_table) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let (st_tbl, src_store_id) = match tables.get(&src_table) {
+ Some(&x) => x,
+ None => continue,
+ };
+ if dst_store_id != src_store_id {
+ continue;
+ }
+ let st = match stores.get_mut(&dst_store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = Table::copy(&mut *st, &dt, dst_index, &st_tbl, src_index, len);
+ }
+
+ ApiCall::TableFill { table, dst, len } => {
+ log::trace!("filling table {table}[{dst}..+{len}]");
+ let (t, store_id) = match tables.get(&table) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get_mut(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let ty = t.ty(&*st);
+ let elem_ty: ValType = ty.element().clone().into();
+ if let Some(val) = elem_ty.default_value() {
+ let _ = t.fill(&mut *st, dst, val.ref_().unwrap(), len);
+ }
+ }
}
}
}