|
||||||||||
PREV NEXT | FRAMES NO FRAMES All Classes |
Packages that use Instruction | |
---|---|
jef.disconnection.impl | |
jef.dna.attributes | |
jef.dna.attributes.impl | |
jef.dna.instructions | |
jef.dna.instructions.impl |
Uses of Instruction in jef.disconnection.impl |
---|
Methods in jef.disconnection.impl with parameters of type Instruction | |
---|---|
protected void |
DefaultMethodDisconnector.handleFieldOrMethodRef(DisconnectedMethod dm,
Dna srcDna,
ConstantPoolTable srcCpt,
int oldRef,
int newRef,
Instruction instruction)
|
Uses of Instruction in jef.dna.attributes |
---|
Methods in jef.dna.attributes that return types with arguments of type Instruction | |
---|---|
java.util.List<Instruction> |
CodeAttribute.generateObjectiveCode(int[] bytecode)
This private method generates an object oriented representation of the bytecode contained within this method. |
java.util.List<Instruction> |
CodeAttribute.getObjectiveCode()
This method returns the object oriented representation of this method's code. |
Uses of Instruction in jef.dna.attributes.impl |
---|
Methods in jef.dna.attributes.impl that return types with arguments of type Instruction | |
---|---|
java.util.List<Instruction> |
Code.generateObjectiveCode(int[] bytecode)
This method generates an object oriented representation of the bytecode contained within this method. |
java.util.List<Instruction> |
Code.getObjectiveCode()
This method returns the object oriented representation of this method's code. |
Uses of Instruction in jef.dna.instructions |
---|
Subinterfaces of Instruction in jef.dna.instructions | |
---|---|
interface |
InstructionRefsCpt
This interface has to be implemented by every class representing a Java bytecode instruction which refers to the constant pool table. |
Methods in jef.dna.instructions that return Instruction | |
---|---|
Instruction |
InstructionFactory.getInstruction(byte opCode)
This method returns class instances implementing the Instruction interface. |
Instruction |
InstructionFactory.getInstruction(int opCode)
This method returns classe instances implementing the Instruction interface. |
Uses of Instruction in jef.dna.instructions.impl |
---|
Classes in jef.dna.instructions.impl that implement Instruction | |
---|---|
class |
AALoad
This class maps the AALOAD bytecode instruction which loads a reference from an
array. |
class |
AAStore
This class maps the AASTORE bytecode instruction which stores a reference to an
array. |
class |
AConst_Null
This class maps the AACONST_NULL bytecode instruction which pushes null onto the
operant stack. |
class |
ALoad
This class maps the ALOAD bytecode instruction which loads a reference from a
local variable. |
class |
ALoad_0
This class maps the ALOAD_0 bytecode instruction which loads a reference from a
local variable stored at the position 0 of the local variable array of the current frame. |
class |
ALoad_1
This class maps the ALOAD_1 bytecode instruction which loads a reference from a
local variable stored at the position 1 of the local variable array of the current frame. |
class |
ALoad_2
This class maps the ALOAD_2 bytecode instruction which loads a reference from a
local variable stored at the position 2 of the local variable array of the current frame. |
class |
ALoad_3
This class maps the ALOAD_3 bytecode instruction which loads a reference from a
local variable stored at the position 3 of the local variable array of the current frame. |
class |
ANewArray
This class maps the ANEWARRAY bytecode instruction. |
class |
AReturn
This class maps the ARETURN bytecode instruction which returns a reference from a
method |
class |
ArrayLength
This class maps the ARRAYLENGTH bytecode instruction which returns the length of
an array. |
class |
AStore
This class maps the ASTORE bytecode instruction which stores a reference into a
local variable |
class |
AStore_0
This class maps the ASTORE bytecode instruction which store a reference into a
local variable. 0 is the index in the local variable array of the current frame |
class |
AStore_1
This class maps the ASTORE bytecode instruction which store a reference into a
local variable. 1 is the index in the local variable array of the current frame |
class |
AStore_2
This class maps the ASTORE_2 bytecode instruction which store a reference into a
local variable. 2 is the index in the local variable array of the current frame |
class |
AStore_3
This class maps the ASTORE_3 bytecode instruction which store a reference into a
local variable. 3 is the index in the local variable array of the current frame |
class |
AThrow
This class maps the ATHROW bytecode instruction which is used to throw an
exception or an error |
class |
BALoad
This class maps the BALOAD bytecode instruction which loads a byte
or a boolean from an array. |
class |
BAStore
This class maps the BASTORE bytecode instruction which stores a byte
or a boolean to an array. |
class |
BiPush
This class maps the BIPUSH bytecode instruction which pushes a byte
onto the stack. |
class |
CALoad
This class maps the CALOAD bytecode instruction which loads a char
from an array. |
class |
CAStore
This class maps the CASTORE bytecode instruction which stores a char
to an array. |
class |
CheckCast
This class maps the CHECKCAST bytecode instruction which checks whether the object
referenced by the reference on the top of the stack can be casted to the type represented by the
constant pool table entry at index indexbyte1<<8|indexbyte2 . |
class |
D2f
This class maps the D2F bytecode instruction which converts a double
to float . |
class |
D2i
This class maps the D2I bytecode instruction which converts a double
to integer . |
class |
D2l
This class maps the D2L bytecode instruction which converts a double
to long . |
class |
DAdd
This class maps the DADD bytecode instruction which adds two operands of type
double stored on the top of the stack. |
class |
DALoad
This class maps the DALOAD bytecode instruction which loads a double
from an array. |
class |
DAStore
This class maps the DASTORE bytecode instruction which stores a
double to an array. |
class |
DCmpg
This class maps the DCMPG bytecode instruction which compares two
double s took from the top of the stack. |
class |
DCmpl
This class maps the DCMPG bytecode instruction which compares two
double s took from the top of the stack. |
class |
DConst_0
This class maps the DCONST_0 bytecode instruction which pushes the
double constant 0.0 on to the operand stack. |
class |
DConst_1
This class maps the DCONST_1 bytecode instruction which pushes the
double constant 1.0 on to the operand stack. |
class |
DDiv
This class maps the DDIV bytecode instruction which divides the two
double s popped out from the operand stack and pushes back the result. |
class |
DLoad
This class maps the DLOAD bytecode instruction which loads a double
from the index specified as parameter (operand). |
class |
DLoad_0
This class maps the DLOAD_0 bytecode instruction which loads a double
from the local variable array of the current frame at index 0. |
class |
DLoad_1
This class maps the DLOAD_1 bytecode instruction which loads a double
from the local variable array of the current frame at index 1. |
class |
DLoad_2
This class maps the DLOAD_2 bytecode instruction which loads a double
from the local variable array of the current frame at index 2. |
class |
DLoad_3
This class maps the DLOAD_3 bytecode instruction which loads a double
from the local variable array of the current frame at index 3. |
class |
DMul
This class maps the DMUL bytecode instruction which multiplies two
double s popped from the operand stack, and pushes the result onto the operand
stack. |
class |
DNeg
This class maps the DNEG bytecode instruction which negates a double . |
class |
DRem
This class maps the DREM bytecode instruction which computes the reminder of the
truncationg division of the two double s popped from the operand stack. |
class |
DReturn
This class maps the DRETURN bytecode instruction which returns a
double popping it from the operand stack. |
class |
DStore
This class maps the DSTORE bytecode instruction which stores a double
popped from the operand stack into a variable whose index is specified as operand. |
class |
DStore_0
This class maps the DSTORE_0 bytecode instruction which stores a
double popped from the operand stack into the index 0 of the local variable array. |
class |
DStore_1
This class maps the DSTORE_1 bytecode instruction which stores a
double popped from the operand stack into the index 1 of the local variable array. |
class |
DStore_2
This class maps the DSTORE_2 bytecode instruction which stores a
double popped from the operand stack into the index 2 of the local variable array. |
class |
DStore_3
This class maps the DSTORE_3 bytecode instruction which stores a
double popped from the operand stack into the index 3 of the local variable array. |
class |
DSub
This class maps the DSUB bytecode instruction which subtracts the first
double popped from the operand stack from the second one, and pushes the result
onto the operand stack. |
class |
Dup
This class maps the DUP bytecode instruction which duplicates the value found at
the top of the operand stack, and pushes the copy of the top of it: as a result at the top of the
operans stack there will be two equal double s. |
class |
Dup_X1
This class maps the DUP_X1 bytecode instruction which duplicates the top value on
the operand stack and insert the duplicated value two values down in the operand stack. |
class |
Dup_X2
This class maps the DUP_X2 bytecode instruction which duplicates the top value on
the operand stack and insert the duplicated value two or three values down in the operand stack. |
class |
Dup2
This class maps the DUP2 bytecode instruction which duplicates the top one or two
values on the operand stack and push the duplicated value or values back onto the operand stack
in the original order. |
class |
Dup2_X1
This class maps the DUP2_X1 bytecode instruction which duplicates the top one or
two values on the operand stack and insert the duplicated values, in the original order, one
value beneath the original value or values in the operand stack. |
class |
Dup2_X2
This class maps the DUP2_X2 bytecode instruction which duplicates the top one or
two values on the operand stack and insert the duplicated values, in the original order, into the
operand stack. |
class |
F2d
This class maps the F2D bytecode instruction which converts a float
popped from the operand stack into a double and places it on the top of the
operand stack. |
class |
F2i
This class maps the F2I bytecode instruction which converts a float
popped from the operand stack into an integer and places it on the top of the
operand stack. |
class |
F2l
This class maps the F2L bytecode instruction which converts a float
popped from the operand stack into a long and places it on the top of the operand
stack. |
class |
FAdd
This class maps the FADD bytecode instruction which adds two float
values. |
class |
FALoad
This class maps the FALOAD bytecode instruction which loads a float
from an array. |
class |
FAStore
This class maps the FASTORE bytecode instruction which stores a float
to an array. |
class |
FCmpg
This class maps the FCMPG bytecode instruction which preforms a comparison between
two float values. |
class |
FCmpl
This class maps the FCMPL bytecode instruction which preforms a comparison between
two float values. |
class |
FConst_0
This class maps the FCONST_0 bytecode instruction which pushes the constant
long 0 onto the operand stack. |
class |
FConst_1
This class maps the FCONST_1 bytecode instruction which pushes the constant
long 1 onto the operand stack. |
class |
FConst_2
This class maps the FCONST_2 bytecode instruction which pushes the constant
long 2 onto the operand stack. |
class |
FDiv
This class maps the FDIV bytecode instruction which divides two float s
popped from the top two positions of the operand stack and pushes back the result. |
class |
FLoad
This class maps the FLOAD bytecode instruction which loads a float
value from a local variable whose index is provided as parameter. |
class |
FLoad_0
This class maps the FLOAD_0 bytecode instruction which loads a float
value from the position 0 of the local variable array of the current frame. |
class |
FLoad_1
This class maps the FLOAD_1 bytecode instruction which loads a float
value from the position 1 of the local variable array of the current frame. |
class |
FLoad_2
This class maps the FLOAD_2 bytecode instruction which loads a float
value from the position 2 of the local variable array of the current frame. |
class |
FLoad_3
This class maps the FLOAD_3 bytecode instruction which loads a float
value from the position 3 of the local variable array of the current frame. |
class |
FMul
This class maps the FMUL bytecode instruction which multiplies two
float s popped from the operand stack. |
class |
FNeg
This class maps the FNEG bytecode instruction which negates the
float |
class |
FRem
This class maps the FREM bytecode instruction which computes the reminder of the
division of the first element taken from the operand stack by the second one. |
class |
FReturn
This class maps the FRETURN bytecode instruction which is needed in order to
return a float value from a method. |
class |
FStore
This class maps the FSTORE bytecode instruction which stores a float
value popped from the operand stack into a local variable whose index has to be provided as
parameter to the FSTORE instruction. |
class |
FStore_0
This class maps the FSTORE_0 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 0. |
class |
FStore_1
This class maps the FSTORE_1 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 1. |
class |
FStore_2
This class maps the FSTORE_2 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 2. |
class |
FStore_3
This class maps the FSTORE_3 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 3. |
class |
FSub
This class maps the FSUB bytecode instruction which subtracts the first value
popped from the operand stack from the second one, and pushes the result back onto the operand
stack. |
class |
GetField
This class maps the GETFIELD bytecode instruction which fetches field from object. |
class |
GetStatic
This class maps the GETSTATIC bytecode instruction which gets static field from
class. |
class |
Goto
This class maps the GOTO bytecode instruction which branches always. |
class |
Goto_W
This class maps the GOTO_W bytecode instruction which branches always (wide
index). |
class |
I2b
This class maps the I2B bytecode instruction which converts an int
popped from the operand stack, to a byte . |
class |
I2c
This class maps the I2C bytecode instruction which converts an int
popped from the operand stack, to a char . |
class |
I2d
This class maps the I2D bytecode instruction which converts an int
popped from the operand stack to a double . |
class |
I2f
This class maps the I2F bytecode instruction which converts an int
popped from the operand stack to a float . |
class |
I2l
This class maps the I2L bytecode instruction which converts an int
popped from the operand stack to a long . |
class |
I2s
This class maps the I2S bytecode instruction which converts an int
popped from the operand stack, to a short . |
class |
IAdd
This class maps the IADD bytecode instruction which adds two int s
took from the operand stack. |
class |
IALoad
This class maps the IALOAD bytecode instruction which loads an int
from the position, specified by the first entry of the operand stack, of the array referenced by
the second entry of the operand stack. |
class |
IAnd
This class maps the IAND bytecode instruction which performs a bitwise and
operation of the first two int popped from the operand stack. |
class |
IAStore
This class maps the IASTORE bytecode instruction which stores an int
into the array referenced by the second entry of the operand stack a the index given by the first
entry of the operand stack. |
class |
IConst_0
This class maps the ICONST_0 bytecode instruction which pushes the costant 0 onto
the operand stack. |
class |
IConst_1
This class maps the ICONST_1 bytecode instruction which pushes the costant 1 onto
the operand stack. |
class |
IConst_2
This class maps the ICONST_2 bytecode instruction which pushes the costant 2 onto
the operand stack. |
class |
IConst_3
This class maps the ICONST_3 bytecode instruction which pushes the costant 3 onto
the operand stack. |
class |
IConst_4
This class maps the ICONST_4 bytecode instruction which pushes the costant 4 onto
the operand stack. |
class |
IConst_5
This class maps the ICONST_5 bytecode instruction which pushes the costant 5 onto
the operand stack. |
class |
IConst_M1
This class maps the ICONST_M1 bytecode instruction which pushes the costant -1
onto the operand stack. |
class |
IDiv
This class maps the IDIV bytecode instruction which divides the second entry of
the operand stack by the first one, and pushes the result back on top of the operand stack. |
class |
If_ACmpEq
This class maps the IFACMPEQ bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the first two values popped from
the operand stack equal. |
class |
If_ACmpNe
This class maps the IFACMPLNE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the first two values popped from
the operand stack don't equal. |
class |
IF_ICmpeq
This class maps the IF_ICMPEQ bytecode instruction which compares the first two
int s popped from the operand stack. |
class |
IF_ICmpge
This class maps the IF_ICMPGE bytecode instruction which compares the first two
int s popped from the operand stack. |
class |
IF_ICmpgt
This class maps the IF_ICMPGT bytecode instruction which compares the first two
int s popped from the operand stack. |
class |
IF_ICmple
This class maps the IF_ICMPLE bytecode instruction which compares the first two
int s popped from the operand stack. |
class |
IF_ICmplt
This class maps the IF_ICMPLT bytecode instruction which compares the first two
int s popped from the operand stack. |
class |
IF_ICmpne
This class maps the IF_ICMPNE bytecode instruction which compares the first two
int s popped from the operand stack. |
class |
Ifeq
This class maps the IFEQ bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack equals 0. |
class |
Ifge
This class maps the IFGE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is greater than or equals 0. |
class |
Ifgt
This class maps the IFGT bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is greater than 0. |
class |
Ifle
This class maps the IFLE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is less than or equals 0. |
class |
Iflt
This class maps the IFLT bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is less than 0. |
class |
Ifne
This class maps the IFNE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack does not equal 0. |
class |
IfNoNull
This class maps the IFNONNULL bytecode instruction which branches to the specified
offset if and only if the value of type reference popped from the operand stack is
not null . |
class |
IfNull
This class maps the IFNULL bytecode instruction which behaves exactly like the
ifnonnull instruction, but the jump happens if and only if the reference popped
from the operand stack is null rether then non null . |
class |
IInc
This class maps the IINC bytecode instruction which increments the
int referenced by the first IINC parameter (this is an index into
the local variable array of the current frame) by a constant given as second paramenter of the
bytecode instruction. |
class |
ILoad
This class maps the ILOAD bytecode instruction which loads an int
from the local variable array of the current frame, at the index specified as parameter of the
instruction. |
class |
ILoad_0
This class maps the ILOAD_0 bytecode instruction which loads an int
from the index 0 of the local variable array of the current frame. |
class |
ILoad_1
This class maps the ILOAD_1 bytecode instruction which loads an int
from the index 1 of the local variable array of the current frame. |
class |
ILoad_2
This class maps the ILOAD_2 bytecode instruction which loads an int
from the index 2 of the local variable array of the current frame. |
class |
ILoad_3
This class maps the ILOAD_3 bytecode instruction which loads an int
from the index 3 of the local variable array of the current frame. |
class |
IMul
This class maps the IMUL bytecode instruction which multiplies the first two
int s popped from the operand stack and pushes back the result. |
class |
INeg
This class maps the INEG bytecode instruction which performs the arithmetical
negation of the int popped from the operand stack, and pushes back the result. |
class |
InstanceOf
This class maps the INSTANCEPF bytecode instruction which determines if the object
references by the address popped from the operand stack is of the type given by the entry of the
runtime constantpool addressed by the two bytes required as parameter for this instruction. |
class |
InstructionAncestor
This class is the ancestor of all the concrete instruction classes, and provides all these methods common to every instruction. |
class |
InstructionAncestorRefsCpt
This class is the ancestor of all the concrete instruction classes referring the constant pool table. |
class |
InstructionRefsCpt16
This class is the ancestor of all the concrete instruction classes referring the constant pool table with 16 bits index. |
class |
InstructionRefsCpt8
This class is the ancestor of all the concrete instruction classes referring the constant pool table with 8 bits index. |
class |
InvokeInterface
This class maps the INVOKEINTERFACE bytecode instruction which invokes an
interface method. |
class |
InvokeSpecial
This class maps the INVOKESPECIAL bytecode instruction which invokes instance
initialization, private and super class methods. |
class |
InvokeStatic
This class maps the INVOKESTATIC bytecode instruction which invokes static
methods. |
class |
InvokeVirtual
This class maps the INVOKEVIRTUAL bytecode instruction which invokes instance
methods. |
class |
IOr
This class maps the IOR bytecode instruction which performs the boolean or of the
first two int s popped from the operand stack. |
class |
IRem
This class maps the IREM bytecode instruction which calculates the reminder of the
division of the second entry of the operand stack by the first one. |
class |
IReturn
This class maps the IRETURN bytecode instruction which is used to return an
int from a method. |
class |
IShl
This class maps the ISHL bytecode instruction which shifts left the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
class |
IShr
This class maps the ISHR bytecode instruction which shifts right the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
class |
IStore
This class maps the ISTORE bytecode instruction which stores an int
popped from the operand stack into a local variable whose address points to an entry of the local
variable array of the current frame. |
class |
IStore_0
This class maps the ISTORE_0 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
0. |
class |
IStore_1
This class maps the ISTORE_1 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
1. |
class |
IStore_2
This class maps the ISTORE_2 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
2. |
class |
IStore_3
This class maps the ISTORE_3 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
3. |
class |
ISub
This class maps the ISUB bytecode instruction which subtracts the first value
popped from the operand stack from the second one, and pushes the result back onto the operand
stack. |
class |
Iushr
This class maps the IUSHR bytecode instruction. |
class |
IXOr
This class maps the IXOR bytecode instruction which performs the boolean xor over
the first two values popped from the operand stack. |
class |
Jsr
This class maps the JSR bytecode instruction which jumps to subroutine. |
class |
Jsr_W
This class maps the JSR_W bytecode instruction which jumps to subroutine (wide
index). |
class |
L2d
This class maps the L2D bytecode instruction which converts a long
to a double . |
class |
L2f
This class maps the L2F bytecode instruction which converts a long
to a float . |
class |
L2i
This class maps the L2I bytecode instruction which converts a long
to an int . |
class |
LAdd
This class maps the LADD bytecode instruction which adds two long s
took from the operand stack. |
class |
LALoad
This class maps the LALOAD bytecode instruction which loads a long
from the position specified by the first entry of the operand stack of the array referenced by
the second entry of the operand stack. |
class |
LAnd
This class maps the LAND bytecode instruction which performs a bitwise and
operation of the first two long s popped from the operand stack. |
class |
LAStore
This class maps the LASTORE bytecode instruction which stores a long
to an array. |
class |
Lcmp
This class maps the LCMP bytecode instruction which compares the first two
long s popped from thr operand stack. |
class |
LConst_0
This class maps the LCONST_0 bytecode instruction which pushes a 0
long constant onto the operand stack. |
class |
LConst_1
This class maps the LCONST_0 bytecode instruction which pushes a 1
long constant onto the operand stack. |
class |
Ldc
This class maps the LDC bytecode instruction which pushes into the operand stack a
value taken from the runtime constant pool of the current class at the index specified by the
only one argument of the LDC instruction. |
class |
Ldc_W
This class maps the LDC_W bytecode instruction which pushes into the operand stack
a value taken from the runtime constant pool of the current class at the index specified by the
two arguments of the LDC instruction. |
class |
Ldc2_W
This class maps the LDC_2W bytecode instruction which pushes into the operand
stack a long or double taken from the runtime constant pool of the
current class at the index specified by the two arguments of the LDC instruction. |
class |
LDiv
This class maps the LDIV bytecode instruction which divides the second entry of
the operand stack by the first one, and pushes the result back on top of the operand stack. |
class |
LLoad
This class maps the LLOAD bytecode instruction which loads a long
value from a local variable whose index is provided as parameter. |
class |
LLoad_0
This class maps the LLOAD_0 bytecode instruction which loads a long
value from the position 0 of the local variable array of the current frame. |
class |
LLoad_1
This class maps the LLOAD_1 bytecode instruction which loads a long
value from the position 1 of the local variable array of the current frame. |
class |
LLoad_2
This class maps the LLOAD_2 bytecode instruction which loads a long
value from the position 2 of the local variable array of the current frame. |
class |
LLoad_3
This class maps the LLOAD_3 bytecode instruction which loads a long
value from the position 3 of the local variable array of the current frame. |
class |
LMul
This class maps the LMUL bytecode instruction which multiplies the first two
long s popped from the operand stack and pushes back the result. |
class |
LNeg
This class maps the LNEG bytecode instruction which performs the arithmetical
negation of the long popped from the operand stack, and pushes back the result. |
class |
LookupSwitch
This class maps the LOOKUPSWITCH bytecode instruction. |
class |
LOr
This class maps the LOR bytecode instruction which performs the boolean or of the
first two long s popped from the operand stack. |
class |
LRem
This class maps the LREM bytecode instruction which calculates the reminder of the
division of the second entry of the operand stack by the first one. |
class |
LReturn
This class maps the LRETURN bytecode instruction which is used to return an
int from a method. |
class |
LShl
This class maps the LSHL bytecode instruction which shifts left the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
class |
LShr
This class maps the LSHR bytecode instruction which shifts right the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
class |
LStore
This class maps the LSTORE bytecode instruction which stores a long
popped from the operand stack into a local variable whose address points to an entry of the local
variable array of the current frame. |
class |
LStore_0
This class maps the LSTORE_0 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 0. |
class |
LStore_1
This class maps the LSTORE_1 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 1. |
class |
LStore_2
This class maps the LSTORE_2 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 2. |
class |
LStore_3
This class maps the LSTORE_3 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 3. |
class |
LSub
This class maps the LSUB bytecode instruction which subtracts the first value
popped from the operand stack from the second one, and pushes the result back onto the operand
stack. |
class |
Lushr
This class maps the LUSHR bytecode instruction. |
class |
LXOr
This class maps the LXOR bytecode instruction which performs the boolean xor over
the first two values popped from the operand stack. |
class |
MonitorEnter
This class maps the MONITORENTER bytecode instruction which enters monitor for
object. |
class |
MonitorExit
This class maps the MONITOREXIT bytecode instruction which exit monitor for
object. |
class |
MultiANewArray
This class maps the MULTIANEWARRAY bytecode instruction which creates new
multidimensional array. |
class |
New
This class maps the NEW bytecode instruction which is used to instantiate a new
object. |
class |
NewArray
This class maps the NEW bytecode instruction which creates a new array whose
dimension is given by the first value popped from the operand stack. |
class |
Nop
This class maps the NOP bytecode instruction which does nothing. |
class |
Pop
This class maps the POP bytecode instruction which pop the top value from the
operand stack. |
class |
Pop2
This class maps the POP2 bytecode instruction which pop the top one or two values
from the operand stack. |
class |
PutField
This class maps the PUTFIELD bytecode instruction which set field in object. |
class |
PutStatic
This class maps the PUTSTATIC bytecode instruction which set static field in
class. |
class |
Ret
This class maps the RET bytecode instruction which returns from a subruotine. |
class |
Return
This class maps the RETURN bytecode instruction which returns void
from a method. |
class |
SALoad
This class maps the SALOAD bytecode instruction which loads short from array. |
class |
SAStore
This class maps the SASTORE bytecode instruction which stores into short array. |
class |
SiPush
This class maps the SIPUSH bytecode instruction which pushes short. |
class |
Swap
This class maps the SWAP bytecode instruction which swap the top two values on the
operand stack. |
class |
TableSwitch
This class maps the TABLESWITVH bytecode instruction which accesses jump table by
index and jump. |
class |
Wide
This class maps the WIDE bytecode instruction which extends local variable index
by additional bytes. |
Methods in jef.dna.instructions.impl that return Instruction | |
---|---|
Instruction |
InstructionFactory.getInstruction(byte opCode)
This method returns class instances implementing the Instruction interface. |
Instruction |
InstructionFactory.getInstruction(int opCode)
This method returns classe instances implementing the Instruction interface. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES All Classes |