A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
New fuzz generator and oracle for GC object accesses (#13369)
Nick Fitzgerald88513e2935c3
diff --git a/Cargo.toml b/Cargo.tomlindex f994c65e45..8ce8ea18b5 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -322,7 +322,7 @@ winch-codegen = { path = "winch/codegen", version = "=46.0.0" }# Internal crates not published to crates.io used in testing, builds, etcwasi-preview1-component-adapter = { path = "crates/wasi-preview1-component-adapter" }-wasmtime-fuzzing = { path = "crates/fuzzing" }+wasmtime-fuzzing = { path = "crates/fuzzing", default-features = false }test-programs-artifacts = { path = 'crates/test-programs/artifacts' }wasmtime-test-util = { path = "crates/test-util" }byte-array-literals = { path = "crates/wasi-preview1-component-adapter/byte-array-literals" }diff --git a/crates/fuzzing/src/generators.rs b/crates/fuzzing/src/generators.rsindex 2b163a7ae5..7b3c19e8a5 100644--- a/crates/fuzzing/src/generators.rs+++ b/crates/fuzzing/src/generators.rs@@ -13,6 +13,7 @@ mod async_config;mod codegen_settings;mod config;pub mod exception_ops;+pub mod gc_access;pub mod gc_ops;mod instance_allocation_strategy;mod memory;@@ -28,6 +29,7 @@ pub use codegen_settings::CodegenSettings;pub use config::CompilerStrategy;pub use config::{Config, WasmtimeConfig};pub use exception_ops::ExceptionOps;+pub use gc_access::GcAccess;pub use gc_ops::{limits::GcOpsLimits, ops::GcOps};pub use instance_allocation_strategy::InstanceAllocationStrategy;pub use memory::{HeapImage, MemoryAccesses, MemoryConfig};diff --git a/crates/fuzzing/src/generators/gc_access.rs b/crates/fuzzing/src/generators/gc_access.rsnew file mode 100644index 0000000000..fa075a70c7--- /dev/null+++ b/crates/fuzzing/src/generators/gc_access.rs@@ -0,0 +1,1663 @@+//! Generate Wasm modules that exercise GC object creation, field access, and+//! assertion patterns across different heap initialization states.++use arbitrary::{Arbitrary, Result, Unstructured};+use std::borrow::Cow;+use wasm_encoder::{+ CodeSection, ConstExpr, DataSection, ElementSection, Elements, Encode, EntityType, ExportKind,+ ExportSection, Function, FunctionSection, GlobalSection, GlobalType, ImportSection,+ Instruction, Module, RefType, StartSection, TableSection, TableType, TypeSection, ValType,+};++/// The storage type for a GC object's field or element.+#[derive(Arbitrary, Debug, Clone, Copy)]+enum ElemType {+ I8,+ I32,+ Anyref,+ I31ref,+}++impl ElemType {+ fn is_packed(self) -> bool {+ matches!(self, ElemType::I8)+ }++ fn is_numeric(self) -> bool {+ matches!(self, ElemType::I8 | ElemType::I32)+ }++ fn is_ref(self) -> bool {+ matches!(self, ElemType::Anyref | ElemType::I31ref)+ }++ fn storage_type(self) -> wasm_encoder::StorageType {+ match self {+ ElemType::I8 => wasm_encoder::StorageType::I8,+ ElemType::I32 => wasm_encoder::StorageType::Val(ValType::I32),+ ElemType::Anyref | ElemType::I31ref => {+ wasm_encoder::StorageType::Val(ValType::Ref(RefType::ANYREF))+ }+ }+ }+}++#[derive(Arbitrary, Debug, Clone, Copy)]+enum ObjectKind {+ Array,+ Struct,+}++#[derive(Arbitrary, Debug, Clone, Copy)]+struct ObjectType {+ kind: ObjectKind,+ elem_type: ElemType,+ mutable: bool,+}++impl ObjectType {+ fn is_array(self) -> bool {+ matches!(self.kind, ObjectKind::Array)+ }+}++/// How the GC heap is initialized before the test's `run` function executes.+#[derive(Arbitrary, Debug, Clone, Copy)]+enum HeapInit {+ /// The heap is left empty; no filler objects are allocated.+ Empty,+ /// The heap is filled to capacity with filler objects.+ Full,+ /// The heap is nearly full, leaving only a small amount of free space.+ AlmostFull,+ /// The heap is filled with two interleaved chains of filler objects, then+ /// one chain is dropped and a GC is triggered, producing a fragmented heap.+ Fragmented,+}++/// How the GC object under test is created in the `run` function.+#[derive(Debug, Clone, Copy)]+enum CreateMode {+ /// Retrieve the object from an immutable global.+ GlobalGet,+ /// Retrieve the object from a table slot.+ TableGet,+ /// Create the object by calling a helper function.+ Call,+ /// Receive the object as a function parameter via `local.get`.+ LocalGet,+ /// Create an array with `array.new` (fill with a single value).+ ArrayNew,+ /// Create an array with `array.new_default` (zero/null-initialized).+ ArrayNewDefault,+ /// Create an array with `array.new_fixed` (each element pushed individually).+ ArrayNewFixed,+ /// Create an array with `array.new_data` from a passive data segment.+ ArrayNewData,+ /// Create an array with `array.new_elem` from a passive element segment.+ ArrayNewElem,+ /// Create a struct with `struct.new`.+ StructNew,+ /// Create a struct with `struct.new_default` (zero/null-initialized).+ StructNewDefault,+}++impl CreateMode {+ fn arbitrary(u: &mut Unstructured<'_>, object_type: &ObjectType) -> Result<Self> {+ let mut modes: Vec<CreateMode> = vec![+ CreateMode::GlobalGet,+ CreateMode::TableGet,+ CreateMode::Call,+ CreateMode::LocalGet,+ ];+ if object_type.is_array() {+ modes.push(CreateMode::ArrayNew);+ modes.push(CreateMode::ArrayNewDefault);+ modes.push(CreateMode::ArrayNewFixed);+ if object_type.elem_type.is_ref() {+ modes.push(CreateMode::ArrayNewElem);+ } else {+ modes.push(CreateMode::ArrayNewData);+ }+ } else {+ modes.push(CreateMode::StructNew);+ modes.push(CreateMode::StructNewDefault);+ }+ Ok(modes[u.int_in_range(0..=modes.len() - 1)?])+ }++ fn is_default(self) -> bool {+ matches!(+ self,+ CreateMode::StructNewDefault | CreateMode::ArrayNewDefault+ )+ }++ fn is_idempotent(self) -> bool {+ matches!(+ self,+ CreateMode::GlobalGet | CreateMode::TableGet | CreateMode::LocalGet+ )+ }+}++/// The access operation performed on the GC object, exercised before and after+/// a GC cycle to verify that the object survives collection correctly.+#[derive(Debug, Clone, Copy)]+enum AccessMode {+ /// Test the object's runtime type with `ref.test`.+ RefTest,+ /// Read the struct field with `struct.get`.+ StructGet,+ /// Read a packed struct field with sign extension via `struct.get_s`.+ StructGetS,+ /// Read a packed struct field with zero extension via `struct.get_u`.+ StructGetU,+ /// Write the struct field with `struct.set`.+ StructSet,+ /// Read an array element with `array.get`.+ ArrayGet,+ /// Read a packed array element with sign extension via `array.get_s`.+ ArrayGetS,+ /// Read a packed array element with zero extension via `array.get_u`.+ ArrayGetU,+ /// Write an array element with `array.set`.+ ArraySet,+ /// Query the array length with `array.len`.+ ArrayLen,+ /// Fill the entire array with a value via `array.fill`.+ ArrayFill,+ /// Copy elements from a source array via `array.copy`.+ ArrayCopy,+ /// Initialize array elements from a passive data segment via `array.init_data`.+ ArrayInitData,+ /// Initialize array elements from a passive element segment via `array.init_elem`.+ ArrayInitElem,+}++impl AccessMode {+ fn arbitrary(u: &mut Unstructured<'_>, object_type: &ObjectType) -> Result<Self> {+ let mut modes: Vec<AccessMode> = vec![AccessMode::RefTest];+ if object_type.is_array() {+ if object_type.elem_type.is_packed() {+ modes.push(AccessMode::ArrayGetS);+ modes.push(AccessMode::ArrayGetU);+ } else {+ modes.push(AccessMode::ArrayGet);+ }+ modes.push(AccessMode::ArrayLen);+ if object_type.mutable {+ modes.push(AccessMode::ArraySet);+ modes.push(AccessMode::ArrayFill);+ modes.push(AccessMode::ArrayCopy);+ if object_type.elem_type.is_numeric() {+ modes.push(AccessMode::ArrayInitData);+ } else if object_type.elem_type.is_ref() {+ modes.push(AccessMode::ArrayInitElem);+ }+ }+ } else {+ if object_type.elem_type.is_packed() {+ modes.push(AccessMode::StructGetS);+ modes.push(AccessMode::StructGetU);+ } else {+ modes.push(AccessMode::StructGet);+ }+ if object_type.mutable {+ modes.push(AccessMode::StructSet);+ }+ }+ Ok(modes[u.int_in_range(0..=modes.len() - 1)?])+ }+}++/// A fuzz test case that generates a Wasm module exercising GC object creation,+/// access, and assertion patterns across different heap initialization states.+#[derive(Debug)]+pub struct GcAccess {+ object_type: ObjectType,+ heap_init: HeapInit,+ create_mode: CreateMode,+ access_mode: AccessMode,+ array_len: u32,+ creation_value: i32,+ mutation_value: i32,+}++impl<'a> Arbitrary<'a> for GcAccess {+ fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {+ let object_type: ObjectType = u.arbitrary()?;+ let heap_init: HeapInit = u.arbitrary()?;+ let create_mode = CreateMode::arbitrary(u, &object_type)?;+ let access_mode = AccessMode::arbitrary(u, &object_type)?;+ let array_len = u.int_in_range(1..=1024)?;+ let creation_value: i32 = u.arbitrary()?;+ let mutation_value: i32 = u.arbitrary()?;+ Ok(GcAccess {+ object_type,+ heap_init,+ create_mode,+ access_mode,+ array_len,+ creation_value,+ mutation_value,+ })+ }+}++impl GcAccess {+ /// Generate the Wasm binary for this test case.+ ///+ /// The generated module imports `"wasmtime" "gc"` as a GC-triggering+ /// function and exports a `"run"` function. The `"run"` function creates a+ /// GC object, accesses it, triggers GC, then asserts the access result is+ /// unchanged.+ pub fn to_wasm(&self) -> Vec<u8> {+ let mut emitter = Emitter::new(self);+ emitter.emit()+ }+}++struct Emitter<'a> {+ cfg: &'a GcAccess,++ // Type indices.+ obj_type: Option<u32>,+ filler_type: Option<u32>,+ nested_obj_type: Option<u32>,+ void_fn_type: Option<u32>,+ make_obj_fn_type: Option<u32>,+ run_impl_fn_type: Option<u32>,++ // Function indices.+ next_func_idx: u32,+ gc_func: Option<u32>,+ make_obj_func: Option<u32>,+ init_func: Option<u32>,+ run_impl_func: Option<u32>,+ run_func: Option<u32>,++ // Global indices.+ global_g: Option<u32>,+ global_root: Option<u32>,+ global_root2: Option<u32>,++ // Table index.+ table_t: Option<u32>,++ // Segment indices.+ data_d: Option<u32>,+ data_dinit: Option<u32>,+ elem_e: Option<u32>,+ elem_einit: Option<u32>,+}++impl<'a> Emitter<'a> {+ fn new(cfg: &'a GcAccess) -> Self {+ Emitter {+ cfg,+ obj_type: None,+ filler_type: None,+ nested_obj_type: None,+ void_fn_type: None,+ make_obj_fn_type: None,+ run_impl_fn_type: None,+ next_func_idx: 0,+ gc_func: None,+ make_obj_func: None,+ init_func: None,+ run_impl_func: None,+ run_func: None,+ global_g: None,+ global_root: None,+ global_root2: None,+ table_t: None,+ data_d: None,+ data_dinit: None,+ elem_e: None,+ elem_einit: None,+ }+ }++ fn obj_ref_type(&self) -> ValType {+ ValType::Ref(RefType {+ nullable: true,+ heap_type: wasm_encoder::HeapType::Concrete(self.obj_type.unwrap()),+ })+ }++ fn obj_ref_type_non_null(&self) -> ValType {+ ValType::Ref(RefType {+ nullable: false,+ heap_type: wasm_encoder::HeapType::Concrete(self.obj_type.unwrap()),+ })+ }++ fn emit(&mut self) -> Vec<u8> {+ let mut module = Module::new();++ let types = self.types();+ sec(&mut module, types);+ let imports = self.imports();+ sec(&mut module, imports);+ let functions = self.functions();+ sec(&mut module, functions);+ if let Some(s) = self.tables() {+ sec(&mut module, s);+ }+ if let Some(s) = self.globals() {+ sec(&mut module, s);+ }+ let exports = self.exports();+ sec(&mut module, exports);+ sec(+ &mut module,+ StartSection {+ function_index: self.init_func.unwrap(),+ },+ );+ if let Some(s) = self.elems() {+ sec(&mut module, s);+ }+ let data = self.data();+ if data.is_some() {+ let count = self.data_d.is_some() as u32 + self.data_dinit.is_some() as u32;+ sec(&mut module, wasm_encoder::DataCountSection { count });+ }+ let code = self.code();+ sec(&mut module, code);+ if let Some(s) = data {+ sec(&mut module, s);+ }++ module.finish()+ }++ fn types(&mut self) -> TypeSection {+ let mut types = TypeSection::new();++ self.obj_type = Some(types.len());+ let field = wasm_encoder::FieldType {+ element_type: self.cfg.object_type.elem_type.storage_type(),+ mutable: self.cfg.object_type.mutable,+ };+ let obj_composite = if self.cfg.object_type.is_array() {+ wasm_encoder::CompositeInnerType::Array(wasm_encoder::ArrayType(field))+ } else {+ wasm_encoder::CompositeInnerType::Struct(wasm_encoder::StructType {+ fields: Box::new([field]),+ })+ };+ types.ty().subtype(&wasm_encoder::SubType {+ is_final: true,+ supertype_idx: None,+ composite_type: wasm_encoder::CompositeType {+ inner: obj_composite,+ shared: false,+ describes: None,+ descriptor: None,+ },+ });++ if !matches!(self.cfg.heap_init, HeapInit::Empty) {+ self.filler_type = Some(types.len());+ let fi = self.filler_type.unwrap();+ types.ty().subtype(&wasm_encoder::SubType {+ is_final: true,+ supertype_idx: None,+ composite_type: wasm_encoder::CompositeType {+ inner: wasm_encoder::CompositeInnerType::Struct(wasm_encoder::StructType {+ fields: Box::new([wasm_encoder::FieldType {+ element_type: wasm_encoder::StorageType::Val(ValType::Ref(RefType {+ nullable: true,+ heap_type: wasm_encoder::HeapType::Concrete(fi),+ })),+ mutable: true,+ }]),+ }),+ shared: false,+ describes: None,+ descriptor: None,+ },+ });+ }++ if self.cfg.object_type.elem_type.is_ref()+ && !self.cfg.create_mode.is_default()+ && matches!(self.cfg.object_type.elem_type, ElemType::Anyref)+ {+ self.nested_obj_type = Some(types.len());+ types.ty().subtype(&wasm_encoder::SubType {+ is_final: true,+ supertype_idx: None,+ composite_type: wasm_encoder::CompositeType {+ inner: wasm_encoder::CompositeInnerType::Struct(wasm_encoder::StructType {+ fields: Box::new([]),+ }),+ shared: false,+ describes: None,+ descriptor: None,+ },+ });+ }++ self.void_fn_type = Some(types.len());+ types.ty().function(vec![], vec![]);++ if matches!(self.cfg.create_mode, CreateMode::Call) {+ self.make_obj_fn_type = Some(types.len());+ types+ .ty()+ .function(vec![], vec![self.obj_ref_type_non_null()]);+ }++ if matches!(self.cfg.create_mode, CreateMode::LocalGet) {+ self.run_impl_fn_type = Some(types.len());+ types.ty().function(vec![self.obj_ref_type()], vec![]);+ }++ types+ }++ fn imports(&mut self) -> ImportSection {+ let mut imports = ImportSection::new();+ self.gc_func = Some(self.next_func_idx);+ self.next_func_idx += 1;+ imports.import(+ "wasmtime",+ "gc",+ EntityType::Function(self.void_fn_type.unwrap()),+ );+ imports+ }++ fn functions(&mut self) -> FunctionSection {+ let mut fns = FunctionSection::new();+ if let Some(t) = self.make_obj_fn_type {+ self.make_obj_func = Some(self.next_func_idx);+ self.next_func_idx += 1;+ fns.function(t);+ }+ self.init_func = Some(self.next_func_idx);+ self.next_func_idx += 1;+ fns.function(self.void_fn_type.unwrap());+ if let Some(t) = self.run_impl_fn_type {+ self.run_impl_func = Some(self.next_func_idx);+ self.next_func_idx += 1;+ fns.function(t);+ }+ self.run_func = Some(self.next_func_idx);+ self.next_func_idx += 1;+ fns.function(self.void_fn_type.unwrap());+ fns+ }++ fn tables(&mut self) -> Option<TableSection> {+ if !matches!(self.cfg.create_mode, CreateMode::TableGet) {+ return None;+ }+ let mut tables = TableSection::new();+ self.table_t = Some(tables.len());+ tables.table_with_init(+ TableType {+ element_type: RefType {+ nullable: false,+ heap_type: wasm_encoder::HeapType::Concrete(self.obj_type.unwrap()),+ },+ minimum: 1,+ maximum: Some(1),+ table64: false,+ shared: false,+ },+ &self.obj_const_expr(self.cfg.creation_value),+ );+ Some(tables)+ }++ fn globals(&mut self) -> Option<GlobalSection> {+ let mut globals = GlobalSection::new();+ let mut any = false;++ if matches!(self.cfg.create_mode, CreateMode::GlobalGet) {+ self.global_g = Some(globals.len());+ any = true;+ globals.global(+ GlobalType {+ val_type: self.obj_ref_type_non_null(),+ mutable: false,+ shared: false,+ },+ &self.obj_const_expr(self.cfg.creation_value),+ );+ }++ if let Some(fi) = self.filler_type {+ if !matches!(self.cfg.heap_init, HeapInit::Empty) {+ self.global_root = Some(globals.len());+ any = true;+ globals.global(+ GlobalType {+ val_type: ValType::Ref(RefType {+ nullable: true,+ heap_type: wasm_encoder::HeapType::Concrete(fi),+ }),+ mutable: true,+ shared: false,+ },+ &ConstExpr::ref_null(wasm_encoder::HeapType::Concrete(fi)),+ );+ }+ if matches!(self.cfg.heap_init, HeapInit::Fragmented) {+ self.global_root2 = Some(globals.len());+ any = true;+ globals.global(+ GlobalType {+ val_type: ValType::Ref(RefType {+ nullable: true,+ heap_type: wasm_encoder::HeapType::Concrete(fi),+ }),+ mutable: true,+ shared: false,+ },+ &ConstExpr::ref_null(wasm_encoder::HeapType::Concrete(fi)),+ );+ }+ }++ if any { Some(globals) } else { None }+ }++ fn exports(&self) -> ExportSection {+ let mut exports = ExportSection::new();+ exports.export("run", ExportKind::Func, self.run_func.unwrap());+ exports+ }++ fn elems(&mut self) -> Option<ElementSection> {+ let mut elems = ElementSection::new();+ let mut any = false;++ if matches!(self.cfg.create_mode, CreateMode::ArrayNewElem) {+ self.elem_e = Some(elems.len());+ any = true;+ let exprs: Vec<ConstExpr> = (0..self.cfg.array_len)+ .map(|_| self.ref_value_const_expr(self.cfg.creation_value))+ .collect();+ elems.segment(wasm_encoder::ElementSegment {+ mode: wasm_encoder::ElementMode::Passive,+ elements: Elements::Expressions(RefType::ANYREF, Cow::Owned(exprs)),+ });+ }++ if matches!(self.cfg.access_mode, AccessMode::ArrayInitElem) {+ self.elem_einit = Some(elems.len());+ any = true;+ let expr = self.ref_value_const_expr(self.cfg.mutation_value);+ elems.segment(wasm_encoder::ElementSegment {+ mode: wasm_encoder::ElementMode::Passive,+ elements: Elements::Expressions(RefType::ANYREF, Cow::Owned(vec![expr])),+ });+ }++ if any { Some(elems) } else { None }+ }++ fn data(&mut self) -> Option<DataSection> {+ let mut data = DataSection::new();+ let mut any = false;++ if matches!(self.cfg.create_mode, CreateMode::ArrayNewData) {+ self.data_d = Some(data.len());+ any = true;+ data.passive(self.data_bytes(self.cfg.creation_value, self.cfg.array_len as usize));+ }+ if matches!(self.cfg.access_mode, AccessMode::ArrayInitData) {+ self.data_dinit = Some(data.len());+ any = true;+ data.passive(self.data_bytes(self.cfg.mutation_value, 1));+ }++ if any { Some(data) } else { None }+ }++ fn data_bytes(&self, val: i32, count: usize) -> Vec<u8> {+ match self.cfg.object_type.elem_type {+ ElemType::I32 => (val as u32)+ .to_le_bytes()+ .iter()+ .copied()+ .cycle()+ .take(4 * count)+ .collect(),+ ElemType::I8 => vec![(val & 0xFF) as u8; count],+ _ => unreachable!(),+ }+ }++ fn code(&self) -> CodeSection {+ let mut code = CodeSection::new();++ if self.make_obj_func.is_some() {+ let mut body = Function::new(vec![]);+ self.emit_make_obj(&mut body);+ finish(&mut code, body);+ }++ // init+ {+ let locals = if !matches!(self.cfg.heap_init, HeapInit::Empty) {+ vec![(1, ValType::I32)]+ } else {+ vec![]+ };+ let mut body = Function::new(locals);+ self.emit_init(&mut body);+ finish(&mut code, body);+ }++ // run_impl (local_get mode)+ if self.run_impl_func.is_some() {+ let mut locals = vec![+ (1, ValType::I32), // $i+ (1, ValType::I32), // $j+ ];+ if self.needs_before() {+ locals.push((1, ValType::I32)); // $before+ }+ if matches!(self.cfg.access_mode, AccessMode::ArrayCopy) {+ locals.push((1, self.obj_ref_type())); // $src+ }+ let mut body = Function::new(locals);+ self.emit_local_get_body(&mut body);+ finish(&mut code, body);+ }++ // run+ {+ if self.run_impl_func.is_some() {+ let mut body = Function::new(vec![]);+ self.emit_make_obj(&mut body);+ body.instruction(&Instruction::Call(self.run_impl_func.unwrap()));+ finish(&mut code, body);+ } else if self.cfg.create_mode.is_idempotent()+ && !matches!(self.cfg.create_mode, CreateMode::LocalGet)+ {+ let mut locals = vec![+ (1, ValType::I32), // $i+ (1, ValType::I32), // $j+ ];+ if self.needs_before() {+ locals.push((1, ValType::I32));+ }+ if matches!(self.cfg.access_mode, AccessMode::ArrayCopy) {+ locals.push((1, self.obj_ref_type()));+ }+ let mut body = Function::new(locals);+ self.emit_idempotent_body(&mut body);+ finish(&mut code, body);+ } else {+ let mut locals = vec![+ (1, self.obj_ref_type()), // $x+ (1, ValType::I32), // $i+ (1, ValType::I32), // $j+ ];+ if self.needs_before() {+ locals.push((1, ValType::I32));+ }+ if matches!(self.cfg.access_mode, AccessMode::ArrayCopy) {+ locals.push((1, self.obj_ref_type()));+ }+ let mut body = Function::new(locals);+ self.emit_normal_body(&mut body);+ finish(&mut code, body);+ }+ }++ code+ }++ fn needs_before(&self) -> bool {+ match self.cfg.access_mode {+ AccessMode::RefTest+ | AccessMode::StructGetS+ | AccessMode::StructGetU+ | AccessMode::ArrayGetS+ | AccessMode::ArrayGetU+ | AccessMode::ArrayLen => true,+ AccessMode::StructGet | AccessMode::ArrayGet => {+ if self.cfg.object_type.elem_type.is_ref() {+ // anyref get with default creates drops the value; nested obj+ // asserts non-null; neither uses $before as i32+ !self.cfg.create_mode.is_default() && !self.uses_nested_obj()+ } else {+ true+ }+ }+ _ => false,+ }+ }++ fn uses_nested_obj(&self) -> bool {+ self.nested_obj_type.is_some()+ }++ fn emit_init(&self, body: &mut Function) {+ let local_i = 0u32;+ match self.cfg.heap_init {+ HeapInit::Empty => {}+ HeapInit::Full => self.emit_filler_loop(body, local_i, 4096),+ HeapInit::AlmostFull => self.emit_filler_loop(body, local_i, 4094),+ HeapInit::Fragmented => self.emit_fragmented(body, local_i),+ }+ }++ fn emit_filler_loop(&self, body: &mut Function, local_i: u32, count: i32) {+ let fi = self.filler_type.unwrap();+ let root = self.global_root.unwrap();++ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::GlobalGet(root));+ body.instruction(&Instruction::StructNew(fi));+ body.instruction(&Instruction::GlobalSet(root));+ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_i));+ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(count));+ body.instruction(&Instruction::I32LtU);+ body.instruction(&Instruction::BrIf(0));+ body.instruction(&Instruction::End);+ }++ fn emit_fragmented(&self, body: &mut Function, local_i: u32) {+ let fi = self.filler_type.unwrap();+ let root = self.global_root.unwrap();+ let root2 = self.global_root2.unwrap();++ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::GlobalGet(root));+ body.instruction(&Instruction::StructNew(fi));+ body.instruction(&Instruction::GlobalSet(root));+ body.instruction(&Instruction::GlobalGet(root2));+ body.instruction(&Instruction::StructNew(fi));+ body.instruction(&Instruction::GlobalSet(root2));+ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_i));+ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(2048));+ body.instruction(&Instruction::I32LtU);+ body.instruction(&Instruction::BrIf(0));+ body.instruction(&Instruction::End);++ body.instruction(&Instruction::RefNull(wasm_encoder::HeapType::Concrete(fi)));+ body.instruction(&Instruction::GlobalSet(root2));+ body.instruction(&Instruction::Call(self.gc_func.unwrap()));+ }++ fn emit_make_obj(&self, body: &mut Function) {+ let obj_type = self.obj_type.unwrap();+ if self.cfg.object_type.is_array() {+ self.emit_value(body, self.cfg.creation_value);+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayNew(obj_type));+ } else {+ self.emit_value(body, self.cfg.creation_value);+ body.instruction(&Instruction::StructNew(obj_type));+ }+ }++ fn emit_create(&self, body: &mut Function) {+ let obj_type = self.obj_type.unwrap();+ match self.cfg.create_mode {+ CreateMode::StructNew => {+ self.emit_value(body, self.cfg.creation_value);+ body.instruction(&Instruction::StructNew(obj_type));+ }+ CreateMode::StructNewDefault => {+ body.instruction(&Instruction::StructNewDefault(obj_type));+ }+ CreateMode::ArrayNew => {+ self.emit_value(body, self.cfg.creation_value);+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayNew(obj_type));+ }+ CreateMode::ArrayNewDefault => {+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayNewDefault(obj_type));+ }+ CreateMode::ArrayNewFixed => {+ for _ in 0..self.cfg.array_len {+ self.emit_value(body, self.cfg.creation_value);+ }+ body.instruction(&Instruction::ArrayNewFixed {+ array_type_index: obj_type,+ array_size: self.cfg.array_len,+ });+ }+ CreateMode::ArrayNewData => {+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayNewData {+ array_type_index: obj_type,+ array_data_index: self.data_d.unwrap(),+ });+ }+ CreateMode::ArrayNewElem => {+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayNewElem {+ array_type_index: obj_type,+ array_elem_index: self.elem_e.unwrap(),+ });+ }+ CreateMode::GlobalGet => {+ body.instruction(&Instruction::GlobalGet(self.global_g.unwrap()));+ }+ CreateMode::TableGet => {+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::TableGet(self.table_t.unwrap()));+ }+ CreateMode::Call => {+ body.instruction(&Instruction::Call(self.make_obj_func.unwrap()));+ }+ CreateMode::LocalGet => unreachable!(),+ }+ }++ fn obj_const_expr(&self, val: i32) -> ConstExpr {+ let obj_type = self.obj_type.unwrap();+ let mut bytes = Vec::new();+ if self.cfg.object_type.is_array() {+ self.push_value_instrs(&mut bytes, val);+ Instruction::I32Const(self.cfg.array_len as i32).encode(&mut bytes);+ Instruction::ArrayNew(obj_type).encode(&mut bytes);+ } else {+ self.push_value_instrs(&mut bytes, val);+ Instruction::StructNew(obj_type).encode(&mut bytes);+ }+ ConstExpr::raw(bytes)+ }++ fn ref_value_const_expr(&self, val: i32) -> ConstExpr {+ let mut bytes = Vec::new();+ if let Some(nested) = self.nested_obj_type {+ Instruction::StructNew(nested).encode(&mut bytes);+ } else {+ Instruction::I32Const(val).encode(&mut bytes);+ Instruction::RefI31.encode(&mut bytes);+ }+ ConstExpr::raw(bytes)+ }++ fn push_value_instrs(&self, buf: &mut Vec<u8>, val: i32) {+ match self.cfg.object_type.elem_type {+ ElemType::I8 | ElemType::I32 => {+ Instruction::I32Const(val).encode(buf);+ }+ ElemType::I31ref => {+ Instruction::I32Const(val).encode(buf);+ Instruction::RefI31.encode(buf);+ }+ ElemType::Anyref => {+ if self.cfg.create_mode.is_default() {+ Instruction::RefNull(wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::Any,+ })+ .encode(buf);+ } else if let Some(nested) = self.nested_obj_type {+ Instruction::StructNew(nested).encode(buf);+ } else {+ Instruction::I32Const(val).encode(buf);+ Instruction::RefI31.encode(buf);+ }+ }+ }+ }++ fn emit_value(&self, body: &mut Function, val: i32) {+ match self.cfg.object_type.elem_type {+ ElemType::I8 | ElemType::I32 => {+ body.instruction(&Instruction::I32Const(val));+ }+ ElemType::I31ref => {+ body.instruction(&Instruction::I32Const(val));+ body.instruction(&Instruction::RefI31);+ }+ ElemType::Anyref => {+ if self.cfg.create_mode.is_default() {+ body.instruction(&Instruction::RefNull(wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::Any,+ }));+ } else if let Some(nested) = self.nested_obj_type {+ body.instruction(&Instruction::StructNew(nested));+ } else {+ body.instruction(&Instruction::I32Const(val));+ body.instruction(&Instruction::RefI31);+ }+ }+ }+ }++ /// Compute the i32 value we expect to read back from a numeric field+ /// written with `val`, after packed storage truncation and unsigned+ /// extension via `{array,struct}.get_u`.+ fn expected_numeric_readback(&self, val: i32) -> i32 {+ match self.cfg.object_type.elem_type {+ ElemType::I8 => val & 0xFF,+ ElemType::I32 => val,+ _ => unreachable!(),+ }+ }++ fn emit_mutation_value(&self, body: &mut Function) {+ match self.cfg.object_type.elem_type {+ ElemType::I8 | ElemType::I32 => {+ body.instruction(&Instruction::I32Const(self.cfg.mutation_value));+ }+ ElemType::I31ref | ElemType::Anyref => {+ body.instruction(&Instruction::I32Const(self.cfg.mutation_value));+ body.instruction(&Instruction::RefI31);+ }+ }+ }++ fn emit_obj_ref(&self, body: &mut Function, r: ObjRef) {+ match r {+ ObjRef::Local(l) => {+ body.instruction(&Instruction::LocalGet(l));+ }+ ObjRef::Global => {+ body.instruction(&Instruction::GlobalGet(self.global_g.unwrap()));+ }+ ObjRef::Table => {+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::TableGet(self.table_t.unwrap()));+ }+ }+ }++ fn idempotent_ref(&self) -> ObjRef {+ match self.cfg.create_mode {+ CreateMode::GlobalGet => ObjRef::Global,+ CreateMode::TableGet => ObjRef::Table,+ _ => unreachable!(),+ }+ }++ fn emit_access(+ &self,+ body: &mut Function,+ r: ObjRef,+ local_before: Option<u32>,+ local_src: Option<u32>,+ ) {+ match self.cfg.access_mode {+ AccessMode::RefTest => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::RefTestNonNull(+ wasm_encoder::HeapType::Concrete(self.obj_type.unwrap()),+ ));+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ AccessMode::StructGet => self.emit_get_access(body, r, local_before),+ AccessMode::StructGetS => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGetS {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ AccessMode::StructGetU => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGetU {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ AccessMode::StructSet => {+ self.emit_obj_ref(body, r);+ self.emit_mutation_value(body);+ body.instruction(&Instruction::StructSet {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ }+ AccessMode::ArrayGet => self.emit_get_access(body, r, local_before),+ AccessMode::ArrayGetS => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGetS(self.obj_type.unwrap()));+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ AccessMode::ArrayGetU => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGetU(self.obj_type.unwrap()));+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ AccessMode::ArraySet => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ self.emit_mutation_value(body);+ body.instruction(&Instruction::ArraySet(self.obj_type.unwrap()));+ }+ AccessMode::ArrayLen => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::ArrayLen);+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ AccessMode::ArrayFill => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ self.emit_mutation_value(body);+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayFill(self.obj_type.unwrap()));+ }+ AccessMode::ArrayCopy => {+ let src = local_src.unwrap();+ self.emit_mutation_value(body);+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayNew(self.obj_type.unwrap()));+ body.instruction(&Instruction::LocalSet(src));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::LocalGet(src));+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(self.cfg.array_len as i32));+ body.instruction(&Instruction::ArrayCopy {+ array_type_index_dst: self.obj_type.unwrap(),+ array_type_index_src: self.obj_type.unwrap(),+ });+ }+ AccessMode::ArrayInitData => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::ArrayInitData {+ array_type_index: self.obj_type.unwrap(),+ array_data_index: self.data_dinit.unwrap(),+ });+ }+ AccessMode::ArrayInitElem => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::ArrayInitElem {+ array_type_index: self.obj_type.unwrap(),+ array_elem_index: self.elem_einit.unwrap(),+ });+ }+ }+ }++ fn emit_get_access(&self, body: &mut Function, r: ObjRef, local_before: Option<u32>) {+ if self.cfg.object_type.elem_type.is_ref() {+ if self.cfg.create_mode.is_default() {+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::Drop);+ } else if self.uses_nested_obj() {+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::Drop);+ } else {+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::RefCastNonNull(+ wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::I31,+ },+ ));+ body.instruction(&Instruction::I31GetU);+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ } else if self.cfg.object_type.is_array() {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGet(self.obj_type.unwrap()));+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ } else {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGet {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ body.instruction(&Instruction::LocalSet(local_before.unwrap()));+ }+ }++ fn emit_assert(&self, body: &mut Function, r: ObjRef, local_before: Option<u32>) {+ match self.cfg.access_mode {+ AccessMode::RefTest => {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::RefTestNonNull(+ wasm_encoder::HeapType::Concrete(self.obj_type.unwrap()),+ ));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::StructGet | AccessMode::ArrayGet => {+ self.emit_get_assert(body, r, local_before)+ }+ AccessMode::StructGetS => {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGetS {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::StructGetU => {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGetU {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::StructSet => {+ self.emit_set_assert(body, r);+ }+ AccessMode::ArrayGetS => {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGetS(self.obj_type.unwrap()));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::ArrayGetU => {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGetU(self.obj_type.unwrap()));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::ArraySet => {+ self.emit_set_assert(body, r);+ }+ AccessMode::ArrayLen => {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::ArrayLen);+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::ArrayFill => {+ self.emit_mutation_assert(body, r);+ }+ AccessMode::ArrayCopy => {+ self.emit_mutation_assert(body, r);+ }+ AccessMode::ArrayInitData => {+ self.emit_read_field(body, r, 0);+ let expected = self.expected_numeric_readback(self.cfg.mutation_value);+ body.instruction(&Instruction::I32Const(expected));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ AccessMode::ArrayInitElem => {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGet(self.obj_type.unwrap()));+ body.instruction(&Instruction::RefCastNonNull(+ wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::I31,+ },+ ));+ body.instruction(&Instruction::I31GetU);+ body.instruction(&Instruction::I32Const(+ self.cfg.mutation_value & 0x7FFF_FFFF,+ ));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ }+ }++ fn emit_get_assert(&self, body: &mut Function, r: ObjRef, local_before: Option<u32>) {+ if self.cfg.object_type.elem_type.is_ref() {+ if self.cfg.create_mode.is_default() {+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::RefIsNull);+ body.instruction(&Instruction::I32Eqz);+ self.emit_trap_if(body);+ } else if self.uses_nested_obj() {+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::RefIsNull);+ self.emit_trap_if(body);+ } else {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::RefCastNonNull(+ wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::I31,+ },+ ));+ body.instruction(&Instruction::I31GetU);+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ } else if self.cfg.object_type.is_array() {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGet(self.obj_type.unwrap()));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ } else {+ body.instruction(&Instruction::LocalGet(local_before.unwrap()));+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGet {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ }++ fn emit_set_assert(&self, body: &mut Function, r: ObjRef) {+ if self.cfg.object_type.elem_type.is_ref() {+ self.emit_read_ref(body, r);+ body.instruction(&Instruction::RefCastNonNull(+ wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::I31,+ },+ ));+ body.instruction(&Instruction::I31GetU);+ body.instruction(&Instruction::I32Const(+ self.cfg.mutation_value & 0x7FFF_FFFF,+ ));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ } else {+ self.emit_read_field(body, r, 0);+ let expected = self.expected_numeric_readback(self.cfg.mutation_value);+ body.instruction(&Instruction::I32Const(expected));+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }+ }++ fn emit_mutation_assert(&self, body: &mut Function, r: ObjRef) {+ if self.cfg.object_type.elem_type.is_ref() {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGet(self.obj_type.unwrap()));+ body.instruction(&Instruction::RefCastNonNull(+ wasm_encoder::HeapType::Abstract {+ shared: false,+ ty: wasm_encoder::AbstractHeapType::I31,+ },+ ));+ body.instruction(&Instruction::I31GetU);+ body.instruction(&Instruction::I32Const(+ self.cfg.mutation_value & 0x7FFF_FFFF,+ ));+ } else {+ self.emit_read_field(body, r, 0);+ let expected = self.expected_numeric_readback(self.cfg.mutation_value);+ body.instruction(&Instruction::I32Const(expected));+ }+ body.instruction(&Instruction::I32Ne);+ self.emit_trap_if(body);+ }++ fn emit_read_ref(&self, body: &mut Function, r: ObjRef) {+ if self.cfg.object_type.is_array() {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::ArrayGet(self.obj_type.unwrap()));+ } else {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::StructGet {+ struct_type_index: self.obj_type.unwrap(),+ field_index: 0,+ });+ }+ }++ fn emit_read_field(&self, body: &mut Function, r: ObjRef, idx: u32) {+ if self.cfg.object_type.is_array() {+ self.emit_obj_ref(body, r);+ body.instruction(&Instruction::I32Const(idx as i32));+ if self.cfg.object_type.elem_type.is_packed() {+ body.instruction(&Instruction::ArrayGetU(self.obj_type.unwrap()));+ } else {+ body.instruction(&Instruction::ArrayGet(self.obj_type.unwrap()));+ }+ } else {+ self.emit_obj_ref(body, r);+ if self.cfg.object_type.elem_type.is_packed() {+ body.instruction(&Instruction::StructGetU {+ struct_type_index: self.obj_type.unwrap(),+ field_index: idx,+ });+ } else {+ body.instruction(&Instruction::StructGet {+ struct_type_index: self.obj_type.unwrap(),+ field_index: idx,+ });+ }+ }+ }++ fn emit_trap_if(&self, body: &mut Function) {+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Unreachable);+ body.instruction(&Instruction::End);+ }++ /// Normal (non-idempotent, non-local_get) run body.+ ///+ /// Layout follows INSTRUCTIONS.md: outer loop with create + access + gc ++ /// assert, then inner loop with access + assert, then trailing access ++ /// assert.+ fn emit_normal_body(&self, body: &mut Function) {+ // locals: $x=0, $i=1, $j=2, [$before=3, [$src=4]]+ let local_x = 0u32;+ let local_i = 1u32;+ let local_j = 2u32;+ let local_before = if self.needs_before() {+ Some(3u32)+ } else {+ None+ };+ let local_src = if matches!(self.cfg.access_mode, AccessMode::ArrayCopy) {+ Some(if self.needs_before() { 4u32 } else { 3u32 })+ } else {+ None+ };+ let r = ObjRef::Local(local_x);++ // i = 0 (already 0)+ // (loop $outer+ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));++ // (if (i32.ge_u $i 10) (return))+ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(10));+ body.instruction(&Instruction::I32GeU);+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Return);+ body.instruction(&Instruction::End);++ // (local.set $x CREATE)+ self.emit_create(body);+ body.instruction(&Instruction::LocalSet(local_x));++ // ACCESS+ self.emit_access(body, r, local_before, local_src);+ // gc()+ body.instruction(&Instruction::Call(self.gc_func.unwrap()));+ // ASSERT+ self.emit_assert(body, r, local_before);++ // j = 0+ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::LocalSet(local_j));++ // (block $break (loop $inner+ body.instruction(&Instruction::Block(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));++ // (if (i32.lt_u $j 10)+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(10));+ body.instruction(&Instruction::I32LtU);+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));++ // (then ACCESS; ASSERT; j += 1; br $inner)+ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_j));+ body.instruction(&Instruction::Br(1)); // br $inner++ // (else ACCESS; ASSERT; j += 1; br $break)+ body.instruction(&Instruction::Else);+ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_j));+ body.instruction(&Instruction::Br(2)); // br $break++ body.instruction(&Instruction::End); // end if+ body.instruction(&Instruction::End); // end loop $inner+ body.instruction(&Instruction::End); // end block $break++ // ACCESS; ASSERT+ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);++ // i += 1+ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_i));++ // br $outer+ body.instruction(&Instruction::Br(0));++ body.instruction(&Instruction::End); // end loop $outer+ }++ /// Idempotent (global_get / table_get) run body — no $x local.+ fn emit_idempotent_body(&self, body: &mut Function) {+ // locals: $i=0, $j=1, [$before=2, [$src=3]]+ let local_i = 0u32;+ let local_j = 1u32;+ let local_before = if self.needs_before() {+ Some(2u32)+ } else {+ None+ };+ let local_src = if matches!(self.cfg.access_mode, AccessMode::ArrayCopy) {+ Some(if self.needs_before() { 3u32 } else { 2u32 })+ } else {+ None+ };+ let r = self.idempotent_ref();++ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));++ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(10));+ body.instruction(&Instruction::I32GeU);+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Return);+ body.instruction(&Instruction::End);++ self.emit_access(body, r, local_before, local_src);+ body.instruction(&Instruction::Call(self.gc_func.unwrap()));+ self.emit_assert(body, r, local_before);++ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::LocalSet(local_j));++ body.instruction(&Instruction::Block(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));++ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(10));+ body.instruction(&Instruction::I32LtU);+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));++ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_j));+ body.instruction(&Instruction::Br(1));++ body.instruction(&Instruction::Else);+ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_j));+ body.instruction(&Instruction::Br(2));++ body.instruction(&Instruction::End); // end if+ body.instruction(&Instruction::End); // end loop $inner+ body.instruction(&Instruction::End); // end block $break++ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);++ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_i));++ body.instruction(&Instruction::Br(0));+ body.instruction(&Instruction::End); // end loop $outer+ }++ /// local_get mode — param $p is the object ref.+ fn emit_local_get_body(&self, body: &mut Function) {+ // param: $p=0, locals: $i=1, $j=2, [$before=3, [$src=4]]+ let param_p = 0u32;+ let local_i = 1u32;+ let local_j = 2u32;+ let local_before = if self.needs_before() {+ Some(3u32)+ } else {+ None+ };+ let local_src = if matches!(self.cfg.access_mode, AccessMode::ArrayCopy) {+ Some(if self.needs_before() { 4u32 } else { 3u32 })+ } else {+ None+ };+ let r = ObjRef::Local(param_p);++ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));++ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(10));+ body.instruction(&Instruction::I32GeU);+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Return);+ body.instruction(&Instruction::End);++ self.emit_access(body, r, local_before, local_src);+ body.instruction(&Instruction::Call(self.gc_func.unwrap()));+ self.emit_assert(body, r, local_before);++ body.instruction(&Instruction::I32Const(0));+ body.instruction(&Instruction::LocalSet(local_j));++ body.instruction(&Instruction::Block(wasm_encoder::BlockType::Empty));+ body.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));++ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(10));+ body.instruction(&Instruction::I32LtU);+ body.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));++ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_j));+ body.instruction(&Instruction::Br(1));++ body.instruction(&Instruction::Else);+ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);+ body.instruction(&Instruction::LocalGet(local_j));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_j));+ body.instruction(&Instruction::Br(2));++ body.instruction(&Instruction::End); // end if+ body.instruction(&Instruction::End); // end loop $inner+ body.instruction(&Instruction::End); // end block $break++ self.emit_access(body, r, local_before, local_src);+ self.emit_assert(body, r, local_before);++ body.instruction(&Instruction::LocalGet(local_i));+ body.instruction(&Instruction::I32Const(1));+ body.instruction(&Instruction::I32Add);+ body.instruction(&Instruction::LocalSet(local_i));++ body.instruction(&Instruction::Br(0));+ body.instruction(&Instruction::End); // end loop $outer+ }+}++/// How the test references the GC object when performing accesses and+/// assertions.+#[derive(Clone, Copy)]+enum ObjRef {+ /// The object is held in a local variable.+ Local(u32),+ /// The object is retrieved from an immutable global each time.+ Global,+ /// The object is retrieved from a table slot each time.+ Table,+}++fn sec(module: &mut Module, section: impl wasm_encoder::Section) {+ module.section(§ion);+}++fn finish(code: &mut CodeSection, mut f: Function) {+ f.instruction(&Instruction::End);+ code.function(&f);+}++#[cfg(test)]+mod tests {+ use super::*;+ use wasmparser::Validator;++ #[test]+ fn gc_access_generates_valid_wasm() {+ crate::test::test_n_times(1024, |input: GcAccess, _u| {+ let wasm = input.to_wasm();+ validate(&wasm);+ Ok(())+ })+ }++ fn validate(wasm: &[u8]) {+ let mut validator = Validator::new_with_features(wasmparser::WasmFeatures::all());+ let err = match validator.validate_all(wasm) {+ Ok(_) => return,+ Err(e) => e,+ };+ drop(std::fs::write("test.wasm", wasm));+ if let Ok(text) = wasmprinter::print_bytes(wasm) {+ drop(std::fs::write("test.wat", &text));+ }+ panic!("wasm failed to validate: {err}");+ }+}diff --git a/crates/fuzzing/src/oracles.rs b/crates/fuzzing/src/oracles.rsindex 8c26379ce0..78f525b234 100644--- a/crates/fuzzing/src/oracles.rs+++ b/crates/fuzzing/src/oracles.rs@@ -17,6 +17,7 @@ pub mod diff_wasmi;pub mod diff_wasmtime;pub mod dummy;pub mod engine;+mod gc_access;pub mod memory;mod stacks;@@ -28,6 +29,7 @@ use crate::generators::{self, CompilerStrategy, DiffValue, DiffValueType};use crate::single_module_fuzzer::KnownValid;use crate::{YieldN, block_on};use arbitrary::Arbitrary;+pub use gc_access::gc_access;pub use stacks::check_stacks;use std::future::Future;use std::pin::Pin;diff --git a/crates/fuzzing/src/oracles/gc_access.rs b/crates/fuzzing/src/oracles/gc_access.rsnew file mode 100644index 0000000000..2c4cf11215--- /dev/null+++ b/crates/fuzzing/src/oracles/gc_access.rs@@ -0,0 +1,77 @@+//! Oracle for the `GcAccess` fuzz test case generator.++use crate::generators;+use wasmtime::*;++/// Run the given `GcAccess` test case.+///+/// Panics if the generated Wasm module's embedded assertions fail, which+/// indicates a GC bug.+pub fn gc_access(config: generators::Config, input: generators::GcAccess) {+ let wasm = input.to_wasm();+ crate::oracles::log_wasm(&wasm);++ let mut wasmtime_config = config.to_wasmtime();+ wasmtime_config.wasm_gc(true);+ wasmtime_config.wasm_function_references(true);+ wasmtime_config.wasm_reference_types(true);+ wasmtime_config.wasm_bulk_memory(true);++ let engine = match Engine::new(&wasmtime_config) {+ Ok(e) => e,+ Err(_) => return,+ };++ let module = match Module::new(&engine, &wasm) {+ Ok(m) => m,+ Err(_) => return,+ };++ let mut linker = Linker::new(&engine);+ linker+ .func_wrap(+ "wasmtime",+ "gc",+ |mut caller: Caller<'_, crate::oracles::StoreLimits>| {+ let _ = caller.gc(None);+ },+ )+ .unwrap();++ let limits = crate::oracles::StoreLimits::new();+ let mut store = Store::new(&engine, limits);+ store.limiter(|s| s as &mut dyn ResourceLimiter);+ config.configure_store_epoch_and_fuel(&mut store);++ let instance = match linker.instantiate(&mut store, &module) {+ Ok(i) => i,+ Err(_) => return,+ };++ let run = instance+ .get_typed_func::<(), ()>(&mut store, "run")+ .expect("should have `run` export");++ if let Err(e) = run.call(&mut store, ()) {+ let msg = format!("{e:?}");+ assert!(+ !msg.contains("wasm trap: wasm `unreachable` instruction executed"),+ "GC access assertion failure: {e:?}"+ );+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::generators::GcAccess;++ #[test]+ fn gc_access_oracle_passes() {+ crate::test::test_n_times(1024, |config: generators::Config, u| {+ let input: GcAccess = u.arbitrary()?;+ gc_access(config, input);+ Ok(())+ })+ }+}diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.tomlindex b31f175cbf..6b73aab132 100644--- a/fuzz/Cargo.toml+++ b/fuzz/Cargo.toml@@ -47,7 +47,7 @@ wasmtime = { workspace = true }wasmtime-test-util = { workspace = true, features = ['component-fuzz'] }[features]-default = ['fuzz-spec-interpreter']+default = ['fuzz-spec-interpreter', 'v8']fuzz-spec-interpreter = ['wasmtime-fuzzing/fuzz-spec-interpreter']v8 = ['wasmtime-fuzzing/v8']chaos = ["cranelift-control/chaos"]diff --git a/fuzz/fuzz_targets/misc.rs b/fuzz/fuzz_targets/misc.rsindex c2506075df..16f9838231 100644--- a/fuzz/fuzz_targets/misc.rs+++ b/fuzz/fuzz_targets/misc.rs@@ -68,6 +68,7 @@ run_fuzzers! {stacksapi_callsdominator_tree+ gc_access}fn pulley_roundtrip(u: Unstructured<'_>) -> Result<()> {@@ -180,3 +181,10 @@ fn dominator_tree(mut data: Unstructured<'_>) -> Result<()> {Ok(())}++fn gc_access(mut u: Unstructured<'_>) -> Result<()> {+ let config: wasmtime_fuzzing::generators::Config = u.arbitrary()?;+ let input: wasmtime_fuzzing::generators::GcAccess = u.arbitrary()?;+ wasmtime_fuzzing::oracles::gc_access(config, input);+ Ok(())+}