Method run

icicle-cortexm/src/lib.rs:443–480

(&mut self, vm: &mut icicle_vm::Vm)

    }

    fn run(&mut self, vm: &mut icicle_vm::Vm) -> anyhow::Result<VmExit> {
        let (icicle_exit, fuzzware_exit) = self.with_uc_ptr(vm, |uc| {
            let ctx = unsafe { &mut *(*uc).ctx.cast::<Context>() };
            let vm = unsafe { &mut *ctx.vm };

            let exit = vm.run();

            if let Some(fuzzware_exit) =
                vm.env_mut::<FuzzwareEnvironment>().unwrap().fuzzware_exit.take()
            {
                let icicle_exit = match fuzzware_exit {
                    fuzzware::uc_err::UC_ERR_OK => VmExit::Halt,

                    fuzzware::uc_err::UC_ERR_BLOCK_LIMIT
                    | fuzzware::uc_err::UC_ERR_NO_FUZZ_CONSUMPTION
                    | fuzzware::uc_err::UC_ERR_INTERRUPT_LIMIT => VmExit::InstructionLimit,

                    fuzzware::uc_err::UC_ERR_NVIC_ASSERTION => {
                        VmExit::UnhandledException((ExceptionCode::InternalError, 0))
                    }

                    fuzzware::uc_err::UC_ERR_NVIC_RESET => VmExit::Killed,

                    fuzzware::uc_err::UC_ERR_FETCH_PROT => VmExit::UnhandledException((
                        ExceptionCode::InvalidInstruction,
                        vm.cpu.read_pc(),
                    )),

                    x => VmExit::UnhandledException((ExceptionCode::UnknownError, x as u64)),
                };
                return (icicle_exit, fuzzware_exit);
            }
            (exit, fuzzware::uc_err::UC_ERR_OK)
        });

        self.fuzzware_exit = fuzzware_exit;
        Ok(icicle_exit)
    }
}

impl<T> icicle_fuzzing::FuzzTarget for CortexmTarget<T> {