羽夏笔记—— AT&T 与 GCC

写在前面

  本文是本人根据《AT&T 汇编语言与 GCC 内嵌汇编简介》进一步整理,修改了一些错误,并删除我并不能复现代码相关的部分。该文章一是我对 AT&T 的学习记录,二是对大家学习 AT&T 有更好的帮助。如对该博文有好的建议,欢迎反馈。码字不易,如果本篇文章有帮助你的,如有闲钱,可以打赏支持我的创作。如想转载,请把我的转载信息附在文章后面,并声明我的个人信息和本人博客地址即可,但必须事先通知我

概述

  在此之前,我建议你学习Intel汇编,否则有些你可能不太懂。因为我是根据有Intel汇编编写的基础的人的快速转型,方便学习Linux源码,因为里面有一些奇奇怪怪的内联汇编的写法,不会的话会看的满头雾水。下面我开始介绍AT&T汇编语言语法与Intel汇编语法的差别:

区别

大小写

  Intel格式的指令一般使用大写字母,而AT&T格式的一般使用小写字母。在使用Intel格式的指令内敛汇编的时候我并没有发现严格大写(除了我见过 Ghidra 严格区分大小写)。

IntelAT&T
MOV EAX,EBXmovl %ebx,%eax

操作数赋值方向

  在Intel语法中,第一个表示目的操作数,第二个表示源操作数,赋值方向从右向左。AT&T语法第一个为源操作数,第二个为目的操作数,方向从左到右。写高级语言的代码写多了,AT&T语法看起来比较难受。

IntelAT&T
MOV EAX,EBXmovl %ebx,%eax

前缀

  在Intel语法中寄存器和立即数不需要前缀;AT&T中寄存器需要加前缀%,立即数需要加前缀$。感觉AT&T语法有点花里胡哨,可读性相对于Intel语法低。

IntelAT&T
MOV EAX,1movl $1,%eax

  符号常数直接引用,不需要加前缀,如:movl value , %ebxvalue为一常数;在符号前加前缀$表示引用符号地址, 如movl $value, %ebx,是将value的地址放到ebx中。
  是不是有点看不太懂,我们来继续举个例子:

IntelAT&T
MOV ESI, [0x4000]movl 0x4000, %esi

  总线锁定前缀lock:总线锁定操作。lock前缀在Linux核心代码中使用很多,特别是SMP代码中。当总线锁定后其它CPU不能存取锁定地址处的内存单元。
  对于AT&T语法,远程跳转指令和子过程调用指令的操作码使用前缀l,分别为ljmplcall,与之相应的返回指令lret,如下是几个例子:

IntelAT&T
CALL FAR SECTION:OFFSETlcall \(secion:\)offset
JMP FAR SECTION:OFFSETljmp \(secion:\)offset
RET FAR SATCK_ADJUSTlret $stack_adjust

间接寻址语法

  Intel中基地址使用[],而在AT&T中使用()。另外处理复杂操作数的语法也不同,IntelSegreg:[base+index*scale+disp],而在AT&T中为%segreg:disp(base,index,sale),其中segregindexscaledisp都是可选的,在指定index而没有显式指定scale的情况下使用默认值 1scaledisp不需要加前缀&。看不懂没关系,我们来几个例子:

IntelAT&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 PTRWORD PTRDWORD PTR

IntelAT&T
mov al, blmovb %bl,%al
mov ax,bxmovw %bx,%ax
mov eax, dword ptr [ebx]movl (%ebx), %eax

  在AT&T汇编指令中,操作数扩展指令有两个后缀,一个指定源操作数的字长,另一个指定目标操作数的字长。AT&T的符号扩展指令的为movs,零扩展指令为movz(相应的Intel指令为movsxmovzx)。因此,movsbl %al,%edx表示对寄存器al中的字节数据进行字节到长字的符号扩展,计算结果存放在寄存器edx中。下面是一些允许的操作数扩展后缀:

  • bl: 字节 -> 长字
  • bw: 字节 -> 字
  • wl: 字 -> 长字

  跳转指令标号后的后缀表示跳转方向,f表示向前forwardb表示向后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语言表达式,本例中只有resultinput,他们按照出现的顺序分别与指令操作数%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读入寄存器%eaxGCC也指定一个寄存器与输出变量result相关,本例也是%eax,等得到操作结果后再使用指令movl %eax, result,将寄存器的值写回C变量result中。从上面的汇编代码我们可以看出与resultinput相关连的寄存器都是%eaxGCC使用%eax替换内嵌汇编指令模板中的%0%1movl %eax,%eax,显然这一句可以不要。但是没有优化,所以这一句没有被去掉。由此可见,C表达式或者变量与寄存器的关系由GCC自动处理,我们只需使用限制字符串指导GCC如何处理即可。限制字符必须与指令对操作数的要求相匹配,否则产生的汇编代码将会有错,读者可以将上例中的两个r,都改为mm 表示操作数放在内存,而不是寄存器中),编译后得到的结果是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。第一个占位符%0C语言变量ADDR对应,第二个占位符%1C语言变量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将输入变量放入eaxebxecxedx中的一个
r将输入变量放入通用寄存器,也就是eaxebxecxedxesiedi中的一个
Aeaxedx合成一个 64 位的寄存器
  • 内存
