本文分析STM32单片机到底是如何软硬件结合的，分析单片机程序如何编译，运行。

软硬件结合
初学者，通常有一个困惑，就是为什么软件能控制硬件？就像当年的51，为什么只要写P1=0X55，就可以在IO口输出高低电平？要理清这个问题，先要认识一个概念：地址空间。

寻址空间
什么是地址空间呢？所谓的地址空间，就是PC指针的寻址范围，因此也叫寻址空间。

/ m4 h, F2 i% X大家应该都知道，我们的电脑有32位系统和64位系统之分，为什么呢？因为32位系统，PC指针就是一个32位的二进制数，也就是0xffffffff，范围只有4G寻址空间。现在内存越来越大，4G根本不够，所以需要扩展，为了能访问超出4G范围的内存，就有了64位系统。STM32是多少位的？是32位的，因此PC指针也是32位，寻址空间也就是4G。
$ R" I# ~  n3 B$ f( n# I
+ T/ t: g6 k  _: j# C1 T4 u. A我们来看看STM32的寻址空间是怎么样的。在数据手册《STM32F407_数据手册.pdf》中有一个图，这个图，就是STM32的寻址空间分配。所有的芯片，都会有这个图，名字基本上都是叫Memory map，用一个新芯片，就先看这个图。

最左边，8个block，每个block 512M，总共就是4G，也就是芯片的寻址空间。
, t- T) R/ p$ A# F! p3 p
block 0 里面有一段叫做FLASH，也就是内部FLASH，我们的程序就是下载到这个地方，起始地址是0X800 0000，大家注意，这个只有1M空间。现在STM32已经有2M flash的芯片了，超出1M的FLASH放在哪里呢？请自行查看对应的芯片手册。
( J( e' q, g! M& r$ s, n' o
3 在block 1 内，有两段SRAM，总共128K，这个空间，也就是我们前面说的内存，存放程序使用的变量。如果需要，也可以把程序放到SRAM中运行。407不是有196K吗？

0 q6 \* J7 h3 M, H其实407有196K内存，但是有64k并不是普通的SRAM，而是放在block 0 内的CCM。这两段区域不连续，而且，CCM只能内核使用，外设不能使用，例如DMA就不能用CCM内存，否则就死机。
$ ?/ s( X4 d; {5 }4 `
block 2，是Peripherals，也就是外设空间。我们看右边，主要就是APB1/APB2、AHB1/AHB2，什么东西呢？回头再说。
! X- \% W1 h; G- ^
& r2 C; ^/ ?9 _( D* W* Sblock 3、block4、block5，是FSMC的空间，FSMC可以外扩SRAM，NAND FALSH，LCD等外设。

8 g* ]2 C6 V1 E' j2 j好的，我们分析了寻址空间，我们回过头看看，软件是如何控制硬件的。对于这个疑惑，也可以看此文：代码是如何控制硬件的？在IO口输出的例程中，我们配置IO口是调用库函数，我们看看库函数是怎么做的。

) }: z7 ?5 _% B2 V* ^例如：
8 M5 u! ^" s" e) j% f3 r

1. GPIO_SetBits(GPIOG, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3);

复制代码

6 v, d. }. X( s这个函数其实就是对一个变量赋值，对GPIOx这个结构体的成员BSRRL赋值。

1. void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   
2. {
   5 f3 [# S+ A( B# c% q' m
3. /* Check the parameters */
   / ]5 X8 |5 Y4 U, H) M, e# C
4. assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
   : j; P. c. x, I
5. assert_param(IS_GPIO_PIN(GPIO_Pin));
   ! \, M4 h6 n! x2 F4 l8 Z! _; ?2 u  N
6. 
   & a' s, W' Y2 }" R4 J. k0 F' R
7. 
   . p: I0 }6 k9 U: ^- \6 D( j" ~; d
8. GPIOx->BSRRL = GPIO_Pin;
   
9. }

复制代码

3 \6 Q- `4 X3 Y% Oassert_param:这个是断言，用于判断输入参数是否符合要求GPIOx是一个输入参数，是一个GPIO_TypeDef结构体指针，所以，要用->获取其成员
, f5 _4 u5 K/ x% M8 r: b- j
3 b8 v) m6 Q% x& n3 SGPIOx是我们传入的参数GPIOG，具体是啥？在stm32f4xx.h中有定义。

1. #define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)

复制代码

& \4 K0 F* {# {3 NGPIOG_BASE同样在文件中有定义，如下：

1. /*!< Peripheral memory map */
   ( y% q7 Z, _* \# |
2. #define APB1PERIPH_BASE       PERIPH_BASE
   
3. #define APB2PERIPH_BASE       (PERIPH_BASE + 0x00010000)
   
4. #define AHB1PERIPH_BASE       (PERIPH_BASE + 0x00020000)
   
5. #define AHB2PERIPH_BASE       (PERIPH_BASE + 0x10000000)

复制代码

再找找PERIPH_BASE的定义
9 X  }' b% W, N2 ~9 o# i  T

1. #define PERIPH_BASE           ((uint32_t)0x40000000)

复制代码

到这里，我们可以看出，操作IO口G，其实就是操作0X40000000+0X1800这个地址上的一个结构体里面的成员。说白了，就是操作了这个地方的寄存器。实质跟我们操作普通变量一样，就像下面的两句代码，区别就是变量i是SRAM空间地址，0X40000000+0X1800是外设空间地址。

1. u32 i;
   9 B( h3 _" ^5 d! I5 z3 b$ ~1 W
2. i = 0x55aa55aa;

复制代码

这个外设空间地址的寄存器是IO口硬件的一部分。关于如下图STM32的GPIO文章推荐：STM32中GPIO工作原理详解。如下图，左边的输出数据寄存器，就是我们操作的寄存器（内存、变量），它的地址就是0X40000000+0X1800+0x14.

控制其他外设也类似，就是将数据写到外设寄存器上，跟操作内存一样，就可控制外设了。

: V/ f8 J8 `' A0 ]1 z) L4 Q; W寄存器，其实应该是内存的统称，外设寄存器应该叫做特殊寄存器。慢慢的，所有人都把外设的叫做寄存器，其他的统称内存或RAM。寄存器为什么能控制硬件外设呢？因为，初略的说，一个寄存器的一个BIT，就是一个开关，开就是1，关就是0。通过这个电子开关去控制电路，从而控制外设硬件。
% N; y- }, N5 A% S* [  @7 R
纯软件-包罗万象的小程序
我们已经完成了串口和IO口的控制，但是我们仅仅知道了怎么用，对其他一无所知。程序怎么跑的？关于程序是怎么在单片机运行的，也可以看此视频：动画演示单片机是如何跑程序的。代码到底放在那里？内存又是怎么保存的？下面，我们通过一个简单的程序，学习嵌入式软件的基本要素。
$ o+ _- _5 _+ J, c% X
分析启动代码
函数从哪里开始运行？
每个芯片都有复位功能，复位后，芯片的PC指针（一个寄存器，指示程序运行位置，对于多级流水线的芯片，PC可能跟真正执行的指令位置不一致，这里暂且认为一致）会复位到固定值，一般是0x00000000，在STM32中，复位到0X08000004。因此复位后运行的第一条代码就是0X08000004。前面我们不是拷贝了一个启动代码文件到工程吗？startup_stm32f40_41xxx.s，这个汇编文件为什么叫启动代码？因为里面的汇编程序，就是复位之后执行的程序。在文件中，有一段数据表，称为中断向量，里面保存了各个中断的执行地址。复位，也是一个中断。

芯片复位时，芯片从中断表中将Reset_Handler这个值（函数指针）加载到PC指针，芯片就会执行Reset_Handler函数了。（一个函数入口就是一个指针）

1. ; Vector Table Mapped to Address 0 at Reset
   ; h& U% T- }$ E+ E- e) i( F1 Q
2.                 AREA    RESET, DATA, READONLY
   
3.                 EXPORT  __Vectors
   
4.                 EXPORT  __Vectors_End
   . d! w* V5 d0 u& B
5.                 EXPORT  __Vectors_Size
   / O! {5 }( \9 f$ z
6. 
   $ ^! x/ g! L; l+ W: j6 f
7. __Vectors       DCD     __initial_sp               ; Top of Stack
   
8.                 DCD     Reset_Handler              ; Reset Handler
   
9.                 DCD     NMI_Handler                ; NMI Handler
   ) c5 |4 y, v1 X
10.                 DCD     HardFault_Handler          ; Hard Fault Handler
    + D; @7 y3 R# l" s
11.                 DCD     MemManage_Handler          ; MPU Fault Handler
    
12.                 DCD     BusFault_Handler           ; Bus Fault Handler
    0 y% k& r& ]5 f' M8 |
13.                 DCD     UsageFault_Handler         ; Usage Fault Handler

复制代码

Reset_Handler函数，先执行SystemInit函数，这个函数在标准库内，主要是初始芯片时钟。然后跳到__main执行，__main函数是什么函数？
  A0 u4 ^) x6 v3 w. x
是我们在main.c中定义的main函数吗？后面我们再说这个问题。

. U! E$ ?% U5 F, q1 s

, }% h: H3 R- e9 w
芯片是怎么知道开始就执行启动代码的呢？或者说，我们如何把这个启动代码放到复位的位置？这就牵涉到一个一般情况下不关注的文件wujique.sct，这个文件在wujique\prj\Objects目录下，通常把这个文件叫做分散加载文件，编译工具在链接时，根据这个文件放置各个代码段和变量。
6 F4 ]9 a2 ]; P5 g
) J* M/ b+ h3 ~在MDK软件Options菜单Linker下有关于这个菜单的设置。

; J6 w% f' H, ~1 F! T

5 o/ Y& B. \1 }# W

把Use Memory Layout from Target Dialog前面的勾去掉，之前不可设置的框都可以设置了。点击Edit进行编辑。

+ h2 M3 U9 @& g7 ^6 Q

9 _* b7 K1 _: \2 A

# P% [3 y  V/ j* ?在代码编辑框出现了分散加载文件内容，当前文件只有基本的内容。

) f: Z) g' v- D9 R4 H' u其实这个文件功能很强大，通过修改这个文件可以配置程序的很多功能，例如：1 指定FLASH跟RAM的大小于起始位置，当我们把程序分成BOOT、CORE、APP，甚至进行驱动分离的时候，就可以用上了。2 指定函数与变量的位置，例如把函数加载到RAM中运行。
3 f% a) l* w) ]" L/ R8 A& f. H
8 V+ x! j9 D% l( h

从这个基本的分散加载文件我们可以看出：
8 |5 D0 M8 n5 W! P, a6 K" ?  ]
6 D- {  v1 m3 n! ]" L# F7 h( k第6行 ER_IROM1 0x08000000 0x00080000定义了ER_IROM1，也就是我们说的内部FLASH，从0x08000000开始，大小0x00080000。

/ @3 R& l' X5 ^- O5 p; ^第7行.o (RESET, +First)从0x08000000开始，先放置一个.o文件， 并且用(RESET, +First)指定RESET块优先放置，RESET块是什么？请查看启动代码，中断向量就是一个AREA，名字叫RESET，属于READONLY。这样编译后，RESET块将放在0x08000000位置，也就是说，中断向量就放在这个地方。DCD是分配空间，4字节，第一个就是__initial_sp，第二个就是Reset_Handler函数指针。也就是说，最后编译后的程序，将Reset_Handler这个函数的指针（地址），放在0x800000+4的地方。所以芯片在复位的时候，就能找到复位函数Reset_Handler。
* o8 ^+ G3 x5 {) q+ h! f- d
# Y! ^5 t1 J8 D1 x/ A第8行 *(InRoot$$Sections)什么鬼？GOOGLE啊！回头再说。

第9行 .ANY (+RO)意思就是其他的所有RO，顺序往后放。就是说，其他代码，跟着启动代码后面。
2 j* p7 V+ W& ^
第11行 RW_IRAM1 0x20000000 0x00020000定义了RAM大小。

% S% Q- U5 z# N/ d0 ]第12行 .ANY (+RW +ZI)所有的RW ZI，全部放到RAM里面。RW,ZI，也就是变量，这一行指定了变量保存到什么地址。
1 [# l& |8 V0 ~& b  h
  Y; X5 p; n* F3 p% W/ ?+ ~- m分析用户代码
; c; ]4 _1 P+ `0 ?到此，基本启动过程已经分析完。下一步开始分析用户代码，就从main函数开始。

/ L$ `  Y) B# j8 f$ e; J9 l' E, a1 程序跳转到main函数后:RCC_GetClocksFreq获取RCC时钟频率；SysTick_Config配置SysTick，在这里打开了SysTick中断，10毫秒一次。Delay(5);延时50毫秒。

1. int main(void)
   6 z( g0 S  B5 j$ S; ]! W1 y7 k
2. {
   
3.   GPIO_InitTypeDef GPIO_InitStructure;
   
4. 
   
5. /*!< At this stage the microcontroller clock setting is already configured,
   
6.        this is done through SystemInit() function which is called from startup
   
7.        files before to branch to application main.
   ) W2 [6 r. A0 Q$ ^/ ?
8.        To reconfigure the default setting of SystemInit() function,
   + m% s: }4 b4 \4 H
9.        refer to system_stm32f4xx.c file */
   6 m! Y2 ?9 t- g6 {- H# G. H
10. 
    4 O/ B  M" \3 Y# Q3 a1 v7 A
11.   /* SysTick end of count event each 10ms */
    7 f3 Z0 i9 u$ H" r0 V
12.   RCC_GetClocksFreq(&RCC_Clocks);
    
13.   SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
    
14. 
    # r+ N/ h- f4 B$ o5 w2 r  o5 ^* P
15.   /* Add your application code here */
    
16.   /* Insert 50 ms delay */
    
17.   Delay(5);

复制代码

2 e2 t7 C! d9 t3 x$ p: E- l8 V2 _2 初始化IO就不说了，进入while(1)，也就是一个死循环，嵌入式程序，都是一个死循环，否则就跑飞了。

1. /*初始化LED IO口*/
   : O% K2 @, X0 `/ }
2. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
   
3. 
   ) l! M1 K( \$ ~0 c- Z
4. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3;
   
5. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   
6. 
   
7. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
   ) ?  Q1 C  \7 t3 k
8. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
   0 |+ T  s+ A' @. D( l! a
9. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
   ' ~6 W  ?* @% n  {& j
10. GPIO_Init(GPIOG, &GPIO_InitStructure);   
    
11. 
    " r; _  @3 v- K6 \5 t
12. /* Infinite loop */
    ) @, N; o7 N% \- h+ r/ E8 }# I
