Sholck

不积跬步,无以至千里.不积小流,无以成江海

0%

linux-assembly入门学习

发表于 更新于 分类于
本文字数： 16k 阅读时长 ≈ 15 分钟

linux-assembly入门学习

学习目的

  1. 应用：kernel底层有着大量的汇编语言，包括机器启动强相关的header.s 和原子性函数实现等内嵌汇编
  2. 需求：应用coredump，内核转储，内存分析都需要了解汇编才能更深入分析dump现场
  3. 提升：根据汇编分析寄存器变化，对堆栈分配，寻址方式等机器运行方式，了解架构机器真正运作的方式

汇编特点

  1. 汇编和机器架构硬件的强相关性，能最大发挥硬件特性，比如借助硬件中断, lock等
  2. 不受编译器(gcc)影响，和libc没有直接关系(没有用到库函数)
  3. 关键代码控制，比如保持代码的原子性，通过lock指令进行lock锁总线
  4. 性能优化，虽然锁总线影响性能，但是锁缓存是不是也比mutex快很多(todo)

汇编介绍

一种架构强相关，硬件强相关的底层语言，以人类可读的语言在汇编为二进制的机器指令码后控制机器的运行

汇编语法

汇编 是根据架构区分的，目前接触的是 AT&T， Inter, arm(需要找个ardroid机器实践)，linux下用的是AT&T，包括header.s和内嵌汇编

不同架构的汇编语法不同

  1. 操作数位置：AT&T和Intel的源操作数，目的操作数位置是相反的

    1
    2
    AT&T语法：源操作数，目的操作数   cmpxchg %ecx, %ebx；如果EAX与EBX相等，则ECX送EBX且ZF置1；否则EBX送EAX，且ZF清0
    Intel语法: 目的操作数，源操作数   CMPXCHG ebx, ecx ；如果EAX与EBX相等，则ECX送EBX且ZF置1；否则EBX送EAX，且ZF清0

  2. 语法前缀：汇编根据架构，语法前缀也是不同的

    1
    2
    AT&T: 操作数和立即数都是有前缀的。  操作数：%作为前缀 %eax 立即数： $作为前缀  $1
    Inter:  操作数和立即数无前缀的。    操作数： eax            立即数： 1

  3. 操作数字长：操作符去表示操作数字长的方式也不同：

    1
    2
    3
    4
    AT&T 由操作符的后缀表示操作数字长： b 单字节   w 双字节   l 4字节  q 8字节(64bit)， 比如
            movb (%rbx), %al  将rbx指向的地址的首字节复制给al
            movb $10, -1(%rbx)  将10复制给 rbx指向的地址的前一个字节
    Intel 通过操作数前面加前缀表示：  比如 byte ptr ， word ptr

  4. 内存寻址，首先需要了解基本的寻址方式有哪些

汇编工具

汇编器

汇编器有as和nasm，可以将汇编代码翻译为二进制的机器码。linux使用的是as，也gcc依赖的汇编器

as一般的使用和选项如下：

1
2
3
4
5
-g 汇编时带上行相关信息
-o 指定目标
--32 i386架构
--64 x86_64架构
//as --gstabs --32 -o args.o args.s

链接器

用来将多个目标代码链接为一个可执行的程序，linux使用的是ld

ld一般的使用和选项如下：

1
2
3
4
5
6
7
-m emulation模拟仿真器链接 -V 可以查看所有支持的仿真器
-T 指定链接脚本
–script=scriptfile 使用该脚本代替ld默认链接脚本
-o output 指定链接结果
–whole-archive file 将归档文件中的路径的库的符号都链接起来，后面需要跟–no-whole-archive代表界限
-s 删除symbol信息，不利于调试
//ld -m elf_i386 -o args args.o

linux下的链接见：Kbuild-Makefile学习

调试器

常用的是gdb, 也有其他的调试器比如ddd, ald，但是调试基本语法都是一致的。

汇编实践

实践前提-系统调用的理解

在应用层可以通过sycall()来进行系统调用，其实是通过libc中的库接口将其转化为汇编语言，要求一般是带系统调用的number和其需要的参数。
syscall()库接口针对不同的架构在汇编中调用不同的指令并将参数copy到对应的寄存器，比如在i386和X86_64中如下：

