## Uses of Class
org.apache.bcel.generic.Instruction

Packages that use Instruction
org.apache.bcel.generic: This package contains the "generic" part of the Byte Code Engineering Library, i.e., classes to dynamically modify class objects and byte code instructions.

Uses of Instruction in org.apache.bcel.generic

Subclasses of Instruction in org.apache.bcel.generic
`class` `AALOAD` AALOAD - Load reference from array Stack: ..., arrayref, index -> value
`class` `AASTORE` AASTORE - Store into reference array Stack: ..., arrayref, index, value -> ...
`class` `ACONST_NULL` ACONST_NULL - Push null reference Stack: ...
`class` `ALOAD` ALOAD - Load reference from local variable Stack: ...
`class` `ANEWARRAY` ANEWARRAY - Create new array of references Stack: ..., count -> ..., arrayref
`class` `ARETURN` ARETURN - Return reference from method Stack: ..., objectref -> <empty>
`class` `ArithmeticInstruction` Super class for the family of arithmetic instructions.
`class` `ArrayInstruction` Super class for instructions dealing with array access such as IALOAD.
`class` `ARRAYLENGTH` ARRAYLENGTH - Get length of array Stack: ..., arrayref -> ..., length
`class` `ASTORE` ASTORE - Store reference into local variable Stack ..., objectref -> ...
`class` `ATHROW` ATHROW - Throw exception Stack: ..., objectref -> objectref
`class` `BALOAD` BALOAD - Load byte or boolean from array Stack: ..., arrayref, index -> ..., value
`class` `BASTORE` BASTORE - Store into byte or boolean array Stack: ..., arrayref, index, value -> ...
`class` `BIPUSH` BIPUSH - Push byte on stack Stack: ...
`class` `BranchInstruction` Abstract super class for branching instructions like GOTO, IFEQ, etc..
`class` `BREAKPOINT` BREAKPOINT, JVM dependent, ignored by default
`class` `CALOAD` CALOAD - Load char from array Stack: ..., arrayref, index -> ..., value
`class` `CASTORE` CASTORE - Store into char array Stack: ..., arrayref, index, value -> ...
`class` `CHECKCAST` CHECKCAST - Check whether object is of given type Stack: ..., objectref -> ..., objectref
`class` `ConversionInstruction` Super class for the x2y family of instructions.
`class` `CPInstruction` Abstract super class for instructions that use an index into the constant pool such as LDC, INVOKEVIRTUAL, etc.
`class` `D2F` D2F - Convert double to float Stack: ..., value.word1, value.word2 -> ..., result
`class` `D2I` D2I - Convert double to int Stack: ..., value.word1, value.word2 -> ..., result
`class` `D2L` D2L - Convert double to long Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
`class` `DADD` DADD - Add doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result1.word2
`class` `DALOAD` DALOAD - Load double from array Stack: ..., arrayref, index -> ..., result.word1, result.word2
`class` `DASTORE` DASTORE - Store into double array Stack: ..., arrayref, index, value.word1, value.word2 -> ...
`class` `DCMPG` DCMPG - Compare doubles: value1 > value2 Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result
`class` `DCMPL` DCMPL - Compare doubles: value1 < value2 Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result
`class` `DCONST` DCONST - Push 0.0 or 1.0, other values cause an exception Stack: ...
`class` `DDIV` DDIV - Divide doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `DLOAD` DLOAD - Load double from local variable Stack ...
`class` `DMUL` DMUL - Multiply doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `DNEG` DNEG - Negate double Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
`class` `DREM` DREM - Remainder of doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `DRETURN` DRETURN - Return double from method Stack: ..., value.word1, value.word2 -> <empty>
`class` `DSTORE` DSTORE - Store double into local variable Stack: ..., value.word1, value.word2 -> ...
`class` `DSUB` DSUB - Substract doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `DUP` DUP - Duplicate top operand stack word Stack: ..., word -> ..., word, word
`class` `DUP_X1` DUP_X1 - Duplicate top operand stack word and put two down Stack: ..., word2, word1 -> ..., word1, word2, word1
`class` `DUP_X2` DUP_X2 - Duplicate top operand stack word and put three down Stack: ..., word3, word2, word1 -> ..., word1, word3, word2, word1
`class` `DUP2` DUP2 - Duplicate two top operand stack words Stack: ..., word2, word1 -> ..., word2, word1, word2, word1
`class` `DUP2_X1` DUP2_X1 - Duplicate two top operand stack words and put three down Stack: ..., word3, word2, word1 -> ..., word2, word1, word3, word2, word1
`class` `DUP2_X2` DUP2_X2 - Duplicate two top operand stack words and put four down Stack: ..., word4, word3, word2, word1 -> ..., word2, word1, word4, word3, word2, word1
`class` `F2D` F2D - Convert float to double Stack: ..., value -> ..., result.word1, result.word2
`class` `F2I` F2I - Convert float to int Stack: ..., value -> ..., result
`class` `F2L` F2L - Convert float to long Stack: ..., value -> ..., result.word1, result.word2
`class` `FADD` FADD - Add floats Stack: ..., value1, value2 -> result
`class` `FALOAD` FALOAD - Load float from array Stack: ..., arrayref, index -> ..., value
`class` `FASTORE` FASTORE - Store into float array Stack: ..., arrayref, index, value -> ...
`class` `FCMPG` FCMPG - Compare floats: value1 > value2 Stack: ..., value1, value2 -> ..., result
`class` `FCMPL` FCMPL - Compare floats: value1 < value2 Stack: ..., value1, value2 -> ..., result
`class` `FCONST` FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception Stack: ...
`class` `FDIV` FDIV - Divide floats Stack: ..., value1, value2 -> result
`class` `FieldInstruction` Super class for the GET/PUTxxx family of instructions.
`class` `FieldOrMethod` Super class for InvokeInstruction and FieldInstruction, since they have some methods in common!
`class` `FLOAD` FLOAD - Load float from local variable Stack ...
`class` `FMUL` FMUL - Multiply floats Stack: ..., value1, value2 -> result
`class` `FNEG` FNEG - Negate float Stack: ..., value -> ..., result
`class` `FREM` FREM - Remainder of floats Stack: ..., value1, value2 -> result
`class` `FRETURN` FRETURN - Return float from method Stack: ..., value -> <empty>
`class` `FSTORE` FSTORE - Store float into local variable Stack: ..., value -> ...
`class` `FSUB` FSUB - Substract floats Stack: ..., value1, value2 -> result
`class` `GETFIELD` GETFIELD - Fetch field from object Stack: ..., objectref -> ..., value OR Stack: ..., objectref -> ..., value.word1, value.word2
`class` `GETSTATIC` GETSTATIC - Fetch static field from class Stack: ..., -> ..., value OR Stack: ..., -> ..., value.word1, value.word2
`class` `GOTO` GOTO - Branch always (to relative offset, not absolute address)
`class` `GOTO_W` GOTO_W - Branch always (to relative offset, not absolute address)
`class` `GotoInstruction` Super class for GOTO
`class` `I2B` I2B - Convert int to byte Stack: ..., value -> ..., result
`class` `I2C` I2C - Convert int to char Stack: ..., value -> ..., result
`class` `I2D` I2D - Convert int to double Stack: ..., value -> ..., result.word1, result.word2
`class` `I2F` I2F - Convert int to float Stack: ..., value -> ..., result
`class` `I2L` I2L - Convert int to long Stack: ..., value -> ..., result.word1, result.word2
`class` `I2S` I2S - Convert int to short Stack: ..., value -> ..., result
`class` `IADD` IADD - Add ints Stack: ..., value1, value2 -> result
`class` `IALOAD` IALOAD - Load int from array Stack: ..., arrayref, index -> ..., value
`class` `IAND` IAND - Bitwise AND int Stack: ..., value1, value2 -> ..., result
`class` `IASTORE` IASTORE - Store into int array Stack: ..., arrayref, index, value -> ...
`class` `ICONST` ICONST - Push value between -1, ..., 5, other values cause an exception Stack: ...
`class` `IDIV` IDIV - Divide ints Stack: ..., value1, value2 -> result
`class` `IF_ACMPEQ` IF_ACMPEQ - Branch if reference comparison succeeds Stack: ..., value1, value2 -> ...
`class` `IF_ACMPNE` IF_ACMPNE - Branch if reference comparison doesn't succeed Stack: ..., value1, value2 -> ...
`class` `IF_ICMPEQ` IF_ICMPEQ - Branch if int comparison succeeds Stack: ..., value1, value2 -> ...
`class` `IF_ICMPGE` IF_ICMPGE - Branch if int comparison succeeds Stack: ..., value1, value2 -> ...
`class` `IF_ICMPGT` IF_ICMPGT - Branch if int comparison succeeds Stack: ..., value1, value2 -> ...
`class` `IF_ICMPLE` IF_ICMPLE - Branch if int comparison succeeds Stack: ..., value1, value2 -> ...
`class` `IF_ICMPLT` IF_ICMPLT - Branch if int comparison succeeds Stack: ..., value1, value2 -> ...
`class` `IF_ICMPNE` IF_ICMPNE - Branch if int comparison doesn't succeed Stack: ..., value1, value2 -> ...
`class` `IFEQ` IFEQ - Branch if int comparison with zero succeeds Stack: ..., value -> ...
`class` `IFGE` IFGE - Branch if int comparison with zero succeeds Stack: ..., value -> ...
`class` `IFGT` IFGT - Branch if int comparison with zero succeeds Stack: ..., value -> ...
`class` `IfInstruction` Super class for the IFxxx family of instructions.
`class` `IFLE` IFLE - Branch if int comparison with zero succeeds Stack: ..., value -> ...
`class` `IFLT` IFLT - Branch if int comparison with zero succeeds Stack: ..., value -> ...
`class` `IFNE` IFNE - Branch if int comparison with zero succeeds Stack: ..., value -> ...
`class` `IFNONNULL` IFNONNULL - Branch if reference is not null Stack: ..., reference -> ...
`class` `IFNULL` IFNULL - Branch if reference is not null Stack: ..., reference -> ...
`class` `IINC` IINC - Increment local variable by constant
`class` `ILOAD` ILOAD - Load int from local variable onto stack Stack: ...
`class` `IMPDEP1` IMPDEP1 - Implementation dependent
`class` `IMPDEP2` IMPDEP2 - Implementation dependent
`class` `IMUL` IMUL - Multiply ints Stack: ..., value1, value2 -> result
`class` `INEG` INEG - Negate int Stack: ..., value -> ..., result
`class` `INSTANCEOF` INSTANCEOF - Determine if object is of given type Stack: ..., objectref -> ..., result
`class` `InvokeInstruction` Super class for the INVOKExxx family of instructions.
`class` `INVOKEINTERFACE` INVOKEINTERFACE - Invoke interface method Stack: ..., objectref, [arg1, [arg2 ...]]
`class` `INVOKESPECIAL` INVOKESPECIAL - Invoke instance method; special handling for superclass, private and instance initialization method invocations Stack: ..., objectref, [arg1, [arg2 ...]]
`class` `INVOKESTATIC` INVOKESTATIC - Invoke a class (static) method Stack: ..., [arg1, [arg2 ...]]
`class` `INVOKEVIRTUAL` INVOKEVIRTUAL - Invoke instance method; dispatch based on class Stack: ..., objectref, [arg1, [arg2 ...]]
`class` `IOR` IOR - Bitwise OR int Stack: ..., value1, value2 -> ..., result
`class` `IREM` IREM - Remainder of int Stack: ..., value1, value2 -> result
`class` `IRETURN` IRETURN - Return int from method Stack: ..., value -> <empty>
`class` `ISHL` ISHL - Arithmetic shift left int Stack: ..., value1, value2 -> ..., result
`class` `ISHR` ISHR - Arithmetic shift right int Stack: ..., value1, value2 -> ..., result
`class` `ISTORE` ISTORE - Store int from stack into local variable Stack: ..., value -> ...
`class` `ISUB` ISUB - Substract ints Stack: ..., value1, value2 -> result
`class` `IUSHR` IUSHR - Logical shift right int Stack: ..., value1, value2 -> ..., result
`class` `IXOR` IXOR - Bitwise XOR int Stack: ..., value1, value2 -> ..., result
`class` `JSR` JSR - Jump to subroutine
`class` `JSR_W` JSR_W - Jump to subroutine
`class` `JsrInstruction` Super class for JSR - Jump to subroutine
`class` `L2D` L2D - Convert long to double Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
`class` `L2F` L2F - Convert long to float Stack: ..., value.word1, value.word2 -> ..., result
`class` `L2I` L2I - Convert long to int Stack: ..., value.word1, value.word2 -> ..., result
`class` `LADD` LADD - Add longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `LALOAD` LALOAD - Load long from array Stack: ..., arrayref, index -> ..., value1, value2
`class` `LAND` LAND - Bitwise AND longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `LASTORE` LASTORE - Store into long array Stack: ..., arrayref, index, value.word1, value.word2 -> ...
`class` `LCMP` LCMP - Compare longs: Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result <= -1, 0, 1>
`class` `LCONST` LCONST - Push 0 or 1, other values cause an exception Stack: ...
`class` `LDC` LDC - Push item from constant pool.
`class` `LDC_W` LDC_W - Push item from constant pool (wide index) Stack: ...
`class` `LDC2_W` LDC2_W - Push long or double from constant pool Stack: ...
`class` `LDIV` LDIV - Divide longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `LLOAD` LLOAD - Load long from local variable Stack ...
`class` `LMUL` LMUL - Multiply longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `LNEG` LNEG - Negate long Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
`class` `LoadInstruction` Denotes an unparameterized instruction to load a value from a local variable, e.g.
`class` `LocalVariableInstruction` Abstract super class for instructions dealing with local variables.
`class` `LOOKUPSWITCH` LOOKUPSWITCH - Switch with unordered set of values
`class` `LOR` LOR - Bitwise OR long Stack: ..., value1, value2 -> ..., result
`class` `LREM` LREM - Remainder of long Stack: ..., value1, value2 -> result
`class` `LRETURN` LRETURN - Return long from method Stack: ..., value.word1, value.word2 -> <empty>
`class` `LSHL` LSHL - Arithmetic shift left long Stack: ..., value1.word1, value1.word2, value2 -> ..., result.word1, result.word2
`class` `LSHR` LSHR - Arithmetic shift right long Stack: ..., value1.word1, value1.word2, value2 -> ..., result.word1, result.word2
`class` `LSTORE` LSTORE - Store long into local variable Stack: ..., value.word1, value.word2 -> ...
`class` `LSUB` LSUB - Substract longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
`class` `LUSHR` LUSHR - Logical shift right long Stack: ..., value1, value2 -> ..., result
`class` `LXOR` LXOR - Bitwise XOR long Stack: ..., value1, value2 -> ..., result
`class` `MONITORENTER` MONITORENTER - Enter monitor for object Stack: ..., objectref -> ...
`class` `MONITOREXIT` MONITOREXIT - Exit monitor for object Stack: ..., objectref -> ...
`class` `MULTIANEWARRAY` MULTIANEWARRAY - Create new mutidimensional array of references Stack: ..., count1, [count2, ...]
`class` `NEW` NEW - Create new object Stack: ...
`class` `NEWARRAY` NEWARRAY - Create new array of basic type (int, short, ...)
`class` `NOP` NOP - Do nothing
`class` `POP` POP - Pop top operand stack word Stack: ..., word -> ...
`class` `POP2` POP2 - Pop two top operand stack words Stack: ..., word2, word1 -> ...
`class` `PUTFIELD` PUTFIELD - Put field in object Stack: ..., objectref, value -> ...
`class` `PUTSTATIC` PUTSTATIC - Put static field in class Stack: ..., value -> ...
`class` `RET` RET - Return from subroutine Stack: ..., -> ..., address
`class` `RETURN` RETURN - Return from void method Stack: ...
`class` `ReturnInstruction` Super class for the xRETURN family of instructions.
`class` `SALOAD` SALOAD - Load short from array Stack: ..., arrayref, index -> ..., value
`class` `SASTORE` SASTORE - Store into short array Stack: ..., arrayref, index, value -> ...
`class` `Select` Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
`class` `SIPUSH` SIPUSH - Push short Stack: ...
`class` `StackInstruction` Super class for stack operations like DUP and POP.
`class` `StoreInstruction` Denotes an unparameterized instruction to store a value into a local variable, e.g.
`class` `SWAP` SWAP - Swa top operand stack word Stack: ..., word2, word1 -> ..., word1, word2
`class` `TABLESWITCH` TABLESWITCH - Switch within given range of values, i.e., low..high

