Package it.unive.lisa.analysis.nonrelational.value

Class BaseNonRelationalValueDomain<T extends BaseNonRelationalValueDomain<T>>

java.lang.Object

it.unive.lisa.analysis.BaseLattice<T>

it.unive.lisa.analysis.nonrelational.value.BaseNonRelationalValueDomain<T>

Type Parameters:

T - the concrete type of this domain

All Implemented Interfaces:

Lattice<T>, NonRelationalDomain<T,ValueExpression,ValueEnvironment<T>>, NonRelationalElement<T,ValueExpression,ValueEnvironment<T>>, NonRelationalValueDomain<T>, SemanticEvaluator

public abstract class BaseNonRelationalValueDomain<T extends BaseNonRelationalValueDomain<T>>
extends BaseLattice<T>
implements NonRelationalValueDomain<T>

Base implementation for NonRelationalValueDomains. This class extends BaseLattice and implements NonRelationalDomain.eval(it.unive.lisa.symbolic.SymbolicExpression, it.unive.lisa.analysis.lattices.FunctionalLattice, ProgramPoint) by taking care of the recursive computation of inner expressions evaluation.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	BaseNonRelationalValueDomain.EvaluationVisitor	A ExpressionVisitor for BaseNonRelationalValueDomain instances.

Field Summary

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

BOTTOM_STRING, TOP_STRING

Constructor Summary

Constructors

Constructor	Description
BaseNonRelationalValueDomain()

Method Summary

Modifier and Type	Method	Description
ValueEnvironment<T>	assume(ValueEnvironment<T> environment, ValueExpression expression, ProgramPoint pp)	Yields the environment environment on which the expression expression is assumed to hold by this domain.
ValueEnvironment<T>	assumeBinaryExpression(ValueEnvironment<T> environment, BinaryOperator operator, ValueExpression left, ValueExpression right, ProgramPoint pp)	Yields the environment environment assuming that a binary expression with operator operator, left argument left, and right argument right holds.
ValueEnvironment<T>	assumeTernaryExpression(ValueEnvironment<T> environment, TernaryOperator operator, ValueExpression left, ValueExpression middle, ValueExpression right, ProgramPoint pp)	Yields the environment environment assuming that a ternary expression with operator operator, left argument left, middle argument middle,and right argument right holds.
ValueEnvironment<T>	assumeUnaryExpression(ValueEnvironment<T> environment, UnaryOperator operator, ValueExpression expression, ProgramPoint pp)	Yields the environment environment assuming that an unary expression with operator operator and argument expression holds.
boolean	canProcess(SymbolicExpression expression)	Yields true if the domain can process expression, false otherwise.
T	eval(ValueExpression expression, ValueEnvironment<T> environment, ProgramPoint pp)	Evaluates a SymbolicExpression, assuming that the values of program variables are the ones stored in environment.
T	evalBinaryExpression(BinaryOperator operator, T left, T right, ProgramPoint pp)	Yields the evaluation of a BinaryExpression applying operator to two expressions whose abstract value are left and right, respectively.
T	evalIdentifier(Identifier id, ValueEnvironment<T> environment, ProgramPoint pp)	Yields the evaluation of an identifier in a given environment.
T	evalNonNullConstant(Constant constant, ProgramPoint pp)	Yields the evaluation of the given non-null constant.
T	evalNullConstant(ProgramPoint pp)	Yields the evaluation of the null constant NullConstant.
T	evalPushAny(PushAny pushAny, ProgramPoint pp)	Yields the evaluation of a push-any expression.
T	evalTernaryExpression(TernaryOperator operator, T left, T middle, T right, ProgramPoint pp)	Yields the evaluation of a TernaryExpression applying operator to two expressions whose abstract value are left, middle and right, respectively.
T	evalTypeCast(BinaryExpression cast, T left, T right, ProgramPoint pp)	Yields the evaluation of a type cast expression.
T	evalTypeConv(BinaryExpression conv, T left, T right, ProgramPoint pp)	Yields the evaluation of a type conversion expression.
T	evalUnaryExpression(UnaryOperator operator, T arg, ProgramPoint pp)	Yields the evaluation of a UnaryExpression applying operator to an expression whose abstract value is arg.
T	glb(T other)	Performs the greatest lower bound operation between this domain element and other.
T	glbAux(T other)	Performs the greatest lower bound operation between this domain element and other, assuming that base cases have already been handled.
SemanticDomain.Satisfiability	satisfies(ValueExpression expression, ValueEnvironment<T> environment, ProgramPoint pp)	Checks whether expression is satisfied in environment, assuming that the values of program variables are the ones stored in environment and returning an instance of SemanticDomain.Satisfiability.
SemanticDomain.Satisfiability	satisfiesAbstractValue(T value, ProgramPoint pp)	Yields the satisfiability of an abstract value of type <T>.
SemanticDomain.Satisfiability	satisfiesBinaryExpression(BinaryOperator operator, T left, T right, ProgramPoint pp)	Yields the satisfiability of a BinaryExpression applying operator to two expressions whose abstract values are left, and right.
SemanticDomain.Satisfiability	satisfiesNonNullConstant(Constant constant, ProgramPoint pp)	Yields the satisfiability of the given non-null constant on this abstract domain.
SemanticDomain.Satisfiability	satisfiesNullConstant(ProgramPoint pp)	Yields the satisfiability of the null constant NullConstant on this abstract domain.
SemanticDomain.Satisfiability	satisfiesTernaryExpression(TernaryOperator operator, T left, T middle, T right, ProgramPoint pp)	Yields the satisfiability of a TernaryExpression applying operator to three expressions whose abstract values are left, middle and right.
SemanticDomain.Satisfiability	satisfiesUnaryExpression(UnaryOperator operator, T arg, ProgramPoint pp)	Yields the satisfiability of a UnaryExpression applying operator to an expression whose abstract value is arg, returning an instance of SemanticDomain.Satisfiability.
java.lang.String	toString()
boolean	tracksIdentifiers(Identifier id)	Yields true if the domain tracks information on the identifier id, false otherwise.

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

