AT&T的彙編格式&X86內聯彙編

AT&T的彙編格式
一　基本語法 
語法上主要有如下幾個不一樣. 
★ 寄存器命名原則 
AT&T: %eax Intel: eax 
★源/目的操做數順序 
AT&T: movl %eax,%ebx Intel: mov ebx,eax 
★常數/當即數的格式 
AT&T: movl $_value,%ebx Intel: mov eax,_value
把_value的地址放入eax寄存器 
AT&T: movl $0xd00d,%ebx Intel: mov ebx,0xd00d 
★ 操做數長度標識 
AT&T: movw %ax,%bx Intel: mov bx,ax 
★尋址方式 
AT&T: immed32(basepointer,indexpointer,indexscale)
Intel: [basepointer + indexpointer*indexscale + imm32) 
Linux工做於保護模式下，用的是３２位線性地址，因此在計算地址時不用考慮segment:offset的問題．上式中的地址應爲：
imm32 + basepointer + indexpointer*indexscale 
下面是一些例子： 
★直接尋址 
AT&T: _booga　; _booga是一個全局的C變量 
注意加上$是表示地址引用，不加是表示值引用．
注：對於局部變量，能夠經過堆棧指針引用． 
Intel: [_booga] 
★寄存器間接尋址 
AT&T: (%eax)
Intel: [eax] 
★變址尋址 
AT&T: _variable(%eax)
Intel: [eax + _variable] 
AT&T: _array(,%eax,4)
Intel: [eax*4 + _array] 
AT&T: _array(%ebx,%eax,8)
Intel: [ebx + eax*8 + _array] 
二　基本的行內彙編 
    ?基本的行內彙編很簡單，通常是按照下面的格式:
        asm("statements");
例如：asm("nop"); asm("cli"); 
    ?asm　和　__asm__是徹底同樣的． 
    ?若是有多行彙編，則每一行都要加上　"＼n＼t"
例如： 
asm( "pushl %eax＼n＼t"
"movl $0,%eax＼n＼t"
"popl %eax"); 
    實際上gcc在處理彙編時，是要把asm(...)的內容"打印"到彙編文件中，因此格式控制字符是必要的． 
