免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

When operands are specified using this constraint, they get stored in General Purpose Registers(GPR). Take the following example:

當(dāng)操作指定了“r”限制符，那么操作數(shù)將會(huì)被存儲(chǔ)在通用寄存器內(nèi)。看下例：

asm ("movl %%eax, %0\n" :"=r"(myval));

Here the variable myval is kept in a register, the value in register eax is copied onto that register, and the value ofmyval is updated into the memory from this register. When the "r" constraint is specified, gcc may keep the variable in any of the available GPRs. To specify the register, you must directly specify the register names by using specific register constraints. They are:

這里的變量myval被存儲(chǔ)在一個(gè)寄存器內(nèi)，代碼將eax寄存器的值拷貝到myval占用的寄存器內(nèi)，然后myval寄存器的值將更新myval的內(nèi)存值。當(dāng)“r”限制符被指定，GCC可能分配任意一個(gè)通用寄存器來存儲(chǔ)操作數(shù)。如果要確切使用某個(gè)寄存器，你應(yīng)該指定這個(gè)寄存器名稱，通過下表的格式：

+---+--------------------+  
| r |    Register(s)     |  
+---+--------------------+  
| a |   %eax, %ax, %al   |  
| b |   %ebx, %bx, %bl   |  
| c |   %ecx, %cx, %cl   |  
| d |   %edx, %dx, %dl   |  
| S |   %esi, %si        |  
| D |   %edi, %di        |  
+---+--------------------+  

When the operands are in the memory, any operations performed on them will occur directly in the memory location, as opposed to register constraints, which first store the value in a register to be modified and then write it back to the memory location. But register constraints are usually used only when they are absolutely necessary for an instruction or they significantly speed up the process. Memory constraints can be used most efficiently in cases where a C variable needs to be updated inside "asm" and you really don’t want to use a register to hold its value. For example, the value of idtr is stored in the memory location loc:

如果限制符“m”后的操作數(shù)在內(nèi)存中，任何對(duì)它們的操作都會(huì)直接更改內(nèi)存值。與“r”限制符不同，“r”首先將操作數(shù)保存在寄存器內(nèi)，然后在寄存器里進(jìn)行數(shù)據(jù)操作，接著把數(shù)據(jù)寫回內(nèi)存區(qū)域。使用“r”限制符，通常是由于某些指令必須使用，或者為了加快程序運(yùn)行，所以占用寄存器?！癿”限制符運(yùn)用更頻繁，當(dāng)我們希望在匯編執(zhí)行過程中就更新內(nèi)存，或者不希望額外占用一個(gè)寶貴的寄存器來裝載變量值，就使用“m”限制符。如下：idtr的值就被保存在loc那塊內(nèi)存。


asm("sidt %0\n" : :"m"(loc));

In some cases, a single variable may serve as both the input and theoutput operand. Such cases may be specified in "asm" by using matching constraints.

在某些情況下，輸出輸入操作可能是同一個(gè)操作數(shù)。這種情況我們需要指定匹配限制符“數(shù)字”。 


asm ("incl %0" :"=a"(var):"0"(var));

We saw similar examples in operands subsection also. In this example for matching constraints, the register %eax is used as both the input and the output variable. var input is read to %eax and updated %eax is stored in var again after increment. "0" here specifies the same constraint as the 0th output variable. That is, it specifies that the output instance of var should be stored in %eax only. This constraint can be used:

上邊見到過類似的例子，此例“0”使用了匹配限制符，寄存器eax同時(shí)供input，output使用。輸入變量var被讀入到eax，運(yùn)算結(jié)束后，再被存儲(chǔ)到eax?！?”這個(gè)限制符表示：與第0個(gè)操作數(shù)使用相同的寄存器。這樣，就指明了輸出輸入使用同一個(gè)寄存器。這個(gè)限制符在如下地方可能用到：

• In cases where input is read from a variable or the variable is modified and modification is written back to the same variable.
• In cases where separate instances of input and output operands are not necessary.
• 輸出輸入為同一變量時(shí)。
• 沒有必要使用更多的寄存器時(shí)。
  

