重學計算機組成原理（六）- 函式呼叫怎麼突然Stack Overflow了!
用Google搜異常資訊，肯定都訪問過Stack Overflow網站
全球最大的程式設計師問答網站，名字來自於一個常見的報錯，就是棧溢位（stack overflow）
從函式呼叫開始，在計算機指令層面函式間的相互呼叫是怎麼實現的，以及什麼情況下會發生棧溢位
1 棧的意義
先看一個簡單的C程式
- function.c
- 直接在Linux中使用GCC編譯執行
[hadoop@JavaEdge Documents]$ vim function.c [hadoop@JavaEdge Documents]$ gcc -g -c function.c [hadoop@JavaEdge Documents]$ objdump -d -M intel -S function.o function.o: file format elf64-x86-64 Disassembly of section .text: 0000000000000000 <add>: #include <stdio.h> int static add(int a, int b) { 0: 55 push rbp 1: 48 89 e5 mov rbp,rsp 4: 89 7d fc mov DWORD PTR [rbp-0x4],edi 7: 89 75 f8 mov DWORD PTR [rbp-0x8],esi a: 8b 45 f8 mov eax,DWORD PTR [rbp-0x8] d: 8b 55 fc mov edx,DWORD PTR [rbp-0x4] 10: 01 d0 add eax,edx 12: 5d pop rbp 13: c3 ret 0000000000000014 <main>: return a+b; } int main() { 14: 55 push rbp 15: 48 89 e5 mov rbp,rsp 18: 48 83 ec 10 sub rsp,0x10 int x = 5; 1c: c7 45 fc 05 00 00 00 mov DWORD PTR [rbp-0x4],0x5 int y = 10; 23: c7 45 f8 0a 00 00 00 mov DWORD PTR [rbp-0x8],0xa int u = add(x, y); 2a: 8b 55 f8 mov edx,DWORD PTR [rbp-0x8] 2d: 8b 45 fc mov eax,DWORD PTR [rbp-0x4] 30: 89 d6 mov esi,edx 32: 89 c7 mov edi,eax 34: e8 c7 ff ff ff call 0 <add> 39: 89 45 f4 mov DWORD PTR [rbp-0xc],eax return 0; 3c: b8 00 00 00 00 mov eax,0x0 } 41: c9 leave 42: c3 ret
main函式和上一節我們講的的程式執行區別不大,主要是把jump指令換成了函式呼叫的call指令,call指令後面跟著的，仍然是跳轉後的程式地址
看看add函式
add函式編譯後，程式碼先執行了一條push指令和一條mov指令
在函式執行結束的時候，又執行了一條pop和一條ret指令
這四條指令的執行，其實就是在進行我們接下來要講壓棧（Push）和出棧（Pop）
函式呼叫和上一節我們講的if…else和for/while迴圈有點像
都是在原來順序執行的指令過程裡，執行了一個記憶體地址的跳轉指令，讓指令從原來順序執行的過程裡跳開，從新的跳轉後的位置開始執行。
但是，這兩個跳轉有個區別
- if…else和for/while的跳轉，是跳轉走了就不再回來了，就在跳轉後的新地址開始順序地執行指令，後會無期
- 函式呼叫的跳轉，在對應函式的指令執行完了之後，還要再回到函式呼叫的地方，繼續執行call之後的指令，地球畢竟是圓的
有沒有一個可以不跳回原來開始的地方,從而實現函式的呼叫呢
似乎有.可以把呼叫的函式指令，直接插入在呼叫函式的地方，替換掉對應的call指令，然後在編譯器編譯程式碼的時候，直接就把函式呼叫變成對應的指令替換掉。
不過思考一下，你會發現漏洞
如果函式A呼叫了函式B，然後函式B再呼叫函式A，我們就得面臨在A裡面插入B的指令，然後在B裡面插入A的指令，這樣就會產生無窮無盡地替換。
就好像兩面鏡子面對面放在一塊兒，任何一面鏡子裡面都會看到無窮多面鏡子
Infinite Mirror Effect
如果函式A呼叫B，B再呼叫A，那麼程式碼會無限展開
那就換一個思路，能不能把後面要跳回來執行的指令地址給記錄下來呢？
就像PC暫存器一樣，可以專門設立一個“程式呼叫暫存器”，儲存接下來要跳轉回來執行的指令地址
等到函式呼叫結束，從這個暫存器裡取出地址，再跳轉到這個記錄的地址，繼續執行就好了。
但在多層函式呼叫裡，只記錄一個地址是不夠的
在呼叫函式A之後，A還可以呼叫函式B，B還能呼叫函式C
這一層又一層的呼叫並沒有數量上的限制
在所有函式呼叫返回之前，每一次呼叫的返回地址都要記錄下來，但是我們CPU裡的暫存器數量並不多
像我們一般使用的Intel i7 CPU只有16個64位暫存器，呼叫的層數一多就存不下了。
最終，CSer們想到了一個比單獨記錄跳轉回來的地址更完善的辦法
在記憶體裡面開闢一段空間，用棧這個後進先出（LIFO，Last In First Out）的資料結構
棧就像一個乒乓球桶，每次程式呼叫函式之前，我們都把呼叫返回後的地址寫在一個乒乓球上，然後塞進這個球桶
這個操作其實就是我們常說的壓棧。如果函式執行完了，我們就從球桶裡取出最上面的那個乒乓球，很顯然，這就是出棧。
拿到出棧的乒乓球，找到上面的地址，把程式跳轉過去，就返回到了函式呼叫後的下一條指令了
如果函式A在執行完成之前又呼叫了函式B，那麼在取出乒乓球之前，我們需要往球桶裡塞一個乒乓球。而我們從球桶最上面拿乒乓球的時候，拿的也一定是最近一次的，也就是最下面一層的函式呼叫完成後的地址
乒乓球桶的底部，就是棧底，最上面的乒乓球所在的位置，就是棧頂
壓棧的不只有函式呼叫完成後的返回地址
比如函式A在呼叫B的時候，需要傳輸一些引數資料，這些引數資料在暫存器不夠用的時候也會被壓入棧中
整個函式A所佔用的所有記憶體空間，就是函式A的棧幀（Stack Frame）
Frame在中文裡也有“相框”的意思，所以，每次到這裡，都有種感覺，整個函式A所需要的記憶體空間就像是被這麼一個“相框”給框了起來，放在了棧裡面。
而實際的程式棧佈局，頂和底與我們的乒乓球桶相比是倒過來的
底在最上面，頂在最下面，這樣的佈局是因為棧底的記憶體地址是在一開始就固定的。而一層層壓棧之後，棧頂的記憶體地址是在逐漸變小而不是變大
對應上面函式add的彙編程式碼，我們來仔細看看，main函式呼叫add函式時
- add函式入口在0～1行
- add函式結束之後在12～13行
在呼叫第34行的call指令時，會把當前的PC暫存器裡的下一條指令的地址壓棧，保留函式呼叫結束後要執行的指令地址
- 而add函式的第0行，push rbp指令，就是在壓棧
這裡的rbp又叫棧幀指標（Frame Pointer），存放了當前棧幀位置的暫存器。push rbp就把之前呼叫函式，也就是main函式的棧幀的棧底地址，壓到棧頂。 - 第1行的一條命令mov rbp, rsp，則是把rsp這個棧指標（Stack Pointer）的值複製到rbp裡，而rsp始終會指向棧頂
這個命令意味著，rbp這個棧幀指標指向的地址，變成當前最新的棧頂，也就是add函式的棧幀的棧底地址了。 - 在函式add執行完成之後，又會分別呼叫第12行的pop rbp
將當前的棧頂出棧,這部分操作維護好了我們整個棧幀 - 然後呼叫第13行的ret指令，這時候同時要把call呼叫的時候壓入的PC暫存器裡的下一條指令出棧，更新到PC暫存器中，將程式的控制權返回到出棧後的棧頂。
2 構造Stack Overflow
通過引入棧，我們可以看到，無論有多少層的函式呼叫，或者在函式A裡呼叫函式B，再在函式B裡呼叫A
這樣的遞迴呼叫，我們都只需要通過維持rbp和rsp，這兩個維護棧頂所在地址的暫存器，就能管理好不同函式之間的跳轉
不過，棧的大小也是有限的。如果函式呼叫層數太多，我們往棧裡壓入它存不下的內容，程式在執行的過程中就會遇到棧溢位的錯誤，這就是stack overflow
構造一個棧溢位的錯誤
並不困難，最簡單的辦法，就是我們上面說的Infiinite Mirror Effect的方式，讓函式A呼叫自己，並且不設任何終止條件
這樣一個無限遞迴的程式，在不斷地壓棧過程中，將整個棧空間填滿，並最終遇上stack overflow。
int a()
{
return a();
}
int main()
{
a();
return 0;
}除了無限遞迴，遞迴層數過深，在棧空間裡面建立非常佔記憶體的變數（比如一個巨大的陣列），這些情況都很可能給你帶來stack overflow
相信你理解了棧在程式執行的過程裡面是怎麼回事，未來在遇到stackoverflow這個錯誤的時候，不會完全沒有方向了。
3 利用函式內聯實現效能優化
上面我們提到一個方法，把一個實際呼叫的函式產生的指令，直接插入到的位置，來替換對應的函式呼叫指令。儘管這個通用的函式呼叫方案，被我們否決了，但是如果被呼叫的函式裡，沒有呼叫其他函式，這個方法還是可以行得通的。
事實上，這就是一個常見的編譯器進行自動優化的場景，我們通常叫函式內聯(Inline)
只要在GCC編譯的時候，加上對應的一個讓編譯器自動優化的引數-O，編譯器就會在可行的情況下，進行這樣的指令替換。
- 案例
為了避免編譯器優化掉太多程式碼，小小修改了一下function.c，讓引數x和y都變成了，通過隨機數生成，並在程式碼的最後加上將u通過printf列印
[hadoop@JavaEdge Documents]$ vim function.c
[hadoop@JavaEdge Documents]$ gcc -g -c -O function.c
[hadoop@JavaEdge Documents]$ objdump -d -M intel -S function.o
function.o: file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <main>:
{
return a+b;
}
int main()
{
0: 53 push rbx
1: bf 00 00 00 00 mov edi,0x0
6: e8 00 00 00 00 call b <main+0xb>
b: 89 c7 mov edi,eax
d: e8 00 00 00 00 call 12 <main+0x12>
12: e8 00 00 00 00 call 17 <main+0x17>
17: 89 c3 mov ebx,eax
19: e8 00 00 00 00 call 1e <main+0x1e>
1e: 89 c1 mov ecx,eax
20: bf 67 66 66 66 mov edi,0x66666667
25: 89 d8 mov eax,ebx
27: f7 ef imul edi
29: d1 fa sar edx,1
2b: 89 d8 mov eax,ebx
2d: c1 f8 1f sar eax,0x1f
30: 29 c2 sub edx,eax
32: 8d 04 92 lea eax,[rdx+rdx*4]
35: 29 c3 sub ebx,eax
37: 89 c8 mov eax,ecx
39: f7 ef imul edi
3b: c1 fa 02 sar edx,0x2
3e: 89 d7 mov edi,edx
40: 89 c8 mov eax,ecx
42: c1 f8 1f sar eax,0x1f
45: 29 c7 sub edi,eax
47: 8d 04 bf lea eax,[rdi+rdi*4]
4a: 01 c0 add eax,eax
4c: 29 c1 sub ecx,eax
#include <time.h>
#include <stdlib.h>
int static add(int a, int b)
{
return a+b;
4e: 8d 34 0b lea esi,[rbx+rcx*1]
{
srand(time(NULL));
int x = rand() % 5;
int y = rand() % 10;
int u = add(x, y);
printf("u = %d\n", u);
51: bf 00 00 00 00 mov edi,0x0
56: b8 00 00 00 00 mov eax,0x0
5b: e8 00 00 00 00 call 60 <main+0x60>
60: b8 00 00 00 00 mov eax,0x0
65: 5b pop rbx
66: c3 ret 上面的function.c的編譯出來的彙編程式碼，沒有把add函式單獨編譯成一段指令順序，而是在呼叫u = add(x, y)的時候，直接替換成了一個add指令。
除了依靠編譯器的自動優化，你還可以在定義函式的地方，加上inline的關鍵字，來提示編譯器對函式進行內聯。
內聯帶來的優化是，CPU需要執行的指令數變少了，根據地址跳轉的過程不需要了，壓棧和出棧的過程也不用了。
不過內聯並不是沒有代價，內聯意味著，我們把可以複用的程式指令在呼叫它的地方完全展開了。如果一個函式在很多地方都被呼叫了，那麼就會展開很多次，整個程式佔用的空間就會變大了。
這樣沒有呼叫其他函式，只會被呼叫的函式，我們一般稱之為葉子函式（或葉子過程）
3 總結
這一節，我們講了一個程式的函式間呼叫，在CPU指令層面是怎麼執行的。其中一定需要你牢記的，就是程式棧這個新概念。
我們可以方便地通過壓棧和出棧操作，使得程式在不同的函式呼叫過程中進行轉移。而函式內聯和棧溢位，一個是我們常常可以選擇的優化方案，另一個則是我們會常遇到的程式Bug。
通過加入了程式棧，我們相當於在指令跳轉的過程種，加入了一個“記憶”的功能，能在跳轉去執行新的指令之後，再回到跳出去的位置，能夠實現更加豐富和靈活的指令執行流程。這個也為我們在程式開發的過程中，提供了“函式”這樣一個抽象，使得我們在軟體開發的過程中，可以複用程式碼和指令，而不是隻能簡單粗暴地複製、貼上程式碼和指令。
4 推薦閱讀
可以仔細讀一下《深入理解計算機系統（第三版）》的3.7小節《過程》，進一步瞭解函式呼叫是怎麼回事。
另外，我推薦你花一點時間，通過搜尋引擎搞清楚function.c每一行彙編程式碼的含義，這個能夠幫你進一步深入瞭解程式棧、棧幀、暫存器以及Intel CPU的指令集。
參考
深入淺出計算機組成原