1. 普通传送
2. 零扩展传送
3. 符号扩展传送
4. 压栈和弹栈

1. leaq 指令
2. 一元与二元操作
3. 移位操作
4. 特殊操作 - 128位扩展

数据传送指令

零扩展传送和符号扩展传送

• MOVZ 零扩展系列 源是内存地址或者寄存器 目的只能是寄存器
  1. movzbw, 从b扩展到w
  2. movzbl, 从b扩展到l
  3. movzbq, 从b扩展到q
  4. movzwl, 从w扩展到l
  5. movzwq, 从w扩展到q
• MOVS 符号扩展系列 源是内存地址或者寄存器 目的只能是寄存器
  1. movsbw, 从b扩展到w
  2. movsbl, 从b扩展到l
  3. movsbq, 从b扩展到q
  4. movswl, 从w扩展到l
  5. movswq, 从w扩展到q
  6. movslq, 从l扩展到q
  7. cltq, 这条指令不需要加操作数. 这条指令内置的源固定是%eax, 目标固定是%rax, 将%eax符号扩展到%rax.

练习题 3.2 根据操作数确定指令后缀

1. movl %eax, (%rsp). 源数据是32位寄存器,所以应该是 movl
2. movw (%rax), %dx. 目标是一个字,应该使用movw
3. movb $0xFF, &bl. 是一个字节传送,应该使用movb
4. movb (%rsp, %rdx, 4), %dl. 目标是一个字节,使用movb.
5. movq (%rdx), %rax. 目标是64位寄存器, 所以使用movq
6. movw %dx, (%rax) ,从一个字传送到64位寄存器,使用 movw

练习题 3.3 找错误

1. movb $0xF, (%ebx), 取地址一定是从64位寄存器中取,所以报错
2. movl %rax, (%rsp), 操作数的长度与指令不符
3. movw (%rax), 4(%rsp), 不能都是内存地址
4. movb %al, %sl, 没有叫做sl的寄存器名称
5. movq %rax, $0x123, 目标是一个常数, 无法操作
6. movl %eax, %rdx, 寄存器长度不一致
7. movb %si, 8(%rbp),si长度是w, 与指令的长度不符

练习题 3.4 汇编编写代码

src_t *sp;  //地址存储在%rdi中
dest_t *dp; //地址存储在%rsi中

*dp = (dest_t) *sp;

练习题 3.5 将汇编翻译成C语言代码

decode1:
    movq (%rdi), %r8
    movq (%rsi), %rcx
    movq (%rdx), %rax
    movq %r8, (%rsi)
    movq %rcx, (%rdx)
    movq %rax, (%rdi)
    ret

1. 第一条, 对指针*xp取值, 放入 %r8寄存器中, 可以翻译成 long temp1 = *xp
2. 第二条, 对指针*yp取值, 放入 %rcx寄存器中, 可以翻译成 long temp2 = *yp
3. 第三条, 对指针*zp取值, 放入 %rax寄存器中, 可以翻译成 long temp3 = *zp
4. 第四条, 把%r8寄存器里的值, 放入yp指针指向的地址中, 可以翻译成 *yp = temp1
5. 第五条, 把%rcx寄存器里的值, 放入zp指针指向的地址中, *zp = temp2
6. 第六条, 把%rax寄存器里的值, 放入xp指针指向的地址中, *xp = temp3

void decode1(long *xp, long *yp, long *zp){
    long temp = *zp;
    *zp = *yp;
    *yp = *xp;
    *xp = temp;
}

压栈和弹栈

1. push,先把%rsp 栈指针寄存器的值减少对应的长度, 然后取其地址, 将该操作数的值写入栈中.
2. pop, 其后接一个操作数, 是将该操作数的值从栈里弹出, 并写入到之后的操作数中. 然后%rsp寄存器的值会增加对应的长度.
3. %rsp, 不管何时, %rsp中保存着当前运行的程序的栈顶的地址

subq $8, %rsp
push %rbp, (%rsp)

movq (%rsp), %rax
addq %$8, %rsp

算术指令

练习 3.6 leaq的灵活使用

