1. 传递控制: 进入Q的时候, 程序计数器的地址很显然要被设置成Q的起始指令所在的内存. 在返回的时候,则需要将程序计数器设置为P调用Q的指令之后的那条指令的地址.
2. 传递数据: P要将参数传递给Q, Q要想办法把结果返回给P
3. 分配和释放内存:Q在开始执行之前,要为其分配空间; 执行结束之后,必须释放空间

1. 运行时栈
2. 转移控制
3. 数据传送 - 寄存器传参规则
4. 数据传送 - 局部存储
5. 数据传送 - 递归

运行时栈

转移控制

1. call Label or *Operand, 可以跟标号或者操作数. 执行callq指令的时候, 会在当前栈里压入callq之后那条指令的地址. 然后将PC设置成Q的第一条指令.
2. ret, 返回指令. 从前边已经知道, 如果过程返回值, 那个值就会放在%rax寄存器当中. ret指令还一个作用是会把callq之后 那条指令的地址从栈里弹出, 然后把程序计数器设置成这条指令的地址.

练习 3.32

数据传送 - 寄存器传参规则

练习题 3.33 逻辑推理

数据传送 - 局部存储

long P(long x, long y) {
    long u = Q(y);
    long v = Q(x);
    return u + v;
}

P:
    pushq   %rbp        保存%rbp的值, 这里注意, 既然%rbp是被调用者保存寄存器, P这个过程本身, 必须向调用者保证不会改变其中的值, 所以要把寄存器的值入栈. 同样,Q过程也必须保证这两个寄存器在P交给Q之前和之后不能变.
    pushq   %rbx        和上边一行一样, 这两个寄存器都是被调用者保存寄存器. 这两行也说明, P过程采取的是在过程中操作这两个寄存器, 返回的时候还原其中值的方法.
    subq    $8, %rsp    栈指针减8个字节, 这8个字节是用来装本地变量, 也就是第一次调用Q的结果u
    movq    %rdi, %rbp  开始使用%rbp寄存器了, 把参数 x 的值复制到其中
    moveq   %rsi, %rdi  把参数 y 的值复制到 %rdi 中, 因为马上要调用 Q(y), 必须保证放置第一个参数的寄存器 %rdi 中的值是y
    callq   Q           调用Q, 此时参数1寄存器%rdi中的值是y. 注意, 调用Q之前的被调用者保存寄存器 %rbp 现在是 x, %rbx除了被保存, 没有用过. 在Q返回的时候, 这两个寄存器的值不会变化. 所以可以放心的把 x 放入其中留着之后用.
    moveq   %rax, %rbx  Q调用完毕, 把Q的返回值放入被调用者寄存器 %rbx 中. 这里使用了第二个被调用者保存寄存器 %rbx.
    moveq   %rbp, %rdi  把 x 复制到1号参数寄存器, 很显然准备调用 Q(x)了
    callq   Q           此时看一下被调用者保存寄存器, %rbp 依然是 x, %rbx 中是 Q(y)的结果, 很放心, 因为Q返回时不会改变其中的值.
    addq    %rbx, %rax  此时的%rax中是Q(x), %rbx 中是  Q(y), 指令执行完毕之后, %rax 中是 Q(y) + Q(x), P的返回值已经准备完毕了, 但是此时不能直接返回, 需要做返回准备工作.

    addq    $8, %rsp    把栈指针+8, 这里我其实没有发现为何要将之前的栈指针先减8, 然后再+8. 因为全程没有用到过栈传递数据, 而调用压栈会自动更新%rsp. 这可能是一种要求吧.
    popq    %rbx        把栈中的%rbx中的值还原, %rbx 后入栈, 要先弹出
    popq    %rbp        还原%rbp的值.
    ret                 准备工作已经做好, 所有的被调用者保存寄存器都恢复到过程开始的阶段, 栈指针也全部复原, 之后就可以返回了.

练习题 3.34 根据汇编代码回答问题

