最牛X的GCC 內聯彙編

時間 2020-03-16

標籤 gcc 內聯彙編欄目 GCC 简体版

原文原文鏈接

1. 簡介linux

1.1 版權許可編程

本文檔自由共享；你能夠從新發布它，而且/或者在遵循自由軟件基金會發布的 GNU 通用公共許可證下修改它；也能夠是該許可證的版本 2 或者（按照你的需求）更晚的版本。函數

發佈這篇文檔是但願它可以幫助別人，可是沒有任何擔保；甚至不包括可售性和適用於任何特定目的的擔保。關於更詳細的信息，能夠查看 GNU 通用許可證。學習

1.2 反饋校訂優化

請將反饋和批評一塊兒提交給 Sandeep.S。我將感謝任何一個指出本文檔中錯誤和不許確之處的人；一被告知，我會立刻改正它們。編碼

1.3 致謝.net

我對提供如此棒的特性的 GNU 人們表示真誠的感謝。感謝 Mr.Pramode C E 所作的全部幫助。感謝在 Govt Engineering College 和 Trichur 的朋友們的精神支持和合做，尤爲是 Nisha Kurur 和 Sakeeb S 。感謝在 Gvot Engineering College 和 Trichur 的老師們的合做。code

另外，感謝 Phillip , Brennan Underwood 和 colin@nyx.net ；這裏的許多東西都厚顏地直接取自他們的工做成果。
教程

2. 概覽

在這裏，咱們將學習 GCC 內聯彙編。這裏內聯表示的是什麼呢？

咱們能夠要求編譯器將一個函數的代碼插入到調用者代碼中函數被實際調用的地方。這樣的函數就是內聯函數。這聽起來和宏差很少？這二者確實有類似之處。

內聯函數的優勢是什麼呢？

這種內聯方法能夠減小函數調用開銷。同時若是全部實參的值爲常量，它們的已知值能夠在編譯期容許簡化，所以並不是全部的內聯函數代碼都須要被包含進去。代碼大小的影響是不可預測的，這取決於特定的狀況。爲了聲明一個內聯函數，咱們必須在函數聲明中使用 "inline" 關鍵字。

如今咱們正處於一個猜想內聯彙編究竟是什麼的點上。它只不過是一些寫爲內聯函數的彙編程序。在系統編程上，它們方便、快速而且極其有用。咱們主要集中學習（GCC）內聯彙編函數的基本格式和用法。爲了聲明內聯彙編函數，咱們使用 "asm" 關鍵詞。

內聯彙編之因此重要，主要是由於它能夠操做而且使其輸出經過 C 變量顯示出來。正是由於此能力， "asm" 能夠用做彙編指令和包含它的 C 程序之間的接口。

3. GCC 彙編語法

Linux上的 GNU C 編譯器 GCC ，使用 AT&T / UNIX 彙編語法。在這裏，咱們將使用 AT&T 語法進行彙編編碼。若是你對 AT&T 語法不熟悉的話，請沒關係張，我會教你的。AT&T 語法和 Intel 語法的差異很大。我會給出主要的區別。

1.源操做數和目的操做數順序

AT&T 語法的操做數方向和 Intel 語法的恰好相反。在Intel 語法中，第一操做數爲目的操做數，第二操做數爲源操做數，然而在 AT&T 語法中，第一操做數爲源操做數，第二操做數爲目的操做數。也就是說，

Intel 語法中的 "Op-code dst src" 變爲 AT&T 語法中的 "Op-code src dst"。

2.寄存器命名

寄存器名稱有 "%" 前綴，即若是必須使用 "eax"，它應該用做 "%eax"。

3.當即數

AT&T 當即數以 "$" 爲前綴。靜態 "C" 變量也使用 "$" 前綴。在 Intel 語法中，十六進制常量以 "h" 爲後綴，然而 AT&T 不使用這種語法，這裏咱們給常量添加前綴 "0x"。因此，對於十六進制，咱們首先看到一個 "$"，而後是 "0x"，最後纔是常量。

4.操做數大小

在 AT&T 語法中，存儲器操做數的大小取決於操做碼名字的最後一個字符。操做碼後綴 ’b’ 、’w’、’l’ 分別指明瞭字節（8位）、字（16位）、長型（32位）存儲器引用。Intel 語法經過給存儲器操做數添加 "byte ptr"、 "word ptr" 和 "dword ptr" 前綴來實現這一功能。

