Chinaunix首页 | 论坛 | 博客
  • 博客访问: 696967
  • 博文数量: 109
  • 博客积分: 1751
  • 博客等级: 上尉
  • 技术积分: 1816
  • 用 户 组: 普通用户
  • 注册时间: 2011-05-31 22:37
文章分类

全部博文(109)

文章存档

2014年(9)

2013年(21)

2012年(48)

2011年(31)

分类: Android平台

2013-01-22 09:52:52

如果您是 Linux 内核的开发人员,您会发现自己经常要对与体系结构高度相关的功能进行编码或优化代码路径。您很可能是通过将汇编语言指令插入到 C 语句的中间(又称为内联汇编的一种方法)来执行这些任务的。让我们看一下 Linux 中内联汇编的特定用法。(注:内联汇编即嵌入汇编)


GNU 汇编程序简述让我们首先看一下 Linux 中使用的基本汇编程序语法。GCC(用于 Linux 的 GNU C 编译器)使用 AT&T 汇编语法。下面列出了这种语法的一些基本规则。(该列表肯定不完整;只包括了与内联汇编相关的那些规则。)
寄存器命名寄存器名称有 % 前缀。即,如果必须使用 eax,它应该用作 %eax。
源操作数和目的操作数的顺序在所有指令中,先是源操作数,然后才是目的操作数。这与将源操作数放在目的操作数之后的 Intel 语法不同。
mov %eax, %ebxtransfers the contents of eax to ebx.


操作数大小根据操作数是字节 (byte)、字 (word) 还是长型 (long),指令的后缀可以是 b、w 或 l。这并不是强制性的;GCC 会尝试通过读取操作数来提供相应的后缀。但手工指定后缀可以改善代码的可读性,并可以消除编译器猜测不正确的可能性。
movb %al, %bl -- Byte move
movw %ax, %bx -- Word move
movl %eax, %ebx -- Longword move


立即操作数通过使用 $ 指定直接操作数。
movl $0xffff, %eax -- will move the value of 0xffff into eax register.


间接内存引用任何对内存的间接引用都是通过使用 ( ) 来完成的。
movb
(%
esi), %al -- will transfer the byte in the memory  pointed by esi into al register


内联汇编GCC 为内联汇编提供特殊结构,它具有以下格式:
GCC 的 “asm” 结构asm
(
assembler template
       : output operands
(
optional)
       : input operands
(
optional)
       : list of clobbered registers
(
optional)
);


本例中,汇编程序模板由汇编指令组成。输入操作数是充当指令输入操作数使用的 C 表达式。输出操作数是将对其执行汇编指令输出的 C 表达式。
内联汇编的重要性体现在它能够灵活操作,而且可以使其输出通过 C 变量显示出来。因为它具有这种能力,所以 “asm” 可以用作汇编指令和包含它的 C 程序之间的接口。
一个非常基本但很重要的区别在于 简单内联汇编只包括指令,而 扩展内联汇编包括操作数。要说明这一点,考虑以下示例:
内联汇编的基本要素{
    int a=10b;
    
asm
("
movl %1, %%eax;"
         "movl %%eax, %0;"
        :"=r"(b)
/* output */    
        :"
r"(a)
/* input */
        :"%eax"); /* clobbered register */
}


在上例中,我们使用汇编指令使 “b” 的值等于 “a”。请注意以下几点:
  • “b” 是输出操作数,由 %0 引用,”a” 是输入操作数,由 %1 引用。
  • “r” 是操作数的约束,它指定将变量 “a” 和 “b” 存储在寄存器中。请注意,输出操作数约束应该带有一个约束修饰符 “=”,指定它是输出操作数。
  • 要在 “asm” 内使用寄存器 %eax,%eax 的前面应该再加一个 %,换句话说就是 %%eax,因为 “asm” 使用 %0、%1 等来标识变量。任何带有一个 % 的数都看作是输入/输出操作数,而不认为是寄存器。
  • 第三个冒号后的修饰寄存器 %eax 告诉将在 “asm” 中修改 GCC %eax 的值,这样 GCC 就不使用该寄存器存储任何其它的值。
  • movl %1, %%eax 将 “a” 的值移到 %eax 中, movl %%eax, %0 将 %eax 的内容移到 “b” 中。
  • 因为 “b” 被指定成输出操作数,因此当 “asm” 的执行完成后,它将反映出更新的值。换句话说,对 “asm” 内 “b” 所做的更改将在 “asm” 外反映出来。
