at&彙編

 from: http://blog.csdn.net/ehui928/article/details/1011329

AT&T彙編語言語法

分類：  AssemblyLanguage2006-08-02 16:52 2018人閱讀  評論(2)  收藏  舉報

彙編 語言 at&t gcc output input

0.3.1 Overview 

 

開發一個OS，儘管絕大部分代碼只須要用C/C++等高級語言就能夠了，但至少和硬件相關部分的代碼須要使用匯編語言，另外，因爲啓動部分的代碼有大小限制，使用精練的彙編能夠縮小目標代碼的Size。另外，對於某些須要被常常調用的代碼，使用匯編來寫能夠提升性能。因此咱們必須瞭解彙編語言，即便你有可能並不喜歡它。

 

若是你是計算機專業的話，在大學裏你應該學習過Intel格式的8086/80386彙編，這裏就再也不討論。若是咱們選擇的OS開發工具是GCC以及GAS的話，就必須瞭解AT&T彙編語言語法，由於GCC/GAS只支持這種彙編語法。

 

本書不會去討論8086/80386的彙編編程，這類的書籍不少，你能夠參考它們。這裏只會討論AT&T的彙編語法，以及GCC的內嵌彙編語法。

 

 

 

0.3.2 Syntax 

1.寄存器引用

引用寄存器要在寄存器號前加百分號%,如「movl %eax, %ebx」。

80386有以下寄存器：

• 8個32-bit寄存器 %eax，%ebx，%ecx，%edx，%edi，%esi，%ebp，%esp；
• 8個16-bit寄存器，它們事實上是上面8個32-bit寄存器的低16位：%ax，%bx，%cx，%dx，%di，%si，%bp，%sp；
• 8個8-bit寄存器：%ah，%al，%bh，%bl，%ch，%cl，%dh，%dl。它們事實上是寄存器%ax，%bx，%cx，%dx的高8位和低8位；
• 6個段寄存器：%cs(code)，%ds(data)，%ss(stack), %es，%fs，%gs；
• 3個控制寄存器：%cr0，%cr2，%cr3；
• 6個debug寄存器：%db0，%db1，%db2，%db3，%db6，%db7；
• 2個測試寄存器：%tr6，%tr7；
• 8個浮點寄存器棧：%st(0)，%st(1)，%st(2)，%st(3)，%st(4)，%st(5)，%st(6)，%st(7)。

2. 操做數順序

