写字楼四层靠窗，整面墙都是临时工位：一格一格从天花板往地下排，新来的员工永远被安排在最底下的空位。主管把一份任务单递给小王：“去楼下把这堆报表算出来，弄完回四层找我。”任务单背面印着返岗方式；小王下楼后，先把“原工位指示牌”放好，再摊开草稿纸开工；算完把结果放上托盘，收起草稿，按指示牌回到原工位继续待命。 这场“开桌—干活—收桌—归位”的循环，正是计算机里每一次函数调用的完整过程：任务单是参数与返回地址，指示牌是被保存的旧基址 rbp，草稿纸是局部变量区，托盘是返回值寄存器 RAX，楼层起伏则是栈指针 rsp 的加减。本文会把这套“工位制度”从里到外拆一遍：调用方如何传参、被调用方如何用序言布置工位、函数体如何取用东西、尾声如何收桌、以及哪些员工可以不占工位直接干活。

岗位关联

对 AI 从业者而言，读懂栈帧构建，就能读懂崩溃回溯、性能剖析与安全审计报告的每一个细节；做模型部署与算子优化时，很多棘手的线上问题最终都要落到这一层。

目录
  1. 可视化演示
  2. 一、调用栈全景：工位墙从高处往下排
  3. 二、调用方传参：任务单的写法与贴法
  4. 三、序言构建帧：开桌三件套
  5. 四、函数体执行：沿着基准墙取东西
  6. 五、尾声销毁帧：收桌与归位
  7. 六、对齐与栈平衡：标准地砖的规矩
  8. 七、叶子函数优化：只干活的实习生
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

本节配有交互动效（进入视口后自动加载，约 3KB）。

系统可视化 处理流程：输入→处理→模型→输出 性能监控：实时指标 P=L×T

一、调用栈全景：工位墙从高处往下排

讲台前最复杂的一幅插图，莫过于“内存里的楼层图”。还记得那栋写字楼吗？整面墙的临时工位从高楼层一直延伸到地下，新员工永远被安排在最底下的空位。把这张图平移进计算机：进程的虚拟内存里，代码段是贴在墙上的制度手册，数据段是公共资料柜，堆是随意堆放的杂物间，而栈区正是那面工位墙——它从高地址开始，每新来一个函数，就向下开辟一格工位。

在 x86-64 体系里，两个寄存器管理着这面工位墙：rsp（栈指针）是前台登记员手里的“当前楼层号”，永远指向最新工位的最下缘；rbp（基址指针）则是一个函数在工位上画下的基准墙。当一个函数被调用，它先向下让出一块区域，这块区域就叫“栈帧”；一个栈帧恰好是一次函数调用的完整工位。

为什么说栈“向下生长”？因为 rsp 的移动方向是数值变小：

前台登记员只会在登记本上上下下拨数字：楼层越低工位越新，下班时逐层拨回原值。调用栈的“长出来”与“缩回去”，正是这套楼层号的精确往复。

rsp新=rsp旧−帧大小\displaystyle \mathrm{rsp_{新}} = \mathrm{rsp_{旧}} - \text{帧大小}
公式通俗说明：栈指针的数值越小，代表走到了越深的楼层；“下移一层”在地址上就是减去一个帧大小。
  1. rsp 是什么栈指针寄存器，始终指向当前栈顶（最新工位的下缘），所有压栈与弹栈都以它为基准。
    rsp\mathrm{rsp}
  2. 减法语义x86-64 中栈向低地址增长，所以“深入一层”体现为地址减小，由 sub 指令完成。
    rsp新=rsp旧−帧大小\mathrm{rsp_{新}} = \mathrm{rsp_{旧}} - \text{帧大小}
  3. 帧大小的构成一个栈帧要容纳旧基址指针（8 字节）、局部变量区、被保存的寄存器和对齐填充。
    帧大小=局部变量区+保存区+填充\text{帧大小} = \text{局部变量区} + \text{保存区} + \text{填充}
  4. 平衡的必然性序言减少了多少字节，尾声就必须原样加回来，否则返回地址会被算错位置。
    rsp返回=rsp调用前\mathrm{rsp_{返回}} = \mathrm{rsp_{调用前}}

