Package it.unive.lisa.analysis

Class SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

java.lang.Object

it.unive.lisa.analysis.BaseLattice<SimpleAbstractState<H,V,T>>

it.unive.lisa.analysis.SimpleAbstractState<H,V,T>

Type Parameters:

H - the type of HeapDomain embedded in this state

V - the type of ValueDomain embedded in this state

T - the type of TypeDomain embedded in this state

All Implemented Interfaces:

AbstractState<SimpleAbstractState<H,V,T>,H,V,T>, Lattice<SimpleAbstractState<H,V,T>>, SemanticDomain<SimpleAbstractState<H,V,T>,SymbolicExpression,Identifier>

public class SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>
extends BaseLattice<SimpleAbstractState<H,V,T>>
implements AbstractState<SimpleAbstractState<H,V,T>,H,V,T>

An abstract state of the analysis, composed by a heap state modeling the memory layout and a value state modeling values of program variables and memory locations.

Nested Class Summary

Nested classes/interfaces inherited from interface it.unive.lisa.analysis.SemanticDomain

SemanticDomain.Satisfiability

Field Summary

Fields inherited from interface it.unive.lisa.analysis.AbstractState

HEAP_REPRESENTATION_KEY, TYPE_REPRESENTATION_KEY, VALUE_REPRESENTATION_KEY

Fields inherited from interface it.unive.lisa.analysis.Lattice

BOTTOM_STRING, TOP_STRING

Constructor Summary

Constructors

Constructor	Description
SimpleAbstractState(H heapState, V valueState, T typeState)	Builds a new abstract state.

Method Summary

Modifier and Type	Method	Description
SimpleAbstractState<H,V,T>	assign(Identifier id, SymbolicExpression expression, ProgramPoint pp)	Yields a copy of this domain, where id has been assigned to value.
SimpleAbstractState<H,V,T>	assume(SymbolicExpression expression, ProgramPoint pp)	Yields a copy of this domain, modified by assuming that the given expression holds.
SimpleAbstractState<H,V,T>	bottom()	Yields the bottom element of this lattice.
boolean	equals(java.lang.Object obj)
SimpleAbstractState<H,V,T>	forgetIdentifier(Identifier id)	Forgets an Identifier.
SimpleAbstractState<H,V,T>	forgetIdentifiersIf(java.util.function.Predicate<Identifier> test)	Forgets all Identifiers that match the given predicate.
<D> D	getDomainInstance(java.lang.Class<D> domain)	Yields the instance of a specific domain, of class domain, contained inside the domain.
H	getHeapState()	Yields the instance of HeapDomain that contains the information on heap structures contained in this abstract state.
T	getTypeState()	Yields the instance of ValueDomain and TypeDomain that contains the information on runtime types of program variables and concretized memory locations.
V	getValueState()	Yields the instance of ValueDomain that contains the information on values of program variables and concretized memory locations.
int	hashCode()
boolean	isBottom()	Yields true if and only if this object represents the bottom of the lattice.
boolean	isTop()	Yields true if and only if this object represents the top of the lattice.
boolean	lessOrEqualAux(SimpleAbstractState<H,V,T> other)	Yields true if and only if this lattice element is in relation with (usually represented through ≤) the given one, assuming that base cases have already been handled.
SimpleAbstractState<H,V,T>	lubAux(SimpleAbstractState<H,V,T> other)	Performs the least upper bound operation between this lattice element and the given one, assuming that base cases have already been handled.
SimpleAbstractState<H,V,T>	popScope(ScopeToken scope)	Pops the scope identified by the given token from the domain.
SimpleAbstractState<H,V,T>	pushScope(ScopeToken scope)	Pushes a new scope, identified by the give token, in the domain.
DomainRepresentation	representation()	Yields a DomainRepresentation of the information contained in this domain's instance.
SemanticDomain.Satisfiability	satisfies(SymbolicExpression expression, ProgramPoint pp)	Checks if the given expression is satisfied by the abstract values of this domain, returning an instance of SemanticDomain.Satisfiability.
SimpleAbstractState<H,V,T>	smallStepSemantics(SymbolicExpression expression, ProgramPoint pp)	Yields a copy of this domain, that has been modified accordingly to the semantics of the given expression.
SimpleAbstractState<H,V,T>	top()	Yields the top element of this lattice.
java.lang.String	toString()
SimpleAbstractState<H,V,T>	wideningAux(SimpleAbstractState<H,V,T> other)	Performs the widening operation between this lattice element and the given one, assuming that base cases have already been handled.

