寄存器或內存

“g” 將輸入變量放入eax，ebx，ecx ，edx中的一個或者作為內存變量
“X”操作數可以是任何類型


立即數
“I” 0-31 之間的立即數（用于32位移位指令）
“J” 0-63 之間的立即數（用于64 位移位指令）
“N” 0-255 ，之間的立即數（用于out 指令）
“i” 立即數
“n” 立即數，有些系統不支持除字以外的立即數，這些系統應該使用“n”而不是“i”


匹配

“0”，“1 ，”... “9 ”

表示用它限制的操作數與某個指定的操作數匹配，也即該操作數就是指定的那個操作數，
例如用“0 ”去描述“％1”操作數，那么“%1”引用的其實就是“%0”操作數，注意作為
限定符字母的0－9 ，與指令中的“％0”－“％9”的區別，前者描述操作數，后者代表操作數。


后面有詳細描述 & 該輸出操作數不能使用過和輸入操作數相同的寄存器


后面有詳細描述


操作數類型
“=” 操作數在指令中是只寫的（輸出操作數）
“+” 操作數在指令中是讀寫類型的（輸入輸出操作數）

浮點數
“f”

浮點寄存器
“t”第一個浮點寄存器
“u”第二個浮點寄存器
“G”標準的80387

浮點常數
% 該操作數可以和下一個操作數交換位置


例如addl的兩個操作數可以交換順序（當然兩個操作數都不能是立即數）


# 部分注釋，從該字符到其后的逗號之間所有字母被忽略

* 表示如果選用寄存器，則其后的字母被忽略


現在繼續看上面的例子，
"=m" (ADDR)表示ADDR為內存變量（“m”），而且是輸出變量（“=”）；"Ir" (nr)表示nr，為
0－31之間的立即數（“I”）或者一個寄存器操作數（“r”）。



2.3.4.2
匹配限制符

I386
指令集中許多指令的操作數是讀寫型的（讀寫型操作數指先讀取原來的值然后參加運算，最后
將結果寫回操作數），例如addl %1,%0，它的作用是將操作數%0與操作數%1的和存入操作數%0，
因此操作數%0是讀寫型操作數。老版本的GCC對這種類型操作數的支持不是很好，它將操作數嚴格
分為輸入和輸出兩種，分別放在輸入部分和輸出部分，而沒有一個單獨部分描述讀寫型操作數，
因此在GCC中讀寫型的操作數需要在輸入和輸出部分分別描述，靠匹配限制符將兩者關聯到一起
注意僅在輸入和輸出部分使用相同的C變量，但是不用匹配限制符，產生的代碼很可能不對，后
面會分析原因。




匹配限制符是一位數字：“0”、“1”……“9，”，分別表示它限制的C表達式分別與
占位符%0，%1，……%9對應的C變量匹配。例如使用“0”作為%1，的限制字符，那么
%0和％1表示同一個C，變量。


看一下下面的代碼就知道為什么要將讀寫型操作數，分別在輸入和輸出部分加以描述。


該例功能是求input+result的和，然后存入result：


extern int input,result;

void test_at_t()
{
result= 0;
input = 1;
__asm__
__volatile__ ("addl %1,%0":"=r"(result): "r"(input));

}

對應的匯編代碼為：

movl $0,_result
movl $1,_input
movl _input,%edx /APP
addl %edx,%eax /NO_APP
movl %eax,%edx
movl %edx,_result

input 為輸入型變量，而且需要放在寄存器中，GCC給它分配的寄存器是%edx，在執行addl之前%edx，
的內容已經是input的值。可見對于使用“r”限制的輸入型變量或者表達式，在使用之前GCC會插入
必要的代碼將他們的值讀到寄存器；“m”型變量則不需要這一步。讀入input后執行addl，顯然%eax
的值不對，需要先讀入result的值才行。再往后看：movl %eax,%edx和movl %edx,_result
的作用是將結果存回result，分配給result的寄存器與分配給input的一樣，都是%edx。

綜上可以總結出如下幾點：

