Using Assembly Language in Linux.

Intel和AT&T匯編語法差異：

1。前綴：

Intel匯編寄存器和立即數(shù)無需前綴。后者寄存器前綴為%，立即數(shù)前綴為$。

eg：

Intex Syntax

mov eax,1

mov ebx,0ffh

int 80h

AT&T Syntax

movl $1,%eax

movl $0xff,%ebx

int?? $0x80

2。二者對操作數(shù)處理方向不同：

eg：

Intel 匯編語法：

instr dest,source

mov eax,[ecx]

AT&T 匯編語法：

instr?? source,dest

movl (%ecx),%eax

3。內存變量語法差異：

Intel語法使用中括號[]，后者使用小括號()

eg：

Intex Syntax

mov eax,[ebx]

mov eax,[ebx+3]

AT&T Syntax

movl (%ebx),%eax

movl 3(%ebx),%eax

4。后綴：

AT&T匯編指令有后綴，以表明數(shù)據(jù)類型(8位、16位等)；Intel則根據(jù)寄存器自動識別。

eg：

Intel Syntax

mov al,bl

mov ax,bx

mov eax,ebx

mov eax, dword ptr [ebx]

AT&T Syntax

movb %bl,%al

movw %bx,%ax

movl %ebx,%eax

movl (%ebx),%eax

5。

Intel：segreg:[base+index*scale+disp]

AT&T： %segreg:disp(base,index,scale).

例子：

1 #include

2

3 int main(void) {

4????? long eax=4;

5????? long ebx=2;

6

7????? __asm__ __volatile__ ("addl %1, %0"

8????????????? : "=b"((long)ebx)

9????????????? : "a"((long)eax), "b"((long)ebx)

10????????????? : "1"

11????????????? );

12

13????? printf("ebx=%d\n", ebx);

14????? return 0;

15 }

輸出結果：ebx=6

linux下c語言內嵌匯編格式：

__asm__("" : output : input : modify);

output, input, modify都是引號括起來的字符串，他們直接用冒號分隔。

每個都可以有多項，項之間用逗號分隔，最多總共不能超過10個。

output要用“=”開頭

寄存器縮寫約定

Abbrev Register

a?? %eax/%ax/%al

b?? %ebx/%bx/%bl

c?? %ecx/%cx/%cl

d?? %edx/%dx/%dl

S?? %esi/%si

D?? %edi/%di

m?? memory

q 由編譯器在a、b、c、d中任意選擇

寄存器還可以使用數(shù)字形式的縮寫，0～9 (%0-%9)，所以會有最多10個項的限制。

系統(tǒng)調用：

1。系統(tǒng)調用號存在eax中

2。系統(tǒng)調用參數(shù)要少于6個，分別存放在ebx, ecx, edx, esi, edi

3。返回值存在eax中

4。參數(shù)超過5個，用ebx指向存放參數(shù)的內存。如果壓入堆棧，要注意參數(shù)順序反過來。

匯編文件入口：

如果使用gcc編譯，入口為main；如果用as和ld編譯連接，入口使用_start，可以用ld的-e選項指定程序入口：ld -e main -o hello hello.o。

匯編程序運行時出現(xiàn)segmentation fault：

程序運行完時，處理器試圖去執(zhí)行下一個內存單元的指令，內存中沒有指令或者為非法指令，硬件或者os包含機制就會發(fā)現(xiàn)

這個異常而產生段包含錯誤。解決方法，加上退出程序的系統(tǒng)調用就可以了。

eg：

1 #.include "defines.h"

2 .data

3 hello:

4 .string "hello world\n"

5

6 .globl?? main

7 main:

8 #write

9 movl???? $4,%eax

10 #stdout

11 movl???? $1,%ebx

12 #content

13 movl???? $hello,%ecx

14 #length of string

15 movl???? $12,%edx

16 #system call

17 int????? $0x80

18

19 #exit

20 movl???? $1,%eax

21 int????? $0x80

22

23 ret

//------------------------------------------------------------------------------------------------------------------------

//? 詳細說明：

//------------------------------------------------------------------------------------------------------------------------