equals, hashCode, lessOrEqual, lessOrEqualAux, lub, lubAux, widening, wideningAux

Methods inherited from class java.lang.Object

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

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

bottom, isBottom, isTop, lessOrEqual, lub, top, widening

Methods inherited from interface it.unive.lisa.analysis.nonrelational.NonRelationalElement

representation, variable

Constructor Detail

BaseNonRelationalValueDomain

public BaseNonRelationalValueDomain()

Method Detail

satisfies

public SemanticDomain.Satisfiability satisfies(ValueExpression expression,
                                               ValueEnvironment<T> environment,
                                               ProgramPoint pp)
                                        throws SemanticException

Description copied from interface: NonRelationalElement

Checks whether expression is satisfied in environment, assuming that the values of program variables are the ones stored in environment and returning an instance of SemanticDomain.Satisfiability.

Specified by:

satisfies in interface NonRelationalElement<T extends BaseNonRelationalValueDomain<T>,ValueExpression,ValueEnvironment<T extends BaseNonRelationalValueDomain<T>>>

Parameters:

expression - the expression whose satisfiability is to be evaluated

environment - the environment containing the values of program variables for the satisfiability

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

Returns:

SemanticDomain.Satisfiability.SATISFIED if the expression is satisfied by the environment, 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 something goes wrong during the computation

eval

public T eval(ValueExpression expression,
              ValueEnvironment<T> environment,
              ProgramPoint pp)
       throws SemanticException

Description copied from interface: NonRelationalDomain

Evaluates a SymbolicExpression, assuming that the values of program variables are the ones stored in environment.

Specified by:

eval in interface NonRelationalDomain<T extends BaseNonRelationalValueDomain<T>,ValueExpression,ValueEnvironment<T extends BaseNonRelationalValueDomain<T>>>

Parameters:

expression - the expression to evaluate

environment - the environment containing the values of program variables for the evaluation

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

Returns:

an new instance of this domain, representing the abstract result of expression when evaluated on environment

Throws:

SemanticException - if something goes wrong during the computation

tracksIdentifiers

public boolean tracksIdentifiers(Identifier id)

