【深入理解JVM】JVM字节码指令集

Myth丶恋晨 2022-08-21 03:26 296阅读 0赞

**Java 虚拟机的指令由一个字节长度的、代表着某种特定操作含义的操作码（Opcode）以及跟随其后的零至多个代表此操作所需参数的操作数（Operands）所构成**。虚拟机中许多指令并不包含操作数，只有一个操作码。

如果忽略异常处理，那 Java 虚拟机的解释器使用下面这个伪代码的循环即可有效地工作：

do{
     自动计算PC寄存器以及从PC寄存器的位置取出操作码;
     if(存在操作数)取出操作数;
     执行操作码所定义的操作
    }while(处理下一次循环);

操作数的数量以及长度取决于操作码，如果一个操作数的长度超过了一个字节，那它将会以 Big-Endian 顺序存储——即高位在前的字节序。举个例子，如果要将一个 16 位长度的无符号整数使用两个无符号字节存储起来（将它们命名为 byte1 和 byte2），那它们的值应该是这样的：

(byte1<<8)|byte2

字节码指令流应当都是单字节对齐的，只有“tableswitch”和“lookupswitch”两条指令例外，由于它们的操作数比较特殊，都是以 4 字节为界划分开的，所以这两条指令那个也需要预留出相应的空位来实现对齐。

限制 Java 虚拟机操作码的长度为一个字节，并且放弃了编译后代码的参数长度对齐，是为了尽可能地获得短小精干的编译代码，即使这可能会让 Java 虚拟机的具体实现付出一定的性能成本为代价。由于每个操作码只能有一个字节长度，所以直接限制了整个指令集的数量 （字节码无法超过 256 条的限制就来源于此） ，又由于没有假设数据是对齐好的，这就意味着虚拟机处理那些超过一个字节的数据的时候，不得不在运行时从字节中重建出具体数据的结构，这在某种程度上会损失一些性能。

#### **1、数据类型与Java虚拟机** ####

在 Java 虚拟机的指令集中，大多数的指令都包含了其操作所对应的数据类型信息。举个例子，iload 指令用于从局部变量表中加载 int 型的数据到操作数栈中，而 fload 指令加载的则是 float 类型的数据。这两条指令的操作可能会是由同一段代码来实现的，但它们必须拥有各自独立的操作符。

对于大部分为与数据类型相关的字节码指令，他们的操作码助记符中都有特殊的字符来表明专门为哪种数据类型服务：i 代表对 int 类型的数据操作，l 代表 long，s 代表 short，b 代表 byte，c 代表 char，f 代表 float，d 代表 double，a 代表 reference。也有一些指令的助记符中没有明确的指明操作类型的字母，例如 arraylength 指令，它没有代表数据类型的特殊字符，但操作数永远只能是一个数组类型的对象。还有另外一些指令，例如无条件跳转指令 goto 则是与数据类型无关的。

由于 Java 虚拟机的操作码长度只有一个字节，所以包含了数据类型的操作码对指令集的设计带来了很大的压力：如果每一种与数据类型相关的指令都支持 Java 虚拟机所有运行时数据类型的话，那恐怕就会超出一个字节所能表示的数量范围了。因此，Java 虚拟机的指令集对于特定的操作只提供了有限的类型相关指令去支持它，换句话说，指令集将会故意被设计成非完全独立的（Not Orthogonal，即并非每种数据类型和每一种操作都有对应的指令）。有一些单独的指令可以在必要的时候用来将一些不支持的类型转换为可被支持的类型。

下表列举了 Java 虚拟机所支持的字节码指令集，通过使用数据类型列所代表的特殊字符替换 opcode 列的指令模板中的 T，就可以得到一个具体的字节码指令。如果在表中指令模板与数据类型两列共同确定的格为空，则说明虚拟机不支持对这种数据类型执行这项操作。例如 load 指令有操作 int 类型的 iload，但是没有操作 byte 类型的同类指令。

请注意，从下表中看来，大部分的指令都没有支持整数类型 byte、char 和 short，甚至没有任何指令支持 boolean 类型。编译器会在编译期或运行期会将 byte 和 short 类型的数据带符号扩展（Sign-Extend）为相应的 int 类型数据，将 boolean 和 char 类型数据零位扩展（Zero-Extend）为相应的 int 类型数据。与之类似的，在处理 boolean、byte、short 和 char 类型的数组时，也会转换为使用对应的 int 类型的字节码指令来处理。因此，大多数对于 boolean、byte、short 和 char 类型数据的操作，实际上都是使用相应的对 int 类型作为运算类型（Computational Type）。

