本文由HeapDump性能社区首席讲师鸠摩（马智）授权整理发布
第17章-x86-64寄存器
不同的CPU都能够解释的机器语言的体系称为指令集架构（ISA，Instruction Set Architecture），也可以称为指令集（instruction set）。Intel将x86系列CPU之中的32位CPU指令集架构称为IA-32，IA是“Intel Architecture”的简称，也可以称为i386、x86-32。AMD等于Intell提出了x86系列的64位扩展，所以由AMD设计的x86系列的64位指令集架构称为AMD64。后来Intel在自己的CPU中加入和AMD64几乎相同的指令集，称为Intel 64的指令集。AMD64和Intel 64可以统称为x86-64。
x86-64的所有寄存器都是与机器字长（数据总线位宽）相同，即64位的，x86-64将x86的8个32位通用寄存器扩展为64位（eax、ebx、ecx、edx、eci、edi、ebp、esp），并且增加了8个新的64位寄存器（r8-r15），在命名方式上，也从”exx”变为”rxx”，但仍保留”exx”进行32位操作，下表描述了各寄存器的命名和作用。
| 描述 | 32位 | 64位 |
| 通用寄存器组 | eax | rax |
| ecx | rcx | |
| edx | rdx | |
| ebx | rbx | |
| esp | rsp | |
| ebp | rbp | |
| esi | rsi | |
| edi | rdi | |
| - | r8~r15 | |
| 浮点寄存器组 | st0~st7 | st0~st7 |
| XMM寄存器组 | XMM0~XMM7 | XMM0~XMM15 |
其中的%esp与%ebp有特殊用途，用来保存指向程序栈中特定位置的指针。
另外还有eflags寄存器，通过位来表示特定的含义，如下图所示。
在HotSpot VM中，表示寄存器的类都继承自AbstractRegisterImpl类，这个类的定义如下：
源代码位置：hotspot/src/share/vm/asm/register.hpp
class AbstractRegisterImpl;
typedef AbstractRegisterImpl* AbstractRegister;
class AbstractRegisterImpl {
protected:
int value() const { return (int)(intx)this; }
};
AbstractRegisterImpl类的继承体系如下图所示。
另外还有个ConcreteRegisterImpl类也继承了AbstractRegisterImpl，这个灰与C2编译器的实现有关，这里不做过多讲解。
1、RegisterImpl类
RegisterImpl类用来表示通用寄存器，类的定义如下：
源代码位置：cpu/x86/vm/register_x86.hpp
// 使用Register做为RegisterImpl的简称
class RegisterImpl;
typedef RegisterImpl* Register;
class RegisterImpl: public AbstractRegisterImpl {
public:
enum {
number_of_registers = 16,
number_of_byte_registers = 16
};
// ...
};
对于64位来说，通用寄存器的位宽为64位，也可以将eax、ebx、ecx和edx的一部分当作8位寄存器来使用，所以可以存储字节的寄存器数量为4。
在HotSpot VM中定义寄存器，如下：
源代码位置：hotspot/src/cpu/x86/vm/register_x86.hpp
CONSTANT_REGISTER_DECLARATION(Register, noreg, (-1)); // noreg_RegisterEnumValue = ((-1))
CONSTANT_REGISTER_DECLARATION(Register, rax, (0)); // rax_RegisterEnumValue = ((0))
CONSTANT_REGISTER_DECLARATION(Register, rcx, (1)); // rcx_RegisterEnumValue = ((1))
CONSTANT_REGISTER_DECLARATION(Register, rdx, (2)); // rdx_RegisterEnumValue = ((2))
CONSTANT_REGISTER_DECLARATION(Register, rbx, (3)); // rbx_RegisterEnumValue = ((3))
CONSTANT_REGISTER_DECLARATION(Register, rsp, (4)); // rsp_RegisterEnumValue = ((4))
CONSTANT_REGISTER_DECLARATION(Register, rbp, (5)); // rbp_RegisterEnumValue = ((5))
CONSTANT_REGISTER_DECLARATION(Register, rsi, (6)); // rsi_RegisterEnumValue = ((6))
CONSTANT_REGISTER_DECLARATION(Register, rdi, (7)); // rdi_RegisterEnumValue = ((7))
CONSTANT_REGISTER_DECLARATION(Register, r8, (8)); // r8_RegisterEnumValue = ((8))
CONSTANT_REGISTER_DECLARATION(Register, r9, (9)); // r9_RegisterEnumValue = ((9))
CONSTANT_REGISTER_DECLARATION(Register, r10, (10)); // r10_RegisterEnumValue = ((10))
CONSTANT_REGISTER_DECLARATION(Register, r11, (11)); // r11_RegisterEnumValue = ((11))
CONSTANT_REGISTER_DECLARATION(Register, r12, (12)); // r12_RegisterEnumValue = ((12))
CONSTANT_REGISTER_DECLARATION(Register, r13, (13)); // r13_RegisterEnumValue = ((13))
CONSTANT_REGISTER_DECLARATION(Register, r14, (14)); // r14_RegisterEnumValue = ((14))
CONSTANT_REGISTER_DECLARATION(Register, r15, (15)); // r15_RegisterEnumValue = ((15))
宏CONSTANT_REGISTER_DECLARATION定义如下：
源代码位置：hotspot/src/share/vm/asm/register.hpp
#define CONSTANT_REGISTER_DECLARATION(type, name, value) \
extern const type name; \
enum { name##_##type##EnumValue = (value) }
经过宏扩展后如下：
extern const Register rax;
enum { rax_RegisterEnumValue = ((0)) }
extern const Register rcx;
enum { rcx_RegisterEnumValue = ((1)) }
extern const Register rdx;
enum { rdx_RegisterEnumValue = ((2)) }
extern const Register rbx;
enum { rbx_RegisterEnumValue = ((3)) }
extern const Register rsp;
enum { rsp_RegisterEnumValue = ((4)) }
extern const Register rbp;
enum { rbp_RegisterEnumValue = ((5)) }
extern const Register rsi;
enum { rsi_RegisterEnumValue = ((6)) }
extern const Register rsi;
enum { rdi_RegisterEnumValue = ((7)) }
extern const Register r8;
enum { r8_RegisterEnumValue = ((8)) }
extern const Register r9;
enum { r9_RegisterEnumValue = ((9)) }
extern const Register r10;
enum { r10_RegisterEnumValue = ((10)) }
extern const Register r11;
enum { r11_RegisterEnumValue = ((11)) }
extern const Register r12;
enum { r12_RegisterEnumValue = ((12)) }
extern const Register r13;
enum { r13_RegisterEnumValue = ((13)) }
extern const Register r14;
enum { r14_RegisterEnumValue = ((14)) }
extern const Register r15;
enum { r15_RegisterEnumValue = ((15)) }
如上的枚举类给寄存器指定了一个常量值。
在cpu/x86/vm/register_definitions_x86.cpp文件中定义的寄存器如下：
const Register noreg = ((Register)noreg_RegisterEnumValue)
const Register rax = ((Register)rax_RegisterEnumValue)
const Register rcx = ((Register)rcx_RegisterEnumValue)
const Register rdx = ((Register)rdx_RegisterEnumValue)
const Register rbx = ((Register)rbx_RegisterEnumValue)
const Register rsp = ((Register)rsp_RegisterEnumValue)
const Register rbp = ((Register)rbp_RegisterEnumValue)
const Register rsi = ((Register)rsi_RegisterEnumValue)
const Register rdi = ((Register)rdi_RegisterEnumValue)
const Register r8 = ((Register)r8_RegisterEnumValue)
const Register r9 = ((Register)r9_RegisterEnumValue)
const Register r10 = ((Register)r10_RegisterEnumValue)
const Register r11 = ((Register)r11_RegisterEnumValue)
const Register r12 = ((Register)r12_RegisterEnumValue)
const Register r13 = ((Register)r13_RegisterEnumValue)
const Register r14 = ((Register)r14_RegisterEnumValue)
const Register r15 = ((Register)r15_RegisterEnumValue)
当我们需要使用通用寄存器时，通过rax、rcx等变量引用就可以了。
2、FloatRegisterImpl
在HotSpot VM中，使用FloatRegisterImpl来表示浮点寄存器，此类的定义如下：
源代码位置：hotspot/src/cpu/x86/vm/register_x86.hpp
// 使用FloatRegister做为简称
class FloatRegisterImpl;
typedef FloatRegisterImpl* FloatRegister;
class FloatRegisterImpl: public AbstractRegisterImpl {
public:
enum {
number_of_registers = 8
};
// ...
}
浮点寄存器有8个，分别是st0~st7，这是8个80位寄存器。
这里需要注意的是，还有一种寄存器MMX，MMX并非一种新的寄存器，而是借用了80位浮点寄存器的低64位，也就是说，使用MMX指令集，会影响浮点运算！
3、MMXRegisterImpl
MMX 为一种 SIMD 技术，即可通过一条指令执行多个数据运算，共有8个64位寄存器（借用了80位浮点寄存器的低64位），分别为mm0 – mm7，他与其他普通64位寄存器的区别在于通过它的指令进行运算，可以同时计算2个32位数据，或者4个16位数据等等，可以应用为图像处理过程中图形 颜色的计算。
MMXRegisterImpl类的定义如下：
class MMXRegisterImpl;
typedef MMXRegisterImpl* MMXRegister;
MMX寄存器的定义如下：
CONSTANT_REGISTER_DECLARATION(MMXRegister, mnoreg , (-1));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx0 , ( 0));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx1 , ( 1));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx2 , ( 2));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx3 , ( 3));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx4 , ( 4));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx5 , ( 5));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx6 , ( 6));
CONSTANT_REGISTER_DECLARATION(MMXRegister, mmx7 , ( 7));
宏扩展后如下：
extern const MMXRegister mnoreg;
enum { mnoreg_MMXRegisterEnumValue = ((-1)) }
extern const MMXRegister mmx0;
enum { mmx0_MMXRegisterEnumValue = (( 0)) }
extern const MMXRegister mmx1;
enum { mmx1_MMXRegisterEnumValue = (( 1)) }
extern const MMXRegister mmx2;
enum { mmx2_MMXRegisterEnumValue = (( 2)) }
extern const MMXRegister mmx3;
enum { mmx3_MMXRegisterEnumValue = (( 3)) }
extern const MMXRegister mmx4;
enum { mmx4_MMXRegisterEnumValue = (( 4)) }
extern const MMXRegister mmx5;
enum { mmx5_MMXRegisterEnumValue = (( 5)) }
extern const MMXRegister mmx6;
enum { mmx6_MMXRegisterEnumValue = (( 6)) }
extern const MMXRegister mmx7;
enum { mmx7_MMXRegisterEnumValue = (( 7)) }
MMX Pentium以及Pentium II之后的CPU中有从mm0到mm7共8个64位寄存器。但实际上MMX寄存器和浮点数寄存器是共用的，即无法同时使用浮点数寄存器和MMX寄存器。
cpu/x86/vm/register_definitions_x86.cpp文件中定义的寄存器变量如下：
const MMXRegister mnoreg = ((MMXRegister)mnoreg_MMXRegisterEnumValue)
const MMXRegister mmx0 = ((MMXRegister)mmx0_MMXRegisterEnumValue)
const MMXRegister mmx1 = ((MMXRegister)mmx1_MMXRegisterEnumValue)
const MMXRegister mmx2 = ((MMXRegister)mmx2_MMXRegisterEnumValue)
const MMXRegister mmx3 = ((MMXRegister)mmx3_MMXRegisterEnumValue)
const MMXRegister mmx4 = ((MMXRegister)mmx4_MMXRegisterEnumValue)
const MMXRegister mmx5 = ((MMXRegister)mmx5_MMXRegisterEnumValue)
const MMXRegister mmx6 = ((MMXRegister)mmx6_MMXRegisterEnumValue)
const MMXRegister mmx7 = ((MMXRegister)mmx7_MMXRegisterEnumValue)
当我们需要使用MMX寄存器时，通过mmx0、mmx1等变量引用就可以了。
4、XMMRegisterImpl类
XMM寄存器是SSE指令用的寄存器。Pentium iii以及之后的CPU中提供了xmm0到xmm7共8个128位宽的XMM寄存器。另外还有个mxcsr寄存器，这个寄存器用来表示SSE指令的运算状态的寄存器。在HotSpot VM中，通过XMMRegisterImpl类来表示寄存器。这个类的定义如下：
源代码位置：hotspot/src/share/x86/cpu/vm/register_x86.hpp
// 使用XMMRegister寄存器做为简称
class XMMRegisterImpl;
typedef XMMRegisterImpl* XMMRegister;
class XMMRegisterImpl: public AbstractRegisterImpl {
public:
enum {
number_of_registers = 16
};
...
}
XMM寄存器的定义如下：
CONSTANT_REGISTER_DECLARATION(XMMRegister, xnoreg , (-1));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm0 , ( 0));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm1 , ( 1));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm2 , ( 2));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm3 , ( 3));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm4 , ( 4));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm5 , ( 5));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm6 , ( 6));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm7 , ( 7));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm8, (8));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm9, (9));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm10, (10));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm11, (11));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm12, (12));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm13, (13));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm14, (14));
CONSTANT_REGISTER_DECLARATION(XMMRegister, xmm15, (15));
经过宏扩展后为：
extern const XMMRegister xnoreg;
enum { xnoreg_XMMRegisterEnumValue = ((-1)) }
extern const XMMRegister xmm0;
enum { xmm0_XMMRegisterEnumValue = (( 0)) }
extern const XMMRegister xmm1;
enum { xmm1_XMMRegisterEnumValue = (( 1)) }
extern const XMMRegister xmm2;
enum { xmm2_XMMRegisterEnumValue = (( 2)) }
extern const XMMRegister xmm3;
enum { xmm3_XMMRegisterEnumValue = (( 3)) }
extern const XMMRegister xmm4;
enum { xmm4_XMMRegisterEnumValue = (( 4)) }
extern const XMMRegister xmm5;
enum { xmm5_XMMRegisterEnumValue = (( 5)) }
extern const XMMRegister xmm6;
enum { xmm6_XMMRegisterEnumValue = (( 6)) }
extern const XMMRegister xmm7;
enum { xmm7_XMMRegisterEnumValue = (( 7)) }
extern const XMMRegister xmm8;
enum { xmm8_XMMRegisterEnumValue = ((8)) }
extern const XMMRegister xmm9;
enum { xmm9_XMMRegisterEnumValue = ((9)) }
extern const XMMRegister xmm10;
enum { xmm10_XMMRegisterEnumValue = ((10)) }
extern const XMMRegister xmm11;
enum { xmm11_XMMRegisterEnumValue = ((11)) }
extern const XMMRegister xmm12;
enum { xmm12_XMMRegisterEnumValue = ((12)) }
extern const XMMRegister xmm13;
enum { xmm13_XMMRegisterEnumValue = ((13)) }
extern const XMMRegister xmm14;
enum { xmm14_XMMRegisterEnumValue = ((14)) }
extern const XMMRegister xmm15;
enum { xmm15_XMMRegisterEnumValue = ((15)) }
在cpu/x86/vm/register_definitions_x86.cpp文件中定义的寄存器变量如下：
const XMMRegister xnoreg = ((XMMRegister)xnoreg_XMMRegisterEnumValue)
const XMMRegister xmm0 = ((XMMRegister)xmm0_XMMRegisterEnumValue)
const XMMRegister xmm1 = ((XMMRegister)xmm1_XMMRegisterEnumValue)
const XMMRegister xmm2 = ((XMMRegister)xmm2_XMMRegisterEnumValue)
const XMMRegister xmm3 = ((XMMRegister)xmm3_XMMRegisterEnumValue)
const XMMRegister xmm4 = ((XMMRegister)xmm4_XMMRegisterEnumValue)
const XMMRegister xmm5 = ((XMMRegister)xmm5_XMMRegisterEnumValue)
const XMMRegister xmm6 = ((XMMRegister)xmm6_XMMRegisterEnumValue)
const XMMRegister xmm7 = ((XMMRegister)xmm7_XMMRegisterEnumValue)
const XMMRegister xmm8 = ((XMMRegister)xmm8_XMMRegisterEnumValue)
const XMMRegister xmm9 = ((XMMRegister)xmm9_XMMRegisterEnumValue)
const XMMRegister xmm10 = ((XMMRegister)xmm10_XMMRegisterEnumValue)
const XMMRegister xmm11 = ((XMMRegister)xmm11_XMMRegisterEnumValue)
const XMMRegister xmm12 = ((XMMRegister)xmm12_XMMRegisterEnumValue)
const XMMRegister xmm13 = ((XMMRegister)xmm13_XMMRegisterEnumValue)
const XMMRegister xmm14 = ((XMMRegister)xmm14_XMMRegisterEnumValue)
const XMMRegister xmm15 = ((XMMRegister)xmm15_XMMRegisterEnumValue)
当我们需要使用XMM寄存器时，直接通过xmm0、xmm1等变量引用就可以了。
第18章-x86指令集之常用指令
x86的指令集可分为以下4种：
- 通用指令
- x87 FPU指令，浮点数运算的指令
- SIMD指令，就是SSE指令
- 系统指令，写OS内核时使用的特殊指令
下面介绍一些通用的指令。指令由标识命令种类的助记符（mnemonic）和作为参数的操作数（operand）组成。例如move指令：
| 指令 | 操作数 | 描述 |
| movq | I/R/M,R/M | 从一个内存位置复制1个双字（64位，8字节）大小的数据到另外一个内存位置 |
| movl | I/R/M,R/M | 从一个内存位置复制1个字（32位，4字节）大小的数据到另外一个内存位置 |
| movw | I/R/M, R/M | 从一个内存位置复制2个字节（16位）大小的数据到另外一个内存位置 |
| movb | I/R/M, R/M | 从一个内存位置复制1个字节（8位）大小的数据到另外一个内存位置 |
movl为助记符。助记符有后缀，如movl中的后缀l表示作为操作数的对象的数据大小。l为long的缩写，表示32位的大小，除此之外，还有b、w，q分别表示8位、16位和64位的大小。
指令的操作数如果不止1个，就将每个操作数以逗号分隔。每个操作数都会指明是否可以是立即模式值（I）、寄存器（R）或内存地址（M）。
另外还要提示一下，在x86的汇编语言中，采用内存位置的操作数最多只能出现一个，例如不可能出现mov M,M指令。
通用寄存器中每个操作都可以有一个字符的后缀，表明操作数的大小，如下表所示。
| C声明 | 通用寄存器后缀 | 大小(字节) |
| char | b | 1 |
| short | w | 2 |
| (unsigned) int / long / char* | l | 4 |
| float | s | 4 |
| double | l | 5 |
| long double | t | 10/12 |
注意：通用寄存器使用后缀“l”同时表示4字节整数和8字节双精度浮点数，这不会产生歧义，因为浮点数使用的是完全不同的指令和寄存器。
我们后面只介绍call、push等指令时，如果在研究HotSpot VM虚拟机的汇编遇到了callq，pushq等指令时，千万别不认识，后缀就是表示了操作数的大小。
下表为操作数的格式和寻址模式。
| 格式 | 操作数值 | 名称 | 样例（通用寄存器 = C语言） |
| $Imm | Imm | 立即数寻址 | $1 = 1 |
| Ea | R[Ea] | 寄存器寻址 | %eax = eax |
| Imm | M[Imm] | 绝对寻址 | 0x104 = *0x104 |
| （Ea） | M[R[Ea]] | 间接寻址 | （%eax）= *eax |
| Imm(Ea) | M[Imm+R[Ea]] | (基址+偏移量)寻址 | 4(%eax) = *(4+eax) |
| （Ea,Eb） | M[R[Ea]+R[Eb]] | 变址 | (%eax,%ebx) = *(eax+ebx) |
| Imm（Ea,Eb） | M[Imm+R[Ea]+R[Eb]] | 寻址 | 9(%eax,%ebx)= *(9+eax+ebx) |
| (,Ea,s) | M[R[Ea]*s] | 伸缩化变址寻址 | (,%eax,4)= (eax4) |
| Imm(,Ea,s) | M[Imm+R[Ea]*s] | 伸缩化变址寻址 | 0xfc(,%eax,4)= (0xfc+eax4) |
| (Ea,Eb,s) | M(R[Ea]+R[Eb]*s) | 伸缩化变址寻址 | (%eax,%ebx,4) = (eax+ebx4) |
| Imm(Ea,Eb,s) | M(Imm+R[Ea]+R[Eb]*s) | 伸缩化变址寻址 | 8(%eax,%ebx,4) = (8+eax+ebx4) |
注：M[xx]表示在存储器中xx地址的值，R[xx]表示寄存器xx的值，这种表示方法将寄存器、内存都看出一个大数组的形式。
汇编根据编译器的不同，有2种书写格式：
（1）Intel : Windows派系
（2）AT&T: Unix派系
下面简单介绍一下两者的不同。
下面就来认识一下常用的指令。
下面我们以给出的是AT&T汇编的写法，这两种写法有如下不同。
1、数据传送指令
将数据从一个地方传送到另外一个地方。
1.1 mov指令
我们在介绍mov指令时介绍的全一些，因为mov指令是出现频率最高的指令，助记符中的后缀也比较多。
mov指令的形式有3种，如下：
mov #普通的move指令
movs #符号扩展的move指令，将源操作数进行符号扩展并传送到一个64位寄存器或存储单元中。movs就表示符号扩展
movz #零扩展的move指令，将源操作数进行零扩展后传送到一个64位寄存器或存储单元中。movz就表示零扩展
mov指令后有一个字母可表示操作数大小，形式如下：
movb #完成1个字节的复制
movw #完成2个字节的复制
movl #完成4个字节的复制
movq #完成8个字节的复制
还有一个指令，如下：
movabsq I,R
与movq有所不同，它是将一个64位的值直接存到一个64位寄存器中。
movs指令的形式如下：
movsbw #作符号扩展的1字节复制到2字节
movsbl #作符号扩展的1字节复制到4字节
movsbq #作符号扩展的1字节复制到8字节
movswl #作符号扩展的2字节复制到4字节
movswq #作符号扩展的2字节复制到8字节
movslq #作符号扩展的4字节复制到8字节
movz指令的形式如下：
movzbw #作0扩展的1字节复制到2字节
movzbl #作0扩展的1字节复制到4字节
movzbq #作0扩展的1字节复制到8字节
movzwl #作0扩展的2字节复制到4字节
movzwq #作0扩展的2字节复制到8字节
movzlq #作0扩展的4字节复制到8字节
举个例子如下：
movl %ecx,%eax
movl (%ecx),%eax
第一条指令将寄存器ecx中的值复制到eax寄存器；第二条指令将ecx寄存器中的数据作为地址访问内存，并将内存上的数据加载到eax寄存器中。
1.2 cmov指令
cmov指令的格式如下：
cmovxx
其中xx代表一个或者多个字母，这些字母表示将触发传送操作的条件。条件取决于 EFLAGS 寄存器的当前值。
eflags寄存器中各个们如下图所示。
其中与cmove指令相关的eflags寄存器中的位有CF（数学表达式产生了进位或者借位） 、OF（整数值无穷大或者过小）、PF（寄存器包含数学操作造成的错误数据）、SF（结果为正不是负）和ZF（结果为零）。
下表为无符号条件传送指令。
| 指令对 | 描述 | eflags状态 |
| cmova/cmovnbe | 大于/不小于或等于 | （CF或ZF）=0 |
| cmovae/cmovnb | 大于或者等于/不小于 | CF=0 |
| cmovnc | 无进位 | CF=0 |
| cmovb/cmovnae | 大于/不小于或等于 | CF=1 |
| cmovc | 进位 | CF=1 |
| cmovbe/cmovna | 小于或者等于/不大于 | （CF或ZF）=1 |
| cmove/cmovz | 等于/零 | ZF=1 |
| cmovne/cmovnz | 不等于/不为零 | ZF=0 |
| cmovp/cmovpe | 奇偶校验/偶校验 | PF=1 |
| cmovnp/cmovpo | 非奇偶校验/奇校验 | PF=0 |
无符号条件传送指令依靠进位、零和奇偶校验标志来确定两个操作数之间的区别。
下表为有符号条件传送指令。
| 指令对 | 描述 | eflags状态 |
| cmovge/cmovnl | 大于或者等于/不小于 | （SF异或OF）=0 |
| cmovl/cmovnge | 大于/不大于或者等于 | （SF异或OF）=1 |
| cmovle/cmovng | 小于或者等于/不大于 | (（SF异或OF）或ZF)=1 |
| cmovo | 溢出 | OF=1 |
| cmovno | 未溢出 | OF=0 |
| cmovs | 带符号（负） | SF=1 |
| cmovns | 无符号（非负） | SF=0 |
举个例子如下：
// 将vlaue数值加载到ecx寄存器中
movl value,%ecx
// 使用cmp指令比较ecx和ebx这两个寄存器中的值，具体就是用ecx减去ebx然后设置eflags
cmp %ebx,%ecx
// 如果ecx的值大于ebx，使用cmova指令设置ebx的值为ecx中的值
cmova %ecx,%ebx
注意AT&T汇编的第1个操作数在前，第2个操作数在后。
1.3 push和pop指令
push指令的形式如下表所示。
| 指令 | 操作数 | 描述 |
| push | I/R/M | PUSH 指令首先减少 ESP 的值，再将源操作数复制到堆栈。操作数是 16 位的，则 ESP 减 2，操作数是 32 位的，则 ESP 减 4 |
| pusha | 指令按序（AX、CX、DX、BX、SP、BP、SI 和 DI）将 16 位通用寄存器压入堆栈。 | |
| pushad | 指令按照 EAX、ECX、EDX、EBX、ESP（执行 PUSHAD 之前的值）、EBP、ESI 和 EDI 的顺序，将所有 32 位通用寄存器压入堆栈。 |
pop指令的形式如下表所示。
| 指令 | 操作数 | 描述 |
| pop | R/M | 指令首先把 ESP 指向的堆栈元素内容复制到一个 16 位或 32 位目的操作数中，再增加 ESP 的值。如果操作数是 16 位的，ESP 加 2，如果操作数是 32 位的，ESP 加 4 |
| popa | 指令按照相反顺序将同样的寄存器弹出堆栈 | |
| popad | 指令按照相反顺序将同样的寄存器弹出堆栈 |
1.4 xchg与xchgl
这个指令用于交换操作数的值，交换指令XCHG是两个寄存器，寄存器和内存变量之间内容的交换指令，两个操作数的数据类型要相同，可以是一个字节，也可以是一个字，也可以是双字。格式如下：
xchg R/M,R/M
xchgl I/R,I/R、
两个操作数不能同时为内存变量。xchgl指令是一条古老的x86指令，作用是交换两个寄存器或者内存地址里的4字节值，两个值不能都是内存地址，他不会设置条件码。
1.5 lea
lea计算源操作数的实际地址，并把结果保存到目标操作数，而目标操作数必须为通用寄存器。格式如下：
lea M,R
lea（Load Effective Address）指令将地址加载到寄存器。
举例如下：
movl 4(%ebx),%eax
leal 4(%ebx),%eax
第一条指令表示将ebx寄存器中存储的值加4后得到的结果作为内存地址进行访问，并将内存地址中存储的数据加载到eax寄存器中。
第二条指令表示将ebx寄存器中存储的值加4后得到的结果作为内存地址存放到eax寄存器中。
再举个例子，如下：
leaq a(b, c, d), %rax
计算地址a + b + c * d，然后把最终地址载到寄存器rax中。可以看到只是简单的计算，不引用源操作数里的寄存器。这样的完全可以把它当作乘法指令使用。
2、算术运算指令
下面介绍对有符号整数和无符号整数进行操作的基本运算指令。
2.1 add与adc指令
指令的格式如下：
add I/R/M,R/M
adc I/R/M,R/M
指令将两个操作数相加，结果保存在第2个操作数中。
对于第1条指令来说，由于寄存器和存储器都有位宽限制，因此在进行加法运算时就有可能发生溢出。运算如果溢出的话，标志寄存器eflags中的进位标志（Carry Flag，CF）就会被置为1。
对于第2条指令来说，利用adc指令再加上进位标志eflags.CF，就能在32位的机器上进行64位数据的加法运算。
常规的算术逻辑运算指令只要将原来IA-32中的指令扩展到64位即可。如addq就是四字相加。
2.2 sub与sbb指令
指令的格式如下：
sub I/R/M,R/M
sbb I/R/M,R/M
指令将用第2个操作数减去第1个操作数，结果保存在第2个操作数中。
2.3 imul与mul指令
指令的格式如下：
imul I/R/M,R
mul I/R/M,R
将第1个操作数和第2个操作数相乘，并将结果写入第2个操作数中，如果第2个操作数空缺，默认为eax寄存器，最终完整的结果将存储到edx:eax中。
第1条指令执行有符号乘法，第2条指令执行无符号乘法。
2.4 idiv与div指令
指令的格式如下：
div R/M
idiv R/M
第1条指令执行无符号除法，第2条指令执行有符号除法。被除数由edx寄存器和eax寄存器拼接而成，除数由指令的第1个操作数指定，计算得到的商存入eax寄存器，余数存入edx寄存器。如下图所示。
edx:eax
------------ = eax（商）... edx（余数）
寄存器
运算时被除数、商和除数的数据的位宽是不一样的，如下表表示了idiv指令和div指令使用的寄存器的情况。
| 数据的位宽 | 被除数 | 除数 | 商 | 余数 |
| 8位 | ax | 指令第1个操作数 | al | ah |
| 16位 | dx:ax | 指令第1个操作数 | ax | dx |
| 32位 | edx:eax | 指令第1个操作数 | eax | edx |
idiv指令和div指令通常是对位宽2倍于除数的被除数进行除法运算的。例如对于x86-32机器来说，通用寄存器的倍数为32位，1个寄存器无法容纳64位的数据，所以 edx存放被除数的高32位，而eax寄存器存放被除数的低32位。
所以在进行除法运算时，必须将设置在eax寄存器中的32位数据扩展到包含edx寄存器在内的64位，即有符号进行符号扩展，无符号数进行零扩展。
对edx进行符号扩展时可以使用cltd（AT&T风格写法）或cdq（Intel风格写法）。指令的格式如下：
cltd // 将eax寄存器中的数据符号扩展到edx:eax
cltd将eax寄存器中的数据符号扩展到edx:eax。
2.5 incl与decl指令
指令的格式如下：
inc R/M
dec R/M
将指令第1个操作数指定的寄存器或内存位置存储的数据加1或减1。
2.6 negl指令
指令的格式如下：
neg R/M
neg指令将第1个操作数的符号进行反转。
3、位运算指令
3.1 andl、orl与xorl指令
指令的格式如下：
and I/R/M,R/M
or I/R/M,R/M
xor I/R/M,R/M
and指令将第2个操作数与第1个操作数进行按位与运算，并将结果写入第2个操作数；
or指令将第2个操作数与第1个操作数进行按位或运算，并将结果写入第2个操作数；
xor指令将第2个操作数与第1个操作数进行按位异或运算，并将结果写入第2个操作数；
3.2 not指令
指令的格式如下：
not R/M
将操作数按位取反，并将结果写入操作数中。
3.3 sal、sar、shr指令
指令的格式如下：
sal I/%cl,R/M #算术左移
sar I/%cl,R/M #算术右移
shl I/%cl,R/M #逻辑左移
shr I/%cl,R/M #逻辑右移
sal指令将第2个操作数按照第1个操作数指定的位数进行左移操作，并将结果写入第2个操作数中。移位之后空出的低位补0。指令的第1个操作数只能是8位的立即数或cl寄存器，并且都是只有低5位的数据才有意义，高于或等于6位数将导致寄存器中的所有数据被移走而变得没有意义。
sar指令将第2个操作数按照第1个操作数指定的位数进行右移操作，并将结果写入第2个操作数中。移位之后的空出进行符号扩展。和sal指令一样，sar指令的第1个操作数也必须为8位的立即数或cl寄存器，并且都是只有低5位的数据才有意义。
shl指令和sall指令的动作完全相同，没有必要区分。
shr令将第2个操作数按照第1个操作数指定的位数进行右移操作，并将结果写入第2个操作数中。移位之后的空出进行零扩展。和sal指令一样，shr指令的第1个操作数也必须为8位的立即数或cl寄存器，并且都是只有低5位的数据才有意义。
4、流程控制指令
4.1 jmp指令
指令的格式如下：
jmp I/R
jmp指令将程序无条件跳转到操作数指定的目的地址。jmp指令可以视作设置指令指针（eip寄存器）的指令。目的地址也可以是星号后跟寄存器的栈，这种方式为间接函数调用。例如：
jmp *%eax
将程序跳转至eax所含地址。
4.2 条件跳转指令
条件跳转指令的格式如下：
Jcc 目的地址
其中cc指跳转条件，如果为真，则程序跳转到目的地址；否则执行下一条指令。相关的条件跳转指令如下表所示。
| 指令 | 跳转条件 | 描述 | 指令 | 跳转条件 | 描述 |
| jz | ZF=1 | 为0时跳转 | jbe | CF=1或ZF=1 | 大于或等于时跳转 |
| jnz | ZF=0 | 不为0时跳转 | jnbe | CF=0且ZF=0 | 小于或等于时跳转 |
| je | ZF=1 | 相等时跳转 | jg | ZF=0且SF=OF | 大于时跳转 |
| jne | ZF=0 | 不相等时跳转 | jng | ZF=1或SF!=OF | 不大于时跳转 |
| ja | CF=0且ZF=0 | 大于时跳转 | jge | SF=OF | 大于或等于时跳转 |
| jna | CF=1或ZF=1 | 不大于时跳转 | jnge | SF!=OF | 小于或等于时跳转 |
| jae | CF=0 | 大于或等于时跳转 | jl | SF!=OF | 小于时跳转 |
| jnae | CF=1 | 小于或等于时跳转 | jnl | SF=OF | 不小于时跳转 |
| jb | CF=1 | 大于时跳转 | jle | ZF=1或SF!=OF | 小于或等于时跳转 |
| jnb | CF=0 | 不大于时跳转 | jnle | ZF=0且SF=OF | 大于或等于时跳转 |
4.3 cmp指令
cmp指令的格式如下：
cmp I/R/M,R/M
cmp指令通过比较第2个操作数减去第1个操作数的差，根据结果设置标志寄存器eflags中的标志位。cmp指令和sub指令类似，不过cmp指令不会改变操作数的值。
操作数和所设置的标志位之间的关系如表所示。
| 操作数的关系 | CF | ZF | OF |
| 第1个操作数小于第2个操作数 | 0 | 0 | SF |
| 第1个操作数等于第2个操作数 | 0 | 1 | 0 |
| 第1个操作数大于第2个操作数 | 1 | 0 | not SF |
4.4 test指令
指令的格式如下：
test I/R/M,R/M
指令通过比较第1个操作数与第2个操作数的逻辑与，根据结果设置标志寄存器eflags中的标志位。test指令本质上和and指令相同，只是test指令不会改变操作数的值。
test指令执行后CF与OF通常会被清零，并根据运算结果设置ZF和SF。运算结果为零时ZF被置为1，SF和最高位的值相同。
举个例子如下：
test指令同时能够检查几个位。假设想要知道 AL 寄存器的位 0 和位 3 是否置 1，可以使用如下指令：
test al,00001001b #掩码为0000 1001，测试第0和位3位是否为1
从下面的数据集例子中，可以推断只有当所有测试位都清 0 时，零标志位才置 1：
0 0 1 0 0 1 0 1 <- 输入值
0 0 0 0 1 0 0 1 <- 测试值
0 0 0 0 0 0 0 1 <- 结果：ZF=0
0 0 1 0 0 1 0 0 <- 输入值
0 0 0 0 1 0 0 1 <- 测试值
0 0 0 0 0 0 0 0 <- 结果：ZF=1
test指令总是清除溢出和进位标志位，其修改符号标志位、零标志位和奇偶标志位的方法与 AND 指令相同。
4.5 sete指令
根据eflags中的状态标志（CF,SF,OF,ZF和PF）将目标操作数设置为0或1。这里的目标操作数指向一个字节寄存器（也就是８位寄存器，如AL，BL，CL）或内存中的一个字节。状态码后缀（cc）指明了将要测试的条件。
获取标志位的指令的格式如下：
setcc R/M
指令根据标志寄存器eflags的值，将操作数设置为0或1。
setcc中的cc和Jcc中的cc类似，可参考表。
4.6 call指令
指令的格式如下：
call I/R/M
call指令会调用由操作数指定的函数。call指令会将指令的下一条指令的地址压栈，再跳转到操作数指定的地址，这样函数就能通过跳转到栈上的地址从子函数返回了。相当于
push %eip
jmp addr
先压入指令的下一个地址，然后跳转到目标地址addr。
4.7 ret指令
指令的格式如下：
ret
ret指令用于从子函数中返回。X86架构的Linux中是将函数的返回值设置到eax寄存器并返回的。相当于如下指令：
popl %eip
将call指令压栈的“call指令下一条指令的地址”弹出栈，并设置到指令指针中。这样程序就能正确地返回子函数的地方。
从物理上来说，CALL 指令将其返回地址压入堆栈，再把被调用过程的地址复制到指令指针寄存器。当过程准备返回时，它的 RET 指令从堆栈把返回地址弹回到指令指针寄存器。
4.8 enter指令
enter指令通过初始化ebp和esp寄存器来为函数建立函数参数和局部变量所需要的栈帧。相当于
push %rbp
mov %rsp,%rbp
4.9 leave指令
leave通过恢复ebp与esp寄存器来移除使用enter指令建立的栈帧。相当于
mov %rbp, %rsp
pop %rbp
将栈指针指向帧指针，然后pop备份的原帧指针到%ebp
5.0 int指令
指令的格式如下：
int I
引起给定数字的中断。这通常用于系统调用以及其他内核界面。
5、标志操作
eflags寄存器的各个标志位如下图所示。
操作eflags寄存器标志的一些指令如下表所示。
| 指令 | 操作数 | 描述 |
| pushfd | R | PUSHFD 指令把 32 位 EFLAGS 寄存器内容压入堆栈 |
| popfd | R | POPFD 指令则把栈顶单元内容弹出到 EFLAGS 寄存器 |
| cld | 将eflags.df设置为0 |
第19篇-加载与存储指令（1）
TemplateInterpreterGenerator::generate_all()函数会生成许多例程（也就是机器指令片段，英文叫Stub），包括调用set_entry_points_for_all_bytes()函数生成各个字节码对应的例程。
最终会调用到TemplateInterpreterGenerator::generate_and_dispatch()函数，调用堆栈如下：
TemplateTable::geneate() templateTable_x86_64.cpp
TemplateInterpreterGenerator::generate_and_dispatch() templateInterpreter.cpp
TemplateInterpreterGenerator::set_vtos_entry_points() templateInterpreter_x86_64.cpp
TemplateInterpreterGenerator::set_short_entry_points() templateInterpreter.cpp
TemplateInterpreterGenerator::set_entry_points() templateInterpreter.cpp
TemplateInterpreterGenerator::set_entry_points_for_all_bytes() templateInterpreter.cpp
TemplateInterpreterGenerator::generate_all() templateInterpreter.cpp
InterpreterGenerator::InterpreterGenerator() templateInterpreter_x86_64.cpp
TemplateInterpreter::initialize() templateInterpreter.cpp
interpreter_init() interpreter.cpp
init_globals() init.cpp
调用堆栈上的许多函数在之前介绍过，每个字节码都会指定一个generator函数，通过Template的_gen属性保存。在TemplateTable::generate()函数中调用。_gen会生成每个字节码对应的机器指令片段，所以非常重要。
首先看一个非常简单的nop字节码指令。这个指令的模板属性如下：
// Java spec bytecodes ubcp|disp|clvm|iswd in out generator argument
def(Bytecodes::_nop , ____|____|____|____, vtos, vtos, nop , _ );
nop字节码指令的生成函数generator不会生成任何机器指令，所以nop字节码指令对应的汇编代码中只有栈顶缓存的逻辑。调用set_vtos_entry_points()函数生成的汇编代码如下：
// aep
0x00007fffe1027c00: push %rax
0x00007fffe1027c01: jmpq 0x00007fffe1027c30
// fep
0x00007fffe1027c06: sub $0x8,%rsp
0x00007fffe1027c0a: vmovss %xmm0,(%rsp)
0x00007fffe1027c0f: jmpq 0x00007fffe1027c30
// dep
0x00007fffe1027c14: sub $0x10,%rsp
0x00007fffe1027c18: vmovsd %xmm0,(%rsp)
0x00007fffe1027c1d: jmpq 0x00007fffe1027c30
// lep
0x00007fffe1027c22: sub $0x10,%rsp
0x00007fffe1027c26: mov %rax,(%rsp)
0x00007fffe1027c2a: jmpq 0x00007fffe1027c30
// bep cep sep iep
0x00007fffe1027c2f: push %rax
// vep
// 接下来为取指逻辑，开始的地址为0x00007fffe1027c30
可以看到，由于tos_in为vtos，所以如果是aep、bep、cep、sep与iep时，直接使用push指令将%rax中存储的栈顶缓存值压入表达式栈中。对于fep、dep与lep来说，在栈上开辟对应内存的大小，然后将寄存器中的值存储到表达式的栈顶上，与push指令的效果相同。
在set_vtos_entry_points()函数中会调用generate_and_dispatch()函数生成nop指令的机器指令片段及取下一条字节码指令的机器指令片段。nop不会生成任何机器指令，而取指的片段如下：
// movzbl 将做了零扩展的字节传送到双字，地址为0x00007fffe1027c30
0x00007fffe1027c30: movzbl 0x1(%r13),%ebx
0x00007fffe1027c35: inc %r13
0x00007fffe1027c38: movabs $0x7ffff73ba4a0,%r10
// movabs的源操作数只能是立即数或标号（本质还是立即数），目的操作数是寄存器
0x00007fffe1027c42: jmpq *(%r10,%rbx,8)
r13指向当前要取的字节码指令的地址。那么%r13+1就是跳过了当前的nop指令而指向了下一个字节码指令的地址，然后执行movzbl指令将所指向的Opcode加载到%ebx中。
通过jmpq的跳转地址为%r10+%rbx*8，关于这个跳转地址在前面详细介绍过，这里不再介绍。
我们讲解了nop指令，把栈顶缓存的逻辑和取指逻辑又回顾了一遍，对于每个字节码指令来说都会有有栈顶缓存和取指逻辑，后面在介绍字节码指令时就不会再介绍这2个逻辑。
加载与存储相关操作的字节码指令如下表所示。
| 字节码 | 助词符 | 指令含义 |
| 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推送至栈顶 |
| 0x0a | lconst_1 | 将long型1推送至栈顶 |
| 0x0b | fconst_0 | 将float型0推送至栈顶 |
| 0x0c | fconst_1 | 将float型1推送至栈顶 |
| 0x0d | fconst_2 | 将float型2推送至栈顶 |
| 0x0e | dconst_0 | 将double型0推送至栈顶 |
| 0x0f | dconst_1 | 将double型1推送至栈顶 |
| 0x10 | bipush | 将单字节的常量值（-128~127）推送至栈顶 |
| 0x11 | sipush | 将一个短整型常量值（-32768~32767）推送至栈顶 |
| 0x12 | ldc | 将int、float或String型常量值从常量池中推送至栈顶 |
| 0x13 | ldc_w | 将int,、float或String型常量值从常量池中推送至栈顶（宽索引） |
| 0x14 | ldc2_w | 将long或double型常量值从常量池中推送至栈顶（宽索引） |
| 0x15 | iload | 将指定的int型本地变量推送至栈顶 |
| 0x16 | lload | 将指定的long型本地变量推送至栈顶 |
| 0x17 | fload | 将指定的float型本地变量推送至栈顶 |
| 0x18 | dload | 将指定的double型本地变量推送至栈顶 |
| 0x19 | aload | 将指定的引用类型本地变量推送至栈顶 |
| 0x1a | iload_0 | 将第一个int型本地变量推送至栈顶 |
| 0x1b | iload_1 | 将第二个int型本地变量推送至栈顶 |
| 0x1c | iload_2 | 将第三个int型本地变量推送至栈顶 |
| 0x1d | iload_3 | 将第四个int型本地变量推送至栈顶 |
| 0x1e | lload_0 | 将第一个long型本地变量推送至栈顶 |
| 0x1f | lload_1 | 将第二个long型本地变量推送至栈顶 |
| 0x20 | lload_2 | 将第三个long型本地变量推送至栈顶 |
| 0x21 | lload_3 | 将第四个long型本地变量推送至栈顶 |
| 0x22 | fload_0 | 将第一个float型本地变量推送至栈顶 |
| 0x23 | fload_1 | 将第二个float型本地变量推送至栈顶 |
| 0x24 | fload_2 | 将第三个float型本地变量推送至栈顶 |
| 0x25 | fload_3 | 将第四个float型本地变量推送至栈顶 |
| 0x26 | dload_0 | 将第一个double型本地变量推送至栈顶 |
| 0x27 | dload_1 | 将第二个double型本地变量推送至栈顶 |
| 0x28 | dload_2 | 将第三个double型本地变量推送至栈顶 |
| 0x29 | dload_3 | 将第四个double型本地变量推送至栈顶 |
| 0x2a | aload_0 | 将第一个引用类型本地变量推送至栈顶 |
| 0x2b | aload_1 | 将第二个引用类型本地变量推送至栈顶 |
| 0x2c | aload_2 | 将第三个引用类型本地变量推送至栈顶 |
| 0x2d | aload_3 | 将第四个引用类型本地变量推送至栈顶 |
| 0x2e | iaload | 将int型数组指定索引的值推送至栈顶 |
| 0x2f | laload | 将long型数组指定索引的值推送至栈顶 |
| 0x30 | faload | 将float型数组指定索引的值推送至栈顶 |
| 0x31 | daload | 将double型数组指定索引的值推送至栈顶 |
| 0x32 | aaload | 将引用型数组指定索引的值推送至栈顶 |
| 0x33 | baload | 将boolean或byte型数组指定索引的值推送至栈顶 |
| 0x34 | caload | 将char型数组指定索引的值推送至栈顶 |
| 0x35 | saload | 将short型数组指定索引的值推送至栈顶 |
| 0x36 | istore | 将栈顶int型数值存入指定本地变量 |
| 0x37 | lstore | 将栈顶long型数值存入指定本地变量 |
| 0x38 | fstore | 将栈顶float型数值存入指定本地变量 |
| 0x39 | dstore | 将栈顶double型数值存入指定本地变量 |
| 0x3a | astore | 将栈顶引用型数值存入指定本地变量 |
| 0x3b | istore_0 | 将栈顶int型数值存入第一个本地变量 |
| 0x3c | istore_1 | 将栈顶int型数值存入第二个本地变量 |
| 0x3d | istore_2 | 将栈顶int型数值存入第三个本地变量 |
| 0x3e | istore_3 | 将栈顶int型数值存入第四个本地变量 |
| 0x3f | lstore_0 | 将栈顶long型数值存入第一个本地变量 |
| 0x40 | lstore_1 | 将栈顶long型数值存入第二个本地变量 |
| 0x41 | lstore_2 | 将栈顶long型数值存入第三个本地变量 |
| 0x42 | lstore_3 | 将栈顶long型数值存入第四个本地变量 |
| 0x43 | fstore_0 | 将栈顶float型数值存入第一个本地变量 |
| 0x44 | fstore_1 | 将栈顶float型数值存入第二个本地变量 |
| 0x45 | fstore_2 | 将栈顶float型数值存入第三个本地变量 |
| 0x46 | fstore_3 | 将栈顶float型数值存入第四个本地变量 |
| 0x47 | dstore_0 | 将栈顶double型数值存入第一个本地变量 |
| 0x48 | dstore_1 | 将栈顶double型数值存入第二个本地变量 |
| 0x49 | dstore_2 | 将栈顶double型数值存入第三个本地变量 |
| 0x4a | dstore_3 | 将栈顶double型数值存入第四个本地变量 |
| 0x4b | astore_0 | 将栈顶引用型数值存入第一个本地变量 |
| 0x4c | astore_1 | 将栈顶引用型数值存入第二个本地变量 |
| 0x4d | astore_2 | 将栈顶引用型数值存入第三个本地变量 |
| 0x4e | astore_3 | 将栈顶引用型数值存入第四个本地变量 |
| 0x4f | iastore | 将栈顶int型数值存入指定数组的指定索引位置 |
| 0x50 | lastore | 将栈顶long型数值存入指定数组的指定索引位置 |
| 0x51 | fastore | 将栈顶float型数值存入指定数组的指定索引位置 |
| 0x52 | dastore | 将栈顶double型数值存入指定数组的指定索引位置 |
| 0x53 | aastore | 将栈顶引用型数值存入指定数组的指定索引位置 |
| 0x54 | bastore | 将栈顶boolean或byte型数值存入指定数组的指定索引位置 |
| 0x55 | castore | 将栈顶char型数值存入指定数组的指定索引位置 |
| 0x56 | sastore | 将栈顶short型数值存入指定数组的指定索引位置 |
| 0xc4 | wide | 扩充局部变量表的访问索引的指令 |
我们不会对每个字节码指令都查看对应的机器指令片段的逻辑（其实是反编译机器指令片段为汇编后，通过查看汇编理解执行逻辑），有些指令的逻辑是类似的，这里只选择几个典型的介绍。
1、压栈类型的指令
（1）aconst_null指令
aconst_null表示将null送到栈顶，模板定义如下：
def(Bytecodes::_aconst_null , ____|____|____|____, vtos, atos, aconst_null , _ );
指令的汇编代码如下：
// xor 指令在两个操作数的对应位之间进行逻辑异或操作，并将结果存放在目标操作数中
// 第1个操作数和第2个操作数相同时，执行异或操作就相当于执行清零操作
xor %eax,%eax
由于tos_out为atos，所以栈顶的结果是缓存在%eax寄存器中的，只对%eax寄存器执行xor操作即可。
（2）iconst_m1指令
iconst_m1表示将-1压入栈内，模板定义如下：
def(Bytecodes::_iconst_m1 , ____|____|____|____, vtos, itos, iconst , -1 );
生成的机器指令经过反汇编后，得到的汇编代码如下：
mov $0xffffffff,%eax
其它的与iconst_m1字节码指令类似的字节码指令，如iconst_0、iconst_1等，模板定义如下：
def(Bytecodes::_iconst_m1 , ____|____|____|____, vtos, itos, iconst , -1 );
def(Bytecodes::_iconst_0 , ____|____|____|____, vtos, itos, iconst , 0 );
def(Bytecodes::_iconst_1 , ____|____|____|____, vtos, itos, iconst , 1 );
def(Bytecodes::_iconst_2 , ____|____|____|____, vtos, itos, iconst , 2 );
def(Bytecodes::_iconst_3 , ____|____|____|____, vtos, itos, iconst , 3 );
def(Bytecodes::_iconst_4 , ____|____|____|____, vtos, itos, iconst , 4 );
def(Bytecodes::_iconst_5 , ____|____|____|____, vtos, itos, iconst , 5 );
可以看到，生成函数都是同一个TemplateTable::iconst()函数。
iconst_0的汇编代码如下：
xor %eax,%eax
iconst_@（@为1、2、3、4、5）的字节码指令对应的汇编代码如下：
// aep
0x00007fffe10150a0: push %rax
0x00007fffe10150a1: jmpq 0x00007fffe10150d0
// fep
0x00007fffe10150a6: sub $0x8,%rsp
0x00007fffe10150aa: vmovss %xmm0,(%rsp)
0x00007fffe10150af: jmpq 0x00007fffe10150d0
// dep
0x00007fffe10150b4: sub $0x10,%rsp
0x00007fffe10150b8: vmovsd %xmm0,(%rsp)
0x00007fffe10150bd: jmpq 0x00007fffe10150d0
// lep
0x00007fffe10150c2: sub $0x10,%rsp
0x00007fffe10150c6: mov %rax,(%rsp)
0x00007fffe10150ca: jmpq 0x00007fffe10150d0
// bep/cep/sep/iep
0x00007fffe10150cf: push %rax
// vep
0x00007fffe10150d0 mov $0x@,%eax // @代表1、2、3、4、5
如果看过我之前写的文章，那么如上的汇编代码应该能看懂，我在这里就不再做过多介绍了。
（3）bipush
bipush 将单字节的常量值推送至栈顶。模板定义如下：
def(Bytecodes::_bipush , ubcp|____|____|____, vtos, itos, bipush , _ );
指令的汇编代码如下：
// %r13指向字节码指令的地址，偏移1位
// 后取出1个字节的内容存储到%eax中
movsbl 0x1(%r13),%eax
由于tos_out为itos，所以将单字节的常量值存储到%eax中，这个寄存器是专门用来进行栈顶缓存的。
（4）sipush
sipush将一个短整型常量值推送到栈顶，模板定义如下：
def(Bytecodes::_bipush , ubcp|____|____|____, vtos, itos, bipush , _ );
生成的汇编代码如下：
// movzwl传送做了符号扩展字到双字
movzwl 0x1(%r13),%eax
// bswap 以字节为单位，把32/64位寄存器的值按照低和高的字节交换
bswap %eax
// （算术右移）指令将目的操作数进行算术右移
sar $0x10,%eax
Java中的短整型占用2个字节，所以需要对32位寄存器%eax进行一些操作。由于字节码采用大端存储，所以在处理时统一变换为小端存储。
2、存储类型指令
istore指令会将int类型数值存入指定索引的本地变量表，模板定义如下：
def(Bytecodes::_istore , ubcp|____|clvm|____, itos, vtos, istore , _ );
生成函数为TemplateTable::istore()，生成的汇编代码如下：
movzbl 0x1(%r13),%ebx
neg %rbx
mov %eax,(%r14,%rbx,8)
由于栈顶缓存tos_in为itos，所以直接将%eax中的值存储到指定索引的本地变量表中。
模板中指定ubcp，因为生成的汇编代码中会使用%r13，也就是字节码指令指针。
其它的istore、dstore等字节码指令的汇编代码逻辑也类似，这里不过多介绍。
第20篇-加载与存储指令之ldc与_fast_aldc指令（2）
ldc指令将int、float、或者一个类、方法类型或方法句柄的符号引用、还可能是String型常量值从常量池中推送至栈顶。
这一篇介绍一个虚拟机规范中定义的一个字节码指令ldc，另外还有一个虚拟机内部使用的字节码指令_fast_aldc。ldc指令可以加载String、方法类型或方法句柄的符号引用，但是如果要加载String、方法类型或方法句柄的符号引用，则会在类连接过程中重写ldc字节码指令为虚拟机内部使用的字节码指令_fast_aldc。下面我们详细介绍ldc指令如何加载int、float类型和类类型的数据，以及_fast_aldc加载String、方法类型或方法句柄，还有为什么要进行字节码重写等问题。
1、ldc字节码指令
ldc指令将int、float或String型常量值从常量池中推送至栈顶。模板的定义如下：
def(Bytecodes::_ldc , ubcp|____|clvm|____, vtos, vtos, ldc , false );
ldc字节码指令的格式如下：
// index是一个无符号的byte类型数据，指明当前类的运行时常量池的索引
ldc index
调用生成函数TemplateTable::ldc(bool wide)。函数生成的汇编代码如下：
第1部分代码：
// movzbl指令负责拷贝一个字节，并用0填充其目
// 的操作数中的其余各位，这种扩展方式叫"零扩展"
// ldc指定的格式为ldc index，index为一个字节
0x00007fffe1028530: movzbl 0x1(%r13),%ebx // 加载index到%ebx
// %rcx指向缓存池首地址、%rax指向类型数组_tags首地址
0x00007fffe1028535: mov -0x18(%rbp),%rcx
0x00007fffe1028539: mov 0x10(%rcx),%rcx
0x00007fffe102853d: mov 0x8(%rcx),%rcx
0x00007fffe1028541: mov 0x10(%rcx),%rax
// 从_tags数组获取操作数类型并存储到%edx中
0x00007fffe1028545: movzbl 0x4(%rax,%rbx,1),%edx
// $0x64代表JVM_CONSTANT_UnresolvedClass，比较，如果类还没有链接，
// 则直接跳转到call_ldc
0x00007fffe102854a: cmp $0x64,%edx
0x00007fffe102854d: je 0x00007fffe102855d // call_ldc
// $0x67代表JVM_CONSTANT_UnresolvedClassInError，也就是如果类在
// 链接过程中出现错误，则跳转到call_ldc
0x00007fffe102854f: cmp $0x67,%edx
0x00007fffe1028552: je 0x00007fffe102855d // call_ldc
// $0x7代表JVM_CONSTANT_Class，表示如果类已经进行了连接，则
// 跳转到notClass
0x00007fffe1028554: cmp $0x7,%edx
0x00007fffe1028557: jne 0x00007fffe10287c0 // notClass
// 类在没有连接或连接过程中出错，则执行如下的汇编代码
// -- call_ldc --
下面看一下调用call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1)函数生成的汇编代码，CAST_FROM_FN_PTR是宏，宏扩展后为( (address)((address_word)(InterpreterRuntime::ldc)) )。
在调用call_VM()函数时，传递的参数如下：
- %rax现在存储类型数组首地址，不过传入是为了接收调用函数的结果值
- adr是InterpreterRuntime::ldc()函数首地址
- c_rarg1用rdi寄存器存储wide值，这里为0，表示为没有加wide前缀的ldc指令生成汇编代码
生成的汇编代码如下：
第2部分：
// 将wide的值移到%esi寄存器，为后续
// 调用InterpreterRuntime::ldc()函数准备第2个参数
0x00007fffe102855d: mov $0x0,%esi
// 调用MacroAssembler::call_VM()函数，通过此函数来调用HotSpot VM中用
// C++编写的函数，通过这个C++编写的函数来调用InterpreterRuntime::ldc()函数
0x00007fffe1017542: callq 0x00007fffe101754c
0x00007fffe1017547: jmpq 0x00007fffe10175df // 跳转到E1
// 调用MacroAssembler::call_VM_helper()函数
// 将栈顶存储的返回地址设置到%rax中，也就是将存储地址0x00007fffe1017547
// 的栈的slot地址设置到%rax中
0x00007fffe101754c: lea 0x8(%rsp),%rax
// 调用InterpreterMacroAssembler::call_VM_base()函数
// 存储bcp到栈中特定位置
0x00007fffe1017551: mov %r13,-0x38(%rbp)
// 调用MacroAssembler::call_VM_base()函数
// 将r15中的值移动到rdi寄存器中，也就是为函数调用准备第一个参数
0x00007fffe1017555: mov %r15,%rdi
// 只有解释器才必须要设置fp
// 将last_java_fp保存到JavaThread类的last_java_fp属性中
0x00007fffe1017558: mov %rbp,0x200(%r15)
// 将last_java_sp保存到JavaThread类的last_java_sp属性中
0x00007fffe101755f: mov %rax,0x1f0(%r15)
// ... 省略调用MacroAssembler::call_VM_leaf_base()函数
// 重置JavaThread::last_java_sp与JavaThread::last_java_fp属性的值
0x00007fffe1017589: movabs $0x0,%r10
0x00007fffe1017593: mov %r10,0x1f0(%r15)
0x00007fffe101759a: movabs $0x0,%r10
0x00007fffe10175a4: mov %r10,0x200(%r15)
// check for pending exceptions (java_thread is set upon return)
0x00007fffe10175ab: cmpq $0x0,0x8(%r15)
// 如果没有异常则直接跳转到ok
0x00007fffe10175b3: je 0x00007fffe10175be
// 如果有异常则跳转到StubRoutines::forward_exception_entry()获取的例程入口
0x00007fffe10175b9: jmpq 0x00007fffe1000420
// -- ok --
// 将JavaThread::vm_result属性中的值存储到%rax寄存器中并清空vm_result属性的值
0x00007fffe10175be: mov 0x250(%r15),%rax
0x00007fffe10175c5: movabs $0x0,%r10
0x00007fffe10175cf: mov %r10,0x250(%r15)
// 结束调用MacroAssembler::call_VM_base()函数
// 恢复bcp与locals
0x00007fffe10175d6: mov -0x38(%rbp),%r13
0x00007fffe10175da: mov -0x30(%rbp),%r14
// 结束调用MacroAssembler::call_VM_helper()函数
0x00007fffe10175de: retq
// 结束调用MacroAssembler::call_VM()函数
下面详细解释如下汇编的意思。
call指令相当于如下两条指令：
push %eip
jmp addr
而ret指令相当于：
pop %eip
所以如上汇编代码：
0x00007fffe1017542: callq 0x00007fffe101754c
0x00007fffe1017547: jmpq 0x00007fffe10175df // 跳转
...
0x00007fffe10175de: retq
调用callq指令将jmpq的地址压入了表达式栈，也就是压入了返回地址x00007fffe1017547，这样当后续调用retq时，会跳转到jmpq指令执行，而jmpq又跳转到了0x00007fffe10175df地址处的指令执行。
通过调用MacroAssembler::call_VM()函数来调用HotSpot VM中用的C++编写的函数，call_VM()函数还会调用如下函数：
MacroAssembler::call_VM_helper
InterpreterMacroAssembler::call_VM_base()
MacroAssembler::call_VM_base()
MacroAssembler::call_VM_leaf_base()
在如上几个函数中，最重要的就是在MacroAssembler::call_VM_base()函数中保存rsp、rbp的值到JavaThread::last_java_sp与JavaThread::last_java_fp属性中，然后通过MacroAssembler::call_VM_leaf_base()函数生成的汇编代码来调用C++编写的InterpreterRuntime::ldc()函数，如果调用InterpreterRuntime::ldc()函数有可能破坏rsp和rbp的值（其它的%r13、%r14等的寄存器中的值也有可能破坏，所以在必要时保存到栈中，在调用完成后再恢复，这样这些寄存器其实就算的上是调用者保存的寄存器了），所以为了保证rsp、rbp，将这两个值存储到线程中，在线程中保存的这2个值对于栈展开非常非常重要，后面我们会详细介绍。
由于如上汇编代码会解释执行，在解释执行过程中会调用C++函数，所以C/C++栈和Java栈都混在一起，这为我们查找带来了一定的复杂度。
调用的MacroAssembler::call_VM_leaf_base()函数生成的汇编代码如下：
第3部分汇编代码：
// 调用MacroAssembler::call_VM_leaf_base()函数
0x00007fffe1017566: test $0xf,%esp // 检查对齐
// %esp对齐的操作，跳转到 L
0x00007fffe101756c: je 0x00007fffe1017584
// %esp没有对齐时的操作
0x00007fffe1017572: sub $0x8,%rsp
0x00007fffe1017576: callq 0x00007ffff66a22a2 // 调用函数，也就是调用InterpreterRuntime::ldc()函数
0x00007fffe101757b: add $0x8,%rsp
0x00007fffe101757f: jmpq 0x00007fffe1017589 // 跳转到E2
// -- L --
// %esp对齐的操作
0x00007fffe1017584: callq 0x00007ffff66a22a2 // 调用函数，也就是调用InterpreterRuntime::ldc()函数
// -- E2 --
// 结束调用
MacroAssembler::call_VM_leaf_base()函数
在如上这段汇编中会真正调用C++函数InterpreterRuntime::ldc()，由于这是一个C++函数，所以在调用时，如果要传递参数，则要遵守C++调用约定，也就是前6个参数都放到固定的寄存器中。这个函数需要2个参数，分别为thread和wide，已经分别放到了%rdi和%rax寄存器中了。InterpreterRuntime::ldc()函数的实现如下：
// ldc负责将数值常量或String常量值从常量池中推送到栈顶
IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide))
ConstantPool* pool = method(thread)->constants();
int index = wide ? get_index_u2(thread, Bytecodes::_ldc_w) : get_index_u1(thread, Bytecodes::_ldc);
constantTag tag = pool->tag_at(index);
Klass* klass = pool->klass_at(index, CHECK);
oop java_class = klass->java_mirror(); // java.lang.Class通过oop来表示
thread->set_vm_result(java_class);
IRT_END
函数将查找到的、当前正在解释执行的方法所属的类存储到JavaThread类的vm_result属性中。我们可以回看第2部分汇编代码，会将vm_result属性的值设置到%rax中。
接下来继续看TemplateTable::ldc(bool wide)函数生成的汇编代码，此时已经通过调用call_VM()函数生成了调用InterpreterRuntime::ldc()这个C++的汇编，调用完成后值已经放到了%rax中。
// -- E1 --
0x00007fffe10287ba: push %rax // 将调用的结果存储到表达式中
0x00007fffe10287bb: jmpq 0x00007fffe102885e // 跳转到Done
// -- notClass --
// $0x4表示JVM_CONSTANT_Float
0x00007fffe10287c0: cmp $0x4,%edx
0x00007fffe10287c3: jne 0x00007fffe10287d9 // 跳到notFloat
// 当ldc字节码指令加载的数为float时执行如下汇编代码
0x00007fffe10287c5: vmovss 0x58(%rcx,%rbx,8),%xmm0
0x00007fffe10287cb: sub $0x8,%rsp
0x00007fffe10287cf: vmovss %xmm0,(%rsp)
0x00007fffe10287d4: jmpq 0x00007fffe102885e // 跳转到Done
// -- notFloat --
// 当ldc字节码指令加载的为非float，也就是int类型数据时通过push加入表达式栈
0x00007fffe1028859: mov 0x58(%rcx,%rbx,8),%eax
0x00007fffe102885d: push %rax
// -- Done --
由于ldc指令除了加载String外，还可能加载int和float，如果是int，直接调用push压入表达式栈中，如果是float，则在表达式栈上开辟空间，然后移到到这个开辟的slot中存储。注意，float会使用%xmm0寄存器。
2、fast_aldc虚拟机内部字节码指令
下面介绍_fast_aldc指令，这个指令是虚拟机内部使用的指令而非虚拟机规范定义的指令。_fast_aldc指令的模板定义如下：
def(Bytecodes::_fast_aldc , ubcp|____|clvm|____, vtos, atos, fast_aldc , false );
生成函数为TemplateTable::fast_aldc(bool wide)，这个函数生成的汇编代码如下：
// 调用InterpreterMacroAssembler::get_cache_index_at_bcp()函数生成
// 获取字节码指令的操作数，这个操作数已经指向了常量池缓存项的索引，在字节码重写
// 阶段已经进行了字节码重写
0x00007fffe10243d0: movzbl 0x1(%r13),%edx
// 调用InterpreterMacroAssembler::load_resolved_reference_at_index()函数生成
// shl表示逻辑左移，相当于乘4,因为ConstantPoolCacheEntry的大小为4个字
0x00007fffe10243d5: shl $0x2,%edx
// 获取Method*
0x00007fffe10243d8: mov -0x18(%rbp),%rax
// 获取ConstMethod*
0x00007fffe10243dc: mov 0x10(%rax),%rax
// 获取ConstantPool*
0x00007fffe10243e0: mov 0x8(%rax),%rax
// 获取ConstantPool::_resolved_references属性的值，这个值
// 是一个指向对象数组的指针
0x00007fffe10243e4: mov 0x30(%rax),%rax
// JNIHandles::resolve(obj)
0x00007fffe10243e8: mov (%rax),%rax
// 从_resolved_references数组指定的下标索引处获取oop，先进行索引偏移
0x00007fffe10243eb: add %rdx,%rax
// 要在%rax上加0x10，是因为数组对象的头大小为2个字，加上后
// %rax就指向了oop
0x00007fffe10243ee: mov 0x10(%rax),%eax
获取_resolved_references属性的值，涉及到的2个属性在ConstantPool类中的定义如下：
// Array of resolved objects from the constant pool and map from resolved
// object index to original constant pool index
jobject _resolved_references; // jobject是指针类型
Array* _reference_map;
关于_resolved_references指向的其实是Object数组。在ConstantPool::initialize_resolved_references()函数中初始化这个属性。调用链如下：
ConstantPool::initialize_resolved_references() constantPool.cpp
Rewriter::make_constant_pool_cache() rewriter.cpp
Rewriter::Rewriter() rewriter.cpp
Rewriter::rewrite() rewriter.cpp
InstanceKlass::rewrite_class() instanceKlass.cpp
InstanceKlass::link_class_impl() instanceKlass.cpp
后续如果需要连接ldc等指令时，可能会调用如下函数：（我们只讨论ldc加载String类型数据的问题，所以我们只看往_resolved_references属性中放入表示String的oop的逻辑，MethodType与MethodHandle将不再介绍，有兴趣的可自行研究）
oop ConstantPool::string_at_impl(
constantPoolHandle this_oop,
int which,
int obj_index,
TRAPS
) {
oop str = this_oop->resolved_references()->obj_at(obj_index);
if (str != NULL)
return str;
Symbol* sym = this_oop->unresolved_string_at(which);
str = StringTable::intern(sym, CHECK_(NULL));
this_oop->string_at_put(which, obj_index, str);
return str;
}
void string_at_put(int which, int obj_index, oop str) {
// 获取类型为jobject的_resolved_references属性的值
objArrayOop tmp = resolved_references();
tmp->obj_at_put(obj_index, str);
}
在如上函数中向_resolved_references数组中设置缓存的值。
大概的思路就是：如果ldc加载的是字符串，那么尽量通过_resolved_references数组中一次性找到表示字符串的oop，否则要通过原常量池下标索引找到Symbol实例（Symbol实例是HotSpot VM内部使用的、用来表示字符串），根据Symbol实例生成对应的oop，然后通过常量池缓存下标索引设置到_resolved_references中。当下次查找时，通过这个常量池缓存下标缓存找到表示字符串的oop。
获取到_resolved_references属性的值后接着看生成的汇编代码，如下：
// ...
// %eax中存储着表示字符串的oop
0x00007fffe1024479: test %eax,%eax
// 如果已经获取到了oop，则跳转到resolved
0x00007fffe102447b: jne 0x00007fffe1024481
// 没有获取到oop，需要进行连接操作，0xe5是_fast_aldc的Opcode
0x00007fffe1024481: mov $0xe5,%edx
调用call_VM()函数生成的汇编代码如下：
// 调用InterpreterRuntime::resolve_ldc()函数
0x00007fffe1024486: callq 0x00007fffe1024490
0x00007fffe102448b: jmpq 0x00007fffe1024526
// 将%rdx中的ConstantPoolCacheEntry项存储到第1个参数中
// 调用MacroAssembler::call_VM_helper()函数生成
0x00007fffe1024490: mov %rdx,%rsi
// 将返回地址加载到%rax中
0x00007fffe1024493: lea 0x8(%rsp),%rax
// 调用call_VM_base()函数生成
// 保存bcp
0x00007fffe1024498: mov %r13,-0x38(%rbp)
// 调用MacroAssembler::call_VM_base()函数生成
// 将r15中的值移动到c_rarg0(rdi)寄存器中，也就是为函数调用准备第一个参数
0x00007fffe102449c: mov %r15,%rdi
// Only interpreter should have to set fp 只有解释器才必须要设置fp
0x00007fffe102449f: mov %rbp,0x200(%r15)
0x00007fffe10244a6: mov %rax,0x1f0(%r15)
// 调用MacroAssembler::call_VM_leaf_base()生成
0x00007fffe10244ad: test $0xf,%esp
0x00007fffe10244b3: je 0x00007fffe10244cb
0x00007fffe10244b9: sub $0x8,%rsp
0x00007fffe10244bd: callq 0x00007ffff66b27ac
0x00007fffe10244c2: add $0x8,%rsp
0x00007fffe10244c6: jmpq 0x00007fffe10244d0
0x00007fffe10244cb: callq 0x00007ffff66b27ac
0x00007fffe10244d0: movabs $0x0,%r10
// 结束调用MacroAssembler::call_VM_leaf_base()
0x00007fffe10244da: mov %r10,0x1f0(%r15)
0x00007fffe10244e1: movabs $0x0,%r10
// 检查是否有异常发生
0x00007fffe10244eb: mov %r10,0x200(%r15)
0x00007fffe10244f2: cmpq $0x0,0x8(%r15)
// 如果没有异常发生，则跳转到ok
0x00007fffe10244fa: je 0x00007fffe1024505
// 有异常发生，则跳转到StubRoutines::forward_exception_entry()
0x00007fffe1024500: jmpq 0x00007fffe1000420
// ---- ok ----
// 将JavaThread::vm_result属性中的值存储到oop_result寄存器中并清空vm_result属性的值
0x00007fffe1024505: mov 0x250(%r15),%rax
0x00007fffe102450c: movabs $0x0,%r10
0x00007fffe1024516: mov %r10,0x250(%r15)
// 结果调用MacroAssembler::call_VM_base()函数
// 恢复bcp和locals
0x00007fffe102451d: mov -0x38(%rbp),%r13
0x00007fffe1024521: mov -0x30(%rbp),%r14
// 结束调用InterpreterMacroAssembler::call_VM_base()函数
// 结束调用MacroAssembler::call_VM_helper()函数
0x00007fffe1024525: retq
// 结束调用MacroAssembler::call_VM()函数，回到
// TemplateTable::fast_aldc()函数继续看生成的代码，只
// 定义了resolved点
// ---- resolved ----
调用的InterpreterRuntime::resolve_ldc()函数的实现如下：
IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(
JavaThread* thread,
Bytecodes::Code bytecode)
) {
ResourceMark rm(thread);
methodHandle m (thread, method(thread));
Bytecode_loadconstant ldc(m, bci(thread));
oop result = ldc.resolve_constant(CHECK);
thread->set_vm_result(result);
}
IRT_END
这个函数会调用一系列的函数，相关调用链如下：
ConstantPool::string_at_put() constantPool.hpp
ConstantPool::string_at_impl() constantPool.cpp
ConstantPool::resolve_constant_at_impl() constantPool.cpp
ConstantPool::resolve_cached_constant_at() constantPool.hpp
Bytecode_loadconstant::resolve_constant() bytecode.cpp
InterpreterRuntime::resolve_ldc() interpreterRuntime.cpp
其中ConstantPool::string_at_impl()函数在前面已经详细介绍过。
调用的resolve_constant()函数的实现如下：
oop Bytecode_loadconstant::resolve_constant(TRAPS) const {
int index = raw_index();
ConstantPool* constants = _method->constants();
if (has_cache_index()) {
return constants->resolve_cached_constant_at(index, THREAD);
} else {
return constants->resolve_constant_at(index, THREAD);
}
}
调用的resolve_cached_constant_at()或resolve_constant_at()函数的实现如下：
oop resolve_cached_constant_at(int cache_index, TRAPS) {
constantPoolHandle h_this(THREAD, this);
return resolve_constant_at_impl(h_this, _no_index_sentinel, cache_index, THREAD);
}
oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) {
constantPoolHandle h_this(THREAD, this);
return resolve_constant_at_impl(h_this, pool_index, _possible_index_sentinel, THREAD);
}
调用的resolve_constant_at_impl()函数的实现如下：
oop ConstantPool::resolve_constant_at_impl(
constantPoolHandle this_oop,
int index,
int cache_index,
TRAPS
) {
oop result_oop = NULL;
Handle throw_exception;
if (cache_index == _possible_index_sentinel) {
cache_index = this_oop->cp_to_object_index(index);
}
if (cache_index >= 0) {
result_oop = this_oop->resolved_references()->obj_at(cache_index);
if (result_oop != NULL) {
return result_oop;
}
index = this_oop->object_to_cp_index(cache_index);
}
jvalue prim_value; // temp used only in a few cases below
int tag_value = this_oop->tag_at(index).value();
switch (tag_value) {
// ...
case JVM_CONSTANT_String:
assert(cache_index != _no_index_sentinel, "should have been set");
if (this_oop->is_pseudo_string_at(index)) {
result_oop = this_oop->pseudo_string_at(index, cache_index);
break;
}
result_oop = string_at_impl(this_oop, index, cache_index, CHECK_NULL);
break;
// ...
}
if (cache_index >= 0) {
Handle result_handle(THREAD, result_oop);
MonitorLockerEx ml(this_oop->lock());
oop result = this_oop->resolved_references()->obj_at(cache_index);
if (result == NULL) {
this_oop->resolved_references()->obj_at_put(cache_index, result_handle());
return result_handle();
} else {
return result;
}
} else {
return result_oop;
}
}
通过常量池的tags数组判断，如果常量池下标index处存储的是JVM_CONSTANT_String常量池项，则调用string_at_impl()函数，这个函数在之前已经介绍过，会根据表示字符串的Symbol实例创建出表示字符串的oop。在ConstantPool::resolve_constant_at_impl()函数中得到oop后就存储到ConstantPool::_resolved_references属性中，最后返回这个oop，这正是ldc需要的oop。
通过重写fast_aldc字节码指令，达到了通过少量指令就直接获取到oop的目的，而且oop是缓存的，所以字符串常量在HotSpot VM中的表示唯一，也就是只有一个oop表示。
C++函数约定返回的值会存储到%rax中，根据_fast_aldc字节码指令的模板定义可知，tos_out为atos，所以后续并不需要进一步操作。
HotSpot VM会在类的连接过程中重写某些字节码，如ldc字节码重写为fast_aldc，还有常量池的tags类型数组、常量池缓存等内容在《深入剖析Java虚拟机：源码剖析与实例详解》中详细介绍过，这里不再介绍。
第21篇-加载与存储指令之ldc与_fast_aldc指令（3）
iload会将int类型的本地变量推送至栈顶。模板定义如下：
def(Bytecodes::_iload , ubcp|____|clvm|____, vtos, itos, iload , _ );
iload指令的格式如下：
iload index
index是一个无符号byte类型整数，指向局部变量表的索引值。
生成函数为TemplateTable::iload()，反编译后的汇编代码如下：
// 将%ebx指向下一条字节码指令的首地址
0x00007fffe1028d30: movzbl 0x2(%r13),%ebx
// $0x15为_iload指令的操作码值
0x00007fffe1028d35: cmp $0x15,%ebx
// 当下一条指令为iload时，直接跳转到done
0x00007fffe1028d38: je 0x00007fffe1028deb // done
// 0xdf为_fast_iload指令的操作码值
0x00007fffe1028d3e: cmp $0xdf,%ebx
// 将_fast_iload2指令移动到%ecx
0x00007fffe1028d44: mov $0xe0,%ecx
0x00007fffe1028d49: je 0x00007fffe1028d5a // rewrite
// 0x34为_caload指令的操作码
// _caload指令表示从数组中加载一个char类型数据到操作数栈
0x00007fffe1028d4b: cmp $0x34,%ebx
// 将_fast_icaload移动到%ecx中
0x00007fffe1028d4e: mov $0xe1,%ecx
0x00007fffe1028d53: je 0x00007fffe1028d5a // rewrite
// 将_fast_iload移动到%ecx中
0x00007fffe1028d55: mov $0xdf,%ecx
// -- rewrite --
// 调用patch_bytecode()函数
// 重写为fast版本，因为%cl中存储的是字节码的fast版本，%ecx的8位叫%cl
0x00007fffe1028de7: mov %cl,0x0(%r13)
// -- done --
// 获取字节码指令的操作数，这个操作数为本地变量表的索引
0x00007fffe1028deb: movzbl 0x1(%r13),%ebx
0x00007fffe1028df0: neg %rbx
// 通过本地变量表索引从本地变量表中加载值到%eax中，
// %eax中存储的就是栈顶缓存值，所以不需要压入栈内
0x00007fffe1028df3: mov (%r14,%rbx,8),%eax
执行的逻辑如下：
假设现在有个方法的字节码指令流为连接3个iload指令，这3个iload指令前后都为非iload指令。那么重写的过程如下：
汇编代码在第一次执行时，如果判断最后一个_iload之后是非_iload指令，则会重写最后一个_iload指令为_fast_iload；第二次执行时，当第2个字节码指令为_iload，而之后接着判断为_fast_iload时，会更新第2个_iload为_fast_iload2。
执行_fast_iload和执行_fast_iload2都可以提高程序执行的效率，_fast_icaload指令也一样，下面详细介绍一下这几个指令。
1、_fast_iload指令
_fast_iload会将int类型的本地变量推送至栈顶。模板定义如下：
def(Bytecodes::_fast_iload , ubcp|____|____|____, vtos, itos, fast_iload , _ );
生成函数为TemplateTable::fast_iload() ，汇编代码如下：
0x00007fffe1023f90: movzbl 0x1(%r13),%ebx
0x00007fffe1023f95: neg %rbx
0x00007fffe1023f98: mov (%r14,%rbx,8),%eax
汇编代码很简单，这里不再过多说。
执行_fast_iload指令与执行_iload指令相比，不用再进行之前汇编介绍的那么多判断，也没有重写的逻辑，所以会提高执行效率。
2、_fast_iload2指令
_fast_iload2会将int类型的本地变量推送至栈顶。模板定义如下：
def(Bytecodes::_fast_iload2 , ubcp|____|____|____, vtos, itos, fast_iload2 , _ );
生成函数为TemplateTable::fast_iload2() ，汇编代码如下：
0x00007fffe1024010: movzbl 0x1(%r13),%ebx
0x00007fffe1024015: neg %rbx
0x00007fffe1024018: mov (%r14,%rbx,8),%eax
0x00007fffe102401c: push %rax
0x00007fffe102401d: movzbl 0x3(%r13),%ebx
0x00007fffe1024022: neg %rbx
0x00007fffe1024025: mov (%r14,%rbx,8),%eax
可以看到，此指令就相当于连续执行了2次iload指令，省去了指令跳转，所以效率要高一些。
3、_fast_icaload指令
caload指令表示从数组中加载一个char类型数据到操作数栈。
_fast_icaload会将char类型数组指定索引的值推送至栈顶。模板定义如下：
def(Bytecodes::_fast_icaload , ubcp|____|____|____, vtos, itos, fast_icaload , _ );
生成函数为TemplateTable::fast_icaload()，生成的汇编代码如下：
0x00007fffe1024090: movzbl 0x1(%r13),%ebx
0x00007fffe1024095: neg %rbx
// %eax中存储着index
0x00007fffe1024098: mov (%r14,%rbx,8),%eax
// %rdx中存储着arrayref
0x00007fffe102409c: pop %rdx
// 将一个双字扩展后送到一个四字中,%rax中存储着index
0x00007fffe102409d: movslq %eax,%rax
// %rdx指向数组对象的首地址，偏移0xc后获取length属性的值
0x00007fffe10240a0: cmp 0xc(%rdx),%eax
0x00007fffe10240a3: mov %eax,%ebx
// 如果数组索引index等于数组的长度或大于数组长度时，那么跳转
// 到_throw_ArrayIndexOutOfBoundsException_entry抛出异常
0x00007fffe10240a5: jae 0x00007fffe100ff20
// 在指定数组arrayref中加载指定索引处index的值
0x00007fffe10240ab: movzwl 0x10(%rdx,%rax,2),%eax
可以看到，此指令省去了指令跳转，所以效率要高一些。
由于字数限制，《模板解释器解释执行Java字节码指令（下）》将在下篇中释出