背景
一下内容是在ubuntu使用gcc自己编译stm32得出的自己的总结，使用keil的时候很多东西，都已经由keil做好了，包括启动文件就是不同的，链接脚本是不需要自己管的。只是为了更加深入的理解整个系统。
) _' E) p; H! ]; g" x
' v* i3 t+ B8 ]3 @, U) _链接脚本
5 ?! d# p6 Z8 j* p+ P8 g编译生成的各个静态库文件.a文件。需要使用链接脚本一起，才可以，链接（重新组织出）出一个，完整有序的，包含所有信息的bin文件。
以下以stm32f407的链接脚本为例

1.设置入口ENTRY
stm32设置的入口即是，中断向量表里的系统复位向量。
  |8 z0 a. G6 o3 x" @

1. 32 /* Entry Point */                                                                                                            
   
2. 33 ENTRY(Reset_Handler)                                                                                                         
   ) I$ _0 `! W/ p
3. 34                                                                                                                              
   
4. 35 /* Highest address of the user mode stack */                                                                                 
   
5. 36 _estack = 0x2001FFFF;    /* end of RAM */                                                                                    
   # z  w/ x" S1 c0 V3 Y7 L/ q! K
6. 37 /* Generate a link error if heap and stack don't fit into RAM */                                                            
   % P( o! E6 l! |$ c( J' `" y# C3 v
7. 38 _Min_Heap_Size = 0x200;;      /* required amount of heap  */                                                                 
   ' b/ b( {& _$ j: h, _  ?1 ?
8. 39 _Min_Stack_Size = 0x400;; /* required amount of stack */  
   3 C$ \" o# F1 i% w% z

复制代码

stm32上电时会做两件事，将0x080000000这个栈顶地址放到，msp寄存器。将第二个地址Reset_Handler赋给，pc指针。这样我们上电debug的时候会发现，单片机第一步就会停留在启动文件里的Reset_Handler哪里。
7 k* b, F" _. ?+ U  t

2.设置MEMORY
, v4 p8 c; F; F- L$ v

1. 37 /* Generate a link error if heap and stack don't fit into RAM */                                                            
   
2. 38 _Min_Heap_Size = 0x200;;      /* required amount of heap  */                                                                 
   
3. 39 _Min_Stack_Size = 0x400;; /* required amount of stack */                                                                     
   - p  W6 P; }4 e% W3 j
4. 40                                                                                                                              
   
5. 41 /* Specify the memory areas */                                                                                               
   
6. 42 MEMORY                                                                                                                       
   
