Struct cwe_checker_lib::abstract_domain::Interval

pub struct Interval {
    pub start: Bitvector,
    pub end: Bitvector,
    pub stride: u64,
}

A strided interval of values with a fixed byte size.

The interval bounds are interpreted as signed integers, i.e. self.start is not allowed to be greater than self.end as signed integers.

The values represented by the interval are start, start + stride, start + 2*stride, ... , end. The following invariants have to hold for a correct interval instance:

• end - start % stride == 0
• if start == end, then the stride should always be set to zero.

Fields

start: Bitvector

The start of the interval. The bound is included in the represented interval.

end: Bitvector

The end of the interval. The bound is included in the represented interval.

stride: u64

The stride.

Implementations

impl Interval

pub fn new(start: Bitvector, end: Bitvector, stride: u64) -> Interval

Construct a new interval.

Both start and end of the interval are inclusive, i.e. contained in the represented interval.

The function automatically rounds down end (if necessary) so that it is contained in the same residue class as the start value modulo the stride. If the stride is 0 then end will be set to start.

pub fn new_top(bytesize: ByteSize) -> Interval

Construct a new unconstrained interval.

pub fn is_top(&self) -> bool

Returns true if all values representable by bitvectors of the corresponding length are contained in the interval.

pub fn bytesize(&self) -> ByteSize

Get the size in bytes of values contained in the interval.

pub fn signed_merge(&self, other: &Interval) -> Interval

Merge two intervals interpreting both as intervals of signed integers.

pub fn signed_intersect(&self, other: &Interval) -> Result<Interval, Error>

Compute the intersection of two intervals as intervals of signed integers. Return an error if the intersection is empty.

pub fn adjust_end_to_value_in_stride(&mut self)

Round down self.end to the nearest value such that self.end - self.start is again divisible by the stride. If afterwards self.start == self.end holds then set the stride to 0.

pub fn adjust_start_to_value_in_stride(&mut self)

Round up self.start to the nearest value such that self.end - self.start is again divisible by the stride. If afterwards self.start == self.end holds then set the stride to 0.

pub fn adjust_to_stride_and_remainder( self, stride: u64, remainder: u64 ) -> Result<Self, Error>

Change the given interval such that it only contains values with the given remainder modulo the given stride. This may round up the start of the interval and may round down the end of the interval. If the resulting interval is empty then an error is returned. This function ignores and replaces the previous stride of the interval.

For intervals with bytesize greater than 8 this function just returns the unmodified interval.

pub fn zero_extend(self, width: ByteSize) -> Interval

Compute the interval represented if the byte size of the value is zero-extended.

pub fn subpiece_higher(self, low_byte: ByteSize) -> Self

Truncate the bitvectors in the interval by removing the least significant bytes lower than the low_byte from them.

pub fn subpiece_lower(self, size: ByteSize) -> Self

Truncate the bitvectors in the interval to size, i.e. the most significant bytes (higher than size) are removed from all values.

pub fn subpiece(self, low_byte: ByteSize, size: ByteSize) -> Self

Take a subpiece of the bitvectors.

pub fn piece(&self, other: &Interval) -> Self

Piece two intervals together, where self contains the most signifcant bytes and other contains the least significant bytes of the resulting values.

pub fn int_2_comp(self) -> Self

Take the 2’s complement of values in the interval.

pub fn bitwise_not(self) -> Self

Compute the bitwise negation of values in the interval. Only exact if there is exactly one value in the interval.

pub fn add(&self, rhs: &Interval) -> Interval

Compute the interval of possible results if one adds a value from self to a value from rhs.

pub fn sub(&self, rhs: &Interval) -> Interval

Compute the interval of possible results if one subtracts a value in rhs from a value in self.

pub fn signed_mul(&self, rhs: &Interval) -> Interval

Compute the interval of possible results if one multiplies a value in self with a value in rhs.

pub fn contains(&self, bitvec: &Bitvector) -> bool

Return true if bitvec is contained in the strided interval. Panics if the interval and bitvec have different bytesizes.

Trait Implementations

impl Clone for Interval

fn clone(&self) -> Interval

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interval

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Interval

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ApInt> for Interval

fn from(bitvec: Bitvector) -> Self

Create an interval that only contains the given bitvector.

impl From<Interval> for IntervalDomain

fn from(interval: Interval) -> IntervalDomain

Generate an interval domain without widening hints.

impl Hash for Interval

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 PartialEq for Interval

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Interval

impl StructuralEq for Interval

impl StructuralPartialEq for Interval