1. 使用“r”限制的輸入變量，GCC先分配一個寄存器，然后將值讀入寄存器，最后
用該寄存器替換占位符；


2. 使用“r”限制的輸出變量，GCC會分配一個寄存器，然后用該寄存器替換占位符，
但是在使用該寄存器之前并不將變量值先讀入寄存器，GCC認為所有輸出變量以前的
值都沒有用處，不讀入寄存器（可能是因為AT&T匯編源于CISC架構處理器的匯編語言
，在CISC處理器中大部分指令的輸入輸出明顯分開，而不像RISC那樣一個操作數既
做輸入又做輸出，例如add r0,r1,r2，r0，和r1是輸入，r2是輸出，輸入和輸出分開，
沒有使用輸入輸出型操作數，這樣我們就可以認為r2對應的操作數原來的值沒有用處，
也就沒有必要先將操作數的值讀入r2，因為這是浪費處理器的CPU周期），最后GCC插入代碼，
將寄存器的值寫回變量；


3. 輸入變量使用的寄存器在最后一處使用它的指令之后，就可以挪做其他用處，因為
已經不再使用。例如上例中的%edx。在執行完addl之后就作為與result對應的寄存器。


因為第二條，上面的內嵌匯編指令不能奏效，因此需要在執行addl之前把result的值讀入
寄存器，也許再將result放入輸入部分就可以了（因為第一條會保證將result
先讀入寄存器）。修改后的指令如下（為了更容易說明問題將input限制符由“r，”改為“m”）：


extern int input,result;

void test_at_t()
{

result = 0;
input = 1;
__asm__
__volatile__ ("addl %2,%0":"=r"(result):"r"(result),"m"(input));

}


看上去上面的代碼可以正常工作，因為我們知道%0和%1都和result相關，應該使用同一個
寄存器，但是GCC并不去判斷%0和%1，是否和同一個C表達式或變量相關聯（這樣易于產生與
內嵌匯編相應的匯編代碼），因此%0和%1使用的寄存器可能不同。我們看一下匯編代碼就知道了。

movl $0,_result
movl $1,_input
movl _result,%edx /APP
addl _input,%eax /NO_APP
movl %eax,%edx
movl %edx,_result

現在在執行addl之前將result的值被讀入了寄存器%edx，但是addl指令的操作數%0
卻成了%eax，而不是%edx，與預料的不同，這是因為GCC給輸出和輸入部分的變量分配了不同
的寄存器，GCC沒有去判斷兩者是否都與result相關，后面會講GCC如何翻譯內嵌匯編，看完之后
就不會驚奇啦。


使用匹配限制符后，GCC知道應將對應的操作數放在同一個位置（同一個寄存器或者同一個
內存變量）。使用匹配限制字符的代碼如下：


extern int input,result;

void test_at_t()
{
result = 0;
input = 1;
__asm__
__volatile__ ("addl %2,%0":"=r"(result):"0"(result),"m"(input));

}

輸入部分中的result用匹配限制符“0”限制，表示%1與％0，代表同一個變量，
輸入部分說明該變量的輸入功能，輸出部分說明該變量的輸出功能，兩者結合表示result
是讀寫型。因為%0和%1，表示同一個C變量，所以放在相同的位置，無論是寄存器還是內存。

相應的匯編代碼為：


movl $0,_result
movl $1,_input
movl _result,%edx
movl %edx,%eax /APP
addl _input,%eax /NO_APP
movl %eax,%edx
movl %edx,_result


可以看到與result相關的寄存器是%edx，在執行指令addl之前先從%edx將result讀入%eax，
執行之后需要將結果從%eax讀入%edx，最后存入result中。這里我們可以看出GCC
處理內嵌匯編中輸出操作數的一點點信息：addl并沒有使用%edx，可見它不是簡單的用result
對應的寄存器%edx去替換%0，而是先分配一個寄存器，執行運算，最后才將運算結果存入
對應的變量，因此GCC是先看該占位符對應的變量的限制符，發現是一個輸出型寄存器變量，
就為它分配一個寄存器，此時沒有去管對應的C變量，最后GCC，知道還要將寄存器的值寫回變量，
與此同時，它發現該變量與%edx關聯，因此先存入%edx，再存入變量。