Description copied from interface: SemanticEvaluator

Yields true if the domain tracks information on the identifier id, false otherwise.

Specified by:

tracksIdentifiers in interface SemanticEvaluator

Parameters:

id - the identifier

Returns:

true if the domain tracks information on the identifier id, false otherwise

canProcess

public boolean canProcess(SymbolicExpression expression)

Description copied from interface: SemanticEvaluator

Yields true if the domain can process expression, false otherwise.

Specified by:

canProcess in interface SemanticEvaluator

Parameters:

expression - the expression

Returns:

true if the domain can process expression, false otherwise.

evalIdentifier

public T evalIdentifier(Identifier id,
                        ValueEnvironment<T> environment,
                        ProgramPoint pp)
                 throws SemanticException

Yields the evaluation of an identifier in a given environment.

Parameters:

id - the identifier to be evaluated

environment - the environment where the identifier must be evaluated

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

Returns:

the evaluation of the identifier

Throws:

SemanticException - if an error occurs during the computation

evalPushAny

public T evalPushAny(PushAny pushAny,
                     ProgramPoint pp)
              throws SemanticException

Yields the evaluation of a push-any expression.

Parameters:

pushAny - the push-any expression to be evaluated

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

Returns:

the evaluation of the push-any expression

Throws:

SemanticException - if an error occurs during the computation

evalTypeConv

public T evalTypeConv(BinaryExpression conv,
                      T left,
                      T right,
                      ProgramPoint pp)
               throws SemanticException

Yields the evaluation of a type conversion expression.

Parameters:

conv - the type conversion expression

left - the left expression, namely the expression to be converted

right - the right expression, namely the types to which left should be converted

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

Returns:

the evaluation of the type conversion expression

Throws:

SemanticException - if an error occurs during the computation

evalTypeCast

public T evalTypeCast(BinaryExpression cast,
                      T left,
                      T right,
                      ProgramPoint pp)
               throws SemanticException

Yields the evaluation of a type cast expression.

Parameters:

cast - the type casted expression

left - the left expression, namely the expression to be casted

right - the right expression, namely the types to which left should be casted

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

Returns:

the evaluation of the type cast expression

Throws:

SemanticException - if an error occurs during the computation

evalNullConstant

public T evalNullConstant(ProgramPoint pp)
                   throws SemanticException

Yields the evaluation of the null constant NullConstant.

Parameters:

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

Returns:

the evaluation of the constant

Throws:

SemanticException - if an error occurs during the computation

evalNonNullConstant

public T evalNonNullConstant(Constant constant,
                             ProgramPoint pp)
                      throws SemanticException

Yields the evaluation of the given non-null constant.

Parameters:

constant - the constant to evaluate

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

Returns:

the evaluation of the constant

Throws:

SemanticException - if an error occurs during the computation

evalUnaryExpression

public T evalUnaryExpression(UnaryOperator operator,
                             T arg,
                             ProgramPoint pp)
                      throws SemanticException

Yields the evaluation of a UnaryExpression applying operator to an expression whose abstract value is arg. It is guaranteed that arg is not Lattice.bottom().

Parameters:

operator - the operator applied by the expression

arg - the instance of this domain representing the abstract value of the expresion's argument

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

Returns:

the evaluation of the expression

Throws:

SemanticException - if an error occurs during the computation

evalBinaryExpression

public T evalBinaryExpression(BinaryOperator operator,
                              T left,
                              T right,
                              ProgramPoint pp)
                       throws SemanticException

Yields the evaluation of a BinaryExpression applying operator to two expressions whose abstract value are left and right, respectively. It is guaranteed that both left and right are not Lattice.bottom() and that operator is neither TypeCast nor TypeConv.

Parameters:

operator - the operator applied by the expression

left - the instance of this domain representing the abstract value of the left-hand side argument

right - the instance of this domain representing the abstract value of the right-hand side argument

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

Returns:

the evaluation of the expression

Throws:

SemanticException - if an error occurs during the computation

evalTernaryExpression

public T evalTernaryExpression(TernaryOperator operator,
                               T left,
                               T middle,
                               T right,
                               ProgramPoint pp)
                        throws SemanticException

