C语言中使用汇编语言之一GCC内嵌汇编

在C语言中如何使用汇编语言呢？这个问题在 不同的编译器中，具体实现方法是不同的。不过在实现大方上也不过就是有两种，而且各种编译器的实现方法也是大同小异。一种是在C语言中嵌入汇编语言代码， 另一种是让C语言从外部调用汇编。下面我们就以 Borland格式为例来说一说具体用法。但是,GCC与Microsoft的实现方法的与Borland只在格式上有点区别。当然，GCC的嵌入汇编是 AT&T格式的。还好，不管什么格式，只是表达形式的不同而已，其内在含义是一模一样的。还是那句话各种编译器的实现方法是大同小异的，并没有本 质的区别。另外在最后还附带了一篇介绍在GCC中使用内嵌汇编的文章。

一、两种实现方式

首先，我们看一看在C语言中如何嵌入汇编语言代码。在C语言中嵌入汇编语言代码，也有两种格式，一种是单句的，一种是模块的。

我们来看看一些简单的例子。

例子1：

单句格式的：

main（）
｛

asm     mov ah,2;
asm     mov bh,0;
asm     mov dl, 20;
asm     mov dh,10;
asm     int 10h; /*调用BIOS中断设置光标位置*/

｝

模块格式的：

main（）
｛

asm｛

mov ah,2
mov bh,0
mov dl, 20
mov dh,10
int 10h

    ｝

｝

在这个小程序里面并没有突出“嵌入”二字。不过从这个程序中可以看出其基本格式。嵌入的各行代码前面加上asm关键字或者把汇编语句放入asm代码块中，每行以分号或换行符结束，而注释必须是C语言格式的。

下面我们来看一个让C语言和汇编协作的例子：

例子2：

main()

{

char const *MESSAGE=”OutPut from asm..\n$”;

asm{

  mov ah, 9
mov dx, MESSAGE
int 21h

}

}

上面这个例子十分的简单，它的纯C语言版本是：

＃i nclude

main()

{

    printf(“OutPut from asm..\n$”);
}

接下来我们看一看如何让C语言调用汇编例程。我们还是看一个简单的小程序：

C语言部分如下：

extern cursor (int,int),

main()

{

        cursor(15,12);
}

汇编语言部分如下：

.MODEL  SMALL
.CODE
PUBLIC

_CURSOR PROC

PUSH  BP
MOV  BP,SP
MOV  DH,[BP+4]
MOV  DL,[BP+6]
MOV  AH,02
MOV  BH,00
INT  10H
POP  BP
RET

_CURSOR ENDP

通过上面这个程序，你会看到调用汇编语言的关键就是如何传递参数。事实上，是通过堆栈来传递的但是具体规则是什么呢？下面我就来看看。

二、调用规则

       实际上，在C语言中使用汇编语言最困难的就是如何安全有效的传递参数。否则在调用汇编子程序时就会从堆栈中取出错误的参数。更可恶的是这种错误在编译的时候是不会发现错误提示的。

       下面是C与MASM汇编语言混合是用的时候采用的规则：

1、  参数传递的次序与它们出现的次序是相反的。例如上例中的cursor (x,y)中，首先传递的是y，然后才是x。这与我们的一般想法是不一样的，所以在这儿容易出现错误。

2、  传递完参数后，C程序还将保存（CS，IP）。如果C程序是SMALL或COMPACT存储模式下编译的（或者过程是NEAR型的），那么只保存IP，而 在MEDIUM、LARGE或HUGE模式下编译的（或者过程是FAR型的），那么CS和IP都会被压入堆栈，其顺序是CS在前，IP在后。不过这个过程 是C语言自动进行的而不需要我们干预。这也就是我们在例子2中为什么用MOV  DH,[BP+4]而不是MOV  DH,[BP]。因为前面是CS和IP而不是参数，真正的参数从[BP+4]开始。

3、  还有BP也必须保存在堆栈中，然后我们才可以通过BP和偏移地址来访问参数。

4、  最后一条指令应当是后面不带数字的RET，因为把堆栈到原始位置的工作将由C程序重新获得控制权以后才会执行。

5、  任何于C程序共享的名称都必须在前面加下划线，而且C语言只识别前8个字符。

6、  对于普通的参数C语言传递的是参数值，而对于数组，传递的是指针（也就是数据的地址）。

7、  如果C程序是在MEDIUM、LARGE或HUGE模式下编译的，那么汇编语言过程应该设为FAR型，C程序是SMALL或COMPACT存储模式下编译的，那么汇编语言过程应该设为NEAR型。

