Struct Dataflows

pub struct Dataflows<A: Arch, C> {
    pub addresses: MemoryAccesses<A>,
    pub outputs: Vec<Dataflow<A, C>>,
    pub found_dependent_bytes: bool,
}

A collection of dataflows and memory accesses.

Fields

addresses: MemoryAccesses<A>

The memory accesses of these dataflows.

outputs: Vec<Dataflow<A, C>>

The outputs of the dataflows.

found_dependent_bytes: bool

Whether any dependent bytes were found during Dataflow Analysis.

Implementations

impl<A: Arch, C> Dataflows<A, C>

pub fn instr(&self) -> &Instruction

Returns the instruction for which these dataflow apply.

pub fn output_dataflows(&self) -> impl Iterator<Item = &Dataflow<A, C>>

Iterates over all dataflows.

pub fn output_dataflow(&self, index: usize) -> &Dataflow<A, C>

Returns the dataflow at position index.

pub fn values( &self, ) -> impl Iterator<Item = (FlowValueLocation, Source<A>)> + '_

Returns all sources in these dataflows.

pub fn get(&self, loc: &Dest<A>) -> Option<&Dataflow<A, C>>

Returns the dataflow with target set to loc.

pub fn extract_memory_areas<'a>( &'a self, state: &'a SystemState<A>, ) -> impl Iterator<Item = Area> + 'a

Returns the memory areas read or written by these dataflows.

pub fn execute(&self, state: &mut SystemState<A>)

where C: Computation,

Executes the dataflows on state, modifying the state.

pub fn map_computations<CNew>( &self, f: impl Fn(&Inputs<A>, &C) -> Option<CNew>, ) -> Dataflows<A, CNew>

Maps all computations in the dataflows to new values.

pub fn split_flag_output(&mut self, index: usize) -> usize

Splits flag outputs in the dataflow with position index into individual bytes.

pub fn map( &self, instr: Instruction, map_flows: impl Fn(FlowValueLocation, &Source<A>) -> Option<Source<A>>, map_address_computations: impl Fn(usize, &AddressComputation) -> Option<AddressComputation>, ) -> Dataflows<A, C>

where C: Clone,

Maps each source and destination in the dataflows and memory accesses to new values.

pub fn insert_imm_value( &mut self, output_indices: impl Iterator<Item = usize>, part_index: usize, ) -> Vec<FlowInputLocation>

Adds an immediate value to all outputs in output_indices. Returns a list containing the locations of the inserted Source::Imms.

pub fn insert_memory_imms( &mut self, locations: &[FlowOutputLocation], offset: i64, part_index: usize, ) -> Vec<FlowInputLocation>

where C: Debug,

Adds an immediate value to all memory accesses and outputs in locations. Returns a list containing the locations of the inserted Source::Imms.

pub fn overlapping_outputs<'a>( &'a self, output_dataflows: &'a [&'a Dataflow<A, C>], ) -> impl Iterator<Item = &'a Dataflow<A, C>>

Returns a list of dataflows that overlap with the list provided in output_dataflows.

Trait Implementations

impl<A: Clone + Arch, C: Clone> Clone for Dataflows<A, C>

fn clone(&self) -> Dataflows<A, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Arch, C: Debug> Debug for Dataflows<A, C>

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

Formats the value using the given formatter.

impl<'de, A: Arch, C> Deserialize<'de> for Dataflows<A, C>

where C: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Arch, C: Computation> Display for Dataflows<A, C>

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

Formats the value using the given formatter.

impl<A: Hash + Arch, C: Hash> Hash for Dataflows<A, C>

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<A: Arch, C> Index<usize> for Dataflows<A, C>

type Output = Dataflow<A, C>

The returned type after indexing.

fn index(&self, index: usize) -> &Dataflow<A, C>

Performs the indexing (container[index]) operation.

impl<A: Arch, C> IndexMut<usize> for Dataflows<A, C>

fn index_mut(&mut self, index: usize) -> &mut Dataflow<A, C>

Performs the mutable indexing (container[index]) operation.

impl<A, C> JsonSchema for Dataflows<A, C>

where A: JsonSchema + Arch, A::Reg: JsonSchema, C: JsonSchema,

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<A: PartialEq + Arch, C: PartialEq> PartialEq for Dataflows<A, C>

fn eq(&self, other: &Dataflows<A, C>) -> 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<A: Arch, C> Serialize for Dataflows<A, C>

where C: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Eq + Arch, C: Eq> Eq for Dataflows<A, C>

impl<A: Arch, C> StructuralPartialEq for Dataflows<A, C>