Yields the evaluation of a TernaryExpression applying operator to two expressions whose abstract value are left, middle and right, respectively. It is guaranteed that both left and right are not Lattice.bottom().

Parameters:

operator - the operator applied by the expression

left - the instance of this domain representing the abstract value of the left-hand side argument

middle - the instance of this domain representing the abstract value of the middle argument

right - the instance of this domain representing the abstract value of the right-hand side argument

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

Returns:

the evaluation of the expression

Throws:

SemanticException - if an error occurs during the computation

satisfiesAbstractValue

public SemanticDomain.Satisfiability satisfiesAbstractValue(T value,
                                                            ProgramPoint pp)
                                                     throws SemanticException

Yields the satisfiability of an abstract value of type <T>.

Parameters:

value - the abstract value whose satisfiability is to be evaluated

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

Returns:

SemanticDomain.Satisfiability.SATISFIED if the expression is satisfied by 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

satisfiesNullConstant

public SemanticDomain.Satisfiability satisfiesNullConstant(ProgramPoint pp)
                                                    throws SemanticException

Yields the satisfiability of the null constant NullConstant on this abstract domain.

Parameters:

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

Returns:

SemanticDomain.Satisfiability.SATISFIED if the expression is satisfied by 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

satisfiesNonNullConstant

public SemanticDomain.Satisfiability satisfiesNonNullConstant(Constant constant,
                                                              ProgramPoint pp)
                                                       throws SemanticException

Yields the satisfiability of the given non-null constant on this abstract domain.

Parameters:

constant - the constant to satisfied

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

Returns:

SemanticDomain.Satisfiability.SATISFIED is the constant is satisfied by 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

satisfiesUnaryExpression

public SemanticDomain.Satisfiability satisfiesUnaryExpression(UnaryOperator operator,
                                                              T arg,
                                                              ProgramPoint pp)
                                                       throws SemanticException

Yields the satisfiability of a UnaryExpression applying operator to an expression whose abstract value is arg, returning an instance of SemanticDomain.Satisfiability. It is guaranteed that operator is not LogicalNegation and arg is not Lattice.bottom().

Parameters:

operator - the unary operator applied by the expression

arg - an instance of this abstract domain representing the argument of the unary expression

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

Returns:

SemanticDomain.Satisfiability.SATISFIED if the expression is satisfied by 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

satisfiesBinaryExpression

public SemanticDomain.Satisfiability satisfiesBinaryExpression(BinaryOperator operator,
                                                               T left,
                                                               T right,
                                                               ProgramPoint pp)
                                                        throws SemanticException

Yields the satisfiability of a BinaryExpression applying operator to two expressions whose abstract values are left, and right. This method returns an instance of SemanticDomain.Satisfiability. It is guaranteed that operator is neither LogicalAnd nor LogicalOr, and that both left and right are not Lattice.bottom().

Parameters:

operator - the binary operator applied by the expression

left - an instance of this abstract domain representing the argument of the left-hand side of the binary expression

right - an instance of this abstract domain representing the argument of the right-hand side of the binary expression

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

Returns:

SemanticDomain.Satisfiability.SATISFIED if the expression is satisfied by 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

satisfiesTernaryExpression

public SemanticDomain.Satisfiability satisfiesTernaryExpression(TernaryOperator operator,
                                                                T left,
                                                                T middle,
                                                                T right,
                                                                ProgramPoint pp)
                                                         throws SemanticException

Yields the satisfiability of a TernaryExpression applying operator to three expressions whose abstract values are left, middle and right. This method returns an instance of SemanticDomain.Satisfiability. It is guaranteed that left, middle and right are not Lattice.bottom().

Parameters:

operator - the ternary operator applied by the expression

left - an instance of this abstract domain representing the argument of the left-most side of the ternary expression

middle - an instance of this abstract domain representing the argument in the middle of the ternary expression

right - an instance of this abstract domain representing the argument of the right-most side of the ternary expression

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

Returns:

SemanticDomain.Satisfiability.SATISFIED if the expression is satisfied by 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

toString

public final java.lang.String toString()

Specified by:

