1
[标签:] 操作码 [操作数1, 操作数2, ...]  // 注释

1
MOVQ $42, AX       // 把立即数 42 存入 AX（AX = 42）
2
ADDQ AX, BX        // BX = BX + AX

1
MOVQ $0, AX         // 立即数 0
2
MOVQ $0x1F, BX      // 十六进制立即数
3
MOVQ $main·result, CX  // 符号地址
4
LEAQ ·name(SB), DX     // 相对 SB 的偏移

1
// 通用寄存器
2
AX, BX, CX, DX      // 通用
3
SI, DI               // 源/目标索引
4
BP                   // 基址指针（帧指针）
5
SP                   // 栈指针
6
R8-R15               // 扩展寄存器
7

8
// 伪寄存器（Plan 9 特有）
9
FP  // Frame Pointer：引用函数参数和局部变量
10
SP  // Stack Pointer：引用栈上的局部变量
11
PC  // Program Counter：跳转指令中使用
12
SB  // Static Base：全局符号的基准地址

1
// Go 函数签名
2
// func add(a, b int64) int64
3
TEXT ·add(SB), NOSPLIT, $0-24
4
    MOVQ a+0(FP), AX    // 第一个参数 a
5
    MOVQ b+8(FP), BX    // 第二个参数 b
6
    ADDQ BX, AX         // AX = a + b
7
    MOVQ AX, ret+16(FP) // 返回值
8
    RET

1
// func example(a int, b int, c float64) (int, float64)
2
// 参数布局：a(8) + b(8) + c(8) = 24 字节
3
// 返回值布局：int(8) + float64(8) = 16 字节
4
// 栈帧大小：$0-40
5

6
TEXT ·example(SB), NOSPLIT, $0-40
7
    MOVQ  a+0(FP),  AX    // a
8
    MOVQ  b+8(FP),  BX    // b
9
    MOVSD c+16(FP), X0    // c（浮点用 X0 寄存器）
10
    // ... 处理 ...
11
    MOVQ  AX, ret+24(FP)     // 第一个返回值
12
    MOVSD X0, ret2+32(FP)    // 第二个返回值
13
    RET

1
MOVQ $10, AX         // 立即数 → 寄存器
2
MOVQ AX, BX          // 寄存器 → 寄存器
3
MOVQ AX, 8(SP)       // 寄存器 → 栈
4
MOVQ 8(SP), AX       // 栈 → 寄存器
5
LEAQ ·data(SB), AX   // 取地址（不加载内容）

1
ADDQ AX, BX    // BX += AX
2
SUBQ $1, CX    // CX -= 1
3
IMULQ AX, BX   // BX *= AX
4
INCQ CX        // CX++
5
DECQ CX        // CX--
6
NEGQ AX        // AX = -AX

1
ANDQ $0xFF, AX   // AX &= 0xFF
2
ORQ  BX, AX      // AX |= BX
3
XORQ AX, AX      // AX = 0（常用清零技巧）
4
SHLQ $4, AX      // AX <<= 4
5
SHRQ $8, BX      // BX >>= 8（无符号）
6
SARQ $1, CX      // CX >>= 1（有符号/算术右移）

1
CMPQ AX, BX        // 比较 AX 和 BX
2
JEQ  label         // 相等跳转
3
JNE  label         // 不等跳转
4
JLT  label         // AX < BX
5
JGT  label         // AX > BX
6
JLE  label         // AX <= BX
7

8
// 无条件跳转
9
JMP  label
10

11
// 测试并跳转
12
TESTQ AX, AX       // 测试 AX 是否为 0
13
JZ   is_zero       // 为 0 跳转
14
JNZ  not_zero      // 不为 0 跳转

1
PUSHQ AX     // AX 压栈
2
POPQ  AX     // 栈顶弹出到 AX
3

4
// 等价于
5
SUBQ $8, SP
6
MOVQ AX, 0(SP)
7
// 和
8
MOVQ 0(SP), AX
9
ADDQ $8, SP

1
// if a > b { return a } else { return b }
2
TEXT ·max(SB), NOSPLIT, $0-24
3
    MOVQ a+0(FP), AX
4
    MOVQ b+8(FP), BX
5
    CMPQ AX, BX
6
    JGT  a_greater
7
    MOVQ BX, ret+16(FP)
8
    RET
9
a_greater:
10
    MOVQ AX, ret+16(FP)
11
    RET

1
// sum(1..n)
2
TEXT ·sum(SB), NOSPLIT, $0-16
3
    MOVQ n+0(FP), CX      // n
4
    XORQ AX, AX            // sum = 0
5
loop:
6
    TESTQ CX, CX           // CX == 0?