1.內嵌匯編舉例

在內嵌匯編中，可以將C語言表達式指定為匯編指令的操作數(shù)，而且不用去管如何將C語言表達式的值讀入哪個寄存器，以及如何將計算結果寫回C變量，你只要告訴程序中C語言表達式與匯編指令操作數(shù)之間的對應關系即可， GCC會自動插入代碼完成必要的操作。使用內嵌匯編，要先編寫匯編指令模板，然后將C語言表達式與指令的操作數(shù)相關聯(lián)，并告訴GCC對這些操作有哪些限制條件。例如在下面的匯編語句：

__asm__ __violate__(

"movl %1,%0"

: "=r" (result)

: "m" (input)

);

其中“movl %1,%0”是指令模板；“%0”和“%1”代表指令的操作數(shù)，稱為占位符，內嵌匯編靠它們將C語言表達式與指令操作數(shù)相對應。指令模板后面用小括號括起來的是C語言表達式也即我們通常所說的變量，本例中只有兩個：“result”和“input”，他們按照出現(xiàn)的順序分別與指令操作數(shù)“%0”，“%1，”對應；注意對應順序：第一個C表達式對應“%0”；第二個表達式對應“%1”，依次類推，操作數(shù)至多有10個，分別用“%0”，“%1”….“%9，”表示。在每個操作數(shù)前面有一個用引號括起來的字符串，字符串的內容是對該操作數(shù)的限制或者說要求。“result”前面的限制字符串是“=r”，其中“=”表示“result”是輸出操作數(shù)，“r”表示需要將“result”與某個通用寄存器相關聯(lián)，先將操作數(shù)的值讀入寄存器，然后在指令中使用相應寄存器，而不是“result”本身，當然指令執(zhí)行完后需要將寄存器中的值存入變量“result”，從表面上看好像是指令直接對“result”進行操作，實際上GCC做了隱式處理，這樣我們可以少寫一些指令。“input”前面的“r”表示該表達式需要先放入某個寄存器，然后在指令中使用該寄存器參加運算。

我們將上面的內嵌代碼放到一個C源文件中，然后使用gcc –c–S得到該C文件源代碼相對應的匯編代碼，然后查看一下匯編代碼，看看GCC是如何處理的。

C源文件如下內容如下，注意該代碼沒有實際意義，僅僅作為例子。

extern int

input,result;

void test(void)

{

input= 1;

__asm__ __volatile__ ("movl %1,%0" :

"=r" (result) : "r" (input));

return;

}

對應的匯編代碼如下;

行號????????? 代碼???????????????? 解釋

1

7

8?????????????? movl $1, input???? 對應C語言語句input = 1;

9?????????????? movl input, %eax

10 #APP GCC插入的注釋，表示內嵌匯編開始

11???????????? movl %eax,%eax?????? 我們的內嵌匯編語句

12 #NO_APP GCC 插入的注釋，表示內嵌匯編結束

13???????????? movl %eax, result????? 將結果存入result變量

從匯編代碼可以看出，第9行和第13行是GCC，自動增加的代碼，GCC根據(jù)限定字符串決定如何處理C表達式，本例兩個表達式都被指定為“r”型，所以先使用指令：

movl input, %eax

將input讀入寄存器%eax；GCC，也指定一個寄存器與輸出變量result相關，本例也是%eax，等得到操作結果后再使用指令：

movl %eax, result

將寄存器的值寫回C變量result中。

從上面的匯編代碼我們可以看出與result和input，相關連的寄存器都是%eax，GCC使用%eax，替換內嵌匯編指令模板中的%0，%1 。movl %eax,%eax顯然這一句可以不要。但是沒有優(yōu)化，所以這一句沒有被去掉。

由此可見，C表達式或者變量與寄存器的關系由GCC自動處理，我們只需使用限制字符串指導GCC如何處理即可。限制字符必須與指令對操作數(shù)的要求相匹配，否則產生的匯編代碼將會有錯，讀者可以將上例中的兩個“r”，都改為“m”(m，表示操作數(shù)放在內存，而不是寄存器中)，編譯后得到的結果是：movl input, result? 很明顯這是一條非法指令，因此限制字符串必須與指令對操作數(shù)的要求匹配。例如指令movl允許寄存器到寄存器，立即數(shù)到寄存器等，但是不允許內存到內存的操作，因此兩個操作數(shù)不能同時使用“m”作為限定字符。

