Linux 組合語言開發指南

Linux 組合語言開發指南

　　組合語言的優點是速度快，可以直接對硬體進行操作，這對諸如圖形處理等關鍵應用是非常重要的。Linux 是一個用 C 語言開發的作業系統，這使得很多程式設計師開始忘記在 Linux 中還可以直接使用匯編這一底層語言來優化程式的效能。本文為那些在Linux 平臺上編寫彙編程式碼的程式設計師提供指南，介紹 Linux 組合語言的語法格式和開發工具，並輔以具體的例子講述如何開發實用的Linux 彙編程式。

　　一、簡介

　　作為最基本的程式語言之一，組合語言雖然應用的範圍不算很廣，但重要性卻勿庸置疑，因為它能夠完成許多其它語言所無法完成的功能。就拿 Linux 核心來講，雖然絕大部分程式碼是用 C 語言編寫的，但仍然不可避免地在某些關鍵地方使用了彙編程式碼，其中主要是在 Linux 的啟動部分。由於這部分程式碼與硬體的關係非常密切，即使是 C 語言也會有些力不從心，而組合語言則能夠很好揚長避短，最大限度地發揮硬體的效能。

　　大多數情況下 Linux 程式設計師不需要使用匯編語言，因為即便是硬體驅動這樣的底層程式在 Linux 作業系統中也可以用完全用 C 語言來實現，再加上 GCC 這一優秀的編譯器目前已經能夠對最終生成的程式碼進行很好的優化，的確有足夠的理由讓我們可以暫時將組合語言拋在一邊了。但實現情況是 Linux 程式設計師有時還是需要使用匯編，或者不得不使用匯編，理由很簡單：精簡、高效和 libc 無關性。假設要移植 Linux 到某一特定的嵌入式硬體環境下，首先必然面臨如何減少系統大小、提高執行效率等問題，此時或許只有組合語言能幫上忙了。

　　組合語言直接同計算機的底層軟體甚至硬體進行互動，它具有如下一些優點：

　　能夠直接訪問與硬體相關的儲存器或 I/O 埠；

　　能夠不受編譯器的限制，對生成的二進位制程式碼進行完全的控制；

　　能夠對關鍵程式碼進行更準確的控制，避免因執行緒共同訪問或者硬體裝置共享引起的死鎖；

　　能夠根據特定的應用對程式碼做最佳的優化，提高執行速度；

　　能夠最大限度地發揮硬體的功能。

　　同時還應該認識到，組合語言是一種層次非常低的語言，它僅僅高於直接手工編寫二進位制的機器指令碼，因此不可避免地存在一些缺點：

　　編寫的程式碼非常難懂，不好維護；

　　很容易產生 bug，難於除錯；

　　只能針對特定的體系結構和處理器進行優化；

　　開發效率很低，時間長且單調。

　　Linux 下用匯編語言編寫的程式碼具有兩種不同的形式。第一種是完全的彙編程式碼，指的是整個程式全部用匯編語言編寫。儘管是完全的彙編程式碼，Linux 平臺下的彙編工具也吸收了 C 語言的長處，使得程式設計師可以使用 #include、#ifdef 等預處理指令，並能夠通過巨集定義來簡化程式碼。第二種是內嵌的彙編程式碼，指的是可以嵌入到C語言程式中的彙編程式碼片段。雖然 ANSI 的 C 語言標準中沒有關於內嵌彙編程式碼的相應規定，但各種實際使用的 C 編譯器都做了這方面的擴充，這其中當然就包括 Linux 平臺下的 GCC。

　　二、Linux 彙編語法格式

　　絕大多數 Linux 程式設計師以前只接觸過DOS/Windows 下的組合語言，這些彙編程式碼都是 Intel 風格的。但在 Unix 和 Linux 系統中，更多采用的還是 AT&T 格式，兩者在語法格式上有著很大的不同：

　　在 AT&T 彙編格式中，暫存器名要加上 '%' 作為字首；而在 Intel 彙編格式中，暫存器名不需要加字首。例如：

