AT&T汇编语言与GCC内嵌汇编简介_1

1 AT&T 与INTEL的汇编语言语法的区别
1.1大小写
1.2操作数赋值方向
1.3前缀
1.4间接寻址语法
1.5后缀
1.6指令

2 GCC内嵌汇编
2.1简介
2.2内嵌汇编举例
2.3语法
2.3.1汇编语句模板
2.3.2输出部分
2.3.3输入部分
2.3.4限制字符
2.3.5破坏描述部分
2.4GCC如何编译内嵌汇编代码

3后记

本节先介绍
AT&T汇编语言语法与INTEL汇编语法的差别，然后介绍GCC内嵌汇编语法。阅读本节需要读者具有INTEL
汇编语言基础。



1 AT&T 与INTEL的汇编语言语法的区别


1.1  
指令大小写
INTEL格式的指令使用大写字母，而AT&T
格式的使用小写字母。
例：
INTEL AT&T
MOV EAX,EBX movl %ebx,%eax
1.2  
指令操作数赋值方向

在INTEL语法中，第一个表示目的操作数，第二个表示源操作数，赋值方向从右向左。
   AT&T语法第一个为源操作数，第二个为目的操作数，方向从左到右，合乎自然。


例：
INTEL AT&T
MOV EAX,EBX movl %ebx,%eax
1.3  
指令前缀
在INTEL语法中寄存器和立即数不需要前缀；
   AT&T中寄存器需要加前缀“%”；立即数需要加前缀“$”。


例：
INTEL AT&T
MOV EAX,1 movl $1,%eax

符号常数直接引用，不需要加前缀，如：
movl value , %ebx
value为一常数；
在符号前加前缀 $, 表示引用符号地址,
如
movl $value, %ebx
是将value的地址放到ebx中。

总线锁定前缀“lock”：
总线锁定操作。“lock”前缀在Linux
核心代码中使用很多，特别是SMP
代码中。当总线锁定后其它CPU
不能存取锁定地址处的内存单元。

远程跳转指令和子过程调用指令的操作码使用前缀“l“，分别为ljmp，lcall，
与之相应的返回指令伪lret。
例：

INTEL AT&T

lcall $secion:$offset
JMP FAR SECTION:OFFSET ljmp $secion:$offset
RET FAR SATCK_ADJUST lret $stack_adjust

1.4   间接寻址语法

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
Instr foo,segreg:[base+index*scale+disp] instr %segreg:disp(base,index,scale),foo

1.5  
指令后缀

       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
中。下面是一些允许的操作数扩展后缀：

l       
bl: ，字节>->长字 l       
bw: ，字节>->字 l       
wl: ，字->长字

跳转指令标号后的后缀表示跳转方向，“f”表示向前（forward），
“b，”表示向后（back）。
例：

jmp 1f
jmp 1f

1.6   指令
INTEL汇编与AT&T汇编指令基本相同，差别仅在语法上。关于每条指令的语法可以参考I386Manual。



2      GCC内嵌汇编

2.1   简介

内核代码绝大部分使用C
语言编写，只有一小部分使用汇编语言编写，例如与特定体系结构相关的代码和对性能影响很大的代码。GCC提供了内嵌汇编的功能，可以在C代码中直接内嵌汇编语言语句，大大方便了程序设计。

简单的内嵌汇编很容易理解


例：

__asm__
__volatile__("hlt");

“__asm__”表示后面的代码为内嵌汇编，“asm”是“__asm__”的别名。
“__volatile__”表示编译器不要优化代码，后面的指令保留原样，
“volatile”是它的别名。括号里面是汇编指令。

2.2   内嵌汇编举例在内嵌汇编中，可以将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”，“%1”….“%9，”表示。在每个操作数前
面有一个用引号括起来的字符串，字符串的内容是对该操作数的限制或者说要求。“result”前面
的限制字符串是“=r”，其中“=”表示“result”是输出操作数，“r
”表示需要将“result”与某个通用寄存器相关联，先将操作数的值读入寄存器，然后
在指令中使用相应寄存器，而不是“result”本身，当然指令执行完后需要将寄存器中的值
存入变量“result”，从表面上看好像是指令直接对“result”进行操作，实际上GCC
做了隐式处理，这样我们可以少写一些指令。“input”前面的“r”表示该表达式需要先放入
某个寄存器，然后在指令中使用该寄存器参加运算。




