c語言asm匯編內(nèi)嵌語法1

.3GCCInlineASM

GCC支持在C/C++代碼中嵌入?yún)R編代碼，這些匯編代碼被稱作GCCInlineASM——GCC內(nèi)聯(lián)匯編。這是一個(gè)非常有用的功能，有利于我們將一些C/C++語法無法表達(dá)的指令直接潛入C/C++代碼中，另外也允許我們直接寫C/C++代碼中使用匯編編寫簡潔高效的代碼。

1.基本內(nèi)聯(lián)匯編

GCC中基本的內(nèi)聯(lián)匯編非常易懂，我們先來看兩個(gè)簡單的例子：

__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"\

);

基本內(nèi)聯(lián)匯編的格式是

__asm____volatile__("InstructionList");

1、__asm__

__asm__是GCC關(guān)鍵字asm的宏定義：

#define__asm__asm

__asm__或asm用來聲明一個(gè)內(nèi)聯(lián)匯編表達(dá)式，所以任何一個(gè)內(nèi)聯(lián)匯編表達(dá)式都是以它開頭的，是必不可少的。

2、InstructionList

InstructionList是匯編指令序列。它可以是空的，比如：__asm____volatile__("");或__asm__("");都是完全合法的內(nèi)聯(lián)匯編表達(dá)式，只不過這兩條語句沒有什么意義。但并非所有InstructionList為空的內(nèi)聯(lián)匯編表達(dá)式都是沒有意義的，比如：__asm__("":::"memory");就非常有意義，它向GCC聲明：“我對內(nèi)存作了改動(dòng)”，GCC在編譯的時(shí)候，會(huì)將此因素考慮進(jìn)去。

我們看一看下面這個(gè)例子：

$catexample1.c

intmain(int__argc,char*__argv[])

{

int*__p=(int*)__argc;

(*__p)=9999;

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

if((*__p)==9999)

return5;

return(*__p);

}

在這段代碼中，那條內(nèi)聯(lián)匯編是被注釋掉的。在這條內(nèi)聯(lián)匯編之前，內(nèi)存指針__p所指向的內(nèi)存被賦值為9999，隨即在內(nèi)聯(lián)匯編之后，一條if語句判斷__p所指向的內(nèi)存與9999是否相等。很明顯，它們是相等的。GCC在優(yōu)化編譯的時(shí)候能夠很聰明的發(fā)現(xiàn)這一點(diǎn)。我們使用下面的命令行對其進(jìn)行編譯：

$gcc-O-Sexample1.c

選項(xiàng)-O表示優(yōu)化編譯，我們還可以指定優(yōu)化等級，比如-O2表示優(yōu)化等級為2；選項(xiàng)-S表示將C/C++源文件編譯為匯編文件，文件名和C/C++文件一樣，只不過擴(kuò)展名由.c變?yōu)?s。

我們來查看一下被放在example1.s中的編譯結(jié)果，我們這里僅僅列出了使用gcc2.96在redhat7.3上編譯后的相關(guān)函數(shù)部分匯編代碼。為了保持清晰性，無關(guān)的其它代碼未被列出。

$catexample1.s

main:

pushl%ebp

movl%esp,%ebp

movl8(%ebp),%eax#int*__p=(int*)__argc

movl$9999,(%eax)#(*__p)=9999

movl$5,%eax#return5

popl%ebp

ret

參照一下C源碼和編譯出的匯編代碼，我們會(huì)發(fā)現(xiàn)匯編代碼中，沒有if語句相關(guān)的代碼，而是在賦值語句(*__p)=9999后直接return5；這是因?yàn)镚CC認(rèn)為在(*__p)被賦值之后，在if語句之前沒有任何改變(*__p)內(nèi)容的操作，所以那條if語句的判斷條件(*__p)==9999肯定是為true的，所以GCC就不再生成相關(guān)代碼，而是直接根據(jù)為true的條件生成return5的匯編代碼（GCC使用eax作為保存返回值的寄存器）。

我們現(xiàn)在將example1.c中內(nèi)聯(lián)匯編的注釋去掉，重新編譯，然后看一下相關(guān)的編譯結(jié)果。

$gcc-O-Sexample1.c

$catexample1.s

main:

pushl%ebp

movl%esp,%ebp