**Java 虚拟机指令集所支持的数据类型：**

![这里写图片描述][20160313222927969]

**在 Java 虚拟机中，实际类型与运算类型之间的映射关系，如下表所示：**

![这里写图片描述][20160313222944438]

有部分对操作栈进行操作的 Java 虚拟机指令（例如 pop 和 swap 指令）是与具体类型无关的，不过这些指令也必须受到运算类型分类的限制，这些分类也在表中列出了。

#### **2、加载和存储指令** ####

加载和存储指令用于将数据从栈帧的局部变量表和操作数栈之间来回传输：

1、将一个局部变量加载到操作栈的指令包括有：iload、iload_<n>、lload、lload_<n>、fload、fload_<n>、dload、dload_<n>、aload、aload_<n>
    
    2、将一个数值从操作数栈存储到局部变量表的指令包括有：istore、istore_<n>、lstore、lstore_<n>、fstore、fstore_<n>、dstore、dstore_<n>、astore、astore_<n>
    
    3、将一个常量加载到操作数栈的指令包括有：bipush、sipush、ldc、ldc_w、ldc2_w、aconst_null、iconst_m1、iconst_<i>、lconst_<l>、fconst_<f>、dconst_<d>
    
    4、扩充局部变量表的访问索引的指令：wide

访问对象的字段或数组元素的指令也同样会与操作数栈传输数据。

上面所列举的指令助记符中，有一部分是以尖括号结尾的（例如 `iload_<n>`），这些指令助记符实际上是代表了一组指令（例如 `iload_<n>`，它代表了 iload\_0、iload\_1、iload\_2 和 iload\_3 这几条指令）。这几组指令都是某个带有一个操作数的通用指令（例如 iload）的特殊形式，对于这若干组特殊指令来说，它们表面上没有操作数，不需要进行取操作数的动作，但操作数都是在指令中隐含的。除此之外，他们的语义与原生的通用指令完全一致（例如 iload\_0 的语义与操作数为 0 时的 iload 指令语义完全一致）。在尖括号之间的字母制定了指令隐含操作数的数据类型，`<i>`代表是 int 形数据，`<l>`代表 long 型，`<f>`代表 float 型，`<d>`代表 double型。在操作 byte、char 和 short 类型数据时，也用 int 类型表示。

这种指令表示方法，在整个《Java 虚拟机规范》之中都是通用的。

#### **3、运算指令** ####

算术指令用于对两个操作数栈上的值进行某种特定运算，并把结果重新存入到操作栈顶。大体上运算指令可以分为两种：对整型数据进行运算的指令与对浮点型数据进行运算的指令，无论是那种算术指令，都是使用 Java 虚拟机的数字类型的。数据没有直接支持 byte、short、char 和 boolean 类型（§2.11.1）的算术指令，对于这些数据的运算，都是使用操作 int 类型的指令。

整数与浮点数的算术指令在溢出和被零除的时候也有各自不同的行为，所有的算术指令包括：

加法指令：iadd、ladd、fadd、dadd
        减法指令：isub、lsub、fsub、dsub
        乘法指令：imul、lmul、fmul、dmul
        除法指令：idiv、ldiv、fdiv、ddiv
        求余指令：irem、lrem、frem、drem
        取反指令：ineg、lneg、fneg、dneg
        位移指令：ishl、ishr、iushr、lshl、lshr、lushr
        按位或指令：ior、lor
        按位与指令：iand、land
        按位异或指令：ixor、lxor
        局部变量自增指令：iinc
        比较指令：dcmpg、dcmpl、fcmpg、fcmpl、lcmp

Java 虚拟机的指令集直接支持了在《Java 语言规范》中描述的各种对整数及浮点数操作的语义。

Java 虚拟机没有明确规定整型数据溢出的情况，但是规定了在处理整型数据时，只有除法指令（idiv 和 ldiv）以及求余指令（irem 和 lrem）出现除数为零时会导致虚拟机抛出异常，如果发生了这种情况，虚拟机将会抛出 ArithmeitcException 异常。

