AT&T ASM Syntax

    1 Overview

    開發(fā)一個OS，盡管絕大部分代碼只需要用C/C++等高級語言就可以了，但至少和硬件相關部分的代碼需要使用匯編語言，另外，由于啟動部分的代碼有大小限制，使用精練的匯編可以縮小目標代碼的Size。另外，對于某些需要被經(jīng)常調用的代碼，使用匯編來寫可以提高性能。所以我們必須了解匯編語言，即使你有可能并不喜歡它。

    如果我們選擇的OS開發(fā)工具是GCC以及GAS的話，就必須了解AT&T匯編語言語法，因為GCC/GAS只支持這種匯編語法。 本文只討論AT&T的匯編語法，以及GCC的內(nèi)嵌匯編語法。

    2 Syntax

    1.寄存器引用

    引用寄存器要在寄存器號前加百分號%,如"movl %eax, %ebx"。

    80386有如下寄存器：

    8個32-bit寄存器 %eax，%ebx，%ecx，%edx，%edi，%esi，%ebp，%esp；

    8個16-bit寄存器，它們事實上是上面8個32-bit寄存器的低16位：%ax，%bx，%cx，%dx，%di，%si，%bp，%sp；

    8個8-bit寄存器：%ah，%al，%bh，%bl，%ch，%cl，%dh，%dl。它們事實上是寄存器%ax，%bx，%cx，%dx的高8位和低8位；

    6個段寄存器：%cs(code)，%ds(data)，%ss(stack),

    %es，%fs，%gs；

    3個控制寄存器：%cr0，%cr2，%cr3；

    6個debug寄存器：%db0，%db1，%db2，%db3，%db6，%db7；

    2個測試寄存器：%tr6，%tr7；

    8個浮點寄存器棧：%st(0)，%st(1)，%st(2)，%st(3)，%st(4)，%st(5)，%st(6)，%st(7)。

    2. 操作數(shù)順序

    操作數(shù)排列是從源（左）到目的（右），如"movl %eax(源）, %ebx(目的）"

    3. 立即數(shù)

    使用立即數(shù)，要在數(shù)前面加符號$, 如"movl $0x04, %ebx"

    或者：

    para = 0x04

    movl $para, %ebx

    指令執(zhí)行的結果是將立即數(shù)04h裝入寄存器ebx。

    4. 符號常數(shù)

    符號常數(shù)直接引用 如

    value: .long 0x12a3f2de

    movl value , %ebx

    指令執(zhí)行的結果是將常數(shù)0x12a3f2de裝入寄存器ebx。

    引用符號地址在符號前加符號$, 如"movl $value, % ebx"則是將符號value的地址裝入寄存器ebx。

    5. 操作數(shù)的長度

    操作數(shù)的長度用加在指令后的符號表示b(byte, 8-bit), w(word, 16-bits), l(long, 32-bits)，如"movb

    %al, %bl"，"movw

    %ax, %bx"，"movl

    %eax, %ebx "。

    如果沒有指定操作數(shù)長度的話，編譯器將按照目標操作數(shù)的長度來設置。比如指令"mov

    %ax, %bx"，由于目標操作數(shù)bx的長度為word，那么編譯器將把此指令等同于"movw

    %ax, %bx"。同樣道理，指令"mov $4, %ebx"等同于指令"movl

    $4, %ebx"，"push %al"等同于"pushb %al"。對于沒有指定操作數(shù)長度，但編譯器又無法猜測的指令，編譯器將會報錯，比如指令"push $4"。

    6. 符號擴展和零擴展指令

    絕大多數(shù)面向80386的AT&T匯編指令與Intel格式的匯編指令都是相同的，符號擴展指令和零擴展指令則是僅有的不同格式指令。

    符號擴展指令和零擴展指令需要指定源操作數(shù)長度和目的操作數(shù)長度，即使在某些指令中這些操作數(shù)是隱含的。

    在AT&T語法中，符號擴展和零擴展指令的格式為，基本部分"movs"和"movz"（對應Intel語法的movsx和movzx），后面跟上源操作數(shù)長度和目的操作數(shù)長度。movsbl意味著movs （from）byte （to）long；movbw意味著movs （from）byte （to）word；movswl意味著movs （from）word （to）long。對于movz指令也一樣。比如指令"movsbl %al, %edx"意味著將al寄存器的內(nèi)容進行符號擴展后放置到edx寄存器中。

    其它的Intel格式的符號擴展指令還有：

    cbw -- sign-extend byte in %al to word in %ax；

    cwde -- sign-extend word in %ax to long in %eax；

    cwd -- sign-extend word in %ax to long in %dx:%ax；

    cdq -- sign-extend dword in %eax to quad in %edx:%eax；

    對應的AT&T語法的指令為cbtw，cwtl，cwtd，cltd。

    7. 調用和跳轉指令

    段內(nèi)調用和跳轉指令為"call"，"ret"和"jmp"，段間調用和跳轉指令為"lcall"，"lret"和"ljmp"。

    段間調用和跳轉指令的格式為"lcall/ljmp $SECTION, $OFFSET"，而段間返回指令則為"lret

    $STACK-ADJUST"。

    8. 前綴

    操作碼前綴被用在下列的情況：

    字符串重復操作指令(rep,repne)；

    指定被操作的段(cs,ds,ss,es,fs,gs)；

    進行總線加鎖(lock)；

    指定地址和操作的大小(data16,addr16)；

    在AT&T匯編語法中，操作碼前綴通常被單獨放在一行，后面不跟任何操作數(shù)。例如，對于重復scas指令，其寫法為：

    repne

    scas

    上述操作碼前綴的意義和用法如下：

    指定被操作的段前綴為cs,ds,ss,es,fs,和gs。在AT&T語法中，只需要按照section:memory-operand的格式就指定了相應的段前綴。比如：lcall

    %cs:realmode_swtch

    操作數(shù)／地址大小前綴是"data16"和"addr16"，它們被用來在32-bit操作數(shù)／地址代碼中指定16-bit的操作數(shù)／地址。

    總線加鎖前綴"lock"，它是為了在多處理器環(huán)境中，保證在當前指令執(zhí)行期間禁止一切中斷。這個前綴僅僅對ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG,DEC, INC,

    NEG, NOT, OR, SBB, SUB, XOR, XADD,XCHG指令有效，如果將Lock前綴用在其它指令之前，將會引起異常。

    字符串重復操作前綴"rep","repe","repne"用來讓字符串操作重復"%ecx"次。

    9. 內(nèi)存引用

    Intel語法的間接內(nèi)存引用的格式為：

    section:[base+index*scale+displacement]

    而在AT&T語法中對應的形式為：

    section:displacement(base,index,scale)

    其中，base和index是任意的32-bit base和index寄存器。scale可以取值1，2，4，8。如果不指定scale值，則默認值為1。section可以指定任意的段寄存器作為段前綴，默認的段寄存器在不同的情況下不一樣。如果你在指令中指定了默認的段前綴，則編譯器在目標代碼中不會產(chǎn)生此段前綴代碼。

    下面是一些例子：

    -4(%ebp)：base=%ebp，displacement=-4，section沒有指定，由于base＝%ebp，所以默認的section=%ss，index,scale沒有指定，則index為0。

    foo(,%eax,4)：index=%eax，scale=4，displacement=foo。其它域沒有指定。這里默認的section=%ds。

    foo(,1)：這個表達式引用的是指針foo指向的地址所存放的值。注意這個表達式中沒有base和index，并且只有一個逗號，這是一種異常語法，但卻合法。

    %gs:foo：這個表達式引用的是放置于%gs段里變量foo的值。

    如果call和jump操作在操作數(shù)前指定前綴"*"，則表示是一個絕對地址調用/跳轉，也就是說jmp/call指令指定的是一個絕對地址。如果沒有指定"*"，則操作數(shù)是一個相對地址。

    任何指令如果其操作數(shù)是一個內(nèi)存操作，則指令必須指定它的操作尺寸(byte,word,long），也就是說必須帶有指令后綴(b,w,l)。

    3 GCC Inline ASM

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

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

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

    __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__("Instruction List");

    a、__asm__

    __asm__是GCC關鍵字asm的宏定義：

    #define __asm__ asm

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

    b、Instruction

    List

    Instruction List是匯編指令序列。它可以是空的，比如：__asm__ __volatile__(""); 或__asm__

    ("");都是完全合法的內(nèi)聯(lián)匯編表達式，只不過這兩條語句沒有什么意義。但并非所有Instruction List為空的內(nèi)聯(lián)匯編表達式都是沒有意義的，比如：__asm__ ("":::"memory"); 就非常有意義，它向GCC聲明："我對內(nèi)存作了改動"，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);

    }

    在這段代碼中，那條內(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ā)現(xiàn)這一點。我們使用下面的命令行對其進行編譯：

    $ gcc -O -S example1.c

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

    我們來查看一下被放在example1.s中的編譯結果，我們這里僅僅列出了使用gcc

    2.96在redhat 7.3上編譯后的相關函數(shù)部分匯編代碼。為了保持清晰性，無關的其它代碼未被列出。

    $ 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源碼和編譯出的匯編代碼，我們會發(fā)現(xiàn)匯編代碼中，沒有if語句相關的代碼，而是在賦值語句(*__p)=9999后直接return

    5；這是因為GCC認為在(*__p)被賦值之后，在if語句之前沒有任何改變(*__p)內(nèi)容的操作，所以那條if語句的判斷條件(*__p)

    == 9999肯定是為true的，所以GCC就不再生成相關代碼，而是直接根據(jù)為true的條件生成return 5的匯編代碼（GCC使用eax作為保存返回值的寄存器）。

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

    $ gcc -O -S example1.c

    $ cat example1.s

    main:

    pushl %ebp

    movl %esp, %ebp

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

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

    #APP

    # __asm__("":::"memory")

    #NO_APP

    cmpl $9999, (%eax) # (*__p) == 9999 ?

    jne .L3 # false

    movl $5, %eax # true, return 5

    jmp .L2

    .p2align 2

    .L3:

    movl (%eax), %eax

    .L2:

    popl %ebp

    ret

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

    可能有人會質疑：為什么要使用__asm__("":::"memory")向GCC聲明內(nèi)存發(fā)生了變化？明明"Instruction

    List"是空的，沒有任何對內(nèi)存的操作，這樣做只會增加GCC生成匯編代碼的數(shù)量。

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

    你可能已經(jīng)注意到了，這次輸出的匯編結果中，有兩個符號：#APP和#NO_APP，GCC將內(nèi)聯(lián)匯編語句中"Instruction

    List"所列出的指令放在#APP和#NO_APP之間，由于__asm__("":::"memory")中"Instruction

    List"為空，所以#APP和#NO_APP中間也沒有任何內(nèi)容。但我們以后的例子會更加清楚的表現(xiàn)這一點。

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

    剛才我們花了大量的內(nèi)容來討論"Instruction List"為空是的情況，但在實際的編程中，"Instruction

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

    當在"Instruction List"中有多條指令的時候，你可以在一對引號中列出全部指令，也可以將一條或幾條指令放在一對引號中，所有指令放在多對引號中。如果是前者，你可以將每一條指令放在一行，如果要將多條指令放在一行，則必須用分號（；）或換行符（\n，大多數(shù)情況下\n后還要跟一個\t，其中\(zhòng)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的方法來實現(xiàn)，也可以真正的放在兩行；

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

    在基本內(nèi)聯(lián)匯編中，"Instruction List"的書寫的格式和你直接在匯編文件中寫非內(nèi)聯(lián)匯編沒有什么不同，你可以在其中定義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內(nèi)聯(lián)代碼常用的格式，非常整齊。也建議大家都使用這種格式來寫內(nèi)聯(lián)匯編代碼。

    c、__volatile__

    __volatile__是GCC關鍵字volatile的宏定義：

    #define __volatile__ volatile

    __volatile__或volatile是可選的，你可以用它也可以不用它。如果你用了它，則是向GCC聲明"不要動我所寫的Instruction List，我需要原封不動的保留每一條指令"，否則當你使用了優(yōu)化選項(-O)進行編譯時，GCC將會根據(jù)自己的判斷決定是否將這個內(nèi)聯(lián)匯編表達式中的指令優(yōu)化掉。

    那么GCC判斷的原則是什么？我不知道（如果有哪位朋友清楚的話，請告訴我）。我試驗了一下，發(fā)現(xiàn)一條內(nèi)聯(lián)匯編語句如果是基本內(nèi)聯(lián)匯編的話（即只有"Instruction

    List"，沒有Input/Output/Clobber的內(nèi)聯(lián)匯編，我們后面將會討論這一點），無論你是否使用__volatile__來修飾，GCC

    2.96在優(yōu)化編譯時，都會原封不動的保留內(nèi)聯(lián)匯編中的"Instruction List"。但或許我的試驗的例子并不充分，所以這一點并不能夠得到保證。

    為了保險起見，如果你不想讓GCC的優(yōu)化影響你的內(nèi)聯(lián)匯編代碼，你最好在前面都加上__volatile__，而不要依賴于編譯器的原則，因為即使你非常了解當前編譯器的優(yōu)化原則，你也無法保證這種原則將來不會發(fā)生變化。而__volatile__的含義卻是恒定的。

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

    GCC允許你通過C/C++表達式指定內(nèi)聯(lián)匯編中"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++表達式的內(nèi)聯(lián)匯編格式為：

    __asm__　__volatile__("Instruction List"

    : Output : Input : Clobber/Modify);

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

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

    如果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之前的冒號(:)既可以省略，也可以不省略。如果都省略，則此匯編退化為一個基本內(nèi)聯(lián)匯編，否則，仍然是一個帶有C/C++表達式的內(nèi)聯(lián)匯編，此時"Instruction List"中的寄存器寫法要遵守相關規(guī)定，比如寄存器前必須使用兩個百分號(%%)，而不是像基本匯編格式一樣在寄存器前只使用一個百分號(%)。比如__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前的冒號必須省略（前面的規(guī)則），而Output前的冒號必須為保留。如果Clobber/Modify不為空，而Input和Output都為空，則Input和Output前的冒號都必須保留。比如__asm__(

    " mov %%eax, %%ebx" : : "a"(foo) )和__asm__( "

    mov %%eax, %%ebx" : : : "ebx" )。

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

    List"后是否有冒號(:)的存在，如果沒有則是基本格式的，否則，則是帶有C/C++表達式格式的。

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

    a). Output

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

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

    這個內(nèi)聯(lián)匯編語句的輸出部分為"=r"(cr0)，它是一個"操作表達式"，指定了一個輸出操作。我們可以很清楚得看到這個輸出操作由兩部分組成：括號括住的部分(cr0)和引號引住的部分"=a"。這兩部分都是每一個輸出操作必不可少的。括號括住的部分是一個C/C++表達式，用來保存內(nèi)聯(lián)匯編的一個輸出值，其操作就等于C/C++的相等賦值cr0

    = output_value，因此，括號中的輸出表達式只能是C/C++的左值表達式，也就是說它只能是一個可以合法的放在C/C++賦值操作中等號(=)左邊的表達式。那么右值output_value從何而來呢？

    答案是引號中的內(nèi)容，被稱作"操作約束"（Operation

    Constraint），在這個例子中操作約束為"=a"，它包含兩個約束：等號(=)和字母a，其中等號(=)說明括號中左值表達式cr0是一個Write-Only的，只能夠被作為當前內(nèi)聯(lián)匯編的輸入，而不能作為輸入。而字母a是寄存器EAX

    / AX / AL的簡寫，說明cr0的值要從eax寄存器中獲取，也就是說cr0 = eax，最終這一點被轉化成匯編指令就是movl %eax, address_of_cr0?，F(xiàn)在你應該清楚了吧，操作約束中會給出：到底從哪個寄存器傳遞值給cr0。

    另外，需要特別說明的是，很多文檔都聲明，所有輸出操作的操作約束必須包含一個等號(=)，但GCC的文檔中卻很清楚的聲明，并非如此。因為等號(=)約束說明當前的表達式是一個Write-Only的，但另外還有一個符號——加號(+)用來說明當前表達式是一個Read-Write的，如果一個操作約束中沒有給出這兩個符號中的任何一個，則說明當前表達式是Read-Only的。因為對于輸出操作來說，肯定是必須是可寫的，而等號(=)和加號(+)都表示可寫，只不過加號(+)同時也表示是可讀的。所以對于一個輸出操作來說，其操作約束只需要有等號(=)或加號(+)中的任意一個就可以了。

    二者的區(qū)別是：等號(=)表示當前操作表達式指定了一個純粹的輸出操作，而加號(+)則表示當前操作表達式不僅僅只是一個輸出操作還是一個輸入操作。但無論是等號(=)約束還是加號(+)約束所約束的操作表達式都只能放在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被放在內(nèi)存-4(%ebp)的位置，所以指令mov %eax, -4(%ebp)即表示將%eax的內(nèi)容輸出到變量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));

    b)、Input

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

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

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

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

    括號中的表達式cpu->db7是一個C/C++語言的表達式，它不必是一個左值表達式，也就是說它不僅可以是放在C/C++賦值操作左邊的表達式，還可以是放在C/C++賦值操作右邊的表達式。所以它可以是一個變量，一個數(shù)字，還可以是一個復雜的表達式（比如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輸入到當前內(nèi)聯(lián)匯編中。

    我們看一個例子：

    $ 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的內(nèi)容裝入了eax寄存器。

    c). Operation Constraint

    每一個Input和Output表達式都必須指定自己的操作約束Operation Constraint，我們這里來討論在80386平臺上所可能使用的操作約束。

    1、寄存器約束

    當你當前的輸入或輸入需要借助一個寄存器時，你需要為其指定一個寄存器約束。你可以直接指定一個寄存器的名字，比如：

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

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

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

    如果你指定一個縮寫，比如字母a，則GCC將會根據(jù)當前操作表達式中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、內(nèi)存約束

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

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

    ("lidt %0" : :"m"(__idt_addr));

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

    $ cat example5.c

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

    下載原始附件

    AT&T ASM Syntax

    1 Overview

    開發(fā)一個OS，盡管絕大部分代碼只需要用C/C++等高級語言就可以了，但至少和硬件相關部分的代碼需要使用匯編語言，另外，由于啟動部分的代碼有大小限制，使用精練的匯編可以縮小目標代碼的Size。另外，對于某些需要被經(jīng)常調用的代碼，使用匯編來寫可以提高性能。所以我們必須了解匯編語言，即使你有可能并不喜歡它。

    如果我們選擇的OS開發(fā)工具是GCC以及GAS的話，就必須了解AT&T匯編語言語法，因為GCC/GAS只支持這種匯編語法。 本文只討論AT&T的匯編語法，以及GCC的內(nèi)嵌匯編語法。

    2 Syntax

    1.寄存器引用

    引用寄存器要在寄存器號前加百分號%,如"movl %eax, %ebx"。

    80386有如下寄存器：

    8個32-bit寄存器 %eax，%ebx，%ecx，%edx，%edi，%esi，%ebp，%esp；

    8個16-bit寄存器，它們事實上是上面8個32-bit寄存器的低16位：%ax，%bx，%cx，%dx，%di，%si，%bp，%sp；

    8個8-bit寄存器：%ah，%al，%bh，%bl，%ch，%cl，%dh，%dl。它們事實上是寄存器%ax，%bx，%cx，%dx的高8位和低8位；

    6個段寄存器：%cs(code)，%ds(data)，%ss(stack),

    %es，%fs，%gs；

    3個控制寄存器：%cr0，%cr2，%cr3；

    6個debug寄存器：%db0，%db1，%db2，%db3，%db6，%db7；

    2個測試寄存器：%tr6，%tr7；

    8個浮點寄存器棧：%st(0)，%st(1)，%st(2)，%st(3)，%st(4)，%st(5)，%st(6)，%st(7)。

    2. 操作數(shù)順序

    操作數(shù)排列是從源（左）到目的（右），如"movl %eax(源）, %ebx(目的）"

    3. 立即數(shù)

    使用立即數(shù)，要在數(shù)前面加符號$, 如"movl $0x04, %ebx"

    或者：

    para = 0x04

    movl $para, %ebx

    指令執(zhí)行的結果是將立即數(shù)04h裝入寄存器ebx。

    4. 符號常數(shù)

    符號常數(shù)直接引用 如

    value: .long 0x12a3f2de

    movl value , %ebx

    指令執(zhí)行的結果是將常數(shù)0x12a3f2de裝入寄存器ebx。

    引用符號地址在符號前加符號$, 如"movl $value, % ebx"則是將符號value的地址裝入寄存器ebx。

    5. 操作數(shù)的長度

    操作數(shù)的長度用加在指令后的符號表示b(byte, 8-bit), w(word, 16-bits), l(long, 32-bits)，如"movb

    %al, %bl"，"movw

    %ax, %bx"，"movl

    %eax, %ebx "。

    如果沒有指定操作數(shù)長度的話，編譯器將按照目標操作數(shù)的長度來設置。比如指令"mov

    %ax, %bx"，由于目標操作數(shù)bx的長度為word，那么編譯器將把此指令等同于"movw

    %ax, %bx"。同樣道理，指令"mov $4, %ebx"等同于指令"movl

    $4, %ebx"，"push %al"等同于"pushb %al"。對于沒有指定操作數(shù)長度，但編譯器又無法猜測的指令，編譯器將會報錯，比如指令"push $4"。

    6. 符號擴展和零擴展指令

    絕大多數(shù)面向80386的AT&T匯編指令與Intel格式的匯編指令都是相同的，符號擴展指令和零擴展指令則是僅有的不同格式指令。

    符號擴展指令和零擴展指令需要指定源操作數(shù)長度和目的操作數(shù)長度，即使在某些指令中這些操作數(shù)是隱含的。

    在AT&T語法中，符號擴展和零擴展指令的格式為，基本部分"movs"和"movz"（對應Intel語法的movsx和movzx），后面跟上源操作數(shù)長度和目的操作數(shù)長度。movsbl意味著movs （from）byte （to）long；movbw意味著movs （from）byte （to）word；movswl意味著movs （from）word （to）long。對于movz指令也一樣。比如指令"movsbl %al, %edx"意味著將al寄存器的內(nèi)容進行符號擴展后放置到edx寄存器中。

    其它的Intel格式的符號擴展指令還有：

    cbw -- sign-extend byte in %al to word in %ax；

    cwde -- sign-extend word in %ax to long in %eax；

    cwd -- sign-extend word in %ax to long in %dx:%ax；

    cdq -- sign-extend dword in %eax to quad in %edx:%eax；

    對應的AT&T語法的指令為cbtw，cwtl，cwtd，cltd。

    7. 調用和跳轉指令

    段內(nèi)調用和跳轉指令為"call"，"ret"和"jmp"，段間調用和跳轉指令為"lcall"，"lret"和"ljmp"。

    段間調用和跳轉指令的格式為"lcall/ljmp $SECTION, $OFFSET"，而段間返回指令則為"lret

    $STACK-ADJUST"。

    8. 前綴

    操作碼前綴被用在下列的情況：

    字符串重復操作指令(rep,repne)；

    指定被操作的段(cs,ds,ss,es,fs,gs)；

    進行總線加鎖(lock)；

    指定地址和操作的大小(data16,addr16)；

    在AT&T匯編語法中，操作碼前綴通常被單獨放在一行，后面不跟任何操作數(shù)。例如，對于重復scas指令，其寫法為：

    repne

    scas

    上述操作碼前綴的意義和用法如下：

    指定被操作的段前綴為cs,ds,ss,es,fs,和gs。在AT&T語法中，只需要按照section:memory-operand的格式就指定了相應的段前綴。比如：lcall

    %cs:realmode_swtch

    操作數(shù)／地址大小前綴是"data16"和"addr16"，它們被用來在32-bit操作數(shù)／地址代碼中指定16-bit的操作數(shù)／地址。

    總線加鎖前綴"lock"，它是為了在多處理器環(huán)境中，保證在當前指令執(zhí)行期間禁止一切中斷。這個前綴僅僅對ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG,DEC, INC,

    NEG, NOT, OR, SBB, SUB, XOR, XADD,XCHG指令有效，如果將Lock前綴用在其它指令之前，將會引起異常。

    字符串重復操作前綴"rep","repe","repne"用來讓字符串操作重復"%ecx"次。

    9. 內(nèi)存引用

    Intel語法的間接內(nèi)存引用的格式為：

    section:[base+index*scale+displacement]

    而在AT&T語法中對應的形式為：

    section:displacement(base,index,scale)

    其中，base和index是任意的32-bit base和index寄存器。scale可以取值1，2，4，8。如果不指定scale值，則默認值為1。section可以指定任意的段寄存器作為段前綴，默認的段寄存器在不同的情況下不一樣。如果你在指令中指定了默認的段前綴，則編譯器在目標代碼中不會產(chǎn)生此段前綴代碼。

    下面是一些例子：

    -4(%ebp)：base=%ebp，displacement=-4，section沒有指定，由于base＝%ebp，所以默認的section=%ss，index,scale沒有指定，則index為0。

    foo(,%eax,4)：index=%eax，scale=4，displacement=foo。其它域沒有指定。這里默認的section=%ds。

    foo(,1)：這個表達式引用的是指針foo指向的地址所存放的值。注意這個表達式中沒有base和index，并且只有一個逗號，這是一種異常語法，但卻合法。

    %gs:foo：這個表達式引用的是放置于%gs段里變量foo的值。

    如果call和jump操作在操作數(shù)前指定前綴"*"，則表示是一個絕對地址調用/跳轉，也就是說jmp/call指令指定的是一個絕對地址。如果沒有指定"*"，則操作數(shù)是一個相對地址。

    任何指令如果其操作數(shù)是一個內(nèi)存操作，則指令必須指定它的操作尺寸(byte,word,long），也就是說必須帶有指令后綴(b,w,l)。

    3 GCC Inline ASM

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

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

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

    __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__("Instruction List");

    a、__asm__

    __asm__是GCC關鍵字asm的宏定義：

    #define __asm__ asm

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

    b、Instruction

    List

    Instruction List是匯編指令序列。它可以是空的，比如：__asm__ __volatile__(""); 或__asm__

    ("");都是完全合法的內(nèi)聯(lián)匯編表達式，只不過這兩條語句沒有什么意義。但并非所有Instruction List為空的內(nèi)聯(lián)匯編表達式都是沒有意義的，比如：__asm__ ("":::"memory"); 就非常有意義，它向GCC聲明："我對內(nèi)存作了改動"，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);

    }

    在這段代碼中，那條內(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ā)現(xiàn)這一點。我們使用下面的命令行對其進行編譯：

    $ gcc -O -S example1.c

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

    我們來查看一下被放在example1.s中的編譯結果，我們這里僅僅列出了使用gcc

    2.96在redhat 7.3上編譯后的相關函數(shù)部分匯編代碼。為了保持清晰性，無關的其它代碼未被列出。

    $ 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源碼和編譯出的匯編代碼，我們會發(fā)現(xiàn)匯編代碼中，沒有if語句相關的代碼，而是在賦值語句(*__p)=9999后直接return

    5；這是因為GCC認為在(*__p)被賦值之后，在if語句之前沒有任何改變(*__p)內(nèi)容的操作，所以那條if語句的判斷條件(*__p)

    == 9999肯定是為true的，所以GCC就不再生成相關代碼，而是直接根據(jù)為true的條件生成return 5的匯編代碼（GCC使用eax作為保存返回值的寄存器）。

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

    $ gcc -O -S example1.c

    $ cat example1.s

    main:

    pushl %ebp

    movl %esp, %ebp

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

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

    #APP

    # __asm__("":::"memory")

    #NO_APP

    cmpl $9999, (%eax) # (*__p) == 9999 ?

    jne .L3 # false

    movl $5, %eax # true, return 5

    jmp .L2

    .p2align 2

    .L3:

    movl (%eax), %eax

    .L2:

    popl %ebp

    ret

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

    可能有人會質疑：為什么要使用__asm__("":::"memory")向GCC聲明內(nèi)存發(fā)生了變化？明明"Instruction

    List"是空的，沒有任何對內(nèi)存的操作，這樣做只會增加GCC生成匯編代碼的數(shù)量。

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

    你可能已經(jīng)注意到了，這次輸出的匯編結果中，有兩個符號：#APP和#NO_APP，GCC將內(nèi)聯(lián)匯編語句中"Instruction

    List"所列出的指令放在#APP和#NO_APP之間，由于__asm__("":::"memory")中"Instruction

    List"為空，所以#APP和#NO_APP中間也沒有任何內(nèi)容。但我們以后的例子會更加清楚的表現(xiàn)這一點。

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

    剛才我們花了大量的內(nèi)容來討論"Instruction List"為空是的情況，但在實際的編程中，"Instruction

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

    當在"Instruction List"中有多條指令的時候，你可以在一對引號中列出全部指令，也可以將一條或幾條指令放在一對引號中，所有指令放在多對引號中。如果是前者，你可以將每一條指令放在一行，如果要將多條指令放在一行，則必須用分號（；）或換行符（\n，大多數(shù)情況下\n后還要跟一個\t，其中\(zhòng)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的方法來實現(xiàn)，也可以真正的放在兩行；

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

    在基本內(nèi)聯(lián)匯編中，"Instruction List"的書寫的格式和你直接在匯編文件中寫非內(nèi)聯(lián)匯編沒有什么不同，你可以在其中定義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內(nèi)聯(lián)代碼常用的格式，非常整齊。也建議大家都使用這種格式來寫內(nèi)聯(lián)匯編代碼。

    c、__volatile__

    __volatile__是GCC關鍵字volatile的宏定義：

    #define __volatile__ volatile

    __volatile__或volatile是可選的，你可以用它也可以不用它。如果你用了它，則是向GCC聲明"不要動我所寫的Instruction List，我需要原封不動的保留每一條指令"，否則當你使用了優(yōu)化選項(-O)進行編譯時，GCC將會根據(jù)自己的判斷決定是否將這個內(nèi)聯(lián)匯編表達式中的指令優(yōu)化掉。

    那么GCC判斷的原則是什么？我不知道（如果有哪位朋友清楚的話，請告訴我）。我試驗了一下，發(fā)現(xiàn)一條內(nèi)聯(lián)匯編語句如果是基本內(nèi)聯(lián)匯編的話（即只有"Instruction

    List"，沒有Input/Output/Clobber的內(nèi)聯(lián)匯編，我們后面將會討論這一點），無論你是否使用__volatile__來修飾，GCC

    2.96在優(yōu)化編譯時，都會原封不動的保留內(nèi)聯(lián)匯編中的"Instruction List"。但或許我的試驗的例子并不充分，所以這一點并不能夠得到保證。

    為了保險起見，如果你不想讓GCC的優(yōu)化影響你的內(nèi)聯(lián)匯編代碼，你最好在前面都加上__volatile__，而不要依賴于編譯器的原則，因為即使你非常了解當前編譯器的優(yōu)化原則，你也無法保證這種原則將來不會發(fā)生變化。而__volatile__的含義卻是恒定的。

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

    GCC允許你通過C/C++表達式指定內(nèi)聯(lián)匯編中"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++表達式的內(nèi)聯(lián)匯編格式為：

    __asm__　__volatile__("Instruction List"

    : Output : Input : Clobber/Modify);

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

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

    如果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之前的冒號(:)既可以省略，也可以不省略。如果都省略，則此匯編退化為一個基本內(nèi)聯(lián)匯編，否則，仍然是一個帶有C/C++表達式的內(nèi)聯(lián)匯編，此時"Instruction List"中的寄存器寫法要遵守相關規(guī)定，比如寄存器前必須使用兩個百分號(%%)，而不是像基本匯編格式一樣在寄存器前只使用一個百分號(%)。比如__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前的冒號必須省略（前面的規(guī)則），而Output前的冒號必須為保留。如果Clobber/Modify不為空，而Input和Output都為空，則Input和Output前的冒號都必須保留。比如__asm__(

    " mov %%eax, %%ebx" : : "a"(foo) )和__asm__( "

    mov %%eax, %%ebx" : : : "ebx" )。

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

    List"后是否有冒號(:)的存在，如果沒有則是基本格式的，否則，則是帶有C/C++表達式格式的。

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

    a). Output

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

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

    這個內(nèi)聯(lián)匯編語句的輸出部分為"=r"(cr0)，它是一個"操作表達式"，指定了一個輸出操作。我們可以很清楚得看到這個輸出操作由兩部分組成：括號括住的部分(cr0)和引號引住的部分"=a"。這兩部分都是每一個輸出操作必不可少的。括號括住的部分是一個C/C++表達式，用來保存內(nèi)聯(lián)匯編的一個輸出值，其操作就等于C/C++的相等賦值cr0

    = output_value，因此，括號中的輸出表達式只能是C/C++的左值表達式，也就是說它只能是一個可以合法的放在C/C++賦值操作中等號(=)左邊的表達式。那么右值output_value從何而來呢？

    答案是引號中的內(nèi)容，被稱作"操作約束"（Operation

    Constraint），在這個例子中操作約束為"=a"，它包含兩個約束：等號(=)和字母a，其中等號(=)說明括號中左值表達式cr0是一個Write-Only的，只能夠被作為當前內(nèi)聯(lián)匯編的輸入，而不能作為輸入。而字母a是寄存器EAX

    / AX / AL的簡寫，說明cr0的值要從eax寄存器中獲取，也就是說cr0 = eax，最終這一點被轉化成匯編指令就是movl %eax, address_of_cr0?，F(xiàn)在你應該清楚了吧，操作約束中會給出：到底從哪個寄存器傳遞值給cr0。

    另外，需要特別說明的是，很多文檔都聲明，所有輸出操作的操作約束必須包含一個等號(=)，但GCC的文檔中卻很清楚的聲明，并非如此。因為等號(=)約束說明當前的表達式是一個Write-Only的，但另外還有一個符號——加號(+)用來說明當前表達式是一個Read-Write的，如果一個操作約束中沒有給出這兩個符號中的任何一個，則說明當前表達式是Read-Only的。因為對于輸出操作來說，肯定是必須是可寫的，而等號(=)和加號(+)都表示可寫，只不過加號(+)同時也表示是可讀的。所以對于一個輸出操作來說，其操作約束只需要有等號(=)或加號(+)中的任意一個就可以了。

    二者的區(qū)別是：等號(=)表示當前操作表達式指定了一個純粹的輸出操作，而加號(+)則表示當前操作表達式不僅僅只是一個輸出操作還是一個輸入操作。但無論是等號(=)約束還是加號(+)約束所約束的操作表達式都只能放在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被放在內(nèi)存-4(%ebp)的位置，所以指令mov %eax, -4(%ebp)即表示將%eax的內(nèi)容輸出到變量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));

    b)、Input

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

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

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

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

    括號中的表達式cpu->db7是一個C/C++語言的表達式，它不必是一個左值表達式，也就是說它不僅可以是放在C/C++賦值操作左邊的表達式，還可以是放在C/C++賦值操作右邊的表達式。所以它可以是一個變量，一個數(shù)字，還可以是一個復雜的表達式（比如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輸入到當前內(nèi)聯(lián)匯編中。

    我們看一個例子：

    $ 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的內(nèi)容裝入了eax寄存器。

    c). Operation Constraint

    每一個Input和Output表達式都必須指定自己的操作約束Operation Constraint，我們這里來討論在80386平臺上所可能使用的操作約束。

    1、寄存器約束

    當你當前的輸入或輸入需要借助一個寄存器時，你需要為其指定一個寄存器約束。你可以直接指定一個寄存器的名字，比如：

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

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

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

    如果你指定一個縮寫，比如字母a，則GCC將會根據(jù)當前操作表達式中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、內(nèi)存約束

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

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

    ("lidt %0" : :"m"(__idt_addr));

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

    $ cat example5.c

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