7. 43 {                                                                                                                           
   
8. 44 FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 1024K                                                                        
   8 F- o% a9 |! x! ?. a1 [! l2 M" M
9. 45 RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 128K                                                                          
   
10. 46 CCMRAM (rw)      : ORIGIN = 0x10000000, LENGTH = 64K                                                                        
    ' d0 Z+ S( X) g- `$ A+ R0 a
11. 47 }
    

复制代码

6 v& n) S: `% [0 E" |( A) E. x! \3 B链接脚本基本就分为两个部分，memory和sections。其中memory规定了单片机rom和ram的地址和大小。每种芯片的这一部分的内容应该都是不一样的。


3.设置SECTIONS
# C# V, A+ x2 B8 S" h# p4 p, T接下来主要是看sections这个部分，通过这个部分我们就可以看到整个映像的各个部分的内容是放在哪里的。

1. 52   /* The startup code goes first into FLASH */                                                                              
   6 D# g3 l: @/ R) [4 X1 B
2. 53   .isr_vector :                                                                                                              
   
3. 54   {                                                                                                                          
   
4. 55     . = ALIGN(4);                                                                                                            
   0 a. T" K0 s' U
5. 56     KEEP(*(.isr_vector)) /* Startup code */                                                                                 
   , Y1 Q" X. K1 I$ k6 P) \
6. 57     . = ALIGN(4);                                                                                                            
   
7. 58   } >FLASH  
   % k% T& M% o# f+ p) H# f3 S6 ]

复制代码

; J9 o' c. T  i! L6 F& V第一部分当然是启动文件，其中最重要的就是中断向量表。启动文件里，规定了有哪些中断函数，发生中断时间时，会自动跳转到对应的中断函数，不同的芯片定义的函数是不一样的。
, L( t9 W, z% a! V7 s" A5 O1 R需要注意的是bin文件里面，包含了，代码段，只读数据段，数据段，bss段（未初始化的全局变量，只有bss段的地址大小描述信息，并不真正改变bin文件的大小），堆栈（同样不会真正占用bin文件的大小）等全部信息。这只是加载的镜像文件，真正在执行的时候，并不是所有的文件都是在rom里面执行的。链接脚本会将数据段等，从rom里面拷贝到ram里面执行。

/ N# _+ L: w! }; e& ~放到rom里面的内容
5 S+ X2 C. D) S8 Z) G$ u

1. 60   /* The program code and other data goes into FLASH */                                                                     
   
2. 61   .text :                                                                                                                    
   5 b* f1 w" A5 L0 r+ B6 j
3. 62   {                                                                                                                          
   
4. 63     . = ALIGN(4);                                                                                                            
   
5. 64     *(.text)           /* .text sections (code) */                                                                           
   * c" ^. h% F1 K" U$ B* a+ m
6. 65     *(.text*)          /* .text* sections (code) */                                                                          
   
7. 66     *(.glue_7)         /* glue arm to thumb code */                                                                          
   ! G# Y' K& X; f: F
8. 67     *(.glue_7t)        /* glue thumb to arm code */                                                                          
   & ?( u* \! O- e# t, b1 M7 j. @% W8 X2 y
9. 68     *(.eh_frame)                                                                                                            
   
10. 69                                                                                                                              
    + r  ~. H2 K; v* S; }, e
11. 70     KEEP (*(.init))                                                                                                         
    
12. 71     KEEP (*(.fini))                                                                                                         
    3 h1 E& r" T" g3 q, T
13. 72                                                                                                                              
    
14. 73     . = ALIGN(4);                                                                                                            
    
15. 74     _etext = .;        /* define a global symbols at end of code */                                                         
    
16. 75   } >FLASH
    
17.   77   /* Constant data goes into FLASH */                                                                                       
    ' _2 D( g; X9 \
18. 78   .rodata :                                                                                                                  
    : ~* q" L8 H, c. ?7 }& l
19. 79   {                                                                                                                          
    
20. 80     . = ALIGN(4);                                                                                                            
    
21. 81     *(.rodata)         /* .rodata sections (constants, strings, etc.) */                                                     
    % d1 A0 G% J; l1 C) ^; H- G* U- Z2 p. W
22. 82     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */                                                   
    3 Y# c1 E0 e! I1 ]' u
23. 83     . = ALIGN(4);                                                                                                            
    # Y+ z: V$ k+ Z% ^/ C6 v
24. 84   } >FLASH  
    - p5 W4 I+ h# ~8 z
25. 
    

复制代码

8 Q: n% ?( `- `7 k0 q  ~% L9 r, X* V可以看出放到rom里面的是代码段，和只读的数据段,例如字符串。
- z- E/ H2 W3 C6 c& w5 n# }) A# l
/ Y% z) P- V0 R, K  r, n: `放到ram里面的内容
- T7 ~) }% \9 A* B5 [

1. 117   /* Initialized data sections goes into RAM, load LMA copy after code */
   
2. 118   .data :
   
3. 119   {
   0 n7 j$ a- R% m' ~- P4 l0 a
4. 120     . = ALIGN(4);
   
5. 121     _sdata = .;        /* create a global symbol at data start */
   
6. 122     *(.data)           /* .data sections */
   
7. 123     *(.data*)          /* .data* sections */
   % p- K& r- V- v9 c5 q0 ~
8. 124                                                                                                                              
   
9. 125     . = ALIGN(4);                                                                                                            
   
10. 126     _edata = .;        /* define a global symbol at data end */                                                              
      P. N5 S0 D# Z0 d0 r
11. 127   } >RAM AT> FLASH  
    + O/ }# ~, U% i1 N
