共计 16887 个字符，预计需要花费 43 分钟才能阅读完成。
作者：ivansli，腾讯 IEG 经营开发工程师
在深刻学习 Golang 的 runtime 和规范库实现的时候发现，如果对 Golang 汇编没有肯定理解的话，很难深刻理解其底层实现机制。在这里整顿总结了一份根底的 Golang 汇编入门常识，通过学习之后可能对其底层实现有肯定的意识。0. 为什么写本文
平时业务中始终应用 PHP 编写代码，然而始终对 Golang 比拟感兴趣，空闲、周末之余会看一些 Go 底层源码。
近日在剖析 go 的某些个性底层性能实现时发现：有些又跟 runtime 运行时无关，而要把握这一部分的话，有一道坎是绕不过来的，那就是 Go 汇编。索性就查阅了很多大佬们写的材料，在浏览之余整顿总结了一下，并在这里分享给大家。
本文应用 Go 版本为 go1.14.1
1. 为什么须要汇编
家喻户晓，在计算机的世界里，只有 2 种类型。那就是：0 和 1。
计算机工作是由一系列的机器指令进行驱动的，这些指令又是一组二进制数字，其对应计算机的高低电平。而这些机器指令的汇合就是机器语言，这些机器语言在最底层是与硬件一一对应的。
不言而喻，这样的机器指令有一个致命的毛病：可浏览性太差（恐怕也只有蠢才和疯子才有能力把控得了）。
为了解决可读性的问题以及代码编辑的需要，于是就诞生了最靠近机器的语言：汇编语言（在我看来，汇编语言更像一种助记符，这些人们容易记住的每一条助记符都映射着一条不容易记住的由 0、1 组成的机器指令。你感觉像不像域名与 IP 地址的关系呢？）。
1.1 程序的编译过程
以 C 语言为例来说，从 hello.c 的源码文件到 hello 可执行文件，通过编译器解决，大抵分为几个阶段：
编译器在不同的阶段会做不同的事件，然而有一步是能够确定的，那就是：源码会被编译成汇编，最初才是二进制。
2. 程序与过程
源码通过编译之后，失去一个二进制的可执行 文件 。 文件 这两个字也就表明，目前失去的这个文件跟其余文件比照，除了是具备肯定的格局（Linux 中是 ELF 格局，即：可运行可链接。executable linkable formate）的二进制组成，并没什么区别。
在 Linux 中文件类型大抵分为 7 种：
1. b: 块设施文件
2. c：字符设施文件
3. d：目录
4. -：一般文件
5. l：链接
6. s：socket
7. p：管道
通过下面能够看到，可执行文件 main 与源码文件 main.go，都是同一种类型，属于一般文件。（当然了，在 Unix 中有一句很经典的话：所有皆文件 ）。
那么，问题来了：
- 什么是程序？
-
什么是过程？
2.1 程序
维基百科通知咱们：程序 是指一组批示计算机或其余具备音讯解决能力设施每一步动作的指令，通常用某种程序设计语言编写，运行于某种指标体系结构上。
从某个层面来看，能够把程序分为动态程序、动静程序：动态程序：单纯的指具备肯定格局的可执行二进制文件。动静程序：则是动态可执行程序文件被加载到内存之后的一种运行时模型（又称为过程）。
2.2 过程
首先，要晓得的是，过程 是调配系统资源的最小单位，线程 (带有工夫片的函数) 是系统调度的最小单位。过程蕴含线程，线程所属于过程。
创立过程个别应用 fork 办法(通常会有个拉起程序，先 fork 本身生成一个子过程。而后，在该子过程中通过 exec 函数把对应程序加载进来，进而启动指标过程。当然，实际上要简单得多)，而创立线程则是应用 pthread 线程库。
以 32 位 Linux 操作系统为例，过程经典的虚拟内存构造模型如下图所示：
其中，有两处构造是动态程序所不具备的，那就是 运行时堆 (heap) 与运行时栈(stack)。
运行时堆 从低地址向高地址增长，申请的内存空间须要程序员本人或者由 GC 开释。运行时栈 从高地址向低地址增长，内存空间在以后栈桢调用完结之后主动开释(并不是革除其所占用内存中数据，而是通过栈顶指针 SP 的挪动，来标识哪些内存是正在应用的)。
3. Go 汇编
对于 Go 编译器而言，其输入的后果是一种形象可移植的汇编代码，这种汇编（Go 的汇编是基于 Plan9 的汇编）并不对应某种实在的硬件架构。Go 的汇编器会应用这种伪汇编，再为指标硬件生成具体的机器指令。
伪汇编 这一个额定层能够带来很多益处，最次要的一点是不便将 Go 移植到新的架构上。
相干的信息能够参考 Rob Pike 的 The Design of the Go Assembler。
要理解 Go 的汇编器最重要的是要晓得 Go 的汇编器不是对底层机器的间接示意，即 Go 的汇编器没有间接应用指标机器的汇编指令。Go 汇编器所用的指令，一部分与指标机器的指令一一对应，而另外一部分则不是。这是因为编译器套件不须要汇编器直接参与惯例的编译过程。相同，编译器应用了一种半形象的指令集，并且局部指令是在代码生成后才被抉择的。汇编器基于这种半形象的模式工作，所以尽管你看到的是一条 MOV 指令，然而工具链针对对这条指令理论生成可能齐全不是一个挪动指令，兴许会是革除或者加载。也有可能准确的对应指标平台上同名的指令。概括来说，特定于机器的指令会以他们的本尊呈现，然而对于一些通用的操作，如内存的挪动以及子程序的调用以及返回通常都做了形象。细节因架构不同而不一样，咱们对这样的不精确性表示歉意，状况并不明确。汇编器程序的工作是对这样半形象指令集进行解析并将其转变为能够输出到链接器的指令。The most important thing to know about Go’s assembler is that it is not a direct representation of the underlying machine. Some of the details map precisely to the machine, but some do not. This is because the compiler suite needs no assembler pass in the usual pipeline. Instead, the compiler operates on a kind of semi-abstract instruction set, and instruction selection occurs partly after code generation. The assembler works on the semi-abstract form, so when you see an instruction like MOV what the toolchain actually generates for that operation might not be a move instruction at all, perhaps a clear or load.
Or it might correspond exactly to the machine instruction with that name. In general, machine-specific operations tend to appear as themselves, while more general concepts like memory move and subroutine call and return are more abstract. The details vary with architecture, and we apologize for the imprecision; the situation is not well-defined.
The assembler program is a way to parse a description of that semi-abstract instruction set and turn it into instructions to be input to the linker.Go 汇编应用的是 caller-save 模式，被调用函数的入参参数、返回值都由调用者保护、筹备。因而，当须要调用一个函数时，须要先将这些工作筹备好，才调用下一个函数，另外这些都须要进行内存对齐，对齐的大小是 sizeof(uintptr)。
3.1 几个概念
在深刻理解 Go 汇编之前，须要晓得的几个概念：
- 栈：过程、线程、goroutine 都有本人的调用栈，先进后出（FILO）
- 栈帧：能够了解是函数调用时，在栈上为函数所调配的内存区域
- 调用者：caller，比方：A 函数调用了 B 函数，那么 A 就是调用者
-
被调者：callee，比方：A 函数调用了 B 函数，那么 B 就是被调者
3.2 Go 的外围寄存器
go 汇编中有 4 个外围的伪寄存器，这 4 个寄存器是编译器用来保护上下文、非凡标识等作用的：
| 寄存器 | 阐明 |
|---|---|
| SB(Static base pointer) | global symbols |
| FP(Frame pointer) | arguments and locals |
| PC(Program counter) | jumps and branches |
| SP(Stack pointer) | top of stack |
- FP: 应用如
symbol+offset(FP)的形式，援用 callee 函数的入参参数。例如arg0+0(FP)，arg1+8(FP)，应用 FP 必须加 symbol，否则无奈通过编译 (从汇编层面来看，symbol 没有什么用，加 symbol 次要是为了晋升代码可读性)。另外，须要留神的是：往往在编写 go 汇编代码时，要站在 callee 的角度来看(FP)，在 callee 看来，(FP) 指向的是 caller 调用 callee 时传递的第一个参数的地位。如果以后的 callee 函数是 add，在 add 的代码中援用 FP，该 FP 指向的地位不在 callee 的 stack frame 之内。而是在 caller 的 stack frame 上，指向调用 add 函数时传递的第一个参数的地位，常常在 callee 中用symbol+offset(FP)来获取入参的参数值。 - SB: 全局动态基指针，个别用在申明函数、全局变量中。
- SP: 该寄存器也是最具备迷惑性的寄存器，因为会有伪 SP 寄存器和硬件 SP 寄存器之分。plan9 的这个伪 SP 寄存器指向以后栈帧第一个局部变量的完结地位 (为什么说是完结地位，能够看上面寄存器内存布局图)，应用形如 symbol+offset(SP) 的形式，援用函数的局部变量。offset 的非法取值是 [-framesize, 0)，留神是个左闭右开的区间。如果局部变量都是 8 字节，那么第一个局部变量就能够用 localvar0-8(SP) 来示意。与硬件寄存器 SP 是两个不同的货色，在栈帧 size 为 0 的状况下，伪寄存器 SP 和硬件寄存器 SP 指向同一地位。手写汇编代码时，如果是 symbol+offset(SP) 模式，则示意伪寄存器 SP。如果是 offset(SP)则示意硬件寄存器 SP。
务必留神：对于编译输入(go tool compile -S / go tool objdump) 的代码来讲，所有的 SP 都是硬件 SP 寄存器，无论是否带 symbol（这一点十分具备迷惑性，须要缓缓了解。往往在剖析编译输入的汇编时，看到的就是硬件 SP 寄存器）。 - PC: 实际上就是在体系结构的常识中常见的 pc 寄存器，在 x86 平台下对应 ip 寄存器，amd64 上则是 rip。除了个别跳转之外，手写 plan9 汇编代码时，很少用到 PC 寄存器。
通过下面的解说，想必曾经对 4 个外围寄存器的区别有了肯定的意识（或者是更加的蛊惑、一头雾水）。那么，须要注意的是：如果是在剖析编译输入的汇编代码时，要重点看 SP、SB 寄存器（FP 寄存器在这里是看不到的）。如果是，在手写汇编代码，那么要重点看 FP、SP 寄存器。
3.2.1 伪寄存器的内存模型
下图形容了栈桢与各个寄存器的内存关系模型，值得注意的是要站在 callee 的角度来看
有一点须要留神的是，return addr 也是在 caller 的栈上的，不过往栈上插 return addr 的过程是由 CALL 指令实现的（在剖析汇编时，是看不到对于 addr 相干空间信息的。在调配栈空间时，addr 所占用空间大小不蕴含在栈帧大小内）。
在 AMD64 环境，伪 PC 寄存器其实是 IP 指令计数器寄存器的别名。伪 FP 寄存器对应的是 caller 函数的帧指针，个别用来拜访 callee 函数的入参参数和返回值。伪 SP 栈指针对应的是以后 callee 函数栈帧的底部（不包含参数和返回值局部），个别用于定位局部变量。伪 SP 是一个比拟非凡的寄存器，因为还存在一个同名的 SP 真寄存器，真 SP 寄存器对应的是栈的顶部。
在编写 Go 汇编时，当须要辨别伪寄存器和真寄存器的时候只须要记住一点：伪寄存器个别须要一个标识符和偏移量为前缀，如果没有标识符前缀则是真寄存器。比方 (SP)、+8(SP) 没有标识符前缀为真 SP 寄存器，而 a(SP)、b+8(SP)有标识符为前缀示意伪寄存器。
3.2.2 几点阐明
咱们这里对容易混同的几点简略进行阐明：
- 伪 SP 和硬件 SP 不是一回事，在手写汇编代码时，伪 SP 和硬件 SP 的辨别办法是看该 SP 前是否有 symbol。如果有 symbol，那么即为伪寄存器，如果没有，那么阐明是硬件 SP 寄存器。
- 伪 SP 和 FP 的绝对地位是会变的，所以不应该尝试用伪 SP 寄存器去找那些用 FP+offset 来援用的值，例如函数的入参和返回值。
- 官网文档中说的伪 SP 指向 stack 的 top，可能是有问题的。其指向的局部变量地位实际上是整个栈的栈底（除 caller BP 之外），所以说 bottom 更适合一些。
- 在 go tool objdump/go tool compile -S 输入的代码中，是没有伪 SP 和 FP 寄存器的，咱们下面说的辨别伪 SP 和硬件 SP 寄存器的办法，对于上述两个命令的输入后果是没法应用的。在编译和反汇编的后果中，只有实在的 SP 寄存器。
3.2.3 IA64 和 plan9 的对应关系
在 plan9 汇编里还能够间接应用的 amd64 的通用寄存器，利用代码层面会用到的通用寄存器次要是: rax, rbx, rcx, rdx, rdi, rsi, r8~r15 这些寄存器，尽管 rbp 和 rsp 也能够用，不过 bp 和 sp 会被用来治理栈顶和栈底，最好不要拿来进行运算。
plan9 中应用寄存器不须要带 r 或 e 的前缀，例如 rax，只有写 AX 即可: MOVQ $101, AX = mov rax, 101
上面是通用通用寄存器的名字在 IA64 和 plan9 中的对应关系:
3.3 罕用操作指令
上面列出了罕用的几个汇编指令（指令后缀Q 阐明是 64 位上的汇编指令）
| 助记符 | 指令品种 | 用处 | 示例 |
|---|---|---|---|
MOVQ |
传送 | 数据传送 | MOVQ 48, AX // 把 48 传送到 AX |
LEAQ |
传送 | 地址传送 | LEAQ AX, BX // 把 AX 无效地址传送到 BX |
PUSHQ |
传送 | 栈压入 | PUSHQ AX // 将 AX 内容送入栈顶地位 |
POPQ |
传送 | 栈弹出 | POPQ AX // 弹出栈顶数据后批改栈顶指针 |
ADDQ |
运算 | 相加并赋值 | ADDQ BX, AX // 等价于 AX+=BX |
SUBQ |
运算 | 相减并赋值 | SUBQ BX, AX // 等价于 AX-=BX |
CMPQ |
运算 | 比拟大小 | CMPQ SI CX // 比拟 SI 和 CX 的大小 |
CALL |
转移 | 调用函数 | CALL runtime.printnl(SB) // 发动调用 |
JMP |
转移 | 无条件转移指令 | JMP 0x0185 // 无条件转至 0x0185 地址处 |
JLS |
转移 | 条件转移指令 | JLS 0x0185 // 右边小于左边，则跳到 0x0185 |
4. 汇编剖析
说了那么多，it is code show time。
4.1 如何输入 Go 汇编
对于写好的 go 源码，生成对应的 Go 汇编，大略有上面几种
- 办法 1 先应用
go build -gcflags "-N -l" main.go生成对应的可执行二进制文件 再应用go tool objdump -s "main." main反编译获取对应的汇编
反编译时"main." 示意只输入 main 包中相干的汇编"main.main" 则示意只输入 main 包中 main 办法相干的汇编
- 办法 2 应用
go tool compile -S -N -l main.go这种形式间接输入汇编 -
办法 3 应用
go build -gcflags="-N -l -S" main.go间接输入汇编
留神：在应用这些命令时，加上对应的 flag，否则某些逻辑会被编译器优化掉，而看不到对应残缺的汇编代码-l 禁止内联 -N 编译时，禁止优化 -S 输入汇编代码
4.2 Go 汇编示例
go 示例代码
package main
func add(a, b int) int{
sum := 0 // 不设置该局部变量 sum，add 栈空间大小会是 0
sum = a+b
return sum
}
func main(){println(add(1,2))
}编译 go 源代码，输入汇编
go tool compile -N -l -S main.go 截取次要汇编如下：
"".add STEXT nosplit size=60 args=0x18 locals=0x10
0x0000 00000 (main.go:3) TEXT "".add(SB), NOSPLIT, $16-24
0x0000 00000 (main.go:3) SUBQ $16, SP ;; 生成 add 栈空间
0x0004 00004 (main.go:3) MOVQ BP, 8(SP)
0x0009 00009 (main.go:3) LEAQ 8(SP), BP
;; ...omitted FUNCDATA stuff...
0x000e 00014 (main.go:3) MOVQ $0, "".~r2+40(SP) ;; 初始化返回值
0x0017 00023 (main.go:4) MOVQ $0, "".sum(SP) ;; 局部变量 sum 赋为 0
0x001f 00031 (main.go:5) MOVQ "".a+24(SP), AX ;; 取参数 a
0x0024 00036 (main.go:5) ADDQ "".b+32(SP), AX ;; 等价于 AX=a+b
0x0029 00041 (main.go:5) MOVQ AX, "".sum(SP) ;; 赋值局部变量 sum
0x002d 00045 (main.go:6) MOVQ AX, "".~r2+40(SP) ;; 设置返回值
0x0032 00050 (main.go:6) MOVQ 8(SP), BP
0x0037 00055 (main.go:6) ADDQ $16, SP ;; 革除 add 栈空间
0x003b 00059 (main.go:6) RET
......
"".main STEXT size=107 args=0x0 locals=0x28
0x0000 00000 (main.go:9) TEXT "".main(SB), $40-0
......
0x000f 00015 (main.go:9) SUBQ $40, SP ;; 生成 main 栈空间
0x0013 00019 (main.go:9) MOVQ BP, 32(SP)
0x0018 00024 (main.go:9) LEAQ 32(SP), BP
;; ...omitted FUNCDATA stuff...
0x001d 00029 (main.go:10) MOVQ $1, (SP) ;;add 入参：1
0x0025 00037 (main.go:10) MOVQ $2, 8(SP) ;;add 入参：2
0x002e 00046 (main.go:10) CALL "".add(SB) ;; 调用 add 函数
0x0033 00051 (main.go:10) MOVQ 16(SP), AX
0x0038 00056 (main.go:10) MOVQ AX, ""..autotmp_0+24(SP)
0x003d 00061 (main.go:10) CALL runtime.printlock(SB)
0x0042 00066 (main.go:10) MOVQ ""..autotmp_0+24(SP), AX
0x0047 00071 (main.go:10) MOVQ AX, (SP)
0x004b 00075 (main.go:10) CALL runtime.printint(SB)
0x0050 00080 (main.go:10) CALL runtime.printnl(SB)
0x0055 00085 (main.go:10) CALL runtime.printunlock(SB)
0x005a 00090 (main.go:11) MOVQ 32(SP), BP
0x005f 00095 (main.go:11) ADDQ $40, SP ;; 革除 main 栈空间
0x0063 00099 (main.go:11) RET
......这里列举了一个简略的 int 类型 加法 示例，理论开发中会遇到各种参数类型，要简单的多，这里只是抛砖引玉 :)
4.3 Go 汇编解析
针对 4.2 输入汇编，对重要外围代码进行剖析。
4.3.1 add 函数汇编解析
TEXT "".add(SB), NOSPLIT|ABIInternal, $16-24TEXT"".addTEXT 指令申明了"".add是 .text 代码段的一部分，并表明跟在这个申明后的是函数的函数体。在链接期，""这个空字符会被替换为以后的包名: 也就是说，"".add在链接到二进制文件后会变成 main.add
(SB) SB 是一个虚构的伪寄存器，保留动态基地址(static-base) 指针，即咱们程序地址空间的开始地址。"".add(SB) 表明咱们的符号位于某个固定的绝对地址空间起始处的偏移地位 (最终是由链接器计算失去的)。换句话来讲，它有一个间接的相对地址: 是一个全局的函数符号。
NOSPLIT: 向编译器表明不应该插入 stack-split 的用来查看栈须要扩张的前导指令。在咱们 add 函数的这种状况下，编译器本人帮咱们插入了这个标记: 它足够聪慧地意识到，因为 add 没有任何局部变量且没有它本人的栈帧，所以肯定不会超出以后的栈。不然，每次调用函数时，在这里执行栈查看就是齐全节约 CPU 工夫了。
$0-16
24 指定了调用方传入的参数 + 返回值大小（24 字节 = 入参 a、b 大小 8 字节 *2+ 返回值 8 字节）
通常来讲，帧大小后个别都跟随着一个参数大小，用减号分隔。(这不是一个减法操作，只是一种非凡的语法) 帧大小 $24-8 意味着这个函数有 24 个字节的帧以及 8 个字节的参数，位于调用者的帧上。如果 NOSPLIT 没有在 TEXT 中指定，则必须提供参数大小。对于 Go 原型的汇编函数，go vet 会查看参数大小是否正确。In the general case, the frame size is followed by an argument size, separated by a minus sign. (It’s not a subtraction, just idiosyncratic syntax.) The frame size $24-8 states that the function has a 24-byte frame and is called with 8 bytes of argument, which live on the caller’s frame. If NOSPLIT is not specified for the TEXT, the argument size must be provided. For assembly functions with Go prototypes, go vet will check that the argument size is correct.SUBQ $16, SPSP 为栈顶指针，该语句等价于 SP-=16（因为栈空间是向下增长的，所以开拓栈空间时为减操作），示意生成 16 字节大小的栈空间。MOVQ $0, "".~r2+40(SP)此时的 SP 为 add 函数栈的栈顶指针，40(SP)的地位则是 add 返回值的地位，该地位位于 main 函数栈空间内。该语句设置返回值类型的 0 值，即初始化返回值，避免失去脏数据（返回值类型为 int，int 的 0 值为 0）。MOVQ "".a+24(SP), AX从 main 函数栈空间获取入参 a 的值，存到寄存器 AXADDQ "".b+32(SP), AX从 main 函数栈空间获取入参 b 的值，与寄存器 AX 中存储的 a 值相加，后果存到 AX。相当于 AX=a+bMOVQ AX, "".~r2+40(SP)把 a+b 的后果放到 main 函数栈中, add(a+b)返回值所在的地位-
ADDQ $16, SP偿还 add 函数占用的栈空间4.3.2 函数栈桢构造模型
依据 4.2 对应汇编绘制的函数栈桢构造模型
还记得后面提到的，Go 汇编应用的是caller-save模式，被调用函数的参数、返回值、栈地位都须要由调用者保护、筹备吗？
在函数栈桢构造中能够看到，add()函数的入参以及返回值都由调用者 main()函数保护。也正是因为如此，GO 有了其余语言不具备的，反对多个返回值的个性。
4.4 Go 汇编语法
这里重点讲一下函数申明、变量申明。
4.4.1 函数申明
来看一个典型的 Go 汇编函数定义
// func add(a, b int) int
// 该 add 函数申明定义在同一个 package name 下的任意 .go 文件中
// 只有函数头，没有实现
// add 函数的 Go 汇编实现
// pkgname 默认是 ""
TEXT pkgname·add(SB), NOSPLIT, $16-24
MOVQ a+0(FP), AX
ADDQ b+8(FP), AX
MOVQ AX, ret+16(FP)
RETGo 汇编实现为什么是 TEXT 结尾？仔细观察下面的过程内存布局图就会发现，咱们的代码在是存储在.text 段中的，这里也就是一种约定俗成的起名形式。实际上在 plan9 中 TEXT 是一个指令，用来定义一个函数。
定义中的 pkgname 是能够省略的，(非想写也能够写上，不过写上 pkgname 的话，在重命名 package 之后还须要改代码，默认为"") 编译器会在链接期主动加上所属的包名称。
中点 · 比拟非凡，是一个 unicode 的中点，该点在 mac 下的输出办法是 option+shift+9。在程序被链接之后，所有的中点 · 都会被替换为句号.，比方你的办法是runtime·main，在编译之后的程序里的符号则是runtime.main。
简略总结一下, Go 汇编实现函数申明，格局为:
动态基地址(static-base) 指针
|
| add 函数入参 + 返回值总大小
| |
TEXT pkgname·add(SB),NOSPLIT,$16-24
| | |
函数所属包名 函数名 add 函数栈帧大小- 函数栈帧大小：局部变量 + 可能须要的额定调用函数的参数空间的总大小，不包含调用其它函数时的 ret address 的大小。
- (SB): SB 是一个虚构寄存器，保留了动态基地址(static-base) 指针，即咱们程序地址空间的开始地址。
"".add(SB)表明咱们的符号位于某个固定的绝对地址空间起始处的偏移地位 (最终是由链接器计算失去的)。换句话来讲，它有一个间接的相对地址: 是一个全局的函数符号。 - NOSPLIT: 向编译器表明，不应该插入 stack-split 的用来查看栈须要扩张的前导指令。在咱们 add 函数的这种状况下，编译器本人帮咱们插入了这个标记: 它足够聪慧地意识到，add 不会超出以后的栈，因而没必要调用函数时在这里执行栈查看。
4.4.2 变量申明
汇编里的全局变量，个别是存储在 .rodata 或者 .data 段中。对应到 Go 代码，就是已初始化过的全局的 const、var 变量 / 常量。
应用 DATA 联合 GLOBL 来定义一个变量。
DATA 的用法为:
DATA symbol+offset(SB)/width, value大多数参数都是字面意思，不过这个 offset 须要留神：其含意是该值绝对于符号 symbol 的偏移，而不是绝对于全局某个地址的偏移。
GLOBL 汇编指令用于定义名为 symbol 的全局变量，变量对应的内存宽度为 width，内存宽度局部必须用常量初始化。
GLOBL ·symbol(SB), width上面是定义了多个变量的例子:
DATA ·age+0(SB)/4, $8 ;; 数值 8 为 4 字节
GLOBL ·age(SB), RODATA, $4
DATA ·pi+0(SB)/8, $3.1415926 ;; 数值 3.1415926 为 float64, 8 字节
GLOBL ·pi(SB), RODATA, $8
DATA ·year+0(SB)/4, $2020 ;; 数值 2020 为 4 字节
GLOBL ·year(SB), RODATA, $4
;; 变量 hello 应用 2 个 DATA 来定义
DATA ·hello+0(SB)/8, $"hello my" ;; `hello my` 共 8 个字节
DATA ·hello+8(SB)/8, $"world" ;; ` world` 共 8 个字节(3 个空格)
GLOBL ·hello(SB), RODATA, $16 ;; `hello my world` 共 16 个字节
DATA ·hello<>+0(SB)/8, $"hello my" ;; `hello my` 共 8 个字节
DATA ·hello<>+8(SB)/8, $"world" ;; ` world` 共 8 个字节(3 个空格)
GLOBL ·hello<>(SB), RODATA, $16 ;; `hello my world` 共 16 个字节大部分都比拟好了解，不过这里引入了新的标记<>，这个跟在符号名之后，示意该全局变量只在以后文件中失效，相似于 C 语言中的 static。如果在另外文件中援用该变量的话，会报 relocation target not found 的谬误。
5. 手写汇编实现性能
在 Go 源码中会看到一些汇编写的代码，这些代码跟其余 go 代码一起组成了整个 go 的底层性能实现。上面，咱们通过一个简略的 Go 汇编代码示例来实现两数相加性能。
5.1 应用 Go 汇编实现 add 函数
Go 代码
package main
func add(a, b int64) int64
func main(){println(add(2,3))
}Go 源码中 add()函数只有函数签名，没有具体的实现（应用 GO 汇编实现）
应用 Go 汇编实现的 add()函数
TEXT ·add(SB), $0-24 ;; add 栈空间为 0，入参 + 返回值大小 =24 字节
MOVQ x+0(FP), AX ;; 从 main 中取参数：2
ADDQ y+8(FP), AX ;; 从 main 中取参数：3
MOVQ AX, ret+16(FP) ;; 保留后果到返回值
RET把 Go 源码与 Go 汇编编译到一起(我这里，这两个文件在同一个目录)
go build -gcflags "-N -l" . 我这里目录为 demo1，所以失去可执行程序 demo1，运行失去后果：5
5.2 反编译可执行程序
对 5.1 中失去的可执行程序 demo1 应用 objdump 进行反编译，获取汇编代码
go tool objdump -s "main." demo1 失去汇编
......
TEXT main.main(SB) /root/go/src/demo1/main.go
main.go:5 0x4581d0 64488b0c25f8ffffff MOVQ FS:0xfffffff8, CX
main.go:5 0x4581d9 483b6110 CMPQ 0x10(CX), SP
main.go:5 0x4581dd 7655 JBE 0x458234
main.go:5 0x4581df 4883ec28 SUBQ $0x28, SP ;; 生成 main 栈桢
main.go:5 0x4581e3 48896c2420 MOVQ BP, 0x20(SP)
main.go:5 0x4581e8 488d6c2420 LEAQ 0x20(SP), BP
main.go:6 0x4581ed 48c7042402000000 MOVQ $0x2, 0(SP) ;; 参数值 2
main.go:6 0x4581f5 48c744240803000000 MOVQ $0x3, 0x8(SP) ;; 参数值 3
main.go:6 0x4581fe e83d000000 CALL main.add(SB);;call add
main.go:6 0x458203 488b442410 MOVQ 0x10(SP), AX
main.go:6 0x458208 4889442418 MOVQ AX, 0x18(SP)
main.go:6 0x45820d e8fe2dfdff CALL runtime.printlock(SB)
main.go:6 0x458212 488b442418 MOVQ 0x18(SP), AX
main.go:6 0x458217 48890424 MOVQ AX, 0(SP)
main.go:6 0x45821b e87035fdff CALL runtime.printint(SB)
main.go:6 0x458220 e87b30fdff CALL runtime.printnl(SB)
main.go:6 0x458225 e8662efdff CALL runtime.printunlock(SB)
main.go:7 0x45822a 488b6c2420 MOVQ 0x20(SP), BP
main.go:7 0x45822f 4883c428 ADDQ $0x28, SP
main.go:7 0x458233 c3 RET
main.go:5 0x458234 e89797ffff CALL runtime.morestack_noctxt(SB)
main.go:5 0x458239 eb95 JMP main.main(SB)
;; 反编译失去的汇编与 add_amd64.s 文件中的汇编大抵操作统一
TEXT main.add(SB) /root/go/src/demo1/add_amd64.s
add_amd64.s:2 0x458240 488b442408 MOVQ 0x8(SP), AX ;; 获取第一个参数
add_amd64.s:3 0x458245 4803442410 ADDQ 0x10(SP), AX ;; 参数 a + 参数 b
add_amd64.s:5 0x45824a 4889442418 MOVQ AX, 0x18(SP) ;; 保留计算结果
add_amd64.s:7 0x45824f c3 RET通过下面操作，可知：
- (FP)伪寄存器，只有在编写 Go 汇编代码时应用。FP 伪寄存器指向 caller 传递给 callee 的第一个参数
- 应用 go tool compile / go tool objdump 失去的汇编中看不到 (FP) 寄存器的踪影
6. Go 调试工具
这里举荐 2 个 Go 代码调试工具。
6.1 gdb 调试 Go 代码
测试代码
package main
type Ier interface{add(a, b int) int
sub(a, b int) int
}
type data struct{a, b int}
func (*data) add(a, b int) int{return a+b}
func (*data) sub(a, b int) int{return a-b}
func main(){var t Ier = &data{3,4}
println(t.add(1,2))
println(t.sub(3,2))
}编译 go build -gcflags "-N -l" -o main
应用 GDB 调试
gdb main
GNU gdb (GDB) Red Hat Enterprise Linux 7.6.1-80.el7
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later http://gnu.org/licenses/gpl.html
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /root/go/src/interface/main...done.
Loading Go Runtime support.
(gdb) list // 显示源码
14 func (*data) add(a, b int) int{
15 return a+b
16 }
17
18 func (*data) sub(a, b int) int{
19 return a-b
20 }
21
22
23 func main(){(gdb) list
24 var t Ier = &data{3,4}
25
26 println(t.add(1,2))
27 println(t.sub(3,2))
28 }
29
(gdb) b 26 // 在源码 26 行处设置断点
Breakpoint 1 at 0x45827c: file /root/go/src/interface/main.go, line 26.
(gdb) r
Starting program: /root/go/src/interface/main
Breakpoint 1, main.main () at /root/go/src/interface/main.go:26
26 println(t.add(1,2))
(gdb) info locals // 显示变量
t = {tab = 0x487020 <data,main.Ier>, data = 0xc000096000}
(gdb) ptype t // 打印 t 的构造
type = struct runtime.iface {
runtime.itab *tab;
void *data;
}
(gdb) p *t.tab.inter // 打印 t.tab.inter 指针指向的数据
$2 = {typ = {size = 16, ptrdata = 16, hash = 2491815843, tflag = 7 '\a', align = 8 '\b', fieldAlign = 8 '\b',
kind = 20 '\024', equal = {void (void *, void *, bool *)} 0x466ec0,
gcdata = 0x484351 "\002\003\004\005\006\a\b\t\n\f\r\016\017\020\022\025\026\030\033\034\036\037\"&(,-5<BUXx\216\231\330\335\377", str = 6568, ptrToThis = 23808}, pkgpath = {bytes = 0x4592b4""}, mhdr = []runtime.imethod = {{name = 277,
ityp = 48608}, {name = 649, ityp = 48608}}}
(gdb) disass // 显示汇编
Dump of assembler code for function main.main:
0x0000000000458210 <+0>: mov %fs:0xfffffffffffffff8,%rcx
0x0000000000458219 <+9>: cmp 0x10(%rcx),%rsp
0x000000000045821d <+13>: jbe 0x458324 <main.main+276>
0x0000000000458223 <+19>: sub $0x50,%rsp
0x0000000000458227 <+23>: mov %rbp,0x48(%rsp)
0x000000000045822c <+28>: lea 0x48(%rsp),%rbp
0x0000000000458231 <+33>: lea 0x10dc8(%rip),%rax # 0x469000
0x0000000000458238 <+40>: mov %rax,(%rsp)
0x000000000045823c <+44>: callq 0x40a5c0 <runtime.newobject>罕用的 gdb 调试命令
- run
- continue
- break
- backtrace 与 frame
- info break、locals
- list 命令
- print 和 ptype 命令
-
disass
除了 gdb，另外举荐一款 gdb 的增强版调试工具 cgdbhttps://cgdb.github.io/
成果如下图所示，分两个窗口：下面显示源代码，上面是具体的命令行调试界面(跟 gdb 一样)：
6.2 delve 调试代码
delve 我的项目地址
https://github.com/go-delve/d…
带图形化界面的 dlv 我的项目地址
https://github.com/aarzilli/gdlv
dlv 的装置应用，这里不再做过多解说，感兴趣的能够尝试一下。
- gdb 作为调试工具自是不必多说，比拟老牌、弱小，能够反对多种语言。
- delve 则是应用 go 语言开发的，用来调试 go 的工具，性能也是非常弱小，打印后果能够显示 gdb 反对不了的货色，这里不再做过多解说，有趣味的能够查阅相干材料。
7. 总结
对于 Go 汇编根底大抵须要相熟上面几个方面：
通过下面的例子置信曾经让你对 Go 的汇编有了肯定的了解。当然，对于大部分业务开发人员来说，只有看的懂即可。如果想进一步的理解，能够浏览相干的材料或者书籍。
最初想说的是：鉴于集体能力无限，在浏览过程中你可能会发现存在的一些问题或者缺点，欢送各位大佬斧正。如果感兴趣的话，也能够一起私下交换。
8. 参考资料
在整顿的过程中，局部参考、援用上面链接地址内容。有一些写的还是不错的，感兴趣的同学能够浏览。
[1] https://github.com/cch123/gol… plan9 assembly
[2] https://segmentfault.com/a/11… 汇编入门
[3] https://www.davidwong.fr/goasm/ Go Assembly by Example
[4] https://juejin.im/post/684490…
[5] https://github.com/go-interna…
[6] https://lrita.github.io/2017/…
[7] https://chai2010.cn/advanced-…
