Tests if the straight-line sequence of instructions that starts with the given pc always ends with an ATHROW instruction or a method call that always throws an exception. The call sequence furthermore has to contain no complex logic. Here, complex means that evaluating the instruction may result in multiple control flows. If the sequence contains complex logic, false will be returned.

One use case of this method is, e.g., to check if the code of the default case of a switch instruction always throws some error (e.g., an UnknownError or AssertionError).

switch(...) {
 case X : ....
 default :
     throw new AssertionError();
}

This is a typical idiom used in Java programs and which may be relevant for certain analyses to detect.

Calculates for each instruction the subroutine to which it belongs to – if any. This information is required to, e.g., identify the subroutine contexts that need to be reset in case of an exception in a subroutine.

Returns the set of all program counters where two or more control flow paths may join.

Example

 0: iload_1
 1: ifgt    6
 2: iconst_1
 5: goto 10
 6: ...
 9: iload_1
10: return // <= PATH JOIN: the predecessors are the instructions 5 and 9.

In case of exception handlers the sound overapproximation is made that all exception handlers with a fitting type may be reached on multiple paths.

Returns the set of all program counters where two or more control flow paths join or fork.

Example

 0: iload_1
 1: ifgt    6 // <= PATH FORK
 2: iconst_1
 5: goto 10
 6: ...
 9: iload_1
10: return // <= PATH JOIN: the predecessors are the instructions 5 and 9.

In case of exception handlers the sound overapproximation is made that all exception handlers may be reached on multiple paths.

Collects all instructions for which the given function is defined.

Usage scenario

Use this function if you want to search for and collect specific instructions and when you do not immediately require the program counter/index of the instruction in the instruction array to make the decision whether you want to collect the instruction.

Examples

Example usage to collect the declaring class of all get field accesses where the field name is "last".

collect({
 case GETFIELD(declaringClass, "last", _) => declaringClass
})

Example usage to collect all instances of a "DUP" instruction.

code.collect({ case dup @ DUP => dup })

Collects all instructions for which the given function is defined. The order in which the instructions are collected is reversed when compared to the order in the instructions array.

Finds a pair of consecutive instructions that are matched by the given partial function.

Example Usage

(pc, _) <- body.findPair {
     case (
         INVOKESPECIAL(receiver1, _, SingleArgumentMethodDescriptor((paramType: BaseType, _))),
         INVOKEVIRTUAL(receiver2, name, NoArgumentMethodDescriptor(returnType: BaseType))
     ) if (...) => (...)
     } yield ...

Collects the results of the evaluation of the partial function until the partial function is not defined.

Applies the given function f to all instruction objects for which the function is defined. The function is passed a tuple consisting of the current program counter/index in the code array and the corresponding instruction.

Example

Example usage to collect the program counters (indexes) of all instructions that are the target of a conditional branch instruction:

code.collectWithIndex({
 case (pc, cbi: ConditionalBranchInstruction) =>
     Seq(cbi.indexOfNextInstruction(pc, code), pc + cbi.branchoffset)
 }) // .flatten should equal (Seq(...))

Compares this element's attributes with the given one.

Returns a view of all potential exception handlers (if any) for the instruction with the given program counter (pc). Finally handlers (catchType == None) are not returned but will stop the evaluation (as all further exception handlers have no further meaning w.r.t. the runtime)! In case of identical caught exceptions only the first of them will be returned. No further checks (w.r.t. the typehierarchy) are done.

Finds a sequence of instructions that are matched by the given partial function.

Returns the smallest line number (if any).

Iterates over all instructions and calls the given function f for every instruction.

Iterates over all instructions and calls the given function f for every instruction.

The list of pcs of those instructions that may handle an exception if the evaluation of the instruction with the given pc throws an exception.

In case of multiple finally handlers only the first one will be returned and no further exception handlers will be returned. In case of identical caught exceptions only the first of them will be returned. No further checks (w.r.t. the type hierarchy) are done.

