004-JVM指令集（指令码、助记符、功能描述）

一、JVM指令助记符

1)操作数栈

　　变量到操作数栈：iload,iload_,lload,lload_,fload,fload_,dload,dload_,aload,aload_
　　操作数栈到变量：istore,istore_,lstore,lstore_,fstore,fstore_,dstore,dstor_,astore,astore_
　　常数到操作数栈：bipush,sipush,ldc,ldc_w,ldc2_w,aconst_null,iconst_ml,iconst_,lconst_,fconst_,dconst_
　　把数据装载到操作数栈：baload,caload,saload,iaload,laload,faload,daload,aaload
　　从操作数栈存存储到数组：bastore,castore,sastore,iastore,lastore,fastore,dastore,aastore
　　操作数栈管理：pop,pop2,dup,dup2,dup_xl,dup2_xl,dup_x2,dup2_x2,swap

2)运算与转换

　　加：iadd,ladd,fadd,dadd
　　减：is ,ls ,fs ,ds
　　乘：imul,lmul,fmul,dmul
　　除：idiv,ldiv,fdiv,ddiv
　　余数：irem,lrem,frem,drem
　　取负：ineg,lneg,fneg,dneg
　　移位：ishl,lshr,iushr,lshl,lshr,lushr
　　按位或：ior,lor
　　按位与：iand,land
　　按位异或：ixor,lxor
　　类型转换：i2l,i2f,i2d,l2f,l2d,f2d(放宽数值转换)
　　　　i2b,i2c,i2s,l2i,f2i,f2l,d2i,d2l,d2f(缩窄数值转换)

3)条件转移

　　有条件转移：ifeq,iflt,ifle,ifne,ifgt,ifge,ifnull,ifnonnull,if_icmpeq,if_icmpene,
　　　　if_icmplt,if_icmpgt,if_icmple,if_icmpge,if_acmpeq,if_acmpne,lcmp,fcmpl,fcmpg,dcmpl,dcmpg
　　复合条件转移：tableswitch,lookupswitch
　　无条件转移：goto,goto_w,jsr,jsr_w,ret

4)类与数组

　　创建类实便：new
　　创建新数组：newarray,anewarray,multianwarray
　　访问类的域和类实例域：getfield,putfield,getstatic,putstatic
　　获取数组长度：arraylength
　　检相类实例或数组属性：instanceof,checkcast

5)调度与返回加finally

　　调度对象的实便方法：invokevirt l
　　调用由接口实现的方法：invokeinterface
　　调用需要特殊处理的实例方法：invokespecial
　　调用命名类中的静态方法：invokestatic
　　方法返回：ireturn,lreturn,freturn,dreturn,areturn,return
　　异常：athrow
　　finally关键字的实现使用：jsr,jsr_w,ret

二、JVM指令集

原文地址：https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