Methods inherited from class it.unive.lisa.analysis.BaseLattice

lessOrEqual, lub, widening

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface it.unive.lisa.analysis.Lattice

lessOrEqual, lub, widening

Methods inherited from interface it.unive.lisa.analysis.SemanticDomain

forgetIdentifiers

Constructor Detail

SimpleAbstractState

public SimpleAbstractState(H heapState,
                           V valueState,
                           T typeState)

Builds a new abstract state.

Parameters:

heapState - the domain containing information regarding heap structures

valueState - the domain containing information regarding values of program variables and concretized memory locations

typeState - the domain containing information regarding runtime types of program variables and concretized memory locations

Method Detail

getHeapState

public H getHeapState()

Description copied from interface: AbstractState

Yields the instance of HeapDomain that contains the information on heap structures contained in this abstract state.

Specified by:

getHeapState in interface AbstractState<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>,H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Returns:

the heap domain

getValueState

public V getValueState()

Description copied from interface: AbstractState

Yields the instance of ValueDomain that contains the information on values of program variables and concretized memory locations.

Specified by:

getValueState in interface AbstractState<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>,H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Returns:

the value domain

getTypeState

public T getTypeState()

Description copied from interface: AbstractState

Yields the instance of ValueDomain and TypeDomain that contains the information on runtime types of program variables and concretized memory locations.

Specified by:

getTypeState in interface AbstractState<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>,H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Returns:

the type domain

assign

public SimpleAbstractState<H,V,T> assign(Identifier id,
                                                     SymbolicExpression expression,
                                                     ProgramPoint pp)
                                              throws SemanticException

Description copied from interface: SemanticDomain

Yields a copy of this domain, where id has been assigned to value.

Specified by:

assign in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

id - the identifier to assign the value to

expression - the expression to assign

pp - the program point that where this operation is being evaluated

Returns:

a copy of this domain, modified by the assignment

Throws:

SemanticException - if an error occurs during the computation

smallStepSemantics

public SimpleAbstractState<H,V,T> smallStepSemantics(SymbolicExpression expression,
                                                                 ProgramPoint pp)
                                                          throws SemanticException

Description copied from interface: SemanticDomain

Yields a copy of this domain, that has been modified accordingly to the semantics of the given expression.

Specified by:

smallStepSemantics in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

expression - the expression whose semantics need to be computed

pp - the program point that where this operation is being evaluated

Returns:

a copy of this domain, modified accordingly to the semantics of expression

Throws:

SemanticException - if an error occurs during the computation

assume

public SimpleAbstractState<H,V,T> assume(SymbolicExpression expression,
                                                     ProgramPoint pp)
                                              throws SemanticException

Description copied from interface: SemanticDomain

Yields a copy of this domain, modified by assuming that the given expression holds. It is required that the returned domain is in relation with this one. A safe (but imprecise) implementation of this method can always return this.

Specified by:

assume in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

expression - the expression to assume to hold.

pp - the program point that where this operation is being evaluated

Returns:

the (optionally) modified copy of this domain

Throws:

SemanticException - if an error occurs during the computation

satisfies

public SemanticDomain.Satisfiability satisfies(SymbolicExpression expression,
                                               ProgramPoint pp)
                                        throws SemanticException