movl8(%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,return5

jmp.L2

.p2align2

.L3:

movl(%eax),%eax

.L2:

popl%ebp

ret

由于內(nèi)聯(lián)匯編語句__asm__("":::"memory")向GCC聲明，在此內(nèi)聯(lián)匯編語句出現(xiàn)的位置內(nèi)存內(nèi)容可能了改變，所以GCC在編譯時(shí)就不能像剛才那樣處理。這次，GCC老老實(shí)實(shí)的將if語句生成了匯編代碼。

可能有人會(huì)質(zhì)疑：為什么要使用__asm__("":::"memory")向GCC聲明內(nèi)存發(fā)生了變化？明明“InstructionList”是空的，沒有任何對內(nèi)存的操作，這樣做只會(huì)增加GCC生成匯編代碼的數(shù)量。

確實(shí)，那條內(nèi)聯(lián)匯編語句沒有對內(nèi)存作任何操作，事實(shí)上它確實(shí)什么都沒有做。但影響內(nèi)存內(nèi)容的不僅僅是你當(dāng)前正在運(yùn)行的程序。比如，如果你現(xiàn)在正在操作的內(nèi)存是一塊內(nèi)存映射，映射的內(nèi)容是外圍I/O設(shè)備寄存器。那么操作這塊內(nèi)存的就不僅僅是當(dāng)前的程序，I/O設(shè)備也會(huì)去操作這塊內(nèi)存。既然兩者都會(huì)去操作同一塊內(nèi)存，那么任何一方在任何時(shí)候都不能對這塊內(nèi)存的內(nèi)容想當(dāng)然。所以當(dāng)你使用高級語言C/C++寫這類程序的時(shí)候，你必須讓編譯器也能夠明白這一點(diǎn)，畢竟高級語言最終要被編譯為匯編代碼。

你可能已經(jīng)注意到了，這次輸出的匯編結(jié)果中，有兩個(gè)符號：#APP和#NO_APP，GCC將內(nèi)聯(lián)匯編語句中"InstructionList"所列出的指令放在#APP和#NO_APP之間，由于__asm__("":::"memory")中“InstructionList”為空，所以#APP和#NO_APP中間也沒有任何內(nèi)容。但我們以后的例子會(huì)更加清楚的表現(xiàn)這一點(diǎn)。

關(guān)于為什么內(nèi)聯(lián)匯編__asm__("":::"memory")是一條聲明內(nèi)存改變的語句，我們后面會(huì)詳細(xì)討論。

剛才我們花了大量的內(nèi)容來討論"InstructionList"為空是的情況，但在實(shí)際的編程中，"InstructionList"絕大多數(shù)情況下都不是空的。它可以有1條或任意多條匯編指令。

當(dāng)在"InstructionList"中有多條指令的時(shí)候，你可以在一對引號中列出全部指令，也可以將一條或幾條指令放在一對引號中，所有指令放在多對引號中。如果是前者，你可以將每一條指令放在一行，如果要將多條指令放在一行，則必須用分號（；）或換行符（\n，大多數(shù)情況下\n后還要跟一個(gè)\t，其中\(zhòng)n是為了換行，\t是為了空出一個(gè)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\tpopl%edi

subl%ecx,%ebx");

都是合法的寫法。如果你將指令放在多對引號中，則除了最后一對引號之外，前面的所有引號里的最后一條指令之后都要有一個(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\tpopl%edi\n"

"subl%ecx,%ebx");

__asm__("movl%eax,%ebx;sti\n\tpopl%edi;""subl%ecx,%ebx");

都是合法的。

上述原則可以歸結(jié)為：

任意兩個(gè)指令間要么被分號(；)分開，要么被放在兩行；

放在兩行的方法既可以從通過\n的方法來實(shí)現(xiàn)，也可以真正的放在兩行；

可以使用1對或多對引號，每1對引號里可以放任一多條指令，所有的指令都要被放到引號中。

在基本內(nèi)聯(lián)匯編中，“InstructionList”的書寫的格式和你直接在匯編文件中寫非內(nèi)聯(lián)匯編沒有什么不同，你可以在其中定義Label，定義對齊(.alignn)，定義段(.sectionname)。例如：

__asm__(".align2\n\t"

"movl%eax,%ebx\n\t"

"test%ebx,%ecx\n\t"

"jneerror\n\t"

"sti\n\t"

"error:popl%edi\n\t"

"subl%ecx,%ebx");

上面例子的格式是Linux內(nèi)聯(lián)代碼常用的格式，非常整齊。也建議大家都使用這種格式來寫內(nèi)聯(lián)匯編代碼。

3、__volatile__

__volatile__是GCC關(guān)鍵字volatile的宏定義：

#define__volatile__volatile

__volatile__或volatile是可選的，你可以用它也可以不用它。如果你用了它，則是向GCC聲明“不要?jiǎng)游宜鶎懙腎nstructionList，我需要原封不動(dòng)的保留每一條指令”，否則當(dāng)你使用了優(yōu)化選項(xiàng)(-O)進(jìn)行編譯時(shí)，GCC將會(huì)根據(jù)自己的判斷決定是否將這個(gè)內(nèi)聯(lián)匯編表達(dá)式中的指令優(yōu)化掉。

那么GCC判斷的原則是什么？我不知道（如果有哪位朋友清楚的話，請告訴我）。我試驗(yàn)了一下，發(fā)現(xiàn)一條內(nèi)聯(lián)匯編語句如果是基本內(nèi)聯(lián)匯編的話（即只有“InstructionList”，沒有Input/Output/Clobber的內(nèi)聯(lián)匯編，我們后面將會(huì)討論這一點(diǎn)），無論你是否使用__volatile__來修飾，GCC2.96在優(yōu)化編譯時(shí)，都會(huì)原封不動(dòng)的保留內(nèi)聯(lián)匯編中的“InstructionList”。但或許我的試驗(yàn)的例子并不充分，所以這一點(diǎn)并不能夠得到保證。

為了保險(xiǎn)起見，如果你不想讓GCC的優(yōu)化影響你的內(nèi)聯(lián)匯編代碼，你最好在前面都加上__volatile__，而不要依賴于編譯器的原則，因?yàn)榧词鼓惴浅Ａ私猱?dāng)前編譯器的優(yōu)化原則，你也無法保證這種原則將來不會(huì)發(fā)生變化。而__volatile__的含義卻是恒定的。

2、帶有C/C++表達(dá)式的內(nèi)聯(lián)匯編

GCC允許你通過C/C++表達(dá)式指定內(nèi)聯(lián)匯編中"InstrcuctionList"中指令的輸入和輸出，你甚至可以不關(guān)心到底使用哪個(gè)寄存器被使用，完全靠GCC來安排和指定。這一點(diǎn)可以讓程序員避免去考慮有限的寄存器的使用，也可以提高目標(biāo)代碼的效率。