Java 虚拟机在处理浮点数时，必须遵循 IEEE 754 规范中所规定行为限制。也就是说 Java虚拟机要求完全支持 IEEE 754 中定义的非正规浮点数值（Denormalized Floating-Point Numbers，§2.3.2）和逐级下溢（Gradual Underflow）。这些特征将会使得某些数值算法处理起来变得更容易一些。

Java 虚拟机要求在进行浮点数运算时，所有的运算结果都必须舍入到适当的进度，非精确的结果必须舍入为可被表示的最接近的精确值，如果有两种可表示的形式与该值一样接近，那将优先选择最低有效位为零的。这种舍入模式也是 IEEE 754 规范中的默认舍入模式，称为向最接近数舍入模式。

在把浮点数转换为整数时，Java 虚拟机使用 IEEE 754 标准中的向零舍入模式，这种模式的舍入结果会导致数字被截断，所有小数部分的有效字节都会被丢弃掉。向零舍入模式将在目标数值类型中选择一个最接近，但是不大于原值的数字来作为最精确的舍入结果。

Java 虚拟机在处理浮点数运算时，不会抛出任何运行时异常（这里所讲的是 Java 的异常，请勿与 IEEE 754 规范中的浮点异常互相混淆），当一个操作产生溢出时，将会使用有符号的无穷大来表示，如果某个操作结果没有明确的数学定义的话，将会时候 NaN 值来表示。所有使用 NaN 值作为操作数的算术操作，结果都会返回 NaN。

在对 long 类型数值进行比较时，虚拟机采用带符号的比较方式，而对浮点数值进行比较时（dcmpg、dcmpl、fcmpg、fcmpl），虚拟机采用 IEEE 754 规范说定义的无信号比较（Nonsignaling Comparisons）方式。

#### **4、类型转换指令** ####

类型转换指令可以将两种 Java 虚拟机数值类型进行相互转换，这些转换操作一般用于实现用户代码的显式类型转换操作，或者用来处理 Java 虚拟机字节码指令集中指令非完全独立独立的问题。

Java 虚拟机直接支持（注：“直接支持”意味着转换时无需显式的转换指令）以下数值的宽化类型转换（Widening Numeric Conversions，小范围类型向大范围类型的安全转换）：

int 类型到 long、float 或者 double 类型
        long 类型到 float、double 类型
        float 类型到 double 类型

窄化类型转换（Narrowing Numeric Conversions）指令包括有：i2b、i2c、i2s、l2i、f2i、f2l、d2i、d2l 和 d2f。窄化类型转换可能会导致转换结果产生不同的正负号、不同的数量级，转换过程很可能会导致数值丢失精度。

在将 int 或 long 类型窄化转换为整数类型 T 的时候，转换过程仅仅是简单的丢弃除最低位N 个字节以外的内容，N 是类型 T 的数据类型长度，这将可能导致转换结果与输入值有不同的正负号（注：在高位字节符号位被丢弃了）。

在将一个浮点值转窄化转换为整数类型 T（T 限于 int 或 long 类型之一）的时候，将遵循以下转换规则：

如果浮点值是 NaN，那转换结果就是 int 或 long 类型的 0，否则，如果浮点值不是无穷大的话，浮点值使用 IEEE 754 的向零舍入模式取整，获得整数值 v，这时候可能有两种情况：

> 如果 T 是 long 类型，并且转换结果在 long 类型的表示范围之内，那就转换为 long类型数值 v；
> 
> 如果 T 是 int 类型，并且转换结果在 int 类型的表示范围之内，那就转换为 int类型数值 v；
> 
> 否则：  
> 如果转换结果 v 的值太小（包括足够小的负数以及负无穷大的情况），无法使用 T 类型表示的话，那转换结果取 int 或 long 类型所能表示的最小数字。
> 
> 如果转换结果 v 的值太大（包括足够大的正数以及正无穷大的情况），无法使用 T 类型表示的话，那转换结果取 int 或 long 类型所能表示的最大数字。

从 double 类型到 float 类型做窄化转换的过程与 IEEE 754 中定义的一致，通过 IEEE 754向最接近数舍入模式（§2.8.1）舍入得到一个可以使用 float 类型表示的数字。如果转换结果的绝对值太小无法使用 float 来表示的话，将返回 float 类型的正负零。如果转换结果的绝对值太大无法使用 float 来表示的话，将返回 float 类型的正负无穷大，对于 double 类型的 NaN值将就规定转换为 float 类型的 NaN 值。