12. 
    3 V: N# E" c/ {
13. 151   .bss :                                                            
    $ ^$ ]7 Y+ L/ D
14. 152   {                                                                 
    
15. 153     /* This is used by the startup in order to initialize the .bss s    ecion */                                                            
    2 _7 x* Y6 Q8 \" v5 x3 O
16. 154     _sbss = .;         /* define a global symbol at bss start */   
    
17. 155     __bss_start__ = _sbss;                                          
    ! B( f8 v( g  I5 N
18. 156     *(.bss)                                                         
    / a0 E  ~3 D+ s, I; C# V- d* a" W
19. 157     *(.bss*)
    8 y$ V( u9 _& w& q3 k" K- j! ~1 W( s
20. 158     *(COMMON)
    
21. 159
      M  ~) l; U5 C- b9 M4 `4 p
22. 160     . = ALIGN(4);
    ( i! t; F* P2 u: z' [
23. 161     _ebss = .;         /* define a global symbol at bss end */
    * U* i; ]$ v+ Y* W% [3 f
24. 162     __bss_end__ = _ebss;
    : w/ s  i) [! h2 ^, x- G0 ?' m' E. G- o1 T
25. 163   } >RAM
    
26. 
    

复制代码

- `6 D  M2 U, I
& r- K) k* Y8 H5 C% g! p1 U可以看出来，数据段和bss段最终都是放到ram里面的。
注意：其中>RAM AT>FLASH这个命令告诉连接器，这段内容是需要搬运的，下载地址和实际运行的地址是不一样的。需要从flash复制到ram里面才可以跑的。
. o1 E8 S  R5 [9 U9 g% c
2 W# N) B0 Q# a, ?' K: d以上就是最终编译链接出的bin文件，是如何在单片机里面跑的。整个bin文件都会放到rom里面，包含了许多的信息，最终跑起来的时候会将，数据段从rom里面，拷贝到ram里面去执行。根据bin文件里的信息，也会知道，bss段，堆栈的地址和大小，这样整个系统就可以跑起来了。（切记不是直接放到ram里面的，因为整个bin文件都是放到rom里面的，要在ram里面使用的时候，是需要拷贝的。也就是说加载的和执行的是不一样的）
- R( m2 o; ~' Z  Q/ S
: `7 s4 p2 J* x6 R) Q

* E: R, G# C) ~# T% |) F
8 C9 M* T" k; J$ E& `) o启动文件
在单片机跑到mian函数，应用程序之前的代码就是启动文件的代码。
下面我们来具体分析一下这个里面包含的内容：

1. 143 g_pfnVectors:                                                                                                                                                                       
   
2. 144   .word  _estack                                                                                                                                      
   
3. 145   .word  Reset_Handler                                                                                                                                
   
4. 146   .word  NMI_Handler                                                                                                                                 
   
5. 147   .word  HardFault_Handler                                                                                                                           
   5 I. Z1 X) O4 `0 ^9 H" `4 Q5 I9 S
6. 148   .word  MemManage_Handler                                                                                                                           
   
7. 149   .word  BusFault_Handler                                                                                                                             
   ( n9 Z& q: M) n/ l3 f( F
8. 150   .word  UsageFault_Handler                                                                                                                           
   
9. 151   .word  0                                                                                                                                            
   6 e* o  L/ r5 ~
10. 152   .word  0                                                                                                                                            
    
11. 153   .word  0                                                                                                                                            
    
12. 154   .word  0                                                                                                                                            
    
13. 155   .word  SVC_Handler                                                                                                                                 
    8 G' G) _) k8 m  M7 }7 w$ R
14. 156   .word  DebugMon_Handler                                                                                                                             
    
15. 157   .word  0                                                                                                                                            
    & _) e& r# s( S# _* @
16. 158   .word  PendSV_Handler                                                                                                                              
    9 e" H  h$ k6 m- j
17. 159   .word  SysTick_Handler                                                                                                                              
    
18. 160                                                                                                                                                      
    
19. 161   /* External Interrupts */                                                                                                                           
    1 Y  Q' B9 o* l! a
20. 162   .word     WWDG_IRQHandler                   /* Window WatchDog              */                                                                     
    
21. 163   .word     PVD_IRQHandler                    /* PVD through EXTI Line detection */                                                                  
    
22. 164   .word     TAMP_STAMP_IRQHandler   
    ! V# v- B6 N" p9 H6 V2 M+ z  L5 e
23. ...
    

复制代码

以上可以看出来，flash最开头的地方就是，中断向量表，从地址0x0800000,开始，第一个就是栈顶指针，第二个就是，Reset_Handler，地址0x08000004。系统复位进入Reset_Handler对应的中断函数，接下来我们看一下，中断函数里面有什么。
, ~* P3 m: g& y: D* D

1. 79 Reset_Handler:                                                                                                                                       
   
2. 80   ldr   sp, =_estack     /* set stack pointer */                                                                                                      
   5 b# z! `/ K7 e# P& }% Z
3. 81                                                                                                                                                      
   
4. 82 /* Copy the data segment initializers from flash to SRAM */                                                                                          
   7 P" n* q, ^+ x7 e, `4 I$ f
5. 83   movs  r1, #0                                                                                                                                                                     
   ) |# s" x6 m3 k; I% N6 ^9 i; Y# j
6. 84   b  LoopCopyDataInit                                                                                                                                 
   1 G5 N  }9 p" m" a) q