我們先來看幾個(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)暈？沒關(guān)系，下面討論完之后你就不會(huì)再暈了。（當(dāng)然，也有可能更暈^_^）。討論開始——

帶有C/C++表達(dá)式的內(nèi)聯(lián)匯編格式為：

__asm____volatile__("InstructionList":Output:Input:Clobber/Modify);

從中我們可以看出它和基本內(nèi)聯(lián)匯編的不同之處在于：它多了3個(gè)部分(Input，Output，Clobber/Modify)。在括號中的4個(gè)部分通過冒號(:)分開。

這4個(gè)部分都不是必須的，任何一個(gè)部分都可以為空，其規(guī)則為：

如果Clobber/Modify為空，則其前面的冒號(:)必須省略。比如__asm__("mov%%eax,%%ebx":"=b"(foo):"a"(inp):)就是非法的寫法；而__asm__("mov%%eax,%%ebx":"=b"(foo):"a"(inp))則是正確的。

如果InstructionList為空，則Input，Output，Clobber/Modify可以不為空，也可以為空。比如__asm__("":::"memory");和__asm__(""::);都是合法的寫法。

如果Output，Input，Clobber/Modify都為空，Output，Input之前的冒號(:)既可以省略，也可以不省略。如果都省略，則此匯編退化為一個(gè)基本內(nèi)聯(lián)匯編，否則，仍然是一個(gè)帶有C/C++表達(dá)式的內(nèi)聯(lián)匯編，此時(shí)"InstructionList"中的寄存器寫法要遵守相關(guān)規(guī)定，比如寄存器前必須使用兩個(gè)百分號(%%)，而不是像基本匯編格式一樣在寄存器前只使用一個(gè)百分號(%)。比如__asm__("mov%%eax,%%ebx"::)；__asm__("mov%%eax,%%ebx":)和__asm__("mov%eax,%ebx")都是正確的寫法，而__asm__("mov%eax,%ebx"::)；__asm__("mov%eax,%ebx":)和__asm__("mov%%eax,%%ebx")都是錯(cuò)誤的寫法。

如果Input，Clobber/Modify為空，但Output不為空，Input前的冒號(:)既可以省略，也可以不省略。比如__asm__("mov%%eax,%%ebx":"=b"(foo):)；__asm__("mov%%eax,%%ebx":"=b"(foo))都是正確的。

如果后面的部分不為空，而前面的部分為空，則前面的冒號(:)都必須保留，否則無法說明不為空的部分究竟是第幾部分。比如，Clobber/Modify，Output為空，而Input不為空，則Clobber/Modify前的冒號必須省略（前面的規(guī)則），而Output前的冒號必須為保留。如果Clobber/Modify不為空，而Input和Output都為空，則Input和Output前的冒號都必須保留。比如__asm__("mov%%eax,%%ebx"::"a"(foo))和__asm__("mov%%eax,%%ebx":::"ebx")。

從上面的規(guī)則可以看到另外一個(gè)事實(shí)，區(qū)分一個(gè)內(nèi)聯(lián)匯編是基本格式的還是帶有C/C++表達(dá)式格式的，其規(guī)則在于在"InstructionList"后是否有冒號(:)的存在，如果沒有則是基本格式的，否則，則是帶有C/C++表達(dá)式格式的。

兩種格式對寄存器語法的要求不同：基本格式要求寄存器前只能使用一個(gè)百分號(%)，這一點(diǎn)和非內(nèi)聯(lián)匯編相同；而帶有C/C++表達(dá)式格式則要求寄存器前必須使用兩個(gè)百分號(%%)，其原因我們會(huì)在后面討論。

1.Output

Output用來指定當(dāng)前內(nèi)聯(lián)匯編語句的輸出。我們看一看這個(gè)例子：

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

這個(gè)內(nèi)聯(lián)匯編語句的輸出部分為"=r"(cr0)，它是一個(gè)“操作表達(dá)式”，指定了一個(gè)輸出操作。我們可以很清楚得看到這個(gè)輸出操作由兩部分組成：括號括住的部分(cr0)和引號引住的部分"=a"。這兩部分都是每一個(gè)輸出操作必不可少的。括號括住的部分是一個(gè)C/C++表達(dá)式，用來保存內(nèi)聯(lián)匯編的一個(gè)輸出值，其操作就等于C/C++的相等賦值cr0=output_value，因此，括號中的輸出表達(dá)式只能是C/C++的左值表達(dá)式，也就是說它只能是一個(gè)可以合法的放在C/C++賦值操作中等號(=)左邊的表達(dá)式。那么右值output_value從何而來呢？

答案是引號中的內(nèi)容，被稱作“操作約束”（OperationConstraint），在這個(gè)例子中操作約束為"=a"，它包含兩個(gè)約束：等號(=)和字母a，其中等號(=)說明括號中左值表達(dá)式cr0是一個(gè)Write-Only的，只能夠被作為當(dāng)前內(nèi)聯(lián)匯編的輸入，而不能作為輸入。而字母a是寄存器EAX/AX/AL的簡寫，說明cr0的值要從eax寄存器中獲取，也就是說cr0=eax，最終這一點(diǎn)被轉(zhuǎn)化成匯編指令就是movl%eax,address_of_cr0?，F(xiàn)在你應(yīng)該清楚了吧，操作約束中會(huì)給出：到底從哪個(gè)寄存器傳遞值給cr0。