　　AT&T 格式 Intel 格式

　　pushl %eax push eax

　　在 AT&T 彙編格式中，用 '$' 字首表示一個立即運算元；而在 Intel 彙編格式中，立即數的表示不用帶任何字首。例如：

　　AT&T 格式 Intel 格式

　　pushl $1 push 1

　　AT&T 和 Intel 格式中的源運算元和目標運算元的位置正好相反。在 Intel 彙編格式中，目標運算元在源運算元的左邊；而在 AT&T 彙編格式中，目標運算元在源運算元的右邊。例如：

　　AT&T 格式 Intel 格式

　　addl $1, %eax add eax, 1

　　在 AT&T 彙編格式中，運算元的字長由操作符的最後一個字母決定，字尾'b'、'w'、'l'分別表示運算元為位元組（byte，8 位元）、字（word，16 位元）和長字（long，32位元）；而在 Intel 彙編格式中，運算元的字長是用 "byte ptr" 和 "word ptr" 等字首來表示的。例如：

　　AT&T 格式 Intel 格式

　　movb val, %al mov al, byte ptr val

　　在 AT&T 彙編格式中，絕對轉移和呼叫指令（jump/call）的運算元前要加上'*'作為字首，而在 Intel 格式中則不需要。

　　遠端轉移指令和遠端子呼叫指令的操作碼，在 AT&T 彙編格式中為 "ljump" 和 "lcall"，而在 Intel 彙編格式中則為 "jmp far" 和 "call far"，即：

　　AT&T 格式 Intel 格式

　　ljump $section, $offset jmp far section:offset

　　lcall $section, $offset call far section:offset

　　與之相應的遠端返回指令則為：

　　AT&T 格式 Intel 格式

　　lret $stack_adjust ret far stack_adjust

　　在 AT&T 彙編格式中，記憶體運算元的定址方式是

　　

section:disp(base, index, scale)



　　而在 Intel 彙編格式中，記憶體運算元的定址方式為：

　　

section:[base + index*scale + disp]



　　由於 Linux 工作在保護模式下，用的是 32 位線性地址，所以在計算地址時不用考慮段基址和偏移量，而是採用如下的地址計算方法：

　　

disp + base + index * scale



　　下面是一些記憶體運算元的例子：

　　AT&T 格式 Intel 格式

　　movl -4(%ebp), %eax mov eax, [ebp - 4]

　　movl array(, %eax, 4), %eax mov eax, [eax*4 + array]

　　movw array(%ebx, %eax, 4), %cx mov cx, [ebx + 4*eax + array]

　　movb $4, %fs:(%eax) mov fs:eax, 4

　　三、Hello World!

　　真不知道打破這個傳統會帶來什麼樣的後果，但既然所有程式設計語言的第一個例子都是在螢幕上列印一個字串 "Hello World!"，那我們也以這種方式來開始介紹 Linux 下的組合語言程式設計。

　　在 Linux 作業系統中，你有很多辦法可以實現在螢幕上顯示一個字串，但最簡潔的方式是使用 Linux 核心提供的系統呼叫。使用這種方法最大的好處是可以直接和作業系統的核心進行通訊，不需要連結諸如 libc 這樣的函式庫，也不需要使用 ELF 直譯器，因而程式碼尺寸小且執行速度快。

　　Linux 是一個執行在保護模式下的 32 位作業系統，採用 flat memory 模式，目前最常用到的是 ELF 格式的二進位制程式碼。一個 ELF 格式的可執行程式通常劃分為如下幾個部分：.text、.data 和 .bss，其中 .text 是隻讀的程式碼區，.data 是可讀可寫的資料區，而 .bss 則是可讀可寫且沒有初始化的資料區。程式碼區和資料區在 ELF 中統稱為 section，根據實際需要你可以使用其它標準的 section，也可以新增自定義 section，但一個 ELF 可執行程式至少應該有一個 .text 部分。下面給出我們的第一個彙編程式，用的是 AT&T 組合語言格式：

