Struct AddressComputation

pub struct AddressComputation {
    pub offset: i64,
    pub terms: [AddrTerm; 4],
}

An address computation of a memory access.

The address computation is a sum of shift-then-multiplied values. For example: A + (B >> 1) * 4 + offset

Fields

offset: i64

The offsets that is added to the computation.

terms: [AddrTerm; 4]

The terms in the computation. There are always four terms, but some terms may be effectively 0.

Implementations

impl AddressComputation

pub fn compute<A: Arch>( &self, inputs: &Inputs<A>, state: &SystemState<A>, ) -> u64

Computes the address accessed by the instruction when executed on state, given that the computation uses inputs.

pub fn compute_from_gpregs<A: Arch>( &self, inputs: &[A::GpReg], state: &SystemState<A>, ) -> u64

Computes the address accessed by the instruction when executed on state, given that the computation uses inputs.

pub fn evaluate(&self, inputs: &[u64]) -> u64

Computes the address, using inputs.

pub fn evaluate_from_iter(&self, inputs: impl Iterator<Item = u64>) -> u64

Computes the address, using inputs.

impl AddressComputation

pub fn unscaled_sum(num: usize) -> AddressComputation

An address computation of the form A + B + C. num determines the number of inputs. num cannot be more than 4.

pub fn with_offset(self, offset: i64) -> AddressComputation

Returns a new computation with the offset replaced with the specified offset.

pub fn with_added_offset(self, offset: i64) -> AddressComputation

Returns a new computation with the offset incremented with the specified offset.

pub fn new_with_inferred_offset<A: Arch>( terms: [AddrTerm; 4], inputs: &Inputs<A>, state: &SystemState<A>, expected: u64, ) -> AddressComputation

Returns a new computation with an offset inferred from the expected address expected.

pub fn from_iter( terms: impl Iterator<Item = AddrTerm>, offset: i64, ) -> AddressComputation

Returns a new computation with the terms (max 4) from terms and the offset specified.

pub fn constant_offset_with(&self, other: &AddressComputation) -> Option<i64>

Returns the fixed difference (other - self) between two address calculations, if they are given the same inputs When adding this offset to the address for self, you will obtain the adress for other.

pub fn constant_offset_considering_inputs<A: Arch>( &self, inputs: &Inputs<A>, other: &AddressComputation, other_inputs: &Inputs<A>, ) -> Option<i64>

Returns the fixed difference (other - self) between two address calculations, if they are given the same inputs When adding this offset to the address for self, you will obtain the adress for other.

pub fn add_constant_term(&mut self)

Adds a new AddrTerm::identity term if there are less than 4 terms. Otherwise, does nothing.

pub fn remove_term(self, index: usize) -> AddressComputation

Removes the term at position index from the computation. If there are less than index + 1 terms, the same computation is returned.

pub fn unify_terms( self, first_index: usize, second_index: usize, ) -> Option<AddressComputation>

Combines the two terms, assuming they have the same index. For example, A + A * 2 would be unified to A * 3.

Trait Implementations

impl Clone for AddressComputation

fn clone(&self) -> AddressComputation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Computation for AddressComputation

fn evaluate<V: AsValue>(&self, inputs: &[V]) -> OwnedValue

Computes the output of the semantics, given inputs.

fn display<'a, S: AsRef<str>>( &'a self, input_names: &'a [S], ) -> impl Display + Debug + 'a

Returns a struct that is suitable for printing, which uses input_names in place of the inputs.

fn used_input_indices(&self) -> Vec<usize>

The indices of all inputs used in the computation.

fn remap_inputs(&mut self, map: &[Option<usize>])

Remaps the input indices, such that new_index = map[old_index].unwrap_or(old_index).

fn is_identity(&self) -> bool

Returns true when the computation is the identity function. This function may under-approximate: it does not necessarily have to return true in all cases.

fn compare_eq<V: AsValue>(&self, inputs: &[V], expected: Value<'_>) -> bool

Returns true if expected matches the output of the computation. This function can be more efficient than manually comparing the result of self.evaluate(..). For example, we can avoid allocating a Vec for OwnedValue::Bytes results.

impl Debug for AddressComputation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AddressComputation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for AddressComputation

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 JsonSchema for AddressComputation

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Ord for AddressComputation

fn cmp(&self, other: &AddressComputation) -> 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,

Restrict a value to a certain interval.

impl PartialEq for AddressComputation

fn eq(&self, other: &AddressComputation) -> 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 AddressComputation

fn partial_cmp(&self, other: &AddressComputation) -> 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 Serialize for AddressComputation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for AddressComputation

impl Eq for AddressComputation

impl StructuralPartialEq for AddressComputation