一、      keil MDK运行时库分析

* Z( ?. q+ r5 X' ~* N# e, [) @0 a! x" `

& |5 o- O+ S* l

一、目的：
7 d+ S8 ?. M; v9 t5 g  通过分析编译出来的执行文件的执行流程，了解C运行库所做的工作，加深对编译器、可执行文件装载映像组成、内存执行映像组成和初始化工作。
; h. j7 w0 r! T& O3 o二、步骤
01、选择一个STM32的MDK工程，设置为在模拟仿真器上调试的方式，编译、进入调试模式。
02、第一条指令：是向量表中复位向量所指向的地址对应的指令。执行第一条指令时，MSP已经初始化为一个值0x2000，04A0，Thread模式。
9 c" L2 C2 S! J* c% {' G" t     这里是  LDR  R0, =__main
             BX   R0  __main是C运行时库的入口，只要用户程序包含main函数，则编译器利用此段代码完成以下工作（将可执行文件的部分代码、全局已初始化数据从装载视图转移到执行视图-复制-主要是执行文件中RW部分，然后进行ZI部分执行视图的建立-清零，接着建立全局堆栈，进行库的初始化工作），然后跳入用户的main程序运行。
    仔细看一下汇编代码部分，可以看到__main函数前面就是向量表（从0x0800，0000开始），此时系统的0x0地址是映射到该flash地址的。
    ResetHandler的地址是0x0800,0164，而在向量表相应位置是0165，0800，小端模式的特征，并且采用Thumb模式。
    向量表总共是59项，0x3B*4=0xec，所以__main函数的起始地址正好是0x0800,00ec。
    在地址0x0800,0164处执行代码：LDR  R0, =__main对应的汇编代码为LDR R0,[PC,#32]，所以__main的地址是经过链接器定位的，具体地址写在下面的一个地址中（0x0800,0188),这用做的好处是什么呢？如果程序中有多处用到__main的地址，则都可以使用相对地址指令，而在最终定位时，只要在该地址写入最终的地址值。
    接下来BX R0跳转到__main执行。
+ w1 Y- \' v: g; \7 ^    问题：（1）SP的初始值为什么是0x2000,04a0,首先RW的起始地址0x2000,0000链接器是知道的，堆栈的大小在.s文件中定义为0x400,估计该程序的全局变量共占据的空间大小为0xa0。
3 {' g" }$ p( G; N6 \   （2）此时装载视图的具体数据可以从哪里获得？即RO部分的大小和结束地址，RW部分的大小和结束地址，ZI有多大？链接器肯定把这个数据写在了某个地方，猜测为地址0x0800,0188那块区域，就是刚刚放__main地址的地方。
  ]% ~8 c5 o- J1 a' f; V- ?5 t; k   （3）在链接映像文件得到以下数据：
  装载映像：Base: 0x08000000, Size: 0x00002db4
  执行映像：Base: 0x08000000, Size: 0x00002d94；该区域为代码和RO DATA。
1 \) o. s+ j. [) K" b% H  Base: 0x20000000, Size: 0x000004a0；其中RW DATA只有0x20大小，bss大小为0x80,堆栈大小为0x400。
# G" _* g" I# U1 @4 y  J  那么应该复制的数据在：0x0800 2d94到2db4.
1 b7 ]# ~) D5 g- |3、_main区域
: O, s7 P0 w( p# W1 {  N   有两条指令：  0x080000EC F000F802  BL.W     __scatterload_rt2_thumb_only (0x080000F4) 和         0x080000F0 F001FB65  BL.W     __rt_entry (0x080017BE)
   先进入前面那个子程序，可以从字面推测为thumb模式下的分散加载程序。
. ~9 y& |/ h/ z4、在__scatterload_rt2_thumb_only中
! A; q& p' t% _. k0 @+ D+ l   接下来在使得R10=0x2ca0然后变成 0x0800，2dc0,R11=0x2cc0然后变成 0x0800,2de0.
R7=R10-1.
5、接下来进入__scatterload_null
/ v) t4 V2 h5 K2 j6 ~/ x# d   先比较R10和R11,不相等则执行BNE 0x0800010A
" k+ }5 ?6 P, L9 r* S处的指令。相等则BL.W __rt_entry (0x080017BE)跳入运行时库的入口执行。
6.在0x0800010A的代码
. M0 [& r/ B9 O* p$ I0x0800010A F2AF0E09  ADR.W    lr,{pc}-0x07  ; @0x08000103，该处就是__scatterload_null,可以说先设置了返回地址。
' Q' }& R/ Y# k$ P, q  L. @0x0800010E E8BA000F  LDM      r10!,{r0-r3}；该处指令读入0x0800,2dc0处的数据，并且R10变为0x0800,2dd0.
! S2 a4 a% i2 i: v/ F数据分别为0x0800 2de0,0x2000 0000,0x20,0x0800 0129.共16个字节，最后四个为__scatterload_copy的跳转地址。
9 s! M4 [% \% ~  E4 k/ h6 x9 [0x08000112 F0130F01  TST      r3,#0x01
) Y9 F, ~3 ^; @7 x) U6 O7 a0x08000116 BF18      IT       NE
0 J/ F1 W! P6 s0x08000118 1AFB      SUBNE    r3,r7,r3
4 p5 X7 H$ t8 z0x0800011A F0430301  ORR      r3,r3,#0x01；将R3变成0x0800 0129,因为下面的指令带状态切换。
0x0800011E 4718      BX       r3；该处的指令为                 __scatterload_copy:
6 Y7 _# j1 p5 D4 q' p7.__scatterload_copy做了什么
0x08000128 3A10      SUBS     r2,r2,#0x10；每次复制10个，
1 @. u$ ~9 S2 J  S3 }0x0800012A BF24      ITT      CS
0x0800012C C878      LDMCS    r0!,{r3-r6}；将R0=0x0800,2de0处的数据复制0x20个到R1所指向的地址。
* }/ H' i0 l7 `# h# A* |4 @0x0800012E C178      STMCS    r1!,{r3-r6}
0x08000130 D8FA      BHI      __scatterload_copy (0x08000128)；直到20个复制完成，才执行下面的语句。
0x08000132 0752      LSLS     r2,r2,#29
! Q8 r; f0 B( q* x0 ~) R0x08000134 BF24      ITT      CS
0 m% t( y2 N# z; f+ g! R! b0x08000136 C830      LDMCS    r0!,{r4-r5}
0x08000138 C130      STMCS    r1!,{r4-r5}
0 _. Y; F# O" [$ b  r' J0x0800013A BF44      ITT      MI
$ {# Q" T0 K" E% W0x0800013C 6804      LDRMI    r4,[r0,#0x00]
- J) R( ]1 N( `6 d( I+ T" O) ^0x0800013E 600C      STRMI    r4,[r1,#0x00]
  U* _0 d$ i# k: w" O* m0x08000140 4770      BX       lr；回到__scatterload_null
8、回来以后__scatterload_null重新执行
   首先取得0x0800 2dd0处的16个数据到R0-R3,R0为数据的源地址0x0800 2e00，R1为目的地址0x2000,0020。因为前面已经复制了0x20个数据。这下是清零操作。R2=操作数据个数，R3为返回地址。
* R$ u: ?( J/ k! ~8 n; x/ S' U: J9、清零操作完成，又回到__scatterload_null重新执行
5 y" l0 V" v2 O& L- Q   此时R10=R11.BL.W __rt_entry (0x080017BE)跳入运行时库的入口执行。
, `5 N5 N. s  C$ q10、__rt_entry代码分析
2 L" ~/ ]- I) u4 \6 d- Y/ P; R  Q0x080017BE F3AF8000  NOP.W   
$ {2 i- }: M7 j; O9 H4 P0x080017C2 F7FFFFEA  BL.W     __rt_stackheap_init (0x0800179A)；先进行堆栈的初始化。
5 C) w; p/ z6 [2 a+ \, q0x080017C6 B403      PUSH     {r0-r1}；这里用到了参数，进行不同平台下的后处理操作。
0x080017C8 F000F93C  BL.W     _platform_post_stackheap_init (0x08001A44)
: L0 j. t* I+ i% M4 ]0x080017CC BC03      POP      {r0-r1}
0x080017CE F000F8D9  BL.W     __rt_lib_init (0x08001984)；进行库初始化。
0x080017D2 B40F      PUSH     {r0-r3}；需要四个参数。
0x080017D4 F000F93B  BL.W     _platform_post_lib_init (0x08001A4E)
0x080017D8 BC0F      POP      {r0-r3}；恢复堆栈的初始状态。
0x080017DA F7FFFC8B  BL.W     main (0x080010F4)；
main函数一般是个循环，不会执行到下面语句，但如果不写成循环，就会执行到下面的语句。
0x080017DE F000F8CB  BL.W     exit (0x08001978)

二、步骤续
11、在__rt_stackheap_init中
9 ]. t  o9 z$ k4 I/ G: n6 X                 __rt_stackheap_init:
0x0800179A 4674      MOV      r4,lr；将返回地址保存在R4中；
9 o1 X  D. `" J8 ^0x0800179C F000F82E  BL.W     __user_setup_stackheap (0x080017FC)
0x080017A0 46A6      MOV      lr,r4
0x080017A2 B50D      PUSH     {r0,r2-r3,lr}；第一次用到了堆栈，保存了程序返回值。
( H- h. R( M" g% }3 A0x080017A4 F000F850  BL.W     __rt_stackheap_storage (0x08001848)
0x080017A8 0004      MOVS     r4,r0；子程序的返回值。
0x080017AA E8BD400D  POP      {r0,r2-r3,lr}
# ?2 A8 A" W# w0x080017AE 0011      MOVS     r1,r2
0x080017B0 4770      BX       lr
1 z7 R# R0 r8 |( Q1 F* l12、在__user_setup_stackheap中，
6 u+ w) H8 v# \$ n9 @0x080017FC 4675      MOV      r5,lr；将返回地址保存在R5中；
6 w5 j5 x: s! O7 T% M" a% I( {0x080017FE F000F8A5  BL.W     0x0800194C；
" A) E0 ]. Y5 O( P% w5 I% R13、0x0800194C的功能分析；该段程序在_sys_exit中。
: P7 g4 m0 e: u8 K+ |0x0800194C 4800      LDR      r0,[pc,#0]  ; @0x08001950
( K  @/ Q- A6 g- C0x0800194E 4770      BX       lr；将0x2000 0040保存在r0中，返回。
, K9 V4 _3 u0 v6 Z1 [  j

14、 __user_setup_stackheap:继续
' [0 j  z& ]- x% y& ]                 __user_setup_stackheap:
0x080017FC 4675      MOV      r5,lr
0x080017FE F000F8A5  BL.W     0x0800194C
0x08001802 46AE      MOV      lr,r5；从上面返回后，恢复lr
% K. E, S$ D% c* j" }0x08001804 0005      MOVS     r5,r0
0x08001806 4669      MOV      r1,sp
. N0 d9 u+ u+ z8 Z0x08001808 4653      MOV      r3,r10
& ]' r3 a* d+ f& c0x0800180A F0200007  BIC      r0,r0,#0x07
0x0800180E 4685      MOV      sp,r0
0x08001810 B018      ADD      sp,sp,#0x60；堆栈的起始点0x2000 00a0.
0x08001812 B520      PUSH     {r5,lr}
: ]  q0 S/ q! M9 [9 r6 t0x08001814 F7FEFCB2  BL.W     __user_initial_stackheap (0x0800017C)
15、 __user_initial_stackheap ；
. I0 U1 K& |$ j+ l: V* M    跳到用户定义的函数，因为堆栈和用户堆得大小都是在程序中
# p  ^6 t/ S2 Z# m% |6 z自己定义的。
    在用户程序中定义的BX LR就是返回到该函数中。
0x08001818 E8BD4020  POP      {r5,lr}
0x0800181C F04F0600  MOV      r6,#0x00
0x08001820 F04F0700  MOV      r7,#0x00
: g- J& z- j- S0x08001824 F04F0800  MOV      r8,#0x00
1 p& y9 g( _9 @( H% Y; N0x08001828 F04F0B00  MOV      r11,#0x00
; s% ?& J4 p) |0x0800182C F0210107  BIC      r1,r1,#0x07
8 `9 d3 H- n$ A  X+ l, O- u0x08001830 46AC      MOV      r12,r5
0x08001832 E8AC09C0  STM      r12!,{r6-r8,r11}
; g* T( S% c4 q! |: u0x08001836 E8AC09C0  STM      r12!,{r6-r8,r11}
' E' a6 ^. e. i3 Y1 D% ^0x0800183A E8AC09C0  STM      r12!,{r6-r8,r11}
0x0800183E E8AC09C0  STM      r12!,{r6-r8,r11}
% P, T, N, q1 B+ a; a! c0x08001842 468D      MOV      sp,r1；将sp设置为0x0800 04a0;
0x08001844 4770      BX       lr；返回到前一级程序__user_setup_stackheap。
16、在__user_setup_stackheap继续执行
; a/ E0 Q1 v4 H0 Q0x080017A0 46A6      MOV      lr,r4；将保存在R4中的子程序返回值送回LR。
0x080017A2 B50D      PUSH     {r0,r2-r3,lr}；利用堆栈保存参数。
! [3 S$ @" l. j9 |( i  W1 s, J0x080017A4 F000F850  BL.W     __rt_stackheap_storage (0x08001848)
+ @4 C3 l) x* E  R: J( b. F在该程序中，主要是在r0中保存了一个值0x2000 0050。
0x080017A8 0004      MOVS     r4,r0；返回值保存到r4中。
0x080017AA E8BD400D  POP      {r0,r2-r3,lr}
0x080017AE 0011      MOVS     r1,r2
- y- D1 y3 M6 ~* {3 j: I6 E" E, U0x080017B0 4770      BX       lr；回到__rt_entry中执行。
17、又回到__rt_entry了，其实走了一圈，具体也没做什么事。
0x080017C6 B403      PUSH     {r0-r1}
0x080017C8 F000F93C  BL.W     _platform_post_stackheap_init (0x08001A44)；具体平台的堆栈相关初始化：本程序中没做什么事，估计是可以人工定义改变的。
0x080017CC BC03      POP      {r0-r1}
0x080017CE F000F8D9  BL.W     __rt_lib_init (0x08001984)


* K4 {8 L6 {* i9 b) T. z18、进入__rt_lib_init
0x08001984 E92D43FE  PUSH     {r1-r9,lr}
, c7 m* J! y' y# u0x08001988 4604      MOV      r4,r0
& b1 b( I3 k5 z8 T0x0800198A 460D      MOV      r5,r1
1 ?6 Y4 q# h9 X* }4 S0x0800198C F000F872  BL.W     _fp_init (0x08001A74)；进入浮点初始化
9 t$ w( S! f& I% j$ z! K$ u19、进入 _fp_init
3 f% b& c3 p# x. w- I- F0 K$ M0x08001A74 B510      PUSH     {r4,lr}
0x08001A76 F7FFFFF7  BL.W     __rt_fp_status_addr (0x08001A68)；马上又进入到__rt_fp_status_addr。
" M0 h- @+ O  N5 k5 F; H0 a0x0800198C F000F872  BL.W     _fp_init (0x08001A74)；回来了，其实也没做什么事，就在0x2000 0044处存了一个数据，什么用途暂时不知。
3 G. }2 Y2 ?% c% v6 R# k$ |0x08001990 2000      MOVS     r0,#0x00
0x08001992 E9CD4500  STRD     r4,r5,[sp,#0]
! E6 _& H) N! I0x08001996 F3AF8000  NOP.W   
1 Z9 W& H! @# M0x0800199A 9002      STR      r0,[sp,#0x08]
0x0800199C 4668      MOV      r0,sp
" g9 ^+ i; w8 L8 Q0x0800199E F7FEFBDF  BL.W     __ARM_argv_veneer (0x08000160)
% ~! A" A% T6 ?8 S) P$ S& K20、在 __ARM_argv_veneer中
. M. m/ d9 u3 \1 Q8 x0x08000160 F001BC80  B.W      __ARM_get_argv (0x08001A64)it (0x08001A44)马上又跳转到另一个函数。又单纯的返回而已。
* i- N7 k$ @( ?% g: @5 o: F$ q0x080019C2 4680      MOV      r8,r0
0x080019C4 F000F848  BL.W     __rt_locale (0x08001A58)
0x080019C8 2100      MOVS     r1,#0x00；最后又回到__rt_entry中。
( c) l$ d  j4 i8 g$ \; ?0x080017D2 B40F      PUSH     {r0-r3}
0x080017D4 F000F93B  BL.W     _platform_post_lib_init (0x08001A4E)
0x080017D8 BC0F      POP      {r0-r3}；最后的操作马上机会进入到主函数main中执行用户程序。
7 c& S3 ^  k. L7 b

二、keil MDK 输出map文件分析

一、文件分析流程
& s  a; |  L& N; R) k0 a0 a) M/ g
* u9 \1 {) ], X6 M5 W- s
- V* D- q  H7 t& Z6 T2 [5 d1、第一部分：Section Cross References


主要是各个源文件生成的模块之间相互引用的关系。
; f+ H$ }7 N# H" v, v

, K2 j1 t9 V7 Z/ U7 z7 ?stm32f10x.o(STACK) refers (Special) to stkheap2.o(.text) for __use_two_region_memory

. t1 n+ b9 [1 V5 j2 M" c  w
* W# O+ n- x3 Q1 s+ [2 G比如上面这句话，stm32f10x.o是stm32f10x.s生成的目标文件模块，(STACK)是文件内定义的一个段，链接器把它视为一个Section，输入节。它引用了模块stkheap2.o输入节(.text)里面的一个全局符号__use_two_region_memory（可能是一个函数或变量）。这个(Special)不知道是什么含义。
4 y1 l9 T2 u. ?2 N

剩下的基本都是这用的意思。


3 n3 a$ A4 b8 q& s3 f$ Ustm32f10x_vector.o(.text) refers to __main.o(!!!main) for __main
& |) r% N' ~) L$ g( {8 k
* u- p# C6 |) j- x& C1 f! `# ?
0 q9 }& d, F/ \__main.o(!!!main) refers to kernel.o(.text) for __rt_entry
% ^! d6 g" i/ i$ P
: `3 z6 `# i" r$ B$ I5 |
kernel.o(.text) refers to usertask.o(.text) for main


0 Z. i+ _% L' ^$ I0 w- i上面这几个对于程序意义比较重大用户在启动代码中调用了__main.o模块中的__main函数，__main又调用了kernel.o中的__rt_entry函数，最后kernel.o又调用了用户定义的main主函数。

5 u+ t. ?3 x6 G  ~
3 ]. c/ ]; S* e6 m+ V) X