另外，需要特別說明的是，很多文檔都聲明，所有輸出操作的操作約束必須包含一個(gè)等號(=)，但GCC的文檔中卻很清楚的聲明，并非如此。因?yàn)榈忍?=)約束說明當(dāng)前的表達(dá)式是一個(gè)Write-Only的，但另外還有一個(gè)符號——加號(+)用來說明當(dāng)前表達(dá)式是一個(gè)Read-Write的，如果一個(gè)操作約束中沒有給出這兩個(gè)符號中的任何一個(gè)，則說明當(dāng)前表達(dá)式是Read-Only的。因?yàn)閷τ谳敵霾僮鱽碚f，肯定是必須是可寫的，而等號(=)和加號(+)都表示可寫，只不過加號(+)同時(shí)也表示是可讀的。所以對于一個(gè)輸出操作來說，其操作約束只需要有等號(=)或加號(+)中的任意一個(gè)就可以了。

二者的區(qū)別是：等號(=)表示當(dāng)前操作表達(dá)式指定了一個(gè)純粹的輸出操作，而加號(+)則表示當(dāng)前操作表達(dá)式不僅僅只是一個(gè)輸出操作還是一個(gè)輸入操作。但無論是等號(=)約束還是加號(+)約束所約束的操作表達(dá)式都只能放在Output域中，而不能被用在Input域中。

另外，有些文檔聲明：盡管GCC文檔中提供了加號(+)約束，但在實(shí)際的編譯中通不過；我不知道老版本會(huì)怎么樣，我在GCC2.96中對加號(+)約束的使用非常正常。

我們通過一個(gè)例子看一下，在一個(gè)輸出操作中使用等號(=)約束和加號(+)約束的不同。

$catexample2.c

intmain(int__argc,char*__argv[])

{

intcr0=5;

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

return0;

}

$gcc-Sexample2.c

$catexample2.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

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

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

$catexample3.c

intmain(int__argc,char*__argv[])

{

intcr0=5;

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

return0;

}

$gcc-Sexample3.c

$catexample3.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

從編譯的結(jié)果可以看出，當(dāng)使用加號(+)約束的時(shí)候，cr0不僅作為輸出，還作為輸入，所使用寄存器都是寄存器約束(字母a，表示使用eax寄存器)指定的。關(guān)于寄存器約束我們后面討論。

在Output域中可以有多個(gè)輸出操作表達(dá)式，多個(gè)操作表達(dá)式中間必須用逗號(,)分開。例如：

__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域的內(nèi)容用來指定當(dāng)前內(nèi)聯(lián)匯編語句的輸入。我們看一看這個(gè)例子：

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

例中Input域的內(nèi)容為一個(gè)表達(dá)式"a"[cpu->db7)，被稱作“輸入表達(dá)式”，用來表示一個(gè)對當(dāng)前內(nèi)聯(lián)匯編的輸入。

像輸出表達(dá)式一樣，一個(gè)輸入表達(dá)式也分為兩部分：帶括號的部分(cpu->db7)和帶引號的部分"a"。這兩部分對于一個(gè)內(nèi)聯(lián)匯編輸入表達(dá)式來說也是必不可少的。

括號中的表達(dá)式cpu->db7是一個(gè)C/C++語言的表達(dá)式，它不必是一個(gè)左值表達(dá)式，也就是說它不僅可以是放在C/C++賦值操作左邊的表達(dá)式，還可以是放在C/C++賦值操作右邊的表達(dá)式。所以它可以是一個(gè)變量，一個(gè)數(shù)字，還可以是一個(gè)復(fù)雜的表達(dá)式（比如a+b/c*d）。比如上例可以改為：__asm__("movl%0,%%db7"::"a"(foo))，__asm__("movl%0,%%db7"::"a"(0x1000))或__asm__("movl%0,%%db7"::"a"(va*vb/vc))。

引號號中的部分是約束部分，和輸出表達(dá)式約束不同的是，它不允許指定加號(+)約束和等號(=)約束，也就是說它只能是默認(rèn)的Read-Only的。約束中必須指定一個(gè)寄存器約束，例中的字母a表示當(dāng)前輸入變量cpu->db7要通過寄存器eax輸入到當(dāng)前內(nèi)聯(lián)匯編中。

我們看一個(gè)例子：

$catexample4.c

intmain(int__argc,char*__argv[])

{

intcr0=5;

__asm____volatile__("movl%0,%%cr0"::"a"(cr0));

return0;

}

$gcc-Sexample4.c

$catexample4.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

我們從編譯出的匯編代碼可以看到，在"InstructionList"之前，GCC按照我們的輸入約束"a"，將變量cr0的內(nèi)容裝入了eax寄存器。

3.OperationConstraint

每一個(gè)Input和Output表達(dá)式都必須指定自己的操作約束OperationConstraint，我們這里來討論在80386平臺(tái)上所可能使用的操作約束。

1、寄存器約束

當(dāng)你當(dāng)前的輸入或輸入需要借助一個(gè)寄存器時(shí)，你需要為其指定一個(gè)寄存器約束。你可以直接指定一個(gè)寄存器的名字，比如：

__asm____volatile__("movl%0,%%cr0"::"eax"(cr0));

也可以指定一個(gè)縮寫，比如：

__asm____volatile__("movl%0,%%cr0"::"a"(cr0));

如果你指定一個(gè)縮寫，比如字母a，則GCC將會(huì)根據(jù)當(dāng)前操作表達(dá)式中C/C++表達(dá)式的寬度決定使用%eax，還是%ax或%al。比如：

unsignedshort__shrt;

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