尽管可能发生上限溢出、下限溢出和精度丢失等情况，但是 Java 虚拟机中数值类型的窄化转换永远不可能导致虚拟机抛出运行时异常（此处的异常是指《Java 虚拟机规范》中定义的异常，请读者不要与 IEEE 754 中定义的浮点异常信号产生混淆）。

#### **5、对象创建与操作** ####

虽然类实例和数组都是对象，但 Java 虚拟机对类实例和数组的创建与操作使用了不同的字节码指令：

> 1、创建类实例的指令：new
> 
> 2、创建数组的指令：newarray，anewarray，multianewarray
> 
> 3、访问类字段（static 字段，或者称为类变量）和实例字段（非 static 字段，或者成为实例变量）的指令：getfield、putfield、getstatic、putstatic
> 
> 4、把一个数组元素加载到操作数栈的指令：baload、caload、saload、iaload、laload、faload、daload、aaload
> 
> 5、将一个操作数栈的值储存到数组元素中的指令：bastore、castore、sastore、iastore、fastore、dastore、aastore
> 
> 6、取数组长度的指令：arraylength
> 
> 7、检查类实例类型的指令：instanceof、checkcas

#### **6、操作数栈管理指令** ####

Java 虚拟机提供了一些用于直接操作操作数栈的指令，包括：pop、pop2、dup、dup2、dup\_x1、dup2\_x1、dup\_x2、dup2\_x2 和 swap。

#### **7、控制转移指令** ####

控制转移指令可以让 Java 虚拟机有条件或无条件地从指定指令而不是控制转移指令的下一条指令继续执行程序。控制转移指令包括有：

> 1、条件分支：ifeq、iflt、ifle、ifne、ifgt、ifge、ifnull、ifnonnull、if\_icmpeq、if\_icmpne、if\_icmplt, if\_icmpgt、if\_icmple、if\_icmpge、if\_acmpeq 和 if\_acmpne。
> 
> 2、复合条件分支：tableswitch、lookupswitch
> 
> 3、无条件分支：goto、goto\_w、jsr、jsr\_w、ret

在 Java 虚拟机中有专门的指令集用来处理 int 和 reference 类型的条件分支比较操作，为了可以无需明显标识一个实体值是否 null，也有专门的指令用来检测 null 值。

boolean 类型、byte 类型、char 类型和 short 类型的条件分支比较操作，都使用 int 类型的比较指令来完成，而对于 long 类型、float 类型和 double 类型的条件分支比较操作，则会先执行相应类型的比较运算指令，运算指令会返回一个整形值到操作数栈中，随后再执行 int 类型的条件分支比较操作来完成整个分支跳转。由于各种类型的比较最终都会转化为 int 类型的比较操作，基于 int 类型比较的这种重要性，Java 虚拟机提供了非常丰富的 int类型的条件分支指令。

所有 int 类型的条件分支转移指令进行的都是有符号的比较操作。

#### **8、方法调用和返回指令** ####

以下四条指令用于方法调用：

> 1、invokevirtual 指令用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是 Java 语言中最常见的方法分派方式。
> 
> 2、invokeinterface 指令用于调用接口方法，它会在运行时搜索一个实现了这个接口方法的对象，找出适合的方法进行调用。
> 
> 3、invokespecial 指令用于调用一些需要特殊处理的实例方法，包括实例初始化方法、私有方法和父类方法。
> 
> 4、invokestatic 指令用于调用类方法（static 方法）。

而方法返回指令则是根据返回值的类型区分的，包括有 ireturn（当返回值是 boolean、byte、char、short 和 int 类型时使用）、lreturn、freturn、dreturn 和 areturn，另外还有一条 return 指令供声明为 void 的方法、实例初始化方法、类和接口的类初始化方法使用。

#### **9、抛出异常** ####

在程序中显式抛出异常的操作会由 athrow 指令实现，除了这种情况，还有别的异常会在其它 Java 虚拟机指令检测到异常状况时由虚拟机自动抛出。

#### **10、同步** ####

Java 虚拟机可以支持方法级的同步和方法内部一段指令序列的同步，这两种同步结构都是使用管程（Monitor）来支持的。

