在gcc中使用intel风格的内联汇编

很简单，内联汇编使用asm(“.intel_syntax noprefix/n”)声明一下，之后的内联汇编就能够用intel风格了，构建可执行文件时给gcc加上-masm=intel参数。
先写一个小程序测试一下：

[cpp] view plain copy

1. #include <stdio.h>  
2. int main() {  
3.         int a = 3;  
4.         asm(".intel_syntax noprefix/n");  
5.         asm("mov dword ptr a,10/n");  
6.         printf("%d/n", a);  
7.         return 0;  
8. }  

[root@jcwkylk src]# gcc -masm=intel test.c -o test
/tmp/ccgWTkUF.o: In function `main':
test.c:(.text+0x1a): undefined reference to `a'
collect2: ld returned 1 exit status
出错，说符号a没有定义。看看编译后的结果是什么样子：
[root@jcwkylk src]# gcc -S test.c
输出不长，把test.s的内容所有贴出来：
[c-sharp] view plain copy

1.         .file   "test.c"  
2.         .section        .rodata  
3. .LC0:  
4.         .string "%d/n"  
5.         .text  
6. .globl main  
7.         .type   main, @function  
8. main:  
9.         leal    4(%esp), %ecx  
10.         andl    $-16, %esp  
11.         pushl   -4(%ecx)  
12.         pushl   %ebp  
13.         movl    %esp, %ebp  
14.         pushl   %ecx  
15.         subl    $36, %esp  
16.         movl    $3, -8(%ebp)  
17. #APP  
18.         .intel_syntax noprefix  
19.         mov dword ptr a,10  
20. #NO_APP  
21.         movl    -8(%ebp), %eax  
22.         movl    %eax, 4(%esp)  
23.         movl    $.LC0, (%esp)  
24.         call    printf  
25.         movl    $0, %eax  
26.         addl    $36, %esp  
27.         popl    %ecx  
28.         popl    %ebp  
29.         leal    -4(%ecx), %esp  
30.         ret  
31.         .size   main, .-main  
32.         .ident  "GCC: (GNU) 4.1.1 20061011 (Red Hat 4.1.1-30)"  
33.         .section        .note.GNU-stack,"",@progbits  

从上面看出来，夹在#APP和#NO_APP之间的部分就是.intel_syntax，它保持了原样，而代码中的a本来是个局部变量，只有在函数运行时它才会动态在栈上分配，使用ebp加上偏移量来访问它，这就是问题所在。由于全局变量的变量名会保存在符号表中，因此若是要在内联汇编中使用变量名，也只能使用全局变量的变量名。只为在内联汇编中用名称来访问变量而把一个局部变量变成全局的是不合理的，因此咱们这里也用ebp+offset的方式来访问局部变量。
要这么作，就得了解gcc编译时是如何为函数分配栈的，以及调用函数时寄存器约定是怎样的。从上面的汇编代码能够看出来：
[c-sharp] view plain copy

1. main:  
2.         leal    4(%esp), %ecx   ; ecx=[esp+4],  
3.         andl    $-16, %esp  
4.         pushl   -4(%ecx)  
5.         pushl   %ebp  
6.         movl    %esp, %ebp  
7.         pushl   %ecx  
8.         subl    $36, %esp  

这几行代码用来初始化mai函数的调用栈，和cl编译器不一样的是在push ebp前面多出来了几行，有个esp &= -16的操做，-16=0xfffffff0，这个做用多是为了对齐，esp应该是保持16字节对齐的。但这些细节在这里做用都不大。最关键的是这三行：
        pushl   %ebp
        movl    %esp, %ebp
        pushl   %ecx
有一个把ecx寄存器压栈的操做，因此第一个局部变量的起始地址应该是ebp-8。
另外一个注意的地方是printf的调用：
        movl    -8(%ebp), %eax
        movl    %eax, 4(%esp)
        movl    $.LC0, (%esp)
        call    printf
在这个代码中printf有两个参数，但却没有看到指望的push。gcc用了另一种方法：直接操做esp。上面这三行代码，首先把[ebp-8]也就是第一个局部变量即a的值给了eax，而后把这个值传递到esp+4这个地址指向的内存单元，而后esp指向printf的第一个参数——那个格式控制字符串。以后call printf会把下一条指令的地址压入栈中，而后跳转到printf，因此，对printf来讲，ebp+4仍然是返回地址，ebp+8仍然是第一个参数，ebp+0xc仍然是第二个参数。一切都没变。
最后有这一行代码：movl    $0, %eax
看来返回值仍然是存放在eax寄存器中。
好，如今写一个比较完整的测试程序：
[cpp] view plain copy

1. #include <stdio.h>  
2. int add(int a, int b) {  
3.         return a+b;  
4. }  
5. int main() {  
6.         int a = 3;  
7.         asm(".intel_syntax noprefix/n");  
8.         asm("mov dword ptr [ebp-8],10/n");  
9.         printf("%d/n", a);  
10.         asm("push dword ptr [ebp-8]/n");  
11.         asm("push 25/n");  
12.         asm("call add/n");  
13.         asm("add esp, 8/n");  
14.         asm("mov dword ptr [ebp-8], eax/n");  
15.         printf("%d/n", a);  
16.         return 0;  
17. }  

[root@jcwkylk src]# gcc -masm=intel test.c -o test
[root@jcwkylk src]# ./test
10
35