由于變量__shrt是16-bitshort類型，則編譯出來的匯編代碼中，則會(huì)讓此變量使用%ex寄存器。編譯結(jié)果為：

movw-2(%ebp),%ax#%ax=__shrt

#APP

movl%ax,%bx

#NO_APP

無論是Input，還是Output操作表達(dá)式約束，都可以使用寄存器約束。

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

約束Input/Output意義

rI,O表示使用一個(gè)通用寄存器，由GCC在%eax/%ax/%al,%ebx/%bx/%bl,%ecx/%cx/%cl,%edx/%dx/%dl中選取一個(gè)GCC認(rèn)為合適的。

qI,O表示使用一個(gè)通用寄存器，和r的意義相同。

aI,O表示使用%eax/%ax/%al

bI,O表示使用%ebx/%bx/%bl

cI,O表示使用%ecx/%cx/%cl

dI,O表示使用%edx/%dx/%dl

DI,O表示使用%edi/%di

SI,O表示使用%esi/%si

fI,O表示使用浮點(diǎn)寄存器

tI,O表示使用第一個(gè)浮點(diǎn)寄存器

uI,O表示使用第二個(gè)浮點(diǎn)寄存器

2、內(nèi)存約束

如果一個(gè)Input/Output操作表達(dá)式的C/C++表達(dá)式表現(xiàn)為一個(gè)內(nèi)存地址，不想借助于任何寄存器，則可以使用內(nèi)存約束。比如：

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

我們看一下它們分別被放在一個(gè)C源文件中，然后被GCC編譯后的結(jié)果：

$catexample5.c

//本例中，變量sh被作為一個(gè)內(nèi)存輸入

intmain(int__argc,char*__argv[])

{

char*sh=(char*)&__argc;

__asm____volatile__("lidt%0"::"m"(sh));

return0;

}

$gcc-Sexample5.c

$catexample5.s

main:

pushl%ebp

movl%esp,%ebp

subl$4,%esp

leal8(%ebp),%eax

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

#APP

lidt-4(%ebp)

#NO_APP

movl$0,%eax

leave

ret

$catexample6.c

//本例中，變量sh被作為一個(gè)內(nèi)存輸出

intmain(int__argc,char*__argv[])

{

char*sh=(char*)&__argc;

__asm____volatile__("lidt%0":"=m"(sh));

return0;

}

$gcc-Sexample6.c

$catexample6.s

main:

pushl%ebp

movl%esp,%ebp

subl$4,%esp

leal8(%ebp),%eax

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

#APP

lidt-4(%ebp)

#NO_APP

movl$0,%eax

leave

ret

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

其次，通過仔細(xì)觀察，你會(huì)發(fā)現(xiàn)一個(gè)驚人的事實(shí)，兩個(gè)例子編譯出來的匯編代碼是一樣的！雖然，一個(gè)例子中變量sh作為輸入，而另一個(gè)例子中變量sh作為輸出。這是怎么回事？

原來，使用內(nèi)存方式進(jìn)行輸入輸出時(shí)，由于不借助寄存器，所以GCC不會(huì)按照你的聲明對其作任何的輸入輸出處理。GCC只會(huì)直接拿來用，究竟對這個(gè)C/C++表達(dá)式而言是輸入還是輸出，完全依賴與你寫在"InstructionList"中的指令對其操作的指令。

由于上例中，對其操作的指令為lidt，lidt指令的操作數(shù)是一個(gè)輸入型的操作數(shù)，所以事實(shí)上對變量sh的操作是一個(gè)輸入操作，即使你把它放在Output域也不會(huì)改變這一點(diǎn)。所以，對此例而言，完全符合語意的寫法應(yīng)該是將sh放在Input域，盡管放在Output域也會(huì)有正確的執(zhí)行結(jié)果。

所以，對于內(nèi)存約束類型的操作表達(dá)式而言，放在Input域還是放在Output域，對編譯結(jié)果是沒有任何影響的，因?yàn)楸緛砦覀儗⒁粋€(gè)操作表達(dá)式放在Input域或放在Output域是希望GCC能為我們自動(dòng)通過寄存器將表達(dá)式的值輸入或輸出。既然對于內(nèi)存約束類型的操作表達(dá)式來說，GCC不會(huì)自動(dòng)為它做任何事情，那么放在哪兒也就無所謂了。但從程序員的角度而言，為了增強(qiáng)代碼的可讀性，最好能夠把它放在符合實(shí)際情況的地方。

約束Input/Output意義

mI,O表示使用系統(tǒng)所支持的任何一種內(nèi)存方式，不需要借助寄存器

3、立即數(shù)約束

如果一個(gè)Input/Output操作表達(dá)式的C/C++表達(dá)式是一個(gè)數(shù)字常數(shù)，不想借助于任何寄存器，則可以使用立即數(shù)約束。

由于立即數(shù)在C/C++中只能作為右值，所以對于使用立即數(shù)約束的表達(dá)式而言，只能放在Input域。

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

立即數(shù)約束很簡單，也很容易理解，我們在這里就不再贅述。

約束Input/Output意義

iI表示輸入表達(dá)式是一個(gè)立即數(shù)(整數(shù))，不需要借助任何寄存器

FI表示輸入表達(dá)式是一個(gè)立即數(shù)(浮點(diǎn)數(shù))，不需要借助任何寄存器

4、通用約束

約束Input/Output意義

gI,O表示可以使用通用寄存器，內(nèi)存，立即數(shù)等任何一種處理方式。

0,1,2,3,4,5,6,7,8,9I表示和第n個(gè)操作表達(dá)式使用相同的寄存器/內(nèi)存。