1
2
3
4
5
6
7
arch/ABI   instruction          syscall #   retval
──────────────────────────────────────────────────
arm/OABI   swi NR               -           a1
arm/EABI   swi 0x0              r7          r0
arm64      svc #0               x8          x0
i386       int $0x80            eax         eax
x86_64     syscall              rax         rax

汇编调用指令并将系统调用number和调用返回值设置在对应的寄存器中，比如eax或者rax

不同的架构参数需要copy到不同的寄存器

1
2
3
4
5
6
7
arch/ABI      arg1  arg2  arg3  arg4  arg5  arg6  arg7
──────────────────────────────────────────────────────
arm/OABI      a1    a2    a3    a4    v1    v2    v3
arm/EABI      r0    r1    r2    r3    r4    r5    r6
arm64         x0    x1    x2    x3    x4    x5    -
i386          ebx   ecx   edx   esi   edi   ebp   -
x86_64        rdi   rsi   rdx   r10   r8    r9    -

针对以上三个平台，我们需要在进行指令调用前将参数按顺序copy到对于的寄存器

对于不同的架构，系统调用的number编号可能也是不同的，比如linux对符号表的定义如下：

1
2
3
4
5
6
//arch/x86/entry/syscalls/syscall_32.tbl
1       i386    exit                    sys_exit
4       i386    write                   sys_write
//arch/x86/entry/syscalls/syscall_64.tbl
1       common  write                   sys_write
60      common  exit                    sys_exit

再编译时通过Makefile处理之后，生成out和uapi两部分

1
2
3
//arch/x86/entry/syscalls/Makefile
out := arch/$(SRCARCH)/include/generated/asm
uapi := arch/$(SRCARCH)/include/generated/uapi/asm

hello-world

打印hello-world其实就是调用write将”hello world”写到标准输出

32位汇编打印hello-world
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#hello.s
.data
        msg : .string "Hello, world!\n"
        len = . - msg
.text
.global _start

_start:
        movl $len, %edx
        movl $msg, %ecx
        movl $1, %ebx
        movl $4, %eax
        int $0x80

        movl $0, %ebx
        movl $1, %eax

        int $0x80

编译验证如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
//不指定架构
➜  0-hello-world git:(master) ✗ as -g -o hello.o hello.s 
➜  0-hello-world git:(master) ✗ ld -o hello hello.o 
➜  0-hello-world git:(master) ✗ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
➜  0-hello-world git:(master) ✗ ./hello
Hello, world!

//指定架构32位
➜  0-hello-world git:(master) ✗ as --32 -g -o hello.o hello.s
➜  0-hello-world git:(master) ✗ ld -m elf_i386 -o hello hello.o
➜  0-hello-world git:(master) ✗ ./hello
Hello, world!

解析命令行参数

32位汇编代码

Linux 汇编语言开发指南上的实例代码无法正常运行，搞了好久，发现需要指定平台进行链接和汇编

解析命令行参数-32位汇编
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# args.s
#.code32
#32位汇编，链接和汇编时需要指定处理器架构
.text
.global _start

_start: 
        popl %ecx    #argc出栈

vnext: 
        popl %ecx   #参数地址出栈
        test %ecx, %ecx   #是否栈为空，栈空时为ecx 为0
        jz exit      # 栈为空就推出

        movl %ecx, %ebx  # ebx作为syscall write的地址部分，所以传递给ebx
        xorl %edx, %edx  # edx目的是为单个参数长度计数，每次都需要置0

strlen:
        movb (%ebx), %al  #将参数的第一个值传给al
        inc %edx          #长度计数器+1
        inc %ebx          #指向参数的第二个值
        test %al, %al     # 如果参数字符为`0`，那么参数长度解析完毕
        jnz strlen        # 如果参数没解析完，继续解析
        movb $10, -1(%ebx)  #将`0`字符换位`\n`字符

        movl $4, %eax    # 4在32bit代表为sys_write 
        movl $1, %ebx    # 1为标准输出
        int $0x80   # syscall中断

        jmp vnext    #解析下一个参数