The most important effect of using matching restraints is that they lead to the efficient use of available registers.

使用匹配限制符最重要的作用是：使得對(duì)有限寄存器資源使用更高效。

Some other constraints used are:

其他一些限制符：

1. "m" : A memory operand is allowed, with any kind of address that the machine supports in general.
2. "o" : A memory operand is allowed, but only if the address is offsettable. ie, adding a small offset to the address gives a valid address.
3. "V" : A memory operand that is not offsettable. In other words, anything that would fit the `m’ constraint but not the `o’constraint.
4. "i" : An immediate integer operand (one with constant value) is allowed. This includes symbolic constants whose values will be known only at assembly time.
5. "n" : An immediate integer operand with a known numeric value is allowed. Many systems cannot support assembly-time constants for operands less than a word wide. Constraints for these operands should use ’n’ rather than ’i’.
6. "g" : Any register, memory or immediate integer operand is allowed, except for registers that are not general registers.
7. “m”：對(duì)內(nèi)存的操作被允許，用一個(gè)合法內(nèi)存空間來做操作數(shù)。
8. “o”：對(duì)內(nèi)存的操作被允許，但是必須支持地址偏移值，即，對(duì)于給出的地址，加上一個(gè)偏移量，此時(shí)也是一個(gè)合法的地址。
9. “V”：對(duì)內(nèi)存的操作被允許，但是不支持偏移量。也就是說，支持“m”限制符，但不支持“o”的那些地址。
10. “i”：對(duì)立即整數(shù)（const，常值）的操作被允許，這個(gè)常值可以是運(yùn)行到匯編內(nèi)才被賦值。
11. “n”：對(duì)立即整數(shù)的操作被允許。許多系統(tǒng)不支持匯編中的操作數(shù)小于一個(gè)字寬，對(duì)于這些操作數(shù)，應(yīng)該使用“n”而非“i”。
12. “g”：任意寄存器，內(nèi)存，立即數(shù)都被允許。除了非通用寄存器。
    

Following constraints are x86 specific.

下面的限制符是x86特定的：

1. "r" : Register operand constraint, look table given above.
2. "q" : Registers a, b, c or d.
3. "I" : Constant in range 0 to 31 (for 32-bit shifts).
4. "J" : Constant in range 0 to 63 (for 64-bit shifts).
5. "K" : 0xff.
6. "L" : 0xffff.
7. "M" : 0, 1, 2, or 3 (shifts for lea instruction).
8. "N" : Constant in range 0 to 255 (for out instruction).
9. "f" : Floating point register
10. "t" : First (top of stack) floating point register
11. "u" : Second floating point register
12. "A" : Specifies the `a’ or `d’ registers. This is primarily useful for 64-bit integer values intended to be returned with the `d’ register holding the most significant bits and the `a’ register holding the least significant bits.

6.2 Constraint Modifiers.

While using constraints, for more precise control over the effects of constraints, GCC provides us with constraint modifiers. Mostly used constraint modifiers are

在使用限制符的時(shí)候，為了更準(zhǔn)確的利用限制符的功能，GCC提供給我們一些限制語句修飾符。最常用的修飾符有：“=”，“&”。

1. "=" : Means that this operand is write-only for this instruction; the previous value is discarded and replaced by output data.
2. "&" : Means that this operand is an earlyclobber operand, which is modified before the instruction is finished using the input operands. Therefore, this operand may not lie in a register that is used as an input operand or as part of any memory address. An input operand can be tied to an earlyclobber operand if its only use as an input occurs before the early result is written.
3. “=”表示此操作數(shù)類型是只寫。之前的值會(huì)被輸出數(shù)據(jù)值替代。
4. “&”表示此操作數(shù)是一個(gè)很早更變的（earlyclobber）操作數(shù)。在指令執(zhí)行過程中，輸出操作數(shù)產(chǎn)生之前，輸入操作數(shù)還未使用完成，所以輸出操作數(shù)不能與該指令的任何輸入操作數(shù)公用同一寄存器。這個(gè)聲明就為防止這種合并寄存器的優(yōu)化。因此，這個(gè)輸入操作數(shù)可能沒有被保存到寄存器。
   

   The list and explanation of constraints is by no means complete. Examples can give a better understanding of the use and usage of inline asm. In the next section we’ll see some examples, there we’ll find more about clobber-lists and constraints.

   上邊對(duì)限制符的解釋絕不完全，下邊的例子可以讓我們更好的理解嵌入?yún)R編的用法。下邊一節(jié)我們將看一些例子，那里我們將遇到更多的colbber list和限制符。

