原创文章，欢迎转载，转载请注明出处，谢谢。
0. 前言
作为一个严肃的 Gopher，了解汇编是必须的。本汇编系列文章会围绕基本的 Go 程序介绍汇编的基础知识。
1. Go 程序到汇编
首先看一个简单到令人发指的示例：
package main
func main() {
a := 1
print(a)
}
运行程序，输出：
# go run ex0.go
1
当使用
go run
运行程序时，代码会经过编译，链接，执行得到输出，这是自动执行的，没办法查看中间过程。我们可以使用
dlv
查看这段代码在执行时做了什么。
dlv
将代码加载到内存中交给 CPU 执行，又不丧失对 CPU 的控制。换言之，我们是在底层通过
dlv
对 CPU 进行调试查看代码的执行过程，这对我们了解程序的执行是非常有帮助的。
使用
dlv debug
调试程序：
# go mod init ex0
go: creating new go.mod: module ex0
go: to add module requirements and sums:
go mod tidy
# dlv debug
Type 'help' for list of commands.
(dlv)
使用
disass
可查看应用程序的汇编代码，这里的汇编是真实的机器执行的汇编代码。汇编是离机器最近的“语言”，翻译成汇编可以帮助我们知道机器在对我们的代码做什么。
(dlv) disass
TEXT _rt0_amd64_linux(SB) /usr/local/go/src/runtime/rt0_linux_amd64.s
=> rt0_linux_amd64.s:8 0x466d00 e95bc9ffff jmp $_rt0_amd64
从这段汇编代码可以看出，进入
main
函数前，机器执行的是 Go runtime 中
rt0_linux_amd64.s
第 8 行的汇编指令。查看
rt0_linux_amd64.s
：
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#include "textflag.h"
TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
JMP _rt0_amd64(SB)
TEXT _rt0_amd64_linux_lib(SB),NOSPLIT,$0
JMP _rt0_amd64_lib(SB)
第 8 行执行的是
JMP _rt0_amd64(SB)
跳转指令。
使用
si
命令单步调试，
si
是指令级调试。执行
si
查看的是 CPU 执行的下一条指令：
(dlv) si
> _rt0_amd64() /usr/local/go/src/runtime/asm_amd64.s:16 (PC: 0x463660)
Warning: debugging optimized function
TEXT _rt0_amd64(SB) /usr/local/go/src/runtime/asm_amd64.s
=> asm_amd64.s:16 0x463660 488b3c24 mov rdi, qword ptr [rsp]
asm_amd64.s:17 0x463664 488d742408 lea rsi, ptr [rsp+0x8]
asm_amd64.s:18 0x463669 e912000000 jmp $runtime.rt0_go
CPU 执行的是
runtime/asm_amd64.s
中的汇编指令。查看
runtime/asm_amd64.s
：
// _rt0_amd64 is common startup code for most amd64 systems when using
// internal linking. This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program. The stack holds the
// number of arguments and the C-style argv.
TEXT _rt0_amd64(SB),NOSPLIT,$-8
MOVQ 0(SP), DI // argc
LEAQ 8(SP), SI // argv
JMP runtime·rt0_go(SB)
可以看到，Go runtime 的汇编和机器实际执行的汇编指令有所出入。这里 Go 的汇编可以理解成在汇编之上又定制的一层汇编，要注意的是机器实际执行的是 Go 汇编翻译之后的汇编。
1.1 main 函数栈
本文的重点并不是单步调试 runtime 的汇编指令，我们使用
b
给 main 函数加断点，使用
c
执行到断点处，重点看 main 函数中的执行过程：
(dlv) b main.main
Breakpoint 1 set at 0x45feca for main.main() ./ex0.go:3
(dlv) c
> main.main() ./ex0.go:3 (hits goroutine(1):1 total:1) (PC: 0x45feca)
1: package main
2:
=> 3: func main() {
4: a := 1
5: print(a)
6: }
程序执行到 ex0.go 的第三行。
disass
查看汇编指令：
(dlv) disass
TEXT main.main(SB) /root/go/src/foundation/ex0/ex0.go
ex0.go:3 0x45fec0 493b6610 cmp rsp, qword ptr [r14+0x10]
ex0.go:3 0x45fec4 762b jbe 0x45fef1
ex0.go:3 0x45fec6 55 push rbp
ex0.go:3 0x45fec7 4889e5 mov rbp, rsp
=> ex0.go:3 0x45feca* 4883ec10 sub rsp, 0x10
汇编代码显示执行到内存地址
0x45feca
处，内存地址中存储的是汇编指令
sub rsp, 0x10
，对应的十六进制是
4883ec10
，转换为二进制机器指令是
1001000100000111110110000010000
。
我们有必要分段介绍执行
sub rsp, 0x10
前 CPU 执行的指令，以方便理解。
首先，
cmp rsp, qword ptr [r14+0x10]
指令比较 rsp 寄存器的值和 [r14+0x10] 寄存器中的值，并将比较的结果存储到标志寄存器中。
接下来，指令
jbe 0x45fef1
将读取标志寄存器的结果，如果比较结果 rsp 小于或等于 [r14+0x10] 则跳转到内存
0x45fef1
。查看
0x45fef1
中存储的指令：
ex0.go:3 0x45fef1 e8eacdffff call $runtime.morestack_noctxt
0x45fef1
存储的是
runtime.morestack_noctxt
函数的调用。
机器指令的语义较难理解这几条指令在干嘛，翻译成语义信息就是，如果当前 main 函数栈的栈空间不足，则调用
runtime.morestack_noctxt
申请更多栈空间。
接着，继续执行指令
push rbp
。在介绍这条指令前，有必要介绍下机器的寄存器，使用
regs
命令查看机器的寄存器：
(dlv) regs
Rip = 0x000000000045feca
Rsp = 0x000000c00003e758
Rax = 0x000000000045fec0
Rbx = 0x0000000000000000
Rcx = 0x0000000000000000
Rdx = 0x00000000004751a0
Rsi = 0x00000000004c3160
Rdi = 0x0000000000000000
Rbp = 0x000000c00003e758
...
机器有很多种寄存器，我们重点关注的是
Rip
，
Rsp
和
Rbp
寄存器。
Rip 寄存器中存储的是 CPU 当前执行指令的内存地址，这里要注意，程序中的内存地址为虚拟地址，不存在段地址和偏移地址。当前
Rip
中存储的是
0x000000000045feca
，对应执行的机器指令是
=> ex0.go:3 0x45feca* 4883ec10 sub rsp, 0x10
。
Rsp
寄存器一般作为函数栈的栈顶，用来存储函数栈的栈顶地址。
Rbp
一般用来存储程序执行的下一条指令，函数栈在跳转时需要知道下一条执行的指令在什么位置(这里不清楚也没关系，后续文章会介绍)
回到
push rbp
指令，该指令会将
rbp
寄存器的值压栈，压栈是从高地址到低地址，
Rsp
寄存器将减小 8 个字节。然后
mov rbp, rsp
指令将当前
rsp
寄存器的值赋给
rbp
,
rbp
将作为函数栈的栈底存在。
根据上述分析，可以画出当前栈的内存空间如下：
继续单步执行
sub rsp, 0x10
指令，
rsp
向下减
0x10
，这是为
main
函数栈开辟栈空间。rsp 值为：
(dlv) regs
Rsp = 0x000000c00003e748
disass
查看后续执行的汇编指令：
(dlv) disass
Sending output to pager...
TEXT main.main(SB) /root/go/src/foundation/ex0/ex0.go
...
=> ex0.go:4 0x45fece 48c744240801000000 mov qword ptr [rsp+0x8], 0x1
ex0.go:5 0x45fed7 e8e449fdff call $runtime.printlock
ex0.go:5 0x45fedc 488b442408 mov rax, qword ptr [rsp+0x8]
ex0.go:5 0x45fee1 e87a50fdff call $runtime.printint
ex0.go:5 0x45fee6 e8354afdff call $runtime.printunlock
ex0.go:6 0x45feeb 4883c410 add rsp, 0x10
ex0.go:6 0x45feef 5d pop rbp
mov qword ptr [rsp+0x8], 0x1
将
0x1
放到 [rsp+0x8] 内存地址中。使用
x
命令可以查看内存地址中的值：
x 0x000000c00003e750
0xc00003e750: 0x01
接着，
mov rax, qword ptr [rsp+0x8]
将内存地址
[rsp+0x8]:0x000000c00003e750
的值拷贝到寄存器
rax
中，调用
call $runtime.printint
打印寄存器中的值（这里忽略
call $runtime.printint
和
call $runtime.printunlock
指令）。
在我们执行下一条指令
add rsp, 0x10
前先看下当前内存空间使用情况。
main
函数栈中
rbp
指向的是函数栈的栈底，
rsp
指向的是函数栈的栈顶，在
[rsp+0x8]
的地址存放着局部变量 1。
接着，执行
add rsp, 0x10
回收栈空间：
(dlv) si
> main.main() ./ex0.go:6 (PC: 0x45feef)
ex0.go:6 0x45feeb* 4883c410 add rsp, 0x10
=> ex0.go:6 0x45feef 5d pop rbp
(dlv) regs
Rsp = 0x000000c00003e758
要注意，回收只是改变
Rsp
寄存器的值，内存中的数据还是存在的，这是栈段，数据并不会被垃圾回收器回收：
x 0x000000c00003e750
0xc00003e750: 0x01
继续，执行
pop rbp
将原来存储在栈底处的值放到
rbp
寄存器中：
(dlv) regs
Rip = 0x000000000045feef
Rsp = 0x000000c00003e758
Rbp = 0x000000c00003e758
(dlv) si
> main.main() ./ex0.go:6 (PC: 0x45fef0)
ex0.go:6 0x45feef 5d pop rbp
=> ex0.go:6 0x45fef0 c3 ret
(dlv) regs
Rip = 0x000000000045fef0
Rsp = 0x000000c00003e760
Rbp = 0x000000c00003e7d0
最后执行
ret
指令退出
main
函数。
至此，我们一个简单的打印局部变量的程序就分析完了。下一篇，我们继续看，如何手写 plan9 汇编。
标签：游戏攻略
