Struct moa_m68k::execute::M68kCycleExecutor

pub struct M68kCycleExecutor<'a, Bus, Instant>
where
    Bus: BusAccess<M68kAddress, Instant = Instant>,
{
    pub state: &'a mut M68kState,
    pub bus: Bus,
    pub debugger: &'a mut M68kDebugger,
    pub cycle: M68kCycle<Instant>,
}

Fields

state: &'a mut M68kState

bus: Bus

debugger: &'a mut M68kDebugger

cycle: M68kCycle<Instant>

Implementations

impl<'a, Bus, BusError, Instant> M68kCycleExecutor<'a, Bus, Instant>

where Bus: BusAccess<M68kAddress, Instant = Instant, Error = BusError>, Instant: Copy,

pub fn check_breakpoints(&mut self) -> Result<(), M68kError<BusError>>

impl<'a, Bus, Instant> M68kCycleExecutor<'a, Bus, Instant>

where Bus: BusAccess<M68kAddress, Instant = Instant>, Instant: Copy,

pub fn end(self) -> M68kCycle<Instant>

impl<'a, Bus, Instant> M68kCycleExecutor<'a, Bus, Instant>

where Bus: BusAccess<M68kAddress, Instant = Instant>, Instant: Copy,

pub fn step(&mut self) -> Result<(), M68kError<Bus::Error>>

pub fn reset_cpu(&mut self) -> Result<(), M68kError<Bus::Error>>

pub fn cycle_one(&mut self) -> Result<(), M68kError<Bus::Error>>

pub fn check_pending_interrupts( &mut self, interrupt: (bool, u8, u8) ) -> Result<(InterruptPriority, Option<u8>), M68kError<Bus::Error>>

pub fn exception( &mut self, number: u8, is_interrupt: bool ) -> Result<(), M68kError<Bus::Error>>

fn setup_group0_exception( &mut self, number: u8 ) -> Result<(), M68kError<Bus::Error>>

fn setup_normal_exception( &mut self, number: u8, is_interrupt: bool ) -> Result<(), M68kError<Bus::Error>>

pub fn process_error( &mut self, result: Result<(), M68kError<Bus::Error>> ) -> Result<(), M68kError<Bus::Error>>

pub fn decode_and_execute(&mut self) -> Result<(), M68kError<Bus::Error>>

pub fn decode_next(&mut self) -> Result<(), M68kError<Bus::Error>>

