【经验分享】STM32启动过程--启动文件--分析

[复制链接]

STMCU小助手发布时间：2022-1-13 21:00

技术帖
文章封面:
文章简介:	STM32启动过程--启动文件--分析

一、概述

1、说明

　　每一款芯片的启动文件都值得去研究，因为它可是你的程序跑的最初一段路，不可以不知道。通过了解启动文件，我们可以体会到处理器的架构、指令集、中断向量安排等内容，是非常值得玩味的。

　　STM32作为一款高端Cortex-M3系列单片机，有必要了解它的启动文件。打好基础，为以后优化程序，写出高质量的代码最准备。

　　本文以一个实际测试代码--START_TEST为例进行阐述。

2、整体过程概括

　　STM整个启动过程是指从上电开始，一直到运行到main函数之间的这段过程，步骤为（以使用微库为例）：

①上电后硬件设置SP、PC

②设置系统时钟

③软件设置SP

④加载.data、.bss，并初始化栈区

⑤跳转到C文件的main函数

3、整个启动过程涉及的代码

　　启动过程涉及的文件不仅包含startup_stm32f10x_hd.s，还涉及到了MDK自带的连接库文件entry.o、entry2.o、entry5.o、entry7.o等（从生成的map文件可以看出来）。

二、程序在Flash上的存储结构

　　在真正讲解启动过程之前，先要讲解程序下载到Flash上的结构和程序运行时（执行到main函数）时的SRAM数据结构。程序在用户Flash上的结构如下图所示。下图是通过阅读hex文件和在MDK下调试综合提炼出来的。

MSP初始值　　　　　　　　编译器生成，主堆栈的初始值

异常向量表　　　　　　　　不多说

外部中断向量表　　　　　　不多说

代码段　　　　　　　　　　存放代码

初始化数据段　　　　　　　.data

未初始化数据段　　　　　　.bss

加载数据段和初始化栈的参数

　　加载数据段和初始化栈的参数分别有4个，这里只讲解加载数据段的参数，至于初始化栈的参数类似。

0x0800 033c　　Flash上的数据段（初始化数据段和未初始化数据段）起始地址

0x2000 0000　　加载到SRAM上的目的地址

0x0000 000c　　数据段的总大小

0x0800 02f4　　调用函数_scatterload_copy

　　需要说明的是初始化栈的函数--0x0800 0304与加载数据段的函数不一样，为_scatterload_zeroinit，它的目的就是将栈空间清零。

三、数据在SRAM上的结构

　　程序运行时（执行到main函数）时的SRAM数据结构

四、详细过程分析

　　有了以上的基础，现在详细分析启动过程。

1、上电后硬件设置SP、PC

　　刚上电复位后，硬件会自动根据向量表偏移地址找到向量表，向量表偏移地址的定义如下：

　　调试现象如下：

　　看看我们的向量表内容（通过J-Flash打开hex文件）

　　硬件这时自动从0x0800 0000位置处读取数据赋给栈指针SP，然后自动从0x0800 0004位置处读取数据赋给PC，完成复位，结果为：

SP = 0x0200 0810

PC = 0x0800 0145

2、设置系统时钟

, B8 q8 e2 l% x& ^) y9 q& u5 M

# r0 }3 O- P% d2 D1 _# @1 n, q) Y

　　上一步中令PC=0x0800 0145的地址没有对齐，硬件自动对齐到0x0800 0144，执行SystemInit函数初始化系统时钟。

3、软件设置SP

LDR R0,=__main　　* m8 T& u6 h1 p! B6 O
BX　　 R0

复制代码

　　执行上两条之类，跳转到__main程序段运行，注意不是main函数，___main的地址是0x0800 0130。