方法级的同步是隐式，即无需通过字节码指令来控制的，它实现在方法调用和返回操作之中。虚拟机可以从方法常量池中的方法表结构（method\_info Structure）中的 ACC\_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时，调用指令将会检查方法的 ACC\_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有管程，然后再执行方法，最后再方法完成（无论是正常完成还是非正常完成）时释放管程。在方法执行期间，执行线程持有了管程，其他任何线程都无法再获得同一个管程。如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的管程将在异常抛到同步方法之外时自动释放。

同步一段指令集序列通常是由 Java 语言中的 synchronized 块来表示的，Java 虚拟机的指令集中有 monitorenter 和 monitorexit 两条指令来支持 synchronized 关键字的语义，正确实现 synchronized 关键字需要编译器与 Java 虚拟机两者协作支持。

结构化锁定（Structured Locking）是指在方法调用期间每一个管程退出都与前面的管程进入相匹配的情形。因为无法保证所有提交给 Java 虚拟机执行的代码都满足结构化锁定，所以 Java 虚拟机允许（但不强制要求）通过以下两条规则来保证结构化锁定成立。假设 T 代表一条线程，M 代表一个管程的话：

> 1、T 在方法执行时持有管程 M 的次数必须与 T 在方法完成（包括正常和非正常完成）时释放管程 M 的次数相等。
> 
> 2、找方法调用过程中，任何时刻都不会出现线程 T 释放管程 M 的次数比 T 持有管程 M 次数多的情况。

请注意，在同步方法调用时自动持有和释放管程的过程也被认为是在方法调用期间发生。

#### **11、栈和局部变量操作指令** ####

**（1）将常量压入栈的指令**

> aconst\_null将null对象引用压入栈  
> iconst\_m1 将int类型常量-1压入栈  
> iconst\_0 将int类型常量0压入栈  
> iconst\_1 将int类型常量1压入栈  
> iconst\_2 将int类型常量2压入栈  
> iconst\_3 将int类型常量3压入栈  
> iconst\_4 将int类型常量4压入栈  
> iconst\_5 将int类型常量5压入栈  
> lconst\_0 将long类型常量0压入栈  
> lconst\_1 将long类型常量1压入栈  
> fconst\_0 将float类型常量0压入栈  
> fconst\_1 将float类型常量1压入栈  
> dconst\_0 将double类型常量0压入栈  
> dconst\_1 将double类型常量1压入栈  
> bipush 将一个8位带符号整数压入栈  
> sipush 将16位带符号整数压入栈  
> ldc 把常量池中的项压入栈  
> ldc\_w 把常量池中的项压入栈（使用宽索引）  
> ldc2\_w 把常量池中long类型或者double类型的项压入栈（使用宽索引）

**（2）从栈中的局部变量中装载值的指令**

> iload 从局部变量中装载int类型值  
> lload 从局部变量中装载long类型值  
> fload 从局部变量中装载float类型值  
> dload 从局部变量中装载double类型值  
> aload 从局部变量中装载引用类型值（refernce）  
> iload\_0 从局部变量0中装载int类型值  
> iload\_1 从局部变量1中装载int类型值  
> iload\_2 从局部变量2中装载int类型值  
> iload\_3 从局部变量3中装载int类型值  
> lload\_0 从局部变量0中装载long类型值  
> lload\_1 从局部变量1中装载long类型值  
> lload\_2 从局部变量2中装载long类型值
> 
> lload\_3 从局部变量3中装载long类型值  
> fload\_0 从局部变量0中装载float类型值  
> fload\_1 从局部变量1中装载float类型值  
> fload\_2 从局部变量2中装载float类型值  
> fload\_3 从局部变量3中装载float类型值  
> dload\_0 从局部变量0中装载double类型值  
> dload\_1 从局部变量1中装载double类型值  
> dload\_2 从局部变量2中装载double类型值  
> dload\_3 从局部变量3中装载double类型值  
> aload\_0 从局部变量0中装载引用类型值  
> aload\_1 从局部变量1中装载引用类型值  
> aload\_2 从局部变量2中装载引用类型值  
> aload\_3 从局部变量3中装载引用类型值  
> iaload 从数组中装载int类型值  
> laload 从数组中装载long类型值  
> faload 从数组中装载float类型值  
> daload 从数组中装载double类型值  
> aaload 从数组中装载引用类型值  
> baload 从数组中装载byte类型或boolean类型值  
> caload 从数组中装载char类型值  
> saload 从数组中装载short类型值

