Struct evmil::dfa::AbstractStack

pub struct AbstractStack { /* private fields */ }

Implementations

impl AbstractStack

pub fn new<T: Into<Interval>>(lower: T, upper: Vec<AbstractValue>) -> Self

Examples found in repository

src/dfa/stack.rs (line 179)

    pub fn merge(self, other: &AbstractStack) -> Self {
        let slen = self.upper.len();
        let olen = other.upper.len();
        // Determine common upper length
        let n = cmp::min(slen,olen);
        // Normalise lower segments
        let lself = self.lower.add(slen - n);
        let lother = other.lower.add(olen - n);
        let mut merger = AbstractStack::new(lself.union(&lother),Vec::new());
        // Push merged items from upper segment
        for i in (0..n).rev() {
            let ithself = self.peek(i);
            let ithother = other.peek(i);
            merger = merger.push(ithself.merge(ithother));
        }
        // Done
        merger
    }

pub fn is_bottom(&self) -> bool

Examples found in repository

src/cfa.rs (line 37)

    pub fn is_bottom(&self) -> bool {
        self.stack.is_bottom()
    }
    pub fn len(&self) -> Interval {
        self.stack.len()
    }
    pub fn push(self, val: AbstractValue) -> Self {
        CfaState::new(self.stack.push(val))
    }
    pub fn pop(mut self, n: usize) -> Self {
        assert!(n > 0);
        let mut stack = self.stack;
        for i in 0..n {
            stack = stack.pop();
        }
        CfaState::new(stack)
    }
    pub fn set(self, n:usize, val: AbstractValue) -> Self {
        CfaState::new(self.stack.set(n,val))
    }
}

impl Clone for CfaState {
    fn clone(&self) -> Self {
        CfaState::new(self.stack.clone())
    }
}

impl fmt::Display for CfaState {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f,"{}",self.stack)
    }
}

impl AbstractState for CfaState {
    fn is_reachable(&self) -> bool { !self.stack.is_bottom() }

src/dfa/stack.rs (line 113)

    pub fn push(mut self, val: AbstractValue) -> Self {
        // Should never be called on bottom
        assert!(!self.is_bottom());
        //
        if val == AbstractValue::Unknown && self.upper.len() == 0 {
            self.lower = self.lower.add(1);
        } else {
            // Pop target address off the stack.
            self.upper.push(val);
        }
        // Done
        self
    }
    /// Pop an item of this stack, producing an updated state.
    pub fn pop(mut self) -> Self {
        // Should never be called on bottom
        assert!(!self.is_bottom());
        // Pop target address off the stack.
        if self.upper.is_empty() {
            self.lower = self.lower.sub(1);
        } else {
            self.upper.pop();
        }
        // Done
        self
    }
    /// Perk nth item on the stack (where `0` is top).
    pub fn peek(&self, n: usize) -> AbstractValue {
        // Should never be called on bottom
        assert!(!self.is_bottom());
        // Get the nth value!
        if n < self.upper.len() {
            // Determine stack index
            let i = self.upper.len() - (1+n);
            // Extract value
            self.upper[i]
        } else {
            AbstractValue::Unknown
        }
    }
    /// Set specific item on this stack.
    pub fn set(mut self, n: usize, val: AbstractValue) -> Self {
        // Should never be called on bottom
        assert!(!self.is_bottom());
        if n < self.upper.len() {
            // Determine stack index
            let i = self.upper.len() - (1+n);
            // Set value
            self.upper[i] = val;
            // Done
            self
        } else {
            // This case is complicated because we need to expand the
            // upper portion to include the new value (where
            // possible).
            todo!("Implement me!");
        }
    }

pub fn len(&self) -> Interval

Determine possible lengths of the stack as an interval

Examples found in repository

src/cfa.rs (line 40)