现在让我们更详细的了解每一项的含义。
汇编程序模板汇编程序模板是一组插入到 C 程序中的汇编指令(可以是单个指令,也可以是一组指令)。每条指令都应该由双引号括起,或者整组指令应该由双引号括起。每条指令还应该用一个定界符结尾。有效的定界符为新行 (n) 和分号 (;)。 ‘n’ 后可以跟一个 tab(t) 作为格式化符号,增加 GCC 在汇编文件中生成的指令的可读性。 指令通过数 %0、%1 等来引用 C 表达式(指定为操作数)。
如果希望确保编译器不会在 “asm” 内部优化指令,可以在 “asm” 后使用关键字 “volatile”。如果程序必须与 ANSI C 兼容,则应该使用 __asm__ 和 __volatile__,而不是 asm 和 volatile。
操作数C 表达式用作 “asm” 内的汇编指令操作数。在汇编指令通过对 C 程序的 C 表达式进行操作来执行有意义的作业的情况下,操作数是内联汇编的主要特性。
每个操作数都由操作数约束字符串指定,后面跟用括弧括起的 C 表达式,例如:”constraint” (C expression)。操作数约束的主要功能是确定操作数的寻址方式。
可以在输入和输出部分中同时使用多个操作数。每个操作数由逗号分隔开。
在汇编程序模板内部,操作数由数字引用。如果总共有 n 个操作数(包括输入和输出),那么第一个输出操作数的编号为 0,逐项递增,最后那个输入操作数的编号为 n -1。总操作数的数目限制在 10,如果机器描述中任何指令模式中的最大操作数数目大于 10,则使用后者作为限制。
修饰寄存器列表如果 “asm” 中的指令指的是硬件寄存器,可以告诉 GCC 我们将自己使用和修改它们。这样,GCC 就不会假设它装入到这些寄存器中的值是有效值。通常不需要将输入和输出寄存器列为 clobbered,因为 GCC 知道 “asm” 使用它们(因为它们被明确指定为约束)。不过,如果指令使用任何其它的寄存器,无论是明确的还是隐含的(寄存器不在输入约束列表中出现,也不在输出约束列表中出现),寄存器都必须被指定为修饰列表。修饰寄存器列在第三个冒号之后,其名称被指定为字符串。
至于关键字,如果指令以某些不可预知且不明确的方式修改了内存,则可能将 “memory” 关键字添加到修饰寄存器列表中。这样就告诉 GCC 不要在不同指令之间将内存值高速缓存在寄存器中。
操作数约束前面提到过,”asm” 中的每个操作数都应该由操作数约束字符串描述,后面跟用括弧括起的 C 表达式。操作数约束主要是确定指令中操作数的寻址方式。约束也可以指定:
  • 是否允许操作数位于寄存器中,以及它可以包括在哪些种类的寄存器中
  • 操作数是否可以是内存引用,以及在这种情况下使用哪些种类的地址
  • 操作数是否可以是立即数
