The class tag can be used to create type safe arrays or to extract the concrete type of the domain value.

val DomainReferenceValue(v) = value // of type "DomainValue"
// v is now of the type DomainReferenceValue

The class tag for the type DomainValue.

Required to generate instances of arrays in which values of type DomainValue can be stored in a type-safe manner.

Initialization

In the sub-trait or class that fixes the type of DomainValue it is necessary to implement this abstract val using:

val DomainValueTag : ClassTag[DomainValue] = implicitly

(As of Scala 2.10 it is necessary that you do not use implicit in the subclass - it will compile, but fail at runtime.)

Creates a domain value from the given value information that represents a properly domain value. A representation of a proper value is created even if the value information is provided for an uninitialized value.

The result of the merge of two incompatible values has to be reported as a MetaInformationUpdate[DomainIllegalValue].

Factory method to create an instance of a ReturnAddressValue.

The singleton instance of the IllegalValue.

The singleton instance of ReturnAddressValues

This project's class hierarchy.

Usually, just a redirect to the Project's class hierarchy or the default class hierarchy.

The result of merging two values should never be reported as a StructuralUpdate if the computed value is an IllegalValue. The JVM semantics guarantee that the value will not be used and, hence, continuing the interpretation is meaningless.

Returns the PCs of all instructions whose execution may have led to an exception. This can, e.g., be instance field read/field write statements or method invocations, but _in very rare cases_ also return instructions.

Called by the abstract interpreter when an exception is thrown that is not (guaranteed to be) handled within the same method.

Completes the computation of the definition/use information by using the recorded cfg.

This method is called after all values which differ have been joined, but before joinPostProcessing will be called.

This methods is called after the evaluation of the instruction with the given pc with respect to targetPC, but before the values are propagated (joined) and before it is checked whether the interpretation needs to be continued. I.e., if the operands (newOperands) or locals (newLocals) are further refined then the refined operands and locals are joined (if necessary).

Computes the set of all executed instructions.

Returns all PCs that may lead to the (ab)normal termination of the method. I.e., those instructions (in particular method call instructions, but potentially also array access instructions and (I]L)DIV|MOD instructions etc.) that may throw some unhandled exceptions will also be returned; even if the instruction may also have regular and also exception handlers!

Computes the transitive hull of all instructions reachable from the given set of instructions.

Computes the transitive hull of all instructions reachable from the given instruction.

Returns the set of all instructions executed after the instruction with the given pc. If this set is empty, either the instruction belongs to dead code, the instruction is a return instruction or the instruction throws an exception that is never handled internally.

The given value, which is a value with computational type reference, is returned by the return instruction with the given pc.

This method is called immediately before a join operation with regard to the specified pc is performed.

Creates a graph representation of the CFG.

Creates a multi-graph that represents the method's def-use information. I.e., in which way a certain value is used by other instructions and where the derived values are then used by further instructions. (Basically, we compute the data-dependence graph.)

Returns the dominator tree; see org.opalj.graphs.DominatorTree$.apply[D<:org\.opalj\.graphs\.AbstractDominatorTree]* for details regarding the properties of the dominator tree.

The given value, which is a value with computational type double, is returned by the return instruction with the given pc.

Creates an XHTML document that contains information about the def-/use information.

Creates an XHTML table node which contains the def/use information.

Called by the framework after evaluating the instruction with the given pc. I.e., the state of all potential successor instructions was updated and the flow method was called – potentially multiple times – accordingly.

By default this method does nothing.

Returns the program counter(s) of the instruction(s) that is(are) executed next if the evaluation of this instruction may raise an exception.

The returned set is always empty for instructions that cannot raise exceptions, such as the StackManagementInstructions.

Called by the framework after performing a computation to inform the domain about the result. That is, after evaluating the effect of the instruction with currentPC on the current stack and register and (if necessary) joining the updated stack and registers with the stack and registers associated with the instruction successorPC. (Hence, this method is ONLY called for return instructions if the return instruction throws an IllegalMonitorStateException.) This function basically informs the domain about the instruction that may be evaluated next. The flow function is called for every possible successor of the instruction with currentPC. This includes all branch targets as well as those instructions that handle exceptions.

In some cases it will even be the case that flow is called multiple times with the same pair of program counters: (currentPC, successorPC). This may happen, e.g., in case of a switch instruction where multiple values have the same body/target instruction and we do not have precise information about the switch value. E.g., as in the following snippet:

switch (i) {  // pc: X => Y (for "1"), Y (for "2"), Y (for "3")
case 1:
case 2:
case 3: System.out.println("Great.");            // pc: Y
default: System.out.println("Not So Great.");    // pc: Z
}

The flow function is also called after instructions that are domain independent such as dup and load instructions which just manipulate the registers and stack in a generic way. This enables the domain to precisely follow the evaluation progress and in particular to perform control-flow dependent analyses.

The given value, which is a value with computational type float, is returned by the return instruction with the given pc.

Returns true if the exception handler may handle at least one exception thrown by an instruction in its try block.

Returns true if the instruction with the given pc has multiple direct predecessors (more than one).

