java 字节码指令

转：http://blog.csdn.net/coslay/article/details/43131645

字节码格式

字节码是JVM的机器语言。JVM加载类文件时，对类中的每个方法，它都会得到一个字节码流。这些字节码流保存在JVM的方法区中。在程序运行过程中，当一个方法被调用时，它的字节码流就会被执行。根据特定JVM设计者的选择，它们可以通过解释的方式，即时编译（Just-in-time compilation）的方式或其他技术的方式被执行。

方法的字节码流就是JVM的指令（instruction）序列。每条指令包含一个单字节的操作码（opcode）和0个或多个操作数（operand）。操作码指明要执行的操作。如果JVM在执行操作前，需要更多的信息，这些信息会以0个或多个操作数的方式，紧跟在操作码的后面。

每种类型的操作码都有一个助记符（mnemonic）。类似典型的汇编语言风格，Java字节码流可以用它们的助记符和紧跟在后面的操作数来表示。例如，下面的字节码流可以分解成多个助记符的形式。

1. // 字节码流:  03 3b  84  00  01 1a  05  68 3b a7 ff f9
2. // 分解后:
3. iconst_0      //  03
4. istore_0      // 3b
5. iinc  0,  1     //  84  00  01
6. iload_0       // 1a
7. iconst_2      //  05
8. imul          //  68
9. istore_0      // 3b
10. goto  -7       // a7 ff f9

字节码指令集被设计的很紧凑。除了处理跳表的2条指令以外，所有的指令都以字节边界对齐。操作码的总数很少，一个字节就能搞定。这最小化了JVM加载前，通过网络传输的类文件的大小；也使得JVM可以维持很小的实现。

JVM中，所有的计算都是围绕栈（stack）而展开的。因为JVM没有存储任意数值的寄存器（register），所有的操作数在计算开始之前，都必须先压入栈中。因此，字节码指令主要是用来操作栈的。例如，在上面的字节码序列中，通过iload_0先把本地变量（local variable）入栈，然后用iconst_2把数字2入栈的方式，来计算本地变量乘以2。两个整数都入栈之后，imul指令有效的从栈中弹出它们，然后做乘法，最后把运算结果压入栈中。istore_0指令把结果从栈顶弹出，保存回本地变量。JVM被设计成基于栈，而不是寄存器的机器，这使得它在如80486寄存器架构不佳的处理器上，也能被高效的实现。

原始类型（primitive types）

JVM支持7种原始数据类型。Java程序员可以声明和使用这些数据类型的变量，而Java字节码，处理这些数据类型。下表列出了这7种原始数据类型：

类型	定义
byte	单字节有符号二进制补码整数
short	2字节有符号二进制补码整数
int	4字节有符号二进制补码整数
long	8字节有符号二进制补码整数
float	4字节IEEE 754单精度浮点数
double	8字节IEEE 754双精度浮点数
char	2字节无符号Unicode字符

原始数据类型以操作数的方式出现在字节码流中。所有长度超过1字节的原始类型，都以大端（big-endian）的方式保存在字节码流中，这意味着高位字节出现在低位字节之前。例如，为了把常量值256（0x0100）压入栈中，你可以用sipush操作码，后跟一个短操作数。短操作数会以“01 00”的方式出现在字节码流中，因为JVM是大端的。如果JVM是小端（little-endian）的，短操作数将会是“00 01”。

1. // Bytecode stream:  17  01  00
2. // Dissassembly:
3. sipush  256;      //  17  01  00

把常量（constants）压入栈中

很多操作码都可以把常量压入栈中。操作码以3中不同的方式指定入栈的常量值：由操作码隐式指明，作为操作数跟在操作码之后，或者从常量池（constant pool）中获取。

有些操作码本身就指明了要入栈的数据类型和常量数值。例如，iconst_1告诉JVM把整数1压入栈中。这种操作码，是为不同类型而经常入栈的数值而定义的。它们在字节码流中只占用1个字节，增进了字节码的执行效率，并减小了字节码流的大小。下表列出了int型和float型的操作码：