**（3）将栈中的值存入局部变量的指令**

> istore 将int类型值存入局部变量  
> lstore 将long类型值存入局部变量  
> fstore 将float类型值存入局部变量  
> dstore 将double类型值存入局部变量  
> astore 将将引用类型或returnAddress类型值存入局部变量  
> istore\_0 将int类型值存入局部变量0  
> istore\_1 将int类型值存入局部变量1  
> istore\_2 将int类型值存入局部变量2
> 
> istore\_3 将int类型值存入局部变量3  
> lstore\_0 将long类型值存入局部变量0  
> lstore\_1 将long类型值存入局部变量1  
> lstore\_2 将long类型值存入局部变量2  
> lstore\_3 将long类型值存入局部变量3  
> fstore\_0 将float类型值存入局部变量0  
> fstore\_1 将float类型值存入局部变量1  
> fstore\_2 将float类型值存入局部变量2  
> fstore\_3 将float类型值存入局部变量3  
> dstore\_0 将double类型值存入局部变量0  
> dstore\_1 将double类型值存入局部变量1  
> dstore\_2 将double类型值存入局部变量2  
> dstore\_3 将double类型值存入局部变量3  
> astore\_0 将引用类型或returnAddress类型值存入局部变量0  
> astore\_1 将引用类型或returnAddress类型值存入局部变量1  
> astore\_2 将引用类型或returnAddress类型值存入局部变量2  
> astore\_3 将引用类型或returnAddress类型值存入局部变量3  
> iastore 将int类型值存入数组中  
> lastore 将long类型值存入数组中  
> fastore 将float类型值存入数组中  
> dastore 将double类型值存入数组中  
> aastore 将引用类型值存入数组中  
> bastore 将byte类型或者boolean类型值存入数组中  
> castore 将char类型值存入数组中  
> sastore 将short类型值存入数组中  
> wide指令  
> wide 使用附加字节扩展局部变量索引

