C语言为什么需要堆栈

Ber_thaw99

最近，看了很多关于uboot的分析，其中就有说要为C语言的运行，就要准备好堆栈。
& y) K2 j: e) W: r5 F% `$ Y
* e0 O4 e6 m; r1 U6 h: g; Y5 a5 |2 D0 A: d, [+ y
而在Uboot的start.S汇编代码中，关于系统初始化，也看到有堆栈指针初始化这个动作。但是，从来只是看到有人说系统初始化要初始化堆栈，即正确给堆栈指针sp赋值，但是却从来没有看到有人解释，为何要初始化堆栈。今天，我们就来试图解释一下，为何要初始化堆栈，即：3 V/ T* b: \: D9 R$ m) }# _# s
+ T3 n6 ]4 I9 g( H7 l' ]+ \; H# h: m/ {/ M) o! ?
7 v' t7 u4 \+ q5 C- A2 C
% `2 @# N2 E( \/ K" Y为何C语言的函数调用要用到堆栈，而汇编却不需要初始化堆栈？
4 }3 X5 `$ t2 e2 U' r& }1 S& [5 d# U) w6 N% K2 G( P, v% ]8 t
* P; ^- j2 h" V( G8 d+ l% i4 g5 |! n, u- ]* M
要明白这个问题，首先要了解堆栈的作用。
: [" c1 e% q& t* ^8 B% d( I; g5 F: T

- [% w0 `# Q1 ^7 K" ?0 B& Q关于堆栈的作用，要详细讲解的话，要很长的篇幅，所以此处只是做简略介绍。

  ]# ~# z9 [) ]7 Y- h0 c% d总的来说，堆栈的作用就是：保存现场/上下文，传递参数。
! p+ c& q0 P2 U% X5 a, ^" s# [

) }0 f; l7 p) b1.保存现场/上下文
1 S7 S& T9 m, U! j$ K& \% b; }现场，意思就相当于案发现场，总有一些现场的情况，要记录下来的，否则被别人破坏掉之后，你就无法恢复现场了。而此处说的现场，就是指CPU运行的时候，用到了一些寄存器，比如r0,r1等等，对于这些寄存器的值，如果你不保存而直接跳转到子函数中去执行，那么很可能就被其破坏了，因为其函数执行也要用到这些寄存器。( P$ W3 y& d9 }& e

/ Y2 |2 ]3 l2 W0 O因此，在函数调用之前，应该将这些寄存器等现场，暂时保持起来，等调用函数执行完毕返回后，再恢复现场。这样CPU就可以正确的继续执行了。