Fields in org.apache.bcel.generic declared as Instruction
`static Instruction` `InstructionConstants.NOP` Predefined instruction objects
`static Instruction` `InstructionConstants.ACONST_NULL`
`static Instruction` `InstructionConstants.ICONST_M1`
`static Instruction` `InstructionConstants.ICONST_0`
`static Instruction` `InstructionConstants.ICONST_1`
`static Instruction` `InstructionConstants.ICONST_2`
`static Instruction` `InstructionConstants.ICONST_3`
`static Instruction` `InstructionConstants.ICONST_4`
`static Instruction` `InstructionConstants.ICONST_5`
`static Instruction` `InstructionConstants.LCONST_0`
`static Instruction` `InstructionConstants.LCONST_1`
`static Instruction` `InstructionConstants.FCONST_0`
`static Instruction` `InstructionConstants.FCONST_1`
`static Instruction` `InstructionConstants.FCONST_2`
`static Instruction` `InstructionConstants.DCONST_0`
`static Instruction` `InstructionConstants.DCONST_1`
`static Instruction` `InstructionConstants.LCMP`
`static Instruction` `InstructionConstants.FCMPL`
`static Instruction` `InstructionConstants.FCMPG`
`static Instruction` `InstructionConstants.DCMPL`
`static Instruction` `InstructionConstants.DCMPG`
`static Instruction` `InstructionConstants.ARRAYLENGTH`
`static Instruction` `InstructionConstants.ATHROW`
`static Instruction` `InstructionConstants.MONITORENTER`
`static Instruction` `InstructionConstants.MONITOREXIT`
`static Instruction[]` `InstructionConstants.INSTRUCTIONS` Get object via its opcode, for immutable instructions like branch instructions entries are set to null.