二、调用方传参：任务单的写法与贴法

主管派活不能只说一句“去算”，他得把数字、统计口径都写清楚——这些写在任务单上的东西就是参数。任务单的张贴顺序有讲究：越靠后的参数越先贴，最后贴的是印着返岗信息的返岗单。这样一来，被调用的员工回来时，第一个拿到的就是返岗单。

在 x86-64 的 System V ABI 里，事情稍有简化：前 6 个整型参数直接放进寄存器（rdi、rsi、rdx、rcx、r8、r9），浮点参数走 xmm0–xmm7；第 7 个起才写进任务单（压栈）。而返岗单（返回地址）由 call 指令自动压栈——它不需要员工动手，是主管顺手贴的。

从被调用方的视角看，栈上参数的排布非常整齐：返回地址在低地址一侧，参数区在它上方（高地址）。设栈上第 $i$ 个参数（从 1 起计），它的地址满足：

谁贴单、谁收单，ABI 写得明明白白：主管负全责，员工只负责在工位上安心干活。这种“责任边界”正是计算机里一切协作协议的缩影。

addr(argi)=rbp+8(1+i)\displaystyle \mathrm{addr}(\mathrm{arg}_i) = \mathrm{rbp} + 8(1+i)
公式通俗说明：站在小王的工位基准墙（rbp）上往上数，先跳过一张返岗单（8 字节），再跳过 $i-1$ 个参数，第 $i$ 个参数就躺在那儿。
  1. rbp 是基准序言完工后 rbp 指向本帧起点，所有“往上数/往下数”都以它为原点。
    rbp\mathrm{rbp}
  2. +8 跳过返岗单返回地址恰好压在旧 rbp 上方 8 字节处，是调用方贴的最后一张单。
    rbp+8=返回地址位置\mathrm{rbp} + 8 = \text{返回地址位置}
  3. 按槽位翻找栈上每个参数占一个 8 字节槽，第 $i$ 个参数相对要再上移 $i$ 格。
    argi=rbp+8+8i\mathrm{arg}_i = \mathrm{rbp} + 8 + 8i
  4. 调用方负责收尾System V 下栈上参数由调用方在返回后用 add rsp 清理，保证来回平衡。
    rsp调用后=rsp调用前\mathrm{rsp_{调用后}} = \mathrm{rsp_{调用前}}

三、序言构建帧：开桌三件套

小王来到工位，并不立刻低头算账。他先做三件事：把“我从哪个工位来”的指示牌挂好（保存旧 rbp），在墙上划一条基准线（建立新 rbp），再钉几层搁板放草稿纸（为局部变量让出空间）。这套标准开场白，在汇编里就叫“序言”（prologue）。

典型序言由三条指令组成：push rbp 把调用方的基址指针压栈；mov rbp, rsp 让 rbp 指向刚压栈的位置；sub rsp, 帧大小 向下让出局部变量区。若函数还要修改被调用方保存的寄存器（rbx、r12–r15 等），也会在这一步把它们压栈，相当于把私人工具箱挂到工位墙上。

这三条指令每一跳都算得清清楚楚：push 减 8，sub 再减一大块。为了让后续嵌套调用时栈满足硬性对齐要求，帧大小必须向上取 16 的倍数：

三件套做完，工位正式启用。从这一刻起，小王的所有动作都以基准墙为参照，不再需要向楼上的前台喊话。

帧大小=16×⌈locals+regs16⌉\displaystyle \text{帧大小} = 16 \times \left\lceil \frac{\text{locals}+\text{regs}}{16} \right\rceil
公式通俗说明：搁板数量必须凑整到标准地砖的整数倍，多出来的空隙就是 padding（填充），用来保证工位线不歪。
  1. push rbp把调用方（旧）帧的基准指针压栈，相当于贴上“原工位指示牌”。
    push %rbp\text{push}~\%\mathrm{rbp}
  2. mov rbp, rsp让 rbp 指向刚压入的旧 rbp 位置，成为本帧基准墙。
    rbp←rsp\mathrm{rbp} \leftarrow \mathrm{rsp}
  3. sub rsp, 帧大小向下让出局部变量与保存区，rsp 成为帧下缘。
    rsp←rsp−帧大小\mathrm{rsp} \leftarrow \mathrm{rsp} - \text{帧大小}
  4. 对齐取整帧大小向上凑成 16 的倍数，使后续嵌套调用前的 rsp 满足 ABI。
    帧大小=16⋅⌈locals+regs16⌉\text{帧大小} = 16 \cdot \left\lceil \frac{\text{locals}+\text{regs}}{16} \right\rceil

