一、什么是BSS段(ZI段)
bss段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。
bss是英文Block Started by Symbol的简称。
bss段属于静态内存分配。

二、为什么要复制data段
$ x1 x' {( G4 O这是因为对于在STM32F103这类资源紧缺的单片机芯片中，数据段只是暂时先保存在Flash上，在使用前被复制到内存里，而复制到内存这个过程是需要我们自己实现的。

三、未处理的结果
! S8 e) Y0 R2 ~. i修改main函数如下所示：
. W1 F- V$ [4 |' J% M
) r! @% X8 y! W2 c" D

1. #include "uart.h"
   
2. #include "led.h"
   
3. 
   
4. int mydata = 0x32315;
   
5. const int myconst = 0x22315;
   
6. int myzero = 0;
   
7. int my;
   
8. 
   
9. int main(void)
   ! T8 c8 u; ]. m" o  Q, a; X! t& W, `
10. {
    
11.     uart_init();
    / k2 v: k( O2 S. k: b) V, p1 I! |
12.     led_init();
    
13.     putstring("stm32f103zet6\r\n");
    & e- e  S# A. I% @! q! K( z
14.         putstring("mydata\t:");
    7 `8 W$ }' u3 w$ I6 y% |' Q1 Q
15.     puthex((unsigned int)&mydata);
    9 u# w, \* t+ _0 x- c
16.     puthex((unsigned int)mydata);
    
17.     putstring("\r\nmyconst\t:");
    " s6 ]7 Y7 m7 e& A' t/ g0 G
18.     puthex((unsigned int)&myconst);
    7 R2 v# j% e4 y8 o3 B/ W) m
19.     puthex((unsigned int)myconst);
    2 b" _5 o# s! g+ D' S' B
20.         putstring("\r\nmyzero\t:");
    
21.     puthex((unsigned int)&myzero);
    
22.     puthex((unsigned int)myzero);
    9 B, t- i4 W, P
23.     putstring("\r\nmy\t:");
      w- U1 j5 R+ w2 |6 e
24.     puthex((unsigned int)&my);
    
25.     puthex((unsigned int)my);
    
26.     putstring("\r\n");
    - s# ~4 M4 m, ]5 c7 _* R/ {7 m+ P
27. 
    
28.     while(1)
    - q* z% K; k# o. r1 M# b, B
29.     {
    
30.                 putstring("led on\r\n");
    
31.         led_on();
    
32.         delay(1000000);
    
33. 
    
34.                 putstring("led off\r\n");
    
35.         led_off();
    ; c# a, o$ X; g- F/ ?% _; N
36.         delay(1000000);
    2 ?3 J) Z9 e; s8 ~8 K
37.     }
    
38. }
    4 R6 F" [) O" K

复制代码

/ @; z& `% k" B- E# t" {编译烧录运行，可以看到，除了存在Flash的只读全局变量的值正确，其他几个变量的值都是错误的
4 |  ~) G1 \9 g8 l
* q& \3 G2 W9 ^+ u, X' O- }* r
# F, s  M: |2 R( u+ F/ m
四、修改链接文件
既然要复制data段和清除BSS段，那么就需要知道如下几个数据

, D- V4 n: Q! P4 x1 O

1. 1、数据段的加载地址，即数据段存放在Flash的哪个位置
   + v) \( ~* @1 n
2. 2、数据段的链接地址，即数据段应该复制到在RAM的哪个位置
   
3. 3、数据段的长度，应该复制多长的数据从Flash到RAM
   
4. 4、BSS段的链接地址，即BSS段应该从何处开始清除
   
5. 5、ZI段的长度，应该清除多长的BSS段

复制代码

我们将链接文件修改为如下所示，得到data段的起始加载地址、起始链接地址和结束链接地址，以及bss段的起始链接地址和结束链接地址。其中>RAM AT > FLASH 表示存放时使用RAM地址，存放时使用FLASH地址。
- j/ e) L. f5 ~9 u& E

1. /* 指定内存区域 */
   9 \: U, v+ a- l) m. \3 ^