7. 85                                                                                                                                                      
   
8. 86 CopyDataInit:                                                                                                                                         
   $ M" n; S8 C8 p
9. 87   ldr  r3, =_sidata                                                                                                                                   
   
10. 88   ldr  r3, [r3, r1]                                                                                                                                   
    7 C) Q/ A6 t: ]4 H/ ?6 v1 m2 c
11. 89   str  r3, [r0, r1]                                                                                                                                   
    - |; m* t, E7 H; T- H
12. 90   adds  r1, r1, #4                                                                                                                                    
    % V2 C  R, W& T. @; G- ^6 T  [! c
13. 91                                                                                                                                                      
    - V7 z" E# y  H
14. 92 LoopCopyDataInit:                                                                                                                                    
    
15. 93   ldr  r0, =_sdata                                                                                                                                    
    
16. 94   ldr  r3, =_edata                                                                                                                                    
    3 [7 G% H# `# Z) a7 B+ i: E
17. 95   adds  r2, r0, r1                                                                                                                                    
    , D& b7 L5 ~! ~0 T/ m
18. 96   cmp  r2, r3                                                                                                                                         
    
19. 97   bcc  CopyDataInit                                                                                                                                   
    
20. 98   ldr  r2, =_sbss                                                                                                                                    
    
21. 99   b  LoopFillZerobss                                                                                                                                 
    
22. 100 /* Zero fill the bss segment. */                                                                                                                     
    
23. 101 FillZerobss:                                                                                                                                          
    . {0 T. u& L8 A0 V
24. 102   movs  r3, #0                                                                                                                                       
    4 P  y2 b8 x# K+ o7 ^
25. 103   str  r3, [r2], #4                                                                                                                                   
    
26. 104                                                                                                                                                      
    2 A/ c4 p% T$ Y; [. g! ^
27. 105 LoopFillZerobss:                                                                                                                                      
    
28. 106   ldr  r3, = _ebss                                                                                                                                    
    3 \: W# G/ `1 [% r" r
29. 107   cmp  r2, r3                                                                                                                                         
    
30. 108   bcc  FillZerobss                                                                                                                                    
    3 F% k) y" x) v
31. 109                                                                                                                                                      
    
32. 110 /* Call the clock system intitialization function.*/                                                                                                  
    
33. 111   bl  SystemInit                                                                                                                                      
    
34. 112 /* Call static constructors */                                                                                                                        
    ! S: Y+ e" J2 c6 X, l; f
35. 113 //  bl __libc_init_array                                                                                                                              
    
36. 114 /* Call the application's entry point.*/                                                                                                              
    . H( z5 D0 u  C4 K7 R
37. 115   bl  main                                                                                                                                            
    : j' o" ?% {* `8 Y6 w7 G4 h2 i
38. 116   bx  lr                                                                                                                                             
    
39. 117 .size  Reset_Handler, .-Reset_Handler   
    7 |* L% y3 b" E9 y9 Q8 g* Y

复制代码

% w& k! _, S# v  m/ l7 e+ \怎么样，片子怎么跑起来的是不是非常清晰。
首先设置栈顶指针
拷贝数据段
( t- s7 f1 \% b/ a清bss段
执行函数SystemInit ，初始化系统时钟等等。
跳转到main函数
4 {. c& ~( m+ U5 [& D3 W
5 U# r0 `7 q. {- [: s; V0 `  |IAP远程升级
* U+ ]$ X  L& U4 x/ ^& w8 a1 w8 @中断向量表的重定位（摘自cotex3权威指南）：


& m1 e* X' j3 y# [" p7 q! `! z
8 W5 D2 V0 {# K1 ~2 f1 [. w有了以上的背景知识，其实远程升级是一件很简单的事情。具体思路如下：
( r9 r9 e3 i  X# C9 Y3 V6 |/ x1.有一份iap代码，中断向量表在0x08000000,主要工作就是对升级数据包即app程序的代码，进行接收（也可以在app代码里面接收），校验。并将校验通过的代码写进0x08000000之后的app的地址，最后跳转到该地址。
1 l! o& U# E; w" O/ N4 i2 O9 {2.重新设置app中断向量表地址，设置的地方就在SystemInit 里设置向量偏移寄存器就可以了。这样APP的代码就可以跑起来了。iap的代码不变，可以不断地升级app的代码。
2 p( v& w+ Y8 Z  h! [
值得注意的是：工程里正在使用的只有一份中断向量表，在app中就不会使用iap的中断向量表。系统复位之后，设置的中断向量表没用了。因此每次复位之后都会，执行iap的代码，最终跳转到app。




, C" z& [9 d" R. B实际应用举例
" G' x4 o/ k7 {4 V9 N+ T( P6 hstm32的map文件
( o; I- j/ L  T4 d( `; I1 h7 d某个工程的文件编译出的文件
7 }- Y0 t3 ~# E
3 K! ]* g# x4 c( i7 H
8 j/ _, {- Q1 ?" Q" f" s* L+ p$ g0 n5 a
对应的map文件


1 g( o: ~! Z* E0 X$ x- q" u
可以看出来: 使用的ram的大小 ram = 7728 + 408 = 8136;
根据map文件，计算栈顶指针为：20001ac8 + 1280 = 0x20001fc8; 而 1fc8的大小刚好是8136。
8 ]5 i6 R, W1 f. Z所以实际的运行视图为，依次为：
内存起始地址
全局变量
6 k7 O/ q9 |# \/ f; k2 v: m静态变量
6 R; h+ P, e' L& {$ ~8 k, |1 g堆
堆内容
6 c' F3 X3 N8 O: H. o  z# b栈内容
栈
7 l, D' Y( z& h内存结束地址

0 U, }$ G8 B. g& |( l0 }( T可以看出来，堆的生长方向为，由小达大
* y6 [8 ]/ u1 Q0 ]栈的生长方向为，由大到小。
- \. }' H- p$ [4 P+ W  m————————————————
& m* y- J( _' B版权声明：raoxu_1154492168
如有侵权请联系删除
7 q6 U$ ~8 `  p" N
, _: e3 K$ |0 D- O


, a+ n- G( b$ r9 a% x6 j