13. mcu_uart_open(3);
    
14. while (1)
    " Q; W: [* _/ c
15. {
    
16.   GPIO_ResetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
    
17.   Delay(100);
    0 t4 |- ~! s7 [3 d" Z7 k& w
18.   GPIO_SetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
    
19.   Delay(100);
    
20.   mcu_uart_test();
    7 w( ~9 D- C9 q7 a" y# P
21. 
    9 \' s/ Y# N5 j! E+ l1 h
22.   TestFun(TestTmp2);
    
23. }

复制代码

+ }  {! U) t# q2 h# i9 m2 {3 在while(1)中调用TestFun函数，这个函数使用两个全局变量，两个局部变量。

1. /* Private functions ---------------------------------------------------------*/
   
2. u32 TestTmp1 = 5;//全局变量，初始化为5
   / e# _9 u  Y0 c: p  Q8 ~/ c
3. u32 TestTmp2;//全局变量，未初始化
   
4. 
   + x8 s# O) r: X
5. const u32 TestTmp3[10] = {6,7,8,9,10,11,12,13,12,13};
   
6. 
   ) i; m! W; k& m
7. u8 TestFun(u32 x)//函数，带一个参数，并返回一个u8值
   
8. {
   7 a, N9 E" S1 f( _0 `1 B
9. u8 test_tmp1 = 4;//局部变量，初始化
   
10. u8 test_tmp2;//局部变量，未初始化
    
11. 
    
12. static u8 test_tmp3 = 0;//静态局部变量
    8 g) q5 t; U' x4 x6 b
