Struct simics_api_sys::bindings::decoder_t

#[repr(C)]
pub struct decoder_t {
    pub user_data: *mut c_void,
    pub decode: Option<unsafe extern "C" fn(code: *mut uint8, valid_bytes: c_int, cpu: *mut conf_object_t, ii: *mut instruction_info_t, user_data: *mut c_void) -> c_int>,
    pub disassemble: Option<unsafe extern "C" fn(code: *mut uint8, valid_bytes: c_int, cpu: *mut conf_object_t, user_data: *mut c_void) -> tuple_int_string_t>,
    pub flush: Option<unsafe extern "C" fn(ii: *mut instruction_info_t, user_data: *mut c_void) -> c_int>,
}

decoder_t

The decode function is called to decode an instruction pointed to by code. The first byte corresponds to the lowest address of the instruction in the simulated memory. valid_bytes tells how many bytes can be read. The CPU is given in the cpu parameter. When the decoder has successfully decoded an instruction, it should set the ii_ServiceRoutine, the ii_Arg, and the ii_Type members of the ii structure (see below), and returns the number of bytes used in the decoding. If it does not apply to the given instruction, it should return zero. If the decoder needs more data than valid_bytes it should return a negative number corresponding to the total number of bytes it will need to continue the decoding. The underlying architecture limits the number of bytes that can be requested, e.g. no more than 4 bytes can be requested on most RISC architectures. Simics will call the decoder again when more bytes are available. This process is repeated until the decoder accepts or rejects the instruction. A decoder should never request more data than it needs. For example, if an instructions can be rejected by looking at the first byte, the decoder should never ask for more bytes.

The instruction_info_t is defined as follows:

The disassemble function is called to disassemble an instruction. It uses the same code,

valid_bytes, and cpu parameters as the decode function. If the disassembly is valid, then the string part of the returned tuple_int_string_t struct should be a MALLOCed string with the disassembly and the integer part should be its length in bytes. The caller is responsible for freeing the disassembly string. The string member should be NULL and the integer part should be zero if the disassembly is not valid. If the disassemble function needs more data than valid_bytes it should return a negative number in the integer part in the same way as the decode function, and set the string part to NULL.

The flush function is called to free any memory allocated when decoding an instruction and any user data associated with the instruction. It should return zero if it does not recognize the instruction, and non-zero if it has accepted it. Usually, the way to recognize if a decoded instruction is the right one to flush is to compare ii->ii_ServiceRoutine with the function that was set in the decode function. Note that the cpu parameter is the processor that caused the flush. It is more or less an arbitrary processor and should be ignored.

In addition to the function pointers, the decoder_t structure contains a user_data pointer that is passed to all the functions. This can be used for passing any data to the decoder functions.

Fields

user_data: *mut c_void

decode: Option<unsafe extern "C" fn(code: *mut uint8, valid_bytes: c_int, cpu: *mut conf_object_t, ii: *mut instruction_info_t, user_data: *mut c_void) -> c_int>

disassemble: Option<unsafe extern "C" fn(code: *mut uint8, valid_bytes: c_int, cpu: *mut conf_object_t, user_data: *mut c_void) -> tuple_int_string_t>

flush: Option<unsafe extern "C" fn(ii: *mut instruction_info_t, user_data: *mut c_void) -> c_int>

Trait Implementations

impl Clone for decoder_t

fn clone(&self) -> decoder_t

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for decoder_t

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for decoder_t

fn default() -> Self

Returns the “default value” for a type.

impl Hash for decoder_t

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for decoder_t

fn cmp(&self, other: &decoder_t) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for decoder_t

fn eq(&self, other: &decoder_t) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for decoder_t

fn partial_cmp(&self, other: &decoder_t) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for decoder_t

impl Eq for decoder_t

impl StructuralPartialEq for decoder_t