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 l0
    Definition Classes
    domain
  • trait DefaultReferenceValuesBinding extends DefaultTypeLevelReferenceValues with DefaultExceptionsFactory

    Default implementation for handling reference values.

    Default implementation for handling reference values.

    Definition Classes
    l0
  • ANullValue
  • AnArrayValue
  • AnObjectValue
  • ArrayAbstraction
  • ArrayValueLike
  • DefaultArrayValue
  • DefaultMObjectValue
  • DefaultSObjectValue
  • IllegalValue
  • IsNull
  • IsPrecise
  • MObjectValueLike
  • NullValueLike
  • ObjectValueLike
  • RETValue
  • ReferenceValue
  • ReferenceValueLike
  • ReturnAddressValue
  • ReturnAddressValues
  • SObjectValueLike
  • SReferenceValue
  • TypedValue
  • UpperTypeBound
  • Value

case class DefaultMObjectValue(upperTypeBound: UIDSet[ObjectType]) extends (DefaultReferenceValuesBinding.this)#MObjectValueLike with Product with Serializable

Attributes
protected
Source
DefaultReferenceValuesBinding.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. DefaultMObjectValue
  2. Serializable
  3. Product
  4. Equals
  5. MObjectValueLike
  6. IsMObjectValue
  7. IsBaseReferenceValue
  8. AnObjectValue
  9. ObjectValueLike
  10. ReferenceValueLike
  11. ArrayAbstraction
  12. ReferenceValue
  13. IsReferenceValue
  14. TypedValue
  15. KnownTypedValue
  16. KnownValue
  17. Value
  18. ValueInformation
  19. AnyRef
  20. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new DefaultMObjectValue(upperTypeBound: UIDSet[ObjectType])

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: (DefaultReferenceValuesBinding.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
    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, origin: ValueOrigin): (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
    MObjectValueLikeValue
    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. final def allValues: Iterable[DefaultMObjectValue.this.type]

    The set of base values (IsReferenceValue) this value abstracts over.

    The set of base values (IsReferenceValue) this value abstracts over. This set is never empty and contains this value if this value does not (further) abstract over other reference values; otherwise it only contains the base values, but not this value.

    Definition Classes
    IsBaseReferenceValueIsReferenceValue
    Note

    Primarily defined as a convenience interface.

  8. final def asDomainReferenceValue: (DefaultReferenceValuesBinding.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
    ReferenceValueLikeValue
  9. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  10. def asPrimitiveValue: IsPrimitiveValue[_ <: BaseType]
    Definition Classes
    ValueInformation
  11. final def asReferenceType: ReferenceType

    Returns the type of the upper type bound if the upper type bound contains exactly one element.

    Returns the type of the upper type bound if the upper type bound contains exactly one element. That is, the function is only always defined iff the type is precise.

    Definition Classes
    IsReferenceValue
  12. final def asReferenceValue: IsReferenceValue
    Definition Classes
    IsReferenceValueValueInformation
  13. def asStructuralUpdate(pc: Int, newUpperTypeBound: UIDSet[ObjectType]): Update[(DefaultReferenceValuesBinding.this)#DomainValue]
    Attributes
    protected
    Definition Classes
    AnObjectValue
  14. final def baseValues: Iterable[DefaultMObjectValue.this.type]

    In general an IsReferenceValue abstracts over all potential values and this information is sufficient for subsequent analyses; but in some cases, analyzing the set of underlying values may increase the overall precision and this set is returned by this function.

    In general an IsReferenceValue abstracts over all potential values and this information is sufficient for subsequent analyses; but in some cases, analyzing the set of underlying values may increase the overall precision and this set is returned by this function. In other words: if baseValues is nonEmpty, then the properties returned by this value are derived from the base values, but still maybe more specific. For example,

    Object o = _;
    if(...) o = f() else o = g();
    // when we reach this point, we generally don't know if the values returned by f and g
    // are non-null; hence, o is potentially null.
    if(o != null)
     // Now, we know that o is not null, but we still don't know if the values returned
     // by f OR g were null and we cannot establish that when we don't know to which value
     // o is actually referring to.
     u(o);
    returns

    The set of values this reference value abstracts over. The set is empty if this value is already a base value and it does not abstract over other values.

    Definition Classes
    IsBaseReferenceValueIsReferenceValue
    Note

    A reference value which belongs to the base values by some other reference value never has itself as a direct base value.

  15. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
  16. 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
    IsReferenceValueValueInformation
    Exceptions thrown

    IllegalStateException if this value is illegal or void.

    Note

    The computational type has to be precise/correct.

  17. def doJoin(pc: Int, other: (DefaultReferenceValuesBinding.this)#DomainValue): Update[(DefaultReferenceValuesBinding.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.

    Attributes
    protected
    Definition Classes
    MObjectValueLikeValue
  18. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  20. 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
    IsReferenceValueValueInformation
  21. 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
    IsMObjectValueValueInformation
  22. 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
    KnownValueValueInformation
    Note

    An IsIllegalValue can always be distinguished from a void value.

  23. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  24. def isMorePreciseThan(other: (DefaultReferenceValuesBinding.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

  25. def isNull: Answer

    If Yes the value is known to always be null at runtime.

    If Yes the value is known to always be null at runtime. In this case the upper bound is (has to be) empty. If the answer is Unknown then the analysis was not able to statically determine whether the value is null or is not null. In this case the upper bound is expected to be non-empty. If the answer is No then the value is statically known not to be null. In this case, the upper bound may precisely identify the runtime type or still just identify an upper bound.

    Definition Classes
    DefaultMObjectValueIsReferenceValue
  26. def isPrecise: Boolean

    Returns true if the type information is precise.

    Returns true if the type information is precise. I.e., the type returned by upperTypeBound precisely models the runtime type of the value. If, isPrecise returns true, the type of this value can generally be assumed to represent a class type (not an interface type) or an array type. However, this domain also supports the case that isPrecise returns true even though the associated type identifies an interface type or an abstract class type. The later case may be interesting in the context of classes that are generated at run time.

    Definition Classes
    IsMObjectValueIsReferenceValue
  27. 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
    IsReferenceValueValueInformation
    Exceptions thrown

    IllegalStateException if this value is illegal.

  28. final def isReferenceValue: Boolean

    Returns true if the value has a reference type.

    Returns true if the value has a reference type.

    Definition Classes
    IsReferenceValueValueInformation
    Exceptions thrown

    IllegalStateException if this value is illegal.

  29. def isValueASubtypeOf(supertype: ReferenceType)(implicit classHierarchy: ClassHierarchy): Answer

    Determines if this value is a subtype of the given supertype by delegating to the isSubtypeOf(ReferenceType,ReferenceType) method of the domain.

    Determines if this value is a subtype of the given supertype by delegating to the isSubtypeOf(ReferenceType,ReferenceType) method of the domain.

    Definition Classes
    IsMObjectValueIsReferenceValue
    Note

    This is a very basic implementation that cannot determine that this value is not a subtype of the given type as this implementation does not distinguish between class types and interface types.

  30. final def isVoid: Boolean

    Returns true if this value represents void.

    Returns true if this value represents void.

    Definition Classes
    KnownTypedValueValueInformation
  31. def join(pc: Int, that: (DefaultReferenceValuesBinding.this)#DomainValue): Update[(DefaultReferenceValuesBinding.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.

  32. def leastUpperType: Option[ReferenceType]

    The least upper type bound of the value.

    The least upper type bound of the value.

    None if and only if the underlying value is null.

    Definition Classes
    MObjectValueLikeIsReferenceValueTypedValue
  33. final def length(pc: Int): Computation[(DefaultReferenceValuesBinding.this)#DomainValue, (DefaultReferenceValuesBinding.this)#ExceptionValue]
    Definition Classes
    AnObjectValueArrayAbstraction
  34. final def load(pc: Int, index: (DefaultReferenceValuesBinding.this)#DomainValue): (DefaultReferenceValuesBinding.this)#ArrayLoadResult
    Definition Classes
    AnObjectValueArrayAbstraction
  35. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  36. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  37. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  38. def productElementNames: Iterator[String]
    Definition Classes
    Product
  39. final def store(pc: Int, value: (DefaultReferenceValuesBinding.this)#DomainValue, index: (DefaultReferenceValuesBinding.this)#DomainValue): (DefaultReferenceValuesBinding.this)#ArrayStoreResult
    Definition Classes
    AnObjectValueArrayAbstraction
  40. def summarize(origin: ValueOrigin): DefaultMObjectValue.this.type

    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
    MObjectValueLikeValue
    Note

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

  41. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  42. def toCanonicalForm: IsBaseReferenceValue

    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
    IsMObjectValueIsBaseReferenceValueIsReferenceValueValueInformation
  43. def toString(): String
    Definition Classes
    MObjectValueLike → AnyRef → Any
  44. val upperTypeBound: UIDSet[ObjectType]

    All types from which the (precise, but unknown) type of the represented value inherits.

    All types from which the (precise, but unknown) type of the represented value inherits. I.e., the value represented by this domain value is known to have a type that (in)directly inherits from all given types at the same time. Hence, the upperTypeBound may contain at most one class type.

    Definition Classes
    DefaultMObjectValueIsMObjectValueIsReferenceValue
  45. 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
    IsMObjectValueValueInformation
    Exceptions thrown

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

  46. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  47. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  48. 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 Serializable

Inherited from Product

Inherited from Equals

Inherited from (DefaultReferenceValuesBinding.this)#MObjectValueLike

Inherited from IsMObjectValue

Inherited from IsBaseReferenceValue

Inherited from (DefaultReferenceValuesBinding.this)#AnObjectValue

Inherited from (DefaultReferenceValuesBinding.this)#ObjectValueLike

Inherited from (DefaultReferenceValuesBinding.this)#ReferenceValueLike

Inherited from (DefaultReferenceValuesBinding.this)#ArrayAbstraction

Inherited from (DefaultReferenceValuesBinding.this)#ReferenceValue

Inherited from IsReferenceValue

Inherited from (DefaultReferenceValuesBinding.this)#TypedValue[ReferenceType]

Inherited from KnownTypedValue

Inherited from KnownValue

Inherited from (DefaultReferenceValuesBinding.this)#Value

Inherited from ValueInformation

Inherited from AnyRef

Inherited from Any

Ungrouped