Trait polkavm_common::program::InstructionVisitor

pub trait InstructionVisitor {
    type ReturnTy;

    // Required methods
    fn trap(&mut self) -> Self::ReturnTy;
    fn fallthrough(&mut self) -> Self::ReturnTy;
    fn call(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn jump_indirect(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn load_imm(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn load_u8(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn load_i8(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn load_u16(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn load_i16(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn load_u32(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn store_u8(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn store_u16(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn store_u32(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy;
    fn branch_eq_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_not_eq_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_less_unsigned_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_less_signed_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_greater_or_equal_unsigned_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_greater_or_equal_signed_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_less_or_equal_signed_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_less_or_equal_unsigned_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_greater_signed_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn branch_greater_unsigned_imm(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn store_imm_indirect_u8(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn store_imm_indirect_u16(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn store_imm_indirect_u32(
        &mut self,
        reg: Reg,
        imm1: u32,
        imm2: u32,
    ) -> Self::ReturnTy;
    fn store_indirect_u8(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn store_indirect_u16(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn store_indirect_u32(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn load_indirect_u8(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn load_indirect_i8(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn load_indirect_u16(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn load_indirect_i16(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn load_indirect_u32(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn call_indirect(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn add_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy;
    fn and_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy;
    fn xor_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy;
    fn or_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy;
    fn mul_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy;
    fn mul_upper_signed_signed_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn mul_upper_unsigned_unsigned_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn set_less_than_unsigned_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn set_less_than_signed_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn shift_logical_left_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn shift_logical_right_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn shift_arithmetic_right_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn negate_and_add_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn set_greater_than_unsigned_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn set_greater_than_signed_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn shift_logical_right_imm_alt(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn shift_arithmetic_right_imm_alt(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn shift_logical_left_imm_alt(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn branch_eq(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy;
    fn branch_not_eq(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn branch_less_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn branch_less_signed(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn branch_greater_or_equal_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn branch_greater_or_equal_signed(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn cmov_if_zero_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn cmov_if_not_zero_imm(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        imm: u32,
    ) -> Self::ReturnTy;
    fn add(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn sub(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn and(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn xor(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn or(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn mul(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn mul_upper_signed_signed(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn mul_upper_unsigned_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn mul_upper_signed_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn set_less_than_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn set_less_than_signed(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn shift_logical_left(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn shift_logical_right(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn shift_arithmetic_right(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn div_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn div_signed(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn rem_unsigned(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn rem_signed(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy;
    fn cmov_if_zero(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn cmov_if_not_zero(
        &mut self,
        reg1: Reg,
        reg2: Reg,
        reg3: Reg,
    ) -> Self::ReturnTy;
    fn jump(&mut self, imm: u32) -> Self::ReturnTy;
    fn ecalli(&mut self, imm: u32) -> Self::ReturnTy;
    fn store_imm_u8(&mut self, imm1: u32, imm2: u32) -> Self::ReturnTy;
    fn store_imm_u16(&mut self, imm1: u32, imm2: u32) -> Self::ReturnTy;
    fn store_imm_u32(&mut self, imm1: u32, imm2: u32) -> Self::ReturnTy;
    fn move_reg(&mut self, reg1: Reg, reg2: Reg) -> Self::ReturnTy;
    fn sbrk(&mut self, reg1: Reg, reg2: Reg) -> Self::ReturnTy;
}

Required Associated Types

type ReturnTy

Required Methods

fn trap(&mut self) -> Self::ReturnTy

fn fallthrough(&mut self) -> Self::ReturnTy

fn call(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn jump_indirect(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn load_imm(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn load_u8(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn load_i8(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn load_u16(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn load_i16(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn load_u32(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn store_u8(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn store_u16(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn store_u32(&mut self, reg: Reg, imm: u32) -> Self::ReturnTy

fn branch_eq_imm(&mut self, reg: Reg, imm1: u32, imm2: u32) -> Self::ReturnTy

fn branch_not_eq_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_less_unsigned_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_less_signed_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_unsigned_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_signed_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_less_or_equal_signed_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_less_or_equal_unsigned_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_greater_signed_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn branch_greater_unsigned_imm( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn store_imm_indirect_u8( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn store_imm_indirect_u16( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn store_imm_indirect_u32( &mut self, reg: Reg, imm1: u32, imm2: u32, ) -> Self::ReturnTy

fn store_indirect_u8( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn store_indirect_u16( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn store_indirect_u32( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn load_indirect_u8(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn load_indirect_i8(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn load_indirect_u16( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn load_indirect_i16( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn load_indirect_u32( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn call_indirect(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn add_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn and_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn xor_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn or_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn mul_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn mul_upper_signed_signed_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn mul_upper_unsigned_unsigned_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn set_less_than_unsigned_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn set_less_than_signed_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn shift_logical_left_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn shift_logical_right_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn shift_arithmetic_right_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn negate_and_add_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn set_greater_than_unsigned_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn set_greater_than_signed_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn shift_logical_right_imm_alt( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn shift_arithmetic_right_imm_alt( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn shift_logical_left_imm_alt( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn branch_eq(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn branch_not_eq(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn branch_less_unsigned( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn branch_less_signed( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_unsigned( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_signed( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn cmov_if_zero_imm(&mut self, reg1: Reg, reg2: Reg, imm: u32) -> Self::ReturnTy

fn cmov_if_not_zero_imm( &mut self, reg1: Reg, reg2: Reg, imm: u32, ) -> Self::ReturnTy

fn add(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn sub(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn and(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn xor(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn or(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn mul(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn mul_upper_signed_signed( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn mul_upper_unsigned_unsigned( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn mul_upper_signed_unsigned( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn set_less_than_unsigned( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn set_less_than_signed( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn shift_logical_left( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn shift_logical_right( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn shift_arithmetic_right( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn div_unsigned(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn div_signed(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn rem_unsigned(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn rem_signed(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn cmov_if_zero(&mut self, reg1: Reg, reg2: Reg, reg3: Reg) -> Self::ReturnTy

fn cmov_if_not_zero( &mut self, reg1: Reg, reg2: Reg, reg3: Reg, ) -> Self::ReturnTy

fn jump(&mut self, imm: u32) -> Self::ReturnTy

fn ecalli(&mut self, imm: u32) -> Self::ReturnTy

fn store_imm_u8(&mut self, imm1: u32, imm2: u32) -> Self::ReturnTy

fn store_imm_u16(&mut self, imm1: u32, imm2: u32) -> Self::ReturnTy

fn store_imm_u32(&mut self, imm1: u32, imm2: u32) -> Self::ReturnTy

fn move_reg(&mut self, reg1: Reg, reg2: Reg) -> Self::ReturnTy

fn sbrk(&mut self, reg1: Reg, reg2: Reg) -> Self::ReturnTy

Implementations on Foreign Types

impl<'a> InstructionVisitor for Formatter<'a>

type ReturnTy = Result<(), Error>

fn trap(&mut self) -> Self::ReturnTy

fn fallthrough(&mut self) -> Self::ReturnTy

fn sbrk(&mut self, d: Reg, s: Reg) -> Self::ReturnTy

fn ecalli(&mut self, nth_import: u32) -> Self::ReturnTy

fn set_less_than_unsigned(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn set_less_than_signed(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn shift_logical_right(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn shift_arithmetic_right(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn shift_logical_left(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn xor(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn and(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn or(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn add(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn sub(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn mul(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn mul_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn mul_upper_signed_signed( &mut self, d: Reg, s1: Reg, s2: Reg, ) -> Self::ReturnTy

fn mul_upper_signed_signed_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn mul_upper_unsigned_unsigned( &mut self, d: Reg, s1: Reg, s2: Reg, ) -> Self::ReturnTy

fn mul_upper_unsigned_unsigned_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn mul_upper_signed_unsigned( &mut self, d: Reg, s1: Reg, s2: Reg, ) -> Self::ReturnTy

fn div_unsigned(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn div_signed(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn rem_unsigned(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn rem_signed(&mut self, d: Reg, s1: Reg, s2: Reg) -> Self::ReturnTy

fn set_less_than_unsigned_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn set_greater_than_unsigned_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn set_less_than_signed_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn set_greater_than_signed_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn shift_logical_right_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn shift_logical_right_imm_alt( &mut self, d: Reg, s2: Reg, s1: u32, ) -> Self::ReturnTy

fn shift_arithmetic_right_imm( &mut self, d: Reg, s1: Reg, s2: u32, ) -> Self::ReturnTy

fn shift_arithmetic_right_imm_alt( &mut self, d: Reg, s2: Reg, s1: u32, ) -> Self::ReturnTy

fn shift_logical_left_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn shift_logical_left_imm_alt( &mut self, d: Reg, s2: Reg, s1: u32, ) -> Self::ReturnTy

fn or_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn and_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn xor_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn load_imm(&mut self, d: Reg, a: u32) -> Self::ReturnTy

fn move_reg(&mut self, d: Reg, s: Reg) -> Self::ReturnTy

fn cmov_if_zero(&mut self, d: Reg, s: Reg, c: Reg) -> Self::ReturnTy

fn cmov_if_not_zero(&mut self, d: Reg, s: Reg, c: Reg) -> Self::ReturnTy

fn cmov_if_zero_imm(&mut self, d: Reg, c: Reg, s: u32) -> Self::ReturnTy

fn cmov_if_not_zero_imm(&mut self, d: Reg, c: Reg, s: u32) -> Self::ReturnTy

fn add_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn negate_and_add_imm(&mut self, d: Reg, s1: Reg, s2: u32) -> Self::ReturnTy

fn store_imm_indirect_u8( &mut self, base: Reg, offset: u32, value: u32, ) -> Self::ReturnTy

fn store_imm_indirect_u16( &mut self, base: Reg, offset: u32, value: u32, ) -> Self::ReturnTy

fn store_imm_indirect_u32( &mut self, base: Reg, offset: u32, value: u32, ) -> Self::ReturnTy

fn store_indirect_u8( &mut self, src: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn store_indirect_u16( &mut self, src: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn store_indirect_u32( &mut self, src: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn store_imm_u8(&mut self, value: u32, offset: u32) -> Self::ReturnTy

fn store_imm_u16(&mut self, value: u32, offset: u32) -> Self::ReturnTy

fn store_imm_u32(&mut self, value: u32, offset: u32) -> Self::ReturnTy

fn store_u8(&mut self, src: Reg, offset: u32) -> Self::ReturnTy

fn store_u16(&mut self, src: Reg, offset: u32) -> Self::ReturnTy

fn store_u32(&mut self, src: Reg, offset: u32) -> Self::ReturnTy

fn load_indirect_u8( &mut self, dst: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn load_indirect_i8( &mut self, dst: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn load_indirect_u16( &mut self, dst: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn load_indirect_i16( &mut self, dst: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn load_indirect_u32( &mut self, dst: Reg, base: Reg, offset: u32, ) -> Self::ReturnTy

fn load_u8(&mut self, dst: Reg, offset: u32) -> Self::ReturnTy

fn load_i8(&mut self, dst: Reg, offset: u32) -> Self::ReturnTy

fn load_u16(&mut self, dst: Reg, offset: u32) -> Self::ReturnTy

fn load_i16(&mut self, dst: Reg, offset: u32) -> Self::ReturnTy

fn load_u32(&mut self, dst: Reg, offset: u32) -> Self::ReturnTy

fn branch_less_unsigned(&mut self, s1: Reg, s2: Reg, imm: u32) -> Self::ReturnTy

fn branch_less_signed(&mut self, s1: Reg, s2: Reg, imm: u32) -> Self::ReturnTy

fn branch_less_unsigned_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_less_signed_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_unsigned( &mut self, s1: Reg, s2: Reg, imm: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_signed( &mut self, s1: Reg, s2: Reg, imm: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_unsigned_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_greater_or_equal_signed_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_eq(&mut self, s1: Reg, s2: Reg, imm: u32) -> Self::ReturnTy

fn branch_not_eq(&mut self, s1: Reg, s2: Reg, imm: u32) -> Self::ReturnTy

fn branch_eq_imm(&mut self, s1: Reg, s2: u32, imm: u32) -> Self::ReturnTy

fn branch_not_eq_imm(&mut self, s1: Reg, s2: u32, imm: u32) -> Self::ReturnTy

fn branch_less_or_equal_unsigned_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_less_or_equal_signed_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_greater_unsigned_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn branch_greater_signed_imm( &mut self, s1: Reg, s2: u32, imm: u32, ) -> Self::ReturnTy

fn jump(&mut self, target: u32) -> Self::ReturnTy

fn call(&mut self, ra: Reg, target: u32) -> Self::ReturnTy

fn jump_indirect(&mut self, base: Reg, offset: u32) -> Self::ReturnTy

fn call_indirect(&mut self, ra: Reg, base: Reg, offset: u32) -> Self::ReturnTy

Implementors