Linux C 語言內聯匯編

Linux 匯編語法格式

絕大多數 Linux 程序員以前只接觸過 DOS/Windows 下的匯編語言,這些匯編代碼都是 Intel 風格（即386 匯編語言）的。但在 Unix 和 Linux 系統中,更多采用的還是 AT&T 格式,兩者在語法格式上有著很大的不同:

1. 前綴——寄存器名/立即操作數

在 Intel 匯編的語法中，寄存器和和立即數都沒有前綴。
在 AT&T 匯編格式中,寄存器名要加上'%'作為前綴;立即操作數要加上 '$'前綴；

AT&T 格式Intel 格式

movl %eax $1	mov eax 1

2. 后綴——十六進制/二進制

在 Intel 的語法中，十六進制和二進制立即數后綴分別冠以“h”和“b”，而在 AT&T 中，十六進制立即數前冠以“0x”；

AT&T 格式Intel 格式

int $0x80	int 80h

3. 源操作數和目標操作數的位置

AT&T 和 Intel 格式中的源操作數和目標操作數的位置正好相反。在 Intel 匯編格式中,目標操作數在源操作數的左邊;而在 AT&T 匯編格式中,目標操作數在源操作數的右邊。

AT&T 格式Intel 格式

addl $1, %eax	add eax, 1

4. 操作數的字長修飾符

在 AT&T 匯編格式中,操作數的字長由操作符的最后一個字母決定,后綴'b'、'w'、'l'分別表示操作數為字節(byte,8 bits)、字(word,16 bits)和長字(long,32 bits);而在 Intel 匯編格式中,操作數的字長是用 "byte ptr" 和 "word ptr"等前綴來表示的。

AT&T 格式Intel 格式

movb %bl,%al	mov al,bl
movw %bx,%ax	mov ax,bx
movl %ebx,%eax	mov eax,ebx
movl (%ebx),%eax	mov eax, dword ptr [ebx]

5. 跳轉指令

在 AT&T 匯編格式中,絕對轉移和調用指令(jump/call)的操作數前要加上'$'作為前綴,而在 Intel 格式中則不需要。 遠程轉移指令和遠程子調用指令的操作碼,在 AT&T 匯編格式中為 "ljump" 和 "lcall",而在 Intel 匯編格式中則為"jmp far" 和"call far".

AT&T 格式Intel 格式

ljump section,section,offset	jmp far section:offset
lcall section,section,offset	call far section:offset

6. 與跳轉指令相應的遠程返回指令

AT&T 格式Intel 格式

lret $stack_adjust	ret far stack_adjust

7. 內存操作數

內存操作數也有所不同。在 Intel 的語法中，基寄存器用“［］”括起來，而在 AT&T 中，用“（）”括起來。

AT&T 格式Intel 格式

movl 5(%ebx),%eax	mov eax,[ebx+5]
disp(base, index, scale)	[base + index*scale + disp]

由于 Linux 工作在保護模式下,用的是 32 位線性地址,所以在計算地址時不用考慮段基址和偏移量,而是采用如下的地址計算方法:
disp + base + index * scale

8. 間接尋址方式

與 Intel 的語法比較，AT&T 間接尋址方式可能更晦澀難懂一些。Intel 的指令格式是segreg:[base+index*scale+disp]，而 AT&T 的格式是%segreg:disp(base,index,scale)。其中index/scale/disp/segreg全部是可選的，完全可以簡化掉。如果沒有指定 scale 而指定了index，則 scale 的缺省值為 1。segreg 段寄存器依賴于指令以及應用程序是運行在實模式還是保護模式下，在實模式下，它依賴于指令，而在保護模式下，segreg 是多余的。在AT&T 中，當立即數用在 scale/disp 中時，不應當在其前冠以“$”前綴。

AT&T 格式Intel 格式