四、函数体执行：沿着基准墙取东西

干活时的小王很省事：他只记“基准墙往上第 2 格是参数单，往下第 3 格是草稿纸”，伸手就能拿到。这就是工位制度的精髓——就地编号，不乱全楼。

在汇编层面，编译器把高级语言的变量名全部翻译成“rbp + 偏移量”：参数位于 rbp 的正方向（高地址），局部变量位于 rbp 的负方向（低地址）。例如 compute(int a) 里，参数 a 可能就在 rbp+16，函数内的临时变量 c 则在 rbp−4。CPU 的一条“基址寻址”指令，就能完成整个取用动作：

有了 rbp 这把尺子，函数体内的一切存取都是“相对几步”而已。这也是为什么栈帧能够随意嵌套生长——每个人只关心自己墙上的格子，从不抬头数整栋楼的楼层。

addr(locali)=rbp−offseti\displaystyle \mathrm{addr}(\mathrm{local}_i) = \mathrm{rbp} - \text{offset}_i
公式通俗说明：基准墙往前（高地址方向）是任务单，往后（低地址方向）是草稿纸；偏移量在编译期就写死在指令里了。
  1. 基址寻址CPU 支持“寄存器 + 偏移量”的内存访问，一条指令完成取数。
    addr=rbp+δ\text{addr} = \mathrm{rbp} + \delta
  2. 正方向是参数参数在返回地址上方，位于高地址，偏移为正。
    参数地址=rbp+8(1+i)\text{参数地址} = \mathrm{rbp} + 8(1+i)
  3. 负方向是局部局部变量在帧内 rsp 一侧，位于低地址，偏移为负。
    局部地址=rbp−offseti\text{局部地址} = \mathrm{rbp} - \text{offset}_i
  4. 编译期定偏移变量名编译后不复存在，只留下一个个数字偏移。
    变量↦常偏移量\text{变量} \mapsto \text{常偏移量}

五、尾声销毁帧：收桌与归位

下班铃响，小王收拾工位。他把结果放进托盘（返回值写入 RAX 或 XMM0），然后做一套和开桌严格对称的收桌动作：先撤掉局部变量搁板，把 rsp 拉回基准墙；再取下“原工位指示牌”，恢复旧基址；最后按返岗单乘电梯回原楼层。这套收尾就是“尾声”（epilogue）。

尾声通常就是两条指令：leave 等价于 mov rsp, rbp; pop rbp（撤桌并恢复基址），ret 则从栈顶弹出返回地址写入 RIP（按返岗单跳转）。它和序言是完全镜像的关系：序言分配的一切，尾声都必须原样归还。这正是栈平衡的物理意义：

收桌不干净，下一位员工就会踩到上一摊东西；在计算机里，这摊东西就是错位的 rsp——轻则崩溃，重则被攻击者利用改写返岗单。

rsp返回后=rsp调用前\displaystyle \mathrm{rsp_{返回后}} = \mathrm{rsp_{调用前}}
公式通俗说明：收桌收得干净与否，只看 rsp 是否回到进场前的准确楼层；差一字节，电梯（ret）就会下错楼层。
  1. mov rsp, rbp抛弃局部变量区，把栈指针拉回基准墙——搁板全部撤掉。
    rsp←rbp\mathrm{rsp} \leftarrow \mathrm{rbp}
  2. pop rbp弹出旧基址指针，恢复“原工位指示牌”。
    rbp←旧rbp\mathrm{rbp} \leftarrow \text{旧rbp}
  3. ret弹出返回地址并跳转，控制权交还调用方。
    rip←返回地址\mathrm{rip} \leftarrow \text{返回地址}
  4. 守恒关系序言减了多少，尾声必定加回多少，rsp 精确回到调用前的值。
    rsp返回后=rsp调用前\mathrm{rsp_{返回后}} = \mathrm{rsp_{调用前}}