pub fn execute_current(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_abcd( &mut self, src: Target, dest: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_add( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_adda( &mut self, src: Target, dest: Register, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_addx( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_and( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_and_to_ccr(&mut self, value: u8) -> Result<(), M68kError<Bus::Error>>

fn execute_and_to_sr(&mut self, value: u16) -> Result<(), M68kError<Bus::Error>>

fn execute_asl( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_asr( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn set_arithmetic_shift_flags( &mut self, result: u32, count: u32, last_bit_out: bool, overflow: bool, size: Size )

fn execute_bcc( &mut self, cond: Condition, offset: i32 ) -> Result<(), M68kError<Bus::Error>>

fn execute_bra(&mut self, offset: i32) -> Result<(), M68kError<Bus::Error>>

fn execute_bsr(&mut self, offset: i32) -> Result<(), M68kError<Bus::Error>>

fn execute_bchg( &mut self, bitnum: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_bclr( &mut self, bitnum: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_bset( &mut self, bitnum: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_btst( &mut self, bitnum: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_bfchg( &mut self, target: Target, offset: RegOrImmediate, width: RegOrImmediate ) -> Result<(), M68kError<Bus::Error>>

fn execute_bfclr( &mut self, target: Target, offset: RegOrImmediate, width: RegOrImmediate ) -> Result<(), M68kError<Bus::Error>>

fn execute_bfexts( &mut self, target: Target, offset: RegOrImmediate, width: RegOrImmediate, reg: Register ) -> Result<(), M68kError<Bus::Error>>

fn execute_bfextu( &mut self, target: Target, offset: RegOrImmediate, width: RegOrImmediate, reg: Register ) -> Result<(), M68kError<Bus::Error>>

fn execute_bfset( &mut self, target: Target, offset: RegOrImmediate, width: RegOrImmediate ) -> Result<(), M68kError<Bus::Error>>

fn execute_bftst( &mut self, target: Target, offset: RegOrImmediate, width: RegOrImmediate ) -> Result<(), M68kError<Bus::Error>>

fn execute_chk( &mut self, target: Target, reg: Register, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_clr( &mut self, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_cmp( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_cmpa( &mut self, src: Target, reg: Register, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_dbcc( &mut self, cond: Condition, reg: Register, offset: i16 ) -> Result<(), M68kError<Bus::Error>>

fn execute_divw( &mut self, src: Target, dest: Register, sign: Sign ) -> Result<(), M68kError<Bus::Error>>

fn execute_divl( &mut self, src: Target, dest_h: Option<Register>, dest_l: Register, sign: Sign ) -> Result<(), M68kError<Bus::Error>>

fn execute_eor( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_eor_to_ccr(&mut self, value: u8) -> Result<(), M68kError<Bus::Error>>

fn execute_eor_to_sr(&mut self, value: u16) -> Result<(), M68kError<Bus::Error>>

fn execute_exg( &mut self, target1: Target, target2: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_ext( &mut self, reg: Register, from_size: Size, to_size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_illegal(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_jmp(&mut self, target: Target) -> Result<(), M68kError<Bus::Error>>

fn execute_jsr(&mut self, target: Target) -> Result<(), M68kError<Bus::Error>>

fn execute_lea( &mut self, target: Target, reg: Register ) -> Result<(), M68kError<Bus::Error>>

fn execute_link( &mut self, reg: Register, offset: i32 ) -> Result<(), M68kError<Bus::Error>>

fn execute_lsl( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_lsr( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn set_shift_flags( &mut self, result: u32, count: u32, last_bit_out: bool, size: Size )

fn execute_move( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_movea( &mut self, src: Target, reg: Register, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_move_from_sr( &mut self, target: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_move_to_sr( &mut self, target: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_move_to_ccr( &mut self, target: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_movec( &mut self, target: Target, control_reg: ControlRegister, dir: Direction ) -> Result<(), M68kError<Bus::Error>>

fn execute_movem( &mut self, target: Target, size: Size, dir: Direction, mask: u16 ) -> Result<(), M68kError<Bus::Error>>

fn move_memory_to_registers( &mut self, addr: u32, size: Size, mask: u16 ) -> Result<u32, M68kError<Bus::Error>>

fn move_registers_to_memory( &mut self, addr: u32, size: Size, mask: u16 ) -> Result<u32, M68kError<Bus::Error>>

fn move_registers_to_memory_reverse( &mut self, addr: u32, size: Size, mask: u16 ) -> Result<u32, M68kError<Bus::Error>>

fn execute_movep( &mut self, dreg: Register, areg: Register, offset: i16, size: Size, dir: Direction ) -> Result<(), M68kError<Bus::Error>>

fn execute_moveq( &mut self, data: u8, reg: Register ) -> Result<(), M68kError<Bus::Error>>

fn execute_moveusp( &mut self, target: Target, dir: Direction ) -> Result<(), M68kError<Bus::Error>>

fn execute_mulw( &mut self, src: Target, dest: Register, sign: Sign ) -> Result<(), M68kError<Bus::Error>>

fn execute_mull( &mut self, src: Target, dest_h: Option<Register>, dest_l: Register, sign: Sign ) -> Result<(), M68kError<Bus::Error>>

fn execute_nbcd(&mut self, dest: Target) -> Result<(), M68kError<Bus::Error>>

fn execute_neg( &mut self, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_negx( &mut self, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_not( &mut self, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_or( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_or_to_ccr(&mut self, value: u8) -> Result<(), M68kError<Bus::Error>>

fn execute_or_to_sr(&mut self, value: u16) -> Result<(), M68kError<Bus::Error>>

fn execute_pea(&mut self, target: Target) -> Result<(), M68kError<Bus::Error>>

fn execute_reset(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_rol( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_ror( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_roxl( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_roxr( &mut self, count: Target, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn set_rotate_flags(&mut self, result: u32, last_bit_out: bool, size: Size)

fn execute_rte(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_rtr(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_rts(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_scc( &mut self, cond: Condition, target: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_stop(&mut self, flags: u16) -> Result<(), M68kError<Bus::Error>>

fn execute_sbcd( &mut self, src: Target, dest: Target ) -> Result<(), M68kError<Bus::Error>>

fn execute_sbcd_val( &mut self, src_val: u32, dest_val: u32 ) -> Result<u32, M68kError<Bus::Error>>

fn execute_sub( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_suba( &mut self, src: Target, dest: Register, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_subx( &mut self, src: Target, dest: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_swap(&mut self, reg: Register) -> Result<(), M68kError<Bus::Error>>

fn execute_tas(&mut self, target: Target) -> Result<(), M68kError<Bus::Error>>

fn execute_tst( &mut self, target: Target, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn execute_trap(&mut self, number: u8) -> Result<(), M68kError<Bus::Error>>

fn execute_trapv(&mut self) -> Result<(), M68kError<Bus::Error>>

fn execute_unlk(&mut self, reg: Register) -> Result<(), M68kError<Bus::Error>>

fn execute_unimplemented_a( &mut self, _: u16 ) -> Result<(), M68kError<Bus::Error>>

fn execute_unimplemented_f( &mut self, _: u16 ) -> Result<(), M68kError<Bus::Error>>

pub(crate) fn get_target_value( &mut self, target: Target, size: Size, used: Used ) -> Result<u32, M68kError<Bus::Error>>

pub(crate) fn set_target_value( &mut self, target: Target, value: u32, size: Size, used: Used ) -> Result<(), M68kError<Bus::Error>>

fn get_target_address( &mut self, target: Target ) -> Result<u32, M68kError<Bus::Error>>

fn post_increment_areg_target( &mut self, reg: Register, size: Size, used: Used ) -> u32

fn pre_decrement_areg_target( &mut self, reg: Register, size: Size, used: Used ) -> u32

fn get_address_sized( &mut self, addr: M68kAddress, size: Size ) -> Result<u32, M68kError<Bus::Error>>

fn set_address_sized( &mut self, addr: M68kAddress, value: u32, size: Size ) -> Result<(), M68kError<Bus::Error>>

fn push_word(&mut self, value: u16) -> Result<(), M68kError<Bus::Error>>

fn pop_word(&mut self) -> Result<u16, M68kError<Bus::Error>>

fn push_long(&mut self, value: u32) -> Result<(), M68kError<Bus::Error>>

fn pop_long(&mut self) -> Result<u32, M68kError<Bus::Error>>

fn set_pc(&mut self, value: u32) -> Result<(), M68kError<Bus::Error>>

pub fn get_bit_field_args( &self, offset: RegOrImmediate, width: RegOrImmediate ) -> (u32, u32)

fn get_reg_or_immediate(&self, value: RegOrImmediate) -> u32

fn get_x_reg_value(&self, xreg: XRegister) -> u32

fn get_base_reg_value(&self, base_reg: BaseRegister) -> u32

fn get_index_reg_value(&self, index_reg: &Option<IndexRegister>) -> i32

fn get_control_reg_mut(&mut self, control_reg: ControlRegister) -> &mut u32

fn get_stack_pointer_mut(&mut self) -> &mut u32

fn get_a_reg(&self, reg: Register) -> u32

fn get_a_reg_mut(&mut self, reg: Register) -> &mut u32

fn is_supervisor(&self) -> bool

fn require_supervisor(&self) -> Result<(), M68kError<Bus::Error>>

fn set_sr(&mut self, value: u16)

fn get_flag(&self, flag: Flags) -> bool

fn set_flag(&mut self, flag: Flags, value: bool)

fn set_compare_flags( &mut self, value: u32, size: Size, carry: bool, overflow: bool )

fn set_logic_flags(&mut self, value: u32, size: Size)

fn set_bit_test_flags(&mut self, value: u32, bitnum: u32, size: Size) -> u32

fn set_bit_field_test_flags(&mut self, field: u32, msb_mask: u32)

fn get_current_condition(&self, cond: Condition) -> bool