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.
org.apache.bcel.util	This package contains utility classes for the Byte Code Engineering Library, namely:
org.apache.bcel.verifier.statics	Provides PassVerifier classes used internally by JustIce.
org.apache.bcel.verifier.structurals	Provides a PassVerifier class mostly used internally by JustIce, yielding a control flow graph for public use as a nice side effect.

Uses of Instruction in org.apache.bcel.generic

Subclasses of Instruction in org.apache.bcel.generic

Modifier and Type	Class	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	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.
private Instruction	InstructionHandle.instruction
private Instruction	PUSH.instruction
private static Instruction[]	InstructionConst.INSTRUCTIONS	Get object via its opcode, for immutable instructions like branch instructions entries are set to null.
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	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(java.lang.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'
static Instruction	InstructionConst.getInstruction(int index)	Gets the Instruction.
Instruction	InstructionHandle.getInstruction()
Instruction	PUSH.getInstruction()
Instruction	SWITCH.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

Modifier and Type	Method	Description
InstructionHandle	InstructionList.append(Instruction i)	Append an instruction to the end of this list.
InstructionHandle	InstructionList.append(InstructionHandle ih, Instruction i)	Append an instruction after instruction (handle) ih contained in this list.
InstructionHandle	InstructionList.append(Instruction i, CompoundInstruction c)	Append a compound instruction, after instruction i.
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)
private InstructionHandle	InstructionList.findInstruction1(Instruction i)	Search for given Instruction reference, start at beginning of list.
private InstructionHandle	InstructionList.findInstruction2(Instruction i)	Search for given Instruction reference, start at end of list
(package private) static InstructionHandle	InstructionHandle.getInstructionHandle(Instruction i)	Factory method.
InstructionHandle	InstructionList.insert(Instruction i)	Insert an instruction at start of this list.
InstructionHandle	InstructionList.insert(InstructionHandle ih, Instruction i)	Insert an instruction before instruction (handle) ih contained in this list.
InstructionHandle	InstructionList.insert(Instruction i, CompoundInstruction c)	Insert a compound instruction before instruction i.
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	Description
InstructionHandle(Instruction i)
InstructionList(Instruction i)	Create instruction list containing one instruction.

Uses of Instruction in org.apache.bcel.util

Fields in org.apache.bcel.util with type parameters of type Instruction

Modifier and Type	Field	Description
private java.util.Map<Instruction,InstructionHandle>	BCELFactory.branch_map

Methods in org.apache.bcel.util with parameters of type Instruction

Modifier and Type	Method	Description
private boolean	BCELFactory.visitInstruction(Instruction i)

Uses of Instruction in org.apache.bcel.verifier.statics

Methods in org.apache.bcel.verifier.statics with parameters of type Instruction

Modifier and Type	Method	Description
private void	Pass3aVerifier.InstOperandConstraintVisitor.constraintViolated(Instruction i, java.lang.String message)	A utility method to always raise an exeption.
private void	Pass3aVerifier.InstOperandConstraintVisitor.indexValid(Instruction i, int idx)	A utility method to raise an exception if the index is not a valid constant pool index.

Uses of Instruction in org.apache.bcel.verifier.structurals

Methods in org.apache.bcel.verifier.structurals with parameters of type Instruction

Modifier and Type	Method	Description
private void	InstConstraintVisitor._visitStackAccessor(Instruction o)	Ensures the general preconditions of an instruction that accesses the stack.
private boolean	InstConstraintVisitor.arrayrefOfArrayType(Instruction o, Type arrayref)	Assures arrayref is of ArrayType or NULL; returns true if and only if arrayref is non-NULL.
private void	InstConstraintVisitor.constraintViolated(Instruction violator, java.lang.String description)	This method is called by the visitXXX() to notify the acceptor of this InstConstraintVisitor that a constraint violation has occured.
private void	InstConstraintVisitor.indexOfInt(Instruction o, Type index)	Assures index is of type INT.
private void	InstConstraintVisitor.referenceTypeIsInitialized(Instruction o, ReferenceType r)	Assures the ReferenceType r is initialized (or Type.NULL).
private void	InstConstraintVisitor.valueOfInt(Instruction o, Type value)	Assures value is of type INT.