.3GCCInlineASM

GCC支持在C/C++代碼中嵌入?yún)R編代碼，這些匯編代碼被稱作GCCInline

ASM一一GCC內(nèi)聯(lián)匯編。這是一個特別有用的功能，有利于我們將一些C/C++語法無法

表達(dá)的指令干脆潛入C/C++代碼中，另外也允許我們干脆寫C/C++代碼中運用匯編編寫

簡潔高效的代碼。

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

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

_asm_("movl%espz%eax");//看起來很熟識吧！

或者是

一asm—("

movl$l,%eax//SYS_exit

xor%ebx,%ebx

int$0x80

")；

或

_asm_(

n

"movl$lz%eax\r\t\

"xor%ebxz%ebx\r\t"\

"int$0x80"\

)；

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

_asm____volatile—("InstructionList");

_asm—

asm—是GCC關(guān)鍵字asm的宏定義:

#defineasmasm

_asm_或asm用來聲明一個內(nèi)聯(lián)匯編表達(dá)式，所以任何一個內(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)存作了改動〃，GCC在編譯

的時候，會將此因素考慮進去。

我們看一看下面這個例子：

$catexamplel.c

intmain(int_argczchar*_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)化編譯的時候能夠很聰慧的發(fā)覺這一點。我

們運用下面的吩咐行對其進行編譯：

$gcc-0-Sexamplel.c

選項-0表示優(yōu)化編譯，我們還可以指定優(yōu)化等級，比如-02表示優(yōu)化等級為2；選項5表

示將C/C++源文件編譯為匯編文件，文件名和C/C++文件一樣，只不過擴展名由.c變

為

我們來查看一下被放在examplel.s中的編譯結(jié)果，我們這里僅僅列出了運用gcc2.96

在redhat7.3上編譯后的相關(guān)函數(shù)部分匯編代碼。為了保持清晰性，無關(guān)的其它代碼未被

列出。

$catexamplel.s

main:

pushl%ebp

movl%espz%ebp

movl8(%ebp)z%eax#int*—p=(int*)—argc

movl$9999,(%eax)#(*—p)=9999

movl$5,%eax#return5

popl%ebp

ret

參照一下C源碼和編譯出的匯編代碼，我們會發(fā)覺匯編代碼中，沒有if語句相關(guān)的代碼，

而是在賦值語句(*_p)=9999后干脆return5：這是因為GCC認(rèn)為在(*_p)被賦值之

后，在if語句之前沒有任何變更(*_p)內(nèi)容的操作，所以那條if語句的推斷條件(*_p)==

9999確定是為true的，所以GCC就不再生成相關(guān)代碼，而是干脆依據(jù)為true的條件生

成return5的匯編代碼(GCC運用eax作為保存返回值的寄存器)。

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

$gcc-O-Sexamplel.c

$catexamplel.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)z%eax

.L2:

popl%ebp

ret

