一、启动流程
对于STM32F103从flash的启动流程如下：
首先设置栈：CPU会从0x08000000读取值，用来设置SP(不使用C语言可以不设置，或者在程序里设置SP)
然后跳转：CPU从0x08000004得到地址值，根据它的BIT0切换为ARM状态或Thumb状态，然后跳转
  N! F( e; S1 B$ o          对于cortex M3/M4，它只支持Thumb状态，所以0x08000004上的值bit0必定是1
           0x08000004上的值 = Reset_Handler + 1
4 y( A& p4 k: R) v5 ?9 |& ]6 i+ @接着就从Reset_Handler继续执行
二、在keil-MDK下编写程序
打开keil，新建工程，选择STM32F103ZE
4 o# t' Z% P+ N) e# H6 e* \( f

7 z6 R3 p8 `$ Z% m7 T' H
新建start.s文件，编写如下代码；
6 d8 b/ X4 ~8 J

1. 
   
2. 
   
3. 
   
4.                 PRESERVE8                                                        ;指示编译器8字节对齐
   6 C7 o, s3 Y4 |7 T4 j
5.                 THUMB                                                                ;指示编译器以后的指令为THUMB指令                                                               
   2 S6 f" S% h( \! o& g1 ~
6. 
   1 [7 D4 M( _$ K0 t, }% v% G
7. 
   
8. ; Vector Table Mapped to Address 0 at Reset
   1 ~8 ?: d' K* H5 f/ F$ B
9.                                 AREA    RESET, CODE, READONLY                ;定义只读数据段，标记为RESET，其实放在CODE区，位于0地址
   * C& _! `+ w" t) t, X
10.                                 EXPORT  __Vectors                                        ;在程序中声明一个全局的标号__Vectors，该标号可在其他的文件中引用
    
11.                                        
    4 @* i3 r9 i% G8 ~5 d
12. __Vectors       DCD     0                                        ;当前地址写入一个字(32bit)数据，值为0x00000000，实际是应该填入栈顶地址
    
13.                 DCD     Reset_Handler                      ;当前地址写入一个字(32bit)数据，值为Reset_Handler的值，即程序入口地址
    
14. 
    
15.                                 AREA    |.text|, CODE, READONLY                ;定义代码段，标记为.text
    7 c; T* D# j2 ~, y5 a% r' I  }& x- a
16. 
    
17. ; Reset handler        ;利用PROC、ENDP这一对伪指令把程序段分为若干个过程，使程序的结构加清晰
    
18. Reset_Handler   PROC                                                                ;过程的开始
    
19.                                 EXPORT  Reset_Handler        [WEAK]                ;[WEAK] 弱定义，意思是如果在别处也定义该标号(函数)，在链接时用别处的地址。
    * s1 ^4 I- v; |% L, b9 I  i6 ?' Q
20. 
    " O1 Y; W; \. t$ C" }. ]* \. y0 K
21.                                 ; 1、使能 GPIOB
    
22.                                 LDR R0, =(0x40021000 + 0x18)
    3 Q# u3 G) q; j+ h
23.                                 LDR R1, [R0]
    
24.                                 ORR R1, R1, #(1<<3)
    
25.                                 STR R1, [R0]
    4 Z. d/ k8 F0 t+ A! l% h5 l9 E
26.                                 
    
27.                                 ; 2、把GPIOB5设置为输出引脚
    
28.                                 LDR R0, =(0x40010C00 + 0x00)
    