13. 
    % G$ `3 i1 s, d
14. test_tmp3++;
    
15. 
    1 u% O& J0 f7 T% S. J
16. test_tmp2 = x;
    
17. 
    
18. if(test_tmp2> TestTmp1)
    6 z- N  B1 X; [" E
19.   test_tmp1 = 10;
    
20. else
    
21.   test_tmp1 = 5;
    ( U( B+ [* I! v8 W
22. 
    
23. TestTmp2 +=TestTmp3[test_tmp1];
    " k. T- U; {/ D7 I* ~
24. 
    7 d1 x% E/ n1 G9 m" v
25. return test_tmp1;
    , L1 n! q% Y9 i4 R' {
26. }

复制代码

然后程序就一直在main函数的while循环里面执行。中断呢？对，还有中断。中断中断，就是中断正常的程序执行流程。相关文章：STM32中断系统。我们查看Delay函数，uwTimingDelay不等于0就死等？谁会将uwTimingDelay改为0？

1. /**
   0 i7 J6 J% S7 c6 z
2.   * @brief  Inserts a delay time.
   
3.   * @param  nTime: specifies the delay time length, in milliseconds.
   ; u7 F7 g1 ?8 O
4.   * @retval None
   
5.   */
   
6. void Delay(__IO uint32_t nTime)
   
7. {
   
8.   uwTimingDelay = nTime;
   / G$ K( @+ Q# ^
9. 
   0 y2 Q7 R  r3 i" R0 F
10.   while(uwTimingDelay != 0);
    * W, n* i% _9 U, {& V! f
11. }

复制代码

6 ?2 b& w- r0 T0 z2 r- h4 Z搜索uwTimingDelay变量，函数TimingDelay_Decrement会将变量一直减到0。
; A) V$ t7 T/ B9 U% ^9 D+ V

1. /**
   3 b" K& U, ~) E  z5 l+ W( W2 i
2.   * @brief  Decrements the TimingDelay variable.
   # @# _$ P7 V! j
3.   * @param  None
   
4.   * @retval None
   - _* a$ v; M; \: o5 x9 `: P