exit:
        movl $1, %eax  # sys_exit, 32 bit
        xorl %ebx, %ebx   # 退出状态值
        int $0x80

        ret
正确的编译方式

编译和验证如下

1
2
3
4
5
6
7
8
➜  1-args git:(master) ✗ as --gstabs --32 -o args.o args.s
➜  1-args git:(master) ✗ ld -m elf_i386 -o args args.o
➜  1-args git:(master) ✗ file args 
args: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, not stripped
➜  1-args git:(master) ✗ ./args test1 tes2 
./args
test1
tes2

针对X86和X64，as可选的处理器架构参数如下：

1
2
--32 | --x32 | --64
   Select the word size, either 32 bits or 64 bits.  --32 implies Intel i386 architecture, while --x32 and --64 imply AMD x86-64 architecture with 32-bit or 64-bit word-size respectively.

ld可选的处理器架构参数如下：

1
2
3
4
5
6
7
8
9
10
11
12
➜  1-args git:(master) ✗ ld -V
GNU ld (GNU Binutils for Ubuntu) 2.26.1
  支持的仿真：
   elf_x86_64
   elf32_x86_64
   elf_i386
   elf_iamcu
   i386linux
   elf_l1om
   elf_k1om
   i386pep
   i386pe

as –x32会报错，可能amd 32位下应该用这个参数

–gstabs对gdb的预览调试还是有影响的，正如-g中描述的一样，为每一行汇编源代码生成调试，gdb调试和objdump -dS都有定位到行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//as -g --32 -o args.o args.s 
➜  1-args git:(master) ✗ gdb args
(gdb) b _start
Breakpoint 1 at 0x8048054: file args.s, line 7.
(gdb) run
Breakpoint 1, _start () at args.s:7
7               popl %ecx

//objdump
08048054 <_start>:
 8048054:       59                      pop    %ecx


//as --32 -o args.o args.s
➜  1-args git:(master) ✗ gdb args
(gdb) b _strt
Breakpoint 1 at 0x8048054
(gdb) run
Breakpoint 1, 0x08048054 in _start ()

//objdump
_start: 
        popl %ecx
 8048054:       59                      pop    %ecx

错误实践

起初我使用默认的选项去进行链接和汇编，但是执行会coredump, 下面是我的实践和分析

  1. 我本地环境为64位，汇编实际为32位，elf结果是64位的，发现链接不过，因此开头增加标记.code32,不然链接失败，但我并没有意识到问题的严重性

  2. strlen 下的 movb (%ebx), %al导致coredump，因为如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    (gdb) n

    Program received signal SIGSEGV, Segmentation fault.
    strlen () at args.s:19
    19              movb (%ebx), %al
    (gdb) info register
    rax            0x0                 0
    rbx            0xffffdeab          4294958763
    rcx            0x7fffffffdeab      140737488346795
    ...
    ...
    (gdb) x/s 0x7fffffffdeab
    0x7fffffffdeab: "/github/linux-driver/linux-assembly/1-args/args"
    (gdb) x/s 0xffffdeab
    0xffffdeab:     <error: Cannot access memory at address 0xffffdeab>
    //发现寄存器都是64位的，64位的如果去寻址32位的有问题

  3. gdb调试分析发现实际流程和汇编代码不一致，objdump反汇编发现和汇编代码不一致，
    test %al, %al被忽略 导致ZF 标记异常，流程出现异常，如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    ➜  1-args git:(master) ✗ objdump -dS args
    args：     文件格式 elf64-x86-64    >>注意到文件格式为64位，和汇编语言增加.code32申明不一致
    ...

        test %al, %al   >>并没有真正执行
        jnz strlen
      400088:       75 f8                   jne    400082 <strlen>

    ...

64位汇编代码

解析命令行参数-64位汇编
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
.text
.globl _start

_start:
    popq %rsi
vnext:
    popq %rsi
    testq %rsi, %rsi 
    jz exit
    movq %rsi, %rbx 
    xorq %rdx, %rdx
strlen:
    movb (%rbx), %al
    incq %rdx
    incq %rbx
    testb %al, %al
    jnz strlen
    movb $10, -1(%rbx) #10是换行键
    movq $1, %rax # 系统调用号(sys_write) 
    movq $1, %rdi # 文件描述符(stdout) 
    syscall
    jmp vnext