所以，Intel的 "mov al, byte ptr foo" 在 AT&T 語法中爲 "movb foo, %al"。

5.存儲器操做數

在 Intel 語法中，基址寄存器包含在 "[" 和 "]" 中，然而在 AT&T 中，它們變爲 "(" 和 ")"。另外，在 Intel 語法中，間接內存引用爲

"section:[base + index*scale + disp]"，在 AT&T中變爲 "section:disp(base, index, scale)"。

須要牢記的一點是，當一個常量用於 disp 或 scale，不能添加 "$" 前綴。

如今咱們看到了 Intel 語法和 AT&T 語法之間的一些主要差異。我僅僅寫了它們差異的一部分而已。關於更完整的信息，請參考 GNU 彙編文檔。如今爲了更好地理解，咱們能夠看一些示例。

+------------------------------+------------------------------------+
|       Intel Code             |      AT&T Code                     |
+------------------------------+------------------------------------+
| mov     eax,1                |  movl    $1,%eax                   |   
| mov     ebx,0ffh             |  movl    $0xff,%ebx                |   
| int     80h                  |  int     $0x80                     |   
| mov     ebx, eax             |  movl    %eax, %ebx                |
| mov     eax,[ecx]            |  movl    (%ecx),%eax               |
| mov     eax,[ebx+3]          |  movl    3(%ebx),%eax              | 
| mov     eax,[ebx+20h]        |  movl    0x20(%ebx),%eax           |
| add     eax,[ebx+ecx*2h]     |  addl    (%ebx,%ecx,0x2),%eax      |
| lea     eax,[ebx+ecx]        |  leal    (%ebx,%ecx),%eax          |
| sub     eax,[ebx+ecx*4h-20h] |  subl    -0x20(%ebx,%ecx,0x4),%eax |
+------------------------------+------------------------------------+

4. 基本內聯

基本內聯彙編的格式很是直接了當。它的基本格式爲：
asm("彙編代碼");
示例

asm("movl %ecx %eax"); /* 將 ecx 寄存器的內容移至 eax  */
__asm__("movb %bh (%eax)"); /* 將 bh 的一個字節數據 移至 eax 寄存器指向的內存 */

你可能注意到了這裏我使用了 "asm" 和 "__asm__"。這二者都是有效的。若是關鍵詞 "asm" 和咱們程序的一些標識符衝突了，咱們可使用 "__asm__"。若是咱們的指令多於一條，咱們能夠每一個一行，並用雙引號圈起，同時爲每條指令添加 ’/n’ 和 ’/t’ 後綴。這是由於 gcc 將每一條看成字符串發送給as（GAS）（LCTT 譯註： GAS 即 GNU 彙編器），而且經過使用換行符/製表符發送正確格式化後的行給彙編器。

示例

__asm__ ("movl %eax, %ebx/n/t"
         "movl $56, %esi/n/t"
         "movl %ecx, $label(%edx,%ebx,$4)/n/t"
         "movb %ah, (%ebx)");

若是在代碼中，咱們涉及到一些寄存器（即改變其內容），但在沒有恢復這些變化的狀況下從彙編中返回，這將會致使一些意想不到的事情。這是由於 GCC 並不知道寄存器內容的變化，這會致使問題，特別是當編譯器作了某些優化。在沒有告知 GCC 的狀況下，它將會假設一些寄存器存儲了一些值——而咱們可能已經改變卻沒有告知 GCC——它會像什麼事都沒發生同樣繼續運行（LCTT 譯註：什麼事都沒發生同樣是指GCC不會假設寄存器裝入的值是有效的，當退出改變了寄存器值的內聯彙編後，寄存器的值不會保存到相應的變量或內存空間）。咱們所能夠作的是使用那些沒有反作用的指令，或者當咱們退出時恢復這些寄存器，要不就等着程序崩潰吧。這是爲何咱們須要一些擴展功能，擴展彙編給咱們提供了那些功能。

5. 擴展彙編

