1
| 63 ... 32 | 31 ... 16 | 15 ... 8 | 7 ... 0 |
2
|-----------|-----------|----------|---------|
3
|   RAX     |   EAX     |    AX    | AH | AL |
4
|   RBX     |   EBX     |    BX    | BH | BL |
5
|   RCX     |   ECX     |    CX    | CH | CL |
6
|   RDX     |   EDX     |    DX    | DH | DL |
7
|   RSI     |   ESI     |    SI    |    SIL  |
8
|   RDI     |   EDI     |    DI    |    DIL  |
9
|   RBP     |   EBP     |    BP    |    BPL  |
10
|   RSP     |   ESP     |    SP    |    SPL  |
11
|  R8-R15   |  R8D-R15D | R8W-R15W | R8B-R15B|

1
# AT&T
2
movl    $42, %eax              # 立即数
3
movl    %eax, %ebx             # 寄存器
4
movl    (%rsp), %eax           # 直接寻址
5
movl    8(%rsp), %eax          # 基址 + 偏移
6
movl    (%rsi, %rdi, 4), %eax  # 基址 + 索引 * 比例
7
movl    0x10(%rsi, %rdi, 4), %eax  # 完整格式

1
; Intel 等价
2
mov     eax, 42
3
mov     ebx, eax
4
mov     eax, [rsp]
5
mov     eax, [rsp + 8]
6
mov     eax, [rsi + rdi*4]
7
mov     eax, [rsi + rdi*4 + 0x10]

1
# 存储 0x12345678 到内存 0x100
2
地址:  0x100  0x101  0x102  0x103
3
值:    0x78   0x56   0x34   0x12

1
movq    %rax, %rbx       # rbx = rax
2
movq    $42, %rax        # rax = 42
3
movq    (%rsp), %rax     # rax = *rsp
4
movq    %rax, (%rsp)     # *rsp = rax
5
leaq    8(%rsp), %rax    # rax = rsp + 8（取地址，不读内存）
6
xchgq   %rax, %rbx      # 交换 rax 和 rbx

1
addq    %rbx, %rax       # rax += rbx
2
subq    $1, %rax         # rax -= 1
3
imulq   %rbx, %rax       # rax *= rbx
4
incq    %rax             # rax++
5
decq    %rax             # rax--
6
negq    %rax             # rax = -rax

1
andq    $0xFF, %rax      # rax &= 0xFF
2
orq     %rbx, %rax       # rax |= rbx
3
xorq    %rax, %rax       # rax = 0（常用清零）
4
shlq    $4, %rax         # rax <<= 4
5
shrq    $8, %rax         # rax >>= 8（逻辑右移）
6
sarq    $1, %rax         # rax >>= 1（算术右移）
7
notq    %rax             # rax = ~rax

1
cmpq    %rbx, %rax       # 计算 rax - rbx，设置标志位
2
testq   %rax, %rax       # 计算 rax & rax，检测是否为 0

1
je      label            # 相等 (ZF=1)
2
jne     label            # 不等 (ZF=0)
3
jl      label            # 有符号小于 (SF!=OF)
4
jg      label            # 有符号大于 (ZF=0 且 SF=OF)
5
jb      label            # 无符号低于 (CF=1)
6
ja      label            # 无符号高于 (CF=0 且 ZF=0)
7
jle     label            # 有符号小于等于
8
jge     label            # 有符号大于等于
9
jbe     label            # 无符号低于等于
10
jae     label            # 无符号高于等于
11
js      label            # 负数 (SF=1)
12
jz      label            # 为零 (同 je)
13
jnz     label            # 非零 (同 jne)

1
cmovle  %rbx, %rax       # 如果 rax <= rbx，rax = rbx
2
cmovne  %rcx, %rdx       # 如果不等，rdx = rcx

1
pushq   %rax             # rsp -= 8; *rsp = rax
2
popq    %rax             # rax = *rsp; rsp += 8

1
# 典型函数序言/结语
2
pushq   %rbp              # 保存旧帧指针
3
movq    %rsp, %rbp        # 设置新帧指针
4
subq    $16, %rsp         # 分配局部变量空间
5