通用約束g是一個(gè)非常靈活的約束，當(dāng)程序員認(rèn)為一個(gè)C/C++表達(dá)式在實(shí)際的操作中，究竟使用寄存器方式，還是使用內(nèi)存方式或立即數(shù)方式并無所謂時(shí)，或者程序員想實(shí)現(xiàn)一個(gè)靈活的模板，讓GCC可以根據(jù)不同的C/C++表達(dá)式生成不同的訪問方式時(shí)，就可以使用通用約束g。比如：

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

JUST_MOV(100)和JUST_MOV(var)則會(huì)讓編譯器產(chǎn)生不同的代碼。

intmain(int__argc,char*__argv[])

{

JUST_MOV(100);

return0;

}

編譯后生成的代碼為：

main:

pushl%ebp

movl%esp,%ebp

#APP

movl$100,%eax

#NO_APP

movl$0,%eax

popl%ebp

ret

很明顯這是立即數(shù)方式。而下一個(gè)例子：

intmain(int__argc,char*__argv[])

{

JUST_MOV(__argc);

return0;

}

經(jīng)編譯后生成的代碼為：

main:

pushl%ebp

movl%esp,%ebp

#APP

movl8(%ebp),%eax

#NO_APP

movl$0,%eax

popl%ebp

ret

這個(gè)例子是使用內(nèi)存方式。

一個(gè)帶有C/C++表達(dá)式的內(nèi)聯(lián)匯編，其操作表達(dá)式被按照被列出的順序編號，第一個(gè)是0，第2個(gè)是1，依次類推，GCC最多允許有10個(gè)操作表達(dá)式。比如：

__asm__("popl%0\n\t"

"movl%1,%%esi\n\t"

"movl%2,%%edi\n\t"

:"=a"(__out)

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

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

再如：

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

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

如果某個(gè)Input操作表達(dá)式使用數(shù)字0到9中的一個(gè)數(shù)字（假設(shè)為1）作為它的操作約束，則等于向GCC聲明：“我要使用和編號為1的Output操作表達(dá)式相同的寄存器（如果Output操作表達(dá)式1使用的是寄存器），或相同的內(nèi)存地址（如果Output操作表達(dá)式1使用的是內(nèi)存）”。上面的描述包含兩個(gè)限定：數(shù)字0到數(shù)字9作為操作約束只能用在Input操作表達(dá)式中，被指定的操作表達(dá)式（比如某個(gè)Input操作表達(dá)式使用數(shù)字1作為約束，那么被指定的就是編號為1的操作表達(dá)式）只能是Output操作表達(dá)式。

由于GCC規(guī)定最多只能有10個(gè)Input/Output操作表達(dá)式，所以事實(shí)上數(shù)字9作為操作約束永遠(yuǎn)也用不到，因?yàn)镺utput操作表達(dá)式排在Input操作表達(dá)式的前面，那么如果有一個(gè)Input操作表達(dá)式指定了數(shù)字9作為操作約束的話，那么說明Output操作表達(dá)式的數(shù)量已經(jīng)至少為10個(gè)了，那么再加上這個(gè)Input操作表達(dá)式，則至少為11個(gè)了，以與超出GCC的限制。

5、ModifierCharacters（修飾符）

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

當(dāng)使用加號(+)的時(shí)候，此Output表達(dá)式等價(jià)于使用等號(=)約束加上一個(gè)Input表達(dá)式。比如

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

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

但如果使用后一種寫法，"InstructionList"中的別名也要相應(yīng)的改動(dòng)。關(guān)于別名，我們后面會(huì)討論。

像等號(=)和加號(+)修飾符一樣，符號(&)也只能用于對Output操作表達(dá)式的修飾。當(dāng)使用它進(jìn)行修飾時(shí)，等于向GCC聲明："GCC不得為任何Input操作表達(dá)式分配與此Output操作表達(dá)式相同的寄存器"。其原因是&修飾符意味著被其修飾的Output操作表達(dá)式要在所有的Input操作表達(dá)式被輸入前輸出。我們看下面這個(gè)例子：

intmain(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));

return0;

}

此例中，%0對應(yīng)的就是Output操作表達(dá)式，它被指定的寄存器是%eax，整個(gè)InstructionList的第一條指令popl%0，編譯后就成為popl%eax，這時(shí)%eax的內(nèi)容已經(jīng)被修改，隨后在InstructionList后，GCC會(huì)通過movl%eax,address_of_out這條指令將%eax的內(nèi)容放置到Output變量__out中。對于本例中的兩個(gè)Input操作表達(dá)式而言，它們的寄存器約束為"r"，即要求GCC為其指定合適的寄存器，然后在InstructionList之前將__in1和__in2的內(nèi)容放入被選出的寄存器中，如果它們中的一個(gè)選擇了已經(jīng)被__out指定的寄存器%eax，假如是__in1，那么GCC在InstructionList之前會(huì)插入指令movladdress_of_in1,%eax，那么隨后popl%eax指令就修改了%eax的值，此時(shí)%eax中存放的已經(jīng)不是Input變量__in1的值了，那么隨后的movl%1,%%esi指令，將不會(huì)按照我們的本意——即將__in1的值放入%esi中——而是將__out的值放入%esi中了。

下面就是本例的編譯結(jié)果，很明顯，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聲明這一點(diǎn)，要求GCC為所有的Input操作表達(dá)式指定別的寄存器，方法就是在Output操作表達(dá)式"=a"(__out)的操作約束中加入&約束，由于GCC規(guī)定等號(=)約束必須放在第一個(gè)，所以我們寫作"=&a"(__out)。

