注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

东月之神

在单纯的观念里面,生命就容易变得比较深刻!

 
 
 

日志

 
 
关于我

别驻足,梦想要不停追逐,别认输,熬过黑暗才有日出,要记住,成功就在下一步,路很苦,汗水是最美的书!

网易考拉推荐

GCC内嵌汇编(一) .  

2012-04-12 20:01:09|  分类: Linux |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
由于工作的需要,所以花了几天时间从网上找了不少资料学习了一下GCC内嵌汇编,在此把我所认为比较重要的部分跟大家分享下,同时也在此感谢那些发表GCC内嵌汇编相关文章的作者!在此也希望我整理的资料对需要学习GCC内嵌汇编的朋友有所帮助。因为内容比较多,所以我特地把它分为几个章节来讲。

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

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

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

汇编语句模板

汇编语句模板由汇编语句序列组成,语句之间使用“;” 、“\n”或“\n\t”分开。指令中的操作数可以使用占位符引用C语言变量, 操作数占位符最多10个, 名称如下: %0, %1, …,%9。指令中使用占位符表示的操作数,总被视为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));

 

例二 :

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为内存变量。

破坏描述部分

 寄存器破坏描述符

如果代码用高级语言编写,编译器可以识别各种语句的作用,在转换的过程中所有的寄存器都由编译器决定如何分配使用, 它有能力保证寄存器的使用不会冲突; 也可以利用寄存器作为变量的缓冲区,因为寄存器的访问速度比内存快很多倍。如果全部使用汇编语言则由程序员去控制寄存器的使用,只能靠程序员去保证寄存器使用的正确性。但是如果两种语言混用情况就变复杂了,因为内嵌的汇编代码可以直接使用寄存器, 而编译器在转换的时候并不去检查内嵌的汇编代码使用了哪些寄存器(因为很难检测汇编指令使用了哪些寄存器,例如有些指令隐式修改寄存器,有时内嵌的汇编代码会调用其他子过程,而子过程也会修改寄存器) ,因此需要一种机制通知编译器我们使用了哪些寄存器(程序员自己知道内嵌汇编代码中使用了哪些寄存器) ,否则对这些寄存器的使用就有可能导致错误,修改描述部分可以起到这种作用。当然内嵌汇编的输入输出部分指明的寄存器或者指定为“r” , “g”型由编译器去分配的寄存器就不需要在破坏描述部分去描述,因为编译器已经知道了。  

破坏描述符由逗号格开的字符串组成,每个字符串描述一种情况,一般是寄存器名;除寄存器外还有“memory” 。例如: “%eax” , “%ebx” , “memory”等。

下面看个例子就很清楚为什么需要通知 GCC 内嵌汇编代码中隐式(称它为隐式是因为GCC并不知道)使用的寄存器。

 在内嵌的汇编指令中可能会直接引用某些寄存器,我们已经知道 AT&T 格式的汇编语言中,寄存器名以“%”作为前缀,为了在生成的汇编程序中保留这个“%”号,在 asm语句中对寄存器的引用必须用“%%”作为寄存器名称的前缀。原因是“%”在 asm 内嵌汇编语句中的作用与“\”在C语言中的作用相同,因此“%%”转换后代表“%” 。

 