29.                                 LDR R1, [R0]
    - C( s* l9 ^# z* x6 w, ]
30.                                 ORR R1, R1, #(1<<20)
    
31.                                 STR R1, [R0]
    / o, P; p. N4 u; [- a
32.                                 
    
33.                                 ; 3、设置GPIOB5的输出寄存器
    
34.                                 LDR R2, =(0x40010C00 + 0x0C)
    " B& y; ]7 I; N6 D# b
35.                                 
    8 p; J+ N  y& u" c- s9 h* T
36.                                 ;4、loop循环
    
37. Loop                                
    . Q$ U0 x9 z1 g% i! h1 t1 k; D) E
38.                                 ; 5、设置GPIOB5输出高
    
39.                                 LDR R1, [R2]
    
40.                                 ORR R1, R1, #(1<<5)
    
41.                                 STR R1, [R2]
    - r0 m% l( ?' L" k3 ?1 F5 p
42.                                 
    
43.                                 LDR R0, =1000000
    1 a0 b; S5 S' f5 D$ _
44.                                 BL delay
    . r: \; j" p# S
45.                                 
    - p' ~' q4 ?$ V5 J
46.                                 ; 6、设置GPIOB5输出低
    
47.                                 LDR R1, [R2]
    " _8 q) A3 s$ P& y
48.                                 BIC R1, R1, #(1<<5)
    
49.                                 STR R1, [R2]
    % d, v7 u4 b6 s  e7 b( v% ^' t7 L' f) `
50.                                 
    
51.                                 LDR R0, =1000000
    8 Q% ^- A! P1 ~+ m
52.                                 BL delay
    7 T6 k7 [: @! |; `* b
53.                                 
    4 X9 ^: K6 _' ?1 k- R
54.                                 B Loop
    9 L( X" L; b& B: ^; T  }! l2 d( @
55.                 ENDP                                                                ;过程的结束
    & l* g& u/ \1 z$ f
56. 
    
57. delay
    
58.                                 SUBS R0, R0, #1
    # q3 G1 ~  a# T9 M2 r; o. N
59.                                 BNE delay
    
60.                                 BX LR
    
61. 
    
62.                 ALIGN                                                                 ;填充字节使地址对齐
    1 ~) j1 _9 L2 `8 q) G  E1 u6 m. @* V
63.                 END                                                                        ;整个汇编文件结束

复制代码

. E) c7 A) m; l# t* r' {然后添加如下两行在编译中执行的命令：

1. fromelf  --bin  --output=led.bin  Objects\led.axf
   
2. fromelf  --text  -a -c  --output=led.dis  Objects\led.axf

复制代码

或者如下通用命令，和上面的命令是等效的

1. fromelf --bin -o "[        DISCUZ_CODE_2        ]lt;a href="mailto:L@L.bin">L@L.bin</a>" "#L"
   
2. fromelf --text -a -c --output="[        DISCUZ_CODE_2        ]lt;a href="mailto:L@L.dis">L@L.dis</a>" "#L"

复制代码

第一行生成.bin文件，第二行生成反汇编.dis文件
7 `: L& ]/ U& T* B7 s% h
( }- \9 F7 w3 H/ t( J
# t) \$ d1 y/ U6 y! y6 y
- q" D0 N& b+ j4 G) C然后点击构建，可以看到，已经生成了led.bin文件和反汇编led.dis文件



打开led.dis和led.bin文件，可以看到，因为stm32f103的cotex-m3内核使用的是Thumb指令集，所以其指令长度既有16位又有32位；按stm32在flash模式下的启动顺序，先在0x0800000地址下获取栈地址，在0x08000000地址下获取程序入口地址+1的值，其中最后一位1表示thumb指令。

. T! m3 Q6 U! @0 p
6 n& W  \7 }& p4 Q
将其烧写到开发板，可以看到其LED灯闪烁
: j2 |: N6 t( T7 N& c" u# x7 U
. l" ?: i8 p, m' v: y
$ u5 ^+ p% i- |; W( z) }6 x% T* s
: `6 g2 k# [1 U* w& k0 e1 `三、使用gcc编译程序
4 D+ [2 M" V  n7 f  @& N5 t编写在gcc下使用的start.s汇编代码
- X7 S2 U) Q0 p0 F" D
$ r. |; G* z7 m( Q- X* Z6 t7 J

1. 
   & S% ]+ ?) u7 H9 P4 q
2.   .syntax unified                   /* 指明当前汇编文件的指令是ARM和THUMB通用格式 */
   
3.   .cpu cortex-m3                    /* 指明cpu核为cortex-m3 */
   1 D/ S+ T& P: s+ Q
4.   .fpu softvfp                      /* 软浮点 */
   
5.   .thumb                            /* thumb指令 */
   , ?' |5 O" ~' P$ H( A3 J
6. 
   ; Q' B6 _6 z4 F+ E  B
7. .global  _reset                     /* .global表示_start是一个全局符号 */
   
8. 
   
9. .word 0x00000000                    /* 当前地址写入一个字(32bit)数据，值为0x00000000，实际上应为栈顶地址 */
   9 \, S$ j3 ]" a8 M4 d$ y
10. .word _reset+1                      /* 当前地址写入一个字(32bit)数据, 值为_reset标号代表的地址+1，即程序入口地址*/
    5 _4 o' a, t) e6 Q
11. 
    % I; s1 w; b4 @
12. _reset:                             /* 标签_start，汇编程序的默认入口是_start */
    / P7 ?) |. Q. g  o; s0 j1 @2 R
13.     /* 1、使能 GPIOB */
    : \' w+ a& f  G! u
14.     LDR R0, = (0x40021000 + 0x18)   /* 将APB2外设时钟使能寄存器的地址值写入R0 */
      g! x# D$ a9 Z
