Struct cwe_checker_lib::abstract_domain::AbstractIdentifier

pub struct AbstractIdentifier(/* private fields */);

An abstract identifier is used to identify an object or a value in an abstract state.

Since many program states can be represented by the same abstract state in data-flow analysis, one sometimes needs a way to uniquely identify a variable or a memory object in all of the represented program states. Abstract identifiers achieve this by identifying a time, i.e. a specific abstract state, and a location, i.e. a recipe for computing a concrete value from any concrete state that is represented by the abstract state. The value in question then serves as the identifier. For example, a pointer may uniquely determine the memory object it is pointing to. Or a value may represent the value of a variable at a certain time, whereas the value of the variable in the current state is given as an offset to the value at the identified time.

Since program points may be visited several times during an execution trace (e.g. in loops), the time component of an abstract identifier may not actually determine an unique point in time of an execution trace. In this case the meaning of an abstract identifier depends upon its use case. E.g. it may represent the union of all values at the specific location for each time the program point is visited during an execution trace or it may only represent the value at the last time the program point was visited.

Alternatively, one can also add path hints to an identifier to further distinguish points in time in an execution trace. Path hints are given as a possibly empty array of time identifiers. To prevent infinitely long path hints, each time identifier is only allowed to appear at most once in the array. The specific meaning of the path hints depends upon the use case.

An abstract identifier is given by a time identifier, a location identifier and a path hints array (containing time identifiers).

For the location identifier see AbstractLocation. The time identifier is given by a Tid. If it is the Tid of a basic block, then it describes the point in time before execution of the first instruction in the block. If it is the Tid of a Def or Jmp, then it describes the point in time after the execution of the Def or Jmp.

Implementations

impl AbstractIdentifier

pub fn new(time: Tid, location: AbstractLocation) -> AbstractIdentifier

Create a new abstract identifier.

pub fn from_var(time: Tid, variable: &Variable) -> AbstractIdentifier

Create a new abstract identifier where the abstract location is a register. Panics if the register is a temporary register.

pub fn from_arg(time: &Tid, arg: &Arg) -> AbstractIdentifier

Create an abstract identifier from a parameter argument.

If the argument is a sub-register, then the created identifier contains the whole base register.

pub fn from_global_address( time: &Tid, address: &Bitvector ) -> AbstractIdentifier

Create an abstract identifier from an address into global memory.

pub fn with_path_hint(&self, path_hint: Tid) -> Result<Self, Error>

Create a new abstract identifier by pushing the given path hint to the array of path hints of self. Returns an error if the path hint is already contained in the path hints of self.

pub fn without_last_path_hint(&self) -> (Self, Option<Tid>)

Create a new abstract identifier by removing the last path hint from the path hint array of self. Return the new identifier together with the removed path hint (or none if self has no path hints).

pub fn get_path_hints(&self) -> &[Tid]

Get the path hints array of self.

pub fn unwrap_register(&self) -> &Variable

Get the register associated to the abstract location. Panics if the abstract location is not a register but a memory location.

pub fn get_tid(&self) -> &Tid

Get the TID representing the time component of the abstract ID.

pub fn get_location(&self) -> &AbstractLocation

Get the location component of the abstract ID.

pub fn bytesize(&self) -> ByteSize

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

pub fn get_id_with_parent_location( &self, generic_pointer_size: ByteSize ) -> Option<AbstractIdentifier>

If the abstract location of self has a parent location then return the ID one gets when replacing the abstract location in self with its parent location.

Trait Implementations

impl Clone for AbstractIdentifier

fn clone(&self) -> AbstractIdentifier

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AbstractIdentifier

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

Formats the value using the given formatter.

impl Deref for AbstractIdentifier

where Arc<AbstractIdentifierData>: Deref,

type Target = <Arc<AbstractIdentifierData> as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for AbstractIdentifier

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AbstractIdentifier

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

Formats the value using the given formatter.

impl Hash for AbstractIdentifier

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 AbstractIdentifier

fn cmp(&self, other: &AbstractIdentifier) -> 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 AbstractIdentifier

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

fn partial_cmp(&self, other: &AbstractIdentifier) -> 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 AbstractIdentifier

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 AbstractIdentifier

impl StructuralEq for AbstractIdentifier

impl StructuralPartialEq for AbstractIdentifier