    pub fn len(&self) -> Interval {
        self.stack.len()
    }

pub fn min_len(&self) -> usize

Determine the minimum length of any stack represented by this abstract stack.

pub fn max_len(&self) -> usize

Determine the maximum length of any stack represented by this abstract stack.

pub fn push(self, val: AbstractValue) -> Self

Push an iterm onto this stack.

Examples found in repository

src/cfa.rs (line 43)

    pub fn push(self, val: AbstractValue) -> Self {
        CfaState::new(self.stack.push(val))
    }

src/dfa/stack.rs (line 184)

    pub fn merge(self, other: &AbstractStack) -> Self {
        let slen = self.upper.len();
        let olen = other.upper.len();
        // Determine common upper length
        let n = cmp::min(slen,olen);
        // Normalise lower segments
        let lself = self.lower.add(slen - n);
        let lother = other.lower.add(olen - n);
        let mut merger = AbstractStack::new(lself.union(&lother),Vec::new());
        // Push merged items from upper segment
        for i in (0..n).rev() {
            let ithself = self.peek(i);
            let ithother = other.peek(i);
            merger = merger.push(ithself.merge(ithother));
        }
        // Done
        merger
    }

pub fn pop(self) -> Self

Pop an item of this stack, producing an updated state.

Examples found in repository

src/cfa.rs (line 49)

    pub fn pop(mut self, n: usize) -> Self {
        assert!(n > 0);
        let mut stack = self.stack;
        for i in 0..n {
            stack = stack.pop();
        }
        CfaState::new(stack)
    }

pub fn peek(&self, n: usize) -> AbstractValue

Perk nth item on the stack (where 0 is top).

Examples found in repository

src/cfa.rs (line 84)

    fn peek(&self, n: usize) -> AbstractValue {
        self.stack.peek(n)
    }

src/dfa/stack.rs (line 182)

    pub fn merge(self, other: &AbstractStack) -> Self {
        let slen = self.upper.len();
        let olen = other.upper.len();
        // Determine common upper length
        let n = cmp::min(slen,olen);
        // Normalise lower segments
        let lself = self.lower.add(slen - n);
        let lother = other.lower.add(olen - n);
        let mut merger = AbstractStack::new(lself.union(&lother),Vec::new());
        // Push merged items from upper segment
        for i in (0..n).rev() {
            let ithself = self.peek(i);
            let ithother = other.peek(i);
            merger = merger.push(ithself.merge(ithother));
        }
        // Done
        merger
    }

pub fn set(self, n: usize, val: AbstractValue) -> Self

Set specific item on this stack.

Examples found in repository

src/cfa.rs (line 54)

    pub fn set(self, n:usize, val: AbstractValue) -> Self {
        CfaState::new(self.stack.set(n,val))
    }

pub fn merge(self, other: &AbstractStack) -> Self

Merge two abstract stacks together.

Examples found in repository

src/dfa/stack.rs (line 199)

    pub fn merge_into(&mut self, other: &AbstractStack) -> bool {
        // NOTE: this could be done more efficiently.
        let old = self.clone();
        let mut tmp = EMPTY_STACK;
        // Install dummy value to keep self alive
        mem::swap(self, &mut tmp);
        // Perform merge
        *self = tmp.merge(other);
        // Check for change
        *self != old
    }

pub fn merge_into(&mut self, other: &AbstractStack) -> bool

Merge an abstract stack into this stack, whilst reporting whether this stack changed or not.

Examples found in repository

src/cfa.rs (line 94)

    fn merge(&mut self, other: Self) -> bool {
        if *self != other {
            if !other.is_bottom() {
                if self.is_bottom() {
                    *self = other;
                    return true;
                } else {
                    return self.stack.merge_into(&other.stack);
                }
            }
        }
        false
    }

Trait Implementations

impl Clone for AbstractStack

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AbstractStack

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

Formats the value using the given formatter.

impl Display for AbstractStack

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

Formats the value using the given formatter.

impl PartialEq<AbstractStack> for AbstractStack

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

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

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

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

impl StructuralPartialEq for AbstractStack