5 m) a+ }2 D8 G/ o: y# c
2、第二部分：Removing Unused input sections from the image.

! J" k- b+ J, t  K% `1 l
就是将库中没有用到的函数从可执行映像中删除掉，减小程序的体积。
6 X8 c$ n& c/ l8 `' Y  x
0 A; |' _) t7 ^9 P9 X2 }
    Removing os_mbox.o(.text), (1094 bytes).
+ a/ l2 N+ v& `2 ]  h0 O; ^' d
" k% F. o5 E8 Z. F
% a+ b# h$ ]/ M% h- M7 Z    Removing os_mutex.o(.text), (1744 bytes).
: V  C" ]/ z- T3 t; ^

- L7 ~5 @! w4 x* ARemoving os_sem.o(.text), (1016 bytes).

; ~! T0 }  F' J+ r+ U( `) p
3、第三部分：Image Symbol Table

" B2 e& b' C. x% }
Local Symbols


符号表里的局部符号。

+ E1 ^3 E  C* E; m
    ../../angel/boardlib.s  0x00000000   Number         0  boardinit1.o ABSOLUTE
4 u- p, L, x2 _; X5 |1 e

   ../../angel/handlers.s  0x00000000   Number     0  __scatter_copy.o ABSOLUTE
0 T( C9 L2 ?1 j3 H

    ../../angel/kernel.s     0x00000000   Number       0  kernel.o ABSOLUTE


) e3 P+ J4 \1 i9 G0 r+ F  k2 y    ../../angel/rt.s    0x00000000   Number         0  rt_raise.o ABSOLUTE


