Enum cwe_checker_lib::abstract_domain::AbstractLocation

pub enum AbstractLocation {
    Register(Variable),
    GlobalAddress {
        address: u64,
        size: ByteSize,
    },
    Pointer(Variable, AbstractMemoryLocation),
    GlobalPointer(u64, AbstractMemoryLocation),
}

An abstract location describes how to find the value of a variable in memory at a given time.

It is defined recursively, where the root is either a register or a (constant) global address. This way only locations that the local state knows about are representable. It is also impossible to accidentally describe circular references.

Variants

Register(Variable)

The location is given by a register.

GlobalAddress

Fields

address: u64

The address in global memory.

size: ByteSize

The byte size of the address (not the pointed-to value!).

The value itself is a constant address to global memory. Note that the size is the size of the pointer and not the size of the value residing at the specific address in global memory.

Pointer(Variable, AbstractMemoryLocation)

The location is in memory. One needs to follow the pointer in the given register and then follow the abstract memory location inside the pointed to memory object to find the actual memory location.

GlobalPointer(u64, AbstractMemoryLocation)

The location is in memory. One needs to follow the pointer located at the given global address and then follow the abstract memory location inside the pointed to memory object to find the actual memory location.

Implementations

impl AbstractLocation

pub fn from_var(variable: &Variable) -> Result<AbstractLocation, Error>

Create an abstract location from a variable corresponding to a register. This function returns an error if the variable is not a physical register.

pub fn from_stack_position( stack_register: &Variable, offset: i64, size: ByteSize ) -> AbstractLocation

Create an abstract location on the stack. The returned location describes the value of the given size at the given offset relative to the memory location that the stack_register is pointing to.

pub fn from_global_address(address: &Bitvector) -> AbstractLocation

Create an abstract location representing an address pointing to global memory.

pub fn with_offset_addendum(self, addendum: i64) -> AbstractLocation

Add an offset to the abstract location.

pub fn dereferenced( self, new_size: ByteSize, generic_pointer_size: ByteSize ) -> AbstractLocation

Return the abstract location that one gets when dereferencing the pointer that self is pointing to.

Panics if self is not pointer-sized.

pub fn bytesize(&self) -> ByteSize

Get the bytesize of the value represented by the abstract location.

pub fn recursion_depth(&self) -> u64

Get the recursion depth of the abstract location, i.e. how many times one has to dereference a pointer until reaching the actual location.

pub fn extend( &mut self, extension: AbstractMemoryLocation, generic_pointer_size: ByteSize )

Extend the location string by adding further derefence operations to it according to the given extension.

pub fn get_parent_location( &self, generic_pointer_size: ByteSize ) -> Result<(AbstractLocation, i64), Error>

Get the abstract location representing the pointer pointing to the memory object that contains the location represented by self together with the offset that one has to add to the pointer to get the location of self.

Returns an error if the abstract location contains no dereference operation (e.g. if self represents a register value).

pub fn get_all_parent_locations( &self, generic_pointer_size: ByteSize ) -> Vec<AbstractLocation>

Get a list of all (recursive) parent locations. The list is sorted by recursion depth, starting with the root location.

Trait Implementations

impl Clone for AbstractLocation

fn clone(&self) -> AbstractLocation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AbstractLocation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AbstractLocation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AbstractLocation

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

Formats the value using the given formatter.

impl Hash for AbstractLocation

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 Ord for AbstractLocation

fn cmp(&self, other: &AbstractLocation) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for AbstractLocation

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

fn partial_cmp(&self, other: &AbstractLocation) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for AbstractLocation

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 AbstractLocation

impl StructuralEq for AbstractLocation

impl StructuralPartialEq for AbstractLocation