大內高手—棧/堆
轉載時請註明出處和作者聯繫方式：http://blog.csdn.net/absurd
作者聯繫方式：李先靜 <xianjimli at hotmail dot com>
更新時間：2007-7-9
l 棧
棧作爲一種基本數據結構，我並不感到驚訝，用來實現函數調用，這也司空見慣的作法。直到我試圖找到另外一種方式實現遞歸操作時，我才感嘆於它的巧妙。要實現遞歸操作，不用棧不是不可能，而是找不出比它更優雅的方式。
儘管大多數編譯器在優化時，會把常用的參數或者局部變量放入寄存器中。但用棧來管理函數調用時的臨時變量（局部變量和參數）是通用做法，前者只是輔助手段，且只在當前函數中使用，一旦調用下一層函數，這些值仍然要存入棧中才行。
通常情況下，棧向下（低地址）增長，每向棧中PUSH一個元素，棧頂就向低地址擴展，每從棧中POP一個元素，棧頂就向高地址回退。一個有興趣的問題：在x86平臺上，棧頂寄存器爲ESP，那麼ESP的值在是PUSH操作之前修改呢，還是在PUSH操作之後修改呢？PUSH ESP這條指令會向棧中存入什麼數據呢？據說x86系列CPU中，除了286外，都是先修改ESP，再壓棧的。由於286沒有CPUID指令，有的OS用這種方法檢查286的型號。
一個函數內的局部變量以及其調用下一級函數的參數，所佔用的內存空間作爲一個基本的單元，稱爲一個幀(frame)。在gdb裏，f 命令就是用來查看指定幀的信息的。在兩個frame之間通過還存有其它信息，比如上一層frame的分界地址(EBP)等。
關於棧的基本知識，就先介紹這麼多，我們下面來看看一些關於棧的技巧及應用：
1. backtrace的實現
callstack調試器的基本功能之一，利用此功能，你可以看到各級函數的調用關係。在gdb中，這一功能被稱爲backtrace，輸入bt命令就可以看到當前函數的callstack。它的實現多少有些有趣，我們在這裏研究一下。
我們先看看棧的基本模型
| 參數N | ↓高地址 |
| 參數… | 函數參數入棧的順序與具體的調用方式有關 |
| 參數 3 | |
| 參數 2 | |
| 參數 1 | |
| EIP | 返回本次調用後，下一條指令的地址 |
| EBP | 保存調用者的EBP，然後EBP指向此時的棧頂。 |
| 臨時變量1 |
|
| 臨時變量2 |
|
| 臨時變量3 |
|
| 臨時變量… |
|
| 臨時變量5 | ↓低地址 |
要實現callstack我們需要知道以下信息：
l 調用函數時的指令地址（即當時的EIP）。
l 指令地址對應的源代碼代碼位置。
關於第一點，從上表中，我們可以看出，棧中存有各級EIP的值，我們取出來就行了。用下面的代碼可以輕易實現：
| #include <stdio.h>
int backtrace(void** BUFFER, int SIZE) { int n = 0; int* p = &n; int i = 0;
int ebp = p[1]; int eip = p[2];
for(i = 0; i < SIZE; i++) { BUFFER[i] = (void*)eip; p = (int*)ebp; ebp = p[0]; eip = p[1]; }
return SIZE; }
#define N 4 static void test2() { int i = 0; void* BUFFER[N] = {0};
backtrace(BUFFER, N);
for(i = 0; i < N; i++) { printf("%p/n", BUFFER[i]); }
return; }
static void test1() { test2(); }
static void test() { test1(); }
int main(int argc, char* argv[]) { test();
return 0; } |
程序輸出：
0x8048460
0x804849c
0x80484a9
0x80484cc
關於第二點，如何把指令地址與行號對應起來，這也很簡單。可以從MAP文件或者ELF中查詢。Binutil帶有一個addr2line的小工具，可以幫助實現這一點。
[root@linux bt]# addr2line 0x804849c -e bt.exe
/root/test/bt/bt.c:42
2. alloca的實現
大家都知道動態分配的內存，一定要釋放掉，否則就會有內存泄露。可能鮮有人知，動態分配的內存，可以不用釋放。Alloca就是這樣一個函數，最後一個a代表auto，即自動釋放的意思。
Alloca是在棧中分配內存的。即然是在棧中分配，就像其它在棧中分配的臨時變量一樣，在當前函數調用完成時，這塊內存自動釋放。
正如我們前面講過，棧的大小是有限制的，普通線程的棧只有10M大小，所以在分配時，要量力而行，且不要分配過大內存。
Alloca可能會漸漸的退出歷史舞臺，原因是新的C/C++標準都支持變長數組。比如int array[n]，老版本的編譯器要求n是常量，而新編譯器允許n是變量。編譯器支持的這一功能完全可以取代alloca。
這不是一個標準函數，但像linux和win32等大多數平臺都支持。即使少數平臺不支持，要自己實現也不難。這裏我們簡單介紹一下alloca的實現方法。
我們先看看一個小程序，再看看它對應的彙編代碼，一切都清楚了。
| #include <stdio.h>
int main(int argc, char* argv[]) { int n = 0; int* p = alloca(1024);
printf("&n=%p p=%p/n", &n, p); return 0; } |
彙編代碼爲：
| int main(int argc, char* argv[]) { 8048394: 55 push %ebp 8048395: 89 e5 mov %esp,%ebp 8048397: 83 ec 18 sub $0x18,%esp 804839a: 83 e4 f0 and $0xfffffff0,%esp 804839d: b8 00 00 00 00 mov $0x0,%eax 80483a2: 83 c0 0f add $0xf,%eax 80483a5: 83 c0 0f add $0xf,%eax 80483a8: c1 e8 04 shr $0x4,%eax 80483ab: c1 e0 04 shl $0x4,%eax 80483ae: 29 c4 sub %eax,%esp int n = 0; 80483b0: c7 45 fc 00 00 00 00 movl $0x0,0xfffffffc(%ebp) int* p = alloca(1024); 80483b7: 81 ec 10 04 00 00 sub $0x410,%esp 80483bd: 8d 44 24 0c lea 0xc(%esp),%eax 80483c1: 83 c0 0f add $0xf,%eax 80483c4: c1 e8 04 shr $0x4,%eax 80483c7: c1 e0 04 shl $0x4,%eax 80483ca: 89 45 f8 mov %eax,0xfffffff8(%ebp)
printf("&n=%p p=%p/n", &n, p); 80483cd: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 80483d0: 89 44 24 08 mov %eax,0x8(%esp) 80483d4: 8d 45 fc lea 0xfffffffc(%ebp),%eax 80483d7: 89 44 24 04 mov %eax,0x4(%esp) 80483db: c7 04 24 98 84 04 08 movl $0x8048498,(%esp) 80483e2: e8 d1 fe ff ff call 80482b8 <printf@plt> return 0; 80483e7: b8 00 00 00 00 mov $0x0,%eax } |
其中關鍵的一條指令爲：sub $0x410,%esp
由此可以看出實現alloca，僅僅是把ESP減去指定大小，擴大棧空間（記記住棧是向下增長），這塊空間就是分配的內存。
3. 可變參數的實現。
對新手來說，可變參數的函數也是比較神奇。還是以一個小程序來說明它的實現。
| #include <stdio.h> #include <stdarg.h>
int print(const char* fmt, ...) { int n1 = 0; int n2 = 0; int n3 = 0; va_list ap; va_start(ap, fmt);
n1 = va_arg(ap, int); n2 = va_arg(ap, int); n3 = va_arg(ap, int);
va_end(ap);
printf("n1=%d n2=%d n3=%d/n", n1, n2, n3);
return 0; }
int main(int arg, char argv[]) { print("%d/n", 1, 2, 3);
return 0; } |
我們看看對應的彙編代碼：
| int print(const char* fmt, ...) { 8048394: 55 push %ebp 8048395: 89 e5 mov %esp,%ebp 8048397: 83 ec 28 sub $0x28,%esp int n1 = 0; 804839a: c7 45 fc 00 00 00 00 movl $0x0,0xfffffffc(%ebp) int n2 = 0; 80483a1: c7 45 f8 00 00 00 00 movl $0x0,0xfffffff8(%ebp) int n3 = 0; 80483a8: c7 45 f4 00 00 00 00 movl $0x0,0xfffffff4(%ebp) va_list ap; va_start(ap, fmt); 80483af: 8d 45 0c lea 0xc(%ebp),%eax 80483b2: 89 45 f0 mov %eax,0xfffffff0(%ebp)
n1 = va_arg(ap, int); 80483b5: 8b 55 f0 mov 0xfffffff0(%ebp),%edx 80483b8: 8d 45 f0 lea 0xfffffff0(%ebp),%eax 80483bb: 83 00 04 addl $0x4,(%eax) 80483be: 8b 02 mov (%edx),%eax 80483c0: 89 45 fc mov %eax,0xfffffffc(%ebp) n2 = va_arg(ap, int); 80483c3: 8b 55 f0 mov 0xfffffff0(%ebp),%edx 80483c6: 8d 45 f0 lea 0xfffffff0(%ebp),%eax 80483c9: 83 00 04 addl $0x4,(%eax) 80483cc: 8b 02 mov (%edx),%eax 80483ce: 89 45 f8 mov %eax,0xfffffff8(%ebp) n3 = va_arg(ap, int); 80483d1: 8b 55 f0 mov 0xfffffff0(%ebp),%edx 80483d4: 8d 45 f0 lea 0xfffffff0(%ebp),%eax 80483d7: 83 00 04 addl $0x4,(%eax) 80483da: 8b 02 mov (%edx),%eax 80483dc: 89 45 f4 mov %eax,0xfffffff4(%ebp)
va_end(ap); printf("n1=%d n2=%d n3=%d/n", n1, n2, n3); 80483df: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 80483e2: 89 44 24 0c mov %eax,0xc(%esp) 80483e6: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 80483e9: 89 44 24 08 mov %eax,0x8(%esp) 80483ed: 8b 45 fc mov 0xfffffffc(%ebp),%eax 80483f0: 89 44 24 04 mov %eax,0x4(%esp) 80483f4: c7 04 24 f8 84 04 08 movl $0x80484f8,(%esp) 80483fb: e8 b8 fe ff ff call 80482b8 <printf@plt>
return 0; 8048400: b8 00 00 00 00 mov $0x0,%eax } int main(int arg, char argv[]) { 8048407: 55 push %ebp 8048408: 89 e5 mov %esp,%ebp 804840a: 83 ec 18 sub $0x18,%esp 804840d: 83 e4 f0 and $0xfffffff0,%esp 8048410: b8 00 00 00 00 mov $0x0,%eax 8048415: 83 c0 0f add $0xf,%eax 8048418: 83 c0 0f add $0xf,%eax 804841b: c1 e8 04 shr $0x4,%eax 804841e: c1 e0 04 shl $0x4,%eax 8048421: 29 c4 sub %eax,%esp int n = print("%d/n", 1, 2, 3); 8048423: c7 44 24 0c 03 00 00 movl $0x3,0xc(%esp) 804842a: 00 804842b: c7 44 24 08 02 00 00 movl $0x2,0x8(%esp) 8048432: 00 8048433: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 804843a: 00 804843b: c7 04 24 0b 85 04 08 movl $0x804850b,(%esp) 8048442: e8 4d ff ff ff call 8048394 <print> 8048447: 89 45 fc mov %eax,0xfffffffc(%ebp)
return 0; 804844a: b8 00 00 00 00 mov $0x0,%eax } |
從彙編代碼中，我們可以看出，參數是逆序入棧的。在取參數時，先讓ap指向第一個參數，又因爲棧是向下增長的，不斷把指針向上移動就可以取出所有參數了。
l 堆
在內存分配算法一節中再詳細講解。