2. MEMORY
   
3. {
   
4.     FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 512K
   
5.     RAM (xrw)   : ORIGIN = 0x20000000, LENGTH = 64K
   
6. }
   ( v0 n& R3 ?' c7 q
7. 
   
8. SECTIONS {
   
9. 
   4 h6 a4 _8 Z1 D2 N$ M0 ^
10.     .text      :
    ) s8 s  h' j0 T  T9 O
11.     {
    ! a. W( Q9 u  U! c
12.         . = ALIGN(4);
      M8 X) B4 ~, c* u! s+ @' K4 Z7 }
13.         *start.o (.text)
    
14.         *main.o (.text)
    
15.         *(.text)
    ( ~. ]8 C+ Y: ~" x: z: ~7 m
16.     } > FLASH
    
17. 
    
18.     .rodata :
    
19.     {
    . v% l- {! s% w* _
20.         . = ALIGN(4);
      O( y8 l: ?0 L8 a# G  ^0 ^9 n
21.         *(.rodata)         /* .rodata sections (constants, strings, etc.) */
    1 ?6 L0 Z1 P/ t
22.         *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
    
23.         . = ALIGN(4);
      }1 ~- [5 ]4 ?
24.     } >FLASH
    
25. 
    % l) ]5 {, Z" }9 [
26.     _sidata = LOADADDR(.data);  /* 获取data段的起始加载地址 */
    $ p$ y" t5 p/ e! ~& c6 v* j
27.     .data :
    $ \$ S: m- I  L4 L' t4 \
28.     {
    
29.         . = ALIGN(4);
    
30.         _sdata = .;        /* 获取data段的起始链接地址 */
    
31.         *(.data)           /* .data sections */
    % a7 Y/ M4 b" L/ b+ Z1 d
32.         *(.data*)          /* .data* sections */
    6 E6 q# V  n  |
33.         . = ALIGN(4);
    # w7 e' F8 W& n# }: g
34.         _edata = .;        /* 获取data段的结束链接地址 */
    
35.     } >RAM AT > FLASH
    / l! H$ i1 S% F  c3 }
36. 
    
37.     . = ALIGN(4);
    
38.     .bss :
    
39.     {
    
40.         _sbss = .;         /* 获取bss段的起始链接地址 */
    % n  `! m' f! Z2 |& A$ H
41.         *(.bss)
    2 _. d0 R9 u2 B. E' h
42.         *(.bss*)
    # h. K! ]+ ]# G
43.         *(COMMON)
    1 y- d% B, J# ?% e6 y0 }- b* h
44. 
    
45.         . = ALIGN(4);
    9 L2 p& ]# d& W
46.         _ebss = .;         /* 获取bss段的结束链接地址 */
    
47.     } >RAM
    
48. }

复制代码

五、修改汇编文件
在start.s中加入如下代码复制data段和清除bss段的代码，其中data段的起始加载地址_sidata、起始链接地址_sdata和结束链接地址_edata，以及bss段的起始链接地址_sbss和结束链接地址_ebss，都是从链接脚本中获取的。

1. 
   
2.   .syntax unified                   /* 指明当前汇编文件的指令是ARM和THUMB通用格式 */
   9 C; ^. I: G- `  X: |7 ]
3.   .cpu cortex-m3                    /* 指明cpu核为cortex-m3 */
   
4.   .fpu softvfp                      /* 软浮点 */
   ! U' o9 R5 r3 Z1 g) m4 H
5.   .thumb                            /* thumb指令 */
   + N7 t4 @' v3 F. m9 i; f
6. 
   4 g7 S/ [  ~- R  z
7. .global  _start                     /* .global表示Reset_Handler是一个全局符号 */
   / B) L; h& @  g; a5 A6 w" {
8. 
   
9. .word 0x00000000                    /* 当前地址写入一个字(32bit)数据，值为0x00000000，实际上应为栈顶地址 */
   # {0 ?3 u% H( p" ]0 f# @- F
