Returns the location – Stack, Register or NoExpression – where the value computed by this instruction is stored. In this case an instruction is only considered to be an expression if it puts a value on the stack or in a register that is the result of some kind of computation; i.e., just copying, duplicating or moving a value between the stack and the registers is not considered to be an expression.

The index of the next instruction in the (sparse) code array.

The index of the next instruction in the code array.

The index of the local (variable)/register that is read is returned. This method is only defined if readsLocal returns true.

The index of the local (variable)/register that is written. This method is only defined if writesLocal returns true.

Determines if this instruction is isomorphic to the given instruction.

Two instructions are isomporphic if they access the same operand and register values and if the instructions have the same bytecode representation, except of (A) (potential) padding bytes and (B) the branch offset of JSR(_W) instructions. In the first case the branch offsets are corrected by the number of padding bytes and in the second case the absolute addresses are compared (i.e., whether both instructions call the same subroutine).

For example, an aload_0 instruction is only isomorphic to another aload_0 instruction and is not isomorphic to an aload(0) instruction – though the runtime effect is the same. However, a LOOKUPSWITCH (TABLESWITCH) instruction is considered isomorphic to another respective instruction if the only difference is the number of padding bytes. Furthermore, two JSR(_W) instructions are isomorphic if and only if they jump to the same subroutine.

Iterator over all (absolute) pcs to which this instruction will jump to.

The exceptions that may be thrown by the JVM at runtime if the execution of this instruction fails. I.e., these are neither exceptions that are explicitly created and then thrown by user code nor errors that may arise due to an invalid code base (in particular LinkageErrors). However, OutOfMemoryErrors are possible.

The number of bytes (in the Code array) used by the instruction.

Returns true if the evaluation of the instruction may lead to some runtime exception. For example, in case of INVOKESTATIC jvmExceptions will return an empty list. However, in general the called method may throw an arbitrary exception.

Errors (such as LinkageError) related to invalid projects are not considered.

The mnemonic of the instruction as defined by the JVM specification.

Returns the IF instruction that - when compared with this if instruction - performs a jump in case of a fall-through and vice-versa. I.e., given the following condition: (a < b), the negation is performend: !(a < b) which is equivalent to (a ≥ b). In other words, if this IF instruction is an IFGT instruction and IFLE instruction is returned.

Returns the pcs of the instructions that may be executed next at runtime. This method takes potentially thrown exceptions into account. I.e., every instruction that may throw an exception checks if it is handled locally and – if so – checks if an appropriate handler exists and – if so – also returns the first instruction of the handler. The chain may contain duplicates, iff the state is potentially different when the target instruction is reached.

A simple conditional branch instruction has two targets unless both targets point to the same instruction. In that case the jump has only one target, because the state - independent of the taken path - always has to be the same.

The number of values that are popped from the operand stack. Here, long and double values are also counted as one value though they use two stack slots. E.g., IADD (integer add) and LADD (long add) both pop two values and push one value.

The number of values that are put onto the operand stack. Here, long and double values are also counted as one value though they use two stack slots. E.g., IADD (integer add) and LADD (long add) both pop two values and push one value.

The opcode of the instruction as defined by the JVM specification. The opcode is a value in the range [0..255].

The number of operand values popped from the operand stack.

The comparison operator (incl. the constant) underlying the if instruction. E.g., <, < 0 or != null.

Returns true if this instruction reads/uses a local variable.

Checks for structural equality of two instructions.

The number of stack slots pushed or popped by this instruction.

Converts this instruction to a LabeledInstruction, where relative jump targets are replaced by symbols using the program counters of the target instructions as Symbols (i.e., absolute targets).

Returns a string representation of this instruction. If this instruction is a (conditional) jump instruction, then the PCs of the target instructions are given absolute address.

Returns true if this instruction writes/updates a local variable.