例(没有使用修改描述符) :

 int main(void)   

 {

    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” ,

对应的汇编代码如下:

  movl $1,-4(%ebp)

  movl -4(%ebp),%eax

/APP

  movl $0, %eax;

    movl %eax, -12(%ebp);

    movl %eax, %eax;

    movl %eax, -8(%ebp);

/NO_APP

 

显然 GCC给input分配的寄存器也是%eax,发生了冲突,output的值始终为0,而不是

input。

 

使用破坏描述后的代码:

int main(void)   

 {

    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(%ebp)

  movl -4(%ebp),%edx

/APP   movl $0, %eax;

  movl %eax, -12(%ebp);

  movl %edx, %eax;

  movl %eax, -8(%ebp);

/NO_APP

 

通过破坏描述部分,GCC得知%eax 已被使用,因此给input分配了%edx。在使用内嵌汇编时请记住一点:尽量告诉 GCC尽可能多的信息,以防出错。

 如果你使用的指令会改变CPU的条件寄存器cc,需要在修改描述部分增加“cc” 。

 memory 破坏描述符

“memory”比较特殊,可能是内嵌汇编中最难懂部分。为解释清楚它,先介绍一下编译器的优化知识,再看C关键字volatile。最后去看该描述符。

 编译器优化介绍

内存访问速度远不及CPU处理速度,为提高机器整体性能,在硬件上引入硬件高速缓存Cache,加速对内存的访问。另外在现代 CPU中指令的执行并不一定严格按照顺序执行,没有相关性的指令可以乱序执行,以充分利用 CPU的指令流水线,提高执行速度。以上是硬件级别的优化。再看软件一级的优化:一种是在编写代码时由程序员优化,另一种是由编译器进行优化。编译器优化常用的方法有:将内存变量缓存到寄存器;调整指令顺序充分利用CPU指令流水线,常见的是重新排序读写指令。对常规内存进行优化的时候,这些优化是透明的,而且效率很好。由编译器优化或者硬件重新排序引起的问题的解决办法是在从硬件 (或者其他处理器)的角度看必须以特定顺序执行的操作之间设置内存屏障(memory barrier) ,linux 提供了一个宏解决编译器的执行顺序问题。void Barrier(void) 这个函数通知编译器插入一个内存屏障,但对硬件无效, 编译后的代码会把当前 CPU寄存器中的所有修改过的数值存入内存,需要这些数据的时候再重新从内存中读出。

 C 语言关键字volatile

C语言关键字volatile(注意它是用来修饰变量而不是上面介绍的__volatile__)表明某个变量的值可能在外部被改变,因此对这些变量的存取不能缓存到寄存器,每次使用时需要重新存取。该关键字在多线程环境下经常使用,因为在编写多线程的程序时,同一个变量可能被多个线程修改,而程序通过该变量同步各个线程,例如: DWORD __stdcall threadFunc(LPVOID signal)

 {

           int* intSignal=reinterpret_cast<int*>(signal);

           *intSignal=2;

           while(*intSignal!=1)

                sleep(1000);

           return 0;

 }

 

该线程启动时将 intSignal 置为 2,然后循环等待直到 intSignal 为 1 时退出。显然intSignal的值必须在外部被改变,否则该线程不会退出。但是实际运行的时候该线程却不会退出,即使在外部将它的值改为 1,看一下对应的伪汇编代码就明白了:

mov ax,signal

label:

if(ax!=1)

    goto label

 

对于 C编译器来说,它并不知道这个值会被其他线程修改。自然就把它 cache在寄存器里面。记住,C 编译器是没有线程概念的!这时候就需要用到 volatile。volatile 的本意

是指: 这个值可能会在当前线程外部被改变。 也就是说, 我们要在threadFunc中的intSignal前面加上 volatile关键字,这时候,编译器知道该变量的值会在外部改变,因此每次访问该变量时会重新读取,所作的循环变为如下面伪码所示:

label:

mov ax,signal

if(ax!=1)

    goto label

 

Memory

有了上面的知识就不难理解Memory修改描述符了,Memory描述符告知GCC: 

 1)不要将该段内嵌汇编指令与前面的指令重新排序;也就是在执行内嵌汇编代码之前,它前面的指令都执行完毕

 2)不要将变量缓存到寄存器,因为这段代码可能会用到内存变量,而这些内存变量会以不可预知的方式发生改变, 因此 GCC插入必要的代码先将缓存到寄存器的变量值写回内存,如果后面又访问这些变量,需要重新访问内存。

 如果汇编指令修改了内存,但是 GCC 本身却察觉不到,因为在输出部分没有描述,此时就需要在修改描述部分增加“memory” ,告诉 GCC 内存已经被修改,GCC 得知这个信息后,就会在这段指令之前, 插入必要的指令将前面因为优化Cache 到寄存器中的变量值先写回内存,如果以后又要使用这些变量再重新读取。  例:

……….. Char test[100];

char a;

char c;

 

c = 0;

test[0] = 1;

……..

a = test [0];

……

__asm__("cld\n\t"

                     "rep\n\t"

                     "stosb"

                     : /* no output */

                     : "a" (c),"D" (test),"c" (100)

                     : "cx","di","memory");

……….

//我们知道test[0]已经修改,所以重新读取

a=test[0];

 ……

 这段代码中的汇编指令功能与memset相当, 也就是相当于调用了memset(test,0,100);它使用 stosb 修改了 test数组的内容,但是没有在输入或输出部分去描述操作数,因为这两条指令都不需要显式的指定操作数,因此需要增加“memory”通知 GCC。现在假设:GCC在优化时将 test[0]放到了%eax 寄存器,那么 test[0] = 1 对应于%eax=1,a = test [0]被换为 a=%eax,如果在那段汇编指令中不使用“memory” ,Gcc 不知道现在 test[0]的值已经被改变了(如果整段代码都是我们自己使用汇编编写,我们自己当然知道这些内存的修改

情况,我们也可以人为的去优化,但是现在除了我们编写的那一小段外,其他汇编代码都是GCC生成的,它并没有那么智能,知道这段代码会修改test[0]) ,结果其后的a=test[0],转换为汇编后却是 a=%eax,因为GCC不知道显式的改变了test数组,结果出错了。如果增加了“memory”修饰符,GCC 知道: “这段代码修改了内存,但是也仅此而已,它并不知道到底修改了哪些变量” ,因此他将以前因优化而缓存到寄存器的变量值全部写回内存,从内嵌汇编开始,如果后面的代码又要存取这些变量,则重新存取内存(不会将读写操作映射到以前缓存的那个寄存器) 。这样上面那段代码最后一句就不再是%eax=1,而是test[0] = 1。 

这两条对实现临界区至关重要, 第一条保证不会因为指令的重新排序将临界区内的代码调到临界区之外(如果临界区内的指令被重排序放到临界区之外,What  will  happen?),第二条保证在临界区访问的变量的值,肯定是最新的值,而不是缓存在寄存器中的值,否则就会导致奇怪的错误。例如下面的代码:

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()的实现(见下章节)没有使用“memory” ,timer->next的值可能会被缓存到寄存器中,后面 if ((next = timer->next) != NULL)会从寄存器中读取timer->next的值,如果在 if  (timer->next)之后,进入临界区之前,timer->next的值可能被在外部改变,这时肯定会出现异常情况,而且这种情况很难Debug。但是如果 cli使用“memory” ,那么if  ((next  =  timer->next)  !=  NULL)语句会重新从内存读取timer->next的值,而不会从寄存器中取,这样就不会出现问题啦。 v

  评论这张
 
阅读(611)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017