在基本內聯彙編中，咱們只有指令。然而在擴展彙編中，咱們能夠同時指定操做數。它容許咱們指定輸入寄存器、輸出寄存器以及修飾寄存器列表。GCC 不強制用戶必須指定使用的寄存器。咱們能夠把頭疼的事留給 GCC ，這可能能夠更好地適應 GCC 的優化。無論怎麼說，基本格式爲：
asm ( 彙編程序模板
: 輸出操做數 /* 可選的 */
: 輸入操做數 /* 可選的 */
: 修飾寄存器列表 /* 可選的 */
);

彙編程序模板由彙編指令組成。每個操做數由一個操做數約束字符串所描述，其後緊接一個括弧括起的 C 表達式。冒號用於將彙編程序模板和第一個輸出操做數分開，另外一個（冒號）用於將最後一個輸出操做數和第一個輸入操做數分開（若是存在的話）。逗號用於分離每個組內的操做數。總操做數的數目限制在 10 個，或者機器描述中的任何指令格式中的最大操做數數目，以較大者爲準。

若是沒有輸出操做數但存在輸入操做數，你必須將兩個連續的冒號放置於輸出操做數本來會放置的地方周圍。

示例：

asm ("cld/n/t"
     "rep/n/t"
     "stosl"
     : /* 無輸出寄存器 */
     : "c" (count), "a" (fill_value), "D" (dest)
     : "%ecx", "%edi" 
     );

如今來看看這段代碼是幹什麼的？以上的內聯彙編是將 "fill_value" 值連續 "count" 次拷貝到寄存器 "edi" 所指位置（LCTT 譯註：每執行 stosl 一次，寄存器 edi 的值會遞增或遞減，這取決因而否設置了 direction 標誌，所以以上代碼實則初始化一個內存塊）。它也告訴 gcc 寄存器 "ecx" 和 "edi" 一直無效。爲了更加清晰地說明，讓咱們再看一個示例。

int a=10, b;
asm ("movl %1, %%eax; 
      movl %%eax, %0;"
     :"=r"(b)        /* 輸出 */
     :"r"(a)         /* 輸入 */
     :"%eax"         /* 修飾寄存器 */
     );

這裏咱們所作的是使用匯編指令使 ’b’ 變量的值等於 ’a’ 變量的值。一些有意思的地方是：

"b" 爲輸出操做數，用 %0 引用，而且 "a" 爲輸入操做數，用 %1 引用。
"r" 爲操做數約束。以後咱們會更詳細地瞭解約束（字符串）。目前，"r" 告訴 GCC 可使用任一寄存器存儲操做數。輸出操做數約束應該有一個約束脩飾符 "=" 。這修飾符代表它是一個只讀的輸出操做數。
寄存器名字以兩個 % 爲前綴。這有利於 GCC 區分操做數和寄存器。操做數以一個 % 爲前綴。
第三個冒號以後的修飾寄存器 %eax 用於告訴 GCC %eax 的值將會在 "asm" 內部被修改，因此 GCC 將不會使用此寄存器存儲任何其餘值。

當「asm」執行完畢， "b" 變量會映射到更新的值，由於它被指定爲輸出操做數。換句話說，「asm」內 "b" 變量的修改應該會被映射到「asm」外部。

如今，咱們能夠更詳細地看看每個域。

1.彙編程序模板

彙編程序模板包含了被插入到 C 程序的彙編指令集。其格式爲：每條指令用雙引號圈起，或者整個指令組用雙引號圈起。同時每條指令應以分界符結尾。有效的分界符有換行符（"/n"）和分號（";"）。"/n" 能夠緊隨一個製表符（"/t"）。咱們應該都明白使用換行符或製表符的緣由了吧（LCTT 譯註：就是爲了排版和分隔）？和 C 表達式對應的操做數使用 %0、%1 ... 等等表示。

2.操做數

C 表達式用做「asm」內的彙編指令操做數。每一個操做數前面是以雙引號圈起的操做數約束。對於輸出操做數，在引號內還有一個約束脩飾符，其後緊隨一個用於表示操做數的 C 表達式。即，「操做數約束」（C 表達式）是一個通用格式。對於輸出操做數，還有一個額外的修飾符。約束字符串主要用於決定操做數的尋址方式，同時也用於指定使用的寄存器。