下面是我們將&約束加入之后編譯的結(jié)果：

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！這下好了，完全與我們的意圖吻合。

如果一個(gè)Output操作表達(dá)式的寄存器約束被指定為某個(gè)寄存器，只有當(dāng)至少存在一個(gè)Input操作表達(dá)式的寄存器約束為可選約束時(shí)，（可選約束的意思是可以從多個(gè)寄存器中選取一個(gè)，或使用非寄存器方式），比如"r"或"g"時(shí)，此Output操作表達(dá)式使用&修飾才有意義。如果你為所有的Input操作表達(dá)式指定了固定的寄存器，或使用內(nèi)存/立即數(shù)約束，則此Output操作表達(dá)式使用&修飾沒有任何意義。比如：

__asm__("popl%0\n\t"

"movl%1,%%esi\n\t"

"movl%2,%%edi\n\t"

:"=&a"(__out)

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

此例中的Output操作表達(dá)式完全沒有必要使用&來修飾，因?yàn)開_in1和__in2都被指定了固定的寄存器，或使用了內(nèi)存方式，GCC無從選擇。

但如果你已經(jīng)為某個(gè)Output操作表達(dá)式指定了&修飾，并指定了某個(gè)固定的寄存器，你就不能再為任何Input操作表達(dá)式指定這個(gè)寄存器，否則會(huì)出現(xiàn)編譯錯(cuò)誤。比如：

__asm__("popl%0\n\t"

"movl%1,%%esi\n\t"

"movl%2,%%edi\n\t"

:"=&a"(__out)

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

本例中，由于__out已經(jīng)指定了寄存器%eax，同時(shí)使用了符號&修飾，則再為__in1指定寄存器%eax就是非法的。

反過來，你也可以為Output指定可選約束，比如"r","g"等，讓GCC為其選擇到底使用哪個(gè)寄存器，還是使用內(nèi)存方式，GCC在選擇的時(shí)候，會(huì)首先排除掉已經(jīng)被Input操作表達(dá)式使用的所有寄存器，然后在剩下的寄存器中選擇，或干脆使用內(nèi)存方式。比如：

__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已經(jīng)被__in1和__in2使用，那么GCC在為__out選擇的時(shí)候，只會(huì)在%ebx和%edx中選擇。

前3個(gè)修飾符只能用在Output操作表達(dá)式中，而百分號[%]修飾符恰恰相反，只能用在Input操作表達(dá)式中，用于向GCC聲明：“當(dāng)前Input操作表達(dá)式中的C/C++表達(dá)式可以和下一個(gè)Input操作表達(dá)式中的C/C++表達(dá)式互換”。這個(gè)修飾符號一般用于符合交換律運(yùn)算，比如加(+)，乘(*)，與(&)，或(|)等等。我們看一個(gè)例子：

intmain(int__argc,char*__argv[])

{

int__in1=8,__in2=4,__out=3;

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

:"=r"(__out)

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

return0;

}

在此例中，由于指令是一個(gè)加法運(yùn)算，相當(dāng)于等式__out=__in1+__in2，而它與等式__out=__in2+__in1沒有什么不同。所以使用百分號修飾，讓GCC知道__in1和__in2可以互換，也就是說GCC可以自動(dòng)將本例的內(nèi)聯(lián)匯編改變?yōu)椋?/p>

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

:"=r"(__out)

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

修飾符Input/Output意義

=O表示此Output操作表達(dá)式是Write-Only的

+O表示此Output操作表達(dá)式是Read-Write的

&O表示此Output操作表達(dá)式獨(dú)占為其指定的寄存器

%I表示此Input操作表達(dá)式中的C/C++表達(dá)式可以和下一個(gè)Input操作表達(dá)式中的C/C++表達(dá)式互換

4.占位符

什么叫占位符？我們看一看下面這個(gè)例子：

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

:"=a"(__out)

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

這個(gè)例子中的%0和%1就是占位符。每一個(gè)占位符對應(yīng)一個(gè)Input/Output操作表達(dá)式。我們在之前已經(jīng)提到，GCC規(guī)定一個(gè)內(nèi)聯(lián)匯編語句最多可以有10個(gè)Input/Output操作表達(dá)式，然后按照它們被列出的順序依次賦予編號0到9。對于占位符中的數(shù)字而言，和這些編號是對應(yīng)的。

由于占位符前面使用一個(gè)百分號(%)，為了區(qū)別占位符和寄存器，GCC規(guī)定在帶有C/C++表達(dá)式的內(nèi)聯(lián)匯編中，"InstructionList"中直接寫出的寄存器前必須使用兩個(gè)百分號(%%)。

GCC對其進(jìn)行編譯的時(shí)候，會(huì)將每一個(gè)占位符替換為對應(yīng)的Input/Output操作表達(dá)式所指定的寄存器/內(nèi)存地址/立即數(shù)。比如在上例中，占位符%0對應(yīng)Output操作表達(dá)式"=a"(__out)，而"=a"(__out)指定的寄存器為%eax，所以把占位符%0替換為%eax，占位符%1對應(yīng)Input操作表達(dá)式"m"(__in1)，而"m"(__in1)被指定為內(nèi)存操作，所以把占位符%1替換為變量__in1的內(nèi)存地址。

也許有人認(rèn)為，在上面這個(gè)例子中，完全可以不使用%0，而是直接寫%%eax，就像這樣：