　　例1. AT&T 格式

　　

#hello.s

.data # 資料段宣告

msg : .string "Hello, world!//n" # 要輸出的字串

len = . - msg # 字串長度

.text # 程式碼段宣告

.global _start # 指定入口函式



_start: # 在螢幕上顯示一個字串

movl $len, %edx # 引數三：字串長度

movl $msg, %ecx # 引數二：要顯示的字串

movl $1, %ebx # 引數一：檔案描述符(stdout)

movl $4, %eax # 系統呼叫號(sys_write)

int $0x80 # 呼叫核心功能



# 退出程式

movl $0,%ebx # 引數一：退出程式碼

movl $1,%eax # 系統呼叫號(sys_exit)

int $0x80 # 呼叫核心功能



　　初次接觸到 AT&T 格式的彙編程式碼時，很多程式設計師都認為太晦澀難懂了，沒有關係，在 Linux 平臺上你同樣可以使用 Intel 格式來編寫彙編程式：

　　例2. Intel 格式

　　

;hello.asm

section .data ;資料段宣告

msg db "Hello, world!", 0xA ;要輸出的字串

len equ $ - msg ;字串長度

section .text ;程式碼段宣告

global _start ;指定入口函式

_start: ;在螢幕上顯示一個字串

mov edx, len ;引數三：字串長度

mov ecx, msg ;引數二：要顯示的字串

mov ebx, 1 ;引數一：檔案描述符(stdout)

mov eax, 4 ;系統呼叫號(sys_write)

int 0x80 ;呼叫核心功能

;退出程式

mov ebx, 0 ;引數一：退出程式碼

mov eax, 1 ;系統呼叫號(sys_exit)

int 0x80 ;呼叫核心功能



　　上面兩個彙編程式採用的語法雖然完全不同，但功能卻都是呼叫 Linux 核心提供的 sys_write 來顯示一個字串，然後再呼叫 sys_exit 退出程式。在 Linux 核心原始檔 include/asm-i386/unistd.h 中，可以找到所有系統呼叫的定義。

　　四、Linux 彙編工具

　　Linux 平臺下的彙編工具雖然種類很多，但同 DOS/Windows 一樣，最基本的仍然是彙編器、聯結器和偵錯程式。

　　1.彙編器

　　彙編器（assembler）的作用是將用匯編語言編寫的源程式轉換成二進位制形式的目的碼。Linux 平臺的標準彙編器是 GAS，它是 GCC 所依賴的後臺彙編工具，通常包含在 binutils 軟體包中。GAS 使用標準的 AT&T 彙編語法，可以用來彙編用 AT&T 格式編寫的程式：

　　

[xiaowp@gary code]$ as -o hello.o hello.s



　　Linux 平臺上另一個經常用到的彙編器是 NASM，它提供了很好的巨集指令功能，並能夠支援相當多的目的碼格式，包括 bin、a.out、coff、elf、rdf 等。NASM 採用的是人工編寫的語法分析器，因而執行速度要比 GAS 快很多，更重要的是它使用的是 Intel 彙編語法，可以用來編譯用 Intel 語法格式編寫的彙編程式：

　　

[xiaowp@gary code]$ nasm -f elf hello.asm



　　2.連結器

　　由彙編器產生的目的碼是不能直接在計算機上執行的，它必須經過連結器的處理才能生成可執行程式碼。連結器通常用來將多個目的碼連線成一個可執行程式碼，這樣可以先將整個程式分成幾個模組來單獨開發，然後才將它們組合(連結)成一個應用程式。 Linux 使用 ld 作為標準的連結程式，它同樣也包含在 binutils 軟體包中。彙編程式在成功通過 GAS 或 NASM 的編譯並生成目的碼後，就可以使用 ld 將其連結成可執行程式了：

　　

[xiaowp@gary code]$ ld -s -o hello hello.o



　　3.偵錯程式