若是咱們使用的操做數多於一個，那麼每個操做數用逗號隔開。

在彙編程序模板中，每一個操做數用數字引用。編號方式以下。若是總共有 n 個操做數（包括輸入和輸出操做數），那麼第一個輸出操做數編號爲 0 ，逐項遞增，而且最後一個輸入操做數編號爲 n - 1 。操做數的最大數目在前一節咱們講過。

輸出操做數表達式必須爲左值。輸入操做數的要求不像這樣嚴格。它們能夠爲表達式。擴展彙編特性經常用於編譯器所不知道的機器指令 ;-)。若是輸出表達式沒法直接尋址（即，它是一個位域），咱們的約束字符串必須給定一個寄存器。在這種狀況下，GCC 將會使用該寄存器做爲彙編的輸出，而後存儲該寄存器的內容到輸出。

正如前面所陳述的同樣，普通的輸出操做數必須爲只寫的； GCC 將會假設指令前的操做數值是死的，而且不須要被（提早）生成。擴展彙編也支持輸入-輸出或者讀-寫操做數。

因此如今咱們來關注一些示例。咱們想要求一個數的5次方結果。爲了計算該值，咱們使用 "lea" 指令。

asm ("leal (%1,%1,4), %0"
     : "=r" (five_times_x)
     : "r" (x) 
     );

這裏咱們的輸入爲 x。咱們不指定使用的寄存器。 GCC 將會選擇一些輸入寄存器，一個輸出寄存器，來作咱們預期的工做。若是咱們想要輸入和輸出放在同一個寄存器裏，咱們也能夠要求 GCC 這樣作。這裏咱們使用那些讀-寫操做數類型。這裏咱們經過指定合適的約束來實現它。

asm ("leal (%0,%0,4), %0"
     : "=r" (five_times_x)
     : "0" (x) 
     );

如今輸出和輸出操做數位於同一個寄存器。可是咱們沒法得知是哪個寄存器。如今假如咱們也想要指定操做數所在的寄存器，這裏有一種方法。

asm ("leal (%%ecx,%%ecx,4), %%ecx"
     : "=c" (x)
     : "c" (x) 
     );

在以上三個示例中，咱們並無在修飾寄存器列表裏添加任何寄存器，爲何？在頭兩個示例， GCC 決定了寄存器而且它知道發生了什麼改變。在最後一個示例，咱們沒必要將 'ecx' 添加到修飾寄存器列表（LCTT 譯註：原文修飾寄存器列表這個單詞拼寫有錯，這裏已修正），gcc 知道它表示 x。所以，由於它能夠知道 "ecx" 的值，它就不被看成修飾的（寄存器）了。

3.修飾寄存器列表

一些指令會破壞一些硬件寄存器內容。咱們不得不在修飾寄存器中列出這些寄存器，即彙編函數內第三個 ’:’ 以後的域。這能夠通知 gcc 咱們將會本身使用和修改這些寄存器，這樣 gcc 就不會假設存入這些寄存器的值是有效的。咱們不用在這個列表裏列出輸入、輸出寄存器。由於 gcc 知道「asm」使用了它們（由於它們被顯式地指定爲約束了）。若是指令隱式或顯式地使用了任何其餘寄存器，（而且寄存器沒有出如今輸出或者輸出約束列表裏），那麼就須要在修飾寄存器列表中指定這些寄存器。

若是咱們的指令能夠修改條件碼寄存器（cc），咱們必須將 "cc" 添加進修飾寄存器列表。

若是咱們的指令以不可預測的方式修改了內存，那麼須要將 "memory" 添加進修飾寄存器列表。這可使 GCC 不會在彙編指令間保持緩存於寄存器的內存值。若是被影響的內存不在彙編的輸入或輸出列表中，咱們也必須添加 "volatile" 關鍵詞。

咱們能夠按咱們的需求屢次讀寫修飾寄存器。參考一下模板內的多指令示例；它假設子例程 _foo 接受寄存器 "eax" 和 "ecx" 裏的參數。

asm ("movl %0,%%eax;
      movl %1,%%ecx;
      call _foo"
     : /* no outputs */
     : "g" (from), "g" (to)
     : "eax", "ecx"
     );

4.Volatile ...?