Methods in org.apache.bcel.generic that return Instruction
`Instruction` `SWITCH.getInstruction()`
`Instruction` `PUSH.getInstruction()`
`Instruction[]` `InstructionList.getInstructions()`
`Instruction` `InstructionHandle.getInstruction()`
`Instruction` `InstructionHandle.swapInstruction(Instruction i)` Temporarily swap the current instruction, without disturbing anything.
`Instruction` `InstructionFactory.createConstant(java.lang.Object value)` Uses PUSH to push a constant value onto the stack.
`Instruction` `InstructionFactory.createAppend(Type type)`
`static Instruction` `InstructionFactory.createThis()` Create reference to `this'
`Instruction` `InstructionFactory.createCast(Type src_type, Type dest_type)` Create conversion operation for two stack operands, this may be an I2C, instruction, e.g., if the operands are basic types and CHECKCAST if they are reference types.
`Instruction` `InstructionFactory.createNewArray(Type t, short dim)` Create new array of given size and type.
`static Instruction` `InstructionFactory.createNull(Type type)` Create "null" value for reference types, 0 for basic types like int
`Instruction` `Instruction.copy()` Use with caution, since `BranchInstruction's have a `target' reference which is not copied correctly (only basic types are).
`static Instruction` `Instruction.readInstruction(ByteSequence bytes)` Read an instruction from (byte code) input stream and return the appropiate object.

