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

Class Parity

java.lang.Object

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

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

it.unive.lisa.analysis.impl.numeric.Parity

All Implemented Interfaces:

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

public class Parity
extends BaseNonRelationalValueDomain<Parity>

The Parity abstract domain, tracking if a numeric value is even or odd, 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 bound, widening and less or equals operations are handled by BaseLattice in BaseLattice.lub(L), BaseLattice.widening(L) and BaseLattice.lessOrEqual(L) methods, 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
Parity()	Builds the parity abstract domain, representing the top of the parity abstract domain.

Method Summary

Modifier and Type	Method	Description
protected ValueEnvironment<Parity>	assumeBinaryExpression(ValueEnvironment<Parity> 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.
Parity	bottom()	Yields the bottom element of this lattice.
boolean	equals(java.lang.Object obj)
protected Parity	evalBinaryExpression(BinaryOperator operator, Parity left, Parity right, ProgramPoint pp)	Yields the evaluation of a BinaryExpression applying operator to two expressions whose abstract value are left and right, respectively.
protected Parity	evalNonNullConstant(Constant constant, ProgramPoint pp)	Yields the evaluation of the given non-null constant.
protected Parity	evalNullConstant(ProgramPoint pp)	Yields the evaluation of the null constant NullConstant.
protected Parity	evalUnaryExpression(UnaryOperator operator, Parity arg, ProgramPoint pp)	Yields the evaluation of a UnaryExpression applying operator to an expression whose abstract value is arg.
int	hashCode()
protected boolean	lessOrEqualAux(Parity 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 Parity	lubAux(Parity 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.
Parity	top()	Yields the top element of this lattice.
protected Parity	wideningAux(Parity 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, evalTernaryExpression, evalTypeCast, evalTypeConv, glb, glbAux, satisfies, satisfiesAbstractValue, satisfiesBinaryExpression, 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, isTop, lessOrEqual, lub, widening

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

variable

Constructor Detail

Parity

public Parity()

Builds the parity abstract domain, representing the top of the parity abstract domain.

Method Detail

top

public Parity 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

bottom

public Parity 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 Parity evalNullConstant(ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

Yields the evaluation of the null constant NullConstant.

Overrides:

evalNullConstant in class BaseNonRelationalValueDomain<Parity>

Parameters:

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

Returns:

the evaluation of the constant

evalNonNullConstant

protected Parity evalNonNullConstant(Constant constant,
                                     ProgramPoint pp)

Description copied from class: BaseNonRelationalValueDomain

Yields the evaluation of the given non-null constant.

Overrides:

evalNonNullConstant in class BaseNonRelationalValueDomain<Parity>

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 Parity evalUnaryExpression(UnaryOperator operator,
                                     Parity 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<Parity>

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 Parity evalBinaryExpression(BinaryOperator operator,
                                      Parity left,
                                      Parity 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<Parity>

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

lubAux

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

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 Parity wideningAux(Parity 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<Parity>

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(Parity 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<Parity>

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<Parity>

equals

public boolean equals(java.lang.Object obj)

Specified by:

equals in class BaseLattice<Parity>

assumeBinaryExpression

protected ValueEnvironment<Parity> assumeBinaryExpression(ValueEnvironment<Parity> 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<Parity>

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