Mnemonic Opcode
(in hex)		 Opcode (in binary) Other bytes
[count]: [operand labels]		 Stack
[before]→[after]		 Description
nop 00 0000 0000   [No change] perform no operation
aconst_null 01 0000 0001   → null push a null reference onto the stack
iconst_m1 02 0000 0010   → -1 load the int value −1 onto the stack
iconst_0 03 0000 0011   → 0 load the int value 0 onto the stack
iconst_1 04 0000 0100   → 1 load the int value 1 onto the stack
iconst_2 05 0000 0101   → 2 load the int value 2 onto the stack
iconst_3 06 0000 0110   → 3 load the int value 3 onto the stack
iconst_4 07 0000 0111   → 4 load the int value 4 onto the stack
iconst_5 08 0000 1000   → 5 load the int value 5 onto the stack
lconst_0 09 0000 1001   → 0L push 0L (the number zero with type long) onto the stack
lconst_1 0a 0000 1010   → 1L push 1L (the number one with type long) onto the stack
fconst_0 0b 0000 1011   → 0.0f push 0.0f on the stack
fconst_1 0c 0000 1100   → 1.0f push 1.0f on the stack
fconst_2 0d 0000 1101   → 2.0f push 2.0f on the stack
dconst_0 0e 0000 1110   → 0.0 push the constant 0.0 (a double) onto the stack
dconst_1 0f 0000 1111   → 1.0 push the constant 1.0 (a double) onto the stack
bipush 10 0001 0000 1: byte → value push a byte onto the stack as an integer value
sipush 11 0001 0001 2: byte1, byte2 → value push a short onto the stack as an integer value
ldc 12 0001 0010 1: index → value push a constant #index from a constant pool (String, int, float, Class, java.lang.invoke.MethodType, or java.lang.invoke.MethodHandle) onto the stack
ldc_w 13 0001 0011 2: indexbyte1, indexbyte2 → value push a constant #index from a constant pool (String, int, float, Class, java.lang.invoke.MethodType, or java.lang.invoke.MethodHandle) onto the stack (wide index is constructed as indexbyte1 << 8 + indexbyte2)
ldc2_w 14 0001 0100 2: indexbyte1, indexbyte2 → value push a constant #index from a constant pool (double or long) onto the stack (wide index is constructed as indexbyte1 << 8 + indexbyte2)
iload 15 0001 0101 1: index → value load an int value from a local variable #index
lload 16 0001 0110 1: index → value load a long value from a local variable #index
fload 17 0001 0111 1: index → value load a float value from a local variable #index
dload 18 0001 1000 1: index → value load a double value from a local variable #index
aload 19 0001 1001 1: index → objectref load a reference onto the stack from a local variable #index
iload_0 1a 0001 1010   → value load an int value from local variable 0
iload_1 1b 0001 1011   → value load an int value from local variable 1
iload_2 1c 0001 1100   → value load an int value from local variable 2
iload_3 1d 0001 1101   → value load an int value from local variable 3
lload_0 1e 0001 1110   → value load a long value from a local variable 0
lload_1 1f 0001 1111   → value load a long value from a local variable 1
lload_2 20 0010 0000   → value load a long value from a local variable 2
lload_3 21 0010 0001   → value load a long value from a local variable 3
fload_0 22 0010 0010   → value load a float value from local variable 0
fload_1 23 0010 0011   → value load a float value from local variable 1
fload_2 24 0010 0100   → value load a float value from local variable 2
fload_3 25 0010 0101   → value load a float value from local variable 3
dload_0 26 0010 0110   → value load a double from local variable 0
dload_1 27 0010 0111   → value load a double from local variable 1
dload_2 28 0010 1000   → value load a double from local variable 2
dload_3 29 0010 1001   → value load a double from local variable 3
aload_0 2a 0010 1010   → objectref load a reference onto the stack from local variable 0
aload_1 2b 0010 1011   → objectref load a reference onto the stack from local variable 1
aload_2 2c 0010 1100   → objectref load a reference onto the stack from local variable 2
aload_3 2d 0010 1101   → objectref load a reference onto the stack from local variable 3
iaload 2e 0010 1110   arrayref, index → value load an int from an array
laload 2f 0010 1111   arrayref, index → value load a long from an array
faload 30 0011 0000   arrayref, index → value load a float from an array
daload 31 0011 0001   arrayref, index → value load a double from an array
aaload 32 0011 0010   arrayref, index → value load onto the stack a reference from an array
baload 33 0011 0011   arrayref, index → value load a byte or Boolean value from an array
caload 34 0011 0100   arrayref, index → value load a char from an array
saload 35 0011 0101   arrayref, index → value load short from array
istore 36 0011 0110 1: index value → store int value into variable #index
lstore 37 0011 0111 1: index value → store a long value in a local variable #index
fstore 38 0011 1000 1: index value → store a float value into a local variable #index
dstore 39 0011 1001 1: index value → store a double value into a local variable #index
astore 3a 0011 1010 1: index objectref → store a reference into a local variable #index
istore_0 3b 0011 1011   value → store int value into variable 0
istore_1 3c 0011 1100   value → store int value into variable 1
istore_2 3d 0011 1101   value → store int value into variable 2
istore_3 3e 0011 1110   value → store int value into variable 3
lstore_0 3f 0011 1111   value → store a long value in a local variable 0
lstore_1 40 0100 0000   value → store a long value in a local variable 1
lstore_2 41 0100 0001   value → store a long value in a local variable 2
lstore_3 42 0100 0010   value → store a long value in a local variable 3
fstore_0 43 0100 0011   value → store a float value into local variable 0
fstore_1 44 0100 0100   value → store a float value into local variable 1
fstore_2 45 0100 0101   value → store a float value into local variable 2
fstore_3 46 0100 0110   value → store a float value into local variable 3
dstore_0 47 0100 0111   value → store a double into local variable 0
dstore_1 48 0100 1000   value → store a double into local variable 1
dstore_2 49 0100 1001   value → store a double into local variable 2
dstore_3 4a 0100 1010   value → store a double into local variable 3
astore_0 4b 0100 1011   objectref → store a reference into local variable 0
astore_1 4c 0100 1100   objectref → store a reference into local variable 1
astore_2 4d 0100 1101   objectref → store a reference into local variable 2
astore_3 4e 0100 1110   objectref → store a reference into local variable 3
iastore 4f 0100 1111   arrayref, index, value → store an int into an array
lastore 50 0101 0000   arrayref, index, value → store a long to an array
fastore 51 0101 0001   arrayref, index, value → store a float in an array
dastore 52 0101 0010   arrayref, index, value → store a double into an array
aastore 53 0101 0011   arrayref, index, value → store into a reference in an array
bastore 54 0101 0100   arrayref, index, value → store a byte or Boolean value into an array
castore 55 0101 0101   arrayref, index, value → store a char into an array
sastore 56 0101 0110   arrayref, index, value → store short to array
pop 57 0101 0111   value → discard the top value on the stack
pop2 58 0101 1000   {value2, value1} → discard the top two values on the stack (or one value, if it is a double or long)
dup 59 0101 1001   value → value, value duplicate the value on top of the stack
dup_x1 5a 0101 1010   value2, value1 → value1, value2, value1 insert a copy of the top value into the stack two values from the top. value1 and value2 must not be of the type double or long.
dup_x2 5b 0101 1011   value3, value2, value1 → value1, value3, value2, value1 insert a copy of the top value into the stack two (if value2 is double or long it takes up the entry of value3, too) or three values (if value2 is neither double nor long) from the top
dup2 5c 0101 1100   {value2, value1} → {value2, value1}, {value2, value1} duplicate top two stack words (two values, if value1 is not double nor long; a single value, if value1 is double or long)
dup2_x1 5d 0101 1101   value3, {value2, value1} → {value2, value1}, value3, {value2, value1} duplicate two words and insert beneath third word (see explanation above)
dup2_x2 5e 0101 1110   {value4, value3}, {value2, value1} → {value2, value1}, {value4, value3}, {value2, value1} duplicate two words and insert beneath fourth word
swap 5f 0101 1111   value2, value1 → value1, value2 swaps two top words on the stack (note that value1 and value2 must not be double or long)
iadd 60 0110 0000   value1, value2 → result add two ints
ladd 61 0110 0001   value1, value2 → result add two longs
fadd 62 0110 0010   value1, value2 → result add two floats
dadd 63 0110 0011   value1, value2 → result add two doubles
isub 64 0110 0100   value1, value2 → result int subtract
lsub 65 0110 0101   value1, value2 → result subtract two longs
fsub 66 0110 0110   value1, value2 → result subtract two floats
dsub 67 0110 0111   value1, value2 → result subtract a double from another
imul 68 0110 1000   value1, value2 → result multiply two integers
lmul 69 0110 1001   value1, value2 → result multiply two longs
fmul 6a 0110 1010   value1, value2 → result multiply two floats
dmul 6b 0110 1011   value1, value2 → result multiply two doubles
idiv 6c 0110 1100   value1, value2 → result divide two integers
ldiv 6d 0110 1101   value1, value2 → result divide two longs
fdiv 6e 0110 1110   value1, value2 → result divide two floats
ddiv 6f 0110 1111   value1, value2 → result divide two doubles
irem 70 0111 0000   value1, value2 → result logical int remainder
lrem 71 0111 0001   value1, value2 → result remainder of division of two longs
frem 72 0111 0010   value1, value2 → result get the remainder from a division between two floats
drem 73 0111 0011   value1, value2 → result get the remainder from a division between two doubles
ineg 74 0111 0100   value → result negate int
lneg 75 0111 0101   value → result negate a long
fneg 76 0111 0110   value → result negate a float
dneg 77 0111 0111   value → result negate a double
ishl 78 0111 1000   value1, value2 → result int shift left
lshl 79 0111 1001   value1, value2 → result bitwise shift left of a long value1 by int value2 positions
ishr 7a 0111 1010   value1, value2 → result int arithmetic shift right
lshr 7b 0111 1011   value1, value2 → result bitwise shift right of a long value1 by int value2 positions
iushr 7c 0111 1100   value1, value2 → result int logical shift right
lushr 7d 0111 1101   value1, value2 → result bitwise shift right of a long value1 by int value2 positions, unsigned
iand 7e 0111 1110   value1, value2 → result perform a bitwise AND on two integers
land 7f 0111 1111   value1, value2 → result bitwise AND of two longs
ior 80 1000 0000   value1, value2 → result bitwise int OR
lor 81 1000 0001   value1, value2 → result bitwise OR of two longs
ixor 82 1000 0010   value1, value2 → result int xor
lxor 83 1000 0011   value1, value2 → result bitwise XOR of two longs
iinc 84 1000 0100 2: index, const [No change] increment local variable #index by signed byte const
i2l 85 1000 0101   value → result convert an int into a long
i2f 86 1000 0110   value → result convert an int into a float
i2d 87 1000 0111   value → result convert an int into a double
l2i 88 1000 1000   value → result convert a long to a int
l2f 89 1000 1001   value → result convert a long to a float
l2d 8a 1000 1010   value → result convert a long to a double
f2i 8b 1000 1011   value → result convert a float to an int
f2l 8c 1000 1100   value → result convert a float to a long
f2d 8d 1000 1101   value → result convert a float to a double
d2i 8e 1000 1110   value → result convert a double to an int
d2l 8f 1000 1111   value → result convert a double to a long
d2f 90 1001 0000   value → result convert a double to a float
i2b 91 1001 0001   value → result convert an int into a byte
i2c 92 1001 0010   value → result convert an int into a character
i2s 93 1001 0011   value → result convert an int into a short
lcmp 94 1001 0100   value1, value2 → result push 0 if the two longs are the same, 1 if value1 is greater than value2, -1 otherwise
fcmpl 95 1001 0101   value1, value2 → result compare two floats
fcmpg 96 1001 0110   value1, value2 → result compare two floats
dcmpl 97 1001 0111   value1, value2 → result compare two doubles
dcmpg 98 1001 1000   value1, value2 → result compare two doubles
ifeq 99 1001 1001 2: branchbyte1, branchbyte2 value → if value is 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
ifne 9a 1001 1010 2: branchbyte1, branchbyte2 value → if value is not 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
iflt 9b 1001 1011 2: branchbyte1, branchbyte2 value → if value is less than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
ifge 9c 1001 1100 2: branchbyte1, branchbyte2 value → if value is greater than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
ifgt 9d 1001 1101 2: branchbyte1, branchbyte2 value → if value is greater than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
ifle 9e 1001 1110 2: branchbyte1, branchbyte2 value → if value is less than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_icmpeq 9f 1001 1111 2: branchbyte1, branchbyte2 value1, value2 → if ints are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_icmpne a0 1010 0000 2: branchbyte1, branchbyte2 value1, value2 → if ints are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_icmplt a1 1010 0001 2: branchbyte1, branchbyte2 value1, value2 → if value1 is less than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_icmpge a2 1010 0010 2: branchbyte1, branchbyte2 value1, value2 → if value1 is greater than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_icmpgt a3 1010 0011 2: branchbyte1, branchbyte2 value1, value2 → if value1 is greater than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_icmple a4 1010 0100 2: branchbyte1, branchbyte2 value1, value2 → if value1 is less than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_acmpeq a5 1010 0101 2: branchbyte1, branchbyte2 value1, value2 → if references are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
if_acmpne a6 1010 0110 2: branchbyte1, branchbyte2 value1, value2 → if references are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
goto a7 1010 0111 2: branchbyte1, branchbyte2 [no change] goes to another instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
jsr a8 1010 1000 2: branchbyte1, branchbyte2 → address jump to subroutine at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2) and place the return address on the stack
ret a9 1010 1001 1: index [No change] continue execution from address taken from a local variable #index (the asymmetry with jsr is intentional)
tableswitch aa 1010 1010 16+: [0–3 bytes padding], defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, lowbyte1, lowbyte2, lowbyte3, lowbyte4, highbyte1, highbyte2, highbyte3, highbyte4, jump offsets... index → continue execution from an address in the table at offset index
lookupswitch ab 1010 1011 8+: <0–3 bytes padding>, defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, npairs1, npairs2, npairs3, npairs4, match-offset pairs... key → a target address is looked up from a table using a key and execution continues from the instruction at that address
ireturn ac 1010 1100   value → [empty] return an integer from a method
lreturn ad 1010 1101   value → [empty] return a long value
freturn ae 1010 1110   value → [empty] return a float
dreturn af 1010 1111   value → [empty] return a double from a method
areturn b0 1011 0000   objectref → [empty] return a reference from a method
return b1 1011 0001   → [empty] return void from method
getstatic b2 1011 0010 2: indexbyte1, indexbyte2 → value get a static field value of a class, where the field is identified by field reference in the constant pool index (indexbyte1 << 8 + indexbyte2)
putstatic b3 1011 0011 2: indexbyte1, indexbyte2 value → set static field to value in a class, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 + indexbyte2)
getfield b4 1011 0100 2: indexbyte1, indexbyte2 objectref → value get a field value of an object objectref, where the field is identified by field reference in the constant pool index (indexbyte1 << 8 + indexbyte2)
putfield b5 1011 0101 2: indexbyte1, indexbyte2 objectref, value → set field to value in an object objectref, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 + indexbyte2)
invokevirtual b6 1011 0110 2: indexbyte1, indexbyte2 objectref, [arg1, arg2, ...] → result invoke virtual method on object objectref and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
invokespecial b7 1011 0111 2: indexbyte1, indexbyte2 objectref, [arg1, arg2, ...] → result invoke instance method on object objectref and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
invokestatic b8 1011 1000 2: indexbyte1, indexbyte2 [arg1, arg2, ...] → result invoke a static method and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
invokeinterface b9 1011 1001 4: indexbyte1, indexbyte2, count, 0 objectref, [arg1, arg2, ...] → result invokes an interface method on object objectref and puts the result on the stack (might be void); the interface method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
invokedynamic ba 1011 1010 4: indexbyte1, indexbyte2, 0, 0 [arg1, [arg2 ...]] → result invokes a dynamic method and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
new bb 1011 1011 2: indexbyte1, indexbyte2 → objectref create new object of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2)
newarray bc 1011 1100 1: atype count → arrayref create new array with count elements of primitive type identified by atype
anewarray bd 1011 1101 2: indexbyte1, indexbyte2 count → arrayref create a new array of references of length count and component type identified by the class reference index (indexbyte1 << 8 + indexbyte2) in the constant pool
arraylength be 1011 1110   arrayref → length get the length of an array
athrow bf 1011 1111   objectref → [empty], objectref throws an error or exception (notice that the rest of the stack is cleared, leaving only a reference to the Throwable)
checkcast c0 1100 0000 2: indexbyte1, indexbyte2 objectref → objectref checks whether an objectref is of a certain type, the class reference of which is in the constant pool at index (indexbyte1 << 8 + indexbyte2)
instanceof c1 1100 0001 2: indexbyte1, indexbyte2 objectref → result determines if an object objectref is of a given type, identified by class reference index in constant pool (indexbyte1 << 8 + indexbyte2)
monitorenter c2 1100 0010   objectref → enter monitor for object ("grab the lock" – start of synchronized() section)
monitorexit c3 1100 0011   objectref → exit monitor for object ("release the lock" – end of synchronized() section)
wide c4 1100 0100 3/5: opcode, indexbyte1, indexbyte2
or
iinc, indexbyte1, indexbyte2, countbyte1, countbyte2		 [same as for corresponding instructions] execute opcode, where opcode is either iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore, or ret, but assume the index is 16 bit; or execute iinc, where the index is 16 bits and the constant to increment by is a signed 16 bit short
multianewarray c5 1100 0101 3: indexbyte1, indexbyte2, dimensions count1, [count2,...] → arrayref create a new array of dimensions dimensions of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2); the sizes of each dimension is identified by count1, [count2, etc.]
ifnull c6 1100 0110 2: branchbyte1, branchbyte2 value → if value is null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
ifnonnull c7 1100 0111 2: branchbyte1, branchbyte2 value → if value is not null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
goto_w c8 1100 1000 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 [no change] goes to another instruction at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4)
jsr_w c9 1100 1001 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 → address jump to subroutine at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4) and place the return address on the stack
breakpoint ca 1100 1010     reserved for breakpoints in Java debuggers; should not appear in any class file
(no name) cb-fd       these values are currently unassigned for opcodes and are reserved for future use
impdep1 fe 1111 1110     reserved for implementation-dependent operations within debuggers; should not appear in any class file
impdep2 ff 1111 1111     reserved for implementation-dependent operations within debuggers; should not appear in any class file