5.   */
   
6. void TimingDelay_Decrement(void)
   
7. {
   & K+ D+ l# L1 h  ?+ l! s+ h
8.   if (uwTimingDelay != 0x00)
   1 ?  B/ t$ K9 j3 k7 H$ p
9.   {
   " \7 A' M2 Y7 ^' I( Z: T
10.     uwTimingDelay--;
    
11.   }
    # n  e! Y$ }. C0 S# U4 I& M
12. }

复制代码

这个函数在哪里执行？经查找，在SysTick_Handler函数中运行。谁用这个函数？

1. /**
   3 v- L5 T9 v* a: O5 B( Y
2.   * @brief  This function handles SysTick Handler.
   1 E2 n& s; I: p6 k; V4 Q2 w# u; G! U
3.   * @param  None
   
4.   * @retval None
   7 z- D7 U! X# Z
5.   */
   
6. void SysTick_Handler(void)
   
7. {
   4 `% o: j* d" K8 S  @1 ~! c
8.   TimingDelay_Decrement();
   " q. D) A( [. H9 ]8 g) N* G
9. }

复制代码

$ K) l# }' f6 Z7 K经查找，在中断向量表中有这个函数，也即是说这个函数指针保存在中断向量表内。当发生中断时，就会执行这个函数。当然，在进出中断会有保存和恢复现场的操作。这个主要涉及到汇编，暂时不进行分析了。有兴趣自己研究研究。通常，现在我们开发程序不用关心上下文切换了。

1. __Vectors       DCD     __initial_sp               ; Top of Stack
   
2.                 DCD     Reset_Handler              ; Reset Handler
   2 }; X. B! c2 y$ \2 b1 ~6 ]- @8 L
3.                 DCD     NMI_Handler                ; NMI Handler
   
4.                 DCD     HardFault_Handler          ; Hard Fault Handler
   + l& b) }4 @+ F, r% P& p
5.                 DCD     MemManage_Handler          ; MPU Fault Handler
   
6.                 DCD     BusFault_Handler           ; Bus Fault Handler
   , [6 D9 A) x: i1 L# i! S  f
7.                 DCD     UsageFault_Handler         ; Usage Fault Handler
   9 V* P0 z  l. S. f7 @1 b
8.                 DCD     0                          ; Reserved
   3 d" J( P" i+ m: d; F
9.                 DCD     0                          ; Reserved
   
10.                 DCD     0                          ; Reserved
    * s+ P6 G8 @7 d* Q! L
11.                 DCD     0                          ; Reserved
    2 `& I" }3 T! F3 ?  n0 a
12.                 DCD     SVC_Handler                ; SVCall Handler
    - k7 G* k$ P# V
13.                 DCD     DebugMon_Handler           ; Debug Monitor Handler
    , G0 O% n9 U$ v$ ]/ f4 g! E; A# u8 V