操作码	操作数	描述
iconst_m1	(none)	pushes int -1 onto the stack
iconst_0	(none)	pushes int 0 onto the stack
iconst_1	(none)	pushes int 1 onto the stack
iconst_2	(none)	pushes int 2 onto the stack
iconst_3	(none)	pushes int 3 onto the stack
iconst_4	(none)	pushes int 4 onto the stack
iconst_5	(none)	pushes int 5 onto the stack
fconst_0	(none)	pushes float 0 onto the stack
fconst_1	(none)	pushes float 1 onto the stack
fconst_2	(none)	pushes float 2 onto the stack

下面列出的操作码处理的int型和float型都是32位的值。Java栈单元（slot）是32位宽的，因此，每次一个int数和float数入栈，它都占用一个单元。下表列出的操作码处理long型和double型。long型和double型的数值占用64位。每次一个long数或double数被压入栈中，它都占用2个栈单元。下面的表格，列出了隐含处理long型和double型的操作码

操作码	操作数	描述
lconst_0	(none)	pushes long 0 onto the stack
lconst_1	(none)	pushes long 1 onto the stack
dconst_0	(none)	pushes double 0 onto the stack
dconst_1	(none)	pushes double 1 onto the stack

另外还有一个隐含入栈常量值的操作码，aconst_null，它把空对象（null object）的引用（reference）压入栈中。对象引用的格式取决于JVM实现。对象引用指向垃圾收集堆（garbage-collected heap）中的对象。空对象引用，意味着一个变量当前没有指向任何合法对象。aconst_null操作码用在给引用变量赋null值的时候。

操作码	操作数	描述
aconst_null	(none)	pushes a null object reference onto the stack

有2个操作码需要紧跟一个操作数来指明入栈的常量值。下表列出的操作码，用来把合法的byte型和short型的常量值压入栈中。byte型或short型的值在入栈之前，先被扩展成int型的值，因为栈单元是32位宽的。对byte型和short型的操作，实际上是基于它们扩展后的int型值的。

操作码	操作数	描述
bipush	byte1	expands byte1 (a byte type) to an int and pushes it onto the stack
sipush	byte1, byte2	expands byte1, byte2 (a short type) to an int and pushes it onto the stack

有3个操作码把常量池中的常量值压入栈中。所有和类关联的常量，如final变量，都被保存在类的常量池中。把常量池中的常量压入栈中的操作码，都有一个操作数，它表示需要入栈的常量在常量池中的索引。JVM会根据索引查找常量，确定它的类型，并把它压入栈中。

在字节码流中，常量池索引（constant pool index）是一个紧跟在操作码后的无符号值。操作码lcd1和lcd2把32位的项压入栈中，如int或float。两者的区别在于lcd1只适用于1-255的常量池索引位，因为它的索引只有1个字节。（常量池0号位未被使用。）lcd2的索引有2个字节，所以它可以适用于常量池的任意位置。lcd2w也有一个2字节的索引，它被用来指示任意含有64位的long或double型数据的常量池位置。下表列出了把常量池中的常量压入栈中的操作码：

操作码	操作数	描述
ldc1	indexbyte1	pushes 32-bit constant_pool entry specified by indexbyte1 onto the stack
ldc2	indexbyte1, indexbyte2	pushes 32-bit constant_pool entry specified by indexbyte1, indexbyte2 onto the stack
ldc2w	indexbyte1, indexbyte2	pushes 64-bit constant_pool entry specified by indexbyte1,indexbyte2 onto the stack

把局部变量（local variables）压入栈中

局部变量保存在栈帧的一个特殊区域中。栈帧是当前执行方法正在使用的栈区。每个栈帧包含3个部分：本地变量区，执行环境和操作数栈区。把本地变量入栈实际上包含了把数值从栈帧的本地变量区移动到操作数栈区。操作数栈区总是在栈的顶部，所以，把一个值压到当前栈帧的操作数栈区顶部，跟压到整个JVM栈的顶部是一个意思。

Java栈是一个先进后出（LIFO）的32位宽的栈。所有的本地变量至少占用32位，因为栈中的每个单元都是32位宽的。像long和double类型的64位的本地变量会占用2个栈单元。byte和short型的本地变量会当做int型来存储，但只拥有较小类型的合法值。例如，表示byte型的int型本地变量取值范围总是-128到127。

每个本地变量都有一个唯一索引。方法栈帧的本地变量区，可以当成是一个拥有32位宽的元素的数组，每个元素都可以用数组索引来寻址。long和double型的占用2个单元的本地变量，且用低位元素的索引寻址。例如，对一个占用2单元和3单元的double数值，会用索引2来引用。