disp(base, index, scale)	[base + index*scale + disp]
mov eax,[ebx+20h]	movl0x20(%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

9. 一些內存操作數的例子

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

AT&T 匯編語言的相關知識

在 Linux 源代碼中，以.S 為擴展名的文件是“純”匯編語言的文件。這里，我們結合具體的例子再介紹一些 AT&T 匯編語言的相關知識。

1. AT&T 中的Section段

在 AT&T 的語法中，一個段由.section 關鍵詞來標識，當你編寫匯編語言程序時，至少需要有以下三種段：

.section .data： 這種段包含程序已初始化的數據，也就是說，包含具有初值的那些變量，例如：

hello : .string "Hello world!\n"hello_len : .long 13

.section .bss：這個段包含程序還未初始化的數據，也就是說，包含沒有初值的那些變量。當操作 系統裝入這個程序時將把這些變量都置為 0，例如：

name : .fill 30 # 用來請求用戶輸入名字name_len : .long 0 # 名字的長度 (尚未定義)

當這個程序被裝入時，name 和 name_len 都被置為 0。如果你在.bss 節不小心給一個變量賦了初值，這個值也會丟失，并且變量的值仍為 0。

使用.bss 比使用.data 的優勢在于，.bss 段不占用磁盤的空間。在磁盤上，一個長整數就足以存放.bss 段。當程序被裝入到內存時，操作系統也只分配給這個段 4 個字段的內存大小。

注意：編譯程序把.data 和.bss 在 4 字節上對齊（align），例如，.data 總共有 34 字節，那么編譯程序把它對其在 36 字節上，也就是說，實際給它 36 字節的空間。

.section .text ：這個段包含程序的代碼，它是只讀段，而.data 和.bss 是讀／寫節。

2．匯編程序指令（Assembler Directive）

上面介紹的.section 就是匯編程序指令的一種，GNU 匯編程序提供了很多這樣的指令（directiv），這種指令都是以句點（.）為開頭，后跟指令名（小寫字母），在此，我們只介紹在內核源代碼中出現的幾個指令（以 arch/i386/kernel/head.S 中的代碼為例）。

(1) .ascii “string”…

.ascii 表示零個或多個（用逗號隔開）字符串，并把每個字符串（結尾不自動加“0“字節）中的字符放在連續的地址單元。還有一個與.ascii 類似的.asciz，z 代表“0“，即每個字符串結尾自動加一個”\0“，例如：

int_msg:.asciz "Unknown interrupt\n"

(2) .byte 表達式

.byte 表示零或多個表達式（用逗號隔開），每個表達式被放在下一個字節單元。

(3) .fill 表達式

形式：.fill repeat , size , value
其中，repeat、size 和 value 都是常量表達式。

Fill 的含義是反復拷貝 size 個字節。
Repeat 可以大于等于 0。size 也可以大于等于 0，但不能超過 8，如果超過 8，也只取 8。把repeat 個字節以 8 個為一組，每組的最高 4 個字節內容為 0，最低 4 字節內容置為 value。 Size 和 value 為可選項。如果第二個逗號和 value 值不存在，則假定 value 為 0。如果第一個逗號和 size 不存在，則假定 size 為 1。

例如，在 Linux 初始化的過程中，對全局描述符表 GDT 進行設置的最后一句為：

.fill NR_CPUS*4, 8, 0 /* space for TSS's and LDT's */

因為每個描述符正好占 8 個字節，因此，.fill 給每個 CPU 留有存放 4 個描述符的位置。

(4) .globl symbol

.globl 使得連接程序（ld）能夠看到 symbl。如果你的局部程序中定義了 symbl，那么，與這個局部程序連接的其他局部程序也能存取 symbl，例如：

.globl SYMBOL_NAME(idt).globl SYMBOL_NAME(gdt)

定義 idt 和 gdt 為全局符號。

(5) .quad bignums

.quad 表示零個或多個 bignums（用逗號分隔），對于每個 bignum，其缺省值是 8 字節整數。如果 bignum 超過 8 字節，則打印一個警告信息；并只取 bignum 最低 8 字節。

例如，對全局描述符表的填充就用到這個指令：

.quad 0x00cf9a000000ffff /* 0x10 kernel 4GB code at 0x00000000 */ .quad 0x00cf92000000ffff /* 0x18 kernel 4GB data at 0x00000000 */ .quad 0x00cffa000000ffff /* 0x23 user 4GB code at 0x00000000 */ .quad 0x00cff2000000ffff /* 0x2b user 4GB data at 0x00000000 */

(6) .rept count

把.rept 指令與.endr 指令之間的行重復 count 次，例如

.rept 3 .long 0.endr # 相當于.long 0.long 0.long 0

(7) .space size , fill

這個指令保留 size 個字節的空間，每個字節的值為 fill。size 和 fill 都是常量表達式。
如果逗號和 fill 被省略，則假定 fill 為 0，例如在 arch/i386/bootl/setup.S 中有一句：

.space 1024

表示保留 1024 字節的空間，并且每個字節的值為 0。

(8) .word expressions

這個表達式表示任意一節中的一個或多個表達式（用逗號分開），表達式的值占兩個字節，例如：

gdt_descr:.word GDT_ENTRIES*8-1

表示變量 gdt_descr 的置為 GDT_ENTRIES*8-1

(9) .long expressions

這與.word 類似

(10) .org new-lc , fill

把當前段的位置計數器提前到 new-lc（new location counter）。new-lc 或者是一個常量表達式，或者是一個與當前子段處于同一段的表達式。也就是說，你不能用.org 橫跨段：如果 new-lc 是個錯誤的值，則.org 被忽略。.org 只能增加位置計數器的值，或者讓其保持不變；但絕不能用.org 來讓位置計數器倒退。
注意，位置計數器的起始值是相對于一個段的開始的，而不是子段的開始。當位置計數器被提升后，中間位置的字節被填充值 fill（這也是一個常量表達式）。如果逗號和fill 都省略，則 fill 的缺省值為 0。例如：

.org 0x2000ENTRY(pg0)

表示把位置計數器置為 0x2000，這個位置存放的就是臨時頁表 pg0。

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. hello word —— AT&T 格式

# hello.s# 數據段聲明 .datamsg : .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. hello word —— Intel 格式

; hello.asm ; 數據段聲明 section .data ; 要輸出的字符串msg db "Hello, world!", 0xA ; 字串長度len equ $ - msgsection .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 格式編寫的程序:

$ as -o hello.o hello.s

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

$ nasm -f elf hello.asm

2.鏈接器

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

$ ld -s -o hello hello.o

3.調試器

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

從調試的角度來看,使用 GAS 的好處是可以在生成的目標代碼中包含符號表(symbol table),這樣就可以使用 GDB 和 DDD 來進行源碼級的調試了。要在生成的可執行程序中包含符號表,可以采用下面的方式進行編譯和鏈接:

$ as --gstabs -o hello.o hello.s $ ld -o hello hello.o

執行 as 命令時帶上參數--gstabs可以告訴匯編器在生成的目標代碼中加上符號表,同時需要注意的是,在用 ld 命令進行鏈接時不要加上 -s 參數,否則目標代碼中的符號表在鏈接時將被刪去。

在 GDB 和 DDD 中調試匯編代碼和調試 C 語言代碼是一樣的,你可以通過設置斷點來中斷程序的運行,查看變量和寄存器的當前值,并可以對代碼進行單步跟蹤。

系統調用

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

在 Linux 平臺下有兩種方式來使用系統調用:利用封裝后的 C 庫(libc)或者通過匯編直接調用。其中通過匯編語言來直接調用系統調用,是最高效地使用 Linux 內核服務的方法,因為最終生成的程序不需要與任何庫進行鏈接,而是直接和內核通信。

和 DOS 一樣,Linux 下的系統調用也是通過中斷(int 0x80)來實現的。在執行 int 80 指令時,寄存器eax中存放的是系統調用的功能號,而傳給系統調用的參數則必須按順序放到寄存器 ebx,ecx,edx,esi,edi中,當系統調用完成之后,返回值可以在寄存器eax中獲得。

所有的系統調用功能號都可以在文件 /usr/include/bits/syscall.h 中找到,為了便于使用,它們是用SYS_<name>這樣的宏來定義的,如 SYS_write、SYS_exit 等。例如,經常用到的 write 函數是如下定義的:

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

該函數的功能最終是通過 SYS_write 這一系統調用來實現的。根據上面的約定,參數 fd、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。

在編寫匯編語言程序時,很多時候需要對這些參數進行處理,下面的代碼示范了如何在匯編代碼中進行命令行參數的處理:

例 1. 處理命令行參數

# args.s .text.globl _start_start:popl %ecx # argcpopl %ecx # argvtest %ecx, %ecx vnext:# 空指針表明結束jz exitmovl %ecx, %ebxxorl %edx, %edxstrlen: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 movl $1,%eax xorl %ebx, %ebx int $0x80 exit:# 系統調用號(sys_exit)# 退出代碼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 能夠采用相應的措施。 內聯匯編語句的最后一個部分告訴 GCC 它將改變該寄存器中的值,GCC 在處理時不應使用該寄存器來存儲任何其它的值。

下面是一個內聯匯編的簡單例子:

例1: 內聯匯編

#include <stdio.h>/* inline.c */ int main() {int a = 10, b = 0;__asm__ __volatile__("movl %1, %%eax; \n\t""movl %%eax, %0 \n\t;":"=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)

例2: 輸出/輸入部分

在輸入部分定義的變量，是不可以被改變的，即不能放在等號的左邊，有點const變量的意思；
而在輸出部分定義的變量，是要放在等號的左邊的；

/* inline.c */ int main() {int a = 10, b = 0, c = 12;__asm__ __volatile__("movl %1, %%eax; \n\t" /* b += c;*/"movl %2, %0; \n\t" /* b = c */"addl %2, %0; \n\t" /* b += c; */"movl %0, %2; \n\t" /* error: c = b */:"=r"(b) /* 輸出 */ :"r"(a), "r"(c)/* 輸入 */:"%eax"); /* 不受影響的寄存器 */printf("Result: %d, %d, %d\n", a, b, c); }

例3: 預留不受計算影響的寄存器

在 GCC 內聯匯編格式中的最后一個部分中,可以對將產生副作用的寄存器進行說明,以便 GCC 能夠采用相應的措施。 內聯匯編語句的最后一個部分告訴GCC用戶程序將顯式地改變該寄存器中的值,GCC 在處理時不應使用該寄存器來存儲任何其它的值。

/* inline.c */ int main() {int a = 10, b = 0, c = 12;__asm__ __volatile__("movl %1, %%eax; \n\t" /* b += c;*/"movl %2, %0; \n\t" /*b = c*/"addl %2, %0; \n\t" /* b += c;*/"addl %%eax, %0; \n\t" /* b += c;*/:"=r"(b) /* 輸出 */ :"r"(a), "r"(c)/* 輸入 */:"%eax"); /* 不受影響的寄存器 */printf("Result: %d, %d, %d\n", a, b, c); }

例4: 復雜應用

在 Linux 內核代碼中，有關字符串操作的函數都是通過嵌入式匯編完成的，因為內核及用戶程序對字符串函數的調用非常頻繁，因此，用匯編代碼實現主要是為了提高效率（當然是以犧牲可讀性和可維護性為代價的）。在此，我們僅列舉一個字符串比較函數strcmp，其代碼在 arch/i386／string.h 中。

static inline int strcmp(const char * cs,const char * ct) {int d0, d1;register int __res;__asm__ __volatile__("1:\tlodsb\n\t""scasb\n\t""jne 2f\n\t""testb %%al,%%al\n\t""jne 1b\n\t""xorl %%eax,%%eax\n\t""jmp 3f\n""2:\tsbbl %%eax,%%eax\n\t""orb $1,%%al\n""3:":"=a" (__res), "=&S" (d0), "=&D" (d1):"1" (cs),"2" (ct));return __res; }

其中的“\n”是換行符，“\t”是 tab 符，在每條命令的結束加這兩個符號，是為了讓 gcc 把嵌入式匯編代碼翻譯成一般的匯編代碼時能夠保證換行和留有一定的空格。例如，上面的嵌入式匯編會被翻譯成：

1：
lodsb //裝入串操作數,即從[esi]傳送到 al 寄存器，然后 esi 指向串中下一個元素
scasb //掃描串操作數，即從 al 中減去 es:[edi]，不保留結果，只改變標志

jne2f //如果兩個字符不相等，則轉到標號 2

testb %al %al
jne 1b

xorl %eax %eax
jmp 3f

2:
sbbl %eax %eax
orb $1 %al

3:
這段代碼看起來非常熟悉，讀起來也不困難。其中1f 表示往前（forword）找到第一個標號為 1 的那一行，相應地，1b 表示往后找。其中嵌入式匯編代碼中輸出和輸入部分的結合情況為：

• 返回值__res，放在 al 寄存器中，與%0 相結合；
• 局部變量 d0，與％1 相結合，也與輸入部分的 cs 參數相對應，也存放在寄存器ESI 中，即 ESI 中存放源字符串的起始地址。
• 局部變量 d1， 與％2 相結合，也與輸入部分的 ct 參數相對應，也存放在寄存器 EDI 中，即 EDI 中存放目的字符串的起始地址。

通過對這段代碼的分析我們應當體會到，萬變不利其本，嵌入式匯編與一般匯編的區別僅僅是形式，本質依然不變。因此，全面掌握 Intel 386 匯編指令乃突破閱讀底層代碼之根本。

小結

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

可能出現的問題

1. Error: invalid instruction suffix for `popl’

程序中有一條命令為：popl %eax
使用 as 編譯時出現錯誤：Error: invalid instruction suffix for `popl’

原因：
64 位系統和 32 位系統的差別引起的

解決方法：
在代碼開頭添加 .code32 即可

參考資料

Linux 匯編語法和簡單實例 http://blog.csdn.net/darennet/article/details/41091133
Linux 中的匯編語言 http://blog.csdn.net/hairetz/article/details/17511567

總結

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

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