10. .word _start+1                      /* 当前地址写入一个字(32bit)数据, 值为_reset标号代表的地址+1，即程序入口地址*/
    , l. |% J/ l3 \' I0 b
11. 
    
12. _start:                             /* 标签_start，汇编程序的默认入口是_start */
    
13.     /* 1、设置栈 */
    : ]' ^- `! R8 h! S
14.     LDR SP, =(0x20000000+0x400)
    
15. 
    
16.     /* 2、复制data段 */
    
17.         movs r1, #0                                                /* r1寄存器用来计数 */
    # ]$ x. w2 R0 x1 b: M5 m+ c
18.     b LoopCopyDataInit
    2 \" ~+ @3 _5 n5 s
19. 
    2 U! x  D' P0 T; k9 i; C+ U. \
20. CopyDataInit:
    * Y+ ~0 }) J+ n" }! P6 L9 }. j
21.     ldr r3, =_sidata                                /* 将data段的起始加载地址存入r3寄存器 */
    
22.     ldr r3, [r3, r1]                                /* 从Flash取出data段的值存入r3寄存器 */
    2 S$ s' _2 Q) C# }2 P* i5 g
23.     str r3, [r0, r1]                                /* 将r3寄存器的值存入RAM中 */
    : O; y" p: p0 |; y" n. ?! f$ p
24.     adds r1, r1, #4                                        /* 每次复制4个字节的data段数据 */
    3 N" B5 q' s5 Z* C1 e6 s# p+ ]9 [
25. 
    
26. LoopCopyDataInit:
      u$ k) j' k% T. e# j
27.     ldr r0, =_sdata                                        /* 将data段的起始链接地址存入r0寄存器 */
    3 i( a1 p% _' a' ?* F% m  [
28.     ldr r3, =_edata                                        /* 将data段的结束链接地址存入r0寄存器 */
    ! \  P' I9 G- h7 T4 Y9 }$ k& R2 B& L
29.     adds r2, r0, r1                                        /* 起始链接地址加上计数，即当前复制地址存入r2寄存器 */
    
30.     cmp r2, r3                                                /* 当前复制地址和结束链接地址相比较 */
    
31.     bcc CopyDataInit                                /* 如果r2小于等于r3跳转到CopyDataInit标签处，如果大于则往下执行 */
      U, g) o; {; d* _9 Z
32. 
    
33.     /* 3、清除bss段 */
    
34.         ldr r2, =_sbss                                        /* 将bss段的起始链接地址存入r2寄存器 */
    ( W' S& \& e' X- \
35.         b LoopFillZerobss
    
36. 
    : H6 X+ ^' K+ L" H, g
37. FillZerobss:
    
38.         movs r3, #0                                                /* 将0存入r3寄存器 */
    7 e6 E' X5 l3 }* |) E5 Q) K
39.         str r3, [r2], #4                                /* 将r3中的值存到r2中的值所指向的地址中, 同时r2中的值加4 */
    
40. 
    
41. LoopFillZerobss:
    9 t3 d; [0 C4 }3 k+ H& }* X, M
42.         ldr r3, = _ebss                                        /* 将bss段的结束链接地址存入r3寄存器 */
    - D9 m- `7 t. L4 m+ J2 }# D9 L
43.         cmp r2, r3                                                /* 比较r2和r3内的值,即当前清除地址和结束链接地址相比较 */
    
44.           bcc FillZerobss                                        /* 如果r2小于等于r3跳转到FillZerobss标签处，如果大于则往下执行 */
    
45. 
    8 }) Q3 m2 k  Q  Z
46.     /* 4、跳转到led函数 */
    
47.     BL main
    
48.     /* 5、原地循环 */
    
49.     B .
    
50. 
    , Y* ]' o: W$ }, C. g

复制代码

9 @( t! C) b+ L2 h然后编译运行烧录，这样我们就可以看到变量的值正常了
1 o' H5 S$ w0 O. E" K


————————————————
! a+ I9 ~* l  i  d2 ?% F4 p转载：Willliam_william
* T3 Q9 {0 X9 [; |& E. M; x
2 @: B  E* A. X2 [9 B6 P