+ ~6 d1 z0 l" g( {& L    ../../angel/scatter.s   0x00000000   Number         0  __scatter.o ABSOLUTE
2 V; t- g1 N5 {  z% x& t' {% o

    ../../angel/startup.s   0x00000000   Number         0  __main.o ABSOLUTE
1 D- g' X( l% ]5 x

    ../../angel/sys.s    0x00000000   Number         0  sys_exit.o ABSOLUTE

9 o# O8 N% o" P  e
   ../../angel/sysapp.c    0x00000000   Number         0  sys_wrch.o ABSOLUTE
0 l2 O" B2 N% M# ?# \8 }

   ../../armsys.c       0x00000000   Number         0  _get_argv.o ABSOLUTE


  ../../division_7m.s  0x00000000   Number         0  rtudiv10.o ABSOLUTE
+ H" W& S) a2 V# }* \

) m7 H+ @( d9 v/ m, s& m6 e% O7 }    ../../fpinit.s   0x00000000   Number         0  fpinit.o ABSOLUTE


    ../../heapalloc.c     0x00000000   Number         0  hrguard.o ABSOLUTE
6 n! O5 I' F$ `1 V8 f7 Q; N8 b. A( ~
* h" T, _5 T$ X! c2 G8 _$ o
+ J6 O3 _7 I) w5 n* d" o+ E    ../../printf.c     0x00000000   Number     0  _printf_outstr_char.o ABSOLUTE