7. Some Useful Recipes.

Now we have covered the basic theory about GCC inline assembly, now we shall concentrate on some simple examples. It is always handy to write inlineasm functions as MACRO’s. We can see many asm functions in the kernel code.(/usr/src/linux/include/asm/*.h).

我們已經(jīng)接觸過內(nèi)嵌匯編的基本理論。現(xiàn)在我們專注幾個(gè)例子。使用內(nèi)嵌匯編來定義宏是非常精妙的，我們經(jīng)?？梢栽趦?nèi)核代碼中看到。

1. First we start with a simple example. We’ll write a program to add two numbers.

   首先，我們寫個(gè)小程序，使兩個(gè)數(shù)做加法。
   

   ---

   1. int main(void)  
   2. {  
   3.         int foo = 10, bar = 15;  
   4.         __asm__ __volatile__("addl  %%ebx,%%eax"  
   5.                              :"=a"(foo)  
   6.                              :"a"(foo), "b"(bar)  
   7.                              );  
   8.         printf("foo+bar=%d\n", foo);  
   9.         return 0;  
   10. }  

   ---

   Here we insist GCC to store foo in %eax, bar in %ebx and we also want the result in %eax. The ’=’ sign shows that it is an output register. Now we can add an integer to a variable in some other way.

   這里我們指定GCC使用eax寄存器來存儲(chǔ)foo，bar存放在ebx寄存器，并且結(jié)果存放到eax中。這個(gè)“=”表示這是輸出結(jié)果的寄存器。接下來，我們用其他方法把一個(gè)整數(shù)存放進(jìn)一個(gè)變量中。
   

   ---

   1. __asm__ __volatile__(  
   2.                      "   lock       ;\n"  
   3.                      "   addl %1,%0 ;\n"  
   4.                      : "=m"  (my_var)  
   5.                      : "ir"  (my_int), "m" (my_var)  
   6.                      :                                 /* no clobber-list */  
   7.                      );  

   ---

   This is an atomic addition. We can remove the instruction ’lock’ to remove the atomicity. In the output field, "=m" says that my_var is an output and it is in memory. Similarly, "ir" says that, my_int is an integer and should reside in some register (recall the table we saw above). No registers are in the clobber list.

   這是一個(gè)（atomic addition）。我們可以去掉‘lock’來去除這個(gè)(atomicity)。在輸出區(qū)域，“=m”是說my_var是輸出操作數(shù)，并且它在內(nèi)存里?！癷r”是說my_int是一個(gè)整數(shù)，并且會(huì)選擇一個(gè)通用寄存器存放它。沒有寄存器在clobber list。
   

2. Now we’ll perform some action on some registers/variables and compare the value.

   現(xiàn)在我們實(shí)現(xiàn)一些操作，使用寄存器/變量，并比較他們的值。
   

   ---

   1. __asm__ __volatile__(  "decl %0; sete %1"  
   2.                      : "=m" (my_var), "=q" (cond)  
   3.                      : "m" (my_var)   
   4.                      : "memory"  
   5.                      );  

   ---

   Here, the value of my_var is decremented by one and if the resulting value is 0then, the variable cond is set. We can add atomicity by adding an instruction "lock;\n\t"as the first instruction in assembler template.

   In a similar way we can use "incl %0" instead of "decl %0", so as to increment my_var.

   Points to note here are that (i) my_var is a variable residing in memory. (ii) cond is in any of the registers eax, ebx, ecx and edx. The constraint "=q" guarantees it. (iii) And we can see that memory is there in the clobber list. ie, the code is changing the contents of memory.

   這里，my_var的值遞減到1，如果結(jié)果值為0。那么，cond就確定了。

   要點(diǎn)：1.my_var存在內(nèi)存中。2.cond被“=q”限制，所以它占用 eax，ebx，ecx，edx中的一個(gè)。3.memory在clobber list中，即，代碼改變了內(nèi)存。
   

