Struct cwe_checker_lib::abstract_domain::DataDomain

pub struct DataDomain<T: RegisterDomain> { /* private fields */ }

An abstract domain representing a set of base values plus offsets or an absolute value (or both).

The base values are represented as abstract IDs, i.e. they are treated as variables with unknown absolute value, e.g. the returned pointer by malloc. For each base value the offset is given by an abstract domain T, which should specialize in representing absolute values (e.g. an interval domain). Note that the domain assumes pointer semantics for these values. That means if one applies operations to the domain that are not used in pointer arithmetics, the abstract ID of the base value might be removed from the domain.

If the domain also represents absolute values, then the values are given by a single instance of the abstract domain T.

The domain also contains a flag to indicate that it includes Top values, i.e. values of fully unknown origin and offset.

Implementations

impl<T: RegisterDomain> DataDomain<T>

pub fn add_offset(&self, offset: &T) -> Self

Add offset to all contained absolute and relative values of self and return the result.

pub fn subtract_offset(&self, offset: &T) -> Self

Subtract offset from all contained absolute and relative values of self and return the result.

impl<T: RegisterDomain> DataDomain<T>

pub fn is_empty(&self) -> bool

Returns true if the domain does not represent any value.

The meaning of an empty value depends on the usage of the domain. E.g. it may indicate an impossible runtime state of a program in one analysis or simply no value of interest in another analysis.

An empty value represents the bottom value in the partial order of the domain.

pub fn new_empty(size: ByteSize) -> Self

Return a new empty value with the given bytesize.

pub fn replace_abstract_id( &mut self, old_id: &AbstractIdentifier, new_id: &AbstractIdentifier, offset_adjustment: &T )

For pointer values replace an abstract identifier with another one and add the offset_adjustment to the pointer offset. This is needed to adjust stack pointer on call and return instructions.

pub fn replace_all_ids( &mut self, replacement_map: &BTreeMap<AbstractIdentifier, Self> )

Replace all abstract IDs in self with the corresponding values given by the replacement_map.

For IDs without a replacement value the contains_top_values flag will be set.

pub fn referenced_ids(&self) -> impl Iterator<Item = &AbstractIdentifier>

Return an iterator over all referenced abstract IDs.

pub fn get_relative_values(&self) -> &BTreeMap<AbstractIdentifier, T>

Return the relative values contained in the domain.

pub fn set_relative_values( &mut self, relative_values: BTreeMap<AbstractIdentifier, T> )

Replace the map of relative values with the given one.

pub fn get_absolute_value(&self) -> Option<&T>

Return the absolute value contained in the domain if present

pub fn set_absolute_value(&mut self, value: Option<T>)

Replace the absolute value contained in the domain with the given one. A value of None means that the domain does not contain an absolute value.

pub fn contains_top(&self) -> bool

Returns true if the domain contains Top values, i.e. values for which neither a value nor an abstract identifier is known.

Note that the DataDomain itself has no maximal value, i.e. this does not indicate a Top value of the abstract domain.

pub fn set_contains_top_flag(&mut self)

Indicate that the domain may contain Top values in addition to the contained absolute and relative values.

This does not remove absolute or relative value information from the domain.

pub fn unset_contains_top_flag(&mut self)

Indicate that the domain does not contain any Top values in addition to the contained absolute and relative values.

pub fn from_target(id: AbstractIdentifier, offset: T) -> Self

Return a new value representing a variable plus an offset, where the variable is represented by the given abstract ID.

pub fn remove_ids(&mut self, ids_to_remove: &BTreeSet<AbstractIdentifier>)

Remove all provided IDs from the list of relative values.

pub fn get_if_absolute_value(&self) -> Option<&T>

Return the contained absolute value only if self contains no other (relative or Top) values.

pub fn get_if_unique_target(&self) -> Option<(&AbstractIdentifier, &T)>

Return the target ID and offset of the contained relative value if self contains exactly one relative value and no absolute or Top values.

impl<T: RegisterDomain + Display> DataDomain<T>

pub fn to_json_compact(&self) -> Value

Get a more compact json-representation of the data domain. Intended for pretty printing, not useable for serialization/deserialization.

Trait Implementations

impl<T: RegisterDomain> AbstractDomain for DataDomain<T>

fn is_top(&self) -> bool

Return whether the element represents a top element or not.

Note that DataDomain technically does not have a Top element with respect to the partial order. Instead a Top element here represents a non-empty value for which nothing is known about the contained values.

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

Returns an upper bound (with respect to the partial order on the domain) for the two inputs self and other.

fn merge_with(&mut self, other: &Self) -> &mut Self

Returns an upper bound (with respect to the partial order on the domain) for the two inputs self and other.

impl<T: RegisterDomain> Add for DataDomain<T>

type Output = DataDomain<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T: Clone + RegisterDomain> Clone for DataDomain<T>

fn clone(&self) -> DataDomain<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + RegisterDomain> Debug for DataDomain<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for DataDomain<T>

where T: Deserialize<'de> + RegisterDomain,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: RegisterDomain + From<Bitvector>> From<ApInt> for DataDomain<T>