long P(long x)
x in %rdi

P:
    pushq   %r15
    pushq   %r14
    pushq   %r13
    pushq   %r12
    pushq   %rbp
    pushq   %rbx    一直到这里, 保存了所有6个被调用者保存寄存器

    subq    $24, %rsp      栈上分配24字节局部存储空间

    movq    %rdi, %rbx     保存 x 的值 到 %rbx 寄存器
    leaq    1(%rdi), %r15  x + 1 -> %r15
    leaq    2(%rdi), %r14  x + 2 -> %r14
    leaq    3(%rdi), %r13  x + 3 -> %r13
    leaq    4(%rdi), %r12  x + 4 -> %r12
    leaq    5(%rdi), %rbp  x + 5 -> %rbp 上边这6行, 在P过程里把所有的被调用者保存器都用了一遍

    leaq    6(%rdi), %rax  x + 6 -> %rax
    mov     %rax, (%rsp)   把 x + 6 的结果放入栈中
    leaq    7(%rdi), %rdx  x + 7 -> %rdx
    movq    %rdx, 8(%rsp)  把 x + 7 的结果放入栈+8的位置里
    movl    $0, %eax       %rax清零, 为进入Q做准备
    call    Q              进入Q

1. 可以看到, x 到 x+5都被存放在被调用者寄存器中. 而这些寄存器原来的值, 都被放在栈区中的被保存的寄存器区域中.
2. 局部变量为 x+6 和 x+7, 分别被保存在栈和栈+8的位置.
3. 因为所有的局部值可能超过被调用者保存寄存器的总大小. 这个例子中一共有8个局部值, 用光了6个, 只能有2个保存在栈上.

数据传送 - 递归

long rfact(long n){
    long result;
    if (n <= 1) {
        result = 1;
    } else result = n * rfact(n - 1);
    return result;
}

long rfact(long n)
n in %rdi

rfact:
    pushq   %rbx            将被调用者寄存器%rbx中的值保存起来, 这个值是什么呢
    movq    %rdi, %rbx      保存n
    movl    $1, %eax        %rax中放入1
    cmpq    %1, %rdi        比较 n : 1
    jle     .L35            如果n<=1 跳转 L35 标号
    leaq    -1(%rdi), %rdi  n = n - 1, %rdi 此时减少1, 同时也是1号参数位置
    call    rfact           调用 rfact(n-1)
    imulq   %rbx, %rax      用 %rbx中的 n 乘以 %rax中的 rfact(n-1)的值

  .L35:
    popq    %rbx            还原%rbx
    ret                     此时%eax中是1, 直接就可以返回1

练习3.35 根据汇编代码补充C函数

long rfun(unsigned long x){
    if(______){
        return ______;
    }
    unsigned long nx = ______;
    long rv = rfun(nx);
    return ______;
}

long rfun(unsigned long x)
x in %rdi

rfun:
    pushq   %rbx           保存被调用者保存寄存器 %rbx 的值到栈区. 这说明程序中要使用 %rbx 来保存当前状态
    movq    %rdi, %rbx     在%rbx中保存了 x 的值, 说明每个过程中需要用到每次传入的参数
    movl    %0, %eax       %rax 置0, 要想到在testq或者comp之前设置 %rax, 可能是某种条件下的返回值就是0
    testq   %rdi, %rdi     测试参数 x
    je      .L2            如果 x = 0, 跳转到 L2 标号
    shrq    $2, %rdi       逻辑右移两位, 相当于 x = x >> 2
    callq   rfun           调用rfun(x/4)
    addq    %rbx, %rax     此时%rbx中是初始参数 x 的值, 这句就是把返回值设置为 x + rfun(x>>2)

  .L2
    popq    %rbx           还原%rbx的值
    ret                    此时返回0.

long rfun(unsigned long x){
    if(x==0){
        return 0;
    }
    unsigned long nx = x>>2;
    long rv = rfun(nx);
    return x + rv;
}