原文地址：https://www.cnblogs.com/bjlhx/p/8856297.html

时间： 2024-10-03 22:38:35

004-JVM指令集（指令码、助记符、功能描述）的相关文章

JVM指令集（指令码、助记符、功能描述）（转）

JVM指令集(指令码.助记符.功能描述) 指令码 助记符 功能描述 0x00 nop 无操作 0x01 aconst_null 指令格式:  aconst_null 功能描述:  null进栈. 指令执行前 指令执行后 栈底 ... ... null 栈顶 注意:JVM并没有为null指派一个具体的值. 0x02 iconst_m1 int型常量值-1进栈 0x03 iconst_0 int型常量值0进栈 0x04 iconst_1 int型常量值1进栈 0x05 iconst_2 int型常量

JVM指令助记符

以下只是JVM指令助记符,关于JVM指令的详细内容请阅读<JVM指令详解> 变量到操作数栈:iload,iload_,lload,lload_,fload,fload_,dload,dload_,aload,aload_ 操作数栈到变量:istore,istore_,lstore,lstore_,fstore,fstore_,dstore,dstore_,astore,astore_ 常数到操作数栈:bipush,sipush,ldc,ldc_w,ldc2_w,aconst_null,icon

JVM 指令集

指令码 助记符 说明 0x00 nop 什么都不做 0x01 aconst_null 将null推送至栈顶 0x02 iconst_m1 将int型-1推送至栈顶 0x03 iconst_0 将int型0推送至栈顶 0x04 iconst_1 将int型1推送至栈顶 0x05 iconst_2 将int型2推送至栈顶 0x06 iconst_3 将int型3推送至栈顶 0x07 iconst_4 将int型4推送至栈顶 0x08 iconst_5 将int型5推送至栈顶 0x09 lconst_

