Skip to content

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

[gc_fuzz]: Add new GC ops to the fuzzer setup (#14196)

Khagan (Khan) Karimov4a9cc4404328
diff --git a/crates/fuzzing/src/generators/gc_ops/ops.rs b/crates/fuzzing/src/generators/gc_ops/ops.rs
index 59a65ec90a..8f791d9b66 100644
--- a/crates/fuzzing/src/generators/gc_ops/ops.rs
+++ b/crates/fuzzing/src/generators/gc_ops/ops.rs
@@ -3,7 +3,7 @@
use crate::generators::gc_ops::types::StackType;
use crate::generators::gc_ops::{
limits::GcOpsLimits,
- types::{CompositeType, RecGroupId, TypeId, Types},
+ types::{CompositeType, RecGroupId, StructField, TypeId, Types},
};
use mutatis::Generate;
use serde::{Deserialize, Serialize};
@@ -24,6 +24,21 @@ fn pick_type_index(indices: &[u32], raw: u32) -> Option<u32> {
}
}
+/// Returns the element field if the indexed type is an array
+fn array_element<'a>(
+ types: &'a Types,
+ encoding_order: &[TypeId],
+ type_index: u32,
+) -> Option<&'a StructField> {
+ encoding_order
+ .get(usize::try_from(type_index).unwrap())
+ .and_then(|tid| types.type_defs.get(tid))
+ .and_then(|def| match &def.composite_type {
+ CompositeType::Array(at) => Some(&at.element),
+ CompositeType::Struct(_) => None,
+ })
+}
+
/// The base offsets and indices for various Wasm entities within
/// their index spaces in the the encoded Wasm binary.
#[derive(Clone, Copy)]
@@ -35,6 +50,7 @@ struct WasmEncodingBases {
i31_local_idx: u32,
array_local_idx: u32,
typed_local_base: u32,
+ typed_local2_base: u32,
struct_global_idx: u32,
eq_global_idx: u32,
i31_global_idx: u32,
@@ -482,15 +498,18 @@ impl GcOps {
));
let typed_local_base: u32 = array_local_idx + 1;
- for i in 0..concrete_count {
- let concrete = struct_type_base + i;
- local_decls.push((
- 1,
- ValType::Ref(RefType {
- nullable: true,
- heap_type: wasm_encoder::HeapType::Concrete(concrete),
- }),
- ));
+ let typed_local2_base: u32 = typed_local_base + concrete_count;
+ for _ in 0..2 {
+ for i in 0..concrete_count {
+ let concrete = struct_type_base + i;
+ local_decls.push((
+ 1,
+ ValType::Ref(RefType {
+ nullable: true,
+ heap_type: wasm_encoder::HeapType::Concrete(concrete),
+ }),
+ ));
+ }
}
let storage_bases = WasmEncodingBases {
@@ -501,6 +520,7 @@ impl GcOps {
i31_local_idx,
array_local_idx,
typed_local_base,
+ typed_local2_base,
struct_global_idx,
eq_global_idx,
i31_global_idx,
@@ -697,6 +717,13 @@ macro_rules! for_each_gc_op {
})]
StructNew { type_index: u32 },
+ #[operands([])]
+ #[results([Struct(Some(type_index))])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ type_index = pick_type_index(struct_type_indices, type_index)?;
+ })]
+ StructNewDefault { type_index: u32 },
+
#[operands([Some(Struct(None))])]
#[results([])]
TakeStructCall,
@@ -874,6 +901,13 @@ macro_rules! for_each_gc_op {
})]
StructGet { type_index: u32, field_index: u32 },
+ #[operands([Some(Struct(Some(type_index)))])]
+ #[results([])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ type_index = pick_type_index(struct_type_indices, type_index)?;
+ })]
+ StructGetU { type_index: u32, field_index: u32 },
+
#[operands([Some(Struct(Some(type_index)))])]
#[results([])]
#[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
@@ -954,6 +988,13 @@ macro_rules! for_each_gc_op {
#[results([Eq])]
I31RefAsEq,
+ #[operands([])]
+ #[results([Array(Some(type_index))])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ type_index = pick_type_index(array_type_indices, type_index)?;
+ })]
+ ArrayNewDefault { type_index: u32 },
+
#[operands([])]
#[results([Array(Some(type_index))])]
#[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
@@ -961,6 +1002,14 @@ macro_rules! for_each_gc_op {
})]
ArrayNew { type_index: u32 },
+ #[operands([])]
+ #[results([Array(Some(type_index))])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ n = n % (limits.array_length + 1);
+ type_index = pick_type_index(array_type_indices, type_index)?;
+ })]
+ ArrayNewFixed { type_index: u32, n: u32 },
+
#[operands([])]
#[results([Array(None)])]
NullArray,
@@ -1092,6 +1141,14 @@ macro_rules! for_each_gc_op {
})]
ArrayGet { type_index: u32, index: u32 },
+ #[operands([Some(Array(Some(type_index)))])]
+ #[results([])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ index = index % (limits.array_length + 1);
+ type_index = pick_type_index(array_type_indices, type_index)?;
+ })]
+ ArrayGetU { type_index: u32, index: u32 },
+
#[operands([Some(Array(Some(type_index)))])]
#[results([])]
#[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
@@ -1100,6 +1157,25 @@ macro_rules! for_each_gc_op {
})]
ArraySet { type_index: u32, index: u32 },
+ #[operands([Some(Array(Some(type_index)))])]
+ #[results([])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ offset = offset % (limits.array_length + 1);
+ len = len % (limits.array_length - offset + 2);
+ type_index = pick_type_index(array_type_indices, type_index)?;
+ })]
+ ArrayFill { type_index: u32, offset: u32, len: u32 },
+
+ #[operands([Some(Array(Some(type_index))), Some(Array(Some(type_index)))])]
+ #[results([])]
+ #[fixup(|limits, num_types, struct_type_indices, array_type_indices| {
+ dst_offset = dst_offset % (limits.array_length + 1);
+ src_offset = src_offset % (limits.array_length + 1);
+ len = len % (limits.array_length - dst_offset.max(src_offset) + 2);
+ type_index = pick_type_index(array_type_indices, type_index)?;
+ })]
+ ArrayCopy { type_index: u32, dst_offset: u32, src_offset: u32, len: u32 },
+
#[operands([Some(Array(None))])]
#[results([])]
ArrayLen,
@@ -1394,7 +1470,12 @@ impl GcOp {
}
func.instruction(&Instruction::StructNew(encoding_bases.struct_type_base + x));
}
- Self::ArrayNew { type_index: x } => {
+ Self::StructNewDefault { type_index: x } => {
+ func.instruction(&Instruction::StructNewDefault(
+ encoding_bases.struct_type_base + x,
+ ));
+ }
+ Self::ArrayNewDefault { type_index: x } => {
// Create a default-initialized array of a fixed length so most
// subsequent indexed accesses are in-bounds.
func.instruction(&Instruction::I32Const(
@@ -1404,6 +1485,30 @@ impl GcOp {
encoding_bases.struct_type_base + x,
));
}
+ Self::ArrayNew { type_index: x } => {
+ if let Some(element) = array_element(types, encoding_order, x) {
+ element
+ .field_type
+ .emit_default_const(func, type_ids_to_index);
+ }
+ func.instruction(&Instruction::I32Const(
+ encoding_bases.array_length.cast_signed(),
+ ));
+ func.instruction(&Instruction::ArrayNew(encoding_bases.struct_type_base + x));
+ }
+ Self::ArrayNewFixed { type_index: x, n } => {
+ if let Some(element) = array_element(types, encoding_order, x) {
+ for _ in 0..n {
+ element
+ .field_type
+ .emit_default_const(func, type_ids_to_index);
+ }
+ }
+ func.instruction(&Instruction::ArrayNewFixed {
+ array_type_index: encoding_bases.struct_type_base + x,
+ array_size: n,
+ });
+ }
Self::TakeStructCall => {
func.instruction(&Instruction::Call(take_structref_idx));
}
@@ -1561,6 +1666,10 @@ impl GcOp {
Self::StructGet {
type_index,
field_index,
+ }
+ | Self::StructGetU {
+ type_index,
+ field_index,
} => {
let wasm_type = encoding_bases.struct_type_base + type_index;
let fields = encoding_order
@@ -1582,10 +1691,17 @@ impl GcOp {
func.instruction(&Instruction::LocalGet(typed_local));
let idx = field_index % u32::try_from(fields.len()).unwrap();
if fields[usize::try_from(idx).unwrap()].field_type.is_packed() {
- func.instruction(&Instruction::StructGetS {
- struct_type_index: wasm_type,
- field_index: idx,
- });
+ if matches!(self, Self::StructGetU { .. }) {
+ func.instruction(&Instruction::StructGetU {
+ struct_type_index: wasm_type,
+ field_index: idx,
+ });
+ } else {
+ func.instruction(&Instruction::StructGetS {
+ struct_type_index: wasm_type,
+ field_index: idx,
+ });
+ }
} else {
func.instruction(&Instruction::StructGet {
struct_type_index: wasm_type,
@@ -1767,7 +1883,7 @@ impl GcOp {
func.instruction(&Instruction::LocalGet(encoding_bases.array_local_idx));
func.instruction(&Instruction::TableSet(encoding_bases.array_table_idx));
}
- Self::ArrayGet { type_index, index } => {
+ Self::ArrayGet { type_index, index } | Self::ArrayGetU { type_index, index } => {
let wasm_type = encoding_bases.struct_type_base + type_index;
let typed_local = encoding_bases.typed_local_base + type_index;
let element = encoding_order
@@ -1789,7 +1905,11 @@ impl GcOp {
func.instruction(&Instruction::LocalGet(typed_local));
func.instruction(&Instruction::I32Const(index.cast_signed()));
if element.field_type.is_packed() {
- func.instruction(&Instruction::ArrayGetS(wasm_type));
+ if matches!(self, Self::ArrayGetU { .. }) {
+ func.instruction(&Instruction::ArrayGetU(wasm_type));
+ } else {
+ func.instruction(&Instruction::ArrayGetS(wasm_type));
+ }
} else {
func.instruction(&Instruction::ArrayGet(wasm_type));
}
@@ -1834,6 +1954,70 @@ impl GcOp {
}
}
}
+ Self::ArrayFill {
+ type_index,
+ offset,
+ len,
+ } => {
+ let wasm_type = encoding_bases.struct_type_base + type_index;
+ let typed_local = encoding_bases.typed_local_base + type_index;
+ match array_element(types, encoding_order, type_index) {
+ Some(element) if element.mutable => {
+ func.instruction(&Instruction::LocalTee(typed_local));
+ func.instruction(&Instruction::RefIsNull);
+ func.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+ func.instruction(&Instruction::Else);
+ func.instruction(&Instruction::LocalGet(typed_local));
+ func.instruction(&Instruction::I32Const(offset.cast_signed()));
+ element
+ .field_type
+ .emit_default_const(func, type_ids_to_index);
+ func.instruction(&Instruction::I32Const(len.cast_signed()));
+ func.instruction(&Instruction::ArrayFill(wasm_type));
+ func.instruction(&Instruction::End);
+ }
+ _ => {
+ func.instruction(&Instruction::Drop);
+ }
+ }
+ }
+ Self::ArrayCopy {
+ type_index,
+ dst_offset,
+ src_offset,
+ len,
+ } => {
+ let wasm_type = encoding_bases.struct_type_base + type_index;
+ let dst_local = encoding_bases.typed_local_base + type_index;
+ let src_local = encoding_bases.typed_local2_base + type_index;
+ match array_element(types, encoding_order, type_index) {
+ Some(element) if element.mutable => {
+ func.instruction(&Instruction::LocalSet(src_local));
+ func.instruction(&Instruction::LocalSet(dst_local));
+ func.instruction(&Instruction::LocalGet(dst_local));
+ func.instruction(&Instruction::RefIsNull);
+ func.instruction(&Instruction::LocalGet(src_local));
+ func.instruction(&Instruction::RefIsNull);
+ func.instruction(&Instruction::I32Or);
+ func.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+ func.instruction(&Instruction::Else);
+ func.instruction(&Instruction::LocalGet(dst_local));
+ func.instruction(&Instruction::I32Const(dst_offset.cast_signed()));
+ func.instruction(&Instruction::LocalGet(src_local));
+ func.instruction(&Instruction::I32Const(src_offset.cast_signed()));
+ func.instruction(&Instruction::I32Const(len.cast_signed()));
+ func.instruction(&Instruction::ArrayCopy {
+ array_type_index_dst: wasm_type,
+ array_type_index_src: wasm_type,
+ });
+ func.instruction(&Instruction::End);
+ }
+ _ => {
+ func.instruction(&Instruction::Drop);
+ func.instruction(&Instruction::Drop);
+ }
+ }
+ }
Self::ArrayLen => {
// array.len traps on null, so guard; the length is not tracked.
func.instruction(&Instruction::LocalTee(encoding_bases.array_local_idx));
diff --git a/crates/fuzzing/src/generators/gc_ops/types.rs b/crates/fuzzing/src/generators/gc_ops/types.rs
index 2e691b6b94..e85e818c5c 100644
--- a/crates/fuzzing/src/generators/gc_ops/types.rs
+++ b/crates/fuzzing/src/generators/gc_ops/types.rs
@@ -1222,7 +1222,7 @@ impl StackType {
);
let t = Self::clamp(t, num_types);
Self::emit(
- GcOp::ArrayNew { type_index: t },
+ GcOp::ArrayNewDefault { type_index: t },
stack,
out,
num_types,