操做數排列是從源（左）到目的（右），如「movl %eax(源）, %ebx(目的）」

3. 當即數

使用當即數，要在數前面加符號$, 如「movl $0x04, %ebx」

或者：

para = 0x04

movl $para, %ebx

指令執行的結果是將當即數04h裝入寄存器ebx。

4. 符號常數

符號常數直接引用 如

value: .long 0x12a3f2de

movl value , %ebx

指令執行的結果是將常數0x12a3f2de裝入寄存器ebx。

引用符號地址在符號前加符號$, 如「movl $value, % ebx」則是將符號value的地址裝入寄存器ebx。

5. 操做數的長度

操做數的長度用加在指令後的符號表示b(byte, 8-bit), w(word, 16-bits), l(long, 32-bits)，如「movb %al, %bl」，「movw %ax, %bx」，「movl %eax, %ebx 」。

若是沒有指定操做數長度的話，編譯器將按照目標操做數的長度來設置。好比指令「mov %ax, %bx」，因爲目標操做數bx的長度爲word，那麼編譯器將把此指令等同於「movw %ax, %bx」。一樣道理，指令「mov $4, %ebx」等同於指令「movl $4, %ebx」，「push %al」等同於「pushb %al」。對於沒有指定操做數長度，但編譯器又沒法猜想的指令，編譯器將會報錯，好比指令「push $4」。

6. 符號擴展和零擴展指令

絕大多數面向80386的AT&T彙編指令與Intel格式的彙編指令都是相同的，符號擴展指令和零擴展指令則是僅有的不一樣格式指令。

符號擴展指令和零擴展指令須要指定源操做數長度和目的操做數長度，即便在某些指令中這些操做數是隱含的。

在AT&T語法中，符號擴展和零擴展指令的格式爲，基本部分"movs"和"movz"（對應Intel語法的movsx和movzx），後面跟上源操做數長度和目的操做數長度。movsbl意味着movs （from）byte （to）long；movbw意味着movs （from）byte （to）word；movswl意味着movs （from）word （to）long。對於movz指令也同樣。好比指令「movsbl %al, %edx」意味着將al寄存器的內容進行符號擴展後放置到edx寄存器中。

其它的Intel格式的符號擴展指令還有：

• cbw -- sign-extend byte in %al to word in %ax；
• cwde -- sign-extend word in %ax to long in %eax；
• cwd -- sign-extend word in %ax to long in %dx:%ax；
• cdq -- sign-extend dword in %eax to quad in %edx:%eax；

對應的AT&T語法的指令爲cbtw，cwtl，cwtd，cltd。

7. 調用和跳轉指令

段內調用和跳轉指令爲"call"，"ret"和"jmp"，段間調用和跳轉指令爲"lcall"，"lret"和"ljmp"。

段間調用和跳轉指令的格式爲「lcall/ljmp $SECTION, $OFFSET」，而段間返回指令則爲「lret $STACK-ADJUST」。

8. 前綴

操做碼前綴被用在下列的狀況：

• 字符串重複操做指令(rep,repne)；
• 指定被操做的段(cs,ds,ss,es,fs,gs)；
• 進行總線加鎖(lock)；
• 指定地址和操做的大小(data16,addr16)；

在AT&T彙編語法中，操做碼前綴一般被單獨放在一行，後面不跟任何操做數。例如，對於重複scas指令，其寫法爲：

             repne
             scas

上述操做碼前綴的意義和用法以下：

• 指定被操做的段前綴爲cs,ds,ss,es,fs,和gs。在AT&T語法中，只須要按照section:memory-operand的格式就指定了相應的段前綴。好比：lcall %cs:realmode_swtch
• 操做數／地址大小前綴是「data16」和"addr16"，它們被用來在32-bit操做數／地址代碼中指定16-bit的操做數／地址。
• 總線加鎖前綴「lock」，它是爲了在多處理器環境中，保證在當前指令執行期間禁止一切中斷。這個前綴僅僅對ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG,DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD,XCHG指令有效，若是將Lock前綴用在其它指令以前，將會引發異常。
• 字符串重複操做前綴"rep","repe","repne"用來讓字符串操做重複「%ecx」次。
  

9. 內存引用

Intel語法的間接內存引用的格式爲：

section:[base+index*scale+displacement]

而在AT&T語法中對應的形式爲：

section:displacement(base,index,scale)

其中，base和index是任意的32-bit base和index寄存器。scale能夠取值1，2，4，8。若是不指定scale值，則默認值爲1。section能夠指定任意的段寄存器做爲段前綴，默認的段寄存器在不一樣的狀況下不同。若是你在指令中指定了默認的段前綴，則編譯器在目標代碼中不會產生此段前綴代碼。

下面是一些例子：

-4(%ebp)：base=%ebp，displacement=-4，section沒有指定，因爲base＝%ebp，因此默認的section=%ss，index,scale沒有指定，則index爲0。

foo(,%eax,4)：index=%eax，scale=4，displacement=foo。其它域沒有指定。這裏默認的section=%ds。

foo(,1)：這個表達式引用的是指針foo指向的地址所存放的值。注意這個表達式中沒有base和index，而且只有一個逗號，這是一種異常語法，但卻合法。

%gs:foo：這個表達式引用的是放置於%gs段裏變量foo的值。

若是call和jump操做在操做數前指定前綴「*」，則表示是一個絕對地址調用/跳轉，也就是說jmp/call指令指定的是一個絕對地址。若是沒有指定"*"，則操做數是一個相對地址。

任何指令若是其操做數是一個內存操做，則指令必須指定它的操做尺寸(byte,word,long），也就是說必須帶有指令後綴(b,w,l)。

 

 

 

 

0.3.3 GCC Inline ASM

GCC支持在C/C++代碼中嵌入彙編代碼，這些彙編代碼被稱做GCC Inline ASM——GCC內聯彙編。這是一個很是有用的功能，有利於咱們將一些C/C++語法沒法表達的指令直接潛入C/C++代碼中，另外也容許咱們直接寫C/C++代碼中使用匯編編寫簡潔高效的代碼。

1.基本內聯彙編

GCC中基本的內聯彙編很是易懂，咱們先來看兩個簡單的例子：

__asm__("movl %esp,%eax");  // 看起來很熟悉吧！

或者是

__asm__("
   movl $1,%eax  // SYS_exit
   xor %ebx,%ebx
   int $0x80
 ");

或

__asm__(
   "movl $1,%eax/r/t" /
   "xor %ebx,%ebx/r/t" /
   "int $0x80" /
   );

基本內聯彙編的格式是

__asm__ __volatile__("Instruction List");

一、__asm__

__asm__是GCC關鍵字asm的宏定義：

#define __asm__ asm

__asm__或asm用來聲明一個內聯彙編表達式，因此任何一個內聯彙編表達式都是以它開頭的，是必不可少的。

二、Instruction List

Instruction List是彙編指令序列。它能夠是空的，好比：__asm__ __volatile__(""); 或__asm__ ("");都是徹底合法的內聯彙編表達式，只不過這兩條語句沒有什麼意義。但並不是全部Instruction List爲空的內聯彙編表達式都是沒有意義的，好比：__asm__ ("":::"memory"); 就很是有意義，它向GCC聲明：「我對內存做了改動」，GCC在編譯的時候，會將此因素考慮進去。

咱們看一看下面這個例子：

$ cat example1.c

int main(int __argc, char* __argv[])  
{                                     
        int* __p = (int*)__argc;      
                                      
        (*__p) = 9999;                
                                      
        //__asm__("":::"memory");       
                                      
        if((*__p) == 9999)            
                return 5;             
                                      
        return (*__p);                
}

在這段代碼中，那條內聯彙編是被註釋掉的。在這條內聯彙編以前，內存指針__p所指向的內存被賦值爲9999，隨即在內聯彙編以後，一條if語句判斷__p所指向的內存與9999是否相等。很明顯，它們是相等的。GCC在優化編譯的時候可以很聰明的發現這一點。咱們使用下面的命令行對其進行編譯：

$ gcc -O -S example1.c

選項-O表示優化編譯，咱們還能夠指定優化等級，好比-O2表示優化等級爲2；選項-S表示將C/C++源文件編譯爲彙編文件，文件名和C/C++文件同樣，只不過擴展名由.c變爲.s。

咱們來查看一下被放在example1.s中的編譯結果，咱們這裏僅僅列出了使用gcc 2.96在redhat 7.3上編譯後的相關函數部分彙編代碼。爲了保持清晰性，無關的其它代碼未被列出。

$ cat example1.s

main:                         
        pushl   %ebp          
        movl    %esp, %ebp    
        movl    8(%ebp), %eax     # int* __p = (int*)__argc
        movl    $9999, (%eax)      # (*__p) = 9999 
        movl    $5, %eax              # return 5
        popl    %ebp          
        ret

參照一下C源碼和編譯出的彙編代碼，咱們會發現彙編代碼中，沒有if語句相關的代碼，而是在賦值語句(*__p)=9999後直接return 5；這是由於GCC認爲在(*__p)被賦值以後，在if語句以前沒有任何改變(*__p)內容的操做，因此那條if語句的判斷條件(*__p) == 9999確定是爲true的，因此GCC就再也不生成相關代碼，而是直接根據爲true的條件生成return 5的彙編代碼（GCC使用eax做爲保存返回值的寄存器）。

咱們如今將example1.c中內聯彙編的註釋去掉，從新編譯，而後看一下相關的編譯結果。

$ gcc -O -S example1.c

$ cat example1.s

main:                          
        pushl   %ebp           
        movl    %esp, %ebp     
        movl    8(%ebp), %eax   # int* __p = (int*)__argc
        movl    $9999, (%eax)    # (*__p) = 9999
#APP                          

                                               # __asm__("":::"memory")
#NO_APP
        cmpl    $9999, (%eax)    # (*__p) == 9999 ?
        jne     .L3                        # false   
        movl    $5, %eax            # true, return 5 
        jmp     .L2            
        .p2align 2             
.L3:                           
        movl    (%eax), %eax   
.L2:                           
        popl    %ebp           
        ret

因爲內聯彙編語句__asm__("":::"memory")向GCC聲明，在此內聯彙編語句出現的位置內存內容可能了改變，因此GCC在編譯時就不能像剛纔那樣處理。此次，GCC老老實實的將if語句生成了彙編代碼。

可能有人會質疑：爲何要使用__asm__("":::"memory")向GCC聲明內存發生了變化？明明「Instruction List」是空的，沒有任何對內存的操做，這樣作只會增長GCC生成彙編代碼的數量。

確實，那條內聯彙編語句沒有對內存做任何操做，事實上它確實什麼都沒有作。但影響內存內容的不只僅是你當前正在運行的程序。好比，若是你如今正在操做的內存是一塊內存映射，映射的內容是外圍I/O設備寄存器。那麼操做這塊內存的就不只僅是當前的程序，I/O設備也會去操做這塊內存。既然二者都會去操做同一塊內存，那麼任何一方在任什麼時候候都不能對這塊內存的內容想固然。因此當你使用高級語言C/C++寫這類程序的時候，你必須讓編譯器也可以明白這一點，畢竟高級語言最終要被編譯爲彙編代碼。

你可能已經注意到了，此次輸出的彙編結果中，有兩個符號：#APP和#NO_APP，GCC將內聯彙編語句中"Instruction List"所列出的指令放在#APP和#NO_APP之間，因爲__asm__("":::"memory")中「Instruction List」爲空，因此#APP和#NO_APP中間也沒有任何內容。但咱們之後的例子會更加清楚的表現這一點。

關於爲何內聯彙編__asm__("":::"memory")是一條聲明內存改變的語句，咱們後面會詳細討論。

剛纔咱們花了大量的內容來討論"Instruction List"爲空是的狀況，但在實際的編程中，"Instruction List"絕大多數狀況下都不是空的。它能夠有1條或任意多條彙編指令。

當在"Instruction List"中有多條指令的時候，你能夠在一對引號中列出所有指令，也能夠將一條或幾條指令放在一對引號中，全部指令放在多對引號中。若是是前者，你能夠將每一條指令放在一行，若是要將多條指令放在一行，則必須用分號（；）或換行符（/n，大多數狀況下/n後還要跟一個/t，其中/n是爲了換行，/t是爲了空出一個tab寬度的空格）將它們分開。好比：

 __asm__("movl %eax, %ebx    
                   sti                
                   popl %edi          
                   subl %ecx, %ebx");

 __asm__("movl %eax, %ebx; sti         
                   popl %edi; subl %ecx, %ebx");

 __asm__("movl %eax, %ebx; sti/n/t popl %edi
                   subl %ecx, %ebx");

都是合法的寫法。若是你將指令放在多對引號中，則除了最後一對引號以外，前面的全部引號裏的最後一條指令以後都要有一個分號(；)或(/n)或(/n/t)。好比：

 __asm__("movl %eax, %ebx    
                    sti/n"                
                   "popl %edi;"          
                   "subl %ecx, %ebx");

 __asm__("movl %eax, %ebx; sti/n/t"         
                 "popl %edi; subl %ecx, %ebx");

 __asm__("movl %eax, %ebx; sti/n/t popl %edi/n"
                 "subl %ecx, %ebx");

__asm__("movl %eax, %ebx; sti/n/t popl %edi;" "subl %ecx, %ebx");

都是合法的。

上述原則能夠歸結爲：

• 任意兩個指令間要麼被分號(；)分開，要麼被放在兩行；
• 放在兩行的方法既能夠從經過/n的方法來實現，也能夠真正的放在兩行；
• 可使用1對或多對引號，每1對引號裏能夠聽任一多條指令，全部的指令都要被放到引號中。

在基本內聯彙編中，「Instruction List」的書寫的格式和你直接在彙編文件中寫非內聯彙編沒有什麼不一樣，你能夠在其中定義Label，定義對齊(.align n )，定義段(.section name )。例如：

 __asm__(".align 2/n/t"         
                 "movl %eax, %ebx/n/t"  
                 "test %ebx, %ecx/n/t"  
                 "jne error/n/t"        
                 "sti/n/t"              
                 "error: popl %edi/n/t" 
                 "subl %ecx, %ebx");

上面例子的格式是Linux內聯代碼經常使用的格式，很是整齊。也建議你們都使用這種格式來寫內聯彙編代碼。

三、__volatile__

__volatile__是GCC關鍵字volatile的宏定義：

#define __volatile__ volatile

__volatile__或volatile是可選的，你能夠用它也能夠不用它。若是你用了它，則是向GCC聲明「不要動我所寫的Instruction List，我須要原封不動的保留每一條指令」，不然當你使用了優化選項(-O)進行編譯時，GCC將會根據本身的判斷決定是否將這個內聯彙編表達式中的指令優化掉。

那麼GCC判斷的原則是什麼？我不知道（若是有哪位朋友清楚的話，請告訴我）。我試驗了一下，發現一條內聯彙編語句若是是基本內聯彙編的話（即只有「Instruction List」，沒有Input/Output/Clobber的內聯彙編，咱們後面將會討論這一點），不管你是否使用__volatile__來修飾，GCC 2.96在優化編譯時，都會原封不動的保留內聯彙編中的「Instruction List」。但或許個人試驗的例子並不充分，因此這一點並不可以獲得保證。

爲了保險起見，若是你不想讓GCC的優化影響你的內聯彙編代碼，你最好在前面都加上__volatile__，而不要依賴於編譯器的原則，由於即便你很是瞭解當前編譯器的優化原則，你也沒法保證這種原則未來不會發生變化。而__volatile__的含義倒是恆定的。

二、帶有C/C++表達式的內聯彙編

GCC容許你經過C/C++表達式指定內聯彙編中"Instrcuction List"中指令的輸入和輸出，你甚至能夠不關心到底使用哪一個寄存器被使用，徹底靠GCC來安排和指定。這一點可讓程序員避免去考慮有限的寄存器的使用，也能夠提升目標代碼的效率。

咱們先來看幾個例子：

__asm__ (" " : : : "memory" );  // 前面提到的

__asm__ ("mov %%eax, %%ebx" : "=b"(rv) : "a"(foo) : "eax", "ebx");

__asm__ __volatile__("lidt %0": "=m" (idt_descr));

__asm__("subl %2,%0/n/t"
                "sbbl %3,%1"
                : "=a" (endlow), "=d" (endhigh)
                : "g" (startlow), "g" (starthigh), "0" (endlow), "1" (endhigh));

怎麼樣，有點印象了吧，是否是也有點暈？不要緊，下面討論完以後你就不會再暈了。（固然，也有可能更暈^_^）。討論開始——

帶有C/C++表達式的內聯彙編格式爲：

__asm__　__volatile__("Instruction List" : Output : Input : Clobber/Modify);

從中咱們能夠看出它和基本內聯彙編的不一樣之處在於：它多了3個部分(Input，Output，Clobber/Modify)。在括號中的4個部分經過冒號(:)分開。

這4個部分都不是必須的，任何一個部分均可覺得空，其規則爲：

• 若是Clobber/Modify爲空，則其前面的冒號(:)必須省略。好比__asm__("mov %%eax, %%ebx" : "=b"(foo) : "a"(inp) : )就是非法的寫法；而__asm__("mov %%eax, %%ebx" : "=b"(foo) : "a"(inp) )則是正確的。
• 若是Instruction List爲空，則Input，Output，Clobber/Modify能夠不爲空，也能夠爲空。好比__asm__ ( " " : : : "memory" );和__asm__(" " : : );都是合法的寫法。
• 若是Output，Input，Clobber/Modify都爲空，Output，Input以前的冒號(:)既能夠省略，也能夠不省略。若是都省略，則此彙編退化爲一個基本內聯彙編，不然，仍然是一個帶有C/C++表達式的內聯彙編，此時"Instruction List"中的寄存器寫法要遵照相關規定，好比寄存器前必須使用兩個百分號(%%)，而不是像基本彙編格式同樣在寄存器前只使用一個百分號(%)。好比__asm__( " mov %%eax, %%ebx" : : )；__asm__( " mov %%eax, %%ebx" : )和__asm__( " mov %eax, %ebx" )都是正確的寫法，而__asm__( " mov %eax, %ebx" : : )；__asm__( " mov %eax, %ebx" : )和__asm__( " mov %%eax, %%ebx" )都是錯誤的寫法。
• 若是Input，Clobber/Modify爲空，但Output不爲空，Input前的冒號(:)既能夠省略，也能夠不省略。好比__asm__( " mov %%eax, %%ebx" : "=b"(foo) : )；__asm__( " mov %%eax, %%ebx" : "=b"(foo) )都是正確的。
• 若是後面的部分不爲空，而前面的部分爲空，則前面的冒號(:)都必須保留，不然沒法說明不爲空的部分到底是第幾部分。好比， Clobber/Modify，Output爲空，而Input不爲空，則Clobber/Modify前的冒號必須省略（前面的規則），而Output前的冒號必須爲保留。若是Clobber/Modify不爲空，而Input和Output都爲空，則Input和Output前的冒號都必須保留。好比__asm__( " mov %%eax, %%ebx" : : "a"(foo) )和__asm__( " mov %%eax, %%ebx" : : : "ebx" )。

從上面的規則能夠看到另一個事實，區分一個內聯彙編是基本格式的仍是帶有C/C++表達式格式的，其規則在於在"Instruction List"後是否有冒號(:)的存在，若是沒有則是基本格式的，不然，則是帶有C/C++表達式格式的。

兩種格式對寄存器語法的要求不一樣：基本格式要求寄存器前只能使用一個百分號(%)，這一點和非內聯彙編相同；而帶有C/C++表達式格式則要求寄存器前必須使用兩個百分號(%%)，其緣由咱們會在後面討論。

1. Output

Output用來指定當前內聯彙編語句的輸出。咱們看一看這個例子：

__asm__("movl %%cr0, %0": "=a" (cr0));

這個內聯彙編語句的輸出部分爲"=r"(cr0)，它是一個「操做表達式」，指定了一個輸出操做。咱們能夠很清楚得看到這個輸出操做由兩部分組成：括號括住的部分(cr0)和引號引住的部分"=a"。這兩部分都是每個輸出操做必不可少的。括號括住的部分是一個C/C++表達式，用來保存內聯彙編的一個輸出值，其操做就等於C/C++的相等賦值cr0 = output_value，所以，括號中的輸出表達式只能是C/C++的左值表達式，也就是說它只能是一個能夠合法的放在C/C++賦值操做中等號(=)左邊的表達式。那麼右值output_value從何而來呢？

答案是引號中的內容，被稱做「操做約束」（Operation Constraint），在這個例子中操做約束爲"=a"，它包含兩個約束：等號(=)和字母a，其中等號(=)說明括號中左值表達式cr0是一個Write-Only的，只可以被做爲當前內聯彙編的輸入，而不能做爲輸入。而字母a是寄存器EAX / AX / AL的簡寫，說明cr0的值要從eax寄存器中獲取，也就是說cr0 = eax，最終這一點被轉化成彙編指令就是movl %eax, address_of_cr0。如今你應該清楚了吧，操做約束中會給出：到底從哪一個寄存器傳遞值給cr0。

另外，須要特別說明的是，不少文檔都聲明，全部輸出操做的操做約束必須包含一個等號(=)，但GCC的文檔中卻很清楚的聲明，並不是如此。由於等號(=)約束說明當前的表達式是一個Write-Only的，但另外還有一個符號——加號(+)用來講明當前表達式是一個Read-Write的，若是一個操做約束中沒有給出這兩個符號中的任何一個，則說明當前表達式是Read-Only的。由於對於輸出操做來講，確定是必須是可寫的，而等號(=)和加號(+)都表示可寫，只不過加號(+)同時也表示是可讀的。因此對於一個輸出操做來講，其操做約束只須要有等號(=)或加號(+)中的任意一個就能夠了。

兩者的區別是：等號(=)表示當前操做表達式指定了一個純粹的輸出操做，而加號(+)則表示當前操做表達式不只僅只是一個輸出操做仍是一個輸入操做。但不管是等號(=)約束仍是加號(+)約束所約束的操做表達式都只能放在Output域中，而不能被用在Input域中。

另外，有些文檔聲明：儘管GCC文檔中提供了加號(+)約束，但在實際的編譯中通不過；我不知道老版本會怎麼樣，我在GCC 2.96中對加號(+)約束的使用很是正常。

咱們經過一個例子看一下，在一個輸出操做中使用等號(=)約束和加號(+)約束的不一樣。

$ cat example2.c

int main(int __argc, char* __argv[])                           
{                                                              
        int cr0 = 5;                                              
                                                               
        __asm__ __volatile__("movl %%cr0, %0":"=a" (cr0));     
                                                               
        return 0;                                              
}

$ gcc -S example2.c

$ cat example2.s

main:                         
        pushl   %ebp          
        movl    %esp, %ebp    
        subl    $4, %esp      
        movl    $5, -4(%ebp)     # cr0 = 5
#APP                          
        movl %cr0, %eax       
#NO_APP                       
        movl    %eax, %eax    
        movl    %eax, -4(%ebp)   # cr0 = %eax
        movl    $0, %eax      
        leave                 
        ret                   

這個例子是使用等號(=)約束的狀況，變量cr0被放在內存-4(%ebp)的位置，因此指令mov %eax, -4(%ebp)即表示將%eax的內容輸出到變量cr0中。

下面是使用加號(+)約束的狀況：

$ cat example3.c

int main(int __argc, char* __argv[])                           
{                                                              
        int cr0 = 5;                                              
                                                               
        __asm__ __volatile__("movl %%cr0, %0" : "+a" (cr0));     
                                                               
        return 0;                                              
}

$ gcc -S example3.c

$ cat example3.s

main:                            
        pushl   %ebp             
        movl    %esp, %ebp       
        subl    $4, %esp         
        movl    $5, -4(%ebp)        # cr0 = 5
        movl    -4(%ebp), %eax    # input ( %eax = cr0 )
#APP                             
        movl    %cr0, %eax
#NO_APP
        movl    %eax, -4(%ebp)    # output (cr0 = %eax )
        movl    $0, %eax
        leave
        ret

從編譯的結果能夠看出，當使用加號(+)約束的時候，cr0不只做爲輸出，還做爲輸入，所使用寄存器都是寄存器約束(字母a，表示使用eax寄存器)指定的。關於寄存器約束咱們後面討論。

在Output域中能夠有多個輸出操做表達式，多個操做表達式中間必須用逗號(,)分開。例如：

 __asm__(                           
        "movl   %%eax, %0 /n/t"              
        "pushl  %%ebx /n/t"                 
        "popl    %1 /n/t"                     
        "movl   %1, %2"                      
        : "+a"(cr0), "=b"(cr1), "=c"(cr2));

二、Input

Input域的內容用來指定當前內聯彙編語句的輸入。咱們看一看這個例子：

__asm__("movl %0, %%db7" : : "a" (cpu->db7));

例中Input域的內容爲一個表達式"a"[cpu->db7)，被稱做「輸入表達式」，用來表示一個對當前內聯彙編的輸入。

像輸出表達式同樣，一個輸入表達式也分爲兩部分：帶括號的部分(cpu->db7)和帶引號的部分"a"。這兩部分對於一個內聯彙編輸入表達式來講也是必不可少的。

括號中的表達式cpu->db7是一個C/C++語言的表達式，它沒必要是一個左值表達式，也就是說它不只能夠是放在C/C++賦值操做左邊的表達式，還能夠是放在C/C++賦值操做右邊的表達式。因此它能夠是一個變量，一個數字，還能夠是一個複雜的表達式（好比a+b/c*d）。好比上例能夠改成：__asm__("movl %0, %%db7" : : "a" (foo))，__asm__("movl %0, %%db7" : : "a" (0x1000))或__asm__("movl %0, %%db7" : : "a" (va*vb/vc))。

引號號中的部分是約束部分，和輸出表達式約束不一樣的是，它不容許指定加號(+)約束和等號(=)約束，也就是說它只能是默認的Read-Only的。約束中必須指定一個寄存器約束，例中的字母a表示當前輸入變量cpu->db7要經過寄存器eax輸入到當前內聯彙編中。

咱們看一個例子：

$ cat example4.c

int main(int __argc, char* __argv[])                         
{                                                            
        int cr0  = 5;                                        
                                                             
        __asm__ __volatile__("movl %0, %%cr0"::"a" (cr0));   
                                                             
        return 0;                                            
}

$ gcc -S example4.c

$ cat example4.s

main:                              
        pushl   %ebp               
        movl    %esp, %ebp         
        subl    $4, %esp           
        movl    $5, -4(%ebp)          # cr0 = 5       
        movl    -4(%ebp), %eax     # %eax = cr0
#APP                               
        movl    %eax, %cr0            
#NO_APP                            
        movl    $0, %eax           
        leave                      
        ret                        

咱們從編譯出的彙編代碼能夠看到，在"Instruction List"以前，GCC按照咱們的輸入約束"a"，將變量cr0的內容裝入了eax寄存器。

3. Operation Constraint

每個Input和Output表達式都必須指定本身的操做約束Operation Constraint，咱們這裏來討論在80386平臺上所可能使用的操做約束。

一、寄存器約束

當你當前的輸入或輸入須要藉助一個寄存器時，你須要爲其指定一個寄存器約束。你能夠直接指定一個寄存器的名字，好比：

__asm__ __volatile__("movl %0, %%cr0"::"eax" (cr0));

也能夠指定一個縮寫，好比：

__asm__ __volatile__("movl %0, %%cr0"::"a" (cr0));

若是你指定一個縮寫，好比字母a，則GCC將會根據當前操做表達式中C/C++表達式的寬度決定使用%eax，仍是%ax或%al。好比：

unsigned short __shrt;

__asm__ ("mov %0，%%bx" : : "a"(__shrt));

因爲變量__shrt是16-bit short類型，則編譯出來的彙編代碼中，則會讓此變量使用%ex寄存器。編譯結果爲：

       movw    -2(%ebp), %ax  # %ax = __shrt
#APP
        movl    %ax, %bx
#NO_APP

不管是Input，仍是Output操做表達式約束，均可以使用寄存器約束。

下表中列出了經常使用的寄存器約束的縮寫。

 

約束	Input/Output	意義
r	I,O	表示使用一個通用寄存器，由GCC在%eax/%ax/%al, %ebx/%bx/%bl, %ecx/%cx/%cl, %edx/%dx/%dl中選取一個GCC認爲合適的。
q	I,O	表示使用一個通用寄存器，和r的意義相同。
a	I,O	表示使用%eax / %ax / %al
b	I,O	表示使用%ebx / %bx / %bl
c	I,O	表示使用%ecx / %cx / %cl
d	I,O	表示使用%edx / %dx / %dl
D	I,O	表示使用%edi / %di
S	I,O	表示使用%esi / %si
f	I,O	表示使用浮點寄存器
t	I,O	表示使用第一個浮點寄存器
u	I,O	表示使用第二個浮點寄存器

 

二、內存約束

若是一個Input/Output操做表達式的C/C++表達式表現爲一個內存地址，不想借助於任何寄存器，則可使用內存約束。好比：

__asm__ ("lidt %0" : "=m"(__idt_addr)); 或 __asm__ ("lidt %0" : :"m"(__idt_addr));

咱們看一下它們分別被放在一個C源文件中，而後被GCC編譯後的結果：

$ cat example5.c

// 本例中，變量sh被做爲一個內存輸入

int main(int __argc, char* __argv[])               
{                                                  
         char* sh = (char*)&__argc;                
                                                   
        __asm__ __volatile__("lidt %0" : : "m" (sh)); 
                                                   
        return 0;                                  
} 

$ gcc -S example5.c

$ cat example5.s

main:                         
        pushl   %ebp          
        movl    %esp, %ebp    
        subl    $4, %esp      
        leal     8(%ebp), %eax 
        movl   %eax, -4(%ebp)  # sh = (char*) &__argc
#APP                          
        lidt      -4(%ebp)         
#NO_APP                       
        movl    $0, %eax      
        leave                 
        ret                   

$ cat example6.c

// 本例中，變量sh被做爲一個內存輸出

int main(int __argc, char* __argv[])               
{                                                  
         char* sh = (char*)&__argc;                
                                                   
        __asm__ __volatile__("lidt %0" : "=m" (sh)); 
                                                   
        return 0;                                  
}         

$ gcc -S example6.c

$ cat example6.s

main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $4, %esp
        leal     8(%ebp), %eax
        movl    %eax, -4(%ebp) # sh = (char*) &__argc
#APP
        lidt      -4(%ebp)
#NO_APP
        movl    $0, %eax
        leave
        ret
首先，你會注意到，在這兩個例子中，變量sh沒有藉助任何寄存器，而是直接參與了指令lidt的操做。

其次，經過仔細觀察，你會發現一個驚人的事實，兩個例子編譯出來的彙編代碼是同樣的！雖然，一個例子中變量sh做爲輸入，而另外一個例子中變量sh做爲輸出。這是怎麼回事？

原來，使用內存方式進行輸入輸出時，因爲不借助寄存器，因此GCC不會按照你的聲明對其做任何的輸入輸出處理。GCC只會直接拿來用，究竟對這個C/C++表達式而言是輸入仍是輸出，徹底依賴與你寫在"Instruction List"中的指令對其操做的指令。

因爲上例中，對其操做的指令爲lidt，lidt指令的操做數是一個輸入型的操做數，因此事實上對變量sh的操做是一個輸入操做，即便你把它放在Output域也不會改變這一點。因此，對此例而言，徹底符合語意的寫法應該是將sh放在Input域，儘管放在Output域也會有正確的執行結果。

因此，對於內存約束類型的操做表達式而言，放在Input域仍是放在Output域，對編譯結果是沒有任何影響的，由於原本咱們將一個操做表達式放在Input域或放在Output域是但願GCC能爲咱們自動經過寄存器將表達式的值輸入或輸出。既然對於內存約束類型的操做表達式來講，GCC不會自動爲它作任何事情，那麼放在哪兒也就無所謂了。但從程序員的角度而言，爲了加強代碼的可讀性，最好可以把它放在符合實際狀況的地方。

 

約束	Input/Output	意義
m	I,O	表示使用系統所支持的任何一種內存方式，不須要藉助寄存器

 

三、當即數約束

若是一個Input/Output操做表達式的C/C++表達式是一個數字常數，不想借助於任何寄存器，則可使用當即數約束。

因爲當即數在C/C++中只能做爲右值，因此對於使用當即數約束的表達式而言，只能放在Input域。

好比：__asm__ __volatile__("movl %0, %%eax" : : "i" (100) );

當即數約束很簡單，也很容易理解，咱們在這裏就再也不贅述。

 

約束	Input/Output	意義
i	I	表示輸入表達式是一個當即數(整數)，不須要藉助任何寄存器
F	I	表示輸入表達式是一個當即數(浮點數)，不須要藉助任何寄存器

 

四、通用約束

 

約束	Input/Output	意義
g	I,O	表示可使用通用寄存器，內存，當即數等任何一種處理方式。
0,1,2,3,4,5,6,7,8,9	I	表示和第n個操做表達式使用相同的寄存器/內存。

 

通用約束g是一個很是靈活的約束，當程序員認爲一個C/C++表達式在實際的操做中，究竟使用寄存器方式，仍是使用內存方式或當即數方式並沒有所謂時，或者程序員想實現一個靈活的模板，讓GCC能夠根據不一樣的C/C++表達式生成不一樣的訪問方式時，就可使用通用約束g。好比：

#define JUST_MOV(foo)  __asm__ ("movl %0, %%eax" : : "g"(foo))

JUST_MOV(100)和JUST_MOV(var)則會讓編譯器產生不一樣的代碼。

int main(int __argc, char* __argv[])    
{                                       
        JUST_MOV(100);                  
                                        
        return 0;                       
}                                      

編譯後生成的代碼爲：

main:                       
        pushl   %ebp        
        movl    %esp, %ebp  
#APP                        
        movl $100, %eax     
#NO_APP                     
        movl    $0, %eax    
        popl    %ebp        
        ret

很明顯這是當即數方式。而下一個例子：

int main(int __argc, char* __argv[])    
{                                       
        JUST_MOV(__argc);                  
                                        
        return 0;                       
}                                      

經編譯後生成的代碼爲：

main:                      
        pushl   %ebp       
        movl    %esp, %ebp 
#APP                       
        movl   8(%ebp), %eax 
#NO_APP                    
        movl    $0, %eax   
        popl     %ebp       
        ret               

這個例子是使用內存方式。

一個帶有C/C++表達式的內聯彙編，其操做表達式被按照被列出的順序編號，第一個是0，第2個是1，依次類推，GCC最多容許有10個操做表達式。好比：

 

 __asm__ ("popl %0 /n/t"
                         "movl %1, %%esi /n/t"
                         "movl %2, %%edi /n/t"
                         : "=a"(__out)
                         : "r" (__in1), "r" (__in2));

此例中，__out所在的Output操做表達式被編號爲0，"r"(__in1)被編號爲1，"r"(__in2)被編號爲2。

再如：

__asm__ ("movl %%eax, %%ebx" : : "a"(__in1), "b"(__in2));

此例中，"a"(__in1)被編號爲0，"b"(__in2)被編號爲1。

若是某個Input操做表達式使用數字0到9中的一個數字（假設爲1）做爲它的操做約束，則等於向GCC聲明：「我要使用和編號爲1的Output操做表達式相同的寄存器（若是Output操做表達式1使用的是寄存器），或相同的內存地址（若是Output操做表達式1使用的是內存）」。上面的描述包含兩個限定：數字0到數字9做爲操做約束只能用在Input操做表達式中，被指定的操做表達式（好比某個Input操做表達式使用數字1做爲約束，那麼被指定的就是編號爲1的操做表達式）只能是Output操做表達式。

因爲GCC規定最多隻能有10個Input/Output操做表達式，因此事實上數字9做爲操做約束永遠也用不到，由於Output操做表達式排在Input操做表達式的前面，那麼若是有一個Input操做表達式指定了數字9做爲操做約束的話，那麼說明Output操做表達式的數量已經至少爲10個了，那麼再加上這個Input操做表達式，則至少爲11個了，以及超出GCC的限制。

五、Modifier Characters（修飾符）

等號(=)和加號(+)用於對Output操做表達式的修飾，一個Output操做表達式要麼被等號(=)修飾，要麼被加號(+)修飾，兩者必居其一。使用等號(=)說明此Output操做表達式是Write-Only的，使用加號(+)說明此Output操做表達式是Read-Write的。它們必須被放在約束字符串的第一個字母。好比"a="(foo)是非法的，而"+g"(foo)則是合法的。

當使用加號(+)的時候，此Output表達式等價於使用等號(=)約束加上一個Input表達式。好比

__asm__ ("movl %0, %%eax; addl %%eax, %0" : "+b"(foo)) 等價於

__asm__ ("movl %1, %%eax; addl %%eax, %0" : "=b"(foo) : "b"(foo))

但若是使用後一種寫法，"Instruction List"中的別名也要相應的改動。關於別名，咱們後面會討論。

像等號(=)和加號(+)修飾符同樣，符號(&)也只能用於對Output操做表達式的修飾。當使用它進行修飾時，等於向GCC聲明："GCC不得爲任何Input操做表達式分配與此Output操做表達式相同的寄存器"。其緣由是&修飾符意味着被其修飾的Output操做表達式要在全部的Input操做表達式被輸入前輸出。咱們看下面這個例子：

int main(int __argc, char* __argv[])       
{                                          
        int __in1 = 8, __in2 = 4, __out = 3;     
                                           
        __asm__ ("popl %0 /n/t"
                         "movl %1, %%esi /n/t"
                         "movl %2, %%edi /n/t"
                         : "=a"(__out)
                         : "r" (__in1), "r" (__in2));
                                           
        return 0;                          
}                                          
此例中，%0對應的就是Output操做表達式，它被指定的寄存器是%eax，整個Instruction List的第一條指令popl %0，編譯後就成爲popl %eax，這時%eax的內容已經被修改，隨後在Instruction List後，GCC會經過movl %eax, address_of_out這條指令將%eax的內容放置到Output變量__out中。對於本例中的兩個Input操做表達式而言，它們的寄存器約束爲"r"，即要求GCC爲其指定合適的寄存器，而後在Instruction List以前將__in1和__in2的內容放入被選出的寄存器中，若是它們中的一個選擇了已經被__out指定的寄存器%eax，假如是__in1，那麼GCC在Instruction List以前會插入指令movl address_of_in1, %eax，那麼隨後popl %eax指令就修改了%eax的值，此時%eax中存放的已經不是Input變量__in1的值了，那麼隨後的movl %1, %%esi指令，將不會按照咱們的本意——即將__in1的值放入%esi中——而是將__out的值放入%esi中了。

下面就是本例的編譯結果，很明顯，GCC爲__in2選擇了和__out相同的寄存器%eax，這與咱們的初衷不符。

main:                               
        pushl   %ebp                
        movl    %esp, %ebp          
        subl    $12, %esp           
        movl    $8, -4(%ebp)        
        movl    $4, -8(%ebp)        
        movl    $3, -12(%ebp)       
        movl    -4(%ebp), %edx      # __in1使用寄存器%edx
        movl    -8(%ebp), %eax      # __in2使用寄存器%eax
#APP                                
        popl %eax                   
        movl %edx, %esi             
        movl %eax, %edi             
                                    
#NO_APP                             
        movl    %eax, %eax          
        movl    %eax, -12(%ebp)     # __out使用寄存器%eax
        movl    $0, %eax            
        leave                       
        ret                         
爲了不這種狀況，咱們必須向GCC聲明這一點，要求GCC爲全部的Input操做表達式指定別的寄存器，方法就是在Output操做表達式"=a"(__out)的操做約束中加入&約束，因爲GCC規定等號(=)約束必須放在第一個，因此咱們寫做"=&a"(__out)。下面是咱們將&約束加入以後編譯的結果：
main:                          
        pushl   %ebp           
        movl    %esp, %ebp     
        subl    $12, %esp      
        movl    $8, -4(%ebp)   
        movl    $4, -8(%ebp)   
        movl    $3, -12(%ebp)  
        movl    -4(%ebp), %edx    #__in1使用寄存器%edx
        movl    -8(%ebp), %eax 
        movl    %eax, %ecx         # __in2使用寄存器%ecx
#APP                           
        popl     %eax              
        movl    %edx, %esi        
        movl    %ecx, %edi        
                               
#NO_APP                        
        movl    %eax, %eax     
        movl    %eax, -12(%ebp)   #__out使用寄存器%eax
        movl    $0, %eax       
        leave                  
        ret                    
OK！這下好了，徹底與咱們的意圖吻合。

若是一個Output操做表達式的寄存器約束被指定爲某個寄存器，只有當至少存在一個Input操做表達式的寄存器約束爲可選約束時，（可選約束的意思是能夠從多個寄存器中選取一個，或使用非寄存器方式），好比"r"或"g"時，此Output操做表達式使用&修飾纔有意義。若是你爲全部的Input操做表達式指定了固定的寄存器，或使用內存/當即數約束，則此Output操做表達式使用&修飾沒有任何意義。好比：

__asm__ ("popl %0 /n/t"           
                 "movl %1, %%esi /n/t"    
                 "movl %2, %%edi /n/t"    
                 : "=&a"(__out)             
                 : "m" (__in1), "c" (__in2));

此例中的Output操做表達式徹底沒有必要使用&來修飾，由於__in1和__in2都被指定了固定的寄存器，或使用了內存方式，GCC無從選擇。

但若是你已經爲某個Output操做表達式指定了&修飾，並指定了某個固定的寄存器，你就不能再爲任何Input操做表達式指定這個寄存器，不然會出現編譯錯誤。好比：

__asm__ ("popl %0 /n/t"           
                 "movl %1, %%esi /n/t"    
                 "movl %2, %%edi /n/t"    
                 : "=&a"(__out)             
                 : "a" (__in1), "c" (__in2));

本例中，因爲__out已經指定了寄存器%eax，同時使用了符號&修飾，則再爲__in1指定寄存器%eax就是非法的。

反過來，你也能夠爲Output指定可選約束，好比"r","g"等，讓GCC爲其選擇到底使用哪一個寄存器，仍是使用內存方式，GCC在選擇的時候，會首先排除掉已經被Input操做表達式使用的全部寄存器，而後在剩下的寄存器中選擇，或乾脆使用內存方式。好比：

__asm__ ("popl %0 /n/t"           
                 "movl %1, %%esi /n/t"    
                 "movl %2, %%edi /n/t"    
                 : "=&r"(__out)             
                 : "a" (__in1), "c" (__in2));

本例中，因爲__out指定了約束"r"，即讓GCC爲其決定使用哪一格寄存器，而寄存器%eax和%ecx已經被__in1和__in2使用，那麼GCC在爲__out選擇的時候，只會在%ebx和%edx中選擇。

前3個修飾符只能用在Output操做表達式中，而百分號[%]修飾符偏偏相反，只能用在Input操做表達式中，用於向GCC聲明：「當前Input操做表達式中的C/C++表達式能夠和下一個Input操做表達式中的C/C++表達式互換」。這個修飾符號通常用於符合交換律運算，好比加(+)，乘(*)，與(&)，或(|)等等。咱們看一個例子：

int main(int __argc, char* __argv[])           
{                                              
        int __in1 = 8, __in2 = 4, __out = 3;         
                                               
        __asm__ ("addl %1, %0/n/t"             
                         : "=r"(__out)                   
                         : "%r" (__in1), "0" (__in2));     
                                               
        return 0;                              
}
在此例中，因爲指令是一個加法運算，至關於等式__out = __in1 + __in2，而它與等式__out = __in2 + __in1沒有什麼不一樣。因此使用百分號修飾，讓GCC知道__in1和__in2能夠互換，也就是說GCC能夠自動將本例的內聯彙編改變爲：

 

__asm__ ("addl %1, %0/n/t"
                  : "=r"(__out)
                  : "%r" (__in2), "0" (__in1));    

 

修飾符	Input/Output	意義
=	O	表示此Output操做表達式是Write-Only的
+	O	表示此Output操做表達式是Read-Write的
&	O	表示此Output操做表達式獨佔爲其指定的寄存器
%	I	表示此Input操做表達式中的C/C++表達式能夠和下一個Input操做表達式中的C/C++表達式互換

4. 佔位符

什麼叫佔位符？咱們看一看下面這個例子：

__asm__ ("addl %1, %0/n/t"
                  : "=a"(__out)
                  : "m" (__in1), "a" (__in2));

這個例子中的%0和%1就是佔位符。每個佔位符對應一個Input/Output操做表達式。咱們在以前已經提到，GCC規定一個內聯彙編語句最多能夠有10個Input/Output操做表達式，而後按照它們被列出的順序依次賦予編號0到9。對於佔位符中的數字而言，和這些編號是對應的。

 

因爲佔位符前面使用一個百分號(%)，爲了區別佔位符和寄存器，GCC規定在帶有C/C++表達式的內聯彙編中，"Instruction List"中直接寫出的寄存器前必須使用兩個百分號(%%)。

GCC對其進行編譯的時候，會將每個佔位符替換爲對應的Input/Output操做表達式所指定的寄存器/內存地址/當即數。好比在上例中，佔位符%0對應Output操做表達式"=a"(__out)，而"=a"(__out)指定的寄存器爲%eax，因此把佔位符%0替換爲%eax，佔位符%1對應Input操做表達式"m"(__in1)，而"m"(__in1)被指定爲內存操做，因此把佔位符%1替換爲變量__in1的內存地址。

也許有人認爲，在上面這個例子中，徹底能夠不使用%0，而是直接寫%%eax，就像這樣：

__asm__ ("addl %1, %%eax/n/t"
                  : "=a"(__out)
                  : "m" (__in1), "a" (__in2));

和上面使用佔位符%0沒有什麼不一樣，那麼使用佔位符%0就沒有什麼意義。確實，二者生成的代碼徹底相同，但這並不意味着這種狀況下佔位符沒有意義。由於若是不使用佔位符，那麼當有一天你想把變量__out的寄存器約束由a改成b時，那麼你也必須將addl指令中的%%eax改成%%ebx，也就是說你須要同時修改兩個地方，而若是你使用佔位符，你只須要修改一次就夠了。另外，若是你不使用佔位符，將不利於代碼的清晰性。在上例中，若是你使用佔位符，那麼你一眼就能夠得知，addl指令的第二個操做數內容最終會輸出到變量__out中；不然，若是你不用佔位符，而是直接將addl指令的第2個操做數寫爲%%eax，那麼你須要考慮一下才知道它最終須要輸出到變量__out中。這是佔位符最粗淺的意義。畢竟在這種狀況下，你徹底能夠不用。

但對於這些狀況來講，不用佔位符就徹底不行了：

首先，咱們看一看上例中的第1個Input操做表達式"m"(__in1)，它被GCC替換以後，表現爲addl address_of_in1, %%eax，__in1的地址是什麼？編譯時才知道。因此咱們徹底沒法直接在指令中去寫出__in1的地址，這時使用佔位符，交給GCC在編譯時進行替代，就能夠解決這個問題。因此這種狀況下，咱們必須使用佔位符。

其次，若是上例中的Output操做表達式"=a"(__out)改成"=r"(__out)，那麼__out在究竟使用那麼寄存器只有到編譯時才能經過GCC來決定，既然在咱們寫代碼的時候，咱們不知道究竟哪一個寄存器被選擇，咱們也就不能直接在指令中寫出寄存器的名稱，而只能經過佔位符替代來解決。

5. Clobber/Modify

有時候，你想通知GCC當前內聯彙編語句可能會對某些寄存器或內存進行修改，但願GCC在編譯時可以將這一點考慮進去。那麼你就能夠在Clobber/Modify域聲明這些寄存器或內存。

這種狀況通常發生在一個寄存器出如今"Instruction List"，但卻不是由Input/Output操做表達式所指定的，也不是在一些Input/Output操做表達式使用"r","g"約束時由GCC爲其選擇的，同時此寄存器被"Instruction List"中的指令修改，而這個寄存器只是供當前內聯彙編臨時使用的狀況。好比：

__asm__ ("movl %0, %%ebx" : : "a"(__foo) : "bx");

寄存器%ebx出如今"Instruction List中"，而且被movl指令修改，但卻未被任何Input/Output操做表達式指定，因此你須要在Clobber/Modify域指定"bx"，以讓GCC知道這一點。

由於你在Input/Output操做表達式所指定的寄存器，或當你爲一些Input/Output操做表達式使用"r","g"約束，讓GCC爲你選擇一個寄存器時，GCC對這些寄存器是很是清楚的——它知道這些寄存器是被修改的，你根本不須要在Clobber/Modify域再聲明它們。但除此以外，GCC對剩下的寄存器中哪些會被當前的內聯彙編修改一無所知。因此若是你真的在當前內聯彙編指令中修改了它們，那麼就最好在Clobber/Modify中聲明它們，讓GCC針對這些寄存器作相應的處理。不然有可能會形成寄存器的不一致，從而形成程序執行錯誤。

在Clobber/Modify域中指定這些寄存器的方法很簡單，你只須要將寄存器的名字使用雙引號(" ")引發來。若是有多個寄存器須要聲明，你須要在任意兩個聲明之間用逗號隔開。好比：

__asm__ ("movl %0, %%ebx; popl %%ecx" : : "a"(__foo) : "bx", "cx" );

這些串包括：

 

聲明的串	表明的寄存器
"al","ax","eax"	%eax
"bl","bx","ebx"	%ebx
"cl","cx","ecx"	%ecx
"dl","dx","edx"	%edx
"si","esi"	%esi
"di", "edi"	%edi

 

由上表能夠看出，你只須要使用"ax","bx","cx","dx","si","di"就能夠了，由於其它的都和它們中的一個是等價的。

若是你在一個內聯彙編語句的Clobber/Modify域向GCC聲明某個寄存器內容發生了改變，GCC在編譯時，若是發現這個被聲明的寄存器的內容在此內聯彙編語句以後還要繼續使用，那麼GCC會首先將此寄存器的內容保存起來，而後在此內聯彙編語句的相關生成代碼以後，再將其內容恢復。咱們來看兩個例子，而後對比一下它們之間的區別。

這個例子中聲明瞭寄存器%ebx內容發生了改變：

$ cat example7.c

int main(int __argc, char* __argv[]) 
{                                    
        int in = 8;                  
                                     
        __asm__ ("addl %0, %%ebx"    
                 : /* no output */   
                 : "a" (in) : "bx"); 
                                     
        return 0;                    
}

$ gcc -O -S example7.c

$ cat example7.s

main:
        pushl   %ebp
        movl    %esp, %ebp
        pushl   %ebx                       # %ebx內容被保存           
        movl    $8, %eax
#APP
        addl     %eax, %ebx
#NO_APP
        movl    $0, %eax
        movl    (%esp), %ebx          # %ebx內容被恢復
        leave
        ret

下面這個例子的C源碼與上一個例子除了沒有聲明%ebx寄存器發生了改變以外，其它都相同。

$ cat example8.c

int main(int __argc, char* __argv[]) 
{                                    
        int in = 8;                  
                                     
        __asm__ ("addl %0, %%ebx"    
                 : /* no output */   
                 : "a" (in) ); 
                                     
        return 0;                    
}

$ gcc -O -S example8.c

$ cat example8.s

main:                      
        pushl   %ebp       
        movl    %esp, %ebp 
        movl    $8, %eax   
#APP                       
        addl %eax, %ebx    
#NO_APP                    
        movl    $0, %eax   
        popl    %ebp       
        ret

仔細對比一下example7.s和example8.s，你就會明白在Clobber/Modify域聲明一個寄存器的意義。

另外須要注意的是，若是你在Clobber/Modify域聲明瞭一個寄存器，那麼這個寄存器將不能再被用作當前內聯彙編語句的Input/Output操做表達式的寄存器約束，若是Input/Output操做表達式的寄存器約束被指定爲"r"或"g"，GCC也不會選擇已經被聲明在Clobber/Modify中的寄存器。好比：

__asm__ ("movl %0, %%ebx" : : "a"(__foo) : "ax", "bx");

此例中，因爲Output操做表達式"a"(__foo)的寄存器約束已經指定了%eax寄存器，那麼再在Clobber/Modify域中指定"ax"就是非法的。編譯時，GCC會給出編譯錯誤。

除了寄存器的內容會被改變，內存的內容也能夠被修改。若是一個內聯彙編語句"Instruction List"中的指令對內存進行了修改，或者在此內聯彙編出現的地方內存內容可能發生改變，而被改變的內存地址你沒有在其Output操做表達式使用"m"約束，這種狀況下你須要使用在Clobber/Modify域使用字符串"memory"向GCC聲明：「在這裏，內存發生了，或可能發生了改變」。例如：

void * memset(void * s, char c, size_t count)
{
     __asm__("cld/n/t"
                     "rep/n/t"
                     "stosb"
                     : /* no output */
                     : "a" (c),"D" (s),"c" (count)
                     : "cx","di","memory");
       return s;
}

此例實現了標準函數庫memset，其內聯彙編中的stosb對內存進行了改動，而其被修改的內存地址s被指定裝入%edi，沒有任何Output操做表達式使用了"m"約束，以指定內存地址s處的內容發生了改變。因此在其Clobber/Modify域使用"memory"向GCC聲明：內存內容發生了變更。

若是一個內聯彙編語句的Clobber/Modify域存在"memory"，那麼GCC會保證在此內聯彙編以前，若是某個內存的內容被裝入了寄存器，那麼在這個內聯彙編以後，若是須要使用這個內存處的內容，就會直接到這個內存處從新讀取，而不是使用被存放在寄存器中的拷貝。由於這個時候寄存器中的拷貝已經極可能和內存處的內容不一致了。

這只是使用"memory"時，GCC會保證作到的一點，但這並非所有。由於使用"memory"是向GCC聲明內存發生了變化，而內存發生變化帶來的影響並不止這一點。好比咱們在前面講到的例子：

int main(int __argc, char* __argv[])  
{                                     
        int* __p = (int*)__argc;      
                                      
        (*__p) = 9999;                
                                      
        __asm__("":::"memory");       
                                      
        if((*__p) == 9999)            
                return 5;             
                                      
        return (*__p);                
}

本例中，若是沒有那條內聯彙編語句，那個if語句的判斷條件就徹底是一句廢話。GCC在優化時會意識到這一點，而直接只生成return 5的彙編代碼，而不會再生成if語句的相關代碼，而不會生成return (*__p)的相關代碼。但你加上了這條內聯彙編語句，它除了聲明內存變化以外，什麼都沒有作。但GCC此時就不能簡單的認爲它不須要判斷都知道(*__p)必定與9999相等，它只有老老實實生成這條if語句的彙編代碼，一塊兒相關的兩個return語句相關代碼。

當一個內聯彙編指令中包含影響eflags寄存器中的條件標誌（也就是那些Jxx等跳轉指令要參考的標誌位，好比，進位標誌，0標誌等），那麼須要在Clobber/Modify域中使用"cc"來聲明這一點。這些指令包括adc, div，popfl，btr，bts等等，另外，當包含call指令時，因爲你不知道你所call的函數是否會修改條件標誌，爲了穩妥起見，最好也使用"cc"。

我不多在相關資料中看到有關"cc"的確切用法，只有一份文檔提到了它，但還不是i386平臺的，只是說"cc"是處理器平臺相關的，並不是全部的平臺都支持它，但即便在不支持它的平臺上，使用它也不會形成編譯錯誤。我作了一些實驗，但發現使用"cc"和不使用"cc"所生成的代碼沒有任何不一樣。但Linux 2.4的相關代碼中用到了它。若是誰知道在i386平臺上"cc"的細節，請和我聯繫。

另外，還能夠在Clobber/Modify域指定數字0到9，以聲明第n個Input/Output操做表達式所使用的寄存器發生了變化，但正如咱們在前面所提到的，若是你爲某個Input/Output操做表達式指定了寄存器，或使用"g","r"等約束讓GCC爲其選擇寄存器，GCC已經知道哪一個寄存器內容發生了變化，因此這麼作沒有什麼意義；我也做了相關的試驗，沒有發現使用它會對GCC生成的彙編代碼有任何影響，至少在i386平臺上是這樣。Linux 2.4的全部i386平臺相關內聯彙編代碼中都沒有使用這一點，但S390平臺相關代碼中有用到，但因爲我對S390彙編沒有任何概念，因此，也不知道這麼作的意義何在