GNU内嵌汇编

本文转自 http://wenku.baidu.com/view/b7bb0e116c175f0e7cd13733.html

 

一、格式
　　asm volatile (“asm code”：output：input：changed); //必须以‘;’结尾，不管有多长对C都只是一条语句

　　asm 内嵌汇编关键字

　　volatile 告诉编译器不要优化内嵌汇编，如果想优化可以不加

　　ANSI C规范的关键字： （ANSI C把asm用于其它用途，不能用于内嵌汇编语句，GCC可以）
　　　　__asm__
　　　　__volatile__ //前面和后面都有两个下划线，它们之间没有空格

　　如果后面部分没有内容，‘：’可以省略，前面或中间的不能省略‘：’
　　没有asm code也不可以省略‘“”’，没有changed必须省略‘：’

二、asm code

　　asm code必须放在一个字符串内，但是字符串中间是不能直接按回车键换行的
　　可以写成多个字符串，只要字符串之间不加任何符号编译完后就会变成一个字符串

　　　　"mov r0,r0\n\t" //指令之间必须要换行，\t可以不加，只是为了在汇编文件中的指令格式对齐
　　　　"mov r1,r1\n\t"
　　　　"mov r2,r2"

　　字符串内不是只能放指令，可以放一些标签、变量、循环、宏等等

　　还可以把内嵌汇编放在C函数外面，用内嵌汇编定义函数、变量、段等汇编有的东东，总之就跟直接在写汇编文件一样

　　在C函数外面定义内嵌汇编时不能加volatile：output：input：changed

　　注意：编译器不检查asm code的内容是否合法，直接交给汇编器

三、output（ASM --> C）和input（C --> ASM）
　　1、 指定输出值
　　　　__asm__ __volatile__ (
　　　　　　"asm code"
　　　　　　:“constraint”（variable）
　　　　);

　　　　constraint定义variable的存放位置：
　　　　　　　　　　r　　　　　使用任何可用的通用寄存器
　　　　　　　　　　m 　　　　使用变量的内存地址

　　　　output修饰符：
　　　　　　　　　　+ 　　　　 可读可写
　　　　　　　　　　= 　　　　 只写
　　　　　　　　　　& 　　　　 该输出操作数不能使用输入部分使用过的寄存器，只能 +& 或 =& 方式使用

　　2、 指定输入值
　　　　__asm__ __volatile__ (
　　　　　　"asm code"
　　　　　　:
　　　　　　:“constraint”（variable / immediate）
　　　　);

　　　　constraint定义variable / immediate的存放位置：
　　　　　　　　　　r　　　　　使用任何可用的通用寄存器（变量和立即数都可以）
　　　　　　　　　　m 　　　　使用变量的内存地址（不能用立即数）
　　　　　　　　　　i　　　　　使用立即数（不能用变量）

　　3、 使用占位符
　　　　int a = 100,b = 200;
　　　　int result;
　　　　__asm__ __volatile__ (
　　　　　　“mov %0,%3\n\t” //mov r3,#123 %0代表result，%3代表123（编译器会自动加 # 号）
　　　　　　“ldr r0,%1\n\t” //ldr r0,[fp, #-12] %1代表 a 的地址
　　　　　　“ldr r1,%2\n\t” //ldr r1,[fp, #-16] %2代表 b 的地址
　　　　　　“str r0,%2\n\t” //str r0,[fp, #-16] 因为%1和%2是地址所以只能用ldr或str指令
　　　　　　“str r1,%1\n\t” //str r1,[fp, #-12] 如果用错指令编译时不会报错，要到汇编时才会
　　　　　　：“=r”(result),“+m”(a),“+m”(b) out1是%0，out2是%1，...，outN是%N-1
　　　　　　：“i”(123) in1是%N，in2是%N+1，...
　　　　);

　　4、引用占位符
　　　　int num = 100;
　　　　__asm__ __volatile__ (
　　　　　　"add %0,%1,#100\n\t"
　　　　　　: "=r"(a)
　　　　　　: "0"(a) //"0"是零，即%0，引用时不可以加 %，只能input引用output,
　　　　); //引用是为了更能分清输出输入部分

　　5、 & 修饰符
　　　　int num;
　　　　__asm__ __volatile__ ( //mov r3, #123 //编译器自动加的指令
　　　　　　"mov %0,%1\n\t" //mov r3,r3 //输入和输出使用相同的寄存器
　　　　　　: "=r"(num)
　　　　　　: "r"(123)
　　　　);

　　　　int num;
　　　　__asm__ __volatile__ ( //mov r3, #123
　　　　　　"mov %0,%1\n\t" //mov r2,r3 //加了&后输入和输出的寄存器不一样了
　　　　　　: "=&r"(num) //mov r3, r2 //编译器自动加的指令
　　　　　　: "r"(123)
　　　　);

四、changed

　　告诉编译器你修改过的寄存器，编译器会自动把保存这些寄存器值的指令加在内嵌汇编之前，再把恢复寄存器值的指令加在内嵌汇编之后

　　　　1 　　void test()　　　　　　　　　　　　　　　　　　test:
　　　　2 　　{　　　　　　　　　　　　　　　　　　　　　　　　  str fp, [sp, #-4]!
　　　　3 　　　　 __asm__ __volatile__ (　　　　　　　　　　　add fp, sp, #0
　　　　4　　　　　　"mov r4,#123"　　　　　　　　　　　　　　 mov r4,#123
　　　　5 　　　　 ); 　　　　　　　　　　　　　　　　　　　　　　add sp, fp, #0
　　　　6 　　} 　　　　　　　　　　　　　　　　　　　　　　　　 ldmfd sp!, {fp}
　　　　7 　　　　　　　　　　　　　　　　　　　　　　　　　　    bx lr
　　　　8
　　　　9 　　void test()　　　　　　　　　　　　　　　　　　test:
　　　　10 　 {　　　　　　　　　　　　　　　　　　　　　　　　　stmfd sp!, {r4, fp}
　　　　11     　　__asm__ __volatile__ ( 　　　　　　　　　　　 add fp, sp, #0
　　　　12     　　"mov r4,#123"　　　　　　　　　　　　　　　　mov r4,#123
　　　　13 　　    : 　　　　　　　　　　　　　　　　　　　　　　  add sp, fp, #0
　　　　14  　　   : 　　　　　　　　　　　　　　　　　　　　　　  ldmfd sp!, {r4, fp}
　　　　15 　　    :"r4" 　　　　　　　　　　　　　　　　　　　　  bx lr
　　　　16 　　    );
　　　　17 　  }

　　汇编的第 2 行与第 6 行没有保存和恢复 R4（R4是通用寄存器变量必须保护，见APCS），第 10 行与第 14 行有保存和恢复 R4

　　如果修改了没有在输入或输出中定义的任何内存位置，必须在changed列表里加上“memory”