indirect address 的用途是在於讓 register 以類似 pointer 的方式來運作，而使用方式上必須用中括號([])包住 register 名稱，以下舉例說明：
mov ax, [myData] ;指定以類似 pointer 方式處理
mov ebx, myData ;EBX = &myData
mov ax, [ebx] ;AX = *EBX
The Stack
現在幾乎大多數 CPU 中都已經支援 stack 了，其特色在於 LIFO(Last In First Out)，因此在程式中常被用來作為資料暫存以及呼叫 subprogram 之用，
以下分別舉兩個例子說明：
資料暫存
在資料暫存的部分，必須透過 PUSH、POP 兩個指令以及 ESP(stack pointer) register 的搭配；其中 PUSH 會將 ESP 中的位址 - 4，並將內容塞入 [ESP] 的位址；而 POP 則會將 ESP 中的位址 + 4，並將內容塞到指定的地方去；以下用範例來說明：
【註】PUSH 的資料長度必須是 double word;假設 EPS 一開始儲存的 memory address 為 0x1000
push dword 1 ;將 1 存於 0x0FFC 的位置，ESP = 0x0FFC(0x1000 - 0x0004)
push dword 2 ;將 2 存於 0x0FF8 的位置，ESP = 0x0FF8(0x0FFC - 0x0004)
push dword 3 ;將 3 存於 0x0FF4 的位置，ESP = 0x0FF4(0x0FF8 - 0x0004)
pop eax ;EAX = 3，ESP = 0x0FF8(0x0FF4 + 0x0004)
pop ebx ;EBX = 2，ESP = 0x0FFC(0x0FF8 + 0x0004)
pop ecx ;ECX = 1，ESP = 0x1000(0x0FFC + 0x0004)
呼叫 subprogram
若要透過 stack 來呼叫 subprogram，則必須使用 CALL 與 RET 兩個指令，其中 CALL 為 unconditional jump，會直接跳到所指定的 Label，並將原本他所在的 memory address push 到儲存下一個執行指令位址的 stack 中；而 RET 則是將 stack 中的 memory address pop 出來，並跳回該 memory address。以下用個範例說明：
透過此種方式，呼叫 subprogram 就更為方便了!mov ebx, input1
;uncondictional jump，跳至 get_int 所在位址，並將原本的 memory address push 到儲存下一個執行指令的 stack 中
call get_int
mov ebx, input2
;uncondictional jump，跳至 get_int 所在位址，並將原本的 memory address push 到儲存下一個執行指令的 stack 中
call get_int
get_int:
call read_int
mov [ebx], eax
ret ;將原本呼叫 subprogram 時所在的 memory address 從 stack pop 出來，以返回呼叫點
Calling Conventions
在其他高階程式語言中，常常會在呼叫 subprogram 時帶入多個參數，這在底層是如何處理的呢? 答案就是利用 stack。
由於參數資料會在 subprogram 中被使用一次甚至數次，因此這些資料不適合放置於 register 中，因此一般會放在 stack 中；而且會在 CALL 指令發生前先 push 進入 stack 中，因此 return address 也會比參數先從 stack 中 pop 出來。以下用一張圖來說明：
但如果在 subprogram 中又有資料要存入 stack 中呢? 在 stack 中的情形會變成如下：
如此一來，參數的位置就從 [ESP+4] 的位置跑到 [ESP+8] 了，若是在 subprogram 中要使用到 stack，就必須注意參數被移到那個位置去，其實蠻麻煩的。
因此，在 80386 以後的 CPU，提供了 EBP(base pointer) register 來解決這個問題，而 EBP 所儲存的內容，則是對應到 return address 所存放的位置(因此一開始 EBP 的內容要設定與 ESP 相同)。
以下用個簡單範例說明 EBP 在 subprogram 中的使用方式：
透過以上這一段程式的使用，ESP 與 EBP 的關係會變成如下圖：subprogram_label:
push ebp ;將 EBP 的內容先存到 stack 中
mov ebp, esp ;EBP = ESP
;subprogram 的實作內容置於此處
pop ebp ;還原 EBP 的值
ret
之後若要取得參數的內容，不管 stack 中已經塞了多少 subprogram 的資料，只要用 [EBP+8] 就可以取得參數的內容囉!
以下用個範例來進行以上說明的總結：
%include "asm_io.inc"
segment .data
sum dd 0 ;定義記憶體空間，長度為 double word
segment .bss
input resd 1
;
; pseudo-code algorithm
; i = 1;
; sum = 0;
; while(get_int(i, &input), input != 0) {
; sum += input;
; i++;
; }
; print_sum(sum);
segment .text
global asm_main
asm_main:
enter 0, 0
pusha
mov edx, 1 ;將 EDX 視為變數 i
while_loop:
push edx
push dword input
call get_int
add esp, 8 ;將 i 與 &input 從 stack 中清除
;判斷輸入的值是否為 0
mov eax, [input]
cmp eax, 0
je end_while
add [sum], eax ;sum += input
inc edx ;i++
jmp while_loop ;繼續執行下一個迴圈
end_while:
push dword [sum] ;將 [sum] 存入 stack 中
call print_sum
pop ecx ;將 [sum] 從 stack 中清除
popa
leave
ret
;subprogram: get_int
;參數(根據順序放入 stack 中)
; 1、輸入的值(位於 [EBP + 12])
; 2、輸入資料所存放的位址(位於 [EBP + 8])
;[EBP] 儲存原本 EBP 中的內容
;[EBP + 4] 儲存 return address
;[EBP + 8] 之後開始儲存參數的相關內容，因為有兩個參數，因此 ESP 要存取第一個參數就必須指向 [EBP + 12]
;注意：
; 在 EAX 與 EBX 中的資料將會被清除
;
segment .data
prompt db ") Enter an integer number (0 to quit): ", 0
segment .text
get_int:
push ebp ;將 EBP 內容暫時存於 stack 中
mov ebp, esp
mov eax, [ebp + 12] ;上面的程式會將 EDX 的值塞到 [EBP + 12] 所儲存的 memory address 中
call print_int ;印出輸入第幾個數字
mov eax, prompt
call print_string
call read_int
mov ebx, [ebp + 8] ;上面的程式會將 input 所在的 memory address 塞到 [EBP + 8]，因此 EBP 儲存的為 memory address 而不是整數
mov [ebx], eax ;以類似 pointer 方式將 EAX 的值存到 EBX 所儲存的 memory address 上
pop ebp ;回復 EBP 中的值
ret
;subprogram: print_sum
; 印出總和
;參數：
; (1)所要輸出的總和(位於 [EBP + 8])
;注意：
; 在 EAX 中的資料將會被清除
;
segment .data
result db "The sum is ", 0
segment .text
print_sum:
push ebp
mov ebp, esp
mov eax, result
call print_string
mov eax, [ebp + 8]
call print_int
call print_nl
pop ebp
ret
Local variables on the stack
在 subprogram 中，難免會使用到 local 變數，一般都是利用 stack 來處理 local 變數(例如：C 語言)，local 變數儲存的地方在原本 EBP 儲存位置之後，以下用一張圖來說明：
(其中 sum 即為 local 變數)
若要取得第一個 local 變數，可透過 [ESP - 4](此時 ESP 指到 EBP 的地方，也就是 +4 的位置)，而在 subprogram 中使用 local 變數的方法，可以使用類似以下的程式碼：
以下用一個較為完整的範例來說明：subprogram_label:
push ebp
mov ebp, esp
sub esp, LOCAL_BYTES ;在此處根據需求保留給 local 變數的空間
;subprogram 的實作內容置於此處
mov esp, ebp
pop ebp
ret
; (C 語言程式碼)
; void calc_sum(int n, int *sump) {
; int i, sum = 0;
;
; for(i = 1 ; i <= n ; i++)
; sum += i;
;
; *sump = sum;
; } //end calc_sum
calc_sum:
push ebp
mov ebp, esp
sub esp, 4 ;保留儲存 local 變數的 memory address 的空間
mov dword [ebp - 4], 0 ;sum = 0;
mov ebx, 1 ;假設 EBX = i
for_loop:
cmp ebx, [ebp + 8] ;i <= n
jnle end_for ;jump if not(less & equal)
add [ebp - 4], ebx ;sum += i
inc ebx
jmp short for_loop
end_for:
mov ebx, [ebp + 12] ;ebx = sump
mov eax, [ebp - 4] ;eax = sum
mov [ebx], eax ;*sump = sum
mov esp, ebp
pop ebp
ret
Multi-Module Programs
所謂的 multi-module program 是由多個 object file 所組合而成的，而之前下一堆指令所產生的執行檔，就是屬於 multi-module program。
而當程式大一點時，總是希望可以將其進行模組化的設計，將龐大的程式拆開成為較小容易閱讀及 debug 的多個檔案，在 assembly 中，可以透過 extern 以及 global 兩個關鍵字。
external
以下先用一段範例程式說明：
透過 extern 的宣告，用來告知 assembler 以上這些 subprogram 的定義位於外部的檔案中，不在這個檔案中。extern read_int, print_int, print_string
extern read_char, print_char, print_nl
extern sub_dump_regs, sub_dump_mem, sub_dump_math, sub_dump_stack
不過在編譯的階段必須將包含定義這些 subprogram 的檔案一併加入編譯，否則會產生編譯時的錯誤。
global
global 在之前的每一支程式都會使用到，用意是讓其他的 module 可以直接呼叫使用 global 關鍵字宣告的 module。
使用範例說明
了解兩個關鍵字的使用方式後，接著以下介紹其使用方式：
編譯與執行可用下列指令：; ==================== main4.asm ====================
%include "asm_io.inc"
segment .data
sum dd 0
segment .bss
input resd 1
segment .text
global asm_main ;宣告為 global，才可以由 C 程式中直接呼叫使用
extern get_int, print_sum ;宣告為 extern，表示這兩個 subprogram 的定義存在於其他檔案中
asm_main:
enter 0, 0
pusha
mov edx, 1
while_loop:
push edx
push dword input
call get_int
add esp, 8 ;清除兩個參數的內容
mov eax, [input]
cmp eax, 0
je end_while
add [sum], eax ;sum += [input]
inc edx
jmp short while_loop
end_while:
push dword [sum]
call print_sum ;印出在 stack 中的 sum
pop ecx
popa
leave
ret
; ==================== sub4.asm ====================
%include "asm_io.inc"
segment .data
prompt db ") Enter an integer number (0 to quit): ", 0
segment .text
global get_int, print_sum
get_int:
enter 0, 0
;saved EBP(EBP) + return address(EBP + 4) + &input(EBP + 8) + i(EBP + 12)
mov eax, [ebp + 12] ;第一個參數(i)
call print_int
mov eax, prompt
call print_string
call read_int
mov ebx, [ebp + 8] ;取得資料所要儲存的 memory address
mov [ebx], eax ;將資料存於指定的 memory address
leave
ret
segment .data
result db "The sum is ", 0
segment .text
print_sum:
enter 0, 0
mov eax, result
call print_string
;saved EBP(EBP) + return address(EBP + 4) + sum(EBP + 8)
mov eax, [ebp + 8]
call print_int
call print_nl
leave
ret
shell> nasm -f elf main4.asm ; nasm -f elf sub4.asm ; gcc -o main4 driver.c main4.o sub4.o asm_io.o; ./main4
Interfacing Assembly with C
之前有提過，由於目前的 compiler 越來越完善，因此編譯出來的 machine code 效能不見得會輸給直接寫 assembly，因此現在已經很少所有程式都使用 assembly 開發了，大多都是在 performance tunning 時，或是需要直接控制到硬體時，才會撰寫 assembly。
因此在使用時，通常都是 C 與 assembly 混合使用，不過有些事情是必須了解的，例如：
- C 語言中在 subroutine 中通常都會維護 EBX、ESI、EBP、CS、DS、SS、ES .... 等 register 的值，不會去更動他(但不代表不能更動，只是必須要回復，通常用 stack 來儲存這些 register 中的值)
- C 語言中 global 或 static 的 function 或變數名稱前都會加上底線(_)，這跟 assembly 中加上底線是不同的意思
- 在參數的傳遞上，C call convention 規定 function 中的參數是以反向的順序塞入 stack 中；因此，第一個參數位於 [EBP + 8]，第二個參數位於 [EBP + 12] (原本第一個參數位於 [EBP + 12]，第二個參數位於 [EBP + 8])
- 回傳值的部分大多都是透過將值存於 register 的方式來達成，可能存於 EAX、EDX:EAX、或是 ST0 中
- 程式中可以指定不同的 call convention，一般的 compiler 都會支援多種 calling convention
以下用個範例說明 C 與 assembly 的搭配：
// ==================== main5.c ====================
#include <stdio.h>
void calc_sum(int, int *) __attribute__((cdecl));
int main(void) {
int n, sum;
printf("Sum integer up to: ");
scanf("%d", &n);
calc_sum(n, &sum);
printf("Sum is %dn", sum);
return 0;
} //end main
;==================== sub5.asm ====================
%include "asm_io.inc"
; subroutine: calc_sum
; 目的: 計算從 1~n 的加總
; 參數：(因為 C calling convention 的關係，因此參數以反向的順序存入 stack 中)
; (1)加總的上限(即為n) [EBP + 8]
; (2)指向儲存加總資料位址的 pointer [EBP + 12]
; pseudo C code:
; void calc_sum(int n, int *sump) {
; int i, sum = 0
; for(i = 1 ; i <= n ; i++)
; sum += i;
; *sump = sum;
; } //end calc_sum
segment .text
global calc_sum
;local variable:
; sum => [ebp - 4]
calc_sum:
enter 4, 0 ;在 stack 中預留空間給 sum 使用
push ebx
mov dword [ebp - 4], 0
dump_stack 1, 2, 4
mov ecx, 1
for_loop:
cmp ecx, [ebp + 8] ;i <= n ?
jnle end_for
add [ebp - 4], ecx
inc ecx
jmp short for_loop
end_for:
mov ebx, [ebp + 12] ;EBX = sump (儲存加總結果的 pointer)
mov eax, [ebp - 4] ;EAX = sum (加總結果)
mov [ebx], eax ;使用 [pointer] 指定該 memory address 儲存的資料為 sum
pop ebx
leave
ret
然而，從 C 可以呼叫 assembly code，當然也可以在 assembly 中使用 C library 囉! 這個部分下個章節會繼續討論囉!!
沒有留言:
張貼留言