不过在MASM5.1或TASM1.0以及更高的版本的时候就不必担心偏移地址、在共享名称前加下划线以及保存BP这些琐事了，因为它们可以由编译器自动完成了。很显然例子2是旧格式的。

三、把参数返回C程序

       当C程序需要从汇编过程获得某个参数时，这个参数应该通过寄存器来传递。具体使用哪些寄存器取决于参数的大小，请看下表：

寄存器
大小（字节）
C数据类型

AL
1
Char,short

AX
2
Int

DX:AX
4
Long

四、把汇编语言程序与C语言程序链接到一起

1、  确保汇编语言中的过程被定义为PUBLIC，过程名以下划线开始。例如，在C语言中叫做“sum”到汇编语言中就应该是“_sum”.

2、  在C语言程序中过程定义为外部类型，例如在例子2中的extern cursor (int,int)。

3、  用汇编器对汇编语言程序汇编，得到XXX.obj文件。

4、  用C语言编译器编译C语言程序，得到YYY.obj文件。

5、  用链接器将它们链接到一起生成可执行文件：

link XXX.obj + YYY.obj

       以上就是混合使用C语言和汇编语言应该注意的几点问题。关于在GCC中使用汇编语言大体上是和上面一样的，只是实现细节上有一点区别而已。下面的这篇文章对于在GCC中使用内嵌汇编进行详细的解释。

GCC使用的内嵌汇编语法格式小教程  

本文对内嵌汇编语法，从基本语法、内嵌汇编的格式介绍、和扩展的内嵌汇编格式进行了详细说明，需要说明的是GCC采用的是AT&T的汇编格式．

一、　基本语法

语法上主要有以下几个不同.

★ 寄存器命名原则

AT&T: ％eax Intel: eax

★源/目的操作数顺序

AT&T: movl ％eax,％ebx Intel: mov ebx,eax

★常数/立即数的格式

AT&T: movl $_value,％ebx Intel: mov eax,_value

把_value的地址放入eax寄存器

AT&T: movl $0xd00d,％ebx Intel: mov ebx,0xd00d

★ 操作数长度标识

AT&T: movw ％ax,％bx Intel: mov bx,ax

★寻址方式

AT&T: immed32(basepointer,indexpointer,indexscale)

Intel: [basepointer indexpointer*indexscale imm32]

Linux工作于保护模式下，用的是32位线性地址，所以在计算地址时不用考虑egment:offset的问题．上式中的地址应为：

imm32 basepointer indexpointer*indexscale

下面是一些例子：

★直接寻址

AT&T: _booga　;

_booga是一个全局的c变量注意加上$是表示地址引用，不加是表示值引用．

注：对于局部变量，可以通过堆栈指针引用．

Intel: [_booga]

★寄存器间接寻址

AT&T: (％eax)

Intel: [eax]

★变址寻址

AT&T: _variable(％eax)

Intel: [eax _variable]

AT&T: _array(,％eax,4)

Intel: [eax*4 _array]

AT&T: _array(％ebx,％eax,8)

Intel: [ebx eax*8 _array] 

二、　基本的内嵌汇编

基本的内嵌汇编很简单，一般是按照下面的格式

asm(statements);

例如：asm(nop); asm(cli);

asm　和　__asm__是完全一样的．

Intel和AT&T汇编语法差异：

1。前缀：

Intel汇编寄存器和立即数无需前缀。后者寄存器前缀为%，立即数前缀为$。

eg：

   Intex Syntax

   mov eax,1

   mov ebx,0ffh

   int 80h

  

   AT&T Syntax

   movl $1,%eax

   movl $0xff,%ebx

   int   $0x80

2。二者对操作数处理方向不同：

eg：

   Intel 汇编语法：

   instr dest,source

   mov eax,[ecx]

  

   AT&T 汇编语法：

   instr   source,dest

   movl (%ecx),%eax

3。内存变量语法差异：

Intel语法使用中括号[]，后者使用小括号()

eg：

   Intex Syntax

   mov eax,[ebx]

   mov eax,[ebx+3]

  

   AT&T Syntax

   movl (%ebx),%eax

   movl 3(%ebx),%eax

4。后缀：

AT&T汇编指令有后缀，以表明数据类型（8位、16位等）；Intel则根据寄存器自动识别。