Description copied from interface: SemanticDomain

Checks if the given expression is satisfied by the abstract values of this domain, returning an instance of SemanticDomain.Satisfiability.

Specified by:

satisfies in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

expression - the expression whose satisfiability is to be evaluated

pp - the program point that where this operation is being evaluated

Returns:

SemanticDomain.Satisfiability.SATISFIED is the expression is satisfied by the values of this domain, SemanticDomain.Satisfiability.NOT_SATISFIED if it is not satisfied, or SemanticDomain.Satisfiability.UNKNOWN if it is either impossible to determine if it satisfied, or if it is satisfied by some values and not by some others (this is equivalent to a TOP boolean value)

Throws:

SemanticException - if an error occurs during the computation

pushScope

public SimpleAbstractState<H,V,T> pushScope(ScopeToken scope)
                                                 throws SemanticException

Description copied from interface: SemanticDomain

Pushes a new scope, identified by the give token, in the domain. This causes information about all variables not associated with a scope (and thus visible) to be mapped to the given scope and hidden away, until the scope is popped with SemanticDomain.popScope(ScopeToken).

Specified by:

pushScope in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

scope - the token identifying the scope to push

Returns:

a copy of this domain where the local variables have been hidden

Throws:

SemanticException - if an error occurs during the computation

popScope

public SimpleAbstractState<H,V,T> popScope(ScopeToken scope)
                                                throws SemanticException

Description copied from interface: SemanticDomain

Pops the scope identified by the given token from the domain. This causes all the visible variables (i.e. that are not mapped to a scope) to be removed from the domain, while the local variables that were associated to the given scope token (and thus hidden) will become visible again.

Specified by:

popScope in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

scope - the token of the scope to be restored

Returns:

a copy of this domain where the local variables have been removed, while the variables mapped to the given scope are visible again

Throws:

SemanticException - if an error occurs during the computation

lubAux

public SimpleAbstractState<H,V,T> lubAux(SimpleAbstractState<H,V,T> other)
                                              throws SemanticException

Description copied from class: BaseLattice

Performs the least upper bound operation between this lattice element and the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:

• other is not null
• other is neither top nor bottom
• this is neither top nor bottom
• this and other are not the same object (according both to == and to Object.equals(Object))

Specified by:

lubAux in class BaseLattice<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>>

Parameters:

other - the other lattice element

Returns:

the least upper bound between this and other

Throws:

SemanticException - if an error occurs during the computation

wideningAux

public SimpleAbstractState<H,V,T> wideningAux(SimpleAbstractState<H,V,T> other)
                                                   throws SemanticException

Description copied from class: BaseLattice

Performs the widening operation between this lattice element and the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:

• other is not null
• other is neither top nor bottom
• this is neither top nor bottom
• this and other are not the same object (according both to == and to Object.equals(Object))

The default implementation of this method delegates to BaseLattice.lubAux(BaseLattice), and is thus safe for finite lattices and ACC ones.

Overrides:

wideningAux in class BaseLattice<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>>

Parameters:

other - the other lattice element

Returns:

the widening between this and other

Throws:

SemanticException - if an error occurs during the computation

lessOrEqualAux

public boolean lessOrEqualAux(SimpleAbstractState<H,V,T> other)
                       throws SemanticException

Description copied from class: BaseLattice

Yields true if and only if this lattice element is in relation with (usually represented through ≤) the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:

• other is not null
• other is neither top nor bottom
• this is neither top nor bottom
• this and other are not the same object (according both to == and to Object.equals(Object))

Specified by:

lessOrEqualAux in class BaseLattice<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>>

Parameters:

other - the other lattice element

Returns:

true if and only if that condition holds

Throws:

SemanticException - if an error occurs during the computation

top

public SimpleAbstractState<H,V,T> top()

Description copied from interface: Lattice

