Function execute

fuzz/fuzz_targets/oom.rs:49–141

(
    module: &[u8],
    _known_valid: KnownValid,
    input: OomInput,
    _u: &mut Unstructured<'_>,
)

}

fn execute(
    module: &[u8],
    _known_valid: KnownValid,
    input: OomInput,
    _u: &mut Unstructured<'_>,
) -> Result<()> {
    if cfg!(not(arc_try_new)) {
        panic!(
            "The OOM fuzzer is disabled because `cfg(arc_try_new)` was not enabled. Build with \
             `RUSTFLAGS=--cfg=arc_try_new` to enable."
        );
    }

    let module_bytes = match compile(&input.config, module) {
        Ok(bytes) => bytes,
        Err(_) => return Ok(()),
    };

    let mut oom_config = input.config.to_wasmtime();
    oom_config.enable_compiler(false);
    oom_config.concurrency_support(false);
    oom_config.consume_fuel(true);

    // Prevent real process-level OOM: fuzzer-generated configs can set
    // `memory_reservation(0)`, forcing `mmap` to commit real pages that bypass
    // `OomTestAllocator`. Use large virtual reservations instead.
    oom_config.memory_reservation(1 << 32);
    oom_config.memory_guard_size(1 << 31);

    let oom_engine = match Engine::new(&oom_config) {
        Ok(e) => e,
        Err(_) => return Ok(()),
    };

    let _ = OomTest::new()
        .seed(input.seed)
        .max_iters(OOM_TEST_ITERS)
        .allow_alloc_after_oom(true)
        .alloc_succeeds_after_oom(true)
        .allow_missed_oom_errors(true)
        .fuzz(|| {
            let module = unsafe { Module::deserialize(&oom_engine, &module_bytes)? };

            let mut store = Store::try_new(&oom_engine, ())?;
            store.set_fuel(OOM_TEST_FUEL).unwrap();

            let linker = dummy::dummy_linker(&mut store, &module)?;
            let instance = linker.instantiate(&mut store, &module)?;

            'export_loop: for export in module.exports() {
                let extern_ty = export.ty();
                let Some(func_ty) = extern_ty.func() else {
                    continue;
                };
                let func = instance.get_func(&mut store, export.name()).unwrap();

                // Build default params; skip if any param type has no default.
                let mut params: TryVec<Val> = TryVec::with_capacity(func_ty.params().len())?;