**（4）通用(无类型）栈操作**

> nop 不做任何操作  
> pop 弹出栈顶端一个字长的内容  
> pop2 弹出栈顶端两个字长的内容  
> dup 复制栈顶部一个字长内容  
> dup\_x1 复制栈顶部一个字长的内容，然后将复制内容及原来弹出的两个字长的内容压入栈
> 
> dup\_x2 复制栈顶部一个字长的内容，然后将复制内容及原来弹出的三个字长的内容压入栈  
> dup2 复制栈顶部两个字长内容  
> dup2\_x1 复制栈顶部两个字长的内容，然后将复制内容及原来弹出的三个字长的内容压入栈  
> dup2\_x2 复制栈顶部两个字长的内容，然后将复制内容及原来弹出的四个字长的内容压入栈  
> swap 交换栈顶部两个字长内容

**（5）类型转换**

> i2l 把int类型的数据转化为long类型  
> i2f 把int类型的数据转化为float类型  
> i2d 把int类型的数据转化为double类型  
> l2i 把long类型的数据转化为int类型  
> l2f 把long类型的数据转化为float类型  
> l2d 把long类型的数据转化为double类型  
> f2i 把float类型的数据转化为int类型  
> f2l 把float类型的数据转化为long类型  
> f2d 把float类型的数据转化为double类型  
> d2i 把double类型的数据转化为int类型  
> d2l 把double类型的数据转化为long类型  
> d2f 把double类型的数据转化为float类型  
> i2b 把int类型的数据转化为byte类型  
> i2c 把int类型的数据转化为char类型  
> i2s 把int类型的数据转化为short类型

**（6）整数运算**

> iadd 执行int类型的加法  
> ladd 执行long类型的加法  
> isub 执行int类型的减法  
> lsub 执行long类型的减法  
> imul 执行int类型的乘法  
> lmul 执行long类型的乘法  
> idiv 执行int类型的除法  
> ldiv 执行long类型的除法
> 
> irem 计算int类型除法的余数  
> lrem 计算long类型除法的余数  
> ineg 对一个int类型值进行取反操作  
> lneg 对一个long类型值进行取反操作  
> iinc 把一个常量值加到一个int类型的局部变量上

**（7）逻辑运算**

移位操作

> ishl 执行int类型的向左移位操作  
> lshl 执行long类型的向左移位操作  
> ishr 执行int类型的向右移位操作  
> lshr 执行long类型的向右移位操作  
> iushr 执行int类型的向右逻辑移位操作  
> lushr 执行long类型的向右逻辑移位操作

按位布尔运算

> iand 对int类型值进行“逻辑与”操作  
> land 对long类型值进行“逻辑与”操作  
> ior 对int类型值进行“逻辑或”操作  
> lor 对long类型值进行“逻辑或”操作  
> ixor 对int类型值进行“逻辑异或”操作  
> lxor 对long类型值进行“逻辑异或”操作

浮点运算

> fadd 执行float类型的加法  
> dadd 执行double类型的加法  
> fsub 执行float类型的减法  
> dsub 执行double类型的减法  
> fmul 执行float类型的乘法  
> dmul 执行double类型的乘法  
> fdiv 执行float类型的除法  
> ddiv 执行double类型的除法  
> frem 计算float类型除法的余数  
> drem 计算double类型除法的余数  
> fneg 将一个float类型的数值取反  
> dneg 将一个double类型的数值取反

**（8）对象和数组**

对象操作指令

> new 创建一个新对象  
> checkcast 确定对象为所给定的类型  
> getfield 从对象中获取字段  
> putfield 设置对象中字段的值  
> getstatic 从类中获取静态字段  
> putstatic 设置类中静态字段的值  
> instanceof 判断对象是否为给定的类型

数组操作指令

> newarray 分配数据成员类型为基本上数据类型的新数组  
> anewarray 分配数据成员类型为引用类型的新数组  
> arraylength 获取数组长度  
> multianewarray 分配新的多维数组

**（9）控制流**

条件分支指令

> ifeq 如果等于0，则跳转  
> ifne 如果不等于0，则跳转  
> iflt 如果小于0，则跳转  
> ifge 如果大于等于0，则跳转  
> ifgt 如果大于0，则跳转  
> ifle 如果小于等于0，则跳转  
> if\_icmpcq 如果两个int值相等，则跳转  
> if\_icmpne 如果两个int类型值不相等，则跳转  
> if\_icmplt 如果一个int类型值小于另外一个int类型值，则跳转  
> if\_icmpge 如果一个int类型值大于或者等于另外一个int类型值，则跳转  
> if\_icmpgt 如果一个int类型值大于另外一个int类型值，则跳转  
> if\_icmple 如果一个int类型值小于或者等于另外一个int类型值，则跳转  
> ifnull 如果等于null，则跳转  
> ifnonnull 如果不等于null，则跳转  
> if\_acmpeq 如果两个对象引用相等，则跳转  
> if\_acmpnc 如果两个对象引用不相等，则跳转

比较指令

> lcmp 比较long类型值  
> fcmpl 比较float类型值（当遇到NaN时，返回-1）  
> fcmpg 比较float类型值（当遇到NaN时，返回1）  
> dcmpl 比较double类型值（当遇到NaN时，返回-1）  
> dcmpg 比较double类型值（当遇到NaN时，返回1）

无条件转移指令

> goto 无条件跳转  
> goto\_w 无条件跳转（宽索引）

表跳转指令

> tableswitch 通过索引访问跳转表，并跳转  
> lookupswitch 通过键值匹配访问跳转表，并执行跳转操作

异常

> athrow 抛出异常或错误  
> finally子句  
> jsr 跳转到子例程  
> jsr\_w 跳转到子例程（宽索引）  
> rct 从子例程返回

（10）方法调用与返回

方法调用指令

> invokcvirtual 运行时按照对象的类来调用实例方法  
> invokespecial 根据编译时类型来调用实例方法  
> invokestatic 调用类（静态）方法  
> invokcinterface 调用接口方法

方法返回指令

> ireturn 从方法中返回int类型的数据  
> lreturn 从方法中返回long类型的数据  
> freturn 从方法中返回float类型的数据  
> dreturn 从方法中返回double类型的数据  
> areturn 从方法中返回引用类型的数据  
> return 从方法中返回，返回值为void

线程同步

> montiorenter 进入并获取对象监视器  
> monitorexit 释放并退出对象监视器

[20160313222927969]: /images/20220731/2e01d0dfb21d4d5ba57526177d6c76dd.png
[20160313222944438]: /images/20220731/bccdcd3544374d599c620e73d5704017.png