　　有人說程式不是編出來而是調出來的，足見除錯在軟體開發中的重要作用，在用匯編語言編寫程式時尤其如此。Linux 下除錯彙編程式碼既可以用 GDB、DDD 這類通用的偵錯程式，也可以使用專門用來除錯彙編程式碼的 ALD(Assembly Language Debugger)。

　　從除錯的角度來看，使用 GAS 的好處是可以在生成的目的碼中包含符號表(symbol table)，這樣就可以使用 GDB 和 DDD 來進行原始碼級的除錯了。要在生成的可執行程式中包含符號表，可以採用下面的方式進行編譯和連結：

　　

[xiaowp@gary code]$ as --gstabs -o hello.o hello.s

[xiaowp@gary code]$ ld -o hello hello.o



　　執行 as 命令時帶上引數 --gstabs 可以告訴彙編器在生成的目的碼中加上符號表，同時需要注意的是，在用 ld 命令進行連結時不要加上 -s 引數，否則目的碼中的符號表在連結時將被刪去。

　　在 GDB 和 DDD 中除錯彙編程式碼和除錯 C 語言程式碼是一樣的，你可以通過設定斷點來中斷程式的執行，檢視變數和暫存器的當前值，並可以對程式碼進行單步跟蹤。圖1 是在 DDD 中除錯彙編程式碼時的情景：

　　

　　

　　圖1 用 DDD 中除錯彙編程式

　　彙編程式設計師通常面對的都是一些比較苛刻的軟硬體環境，短小精悍的ALD可能更能符合實際的需要，因此下面主要介紹一下如何用ALD來除錯彙編程式。首先在命令列方式下執行ald命令來啟動偵錯程式，該命令的引數是將要被除錯的可執行程式：

　　

[xiaowp@gary doc]$ ald hello

Assembly Language Debugger 0.1.3

Copyright (C) 2000-2002 Patrick Alken

hello: ELF Intel 80386 (32 bit), LSB, Executable, Version 1 (current)

Loading debugging symbols...(15 symbols loaded)

ald>



　　當 ALD 的提示符出現之後，用 disassemble 命令對程式碼段進行反彙編：

　　

ald> disassemble -s .text

Disassembling section .text (0x08048074 - 0x08048096)

08048074 BA0F000000 mov edx, 0xf

08048079 B998900408 mov ecx, 0x8049098

0804807E BB01000000 mov ebx, 0x1

08048083 B804000000 mov eax, 0x4

08048088 CD80 int 0x80

0804808A BB00000000 mov ebx, 0x0

0804808F B801000000 mov eax, 0x1

08048094 CD80 int 0x80



　　上述輸出資訊的第一列是指令對應的地址碼，利用它可以設定在程式執行時的斷點：

　　

ald> break 0x08048088

Breakpoint 1 set for 0x08048088



　　斷點設定好後，使用 run 命令開始執行程式。ALD 在遇到斷點時將自動暫停程式的執行，同時會顯示所有暫存器的當前值：

　　

ald> run

Starting program: hello

Breakpoint 1 encountered at 0x08048088

eax = 0x00000004 ebx = 0x00000001 ecx = 0x08049098 edx = 0x0000000F

esp = 0xBFFFF6C0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000

ds = 0x0000002B es = 0x0000002B fs = 0x00000000 gs = 0x00000000

ss = 0x0000002B cs = 0x00000023 eip = 0x08048088 eflags = 0x00000246

Flags: PF ZF IF

08048088 CD80 int 0x80



　　如果需要對彙編程式碼進行單步除錯，可以使用 next 命令：

　　

ald> next

Hello, world!

eax = 0x0000000F ebx = 0x00000000 ecx = 0x08049098 edx = 0x0000000F

esp = 0xBFFFF6C0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000

ds = 0x0000002B es = 0x0000002B fs = 0x00000000 gs = 0x00000000

ss = 0x0000002B cs = 0x00000023 eip = 0x0804808F eflags = 0x00000346

Flags: PF ZF TF IF

