Struct gf::ai::symbolic::SymbolicInterp

pub struct SymbolicInterp<'a, C: Concretizer = TrivialConcretizer> { /* fields omitted */ }

🟢 Symbolic interpretation.

Implementations

impl<'a, C: Concretizer> SymbolicInterp<'a, C>

pub fn new(concretizer: C) -> Self

Create a symbolic implementation using the given concretizer.

Trait Implementations

impl<'a, C: Clone + Concretizer> Clone for SymbolicInterp<'a, C>

fn clone(&self) -> SymbolicInterp<'a, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, C: Copy + Concretizer> Copy for SymbolicInterp<'a, C>

impl<'a, C: Default + Concretizer> Default for SymbolicInterp<'a, C>

fn default() -> SymbolicInterp<'a, C>

Returns the "default value" for a type.

impl<'a, C: Eq + Concretizer> Eq for SymbolicInterp<'a, C>

impl<'a, C: Hash + Concretizer> Hash for SymbolicInterp<'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, 

Feeds a slice of this type into the given Hasher.

impl<'a, C: Concretizer> Interp<'a, Forward> for SymbolicInterp<'a, C>

type State = SymbolicState<'a>

Abstract state.

fn edge(&self, state: &mut Self::State, edge: Edge<'a>)

Propagate state across an intraprocedural edge.

fn apply(&self, state: &mut Self::State, stmt: Stmt<'a, Apply>)

Propagate state across an APPLY statement.

fn call(&self, state: &Self::State, stmt: Stmt<'a, Call>) -> Self::State

Propagate state across a CALL statement.

fn call_ret(
    &self,
    caller_state: &mut Self::State,
    callee_state: Self::State,
    stmt: Stmt<'a, Call>
)

Propagate state across a return from a CALL statement.

fn init(&self, state: &mut Self::State, stmt: Stmt<'a, Init>)

Propagate state across an INIT statement.

fn load(&self, state: &mut Self::State, stmt: Stmt<'a, Load>)

Propagate state across a LOAD statement.

fn mix(&self, state: &mut Self::State, stmt: Stmt<'a, Mix>)

Propagate state across a MIX statement.

fn slice(&self, state: &mut Self::State, stmt: Stmt<'a, Slice>)

Propagate state across a SLICE statement.

fn store(&self, state: &mut Self::State, stmt: Stmt<'a, Store>)

Propagate state across a STORE statement.

impl<'a, C: PartialEq + Concretizer> PartialEq<SymbolicInterp<'a, C>> for SymbolicInterp<'a, C>

fn eq(&self, other: &SymbolicInterp<'a, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SymbolicInterp<'a, C>) -> bool

This method tests for !=.

impl<'a, C: Concretizer> StructuralEq for SymbolicInterp<'a, C>

impl<'a, C: Concretizer> StructuralPartialEq for SymbolicInterp<'a, C>