看一個例子：

void FuncA()
{
}

void FuncB()
{
    FuncA();
}

int main()
{
    FuncB();
    return 0;
}

用下面命令編譯出它釋出版本：

[[email protected] 1]$ g++  -o xuzhina_dump_c3_s1_relxuzhina_dump_c3_s1.cpp

在討論它們的棧之前，先分析一下main，FuncB，FuncA這三個函式的彙編：

(gdb) disassemble FuncA
Dump of assembler code for function_Z5FuncAv:
  0x08048470 <+0>:    push   %ebp
  0x08048471 <+1>:    mov    %esp,%ebp
  0x08048473 <+3>:    pop    %ebp
  0x08048474 <+4>:    ret   
End of assembler dump.
 

(gdb) disassemble FuncB
Dump of assembler code for function_Z5FuncBv:
  0x08048475 <+0>:    push   %ebp
  0x08048476 <+1>:    mov    %esp,%ebp
  0x08048478 <+3>:    call   0x8048470 <_Z5FuncAv>
  0x0804847d <+8>:    pop    %ebp
  0x0804847e <+9>:    ret   
End of assembler dump.

(gdb) disassemble main
Dump of assembler code for function main:
  0x0804847f <+0>:    push   %ebp
  0x08048480 <+1>:    mov    %esp,%ebp
  0x08048482 <+3>:    call   0x8048475 <_Z5FuncBv>
  0x08048487 <+8>:    mov    $0x0,%eax
  0x0804848c <+13>:   pop    %ebp
  0x0804848d <+14>:   ret   
End of assembler dump.
 

從它們的彙編，都可以看到在這三個函式的開頭，都有這樣的指令：

push  %ebp
mov   %esp,%ebp

而在它們的結尾則有這樣的指令：

pop   %ebp
ret   

在沒有使用gcc的-fomit-frame-pointer選項來編譯的函式一般都會有這樣的開頭和結尾。這幾行指令可以看作是函式的開頭和結尾的特徵。像FuncA這樣空葉子函式，一般就是由這兩個特徵拼起來的。

在x86裡，ebp存放著函式楨指標，而esp則指向當前棧頂位置，而eip則是要執行的下一條指令地址。

所以，函式開頭的兩條指令的含義如下

push  %ebp             // esp = esp – 4，把ebp的值放入到esp指向的地址
mov   %esp,%ebp        // 把esp的值放到ebp裡。即ebp = esp
 

函式結尾兩條指令的含義如下

pop   %ebp                      // 把esp指向地址的內容放到ebp， esp ＝ esp+4
ret                             //把ebp指向地址下一個單元的內容放到eip，esp ＝ esp + 4

下面驗證一下上面的內容。在main函式的開頭指令地址0x0804847f打斷點

(gdb) tbreak *0x0804847f
Temporary breakpoint 1 at 0x804847f

逐步地看一下是不是

(gdb) r
Starting program:/home/buckxu/work/3/1/xuzhina_dump_c3_s1_rel
 
Temporary breakpoint 1, 0x0804847f in main()
(gdb) i r ebp esp
ebp            0x0      0x0
esp            0xbffff4dc       0xbffff4dc
(gdb) x /4x $esp
0xbffff4dc:     0x4a8bf635      0x00000001      0xbffff574      0xbffff57c
(gdb) ni
0x08048480 in main ()
(gdb) i r ebp esp
ebp            0x0      0x0
esp            0xbffff4d8       0xbffff4d8
(gdb) x /4x $esp
0xbffff4d8:     0x00000000      0x4a8bf635      0x00000001      0xbffff574

果然，在運行了

push  %ebp

之後，esp的值由0xbffff4dc變為0xbffff4d8，而它所指向的單元剛好是ebp的值0。這一操作實質是把舊的函式楨指標儲存到棧裡。

再繼續執行下去

(gdb) ni
0x08048482 in main ()
(gdb) i r ebp esp
ebp            0xbffff4d8       0xbffff4d8
esp            0xbffff4d8       0xbffff4d8
(gdb) x /4x $esp
0xbffff4d8:     0x00000000      0x4a8bf635      0x00000001      0xbffff574

可見

mov   %esp,%ebp

確實是把esp的值賦給了ebp，這一操作實質是設定函式楨指標，新的函式楨指標所指向的地址剛好放著舊的函式楨指標。

那為什麼要設定函式楨呢？只是考察了main函式，並不一定能夠找到規律，繼續執行FuncB，FuncA，看一下能不能找到規律。

(gdb) si
0x08048475 in FuncB() ()
(gdb) i r esp ebp
esp            0xbffff4d4       0xbffff4d4
ebp            0xbffff4d8       0xbffff4d8
(gdb) x /4x $esp
0xbffff4d4:     0x08048487      0x00000000      0x4a8bf635      0x00000001

只是進入了FuncB,沒有進行任何操作，esp的值卻比ebp要小4個位元組，變為0xbffff4d4,而0xbffff4d4地址卻放入一個值0x08048487,正好是

  0x08048482 <+3>:    call   0x8048475 <_Z5FuncBv>