toString in class BaseLattice<T extends BaseNonRelationalValueDomain<T>>

assume

public ValueEnvironment<T> assume(ValueEnvironment<T> environment,
                                  ValueExpression expression,
                                  ProgramPoint pp)
                           throws SemanticException

Description copied from interface: NonRelationalElement

Yields the environment environment on which the expression expression is assumed to hold by this domain.

Specified by:

assume in interface NonRelationalElement<T extends BaseNonRelationalValueDomain<T>,ValueExpression,ValueEnvironment<T extends BaseNonRelationalValueDomain<T>>>

Parameters:

environment - the environment

expression - the expression to be assumed

pp - the program point where expression occurs.

Returns:

the environment environment where expression is assumed to hold

Throws:

SemanticException - if an error occurs during the computation

assumeTernaryExpression

public ValueEnvironment<T> assumeTernaryExpression(ValueEnvironment<T> environment,
                                                   TernaryOperator operator,
                                                   ValueExpression left,
                                                   ValueExpression middle,
                                                   ValueExpression right,
                                                   ProgramPoint pp)
                                            throws SemanticException

Yields the environment environment assuming that a ternary expression with operator operator, left argument left, middle argument middle,and right argument right holds.

Parameters:

environment - the environment on which the expression must be assumed

operator - the operator of the ternary expression

left - the left-hand side argument of the ternary expression

middle - the middle-hand side argument of the ternary expression

right - the right-hand side argument of the ternary expression

pp - the program point where the ternary expression occurs

Returns:

the environment environment assuming that a ternary expression with operator operator, left argument left, middle argument middle,and right argument right holds

Throws:

SemanticException - if something goes wrong during the assumption

assumeBinaryExpression

public ValueEnvironment<T> assumeBinaryExpression(ValueEnvironment<T> environment,
                                                  BinaryOperator operator,
                                                  ValueExpression left,
                                                  ValueExpression right,
                                                  ProgramPoint pp)
                                           throws SemanticException

Yields the environment environment assuming that a binary expression with operator operator, left argument left, and right argument right holds. The binary expression with binary operator LogicalAnd and LogicalOr are already handled by assume(it.unive.lisa.analysis.nonrelational.value.ValueEnvironment<T>, it.unive.lisa.symbolic.value.ValueExpression, it.unive.lisa.program.cfg.ProgramPoint).

Parameters:

environment - the environment on which the expression must be assumed

operator - the operator of the binary expression

left - the left-hand side argument of the binary expression

right - the right-hand side argument of the binary expression

pp - the program point where the binary expression occurs

Returns:

the environment environment assuming that a binary expression with operator operator, left argument left, and right argument right holds

Throws:

SemanticException - if something goes wrong during the assumption

assumeUnaryExpression

public ValueEnvironment<T> assumeUnaryExpression(ValueEnvironment<T> environment,
                                                 UnaryOperator operator,
                                                 ValueExpression expression,
                                                 ProgramPoint pp)
                                          throws SemanticException

Yields the environment environment assuming that an unary expression with operator operator and argument expression holds.

Parameters:

environment - the environment on which the expression must be assumed

operator - the operator of the unary expression

expression - the argument of the unary expression

pp - the program point where the unary expression occurs

Returns:

the environment environment assuming that an unary expression with operator operator and argument expression holds.

Throws:

SemanticException - if something goes wrong during the assumption

glb

public T glb(T other)
      throws SemanticException

Description copied from interface: NonRelationalElement

Performs the greatest lower bound operation between this domain element and other.

Specified by:

glb in interface NonRelationalElement<T extends BaseNonRelationalValueDomain<T>,ValueExpression,ValueEnvironment<T extends BaseNonRelationalValueDomain<T>>>

Parameters:

other - the other domain element

Returns:

the greatest lowe bound between this and other

Throws:

SemanticException - if an error occurs during the computation

glbAux

public T glbAux(T other)
         throws SemanticException

Performs the greatest lower bound operation between this domain element and other, 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))
• this and other are not comparable

Parameters:

other - the other domain element

Returns:

the greatest lower bound between this domain element and other

Throws:

SemanticException - if an error occurs during the computation