六、对齐与栈平衡：标准地砖的规矩

物业有一条铁律：工位必须铺标准地砖，一格 16 厘米，谁都不能压线。压线的工位会让隔板错位，主管查岗时一眼就能看出哪层歪了。计算机世界的“标准地砖”，就是 16 字节对齐。

ABI 要求：任意 call 发生之前，rsp 必须是 16 字节对齐的。而 call 会压入 8 字节的返回地址，所以被调用方在入口处（序言之前）的 rsp 恰好余 8。为了让函数内部再次调用别人时恢复对齐，编译器会在序言里用 padding 把帧大小凑成 16 的倍数。入口条件写成公式就是：

只要人人都守地砖线，工位墙的每一格都能严丝合缝地嵌套；一旦某个函数破坏平衡，整条链上的地址全部错乱——这正是栈溢出漏洞的技术根源。

rsp入口≡8(mod16)\displaystyle \mathrm{rsp_{入口}} \equiv 8 \pmod{16}
公式通俗说明：每个函数的“打卡时间”都必须踩在固定的地砖缝上——不是 16 的倍数，而是差一张返岗单（8 字节）的位置。
  1. 入口条件调用前 rsp 整除 16，call 压入 8 字节后，入口余 8。
    rsp入口≡8(mod16)\mathrm{rsp_{入口}} \equiv 8 \pmod{16}
  2. 序言恢复push rbp 之后 rsp 回到整除 16，sub 的帧大小保持 16 倍数，仍整除 16。
    rsp帧内≡0(mod16)\mathrm{rsp_{帧内}} \equiv 0 \pmod{16}
  3. padding 充数局部与保存区不足 16 倍数时，编译器补填充字节凑整。
    pad=(16−((L+S) mod 16)) mod 16\mathrm{pad} = (16 - ((L + S) \bmod 16)) \bmod 16
  4. 平衡校验每个 sub 必须配对等量的 add/pop，栈在 ret 后回到原值。
    ∑分配=∑回收\sum \text{分配} = \sum \text{回收}

七、叶子函数优化：只干活的实习生

实习生小赵有个显著特点：他从不派活给别人。没有下属，他就不需要一套正式工位，直接借主管桌角放几张纸，干完就走。开桌、收桌的仪式全部省掉。在编译器眼里，这样的函数叫“叶子函数”（leaf function），对应一棵调用树中最末端的叶子。

叶子函数为什么能省？回顾栈帧的两大存在理由：一是为嵌套调用保证 16 字节对齐与参数空间，二是保存被调用方寄存器以便返回时恢复。叶子函数既不调用别人，又只用临时寄存器（如 r10、r11），这两条理由都不成立，于是编译器允许它省略序言的 sub 与尾声的 leave，甚至完全不碰 rbp。省略的收益，在每次调用上都体现一次：

不派活的员工让工位资源零浪费——这正是编译器在热路径上猛用的招数，也是你优化 AI 算子时值得留意的角落。

Δ=c序言+c尾声\displaystyle \Delta = c_{\text{序言}} + c_{\text{尾声}}
公式通俗说明：每次借桌都省下“摆桌 + 收桌”的固定动作；热路径上调用次数越多，节省越可观。
  1. 叶子定义调用图中出度为 0 的函数，没有任何派活对象。
    outdegree(f)=0\text{outdegree}(f) = 0
  2. 免对齐需求不调用别人，就不需要在函数内维持调用前的 16 字节对齐。
    无需 rsp≡0(mod16) 约束\text{无需}~ \mathrm{rsp} \equiv 0 \pmod{16} ~\text{约束}
  3. 免保存需求若只用调用方保存的临时寄存器，就无需压栈保存旧值。
    无需 push %rbx 等\text{无需}~ \text{push}~\%\mathrm{rbx} ~\text{等}
  4. 每调用节省省略的指令在每次调用都被省一次，乘上调用次数便是总收益。
    Δ=c序言+c尾声\Delta = c_{\text{序言}} + c_{\text{尾声}}

