Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package opalj

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode. OPAL is designed with performance, scalability and adaptability in mind.

    Its main components are:

    • a library (Common) which provides generally useful data-structures and algorithms for static analyses.
    • a framework for implementing lattice based static analyses (Static Analysis Infrastructure)
    • a framework for parsing Java bytecode (Bytecode Infrastructure) that can be used to create arbitrary representations.
    • a library to create a one-to-one in-memory representation of Java bytecode (Bytecode Disassembler).
    • a library to create a representation of Java bytecode that facilitates writing simple static analyses (Bytecode Representation - org.opalj.br).
    • a scalable, easily customizable framework for the abstract interpretation of Java bytecode (Abstract Interpretation Framework - org.opalj.ai).
    • a library to extract dependencies between code elements and to facilitate checking architecture definitions.
    • a library for the lightweight manipulation and creation of Java bytecode (Bytecode Assembler).

    General Design Decisions

    Thread Safety

    Unless explicitly noted, OPAL is thread safe. I.e., the classes defined by OPAL can be considered to be thread safe unless otherwise stated. (For example, it is possible to read and process class files concurrently without explicit synchronization on the client side.)

    No null Values

    Unless explicitly noted, OPAL does not null values I.e., fields that are accessible will never contain null values and methods will never return null. If a method accepts null as a value for a parameter or returns a null value it is always explicitly documented. In general, the behavior of methods that are passed null values is undefined unless explicitly documented.

    No Typecasts for Collections

    For efficiency reasons, OPAL sometimes uses mutable data-structures internally. After construction time, these data-structures are generally represented using their generic interfaces (e.g., scala.collection.{Set,Map}). However, a downcast (e.g., to add/remove elements) is always forbidden as it would effectively prevent thread-safety.

    Assertions

    OPAL makes heavy use of Scala's Assertion Facility to facilitate writing correct code. Hence, for production builds (after thorough testing(!)) it is highly recommend to build OPAL again using -Xdisable-assertions.

    Definition Classes
    org
  • package ai

    Implementation of an abstract interpretation (ai) framework – also referred to as OPAL.

    Implementation of an abstract interpretation (ai) framework – also referred to as OPAL.

    Please note that OPAL/the abstract interpreter just refers to the classes and traits defined in this package (ai). The classes and traits defined in the sub-packages (in particular in domain) are not considered to be part of the core of OPAL/the abstract interpreter.

    Definition Classes
    opalj
    Note

    This framework assumes that the analyzed bytecode is valid; i.e., the JVM's bytecode verifier would be able to verify the code. Furthermore, load-time errors (e.g., LinkageErrors) are – by default – completely ignored to facilitate the analysis of parts of a project. In general, if the presented bytecode is not valid, the result is undefined (i.e., OPAL may report meaningless results, crash or run indefinitely).

    See also

    org.opalj.ai.AI - Implements the abstract interpreter that processes a methods code and uses an analysis-specific domain to perform the abstract computations.

    org.opalj.ai.Domain - The core interface between the abstract interpretation framework and the abstract domain that is responsible for performing the abstract computations.

  • package domain

    This package contains definitions of common domains that can be used for the implementation of analyses.

    This package contains definitions of common domains that can be used for the implementation of analyses.

    Types of Domains

    In general, we distinguish two types of domains. First, domains that define a general interface (on top of the one defined by Domain), but do not directly provide an implementation. Hence, whenever you develop a new Domain you should consider implementing/using these domains to maximize reusability. Second, Domains that implement a specific interface (trait). In this case, we further distinguish between domains that provide a default implementation (per interface only one of these Domains can be used to create a final Domain) and those that can be stacked and basically refine the overall functionality.

    Examples

    • Domains That Define a General Interface
      • Origin defines two types which domains that provide information abou the origin of a value should consider to implement.
      • TheProject defines a standard mechanism how a domain can access the current project.
      • ...
    • Domains That Provide a Default Implementation
    • Domains That Implement Stackable Functionality
      • org.opalj.ai.domain.RecordThrownExceptions records information about all uncaught exceptions by intercepting a Domain's respective methods. However, it does provide a default implementation. Hence, a typical pattern is:
    class MyDomain extends Domain with ...
    with DefaultHandlingOfMethodResults with RecordThrownExceptions

    Thread Safety

    Unless explicitly documented, a domain is never thread-safe. The general programming model is to use one Domain object per code block/method and therefore, thread-safety is not required for Domains that are used for the evaluation of methods. However domains that are used to adapt/transfer values should be thread safe (see org.opalj.ai.domain.ValuesCoordinatingDomain for further details).

    Definition Classes
    ai
  • package l1

    Commonly useful methods.

    Commonly useful methods.

    Definition Classes
    domain
  • trait DefaultIntegerRangeValues extends DefaultSpecialDomainValuesBinding with IntegerRangeValues

    This domain implements the tracking of integer values at the level of ranges.

    This domain implements the tracking of integer values at the level of ranges.

    Definition Classes
    l1
  • AnIntegerValue
  • AnIntegerValueLike
  • ConcreteIntegerValue
  • DomainReferenceValue
  • IllegalValue
  • IntegerLikeValue
  • IntegerRange
  • IntegerRangeLike
  • RETValue
  • ReferenceValue
  • ReturnAddressValue
  • ReturnAddressValues
  • TypedValue
  • Value

