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

- Packages that use Instruction
  Package | Description
  --- | ---
  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
    Modifier and Type | Class and Description
    --- | ---
    `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` | `INVOKEDYNAMIC` Class for INVOKEDYNAMIC.
    `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` | `NameSignatureInstruction` Super class for FieldOrMethod and INVOKEDYNAMIC, since they both have names and signatures
    `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
    Modifier and Type | Field and Description
    --- | ---
    `static Instruction` | InstructionConst.`ACONST_NULL`
    `static Instruction` | InstructionConstants.`ACONST_NULL` Deprecated.
    `static Instruction` | InstructionConst.`ARRAYLENGTH`
    `static Instruction` | InstructionConstants.`ARRAYLENGTH` Deprecated.
    `static Instruction` | InstructionConst.`ATHROW`
    `static Instruction` | InstructionConstants.`ATHROW` Deprecated.
    `static Instruction` | InstructionConst.`DCMPG`
    `static Instruction` | InstructionConstants.`DCMPG` Deprecated.
    `static Instruction` | InstructionConst.`DCMPL`
    `static Instruction` | InstructionConstants.`DCMPL` Deprecated.
    `static Instruction` | InstructionConst.`DCONST_0`
    `static Instruction` | InstructionConstants.`DCONST_0` Deprecated.
    `static Instruction` | InstructionConst.`DCONST_1`
    `static Instruction` | InstructionConstants.`DCONST_1` Deprecated.
    `static Instruction` | InstructionConst.`FCMPG`
    `static Instruction` | InstructionConstants.`FCMPG` Deprecated.
    `static Instruction` | InstructionConst.`FCMPL`
    `static Instruction` | InstructionConstants.`FCMPL` Deprecated.
    `static Instruction` | InstructionConst.`FCONST_0`
    `static Instruction` | InstructionConstants.`FCONST_0` Deprecated.
    `static Instruction` | InstructionConst.`FCONST_1`
    `static Instruction` | InstructionConstants.`FCONST_1` Deprecated.
    `static Instruction` | InstructionConst.`FCONST_2`
    `static Instruction` | InstructionConstants.`FCONST_2` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_0`
    `static Instruction` | InstructionConstants.`ICONST_0` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_1`
    `static Instruction` | InstructionConstants.`ICONST_1` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_2`
    `static Instruction` | InstructionConstants.`ICONST_2` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_3`
    `static Instruction` | InstructionConstants.`ICONST_3` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_4`
    `static Instruction` | InstructionConstants.`ICONST_4` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_5`
    `static Instruction` | InstructionConstants.`ICONST_5` Deprecated.
    `static Instruction` | InstructionConst.`ICONST_M1`
    `static Instruction` | InstructionConstants.`ICONST_M1` Deprecated.
    `static Instruction[]` | InstructionConstants.`INSTRUCTIONS` Deprecated. Get object via its opcode, for immutable instructions like branch instructions entries are set to null.
    `static Instruction` | InstructionConst.`LCMP`
    `static Instruction` | InstructionConstants.`LCMP` Deprecated.
    `static Instruction` | InstructionConst.`LCONST_0`
    `static Instruction` | InstructionConstants.`LCONST_0` Deprecated.
    `static Instruction` | InstructionConst.`LCONST_1`
    `static Instruction` | InstructionConstants.`LCONST_1` Deprecated.
    `static Instruction` | InstructionConst.`MONITORENTER`
    `static Instruction` | InstructionConstants.`MONITORENTER` Deprecated.
    `static Instruction` | InstructionConst.`MONITOREXIT`
    `static Instruction` | InstructionConstants.`MONITOREXIT` Deprecated.
    `static Instruction` | InstructionConst.`NOP` Predefined instruction objects
    `static Instruction` | InstructionConstants.`NOP` Deprecated. Predefined instruction objects

    Methods in org.apache.bcel.generic that return Instruction
    Modifier and Type | Method and Description
    --- | ---
    `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` | InstructionHandle.`getInstruction()`
    `Instruction` | PUSH.`getInstruction()`
    `Instruction` | SWITCH.`getInstruction()`
    `static Instruction` | InstructionConst.`getInstruction(int index)` Gets the Instruction.
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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` | BranchHandle.`setInstruction(Instruction i)` Set new contents.
    `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.

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

Copyright © 2004–2020 The Apache Software Foundation. All rights reserved.