; k8 B. @9 H" L% G9 j
" }2 \9 w/ u% o$ M9 ], L- X    ../../signal.c     0x00000000   Number         0  defsig_exit.o ABSOLUTE


   ../../stdlib.c     0x00000000   Number         0  exit.o ABSOLUTE
/ m+ [$ [9 p3 p) T' q

    ../../stkheap.s      0x00000000   Number         0  heapext.o ABSOLUTE


   以上是一些系统内部的局部符号，还有用户的一些局部符号


" ~5 i* m$ ~1 a
& D- z# E4 E* n- S9 L- L6 p

& J: T) j& d% {. k2 _0 Z; ?! I. R4、第四部分：Global Symbols
& g5 C. H; I7 r

全局符号
/ y  O4 I3 g0 ~  d

    _terminate_user_alloc                      - Undefined Weak Reference


    _terminateio                              - Undefined Weak Reference


    __Vectors       0x08000000   Data           4  stm32f10x_vector.o(RESET)

3 x9 {7 H9 N' ~7 i
1 w! e! X/ N2 s7 t, J! a4 Q    __main         0x08000131   Thumb Code     8  __main.o(!!!main)
% A) w! r. X* [4 ?! z) L6 \. m# }

6 O3 L1 f3 q5 p. H. w    __scatterload    0x08000139   Thumb Code     0  __scatter.o(!!!scatter)

9 @+ v5 F2 x! h: E
1 y: W5 ~1 `; i, y   __scatterload_rt2  0x08000139   Thumb Code    44  __scatter.o(!!!scatter)
* G+ k& ~) y6 P" ^
( v0 H& Z2 {7 d0 F
这些是一些系统的全局符号


    Font8x16   0x08001a82   Data        2048  tft018.o(.constdata)
0 Q; @% s% J1 S* E

4 K7 @/ @% a) V7 ?3 n    Font8x8    0x08002282   Data        2056  tft018.o(.constdata)

5 e  ?1 [- }& q5 I( C
    codeGB_16  0x08002a8a   Data         770  tft018.o(.constdata)
( ]. G- t; O- G% s

    Region$$Table$$Base  0x08002dc0   Number  0  anon$$obj.o(Region$$Table)
' z3 O4 }( }6 v  F
) i# V* }6 }# u# a
    Region$$Table$$Limit  0x08002de0   Number   0  anon$$obj.o(Region$$Table)

  `8 z" x; j4 B1 F7 W* k
   
  z$ f. x' u6 v$ Z& f$ G

后面这两个符号我认为很重要，在运行库代码将可执行映像从加载视图转变为可执行视图的过程中起到了关键作用。Number是指它并不占据程序空间，而只是一个具有一定数值的符号，类似于程序中用define和EQU定义的。所以这里，我先放下map文件的分析，先通过仿真调试，看这两个数值在程序中怎么用。

6 L% j) y" J% [  h  \4 r& k