3. How to set/clear a bit in a register? As next recipe, we are going to see it.

   怎么設(shè)置/清除寄存器的一位？下個(gè)例子：
   

   ---

   1. __asm__ __volatile__(   "btsl %1,%0"  
   2.                       : "=m" (ADDR)  
   3.                       : "Ir" (pos)  
   4.                       : "cc"  
   5.                       );  

   ---

   Here, the bit at the position ’pos’ of variable at ADDR ( a memory variable ) is set to1We can use ’btrl’ for ’btsl’ to clear the bit. The constraint "Ir" of pos says that, pos is in a register, and it’s value ranges from 0-31 (x86 dependant constraint). ie, we can set/clear any bit from 0th to 31st of the variable at ADDR. As the condition codes will be changed, we are adding "cc" to clobberlist.

   內(nèi)存變量ADDR的'pos'字位被置1。我們可以使用‘btrl’指令來清除這位。限制符“Ir”表示pos存放到寄存器內(nèi)，并且pos的范圍是0～31（x86專用限制符，上邊有提及）。隨著條件代碼的改變，我們把“cc”加入到clobber list。
   

4. Now we look at some more complicated but useful function. String copy.

   現(xiàn)在我們看實(shí)現(xiàn)String copy函數(shù)：
   

   ---

   1. static inline char * strcpy(char * dest,const char *src)  
   2. {  
   3. int d0, d1, d2;  
   4. __asm__ __volatile__(  "1:\tlodsb\n\t"  
   5.                        "stosb\n\t"  
   6.                        "testb %%al,%%al\n\t"  
   7.                        "jne 1b"  
   8.                      : "=&S" (d0), "=&D" (d1), "=&a" (d2)  
   9.                      : "0" (src),"1" (dest)   
   10.                      : "memory");  
   11. return dest;  
   12. }  

   ---

   The source address is stored in esi, destination in edi, and then starts the copy, when we reach at 0, copying is complete. Constraints "&S", "&D", "&a"say that the registers esi, edi and eax are early clobber registers, ie, their contents willchange before the completion of the function. Here also it’s clear that why memory is in clobberlist.

   We can see a similar function which moves a block of double words. Notice that the function is declared as a macro.

   源地址存放在esi中，目的地址在edi，接下來開始拷貝。當(dāng)?shù)竭_(dá)0時(shí)，程序完成。限制符“&S”，“&D”，“&a”分別指定esi，edi，eax，并且他們是早期改變的寄存器，即，他們的內(nèi)容在程序結(jié)束前，就會(huì)有變化。同樣memroy出現(xiàn)在clobber list。下例，類似的功能，移動(dòng)兩個(gè)字節(jié)的內(nèi)存塊，注意，它是以宏的方式實(shí)現(xiàn)的。
   

   
   

   ---

   1. #define mov_blk(src, dest, numwords) \  
   2. __asm__ __volatile__ (                                          \  
   3.                        "cld\n\t"                                \  
   4.                        "rep\n\t"                                \  
   5.                        "movsl"                                  \  
   6.                        :                                        \  
   7.                        : "S" (src), "D" (dest), "c" (numwords)  \  
   8.                        : "%ecx", "%esi", "%edi"                 \  
   9.                        )  

   ---

   Here we have no outputs, so the changes that happen to the contents of the registers ecx, esi and edi are side effects of the block movement. So we have to add them to the clobber list.

   這里沒有輸出，使用兩個(gè)連續(xù)的：：。ecx，esi，edi的變化實(shí)現(xiàn)內(nèi)存塊搬移。所以，把他們也加到clobber list。
   