AI 应用场景

崩溃回溯与安全审计

阶段：可观测性与可靠性工程

解决的问题：大模型服务偶发崩溃，传统做法是盯着一坨十六进制地址人肉猜。理解了序言/尾声模式后，回溯工具能沿“返回地址链”逐层还原调用栈；再用 AI 模型对历史崩溃模式分类，自动定位根因。

具体案例：某推理平台把 core dump 喂给栈回溯器，先按标准序言模式识别每帧的旧 rbp 与返回地址，再让 LLM 结合源码语义把崩溃栈翻译成“第几层的哪个算子越界”，工单量因此下降七成。

性能剖析驱动的算子优化

阶段：模型部署与性能优化

解决的问题：profiler 显示某个基础算子被调用百万次，每次序言尾声浪费 2~3 条指令。AI 工程师借助叶子函数与帧指针省略规则，给不派活的热点 helper 加上 leaf 优化或直接内联。

具体案例：某团队在自定义算子库中把内部小工具函数改为叶函数风格，去掉多余的 rbp 维护与栈空间分配，端到端推理时延下降约 8%。

AI 辅助反编译与函数识别

阶段：安全分析与二进制理解

解决的问题：逆向工程师面对裸二进制，第一步是找函数边界。序言/尾声是天然的“函数签章”，AI 模型结合这些模式可以自动切分函数、推断参数个数，再与已知签名比对。

具体案例：某安全团队用汇编语言模型扫描固件，以"push rbp / mov rbp,rsp / sub rsp"三件套为锚点恢复函数表，成功定位到隐藏的后门函数。

Python 演示

python60 行
"""栈帧序言/尾声迷你模拟器用一块假内存演示: call 压返回地址 -> 序言开帧 -> 尾声收帧 -> ret 返回"""  class StackMachine:    def __init__(self, mem_size=64, base_addr=1000):        self.mem = [0] * mem_size        # 模拟的64个8字节槽位        self.base_addr = base_addr       # 栈底(高地址)        self.rsp = base_addr             # 栈指针, 只向低地址增长        self.rbp = 0                     # 基址指针        self.rax = 0                     # 返回值寄存器     def _idx(self, addr):        return (self.base_addr - addr) // 8     def push(self, value):        self.rsp -= 8                    # 栈向下增长        self.mem[self._idx(self.rsp)] = value     def pop(self):        value = self.mem[self._idx(self.rsp)]        self.rsp += 8        return value     def prologue(self, frame_size):        self.push(self.rbp)              # push rbp        self.rbp = self.rsp              # mov rbp, rsp        self.rsp -= frame_size           # sub rsp, frame_size     def epilogue(self):        self.rsp = self.rbp              # mov rsp, rbp        self.rbp = self.pop()            # pop rbp     def call_fn(self, ret_addr, frame_size, name):        print("[call ] %s 调用前 rsp=%d" % (name, self.rsp))        self.push(ret_addr)              # call 压入返回地址        self.prologue(frame_size)        print("[序言 ] %s 开帧后 rsp=%d rbp=%d" % (name, self.rsp, self.rbp))        self.rax = len(ret_addr)         # 模拟函数体产出的返回值     def ret_fn(self, name):        self.epilogue()        ret_addr = self.pop()            # ret 弹出返回地址        print("[尾声 ] %s 收帧后 rsp=%d rbp=%d 返回:%s" % (name, self.rsp, self.rbp, ret_addr))  def main():    vm = StackMachine()    vm.call_fn("main_ret", 32, "main")    vm.call_fn("add_ret", 16, "add")    vm.call_fn("compute_ret", 8, "compute")    vm.ret_fn("compute")    vm.ret_fn("add")    vm.ret_fn("main")    print("最终 rsp=%d (恢复初始值)" % vm.rsp)  if __name__ == "__main__":    main()
目的：用纯 Python 模拟 x86-64 的序言/尾声，直观看到三层嵌套调用后 rsp 逐层复原的过程。
  1. self.rsp -= 8模拟 sub rsp, 8：栈向低地址生长，指针数值减小。
  2. self.mem[self._idx(self.rsp)] = value把值写进“低地址”对应的槽位，完成地址到数组的映射。
  3. self.push(ret_addr)模拟 call 的行为：先把返岗单（返回地址）压栈，再跳入新函数。
  4. self.push(self.rbp)序言第一步：把旧基准指针压栈保存。
  5. self.rsp -= frame_size序言第三步：给局部变量与保存区让出空间。
  6. self.rsp = self.rbpleave 的一半：撤掉局部区，把栈指针拉回基准墙。
  7. self.rbp = self.pop()pop rbp：恢复上一层的基址指针。
  8. vm.ret_fn("compute")从最内层开始逐一收帧，先入后出，栈最终归零。