JVM指令集

指令码 助记符 说明0x00 nop 什么都不做0x01 aconst_null 将null推送至栈顶0x02 iconst_m1 将int型-1推送至栈顶0x03 iconst_0 将int型0推送至栈顶0x04 iconst_1 将int型1推送至栈顶0x05 iconst_2 将int型2推送至栈顶0x06 iconst_3 将int型3推送至栈顶0x07 iconst_4 将int型4推送至栈顶0x08 iconst_5 将int型5推送至栈顶0x09 lconst_0 将long型0推

【分支结构】Jcc 的一些助记

eax > ebx OF=0 SF=0 ZF=0 AF=0 PF=0 CF=0 eax = ebx OF=0 SF=0 ZF=1 AF=0 PF=1 CF=0 eax < ebx OF=0 SF=1 ZF=0 AF=1 PF=1 CF=1 其中,重点看CF.ZF.( SF 和 OF) Jcc 的指令关于五个状态标志的十种状态分别有十种指令与之对应,如下所示: 标志 状态 指令 说明 ZF ZF=1 JZ 相等/等于零 ZF=0 JNZ ---- SF SF=1 JS 符号为负 SF=0 JNS

1.16. BIP39协议:使用助记词生成确定性钱包

以太坊系统学习教程: https://www.netkiller.cn/blockchain/bip39.html BIP:39 层:应用层 标题:使用助记词生成确定性钱包秘钥 作者:Marek Palatinus [email protected] Pavol Rusnak [email protected] Aaron Voisine [email protected] Sean Bowe [email protected] 状态:已经被提议 类型:标准化跟踪 创建日期:2013-09-10