在计算机中，你常可以看到上下文这个词，对应的英文是context。那么：
3 f- L0 a6 K' g* P# Y! {
1.1.什么叫做上下文context
保存现场，也叫保存上下文。4 P/ A; x$ H( V
+ o2 J" c1 X0 J2 I5 Z
$ m* z% C( ^3 E. L; W
上下文，英文叫做context，就是上面的文章，和下面的文章，即与你此刻，当前CPU运行有关系的内容，即那些你用到寄存器。所以，和上面的现场，是一个意思。
9 Z6 B- ~( J, a. b- Q' m) F1 m: Y- Q  T
1 |* E9 L' i4 g1 h( R3 O5 v& l保存寄存器的值，一般用的是push指令，将对应的某些寄存器的值，一个个放到堆栈中，把对应的值压入到堆栈里面，即所谓的压栈。' g7 M; ~' W' J$ N$ b
+ T5 x( P! a' w# h$ k. `9 x  Z9 B& e/ C; |: O# Y3 G# Q4 Y. ~/ T  N
8 u$ A1 {$ q: ]
( I- X3 r1 ]- a! R' T% G然后待被调用的子函数执行完毕的时候，再调用pop，把堆栈中的一个个的值，赋值给对应的那些你刚开始压栈时用到的寄存器，把对应的值从堆栈中弹出去，即所谓的出栈。

其中保存的寄存器中，也包括lr的值（因为用bl指令进行跳转的话，那么之前的pc的值是存在lr中的），然后在子程序执行完毕的时候，再把堆栈中的lr的值pop出来，赋值给pc，这样就实现了子函数的正确的返回。; k6 s! F- y1 D* h2 N
+ W# a, o: d* }8 v+ o
2.传递参数- v: P* A9 {( r3 W8 U1 k- }* X4 L
) r8 R9 }3 L3 W# `0 fC语言进行函数调用的时候，常常会传递给被调用的函数一些参数，对于这些C语言级别的参数，被编译器翻译成汇编语言的时候，就要找个地方存放一下，并且让被调用的函数能够访问，否则就没发实现传递参数了。对于找个地方放一下，分两种情况。2 v0 t" @# h3 C" _" c* y: _
; g; d8 W7 Q5 ~! C/ X* C$ F9 ^, D$ K' g1 ~
一种情况是，本身传递的参数就很少，就可以通过寄存器传送参数。
$ M8 a) i% G' c0 |' F4 P% V0 {9 O; |4 D1 V
因为在前面的保存现场的动作中，已经保存好了对应的寄存器的值，那么此时，这些寄存器就是空闲的，可以供我们使用的了，那就可以放参数，而参数少的情况下，就足够存放参数了，比如参数有2个，那么就用r0和r1存放即可。（关于参数1和参数2，具体哪个放在r0，哪个放在r1，就是和APCS中的“在函数调用之间传递/返回参数”相关了，APCS中会有详细的约定。感兴趣的自己去研究。）; i! J& m" m; w. l; y: W9 J

但是如果参数太多，寄存器不够用，那么就得把多余的参数堆栈中了。8 u, a! w7 c4 N# f' |" S' Z
0 z  \) D# l. N1 V5 h
即，可以用堆栈来传递所有的或寄存器放不下的那些多余的参数。
" T4 `4 p3 o3 Z! s8 e
5 l) F/ ]8 v1 J3.举例分析C语言函数调用是如何使用堆栈的! z* V' k! G, p( y
2 \; }5 z0 K- [! e对于上面的解释的堆栈的作用显得有些抽象，此处再用例子来简单说明一下，就容易明白了：


用:
; r7 ^9 Y% Y( H. T- x* ~
" T- @# g6 |# l% s7 U
  j% i6 ~; K: Z' z* g1 \1. ARM-inux-objdump –d u-boot > dump_u-boot.txt% H+ y' t. O. X. N4 g( N. l
7 T: T4 j7 h7 ]: Z
* c; g7 X" s3 C& r( k: x$ z7 w" X9 ?4 B2 s6 M5 {' S& n
可以得到dump_u-boot.txt文件。该文件就是中，包含了u-boot中的程序的可执行的汇编代码，其中我们可以看到C语言的函数的源代码，到底对应着那些汇编代码。0 ~* S3 D7 L* Z: V" H" \% c" {
3 m$ r: H/ v! G. \! U: v2 W1 l1 y& L# c/ w
( F6 U, o- A8 Z$ C. B  A下面贴出两个函数的汇编代码，7 l/ U7 r3 R; J  U+ b8 \$ u3 p/ [
一个是clock_init，
" j4 N# Z2 M9 |+ L/ S另一个是与clock_init在同一C源文件中的，另外一个函数CopyCode2Ram：; n; n/ f+ d! @' C& G" Q7 R- k1 ]
: Q1 K: J+ `3 P2 w$ ?6 w( o2 t
1. 33d0091c <CopyCode2Ram>:
$ G' h* b& p" S+ Y& O& }. N2. 33d0091c:  e92d4070   push   {r4, r5, r6, lr}
% s9 V2 a. ?! I. K3. 33d00920:  e1a06000   mov r6, r0
4. 33d00924:  e1a05001   mov r5, r1
. H) D* z: F# H) z( \0 O  r% z5. 33d00928:  e1a04002   mov r4, r2
  A5 e$ c! d. H# Y8 {" U) `) _6. 33d0092c:  ebffffef   bl  33d008f0 <bBootFrmNORFlash>
7. ... ...
% r9 F; H; j$ w# ]" k- b8. 33d00984:  ebffff14   bl  33d005dc <nand_read_ll>. e! F3 s5 r) E  Z1 W$ b1 W0 A* p
8 w; H  y# z" F2 L7 E4 s9. ... ...) x6 ]3 K: {+ J1 f) @3 q! v
! ^0 Y  Q" \7 v10. 33d009a8:  e3a00000   mov r0, #0 ; 0x0% C5 a1 o0 R9 \; O% Z
11. 33d009ac:  e8bd8070   pop {r4, r5, r6, pc}# B' E, C4 b5 u& L! [: ^
$ t$ W& `9 J. s9 \4 G, s* V12.  
. a  ?" {& {9 O13. 33d009b0 <clock_init>:. }! u* w2 R7 V9 W3 ~7 R
8 X, [, T  ]- {+ L8 S  r14. 33d009b0:  e3a02313   mov r2, #1275068416   ; 0x4c000000+ y1 H2 a- W6 y4 F; U& c) F
- [3 S* Z% K: N+ _# \- o' S15. 33d009b4:  e3a03005   mov r3, #5 ; 0x5
9 n0 ~5 y6 ]+ r1 S16. 33d009b8:  e5823014   str r3, [r2, #20]4 ?) Z! L1 ]( K! Z$ F4 l
17. ... ...4 v. J% Y1 v# ?+ @4 P# n2 V; [
18. 33d009f8:  e1a0f00e   mov pc, lr
  G5 E, `7 a) S* Z2 G1 s8 U( P
（1）clock_init部分的代码
& H7 s( M- T; ^/ U  a可以看到该函数第一行：4 i; W! N1 s$ F9 F8 ?) I7 j& u3 d; ~

1. 33d009b0:  e3a02313   mov r2, #1275068416   ; 0x4c000000

9 ?& W) t$ j' y$ v) u3 ~; D! h9 }# H
就没有我们所期望的push指令，没有去将一些寄存器的值放到堆栈中。这是因为，我们clock_init这部分的内容，所用到的r2,r3等等寄存器，和前面调用clock_init之前所用到的寄存器r0，没有冲突，所以此处可以不用push去保存这类寄存器的值，不过有个寄存器要注意，那就是r14，即lr，其是在前面调用clock_init的时候，用的是bl指令，所以会自动把跳转时候的pc的值赋值给lr，所以也不需要push指令去将PC的值保存到堆栈中。

2 L' R- |* [. f  o5 M" a8 ?; H1 S: f% y3 m
4 G2 T. S6 ]6 s% ^而clock_init的代码的最后一行:
# p! g' M) ~' X+ e2 n, ?* P6 _' T
% v; G- s2 l  I# ]5 q; |* ^7 b6 c' Y% u9 U' g
' R5 a! i& c) F. S& H- Q' F1. 33d009f8: e1a0f00e mov pc, lr
% }) \$ [7 r+ t8 [+ \7 m  B  t
& @) r) [2 B% P) `; n) W$ |
就是我们常见的mov pc, lr，把lr的值，即之前保存的函数调用时候的PC值，赋值给现在的PC，这样就实现了函数的正确的返回，即返回到了函数调用时候下一个指令的位置。2 P8 O# [3 {% ^  u8 ~/ g( _; I; {

& q. M" _" R  Z
这样CPU就可以继续执行原先函数内剩下那部分的代码了。; x: b! [" s; Z+ Y7 y) F
0 A4 B0 e+ x0 Y  @3 f5 x
+ O) b' }$ N% p. @! w+ M: r4 l* Y2 J
% `! X3 f9 U" A$ w0 z7 R（2）CopyCode2Ram部分的代码
& |' S. Z: G' g7 F* _
- f& _# G1 T6 @) z( F8 _1. 33d0091c: e92d4070 push {r4, r5, r6, lr}
, J4 B5 F8 {8 \, y3 _
- Q# k; i5 [6 b0 o2 R! B
+ t+ I: t1 p$ s  w! u就是我们所期望的，用push指令，保存了r4,r5,r以及lr。用push去保存r4,r5,r6，那是因为所谓的保存现场，以后后续函数返回时候再恢复现场，而用push去保存lr，那是因为此函数里面，还有其他函数调用：


1. 33d0092c:  ebffffef   bl  33d008f0 <bBootFrmNORFlash>" v; ~$ Q) }; z" I5 `
9 U1 ?8 [. K. g  f2. ... ...
( k# P4 J; f, X6 H8 E# x3. 33d00984:  ebffff14   bl  33d005dc <nand_read_ll>* A5 K1 ?" K$ y" r' a
4. ... ...% W+ ?, d  g. h( [0 B3 i: z

3 N3 V8 S2 @% u! C9 O
也用到了bl指令，会改变我们最开始进入clock_init时候的lr的值，所以我们要用push也暂时保存起来。而对应地，CopyCode2Ram的最后一行：

- {% A) u/ D) ], ]1 H, G+ s+ W9 M) z' m9 o* H' }
1. 33d009ac: e8bd8070 pop {r4, r5, r6, pc}

- Z  u. a9 m5 X+ }
: p( v; b' ]0 f, j就是把之前push的值，给pop出来，还给对应的寄存器，其中最后一个是将开始push的lr的值，pop出来给赋给PC，因为实现了函数的返回。另外，我们注意到，在CopyCode2Ram的倒数第二行是：
( t. y! @1 A* A2 o/ P3 E% P0 K. A! E) n; Y# q& D) A% O
8 C- Z1 |8 I) [* n# ~
  @- K' T- e$ l8 g! L6 M. v1. 33d009a8: e3a00000 mov r0, #0 ; 0x05 @/ b+ n7 J" U. B
9 S; O) _  r) g3 Q$ _/ r
2 I+ b& _$ R' T8 l- Y) ?7 {; e$ o& {& b
: ]3 }9 G1 B4 e$ I5 x/ x是把0赋值给r0寄存器，这个就是我们所谓返回值的传递，是通过r0寄存器的。$ _, r# J$ z6 Y- H1 t1 [9 J
2 _1 r) h! X' }, d, _

此处的返回值是0，也对应着C语言的源码中的“return 0”.

& P& C- [  ?# [& V对于使用哪个寄存器来传递返回值：
当然你也可以用其他暂时空闲没有用到的寄存器来传递返回值，但是这些处理方式，本身是根据ARM的APCS的寄存器的使用的约定而设计的，你最好不要随便改变使用方式，最好还是按照其约定的来处理，这样程序更加符合规范。
, u$ N6 t$ ~: p