class IntegerRange extends (DefaultIntegerRangeValues.this)#IntegerRangeLike

Represents a specific integer value in the range [lowerBound,upperBound].

Source
DefaultIntegerRangeValues.scala
Linear Supertypes
(DefaultIntegerRangeValues.this)#IntegerRangeLike, (DefaultIntegerRangeValues.this)#IntegerLikeValue, IsIntegerValue, IsIntegerLikeValue[IntegerType], IsPrimitiveValue[IntegerType], ConstantValueInformationProvider[JType], (DefaultIntegerRangeValues.this)#TypedValue[CTIntType], KnownTypedValue, KnownValue, (DefaultIntegerRangeValues.this)#Value, ValueInformation, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IntegerRange
  2. IntegerRangeLike
  3. IntegerLikeValue
  4. IsIntegerValue
  5. IsIntegerLikeValue
  6. IsPrimitiveValue
  7. ConstantValueInformationProvider
  8. TypedValue
  9. KnownTypedValue
  10. KnownValue
  11. Value
  12. ValueInformation
  13. AnyRef
  14. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new IntegerRange(lowerBound: Int, upperBound: Int)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def PCIndependent: Int
    Definition Classes
    Value
    Annotations
    @inline()
  5. def abstractsOver(other: (DefaultIntegerRangeValues.this)#DomainValue): Boolean

    Returns true iff the abstract state represented by this value abstracts over the state of the given value.

    Returns true iff the abstract state represented by this value abstracts over the state of the given value. In other words if every possible runtime value represented by the given value is also represented by this value.

    The abstract state generally encompasses every information that would be considered during a join of this value and the other value and that could lead to a true Update.

    This method is reflexive, I.e., every value abstracts over itself.

    TheIllegalValue only abstracts over itself.

    Definition Classes
    IntegerRange → Value
    Note

    abstractsOver is only defined for comparable values where both values have the same computational type.

    ,

    The default implementation uses the join method of this domain value. Overriding this method is, hence, primarily meaningful for performance reasons.

    See also

    isMorePreciseThan

  6. def adapt(target: TargetDomain, pc: Int): (target)#DomainValue

    Adapts this value to the given domain (default: throws a domain exception that adaptation is not supported).

    Adapts this value to the given domain (default: throws a domain exception that adaptation is not supported). This method needs to be overridden by concrete Value classes to support the adaptation for a specific domain.

    Supporting the adapt method is primarily necessary when you want to analyze a method that is called by the currently analyzed method and you need to adapt this domain's values (the actual parameters of the method) to the domain used for analyzing the called method.

    Additionally, the adapt method is OPAL's main mechanism to enable dynamic domain-adaptation. I.e., to make it possible to change the abstract domain at runtime if the analysis time takes too long using a (more) precise domain.

    Definition Classes
    IntegerRange → Value
    Note

    The abstract interpretation framework does not use/call this method. This method is solely predefined to facilitate the development of project-wide analyses.

  7. def asConstantBoolean: Boolean
    Definition Classes
    ConstantValueInformationProvider
  8. def asConstantByte: Byte
    Definition Classes
    ConstantValueInformationProvider
  9. def asConstantChar: Char
    Definition Classes
    ConstantValueInformationProvider
  10. def asConstantDouble: Double
    Definition Classes
    ConstantValueInformationProvider
  11. def asConstantFloat: Float
    Definition Classes
    ConstantValueInformationProvider
  12. def asConstantInteger: Integer
    Definition Classes
    IsIntegerValue → ConstantValueInformationProvider
  13. def asConstantLong: Long
    Definition Classes
    ConstantValueInformationProvider
  14. def asConstantShort: Short
    Definition Classes
    ConstantValueInformationProvider
  15. def asDomainReferenceValue: (DefaultIntegerRangeValues.this)#DomainReferenceValue

    Returns the represented reference value iff this value represents a reference value.

    Returns the represented reference value iff this value represents a reference value.

    Definition Classes
    Value
  16. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  17. final def asPrimitiveValue: IsPrimitiveValue[IntegerType]
    Definition Classes
    IsPrimitiveValue → ValueInformation
  18. def asReferenceValue: IsReferenceValue
    Definition Classes
    ValueInformation
  19. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
  20. final def computationalType: ComputationalType

    The computational type of the value if this object represents a legal value.

    The computational type of the value if this object represents a legal value.

    The precise computational type is, e.g., needed to calculate the effect of generic stack manipulation instructions (e.g., DUP_... and SWAP) on the stack as well as to calculate the jump targets of RET instructions and to determine which values are actually copied by, e.g., the dup_XX instructions.

    Definition Classes
    IsPrimitiveValue → ValueInformation
    Exceptions thrown

    IllegalStateException if this value is illegal or void.

    Note

    The computational type has to be precise/correct.

  21. def constantValue: Option[ValueOrigin]

    The constant value that this variable takes - if it take a single constant value! I.e., if the variable may take multiple different values at runtime constantValue will return None.

    The constant value that this variable takes - if it take a single constant value! I.e., if the variable may take multiple different values at runtime constantValue will return None.

    Definition Classes
    IntegerRange → ConstantValueInformationProvider
  22. def doJoin(pc: Int, other: (DefaultIntegerRangeValues.this)#DomainValue): Update[(DefaultIntegerRangeValues.this)#DomainValue]

    Joins this value and the given value.

    Joins this value and the given value.

    Join is called whenever an instruction is evaluated more than once and, hence, the values found on the paths need to be joined. This method is, however, only called if the two values are two different objects ((this ne value) === true), but both values have the same computational type.

    This basically implements the join operator of complete lattices.

    Example

    For example, joining a DomainValue that represents the integer value 0 with a DomainValue that represents the integer value 1 may return a new DomainValue that precisely captures the range [0..1] or that captures all positive integer values or just some integer value.

    Contract

    this value is always the value that was previously used to perform subsequent computations/analyses. Hence, if this value subsumes the given value, the result has to be either NoUpdate or a MetaInformationUpdate. In case that the given value subsumes this value, the result has to be a StructuralUpdate with the given value as the new value. Hence, this join operation is not commutative. If a new (more abstract) abstract value is created that represents both values the result always has to be a StructuralUpdate. If the result is a StructuralUpdate the framework will continue with the interpretation.

    The termination of the abstract interpretation directly depends on the fact that at some point all (abstract) values are fixed and don't change anymore. Hence, it is important that the type of the update is only a org.opalj.ai.StructuralUpdate if the value has changed in a way relevant for future computations/analyses involving this value. In other words, when two values are joined it has to be ensured that no fall back to a previous value occurs. E.g., if you join the existing integer value 0 and the given value 1 and the result would be 1, then it must be ensured that a subsequent join with the value 0 will not result in the value 0 again.

    Conceptually, the join of an object with itself has to return the object itself. Note, that this is a conceptual requirement as such a call (this.doJoin(..,this)) will not be performed by the abstract interpretation framework; this case is handled by the join method. However, if the join object is also used by the implementation of the domain itself, it may be necessary to explicitly handle self-joins.

    Performance

    In general, the domain should try to minimize the number of objects that it uses to represent values. That is, two values that are conceptually equal should – whenever possible – use only one object. This has a significant impact on functions such as join.

    pc

    The program counter of the instruction where the paths converge.

    Definition Classes
    IntegerRange → Value
  23. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. def equals(other: Any): Boolean
    Definition Classes
    IntegerRange → AnyRef → Any
  25. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  26. final def hasCategory2ComputationalType: Boolean

    Returns true if and only if the value has the computational type 2; false in all other cases (including the case where this value is illegal!).

    Returns true if and only if the value has the computational type 2; false in all other cases (including the case where this value is illegal!).

    Definition Classes
    IsIntegerValue → ValueInformation
  27. def hashCode(): Int
    Definition Classes
    IntegerRange → AnyRef → Any
  28. final def isArrayValue: Answer

    Returns Yes if the value is _not null_ and the least upper type bound is an ArrayType; the value is Unknown if the least upper type bound is ArrayType but the value may be null; in all other cases No is returned; in particular if the value is known to be null.

    Returns Yes if the value is _not null_ and the least upper type bound is an ArrayType; the value is Unknown if the least upper type bound is ArrayType but the value may be null; in all other cases No is returned; in particular if the value is known to be null. No is also returned if the value's type is Object or Seriablizable or Cloneable.

    Definition Classes
    IsPrimitiveValue → ValueInformation
  29. final def isIllegalValue: Boolean

    Returns true iff this value is not a legal value according to the JVM specification.

    Returns true iff this value is not a legal value according to the JVM specification. Such values cannot be used to perform any computations and will generally not occur in static analyses unless the analysis or the bytecode is buggy.

    Definition Classes
    KnownValue → ValueInformation
    Note

    An IsIllegalValue can always be distinguished from a void value.

  30. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  31. def isMorePreciseThan(other: (DefaultIntegerRangeValues.this)#DomainValue): Boolean

    Returns true iff the abstract state represented by this value is strictly more precise than the state of the given value.

    Returns true iff the abstract state represented by this value is strictly more precise than the state of the given value. In other words if every possible runtime value represented by this value is also represented by the given value, but both are not equal; in other words, this method is irreflexive.

    The considered abstract state generally encompasses every information that would be considered during a join of this value and the other value and that could lead to a StructuralUpdate.

    other

    Another DomainValue with the same computational type as this value. (The IllegalValue has no computational type and, hence, a comparison with an IllegalValue is not well defined.)

    Definition Classes
    Value
    Note

    It is recommended to overwrite this method for performance reasons, as the default implementation relies on join.

    See also

    abstractsOver

  32. final def isPrimitiveValue: Boolean

    Returns true in case of a value with primitive type.

    Returns true in case of a value with primitive type.

    Definition Classes
    IsPrimitiveValue → ValueInformation
    Exceptions thrown

    IllegalStateException if this value is illegal.

  33. final def isReferenceValue: Boolean

    Returns true if the value has a reference type.

    Returns true if the value has a reference type.

    Definition Classes
    IsPrimitiveValue → ValueInformation
    Exceptions thrown

    IllegalStateException if this value is illegal.

  34. final def isVoid: Boolean

    Returns true if this value represents void.

    Returns true if this value represents void.

    Definition Classes
    KnownTypedValue → ValueInformation
  35. def join(pc: Int, that: (DefaultIntegerRangeValues.this)#DomainValue): Update[(DefaultIntegerRangeValues.this)#DomainValue]

    Checks that the given value and this value are compatible with regard to its computational type and – if so – calls doJoin.

    Checks that the given value and this value are compatible with regard to its computational type and – if so – calls doJoin.

    See doJoin(PC,DomainValue) for details.

    pc

    The program counter of the instruction where the paths converge or Int.MinValue if the join is done independently of an instruction.

    that

    The "new" domain value with which this domain value should be joined. The caller has to ensure that the given value and this value are guaranteed to be two different objects.

    returns

    MetaInformationUpdateIllegalValue or the result of calling doJoin.

    Definition Classes
    Value
    Note

    It is in general not recommended/needed to override this method.

  36. final def leastUpperType: Option[CTIntType]

    The type kind of the values, if the value has a specific type kind; None if and only if the underlying value is null.

    The type kind of the values, if the value has a specific type kind; None if and only if the underlying value is null.

    returns

    The type/the least upper type bound of the value. If the type is a base type, then the type is necessarily precise. In case of a reference type the type may be an upper type bound or may be precise. In the latter case, it may be possible to get further information using the concrete domain. If the underlying value is null, None is returned.

    Definition Classes
    IntegerLikeValue → TypedValue
  37. val lowerBound: Int
    Definition Classes
    IntegerRange → IntegerRangeLike → IsIntegerValue
  38. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  39. def newInstance: (DefaultIntegerRangeValues.this)#IntegerRange
    Definition Classes
    IntegerRange → IntegerLikeValue
  40. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  41. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  42. final def primitiveType: IntegerType
    Definition Classes
    IsIntegerValue → IsPrimitiveValue
  43. def summarize(pc: Int): (DefaultIntegerRangeValues.this)#DomainValue

    Creates a summary of this value.

    Creates a summary of this value.

    In general, creating a summary of a value may be useful/required for values that are potentially returned by a called method and which will then be used by the calling method. For example, it may be useful to precisely track the flow of values within a method to be able to distinguish between all sources of a value (E.g., to be able to distinguish between a NullPointerException created by instruction A and another one created by instruction B (A != B).)

    However, from the caller perspective it may be absolutely irrelevant where/how the value was created in the called method and, hence, keeping all information would just waste memory and a summary may be sufficient.

    Definition Classes
    IntegerRange → Value
    Note

    This method is predefined to facilitate the development of project-wide analyses.

  44. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  45. def toCanonicalForm: ValueInformation

    Returns a ValueInformation object that just captures the basic information as defined by this value framework.

    Returns a ValueInformation object that just captures the basic information as defined by this value framework. The returned value information object will be independent of the underlying representation from which it was derived.

    Definition Classes
    IsIntegerValue → ValueInformation
  46. def toString(): String
    Definition Classes
    IntegerRange → AnyRef → Any
  47. def update(newValue: Int): (DefaultIntegerRangeValues.this)#DomainValue

    Creates a new IntegerRange value that also represents the given value.

    Creates a new IntegerRange value that also represents the given value. A new integer value is always created.

  48. val upperBound: Int
    Definition Classes
    IntegerRange → IntegerRangeLike → IsIntegerValue
  49. final def verificationTypeInfo: VerificationTypeInfo

    The type of this value as used by the org.opalj.br.StackMapTable attribute.

    The type of this value as used by the org.opalj.br.StackMapTable attribute.

    Definition Classes
    IsIntegerLikeValue → ValueInformation
    Exceptions thrown

    IllegalStateException if this value represents void or a return address value.

  50. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  51. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  52. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from (DefaultIntegerRangeValues.this)#IntegerRangeLike

Inherited from (DefaultIntegerRangeValues.this)#IntegerLikeValue

Inherited from IsIntegerValue

Inherited from IsIntegerLikeValue[IntegerType]

Inherited from IsPrimitiveValue[IntegerType]

Inherited from ConstantValueInformationProvider[JType]

Inherited from (DefaultIntegerRangeValues.this)#TypedValue[CTIntType]

Inherited from KnownTypedValue

Inherited from KnownValue

Inherited from (DefaultIntegerRangeValues.this)#Value

Inherited from ValueInformation

Inherited from AnyRef

Inherited from Any

Ungrouped