管道和过滤器模式----POSA模式助记格式

名称:管道和过滤器(Pipes and Filters) 问题: 处理数据流 1.步骤可替换 2.步骤比组件更易于重用 3.不相连的步骤不共享信息 4.存在不同的输入数据源 5.可以以多种方式给出或存放输出结果 6.中间结果需要落地,以确保处理的正确性 7.暂不取消多重步骤(并发) 方案: 管道和过滤器模式----POSA模式助记格式,布布扣,bubuko.com

层(layer)模式----POSA模式助记格式

名称:层(layer) 问题: 需要分解的大系统 1.修改应被限制在组件内,即通用和专用分离 2.接口稳定 3.系统各个部分要可替换 4.低层平台可复用,比如用于其他应用 5.相似职责需要进行分组,以提高可理解性和可维护性.足够内聚的,才易分组. 6.组件粒度,无标准 7.复杂组件可进一步分解 8.数据在组件接口间传递,可能影响性能 9.系统由一组程序员完成,工作界限要求清楚 方案: 层(layer)模式----POSA模式助记格式

汉字助记码，你会了吗？

汉字助记码,你会了吗? 在编程中,我们经常会遇到汉字助记码的问题,笔者曾经为此多次发愁,现总结前辈的好东西,记录于此,希望能帮助到您,方法有多种,在此比较几种方案,简单剖析一下. 首先说明,什么是汉字助记码?所谓的汉字助记码就是一个汉字的拼音的首字母,如:张的汉字助记码为Z,湖北中医药大学的助记码为HBZYYDX.下面通过程序用三种方法实现: 方法一:表获取方法; 表内容大致说明:       实现核心代码--SQL标量值函数: 1 -------------------------------