　　可以看到指令LDR.W sp,[pc,#12]，结果SP=0x2000 0810。

4、加载.data、.bss，并初始化栈区

BL.W __scatterload_rt2

复制代码

　　进入 __scatterload_rt2代码段。

__scatterload_rt2:: n3 t, J# _2 u7 D% R6 h' @7 U
0x08000168 4C06 LDR r4,[pc,#24] ; @0x08000184* L3 P( O P5 j6 A. i- w* s) Y1 S
0x0800016A 4D07 LDR r5,[pc,#28] ; @0x08000188
) p) D- Q" |( P9 X1 s; D
0x0800016C E006 B 0x0800017C
8 y$ @! j" `% I; v9 _7 U1 g
0x0800016E 68E0 LDR r0,[r4,#0x0C]
" f' c3 N- j( h: F6 {5 _ r2 w
0x08000170 F0400301 ORR r3,r0,#0x01% b5 X; K2 B- v
0x08000174 E8940007 LDM r4,{r0-r2}
8 k$ Q- e% ^( e" u; W( I
0x08000178 4798 BLX r31 A; X3 |5 F$ e/ ~
0x0800017A 3410 ADDS r4,r4,#0x10
( t% r6 C5 a, @0 U5 c2 r* K
0x0800017C 42AC CMP r4,r5% q2 q9 N. j) ?( _
0x0800017E D3F6 BCC 0x0800016E9 v1 g: l% H0 i2 r# k/ v
0x08000180 F7FFFFDA BL.W _main_init (0x08000138)

复制代码

　　这段代码是个循环（BCC 0x0800016e），实际运行时候循环了两次。第一次运行的时候，读取“加载数据段的函数（_scatterload_copy）”的地址并跳转到该函数处运行（注意加载已初始化数据段和未初始化数据段用的是同一个函数）；第二次运行的时候，读取“初始化栈的函数（_scatterload_zeroinit）”的地址并跳转到该函数处运行。相应的代码如下：

0x0800016E 68E0 LDR r0,[r4,#0x0C]0x08000170 F0400301 ORR r3,r0,#0x010x08000174
0x08000178 4798 BLX r3
　　
　　当然执行这两个函数的时候，还需要传入参数。至于参数，我们在“加载数据段和初始化栈的参数”环节已经阐述过了。当这两个函数都执行完后，结果就是“数据在SRAM上的结构”所展示的图。最后，也把事实加载和初始化的两个函数代码奉上如下：

0x0800016E 68E0 LDR r0,[r4,#0x0C]
6 B" D' W- L" \: t( q' Q
0x08000170 F0400301 ORR r3,r0,#0x01& f0 M. F1 J6 n9 C% `) g
0x08000174
/ S( a2 m- @# F/ C3 X! N! }
0x08000178 4798 BLX r3

复制代码

当然执行这两个函数的时候，还需要传入参数。至于参数，我们在“加载数据段和初始化栈的参数”环节已经阐述过了。当这两个函数都执行完后，结果就是“数据在SRAM上的结构”所展示的图。最后，也把事实加载和初始化的两个函数代码奉上如下：

__scatterload_copy:
7 y5 S8 @" |, F, a0 ]6 V
0x080002F4 E002 B 0x080002FC" u( x' m# E. x; G
0x080002F6 C808 LDM r0!,{r3}9 ]+ ~1 m8 ]6 D; K. P
0x080002F8 1F12 SUBS r2,r2,#46 ~& o" |7 t3 n W7 S
0x080002FA C108 STM r1!,{r3}; Q4 c( `$ l2 ~# ^5 Y @
0x080002FC 2A00 CMP r2,#0x00
: E5 q0 ^1 S# v' Z
0x080002FE D1FA BNE 0x080002F63 v5 u+ a1 L7 X0 _- }) V
0x08000300 4770 BX lr. w4 s, I f) n2 w
__scatterload_null:2 w5 x" F& Q+ W! [0 _1 j
0x08000302 4770 BX lr7 ^7 z0 p, ?9 Q
__scatterload_zeroinit:
; i* U/ o8 n0 d+ k; K
0x08000304 2000 MOVS r0,#0x00
+ g/ t# D8 c$ r* Z" C5 l0 o
0x08000306 E001 B 0x0800030C
& ?5 T4 @& z5 |& Y& B; K: }
0x08000308 C101 STM r1!,{r0}
# d( v( K# d$ J2 v. f: x
0x0800030A 1F12 SUBS r2,r2,#46 B# R0 o4 O' W
0x0800030C 2A00 CMP r2,#0x00
7 O/ C I: P3 }9 W+ J
0x0800030E D1FB BNE 0x08000308
! b! j: D' G- a
0x08000310 4770 BX lr

复制代码

5、跳转到C文件的main函数

_main_init:
4 H( v9 E) q+ `0 b. f& h1 B8 e
0x08000138 4800 LDR r0,[pc,#0] ; @0x0800013C- q/ V" h2 W: c
0x0800013A 4700 BX r0

复制代码

五、异常向量与中断向量表

; Vector Table Mapped to Address 0 at Reset
& S- ?' l* `& w' d+ _
AREA RESET, DATA, READONLY% d, \ t! l/ Y5 z
EXPORT __Vectors) r. ?4 V% J8 [ V( n5 Q" M
EXPORT __Vectors_End" D1 S+ {: a& A9 L |6 u
EXPORT __Vectors_Size) ~- f5 l, w7 L6 j1 R
0 ]5 Q2 N. t% M
__Vectors DCD __initial_sp ; Top of Stack
" F( Z. a0 f( w7 a5 @' H
DCD Reset_Handler ; Reset Handler) H4 A6 a% k% `8 I
DCD NMI_Handler ; NMI Handler K& G0 q; b! v2 z
DCD HardFault_Handler ; Hard Fault Handler
% v6 }3 Z( W5 K4 R2 G5 D/ w; n, ^
DCD MemManage_Handler ; MPU Fault Handler, D3 F5 T* G, G7 S% z+ U
DCD BusFault_Handler ; Bus Fault Handler
/ q2 e4 l# E7 D. ^: ?& Z
DCD UsageFault_Handler ; Usage Fault Handler
" E* W0 R% ^+ K( J
DCD 0 ; Reserved
: w* V2 a! ]5 u+ O. }" f% f
DCD 0 ; Reserved6 D% Z: z5 ]1 H
DCD 0 ; Reserved! g ^; z1 d* I: X: I$ }. j" N* z
DCD 0 ; Reserved
' _1 S: E2 y7 } B3 u
DCD SVC_Handler ; SVCall Handler
: V, G) K: n% B
DCD DebugMon_Handler ; Debug Monitor Handler9 a* ?) T' t" X3 {2 Z, o& g
DCD 0 ; Reserved( \# U7 D. { D( W, M2 f
DCD PendSV_Handler ; PendSV Handler
8 h! z" d6 V7 g/ Y! ]# E
DCD SysTick_Handler ; SysTick Handler( ~! x" J, D+ n e3 u$ G( s8 g$ f
0 M+ q) T( E" v+ ~+ z$ v
; External Interrupts
: b ^1 R' U' }1 m, n3 j. I1 @
DCD WWDG_IRQHandler ; Window Watchdog' v' |4 Q; B9 s* Q9 Y. e
DCD PVD_IRQHandler ; PVD through EXTI Line detect: K; x8 T N/ r& g5 Q
DCD TAMPER_IRQHandler ; Tamper
, h8 J5 ?' \6 u: u* n3 r
DCD RTC_IRQHandler ; RTC% Z2 L; D) W3 E6 k" S9 Y
DCD FLASH_IRQHandler ; Flash7 f- s0 p8 r5 c4 B2 c6 l% K. T
DCD RCC_IRQHandler ; RCC7 w2 X% @. v' j
DCD EXTI0_IRQHandler ; EXTI Line 0! i% X; N7 W" v- T c
DCD EXTI1_IRQHandler ; EXTI Line 1
% ]' Q& W8 e' Q6 q Z
DCD EXTI2_IRQHandler ; EXTI Line 23 P( y. g; ^* C/ {5 ]
DCD EXTI3_IRQHandler ; EXTI Line 3
0 i9 L n/ h2 e u
DCD EXTI4_IRQHandler ; EXTI Line 46 T/ W9 u9 X2 C- ~) x" |% y/ i
DCD DMA1_Channel1_IRQHandler ; DMA1 Channel 1
g% H' O! h5 H6 A9 h
DCD DMA1_Channel2_IRQHandler ; DMA1 Channel 2% ~; J B+ j9 R
DCD DMA1_Channel3_IRQHandler ; DMA1 Channel 3
. v7 T6 c1 `- w1 A
DCD DMA1_Channel4_IRQHandler ; DMA1 Channel 4
* g- z5 i) Y9 L" |* Z
DCD DMA1_Channel5_IRQHandler ; DMA1 Channel 5* s& j& Y9 B+ D, G
DCD DMA1_Channel6_IRQHandler ; DMA1 Channel 6" C6 b5 ]2 v& Q! n$ @9 \% C
DCD DMA1_Channel7_IRQHandler ; DMA1 Channel 7' I8 S) C9 I F) {* x0 o2 J
DCD ADC1_2_IRQHandler ; ADC1 & ADC2
" h( A% Q( D' Z9 A2 P& y- m' b6 `
DCD USB_HP_CAN1_TX_IRQHandler ; USB High Priority or CAN1 TX. u3 ]- ?0 x# j6 i& L4 ]
DCD USB_LP_CAN1_RX0_IRQHandler ; USB Low Priority or CAN1 RX0
6 {- C! Q" R1 q
DCD CAN1_RX1_IRQHandler ; CAN1 RX1 y2 u; r& d$ C& \1 z% E k
DCD CAN1_SCE_IRQHandler ; CAN1 SCE0 n$ L1 B7 _8 Y/ H
DCD EXTI9_5_IRQHandler ; EXTI Line 9..5
* |6 e! z; T+ x' H
DCD TIM1_BRK_IRQHandler ; TIM1 Break% E2 } H- M) l8 u0 S: k' x& i/ {
DCD TIM1_UP_IRQHandler ; TIM1 Update
& Q* |; |/ _0 ~ Y' E
DCD TIM1_TRG_COM_IRQHandler ; TIM1 Trigger and Commutation
' c- I- _$ ?7 ]/ i" `+ O' Y; |
DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
( D2 r9 g0 C3 R% C
DCD TIM2_IRQHandler ; TIM2, E. l* I0 x8 L9 H
DCD TIM3_IRQHandler ; TIM3
; Y5 }; b- I( S) [; W
DCD TIM4_IRQHandler ; TIM4- ?% F+ `- V: Q9 R8 ]
DCD I2C1_EV_IRQHandler ; I2C1 Event
, \- x" X' v1 ^' Z5 `: D; ]
DCD I2C1_ER_IRQHandler ; I2C1 Error/ l. o$ W. ^8 F
DCD I2C2_EV_IRQHandler ; I2C2 Event1 ~; {$ V! e! p! G7 P9 u3 r X2 x. R
DCD I2C2_ER_IRQHandler ; I2C2 Error
c$ T' x h# z/ Q3 W4 z7 D
DCD SPI1_IRQHandler ; SPI1
6 f$ T ?; P& q8 t# D& K
DCD SPI2_IRQHandler ; SPI23 `* T6 K( t$ y+ W" [; O$ w7 b
DCD USART1_IRQHandler ; USART12 Y+ R0 e+ C% [7 k6 x
DCD USART2_IRQHandler ; USART2
3 h0 J* [; d- O, w1 m5 a3 N& m
DCD USART3_IRQHandler ; USART3; O0 m2 \: t, o
DCD EXTI15_10_IRQHandler ; EXTI Line 15..10
" b# k c9 e# y
DCD RTCAlarm_IRQHandler ; RTC Alarm through EXTI Line
$ r% X2 r) D+ |
DCD USBWakeUp_IRQHandler ; USB Wakeup from suspend
: F4 W* b9 M1 r$ |# I
DCD TIM8_BRK_IRQHandler ; TIM8 Break, r! O* d( J, k, v
DCD TIM8_UP_IRQHandler ; TIM8 Update3 u* f& S! W9 ^
DCD TIM8_TRG_COM_IRQHandler ; TIM8 Trigger and Commutation
|4 T2 {& q, a+ E8 O
DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare3 L8 A2 n% a$ x$ c+ s4 u0 r
DCD ADC3_IRQHandler ; ADC3" Z# R" j- Y/ m5 }; W
DCD FSMC_IRQHandler ; FSMC/ { V$ N* w; l8 ^% i. J6 r8 A
DCD SDIO_IRQHandler ; SDIO b6 }- q8 q h, v! N. X$ t
DCD TIM5_IRQHandler ; TIM5
' y! F2 Q9 K" }$ _" c
DCD SPI3_IRQHandler ; SPI3
. y- k* A) }: `" V) G" e
DCD UART4_IRQHandler ; UART4; v1 h; ~& ]8 A
DCD UART5_IRQHandler ; UART5
% D7 u4 F3 Z3 Z9 y2 K# U
DCD TIM6_IRQHandler ; TIM6
) W1 B* S: Q) h8 }# V& P
DCD TIM7_IRQHandler ; TIM7: B+ M! U0 k8 u
DCD DMA2_Channel1_IRQHandler ; DMA2 Channel1
+ {) ^; t! c( x/ b) [
DCD DMA2_Channel2_IRQHandler ; DMA2 Channel2. n6 p& s6 d5 f9 F+ f
DCD DMA2_Channel3_IRQHandler ; DMA2 Channel3. B# S) T% w8 s2 Z) k
DCD DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & Channel5. w- l1 p9 Y9 X$ J
__Vectors_End

复制代码

　　这段代码就是定义异常向量表，在之前有一个“J-Flash打开hex文件”的图片跟这个表格是一一对应的。编译器根据我们定义的函数 Reset_Handler、NMI_Handler等，在连接程序阶段将这个向量表填入这些函数的地址。

startup_stm32f10x_hd.s内容：& {; k1 K# @& y: i5 S' |3 R" o
0 G6 ^8 Q! k+ ?' J, S
NMI_Handler PROC; P5 \. ?: v9 D; F) K
EXPORT NMI_Handler [WEAK]
, u; M$ i, P5 E' R" e. U. p) W# c
B .
9 X2 Y* S8 R& S# J# t! m w
ENDP- x& T0 {# h$ D" @5 E# p( c
6 A# ]4 X& v" V# c8 W* ~8 c
+ B1 X- X2 ] f+ j2 V4 ]
stm32f10x_it.c中内容：
+ Y2 } ]% v' T
void NMI_Handler(void)
]- k9 V5 E$ E1 o( H
{
0 ]7 s$ P) A/ e0 W* g) ^0 W2 k, {
}