我们将上面的内嵌代码放到一个C源文件中，然后使用gcc –c–S得到该C
文件源代码相对应的汇编代码，然后查看一下汇编代码，看看GCC是如何处理的。



C源文件如下内容如下，注意该代码没有实际意义，仅仅作为例子。


extern     int
input,result;
  
void test(void)
{
         input
= 1;
__asm__ __volatile__ ("movl %1,%0" :
"=r" (result) : "r" (input));
         return
;
}







对应的汇编代码如下;

行号 代码 解释

1
7
8 movl    $1, input 对应C语言语句input = 1;
9 input, %eax
10 #APP GCC插入的注释，表示内嵌汇编开始
11 movl %eax,%eax 我们的内嵌汇编语句
12 #NO_APP GCC 插入的注释，表示内嵌汇编结束
13 movl %eax, result 将结果存入result变量
14
－
18
。。。。。。

从汇编代码可以看出，第9行和第13行是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”作为限定字符。

2.3   语法


内嵌汇编语法如下：

__asm__(
汇编语句模板:
输出部分:
输入部分:
破坏描述部分)


共四个部分：汇编语句模板，输出部分，输入部分，破坏描述部分，各部分使用“:”格
开，汇编语句模板必不可少，其他三部分可选，如果使用了后面的部分，而前面部分为空，
也需要用“:”格开，相应部分内容为空。例如：

__asm__ __volatile__(
"cli":
:
:"memory")

2.3.1   汇编语句模板


汇编语句模板由汇编语句序列组成，语句之间使用“;”、“\n”或“\n\t”分开。
指令中的操作数可以使用占位符引用C语言变量，操作数占位符最多10个，名称如下：%0，%1…，%9。
指令中使用占位符表示的操作数，总被视为long型（4，个字节），但对其施加的操作
根据指令可以是字或者字节，当把操作数当作字或者字节使用时，默认为低字或者低字节。
对字节操作可以显式的指明是低字节还是次字节。方法是在%和序号之间插入一个字母，
“b”代表低字节，“h”代表高字节，例如：%h1。

2.3.2 输出部分

输出部分描述输出操作数，不同的操作数描述符之间用逗号格开，每个操作数描述符由限定字符串和
C语言变量组成。每个输出操作数的限定字符串必须包含“=”表示他是一个输出操作数。


例：
__asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x) )

描述符字符串表示对该变量的限制条件，这样GCC就可以根据这些条件决定如何
分配寄存器，如何产生必要的代码处理指令操作数与C表达式或C变量之间的联系。

2.3.3   输入部分

输入部分描述输入操作数，不同的操作数描述符之间使用逗号格开，每个操作数描述符由
限定字符串和C语言表达式或者C语言变量组成。


例1：
__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为内存变量。

2.3.4   限制字符
2.3.4.1            限制字符列表
限制字符有很多种，有些是与特定体系结构相关，此处仅列出常用的限定字符和i386
中可能用到的一些常用的限定符。它们的作用是指示编译器如何处理其后的C
语言变量与指令操作数之间的关系，例如是将变量放在寄存器中还是放在内存中等，
下表列出了常用的限定字母。

分类
限定符 描述 通用寄存器


“a”将输入变量放入eax

这里有一个问题：假设eax已经被使用，那怎么办？

其实很简单：因为GCC知道eax已经被使用，它在这段汇编代码的起始处插入一条
语句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位的寄存器(uselong longs)
“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”


匹配

“0”，“1 ，”... “9 ”

表示用它限制的操作数与某个指定的操作数匹配，也即该操作数就是指定的那个操作数，
例如用“0 ”去描述“％1”操作数，那么“%1”引用的其实就是“%0”操作数，注意作为
限定符字母的0－9 ，与指令中的“％0”－“％9”的区别，前者描述操作数，后者代表操作数。
  

