羽夏笔记—— AT&T 与 GCC
写在前面
本文是本人根据《AT&T 汇编语言与 GCC 内嵌汇编简介》进一步整理,修改了一些错误,并删除我并不能复现代码相关的部分。该文章一是我对 AT&T 的学习记录,二是对大家学习 AT&T 有更好的帮助。如对该博文有好的建议,欢迎反馈。码字不易,如果本篇文章有帮助你的,如有闲钱,可以打赏支持我的创作。如想转载,请把我的转载信息附在文章后面,并声明我的个人信息和本人博客地址即可,但必须事先通知我。
概述
在此之前,我建议你学习Intel
汇编,否则有些你可能不太懂。因为我是根据有Intel
汇编编写的基础的人的快速转型,方便学习Linux
源码,因为里面有一些奇奇怪怪的内联汇编的写法,不会的话会看的满头雾水。下面我开始介绍AT&T
汇编语言语法与Intel
汇编语法的差别:
区别
大小写
Intel
格式的指令一般使用大写字母,而AT&T
格式的一般使用小写字母。在使用Intel
格式的指令内敛汇编的时候我并没有发现严格大写(除了我见过 Ghidra 严格区分大小写)。
Intel | AT&T |
---|---|
MOV EAX,EBX | movl %ebx,%eax |
操作数赋值方向
在Intel
语法中,第一个表示目的操作数,第二个表示源操作数,赋值方向从右向左。AT&T
语法第一个为源操作数,第二个为目的操作数,方向从左到右。写高级语言的代码写多了,AT&T
语法看起来比较难受。
Intel | AT&T |
---|---|
MOV EAX,EBX | movl %ebx,%eax |
前缀
在Intel
语法中寄存器和立即数不需要前缀;AT&T
中寄存器需要加前缀%
,立即数需要加前缀$
。感觉AT&T
语法有点花里胡哨,可读性相对于Intel
语法低。
Intel | AT&T |
---|---|
MOV EAX,1 | movl $1,%eax |
符号常数直接引用,不需要加前缀,如:movl value , %ebx
,value
为一常数;在符号前加前缀$
表示引用符号地址, 如movl $value, %ebx
,是将value
的地址放到ebx
中。
是不是有点看不太懂,我们来继续举个例子:
Intel | AT&T |
---|---|
MOV ESI, [0x4000] | movl 0x4000, %esi |
总线锁定前缀lock
:总线锁定操作。lock
前缀在Linux
核心代码中使用很多,特别是SMP
代码中。当总线锁定后其它CPU
不能存取锁定地址处的内存单元。
对于AT&T
语法,远程跳转指令和子过程调用指令的操作码使用前缀l
,分别为ljmp
和lcall
,与之相应的返回指令lret
,如下是几个例子:
Intel | AT&T |
---|---|
CALL FAR SECTION:OFFSET | lcall \(secion:\)offset |
JMP FAR SECTION:OFFSET | ljmp \(secion:\)offset |
RET FAR SATCK_ADJUST | lret $stack_adjust |
间接寻址语法
Intel
中基地址使用[]
,而在AT&T
中使用()
。另外处理复杂操作数的语法也不同,Intel
为Segreg:[base+index*scale+disp]
,而在AT&T
中为%segreg:disp(base,index,sale)
,其中segreg
,index
,scale
,disp
都是可选的,在指定index
而没有显式指定scale
的情况下使用默认值 1
。scale
和disp
不需要加前缀&
。看不懂没关系,我们来几个例子:
Intel | AT&T |
---|---|
LEA RCX, [R13+RDX*8+0x10] | leaq 0x10(%r13, %rdx, 8), %rcx |
后缀
AT&T
语法中大部分指令操作码的最后一个字母表示操作数大小,b
表示byte
(一个字节);w
表示word
(2 个字节);l
表示long
(4 个字节)。Intel
中处理内存操作数时也有类似的语法如:BYTE PTR
、WORD PTR
、DWORD PTR
。
Intel | AT&T |
---|---|
mov al, bl | movb %bl,%al |
mov ax,bx | movw %bx,%ax |
mov eax, dword ptr [ebx] | movl (%ebx), %eax |
在AT&T
汇编指令中,操作数扩展指令有两个后缀,一个指定源操作数的字长,另一个指定目标操作数的字长。AT&T
的符号扩展指令的为movs
,零扩展指令为movz
(相应的Intel
指令为movsx
和movzx
)。因此,movsbl %al,%edx
表示对寄存器al
中的字节数据进行字节到长字的符号扩展,计算结果存放在寄存器edx
中。下面是一些允许的操作数扩展后缀:
- bl: 字节 -> 长字
- bw: 字节 -> 字
- wl: 字 -> 长字
跳转指令标号后的后缀表示跳转方向,f
表示向前forward
,b
表示向后backward
,比如:
jmp 1f
1: jmp 1f
1:
指令
Intel
汇编与AT&T
汇编指令基本相同,差别仅在语法上,具体请查阅手册。
GCC 内联汇编概述
内核代码绝大部分使用C
语言编写,只有一小部分使用汇编语言编写,例如与特定体系结构相关的代码和对性能影响很大的代码。GCC
提供了内嵌汇编的功能,可以在C
代码中直接内嵌汇编语言语句,大大方便了程序设计。简单的内嵌汇编很容易理解,例如:
__asm__ __volatile__("hlt");
__asm__
表示后面的代码为内嵌汇编,asm
是__asm__
的别名;__volatile__
表示编译器不要优化代码,后面的指令保留原样,volatile
是它的别名;括号里面是汇编指令。
在内嵌汇编中,可以将C
语言表达式指定为汇编指令的操作数,而且不用去管如何将C
语言表达式的值读入哪个寄存器,以及如何将计算结果写回C
变量,你只要告诉程序中C
语言表达式与汇编指令操作数之间的对应关系即可,GCC
会自动插入代码完成必要的操作。
使用内嵌汇编,要先编写汇编指令模板,然后将C
语言表达式与指令的操作数相关联,并告诉GCC
对这些操作有哪些限制条件。例如在下面的汇编语句:
__asm__ __violate__ ("movl %1,%0" : "=r" (result) : "m" (input));
movl %1,%0
是指令模板;%0
和%1
代表指令的操作数,称为占位符,内嵌汇编靠它们将C
语言表达式与指令操作数相对应。指令模板后面用小括号括起来的是C
语言表达式,本例中只有result
和input
,他们按照出现的顺序分别与指令操作数%0
和%1
对应。注意对应顺序:第一个C
表达式对应%0
;第二个表达式对应%1
,依次类推。操作数至多有 10 个,分别用%0
-%9
表示。在每个操作数前面有一个用引号括起来的字符串,字符串的内容是对该操作数的限制或者要求。result
前面的限制字符串是=r
,其中=
表示result
是输出操作数,r
表示需要将result
与某个通用寄存器相关联,先将操作数的值读入寄存器,然后在指令中使用相应寄存器,而不是result
本身,当然指令执行完后需要将寄存器中的值存入变量result
,从表面上看好像是指令直接对result
进行操作,实际上GCC
做了隐式处理,这样我们可以少写一些指令。input
前面的r
表示该表达式需要先放入某个寄存器,然后在指令中使用该寄存器参加运算。
具体细节我们还会在后面进行介绍,下面我们先进行测试:
int input,result;
int main()
{
input = 1;
__asm__ __volatile__ ("movl %1,%0" : "=r" (result) : "r" (input));
return 0;
}
我们使用gcc -c wingsummer.c -S
将源代码转成汇编:
.file "wingsummer.c"
.text
.comm input,4,4
.comm result,4,4
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $1, input(%rip)
movl input(%rip), %eax
#APP
# 6 "wingsummer.c" 1
movl %eax,%eax
# 0 "" 2
#NO_APP
movl %eax, result(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
我们重点关注的是:
movl $1, input(%rip)
movl input(%rip), %eax
#APP
# 6 "wingsummer.c" 1
movl %eax,%eax
# 0 "" 2
#NO_APP
movl %eax, result(%rip)
上面的汇编是GCC
自动增加的代码,GCC
根据限定字符串决定如何处理C
表达式,本例两个表达式都被指定为r
型,所以先使用指令movl input, %eax
,将input
读入寄存器%eax
;GCC
也指定一个寄存器与输出变量result
相关,本例也是%eax
,等得到操作结果后再使用指令movl %eax, result
,将寄存器的值写回C
变量result
中。从上面的汇编代码我们可以看出与result
和input
相关连的寄存器都是%eax
,GCC
使用%eax
替换内嵌汇编指令模板中的%0
和%1
:movl %eax,%eax
,显然这一句可以不要。但是没有优化,所以这一句没有被去掉。由此可见,C
表达式或者变量与寄存器的关系由GCC
自动处理,我们只需使用限制字符串指导GCC
如何处理即可。限制字符必须与指令对操作数的要求相匹配,否则产生的汇编代码将会有错,读者可以将上例中的两个r
,都改为m
(m
表示操作数放在内存,而不是寄存器中),编译后得到的结果是movl input, result
,很明显这是一条非法指令,因此限制字符串必须与指令对操作数的要求匹配。例如指令movl
允许寄存器到寄存器,立即数到寄存器等,但是不允许内存到内存的操作,因此两个操作数
不能同时使用m
作为限定字符。
GCC 内联汇编详解
内嵌汇编语法如下:
__asm__(汇编语句模板: 输出部分: 输入部分: 破坏描述部分)
正如上面所示,一共四个部分:汇编语句模板,输出部分,输入部分,破坏描述部分。各部分使用:
格开,汇编语句模板必不可少,其他三部分可选,如果使用了后面的部分,而前面部分为空,
也需要用:
格开,相应部分内容为空,这个和C
的普通的for
语句点写法差不多。例如:
__asm__ __volatile__("cli": : :"memory")
汇编语句模板
汇编语句模板由汇编语句序列组成,语句之间使用;
、\n
或\n\t
分开。指令中的操作数可以使用占位符引用C
语言变量,操作数占位符最多 10 个。指令中使用占位符表示的操作数,总被视为long
型(4 个字节),但对其施加的操作根据指令可以是字或者字节,当把操作数当作字或者字节使用时,默认为低字或者低字节。对字节操作可以显式的指明是低字节还是次字节。方法是在%
和序号之间插入一个字母,b
代表低字节,h
代表高字节,例如:%h1
。
输出部分
输出部分描述输出操作数,不同的操作数描述符之间用逗号格开,每个操作数描述符由限定字符串和C
语言变量组成。每个输出操作数的限定字符串必须包含=
表示他是一个输出操作数。比如:
__asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x) )
描述符字符串表示对该变量的限制条件,这样GCC
就可以根据这些条件决定如何分配寄存器,如何产生必要的代码处理指令操作数与C
表达式或C
变量之间的联系。
输入部分
输入部分描述输入操作数,不同的操作数描述符之间使用逗号格开,每个操作数描述符由限定字符串和C
语言表达式或者C
语言变量组成。下面给几个例子:
__asm__ __volatile__ ("lidt %0" : : "m" (real_mode_idt));
//bitops.h
static __inline__ void __set_bit(int nr, volatile void * addr)
{
__asm__(
"btsl %1,%0"
:"=m" (ADDR)
:"Ir" (nr));
}
最后一个例子展示的功能是将*addr
的第nr
位设为 1
。第一个占位符%0
与C
语言变量ADDR
对应,第二个占位符%1
与C
语言变量nr
对应。因此改汇编语句代码与伪代码btsl nr, ADDR
等价,该指令的两个操作数不能全是内存变量,因此将nr
的限定字符串指定为Ir
,将nr
与立即数或者寄存器相关联,这样两个操作数中只有ADDR
为内存变量。
限制字符
限制字符列表
限制字符有很多种,有些是与特定体系结构相关,此处我们以x86
为例,仅列出常用的限定字符和i386
中可能用到的一些常用的限定符。它们的作用是指示编译器如何处理其后的C
语言变量与指令操作数之间的关系,例如是将变量放在寄存器中还是放在内存中等,下表列出了常用的限定字母:
- 通用寄存器
限定符 | 描述 |
---|---|
a |
将输入变量放入eax 。如果被占用了,GCC 会在这段汇编代码的起始处插入一条语句pushl %eax ,将eax 内容保存到堆栈,然后在这段代码结束处再增加一条语句popl %eax ,恢复 eax 的内容 |
b |
将输入变量放入ebx |
c |
将输入变量放入ecx |
d |
将输入变量放入edx |
s |
将输入变量放入esi |
d |
将输入变量放入edi |
q |
将输入变量放入eax ,ebx ,ecx ,edx 中的一个 |
r |
将输入变量放入通用寄存器,也就是eax ,ebx ,ecx ,edx ,esi ,edi 中的一个 |
A |
把eax 和edx 合成一个 64 位的寄存器 |
- 内存
限定符 | 描述 |
---|---|
m |
内存变量 |
o |
操作数为内存变量,但是其寻址方式是偏移量类型,也即是基址寻址,或者是基址加变址寻址 |
V |
操作数为内存变量,但寻址方式不是偏移量类型 |
|
操作数为内存变量,但寻址方式为自动增量 |
p |
操作数是一个合法的内存地址(指针) |
- 寄存器或内存
限定符 | 描述 |
---|---|
g |
将输入变量放入eax ,ebx ,ecx ,edx 中的一个或者作为内存变量 |
X |
操作数可以是任何类型 |
- 立即数
限定符 | 描述 |
---|---|
I |
0-31 之间的立即数(用于 32 位移位指令) |
J |
0-63 之间的立即数(用于 64 位移位指令) |
N |
0-255 之间的立即数(用于 out 指令) |
i |
立即数 |
n |
立即数,有些系统不支持除字以外的立即数,这些系统应该使用n 而不是i |
- 操作数类型
限定符 | 描述 |
---|---|
= |
操作数在指令中是只写的(输出操作数) |
+ |
操作数在指令中是读写类型的(输入输出操作数) |
- 浮点数
限定符 | 描述 |
---|---|
f |
浮点寄存器 |
t |
第一个浮点寄存器 |
u |
第二个浮点寄存器 |
G |
标准的 80387 浮点常数 |
- 匹配
限定符 | 描述 |
---|---|
0 -9 |
表示用它限制的操作数与某个指定的操作数匹配,也即该操作数就是指定的那个操作数,例如用0 去描述%1 操作数,那么%1 引用的其实就是%0 操作数,注意作为限定符字母的0 -9 与指令中的%0 -%9 的区别,前者描述操作数,后者代表操作数。 |
- 其他
限定符 | 描述 |
---|---|
& |
该输出操作数不能使用过和输入操作数相同的寄存器 |
% |
该操作数可以和下一个操作数交换位置 |
# |
部分注释,从该字符到其后的逗号之间所有字母被忽略 |
* |
表示如果选用寄存器,则其后的字母被忽略 |
现在继续看上面的例子,"=m" (ADDR)
表示ADDR
为内存变量,而且是输出变量;"Ir" (nr)
表示nr
为0-31
之间的立即数或者一个寄存器操作数。
匹配限制符
I386
指令集中许多指令的操作数是读写型的(读写型操作数指先读取原来的值然后参加运算,最后将结果写回操作数),例如addl %1,%0
,它的作用是将操作数%0
与操作数%1
的和存入操作数%0
,因此操作数%0
是读写型操作数。老版本的GCC
对这种类型操作数的支持不是很好,它将操作数严格分为输入和输出两种,分别放在输入部分和输出部分,而没有一个单独部分描述读写型操作数,因此在GCC
中读写型的操作数需要在输入和输出部分分别描述,靠匹配限制符将两者关联到一起。注意仅在输入和输出部分使用相同的C
变量,但是不用匹配限制符,产生的代码很可能不对,后面会分析原因。看一下下面的代码就知道为什么要将读写型操作数,分别在输入和输出部分加以描述(求input
+result
的和,然后存入result
):
int input,result;
int main()
{
result = 0;
input = 1;
__asm__ __volatile__ ("addl %1,%0" : "=r" (result) : "r" (input));
return 0;
}
看一下生成的汇编代码:
.file "wingsummer.c"
.text
.comm input,4,4
.comm result,4,4
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $0, result(%rip)
movl $1, input(%rip)
movl input(%rip), %eax
#APP
# 8 "wingsummer.c" 1
addl %eax,%eax
# 0 "" 2
#NO_APP
movl %eax, result(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
从上面我们明显的看出,这根本和预想的根本不一样,最终的结果是result = input + input
,这显然不是我们想要的。
综上可以总结出如下几点:
- 使用
r
限制的输入变量,GCC
先分配一个寄存器,然后将值读入寄存器,最后用该寄存器替换占位符; - 使用
r
限制的输出变量,GCC
会分配一个寄存器,然后用该寄存器替换占位符,但是在使用该寄存器之前并不将变量值先读入寄存器,GCC
认为所有输出变量以前的值都没有用处,不读入寄存器,最后GCC
插入代码,将寄存器的值写回变量; - 输入变量使用的寄存器在最后一处使用它的指令之后,就可以挪做其他用处,因为已经不再使用。
因为第二条,上面的内嵌汇编指令不能奏效,因此需要在执行addl
之前把result
的值读入寄存器,也许再将result
放入输入部分就可以了,修改如下:
int input,result;
int main()
{
result = 0;
input = 1;
__asm__ __volatile__ ("addl %2,%0":"=r"(result):"r"(result),"m"(input));
return 0;
}
看上去上面的代码可以正常工作,因为我们知道%0
和%1
都和result
相关,应该使用同一个寄存器,但是GCC
并不去判断%0
和%1
是否和同一个C
表达式或变量相关联(这样易于产生与内嵌汇编相应的汇编代码),因此%0
和%1
使用的寄存器可能不同。
我们来生成一下汇编:
.file "wingsummer.c"
.text
.comm input,4,4
.comm result,4,4
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $0, result(%rip)
movl $1, input(%rip)
movl result(%rip), %eax
#APP
# 8 "wingsummer.c" 1
addl input(%rip),%eax
# 0 "" 2
#NO_APP
movl %eax, result(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
可以看出,这次汇编代码生成正确,正如我们想要的。使用匹配限制符后,GCC
知道应将对应的操作数放在同一个位置(同一个寄存器或者同一个内存变量)。使用匹配限制字符的代码如下:
int input,result;
int main()
{
result = 0;
input = 1;
__asm__ __volatile__ ("addl %2,%0":"=r"(result):"0"(result),"m"(input));
return 0;
}
输入部分中的result
用匹配限制符0
限制,表示%1
与%0
代表同一个变量,输入部分说明该变量的输入功能,输出部分说明该变量的输出功能,两者结合表示result
是读写型。因为%0
和%1
表示同一个C
变量,所以放在相同的位置,无论是寄存器还是内存。如下是反汇编:
.file "wingsummer.c"
.text
.comm input,4,4
.comm result,4,4
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $0, result(%rip)
movl $1, input(%rip)
movl result(%rip), %eax
#APP
# 8 "wingsummer.c" 1
addl input(%rip),%eax
# 0 "" 2
#NO_APP
movl %eax, result(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
至此你应该明白了匹配限制符的意义和用法。在新版本的GCC
中增加了一个限制字符“+”,它表示操作数是读写型的,GCC
知道应将变量值先读入寄存器,然后计算,最后写回变量,而无需在输入部分再去描述该变量:
int input,result;
int main()
{
result = 0;
input = 1;
__asm__ __volatile__ ("addl %1,%0":"+r"(result):"m"(input));
return 0;
}
汇编如下:
.file "wingsummer.c"
.text
.comm input,4,4
.comm result,4,4
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $0, result(%rip)
movl $1, input(%rip)
movl result(%rip), %eax
#APP
# 8 "wingsummer.c" 1
addl input(%rip),%eax
# 0 "" 2
#NO_APP
movl %eax, result(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
& 限制符
限制符&
在内核中使用的比较多,它表示输入和输出操作数不能使用相同的寄存器,这样可以避免很多错误。举一个例子,下面代码的作用是将函数foo
的返回值存入变量ret
中:
int foo()
{
return 1;
}
int main()
{
__asm__ ( “call foo\n\tmovl %%ebx,%1”, : ”=a”(ret) : ”r”(bar) );
return 0;
}
它的反汇编如下:
.file "wingsummer.c"
.text
.comm ret,4,4
.comm bar,4,4
.globl foo
.type foo, @function
foo:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $1, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size foo, .-foo
.globl main
.type main, @function
main:
.LFB1:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl bar(%rip), %eax
#APP
# 10 "wingsummer.c" 1
call foo
movl %ebx,%eax
# 0 "" 2
#NO_APP
movl %eax, ret(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE1:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
我们知道函数的int
型返回值存放在%eax
中,但是gcc
编译的结果是输入和输出同时使用了寄存器%eax
,这显然不对。避免这种情况的方法是使用&
限定符,这样bar
就不会再使用%eax
寄存器,因为已被ret
指定使用。
int ret,bar;
int foo()
{
return 1;
}
int main()
{
__asm__ ( "call foo\n\tmovl %%ebx,%1" : "=&a"(ret) : "r"(bar) );
return 0;
}
汇编如下:
.file "wingsummer.c"
.text
.comm ret,4,4
.comm bar,4,4
.globl foo
.type foo, @function
foo:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $1, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size foo, .-foo
.globl main
.type main, @function
main:
.LFB1:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl bar(%rip), %edx
#APP
# 10 "wingsummer.c" 1
call foo
movl %ebx,%edx
# 0 "" 2
#NO_APP
movl %eax, ret(%rip)
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE1:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
破坏描述部分
寄存器破坏描述符
通常编写程序只使用一种语言:高级语言或者汇编语言。高级语言编译的步骤大致如下:
- 预处理
- 编译
- 汇编
- 链接
我们这里只关心第二步编译(将C
代码转换成汇编代码):因为所有的代码都是用高级语言编写,编译器可以识别各种语句的作用,在转换的过程中所有的寄存器都由编译器决定如何分配使用,它有能力保证寄存器的使用不会冲突;也可以利用寄存器作为变量的缓冲区,因为寄存器的访问速度比内存快很多倍。如果全部使用汇编语言则由程序员去控制寄存器的使用,只能靠程序员去保证寄存器使用的正确性。但是如果两种语言混用情况就变复杂了,因为内嵌的汇编代码可以直接使用寄存器,而编译器在转换的时候并不去检查内嵌的汇编代码使用了哪些寄存器(因为很难检测汇编指令使用了哪些寄存器,例如有些指令隐式修改寄存器,有时内嵌的汇编代码会调用其他子过程,而子过程也会修改寄存器),因此需要一种机制通知编译器我们使用了哪些寄存器(程序员自己知道内嵌汇编代码中使用了哪些寄存器),否则对这些寄存器的使用就有可能导致错误,修改描述部分可以起到这种作用。当然内嵌汇编的输入输出部分指明的寄存器或者指定为r
,g
型由编译器去分配的寄存器就不需要在破坏描述部分去描述,因为编译器已经知道了。
破坏描述符由逗号格开的字符串组成,每个字符串描述一种情况,一般是寄存器名,除寄存器外还有memory
。例如:%eax
,%ebx
,memory
等。下面看个例子就很清楚为什么需要通知 GCC 内嵌汇编代码中隐式(称它为隐式是因为GCC 并不知道)使用的寄存器。
在内嵌的汇编指令中可能会直接引用某些寄存器,我们已经知道AT&T
格式的汇编语言中,寄存器名以%
作为前缀,为了在生成的汇编程序中保留这个%
号,在asm
语句中对寄存器的引用必须用%%
作为寄存器名称的前缀。原因是%
在asm
内嵌汇编语句中的作用与\
在 C 语言中的作用相同,因此%%
转换后代表%
。
int main()
{
int input, output, temp;
input = 1;
__asm__ __volatile__("movl $0, %%eax;\n\t"
"movl %%eax, %1;\n\t"
"movl %2, %%eax;\n\t"
"movl %%eax, %0;\n\t"
: "=m"(output), "=m"(temp) /* output */
: "r"(input) /* input */
);
return 0;
}
这段代码使用%eax
作为临时寄存器,功能相当于C
代码temp = 0;output=input;
,汇编如下:
.file "wingsummer.c"
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $1, -4(%rbp)
movl -4(%rbp), %eax
#APP
# 6 "wingsummer.c" 1
movl $0, %eax;
movl %eax, -12(%rbp);
movl %eax, %eax;
movl %eax, -8(%rbp);
# 0 "" 2
#NO_APP
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Uos 8.3.0.3-3+rebuild) 8.3.0"
.section .note.GNU-stack,"",@progbits
对应的汇编代码如下:
movl $1, -4(%rbp)
movl -4(%rbp), %eax
# 6 "wingsummer.c" 1
movl $0, %eax;
movl %eax, -12(%rbp);
movl %eax, %eax;
movl %eax, -8(%rbp);
# 0 "" 2
#NO_APP
movl $0, %eax
显然GCC
给input
分配的寄存器也是%eax
,发生了冲突,output
的值始终为0
,而不是input
。
int main()
{
int input, output, temp;
input = 1;
__asm__ __volatile__("movl $0, %%eax;\n\t"
"movl %%eax, %1;\n\t"
"movl %2, %%eax;\n\t"
"movl %%eax, %0;\n\t"
: "=m"(output), "=m"(temp) /* output */
: "r"(input) /* input */
: "eax" /* 描述符 */
);
return 0;
}
对应的关键汇编代码如下:
movl $1, -4(%rbp)
movl -4(%rbp), %edx
#APP
# 6 "wingsummer.c" 1
movl $0, %eax;
movl %eax, -12(%rbp);
movl %edx, %eax;
movl %eax, -8(%rbp);
# 0 "" 2
#NO_APP
movl $0, %eax
通过破坏描述部分,GCC
得知%eax
已被使用,因此给input
分配了%edx
。在使用内嵌汇编时请记住一点:尽量告诉GCC
尽可能多的信息,以防出错。如果你使用的指令会改变CPU
的条件寄存器cc
,需要在修改描述部分增加cc
。
memory 破坏描述符
memory
比较特殊,可能是内嵌汇编中最难懂部分。memory
描述符告知GCC
:
- 不要将该段内嵌汇编指令与前面的指令重新排序;也就是在执行内嵌汇编代码之前,它前面的指令都执行完毕。
- 不要将变量缓存到寄存器,因为这段代码可能会用到内存变量,而这些内存变量会以不可预知的方式发生改变,因此
GCC
插入必要的代码先将缓存到寄存器的变量值写回内存,如果后面又访问这些变量,需要重新访问内存。
如果汇编指令修改了内存,但是 GCC 本身却察觉不到,因为在输出部分没有描述,此时就需要在修改描述部分增加memory
,告诉GCC
内存已经被修改,GCC
得知这个信息后,就会在这段指令之前,插入必要的指令将前面因为优化Cache
到寄存器中的变量值先写回内存,如果以后又要使用这些变量再重新读取。
这两条对实现临界区至关重要,第一条保证不会因为指令的重新排序将临界区内的代码调到临界区之外,第二条保证在临界区访问的变量的值,肯定是最新的值,而不是缓存在寄存器中的值,否则就会导致奇怪的错误。例如下面的代码:
int del_timer(struct timer_list *timer)
{
int ret = 0;
if (timer->next)
{
unsigned long flags;
struct timer_list *next;
save_flags(flags);
cli();
//临界区开始
if ((next = timer->next) != NULL)
{
(next->prev = timer->prev)->next = next;
timer->next = timer->prev = NULL;
ret = 1;
}
//临界区结束
restore_flags(flags);
}
return ret;
}
它先判断timer->next
的值,如果是空直接返回,无需进行下面的操作。如果不是空,则进入临界区进行操作,但是cli()
的实现(见下面)没有使用memory
,timer->next
的值可能会被缓存到寄存器中,后面if ((next = timer->next) != NULL)
会从寄存器中读取timer->next
的值,如果在if (timer->next)
之后,进入临界区之前,timer->next
的值可能被在外部改变,这时肯定会出现异常情况,而且这种情况很难Debug
。但是如果cli
使用memory
,那么if ((next = timer->next) != NULL)
语句会重新从内存读取timer->next
的值,而不会从寄存器中取,这样就不会出现问题了。2.4 版内核中cli
和sti
的代码如下:
#define __cli() __asm__ __volatile__("cli": : :"memory")
#define __sti() __asm__ __volatile__("sti": : :"memory")
这就是为什么指令没有修改内存,但是却使用memory
修改描述符的原因,应从指令的上下文去理解为什么要这样做。
小结
本篇我们介绍了AT&T
和如何使用GCC
的内联汇编,当然本篇仅仅是抛砖引玉,给熟练使用Intel
汇编语法的同志们更快的熟悉并会使用AT&T
汇编语法。不过吐槽一句:有一说一,AT&T
可读性远远低于Intel
的,写起来也比较麻烦。
本文来自博客园,作者:寂静的羽夏 ,一个热爱计算机技术的菜鸟
转载请注明原文链接:https://www.cnblogs.com/wingsummer/p/16305622.html