14.                 DCD     0                          ; Reserved
    " J; q+ Q( k- j: Q( N
15.                 DCD     PendSV_Handler             ; PendSV Handler
    
16.                 DCD     SysTick_Handler            ; SysTick Handler

复制代码

. G! n: T: u# @% z* e  G+ v/ D余下问题
% c4 t: ^; }6 N- ]1 __main函数是什么函数？是我们在main.c中定义的main函数吗？2 分散加载文件中*(InRoot$$Sections)是什么？3 ZI段，也就是初始化为0的数据段，什么时候初始化？谁初始化？
; Q( B4 h# d9 ?! Q
0 s) b' D2 L$ j9 D: W6 m为什么这几个问题前面留着不说？因为这是同一个问题。顺藤摸瓜！
9 I4 c: q' \2 l& i' p3 X; {
. d' ~; d, V7 `( H3 U
+ f* F- V/ Q+ w6 ?通过MAP文件了解代码构成
编译结果
程序编译后，在下方的Build Output窗口会输出信息：

1. *** Using Compiler 'V5.06 update 5 (build 528)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'
   : S; ]4 a, K. ^, o" W& B, V& ^2 v$ q
2. Build target 'wujique'
   , R4 |8 f, @; C( s- ^/ L: ?
3. compiling stm32f4xx_it.c...
   : B: B" w3 ?$ Q' l6 ?
4. ...
   
5. assembling startup_stm32f40_41xxx.s...
   
6. compiling misc.c...
   6 L) P" P/ z4 i  C; Q