7
    JZ   done              // 是，退出
8
    ADDQ CX, AX            // sum += CX
9
    DECQ CX                // CX--
10
    JMP  loop
11
done:
12
    MOVQ AX, ret+8(FP)
13
    RET

1
// 调用其他 Go 函数
2
CALL ·otherFunc(SB)    // 调用包内函数
3
CALL runtime·morestack(SB)  // 调用 runtime 函数
4

5
// 调用前需确保：
6
// 1. SP 对齐到 16 字节
7
// 2. 参数已放入约定位置
8
// 3. 返回地址已压栈

1
// 调用 runtime 函数
2
CALL runtime·memmove(SB)
3

4
// 调用自定义函数
5
CALL ·helper(SB)
6

7
// 需要手动处理栈帧
8
TEXT ·caller(SB), NOSPLIT, $32-8
9
    // 分配 32 字节栈帧
10
    MOVQ $42, 0(SP)        // 第一个参数
11
    CALL ·helper(SB)       // 调用
12
    MOVQ 8(SP), AX         // 获取返回值
13
    MOVQ AX, ret+0(FP)
14
    RET

1
// Go 侧声明
2
// var Count int64
3

4
// 汇编中访问
5
MOVQ ·Count(SB), AX       // 读取
6
ADDQ $1, AX
7
MOVQ AX, ·Count(SB)       // 写入

1
// atomic add
2
TEXT ·atomicAdd(SB), NOSPLIT, $0-16
3
    MOVQ addr+0(FP), BX
4
    MOVQ delta+8(FP), AX
5
    LOCK XADDQ AX, 0(BX)    // LOCK 前缀保证原子性
6
    MOVQ AX, ret+0(FP)
7
    RET

1
// 获取字符串长度
2
TEXT ·strLen(SB), NOSPLIT, $0-16
3
    MOVQ str+0(FP), AX   // 字符串指针
4
    MOVQ str+8(FP), BX   // 字符串长度
5
    MOVQ BX, ret+16(FP)
6
    RET

1
// 获取切片的第三个元素
2
TEXT ·third(SB), NOSPLIT, $0-32
3
    MOVQ slice+0(FP), AX   // 底层数组指针
4
    MOVQ slice+8(FP), BX   // 长度
5
    CMPQ BX, $3             // len < 3?
6
    JLT  out_of_bounds
7
    MOVQ 16(AX), AX         // 第三个元素（偏移 16 = 2 * 8）
8
    MOVQ AX, ret+24(FP)
9
    RET
10
out_of_bounds:
11
    CALL runtime·panicIndex(SB)
12
    RET

1
// Compare And Swap
2
TEXT ·cas(SB), NOSPLIT, $0-24
3
    MOVQ addr+0(FP), BX
4
    MOVQ old+8(FP), AX
5
    MOVQ new+16(FP), CX
6
    LOCK CMPXCHGQ CX, 0(BX)   // if *addr == AX, *addr = CX
7
    JNE  failed
8
    MOVB $1, ret+24(FB)        // 返回 true
9
    RET
10
failed:
11
    MOVB $0, ret+24(FB)        // 返回 false
12
    RET

1
# 查看函数的汇编输出
2
go build -gcflags="-S" ./...
3

4
# 查看特定函数
5
go tool compile -S -I xxx file.go
6

7
# 反编译二进制
8
go tool objdump binary
9
go tool objdump -s "main\.myFunc" binary
10

11
# 导出汇编到文件
12
go build -gcflags="-S" . 2> asm_output.txt

1
TEXT ·growable(SB), $0-8
2
    // 编译器会自动插入栈分裂检查
3
    // 等价于：
4
    // CMPQ SP, 16(g)
5
    // JHI ok
6
    // CALL runtime·morestack(SB)
7
    // JMP growable
8
ok:
9
    // 函数体
10
    RET

1
// 通过 TLS 或 FS/GS 段寄存器获取当前 g
2
get_tls(CX)             // 将当前 g 的地址加载到 CX
3
MOVQ g(CX), DX          // DX = *g
4

5
// 常用字段偏移
6
MOVQ g_stackguard(DX), AX  // 栈保护
7
MOVQ g_p(DX), BX           // 关联的 P

1
// 文件命名约定
2
add_amd64.s     // 仅 amd64
3
add_arm64.s     // 仅 arm64
4
add_riscv64.s   // 仅 riscv64
5

6
// 代码中使用架构常量
7
#ifdef GOARCH_amd64
8
    MOVQ $1, AX
9
#endif
10
#ifdef GOARCH_arm64
11
    MOVD $1, R0
12
#endif