6
# ... 函数体 ...
7

8
movq    %rbp, %rsp        # 恢复栈指针
9
popq    %rbp              # 恢复帧指针
10
ret                       # 返回

1
| 返回地址     |  <- call 指令压入
2
| 旧 %rbp     |  <- push %rbp
3
| 局部变量 1  |  <- -8(%rbp)
4
| 局部变量 2  |  <- -16(%rbp)

1
int add(int a, int b) {
2
    return a + b;
3
}
4

5
int main() {
6
    int result = add(3, 4);
7
    return result;
8
}

1
add:
2
    leal    (%rdi, %rsi), %eax   # eax = edi + esi
3
    ret
4

5
main:
6
    subq    $8, %rsp             # 栈对齐
7
    movl    $3, %edi             # 第一个参数
8
    movl    $4, %esi             # 第二个参数
9
    call    add                  # 调用 add
10
    addq    $8, %rsp             # 恢复栈
11
    ret

1
.data
2
msg:
3
    .ascii "Hello, World!\n"
4
    len = . - msg
5

6
.text
7
.global _start
8
_start:
9
    # write(1, msg, len)
10
    movq    $1, %rax        # syscall: write
11
    movq    $1, %rdi        # fd: stdout
12
    leaq    msg(%rip), %rsi # buf: 字符串地址
13
    movq    $len, %rdx      # count: 长度
14
    syscall
15

16
    # exit(0)
17
    movq    $60, %rax       # syscall: exit
18
    xorq    %rdi, %rdi      # status: 0
19
    syscall

1
# 标量浮点运算（SSE）
2
addss   %xmm0, %xmm1     # 单精度加法
3
addsd   %xmm0, %xmm1     # 双精度加法
4
mulss   %xmm0, %xmm1     # 单精度乘法
5
divsd   %xmm0, %xmm1     # 双精度除法
6

7
# 浮点比较
8
ucomiss %xmm0, %xmm1     # 单精度比较
9
ucomisd %xmm0, %xmm1     # 双精度比较
10

11
# 数据传送
12
movss   (%rsp), %xmm0    # 加载单精度
13
movsd   (%rsp), %xmm0    # 加载双精度

1
# 反汇编当前函数
2
(gdb) disas
3

4
# 反汇编指定函数
5
(gdb) disas main
6

7
# Intel 语法
8
(gdb) set disassembly-flavor intel
9

10
# 查看寄存器
11
(gdb) info registers
12

13
# 查看标志位
14
(gdb) info registers eflags
15

16
# 单步执行（汇编级）
17
(gdb) si     # step instruction
18
(gdb) ni     # next instruction

1
# 反汇编整个文件
2
objdump -d program
3

4
# Intel 语法
5
objdump -d -M intel program
6

7
# 只看某个函数
8
objdump -d program | grep -A 20 '<main>'

1
# 生成汇编文件
2
gcc -S -masm=att program.c    # AT&T 语法
3
gcc -S -masm=intel program.c  # Intel 语法
4

5
# 不优化
6
gcc -O0 -S program.c
7

8
# 优化并查看
9
gcc -O2 -S program.c
10

11
# 包含 C 源码对照
12
gcc -g -S program.c

1
asm ( "汇编模板"
2
    : 输出操作数   /* 可选 */
3
    : 输入操作数   /* 可选 */
4
    : 修改的寄存器 /* 可选 */
5
);

1
// 读取时间戳计数器
2
static inline unsigned long rdtsc(void) {
3
    unsigned int lo, hi;
4
    asm volatile (
5
        "rdtsc"
6
        : "=a" (lo), "=d" (hi)
7
    );
8
    return ((unsigned long)hi << 32) | lo;
9
}
10

11
// 原子比较并交换
12
bool cas(long *ptr, long oldval, long newval) {
13
    unsigned char result;
14
    asm volatile (
15
        "lock; cmpxchgq %2, %1"
16
        : "=a" (result), "+m" (*ptr)
17
        : "r" (newval), "0" (oldval)
18
        : "memory"
19
    );
20
    return result;
21
}