7. ...
   : @" x% h$ `' J0 X( z% a! N
8. compiling mcu_uart.c...
   ! |# @! ^3 V5 R9 i+ w
9. linking...
   
10. Program Size: Code=9038 RO-data=990 RW-data=40 ZI-data=6000  
    8 v& G2 ?3 U/ A4 T. k
11. FromELF: creating hex file...
    3 _, r" C( m1 E- g
12. ".\Objects\wujique.axf" - 0 Error(s), 0 Warning(s).
    5 d6 J  _% Q$ Y/ C. r
13. Build Time Elapsed:  00:00:32

复制代码

4 K4 y/ S3 C' I( Y9 x% j/ F编译目标是wujique
+ |! v3 t$ `( }9 s7 E% |C文件compiling，汇编文件assembling，这个过程叫编译
编译结束后，就进行link，链接。
最后得到一个编译结果，9038字节code，RO 990，RW 40，ZI 6000。CODE，是代码，很好理解，那RO、RW、ZI都是什么？
+ o) H6 c9 N0 Y: g3 t; `, p3 M- bFromELF，创建hex文件，FromELF是一个好工具，需要自己添加到option中才能用

+ i4 C1 M( q5 N+ c5 i. x7 \map文件配置
" L4 ~- \. X, X更多编译具体信息在map文件中，在MDK Options中我们可以看到，所有信息都放在\Listings\wujique.map

  A( V5 K5 F  V5 Y; I6 A, w; x8 B5 q  Q/ J默认很多编译信息可能没钩，钩上所有信息会增加编译时间。
- \6 S* R! d' j& {

0 y# D. M- K7 `: r, R
. v* N" Z$ B, e+ K% `+ Zmap文件
& i% }( X0 j  d8 g6 r打开map文件，好乱？习惯就好。我们抓重点就行了。


  u' Y) i' e9 ^; K7 @
map 总信息

  I" ^- S; A0 o9 e从最后看起，看到没？最后的这一段map内容，说明了整个程序的基本概况。

5 L8 {6 N) h2 D+ [5 O1 z有多少RO？RO到底是什么？
  S" Y( m; `3 R3 X! r; t
有多少RW?RW又是什么？
, b) _' L$ r+ h% M
ROM为什么不包括ZI Data？为什么包含RW Data？
" \4 }; A. S2 }8 n
+ G, ^' \& K! h4 I6 g7 p  D
Image component sizes

4 p" R4 u8 Y: V往上，看看Image component sizes，这个就比刚刚的总体统计更细了。
! V9 A8 Z: n1 B9 S; Y9 h! X
这部分内容，说明了每个源文件的概况
+ K$ Q5 }5 `# }* T5 B
首先，是我们自己的源码，这个程序我们的代码不多，只有main.o，wujique_log.o，和其他一些STM32的库文件。
3 g; R- {- Q& C7 F; g4 E

第2部分是库里面的文件，看到没？里面有一个main.o。main函数是不是我们写的main函数？明显不是，我们的main函数是放在main.o文件。这么小的一个工程，用了这么多库，你以前关注过吗？估计没有，除非你曾经将一个原本在1M flash上的程序压缩到能在512K上运行。

) v# {% Q! |0 o- w% S& u- Q% w

5 I5 k9 s; X" x
- n( O, @% M; R: r4 a' o第3部分也是库，暂时没去分析这两个是什么东西。

) {+ B1 E, }7 F9 Q. `5 r

库文件是什么？库文件就是别人已经别写好的代码库。在代码中，我们经常会包含一些头文件，例如：
6 Z/ r+ L; [2 {& e( ^# f#include <stdarg.h>
#include <stdlib.h>
#include <string.h>  
. Q& M* s2 i. ~2 }. Z; M# b
这些就是库的头文件。这些头文件保存在MDK开发工具的安装目录下。我们经常用的库函数有：memcpy、memcmp、strcmp等。只要代码中包含了这些函数，就会链接库文件。
* L" m- o5 c+ C; Y9 L
9 P& g+ ?9 a$ {7 |  b
$ Y$ ^% S- t- H. y: F; n文件map
' \* G; Y$ w+ S! k/ s  q再往上，就是文件MAP了，也就时每个文件中的代码段（函数）跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET
0 a5 Z% P; p& X: o3 z" D% k4 A
库文件是什么？
' N+ J, a% j/ L. j) Z库文件就是别人已经别写好的代码库。
, s+ N% \0 m  |* k8 a# i& {  a! G. I
在代码中，我们经常会包含一些头文件，例如：

1. #include <stdarg.h>
   0 N! b; g% J* F* l& {6 h$ f5 i
2. #include <stdlib.h>
   & N' t" ~; }1 q" E% Z
3. #include <string.h>

复制代码

5 i& P2 e% K9 D( j这些就是库的头文件。相关文章：C语言中的头文件。这些头文件保存在MDK开发工具的安装目录下。

; l4 V: n) G: I! H6 T我们经常用的库函数有：memcpy、memcmp、strcmp等。

只要代码中包含了这些函数，就会链接库文件。

7 z+ l! I# i' ~3 }文件map
' i' L  ?5 C* b5 s再往上，就是文件MAP了，也就时每个文件中的代码段（函数）跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET
3 [5 {/ Y1 }5 K) C  u8 u+ a

6 t0 g4 T* \0 w6 P6 A% }8 o9 R每个文件有有多行，例如串口，4个函数。
" c  q, Q, z9 ~( m
) v3 x! U9 U7 S0 p( H$ J

0 n: S2 u9 o1 O9 w0 R) Z' `$ K( K
然后是RAM的，main.o中的变量，放在0x20000000，总共有0x0000000c，类型是Data、RW。串口有两种变量，data和bss，什么是bss？这两个名称，是section name，也就是段的意思。看前面type和Attr，
. H% a$ Y( T7 ^, `' V6 }. r" b; E
RW Data，放在.data段；RW Zero放在.bss段，RW Zero，其实就是ZI。到底哪些变量是RW，哪些是ZI？

3 S: x, Q" ?2 ^  A% [7 {  h
# T$ P3 F6 ?( hImage Symbol Table
4 Y6 O8 B& ^$ C! {, l
; `, L9 J; ~5 l再往上就是Image Symbol Table，就更进一步到每个函数或者变量的信息了

, l+ k$ @5 D+ @+ }  _

例如，全局变量TestTmp1，是Data，4字节，分配的位置是0x20000004。

7 F5 L" Y& U4 h+ V0 B% Q9 O5 I' ~8 L

; D+ U% d; }: ]; e4 Y& D
# x6 v- \( N0 s* J. c7 NTestTmp3数组放在哪里？放在0X080024E0这个地方，这可是代码区额。因为我们用const修饰了这个全局变量数组，告诉编译器，这个数组是不可以改变的，编译器就将这个数组保存到代码中了。程序中我们经常会使用一些大数组数据，例如字符点阵，通常有几K几十K大，不可能也没必要放到RAM区，整个程序运行过程这些数据都不改变，因此通过const修饰，将其存放到代码区。
5 O' }! C# E  ~
" H: n" y' }! S: v  O+ F8 ?2 hconst的用处比较多，可以修饰变量，也可以修饰函数。更多用法自行学习
7 z- S( V4 R8 M) m6 C4 n' O

$ C* d9 @: W. n" ^3 c那局部变量存放在哪里呢？我们找到了test_tmp3，
, k' C4 I5 V& c! U1 L# |& H1 k9 b

没找到test_tmp1/test_tmp2，为什么呢？在定义时，test_tmp3增加了static定义，意思就是静态局部变量，功能上，相当于全局变量，定义在函数内，限制了这个全局变量只能在这个函数内使用。哪test_tmp1、test_tmp2放在哪里呢？ 局部变量，在编译链接时，并没有分配空间，只有在运行时，才从栈分配空间。

1. <blockquote>u8 TestFun(u32 x)//函数，带一个参数，并返回一个u8值

复制代码

上一部分，我们留了一个问题，哪些变量是RW，哪些是ZI？我们看看串口变量的情况，UartBuf3放在bss段，其他变量放在.data段。为什么数组就放在bss？bss是英文Block Started by Symbol的简称。

( P7 `* y1 r' f( G5 a
, G( d) N4 K6 S. N到这里，我们可解释下面几个概念了：
5 H- [0 O+ @: H# tCode就是代码，函数。
" K3 ]6 U( C. @+ _8 eRO Data，就是只读变量，例如用const修饰的数组。
RW Data，就是读写变量，例如全局变量跟static修饰的局部变量。
ZI Data，就是系统自动初始化为0的读写变量，大部分是数组，放在bss段。
, K. b5 h& _9 J, LRO Size等于代码加只读变量。
RW Size等于读写变量（包括自动初始化为0的），这个也就是RAM的大小。
4 z- c' p  t4 K6 t1 `$ VROM Size，也就是我们编译之后的目标文件大小，也就是FLASH的大小。但是？为什么会包含RW Data呢？因为所有全局变量都需要一个初始化的值（就算没有真正初始化，系统也会分配一个初始化空间），例如我们定义一个变量u8 i = 8;这样的全局变量，8，这个值，就需要保存在FALSH区。

( n4 w9 H' }- l

3 G4 ]# Q, M- t$ N, z: E
, u' D3 U8 ?1 X& \我们看看函数的情况，前面我们不是有一个问题吗？__main和main是一个函数吗？查找main后发现，main是main，放在0x08000579
8 l1 A% p6 l8 T: L- h

main是main，放在0x08000189
! D& D( B+ d- _1 Y% I5 C
' ?0 M! L7 X( V% q! e% X

/ h: A+ I1 L, }% ~$ w; M0 R; e
__main到main之间发生了什么？还记得分散加载文件中的这句吗？
*(InRoot$$Sections)

__main就在这个段内。下图是__main的地址，在0x08000189。__Vectors就是中断向量，放在最开始。

; t2 n' I& K1 f# B
6 A  e& w- {7 Y在分散加载文件中，紧跟RESET的就是*(InRoot$$Sections)。

' l" _) s4 e. i) M2 K; z
8 {5 [4 g1 ^) R2 O9 V8 y而且，RESET段正好大小0x00000188。

+ e2 _3 O0 A5 g7 D1 Q0 k; q, l

巧合？可以参考PPT文档《ARM嵌入式软件开发.ppt》。
4 P, J; s5 r, d/ ]2 k4 ]* m( h5 _* U
% C2 _& M+ r0 \/ T- T( I9 I# q2 f

8 w& d: c0 G' h; o4 Q* s7 p) b- c3 T这一段代码都完成什么功能呢？主要完成ZI代码的初始化，也就是将一部分RAM初始化为0。其他环境初始化……
  I, y$ z/ ?0 ]$ `/ k2 [/ z) h
: H  N! S3 k* Q3 U, d
最后
到这里，一个程序，是怎么组成的，程序是如何运行的，基本有一个总体印象了。


3 b0 A- ^# R6 ]0 q转载自： [color=var(--weui-LINK)][url=]STM32嵌入式开发[/url]
如有侵权请联系删除
6 T5 k; A1 p# m4 b9 A0 `2 K3 d" _
: x  D2 c1 @0 z! E2 @5 D