后面有详细描述 & 该输出操作数不能使用过和输入操作数相同的寄存器
  

后面有详细描述


操作数类型
“=” 操作数在指令中是只写的（输出操作数）
“+” 操作数在指令中是读写类型的（输入输出操作数）

   浮点数
“f”

浮点寄存器
“t”第一个浮点寄存器
“u”第二个浮点寄存器
“G”标准的80387

浮点常数
   % 该操作数可以和下一个操作数交换位置


例如addl的两个操作数可以交换顺序（当然两个操作数都不能是立即数）


# 部分注释，从该字符到其后的逗号之间所有字母被忽略

* 表示如果选用寄存器，则其后的字母被忽略


现在继续看上面的例子，
"=m" (ADDR)表示ADDR为内存变量（“m”），而且是输出变量（“=”）；"Ir" (nr)表示nr，为
0－31之间的立即数（“I”）或者一个寄存器操作数（“r”）。



2.3.4.2           
匹配限制符

I386
指令集中许多指令的操作数是读写型的（读写型操作数指先读取原来的值然后参加运算，最后
将结果写回操作数），例如addl %1,%0，它的作用是将操作数%0与操作数%1的和存入操作数%0，
因此操作数%0是读写型操作数。老版本的GCC对这种类型操作数的支持不是很好，它将操作数严格
分为输入和输出两种，分别放在输入部分和输出部分，而没有一个单独部分描述读写型操作数，
因此在GCC中读写型的操作数需要在输入和输出部分分别描述，靠匹配限制符将两者关联到一起
注意仅在输入和输出部分使用相同的C变量，但是不用匹配限制符，产生的代码很可能不对，后
面会分析原因。




匹配限制符是一位数字：“0”、“1”……“9，”，分别表示它限制的C表达式分别与
占位符%0，%1，……%9对应的C变量匹配。例如使用“0”作为%1，的限制字符，那么
%0和％1表示同一个C，变量。


看一下下面的代码就知道为什么要将读写型操作数，分别在输入和输出部分加以描述。


该例功能是求input+result的和，然后存入result：


extern int input,result;
  
void test_at_t()
{
         result= 0;
         input = 1;
         __asm__
__volatile__ ("addl %1,%0":"=r"(result): "r"(input));
        
}

对应的汇编代码为：

         movl $0,_result
         movl $1,_input
         movl _input,%edx /APP
         addl %edx,%eax /NO_APP
         movl %eax,%edx
         movl %edx,_result

input 为输入型变量，而且需要放在寄存器中，GCC给它分配的寄存器是%edx，在执行addl之前%edx，
的内容已经是input的值。可见对于使用“r”限制的输入型变量或者表达式，在使用之前GCC会插入
必要的代码将他们的值读到寄存器；“m”型变量则不需要这一步。读入input后执行addl，显然%eax
的值不对，需要先读入result的值才行。再往后看：movl %eax,%edx和movl %edx,_result
的作用是将结果存回result，分配给result的寄存器与分配给input的一样，都是%edx。

综上可以总结出如下几点：

1.       使用“r”限制的输入变量，GCC先分配一个寄存器，然后将值读入寄存器，最后
用该寄存器替换占位符；


2.        使用“r”限制的输出变量，GCC会分配一个寄存器，然后用该寄存器替换占位符，
但是在使用该寄存器之前并不将变量值先读入寄存器，GCC认为所有输出变量以前的
值都没有用处，不读入寄存器（可能是因为AT&T汇编源于CISC架构处理器的汇编语言
，在CISC处理器中大部分指令的输入输出明显分开，而不像RISC那样一个操作数既
做输入又做输出，例如add r0,r1,r2，r0，和r1是输入，r2是输出，输入和输出分开，
没有使用输入输出型操作数，这样我们就可以认为r2对应的操作数原来的值没有用处，
也就没有必要先将操作数的值读入r2，因为这是浪费处理器的CPU周期），最后GCC插入代码，
将寄存器的值写回变量；


