AT&T組合語言語法及GCC的內嵌彙編語法
AT&T組合語言語法及GCC的內嵌彙編語法
AT&T ASM Syntax
Overview
開發一個OS，儘管絕大部分程式碼只需要用C/C++等高階語言就可以了，但至少和硬體相關部分的程式碼需要使用匯編語言，另外，由於啟動部分的程式碼有大小限制，使用精練的彙編可以縮小目的碼的Size。另外，對於某些需要被經常呼叫的程式碼，使用匯編來寫可以提高效能。 所以我們必須瞭解組合語言，即使你有可能並不喜歡它。
如果你是計算機專業的話，在大學裡你應該學習過Intel格式的8086/80386彙編，這裡就不再討論。 如果我們選擇的OS開發工具是GCC以及GAS的話，就必須瞭解AT&T組合語言語法，因為GCC/GAS只支援這種彙編語法。
本書不會去討論8086/80386的彙編程式設計，這類的書籍很多，你可以參考它們。 這裡只會討論AT&T的彙編語法，以及GCC的內嵌彙編語法。
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)。
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");
1、__asm__
__asm__是GCC關鍵字asm的巨集定義：
#define __asm__ asm
__asm__或asm用來宣告一個內聯彙編表示式，所以任何一個內聯彙編表示式都是以它開頭的，是必不可少的。
2、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內聯程式碼常用的格式，非常整齊。 也建議大家都使用這種格式來寫內聯彙編程式碼。
3、__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__的含義卻是恆定的。
2、帶有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));
2、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平臺上所可能使用的操作約束。
1、暫存器約束
當你當前的輸入或輸入需要藉助一個暫存器時，你需要為其指定一個暫存器約束。 你可以直接指定一個暫存器的名字，比如：
__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 表示使用第二個浮點暫存器
2、記憶體約束
如果一個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 表示使用系統所支援的任何一種記憶體方式，不需要藉助暫存器
3、立即數約束
如果一個Input/Output操作表示式的C/C++表示式是一個數字常數，不想借助於任何暫存器，則可以使用立即數約束。
由於立即數在C/C++中只能作為右值，所以對於使用立即數約束的表示式而言，只能放在Input域。
比如：__asm__ __volatile__("movl %0, %%eax" : : "i" (100) );
立即數約束很簡單，也很容易理解，我們在這裡就不再贅述。
約束 Input/Output 意義
i I 表示輸入表示式是一個立即數(整數)，不需要藉助任何暫存器
F I 表示輸入表示式是一個立即數(浮點數)，不需要藉助任何暫存器
4、通用約束
約束 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的限制。
5、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彙編沒有任何概念，所以，也不知道這麼做的意義何在。