Struct InstructionModifiers 

pub struct InstructionModifiers<A: Arch + ValueLocations>
where
    A::Location: AbiDefaults,
{
    pub calls: HashMap<A::Address, A::Address>,
    /* private fields */
}

The Vec<ModifierExpression> are conjunctions. This differs from ValueSet, which uses a sequence of values as disjunctions. This means there’s no way to express a sparseset of values as ModifierExpression, for the time being.

Fields

calls: HashMap<A::Address, A::Address>

Implementations

impl<A: Arch + ValueLocations> InstructionModifiers<A>

where A::Location: AbiDefaults,

pub fn new( fn_query: Rc<RefCell<HashMap<A::Address, FunctionImpl<A::Location>>>>, ) -> Self

pub fn modifiers_between( &self, from: A::Address, to: A::Address, ) -> Option<&HashMap<Option<A::Location>, Vec<ModifierExpression>>>

pub fn add_edge_modifier( &mut self, from: A::Address, to: A::Address, loc: Option<A::Location>, expr: ModifierExpression, )

Trait Implementations

impl ConditionalBoundInference<Arch, InstructionModifiers<Arch>> for ConditionalInference

fn inferrable_conditional( conditional_instr: &<x86_64 as Arch>::Instruction, ) -> bool

Is the instruction in question one that an implementor might want to look at?

fn conditional_source_for( conditional_instr: &<x86_64 as Arch>::Instruction, addr: <x86_64 as Arch>::Address, dfg: &SSA<x86_64>, ) -> Option<(<x86_64 as Arch>::Address, DefSource<<x86_64 as Arch>::Address>)>

Finds the instruction responsible for the condition that conditional_instr branches on. For some architectures, this may be a ways earlier in the program. For others, this may simply be “the conditional instruction”.

fn infer_conditional_bounds( curr_block: <x86_64 as Arch>::Address, test_instr: &<x86_64 as Arch>::Instruction, test_addr: <x86_64 as Arch>::Address, conditional_instr: &<x86_64 as Arch>::Instruction, conditional_addr: <x86_64 as Arch>::Address, _cfg: &ControlFlowGraph<<x86_64 as Arch>::Address>, _dfg: &SSA<x86_64>, aux_data: &mut InstructionModifiers<x86_64>, ) -> bool

This yadda yadda’s the good stuff. Given a conditional instruction, and instruction that decides its conditionality (these may be the same!) apply bounds to the program for control-depndent edges.

fn add_conditional_bounds<M: MemoryRange<A>>( block_start: A::Address, conditional: A::Address, conditional_instr: &A::Instruction, cfg: &ControlFlowGraph<A::Address>, dfg: &SSA<A>, data: &M, aux_data: &mut U, ) -> bool

where A: DecodeFrom<M>,

impl<A: Debug + Arch + ValueLocations> Debug for InstructionModifiers<A>

where A::Location: AbiDefaults + Debug, A::Address: Debug,

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

Formats the value using the given formatter.

impl<'de, A: Arch + ValueLocations> Deserialize<'de> for InstructionModifiers<A>

where A::Location: AbiDefaults,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Arch + ValueLocations> ModifierCollection<A> for InstructionModifiers<A>

where A::Location: AbiDefaults,

fn between( &self, from: A::Address, to: A::Address, ) -> Vec<(Option<A::Location>, Direction)>

fn before(&self, addr: A::Address) -> Vec<(Option<A::Location>, Direction)>

fn after(&self, addr: A::Address) -> Vec<(Option<A::Location>, Direction)>

impl<A: Arch + ValueLocations> Serialize for InstructionModifiers<A>

where A::Location: AbiDefaults,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.