5. In Linux, system calls are implemented using GCC inline assembly. Let us look how a system call is implemented.All the system calls are written as macros (linux/unistd.h). For example, a system call with three arguments is defined as a macro as shown below.

   Linux中，系統(tǒng)調(diào)用用內(nèi)嵌匯編實(shí)現(xiàn)。我們一起看看系統(tǒng)調(diào)用怎樣實(shí)現(xiàn)的。所有的系統(tǒng)調(diào)用都用匯編書寫。例如，系統(tǒng)調(diào)用3個(gè)參數(shù)，被定義成如下宏：
   

   ---

   1. #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \  
   2. type name(type1 arg1,type2 arg2,type3 arg3) \  
   3. { \  
   4. long __res; \  
   5. __asm__ volatile (  "int $0x80" \  
   6.                   : "=a" (__res) \  
   7.                   : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \  
   8.                     "d" ((long)(arg3))); \  
   9. __syscall_return(type,__res); \  
   10. }  

   ---

   
   Whenever a system call with three arguments is made, the macro shown above is used to make the call.The syscall number is placed in eax, then each parameters in ebx, ecx, edx. And finally "int 0x80" is the instruction which makes the system call work. The return value can be collected from eax.

   每當(dāng)系統(tǒng)調(diào)用一個(gè)3參數(shù)的函數(shù)時(shí)，就使用上邊這個(gè)宏來調(diào)用。系統(tǒng)調(diào)用的名稱name被放置在eax，其后的參數(shù)分別占用ebx，ecx，edx。最后“int 0x80”這條指令實(shí)現(xiàn)了調(diào)用，而且返回值存入eax內(nèi)。
   

   Every system calls are implemented in a similar way. Exit is a single parameter syscall and let’s see how it’s code will look like. It is as shown below.

   每個(gè)系統(tǒng)調(diào)用的實(shí)現(xiàn)都相似，Exit（）系統(tǒng)函數(shù)只有一個(gè)參數(shù)，我們來看看它的代碼長什么樣子。如下：
   

   ---

   1. {  
   2.         asm("movl $1,%%eax;         /* SYS_exit is 1 */  
   3.              xorl %%ebx,%%ebx;      /* Argument is in ebx, it is 0 */  
   4.              int  $0x80"            /* Enter kernel mode */  
   5.              );  
   6. }  

   ---

   The number of exit is "1" and here, it’s parameter is 0. So we arrange eax to contain 1 and ebx to contain 0 and byint $0x80, theexit(0) is executed. This is how exit works.

   exit的編號(hào)是1，它的參數(shù)是0。所以我們安排eax存放1，ebx存放2，然后指令“int $0x80”，exit（0）就執(zhí)行了。這就是它的工作方式。
   

8. Concluding Remarks.

This document has gone through the basics of GCC Inline Assembly. Once you have understood the basic concept it is not difficult to take steps by your own. We saw some examples which are helpful in understanding the frequently used features of GCC Inline Assembly.

GCC Inlining is a vast subject and this article is by no means complete. More details about the syntax’s we discussed about is available in the official documentation for GNU Assembler. Similarly, for a complete list of theconstraints refer to the official documentation of GCC.

And of-course, the Linux kernel use GCC Inline in a large scale. So we can find many examples of various kinds in the kernel sources. They can help us a lot.

If you have found any glaring typos, or outdated info in thisdocument, please let us know.

這個(gè)文檔縱覽了GCC內(nèi)嵌匯編的基本內(nèi)容。一旦你理解了這些基本概念，那麼修行靠個(gè)人。

GCC內(nèi)嵌匯編是一個(gè)巨大的工程，并且這樣的藝術(shù)之作絕不會(huì)完成。更多細(xì)節(jié)請(qǐng)參見GNU Assembler官方文檔。

當(dāng)然，Linux大規(guī)模使用了GCC內(nèi)嵌匯編，所以我們從中可以找到大量的例子。她們會(huì)給我們很多幫助。

請(qǐng)留言，我將立刻改正翻譯不妥之處，以免誤導(dǎo)讀者，為了鍛煉自己閱讀能力，我才干了這事兒。thanks a lot～

:-）