限定符描述
m内存变量
o操作数为内存变量,但是其寻址方式是偏移量类型,也即是基址寻址,或者是基址加变址寻址
V操作数为内存变量,但寻址方式不是偏移量类型
操作数为内存变量,但寻址方式为自动增量
p操作数是一个合法的内存地址(指针)
  • 寄存器或内存
限定符描述
g将输入变量放入eaxebxecxedx中的一个或者作为内存变量
X操作数可以是任何类型
  • 立即数
限定符描述
I0-31 之间的立即数(用于 32 位移位指令)
J0-63 之间的立即数(用于 64 位移位指令)
N0-255 之间的立即数(用于 out 指令)
i立即数
n立即数,有些系统不支持除字以外的立即数,这些系统应该使用n而不是i
  • 操作数类型
限定符描述
=操作数在指令中是只写的(输出操作数)
+操作数在指令中是读写类型的(输入输出操作数)
  • 浮点数
限定符描述
f浮点寄存器
t第一个浮点寄存器
u第二个浮点寄存器
G标准的 80387 浮点常数
  • 匹配
限定符描述
09表示用它限制的操作数与某个指定的操作数匹配,也即该操作数就是指定的那个操作数,例如用0去描述%1操作数,那么%1引用的其实就是%0操作数,注意作为限定符字母的09与指令中的%0%9的区别,前者描述操作数,后者代表操作数。
  • 其他
限定符描述
&该输出操作数不能使用过和输入操作数相同的寄存器
%该操作数可以和下一个操作数交换位置
#部分注释,从该字符到其后的逗号之间所有字母被忽略
*表示如果选用寄存器,则其后的字母被忽略

  现在继续看上面的例子,"=m" (ADDR)表示ADDR为内存变量,而且是输出变量;"Ir" (nr)表示nr0-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,这显然不是我们想要的。
  综上可以总结出如下几点:

  1. 使用r限制的输入变量,GCC先分配一个寄存器,然后将值读入寄存器,最后用该寄存器替换占位符;
  2. 使用r限制的输出变量,GCC会分配一个寄存器,然后用该寄存器替换占位符,但是在使用该寄存器之前并不将变量值先读入寄存器,GCC认为所有输出变量以前的值都没有用处,不读入寄存器,最后GCC插入代码,将寄存器的值写回变量;
  3. 输入变量使用的寄存器在最后一处使用它的指令之后,就可以挪做其他用处,因为已经不再使用。

  因为第二条,上面的内嵌汇编指令不能奏效,因此需要在执行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代码转换成汇编代码):因为所有的代码都是用高级语言编写,编译器可以识别各种语句的作用,在转换的过程中所有的寄存器都由编译器决定如何分配使用,它有能力保证寄存器的使用不会冲突;也可以利用寄存器作为变量的缓冲区,因为寄存器的访问速度比内存快很多倍。如果全部使用汇编语言则由程序员去控制寄存器的使用,只能靠程序员去保证寄存器使用的正确性。但是如果两种语言混用情况就变复杂了,因为内嵌的汇编代码可以直接使用寄存器,而编译器在转换的时候并不去检查内嵌的汇编代码使用了哪些寄存器(因为很难检测汇编指令使用了哪些寄存器,例如有些指令隐式修改寄存器,有时内嵌的汇编代码会调用其他子过程,而子过程也会修改寄存器),因此需要一种机制通知编译器我们使用了哪些寄存器(程序员自己知道内嵌汇编代码中使用了哪些寄存器),否则对这些寄存器的使用就有可能导致错误,修改描述部分可以起到这种作用。当然内嵌汇编的输入输出部分指明的寄存器或者指定为rg型由编译器去分配的寄存器就不需要在破坏描述部分去描述,因为编译器已经知道了。
  破坏描述符由逗号格开的字符串组成,每个字符串描述一种情况,一般是寄存器名,除寄存器外还有memory。例如:%eax%ebxmemory等。下面看个例子就很清楚为什么需要通知 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

  显然GCCinput分配的寄存器也是%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

  1. 不要将该段内嵌汇编指令与前面的指令重新排序;也就是在执行内嵌汇编代码之前,它前面的指令都执行完毕。
  2. 不要将变量缓存到寄存器,因为这段代码可能会用到内存变量,而这些内存变量会以不可预知的方式发生改变,因此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()的实现(见下面)没有使用memorytimer->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 版内核中clisti的代码如下:

#define __cli() __asm__ __volatile__("cli": : :"memory") 
#define __sti() __asm__ __volatile__("sti": : :"memory") 

  这就是为什么指令没有修改内存,但是却使用memory修改描述符的原因,应从指令的上下文去理解为什么要这样做。

小结

  本篇我们介绍了AT&T和如何使用GCC的内联汇编,当然本篇仅仅是抛砖引玉,给熟练使用Intel汇编语法的同志们更快的熟悉并会使用AT&T汇编语法。不过吐槽一句:有一说一,AT&T可读性远远低于Intel的,写起来也比较麻烦。

《羽夏笔记—— AT&T 与 GCC》

    原文作者:寂静的羽夏
    原文地址: https://www.cnblogs.com/wingsummer/p/16305622.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