2 語法

內嵌匯編語法如下：

__asm__(

匯編語句模板:

輸出部分:

輸入部分:

破壞描述部分)

共四個部分：匯編語句模板，輸出部分，輸入部分，破壞描述部分，各部分使用“:”格開，匯編語句模板必不可少，其他三部分可選，如果使用了后面的部分，而前面部分為空，也需要用“:”格開，相應部分內容為空。例如：

__asm__ __volatile__(

"CLI":

:"memory")

2.1 匯編語句模板

匯編語句模板由匯編語句序列組成，語句之間使用“;”、“\n”或“\n\t”分開。指令中的操作數(shù)可以使用占位符引用C語言變量，操作數(shù)占位符最多10個，名稱如下：%0，%1…，%9。指令中使用占位符表示的操作數(shù)，總被視為long型(4，個字節(jié))，但對其施加的操作根據(jù)指令可以是字或者字節(jié)，當把操作數(shù)當作字或者字節(jié)使用時，默認為低字或者低字節(jié)。對字節(jié)操作可以顯式的指明是低字節(jié)還是次字節(jié)。方法是在%和序號之間插入一個字母，“b”代表低字節(jié)，“h”代表高字節(jié)，例如：%h1。

2.2 輸出部分

輸出部分描述輸出操作數(shù)，不同的操作數(shù)描述符之間用逗號格開，每個操作數(shù)描述符由限定字符串和C語言變量組成。每個輸出操作數(shù)的限定字符串必須包含“=”表示他是一個輸出操作數(shù)。

例：

__asm__ __volatile__(

"pushfl ;

popl %0 ;

cli"

:"=g" (x)

)

描述符字符串表示對該變量的限制條件，這樣GCC就可以根據(jù)這些條件決定如何分配寄存器，如何產生必要的代碼處理指令操作數(shù)與C表達式或C變量之間的聯(lián)系。

2.3 輸入部分

輸入部分描述輸入操作數(shù)，不同的操作數(shù)描述符之間使用逗號格開，每個操作數(shù)描述符由限定字符串和C語言表達式或者C語言變量組成。

例1：

__asm__ __volatile__ (

"lidt %0"

:

: "m" (real_mode_idt)

);

例二(bitops.h)：

Static __inline__ void __set_bit(int nr, volatile void * addr)

{

__asm__(

"btsl%1,%0" :

"=m"(ADDR) :

"Ir"(nr));

}

后例功能是將(*addr)的第nr位設為1。第一個占位符%0與C語言變量ADDR對應，第二個占位符%1與C語言變量nr對應。因此上面的匯編語句代碼與下面的偽代碼等價：

btsl nr, ADDR，

該指令的兩個操作數(shù)不能全是內存變量，因此將nr的限定字符串指定為“Ir”，將nr，與立即數(shù)或者寄存器相關聯(lián)，這樣兩個操作數(shù)中只有ADDR為內存變量。

2.4 限制字符

2.4.1 限制字符列表

限制字符有很多種，有些是與特定體系結構相關，此處僅列出常用的限定字符和i386中可能用到的一些常用的限定符。它們的作用是指示編譯器如何處理其后的C語言變量與指令操作數(shù)之間的關系，例如是將變量放在寄存器中還是放在內存中等，下表列出了常用的限定字母。

分類 限定符 描述 通用寄存器

“a”將輸入變量放入eax

這里有一個問題：假設eax已經被使用，那怎么辦？

其實很簡單：因為GCC知道eax已經被使用，它在這段匯編代碼的起始處插入一條語句pushl %eax，將eax內容保存到堆棧，然后在這段代碼結束處再增加一條語句popl %eax，恢復eax的內容

“b”將輸入變量放入ebx

“c”將輸入變量放入ecx

“d”將輸入變量放入edx

“s”將輸入變量放入esi

