程序的机器级表示part2——访问信息
目录
1. 整数寄存器
2. 操作数指示符与寻址模式
3. 数据传送指令
4. 压入和弹出栈数据
1. 整数寄存器
一个x86-64的CPU包含一组16个存储64位值的通用目的寄存器(general-purpose registers)
整型寄存器
x86-64的CPU是64位的，因此相应的寄存器长度与机器字长(数据总线位宽)相同，也为64位。而每一个寄存器又能分为不同的几个部分，供不同的操作使用，这是由于指令集的不断发展导致的
最初的8086中有8个16位的寄存器，即图中的%ax-%sp
扩展到IA32架构时，这些寄存器也扩展32位，标号%eax-%esp
扩展到x86-64后，寄存器进一步扩展到64位，即%rax-%rsp，并新增了8个寄存器：%r8-%r15
对于%rax、%rbx、%rcx和%rdx寄存器，低16位又可分为两部分
一条指令可以使用寄存器的低1、2、4、8字节，分别对应字节级操作、16位操作、32位操作和64位操作
当指令以寄存器作为目标时，对于生成小于8字节结果的指令，有如下规则：
- 生成1字节和2字节数字的指令会保持剩下的字节不变
- 生成4字节数字的指令会把高位4个字节置0
例题：
在x86-64计算机中，若地址0x1300~0x1307的8个内存字节的数值依次时0x40、0x41、0x42、0x43、0x44、0x45、0x46、0x47，寄存器%rbx=0x1020304050607080，则
(1) 执行汇编指令"mov $0x1300, %ebx"后，寄存器 rbx 的数值是多少？
(2) 继续执行指令"mov 2(%ebx), %eax"后，寄存器 ah 的数值是多少？
(3) 继续执行指令"add (%ebx), %eax"后，寄存器 ah 的数值是多少？
1. 首先注意到汇编指令"mov $0x1300, %ebx"没有给出操作数大小后缀，并且观察到目标操作数为寄存器%ebx，是一个32位寄存器，因此实际上是将0x00001300这样一个四字节数传送到%ebx内，这样的操作会使得寄存器%rbx内原来的高位字节置0，此时%rbx内的值位0x0000000000001300，故答案是0x1300
2. 在1的基础上继续执行"mov 2(%ebx), %eax"，将地址(0x1300+2)处开始，四字节的值传送到%eax内，同样将高4位置0，%eax内的值为0x45444342(和上图方向相同，从左到右由高位到低位)，则%ah内存放0x43
3.在2的基础上继续执行"add (%ebx), %eax"，将地址(0x1300)处开始，四字节的值与寄存器%eax中的值相加，同样将高4位置0，实际上是0x40414243+0x42434445 = 0x82848688，因此%ah内存放0x84
从上图中还能看出，每个寄存器都有自己的作用，特别的比如栈指针%rsp，用来执行函数栈帧结束的位置，后面将会频繁使用这些寄存器，届时会对这些寄存器有更深的理解
2. 操作数指示符与寻址模式
大多数指令有一个或多个操作数(operand)，指示出一个操作中要使用的源数据值，以及放置结果的目的位置
比如一条指令，根据AT&T汇编代码的格式，左边是源操作数，右边是目的操作数，这条指令执行的操作是将100这个立即数放到寄存器%rax中，100是源数据值，寄存器%rax是目的位置
addq $100 %raxx86-64支持多种操作数格式。其中，源操作数可以是
- 以常数形式给出(上述指令中源操作数为常数100)
- 从寄存器中读出
- 从内存中读出
结果可以存放在
- 寄存器(上述指令中将结果放在寄存器中)
- 内存
因此，各种不同的操作数被分为三种类型：
- 立即数( immediate )，整型常数，以$开头如$2023、$0x23。AT&T汇编要在立即数前加$
- 寄存器( register )，加前缀%，如%eax、%rcx。表示某个寄存器的内容
- 内存引用( memory reference )，指定内存地址开始的连续字节，地址的指定方式有多种
在x86-64中，
- 对于寄存器，我们用符号ra来表示一个寄存器，R[ra]来表示寄存器内的值
- 对于内存，我们用符号M[Addr]来表示对内存的引用
寻址模式分很多种，如下表所示，允许不同内存的引用。最一般情况的表达式是Imm(rb, ri, s)，它有四个组成部分—— 一个立即数Imm用来表示偏移量，一个基址寄存器rb，一个变址寄存器ri和一个比例因子s(这里的s必须为1、2、4或8，一般s用于数组的索引，数组元素类型为char、short、int、double对应的比例因子就是1、2、4和8)。有效地址的计算方法为 Imm + R[rb]+ R[ri] * s
举个例子，一个存放 int 类型数据的数组arr的起始地址为0x101，寄存器rb中存放基地址0x100，偏移量Imm为0x1，通过R[rb] + Imm 可以得到数组的起始地址，由于数据类型是int，因此比例因子是4，假设要访问数组第2个数据，变址寄存器内存的就是2，那么对于数组内第二个元素arr[2]的寻址就是 0x1 + 0x100 + 4 * 2
| 类型 | 格式 | 操作数值 | 名称 |
| 立即数 | $Imm | Imm | 立即数寻址 |
| 寄存器 | ra |
R[ra] |
寄存器寻址 |
| 存储器 | Imm | M[Imm] | 绝对寻址 |
| 存储器 | (ra) | M[R[ra]] | 间接寻址 |
| 存储器 | Imm(rb) | M[Imm + R[ra]] | (基址+偏移量)寻址 |
| 存储器 | (rb, ri) | M[R[rb] + R[rb]] | 变址寻址 |
| 存储器 | Imm(rb, ri) | M[Imm + R[rb] + R[rb]] | 变址寻址 |
| 存储器 | (, ri, s) |
M[R[ri] * s] | 比例变址寻址 |
| 存储器 | Imm(, ri, s) | M[Imm + R[ri] * s] | 比例变址寻址 |
| 存储器 | (rb, ri, s) | M[R[rb] + R[ri] * s] | 比例变址寻址 |
| 存储器 | Imm(rb, ri, s) | M[Imm + R[rb] + R[ri] * s] | 比例变址寻址 |
练习
假设下面的值存放在指明的内存地址和寄存器中：
地址 值 0x100 0xFF 0x104 0xAB 0x108 0x13 0x10C 0x11
寄存器 值 %rax 0x100 %rcx 0x1 %rdx 0x3 给出操作数的值：
%rax —— 0x100 ，对应类型2，值为R[ra]，直接给出一个寄存器，其值就是寄存器里的值
0x104 —— 0xAB，对应类型3，值为M[Imm]，常数前不加$说明这是一个地址，取出该地址处的值
$0x108 —— 0x108，对应类型1，值为Imm，常数前面有$，说明以这个立即数作为操作数的值
(%rax) —— 0xFF，对应类型4，值为M[R[ra]]，把寄存器里的值当作地址，取出该地址的值(地址0x100)
4(%rax) —— 0xAB，对应类型5，值为M[Imm + R[ra]]，把寄存器里的值当作基址，立即数当作偏移量，算出地址(0x100 + 0x4 = 0x104)
9(%rax,%rdx) —— 0x11，对应类型7，值为M[Imm + R[rb] + R[rb]]，(0x100 + 0x3 + 0x9 = 0x10C)
0xFC(,%rcx,4) —— 0xFF，对应类型9，值为M[Imm + R[ri] * s]，(0xFC + 0x1 * 4 = 0x100)
(%rax,%rdx,4) —— 0x11，对应类型10，值为M[R[rb] + R[ri] * s]，(0x100 + 0x3 * 4 = 0x10C)
3. 数据传送指令
数据传送指令是最频繁使用的指令，其作用是将数据从一个位置复制到另一个位置
MOV
| 指令 | 效果 | 描述 |
|---|---|---|
| MOV S, D | D ← S | 传送 |
| movb | D ← S | 传送字节(Byte) |
| movw | D ← S | 传送字(2Byte) |
| movl | D ← S | 传送双字(4Byte) |
| movq | D ← S | 传送四字(8Byte) |
| movabsq | R ← I | 传送绝对的四字(8Byte) |
D表示目的操作数，S表示源操作数，I表示立即数
这些mov指令的后面一般会跟上操作数的大小指示符，‘b’、‘w’、‘l’、‘q’分别对应1、2、4、8字节的数据，当这些操作数是寄存器操作数时，寄存器的大小必须要和大小指示符相对应
movb $0xF, (%ebx)
错误，x86-64下的地址是64位的，(%ebx)表示以%ebx内的值作为地址，长度不够，内存引用的寄存器必须是64位
movl %rax (%rsp)
错误，大小指示符l表示操作数位32位，%rax是64位寄存器，应该用%eax或将l改成q
movl %eax %rdx
错误，%rdx是64位的，不应该用来接受32位的值对于数据传送指令的源操作数有如下规定：
- 只能是存储在寄存器或内存中的立即数
目的操作数有如下规定：
- 目的操作数必须指定一个位置，要么是一个寄存器，要么是一个内存地址
- 目的操作数和源操作数不能同时为内存，也就是说单条指令不能进行从内存到内存的数据传送
将一个内存位置的数据传到另一个内存地址需要两条指令，即先用一条指令将源值加载到寄存器中，第二条指令将该寄存器的值写入目的内存位置
movw (%rax) 4(%rsp) // 这是一条错误的指令，其本意是以%rax内的值作为地址，将该地址处的值复制到地址%rsp内的值 + 4处
// 正确的写法应该是
movw (%rax) %cx // 先将16位的数(大小指示符w)从源地址取出放到%cx(16位寄存器)
movw %cx 4(%rsp) // 再将%cx的值传送到目的位置下面给出源和目的类型的五种可能组合，第一个是源操作数，第二个是目的操作数
movl $0x4050,%eax 立即数传送到寄存器中, 4 bytes
movw %bp,%sp 寄存器的值传送到寄存器中, 2 bytes
movb (%rdi,%rcx),%al 内存的值传送到寄存器中, 1 byte
movb $-17,(%esp) 立即数传送到内存中, 1 byte
movq %rax,-12(%rbp) 寄存器的值传送到内存中, 8 bytes大多数情况下，MOV指令只会更新目的操作数指定的那些寄存器字节或内存地址，也就是说如果是movb指令（对应的目的寄存器应该是%al，8位），它只会更改%rax的低8位也就是%al部分
然而一个例外是movl指令以寄存器作为目标操作数，我们之前提到过，当指令以寄存器作为目标时，生成4字节的数字的指令会把高位4个字节置0。重新看上面的例题，或许会有更深的感悟
普通的movq指令只能以表示为32位补码数字的立即数作为源操作数，然后把这个值符号扩展到64位，movabsq指令能够以任意64位立即数作为源操作数，并且只能以寄存器作为目的
我们在C语言中学到过整型提升，它按照变量的数据类型的符号位进行提升的，比如下面的代码
int main()
{
short a = 1;
int b = a; // 16位a提升为32为的b
return 0;
}
通过汇编代码查看这一提升是如何实现的
00000000004004ed :
4004ed: 55 push %rbp
4004ee: 48 89 e5 mov %rsp,%rbp
4004f1: 66 c7 45 fe 01 00 movw $0x1,-0x2(%rbp) // 将1这个立即数复制到内存地址(%rbp-2)处,这个内存地址就是a的地址
4004f7: 0f bf 45 fe movswl -0x2(%rbp),%eax // 将1(16位)传送给寄存器%eax(32位)
4004fb: 89 45 f8 mov %eax,-0x8(%rbp) // 将%eax里的值(1)复制到内存地址(%rbp-8)处,这个内存地址就是b的地址
4004fe: b8 00 00 00 00 mov $0x0,%eax
400503: 5d pop %rbp
400504: c3 retq
400505: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
40050c: 00 00 00
40050f: 90 nop
注意看4004f7处的汇编，movswl -0x2(%rbp), %eax，这是一条符号扩展数据传送指令
当我们要将较小的源值复制到较大的目的时使用的指令有两类MOVZ和MOVS
MOVZ
| 指令 | 效果 | 描述 |
|---|---|---|
| MOVZ S, R | R ← 零扩展(S) | 以零扩展进行传送 |
| movzbw | R ← 零扩展(S) | 将做了零扩展的字节传送到字 |
| movzbl | R ← 零扩展(S) | 将做了零扩展的字节传送到双字 |
| movzwl | R ← 零扩展(S) | 将做了零扩展的字传送到双字 |
| movzbq | R ← 零扩展(S) | 将做了零扩展的字节传送到四字 |
| movzwq | R ← 零扩展(S) | 将做了零扩展的字传送到四字 |
零扩展数据传送指令以寄存器或内存中的数据作为源，寄存器作为目的(表中的R代表寄存器)。MOVZ指令将目的中剩余的字节填充位0，这意味着如果要实现%cl → %eax的零扩展传送，就会把%cl中的数据存放在%al中，同时将整个%eax的其余部分置0
MOVS
| 指令 | 效果 | 描述 |
|---|---|---|
| MOVS S, R | D ← 符号扩展(S) | 传送符号扩展的字节 |
| movsbw | R ← 符号扩展(S) | 将做了符号扩展的字节传送到字 |
| movsbl | R ← 符号扩展(S) | 将做了符号扩展的字节传送到双字 |
| movswl | R ← 符号扩展(S) | 将做了符号扩展的字传送到双字 |
| movsbq | R ← 符号扩展(S) | 将做了符号扩展的字节传送到四字 |
| movswq | R ← 符号扩展(S) | 将做了符号扩展的字传送到四字 |
| movslq |
R ← 符号扩展(S) | 将做了符号扩展的双字传送到四字 |
| cltq | %rax ← 符号扩展(%eax) | 把%eax符号扩展到%rax |
符号扩展数据传送指令和零扩展数据指令的区别是，它使用数据的符号位来进行填充
其中cltq比较特殊，它只以%eax或%rax作为对象，完成32位数据到64位数据的符号扩展
int main()
{
short a = 1;
int b = a;
long c = b; // 在刚刚的代码上多加一行，实现32位向64位扩展
return 0;
}
得到的汇编为
00000000004004ed :
4004ed: 55 push %rbp
4004ee: 48 89 e5 mov %rsp,%rbp
4004f1: 66 c7 45 fe 01 00 movw $0x1,-0x2(%rbp)
4004f7: 0f bf 45 fe movswl -0x2(%rbp),%eax
4004fb: 89 45 f8 mov %eax,-0x8(%rbp)
4004fe: 8b 45 f8 mov -0x8(%rbp),%eax // 把b存到%eax中
400501: 48 98 cltq // 使用cltq实现%eax的符号扩展
400503: 48 89 45 f0 mov %rax,-0x10(%rbp) // 直接使用扩展后的%rax
400507: b8 00 00 00 00 mov $0x0,%eax
40050c: 5d pop %rbp
40050d: c3 retq
40050e: 66 90 xchg %ax,%ax
通过Swap()来更好的理解数据传送
void swap(long *xp, long *yp) #Register Value
{ %rdi xp
long t0 = *xp; %rsi yp
long t1 = *yp; %rax t0
*xp = t1; %rdx t1
*yp = t0;
}- %rdi和%rsi分别作为第一个参数和第二个参数，存放的是xp和yp这两个地址
- movq (%rdi), %rax 将%rdi里的值作为地址(*xp)，取出地址里的值后传递给寄存器%rax(变量t0)， t0 = *xp
- 同上，t1 = *yp
- 将%rdx里的值(t1)，复制到%rdi的值对应的内存地址处，*xp = t1
- 同上，*yp = t0
4. 压入和弹出栈数据
这两个数据传送操作完成了数据在程序栈之中的压入和弹出，也就是push和pop操作。在程序中经常需要将变量或其他数据入栈和出栈，特别是在函数栈帧的调用之中
pushq和popq
| 指令 | 效果 | 描述 |
| pushq S | R[%rsp] ← R[%rsp]− 8; M[R[%rsp]] ← S |
将四字入栈 |
| popq D | D ← M[R[%rsp]]; R[%rsp] ← R[%rsp]+ 8 |
将四字出栈 |
pushq指令的功能是把数据压入到栈上，而popq指令则是弹出数据。它们都只有一个操作数——压入的数据源和弹出的数据目的
数据的出栈和入栈都是通过栈指针的增减来完成的，并且栈指针能够找到pushq指令要入栈的位置和popq指令要弹出数据的位置，因此pushq指令只需要即将入栈的数据作为源，而popq只需要将出栈的数据保存到寄存器或内存(目的)即可
将一个四字节值压入栈中，首先要将栈指针减8，然后将值写到新的栈顶地址。因此一条pushq %rbp指令相当于下面两条指令
subq $8,%rsp 减少栈指针，为数据在栈上开辟空间
movq %rbp,(%rsp) 将%rbp里的值存储在栈上同样popq指令先要从栈中取出一个四字节的值，要先将这个值弹出，再将栈指针加8。因此，一条popq %rax指令相当于下面两条指令
movq (%rsp),%rax 从栈中弹出数据到%rax中
addq $8,%rsp 栈指针减8，将之前数据所占空间释放
- 压栈时，先将栈指针%rsp-8，[0x108 - 8 = 0x100]，然后将%rax的值0x123存储到%rsp[0x100]处
- 出栈时，先将%rsp[0x100]处的值0x123弹出，放到寄存器%rdx中，再将栈指针%rsp+8，[0x100 + 8 = 0x108]