常见误区

误区我一开始以为栈和堆一样往上长，新变量的地址应该越来越大，画内存图时总把新帧画在旧帧上面。

正解x86-64 的栈向低地址增长：调用越深，rsp 数值越小。可以这样记：每次序言都在做减法（sub），rsp 只减不增地往下走，返回时才用加法或 pop 加回来；像电梯下行，“楼层号越来越小”才是更深处。

为何常见：日常语言里“栈”给人的感觉是越垒越高，加上高级语言从不暴露地址方向，人们很容易凭直觉画成向上生长。

误区反正不分配 rsp 也能跑，有些函数没写序言不也正常返回了吗？编译器应该会自动帮我修平衡吧？

正解能省略是编译器判断出“叶子 + 不乱改寄存器 + 无需回溯”后才做的合法优化；手写汇编若随意删，返回地址取错，ret 会直接跳到垃圾地址。栈平衡不是自动修复机制，而是调用方与被调用方按 ABI 共同遵守的合同。

为何常见：看编译器输出时经常见到“没有序言的函数”，误以为序言无用，其实那是已经做过叶子优化的结果。

误区64 位下有 RIP 相对寻址，rbp 就是老古董，写代码时根本不用管它。

正解rbp 在调试构建和多数未开激进优化的代码里仍是回溯锚点：崩溃回溯、异常展开、调试器单步都依赖帧指针。编译器开帧指针省略（FPO）后会失去这层便利；对崩溃分析和安全审计来说，帧指针有无直接决定能否快速还原调用链。

为何常见：主流编译器开 -O2 后常省略 rbp，看得多了，就误以为它从 ABI 中消失了。

误区我看到很多函数在 ret 之前 add rsp，就以为清理栈上参数是被调用方的固定职责。

正解清理责任由调用约定决定：cdecl（32 位）由调用方清理，stdcall 由被调用方清理，而 x86-64 System V 把整型参数放寄存器，栈上的额外参数由调用方清理。判断依据是 ABI，不是函数长短。

为何常见：Windows 或旧教程里 stdcall 很常见，以偏概全地把规则套到了所有平台。

面试题

Q1. 在 x86-64 中，栈的生长方向是？

单选题 · easy

  • A.向地址变大方向生长
  • B.向地址变小方向生长← 正确答案
  • C.同时向两端方向生长
  • D.由操作系统动态决定

答案：B。x86-64 的栈向低地址增长，序言里 sub rsp 让指针变小，像写字楼的楼层号越往下越小；A 是堆的方向，C、D 都不符合 ABI 的确定性。

Q2. call 指令执行时自动完成哪件事？

单选题 · easy

  • A.压入返回地址并跳转← 正确答案
  • B.压入参数并顺序执行
  • C.保存所有通用寄存器
  • D.把栈指针直接清零

答案：A。call 相当于主管顺手贴返岗单：先压入 8 字节返回地址，再跳转到目标函数；参数由调用方按 ABI 提前准备，寄存器保存是函数自己的职责。

Q3. 函数序言中 push rbp; mov rbp, rsp 的目的是什么？