练习 3.7 看汇编写C代码

long scale2(long x, long y, long z){
    long t = __________
    return t;
}

scale2:
    leaq (%rdi, %rdi, 4), %rax
    leaq (%rax, %rsi, 2), %rax
    leaq (%rax, %rdx, 8), %rax

1. 第一步, 计算 5x , 存放在 %rax中
2. 第二步, 计算5x + 2y, 存放在%rax中
3. 第三步, 计算5x + 2y + 8z, 存放在%rax中

算术指令还有一个突出的特点是有一部分指令只有一个操作数,这叫做一元操作指令.

练习 3.8 一元和二元操作

还有一类指令是移位操作.先要给出一个移位量, 再给出要移位的操作数. 注意移位量可以是一个立即数, 也可以是单字节的%cl寄存器, 其他寄存器不能用于移位. 目的操作数可以是寄存器或者内存地址.

1. salb, 长度是8位,所以只看%cl的后三位, 所以最多移动7位
2. sall, 长度是16位,所以只看%cl的后四位,所以最多移动15位
3. sald, 长度是32位,所以只看%cl的后五位,所以最多移动31位
4. salq, 长度是32位,所以只看%cl的后六位,所以最多移动63位

练习3.9 根据C语言写出汇编代码

long shift_left4_rightn(long x, long n){
    x <<= 4;
    x >>= n;
    return x;
}

// x in %rdi, n in %rsi
shift_left4_rightn:
    movq %rdi, %rax;
    ________________
    movq %esi, %ecx;
    ________________

练习 3.10 通过汇编代码写出函数代码

long arith2(long x, long y, long z)
arith2:
    orq %rsi, %rdi
    sarq $3, %rdi
    notq %rdi
    movq %rdx, %rax
    subq %rdi, %rax
    ret

1. 这个是用%rsi和%rdi进行或运算, 结果放在%rdi中, 即 long t1 = x|y
2. 算术右移3 结果放在%rdi中, 即 long t2 = t1 >> 3
3. 取反, 即 long t3 = ~t2
4. 将%rdx 移动到%rax中, 这个就是long t4 = z
5. 这个是从%rax中减去%rdi, 也就是此时的t3, 结合上一条看, 就是 long t4 = z - t3

练习 3.11 汇编代码分析

xorq %rdx, %rdx

1. imulq S, 注意,这和之前的imul指令类不同, 是单操作数. 这暗含了另外一个操作数的就是%rax, 然后把结果的低64位放入%rax中, 高64位放入%rdx中, 这是固定的. 而两操作数的imul则只计算64位的乘法. 为何两操作数的imul不区分高低位, 是因为截取到64位的时候,补码和无符号的运算相同.
2. mulq S, 两个64位相乘, 得到128位的无符号乘法. 同样也暗含另外一个操作数在%rax中, 结果存放在高位%rdx和地位%rax中.
3. clto, 这个指令没有操作数, 是将%rax中的64位按照符号扩展到%rdx, 两个寄存器拼成一个128位数值.
4. idivq S, 这个是有符号数的除法指令, 操作数S是除数, 被除数固定使用%rax作为低64字节, %rdx作为高64字节. 除法进行完之后,商存储在%rax中, 而余数存储在%rdx中.
5. divq S, 无符号的除法指令, 隐含条件与有符号一样.

练习 3.12 无符号64位除法的商和余数

void uremdiv(unsigned long x, unsigned long y, unsigned long *qp, unsigned long *rp) {
    unsigned long q = x / y;
    unsigned long r = x % y;
    *qp = q;
    *rp = r;
}
// x in %rdi, y in %rsi, qp in %rdx, rp in %rcx

uremdiv:
    movq %rdx, %r8     把qp的地址放进%r8存储器
    movq %rdi, %rax    把x的值放进%rax, 准备被除数
    movl $0, %edx      设置%rdx为0, 只需要设置低32位, 高32位也变成0
    divq %rsi         x/y
    movq %rax, (%r8)   把商传递到qp指针指向的内存位置
    movq %rdx, (%rcx)  把余数传递给rp指针指向的内存位置
    ret