Function exception_ops

crates/fuzzing/src/oracles.rs:953–1018

Execute a series of exception-related operations.

(mut fuzz_config: generators::Config, mut ops: ExceptionOps)

/// Execute a series of exception-related operations.
pub fn exception_ops(mut fuzz_config: generators::Config, mut ops: ExceptionOps) -> Result<()> {
    match fuzz_config.wasmtime.compiler_strategy {
        // Winch doesn't support exceptions; force to Cranelift.
        CompilerStrategy::Winch => {
            fuzz_config.wasmtime.compiler_strategy = CompilerStrategy::CraneliftNative;
        }
        CompilerStrategy::CraneliftNative | CompilerStrategy::CraneliftPulley => {}
    }

    let module_cfg = &mut fuzz_config.module_config.config;
    // Force exceptions + GC on (exceptions require GC).
    module_cfg.gc_enabled = true;
    module_cfg.exceptions_enabled = true;
    module_cfg.reference_types_enabled = true;

    let expected = ops.expected_result();

    let wasm = ops.to_wasm_binary();
    log_wasm(&wasm);

    let mut store = fuzz_config.to_store();

    let module = compile_module(store.engine(), &wasm, KnownValid::No, &fuzz_config)
        .ok_or_else(|| wasmtime::format_err!("Compilation failed"))?;
    let mut linker = Linker::new(store.engine());

    let check_ty = FuncType::new(store.engine(), [ValType::I32, ValType::I32], []);
    let check_func = Func::new(&mut store, check_ty, |_caller, params, _results| {
        let actual = params[0].unwrap_i32();
        let expected = params[1].unwrap_i32();
        assert_eq!(actual, expected, "check_i32 mismatch");
        Ok(())
    });
    linker.define(&store, "", "check_i32", check_func).unwrap();

    let instance = linker.instantiate(&mut store, &module).unwrap();
    let run = instance.get_func(&mut store, "run").unwrap();

    let mut results = [Val::I32(0)];
    match run.call(&mut store, &[], &mut results) {
        Ok(()) => {
            let actual = results[0].unwrap_i32();
            assert_eq!(
                actual, expected,
                "exception_ops: run returned {actual}, expected {expected} \
                 (one catch per scenario)"
            );
        }
        Err(e) => {
            // AllocationTooLarge / GcHeapOutOfMemory are acceptable resource-limit traps.
            if let Some(trap) = e.downcast_ref::<Trap>() {
                match trap {
                    Trap::AllocationTooLarge => return Ok(()),
                    _ => {}
                }
            }
            if e.is::<GcHeapOutOfMemory<()>>() {
                return Ok(());