A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Stack types (#12015)
Khagan (Khan) Karimov196a50c40757
diff --git a/crates/fuzzing/src/generators/gc_ops/mutator.rs b/crates/fuzzing/src/generators/gc_ops/mutator.rsindex 581408d383..9ed63b003e 100644--- a/crates/fuzzing/src/generators/gc_ops/mutator.rs+++ b/crates/fuzzing/src/generators/gc_ops/mutator.rs@@ -1,15 +1,6 @@//! Mutators for the `gc` operations.-use crate::generators::gc_ops::{- limits::{- GcOpsLimits, MAX_OPS, MAX_REC_GROUPS_RANGE, MAX_TYPES_RANGE, NUM_GLOBALS_RANGE,- NUM_PARAMS_RANGE, TABLE_SIZE_RANGE,- },- ops::{GcOp, GcOps},- types::{RecGroupId, TypeId, Types},-};--use mutatis::mutators as m;+use crate::generators::gc_ops::ops::{GcOp, GcOps};use mutatis::{Candidates, Context, DefaultMutate, Generate, Mutate, Result as MutResult};/// A mutator for the gc ops@@ -21,8 +12,7 @@ impl Mutate<GcOps> for GcOpsMutator {if !c.shrink() {c.mutation(|ctx| {if let Some(idx) = ctx.rng().gen_index(ops.ops.len() + 1) {- let stack = ops.abstract_stack_depth(idx);- let (op, _new_stack_size) = GcOp::generate(ctx, &ops, stack)?;+ let op = GcOp::generate(ctx, &ops)?;ops.ops.insert(idx, op);}Ok(())@@ -63,64 +53,12 @@ impl<'a> arbitrary::Arbitrary<'a> for GcOps {}impl Generate<GcOps> for GcOpsMutator {- fn generate(&mut self, ctx: &mut Context) -> MutResult<GcOps> {- let num_params = m::range(NUM_PARAMS_RANGE).generate(ctx)?;- let num_globals = m::range(NUM_GLOBALS_RANGE).generate(ctx)?;- let table_size = m::range(TABLE_SIZE_RANGE).generate(ctx)?;-- let max_rec_groups = m::range(MAX_REC_GROUPS_RANGE).generate(ctx)?;- let max_types = m::range(MAX_TYPES_RANGE).generate(ctx)?;-- let mut ops = GcOps {- limits: GcOpsLimits {- num_params,- num_globals,- table_size,- max_rec_groups,- max_types,- },- ops: {- let mut v = vec![GcOp::Null(), GcOp::Drop(), GcOp::Gc()];- if num_params > 0 {- v.push(GcOp::LocalSet(0));- v.push(GcOp::LocalGet(0));- }- if num_globals > 0 {- v.push(GcOp::GlobalSet(0));- v.push(GcOp::GlobalGet(0));- }- if max_types > 0 {- v.push(GcOp::StructNew(0));- }- v- },- types: Types::new(),- };-- for i in 0..ops.limits.max_rec_groups {- ops.types.insert_rec_group(RecGroupId(i));- }-- if ops.limits.max_rec_groups > 0 {- for i in 0..ops.limits.max_types {- let tid = TypeId(i);- let gid = RecGroupId(m::range(0..=ops.limits.max_rec_groups - 1).generate(ctx)?);-- ops.types.insert_empty_struct(tid, gid);- }- }-- let mut stack: usize = 0;-- while ops.ops.len() < MAX_OPS {- let (op, new_stack_len) = GcOp::generate(ctx, &ops, stack)?;- ops.ops.push(op);- stack = new_stack_len;- }+ fn generate(&mut self, _ctx: &mut Context) -> MutResult<GcOps> {+ let mut ops = GcOps::default();+ let mut session = mutatis::Session::new();- // Drop any leftover refs on the stack.- for _ in 0..stack {- ops.ops.push(GcOp::Drop());+ for _ in 0..64 {+ session.mutate(&mut ops)?;}Ok(ops)diff --git a/crates/fuzzing/src/generators/gc_ops/ops.rs b/crates/fuzzing/src/generators/gc_ops/ops.rsindex ecaefd3763..ef8cfa5a25 100644--- a/crates/fuzzing/src/generators/gc_ops/ops.rs+++ b/crates/fuzzing/src/generators/gc_ops/ops.rs@@ -1,12 +1,12 @@//! Operations for the `gc` operations.+use crate::generators::gc_ops::types::StackType;use crate::generators::gc_ops::{limits::GcOpsLimits,types::{CompositeType, RecGroupId, StructType, TypeId, Types},};use mutatis::{Context, Generate, mutators as m};use serde::{Deserialize, Serialize};-use smallvec::SmallVec;use std::collections::BTreeMap;use wasm_encoder::{CodeSection, ConstExpr, EntityType, ExportKind, ExportSection, Function, FunctionSection,@@ -218,19 +218,6 @@ impl GcOps {module.finish()}- /// Computes the abstract stack depth after executing all operations- pub fn abstract_stack_depth(&self, index: usize) -> usize {- debug_assert!(index <= self.ops.len());- let mut stack: usize = 0;- for op in self.ops.iter().take(index) {- let pop = op.operands_len();- let push = op.results_len();- stack = stack.saturating_sub(pop);- stack += push;- }- stack- }-/// Fixes this test case such that it becomes valid.////// This is necessary because a random mutation (e.g. removing an op in the@@ -247,7 +234,11 @@ impl GcOps {self.types.fixup(&self.limits);let mut new_ops = Vec::with_capacity(self.ops.len());- let mut stack = 0;+ let mut stack: Vec<StackType> = Vec::new();+ let num_types = u32::try_from(self.types.type_defs.len())+ .expect("types len should be within u32 range");++ let mut operand_types = Vec::new();for mut op in self.ops.iter().copied() {if self.limits.max_types == 0@@ -268,26 +259,29 @@ impl GcOps {continue;}- op.fixup(&self.limits);+ op.fixup(&self.limits, num_types);- let mut temp = SmallVec::<[_; 4]>::new();+ let op = if let Some(op) = op.fixup(&self.limits, num_types) {+ op+ } else {+ continue;+ };- while stack < op.operands_len() {- temp.push(GcOp::Null());- stack += 1;+ operand_types.clear();+ op.operand_types(&mut operand_types);+ for ty in &operand_types {+ StackType::fixup(*ty, &mut stack, &mut new_ops, num_types);}- temp.push(op);- stack = stack - op.operands_len() + op.results_len();-- new_ops.extend(temp);+ // Finally, emit the op itself (updates stack abstractly)+ let mut result_types = Vec::new();+ StackType::emit(op, &mut stack, &mut new_ops, num_types, &mut result_types);}- // Insert drops to balance the final stack state- for _ in 0..stack {+ // Balance any leftovers with drops (works for any type)+ for _ in 0..stack.len() {new_ops.push(GcOp::Drop());}-self.ops = new_ops;}@@ -303,79 +297,58 @@ impl GcOps {macro_rules! define_gc_ops {($(- $op:ident $( ( $($limit_var:ident : $limit:expr => $ty:ty),* ) )? : $params:expr => $results:expr ,+ $op:ident+ $( ( $($limit_var:ident : $limit:expr => $ty:ty),* ) )?+ : [ $($operand:expr),* $(,)? ] => [ $($result:expr),* $(,)? ] ,)*) => {- /// The operations for the `gc` operations.++ /// The operations that can be performed by the `gc` function.#[derive(Copy, Clone, Debug, Serialize, Deserialize)]- pub(crate) enum GcOp {+ pub enum GcOp {$(+ #[allow(missing_docs, reason = "macro-generated code")]$op ( $( $($ty),* )? ),)*}- /// Names of the operations for testing purposes.#[cfg(test)]- pub const OP_NAMES: &'static[&'static str] = &[- $(- stringify!($op),- )*+ pub(crate) const OP_NAMES: &'static [&'static str] = &[+ $( stringify!($op), )*];impl GcOp {#[cfg(test)]- pub fn name(&self) -> &'static str {- match self {- $(- Self::$op (..) => stringify!($op),- )*- }+ pub(crate) fn name(&self) -> &'static str {+ match self { $( Self::$op(..) => stringify!($op), )* }}- pub fn operands_len(&self) -> usize {+ #[allow(unreachable_patterns, reason = "macro-generated code")]+ pub(crate) fn operand_types(&self, out: &mut Vec<Option<StackType>>) {+match self {+ Self::TakeTypedStructCall(t) => {+ out.push(Some(StackType::Struct(Some(*t))));+ }$(- Self::$op (..) => $params,- )*+ Self::$op(..) => {+ $( out.push($operand); )*+ }+ ),*}}- pub fn results_len(&self) -> usize {+ #[allow(unreachable_patterns, reason = "macro-generated code")]+ pub(crate) fn result_types(&self, out: &mut Vec<StackType>) {match self {- $(- Self::$op (..) => $results,- )*+ Self::StructNew(t) => {+ out.push(StackType::Struct(Some(*t)));+ }+ $( Self::$op(..) => { $( out.push($result); )* }, )*}}- }- $(- #[allow(non_snake_case, reason = "macro-generated code")]- fn $op(- _ctx: &mut mutatis::Context,- _limits: &GcOpsLimits,- stack: usize,- ) -> mutatis::Result<(GcOp, usize)> {- #[allow(unused_comparisons, reason = "macro-generated code")]- {- debug_assert!(stack >= $params);- }-- let op = GcOp::$op(- $($({- let limit_fn = $limit as fn(&GcOpsLimits) -> $ty;- let limit = (limit_fn)(_limits);- debug_assert!(limit > 0);- m::range(0..=limit - 1).generate(_ctx)?- }),*)?- );- let new_stack = stack - $params + $results;- Ok((op, new_stack))- }- )*-- impl GcOp {- fn fixup(&mut self, limits: &GcOpsLimits) {+ pub(crate) fn fixup(&mut self, limits: &GcOpsLimits, num_types: u32) -> Option<Self> {match self {$(Self::$op( $( $( $limit_var ),* )? ) => {@@ -388,62 +361,102 @@ macro_rules! define_gc_ops {})*}+ match self {+ Self::StructNew(t)+ | Self::TakeStructCall(t)+ | Self::TakeTypedStructCall(t) => {+ if num_types == 0 {+ return None;+ }+ *t %= num_types;+ }+ _ => {}+ }++ Some(*self)}+ /// Generate an arbitrary op without stack-depth awareness.+ /// The fixup pass will make the sequence valid.pub(crate) fn generate(ctx: &mut mutatis::Context,ops: &GcOps,- stack: usize,- ) -> mutatis::Result<(GcOp, usize)> {+ ) -> mutatis::Result<GcOp> {let mut valid_choices: Vec<- fn(&mut Context, &GcOpsLimits, usize) -> mutatis::Result<(GcOp, usize)>+ fn(&mut Context, &GcOpsLimits) -> mutatis::Result<GcOp>> = vec![];+$(- #[allow(unused_comparisons, reason = "macro-generated code")]- if stack >= $params $($(- && {- let limit_fn = $limit as fn(&GcOpsLimits) -> $ty;- let limit = (limit_fn)(&ops.limits);- limit > 0- }- )*)? {- valid_choices.push($op);- }+ valid_choices.push($op);)*let f = *ctx.rng().choose(&valid_choices).expect("should always have a valid op choice");-- (f)(ctx, &ops.limits, stack)+ (f)(ctx, &ops.limits)}}++ $(+ #[allow(non_snake_case, reason = "macro-generated code")]+ fn $op(+ _ctx: &mut mutatis::Context,+ _limits: &GcOpsLimits,+ ) -> mutatis::Result<GcOp> {+ let op = GcOp::$op(+ $($({+ let limit_fn = $limit as fn(&GcOpsLimits) -> $ty;+ let limit = (limit_fn)(_limits);+ // Generate a value even if limit is 0; fixup will handle it+ if limit > 0 {+ m::range(0..=limit - 1).generate(_ctx)?+ } else {+ 0+ }+ }),*)?+ );+ Ok(op)+ }+ )*};}define_gc_ops! {- Gc : 0 => 3,+ Gc : [] => [StackType::ExternRef, StackType::ExternRef, StackType::ExternRef],- MakeRefs : 0 => 3,- TakeRefs : 3 => 0,+ MakeRefs : [] => [StackType::ExternRef, StackType::ExternRef, StackType::ExternRef],+ TakeRefs : [Some(StackType::ExternRef), Some(StackType::ExternRef), Some(StackType::ExternRef)] => [],// Add one to make sure that out of bounds table accesses are possible, but still rare.- TableGet(elem_index: |ops| ops.table_size + 1 => u32) : 0 => 1,- TableSet(elem_index: |ops| ops.table_size + 1 => u32) : 1 => 0,+ TableGet(elem_index: |ops| ops.table_size + 1 => u32)+ : [] => [StackType::ExternRef],+ TableSet(elem_index: |ops| ops.table_size + 1 => u32)+ : [Some(StackType::ExternRef)] => [],- GlobalGet(global_index: |ops| ops.num_globals => u32) : 0 => 1,- GlobalSet(global_index: |ops| ops.num_globals => u32) : 1 => 0,+ GlobalGet(global_index: |ops| ops.num_globals => u32)+ : [] => [StackType::ExternRef],+ GlobalSet(global_index: |ops| ops.num_globals => u32)+ : [Some(StackType::ExternRef)] => [],- LocalGet(local_index: |ops| ops.num_params => u32) : 0 => 1,- LocalSet(local_index: |ops| ops.num_params => u32) : 1 => 0,+ LocalGet(local_index: |ops| ops.num_params => u32)+ : [] => [StackType::ExternRef],+ LocalSet(local_index: |ops| ops.num_params => u32)+ : [Some(StackType::ExternRef)] => [],- StructNew(type_index: |ops| ops.max_types => u32) : 0 => 0,- TakeStructCall(type_index: |ops| ops.max_types => u32) : 1 => 0,- TakeTypedStructCall(type_index: |ops| ops.max_types => u32) : 1 => 0,+ // `StructNew` result is special-cased to push `Struct(Some(t))`, so results list is empty.+ StructNew(type_index: |ops| ops.max_types => u32)+ : [] => [],- Drop : 1 => 0,+ TakeStructCall(type_index: |ops| ops.max_types => u32)+ : [Some(StackType::Struct(None))] => [],- Null : 0 => 1,+ // `TakeTypedStructCall` operand is special-cased to require `Struct(Some(t))`, so operands list is empty.+ TakeTypedStructCall(type_index: |ops| ops.max_types => u32)+ : [] => [],++ Drop : [None] => [],++ Null : [] => [StackType ::ExternRef],}impl GcOp {@@ -499,16 +512,12 @@ impl GcOp {}Self::StructNew(x) => {func.instruction(&Instruction::StructNew(x + struct_type_base));- func.instruction(&Instruction::Call(take_structref_idx));}- Self::TakeStructCall(x) => {- func.instruction(&Instruction::StructNew(x + struct_type_base));+ Self::TakeStructCall(_x) => {func.instruction(&Instruction::Call(take_structref_idx));}Self::TakeTypedStructCall(x) => {- let s = struct_type_base + x;let f = typed_first_func_index + x;- func.instruction(&Instruction::StructNew(s));func.instruction(&Instruction::Call(f));}}diff --git a/crates/fuzzing/src/generators/gc_ops/tests.rs b/crates/fuzzing/src/generators/gc_ops/tests.rsindex b5907c0f84..f1911de865 100644--- a/crates/fuzzing/src/generators/gc_ops/tests.rs+++ b/crates/fuzzing/src/generators/gc_ops/tests.rs@@ -250,7 +250,7 @@ fn test_wat_string() -> mutatis::Result<()> {global.set 0global.get 0struct.new 5- call 3+ dropdropdropdrop@@ -297,3 +297,83 @@ fn emits_empty_rec_groups_and_validates() -> mutatis::Result<()> {Ok(())}++#[test]+fn fixup_check_types_and_indexes() -> mutatis::Result<()> {+ let _ = env_logger::try_init();++ // Create GcOps with 5 types so that 7 % 5 = 2+ let mut ops = test_ops(5, 5, 5);+ ops.limits.max_types = 5;++ // We create max types 5 and out ouf bounds for the type index+ ops.ops = vec![+ GcOp::TakeTypedStructCall(27),+ GcOp::GlobalSet(0),+ GcOp::StructNew(24),+ GcOp::LocalSet(0),+ ];++ // Call fixup to resolve dependencies+ // this should fix the types by inserting missing types+ // also put the indexes in the correct bounds+ ops.fixup();++ // Verify that fixup()+ // The expected sequence should be:+ // 1. StructNew(_) - inserted by fixup to satisfy TakeTypedStructCall(_)+ // 2. TakeTypedStructCall(_) - now has Struct(_) on stack+ // 3. Null() - inserted by fixup to satisfy GlobalSet(0)+ // 4. GlobalSet(0) - now has ExternRef on stack+ // 5. StructNew(_) - produces Struct(_)+ // 6. Null() - inserted by fixup to satisfy LocalSet(0)+ // 7. LocalSet(0) - now has ExternRef on stack+ // 8. Drop() - inserted by fixup to consume ExternRef before Drop()++ // This is the expected sequence in wat format:+ // loop ;; label = @1+ // struct.new 7+ // call 6+ // ref.null extern+ // global.set 0+ // struct.new 9+ // ref.null extern+ // local.set 0+ // drop+ // br 0 (;@1;)+ // end++ // Find the index of TakeTypedStructCall(_) after fixup+ let take_call_idx = ops+ .ops+ .iter()+ .position(|op| matches!(op, GcOp::TakeTypedStructCall(_)))+ .expect("TakeTypedStructCall(_) should be present after fixup");++ // Verify that StructNew(_) appears before TakeTypedStructCall(_)+ let struct_new_2_before = ops+ .ops+ .iter()+ .take(take_call_idx)+ .any(|op| matches!(op, GcOp::StructNew(_)));++ assert!(+ struct_new_2_before,+ "fixup should insert StructNew(_) before TakeTypedStructCall(_) to satisfy the dependency"+ );++ // Verify the sequence validates correctly+ let wasm = ops.to_wasm_binary();+ let wat = wasmprinter::print_bytes(&wasm).unwrap();+ log::debug!("{wat}");+ let feats = wasmparser::WasmFeatures::default();+ feats.reference_types();+ feats.gc();+ let mut validator = wasmparser::Validator::new_with_features(feats);+ assert!(+ validator.validate_all(&wasm).is_ok(),+ "GC validation should pass after fixup"+ );++ Ok(())+}diff --git a/crates/fuzzing/src/generators/gc_ops/types.rs b/crates/fuzzing/src/generators/gc_ops/types.rsindex 5cd44ae618..fb51491950 100644--- a/crates/fuzzing/src/generators/gc_ops/types.rs+++ b/crates/fuzzing/src/generators/gc_ops/types.rs@@ -1,6 +1,7 @@//! Types for the `gc` operations.use crate::generators::gc_ops::limits::GcOpsLimits;+use crate::generators::gc_ops::ops::GcOp;use serde::{Deserialize, Serialize};use std::collections::{BTreeMap, BTreeSet};@@ -88,3 +89,83 @@ impl Types {);}}++/// This is used to track the requirements for the operands of an operation.+#[derive(Copy, Clone, Debug)]+pub enum StackType {+ /// `externref`+ ExternRef,+ /// `(ref $*)`;+ Struct(Option<u32>),+}++impl StackType {+ /// Fixes the stack type to match the given requirement.+ pub fn fixup(+ req: Option<StackType>,+ stack: &mut Vec<StackType>,+ out: &mut Vec<GcOp>,+ num_types: u32,+ ) {+ let mut result_types = Vec::new();+ match req {+ None => {+ if stack.is_empty() {+ Self::emit(GcOp::Null(), stack, out, num_types, &mut result_types);+ }+ stack.pop(); // always consume exactly one value+ }+ Some(Self::ExternRef) => match stack.last() {+ Some(Self::ExternRef) => {+ stack.pop();+ }+ _ => {+ Self::emit(GcOp::Null(), stack, out, num_types, &mut result_types);+ stack.pop(); // consume just-synthesized externref+ }+ },+ Some(Self::Struct(wanted)) => {+ let ok = match (wanted, stack.last()) {+ (Some(wanted), Some(Self::Struct(Some(s)))) => *s == wanted,+ (None, Some(Self::Struct(_))) => true,+ _ => false,+ };++ if ok {+ stack.pop();+ } else {+ // Ensure there *is* a struct to consume.+ let t = match wanted {+ Some(t) => Self::clamp(t, num_types),+ None => Self::clamp(0, num_types),+ };+ Self::emit(GcOp::StructNew(t), stack, out, num_types, &mut result_types);+ stack.pop(); // consume the synthesized struct+ }+ }+ }+ }++ pub(crate) fn emit(+ op: GcOp,+ stack: &mut Vec<Self>,+ out: &mut Vec<GcOp>,+ num_types: u32,+ result_types: &mut Vec<Self>,+ ) {+ out.push(op);+ result_types.clear();+ op.result_types(result_types);+ for ty in result_types {+ let clamped_ty = match ty {+ Self::Struct(Some(t)) => Self::Struct(Some(Self::clamp(*t, num_types))),+ other => *other,+ };+ stack.push(clamped_ty);+ }+ }++ fn clamp(t: u32, n: u32) -> u32 {+ if n == 0 { 0 } else { t % n }+ }+}