至此讀者應該明白了匹配限制符的意義和用法。在新版本的GCC中增加了一個限制字符“+”，
它表示操作數是讀寫型的，GCC知道應將變量值先讀入寄存器，然后計算，最后寫回變量，而
無需在輸入部分再去描述該變量。


例;
extern int input,result;

void test_at_t()
{

result = 0;
input = 1;
__asm__
__volatile__ ("addl %1,%0":"+r"(result):"m"(input));

}


此處用“+”替換了“=”，而且去掉了輸入部分關于result的描述，產生的匯編代碼如下：
movl $0,_result
movl $1,_input
movl _result,%eax /APP
addl _input,%eax /NO_APP
movl %eax,_result
L2:
movl %ebp,%esp

處理的比使用匹配限制符的情況還要好，省去了好幾條匯編代碼。


2.3.4.3 “&”限制符

限制符“&”在內核中使用的比較多，它表示輸入和輸出操作數不能使用相同的寄存器，
這樣可以避免很多錯誤。

舉一個例子，下面代碼的作用是將函數foo的返回值存入變量ret中：


__asm__ ( “call foo;movl %%edx,%1”, :”=a”(ret) : ”r”(bar) );


我們知道函數的int型返回值存放在%eax中，但是gcc編譯的結果是輸入和輸出同時使用了
寄存器%eax，如下：

movl bar, %eax
#APP
call foo
movl %ebx,%eax

#NO_APP
movl %eax, ret

結果顯然不對，原因是GCC并不知道%eax中的值是我們所要的。避免這種情況的方法是使用“&”
限定符，這樣bar就不會再使用%eax寄存器，因為已被ret指定使用。

_asm__ ( “call foo;movl %%edx,%1”,:”=&a”(ret) : ”r”(bar) );


2.3.5 破壞描述部分

2.3.5.1 寄存器破壞描述符


通常編寫程序只使用一種語言：高級語言或者匯編語言。高級語言編譯的步驟大致如下：
l
預處理；
l
編譯
l
匯編
l
鏈接


我們這里只關心第二步編譯（將C代碼轉換成匯編代碼）：因為所有的代碼都是用高級語言編寫，
編譯器可以識別各種語句的作用，在轉換的過程中所有的寄存器都由編譯器決定如何分配使用，
它有能力保證寄存器的使用不會沖突；也可以利用寄存器作為變量的緩沖區，因為寄存器的訪問
速度比內存快很多倍。如果全部使用匯編語言則由程序員去控制寄存器的使用，只能靠程序員去
保證寄存器使用的正確性。但是如果兩種語言混用情況就變復雜了，因為內嵌的匯編代碼可以直接
使用寄存器，而編譯器在轉換的時候并不去檢查內嵌的匯編代碼使用了哪些寄存器（因為很難檢測
匯編指令使用了哪些寄存器，例如有些指令隱式修改寄存器，有時內嵌的匯編代碼會調用其他子過程，
而子過程也會修改寄存器），因此需要一種機制通知編譯器我們使用了哪些寄存器（程序員自己知道
內嵌匯編代碼中使用了哪些寄存器），否則對這些寄存器的使用就有可能導致錯誤，修改描述部分
可以起到這種作用。當然內嵌匯編的輸入輸出部分指明的寄存器或者指定為“r”，“g”型由編譯器
去分配的寄存器就不需要在破壞描述部分去描述，因為編譯器已經知道了。


破壞描述符由逗號格開的字符串組成，每個字符串描述一種情況，一般是寄存器名；除寄存器外
還有“memory”。例如：“%eax”，“%ebx”，“memory”等。


下面看個例子就很清楚為什么需要通知GCC內嵌匯編代碼中隱式（稱它為隱式是因為GCC并不知道）
使用的寄存器。