0804808F B801000000 mov eax, 0x1



　　若想獲得 ALD 支援的所有除錯命令的詳細列表，可以使用 help 命令：

　　

ald> help

Commands may be abbreviated.

If a blank command is entered, the last command is repeated.

Type `help ' for more specific information on .

General commands

attach clear continue detach disassemble

enter examine file help load

next quit register run set

step unload window write

Breakpoint related commands

break delete disable enable ignore

lbreak tbreak



　　五、系統呼叫

　　即便是最簡單的彙編程式，也難免要用到諸如輸入、輸出以及退出等操作，而要進行這些操作則需要呼叫作業系統所提供的服務，也就是系統呼叫。除非你的程式只完成加減乘除等數學運算，否則將很難避免使用系統呼叫，事實上除了系統呼叫不同之外，各種作業系統的彙編程式設計往往都是很類似的。

　　在 Linux 平臺下有兩種方式來使用系統呼叫：利用封裝後的 C 庫（libc）或者通過彙編直接呼叫。其中通過組合語言來直接呼叫系統呼叫，是最高效地使用 Linux 核心服務的方法，因為最終生成的程式不需要與任何庫進行連結，而是直接和核心通訊。

　　和 DOS 一樣，Linux 下的系統呼叫也是通過中斷（int 0x80）來實現的。在執行 int 80 指令時，暫存器 eax 中存放的是系統呼叫的功能號，而傳給系統呼叫的引數則必須按順序放到暫存器 ebx，ecx，edx，esi，edi 中，當系統呼叫完成之後，返回值可以在暫存器 eax 中獲得。

　　所有的系統呼叫功能號都可以在檔案 /usr/include/bits/syscall.h 中找到，為了便於使用，它們是用 SYS_ 這樣的巨集來定義的，如 SYS_write、SYS_exit 等。例如，經常用到的 write 函式是如下定義的：

　　

ssize_t write(int fd, const void *buf, size_t count);



　　該函式的功能最終是通過 SYS_write 這一系統呼叫來實現的。根據上面的約定，引數 fb、buf 和 count 分別存在暫存器 ebx、ecx 和 edx 中，而系統呼叫號 SYS_write 則放在暫存器 eax 中，當 int 0x80 指令執行完畢後，返回值可以從暫存器 eax 中獲得。

　　或許你已經發現，在進行系統呼叫時至多隻有 5 個暫存器能夠用來儲存引數，難道所有系統呼叫的引數個數都不超過 5 嗎？當然不是，例如 mmap 函式就有 6 個引數，這些引數最後都需要傳遞給系統呼叫 SYS_mmap：

　　

void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);



　　當一個系統呼叫所需的引數個數大於 5 時，執行int 0x80 指令時仍需將系統呼叫功能號儲存在暫存器 eax 中，所不同的只是全部引數應該依次放在一塊連續的記憶體區域裡，同時在暫存器 ebx 中儲存指向該記憶體區域的指標。系統呼叫完成之後，返回值仍將儲存在暫存器 eax 中。

　　由於只是需要一塊連續的記憶體區域來儲存系統呼叫的引數，因此完全可以像普通的函式呼叫一樣使用棧(stack)來傳遞系統呼叫所需的引數。但要注意一點，Linux 採用的是 C 語言的呼叫模式，這就意味著所有引數必須以相反的順序進棧，即最後一個引數先入棧，而第一個引數則最後入棧。如果採用棧來傳遞系統呼叫所需的引數，在執行int 0x80 指令時還應該將棧指標的當前值複製到暫存器 ebx中。

　　六、命令列引數

　　在 Linux 作業系統中，當一個可執行程式通過命令列啟動時，其所需的引數將被儲存到棧中：首先是 argc，然後是指向各個命令列引數的指標陣列 argv，最後是指向環境變數的指標資料 envp。在編寫組合語言程式時，很多時候需要對這些引數進行處理，下面的程式碼示範瞭如何在彙編程式碼中進行命令列引數的處理：

　　例3. 處理命令列引數

　　

# args.s

.text

.globl _start



_start:

popl %ecx # argc

vnext:

popl %ecx # argv

test %ecx, %ecx # 空指標表明結束

jz exit

movl %ecx, %ebx

xorl %edx, %edx

strlen:

movb (%ebx), %al

inc %edx

inc %ebx

test %al, %al

jnz strlen

movb $10, -1(%ebx)

movl $4, %eax # 系統呼叫號(sys_write)

movl $1, %ebx # 檔案描述符(stdout)

int $0x80

jmp vnext

exit:

movl $1,%eax # 系統呼叫號(sys_exit)

xorl %ebx, %ebx # 退出程式碼

int $0x80



ret



　　七、GCC 內聯彙編

　　用匯編編寫的程式雖然執行速度快，但開發速度非常慢，效率也很低。如果只是想對關鍵程式碼段進行優化，或許更好的辦法是將彙編指令嵌入到 C 語言程式中，從而充分利用高階語言和組合語言各自的特點。但一般來講，在 C 程式碼中嵌入彙編語句要比"純粹"的組合語言程式碼複雜得多，因為需要解決如何分配暫存器，以及如何與C程式碼中的變數相結合等問題。

　　GCC 提供了很好的內聯彙編支援，最基本的格式是：

　　

__asm__("asm statements");



　　例如：

　　

__asm__("nop");



　　如果需要同時執行多條彙編語句，則應該用"//n//t"將各個語句分隔開，例如：

　　

__asm__( "pushl %%eax //n//t"

"movl $0, %%eax //n//t"

"popl %eax");



　　通常嵌入到 C 程式碼中的彙編語句很難做到與其它部分沒有任何關係，因此更多時候需要用到完整的內聯彙編格式：

　　

__asm__("asm statements" : outputs : inputs : registers-modified);



　　插入到 C 程式碼中的彙編語句是以":"分隔的四個部分，其中第一部分就是彙編程式碼本身，通常稱為指令部，其格式和在組合語言中使用的格式基本相同。指令部分是必須的，而其它部分則可以根據實際情況而省略。

　　在將彙編語句嵌入到C程式碼中時，運算元如何與C程式碼中的變數相結合是個很大的問題。GCC採用如下方法來解決這個問題：程式設計師提供具體的指令，而對暫存器的使用則只需給出"樣板"和約束條件就可以了，具體如何將暫存器與變數結合起來完全由GCC和GAS來負責。

　　在GCC內聯彙編語句的指令部中，加上字首'%'的數字(如%0，%1)表示的就是需要使用暫存器的"樣板"運算元。指令部中使用了幾個樣板運算元，就表明有幾個變數需要與暫存器相結合，這樣GCC和GAS在編譯和彙編時會根據後面給定的約束條件進行恰當的處理。由於樣板運算元也使用'%'作為字首，因此在涉及到具體的暫存器時，暫存器名前面應該加上兩個'%'，以免產生混淆。

　　緊跟在指令部後面的是輸出部，是規定輸出變數如何與樣板運算元進行結合的條件，每個條件稱為一個"約束"，必要時可以包含多個約束，相互之間用逗號分隔開就可以了。每個輸出約束都以'='號開始，然後緊跟一個對運算元型別進行說明的字後，最後是如何與變數相結合的約束。凡是與輸出部中說明的運算元相結合的暫存器或運算元本身，在執行完嵌入的彙編程式碼後均不保留執行之前的內容，這是GCC在排程暫存器時所使用的依據。

　　輸出部後面是輸入部，輸入約束的格式和輸出約束相似，但不帶'='號。如果一個輸入約束要求使用暫存器，則GCC在預處理時就會為之分配一個暫存器，並插入必要的指令將運算元裝入該暫存器。與輸入部中說明的運算元結合的暫存器或運算元本身，在執行完嵌入的彙編程式碼後也不保留執行之前的內容。

　　有時在進行某些操作時，除了要用到進行資料輸入和輸出的暫存器外，還要使用多個暫存器來儲存中間計算結果，這樣就難免會破壞原有暫存器的內容。在GCC內聯彙編格式中的最後一個部分中，可以對將產生副作用的暫存器進行說明，以便GCC能夠採用相應的措施。

　　下面是一個內聯彙編的簡單例子：

　　例4.內聯彙編

　　

/* inline.c */

int main()

{

int a = 10, b = 0;

__asm__ __volatile__("movl %1, %%eax;//n//r"

"movl %%eax, %0;"

:"=r"(b) /* 輸出 */

:"r"(a) /* 輸入 */

:"%eax"); /* 不受影響的暫存器 */



printf("Result: %d, %d//n", a, b);

}



　　上面的程式完成將變數a的值賦予變數b，有幾點需要說明：

　　變數b是輸出運算元，通過%0來引用，而變數a是輸入運算元，通過%1來引用。

　　輸入運算元和輸出運算元都使用r進行約束，表示將變數a和變數b儲存在暫存器中。輸入約束和輸出約束的不同點在於輸出約束多一個約束脩飾符'='。

　　在內聯彙編語句中使用暫存器eax時，暫存器名前應該加兩個'%'，即%%eax。內聯彙編中使用%0、%1等來標識變數，任何只帶一個'%'的識別符號都看成是運算元，而不是暫存器。

　　內聯彙編語句的最後一個部分告訴GCC它將改變暫存器eax中的值，GCC在處理時不應使用該暫存器來儲存任何其它的值。

　　由於變數b被指定成輸出運算元，當內聯彙編語句執行完畢後，它所儲存的值將被更新。

　　在內聯彙編中用到的運算元從輸出部的第一個約束開始編號，序號從0開始，每個約束記數一次，指令部要引用這些運算元時，只需在序號前加上'%'作為字首就可以了。需要注意的是，內聯彙編語句的指令部在引用一個運算元時總是將其作為32位的長字使用，但實際情況可能需要的是字或位元組，因此應該在約束中指明正確的限定符：

　　限定符 意義

　　"m"、"v"、"o" 記憶體單元

　　"r" 任何暫存器

　　"q" 暫存器eax、ebx、ecx、edx之一

　　"i"、"h" 直接運算元

　　"E"和"F" 浮點數

　　"g" 任意

　　"a"、"b"、"c"、"d" 分別表示暫存器eax、ebx、ecx和edx

　　"S"和"D" 暫存器esi、edi

　　"I" 常數（0至31）

　　八、小結

　　Linux作業系統是用C語言編寫的，彙編只在必要的時候才被人們想到，但它卻是減少程式碼尺寸和優化程式碼效能的一種非常重要的手段，特別是在與硬體直接互動的時候，彙編可以說是最佳的選擇。Linux提供了非常優秀的工具來支援彙編程式的開發，使用GCC的內聯彙編能夠充分地發揮C語言和組合語言各自的優點。

　　參考資料

　　在網站 http://linuxassembly.org上可以找到大量的Linux彙編資源。

　　軟體包binutils提供了as和ld等實用工具，其相關資訊可以在網站 http://sources.redhat.com/binutils/上找到。

　　NASM是Intel格式的彙編器，其相關資訊可以在網站 http://nasm.sourceforge.net上找到。

　　ALD是一個短小精悍的彙編偵錯程式，其相關資訊可以在網站 http://dunx1.irt.drexel.edu/~psa22/ald.html上找到。

　　intel2gas是一個能夠將Intel彙編格式轉換成AT&T彙編格式的小工具，其相關資訊可以在網站 http://www.niksula.cs.hut.fi/~mtiihone/intel2gas/上找到。

　　IBM developerWorks上有一篇介紹GCC內聯彙編的文章( http://www.ibm.com/developerworks/cn/linux/sdk/assemble/inline/index.shtml)。

　　本文程式碼下載： 程式碼。



本文轉自

http://www.ibm.com/developerworks/cn/linux/l-assembly/index.html