Type Members

1.  abstract class AI[D <: Domain] extends AnyRef

   A highly-configurable framework for the (abstract) interpretation of Java bytecode.

   A highly-configurable framework for the (abstract) interpretation of Java bytecode. The framework is built upon OPAL's standard representation (org.opalj.br) of Java bytecode.

   This framework basically traverses all instructions of a method in depth-first order until an instruction is hit where multiple control flows potentially join. This instruction is then only analyzed if no further instruction can be evaluated where no paths join (org.opalj.br.Code.cfPCs). Each instruction is then evaluated using a given (abstract) org.opalj.ai.Domain. The evaluation of a subroutine (Java code < 1.5) - in case of an unhandled exception – is always first completed before the evaluation of the parent (sub)routine is continued.

   Interacting with OPAL's Abstract Interpreter

   The primary means how to make use of this framework is to perform an abstract interpretation of a method using a customized Domain. That customized domain can be used, e.g., to build a call graph or to do other intra-/interprocedural analyses while the code is analyzed. Additionally, it is possible to analyze the result of an abstract interpretation. The latter is particularly facilitated by the 3-address code.

   Thread Safety

   This class is thread-safe. However, to make it possible to use one abstract interpreter instance for the concurrent abstract interpretation of independent methods, the AITracer (if any) has to be thread-safe too.

   Hence, it is possible to use a single instance to analyze multiple methods in parallel. However, if you want to be able to selectively abort the abstract interpretation of some methods or want to selectively trace the interpretation of some methods, then you should use multiple abstract interpreter instances. Creating new instances is usually extremely cheap as this class does not have any significant associated state.

   Subclasses are not required to be thread-safe and may have more complex state.

   Note

   OPAL does not make assumptions about the number of domains that are used. However, if a single domain object is used by multiple instances of this class and the abstract interpretations are executed concurrently, then the domain has to be thread-safe. The latter is trivially the case when the domain object itself does not have any state; however, most domain objects have some state.

   ,

   Useless Joins Avoidance

   OPAL tries to minimize unnecessary joins by using the results of a naive live variables analysis (limited to the registers only!). This analysis helps to prevent unnecessary joins and also helps to reduce the overall number of processing steps. E.g., in the following case the swallowed exceptions that may occur whenever transformIt is called, would lead to an unnecessary join though the exception is not required!

   if (enc != null) {
     try {
       return transformIt(transformIt(enc));
     } catch (RuntimeException re) {}
   }
   return "";

   This analysis leads to an overall reduction in the number of evaluated instruction of about 4,5%. Additionally, it also reduces the effort spent on "expensive" joins which leads to an overall(!) improvement for the l1.DefaultDomain of ~8,5%. TODO ==Dead Variables Elimination based on Definitive Paths== (STILL IN DESIGN!!!!)

   Idea

   Given an instruction i which may result in a fork of the control-flow (e.g., a conditional branch or an invoke instruction that may throw a catched exception). If the (first) evaluation of i definitively rules out several possible paths and - on all paths that are taken - some values are dead, but live on some of the other paths, then the respectively current values will never be propagated to the remaining paths, even if the remaining paths are eventually taken! This helps in variety of cases such as, e.g.,

   var s : Object = null
   for{/* it can statically be determined that this path is taken at least once!*/} {
       s = "something else"
   }
   doIt(s); // here, "s" is guaranteed not to reference the orignal value "null"!

   Implementation

   When we have a fork, check if all paths...

   Customizing the Abstract Interpretation Framework

   Customization of the abstract interpreter is done by creating new subclasses that override the relevant methods (in particular: AI#isInterrupted and AI#tracer).

2.  sealed abstract class AIAborted extends AIResult

   Encapsulates the intermediate result of an aborted abstract interpretation of a method.

3.  sealed abstract class AICompleted extends AIResult

   Encapsulates the final result of the successful abstract interpretation of a method.

4.  class AIException extends RuntimeException

   A general, non-recoverable exception occurred during the abstract interpretation of a method.

5.  sealed abstract class AIResult extends AnyRef

   Encapsulates the result of the abstract interpretation of a method.

   Encapsulates the result of the abstract interpretation of a method. If the abstract interpretation was cancelled, the result encapsulates the current state of the evaluation which can be used to continue the abstract interpretation later on if necessary/desired.

6.  trait AITracer extends AnyRef

   Defines the interface between the abstract interpreter and a module for tracing and debugging the interpreter's progress.

   Defines the interface between the abstract interpreter and a module for tracing and debugging the interpreter's progress. In general, a tracer is first registered with an abstract interpreter. After that, when a method is analyzed, the AI calls the tracer's methods at the respective points in time.

   A tracer is registered with an abstract interpreter by creating a new subclass of AI and overriding the method AI.tracer.

   Note

   All data structures passed to the tracer are the original data structures used by the abstract interpreter. Hence, if a value is mutated (e.g., for debugging purposes) it has to be guaranteed that the state remains meaningful. Hence, using the AITracer it is possible to develop a debugger for OPAL and to enable the user to perform certain mutations.

7.  final type ALocalsArray[T >: Null <: DomainValue] = Array[Locals[T]]
8.  final type AnOperandsArray[T >: Null <: DomainValue] = Array[Operands[T]]
9.  class BaseAI extends AI[Domain]

   A base abstract interpreter that can be used with any domain that has no special requirements on the abstract interpreter.

   A base abstract interpreter that can be used with any domain that has no special requirements on the abstract interpreter. The base interpreter can be interrupted by calling the interrupt method of the AI's thread.

   See also

   BoundedInterruptableAI for an abstract interpreter that can easily be interrupted and which also interrupts itself if a certain threshold is exceeded.

10.  class BoundedInterruptableAI[D <: Domain] extends InstructionCountBoundedAI[D]

    An abstract interpreter that interrupts itself after the evaluation of the given number of instructions or if the callback function doInterrupt returns false or if the maximum allowed time is exceeded.

11.  sealed abstract class Computation[+V, +E] extends AnyRef

    Encapsulates the result of a computation in a domain.

    Encapsulates the result of a computation in a domain. In general, the result is either some value V or some exception(s) E. In some cases, however, when the domain cannot precisely determine the result, it may be both: some exceptional value(s) and a value.

    In the latter case the abstract interpreter will generally follow all possible paths. A computation that declares to return a result (i.e., the type V is not Nothing) must not return a result and/or throw an exception if the computation did not finish.

    Querying Computations

    Before accessing a computation's result (result or exceptions) it first has to be checked whether the computation returned normally (returnsNormally) or threw an exception (throwsException). Only if returnsNormally returns true the methods result and hasResult are defined.

    V

    The result of the computation. Typically a DomainValue; if the computation is executed for its side effect (e.g., as in case of a monitorenter or monitorexit instruction) the type of V maybe Nothing.

    E

    The exception(s) that maybe thrown by the computation. Typically, a DomainValue which represents a reference value with type java.lang.Throwable or a subtype thereof. If multiple exceptions may be thrown it may also be a set or Iterable of DomainValues (e.g., ExceptionValues).

    Note

    The precise requirements on the result of a computation are determined by the Domain object's methods that perform computations.

12.  final case class ComputationWithSideEffectOrException[+E](exceptions: E) extends Computation[Nothing, E] with Product with Serializable

    Encapsulates the result of a computation that returned normally (but which did not return some value) or that threw an exception/multiple exceptions.

13.  final case class ComputedValue[+V](result: V) extends Computation[V, Nothing] with Product with Serializable

    Encapsulates the result of a computation that returned normally and that did not throw an exception.

14.  final case class ComputedValueOrException[+V, +E](result: V, exceptions: E) extends Computation[V, E] with Product with Serializable

    Encapsulates the result of a computation that either returned normally or threw an exception.

15.  trait Configuration extends AnyRef

    Centralizes all configuration options related to how a domain should handle situations in which the information about a value is (often) not completely available and which could lead to some kind of exception.

    Centralizes all configuration options related to how a domain should handle situations in which the information about a value is (often) not completely available and which could lead to some kind of exception.

    Basically all domains that perform some kind of abstraction should mix in this trait and query the respective method to decide if a respective exception should be thrown if it is possible that an exception may be thrown.

    Usage

    If you need to adapt a setting just override the respective method in your domain.

    In general, the org.opalj.ai.domain.ThrowAllPotentialExceptionsConfiguration should be used as a foundation as it generates all exceptions that may be thrown; however, configuring the behavior of method calls may be worth while.

16.  trait CoreDomainFunctionality extends ValuesDomain with SubroutinesDomain

    Defines the core functionality that is shared across all Domains that implement the operations related to different kinds of values and instructions.

    Defines the core functionality that is shared across all Domains that implement the operations related to different kinds of values and instructions. It primarily defines the abstraction for DomainValues.

    Note

    This trait defines concrete methods that facilitate unit testing of partial domains that build on top of this CoreDomain such as the IntegerValuesDomain.

    See also

    Domain For an explanation of the underlying concepts and ideas.

17.  trait CorrelationalDomain extends Domain with CorrelationalDomainSupport

    A Domain that supports the tracking of correlations between values.

18.  trait CorrelationalDomainSupport extends JoinStabilization with IdentityBasedCorrelationChangeDetection

    Provides basic support for tracking the correlation between domain values stored in different registers/in different stack slots.

19.  class CountingAI[D <: Domain] extends InterruptableAI[D]

    An abstract interpreter that counts the number of instruction evaluations that are performed.

    An abstract interpreter that counts the number of instruction evaluations that are performed. This is particularly helpful to determine the effect of optimizations or the choice of the domain.

    Thread Safety

    This class is thread-safe. I.e., one instance can be used to run multiple abstract interpretations in parallel.

20.  trait CustomInitialization extends AnyRef

    Mixin this trait if a domain needs to perform some custom initialization.

    Mixin this trait if a domain needs to perform some custom initialization.

    Usage

    It is sufficient to mixin this trait in a Domain that needs custom initialization. The abstract interpreter will then perform the initialization.

    This information is set immediately before the abstract interpretation is started/continued. I.e., this makes it potentially possible to reuse a Domain object for the interpretation of multiple methods.

21.  trait Domain extends CoreDomainFunctionality with IntegerValuesDomain with LongValuesDomain with FloatValuesDomain with DoubleValuesDomain with ReferenceValuesDomain with FieldAccessesDomain with MethodCallsDomain with MonitorInstructionsDomain with ReturnInstructionsDomain with DynamicLoadsDomain with PrimitiveValuesConversionsDomain with TypedValuesFactory with Configuration

    A domain is the fundamental abstraction mechanism in OPAL that enables the customization of the abstract interpretation framework towards the needs of a specific analysis.

    A domain is the fundamental abstraction mechanism in OPAL that enables the customization of the abstract interpretation framework towards the needs of a specific analysis.

    A domain encodes the semantics of computations (e.g., the addition of two values) with respect to the domain's values (e.g., the representation of integer values). Customizing a domain is the fundamental mechanism of adapting the AI framework to one's needs.

    This trait defines the interface between the abstract interpretation framework and some (user defined) domain. I.e., this interface defines all methods that are needed by OPAL to perform an abstract interpretation.

    Control Flow

    OPAL controls the process of evaluating the code of a method, but requires a domain to perform the actual computations of an instruction's result. E.g., to calculate the result of adding two integer values, or to perform the comparison of two object instances, or to get the result of converting a long value to an int value, the framework always consults the domain.

    Handling of instructions that manipulate the stack (e.g. dup), that move values between the stack and the locals (e.g., Xload_Y) or that determine the control flow is, however, completely embedded into OPAL-AI.

    OPAL uses the following methods to inform a domain about the progress of the abstract interpretation:

    • org.opalj.ai.CoreDomainFunctionality.afterEvaluation
    • org.opalj.ai.CoreDomainFunctionality.flow
    • org.opalj.ai.CoreDomainFunctionality.evaluationCompleted
    • org.opalj.ai.CoreDomainFunctionality.abstractInterpretationEnded A domain that implements (overrides) one of these methods should always also delegate the call to its superclass to make sure that every domain interested in these events is informed.

    Implementing Abstract Domains

    While it is perfectly possible to implement a new domain by inheriting from this trait, it is recommended to first study the already implemented domains and to use them as a foundation. To facilitate the usage of OPAL several classes/traits that implement parts of this Domain trait are pre-defined and can be flexibly combined (mixed together) when needed.

    When you extend this trait or implement parts of it you should keep as many methods/ fields private to facilitate mix-in composition of multiple traits.

    Thread Safety

    When every analyzed method is associated with a unique Domain instance and – given that OPAL only uses one thread to analyze a given method at a time – no special care has to be taken. However, if a domain needs to consult another domain which is, e.g, associated with a project as a whole (e.g., to create a central store of values), it is then the responsibility of the domain to make sure that coordination with the world is thread safe.

    Note

    OPAL assumes that – at least conceptually – every method/code block is associated with its own instance of a domain object.

22.  case class DomainException(message: String) extends AIException with Product with Serializable

    An exception related to a computation in a specific domain occurred.

    An exception related to a computation in a specific domain occurred. This exception is intended to be used if the exception occurred inside the Domain.

23.  trait DoubleValuesDomain extends DoubleValuesFactory

    Defines the public interface between the abstract interpreter and the domain that implements the functionality related to the handling of double values.

24.  trait DoubleValuesFactory extends ValuesDomain

    Defines the primary factory methods for Double values.

25.  trait DynamicLoadsDomain extends AnyRef

    Interface related to the handling of dynamic ldc/ldc_w/ldc2_w instructions.

26.  trait ExceptionsFactory extends ValuesDomain

    Defines factory methods for those exceptions that are (also) created by the JVM when the evaluation of a specific bytecode instruction fails (e.g., idiv, checkcast, monitorexit, return...).

27.  final type ExceptionsRaisedByCalledMethod = ai.ExceptionsRaisedByCalledMethods.Value
28.  trait FieldAccessesDomain extends AnyRef

    Interface related to the handling of field access instructions.

29.  trait FloatValuesDomain extends FloatValuesFactory

    Defines the public interface between the abstract interpreter and the domain that implements the functionality related to the handling of float values.

30.  trait FloatValuesFactory extends ValuesDomain

    Defines factory methods to create concrete representations of constant float values.

31.  trait GlobalLogContextProvider extends LogContextProvider
32.  trait IdentityBasedCorrelationChangeDetection extends CoreDomainFunctionality

    Identifies situations (based on a reference comparison of the domain values) in which the memory layout changes such that a correlation between two values, which existed before a join was performed, no longer exists.

    Identifies situations (based on a reference comparison of the domain values) in which the memory layout changes such that a correlation between two values, which existed before a join was performed, no longer exists. In this case the UpdateType is lifted from MetaInformationUpdate to StructuralUpdateType. For example, imagine that the old stack layout (before the join was executed) is as follows:

    AnIntegerValue[#1] <- AnIntegerValue[#1] <- IntegerRange(lb=0,ub=10)[#2] <- ...

    and that the stack after the join is:

    AnIntegerValue[#2] <- AnIntegerValue[#3] <- IntegerRange(lb=0,ub=10)[#2] <- ...

    Hence, the two top-most stack values are now different values and – if the result of an analysis/domain is influenced by correlation information – the continuation of the abstract interpretation is enforced.

    Concrete Example

    static void cfDependentValues(int i) {
     Object b = null;
     Object c = null;
     int j = i; // <--- j is just an alias for i
     while (j < 2) {
         Object a = maybeNull(); // returns "null" or a new instance of Object
         if (i == 1)
             b = a; // <--- b is just an alias for a
         else
             c = a; // <--- c is just an alias for a
         i++;
         j = i;
     }
     // b and c are never referring to the same object; hence a constraint related to
     // c does not affect b and vice versa
     if (c == null) { // this just constraints "c" (not "b")
         doIt(b); // we know nothing special about b
         doIt(c); // c is null
     } else if (b != null) {
         doIt(b); // b is non-null
         doIt(c); // we know nothing special  about c
     }
    }

    This trait requires that updates to a value that do not influence the represented value as such, but which may influence its correlation information, have to create a MetaInformationUpdate. Here, correlation means:

    • two reference values that refer to the same object are considered aliases
    • two local variables that are guaranteed to be identical in all cases, and, hence are subject to the same constraints are also correlated.

    Note

    Mixing in this trait is strictly necessary when aliases are traced using a DomainValue's reference.

33.  class InstructionCountBoundedAI[D <: Domain] extends AI[D]

    An abstract interpreter that interrupts itself after the evaluation of the given number of instructions.

    An abstract interpreter that interrupts itself after the evaluation of the given number of instructions.

    Thread Safety

    This class is thread-safe. I.e., one instance of the InstructionCountBoundedAI can be used to run multiple abstract interpretations in parallel and to ensure that they terminate (as a whole) if the threshold is exceeded.

34.  trait IntegerRangeValuesFactory extends IntegerValuesFactory

    Defines a factory method to create IntegerRange values.

35.  trait IntegerValuesDomain extends IntegerValuesFactory

    Defines the public interface between the abstract interpreter and the domain that implements the functionality related to the handling of integer values.

36.  trait IntegerValuesFactory extends ValuesDomain

    Defines the primary factory methods to create Integer values.

37.  sealed trait InterpretationFailedException extends AnyRef

    Exception that is thrown by the abstract interpreter when the abstract interpretation of a method's implementation failed.

    Exception that is thrown by the abstract interpreter when the abstract interpretation of a method's implementation failed.

    To create an instance use the companion object InterpretationFailedException$.

38.  class InterruptableAI[D <: Domain] extends AI[D]

    An abstract interpreter that can be interrupted by calling the AI's interrupt method or by calling the executing thread's interrupt method.

39.  trait JoinStabilization extends CoreDomainFunctionality

    Ensures that the same DomainValue is used whenever we merge the same pair of domain values.

    Ensures that the same DomainValue is used whenever we merge the same pair of domain values. This ensures that the relation between the values remains the same.

    For example, given the following two stacks:

    • AnIntegerValue[#1] <- AnIntegerValue[#1] <- IntRange(lb=0,ub=10)[#2] <- ...
    • AnIntegerValue[#3] <- AnIntegerValue[#3] <- IntRange(lb=0,ub=10)[#2] <- ...

    The result will be (assuming that the result of joining AnIntegerValue[#1] with AnIntegerValue[#3] creates a new value, e.g., AnIntegerValue[#4]):

    • AnIntegerValue[#4] <- AnIntegerValue[#4] <- IntRange(lb=0,ub=10)[#2] <- ...

    Without this trait each pair of values is joined again. In this case the result would be:

    • AnIntegerValue[#4] <- AnIntegerValue[#5] <- IntRange(lb=0,ub=10)[#2] <- ...

    Using join stabilization is necessary if constraints are propagated or (makes sense) if the merge of domain values is expensive.

    Note

    Join stabilization is always done for all domain values once this trait is mixed in.

40.  final type Locals[T >: Null <: DomainValue] = collection.mutable.Locals[T]
41.  trait LogContextProvider extends AnyRef

    Provides log context information.

42.  trait LongValuesDomain extends LongValuesFactory

    Defines the public interface between the abstract interpreter and the domain that implements the functionality related to the handling of long values.

43.  trait LongValuesFactory extends ValuesDomain

    Defines the primary factory methods to create long values.

44.  final case class MetaInformationUpdate[V](value: V) extends SomeUpdate[V] with Product with Serializable

    Characterizes an update that did not affect the abstract state but instead just updated some meta information.

    Characterizes an update that did not affect the abstract state but instead just updated some meta information.

    In general, the abstract interpretation framework handles NoUpdates and MetaInformationUpdates in the same way.

    Example

    If two values are merged that are seen on two different paths, but which represent the same abstract value, we may want to update the meta-information about the origin of the current value, but this information may not be part of the abstract state and hence, is not relevant for the abstract interpreter. In this case the interpreter will not reschedule subsequent instructions. However, whether or not the information about the origin of a value is considered to be part of the abstract state is a decision of the domain.

45.  sealed trait MetaInformationUpdateType extends UpdateType
46.  trait MethodCallsDomain extends AnyRef

    Defines all methods related to the invocation of other methods.

47.  trait MonitorInstructionsDomain extends AnyRef

    Domain that defines all methods related to monitor instructions.

48.  class MultiTracer extends AITracer

    A tracer that forwards every call to all registered tracers.

49.  final type Operands[T >: Null <: DomainValue] = List[T]
50.  final type PCs = IntTrieSet
51.  trait PrimitiveValuesConversionsDomain extends AnyRef

    Defines the methods that performs type conversions between primitive values with different computational types.

52.  type PrimitiveValuesFactory = IntegerValuesFactory with LongValuesFactory with FloatValuesFactory with DoubleValuesFactory
53.  trait ReferenceValuesDomain extends ReferenceValuesFactory

    Domain that defines all methods that perform computations related to RefernceValues.

54.  trait ReferenceValuesFactory extends ExceptionsFactory

    Definition of factory methods to create ReferenceValues.

55.  trait ReturnInstructionsDomain extends AnyRef

    Defines the methods that lead to a return from a method.

    Defines the methods that lead to a return from a method. In general, a return instruction can throw an IllegalMonitorStateException. If, e.g., the method is synchronized and the method body contains a Monitorexit instruction, but no Monitorenter instruction.

56.  type SomeAI[D <: Domain] = AI[_ >: D]

    Type alias that can be used if the AI can use all kinds of domains.

    Type alias that can be used if the AI can use all kinds of domains.

    Note

    This type alias serves comprehension purposes only.

57.  sealed abstract class SomeUpdate[V] extends Update[V]

    Identifies updates where something was updated without further qualifying the update.

    Identifies updates where something was updated without further qualifying the update.

    Usage

    This class (and its companion object) are primarily used for pattern matching purposes.

58.  final case class StructuralUpdate[V](value: V) extends SomeUpdate[V] with Product with Serializable

    Characterizes updates where the abstract state was updated such that it is required to continue the abstract interpretation.

59.  trait SubroutinesDomain extends AnyRef

    Enables specialized processing of subroutine calls by domains; this is generally only relevant for those domains that record the control-flow graph.

60.  type TargetDomain = ValuesDomain with ValuesFactory
61.  trait TheAI[D <: Domain] extends AnyRef

    Makes the instance of the abstract interpreter that performs the abstract interpretation available to the domain.

    Makes the instance of the abstract interpreter that performs the abstract interpretation available to the domain.

    Usage

    It is sufficient to mixin this trait in a Domain that needs to access the abstract interpreter. The abstract interpreter will then perform the initialization.

    The concrete instance of AI that performs the abstract interpretation is set immediately before the abstract interpretation is started/continued.

62.  trait TheCodeStructure extends AnyRef

    Mixin this trait if the domain needs information about the structure of the code.

    Mixin this trait if the domain needs information about the structure of the code.

    Usage

    It is sufficient to mixin this trait in a Domain that needs to get access to the code array. The abstract interpreter will then perform the initialization.

    This information is set immediately before the abstract interpretation is started/continued.

63.  final type TheLocalsArray[T >: Null <: ai.TheLocalsArray.T.d.type.Locals forSome {val d: ValuesDomain}] = Array[T]
64.  trait TheMemoryLayout extends AnyRef

    Mixin this trait if a domain needs access to the operands (Domain#OperandsArray) and/or locals (Domain#LocalsArray).

    Mixin this trait if a domain needs access to the operands (Domain#OperandsArray) and/or locals (Domain#LocalsArray).

    Usage

    It is sufficient to mixin this trait in a Domain that needs to get access to the memory structures. The abstract interpreter will then perform the initialization.

    This information is set immediately before the abstract interpretation is started/continued.

65.  final type TheOperandsArray[T >: Null <: ai.TheOperandsArray.T.d.type.Operands forSome {val d: ValuesDomain}] = Array[T]
66.  final case class ThrowsException[+E](exceptions: E) extends Computation[Nothing, E] with Product with Serializable

    Encapsulates the result of a computation that threw an exception.

67.  class TimeBoundedAI[D <: Domain] extends AI[D]

    An abstract interpreter that interrupts itself after some configurable (maxEffort) time has passed.

68.  trait TypedValuesFactory extends AnyRef

    Defines additional, generally useful factory methods to create DomainValues.

69.  sealed abstract class Update[+V] extends AnyRef

    Encapsulates an updated value and qualifies the type of the update.

    Encapsulates an updated value and qualifies the type of the update.

    In general OPAL distinguishes between updates to a value that are relevant w.r.t. the abstract interpretation and those updates that just update some meta-information and which do not affect the abstract interpretation and – in particular – do not force the framework to continue the abstract interpretation.

70.  sealed abstract class UpdateType extends AnyRef

    Specifies the type of an update.

    Specifies the type of an update. The type hierarchies of Update and UpdateType are aligned and it is possible to conveniently switch between them. Contrary to an Update object an UpdateType object never has any payload, it just characterizes an update. However, by passing a value to an UpdateType the UpdateType is turned into a corresponding org.opalj.ai.Update object.

    Example

    val updateType : UpdateType = ...
    val update : Update = updateType(<someValue>)

71.  type ValueOrigin = Int
72.  final type ValueOrigins = IntTrieSet

    A ValueOrigin identifies the origin of a value within a method.

    A ValueOrigin identifies the origin of a value within a method. In most cases the origin is equal to the program counter of the instruction that created the value. However, several negative values do have special semantics which are explained in the following.

    Parameter Identification

    In general, parameters are identified by using negative origin information as described below. Given that

    • the maximum size of the method parameters array is 255 and
    • that the first slot is required for the this reference in case of instance methods and
    • that long and double values require two slots the smallest number used to encode that the value is an actual parameter is -256.

    AI Framework

    In case of the ai framework, values passed to a method get indexes as follows: -1-(isStatic ? 0 : 1)-(the index of the parameter adjusted by the computational type of the previous parameters).

    For example, in case of an instance method with the signature:

    public void (double d/*parameter index:0*/, Object o/*parameter index:1*/){...}

    • The value -1 is used to identify the implicit this reference.
    • The value -2 identifies the value of the parameter d.
    • The value -4 identifies the parameter o. (The parameter d is a value of computational-type category 2 and needs two stack/operands values.)

    Three-address Code

    In case of the three address code the parameter origins are normalized (see org.opalj.tac.TACAI for further details).

    Subroutines JSR/RET

    Some special values are used when methods have subroutines: (SUBROUTINE_START, SUBROUTINE_END, SUBROUTINE). These methods, never show up at the def-use or cfg level, but will show up in the evaluation trace.

    Implicit JVM Constants

    The value -333 is used to encode that the value is an implicit constant (ConstantValueOrigin). This value is used for the implicit value of IF_XXX instructions to facilitates a generalized handling of ifs.

    Values in the range [ SpecialValuesOriginOffset (-800,000,000) , MethodExternalExceptionsOriginOffset (-1,000,000) ] are used to identify exceptions that are created outside of the method; i.e., by an instruction which does not belong to the method. Exceptions in the range (MethodExternalExceptionsOriginOffset (-1,000,000), ImmediateVMExceptionsOriginOffset (-100,000)] are used to identify values that are created by the VM due to an exception while evaluating an instruction.

    See also

    isImmediateVMException, ValueOriginForImmediateVMException, pcOfImmediateVMException, isMethodExternalExceptionOrigin, ValueOriginForMethodExternalException, pcOfMethodExternalException

73.  final type ValueOriginsIterator = IntIterator
74.  trait ValuesDomain extends AnyRef

    Defines the concept of a value in a Domain.

    Defines the concept of a value in a Domain.

    See also

    Domain For an explanation of the underlying concepts and ideas.

75.  type ValuesFactory = PrimitiveValuesFactory with ReferenceValuesFactory with ExceptionsFactory with TypedValuesFactory