若是你熟悉內核源碼或者相似漂亮的代碼，你必定見過許多聲明爲 "volatile" 或者 "__volatile__"的函數，其跟着一個 "asm" 或者 "__asm__"。我以前提到過關鍵詞 "asm" 和 "__asm__"。那麼什麼是 "volatile" 呢？

若是咱們的彙編語句必須在咱們放置它的地方執行（例如，不能爲了優化而被移出循環語句），將關鍵詞 "volatile" 放置在 asm 後面、()的前面。以防止它被移動、刪除或者其餘操做，咱們將其聲明爲 "asm volatile ( ... : ... : ... : ...);"

若是擔憂發生衝突，請使用 "__volatile__"。

若是咱們的彙編只是用於一些計算而且沒有任何反作用，不使用 "volatile" 關鍵詞會更好。不使用 "volatile" 能夠幫助 gcc 優化代碼並使代碼更漂亮。

在「一些實用的訣竅」一節中，我提供了多個內聯彙編函數的例子。那裏咱們能夠了解到修飾寄存器列表的細節。

6. 更多關於約束

到這個時候，你可能已經瞭解到約束和內聯彙編有很大的關聯。但咱們對約束講的還很少。約束用於代表一個操做數是否能夠位於寄存器和位於哪一種寄存器；操做數是否能夠爲一個內存引用和哪一種地址；操做數是否能夠爲一個當即數和它可能的取值範圍（即值的範圍），等等。

6.1 經常使用約束/strong>

在許多約束中，只有小部分是經常使用的。咱們來看看這些約束。
1. 寄存器操做數約束

當使用這種約束指定操做數時，它們存儲在通用寄存器（GPR）中。請看下面示例：

asm ("movl %%eax, %0/n" :"=r"(myval));

這裏，變量 myval 保存在寄存器中，寄存器 eax 的值被複制到該寄存器中，而且 myval 的值從寄存器更新到了內存。當指定 "r" 約束時， gcc 能夠將變量保存在任何可用的 GPR 中。要指定寄存器，你必須使用特定寄存器約束直接地指定寄存器的名字。它們爲：

+---+--------------------+
| r |    Register(s)     |
+---+--------------------+
| a |   %eax, %ax, %al   |
| b |   %ebx, %bx, %bl   |
| c |   %ecx, %cx, %cl   |
| d |   %edx, %dx, %dl   |
| S |   %esi, %si        |
| D |   %edi, %di        |
+---+--------------------+

2. 內存操做數約束

當操做數位於內存時，任何對它們的操做將直接發生在內存位置，這與寄存器約束相反，後者首先將值存儲在要修改的寄存器中，而後將它寫回到內存位置。但寄存器約束一般用於一個指令必須使用它們或者它們能夠大大提升處理速度的地方。當須要在「asm」內更新一個 C 變量，而又不想使用寄存器去保存它的值，使用內存最爲有效。例如，IDTR 寄存器的值存儲於內存位置 loc 處：

asm("sidt %0/n" : :"m"(loc));

3. 匹配（數字）約束

在某些狀況下，一個變量可能既充當輸入操做數，也充當輸出操做數。能夠經過使用匹配約束在 "asm" 中指定這種狀況。

asm ("incl %0" :"=a"(var):"0"(var));

在操做數那一節中，咱們也看到了一些相似的示例。在這個匹配約束的示例中，寄存器 "%eax" 既用做輸入變量，也用做輸出變量。 var 輸入被讀進 %eax，而且等遞增後更新的 %eax 再次被存儲進 var。這裏的 "0" 用於指定與第 0 個輸出變量相同的約束。也就是，它指定 var 輸出實例應只被存儲在 "%eax" 中。該約束可用於：

在輸入從變量讀取或變量修改後且修改被寫回同一變量的狀況
在不須要將輸入操做數實例和輸出操做數實例分開的狀況

使用匹配約束最重要的意義在於它們能夠有效地使用可用寄存器。

其餘一些約束：