eg：

   Intel Syntax

   mov al,bl

   mov ax,bx

   mov eax,ebx

   mov eax, dword ptr [ebx]

  

   AT&T Syntax

   movb %bl,%al

   movw %bx,%ax

   movl %ebx,%eax

   movl (%ebx),%eax

5。

Intel：segreg:[base+index*scale+disp]

AT&T： %segreg:disp(base,index,scale).

例子：

       1 #include

       2

       3 int main(void) {

       4      long eax=4;

       5      long ebx=2;

       6

       7      __asm__ __volatile__ ("addl %1, %0"

       8              : "=b"((long)ebx)

       9              : "a"((long)eax), "b"((long)ebx)

      10              : "1"

      11              );

      12

      13      printf("ebx=%d\n", ebx);

      14      return 0;

      15 }

输出结果：ebx=6

linux下c语言内嵌汇编格式：

__asm__("" : output : input : modify);

output, input, modify都是引号括起来的字符串，他们直接用冒号分隔。

每个都可以有多项，项之间用逗号分隔，最多总共不能超过10个。

output要用“=”开头

寄存器缩写约定

Abbrev Register

a   %eax/%ax/%al

b   %ebx/%bx/%bl

c   %ecx/%cx/%cl

d   %edx/%dx/%dl

S   %esi/%si

D   %edi/%di

m   memory

q 由编译器在a、b、c、d中任意选择

寄存器还可以使用数字形式的缩写，0～9 (%0-%9)，所以会有最多10个项的限制。

系统调用：

1。系统调用号存在eax中

2。系统调用参数要少于6个，分别存放在ebx, ecx, edx, esi, edi

3。返回值存在eax中

4。参数超过5个，用ebx指向存放参数的内存。如果压入堆栈，要注意参数顺序反过来。

汇编文件入口：

如果使用gcc编译，入口为main；如果用as和ld编译连接，入口使用_start，可以用ld的-e选项指定程序入口：ld -e main -o hello hello.o。

汇编程序运行时出现segmentation fault：

程序运行完时，处理器试图去执行下一个内存单元的指令，内存中没有指令或者为非法指令，硬件或者os包含机制就会发现

这个异常而产生段包含错误。解决方法，加上退出程序的系统调用就可以了。

eg：

       1 #.include "defines.h"

       2 .data

       3 hello:

       4 .string "hello world\n"

       5

       6 .globl   main

       7 main:

       8 #write

       9 movl     $4,%eax

      10 #stdout

      11 movl     $1,%ebx

      12 #content

      13 movl     $hello,%ecx

      14 #length of string

      15 movl     $12,%edx

      16 #system call

      17 int      $0x80

      18

      19 #exit

      20 movl     $1,%eax

      21 int      $0x80

      22

      23 ret

//------------------------------------------------------------------------------------------------------------------------

//  详细说明：

//------------------------------------------------------------------------------------------------------------------------

1.内嵌汇编举例

在内嵌汇编中，可以将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               movl input, %eax                              

10 #APP GCC插入的注释，表示内嵌汇编开始

11             movl %eax,%eax       我们的内嵌汇编语句

12 #NO_APP GCC 插入的注释，表示内嵌汇编结束

13             movl %eax, result      将结果存入result变量

从汇编代码可以看出，第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 语法

内嵌汇编语法如下：

__asm__(

汇编语句模板:

输出部分:

输入部分:

破坏描述部分)

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

__asm__ __volatile__(

"CLI":

:"memory")

2.1 汇编语句模板

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

2.2 输出部分

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

例：

__asm__ __volatile__(

"pushfl ;

 popl %0 ;

 cli"

:"=g" (x)

 )

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

2.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.4 限制字符

2.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.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

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

2.4.3 “&”限制符

限制符“&”在内核中使用的比较多，它表示输入和输出操作数不能使用相同的寄存器，这样可以避免很多错误。

举一个例子，下面代码的作用是将函数foo的返回值存入变量ret中

__asm__ ( “call foo;movl %%edx,%1”, :”=a”(ret) : ”r”(bar) );

我们知道函数的int型返回值存放在%eax中，但是gcc编译的结果是输入和输出同时使用了寄存器%eax，如下：

movl bar, %eax

#APP

call foo

movl %ebx,%eax

#NO_APP

movl %eax, ret

结果显然不对，原因是GCC并不知道%eax中的值是我们所要的。避免这种情况的方法是使用“&”限定符，这样bar就不会再使用%eax寄存器，因为已被ret指定使用。

_asm__ ( “call foo;movl %%edx,%1”,:”=&a”(ret) : ”r”(bar) );