“d”將輸入變量放入edi

“q”將輸入變量放入eax，ebx ,ecx ，edx中的一個

“r”將輸入變量放入通用寄存器，也就是eax ，ebx，ecx,edx，esi，edi中的一個

“A”把eax和edx，合成一個64位的寄存器(uselong longs)

“m”內存變量

“o”操作數(shù)為內存變量，但是其尋址方式是偏移量類型，也即是基址尋址，或者是基址加變址尋址

“V”操作數(shù)為內存變量，但尋址方式不是偏移量類型

“,” 操作數(shù)為內存變量，但尋址方式為自動增量

“p”操作數(shù)是一個合法的內存地址(指針)

寄存器或內存

“g” 將輸入變量放入eax，ebx，ecx ，edx中的一個或者作為內存變量

“X”操作數(shù)可以是任何類型

立即數(shù)

“I” 0-31 之間的立即數(shù)(用于32位移位指令)

“J” 0-63 之間的立即數(shù)(用于64 位移位指令)

“N” 0-255 ，之間的立即數(shù)(用于out 指令)

“i” 立即數(shù)

“n” 立即數(shù)，有些系統(tǒng)不支持除字以外的立即數(shù)，這些系統(tǒng)應該使用“n”而不是“i”

匹配

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

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

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

操作數(shù)類型

“=” 操作數(shù)在指令中是只寫的(輸出操作數(shù))

“+” 操作數(shù)在指令中是讀寫類型的(輸入輸出操作數(shù))

浮點數(shù)

“f”浮點寄存器“t”第一個浮點寄存器“u”第二個浮點寄存器“G”標準的80387浮點常數(shù)% 該操作數(shù)可以和下一個操作數(shù)交換位置例如addl的兩個操作數(shù)可以交換順序(當然兩個操作數(shù)都不能是立即數(shù))# 部分注釋，從該字符到其后的逗號之間所有字母被忽略* 表示如果選用寄存器，則其后的字母被忽略現(xiàn)在繼續(xù)看上面的例子，"=m" (ADDR)表示ADDR為內存變量(“m”)，而且是輸出變量(“=”)；"Ir" (nr)表示nr，為0－31之間的立即數(shù)(“I”)或者一個寄存器操作數(shù)(“r”)。

2.4.2 匹配限制符

I386

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

例如使用“0”作為%1，的限制字符，那么%0和％1表示同一個C，變量。看一下下面的代碼就知道為什么要將讀寫型操作數(shù)，分別在輸入和輸出部分加以描述。該例功能是求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，在執(zhí)行addl之前%edx，的內容已經是input的值。可見對于使用“r”限制的輸入型變量或者表達式，在使用之前GCC會插入必要的代碼將他們的值讀到寄存器；“m”型變量則不需要這一步。讀入input后執(zhí)行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那樣一個操作數(shù)既做輸入又做輸出，例如add r0,r1,r2，r0，和r1是輸入，r2是輸出，輸入和輸出分開，沒有使用輸入輸出型操作數(shù)，這樣我們就可以認為r2對應的操作數(shù)原來的值沒有用處，也就沒有必要先將操作數(shù)的值讀入r2，因為這是浪費處理器的CPU周期)，最后GCC插入代碼，將寄存器的值寫回變量；

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

因為第二條，上面的內嵌匯編指令不能奏效，因此需要在執(zhí)行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表達式或變量相關聯(lián)(這樣易于產生與內嵌匯編相應的匯編代碼)，因此%0和%1使用的寄存器可能不同。我們看一下匯編代碼就知道了。

movl $0,_result

movl $1,_input

movl _result,%edx /APP

addl _input,%eax /NO_APP

movl %eax,%edx

movl %edx,_result

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

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

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

至此讀者應該明白了匹配限制符的意義和用法。在新版本的GCC中增加了一個限制字符“+”，它表示操作數(shù)是讀寫型的，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.4.3 “&”限制符

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

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

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

我們知道函數(shù)的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) );

總結

以上是生活随笔為你收集整理的Linux 应用程序 嵌汇编,Linux下C语言嵌汇编的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。