原稿：http://blog.sina.com.cn/s/blog_475cb6780100gnn5.html
1、__asm__是GCC關(guān)鍵字asm的宏定義：
#define __asm__ asm
__asm__或asm用來(lái)聲明一個(gè)內聯(lián)匯編表達式，所以任何一個(gè)內聯(lián)匯編表達式都是以它開(kāi)頭的，是必不可少的。
2、Instruction List
Instruction List是匯編指令序列。它可以是空的，比如：__asm__ __volatile__(""); 或__asm__ ("");都是完全合法的內聯(lián)匯編表達式，只不過(guò)這兩條語(yǔ)句沒(méi)有什么意義。但并非所有Instruction List為空的內聯(lián)匯編表達式都是沒(méi)有意義的，比如：__asm__ ("":::"memory"); 就非常有意義，它向GCC聲明：“我對內存作了改動(dòng)”，GCC在編譯的時(shí)候，會(huì )將此因素考慮進(jìn)去。
我們看一看下面這個(gè)例子：
$ cat example1.c
int main(int __argc, char* __argv[])
{
int* __p = (int*)__argc;
(*__p) = 9999;
//__asm__("":::"memory");
if((*__p) == 9999)
return 5;
return (*__p);
}
在 這段代碼中，那條內聯(lián)匯編是被注釋掉的。在這條內聯(lián)匯編之前，內存指針__p所指向的內存被賦值為9999，隨即在內聯(lián)匯編之后，一條if語(yǔ)句判斷__p 所指向的內存與9999是否相等。很明顯，它們是相等的。GCC在優(yōu)化編譯的時(shí)候能夠很聰明的發(fā)現這一點(diǎn)。我們使用下面的命令行對其進(jìn)行編譯：
$ gcc -O -S example1.c
選項-O表示優(yōu)化編譯，我們還可以指定優(yōu)化等級，比如-O2表示優(yōu)化等級為2；選項-S表示將C/C++源文件編譯為匯編文件，文件名和C/C++文件一樣，只不過(guò)擴展名由.c變?yōu)?s。
我們來(lái)查看一下被放在example1.s中的編譯結果，我們這里僅僅列出了使用gcc 2.96在redhat 7.3上編譯后的相關(guān)函數部分匯編代碼。為了保持清晰性，無(wú)關(guān)的其它代碼未被列出。
$ 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源碼和編譯出的匯編代碼，我們會(huì )發(fā)現匯編代碼中，沒(méi)有if語(yǔ)句相關(guān)的代碼，而是在賦值語(yǔ)句(*__p)=9999后直接return 5；這是因為GCC認為在(*__p)被賦值之后，在if語(yǔ)句之前沒(méi)有任何改變(*__p)內容的操作，所以那條if語(yǔ)句的判斷條件(*__p) == 9999肯定是為true的，所以GCC就不再生成相關(guān)代碼，而是直接根據為true的條件生成return 5的匯編代碼（GCC使用eax作為保存返回值的寄存器）。
我們現在將example1.c中內聯(lián)匯編的注釋去掉，重新編譯，然后看一下相關(guān)的編譯結果。
$ 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
由于內聯(lián)匯編語(yǔ)句__asm__("":::"memory")向GCC聲明，在此內聯(lián)匯編語(yǔ)句出現的位置內存內容可能了改變，所以GCC在編譯時(shí)就不能像剛才那樣處理。這次，GCC老老實(shí)實(shí)的將if語(yǔ)句生成了匯編代碼。
可能有人會(huì )質(zhì)疑：為什么要使用__asm__("":::"memory")向GCC聲明內存發(fā)生了變化？明明“Instruction List”是空的，沒(méi)有任何對內存的操作，這樣做只會(huì )增加GCC生成匯編代碼的數量。
確 實(shí)，那條內聯(lián)匯編語(yǔ)句沒(méi)有對內存作任何操作，事實(shí)上它確實(shí)什么都沒(méi)有做。但影響內存內容的不僅僅是你當前正在運行的程序。比如，如果你現在正在操作的內存 是一塊內存映射，映射的內容是外圍I/O設備寄存器。那么操作這塊內存的就不僅僅是當前的程序，I/O設備也會(huì )去操作這塊內存。既然兩者都會(huì )去操作同一塊 內存，那么任何一方在任何時(shí)候都不能對這塊內存的內容想當然。所以當你使用高級語(yǔ)言C/C++寫(xiě)這類(lèi)程序的時(shí)候，你必須讓編譯器也能夠明白這一點(diǎn)，畢竟高 級語(yǔ)言最終要被編譯為匯編代碼。
你可能已經(jīng)注意到了，這次輸出的匯編結果中，有兩個(gè)符號：#APP和#NO_APP，GCC將內聯(lián)匯編語(yǔ) 句中"Instruction List"所列出的指令放在#APP和#NO_APP之間，由于__asm__("":::"memory")中“Instruction List”為空，所以#APP和#NO_APP中間也沒(méi)有任何內容。但我們以后的例子會(huì )更加清楚的表現這一點(diǎn)。
關(guān)于為什么內聯(lián)匯編__asm__("":::"memory")是一條聲明內存改變的語(yǔ)句，我們后面會(huì )詳細討論。
剛才我們花了大量的內容來(lái)討論"Instruction List"為空是的情況，但在實(shí)際的編程中，"Instruction List"絕大多數情況下都不是空的。它可以有1條或任意多條匯編指令。
當 在"Instruction List"中有多條指令的時(shí)候，你可以在一對引號中列出全部指令，也可以將一條或幾條指令放在一對引號中，所有指令放在多對引號中。如果是前者，你可以將 每一條指令放在一行，如果要將多條指令放在一行，則必須用分號（；）或換行符（\n，大多數情況下\n后還要跟一個(gè)\t，其中\n是為了換行，\t是為了 空出一個(gè)tab寬度的空格）將它們分開(kāi)。比如：
__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");
都是合法的寫(xiě)法。如果你將指令放在多對引號中，則除了最后一對引號之外，前面的所有引號里的最后一條指令之后都要有一個(gè)分號(；)或(\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");
都是合法的。
上述原則可以歸結為：
任意兩個(gè)指令間要么被分號(；)分開(kāi)，要么被放在兩行；
放在兩行的方法既可以從通過(guò)\n的方法來(lái)實(shí)現，也可以真正的放在兩行；
可以使用1對或多對引號，每1對引號里可以放任一多條指令，所有的指令都要被放到引號中。
在基本內聯(lián)匯編中，“Instruction List”的書(shū)寫(xiě)的格式和你直接在匯編文件中寫(xiě)非內聯(lián)匯編沒(méi)有什么不同，你可以在其中定義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內聯(lián)代碼常用的格式，非常整齊。也建議大家都使用這種格式來(lái)寫(xiě)內聯(lián)匯編代碼。
3、__volatile__
__volatile__是GCC關(guān)鍵字volatile的宏定義：
#define __volatile__ volatile
__volatile__ 或volatile是可選的，你可以用它也可以不用它。如果你用了它，則是向GCC聲明“不要動(dòng)我所寫(xiě)的Instruction List，我需要原封不動(dòng)的保留每一條指令”，否則當你使用了優(yōu)化選項(-O)進(jìn)行編譯時(shí)，GCC將會(huì )根據自己的判斷決定是否將這個(gè)內聯(lián)匯編表達式中的指 令優(yōu)化掉。
那么GCC判斷的原則是什么？我不知道（如果有哪位朋友清楚的話(huà)，請告訴我）。我試驗了一下，發(fā)現一條內聯(lián)匯編語(yǔ)句如果是基本 內聯(lián)匯編的話(huà)（即只有“Instruction List”，沒(méi)有Input/Output/Clobber的內聯(lián)匯編，我們后面將會(huì )討論這一點(diǎn)），無(wú)論你是否使用__volatile__來(lái)修飾， GCC 2.96在優(yōu)化編譯時(shí)，都會(huì )原封不動(dòng)的保留內聯(lián)匯編中的“Instruction List”。但或許我的試驗的例子并不充分，所以這一點(diǎn)并不能夠得到保證。
為了保險起見(jiàn)，如果你不想讓GCC的優(yōu)化影響你的內聯(lián)匯編代碼，你最好在前面都加上__volatile__，而不要依賴(lài)于編譯器的原則，因為即使你非常了解當前編譯器的優(yōu)化原則，你也無(wú)法保證這種原則將來(lái)不會(huì )發(fā)生變化。而__volatile__的含義卻是恒定的。
2、帶有C/C++表達式的內聯(lián)匯編
GCC允許你通過(guò)C/C++表達式指定內聯(lián)匯編中"Instrcuction List"中指令的輸入和輸出，你甚至可以不關(guān)心到底使用哪個(gè)寄存器被使用，完全靠GCC來(lái)安排和指定。這一點(diǎn)可以讓程序員避免去考慮有限的寄存器的使用，也可以提高目標代碼的效率。
我們先來(lái)看幾個(gè)例子：
__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));
怎么樣，有點(diǎn)印象了吧，是不是也有點(diǎn)暈？沒(méi)關(guān)系，下面討論完之后你就不會(huì )再暈了。（當然，也有可能更暈^_^）。討論開(kāi)始——
帶有C/C++表達式的內聯(lián)匯編格式為：
__asm__ __volatile__("Instruction List" : Output : Input : Clobber/Modify);
從中我們可以看出它和基本內聯(lián)匯編的不同之處在于：它多了3個(gè)部分(Input，Output，Clobber/Modify)。在括號中的4個(gè)部分通過(guò)冒號(:)分開(kāi)。
這4個(gè)部分都不是必須的，任何一個(gè)部分都可以為空，其規則為：
如 果Clobber/Modify為空，則其前面的冒號(:)必須省略。比如__asm__("mov %%eax, %%ebx" : "=b"(foo) : "a"(inp) : )就是非法的寫(xiě)法；而__asm__("mov %%eax, %%ebx" : "=b"(foo) : "a"(inp) )則是正確的。
如果Instruction List為空，則Input，Output，Clobber/Modify可以不為空，也可以為空。比如__asm__ ( " " : : : "memory" );和__asm__(" " : : );都是合法的寫(xiě)法。
如 果Output，Input，Clobber/Modify都為空，Output，Input之前的冒號(:)既可以省略，也可以不省略。如果都省略，則 此匯編退化為一個(gè)基本內聯(lián)匯編，否則，仍然是一個(gè)帶有C/C++表達式的內聯(lián)匯編，此時(shí)"Instruction List"中的寄存器寫(xiě)法要遵守相關(guān)規定，比如寄存器前必須使用兩個(gè)百分號(%%)，而不是像基本匯編格式一樣在寄存器前只使用一個(gè)百分號(%)。比如 __asm__( " mov %%eax, %%ebx" : : )；__asm__( " mov %%eax, %%ebx" : )和__asm__( " mov %eax, %ebx" )都是正確的寫(xiě)法，而__asm__( " mov %eax, %ebx" : : )；__asm__( " mov %eax, %ebx" : )和__asm__( " mov %%eax, %%ebx" )都是錯誤的寫(xiě)法。
如果Input，Clobber/Modify為空，但Output不為空，Input前的冒號(:)既可以省略，也可以不省略。比如 __asm__( " mov %%eax, %%ebx" : "=b"(foo) : )；__asm__( " mov %%eax, %%ebx" : "=b"(foo) )都是正確的。
如果后面的部分不為空，而前面的部分為空，則前面的冒號(:)都必須保留，否則無(wú)法說(shuō) 明不為空的部分究竟是第幾部分。比如， Clobber/Modify，Output為空，而Input不為空，則Clobber/Modify前的冒號必須省略（前面的規則），而Output 前的冒號必須為保留。如果Clobber/Modify不為空，而Input和Output都為空，則Input和Output前的冒號都必須保留。比如 __asm__( " mov %%eax, %%ebx" : : "a"(foo) )和__asm__( " mov %%eax, %%ebx" : : : "ebx" )。
從上面的規則可以看到另外一個(gè)事實(shí)，區分一個(gè)內聯(lián)匯編是基本格式的還是帶有C/C++表達式格式的，其規則在于在"Instruction List"后是否有冒號(:)的存在，如果沒(méi)有則是基本格式的，否則，則是帶有C/C++表達式格式的。
兩種格式對寄存器語(yǔ)法的要求不同：基本格式要求寄存器前只能使用一個(gè)百分號(%)，這一點(diǎn)和非內聯(lián)匯編相同；而帶有C/C++表達式格式則要求寄存器前必須使用兩個(gè)百分號(%%)，其原因我們會(huì )在后面討論。
1. Output
Output用來(lái)指定當前內聯(lián)匯編語(yǔ)句的輸出。我們看一看這個(gè)例子：
__asm__("movl %%cr0, %0": "=a" (cr0));
這 個(gè)內聯(lián)匯編語(yǔ)句的輸出部分為"=r"(cr0)，它是一個(gè)“操作表達式”，指定了一個(gè)輸出操作。我們可以很清楚得看到這個(gè)輸出操作由兩部分組成：括號括住 的部分(cr0)和引號引住的部分"=a"。這兩部分都是每一個(gè)輸出操作必不可少的。括號括住的部分是一個(gè)C/C++表達式，用來(lái)保存內聯(lián)匯編的一個(gè)輸出 值，其操作就等于C/C++的相等賦值cr0 = output_value，因此，括號中的輸出表達式只能是C/C++的左值表達式，也就是說(shuō)它只能是一個(gè)可以合法的放在C/C++賦值操作中等號(=) 左邊的表達式。那么右值output_value從何而來(lái)呢
括 號中的表達式cpu->db7是一個(gè)C/C++語(yǔ)言的表達式，它不必是一個(gè)左值表達式，也就是說(shuō)它不僅可以是放在C/C++賦值操作左邊的表達式， 還可以是放在C/C++賦值操作右邊的表達式。所以它可以是一個(gè)變量，一個(gè)數字，還可以是一個(gè)復雜的表達式（比如a+b/c*d）。比如上例可以改為： __asm__("movl %0, %%db7" : : "a" (foo))，__asm__("movl %0, %%db7" : : "a" (0x1000))或__asm__("movl %0, %%db7" : : "a" (va*vb/vc))。
引號號中的 部分是約束部分，和輸出表達式約束不同的是，它不允許指定加號(+)約束和等號(=)約束，也就是說(shuō)它只能是默認的Read-Only的。約束中必須指定 一個(gè)寄存器約束，例中的字母a表示當前輸入變量cpu->db7要通過(guò)寄存器eax輸入到當前內聯(lián)匯編中。
我們看一個(gè)例子：
$ 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
每一個(gè)Input和Output表達式都必須指定自己的操作約束Operation Constraint，我們這里來(lái)討論在80386平臺上所可能使用的操作約束。
1、寄存器約束
當你當前的輸入或輸入需要借助一個(gè)寄存器時(shí)，你需要為其指定一個(gè)寄存器約束。你可以直接指定一個(gè)寄存器的名字，比如：
__asm__ __volatile__("movl %0, %%cr0"::"eax" (cr0));
也可以指定一個(gè)縮寫(xiě)，比如：
__asm__ __volatile__("movl %0, %%cr0"::"a" (cr0));
如果你指定一個(gè)縮寫(xiě)，比如字母a，則GCC將會(huì )根據當前操作表達式中C/C++表達式的寬度決定使用%eax，還是%ax或%al。比如：
unsigned short __shrt;
__asm__ ("mov %0，%%bx" : : "a"(__shrt));
由于變量__shrt是16-bit short類(lèi)型，則編譯出來(lái)的匯編代碼中，則會(huì )讓此變量使用%ex寄存器。編譯結果為：
movw -2(%ebp), %ax # %ax = __shrt
#APP
movl %ax, %bx
#NO_APP
無(wú)論是Input，還是Output操作表達式約束，都可以使用寄存器約束。
下表中列出了常用的寄存器約束的縮寫(xiě)。
約束 Input/Output 意義
r I,O 表示使用一個(gè)通用寄存器，由GCC在%eax/%ax/%al, %ebx/%bx/%bl, %ecx/%cx/%cl, %edx/%dx/%dl中選取一個(gè)GCC認為合適的。
q I,O 表示使用一個(gè)通用寄存器，和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 表示使用浮點(diǎn)寄存器
t I,O 表示使用第一個(gè)浮點(diǎn)寄存器
u I,O 表示使用第二個(gè)浮點(diǎn)寄存器
2、內存約束
如果一個(gè)Input/Output操作表達式的C/C++表達式表現為一個(gè)內存地址，不想借助于任何寄存器，則可以使用內存約束。比如：
__asm__ ("lidt %0" : "=m"(__idt_addr)); 或 __asm__ ("lidt %0" : :"m"(__idt_addr));
我們看一下它們分別被放在一個(gè)C源文件中，然后被GCC編譯后的結果：
$ cat example5.c
// 本例中，變量sh被作為一個(gè)內存輸入
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被作為一個(gè)內存輸出
int main(int __argc, char* __argv[])
{
char* sh = (char*)&__argc;
__asm__ __volatile__("lidt %0"
