朋友們，我是從http://www.cnblogs.com/latifrons/archive/2009/09/17/1568198.html這里轉載過來的，很不錯就收藏了，如果轉載，請注明初始鏈接。

.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");


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匯編沒有任何概念，所以，也不知道這 么做的意義何在。

總結

以上是生活随笔為你收集整理的C语言ASM汇编内嵌语法zz的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。