果然，在刚开始执行程序时，R10和R11的值就已经被赋值成了这两个值。

% U9 s$ J' o0 n$ r3 n, w
* I1 E3 c' s! G

# y5 H$ `& a4 ]( o

。。。

很快就将0x08002dc0到0x08002dcf处的16个字节，4个双字加载到了R0-R3，我们可以分析一下里面的内容，R0就是程序加载视图的RW区的起始地址（0x08002de0），R1就是要输出的执行视图的RW区的地址（0x20000000），R2就是要复制的RW数据的个数，R3是复制函数 （ __scatterload_copy)的地址，类似于一个回调函数。接下来就要用了：0x0800011E 4718  BX  r3这条指令去执行复制工作。

接下来又将0x08002dd0到0x08002ddf处的16个字节，4个双字加载到了R0-R3，我们可以分析一下里面的内容，R0就是程序加载视图的RW区的起始地址（0x08002de0+0x20=0x08002e00），R1就是要输出的执行视图的RW区的地址（0x20000020），R2就是要复制的RW数据的个数，R3是ZI区域建立函数（  __scatterload_zeroinit )的地址。
1 p! f! ?3 E* p- c# ]



+ \+ [; p+ W/ ^7 [2 S% D执行完成后，程序就会进入BL.W  __rt_entry处进行库的初始化工作
& Y  M. R3 A( M
4 d' a; U8 ~: k4 G

* S7 K8 Y0 ~" n# Z经过这么一分析，现在我对于程序的加载映像和执行映像有了较深的理解：程序的RO_Code加上RO_Data总共是0x2dc0这么大，地址范围0x0800,0000到0x8000,2dbf。然后在0x0800,2dc0-2dcf共16个字节放了RW加载映像地址（0x0800,2de0）、执行映像地址(0x2000,0000)、RW长度(0x20)和将该段数据从加载映像复制到执行映像的函数地址。在0x0800,2dd0-2ddf共16个字节放了ZI加载映像地址（0x0800,2e00）、执行映像地址(0x2000,0020)、ZI长度(0x480)和建立ZI、HEAP和STACK执行映像的函数地址。
9 F4 {- _$ G! [

在上面的第二个阶段，将ZI清零阶段，程序的ZI长度实际上只有0x20，而库代码留出了0x60的长度。因此数据区的顶端为0x2000,00a0-1。接下来从0x2000,00a0开始为堆的起始地址，堆长度加上程序栈长度为0x2000,04a0，这就是堆栈顶端，也是__initial_SP的初始值。
% z6 L" |/ }2 \: X: l( z

' l4 J4 _9 i6 |程序进入_rt_entry后，还要对heapstack进行处理，但我没有看到有什么用的变化。从中对库留出的ZI数据区进行了一些处理，我暂时也看不明白。好了，调试就到这里，回到map文件分析的正途。
3 Q; V( d& q8 [

5、第五部分：
0 E5 t9 E1 D6 B5 s

  b6 a& e5 X  \Memory Map of the image
9 g' S# N  S! b) J# B" o/ ?

- L8 d5 y, X$ Z" Z( r9 |//映像的内存分布
& Z" N: u$ F7 @! C
( k8 h' L9 o% L8 N
4 `% i+ o0 o2 r% a( d  Image Entry point : 0x080000ed
4 h4 ?+ k, T+ q  }7 z# K$ g" R

//程序的入口点：这里应该是RESET_Handler的地址
4 c$ j# o; C0 Q; z% b0 _+ @
. c* u2 R6 D9 C6 w$ U1 N! x$ c& e1 N
% r4 C; C# V2 \1 G8 p9 K8 X  Load Region LR_IROM1 (Base: 0x08000000, Size: 0x00002e00, Max: 0x00020000, ABSOLUTE)
8 [' i% l2 K( Z- M* ?

# W4 P# A- e7 G$ Q+ @. S" s//程序的加载映像地址和长度，2e00=2dc0（代码和常数）+0x20（Region Table是RW的加载和执行地址、ZI与HEAPSTACK的执行地址）+0x20（已经初始化的数据）。

1 s' ^8 ^: I9 f
, S; H" c, E( y2 P    Execution Region ER_IROM1 (Base: 0x08000000, Size: 0x00002de0, Max: 0x00020000, ABSOLUTE) //这段RO区域的加载映像和执行映像一致。
* s, g# ]: F3 S- r  F
9 b" _, ]! i& u' V$ G& n
    Base Addr    Size         Type   Attr      Idx    E Section Name        Object
3 w+ v4 Y9 x1 K- ?& V
( D) \4 ^( \7 l3 T% W3 x
    0x08000000 0x000000ec   Data   RO      3    RESET               stm32f10x.o


* i/ p; k: d. y% @1 _) U( Y! \    0x080000ec 0x00000008  Code   RO  191  * !!!main             __main.o(c_w.l)
' U8 G( w8 S+ z

   

- d6 ?1 S' r) U; ^  L' M
- Y5 w& Y7 e" R% X. ]   Execution Region RW_IRAM1 (Base: 0x20000000, Size: 0x000004a0, Max: 0x00005000, ABSOLUTE) //RW数据区 ZI数据区 Heap和Stack数据区。
, l& C5 r! z* V7 u3 E
5 ~5 e. Y/ i5 N( W6 {" O0 q* C0 _5 Z

2 M, ^8 N7 ?: R! B8 m    Base Addr    Size         Type   Attr      Idx    E Section Name        Object


    0x20000000   0x00000001   Data   RW   100    .data              tft018.o


    x20000040   0x00000060   Zero   RW  212  .bss                libspace.o(c_w.l)
- N- B9 k  w& W0 j
# D1 r  B, B$ K/ G! p
* R; o- X3 J0 o4 D0 Z* e    0x200000a0   0x00000000   Zero   RW  2    HEAP          stm32f10x.o
# ]: T% n, C/ s$ q

9 a. d% H6 J- ~2 j9 B8 e: s* ~    0x200000a0   0x00000400   Zero   RW    1  STACK               stm32f10x.o
* Y& B$ @( H) C& L4 b
' E( }+ V5 |; ~3 p8 v0 K+ g" O
( }/ U6 ~* f' d- T* k6、第六部分：Image component sizes
5 k7 v' b% V' z8 F6 w  H
# Y, Z. h. R6 i' ~$ A/ L- P
/ Y4 G+ \  a, L6 H3 L% s这是指出各个模块的输入节的大小
( P$ P0 B: t3 ^3 w
5 y9 z4 {9 E; i. D4 C1 V0 ^# {# x
      Code (inc. data)   RO Data    RW Data    ZI Data      Debug   Object Name

6 j( W$ |' k9 M3 n( d4 E
9 T1 R+ q7 u7 ~( t+ N       972         58          0         10         32       2416   can.o

. z' ^0 f* y; B1 E
& d) p5 V2 z+ ]( W8 r- \       824        168          0         15          0       1791   candemo.o
- u" c# g) W, g% D; V
5 a. E, ^; ^0 @2 i& f
       928         88          0          0          0       4529   stm32_init.o

; a5 b2 E9 b8 \
5 t4 A3 [, d# v! V0 r" u' h        52         18        236          0       1024       2700   stm32f10x.o
! H8 g8 @8 I" U9 h0 G
& {) P7 K" D1 }! }4 O
      1836         32       4874          1          0       8076   tft018.o
  \+ c/ j2 p- e0 M- M. X

最后给出总长度：这个11744应该=0x2dc0，1184应该0x4a0。11776应该是=0x2e00。
% O% p" m, H2 A" z

! k" V0 n' x* _2 t2 Q    Total RO  Size (Code + RO Data)                11744 (  11.47kB)
; P* X4 F7 j2 p4 ]
$ l% z6 I/ e( p- T: {% A/ o  a
* c4 D" B7 R- ]    Total RW  Size (RW Data + ZI Data)              1184 (   1.16kB)
1 X/ ~/ c" x+ z9 t

! r" D# W" r2 iTotal ROM Size (Code + RO Data + RW Data)      11776 (  11.50kB)
: h. i1 |! K5 r# h