有一些操作码可以把int和float型本地变量压入操作数栈。部分操作码，定义成隐含常用本地变量地址的引用。例如，iload_0加载处在位置0的int型本地变量。其他本地变量，通过操作码后跟一个字节的本地变量索引的方式压入栈中。iload指令就是这种操作码类型的一个例子。iload后的一个字节被解释成指向本地变量的8位无符号索引。

类似iload所用的8位无符号本地变量索引，限制了一个方法最多只能有256个本地变量。有一个单独的wide指令可以把8位索引扩展为16位索引，则使得本地变量数的上限提高到64k个。操作码wide只有1个操作数。wide和它的操作数，出现在像iload之类的有一个8位无符号本地变量索引的指令之前。JVM会把wide的操作数和iload的操作数合并为一个16位的无符号本地变量索引。

下表列出了把int和float型本地变量压入栈中的操作码：

操作码	操作数	描述
iload	vindex	pushes int from local variable position vindex
iload_0	(none)	pushes int from local variable position zero
iload_1	(none)	pushes int from local variable position one
iload_2	(none)	pushes int from local variable position two
iload_3	(none)	pushes int from local variable position three
fload	vindex	pushes float from local variable position vindex
fload_0	(none)	pushes float from local variable position zero
fload_1	(none)	pushes float from local variable position one
fload_2	(none)	pushes float from local variable position two
fload_3	(none)	pushes float from local variable position three

接下来的这张表，列出了把long和double型本地变量压入栈中的指令。这些指令把64位的数从栈帧的本地变量区移动到操作数区。

操作码	操作数	描述
lload	vindex	pushes long from local variable positions vindex and (vindex + 1)
lload_0	(none)	pushes long from local variable positions zero and one
lload_1	(none)	pushes long from local variable positions one and two
lload_2	(none)	pushes long from local variable positions two and three
lload_3	(none)	pushes long from local variable positions three and four
dload	vindex	pushes double from local variable positions vindex and (vindex + 1)
dload_0	(none)	pushes double from local variable positions zero and one
dload_1	(none)	pushes double from local variable positions one and two
dload_2	(none)	pushes double from local variable positions two and three
dload_3	(none)	pushes double from local variable positions three and four

最后一组操作码，把32位的对象引用从栈帧的本地变量区移动到操作数区。如下表：

操作码	操作数	描述
aload	vindex	pushes object reference from local variable position vindex
aload_0	(none)	pushes object reference from local variable position zero
aload_1	(none)	pushes object reference from local variable position one
aload_2	(none)	pushes object reference from local variable position two
aload_3	(none)	pushes object reference from local variable position three

弹出到本地变量

每一个将局部变量压入栈中的操作码，都有一个对应的负责弹出栈顶元素到本地变量中的操作码。这些操作码的名字可以通过替换入栈操作码名中的“load”为“store”得到。下表列出了将int和float型数值弹出操作数栈到本地变量中的操作码。这些操作码将一个32位的值从栈顶移动到本地变量中。

操作码	操作数	描述
istore	vindex	pops int to local variable position vindex
istore_0	(none)	pops int to local variable position zero
istore_1	(none)	pops int to local variable position one
istore_2	(none)	pops int to local variable position two
istore_3	(none)	pops int to local variable position three
fstore	vindex	pops float to local variable position vindex
fstore_0	(none)	pops float to local variable position zero
fstore_1	(none)	pops float to local variable position one
fstore_2	(none)	pops float to local variable position two
fstore_3	(none)	pops float to local variable position three

下一张表中，展示了负责将long和double类型数值出栈并存到局部变量的字节码指令，这些指令将64位的值从操作数栈顶移动到本地变量中。

操作码	操作数	描述
lstore	vindex	pops long to local variable positions vindex and (vindex + 1)
lstore_0	(none)	pops long to local variable positions zero and one
lstore_1	(none)	pops long to local variable positions one and two
lstore_2	(none)	pops long to local variable positions two and three
lstore_3	(none)	pops long to local variable positions three and four
dstore	vindex	pops double to local variable positions vindex and (vindex + 1)
dstore_0	(none)	pops double to local variable positions zero and one
dstore_1	(none)	pops double to local variable positions one and two
dstore_2	(none)	pops double to local variable positions two and three
dstore_3	(none)	pops double to local variable positions three and four

