GCC Inline ASM GCC内聯彙編

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中内聯彙編的注釋去掉，重新編譯，然後看一下相關的編譯結果。

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: 

由于内聯彙編語句__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)。比如：

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" 

上面例子的格式是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 cr0 = 5; 

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

return 0; 

$ gcc -s example2.c

$ cat example2.s

subl $4, %esp 

movl $5, -4(%ebp) # cr0 = 5

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

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

$ gcc -s example3.c

$ cat example3.s

movl -4(%ebp), %eax # input ( %eax = cr0 )

movl %cr0, %eax

movl %eax, -4(%ebp) # output (cr0 = %eax )

movl $0, %eax

leave

從編譯的結果可以看出，當使用加号(+)限制的時候，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

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

$ gcc -s example4.c

$ cat example4.s

movl $5, -4(%ebp) # cr0 = 5 

movl -4(%ebp), %eax # %eax = cr0

movl %eax, %cr0 

我們從編譯出的彙編代碼可以看到，在"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

無論是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被作為一個記憶體輸入

char* sh = (char*)&__argc; 

__asm__ __volatile__("lidt %0" : : "m" (sh)); 

} 

$ gcc -s example5.c

$ cat example5.s

leal 8(%ebp), %eax 

movl %eax, -4(%ebp) # sh = (char*) &__argc

lidt -4(%ebp) 

$ cat example6.c

// 本例中，變量sh被作為一個記憶體輸出

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

$ gcc -s example6.c

$ cat example6.s

main:

pushl %ebp

movl %esp, %ebp

subl $4, %esp

leal 8(%ebp), %eax

lidt -4(%ebp)

首先，你會注意到，在這兩個例子中，變量sh沒有借助任何寄存器，而是直接參與了指令lidt的操作。

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

原來，使用記憶體方式進行輸入輸出時，由于不借助寄存器，是以gcc不會按照你的聲明對其作任何的輸入輸出處理。gcc隻會直接拿來用，究竟對這個c/c++表達式而言是輸入還是輸出，完全依賴與你寫在"instruction list"中的指令對其操作的指令。

由于上例中，對其操作的指令為lidt，lidt指令的操作數是一個輸入型的操作數，是以事實上對變量sh的操作是一個輸入操作，即使你把它放在 output域也不會改變這一點。是以，對此例而言，完全符合語意的寫法應該是将sh放在input域，盡管放在output域也會有正确的執行結果。

是以，對于記憶體限制類型的操作表達式而言，放在input域還是放在output域，對編譯結果是沒有任何影響的，因為本來我們将一個操作表達式放在 input域或放在output域是希望gcc能為我們自動通過寄存器将表達式的值輸入或輸出。既然對于記憶體限制類型的操作表達式來說，gcc不會自動為它做任何事情，那麼放在哪兒也就無所謂了。但從程式員的角度而言，為了增強代碼的可讀性，最好能夠把它放在符合實際情況的地方。

m i,o 表示使用系統所支援的任何一種記憶體方式，不需要借助寄存器 

3、立即數限制

如果一個input/output操作表達式的c/c++表達式是一個數字常數，不想借助于任何寄存器，則可以使用立即數限制。

由于立即數在c/c++中隻能作為右值，是以對于使用立即數限制的表達式而言，隻能放在input域。

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

立即數限制很簡單，也很容易了解，我們在這裡就不再贅述。

i i 表示輸入表達式是一個立即數(整數)，不需要借助任何寄存器 

f i 表示輸入表達式是一個立即數(浮點數)，不需要借助任何寄存器 

4、通用限制

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)則會讓編譯器産生不同的代碼。

just_mov(100); 

編譯後生成的代碼為：

movl $100, %eax 

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

just_mov(__argc); 

經編譯後生成的代碼為：

movl 8(%ebp), %eax 

這個例子是使用記憶體方式。

一個帶有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 __in1 = 8, __in2 = 4, __out = 3; 

此例中，%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，這與我們的初衷不符。

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

popl %eax 

movl %edx, %esi 

movl %eax, %edi 

movl %eax, -12(%ebp) # __out使用寄存器%eax

為了避免這種情況，我們必須向gcc聲明這一點，要求gcc為所有的input操作表達式指定别的寄存器，方法就是在output操作表達式"=a" (__out)的操作限制中加入&限制，由于gcc規定等号(=)限制必須放在第一個，是以我們寫作"=&a"(__out)。 

下面是我們将&限制加入之後編譯的結果：

movl -4(%ebp), %edx #__in1使用寄存器%edx

movl -8(%ebp), %eax 

movl %eax, %ecx # __in2使用寄存器%ecx

movl %ecx, %edi 

movl %eax, -12(%ebp) #__out使用寄存器%eax

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操作表達式指定這個寄存器，否則會出現編譯錯誤。比如：

: "a" (__in1), "c" (__in2)); 

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

反過來，你也可以為output指定可選限制，比如"r","g"等，讓gcc為其選擇到底使用哪個寄存器，還是使用記憶體方式，gcc在選擇的時候，會首先排除掉已經被input操作表達式使用的所有寄存器，然後在剩下的寄存器中選擇，或幹脆使用記憶體方式。比如：

: "=&r"(__out) 

本例中，由于__out指定了限制"r"，即讓gcc為其決定使用哪一格寄存器，而寄存器%eax和%ecx已經被__in1和__in2使用，那麼gcc在為__out選擇的時候，隻會在%ebx和%edx中選擇。

前3 個修飾符隻能用在output操作表達式中，而百分号[%]修飾符恰恰相反，隻能用在input操作表達式中，用于向gcc聲明：“目前input操作表達式中的c/c++表達式可以和下一個input操作表達式中的c/c++表達式互換”。這個修飾符号一般用于符合交換律運算，比如加(+)，乘(*)，與(&)，或(|)等等。我們看一個例子：

__asm__ ("addl %1, %0/n/t" 

: "=r"(__out) 

: "%r" (__in1), "0" (__in2)); 

在此例中，由于指令是一個加法運算，相當于等式__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. 占位符

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

: "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"

和上面使用占位符%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 in = 8; 

__asm__ ("addl %0, %%ebx" 

: /* no output */ 

: "a" (in) : "bx"); 

$ gcc -o -s example7.c

$ cat example7.s

pushl %ebx # %ebx内容被儲存 

movl $8, %eax

addl %eax, %ebx

movl (%esp), %ebx # %ebx内容被恢複

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

$ cat example8.c

: "a" (in) ); 

$ gcc -o -s example8.c

$ cat example8.s

movl $8, %eax 

addl %eax, %ebx 

仔細對比一下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聲明記憶體發生了變化，而記憶體發生變化帶來的影響并不止這一點。比如我們在前面講到的例子：

__asm__("":::"memory"); 

本例中，如果沒有那條内聯彙編語句，那個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彙編沒有任何概念，是以，也不知道這麼做的意義何在。