的下一條指令的地址：

   0x08048487 <+8>:     mov   $0x0,%eax

這是由於main函式使用call指令呼叫FuncB時，call指令把0x08048487壓入棧的。這個地址實際上就是main函式的返回地址。

繼續執行

(gdb) ni
0x08048476 in FuncB() ()
(gdb) ni         
0x08048478 in FuncB() ()
(gdb) i r ebp esp
ebp            0xbffff4d0       0xbffff4d0
esp            0xbffff4d0       0xbffff4d0
(gdb) i r eip
eip            0x8048478        0x8048478 <FuncB()+3>
(gdb) x /4x $esp
0xbffff4d0:     0xbffff4d8      0x08048487      0x00000000      0x4a8bf635
(gdb) x /4x 0xbffff4d8
0xbffff4d8:     0x00000000      0x4a8bf635      0x00000001      0xbffff574

從上面可以看到，函式楨指標可能是一種單鏈表關係，它的表頭指標由ebp來放置。用C/C++語言方式表示，則是

struct  FramePointer
{
       struct  FramePointer* next;
};

它是不是一種連結串列關係呢？繼續執行到FuncA。

(gdb) tbreak FuncA
Temporary breakpoint 2 at 0x8048473
(gdb) c
Continuing.
 
Temporary breakpoint 2, 0x08048473 inFuncA() ()
(gdb) i r ebp esp
ebp            0xbffff4c8       0xbffff4c8
esp            0xbffff4c8       0xbffff4c8
(gdb) x /4x $ebp
0xbffff4c8:     0xbffff4d0      0x0804847d      0xbffff4d8      0x08048487
(gdb) x /4x 0xbffff4d0
0xbffff4d0:     0xbffff4d8      0x08048487      0x00000000      0x4a8bf635
(gdb) x /4x 0xbffff4d8
0xbffff4d8:     0x00000000      0x4a8bf635      0x00000001      0xbffff574

可見函式楨指標確實如上面structFramePointer,是由ebp為表頭。而且考察每個在棧裡的函式楨指標的下一個單元內容和eip的值，會發現這樣的情況：

(gdb) i r eip
eip            0x8048473        0x8048473 <FuncA()+3>
(gdb) info symbol 0x0804847d
FuncB() + 8 in section .text of/home/buckxu/work/3/1/xuzhina_dump_c3_s1_rel
(gdb) info symbol 0x08048487
main + 8 in section .text of/home/buckxu/work/3/1/xuzhina_dump_c3_s1_rel

正好和棧的內容一致：

(gdb) bt
#0  0x08048473 in FuncA() ()
#1  0x0804847d in FuncB() ()
#2  0x08048487 in main ()

所以，函式楨指標的結構擴充套件如下：

struct FramePointer
{
       struct FramePointer* next;
       void*  ret;               //返回地址
};

用圖形表示的話，如下：

gdb也是根據這個規律來解析棧，才能夠顯示正確的棧。那麼不正確的棧是怎樣的呢？

在瞭解這個問題之前，先考察一下函式結尾的特徵指令

pop   %ebp                      // 把esp指向地址的內容放到ebp， esp ＝ esp+4
ret                             //把ebp指向地址下一個單元的內容放到eip， esp ＝ esp + 4

由於現在程式已經執行到FuncA，看一下執行完FuncA，ebp，eip，esp的值是不是真的這樣變化：

(gdb) x /4x $ebp
0xbffff4c8:     0xbffff4d0     0x0804847d      0xbffff4d8      0x08048487
(gdb) i r eip esp ebp
eip            0x8048473        0x8048473 <FuncA()+3>
esp            0xbffff4c8       0xbffff4c8
ebp            0xbffff4c8       0xbffff4c8
(gdb) ni
0x08048474 in FuncA() ()
(gdb) ni
0x0804847d in FuncB() ()
(gdb) i r eip esp ebp
eip            0x804847d        0x804847d <FuncB()+8>
esp            0xbffff4d0       0xbffff4d0
ebp            0xbffff4d0       0xbffff4d0

果然ebp，esp，eip的變化在意料之中。

現在來仔細考察一下函式結尾的特徵指令，pop %ebp是把棧頂的內容放入ebp。如果棧頂的內容被修改了，指向一個非法的位置，結果會怎樣？

在這裡，重新跑一下程式，在FuncA退出前，修改一下棧的內容。

(gdb) tbreak FuncA
Temporary breakpoint 1 at 0x8048473
(gdb) r
Starting program:/home/buckxu/work/3/1/xuzhina_dump_c3_s1_rel
 
Temporary breakpoint 1, 0x08048473 inFuncA() ()
 (gdb) bt
