## 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
`class` `AASTORE` AASTORE - Store into reference array
`class` `ACONST_NULL` ACONST_NULL - Push null reference
`class` `ALOAD` ALOAD - Load reference from local variable
`class` `ANEWARRAY` ANEWARRAY - Create new array of references
`class` `ARETURN` ARETURN - Return reference from method
`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
`class` `ASTORE` ASTORE - Store reference into local variable
`class` `ATHROW` ATHROW - Throw exception
`class` `BALOAD` BALOAD - Load byte or boolean from array
`class` `BASTORE` BASTORE - Store into byte or boolean array
`class` `BIPUSH` BIPUSH - Push byte on 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
`class` `CASTORE` CASTORE - Store into char array
`class` `CHECKCAST` CHECKCAST - Check whether object is of given type
`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
`class` `D2I` D2I - Convert double to int
`class` `D2L` D2L - Convert double to long
`class` `DADD` DADD - Add doubles
`class` `DALOAD` DALOAD - Load double from array
`class` `DASTORE` DASTORE - Store into double array
`class` `DCMPG` DCMPG - Compare doubles: value1 > value2
`class` `DCMPL` DCMPL - Compare doubles: value1 < value2
`class` `DCONST` DCONST - Push 0.0 or 1.0, other values cause an exception
`class` `DDIV` DDIV - Divide doubles
`class` `DLOAD` DLOAD - Load double from local variable
`class` `DMUL` DMUL - Multiply doubles
`class` `DNEG` DNEG - Negate double
`class` `DREM` DREM - Remainder of doubles
`class` `DRETURN` DRETURN - Return double from method
`class` `DSTORE` DSTORE - Store double into local variable
`class` `DSUB` DSUB - Substract doubles
`class` `DUP` DUP - Duplicate top operand stack word
`class` `DUP_X1` DUP_X1 - Duplicate top operand stack word and put two down
`class` `DUP_X2` DUP_X2 - Duplicate top operand stack word and put three down
`class` `DUP2` DUP2 - Duplicate two top operand stack words
`class` `DUP2_X1` DUP2_X1 - Duplicate two top operand stack words and put three down
`class` `DUP2_X2` DUP2_X2 - Duplicate two top operand stack words and put four down
`class` `F2D` F2D - Convert float to double
`class` `F2I` F2I - Convert float to int
`class` `F2L` F2L - Convert float to long
`class` `FADD` FADD - Add floats
`class` `FALOAD` FALOAD - Load float from array
`class` `FASTORE` FASTORE - Store into float array
`class` `FCMPG` FCMPG - Compare floats: value1 > value2
`class` `FCMPL` FCMPL - Compare floats: value1 < value2
`class` `FCONST` FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
`class` `FDIV` FDIV - Divide floats
`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
`class` `FMUL` FMUL - Multiply floats
`class` `FNEG` FNEG - Negate float
`class` `FREM` FREM - Remainder of floats
`class` `FRETURN` FRETURN - Return float from method
`class` `FSTORE` FSTORE - Store float into local variable
`class` `FSUB` FSUB - Substract floats
`class` `GETFIELD` GETFIELD - Fetch field from object
`class` `GETSTATIC` GETSTATIC - Fetch static field from class
`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
`class` `I2C` I2C - Convert int to char
`class` `I2D` I2D - Convert int to double
`class` `I2F` I2F - Convert int to float
`class` `I2L` I2L - Convert int to long
`class` `I2S` I2S - Convert int to short
`class` `IADD` IADD - Add ints
`class` `IALOAD` IALOAD - Load int from array
`class` `IAND` IAND - Bitwise AND int
`class` `IASTORE` IASTORE - Store into int array
`class` `ICONST` ICONST - Push value between -1, ..., 5, other values cause an exception
`class` `IDIV` IDIV - Divide ints
`class` `IF_ACMPEQ` IF_ACMPEQ - Branch if reference comparison succeeds
`class` `IF_ACMPNE` IF_ACMPNE - Branch if reference comparison doesn't succeed
`class` `IF_ICMPEQ` IF_ICMPEQ - Branch if int comparison succeeds
`class` `IF_ICMPGE` IF_ICMPGE - Branch if int comparison succeeds
`class` `IF_ICMPGT` IF_ICMPGT - Branch if int comparison succeeds
`class` `IF_ICMPLE` IF_ICMPLE - Branch if int comparison succeeds
`class` `IF_ICMPLT` IF_ICMPLT - Branch if int comparison succeeds
`class` `IF_ICMPNE` IF_ICMPNE - Branch if int comparison doesn't succeed
`class` `IFEQ` IFEQ - Branch if int comparison with zero succeeds
`class` `IFGE` IFGE - Branch if int comparison with zero succeeds
`class` `IFGT` IFGT - Branch if int comparison with zero succeeds
`class` `IfInstruction` Super class for the IFxxx family of instructions.
`class` `IFLE` IFLE - Branch if int comparison with zero succeeds
`class` `IFLT` IFLT - Branch if int comparison with zero succeeds
`class` `IFNE` IFNE - Branch if int comparison with zero succeeds
`class` `IFNONNULL` IFNONNULL - Branch if reference is not null
`class` `IFNULL` IFNULL - Branch if reference is not null
`class` `IINC` IINC - Increment local variable by constant
`class` `ILOAD` ILOAD - Load int from local variable onto stack
`class` `IMPDEP1` IMPDEP1 - Implementation dependent
`class` `IMPDEP2` IMPDEP2 - Implementation dependent
`class` `IMUL` IMUL - Multiply ints
`class` `INEG` INEG - Negate int
`class` `INSTANCEOF` INSTANCEOF - Determine if object is of given type
`class` `InvokeInstruction` Super class for the INVOKExxx family of instructions.
`class` `INVOKEINTERFACE` INVOKEINTERFACE - Invoke interface method
`class` `INVOKESPECIAL` INVOKESPECIAL - Invoke instance method; special handling for superclass, private and instance initialization method invocations
`class` `INVOKESTATIC` INVOKESTATIC - Invoke a class (static) method
`class` `INVOKEVIRTUAL` INVOKEVIRTUAL - Invoke instance method; dispatch based on class
`class` `IOR` IOR - Bitwise OR int
`class` `IREM` IREM - Remainder of int
`class` `IRETURN` IRETURN - Return int from method
`class` `ISHL` ISHL - Arithmetic shift left int
`class` `ISHR` ISHR - Arithmetic shift right int
`class` `ISTORE` ISTORE - Store int from stack into local variable
`class` `ISUB` ISUB - Substract ints
`class` `IUSHR` IUSHR - Logical shift right int
`class` `IXOR` IXOR - Bitwise XOR int
`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
`class` `L2F` L2F - Convert long to float
`class` `L2I` L2I - Convert long to int
`class` `LADD` LADD - Add longs
`class` `LALOAD` LALOAD - Load long from array
`class` `LAND` LAND - Bitwise AND longs
`class` `LASTORE` LASTORE - Store into long array
`class` `LCMP` LCMP - Compare longs:
`class` `LCONST` LCONST - Push 0 or 1, other values cause an exception
`class` `LDC` LDC - Push item from constant pool.
`class` `LDC_W` LDC_W - Push item from constant pool (wide index)
`class` `LDC2_W` LDC2_W - Push long or double from constant pool
`class` `LDIV` LDIV - Divide longs
`class` `LLOAD` LLOAD - Load long from local variable
`class` `LMUL` LMUL - Multiply longs
`class` `LNEG` LNEG - Negate long
`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
`class` `LREM` LREM - Remainder of long
`class` `LRETURN` LRETURN - Return long from method
`class` `LSHL` LSHL - Arithmetic shift left long
`class` `LSHR` LSHR - Arithmetic shift right long
`class` `LSTORE` LSTORE - Store long into local variable
`class` `LSUB` LSUB - Substract longs
`class` `LUSHR` LUSHR - Logical shift right long
`class` `LXOR` LXOR - Bitwise XOR long
`class` `MONITORENTER` MONITORENTER - Enter monitor for object
`class` `MONITOREXIT` MONITOREXIT - Exit monitor for object
`class` `MULTIANEWARRAY` MULTIANEWARRAY - Create new mutidimensional array of references
`class` `NEW` NEW - Create new object
`class` `NEWARRAY` NEWARRAY - Create new array of basic type (int, short, ...)
`class` `NOP` NOP - Do nothing
`class` `POP` POP - Pop top operand stack word
`class` `POP2` POP2 - Pop two top operand stack words
`class` `PUTFIELD` PUTFIELD - Put field in object
`class` `PUTSTATIC` PUTSTATIC - Put static field in class
`class` `RET` RET - Return from subroutine
`class` `RETURN` RETURN - Return from void method
`class` `ReturnInstruction` Super class for the xRETURN family of instructions.
`class` `SALOAD` SALOAD - Load short from array
`class` `SASTORE` SASTORE - Store into short array
`class` `Select` Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
`class` `SIPUSH` SIPUSH - Push short
`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
`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.ACONST_NULL`
`static Instruction` `InstructionConstants.ARRAYLENGTH`
`static Instruction` `InstructionConstants.ATHROW`
`static Instruction` `InstructionConstants.DCMPG`
`static Instruction` `InstructionConstants.DCMPL`
`static Instruction` `InstructionConstants.DCONST_0`
`static Instruction` `InstructionConstants.DCONST_1`
`static Instruction` `InstructionConstants.FCMPG`
`static Instruction` `InstructionConstants.FCMPL`
`static Instruction` `InstructionConstants.FCONST_0`
`static Instruction` `InstructionConstants.FCONST_1`
`static Instruction` `InstructionConstants.FCONST_2`
`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.ICONST_M1`
`static Instruction[]` `InstructionConstants.INSTRUCTIONS` Get object via its opcode, for immutable instructions like branch instructions entries are set to null.
`static Instruction` `InstructionConstants.LCMP`
`static Instruction` `InstructionConstants.LCONST_0`
`static Instruction` `InstructionConstants.LCONST_1`
`static Instruction` `InstructionConstants.MONITORENTER`
`static Instruction` `InstructionConstants.MONITOREXIT`
`static Instruction` `InstructionConstants.NOP` Predefined instruction objects

Methods in org.apache.bcel.generic that return Instruction
`Instruction` `Instruction.copy()` Use with caution, since `BranchInstruction's have a `target' reference which is not copied correctly (only basic types are).
`Instruction` `InstructionFactory.createAppend(Type type)`
`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.createConstant(Object value)` Uses PUSH to push a constant value onto the stack.
`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
`static Instruction` `InstructionFactory.createThis()` Create reference to `this'
`Instruction` `SWITCH.getInstruction()`
`Instruction` `PUSH.getInstruction()`
`Instruction` `InstructionHandle.getInstruction()`
`Instruction[]` `InstructionList.getInstructions()`
`static Instruction` `Instruction.readInstruction(ByteSequence bytes)` Read an instruction from (byte code) input stream and return the appropiate object.
`Instruction` `InstructionHandle.swapInstruction(Instruction i)` Temporarily swap the current instruction, without disturbing anything.

Methods in org.apache.bcel.generic with parameters of type Instruction
`InstructionHandle` `InstructionList.append(Instruction i)` Append an instruction to the end of this list.
`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.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, InstructionList il)` Append another list after instruction i contained in this list.
`boolean` `InstructionList.contains(Instruction i)`
`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.
`boolean` `InstructionComparator.equals(Instruction i1, Instruction i2)`
`InstructionHandle` `InstructionList.insert(Instruction i)` Insert an instruction at start of this list.
`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.
`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, InstructionList il)` Insert another list before Instruction i contained in this list.
`void` `InstructionHandle.setInstruction(Instruction i)` Replace current instruction contained in this handle.
`void` `BranchHandle.setInstruction(Instruction i)` Set new contents.
`Instruction` `InstructionHandle.swapInstruction(Instruction i)` Temporarily swap the current instruction, without disturbing anything.

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

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