Yields the top element of this lattice. The returned element should be unique across different calls to this method, since Lattice.isTop() uses reference equality by default. If the value returned by this method is not a singleton, override Lattice.isTop() accordingly to provide a coherent test.

Specified by:

top in interface Lattice<H extends HeapDomain<H>>

Returns:

the top element

bottom

public SimpleAbstractState<H,V,T> bottom()

Description copied from interface: Lattice

Yields the bottom element of this lattice. The returned element should be unique across different calls to this method, since Lattice.isBottom() uses reference equality by default. If the value returned by this method is not a singleton, override Lattice.isBottom() accordingly to provide a coherent test.

Specified by:

bottom in interface Lattice<H extends HeapDomain<H>>

Returns:

the bottom element

isTop

public boolean isTop()

Description copied from interface: Lattice

Yields true if and only if this object represents the top of the lattice. The default implementation of this method uses reference equality between this and the value returned by Lattice.top(), thus assuming that the top element is a singleton. If this is not the case, override this method accordingly to provide a coherent test.

Specified by:

isTop in interface Lattice<H extends HeapDomain<H>>

Returns:

true if this is the top of the lattice

isBottom

public boolean isBottom()

Description copied from interface: Lattice

Yields true if and only if this object represents the bottom of the lattice. The default implementation of this method uses reference equality between this and the value returned by Lattice.bottom(), thus assuming that the bottom element is a singleton. If this is not the case, override this method accordingly to provide a coherent test.

Specified by:

isBottom in interface Lattice<H extends HeapDomain<H>>

Returns:

true if this is the bottom of the lattice

forgetIdentifier

public SimpleAbstractState<H,V,T> forgetIdentifier(Identifier id)
                                                        throws SemanticException

Description copied from interface: SemanticDomain

Forgets an Identifier. This means that all information regarding the given id will be lost. This method should be invoked whenever an identifier gets out of scope.

Specified by:

forgetIdentifier in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

id - the identifier to forget

Returns:

the semantic domain without information about the given id

Throws:

SemanticException - if an error occurs during the computation

forgetIdentifiersIf

public SimpleAbstractState<H,V,T> forgetIdentifiersIf(java.util.function.Predicate<Identifier> test)
                                                           throws SemanticException

Description copied from interface: SemanticDomain

Forgets all Identifiers that match the given predicate. This means that all information regarding the those identifiers will be lost. This method should be invoked whenever an identifier gets out of scope.

Specified by:

forgetIdentifiersIf in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Parameters:

test - the test to identify the targets of the removal

Returns:

the semantic domain without information about the ids

Throws:

SemanticException - if an error occurs during the computation

hashCode

public int hashCode()

Specified by:

hashCode in class BaseLattice<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>>

equals

public boolean equals(java.lang.Object obj)

Specified by:

equals in class BaseLattice<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>>

representation

public DomainRepresentation representation()

Description copied from interface: SemanticDomain

Yields a DomainRepresentation of the information contained in this domain's instance.

Specified by:

representation in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Returns:

the representation

toString

public java.lang.String toString()

Specified by:

toString in class BaseLattice<SimpleAbstractState<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>>

getDomainInstance

public <D> D getDomainInstance(java.lang.Class<D> domain)

Description copied from interface: SemanticDomain

Yields the instance of a specific domain, of class domain, contained inside the domain. If this domain is an instance of the specified class, then this is returned. Otherwise, inner domains are recursively checked (enabling retrieval of semantic domains through Cartesian products or other types of combinations), returning the first that is instance of domain.

The default implementation of this method returns this if domain.isAssignableFrom(getClass()) == true, otherwise it returns null.

Specified by:

getDomainInstance in interface SemanticDomain<H extends HeapDomain<H>,V extends ValueDomain<V>,T extends TypeDomain<T>>

Type Parameters:

D - the type of domain to retrieve

Parameters:

domain - the class of the domain instance to retrieve

Returns:

the instance of that domain, or null