#0  0x08048473 in FuncA() ()
#1  0x0804847d in FuncB() ()
#2  0x08048487 in main ()
(gdb) i r ebp eip esp
ebp            0xbffff4c8       0xbffff4c8
eip            0x8048473        0x8048473 <FuncA()+3>
esp            0xbffff4c8       0xbffff4c8
(gdb) x /4x $esp
0xbffff4c8:     0xbffff4d0      0x0804847d      0xbffff4d8      0x08048487
(gdb) set *0xbffff4c8 =0x10
(gdb) ni
0x08048474 in FuncA() ()
(gdb) i r ebp eip esp
ebp            0x10     0x10
eip            0x8048474        0x8048474 <FuncA()+4>
esp            0xbffff4cc       0xbffff4cc
(gdb) ni
Cannot access memory ataddress 0x14
(gdb) bt
#0  0x0804847d in FuncB() ()
Cannot access memory ataddress 0x14
(gdb) c
Continuing.
[Inferior 1 (process 1178) exited normally]

可以看到，gdb只能解析出FuncB函式楨，而無法解析出楨main函式楨，只因為FuncB的返回地址沒有被修改。

再看一下函式結尾的第二條指令，ret是把esp所指向的內容放到eip裡。假如esp所指向的內容是非法，棧又會變成怎樣？

在重新考察一下這個程式，但這次是修改esp+4那個單元的內容。

(gdb) tbreak FuncA
Temporary breakpoint 1 at 0x8048473
(gdb) r
Starting program: /home/buckxu/work/3/1/xuzhina_dump_c3_s1_rel
 
Temporary breakpoint 1, 0x08048473 inFuncA() ()
(gdb) bt
#0  0x08048473 in FuncA() ()
#1  0x0804847d in FuncB() ()
#2  0x08048487 in main ()
(gdb) i r eip esp ebp
eip            0x8048473        0x8048473 <FuncA()+3>
esp            0xbffff4c8       0xbffff4c8
ebp            0xbffff4c8       0xbffff4c8
(gdb) x /4x $esp
0xbffff4c8:     0xbffff4d0      0x0804847d      0xbffff4d8      0x08048487
(gdb) set *0xbffff4cc= 0x10
(gdb) ni
0x08048474 in FuncA() ()
(gdb) ni
0x00000010 in ?? ()
(gdb) bt
#0  0x00000010 in ?? ()
#1  0xbffff4d8 in ?? ()
#2  0x08048487 in main ()
(gdb) c
Continuing.
 
Program received signalSIGSEGV, Segmentation fault.
0x00000010 in ?? ()
(gdb) bt
#0  0x00000010 in ?? ()
#1  0xbffff4d8 in ?? ()
#2  0x08048487 in main ()
 

可以看到，出現了“？？”的棧，這也是因為函式的返回地址被修改的原因。那麼，存放在棧上的函式楨指標和返回地址都被修改了，棧又會變成怎樣？

(gdb) tbreak FuncA
Temporary breakpoint 1 at 0x8048473
(gdb) r
Starting program:/home/buckxu/work/3/1/xuzhina_dump_c3_s1_rel
 
Temporary breakpoint 1, 0x08048473 inFuncA() ()
(gdb) bt
#0  0x08048473 in FuncA() ()
#1  0x0804847d in FuncB() ()
#2  0x08048487 in main ()
(gdb) i r eip esp ebp
eip            0x8048473        0x8048473 <FuncA()+3>
esp            0xbffff4c8       0xbffff4c8
ebp            0xbffff4c8       0xbffff4c8
(gdb) x /4x $esp
0xbffff4c8:     0xbffff4d0      0x0804847d      0xbffff4d8      0x08048487
(gdb) set *0xbffff4c8= 0x10
(gdb) set *0xbffff4cc= 0x20
(gdb) ni
0x08048474 in FuncA() ()
(gdb) ni
0x00000020 in ?? ()
(gdb) i r eip esp ebp           
eip            0x20     0x20
esp            0xbffff4d0       0xbffff4d0
ebp            0x10     0x10
(gdb) x /4x $esp           
0xbffff4d0:     0xbffff4d8      0x08048487      0x00000000      0x4a8bf635
(gdb) bt
#0  0x00000020 in ?? ()
#1  0xbffff4d8 in ?? ()
Backtrace stopped:previous frame inner to this frame (corrupt stack?)
(gdb) c
Continuing.
 
Program received signalSIGSEGV, Segmentation fault.
0x00000020 in ?? ()
(gdb) bt
#0  0x00000020 in ?? ()
#1  0xbffff4d8 in ?? ()
Backtrace stopped: previous frame inner tothis frame (corrupt stack?)
 

可以看到，這正好是前言看到那種的棧。現在可以知道，之後會出現“？？“的棧，是因為存在棧上的函式楨指標和返回地址被修改了。在實際開發過程中，往往會由於拷貝記憶體導致這種情況。這種情況叫做棧溢位。

在這一章的最後一節“coredump例子“會顯示怎樣恢復部分正常的棧。而為什麼記憶體拷貝之類的操作會導致棧溢位，原因會放在第5章裡講述。