Package it.unive.lisa.analysis.impl.numeric

Class IntegerConstantPropagation

java.lang.Object

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

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

it.unive.lisa.analysis.impl.numeric.IntegerConstantPropagation

All Implemented Interfaces:

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

public class IntegerConstantPropagation
extends BaseNonRelationalValueDomain<IntegerConstantPropagation>

The basic integer constant propagation abstract domain, tracking if a certain integer value has constant value or not, implemented as a BaseNonRelationalValueDomain, handling top and bottom values for the expression evaluation and bottom values for the expression satisfiability. Top and bottom cases for least upper bounds, widening and less or equals operations are handled by BaseLattice in BaseLattice.lub(L), BaseLattice.widening(L) and BaseLattice.lessOrEqual(L), respectively.

Field Summary

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

BOTTOM_REPR, BOTTOM_STRING, TOP_REPR, TOP_STRING

Constructor Summary

Constructors

Constructor	Description
IntegerConstantPropagation()	Builds the top abstract value.

Method Summary

Modifier and Type	Method	Description
protected ValueEnvironment<IntegerConstantPropagation>	assumeBinaryExpression(ValueEnvironment<IntegerConstantPropagation> 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.
IntegerConstantPropagation	bottom()	Yields the bottom element of this lattice.
boolean	equals(java.lang.Object obj)
protected IntegerConstantPropagation	evalBinaryExpression(BinaryOperator operator, IntegerConstantPropagation left, IntegerConstantPropagation right, ProgramPoint pp)	Yields the evaluation of a BinaryExpression applying operator to two expressions whose abstract value are left and right, respectively.
protected IntegerConstantPropagation	evalNonNullConstant(Constant constant, ProgramPoint pp)	Yields the evaluation of the given non-null constant.
protected IntegerConstantPropagation	evalNullConstant(ProgramPoint pp)	Yields the evaluation of the null constant NullConstant.
protected IntegerConstantPropagation	evalTernaryExpression(TernaryOperator operator, IntegerConstantPropagation left, IntegerConstantPropagation middle, IntegerConstantPropagation right, ProgramPoint pp)	Yields the evaluation of a TernaryExpression applying operator to two expressions whose abstract value are left, middle and right, respectively.
protected IntegerConstantPropagation	evalUnaryExpression(UnaryOperator operator, IntegerConstantPropagation arg, ProgramPoint pp)	Yields the evaluation of a UnaryExpression applying operator to an expression whose abstract value is arg.
int	hashCode()
boolean	isTop()	Yields true if and only if this object represents the top of the lattice.
protected boolean	lessOrEqualAux(IntegerConstantPropagation 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.
protected IntegerConstantPropagation	lubAux(IntegerConstantPropagation other)	Performs the least upper bound operation between this lattice element and the given one, assuming that base cases have already been handled.
DomainRepresentation	representation()	Yields a DomainRepresentation of the information contained in this domain's instance.
protected SemanticDomain.Satisfiability	satisfiesBinaryExpression(BinaryOperator operator, IntegerConstantPropagation left, IntegerConstantPropagation right, ProgramPoint pp)	Yields the satisfiability of a BinaryExpression applying operator to two expressions whose abstract values are left, and right.
IntegerConstantPropagation	top()	Yields the top element of this lattice.
protected IntegerConstantPropagation	wideningAux(IntegerConstantPropagation 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.nonrelational.value.BaseNonRelationalValueDomain

assume, assumeTernaryExpression, assumeUnaryExpression, canProcess, eval, evalIdentifier, evalPushAny, evalTypeCast, evalTypeConv, glb, glbAux, satisfies, satisfiesAbstractValue, satisfiesNonNullConstant, satisfiesNullConstant, satisfiesTernaryExpression, satisfiesUnaryExpression, toString, tracksIdentifiers

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

isBottom, lessOrEqual, lub, widening

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

variable

Constructor Detail

IntegerConstantPropagation

public IntegerConstantPropagation()

Builds the top abstract value.

Method Detail

top

public IntegerConstantPropagation 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.

Returns:

the top 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.

Returns:

true if this is the top of the lattice

bottom

public IntegerConstantPropagation 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.

Returns:

the bottom element

representation

public DomainRepresentation representation()

Description copied from interface: NonRelationalElement

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

Returns:

the representation

evalNullConstant

protected IntegerConstantPropagation evalNullConstant(ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

Yields the evaluation of the null constant NullConstant.

Overrides:

evalNullConstant in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

Parameters:

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

Returns:

the evaluation of the constant

evalNonNullConstant

protected IntegerConstantPropagation evalNonNullConstant(Constant constant,
                                                         ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

Yields the evaluation of the given non-null constant.

Overrides:

evalNonNullConstant in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

Parameters:

constant - the constant to evaluate

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

Returns:

the evaluation of the constant

evalUnaryExpression

protected IntegerConstantPropagation evalUnaryExpression(UnaryOperator operator,
                                                         IntegerConstantPropagation arg,
                                                         ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

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().

Overrides:

evalUnaryExpression in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

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

evalBinaryExpression

protected IntegerConstantPropagation evalBinaryExpression(BinaryOperator operator,
                                                          IntegerConstantPropagation left,
                                                          IntegerConstantPropagation right,
                                                          ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

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 BinaryOperator.TYPE_CAST nor BinaryOperator.TYPE_CONV.

Overrides:

evalBinaryExpression in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

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

evalTernaryExpression

protected IntegerConstantPropagation evalTernaryExpression(TernaryOperator operator,
                                                           IntegerConstantPropagation left,
                                                           IntegerConstantPropagation middle,
                                                           IntegerConstantPropagation right,
                                                           ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

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().

Overrides:

evalTernaryExpression in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

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

lubAux

protected IntegerConstantPropagation lubAux(IntegerConstantPropagation 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<IntegerConstantPropagation>

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

protected IntegerConstantPropagation wideningAux(IntegerConstantPropagation 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))

Specified by:

wideningAux in class BaseLattice<IntegerConstantPropagation>

Parameters:

other - the other lattice element

Returns:

the widening between this and other

Throws:

SemanticException - if an error occurs during the computation

lessOrEqualAux

protected boolean lessOrEqualAux(IntegerConstantPropagation 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<IntegerConstantPropagation>

Parameters:

other - the other lattice element

Returns:

true if and only if that condition holds

Throws:

SemanticException - if an error occurs during the computation

hashCode

public int hashCode()

Specified by:

hashCode in class BaseLattice<IntegerConstantPropagation>

equals

public boolean equals(java.lang.Object obj)

Specified by:

equals in class BaseLattice<IntegerConstantPropagation>

satisfiesBinaryExpression

protected SemanticDomain.Satisfiability satisfiesBinaryExpression(BinaryOperator operator,
                                                                  IntegerConstantPropagation left,
                                                                  IntegerConstantPropagation right,
                                                                  ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

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 BinaryOperator.LOGICAL_AND nor BinaryOperator.LOGICAL_OR, and that both left and right are not Lattice.bottom().

Overrides:

satisfiesBinaryExpression in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

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)

assumeBinaryExpression

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

Description copied from class: BaseNonRelationalValueDomain

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 BinaryOperator.LOGICAL_AND and BinaryOperator.LOGICAL_OR are already handled by BaseNonRelationalValueDomain.assume(it.unive.lisa.analysis.nonrelational.value.ValueEnvironment<T>, it.unive.lisa.symbolic.value.ValueExpression, it.unive.lisa.program.cfg.ProgramPoint).

Overrides:

assumeBinaryExpression in class BaseNonRelationalValueDomain<IntegerConstantPropagation>

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