3. 输入变量使用的寄存器在最后一处使用它的指令之后，就可以挪做其他用处，因为
已经不再使用。例如上例中的%edx。在执行完addl之后就作为与result对应的寄存器。


因为第二条，上面的内嵌汇编指令不能奏效，因此需要在执行addl之前把result的值读入
寄存器，也许再将result放入输入部分就可以了（因为第一条会保证将result
先读入寄存器）。修改后的指令如下（为了更容易说明问题将input限制符由“r，”改为“m”）：


extern int input,result;
  
void test_at_t()
{
  
         result = 0;
         input = 1;
         __asm__
__volatile__ ("addl %2,%0":"=r"(result):"r"(result),"m"(input));
        
}


看上去上面的代码可以正常工作，因为我们知道%0和%1都和result相关，应该使用同一个
寄存器，但是GCC并不去判断%0和%1，是否和同一个C表达式或变量相关联（这样易于产生与
内嵌汇编相应的汇编代码），因此%0和%1使用的寄存器可能不同。我们看一下汇编代码就知道了。

movl $0,_result
         movl $1,_input
         movl _result,%edx /APP
         addl _input,%eax /NO_APP
         movl %eax,%edx
         movl %edx,_result

现在在执行addl之前将result的值被读入了寄存器%edx，但是addl指令的操作数%0
却成了%eax，而不是%edx，与预料的不同，这是因为GCC给输出和输入部分的变量分配了不同
的寄存器，GCC没有去判断两者是否都与result相关，后面会讲GCC如何翻译内嵌汇编，看完之后
就不会惊奇啦。


使用匹配限制符后，GCC知道应将对应的操作数放在同一个位置（同一个寄存器或者同一个
内存变量）。使用匹配限制字符的代码如下：


extern int input,result;
  
void test_at_t()
{
         result = 0;
         input = 1;
         __asm__
__volatile__ ("addl %2,%0":"=r"(result):"0"(result),"m"(input));
        
}

输入部分中的result用匹配限制符“0”限制，表示%1与％0，代表同一个变量，
输入部分说明该变量的输入功能，输出部分说明该变量的输出功能，两者结合表示result
是读写型。因为%0和%1，表示同一个C变量，所以放在相同的位置，无论是寄存器还是内存。

相应的汇编代码为：


         movl $0,_result
         movl $1,_input
         movl _result,%edx
         movl %edx,%eax /APP
         addl _input,%eax /NO_APP
         movl %eax,%edx
         movl %edx,_result


可以看到与result相关的寄存器是%edx，在执行指令addl之前先从%edx将result读入%eax，
执行之后需要将结果从%eax读入%edx，最后存入result中。这里我们可以看出GCC
处理内嵌汇编中输出操作数的一点点信息：addl并没有使用%edx，可见它不是简单的用result
对应的寄存器%edx去替换%0，而是先分配一个寄存器，执行运算，最后才将运算结果存入
对应的变量，因此GCC是先看该占位符对应的变量的限制符，发现是一个输出型寄存器变量，
就为它分配一个寄存器，此时没有去管对应的C变量，最后GCC，知道还要将寄存器的值写回变量，
与此同时，它发现该变量与%edx关联，因此先存入%edx，再存入变量。


至此读者应该明白了匹配限制符的意义和用法。在新版本的GCC中增加了一个限制字符“+”，
它表示操作数是读写型的，GCC知道应将变量值先读入寄存器，然后计算，最后写回变量，而
无需在输入部分再去描述该变量。


例;
extern int input,result;
  
void test_at_t()
{
  
         result = 0;
         input = 1;
         __asm__
__volatile__ ("addl %1,%0":"+r"(result):"m"(input));
        
}


此处用“+”替换了“=”，而且去掉了输入部分关于result的描述，产生的汇编代码如下：
         movl $0,_result
         movl $1,_input
         movl _result,%eax /APP
         addl _input,%eax /NO_APP
         movl %eax,_result
L2:
         movl %ebp,%esp

处理的比使用匹配限制符的情况还要好，省去了好几条汇编代码。