在內嵌的匯編指令中可能會直接引用某些寄存器，我們已經知道AT&T格式的匯編語言中，寄存器
名以“%”作為前綴，為了在生成的匯編程序中保留這個“%”號，在asm語句中對寄存器的
引用必須用“%%”作為寄存器名稱的前綴。原因是“%”在asm，內嵌匯編語句中的作用與“\”在C
語言中的作用相同，因此“%%”轉換后代表“%”。

例（沒有使用修改描述符）：

int main(void)
{
int input, output,temp;
input = 1;

__asm__ __volatile__ ("movl $0, %%eax;\n\t
movl %%eax, %1;\n\t
movl %2, %%eax;\n\t
movl %%eax, %0;\n\t"
:"=m"(output),"=m"(temp) /* output */
:"r"(input) /* input */
);
return 0;
}


這段代碼使用%eax作為臨時寄存器，功能相當于C代碼：“temp = 0;output=input”，
對應的匯編代碼如下：

movl $1,-4(%ebp)
movl -4(%ebp),%eax /APP
movl $0, %eax;
movl %eax, -12(%ebp);
movl %eax, %eax;
movl %eax, -8(%ebp); /NO_APP

顯然GCC給input分配的寄存器也是%eax，發生了沖突，output的值始終為0，而不是input。

使用破壞描述后的代碼：


int main(void)
{
int input, output,temp;

input = 1;

__asm__ __volatile__
( "movl $0, %%eax;\n\t
movl %%eax, %1;\n\t
movl %2, %%eax;\n\t
movl %%eax, %0;\n\t"
:"=m"(output),"=m"(temp) /* output */
:"r"(input) /* input */
:"eax"); /* 描述符 */

return 0;
}

對應的匯編代碼：


movl $1,-4(%ebp)
movl -4(%ebp),%edx /APP
movl $0, %eax;
movl %eax, -12(%ebp);
movl %edx, %eax;
movl %eax, -8(%ebp); /NO_APP


通過破壞描述部分，GCC得知%eax已被使用，因此給input分配了%edx。在使用內嵌匯編時請記
住一點：盡量告訴GCC盡可能多的信息，以防出錯。


如果你使用的指令會改變CPU的條件寄存器cc，需要在修改描述部分增加“cc”。

2.3.5.2 memory破壞描述符

“memory”比較特殊，可能是內嵌匯編中最難懂部分。為解釋清楚它，先介紹一下編譯器的
優化知識，再看C關鍵字volatile。最后去看該描述符。

2.3.5.2.1 編譯器優化介紹

內存訪問速度遠不及CPU處理速度，為提高機器整體性能，在硬件上引入硬件高速緩存Cache，
加速對內存的訪問。另外在現代CPU中指令的執行并不一定嚴格按照順序執行，沒有相關性
的指令可以亂序執行，以充分利用CPU的指令流水線，提高執行速度。以上是硬件級別的優化。
再看軟件一級的優化：一種是在編寫代碼時由程序員優化，另一種是由編譯器進行優化。編譯器
優化常用的方法有：將內存變量緩存到寄存器；調整指令順序充分利用CPU指令流水線，常見的
是重新排序讀寫指令。


對常規內存進行優化的時候，這些優化是透明的，而且效率很好。由編譯器優化或者硬件重新排序引起的問題的解決辦法是在從硬件（或者其他處理器）的角度看必須以特定順序執行的操作之間設置內存屏障（memory barrier），linux提供了一個宏解決編譯器的執行順序問題。

void Barrier(void)

這個函數通知編譯器插入一個內存屏障，但對硬件無效，編譯后的代碼會把當前CPU
寄存器中的所有修改過的數值存入內存，需要這些數據的時候再重新從內存中讀出。

2.3.5.2.2 C 語言關鍵字volatile

C 語言關鍵字volatile（注意它是用來修飾變量而不是上面介紹的__volatile__）表明某個變量
的值可能在外部被改變，因此對這些變量的存取不能緩存到寄存器，每次使用時需要重新存取。
該關鍵字在多線程環境下經常使用，因為在編寫多線程的程序時，同一個變量可能被多個線程修
改，而程序通過該變量同步各個線程，例如：


DWORD __stdcall threadFunc(LPVOID signal)
{

int* intSignal=reinterpret_cast