再例如：
asm("movl %eax,%ebx");
asm("xorl %ebx,%edx");
asm("movl $0,_booga); 
    在上面的例子中，因爲咱們在行內彙編中改變了edx和ebx的值，可是因爲gcc的特殊的處理方法，即先造成彙編文件，再交給GAS去彙編，因此GAS並不知道咱們已經改變了edx和ebx的值，若是程序的上下文須要edx或ebx做暫存，這樣就會引發嚴重的後果．對於變量_booga也存在同樣的問題．爲了解決這個問題，就要用到擴展的行內彙編語法． 
三　擴展的行內彙編 
    擴展的行內彙編相似於Watcom. 
    基本的格式是：
asm ( "statements" : output_regs : input_regs : clobbered_regs);
clobbered_regs指的是被改變的寄存器． 
下面是一個例子(爲方便起見，我使用全局變量）： 
int count=1;
int value=1;
int buf[10];
void main()
{
asm(
"cld ＼n＼t"
"rep ＼n＼t"
"stosl"
:
: "c" (count), "a" (value) , "D" (buf[0])
: "%ecx","%edi" );
} 
獲得的主要彙編代碼爲： 
movl count,%ecx
movl value,%eax
movl buf,%edi
#APP
cld
rep
stosl
#NO_APP 
    cld,rep,stos就不用多解釋了．這幾條語句的功能是向buf中寫上count個value值．冒號後的語句指明輸入，輸出和被改變的寄存器．經過冒號之後的語句，編譯器就知道你的指令須要和改變哪些寄存器，從而能夠優化寄存器的分配．
    其中符號"c"(count)指示要把count的值放入ecx寄存器 
相似的還有： 
a eax
b ebx
c ecx
d edx
S esi
D edi
I 常數值，(0 - 31)
q,r 動態分配的寄存器
g eax,ebx,ecx,edx或內存變量
A 把eax和edx合成一個64位的寄存器(use long longs) 
咱們也可讓gcc本身選擇合適的寄存器．
以下面的例子：
asm("leal (%1,%1,4),%0"
: "=r" (x)
: "0" (x) ); 
這段代碼實現5*x的快速乘法．
獲得的主要彙編代碼爲：
movl x,%eax
#APP
leal (%eax,%eax,4),%eax
#NO_APP
movl %eax,x 
幾點說明： 
1.使用q指示編譯器從eax,ebx,ecx,edx分配寄存器．使用r指示編譯器從eax,ebx,ecx,edx,esi,edi分配寄存器． 
2.咱們沒必要把編譯器分配的寄存器放入改變的寄存器列表，由於寄存器已經記住了它們． 
3."="是標示輸出寄存器，必須這樣用． 
4.數字%n的用法： 
    數字表示的寄存器是按照出現和從左到右的順序映射到用"r"或"q"請求的寄存器．若是咱們要重用"r"或"q"請求的寄存器的話，就可使用它們． 
5.若是強制使用固定的寄存器的話，如不用%1,而用ebx,則asm("leal (%%ebx,%%ebx,4),%0" 
: "=r" (x)
: "0" (x) ); 
注意要使用兩個%,由於一個%的語法已經被%n用掉了． 
下面能夠來解釋letter 4854-4855的問題： 
一、變量加下劃線和雙下劃線有什麼特殊含義嗎？
    加下劃線是指全局變量，但個人gcc中加不加都無所謂． 
二、以上定義用以下調用時展開會是什麼意思？
#define _syscall1(type,name,type1,arg1) ＼
type name(type1 arg1) ＼
{ ＼
long __res; ＼
/* __res應該是一個全局變量　*/
__asm__ volatile ("int $0x80" ＼
/* volatile 的意思是不容許優化，使編譯器嚴格按照你的彙編代碼彙編*/
: "=a" (__res) ＼
/* 產生代碼　movl %eax, __res */
: "0" (__NR_##name),"b" ((long)(arg1))); ＼
/* 若是我沒記錯的話，這裏##指的是兩次宏展開．
　　即用實際的系統調用名字代替"name",而後再把__NR_...展開．
　　接着把展開的常數放入eax，把arg1放入ebx */
if (__res >= 0) ＼
return (type) __res; ＼
errno = -__res; ＼
return -1; ＼
} 
[目錄]
x86內聯彙編
    本文提供了在 Linux 平臺上使用和構造 x86 內聯彙編的歸納性介紹。他介紹了內聯彙編及其各類用法的基礎知識，提供了一些基本的內聯彙編編碼指導，並解釋了在 Linux 內核中內聯彙編代碼的一些實例。
    若是您是 Linux 內核的開發人員，您會發現本身常常要對與體系結構高度相關的功能進行編碼或優化代碼路徑。您極可能是經過將彙編語言指令插入到 C 語句的中間（又稱爲內聯彙編的一種方法）來執行這些任務的。讓咱們看一下 Linux 中內聯彙編的特定用法。（咱們將討論限制在 IA32 彙編。） 
[目錄]
簡述
GNU 彙編程序簡述
    讓咱們首先看一下 Linux 中使用的基本彙編程序語法。GCC（用於 Linux 的 GNU C 編譯器）使用 AT&T 彙編語法。下面列出了這種語法的一些基本規則。（該列表確定不完整；只包括了與內聯彙編相關的那些規則。） 
寄存器命名
    寄存器名稱有 % 前綴。即，若是必須使用 eax，它應該用做 %eax。 
源操做數和目的操做數的順序
    在全部指令中，先是源操做數，而後纔是目的操做數。這與將源操做數放在目的操做數以後的 Intel 語法不一樣。
    mov %eax, %ebx, transfers the contents of eax to ebx. 
操做數大小
    根據操做數是字節 (byte)、字 (word) 仍是長型 (long)，指令的後綴能夠是 b、w 或 l。這並非強制性的；GCC 會嘗試經過讀取操做數來提供相應的後綴。但手工指定後綴能夠改善代碼的可讀性，並能夠消除編譯器猜想不正確的可能性。 
    movb %al, %bl -- Byte move
    movw %ax, %bx -- Word move
    movl %eax, %ebx -- Longword move 
當即操做數
    經過使用 $ 指定直接操做數。 
    movl $0xffff, %eax -- will move the value of 0xffff into eax register. 
間接內存引用
    任何對內存的間接引用都是經過使用 ( ) 來完成的。 
    movb (%esi), %al -- will transfer the byte in the memory
    pointed by esi into al register 
[目錄]
內聯彙編
內聯彙編
    GCC 爲內聯彙編提供特殊結構，它具備如下格式：
    asm ( assembler template
        : output operands               (optional)
        : input operands                (optional)
        : list of clobbered registers   (optional)
        ); 
    本例中，彙編程序模板由彙編指令組成。輸入操做數是充當指令輸入操做數使用的 C 表達式。輸出操做數是將對其執行彙編指令輸出的 C 表達式。 
    內聯彙編的重要性體如今它可以靈活操做，並且可使其輸出經過 C 變量顯示出來。由於它具備這種能力，因此 "asm" 能夠用做彙編指令和包含它的 C 程序之間的接口。 
    一個很是基本但很重要的區別在於簡單內聯彙編只包括指令，而擴展內聯彙編包括操做數。要說明這一點，考慮如下示例： 
內聯彙編的基本要素 
{
    int a=10, b;
    asm ("movl %1, %%eax;
          movl %%eax, %0;"
          :"=r"(b)  /* output */
          :"r"(a)       /* input */
         :"%eax"); /* clobbered register */
} 
    在上例中，咱們使用匯編指令使 "b" 的值等於 "a"。請注意如下幾點：
    "b" 是輸出操做數，由 %0 引用，"a" 是輸入操做數，由 %1 引用。
    "r" 是操做數的約束，它指定將變量 "a" 和 "b" 存儲在寄存器中。請注意，輸出操做數約束應該帶有一個約束脩飾符 "="，指定它是輸出操做數。
    要在 "asm" 內使用寄存器 %eax，%eax 的前面應該再加一個 %，換句話說就是 %%eax，由於 "asm" 使用 %0、%1 等來標識變量。任何帶有一個 % 的數都看做是輸入／輸出操做數，而不認爲是寄存器。
第三個冒號後的修飾寄存器 %eax 告訴將在 "asm" 中修改 GCC %eax 的值，這樣 GCC 就不使用該寄存器存儲任何其它的值。
    movl %1, %%eax 將 "a" 的值移到 %eax 中，movl %%eax, %0 將 %eax 的內容移到 "b" 中。
由於 "b" 被指定成輸出操做數，所以當 "asm" 的執行完成後，它將反映出更新的值。換句話說，對 "asm" 內 "b" 所作的更改將在 "asm" 外反映出來。 
[目錄]
程序模板
    彙編程序模板是一組插入到 C 程序中的彙編指令（能夠是單個指令，也能夠是一組指令）。每條指令都應該由雙引號括起，或者整組指令應該由雙引號括起。每條指令還應該用一個定界符結尾。有效的定界符爲新行 (＼n) 和分號 (;)。 ’＼n’ 後能夠跟一個 tab(＼t) 做爲格式化符號，增長 GCC 在彙編文件中生成的指令的可讀性。 指令經過數 %0、%1 等來引用 C 表達式（指定爲操做數）。 
    若是但願確保編譯器不會在 "asm" 內部優化指令，能夠在 "asm" 後使用關鍵字 "volatile"。若是程序必須與 ANSI C 兼容，則應該使用 __asm__ 和 __volatile__，而不是 asm 和 volatile。 
[目錄]
操做數
   C 表達式用做 "asm" 內的彙編指令操做數。在彙編指令經過對 C 程序的 C 表達式進行操做來執行有意義的做業的狀況下，操做數是內聯彙編的主要特性。 
    每一個操做數都由操做數約束字符串指定，後面跟用括弧括起的 C 表達式，例如："constraint" (C expression)。操做數約束的主要功能是肯定操做數的尋址方式。 
    能夠在輸入和輸出部分中同時使用多個操做數。每一個操做數由逗號分隔開。 
    在彙編程序模板內部，操做數由數字引用。若是總共有 n 個操做數（包括輸入和輸出），那麼第一個輸出操做數的編號爲 0，逐項遞增，最後那個輸入操做數的編號爲 n-1。總操做數的數目限制在 10，若是機器描述中任何指令模式中的最大操做數數目大於 10，則使用後者做爲限制。 
[目錄]
修飾寄存器列表
    若是 "asm" 中的指令指的是硬件寄存器，能夠告訴 GCC 咱們將本身使用和修改它們。這樣，GCC 就不會假設它裝入到這些寄存器中的值是有效值。一般不須要將輸入和輸出寄存器列爲 clobbered，由於 GCC 知道 "asm" 使用它們（由於它們被明確指定爲約束）。不過，若是指令使用任何其它的寄存器，不管是明確的仍是隱含的（寄存器不在輸入約束列表中出現，也不在輸出約束列表中出現），寄存器都必須被指定爲修飾列表。修飾寄存器列在第三個冒號以後，其名稱被指定爲字符串。 
    至於關鍵字，若是指令以某些不可預知且不明確的方式修改了內存，則可能將 "memory" 關鍵字添加到修飾寄存器列表中。這樣就告訴 GCC 不要在不一樣指令之間將內存值高速緩存在寄存器中。 
[目錄]
操做數約束
    前面提到過，"asm" 中的每一個操做數都應該由操做數約束字符串描述，後面跟用括弧括起的 C 表達式。操做數約束主要是肯定指令中操做數的尋址方式。約束也能夠指定： 
    ?是否容許操做數位於寄存器中，以及它能夠包括在哪些種類的寄存器中
    ?操做數是否能夠是內存引用，以及在這種狀況下使用哪些種類的地址
    ?操做數是否能夠是當即數 
約束還要求兩個操做數匹配。 
經常使用約束 
    在可用的操做數約束中，只有一小部分是經常使用的；下面列出了這些約束以及簡要描述。有關操做數約束的完整列表，請參考 GCC 和 GAS 手冊。 
寄存器操做數約束 (r)
    使用這種約束指定操做數時，它們存儲在通用寄存器中。請看下例：
           asm ("movl %%cr3, %0＼n" :"=r"(cr3val));
    這裏，變量 cr3val 保存在寄存器中，%cr3 的值複製到寄存器上，cr3val 的值從該寄存器更新到內存中。指定 "r" 約束時，GCC 能夠將變量 cr3val 保存在任何可用的 GPR 中。要指定寄存器，必須經過使用特定的寄存器約束直接指定寄存器名。 
a   %eax
b   %ebx
c   %ecx
d   %edx
S   %esi
D   %edi 
內存操做數約束 (m)
    當操做數位於內存中時，任何對它們執行的操做都將在內存位置中直接發生，這與寄存器約束正好相反，後者先將值存儲在要修改的寄存器中，而後將它寫回內存位置中。但寄存器約束一般只在對於指令來講它們是絕對必需的，或者它們能夠大大提升進程速度時使用。當須要在 "asm" 內部更新 C 變量，而您又確實不但願使用寄存器來保存其值時，使用內存約束最爲有效。例如，idtr 的值存儲在內存位置 loc 中：
        ("sidt %0＼n" : :"m"(loc)); 
匹配（數字）約束
    在某些狀況下，一個變量既要充當輸入操做數，也要充當輸出操做數。能夠經過使用匹配約束在 "asm" 中指定這種狀況。 
        asm ("incl %0" :"=a"(var):"0"(var)); 
    在匹配約束的示例中，寄存器 %eax 既用做輸入變量，也用做輸出變量。將 var 輸入讀取到 %eax，增長後將更新的 %eax 再次存儲在 var 中。這裏的 "0" 指定第 0 個輸出變量相同的約束。即，它指定 var 的輸出實例只應該存儲在 %eax 中。該約束能夠用於如下狀況： 
   ?輸入從變量中讀取，或者變量被修改後，修改寫回到同一變量中
   ?不須要將輸入操做數和輸出操做數的實例分開
   ?使用匹配約束最重要的意義在於它們能夠致使有效地使用可用寄存器。 


示例
通常內聯彙編用法示例
    如下示例經過各類不一樣的操做數約束說明了用法。有如此多的約束以致於沒法將它們一一列出，這裏只列出了最常用的那些約束類型。 
寄存器約束
"asm" 和寄存器約束 "r"
    讓咱們先看一下使用寄存器約束 r 的 "asm"。咱們的示例顯示了 GCC 如何分配寄存器，以及它如何更新輸出變量的值。 
int main(void)
{
    int x = 10, y;
    asm ("movl %1, %%eax;
         "movl %%eax, %0;"
         :"=r"(y)  /* y is output operand */
         :"r"(x)       /* x is input operand */
         :"%eax"); /* %eax is clobbered register */
} 
    在該例中，x 的值複製爲 "asm" 中的 y。x 和 y 都經過存儲在寄存器中傳遞給 "asm"。爲該例生成的彙編代碼以下： 
main:
pushl %ebp
movl %esp,%ebp
subl $8,%esp
movl $10,-4(%ebp)
movl -4(%ebp),%edx  /* x=10 is stored in %edx */
#APP    /* asm starts here */
movl %edx, %eax     /* x is moved to %eax */
movl %eax, %edx     /* y is allocated in edx and updated */
#NO_APP /* asm ends here */
movl %edx,-8(%ebp)  /* value of y in stack is updated with the value in %edx */ 
    當使用 "r" 約束時，GCC 在這裏能夠自由分配任何寄存器。在咱們的示例中，它選擇 %edx 來存儲 x。在讀取了 %edx 中 x 的值後，它爲 y 也分配了相同的寄存器。 
    由於 y 是在輸出操做數部分中指定的，因此 %edx 中更新的值存儲在 -8(%ebp)，堆棧上 y 的位置中。若是 y 是在輸入部分中指定的，那麼即便它在 y 的臨時寄存器存儲值 (%edx) 中被更新，堆棧上 y 的值也不會更新。 
    由於 %eax 是在修飾列表中指定的，GCC 不在任何其它地方使用它來存儲數據。 
    輸入 x 和輸出 y 都分配在同一個 %edx 寄存器中，假設輸入在輸出產生以前被消耗。請注意，若是您有許多指令，就不是這種狀況了。要確保輸入和輸出分配到不一樣的寄存器中，能夠指定 & 約束脩飾符。下面是添加了約束脩飾符的示例。 
int main(void)
{
    int x = 10, y;
    asm ("movl %1, %%eax;
         "movl %%eax, %0;"
        :"=&r"(y) /* y is output operand, note the & constraint modifier. */
        :"r"(x)       /* x is input operand */
        :"%eax"); /* %eax is clobbered register */
} 
    如下是爲該示例生成的彙編代碼，從中能夠明顯地看出 x 和 y 存儲在 "asm" 中不一樣的寄存器中。 
main:
pushl %ebp
movl %esp,%ebp
subl $8,%esp
movl $10,-4(%ebp)
movl -4(%ebp),%ecx  /* x, the input is in %ecx */
#APP
    movl %ecx, %eax
    movl %eax, %edx     /* y, the output is in %edx */
#NO_APP
movl %edx,-8(%ebp) 
特定寄存器約束的使用
    如今讓咱們看一下如何將個別寄存器做爲操做數的約束指定。在下面的示例中，cpuid 指令採用 %eax 寄存器中的輸入，而後在四個寄存器中給出輸出：%eax、%ebx、%ecx、%edx。對 cpuid 的輸入（變量 "op"）傳遞到 "asm" 的 eax 寄存器中，由於 cpuid 但願它這樣作。在輸出中使用 a、b、c 和 d 約束，分別收集四個寄存器中的值。 
        asm ("cpuid"
              : "=a" (_eax),
              "=b" (_ebx),
              "=c" (_ecx),
              "=d" (_edx)
              : "a" (op)); 
    在下面能夠看到爲它生成的彙編代碼（假設 _eax、_ebx 等... 變量都存儲在堆棧上）： 
movl -20(%ebp),%eax /* store ’op’ in %eax -- input */
#APP
cpuid
#NO_APP
movl %eax,-4(%ebp)  /* store %eax in _eax -- output */
movl %ebx,-8(%ebp)  /* store other registers in
movl %ecx,-12(%ebp)
respective output variables */
movl %edx,-16(%ebp) 
strcpy 函數能夠經過如下方式使用 "S" 和 "D" 約束來實現： 
        asm ("cld＼n
              rep＼n
              movsb"
              : /* no input */
              :"S"(src), "D"(dst), "c"(count)); 
    經過使用 "S" 約束將源指針 src 放入 %esi 中，使用 "D" 約束將目的指針 dst 放入 %edi 中。由於 rep 前綴須要 count 值，因此將它放入 %ecx 中。 
    在下面能夠看到另外一個約束，它使用兩個寄存器 %eax 和 %edx 將兩個 32 位的值合併在一塊兒，而後生成一個64 位的值： 
#define rdtscll(val) ＼
__asm__ __volatile__ ("rdtsc" : "=A" (val))
The generated assembly looks like this (if val has a 64 bit memory space).
#APP
rdtsc
#NO_APP
movl %eax,-8(%ebp)  /* As a result of A constraint
movl %edx,-4(%ebp)
%eax and %edx serve as outputs */
Note here that the values in %edx:%eax serve as 64 bit output. 
匹配約束
使用匹配約束
    在下面將看到系統調用的代碼，它有四個參數： 
#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) ＼
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) ＼
{ ＼
long __res; ＼
__asm__ volatile ("int $0x80" ＼
: "=a" (__res) ＼
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), ＼
"d" ((long)(arg3)),"S" ((long)(arg4))); ＼
__syscall_return(type,__res); ＼
} 
    在上例中，經過使用 b、c、d 和 S 約束將系統調用的四個自變量放入 %ebx、%ecx、%edx 和 %esi 中。請注意，在輸出中使用了 "=a" 約束，這樣，位於 %eax 中的系統調用的返回值就被放入變量 __res 中。經過將匹配約束 "0" 用做輸入部分中第一個操做數約束，syscall 號 __NR_##name 被放入 %eax 中，並用做對系統調用的輸入。這樣，這裏的 %eax 既能夠用做輸入寄存器，又能夠用做輸出寄存器。沒有其它寄存器用於這個目的。另請注意，輸入（syscall 號）在產生輸出（syscall 的返回值）以前被消耗（使用）。 
內存操做數約束
內存操做數約束的使用
    請考慮下面的原子遞減操做： 
        __asm__ __volatile__(
                "lock; decl %0"
                :"=m" (counter)
                :"m" (counter)); 
    爲它生成的彙編相似於： 
#APP
    lock
    decl -24(%ebp) /* counter is modified on its memory location */
#NO_APP. 
    您可能考慮在這裏爲 counter 使用寄存器約束。若是這樣作，counter 的值必須先複製到寄存器，遞減，而後對其內存更新。但這樣您會沒法理解鎖定和原子性的所有意圖，這些明確顯示了使用內存約束的必要性。 
修飾寄存器
使用修飾寄存器
    請考慮內存拷貝的基本實現。 
       asm ("movl $count, %%ecx;
            up: lodsl;
            stosl;
            loop up;"
            :           /* no output */
            :"S"(src), "D"(dst) /* input */
            :"%ecx", "%eax" );  /* clobbered list */ 

    當 lodsl 修改 %eax 時，lodsl 和 stosl 指令隱含地使用它。%ecx 寄存器明確裝入 count。但 GCC 在咱們通知它之前是不知道這些的，咱們是經過將 %eax 和 %ecx 包括在修飾寄存器集中來通知 GCC 的。在完成這一步以前，GCC 假設 %eax 和 %ecx 是自由的，它可能決定將它們用做存儲其它的數據。請注意，%esi 和 %edi 由 "asm" 使用，它們不在修飾列表中。這是由於已經聲明 "asm" 將在輸入操做數列表中使用它們。這裏最低限度是，若是在 "asm" 內部使用寄存器（不管是明確仍是隱含地），既不出如今輸入操做數列表中，也不出如今輸出操做數列表中，必須將它列爲修飾寄存器。

From: http://www.sudu.cn/info/html/edu/20080425/301547.html

Win32與 Linux彙編語法的區別

彙編語言的優勢是速度快，能夠直接對硬件進行操做，這對諸如圖形處理等關鍵應用是很是重要的。Linux 是一個用 C 語言開發的操做系統，這使得不少程序員開始忘記在 Linux 中還能夠直接使用匯編這一底層語言來優化程序的性能。本文爲那些在Linux 平臺上編寫彙編代碼的程序員提供指南，介紹 Linux 彙編語言的語法格式和開發工具，並輔以具體的例子講述如何開發實用的Linux 彙編程序。

1、簡介

做爲最基本的編程語言之一，彙編語言雖然應用的範圍不算很廣，但重要性卻勿庸置疑，由於它可以完成許多其它語言所沒法完成的功能。就拿 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。

回頁首

2、Linux 彙編語法格式

絕大多數 Linux 程序員之前只接觸過DOS/Windows 下的彙編語言，這些彙編代碼都是 Intel 風格的。但在 Unix 和 Linux 系統中，更多采用的仍是 AT&T 格式，二者在語法格式上有着很大的不一樣：

1. 在 AT&T 彙編格式中，寄存器名要加上 '%' 做爲前綴；而在 Intel 彙編格式中，寄存器名不須要加前綴。例如：

   AT&T 格式	Intel 格式
   pushl %eax	push eax

2. 在 AT&T 彙編格式中，用 '$' 前綴表示一個當即操做數；而在 Intel 彙編格式中，當即數的表示不用帶任何前綴。例如：

   AT&T 格式	Intel 格式
   pushl $1	push 1

3. AT&T 和 Intel 格式中的源操做數和目標操做數的位置正好相反。在 Intel 彙編格式中，目標操做數在源操做數的左邊；而在 AT&T 彙編格式中，目標操做數在源操做數的右邊。例如：

   AT&T 格式	Intel 格式
   addl $1, %eax	add eax, 1

4. 在 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

5. 在 AT&T 彙編格式中，絕對轉移和調用指令（jump/call）的操做數前要加上'*'做爲前綴，而在 Intel 格式中則不須要。

6. 遠程轉移指令和遠程子調用指令的操做碼，在 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

7. 在 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

回頁首

3、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 中，能夠找到全部系統調用的定義。

回頁首

4、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 <command>' for more specific information on <command>. 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

5、系統調用

即使是最簡單的彙編程序，也不免要用到諸如輸入、輸出以及退出等操做，而要進行這些操做則須要調用操做系統所提供的服務，也就是系統調用。除非你的程序只完成加減乘除等數學運算，不然將很難避免使用系統調用，事實上除了系統調用不一樣以外，各類操做系統的彙編編程每每都是很相似的。

在 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 這一系統調用來實現的。根據上面的約定，參數 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中。

回頁首

6、命令行參數

在 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

回頁首

7、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）

回頁首

8、小結

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

linux下的彙編學習體會

From：http://apps.hi.baidu.com/share/detail/16002968

Linux下的彙編程序學習體會（1）

1、爲何學習linux下的彙編

1. Linux的應用領域愈來愈普遍，特別是在嵌入式領域有着得天獨厚的優點。涉及到硬件相關的開發天然少不了彙編語言。
2. 大學裏學習的彙編都是16位的，與如今32位芯片有些出入。
3. 並且不少AT/T的彙編格式代碼也讓咱們感到困惑
4. Linux內核代碼由一些核心部分也是用匯編寫的。爲了讀懂linux內核，須要對彙編有必定的瞭解。本人正是基於這個目的出發，才學習彙編的。

2、硬件和彙編語言

1. 彙編語言根機器語言是一一對應的；因此，不一樣型號的機器有不一樣的彙編語言，本文全部的論述都是基於X86的體系結構。
2. Linux彙編按照語法格式能夠分爲兩種inter格式和AT/T格式。前者跟咱們大學裏學習的彙編語言格式相近；後者在linux內核代碼中獲得了普遍的應用。關於這兩種格式的詳細描述請參考《linux下的彙編程序學習體會（2）》。Linux下還有一個小工具，intel2gas能夠把inter格式轉換成AT/T格式。本文所涉及的都是AT/T格式的彙編。

3、開發環境

編輯器

Linux下任何一款文本編輯器，vi, emac, etc. 若是喜歡直接寫屏，也沒什麼不妥（男人就要對本身狠一點）。不過本人仍是鍾愛vi.

編譯器

推薦as, 沒啥可說的，看man page吧。

鏈接器

固然是老牌勁旅ld, (其實我沒用過別的)，用法仍是參考man page.

調試器

能夠用gdb, 不過康奈爾大學的好事者Patrick Alken先生獨立開發了一個ald。本人就是用ald, 這個軟件能夠從http://ald.sourceforge.net/ 得到，它的編譯須要依賴行編輯器readline, readline能夠從http://www.gnu.org/ 上找到。

教材

推薦ProgrammingGroundUp, 淺顯易懂實用

4、入門實例

先來個感性的認識，用一個Hello World程序把彙編語言的開發過程完整的走一編。

第一步，編輯程序。

用編輯器編譯下列程序保存文件名爲hello.s

#hello.s

.data # 數據段聲明

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

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 # 調用內核功能

第二步，編譯

運行命令as –gstabs –o hello.o hello.s 就獲得了二進制目標文件hello.o, 參數—gstabs 的意義是保存符號表，以方便未來的調試。

第三步，鏈接

運行命令ld –o hello hello.o 就輸出了可執行程序hello.

第四步，運行

敲入命令./hello, 就看到了輸出。

第五步，調試

這個程序工做正常，實際上無需調試。這裏只是介紹調試器的使用方法。運行命令ald hello

就進入了調試狀態。

Assembly Language Debugger 0.1.7

Copyright (C) 2000-2004 Patrick Alken



hello: ELF Intel 80386 (32 bit), LSB - little endian, Executable, Version 1 (Current)

Loading debugging symbols...(15 symbols loaded)

ald>

用反彙編命令獲得程序的代碼段

ald> d -s .text

Disassembling section .text (0x08048074 - 0x08048096)

08048074:<_start> BA0E000000 mov edx, 0xe

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> b 0x0804807E

Breakpoint 1 set for 0x0804807E

運行程序

ald> r

Starting program: hello

Breakpoint 1 encountered at 0x0804807E

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

esp = 0xBFFFFCC0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000

ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000

ss = 0x007B cs = 0x0073 eip = 0x0804807E eflags = 0x00200212



Flags: AF IF ID





0804807E BB01000000 mov ebx, 0x1

單步運行到結束

ald> n eax = 0x00000000 ebx = 0x00000001 ecx = 0x08049098 edx = 0x0000000E esp = 0xBFFFFCC0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x08048083 eflags = 0x00200312 Flags: AF TF IF ID 08048083 B804000000 mov eax, 0x4 ald> n eax = 0x00000004 ebx = 0x00000001 ecx = 0x08049098 edx = 0x0000000E esp = 0xBFFFFCC0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x08048088 eflags = 0x00200312 Flags: AF TF IF ID 08048088 CD80 int 0x80 ald> n Hello, world!eax = 0x0000000E ebx = 0x00000000 ecx = 0x08049098 edx = 0x0000000E esp = 0xBFFFFCC0 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x0804808F eflags = 0x00200312 Flags: AF TF IF ID 04808F B801000000 mov eax, 0x1