exit:
    movq $60,%rax
    movq $0,%rdi
    syscall

64位代码运行如下：

1
2
3
4
5
6
➜  1-args git:(master) ✗ as -g --64 -o args-x86_64.o args-x86_64.s
➜  1-args git:(master) ✗ ld -m elf_x86_64 -o args-x86_64 args-x86_64.o
➜  1-args git:(master) ✗ ./args-x86_64 test1 test2
./args-x86_64
test1
test2
gdb分析64位代码运行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
➜  1-args git:(master) ✗ gdb args-x86_64
(gdb) b _start
Breakpoint 1 at 0x400078: file args-x86_64.s, line 5.
(gdb) b vnext
Breakpoint 2 at 0x400079: file args-x86_64.s, line 7.
(gdb) b strlen
Breakpoint 3 at 0x400085: file args-x86_64.s, line 13.
(gdb) run test1
Starting program: /github/linux-driver/linux-assembly/1-args/args-x86_64 test1
Breakpoint 1, _start () at args-x86_64.s:5
5           popq %rsi
(gdb) info register
rax            0x0                 0
rbx            0x0                 0
rcx            0x0                 0
rdx            0x0                 0
rsi            0x0                 0
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdac0      0x7fffffffdac0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400078            0x400078 <_start>
eflags         0x202               [ IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
Breakpoint 2, vnext () at args-x86_64.s:7
7           popq %rsi
(gdb) info register
rax            0x0                 0
rbx            0x0                 0
rcx            0x0                 0
rdx            0x0                 0 
rsi            0x2                 2   >>argc为2
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdac8      0x7fffffffdac8  >>popq一次，栈指针下移
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400079            0x400079 <vnext>
eflags         0x202               [ IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
vnext () at args-x86_64.s:8
8           testq %rsi, %rsi 
(gdb) info register
rax            0x0                 0
rbx            0x0                 0
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffde96      140737488346774  >>argv[0]地址
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0   >>popq一次，栈指针下移
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x40007a            0x40007a <vnext+1>
eflags         0x202               [ IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
9           jz exit
(gdb) info register
rax            0x0                 0
rbx            0x0                 0
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x40007d            0x40007d <vnext+4>
eflags         0x206               [ PF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
10          movq %rsi, %rbx 
(gdb) info register
rax            0x0                 0
rbx            0x0                 0
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x40007f            0x40007f <vnext+6>
eflags         0x206               [ PF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
11          xorq %rdx, %rdx
(gdb) info register
rax            0x0                 0
rbx            0x7fffffffde96      140737488346774
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400082            0x400082 <vnext+9>
eflags         0x206               [ PF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
Breakpoint 3, strlen () at args-x86_64.s:13
13          movb (%rbx), %al
(gdb) info register
rax            0x0                 0
rbx            0x7fffffffde96      140737488346774
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400085            0x400085 <strlen>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) n
14          incq %rdx
(gdb) info register
rax            0x2f                47                 >> `/`的ASCII是0x2f
rbx            0x7fffffffde96      140737488346774
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400087            0x400087 <strlen+2>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) x/s 0x7fffffffde96         >>打印第一个参数
0x7fffffffde96: "/github/linux-driver/linux-assembly/1-args/args-x86_64"
(gdb) x/x 0x7fffffffde96
0x7fffffffde96: 0x2f
(gdb) x/c 0x7fffffffde96
0x7fffffffde96: 47 '/'
(gdb) x/55c 0x7fffffffde96
0x7fffffffde96: 47 '/'  103 'g' 105 'i' 116 't' 104 'h' 117 'u' 98 'b'  47 '/'
0x7fffffffde9e: 108 'l' 105 'i' 110 'n' 117 'u' 120 'x' 45 '-'  100 'd' 114 'r'
0x7fffffffdea6: 105 'i' 118 'v' 101 'e' 114 'r' 47 '/'  108 'l' 105 'i' 110 'n'
0x7fffffffdeae: 117 'u' 120 'x' 45 '-'  97 'a'  115 's' 115 's' 101 'e' 109 'm'
0x7fffffffdeb6: 98 'b'  108 'l' 121 'y' 47 '/'  49 '1'  45 '-'  97 'a'  114 'r'
0x7fffffffdebe: 103 'g' 115 's' 47 '/'  97 'a'  114 'r' 103 'g' 115 's' 45 '-'
0x7fffffffdec6: 120 'x' 56 '8'  54 '6'  95 '_'  54 '6'  52 '4'  0 '\000'
>>注意最后一个是ASCII 0
(gdb) c 
Continuing.

Breakpoint 3, strlen () at args-x86_64.s:13
13          movb (%rbx), %al
(gdb) info register
rax            0x2f                47
rbx            0x7fffffffde97      140737488346775  >>指向参数的下一个字符
rcx            0x0                 0
rdx            0x1                 1          >>长度计数已经为1
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400085            0x400085 <strlen>
eflags         0x202               [ IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) disable 3
(gdb) b args-x86_64.s:18
Breakpoint 4 at 0x400091: file args-x86_64.s, line 18.   >>想要结束第一个参数的解析
(gdb) c
Continuing.

Breakpoint 4, strlen () at args-x86_64.s:18
18          movb $10, -1(%rbx) #10是换行键
(gdb) info registers 
rax            0x0                 0         >>此时为尾部的ASCII 0
rbx            0x7fffffffdecd      140737488346829   >>指向参数尾部ASCII 0的下一个字符地址
rcx            0x0                 0
rdx            0x37                55          >>长度计数为55,包括尾部的ASCII 0
rsi            0x7fffffffde96      140737488346774
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffdad0      0x7fffffffdad0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400091            0x400091 <strlen+12>
eflags         0x246               [ PF ZF IF ]  >>注意此时ZF=1, 因为testb %al, %al 结果为0,所以ZF置位
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) x/2c 0x7fffffffdecb 
0x7fffffffdecb: 52 '4'  0 '\000' >>确认一致
(gdb) info b
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000400078 args-x86_64.s:5
        breakpoint already hit 1 time
2       breakpoint     keep y   0x0000000000400079 args-x86_64.s:7
        breakpoint already hit 1 time
3       breakpoint     keep n   0x0000000000400085 args-x86_64.s:13
        breakpoint already hit 2 times
4       breakpoint     keep y   0x0000000000400091 args-x86_64.s:18
        breakpoint already hit 1 time
(gdb) disable 4  >>想要跳出第一个参数的解析
(gdb) c
Continuing.
/github/linux-driver/linux-assembly/1-args/args-x86_64

Breakpoint 2, vnext () at args-x86_64.s:7
7           popq %rsi   >>开始要解析test1这个参数
(gdb) c
Continuing.
test1

Breakpoint 2, vnext () at args-x86_64.s:7
7           popq %rsi
(gdb) info registers 
rax            0x6                 6            >>write函数返回值，上一次成功写入6个字符
rbx            0x7fffffffded3      140737488346835
rcx            0x4000a5            4194469
rdx            0x6                 6   >>第二个参数计数为6
rsi            0x7fffffffdecd      140737488346829
rdi            0x1                 1
rbp            0x0                 0x0
rsp            0x7fffffffdad8      0x7fffffffdad8
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x246               582
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400079            0x400079 <vnext>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
(gdb) b args-x86_64.s:8                     >>想要检查rsi的值
Breakpoint 5 at 0x40007a: file args-x86_64.s, line 8. 
(gdb) c
Continuing.

Breakpoint 5, vnext () at args-x86_64.s:8
8           testq %rsi, %rsi 
(gdb) info registers 
rax            0x6                 6 
rbx            0x7fffffffded3      140737488346835
rcx            0x4000a5            4194469
rdx            0x6                 6
rsi            0x0                 0          >>rsi为空
rdi            0x1                 1
rbp            0x0                 0x0
rsp            0x7fffffffdae0      0x7fffffffdae0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x246               582
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x40007a            0x40007a <vnext+1>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0

内联汇编

内联汇编在cmpxchg kernel-api学习这一部分已经有过描述，下面一部分主要是系统的介绍

为了针对关键代码进行控制和优化，因此在c代码中引入汇编，称为内联汇编，我们需要按照规则进行编写，内联汇编则会由gcc进行解析。

汇编与c之间的联系，问题有：

  1. 变量如何分配给寄存器
  2. 变量是否分配给寄存器，或是直接通过指令直接进行内存操作
  3. 如果变量传给寄存器进行运算，之后是否需要回写到变量内存
  4. …

内联汇编基本格式为__asm__("asm statements" : outputs : inputs : registers-modified);

其编写规则分为如下4个部分，解决了以上问题

  1. 指令部分(内联模板)：描述汇编指令，用%0, %1描述将用第几个操作数传递到寄存器或者直接操作内存进行运算
    因为AT&T寄存器也是使用%描述，因此使用%%来描述寄存器
  2. 输出部分：操作数约束条件 + 输出操作数，约束条件前加=或者+，之后回写到内存变量
  3. 输入部分：操作数约束条件 + 输入操作数
  4. clobbers：对内存变量/寄存器/编译优化的规则描述,一般设置如下：
    1
    2
    3
    4
    寄存器: 指的是非输出输入部分列出的，在指令部分显示和隐式使用的寄存器说明，比如保存中间结果寄存器，指的是我们破坏了这些寄存器原本的数值
    memory: 不要将这段指令和内嵌汇编前的指令重新排序，也就是在执行内嵌汇编代码之前，它前面的指令都执行完毕
            不要将内存变量缓存到寄存器，因为指令中可能用到了内存变量，而这些内存变量可能会因为其他原因改变
            在内嵌汇编之后再使用内嵌汇编中的变量，应该从内存重新装载，而不是使用寄存器的值，因为寄存器的值可能已经发生改变

嵌入式汇编（内联汇编）同样对这部分有很好的描述

实践-copy

将c copy到a和b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define asm __asm__    
#define volatile __volatile__ 

/* 
 * 将c复制到a和b
 */

int main() {
        int a = 1, b = 2, c = 3, d = 4;    
        asm volatile("movl %2, %%ebx \n\t"    
                     "movl %%ebx, %1 \n\t"    
                     "movl %%ebx, %3"    
                     : "=a" (a), "=r" (b)    
                     : "0" (c), "r" (d)    
                     : "%ebx");    
        printf("a is %d, b is %d, c is %d, d is%d \n", a, b, c, d);    
        return 0; 
1
2
3
4
5
6
➜  inline-assembly git:(master) ✗ gcc -o copy2.o copy2.c 
➜  inline-assembly git:(master) ✗ ./copy2.o 
    a is 3, b is 3, c is 3, d is4 
    c copy到a 是通过将c绑定到eax，之后输出时eax回写到a
    c copy到b 是通过将中间寄存器ebx 复制到b
    d不变是因为d对应的寄存器参与了运算，但是没有回写到b

实践-cmpxchgl

cmpxchgl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define asm __asm__
#define volatile __volatile__

/*    
 * 比较并交换，见指令cmpxchg
 */

int main() {
        int A = 1, old = 2, new = 3;
        int *ptr = &A;
 	int ret;
        asm volatile("lock;" "cmpxchgl %2,%1"               \
                     : "=a" (ret), "+m" (*ptr)              \
                     : "r" (new), "0" (old)                 \
                     : "memory"); 
	printf("ret is %d, A is %d, old is %d\n", ret, A, old);
        A = 2;
        asm volatile("lock;" "cmpxchgl %2,%1"               \
                     : "=a" (ret), "+m" (*ptr)              \
                     : "r" (new), "0" (old)                 \
                     : "memory"); 
	printf("ret is %d, A is %d, old is %d\n", ret, A, old);
	return 0;
}
1
2
3
4
5
6
➜  inline-assembly git:(master) ✗ gcc -o cmpxchgl cmpxchgl.c
➜  inline-assembly git:(master) ✗ ./cmpxchgl 
ret is 1, A is 1, old is 2
ret is 2, A is 3, old is 2
//A !=old， ret = A
//A == old, ret不变， A=new

参考

  1. Linux 汇编语言开发指南
  2. 在Linux虚拟机上写汇编-2.处理命令行参数
推荐文章