fn from(bitvector: Bitvector) -> Self

Converts to this type from the input type.

impl<T: RegisterDomain> From<T> for DataDomain<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: RegisterDomain> HasTop for DataDomain<T>

fn top(&self) -> Self

Generate a new Top element with the same bytesize as self.

impl<'a> HasVsaResult<DataDomain<IntervalDomain>> for Context<'a>

fn vsa_result(&self) -> &impl VsaResult<ValueDomain = PiData>

Converts a reference to Self into a reference to a type that implements VsaResult with ValueDomain T.

impl<T: Hash + RegisterDomain> Hash for DataDomain<T>

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<T: PartialEq + RegisterDomain> PartialEq for DataDomain<T>

fn eq(&self, other: &DataDomain<T>) -> 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<T: RegisterDomain> RegisterDomain for DataDomain<T>

fn bin_op(&self, op: BinOpType, rhs: &Self) -> Self

Compute the (abstract) result of a binary operation

fn un_op(&self, op: UnOpType) -> Self

Compute the (abstract) result of a unary operation

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

extract a sub-bitvector

fn cast(&self, kind: CastOpType, width: ByteSize) -> Self

Cast a bitvector using the given cast type

fn bin_op_bytesize(&self, op: BinOpType, rhs: &Self) -> ByteSize

Return the bytesize of the result of the given binary operation. Has a generic implementation that should not be overwritten!

impl<T> Serialize for DataDomain<T>

where T: Serialize + RegisterDomain,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: RegisterDomain> SizedDomain for DataDomain<T>

fn bytesize(&self) -> ByteSize

Return the bytesize of self.

fn new_top(bytesize: ByteSize) -> Self

Return a new Top element with the given bytesize.

Note that DataDomain technically does not have a Top element with respect to the partial order. Instead a Top element here represents a non-empty value for which nothing is known about the contained values.

impl<T: SpecializeByConditional + RegisterDomain> SpecializeByConditional for DataDomain<T>

fn intersect(self, other: &Self) -> Result<Self, Error>

Compute the intersetion of two DataDomains.

Note that this implementation is unsound for several reasons:

• For example, it assumes that two different relative values cannot intersect. But that is not true if their offfsets are big enough or if the relative values do in fact reference the same object despite having different identifiers.
• If intersecting relative values with absolute values we represent the result with the absolute values. But depending on the use-case an approximation by the relative values could be more precise.

fn add_signed_less_equal_bound(self, bound: &Bitvector) -> Result<Self, Error>

Return the restriction of self to values satisfying self <= bound with self and bound interpreted as signed integers. Returns an error if no value represented by self can satisfy the comparison.

fn add_unsigned_less_equal_bound(self, bound: &Bitvector) -> Result<Self, Error>

Return the restriction of self to values satisfying self <= bound with self and bound interpreted as unsigned integers. Returns an error if no value represented by self can satisfy the comparison.

fn add_signed_greater_equal_bound( self, bound: &Bitvector ) -> Result<Self, Error>

Return the restriction of self to values satisfying self >= bound with self and bound interpreted as signed integers. Returns an error if no value represented by self can satisfy the comparison.

fn add_unsigned_greater_equal_bound( self, bound: &Bitvector ) -> Result<Self, Error>

Return the restriction of self to values satisfying self >= bound with self and bound interpreted as unsigned integers. Returns an error if no value represented by self can satisfy the comparison.

fn add_not_equal_bound(self, bound: &Bitvector) -> Result<Self, Error>

Return the restriction of self to values satisfying self != bound Returns an error if self only represents one value for which self == bound holds.

fn without_widening_hints(self) -> Self

Remove all widening hints from self. Necessary for cases where several sources have widening hints, but only one source should contribute widening hints to the result.

impl<T: RegisterDomain> Sub for DataDomain<T>

type Output = DataDomain<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T: RegisterDomain + TryToBitvec> TryToBitvec for DataDomain<T>

fn try_to_bitvec(&self) -> Result<Bitvector, Error>

If the domain represents a single, absolute value, return it.

fn try_to_offset(&self) -> Result<i64, Error>

If self represents a single absolute value, try to convert it to a signed integer and return it. Else return an error. Note that the conversion loses information about the bytesize of the value.

impl<T: RegisterDomain + TryToInterval> TryToInterval for DataDomain<T>

fn try_to_interval(&self) -> Result<Interval, Error>

If the domain represents (or can be widened to) an interval of absolute values, return the interval.

fn try_to_offset_interval(&self) -> Result<(i64, i64), Error>

If self represents an interval of absolute values (or can be widened to represent such an interval) then return it as an interval of signed integers of the form (start, end) if the interval is bounded. Else return an error. Note that the conversion loses information about the bytesize of the values contained in the interval.

impl<T: Eq + RegisterDomain> Eq for DataDomain<T>

impl<T: RegisterDomain> StructuralEq for DataDomain<T>

impl<T: RegisterDomain> StructuralPartialEq for DataDomain<T>