"m" : 容許一個內存操做數，可使用機器廣泛支持的任一種地址。
"o" : 容許一個內存操做數，但只有當地址是可偏移的。即，該地址加上一個小的偏移量能夠獲得一個有效地址。
"V" : 一個不容許偏移的內存操做數。換言之，任何適合 "m" 約束而不適合 "o" 約束的操做數。
"i" : 容許一個（帶有常量）的當即整形操做數。這包括其值僅在彙編時期知道的符號常量。
"n" : 容許一個帶有已知數字的當即整形操做數。許多系統不支持彙編時期的常量，由於操做數少於一個字寬。對於此種操做數，約束應該使用 'n' 而不是'i'。
"g" : 容許任一寄存器、內存或者當即整形操做數，不包括通用寄存器以外的寄存器。

如下約束爲 x86 特有。

"r" : 寄存器操做數約束，查看上面給定的表格。
"q" : 寄存器 a、b、c 或者 d。
"I" : 範圍從 0 到 31 的常量（對於 32 位移位）。
"J" : 範圍從 0 到 63 的常量（對於 64 位移位）。
"K" : 0xff。
"L" : 0xffff。
"M" : 0、一、2 或 3 （lea 指令的移位）。
"N" : 範圍從 0 到 255 的常量（對於 out 指令）。
"f" : 浮點寄存器
"t" : 第一個（棧頂）浮點寄存器
"u" : 第二個浮點寄存器
"A" : 指定 "a" 或 "d" 寄存器。這主要用於想要返回 64 位整形數，使用 "d" 寄存器保存最高有效位和 "a" 寄存器保存最低有效位。

6.2 約束脩飾符

當使用約束時，對於更精確的控制超過了對約束做用的需求，GCC 給咱們提供了約束脩飾符。最經常使用的約束脩飾符爲：

"=" : 意味着對於這條指令，操做數爲只寫的；舊值會被忽略並被輸出數據所替換。
"&" : 意味着這個操做數爲一個早期改動的操做數，其在該指令完成前經過使用輸入操做數被修改了。所以，這個操做數不能夠位於一個被用做輸出操做數或任何內存地址部分的寄存器。若是在舊值被寫入以前它僅用做輸入而已，一個輸入操做數能夠爲一個早期改動操做數。

上述的約束列表和解釋並不完整。示例可讓咱們對內聯彙編的用途和用法更好的理解。在下一節，咱們會看到一些示例，在那裏咱們會發現更多關於修飾寄存器列表的東西。

7. 一些實用的訣竅

如今咱們已經介紹了關於 GCC 內聯彙編的基礎理論，如今咱們將專一於一些簡單的例子。將內聯彙編函數寫成宏的形式老是很是方便的。咱們能夠在 Linux 內核代碼裏看到許多彙編函數。（usr/src/linux/include/asm/*.h）。

首先咱們從一個簡單的例子入手。咱們將寫一個兩個數相加的程序。
```
int main(void)
{
        int foo = 10, bar = 15;
        __asm__ __volatile__("addl  %%ebx,%%eax"
                             :"=a"(foo)
                             :"a"(foo), "b"(bar)
                             );
        printf("foo+bar=%d/n", foo);
        return 0;
}
```
這裏咱們要求 GCC 將 foo 存放於 %eax，將 bar 存放於 %ebx，同時咱們也想要在 %eax 中存放結果。'=' 符號表示它是一個輸出寄存器。如今咱們能夠以其餘方式將一個整數加到一個變量。
```
__asm__ __volatile__(
                     "   lock       ;/n"
                     "   addl %1,%0 ;/n"
                     : "=m"  (my_var)
                     : "ir"  (my_int), "m" (my_var)
                     :                                 /* 無修飾寄存器列表 */
                     );
```
這是一個原子加法。爲了移除原子性，咱們能夠移除指令 'lock'。在輸出域中，"=m" 代表 myvar 是一個輸出且位於內存。相似地，"ir" 代表 myint 是一個整型，並應該存在於其餘寄存器（回想咱們上面看到的表格）。沒有寄存器位於修飾寄存器列表中。
如今咱們將在一些寄存器/變量上展現一些操做，並比較值。
```
__asm__ __volatile__(  "decl %0; sete %1"
                     : "=m" (my_var), "=q" (cond)
                     : "m" (my_var) 
                     : "memory"
                     );