Tests if the instruction with the given pc has a successor instruction with a pc' that satisfies the given predicate p.

Returns the first instructions of the infinite loops of the current method. An infinite loop is a set of instructions that does not have a connection to any instruction outside of the loop (closed strongly connected component). I.e., whatever path is taken, all remaining paths will eventually include the loop header instruction. The very vast majority of methods does not have infinite loops.

Override this method to perform custom initialization steps.

Always use abstract override and call the super method; it is recommended to complete the initialization of this domain before calling the super method.

The given value, which is a value with computational type integer, is returned by the return instruction with the given pc.

Tests if subtype is known to be subtype of supertype. See org.opalj.br.ClassHierarchy's isSubtypeOf method for details.

Tests if the instruction with the given pc is a direct or indirect predecessor of the given successor instruction.

If pc equals successorPC true is returned.

Tests if subtype is known to be subtype of supertype. See org.opalj.br.ClassHierarchy's isSubtypeOf method for details.

Joins the given operand stacks and local variables.

In general there should be no need to refine this method. Overriding this method should only be done for analysis purposes.

Performance

This method heavily relies on reference comparisons to speed up the overall process of performing an abstract interpretation of a method. Hence, a computation should – whenever possible – return (one of) the original object(s) if that value has the same abstract state as the result. Furthermore, if all original values capture the same abstract state as the result of the computation, the "left" value/the value that was already used in the past should be returned.

Enables the customization of the behavior of the base join method.

This method in particular enables, in case of a MetaInformationUpdate, to raise the update type to force the continuation of the abstract interpretation process.

Methods should always override this method and should call the super method.

The set of instructions to which a jump back is performed.

Returns true if the execution of the given instruction – identified by its pc – always just throws an exception that is (potentially) handled by the method.

Returns the instruction(s) which define(s) the value found in the register variable with index registerIndex and the program counter pc.

The given value, which is a value with computational type long, is returned by the return instruction with the given pc.

Merges the given domain value v1 with the domain value v2 and returns the merged value which is v1 if v1 is an abstraction of v2, v2 if v2 is an abstraction of v1 or some other value if a new value is computed that abstracts over both values.

This operation is commutative.

Returns the PCs of all return instructions which may have returned normally; which are practically always all return instructions unless the analysis _really_ finds an unbalanced return; which is very unlikely.

Returns the instruction(s) which defined the value used by the instruction with the given pc and which is stored at the stack position with the given stackIndex. The first/top value on the stack has index 0 and the second value - if it exists - has index two; independent of the computational category of the values.

Returns the origins of a domain value. This method is intended to be overridden by domains that provide more precise def/use information than the default def/use analysis.

E.g., the l1.ReferenceValues domain tracks alias relations and can (when we inline calls) correctly identify those returned values that were passed to it.

Computes the control dependencies graph based on the post dominator tree.

Internally, a post dominator tree is used for methods without infinite loops; i.e., we compute non-termination insensitive control dependencies. Note that – dues to exceptions which may lead to abnormal returns

Returns the org.opalj.graphs.PostDominatorTree (PDT).

Returns the program counter(s) of the instruction(s) that is(are) executed before the instruction with the given pc.

If the instruction with the given pc was never executed an empty set is returned.

Prints out the information by which values the current values are used.

Returns a string representation of the properties associated with the instruction with the respective program counter.

Associating properties with an instruction and maintaining those properties is, however, at the sole responsibility of the Domain.

This method is predefined to facilitate the development of support tools and is not used by the abstract interpretation framework.

Domains that define (additional) properties should (abstract) override this method and should return a textual representation of the property.

Returns the program counter(s) of the instruction(s) that is(are) executed next if the evaluation of this instruction may succeed without raising an exception.

The returned set is always empty for return instructions. It is also empty for instructions that always throw an exception (e.g., an integer value that is divided by zero will always result in a NullPointException.)

Called when a return instruction with the given pc is reached. In other words, when the method returns normally.

Returns the instructions which use the (external) exception raised by the instruction with the given ValueOrigin.

Returns the instructions which use the value or the external exception identified by the given value origin. Basically, the same as usedBy except that an empty set of value origins is returned if the instruction with the given value origin is dead.

This function can be called when the instruction successorPC needs to be scheduled. The function will test if the instruction is already scheduled and – if so – returns the given worklist. Otherwise the instruction is scheduled in the correct (subroutine-)context.

Returns the PCs of the first instructions of all subroutines; that is, the instructions a JSR instruction jumps to.

Creates a summary of the given domain values by summarizing and joining the given values. For the precise details regarding the calculation of a summary see Value.summarize(...).

Returns true if the execution of the given instruction – identified by its pc – ex-/implicitly throws an exception that is (potentially) handled by the method.

Returns the union of the set of unused parameters and the set of all instructions which compute a value that is not used in the following.

Replaces all occurrences of oldValue (using reference-quality) with newValue. If no occurrences are found, the original operands and locals data structures are returned.

Returns the instructions which use the value or the external exception identified by the given value origin. In case of external exceptions thrown by an instruction, the pc of the value origin pc is ai.underlyingPC(valueOrigin)

Returns true if the instruction with the given pc was executed.