最后一组操作码，负责将32位的对象引用从操作数栈顶移动到本地变量中。

操作码	操作数	描述
astore	vindex	pops object reference to local variable position vindex
astore_0	(none)	pops object reference to local variable position zero
astore_1	(none)	pops object reference to local variable position one
astore_2	(none)	pops object reference to local variable position two
astore_3	(none)	pops object reference to local variable position three

类型转换

JVM中有一些操作码用来将一种基本类型的数值转换成另外一种。字节码流中的转换操作码后面不跟操作数，被转换的值取自栈顶。JVM弹出栈顶的值，转换后再将结果压入栈中。下表列出了在int，long，float和double间转换的操作码。这四种类型组合的每一个可能的转换，都有一个对应的操作码。

操作码	操作数	描述
i2l	(none)	converts int to long
i2f	(none)	converts int to float
i2d	(none)	converts int to double
l2i	(none)	converts long to int
l2f	(none)	converts long to float
l2d	(none)	converts long to double
f2i	(none)	converts float to int
f2l	(none)	converts float to long
f2d	(none)	converts float to double
d2i	(none)	converts double to int
d2l	(none)	converts double to long
d2f	(none)	converts double to float

下表列出了将int型转换为更小类型的操作码。不存在直接将long，float，double型转换为比int型小的类型的操作码。因此，像float到byte这样的转换，需要两步。第一步，f2i将float转换为int，第二步，int2byte操作码将int转换为byte。

操作码	操作数	描述
int2byte	(none)	converts int to byte
int2char	(none)	converts int to char
int2short	(none)	converts int to short

虽然存在将int转换为更小类型（byte，short，char）的操作码，但是不存在反向转换的操作码。这是因为byte，short和char型的数值在入栈之前会转换成int型。byte，short和char型数值的算术运算，首先要将这些类型的值转为int，然后执行算术运算，最后得到int型结果。也就是说，如果两个byte型的数相加，会得到一个int型的结果，如果你想要byte型的结果，你必须显式地将int类型的结果转换为byte类型的值。例如，下面的代码编译出错：

1. class BadArithmetic  {
2.      byte addOneAndOne ( )  {
3.          byte a =  1 ;
4.          byte b =  1 ;
5.          byte c = a + b ;
6.          return c ;
7.      }
8. }

javac会对上面的代码给出如下错误：

1. BadArithmetic.java ( 7 ): Incompatible type  for declaration.
2. Explicit cast needed to convert int to byte.
3.                 byte c = a + b;
4.                      ^

Java程序员必须显式的把a + b的结果转换为byte，这样才能通过编译。

1. class GoodArithmetic  {
2.      byte addOneAndOne ( )  {
3.          byte a =  1 ;
4.          byte b =  1 ;
5.          byte c =  ( byte )  (a + b ) ;
6.          return c ;
7.      }
8. }

这样，javac会很高兴的生成GoodArithmetic.class文件，它包含如下的addOneAndOne()方法的字节码序列：

1. iconst_1  // Push int constant  1.
2. istore_1  // Pop into local variable  1, which is a: byte a =  1;
3. iconst_1  // Push int constant  1 again.
4. istore_2  // Pop into local variable  2, which is b: byte b =  1;
5. iload_1   // Push a  (a is already stored as an int  in local variable  1 ).
6. iload_2   // Push b  (b is already stored as an int  in local variable  2 ).
7. iadd      // Perform addition. Top of stack is now  (a + b ), an int.
8. int2byte  // Convert int result to byte  (result still occupies  32 bits ).
9. istore_3  // Pop into local variable  3, which is byte c: byte c =  (byte )  (a + b );
10. iload_3   // Push the value of c so it can be returned.
11. ireturn   // Proudly return the result of the addition: return c;

本文译自：Bytecode basics

转载自：http://iofree.cc/%E5%AD%97%E8%8A%82%E7%A0%81%E5%9F%BA%E7%A1%80%EF%BC%9Ajvm%E5%AD%97%E8%8A%82%E7%A0%81%E5%88%9D%E6%8E%A2/

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