单选题 · mid

  • A.为参数预留出栈空间
  • B.保存当前的返回地址
  • C.保存旧基址并建立新基准← 正确答案
  • D.把栈对齐到十六字节

答案：C。push rbp 把调用方的基址指针压栈，mov rbp,rsp 让 rbp 指向新本帧的基准墙；返回地址是 call 压的，参数空间由调用方处理，对齐靠 sub 的帧大小调节。

Q4. 关于栈帧参数访问，下列说法正确的是？

多选题 · mid

  • A.参数位于 rbp 正方向一侧← 正确答案
  • B.返回地址位于 rbp+8 处← 正确答案
  • C.局部变量位于 rbp 负方向← 正确答案
  • D.栈参数一律由被调用方清

答案：ABC。参数在返回地址上方（高地址），即 rbp 正方向；返回地址恰好压在旧 rbp 之上，位于 rbp+8；局部变量在低地址一侧。清理责任由 ABI 决定，不能一律归给被调用方，D 错。

Q5. 假设调用前 rsp 已 16 字节对齐，call 之后、序言之前的函数入口处满足什么条件？

单选题 · mid

  • A.rsp 对 16 取模等于 0
  • B.rsp 对 16 取模等于 8← 正确答案
  • C.rsp 对 16 取模等于 16
  • D.rsp 对 16 取模等于 4

答案：B。call 压入 8 字节返回地址，使原本整除 16 的 rsp 变成余 8；序言中 push rbp 后恢复整除 16，再配 16 的倍数帧大小，保证嵌套调用前重新对齐。

Q6. 下列哪些属于函数尾声（epilogue）的典型动作？

多选题 · mid

  • A.把返回值放入 RAX 寄存器← 正确答案
  • B.用 leave 恢复旧基址指针← 正确答案
  • C.用 ret 弹出返回地址跳回← 正确答案
  • D.用 sub 分配新的栈空间

答案：ABC。尾声是收桌：结果放 RAX（或 XMM0），leave 恢复 rbp，ret 按返岗单返回；sub 分配栈空间是序言的活，方向正好相反。

Q7. 关于叶子函数优化，下列说法正确的是？

单选题 · hard

  • A.只要函数小就能省略栈帧
  • B.不调用他人的函数可省帧← 正确答案
  • C.叶函数不需要任何局部变量
  • D.省略栈帧后仍能精确回溯

答案：B。叶子函数在调用图中出度为 0，不派活就不需要为嵌套调用保留对齐与参数空间，可省略完整序言尾声；能否省与函数大小无关，叶函数也可有局部变量，省略后回溯能力反而下降。

Q8. 要安全地省略序言/尾声，函数必须满足哪些约束？

多选题 · hard

  • A.函数内部不调用其他函数← 正确答案
  • B.不修改被调用方保存寄存器← 正确答案
  • C.无需为嵌套调用预留对齐← 正确答案
  • D.局部变量必须全部寄存器化

答案：ABC。不调用他人，就没有对齐与参数空间需求；不修改 rbx/r12–r15 等被调用方保存寄存器，就无需压栈恢复。局部变量放不放寄存器不是必要条件，D 错。

Q9. leave 指令等价于哪两条指令？

单选题 · mid

  • A.mov rsp,rbp 再 pop rbp← 正确答案
  • B.pop rbp 再 mov rsp,rbp
  • C.push rbp 再 mov rbp,rsp
  • D.add rsp, 8 再 ret 返回

答案：A。leave 先让 rsp 回到 rbp（撤掉局部区），再弹出旧基址；顺序不能反，必须先撤桌再取指示牌，否则取到的值就错了。

Q10. 栈帧不平衡（序言分配了 32 字节但尾声只回收 24 字节）最直接的后果是什么？

单选题 · extreme

  • A.参数区内容被悄悄清空
  • B.ret 弹错地址导致崩溃或劫持← 正确答案
  • C.代码段会被重新写入
  • D.编译器无法生成可执行文件

答案：B。差出的字节会让 rsp 停在错误位置，ret 从错误地址弹出“返回地址”，轻则崩溃，重则被攻击者导向恶意代码；这正是栈破坏与 ROP 攻击的核心机制。