约束还要求两个操作数匹配。
常用约束在可用的操作数约束中,只有一小部分是常用的;下面列出了这些约束以及简要描述。有关操作数约束的完整列表,请参考 GCC 和 GAS 手册。
寄存器操作数约束 (r)使用这种约束指定操作数时,它们存储在通用寄存器中。请看下例:
asm
("
movl %%cr3, %0n" :"=r"(cr3val));


这里,变量 cr3val 保存在寄存器中,%cr3 的值复制到寄存器上,cr3val 的值从该寄存器更新到内存中。指定 “r” 约束时,GCC 可以将变量 cr3val 保存在任何可用的 GPR 中。要指定寄存器,必须通过使用特定的寄存器约束直接指定寄存器名。
a   %eax
b   %ebx
c   %ecx
d   %edx
S   %esi
D   %edi


内存操作数约束 (m)当操作数位于内存中时,任何对它们执行的操作都将在内存位置中直接发生,这与寄存器约束正好相反,后者先将值存储在要修改的寄存器中,然后将它写回内存位置中。但寄存器约束通常只在对于指令来说它们是绝对必需的,或者它们可以大大提高进程速度时使用。当需要在 “asm” 内部更新 C 变量,而您又确实不希望使用寄存器来保存其值时,使用内存约束最为有效。例如,idtr 的值存储在内存位置 loc 中:
("sidt %0n" : :"m"(loc));


匹配(数字)约束在某些情况下,一个变量既要充当输入操作数,也要充当输出操作数。可以通过使用匹配约束在 “asm” 中指定这种情况。
asm
("
incl %0" :"=a"(var):"0"(var));


在匹配约束的示例中,寄存器 %eax 既用作输入变量,也用作输出变量。将 var 输入读取到 %eax,增加后将更新的 %eax 再次存储在 var 中。这里的 “0″ 指定第 0 个输出变量相同的约束。即,它指定 var 的输出实例只应该存储在 %eax 中。该约束可以用于以下情况:
  • 输入从变量中读取,或者变量被修改后,修改写回到同一变量中
  • 不需要将输入操作数和输出操作数的实例分开
使用匹配约束最重要的意义在于它们可以导致有效地使用可用寄存器。
一般内联汇编用法示例以下示例通过各种不同的操作数约束说明了用法。有如此多的约束以至于无法将它们一一列出,这里只列出了最经常使用的那些约束类型。
“asm” 和寄存器约束 “r”让我们先看一下使用寄存器约束 r 的 “asm”。我们的示例显示了 GCC 如何分配寄存器,以及它如何更新输出变量的值。
int main(void)
{

    int x = 10y;
    
asm
("
movl %1, %%eax;"
         "movl %%eax, %0;"
        :"=r"(y)
/* y is output operand */
        :"r"(x)
/* x is input operand */
        :"%eax"); /* %eax is clobbered register */
}


在该例中,x 的值复制为 “asm” 中的 y。x 和 y 都通过存储在寄存器中传递给 “asm”。为该例生成的汇编代码如下:
main:
pushl %ebp
movl %esp,%ebp
subl $8,%esp
movl $10,-4(%ebp)    
movl -4(%ebp),%edx  /* x=10 is stored in %edx */
#APP    /* asm starts here */


    movl %edx, %eax     /* x is moved to %eax */
    movl %eax, %edx     /* y is allocated in edx and updated */
#NO_APP /* asm ends here */

movl %edx,-8(%ebp)
/* value of y in stack is updated with the value in %edx */


当使用 “r” 约束时,GCC 在这里可以自由分配任何寄存器。在我们的示例中,它选择 %edx 来存储 x。在读取了 %edx 中 x 的值后,它为 y 也分配了相同的寄存器。
因为 y 是在输出操作数部分中指定的,所以 %edx 中更新的值存储在 -8(%ebp),堆栈上 y 的位置中。如果 y 是在输入部分中指定的,那么即使它在 y 的临时寄存器存储值 (%edx) 中被更新,堆栈上 y 的值也不会更新。
因为 %eax 是在修饰列表中指定的,GCC 不在任何其它地方使用它来存储数据。
输入 x 和输出 y 都分配在同一个 %edx 寄存器中,假设输入在输出产生之前被消耗。请注意,如果您有许多指令,就不是这种情况了。要确保输入和输出分配到不同的寄存器中,可以指定 & 约束修饰符。下面是添加了约束修饰符的示例。
int main(void)
{

    int x = 10y;
    
asm
("
movl %1, %%eax;"
         "movl %%eax, %0;"
        :"=&r"(y)
/* y is output operand, note the & constraint modifier. */
        :"r"(x)
/* x is input operand */
        :"%eax"); /* %eax is clobbered register */
}


以下是为该示例生成的汇编代码,从中可以明显地看出 x 和 y 存储在 “asm” 中不同的寄存器中。
main:
pushl %ebp
movl %esp,%ebp
subl $8,%esp
movl $10,-4(%ebp)
movl -4(%ebp),%ecx  /* x, the input is in %ecx */
#APP
    movl %ecx, %eax
    movl %eax, %edx     /* y, the output is in %edx */
#NO_APP

movl %edx,-8(%ebp)


特定寄存器约束的使用现在让我们看一下如何将个别寄存器作为操作数的约束指定。在下面的示例中,cpuid 指令采用 %eax 寄存器中的输入,然后在四个寄存器中给出输出:%eax、%ebx、%ecx、%edx。对 cpuid 的输入(变量 “op”)传递到 “asm” 的 eax 寄存器中,因为 cpuid 希望它这样做。在输出中使用 a、b、c 和 d 约束,分别收集四个寄存器中的值。
asm
("
cpuid"
    :"=a"
(
_eax),
     "
=b"
(
_ebx),
     "
=c"
(
_ecx),
     "
=d"
(
_edx)
    :"a"
(
op));


在下面可以看到为它生成的汇编代码(假设 _eax、_ebx 等… 变量都存储在堆栈上):
movl -20(%ebp),%eax /* store 'op' in %eax -- input */
#APP
    cpuid
#NO_APP

movl %eax,-4(%ebp)
/* store %eax in _eax -- output */
movl %ebx,-8(%ebp)
/* store other registers in respective output variables */
movl %ecx,-12(%ebp) 
movl %edx,-16(%ebp)


strcpy 函数可以通过以下方式使用 “S” 和 “D” 约束来实现:
asm
("
cldn
      repn
      movsb
"
    : /* no input */
    :"S"(src), "D"(dst), "c"(count));


通过使用 “S” 约束将源指针 src 放入 %esi 中,使用 “D” 约束将目的指针 dst 放入 %edi 中。因为 rep 前缀需要 count 值,所以将它放入 %ecx 中。
在下面可以看到另一个约束,它使用两个寄存器 %eax 和 %edx 将两个 32 位的值合并在一起,然后生成一个64 位的值:
#define rdtscll(val)


__asm__ __volatile__
("
rdtsc" : "=A"
(
val))


The generated assembly looks like this (if val has a 64 bit memory space).
#APP
rdtsc
#NO_APP

movl %eax,-8(%ebp)
/* As a result of A constraint %eax and %edx serve as outputs */
movl %edx,-4(%ebp)


Note here that the values in %edx:%eax serve as 64 bit output.
使用匹配约束在下面将看到系统调用的代码,它有四个参数:
#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)


type name
(
type1 arg1type2 arg2type3 arg3type4 arg4)
{
 
    
long __res
    
__asm__ volatile
("
int $0x80" 
    : "
=a"
(
__res) 
    : "
0"
(
__NR_##name),"b"
((
long)(arg1)),"c"
((
long)(arg2))
    "
d"
((
long)(arg3)),"S"
((
long)(arg4)))
    
__syscall_return(type,__res)
}



在上例中,通过使用 b、c、d 和 S 约束将系统调用的四个自变量放入 %ebx、%ecx、%edx 和 %esi 中。请注意,在输出中使用了 “=a” 约束,这样,位于 %eax 中的系统调用的返回值就被放入变量 __res 中。通过将匹配约束 “0″ 用作输入部分中第一个操作数约束,syscall 号 __NR_##name 被放入 %eax 中,并用作对系统调用的输入。这样,这里的 %eax 既可以用作输入寄存器,又可以用作输出寄存器。没有其它寄存器用于这个目的。另请注意,输入(syscall 号)在产生输出(syscall 的返回值)之前被消耗(使用)。
内存操作数约束的使用请考虑下面的原子递减操作:
__asm__ __volatile__(
    "lock; decl %0"
    :"=m"
(
counter)
    :"m"
(
counter));


为它生成的汇编类似于:
#APP
    lock
    decl -24(%ebp)
/* counter is modified on its memory location */
#NO_APP.



您可能考虑在这里为 counter 使用寄存器约束。如果这样做,counter 的值必须先复制到寄存器,递减,然后对其内存更新。但这样您会无法理解锁定和原子性的全部意图,这些明确显示了使用内存约束的必要性。
使用修饰寄存器请考虑内存拷贝的基本实现。
asm
("
movl $count, %%ecx;"
     "up: lodsl;"
     "stosl;"
     "loop up;"
    :           /* no output */
    :"S"(src), "D"(dst)
/* input */
    :"%ecx", "%eax"
);  
/* clobbered list */


当 lodsl 修改 %eax 时,lodsl 和 stosl 指令隐含地使用它。%ecx 寄存器明确装入 count。但 GCC 在我们通知它以前是不知道这些的,我们是通过将 %eax 和 %ecx 包括在修饰寄存器集中来通知 GCC 的。在完成这一步之前,GCC 假设 %eax 和 %ecx 是自由的,它可能决定将它们用作存储其它的数据。请注意,%esi 和 %edi 由 “asm” 使用,它们不在修饰列表中。这是因为已经声明 “asm” 将在输入操作数列表中使用它们。这里最低限度是,如果在 “asm” 内部使用寄存器(无论是明确还是隐含地),既不出现在输入操作数列表中,也不出现在输出操作数列表中,必须将它列为修饰寄存器。
结束语总的来说,内联汇编非常巨大,它提供的许多特性我们甚至在这里根本没有涉及到。但如果掌握了本文描述的基本材料,您应该可以开始对自己的内联汇编进行编码了。

这篇文章是IBM网站上收集的,非本人所写。


=======================================================================


gcc内嵌汇编简介
在内嵌汇编中,可以将C语言表达式指定为汇编指令的操作数,而且不用去管如何将C语言表达式的值读入哪个寄存器,以及如何将计算结果写回C 变量,你只要告诉程序中C语言表达式与汇编指令操作数之间的对应关系即可, GCC会自动插入代码完成必要的操作。

1、简单的内嵌汇编
例:
__asm__ __volatile__("hlt"); "__asm__"表示后面的代码为内嵌汇编,"asm"是"__asm__"的别名。"__volatile__"表示编译器不要优化代码,后面的指令保留原样,"volatile"是它的别名。括号里面是汇编指令。

2、内嵌汇编举例
使用内嵌汇编,要先编写汇编指令模板,然后将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自动处理,我们只需使用限制字符串指导GCC如何处理即可。限制字符必须与指令对操作数的要求相匹配,否则产生的汇编代码将会有错,读者可以将上例中的两个"r",都改为"m"(m表示操作数放在内存,而不是寄存器中),编译后得到的结果是:
movl input, result
很明显这是一条非法指令,因此限制字符串必须与指令对操作数的要求匹配。例如指令movl允许寄存器到寄存器,立即数到寄存器等,但是不允许内存到内存的操作,因此两个操作数不能同时使用"m"作为限定字符。


内嵌汇编语法如下:
__asm__(汇编语句模板: 输出部分: 输入部分: 破坏描述部分)
共四个部分:汇编语句模板,输出部分,输入部分,破坏描述部分,各部分使用":"格开,汇编语句模板必不可少,其他三部分可选,如果使用了后面的部分,而前面部分为空,也需要用":"格开,相应部分内容为空。例如:
__asm__ __volatile__("cli": : :"memory")

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

2、输出部分
输出部分描述输出操作数,不同的操作数描述符之间用逗号格开,每个操作数描述符由限定字符串和C 语言变量组成。每个输出操作数的限定字符串必须包含"="表示他是一个输出操作数。
例:
__asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x) )
描述符字符串表示对该变量的限制条件,这样GCC 就可以根据这些条件决定如何分配寄存器,如何产生必要的代码处理指令操作数与C表达式或C变量之间的联系。

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

4、限制字符
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 位的寄存器(use long 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" ... 也即该操作数就是指定的那个操作数,例如"0"
"9" 去描述"%1"操作数,那么"%1"引用的其实就
是"%0"操作数,注意作为限定符字母的0-9 与
指令中的"%0"-"%9"的区别,前者描述操作数,
后者代表操作数。
& 该输出操作数不能使用过和输入操作数相同的寄存器

操作数类型 "=" 操作数在指令中是只写的(输出操作数)
"+" 操作数在指令中是读写类型的(输入输出操作数)

浮点数 "f" 浮点寄存器
"t" 第一个浮点寄存器
"u" 第二个浮点寄存器
"G" 标准的80387浮点常数
% 该操作数可以和下一个操作数交换位置
例如addl的两个操作数可以交换顺序
(当然两个操作数都不能是立即数)
# 部分注释,从该字符到其后的逗号之间所有字母被忽略
* 表示如果选用寄存器,则其后的字母被忽略

5、破坏描述部分
破坏描述符用于通知编译器我们使用了哪些寄存器或内存,由逗号格开的字符串组成,每个字符串描述一种情况,一般是寄存器名;除寄存器外还有"memory"。例如:"%eax","%ebx","memory"等。

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

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

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

3、Memory
有了上面的知识就不难理解Memory修改描述符了,Memory描述符告知GCC:
1)不要将该段内嵌汇编指令与前面的指令重新排序;也就是在执行内嵌汇编代码之前,它前面的指令都执行完毕
2)不要将变量缓存到寄存器,因为这段代码可能会用到内存变量,而这些内存变量会以不可预知的方式发生改变,因此GCC插入必要的代码先将缓存到寄存器的变量值写回内存,如果后面又访问这些变量,需要重新访问内存。

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

使用"volatile"也可以达到这个目的,但是我们在每个变量前增加该关键字,不如使用"memory"方便

阅读(1586) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册