关于golang:转

在深刻学习 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 中文件类型大抵分为 7 种：

1.  b: 块设施文件 
2.  c：字符设施文件
3.  d：目录
4.  -：一般文件
5.  l：链接
6.  s：socket
7.  p：管道

所有皆文件

什么是程序？
什么是过程？

2.1 程序

程序

2.2 过程

过程线程

创立过程个别应用 fork 办法(通常会有个拉起程序，先 fork 本身生成一个子过程。而后，在该子过程中通过 exec 函数把对应程序加载进来，进而启动指标过程。当然，实际上要简单得多)，而创立线程则是应用 pthread 线程库。

运行时堆(heap)运行时栈(stack)

运行时堆运行时栈

3. Go 汇编

对于 Go 编译器而言，其输入的后果是一种形象可移植的汇编代码，这种汇编（Go 的汇编是基于 Plan9 的汇编）并不对应某种实在的硬件架构。Go 的汇编器会应用这种伪汇编，再为指标硬件生成具体的机器指令。

伪汇编

Rob PikeThe 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.

caller-save

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

symbol+offset(FP)arg0+0(FP)，arg1+8(FP)symbol+offset(FP)务必留神

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 罕用操作指令

MOVQLEAQPUSHQPOPQADDQSUBQCMPQCALLJMPJLS

4. 汇编剖析

说了那么多，it is code show time。

4.1 如何输入 Go 汇编

对于写好的 go 源码，生成对应的 Go 汇编，大略有上面几种

go build -gcflags "-N -l" main.gogo tool objdump -s "main." main

"main.""main.main"

go tool compile -S -N -l main.gogo build -gcflags="-N -l -S" main.go

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
    ......

加法

4.3 Go 汇编解析

针对 4.2 输入汇编，对重要外围代码进行剖析。

4.3.1 add 函数汇编解析

TEXT "".add(SB), NOSPLIT|ABIInternal, $16-24TEXT "".add"".add"""".add

(SB)"".add(SB)

NOSPLIT:

$0-16

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, SPMOVQ $0, "".~r2+40(SP)MOVQ "".a+24(SP), AXADDQ "".b+32(SP), AXMOVQ AX, "".~r2+40(SP)ADDQ $16, SPcaller-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)
    RET

TEXT

""

··.runtime·mainruntime.main

简略总结一下, Go 汇编实现函数申明，格局为:

动态基地址(static-base) 指针
                  |
                  |      add函数入参+返回值总大小
                  |               |
TEXT pkgname·add(SB),NOSPLIT,$16-24
        |     |               |
函数所属包名  函数名          add函数栈帧大小

"".add(SB)

4.4.2 变量申明

.rodata.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个字节

<>

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 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 的增强版调试工具 cgdb

https://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-…

当前版本	AnqiCMS-v3.3.3
开发者	Sinclair Liang
主要特色	安企内容管理系统(AnqiCMS)，是一款使用 GoLang 开发的企业站内容管理系统，它部署简单，软件安全，界面优雅，小巧，执行速度飞快，使用 AnqiCMS 搭建的网站可以防止众多安全问题发生。
GitHub	https://github.com/fesiong/goblog

0. 为什么写本文

1. 为什么须要汇编

2. 程序与过程

2.1 程序

2.2 过程

3. Go 汇编

3.1 几个概念

3.2 Go 的外围寄存器

3.2.1 伪寄存器的内存模型

3.2.2 几点阐明

3.2.3 IA64 和 plan9 的对应关系

3.3 罕用操作指令

4. 汇编剖析

4.1 如何输入 Go 汇编

4.2 Go 汇编示例

4.3 Go 汇编解析

4.3.1 add 函数汇编解析

4.4 Go 汇编语法

4.4.1 函数申明

4.4.2 变量申明

5. 手写汇编实现性能

5.1 应用 Go 汇编实现 add 函数

5.2 反编译可执行程序

6. Go 调试工具

6.1 gdb 调试 Go 代码

6.2 delve 调试代码

7. 总结

google浏览器打不开youtube

华为谷歌三件套 2024 最新版

谷歌三件套华为专版app软件下载

华为谷歌安装器最新版2024 v22.7.96手机版

谷歌四件套一键安装包(Go安装器)

谷歌四件套最新版一键安装包2024(go安装器)

Golang深入理解GPM模型

深入理解golang的异常处理机制

深入理解 Go 语言 defer

Go 单测高级篇：Golang 单测原理深入理解

深入理解Golang并发工具

Golang源码系列四：Interface实现原理分析（golang接口深入理解）