15.     LDR R1, [R0]                    /* 读取该寄存器的值 */      
      v3 w  O: T# {( J9 d6 l
16.     ORR.W R1, R1, #(1<<20)             /* 修改读出的值 */
    # p$ `1 `; U5 @$ ^
17.     STR R1, [R0]                    /* 写入修改后的值到该寄存器 */
    $ `, b' S% _: ]- P4 t' b
18. 
    , z: D) N( o$ `& |( b  a
19.     /* 2、把GPIOB5设置为输出引脚 */
    
20.     LDR R0, = (0x40010c00 + 0x00)
    0 R! E! U7 F( E8 G' c" x1 L
21.     LDR R1, [R0]
    
22.     ORR.W R1, R1, #(1<<20)
    
23.     STR R1, [R0]
    % e2 d2 p& }" ?+ t; S9 n! n$ Z
24. 
    
25.     /* 3、设置GPIOB5的输出寄存器 */
    
26.     LDR R2, = (0x40010c00 + 0x0c)
    
27. 
    
28.     /* 4、loop循环 */
    8 Z: ~" U, u6 X. Y
29. loop:
    
30.     /* 5、设置GPIOB5输出高 */
    9 ?' A, I+ L7 j1 S+ t
31.     LDR R1, [R2]
    
32.     ORR.W R1, R1, #(1<<5)
    
33.     STR R1, [R2]
    4 F. O0 u4 k6 [) i4 ], M: U
34. 
    
35.     LDR R0, =1000000
    + o" \5 `, z7 N  A- O0 S
36.     BL delay
    5 Y8 g9 ~. n- I
37. 
    
38.     /* 6、设置GPIOB5输出低 */
    
39.     LDR R1, [R2]
    
40.     BIC.W R1, R1, #(1<<5)
    $ d9 {& K' h4 V9 {9 y1 J
41.     STR R1, [R2]
    
42. 
    # C9 V% i6 Y3 Y( L* S- ?
43.     LDR R0, =1000000
    ' u$ d# n5 A6 i) Q9 I0 T- j  i  r
44.     BL delay
    1 w7 s0 _4 _+ g4 f) r
45. 
    
46.     b loop
    4 Y# c1 H8 a3 ]9 J
47. 
    
48. delay:
    
49.     SUBS R0,R0,#1
    ; |9 z: T9 X& X- @0 K9 A4 P
50.     BNE delay
    
51.     BX LR

复制代码

0 C. r3 F7 q  f3 x" N8 ]2 n以及Makefile文件如下
0 x& D  p8 A# U9 P$ r+ v5 W" ~

1. 
   ! T7 w5 Q" ^" m3 h% G
2. led.bin:start.S
   2 _2 D, o3 n& T' ?  |
3.         arm-none-eabi-gcc -c start.s -o led.o
   
4.         arm-none-eabi-ld led.o -Ttext 0X80000000 -o led.elf
   
5.         arm-none-eabi-objcopy led.elf -O ihex led.hex
   ! \" g0 R4 Y9 o2 l% f8 O' C6 l
6.         arm-none-eabi-objcopy led.elf -O binary -S led.bin
   ; a+ v) C) I' H/ l, `
7.         arm-none-eabi-objdump -D -m cortex-m3 led.elf > led.dis
   " |& O4 L; c! O$ g! b
8. 
   . w/ V0 D" k! |6 e% f
9. clean:
   + x+ y' c7 ^7 L: _
10.         rm -rf *.o led.elf led.hex led.bin led.dis

复制代码

; {: y! Z& g% }1 a/ l; W然后执行make命令，如下所示，编译成功，



将其烧写到开发板，可以看到其LED灯闪烁
6 z. T7 D4 E6 [8 |$ v, E
4 A$ M! S  M/ u. O4 ]1 v; R/ B

0 y$ L# e$ G0 D$ L( A1 Y( D2 \四、比较MDK和GCC编译差别
0 w4 ]8 m5 t3 g, O分别比较两个.dis文件，如下所示，按stm32在flash模式下的启动顺序，先在0x0800000地址下获取栈地址，在0x08000000地址下获取程序入口地址+1的值，其中最后一位1表示thumb指令。
  s8 J  q; K2 z$ @( F9 @& G另外发现其中有一个位置不同，但在汇编文件中使用的指令是相同的，这是因为gcc编译器会强制将SUBS有两个相同寄存器指令转换为单个寄存器操作。

& j; [% F( X# P6 U+ j6 K% ^' h

————————————————
转载：Willliam_william


' i+ e( }. m0 d" S" r# v! f% t