```
這裏，my_var 的值減 1 ，而且若是結果的值爲 0，則變量 cond 置 1。咱們能夠經過將指令 "lock;/n/t" 添加爲彙編模板的第一條指令以增長原子性。

以相似的方式，爲了增長 my_var，咱們可使用 "incl %0" 而不是 "decl %0"。

這裏須要注意的地方是（i）my_var 是一個存儲於內存的變量。（ii）cond 位於寄存器 eax、ebx、ecx、edx 中的任何一個。約束 "=q" 保證了這一點。（iii）同時咱們能夠看到 memory 位於修飾寄存器列表中。也就是說，代碼將改變內存中的內容。
如何置 1 或清 0 寄存器中的一個比特位。做爲下一個訣竅，咱們將會看到它。
```
__asm__ __volatile__(   "btsl %1,%0"
                      : "=m" (ADDR)
                      : "Ir" (pos)
                      : "cc"
                      );
```
這裏，ADDR 變量（一個內存變量）的 'pos' 位置上的比特被設置爲 1。咱們可使用 'btrl' 來清除由 'btsl' 設置的比特位。pos 的約束 "Ir" 代表 pos 位於寄存器，而且它的值爲 0-31（x86 相關約束）。也就是說，咱們能夠設置/清除 ADDR 變量上第 0 到 31 位的任一比特位。由於條件碼會被改變，因此咱們將 "cc" 添加進修飾寄存器列表。

如今咱們看看一些更爲複雜而有用的函數。字符串拷貝。

static inline char * strcpy(char * dest,const char *src)
{
int d0, d1, d2;
__asm__ __volatile__(  "1:/tlodsb/n/t"
                       "stosb/n/t"
                       "testb %%al,%%al/n/t"
                       "jne 1b"
                     : "=&S" (d0), "=&D" (d1), "=&a" (d2)
                     : "0" (src),"1" (dest) 
                     : "memory");
return dest;
}

源地址存放於 esi，目標地址存放於 edi，同時開始拷貝，當咱們到達 0 時，拷貝完成。約束 "&S"、"&D"、"&a" 代表寄存器 esi、edi 和 eax 早期修飾寄存器，也就是說，它們的內容在函數完成前會被改變。這裏很明顯能夠知道爲何 "memory" 會放在修飾寄存器列表。

咱們能夠看到一個相似的函數，它能移動雙字塊數據。注意函數被聲明爲一個宏。

#define mov_blk(src, dest, numwords) /
__asm__ __volatile__ (                                          /
                       "cld/n/t"                                /
                       "rep/n/t"                                /
                       "movsl"                                  /
                       :                                        /
                       : "S" (src), "D" (dest), "c" (numwords)  /
                       : "%ecx", "%esi", "%edi"                 /
                       )

這裏咱們沒有輸出，寄存器 ecx、esi和 edi 的內容發生了改變，這是塊移動的反作用。所以咱們必須將它們添加進修飾寄存器列表。

在 Linux 中，系統調用使用 GCC 內聯彙編實現。讓咱們看看如何實現一個系統調用。全部的系統調用被寫成宏（linux/unistd.h）。例如，帶有三個參數的系統調用被定義爲以下所示的宏。
```
type name(type1 arg1,type2 arg2,type3 arg3) /
{ /
long __res; /
__asm__ volatile (  "int $0x80" /
                  : "=a" (__res) /
                  : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), /
                    "d" ((long)(arg3))); /
__syscall_return(type,__res); /
}
```
不管什麼時候調用帶有三個參數的系統調用，以上展現的宏就會用於執行調用。系統調用號位於 eax 中，每一個參數位於 ebx、ecx、edx 中。最後 "int 0x80" 是一條用於執行系統調用的指令。返回值被存儲於 eax 中。

每一個系統調用都以相似的方式實現。Exit 是一個單一參數的系統調用，讓咱們看看它的代碼看起來會是怎樣。它以下所示。
```
{
        asm("movl $1,%%eax;         /* SYS_exit is 1 */
             xorl %%ebx,%%ebx;      /* Argument is in ebx, it is 0 */
             int  $0x80"            /* Enter kernel mode */
            );
}
```
Exit 的系統調用號是 1，同時它的參數是 0。所以咱們分配 eax 包含 1，ebx 包含 0，同時經過 "int $0x80" 執行 "exit(0)"。這就是 exit 的工做原理。