复制代码

　　在启动汇编文件中已经定义了函数NMI_Handler，但是使用了“弱”，它允许我们再重新定义一个NMI_Handler函数，程序在编译的时候会将汇编文件中的弱函数“覆盖掉”--两个函数的代码在连接后都存在，只是在中断向量表中的地址填入的是我们重新定义函数的地址。

六、使用微库与不使用微库的区别

+ @1 a7 Y! I& e; S2 x+ Q

　　使用微库就意味着我们不想使用MDK提供的库函数，而想用自己定义的库函数，比如说printf函数。那么这一点是怎样实现的呢？我们以printf函数为例进行说明。

1、不使用微库而使用系统库

　　在连接程序时，肯定会把系统中包含printf函数的库拿来调用参与连接，即代码段有系统库的参与。

　　在启动过程中，不使用微库而使用系统库在初始化栈的时候，还需要初始化堆（猜测系统库需要用到堆），而使用微库则是不需要的。

IF :DEF:__MICROLIB6 }- t3 b( S4 l: S6 X
I0 p1 F3 ~) h% t" }+ s# F
EXPORT __initial_sp
4 x. L* J M6 _! b# O* G% o
EXPORT __heap_base# l$ x Q, ^" r# Z; ^
EXPORT __heap_limit
# Q& e' o8 v* J; S
4 V' L6 o0 m2 }7 h& C
ELSE
+ ^* a A3 p7 w9 |. A( q' `
7 q9 |7 z$ R o ^: u, R
IMPORT __use_two_region_memory# o+ F# O8 b) ?) f$ h, i
EXPORT __user_initial_stackheap
' Z- D8 [3 X/ Q. n! p. H, }" `- s1 K
& e3 y( r3 L6 B3 v j
__user_initial_stackheap* B" C9 c7 v! X4 _ H. u8 V) i) F
! }: \" O# [$ i9 c; W# R" [
LDR R0, = Heap_Mem
) ^5 L6 b R* _5 F \
LDR R1, =(Stack_Mem + Stack_Size)
) ^. J, o! |3 a
LDR R2, = (Heap_Mem + Heap_Size)
% I/ U4 q* d4 k' c0 {
LDR R3, = Stack_Mem+ X- d0 Q$ i2 a1 J$ ~
BX LR
7 |4 V4 {) I, S/ p
4 d d- A$ [; ?# s0 m& o6 ^
ALIGN
5 T7 o- T {, M+ W
* l/ r5 y1 |+ \6 Y0 M0 @8 a8 N
ENDIF

复制代码

　　另外，在执行__main函数的过程中，不仅需要完成“使用微库”情况下的所有工作，额外的工作还需要进行库的初始化，才能使用系统库（这一部分我还没有深入探讨）。附上__main函数的内容：

__main:
2 O( o' v( S {" l
0x08000130 F000F802 BL.W __scatterload_rt2_thumb_only (0x08000138)
- w! V5 a) B5 X( E
0x08000134 F000F83C BL.W __rt_entry_sh (0x080001B0)* w! Y& k2 q, K7 P$ q
__scatterload_rt2_thumb_only:8 P( R2 d5 B0 y o
0x08000138 A00A ADR r0,{pc}+4 ; @0x08000164
* R7 n1 x% S2 N: ~
0x0800013A E8900C00 LDM r0,{r10-r11}+ V' N4 s, Z6 t+ X7 x
0x0800013E 4482 ADD r10,r10,r0
2 D& N+ c/ ~ ?2 c
0x08000140 4483 ADD r11,r11,r0
/ J0 L, ?- B9 ]/ v( d# U" ~/ ]
0x08000142 F1AA0701 SUB r7,r10,#0x01
' h1 [9 H; Y' y) ~3 |+ `
__scatterload_null:
0 C, t* u# k% \( ~2 r
0x08000146 45DA CMP r10,r11# G' {5 j# }8 a! L
0x08000148 D101 BNE 0x0800014E) P8 e( w+ D. n* Z+ }7 a, c/ V
0x0800014A F000F831 BL.W __rt_entry_sh (0x080001B0)
) a+ C/ q9 k) m' s. E
0x0800014E F2AF0E09 ADR.W lr,{pc}-0x07 ; @0x08000147
7 \1 z; N- d4 [' K+ C1 I. ?
0x08000152 E8BA000F LDM r10!,{r0-r3}$ d6 ?% I( |) z, B
0x08000156 F0130F01 TST r3,#0x01
5 l9 i- h/ R" Z+ \) g; [
0x0800015A BF18 IT NE
; ^4 J9 @0 X; [/ B( N
0x0800015C 1AFB SUBNE r3,r7,r3' [1 K( T. {. g4 Y6 Z
0x0800015E F0430301 ORR r3,r3,#0x01
2 w/ y* {$ p# g" T- w; h5 m, V4 \
0x08000162 4718 BX r3
5 R/ ^. N9 V9 V* {8 V# \5 t+ ]1 ]
0x08000164 0298 LSLS r0,r3,#10
! Y m# B" }% }
0x08000166 0000 MOVS r0,r0' X$ c6 V) ^2 q/ _5 R9 M* n
0x08000168 02B8 LSLS r0,r7,#10
& H7 V- L: W/ [$ z! o* U0 c
0x0800016A 0000 MOVS r0,r0) ^! O P k+ o7 T$ o. X" |6 z$ C
__scatterload_copy:
+ j+ W/ L$ V7 o; O( Z
0x0800016C 3A10 SUBS r2,r2,#0x10
. Z1 F4 N8 |0 x- [
0x0800016E BF24 ITT CS
7 w W7 X' X% ]# Q- p
0x08000170 C878 LDMCS r0!,{r3-r6}- O8 Y: J8 J4 c4 v
0x08000172 C178 STMCS r1!,{r3-r6}
8 \/ T9 }( z2 G# N4 _7 u, j
0x08000174 D8FA BHI __scatterload_copy (0x0800016C)
# d4 @' a( V; f
0x08000176 0752 LSLS r2,r2,#29
7 P- B% L" z. U* ]8 A( W
0x08000178 BF24 ITT CS
7 u; z; r4 k; t" L! C$ e8 a* _1 T
0x0800017A C830 LDMCS r0!,{r4-r5}
, n0 Z" \: ?% ~
0x0800017C C130 STMCS r1!,{r4-r5}
G o. Q$ f7 z$ W4 S2 \& b( C
0x0800017E BF44 ITT MI
* i. A5 z& T! S5 {. K
0x08000180 6804 LDRMI r4,[r0,#0x00]
( J. ~- @- M/ j
0x08000182 600C STRMI r4,[r1,#0x00]% I6 E7 }0 i( L% f4 u: j
0x08000184 4770 BX lr/ R0 @ e$ J% N4 H2 w
0x08000186 0000 MOVS r0,r0
9 |( {0 f5 O) c7 f- a: H
__scatterload_zeroinit:
" Y+ ]1 ?( x/ Q/ _( S9 G! `5 F% ~; F
0x08000188 2300 MOVS r3,#0x005 V6 x h' c' R, W% x' \: S6 B
0x0800018A 2400 MOVS r4,#0x00; q% q4 v# y6 O4 H% Z* a* H' E
0x0800018C 2500 MOVS r5,#0x00
2 y3 ~1 Z ? `% S& I2 ~! I
0x0800018E 2600 MOVS r6,#0x00# F7 H( |$ D; @! p1 ~; z9 A% P3 \1 {
0x08000190 3A10 SUBS r2,r2,#0x10" p. E4 f" z5 T; @1 ~
0x08000192 BF28 IT CS( W5 M& Y. x3 n: U/ U% ?& K: ^
0x08000194 C178 STMCS r1!,{r3-r6}
. b/ V% d0 e$ v& T
0x08000196 D8FB BHI 0x080001906 i% m: g( C; c* o
0x08000198 0752 LSLS r2,r2,#29
: ? i5 ~% e7 w
0x0800019A BF28 IT CS
# R! j c1 d7 G8 m; }' c
0x0800019C C130 STMCS r1!,{r4-r5}, l# m1 x4 i2 Q& v5 L
0x0800019E BF48 IT MI& z2 ^% s+ }# o- z5 \' A" |8 ~
0x080001A0 600B STRMI r3,[r1,#0x00]5 b4 C1 e. _7 D' h
0x080001A2 4770 BX lr$ Y g8 ^0 F w' h( _
__rt_lib_init:0 P/ y8 P* z0 ~" r7 K7 n
0x080001A4 B51F PUSH {r0-r4,lr}
9 m, [0 F n: p# ^
0x080001A6 F3AF8000 NOP.W
: m, k' f9 M4 F8 {
__rt_lib_init_user_alloc_1:
, C$ D; h' ?& S! M
0x080001AA BD1F POP {r0-r4,pc}. C4 U! c6 L J b) @
__rt_lib_shutdown:1 ?4 e1 P; B2 q% Y5 _
0x080001AC B510 PUSH {r4,lr}
6 Y& m. l6 r6 U: P
__rt_lib_shutdown_user_alloc_1:" \7 }: V2 ~7 z9 v, Z
0x080001AE BD10 POP {r4,pc}; J' i$ v0 U1 b/ m- s' O/ K! I
__rt_entry_sh:8 l H( h# [. G: C1 R6 X0 k$ P
0x080001B0 F000F82F BL.W __user_setup_stackheap (0x08000212)! `( N$ G$ D: K1 ~
0x080001B4 4611 MOV r1,r2
- F$ w/ I" K( s6 x0 L8 i" Q
__rt_entry_postsh_1:
: X# ]3 m6 v: f1 }, S* W8 J, \4 }
0x080001B6 F7FFFFF5 BL.W __rt_lib_init (0x080001A4)
; X. V/ z: ]' [
__rt_entry_postli_1:
; o8 g5 e3 f( A3 A
0x080001BA F000F919 BL.W main (0x080003F0)