Methods in org.apache.bcel.generic with parameters of type Instruction
`InstructionHandle` `InstructionList.append(Instruction i, InstructionList il)` Append another list after instruction i contained in this list.
`InstructionHandle` `InstructionList.append(Instruction i)` Append an instruction to the end of this list.
`InstructionHandle` `InstructionList.append(Instruction i, Instruction j)` Append a single instruction j after another instruction i, which must be in this list of course!
`InstructionHandle` `InstructionList.append(Instruction i, Instruction j)` Append a single instruction j after another instruction i, which must be in this list of course!
`InstructionHandle` `InstructionList.append(Instruction i, CompoundInstruction c)` Append a compound instruction, after instruction i.
`InstructionHandle` `InstructionList.append(InstructionHandle ih, Instruction i)` Append an instruction after instruction (handle) ih contained in this list.
`InstructionHandle` `InstructionList.insert(Instruction i, InstructionList il)` Insert another list before Instruction i contained in this list.
`InstructionHandle` `InstructionList.insert(Instruction i)` Insert an instruction at start of this list.
`InstructionHandle` `InstructionList.insert(Instruction i, Instruction j)` Insert a single instruction j before another instruction i, which must be in this list of course!
`InstructionHandle` `InstructionList.insert(Instruction i, Instruction j)` Insert a single instruction j before another instruction i, which must be in this list of course!
`InstructionHandle` `InstructionList.insert(Instruction i, CompoundInstruction c)` Insert a compound instruction before instruction i.
`InstructionHandle` `InstructionList.insert(InstructionHandle ih, Instruction i)` Insert an instruction before instruction (handle) ih contained in this list.
`void` `InstructionList.delete(Instruction i)` Remove instruction from this list.
`void` `InstructionList.delete(Instruction from, Instruction to)` Remove instructions from instruction `from' to instruction `to' contained in this list.
`void` `InstructionList.delete(Instruction from, Instruction to)` Remove instructions from instruction `from' to instruction `to' contained in this list.
`boolean` `InstructionList.contains(Instruction i)`
`void` `InstructionHandle.setInstruction(Instruction i)` Replace current instruction contained in this handle.
`Instruction` `InstructionHandle.swapInstruction(Instruction i)` Temporarily swap the current instruction, without disturbing anything.
`boolean` `InstructionComparator.equals(Instruction i1, Instruction i2)`
`boolean` `InstructionComparator.equals(Instruction i1, Instruction i2)`
`void` `BranchHandle.setInstruction(Instruction i)` Set new contents.

Constructors in org.apache.bcel.generic with parameters of type Instruction
`InstructionList(Instruction i)` Create instruction list containing one instruction.
`InstructionHandle(Instruction i)`

Copyright © 2002-2003 Apache Software Foundation. All Rights Reserved.