由于內(nèi)聯(lián)匯編語句_asm_("“：：："memory")向GCC聲明，在此內(nèi)聯(lián)匯編語句出現(xiàn)的位

置內(nèi)存內(nèi)容可能了變更，所以GCC在編譯時就不能像剛才那樣處理。這次，GCC老醇厚

實的將if語句生成了匯編代碼。

可能有人會質(zhì)疑：為什么要運用_asm_(""：：/memory")向GCC聲明內(nèi)存發(fā)生了變

更？明明''InstructionList〃是空的，沒有任何對內(nèi)存的操作，這樣做只會增加GCC生成

匯編代碼的數(shù)量。

確實，那條內(nèi)聯(lián)匯編語句沒有對內(nèi)存作任何操作，事實上它的確什么都沒有做。但影響內(nèi)

存內(nèi)容的不僅僅是你當(dāng)前正在運行的程序。比如，假如你現(xiàn)在正在操作的內(nèi)存是一塊內(nèi)存

映射，映射的內(nèi)容是外圍I/O設(shè)備寄存器。那么操作這塊內(nèi)存的就不僅僅是當(dāng)前的程序，

I/O設(shè)備也會去操作這塊內(nèi)存。既然兩者都會去操作同一塊內(nèi)存，那么任何一方在任何時

候都不能對這塊內(nèi)存的內(nèi)容想當(dāng)然。所以當(dāng)你運用高級語言C/C++寫這類程序的時候，你

必需讓編譯器也能夠明白這一點，終歸高級語言最終要被編譯為匯編代碼。

你可能已經(jīng)留意到了，這次輸出的匯編結(jié)果中，有兩個符號：#APPGCC

將內(nèi)聯(lián)匯編語句中“InstructionList”所列出的指令放在#APP和#1\10_慶「「之間，由于

―asm—("“：：/memory")中"InstructionList〃為空，所以#APP和#NO_APP中間也

沒有任何內(nèi)容。但我們以后的例子會更加清晰的表現(xiàn)這一點。

關(guān)于為什么內(nèi)聯(lián)匯編_asm_("“："“memory”)是一條聲明內(nèi)存變更的語句，我們后面會

具體探討。

剛才我們花了大量的內(nèi)容來探討“InstructionList”為空是的狀況，但在實際的編程中，

"InstructionList"絕大多數(shù)狀況下都不是空的。它可以有1條或隨意多條匯編指令.

當(dāng)在“InstructionList”中有多條指令的時候，你可以在一對引號中列出全部指令，也可以

將一條或幾條指令放在一對引號中，全部指令放在多對引號中。假如是前者，你可以將每

一條指令放在一行，假如要將多條指令放在一行，則必需用分號(；)或換行符(\n,大多

數(shù)狀況下\n后還要跟一個\t,其中\(zhòng)n是為了換行，\t是為了空出一個tab寬度的空格)

將它們分開。比如：

—asm—("movl%eaxz%ebx

sti

popl%edi

subl%ecx,%ebx");

asm("movl%eaxz%ebx;sti

popl%edi;subl%ecx,%ebx");

_asm_("movl%eax,%ebx;sti\n\tpopl%edi

subl%ecxz%ebx");

都是合法的寫法。假如你將指令放在多對引號中，則除了最終一對引號之外，前面的全部引

號里的最終一條指令之后都要有一個分號(；)或(\「)或(\ri\t)。比如：

—asm—("movl%eaxz%ebx

sti\n"

"popl%edi;"

"subl%ecx,%ebx");

_asm_("movl%eaxz%ebx;sti\n\t"

"popl%edi;subl%ecxz%ebx");

_asm_("movl%eax,%ebx;sti\n\tpopl%edi\n"

"subl%ecxz%ebx");

_asm_("movl%eaxz%ebx;sti\n\tpopl%edi;""subl%ecx,%ebx");

都是合法的。

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

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

放在兩行的方法既可以從通過\n的方法來實現(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%ebxz%ecx\n\t"

"jneerror\n\t"

"sti\n\t"

"error:popl%edi\n\t"

"subl%ecxz%ebx");

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

寫內(nèi)聯(lián)匯編代碼。

3、_volatile_

volatile—是GCC關(guān)鍵字volatile的宏定義:

#define_volatile_volatile

—volatile—或volatile是可選的，你可以用它也可以不用它。假如你用了它，則是向

GCC聲明''不要動我所寫的InstructionList,我須要原封不動的保留每?條指令〃，否則

當(dāng)你運用了優(yōu)化選項(-0)進行編譯時，GCC將會依據(jù)自己的推斷確定是否將這個內(nèi)聯(lián)匯編

表達(dá)式中的指令優(yōu)化掉。

那么GCC推斷的原則是什么？我不知道(假如有哪位摯友清晰的話，請告知我)。我試驗

了一下，發(fā)覺一條內(nèi)聯(lián)匯編語句假如是基本內(nèi)聯(lián)匯編的話(即只有''InstructionList",沒

有Input/Output/Clobber的內(nèi)聯(lián)匯編，我們后面將會探討這一點)，無論你是否運用

_volatile_來修飾，GCC2.96在優(yōu)化編譯時，都會原封不動的保留內(nèi)聯(lián)匯編中的

''InstructionList、但或許我的試驗的例子并不充分，所以這一點并不能夠得到保證。

為了保險起見，假如你不想讓GCC的優(yōu)化影響你的內(nèi)聯(lián)匯編代碼，你最好在前面都加上

_volatile_,而不要依靠于編譯器的原則，因為即使你特別了解當(dāng)前編譯器的優(yōu)化原則，

你也無法保證這種原則將來不會發(fā)生變更。而_volatHe_的含義卻是恒定的。

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

GCC允許你通過C/C++表達(dá)式指定內(nèi)聯(lián)匯編中“InstrcuctionList”中指令的輸入和輸出，

你甚至可以不關(guān)切究竟運用哪個寄存器被運用，完全靠GCC來支配和指定。這一點可以讓

程序員避開去考慮有限的存存器的運用，也可以提高目標(biāo)代碼的效率。

我們先來看幾個例子：

_asm_("":::"memory");//前面提到的

_asm_("mov%%eax,%%ebx":"=b"(rv):na"(foo):"eax","ebx");

_asm____volatile_("lidt%0":"=m"(idt_descr));

_asm_("subl%2,%0\n\t”

"sbbl

:"=a"(endlow),"=d"(endhigh)

:"g"(startlow)z"g"(starthigh),"0"(endlow),"1"(endhigh));

怎么樣，有點印象了吧，是不是也有點暈？沒關(guān)系，下面探討完之后你就不會再暈了。(當(dāng)

然，也有可能更暈人_入)。探討起先一一

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

_asm__volatile_("InstructionList":Output:Input:Clobber/Modif/);

從中我們可以看出它和基本內(nèi)聯(lián)匯編的不同之處在F：它多了3個部分(Input,Output,

Clobber7Modify)。在括號中的4個部分通過冒號(:)分開。

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

如果Clobber/Modify為空，則其前面的冒號(:)必需省略。比如

_asm_("mov%%eaxz%%ebx":"=b"(foo):“a"(inp):)就是非法的寫法：而

―asm—("mov%%eax,%%ebx":"=b"(foo):"a"(inp))則是正確的。

假如InstructionList為空，MInput,Output,Clobber7Modify可以不為空，也可以

為空。比如_asm_"memory");^_asm_(""::);都是合法的寫法。

如果Output,Input,Clobber7Modify都為空，Output,Input之前的冒號(:)既可以

省略，也可以不省略。假如都省略，則此匯編退化為一個基本內(nèi)聯(lián)匯編，否則，仍舊是一

個帶有C/C++表達(dá)式的內(nèi)聯(lián)匯編，此時叫nstructionList”中的寄存器寫法要遵守相關(guān)規(guī)

定，比如寄存器前必需運用兩個百分號(％%),而不是像基本匯編格式一樣在寄存器前只

運用一個百分號(％)?比如_asm_("mov%%eax,%%ebx"::)；_asm_("

mov%%eax,%%ebx":)和—asm—("mov%eax,%ebx")都是正確的寫法，而

_asm_("mov%eax,%ebx"::)：_asm_("mov%eaxz%ebx":)和

—asm—("mov%%eax,%%ebx")都是錯誤的寫法。

假如Input,Clobber/Modify為空，但Output不為空，Input前的冒號⑴既可以省略,

也可以不省略。比如—asm—("mov%%eax,%%ebx":"=b"(foo):)；

_asm_("mov%%eaxz%%ebx":"=b"(foo))都是正確的。

假如后面的部分不為空，而前面的部分為空，則前面的冒號C)都必需保留，否則無法說明

不為空的部分原委是第幾部分。比如，Clobber/Modify,Output為空，而Input不為空,

則Clobber/Modify前的冒號必需省略(前面的規(guī)則)，而Output前的冒號必需為俁留。

假如Clobber/Modify不為空,而Input和Output都為空,則Input和Output前的冒

號都必需保留。比如_asm_("mov%%eaxz%%ebx"::"a"(foo))和

―asm—("mov%%eaxz%%ebx":::"ebx"),

從上面的規(guī)則可以看到另外一個事實，區(qū)分一個內(nèi)聯(lián)匯編是基本格式的還是帶有C/C++表

達(dá)式格式的，其規(guī)則在于在“InstructionList”后是否有冒號(:)的存在，假如沒有則是基本

格式的，否則，則是帶有C/C++表達(dá)式格式的。

兩種格式對寄存器語法的要求不同：基本格式要求寄存器前只能運用一個百分號(％)，這一

點和非內(nèi)聯(lián)匯編相同；而帶有C/C++表達(dá)式格式則要求寄存器前必需運用兩個百分號

(%%)＞其緣由我們會在后面探討。

1.Output

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

_asm_("movl%%crOz%0":"=a"(crO));

這個內(nèi)聯(lián)匯編語句的輸出部分為“二r"(crO),它是一個''操作表達(dá)式“，指定了一個輸出操

作。我們可以很清晰得看到這個輸出操作由兩部分組成：括號括住的部分(crO)和引號引住

的部分”二a"。這兩部分都是每一個輸出操作必不行少的。括號括住的部分是一個C/C++

表達(dá)式，用來保存內(nèi)聯(lián)匯編的一個輸出值，其操作就等于C/C++的相等賦值crO=

output_value,因此，括號中的輸出表達(dá)式只能是C/C++的左值表達(dá)式，也就是說它只

能是一個可以合法的放在C/C++賦值操作中等號(=)左邊的表達(dá)式。那么右值

output_value從何而來呢？

答案是引號中的內(nèi)容，被稱作''操作約束〃(OperationConstraint),在這個例子中操作約

束為“二a"，它包含兩個約束：等號(=)和字母a,其中等號(=)說明括號中左值表達(dá)式c「0

是一個Write-Only的，只能夠被作為當(dāng)前內(nèi)聯(lián)匯編的輸入，而不能作為輸入。而字母a

是寄存器EAX/AX/AL的簡寫，說明crO的值要從eax寄存器中獲得，也就是說crO二

eax,最終這一點被轉(zhuǎn)化成匯編指令就是movl%eaxzaddress_of_crOo現(xiàn)在你應(yīng)當(dāng)清

晰了吧，操作約束中會給出：究竟從哪個寄存器傳遞值給crO.

另外，須要特殊說明的是，許多文檔都聲明，全部輸出操作的操作約束必需包含一個等號

（=）,但GCC的文檔中卻很清晰的聲明，并非如此。因為等號（二）約束說明當(dāng)前的表達(dá)式

是一個Write-Only的，但另外還有一個符號一一加號（+）用來說明當(dāng)前表達(dá)式是一個

Read-Write的，假如一個操作約束中沒有給出這兩個符號中的任何一個，則說明當(dāng)前表

達(dá)式是Read-Only的。因為對于輸出操作來說，確定是必需是可寫的，而等號（二）和加號

（十）都表示可寫，只不過加號（+）同時也表示是可讀的。所以對于一個輸出操作來說，其操

作約束只須要有等號（二）或加號（+）中的隨意一個就可以了。

二者的區(qū)分是：等號（二）表示當(dāng)前操作表達(dá)式指定了一個純粹的輸出操作，而加號（+）則表

示當(dāng)前操作表達(dá)式不僅僅只是一個輸出操作還是一個輸入操作。但無論是等號（二）約束還是

加號（+）約束所約束的操作表達(dá)式都只能放在Output域中，而不能被用在Input域中。

另外，有些文檔聲明：盡管GCC文檔中供應(yīng)了加號（+）約束，但在實際的編譯中通不過；

我不知道老版本會怎么樣，我在GCC2.96中對加號（十）約束的運用特別正常。

我們通過一個例子看一下，在一個輸出操作中運用等號（二）約束和加號（+）約束的不同。

$catexample2.c

intmain（int_argc,char*_argv[]）

{

intcrO=5;

_asm____volatile_("movl%%crOz%0":"=a"(crO));

return0;

)

$gcc-Sexample2.c

$catexample2.s

main:

pushl%ebp

movl%espz%ebp

subl$4,%esp

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

#APP

movl%crO,%eax

#NO_APP

movl%eax,%eax

movl%eaxz-4(%ebp；#crO=%eax

movl$0,%eax

leave

ret

這個例子是運用等號(=)約束的狀況，變量crO被放在內(nèi)存-4(%ebp)的位置，所以指令

mov%eax,-4(%ebp)卻表示將％砥乂的內(nèi)容輸出到變量crO中。

下面是運用加號(+)約束的狀況：

$catexamples.c

intmain(int_argc,char*_argv[])

{

intcrO=5;

_asm____volatile_("movl%%crOz%0":"+a"(crO));

return0;

)

$gcc-Sexamples.c

$catexample3.s

main:

pushl%ebp

movl%espz%ebp

subl$4,%esp

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

movl-4(%ebp)z%eax#input(%eax=crO)

#APP

movl%crO,%eax

#NO_APP

movl%eaxz-4(%ebp；#output(crO=%eax)

movl$0,%eax

leave

ret

從編譯的結(jié)果可以看出，當(dāng)運川加號(+)約束的時候，c「0不僅作為輸出，還作為輸入，所

運用寄存器都是寄存器約束(字母a,表示運用eax寄存器)指定的。關(guān)于寄存器約束我們后

面探討。

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

如：

—asm—(

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

"pushl%%ebx\n\t"

"popl%1\n\t"

"movl%1,%2"

:"+a"(crO)z"=b"(crl)z"=c"(cr2));

2、Input

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

_asm_("movl%0z%%db7"::"a"(cpu->db7));

例中Input域的內(nèi)容為一個表達(dá)式“a”[cpu->db7),被稱作''輸入表達(dá)式〃，用來表示一個

對當(dāng)前內(nèi)聯(lián)匯編的輸入。

像輸出表達(dá)式一樣，一個輸入表達(dá)式也分為兩部分：帶括號的部分(cpu->db7)和帶引號的

部分“a“。這兩部分對于一個內(nèi)聯(lián)匯編輸入表達(dá)式來說也是必不行少的。

括號中的表達(dá)式cpu->db7是一個C/C++語言的表達(dá)式，它不必是一個左值表達(dá)式，也

就是說它不僅可以是放在C/C++賦值操作左邊的表達(dá)式，還可以是放在C/C++賦值操作

右邊的表達(dá)式。所以它可以是一個變量，一個數(shù)字，還可以是一個困難的表達(dá)式(比如

a+b/c*d)o比如上例可以改為：_asm_("movl%0,%%db7"::"a"(foo)),

_asm_("movl%0,%%db7"::"a"(0x1000))或

_asm_("movl%0z%%db7"::"a"(va*vb/vc))o

引號號中的部分是約束部分，和輸出表達(dá)式約束不同的是，它不允許指定加號(十)約束和

等號(=)約束，也就是說它只能是默認(rèn)的Read-Only的.約束中必需指定一個寄存器約束，

例中的字母a表示當(dāng)前輸入變量cpu->db7要通過寄存器eax輸入到當(dāng)前內(nèi)聯(lián)匯編中。

我們看一個例子：

$catexample4.c

intmain(int_argczchar*_argv[])

{

intcrO=5;

n

_asm____volatile_(movl%OZ%%crO"::"a"(crO));

return0;

?

$gcc-Sexample4.c

$catexample4.s

main:

pushl%ebp

movl%espz%ebp

subl$4,%esp

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

movl-4(%ebp)z%eax#%eax=crO

#APP

movl%eax,%crO

#NO_APP

movl$0,%eax

leave

ret

我們從編譯出的匯編代碼可以看到，在“InstructionList”之前，GCC依據(jù)我們的輸入約束

"a",將變量crO的內(nèi)容裝入了eax寄存器。

3.OperationConstraint

每一個Input和Output表達(dá)式都必需指定自己的操作約束OperationConstraint,我們

這里來探討在80386平臺上所可能運用的操作約束。

1、寄存器約束

當(dāng)你當(dāng)前的輸入或輸入須要借助一個寄存器時，你須要為其指定一個寄存器約束。你可以干

脆指定一個寄存器的名字，比如：

_asm____volatile—("movl%0,%%crO"::"eax"(crO));

也可以指定一個縮寫，比如：

asm____volatile_("movl%0,%%crO"::"a"(crO));

假如你指定一個縮寫，比如字母a,則GCC將會依據(jù)當(dāng)前操作表達(dá)式中C/C++表達(dá)式的

寬度確定運用％eax,還是%比如：

unsignedshort_shrt;

_asm_("mov%0,%%bx"::"a"(_shrt));

由「變量_shrt是16-bitshort類型，則編譯出來的匯編代碼中，則會讓此變量運用％ex

寄存器。編譯結(jié)果為：

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

#APP

movl%axz%bx

#NO_APP

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

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

約束Input/Output意義

rIz0表示運用一個通用寄存器，由GCC

?%eax/%ax/%al,%ebx/%bx/%blz%ecx/%cx/%cl,%edx/%dx/%dl中選取一

個GCC認(rèn)為合適的。

q1,0表示運用一個通用寄存器，和r的意義相同。

a1,0表示運用%eax/%ax/%al

b1,0表示運用％65乂/%bx/%bl

clz0表示運用%ecx/%cx/%cl

d1,0表示運用％6(^/%dx/%dl

D1,0表示運用%65/%di

S1,0表示運用%051/%si

fLO表示運用浮點寄存器

tIz0表示運用第一個浮點寄存器

u1,0表示運用其次個浮點寄存器

2、內(nèi)存約束

假如一個Input/Output操作表達(dá)式的C/C++表達(dá)式表現(xiàn)為一個內(nèi)存地址，不想借助于任

何寄存器，則可以運用內(nèi)存約束。比如：

_asm_("lidt%0""=m"(_idt_addr));或_asm

("lidt%0":："m"(_idt_addr));

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

$catexamples.c

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

intmain(int_argczchar*_argv[])

{

char*sh=(char*)&—argc;

_asm____volatile—("lidt%0"::"m"(sh));

return0;

?

$gcc-Sexamples.c

$catexamples.s

main:

pushl%ebp

movl%espz%ebp

subl$4,%esp

leal8(%ebp),%eax

movl%eax,-4(%ebpJ#sh=(char*)&—argc

#APP

lidt-4(%ebp)

#NO_APP

movl$0,%eax

leave

ret

$catexamples.c

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

intmain(int_argczchar*_argv[])

{

char*sh=(char*)&._argc;

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

return0;

?

$gcc-Sexamples.c

$catexample6.s

main:

pushl%ebp

movl%espz%ebp

subl$4Z%esp

leal8(%ebp)z%eax

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

#APP

lidt-4(%ebp)

#NO_APP

movl$0,%eax

leave

ret

首先，你會留意到，在這兩個例子中，變量sh沒有借助任何寄存器，而是干脆參加了指令

lidt的操作。

其次，通過細(xì)致視察，你會發(fā)覺一個驚人的事實，兩個例子編譯出來的匯編代碼是一樣的！

雖然，一個例子中變量sh作為輸入，而另一個例子中變量sh作為輸出。這是怎么回事？

原來，運用內(nèi)存方式進行輸入輸出時，由于不借助寄存器，所以GCC不會依據(jù)你的聲明對

其作任何的輸入輸出處理，GCC只會干脆拿來用，原委對這個C/C++表達(dá)式而言是輸入

還是輸出，完全依靠與你寫在“InstructionList”中的指令對其操作的指令。

由于上例中，對其操作的指令為lidt,lidt指令的操作數(shù)是一個輸入型的操作數(shù)，所以事

實上對變量sh的操作是一個輸入操作，即使你把它放在Output域也不會變更這一點。所

以，對此例而言，完全符合語意的寫法應(yīng)當(dāng)是將sh放在Input域，盡管放在Output域也

會有正確的執(zhí)行結(jié)果。

所以，對于內(nèi)存約束類型的操作表達(dá)式而言，放在Input域還是放在Output域，對編譯

結(jié)果是沒有任何影響的，可為原來我們將一個操作表達(dá)式放在Input域或放在Output域

是希望GCC能為我們自動通過寄存器將表達(dá)式的值輸入或輸出。既然對于內(nèi)存約束類型的

操作表達(dá)式來說，GCC不會自動為它做任何事情，那么放在哪兒也就無所謂了。但從程序

員的角度而言，為了增加代碼的可讀性，最好能夠把它放在符合實際狀況的地方。

約束Input/Output意義

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

3、馬上數(shù)約束

假如?個Input/Output操作表達(dá)式的C/C++表達(dá)式是一個數(shù)字常數(shù)，不想借助于任何寄

存器，則可以運用馬上數(shù)約束。

由于馬上數(shù)在C/C++中只能作為右值，所以對于運用馬上數(shù)約束的表達(dá)式而言，只能放在

Input域。

比如：_asm____volatile_("movl%Of%%eax"::"i"(100));

馬上數(shù)約束很簡潔，也很簡潔理解，我們在這里就不再贅述。

約束Input/Output意義

iI表示輸入表達(dá)式是一個馬上數(shù)(整數(shù))，不須要借助任何寄存器

FI表示輸入表達(dá)式是一個馬上數(shù)(浮點數(shù))，不須要借助任何寄存器

4、通用約束

約束Input/Output意義

g1,0表示可以運用通用寄存器，內(nèi)存，馬上數(shù)等任何一種處理方式。

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

通用約束g是一個特別敏捷的約束，當(dāng)程序員認(rèn)為一個C/C++表達(dá)式在實際的操作中，

原委運用寄存器方式,，還是運用內(nèi)存方式或馬上數(shù)方式并無所謂時，或者程序員想實現(xiàn)一

個敏捷的模板，讓GCC可以依據(jù)不同的C/C++表達(dá)式生成不同的訪問方式時，就可以運

用通用約束g。比如：

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

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

intmain(int_argczchar*_argv[])

{

JUST_MOV(100);

return0;

?

編譯后生成的代碼為：

main:

pushl%ebp

movl%espz%ebp

#APP

movl$100,%eax

#NO_APP

movl$0,%eax

popl%ebp

ret

很明顯這是馬上數(shù)方式。而下一個例子：

intmain(int_argc,char*_argv[])

{

JUST_MOV(_argc);

return0;

}

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

main:

pushl%ebp

movl%espz%ebp

#APP

movl8(%ebp)z%eax

#NO_APP

movl$0,%eax

popl%ebp

ret

這個例子是運用內(nèi)存方式，

一個帶有C/C十十表達(dá)式￡勺內(nèi)聯(lián)匯編，其操作表達(dá)式被依據(jù)被列出的依次編號，第一個是0,

第2個是1,依次類推，GCC最多允許有10個操作表達(dá)式。比如：

—asm—("popl%0\n\t"

"movl%lz%%esi\n\t"

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

:"=a"(_out)

："r"(_inl)z"r"(_in2));

此例中,_out所在的Output操作表達(dá)式被編號為0,T'(_inl)被編號為l,"r"(_in2)

被編號為2。

再如：

n

_asm_("movl%%eaxz%%ebx"::a"(_inl)z"b"(_in2));

此例中，七”(_inl)被編號為O”b”(_in2)被編號為1。

如果某個Input操作表達(dá)式運用數(shù)字0到9中的一個數(shù)字(假設(shè)為1)作為它的操作約束，

則等于向GCC聲明：''我要運用和編號為1的Output操作表達(dá)式相同的寄存器(假如

Output操作表達(dá)式1運用的是寄存器)，或相同的內(nèi)存地址(假如Output操作表達(dá)式1

運用的是內(nèi)存尸。上面的描述包含兩個限定:數(shù)字0到數(shù)字9作為操作約束只能用在Input

操作表達(dá)式中，被指定的操作表達(dá)式(比如某個Input操作表達(dá)式運用數(shù)字1作為約束，

那么被指定的就是編號為1的操作表達(dá)式)只能是Output操作表達(dá)式。

由于GCC規(guī)定最多只能有10個Input/Output操作表達(dá)式，所以事實上數(shù)字9作為操

作約束恒久也用不到，因為Output操作表達(dá)式排在Input操作表達(dá)式的前面，那么假如

有一個Input操作表達(dá)式指定了數(shù)字9作為操作約束的話，那么說明Output操作表達(dá)式

的數(shù)量已經(jīng)至少為10個了，那么再加上這個Input操作表達(dá)式，則至少為11個了，以與

超出GCC的限制。

5、ModifierCharacters(修飾符)

等號(二)和加號(+)用于對Output操作表達(dá)式的修飾，一個Output操作表達(dá)式要么被等

號(二)修飾，要么被加號(+)修飾，二者必居其一。運用等號(二)說明此Output操作表達(dá)

式是Write-Only的，運用加號(+)說明此Output操作表達(dá)式是Read-Write的。它們必

需被放在約束字符串的第一個字母。比如“a="(foo)是非法的，而“+g”(foo)則是合法的。

當(dāng)運用加號(+)的時候，此Output表達(dá)式等價于運用等號(二)約束加上個Input表達(dá)式。

比如

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

_asm_("movl%lz%%eax;addl%%eaxz%0":"=b"(foo):"b"(foo))

但假如運用后一種寫法，"InstructionList”中的別名也要相應(yīng)的改動。關(guān)于別名，我們后

面會探討。

像等號(二)和加號(+)修飾符一樣，符號(&)也只能用于對Output操作表達(dá)式的修飾。當(dāng)

運用它進行修飾時，等于向GCC聲明："GCC不得為任何Input操作表達(dá)式安排與此

Output操作表達(dá)式相同的寄存器”。其緣由是&修飾符意味著被其修飾的Output操作表達(dá)

式要在全部的Input操作表達(dá)式被輸入前輸出。我們看下面這個例子：

intmain(int_argczchar*_argv[])

{

intini=8,in2=4,out=3:

―asm—("popl%0\n\t"

"movl%lz%%esi\n\t"

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

:"=a"(_out)

："r"(_inl),"r"(_in2));

return0;

)

此例中，%0對應(yīng)的就是Output操作表達(dá)式，它被指定的寄存器是%eax,整個

InstructionList的第一條指令popl%0,編譯后就成為popl%eax,這時％eax的內(nèi)容

已經(jīng)被修改，隨后在InstructionList后，GCC會通過movl%eax,address_of_out

這條指令將％eax的內(nèi)容放置到Output變量—out中。對于本例中的兩個Input操作表

達(dá)式而言，它們的寄存器約束為“r"，即要求GCC為其指定合適的寄存器，然后在

InstructionList之前將—ini和—in2的內(nèi)容放入被選出的寄存器中，假如它們中的一個

選擇了已經(jīng)被_out指定的寄存器%eax,假如是_inl,那么GCC在InstructionList

之前會插入指令movladdress_of_inlz%eax,那么隨后popl%eax指令就修改

了％63乂的值，此時％eax中存放的已經(jīng)不是Input變量_ini的值了，那么隨后的

movl%1,%%esi指令，將不會依據(jù)我們的本意一一即將_inl的值放入％6S1中一一而

是將—OUt的值放入％651中了。

下面就是本例的編譯結(jié)果，很明顯，GCC為_Jn2選擇了和_out相同的寄存器％eax,

這與我們的初衷不符。

main:

pushl%ebp

movl%espz%ebp

subl$12z%esp

movl$8,-4(%ebp)

movl$4,-8(%ebp)

movl$3,-12(%ebp)

movl-4(%ebp)z%edx#—ini運用寄存器％edx

movl-8(%ebp)z%eax#_in2運用寄存器％eax

#APP

popl%eax

movl%edxz%esi

movl%eax,%edi

#NO_APP

movl%eaxz%eax

movl%eax,-12(%ebp)#—out運用寄存器%eax

movl$0,%eax

leave

ret

為了避開這種狀況，我們必需向GCC聲明這一點，要求GCC為全部的Input操作表達(dá)式

指定別的寄存器，方法就是在Output操作表達(dá)式(_out)的操作約束中加入&約束,

由于GCC規(guī)定等號(=)約束必需放在第一個，所以我們寫作”=&a”(__out)。

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

main:

pushl%ebp

movl%espz%ebp

subl$12,%esp

movl$8,-4(%ebp)

movl$4,-8(%ebp)

movl$3,-12(%ebp)

movl-4(%ebp)z%edx#_ini運用寄存器％edx

movl-8(%ebp)z%eax

movl%eax,%ecx#_in2運用寄存器%ecx

#APP

popl%eax

movl%edx,%esi

movl%ecxz%edi

#NO_APP

movl%eaxz%eax

movl%eax,-12(%ebp)#—out運用寄存器％eax

movl$0,%eax

leave

ret

OK!這下好了，完全與我們的意圖吻合。

如果一個Output操作表達(dá)式的寄存器約束被指定為某個寄存器，只有當(dāng)至少存在一個

Input操作表達(dá)式的寄存器約束為可選約束時，(可選約束的意思是可以從多個寄存器中選

取一個，或運用非寄存器方式)，比如”r“或”g”時，此Output操作表達(dá)式運用&修飾才有

意義。假如你為全部的Input操作表達(dá)式指定了固定的寄存器，或運用內(nèi)存/馬上數(shù)約束，

則此Output操作表達(dá)式運用&修飾沒有任何意義。比如：

_asm_("popl%0\n\t"

"movl%lz%%esi\n\t"

"movl°/o2,%%edi\n\t"

:"=&a"(_out)

:"m"(_inl)z"c"(_in2));

此例中的Output操作表達(dá)式完全沒有必要運用&來修飾，因為_inl和_in2都被指定了

固定的寄存器，或運用了內(nèi)存方式，GCC無從選擇。

但假如你已經(jīng)為某個Output操作表達(dá)式指定了&修飾，并指定了某個固定的寄存器，你就

不能再為任何Input操作表達(dá)式指定這個寄存器，否則會出現(xiàn)編譯錯誤。比如：

―asm—("popl%0\n\t"

"movl%lz%%esi\n\t"

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

:"=&a"(_out)

："a"(_ini),"cn(_in2));

本例中，由于_out已經(jīng)指定了寄存器％eax,同時運用了符號&修飾，則再為_inl指定

寄存器％eax就是非法的。

反過來，你也可以為Output指定可選約束，比如”等，讓GCC為其選擇究竟運用哪

個寄存器，還是運用內(nèi)存方式，GCC在選擇的時候，會首先解除掉已經(jīng)被Input操作表達(dá)

式運用的全部寄存器，然后在剩下的寄存器中選擇，或干脆運用內(nèi)存方式。比如：

―asm—("popl%0\n\t"

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

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

:"=&r"(_out)

："a"(_ini),"c-(_in2));

本例中，由于_out指定了約束“r"，即讓GCC為其確定運用哪一格寄存器，而寄存器%eax

和％ecx已經(jīng)被_inl和_in2運用，那么GCC在為_out選擇的時候，只會在%ebx

和%edx中選擇。

前3個修飾符只能用在Output操作表達(dá)式中，而百分號［%］修飾符恰恰相反，只能用在

Input操作表達(dá)式中，用于向GCC聲明：''當(dāng)前Input操作表達(dá)式中的C/C++表達(dá)式可

以和下一個Input操作表達(dá)式中的C/C++表達(dá)式互換“。這個修飾符號一般用于符合交換

律運算，比如加(+),乘(*),與(&),或(|)等等。我們看一個例子：

intmain(int_argc,char*_argv[])

{

int_ini=8,_in2=4,_out=3;

_asm_("addl%1,%O\n\t"

："=r"(_out)

:"%r"(_inl)z"0"(_in2));

return0;

}

在此例中，由于指令是一個加法運算，相當(dāng)于等式_out=_inl+_in2,而它與等

式_out=_in2+_inl沒有什么不同。所以運用百分號修飾，讓GCC知道_inl和

_in2可以互換，也就是說GCC可以自動將本例的內(nèi)聯(lián)匯編變更為：

―asm—("addl%1,%0\n\t"

:"=r"(_out)

:"%r"(_in2)z"0"(_inl));

修飾符Input/Output意義

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

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

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

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

C/C++表達(dá)式互換

4.占位符

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

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

:"=a"(_out)

："m"(_inl)z"a"(_in2));

這個例子中的%)0和％1就是占位符。每一個占位符對應(yīng)一個Input/Output操作表達(dá)式。

我們在之前已經(jīng)提到，GCC規(guī)定一個內(nèi)聯(lián)匯編語句最多可以有10個Input/Output操作

表達(dá)式，然后依據(jù)它們被列出的依次依次給予編號。到9。對于占位符中的數(shù)字而言，和這

些編號是對應(yīng)的。

由于占位符前面運用一個百分號(%),為了區(qū)分占位符和寄存器，GCC規(guī)定在帶有C/C++

表達(dá)式的內(nèi)聯(lián)匯編中，"InstructionList”中干脆寫相的寄存器前必需運用兩個百分號

(%%)?

GCC對其進行編譯的時候，會將每一個占位符替換為對應(yīng)的Input/Output操作表達(dá)式所

指定的寄存器/內(nèi)存地址/馬上數(shù)。比如在上例中，占位符%0對應(yīng)Output操作表達(dá)式

"=a"(_out),而”=a”(_oiJt)指定的寄存器的%eax,所以把占位符％0替換為％eax,

占位符%1對應(yīng)Input操作表達(dá)式而”E”(_inl)被指定為內(nèi)存操作，所以

把占位符%1替換為變量_inl的內(nèi)存地址。

或許有人認(rèn)為，在上面這個例子中，完全可以不運用%0,而是干脆寫％%eax,就像這樣:

―asm—("addl%1,%%eax\n\t"

:"=a"(_out)

："m"(—ini),"a"(_in2));

和上面運用占位符％0沒有什么不同，那么運用占位符％。就沒有什么意義。的確，兩者

生成的代碼完全相同，但這并不意味著這種狀況下占位符沒有意義。因為假如不運用占位

符，那么當(dāng)有一天你想把變量_out的寄存器約束由a改為b時，那么你也必需將addl

指令中的%%eax改為%%ebx,也就是說你須要同時修改兩個地方，而假如你運用占位

符，你只須要修改一次就夠了。另外，假如你不運用占位符，將不利于代碼的清晰性。在上

例中，假如你運用占位符，那么你一眼就可以得知，addl指令的其次個操作數(shù)內(nèi)容最終會

輸出到變量_out中：否則，假如你不用占位符，而是二脆將addl指令的第2個操作數(shù)寫

為％%eax,那么你須要考慮一下才知道它最終須要輸出到變量_out中。這是占位符最

粗淺的意義。終歸在這種狀況下，你完全可以不用。

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

首先，我們看一看上例中的第1個Input操作表達(dá)式“m”(_ini),它被GCC替換之后，

表現(xiàn)為addladdress_of_inlz%%eax,_ini的地址是什么？編譯時才知道。所以我

們完全無法干脆在指令中去寫出_inl的地址，這時運用占位符，交給GCC在編譯時進行

替代，就可以解決這個問題。所以這種狀況下，我們必需運用占位符。

其次，假如上例中的Output操作表達(dá)式a”(__out)改為“=r”(_out),那么_out在

原委運用那么寄存器只有到編譯時才能通過GCC來確定，既然在我們寫代碼的時候，我們

不知道原委哪個寄存器被選擇，我們也就不能干脆在指令中寫出寄存器的名稱，而只能通

過占位符替代來解決。

5.Clobber/Modify

有時候，你想通知GCC當(dāng)前內(nèi)聯(lián)匯編語句可能會對某些寄存器或內(nèi)存進行修改，希望GCC

在編譯時能夠?qū)⑦@一點考慮進去。那么你就可以在Clobber/Modify域聲明這些寄存器或

內(nèi)存。

這種狀況一般發(fā)生在一個寄存器出現(xiàn)在"InstructionList",但卻不是由Input/Output

操作表達(dá)式所指定的，也不是在一些Input/Output操作表達(dá)式運用“約束時由GCC

為其選擇的，同時此寄存器被“InstructionList”中的指令修改，而這個寄存器只是供當(dāng)前

內(nèi)聯(lián)匯編臨時運用的狀況，比如：

_asm_("movl%0,%%ebx"::"a"(—foo):"bx");

寄存器%)ebx出現(xiàn)在"InstructionList中“，并且被movl指令修改，但卻未被任何

Input/Output操作表達(dá)式指定，所以你須要在Clobber7Modify域指定“bx”，以讓GCC

知道這一點。

因為你在Input/Output操作表達(dá)式所指定的寄存器，或當(dāng)你為一些Input/Output操作

表達(dá)式運用”約束，讓GCC為你選擇一個寄存器時，GCC對這些寄存器是特別清晰

的一一它知道這些寄存器是被修改的，你根本不須要在Clobber/Modify域再聲明它們。

但除此之外，GCC對剩下的寄存器中哪些會被當(dāng)前的內(nèi)聯(lián)匯編修改一竅不通。所以假如你

真的在當(dāng)前內(nèi)聯(lián)匯編指令中修改了它們，那么就最好在Clobber/Modify中聲明它們，讓

GCC針對這些寄存器做相應(yīng)的處理。否則有可能會造成寄存器的不一樣，從而造成程序執(zhí)

行錯誤。

在Clobber/Modify域中指定這些寄存器的方法很簡潔，你只須要將寄存器的名字運用雙

引號("")引起來。假如有多個寄存器須要聲明，你須要在隨意兩個聲明之間用逗號隔開。

比如：

_asm_("movl%0z%%ebx;popl%%ecx"::"a"(_foo):"bx","ex");

這些串包括：

聲明的串代表的寄存器

"al'Y'ax'Y'eax"%eax

"bl"z"bx"z"ebx"%ebx

"cr'/'cx'Y'ecx"%ecx

"dl"z"dx"z"edx"%edx

"si'7'esi"%esi

"di","edi"%edi

由上表可以看出,你只須要運用"》”「七X”,要乂”,”<^”,叼",“附'就可以了,因為其它的都和

它們中的一個是等價的。

如果你在一個內(nèi)聯(lián)匯編語句的Clobber/Modify域向GCC聲明某個寄存器內(nèi)容發(fā)生了變

更，GCC在編譯時，假如發(fā)覺這個被聲明的寄存器的內(nèi)容在此內(nèi)聯(lián)匯編語句之后還要接著

運用，那么GCC會首先將此寄存器的內(nèi)容保存起來，然后在此內(nèi)聯(lián)匯編語句的相關(guān)生成代

碼之后，再將其內(nèi)容復(fù)原，我們來看兩個例子，然后對比一下它們之間的區(qū)分。

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

$catexample7.c

intmain(int_argczchar*_argv[])

{

intin=