__asm__("addl%1,%%eax\n\t"

:"=a"(__out)

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

和上面使用占位符%0沒有什么不同，那么使用占位符%0就沒有什么意義。確實(shí)，兩者生成的代碼完全相同，但這并不意味著這種情況下占位符沒有意義。因?yàn)槿绻皇褂谜嘉环敲串?dāng)有一天你想把變量__out的寄存器約束由a改為b時(shí)，那么你也必須將addl指令中的%%eax改為%%ebx，也就是說你需要同時(shí)修改兩個(gè)地方，而如果你使用占位符，你只需要修改一次就夠了。另外，如果你不使用占位符，將不利于代碼的清晰性。在上例中，如果你使用占位符，那么你一眼就可以得知，addl指令的第二個(gè)操作數(shù)內(nèi)容最終會(huì)輸出到變量__out中；否則，如果你不用占位符，而是直接將addl指令的第2個(gè)操作數(shù)寫為%%eax，那么你需要考慮一下才知道它最終需要輸出到變量__out中。這是占位符最粗淺的意義。畢竟在這種情況下，你完全可以不用。

但對于這些情況來說，不用占位符就完全不行了：

首先，我們看一看上例中的第1個(gè)Input操作表達(dá)式"m"(__in1)，它被GCC替換之后，表現(xiàn)為addladdress_of_in1,%%eax，__in1的地址是什么？編譯時(shí)才知道。所以我們完全無法直接在指令中去寫出__in1的地址，這時(shí)使用占位符，交給GCC在編譯時(shí)進(jìn)行替代，就可以解決這個(gè)問題。所以這種情況下，我們必須使用占位符。

其次，如果上例中的Output操作表達(dá)式"=a"(__out)改為"=r"(__out)，那么__out在究竟使用那么寄存器只有到編譯時(shí)才能通過GCC來決定，既然在我們寫代碼的時(shí)候，我們不知道究竟哪個(gè)寄存器被選擇，我們也就不能直接在指令中寫出寄存器的名稱，而只能通過占位符替代來解決。

5.Clobber/Modify

有時(shí)候，你想通知GCC當(dāng)前內(nèi)聯(lián)匯編語句可能會(huì)對某些寄存器或內(nèi)存進(jìn)行修改，希望GCC在編譯時(shí)能夠?qū)⑦@一點(diǎn)考慮進(jìn)去。那么你就可以在Clobber/Modify域聲明這些寄存器或內(nèi)存。

這種情況一般發(fā)生在一個(gè)寄存器出現(xiàn)在"InstructionList"，但卻不是由Input/Output操作表達(dá)式所指定的，也不是在一些Input/Output操作表達(dá)式使用"r","g"約束時(shí)由GCC為其選擇的，同時(shí)此寄存器被"InstructionList"中的指令修改，而這個(gè)寄存器只是供當(dāng)前內(nèi)聯(lián)匯編臨時(shí)使用的情況。比如：

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

寄存器%ebx出現(xiàn)在"InstructionList中"，并且被movl指令修改，但卻未被任何Input/Output操作表達(dá)式指定，所以你需要在Clobber/Modify域指定"bx"，以讓GCC知道這一點(diǎn)。

因?yàn)槟阍贗nput/Output操作表達(dá)式所指定的寄存器，或當(dāng)你為一些Input/Output操作表達(dá)式使用"r","g"約束，讓GCC為你選擇一個(gè)寄存器時(shí)，GCC對這些寄存器是非常清楚的——它知道這些寄存器是被修改的，你根本不需要在Clobber/Modify域再聲明它們。但除此之外，GCC對剩下的寄存器中哪些會(huì)被當(dāng)前的內(nèi)聯(lián)匯編修改一無所知。所以如果你真的在當(dāng)前內(nèi)聯(lián)匯編指令中修改了它們，那么就最好在Clobber/Modify中聲明它們，讓GCC針對這些寄存器做相應(yīng)的處理。否則有可能會(huì)造成寄存器的不一致，從而造成程序執(zhí)行錯(cuò)誤。

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

__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"就可以了，因?yàn)槠渌亩己退鼈冎械囊粋€(gè)是等價(jià)的。

如果你在一個(gè)內(nèi)聯(lián)匯編語句的Clobber/Modify域向GCC聲明某個(gè)寄存器內(nèi)容發(fā)生了改變，GCC在編譯時(shí)，如果發(fā)現(xiàn)這個(gè)被聲明的寄存器的內(nèi)容在此內(nèi)聯(lián)匯編語句之后還要繼續(xù)使用，那么GCC會(huì)首先將此寄存器的內(nèi)容保存起來，然后在此內(nèi)聯(lián)匯編語句的相關(guān)生成代碼之后，再將其內(nèi)容恢復(fù)。我們來看兩個(gè)例子，然后對比一下它們之間的區(qū)別。

這個(gè)例子中聲明了寄存器%ebx內(nèi)容發(fā)生了改變：

$catexample7.c

intmain(int__argc,char*__argv[])

{

intin=8;

__asm__("addl%0,%%ebx"

:/*nooutput*/

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

return0;

}

$gcc-O-Sexample7.c

$catexample7.s

main:

pushl%ebp

movl%esp,%ebp

pushl%ebx#%ebx內(nèi)容被保存

movl$8,%eax

#APP

addl%eax,%ebx

#NO_APP

movl$0,%eax

movl(%esp),%ebx#%ebx內(nèi)容被恢復(fù)

leave

ret

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

$catexample8.c

intmain(int__argc,char*__argv[])

{

intin=8;

__asm__("addl%0,%%ebx"

:/*nooutput*/

:"a"(