If different exceptions are handled by the same handler, the corresponding pc is returned multiple times.

Returns a view of all handlers (exception and finally handlers) for the instruction with the given program counter (pc) that may catch an exception; as soon as a finally handler is found no further handlers will be returned!

In case of multiple exception handlers that are identical (in particular in case of the finally handlers) only the first one is returned as that one is the one that will be used by the JVM at runtime. No further checks (w.r.t. the type hierarchy) are done.

Returns the handlers that may handle the given exception.

The (known/given) type hierarchy is taken into account as well as the order between the exception handlers.

Returns Some(true) if both pcs have the same line number. If line number information is not available None is returned.

Counts the number of instructions.

True if the instruction with the given program counter is modified by wide.

Iterates over all instructions with the given opcode and calls the given function f for every instruction.

Iterates over all instructions and calls the given function f for every instruction.

This attribute's kind id.

Returns the line number associated with the instruction with the given pc if it is available.

Returns the line number table - if any.

Performs a live variable analysis restricted to a method's locals.

Collects (the merged if necessary) local variable table.

Collects all local variable type tables.

Returns the set of local variables defined at the given pc base on debug information.

Matches pairs of two consecutive instructions. For each matched pair, the program counter of the first instruction is returned.

Example Usage

for {
 classFile <- project.view.map(_._1).par
 method @ MethodWithBody(body) <- classFile.methods
 pc <- body.matchPair({
     case (
         INVOKESPECIAL(receiver1, _, TheArgument(parameterType: BaseType)),
         INVOKEVIRTUAL(receiver2, name, NoArgumentMethodDescriptor(returnType: BaseType))
     ) => { (receiver1 eq receiver2) && (returnType ne parameterType) }
     case _ => false
     })
 } yield (classFile, method, pc)

Finds a sequence of 3 consecutive instructions for which the given function returns true, and returns the PC of the first instruction in each found sequence.

Returns the next instruction that will be executed at runtime that is not a org.opalj.br.instructions.GotoInstruction. If the given instruction is not a org.opalj.br.instructions.GotoInstruction, the given instruction is returned.

Returns the program counter of the next instruction after the instruction with the given counter (currentPC).

Returns the program counter of the previous instruction in the code array. currentPC must be the program counter of an instruction.

This function is only defined if currentPC is larger than 0; i.e., if there is a previous instruction! If currentPC is larger than instructions.size the behavior is undefined.

Computes for each instruction the set of predecessor instructions as well as all instructions without predecessors. Those instructions with multiple predecessors are also returned.

Returns an iterator to iterate over the program counters (pcs) of the instructions of this Code block.

Returns true if this attribute and the given one are guaranteed to be indistinguishable at runtime.

Slides over the code array and tries to apply the given function to each sequence of instructions consisting of windowSize elements.

Scenario

If you want to search for specific patterns of bytecode instructions. Some "bug patterns" are directly related to specific bytecode sequences and these patterns can easily be identified using this method.

Example

Search for sequences of the bytecode instructions PUTFIELD and ALOAD_O in the method's body and return the list of program counters of the start of the identified sequences.

code.slidingCollect(2)({
     case (pc, Seq(PUTFIELD(_, _, _), ALOAD_0)) => (pc)
}) should be(Seq(...))

Computes the stack depth for the instruction with the given pc (atPC). I.e, computes the stack depth before executing the instruction! This function is intended to be used if and only if the stack depth is only required for a single instruction; it recomputes the stack depth for all instructions whenever the function is called.

The JVM specification mandates that a Code attribute has at most one StackMapTable attribute.

Computes the set of PCs for which a stack map frame is required. Calling this method (i.e., the generation of stack map tables in general) is only defined for Java > 5 code; i.e., cocde which does not use JSR/RET; therefore the behavior for Java 5 or earlier code is deliberately undefined.

A complete representation of this code attribute (including instructions, attributes, etc.).