Function replay_trace

hail-fuzz/src/debugging/replay.rs:217–265

(mut vm: Vm, mut target: CortexmMultiStream)

}

fn replay_trace(mut vm: Vm, mut target: CortexmMultiStream) -> anyhow::Result<()> {
    let path_tracer = trace::add_path_tracer(&mut vm, target.mmio_handler.unwrap())?;

    let mut cmplog = None;
    if icicle_fuzzing::parse_bool_env("REPLAY_CMPLOG")?.unwrap_or(false) {
        let cmplog_ref =
            icicle_fuzzing::cmplog2::CmpLog2Builder::new().instrument_calls(true).finish(&mut vm);
        cmplog_ref.set_enabled(&mut vm.cpu, true);
        cmplog = Some(cmplog_ref);
    }

    icicle_fuzzing::add_debug_instrumentation(&mut vm);

    let exit = target.run(&mut vm)?;

    let xpsr = vm.cpu.arch.sleigh.get_varnode("xpsr").unwrap();
    let active_irq = vm.cpu.read_reg(xpsr) & 0x1ff;
    eprintln!(
        "\n[icicle] exited with: {} (icount = {}), active_irq = {active_irq}",
        target.exit_string(exit),
        vm.cpu.icount()
    );
    eprintln!("[icicle] callstack:\n{}", icicle_vm::debug::backtrace(&mut vm));

    let print_count = match std::env::var("PRINT_LAST_BLOCKS").ok() {
        Some(c) => c.parse().context("Failed to parse `PRINT_LAST_BLOCKS` environment variable")?,
        None => 10,
    };
    eprintln!("[icicle] last blocks:\n{}", path_tracer.print_last_blocks(&mut vm, print_count));

    let reglist = icicle_vm::debug::get_debug_regs(&vm.cpu);
    eprintln!("registers:\n{}", icicle_vm::debug::print_regs(&vm, &reglist));

    if let Some(cmplog) = cmplog {
        log_cmplog_data(&mut vm, cmplog, "cmplog.txt".as_ref())?;
    }
    if icicle_fuzzing::parse_bool_env("SAVE_TRACE")?.unwrap_or(true) {
        let symbolize = icicle_fuzzing::parse_bool_env("SYMBOLIZE_TRACE")?.unwrap_or(false);
        path_tracer.save_trace(&mut vm, "trace.txt".as_ref(), symbolize);
    }
    if icicle_fuzzing::parse_bool_env("SAVE_MMIO_READS")?.unwrap_or(false) {
        trace::save_mmio_reads("mmio_reads.txt".as_ref(), &path_tracer.get_mmio_reads(&mut vm));
    }
    if icicle_fuzzing::parse_bool_env("DEBUG_IL")?.unwrap_or(false) {
        std::fs::write("il.pcode", icicle_vm::debug::dump_semantics(&vm)?)?;
    }

    Ok(())
}

pub fn analyze_crashes(mut config: Config, path: &str) -> anyhow::Result<()> {
    let features = config::EnabledFeatures::from_env()?;