Method handle_exception

icicle-cortexm/src/lib.rs:672–725

(&mut self, cpu: &mut Cpu)

    }

    fn handle_exception(&mut self, cpu: &mut Cpu) -> Option<VmExit> {
        match ExceptionCode::from_u32(cpu.exception.code) {
            ExceptionCode::Syscall => {
                // Update PC to point to the next pc value (this is not done inside of the SVC
                // handler).
                cpu.resume_next();
                unsafe {
                    fuzzware::handler_svc(self.uc_ptr, crate::arm::EXCP_SWI, std::ptr::null_mut());
                }
            }
            ExceptionCode::SoftwareBreakpoint => {
                // Ignore software breakpoints while fuzzing (these sometimes occur during panic
                // handlers).
                cpu.exception.clear();
                cpu.resume_next();
            }
            ExceptionCode::Sleep => {
                self.trigger_next_time_based_interrupt();
                cpu.exception.clear();
                cpu.resume_next();
            }
            ExceptionCode::Halt => {
                // Report as a deadlock if halt occurs inside of a IRQ
                let exception_number = self.get_active_exception(cpu);
                if exception_number != 0 {
                    // @todo: allow this if nested interrupts are enabled?.
                    tracing::debug!("Deadlock in IRQ: {exception_number}");
                    return Some(VmExit::Deadlock);
                }

                if self.trigger_interrupt_on_halt {
                    self.force_trigger_next_time_based_interrupt();
                    cpu.exception.clear();
                }
                else {
                    return Some(VmExit::InstructionLimit);
                }
            }
            ExceptionCode::CodeNotTranslated
            | ExceptionCode::InvalidInstruction
            | ExceptionCode::ShadowStackInvalid => {
                let value = cpu.exception.value as u32;
                if is_arm_exception_return(value) {
                    cpu.exception.clear();
                    unsafe { fuzzware::ExceptionReturn(self.uc_ptr, value) }
                }
            }
            _ => {
                // Any other exceptions are left for the emulator to handle.
            }
        }

        None
    }

    fn snapshot(&mut self) -> Box<dyn std::any::Any> {
        Box::new((self.saved_prev, FuzzwareSnapshot::take(self.uc_ptr)))