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

【经验分享】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、设置系统时钟

" d/ p5 e) Y+ w* A9 |+ g

; O* d) e; c% }

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

3、软件设置SP

LDR R0,=__main　　
: C# e' C0 C0 K5 v4 |
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:2 D7 B' a) O- `9 d# c0 y$ g* c" Q0 g
0x08000168 4C06 LDR r4,[pc,#24] ; @0x08000184# D2 \# y0 p. u( ]! M
0x0800016A 4D07 LDR r5,[pc,#28] ; @0x08000188 N e8 T, ]% C; W4 M6 e
0x0800016C E006 B 0x0800017C8 o! B+ S) L3 ]
0x0800016E 68E0 LDR r0,[r4,#0x0C]
: O% x7 i! q' B: i# e
0x08000170 F0400301 ORR r3,r0,#0x01
1 Z% ?7 R% B. J3 W L/ p: t& k
0x08000174 E8940007 LDM r4,{r0-r2}& S% f6 n6 x' r$ A
0x08000178 4798 BLX r3
, j( Y& Q3 ~) f7 e) Y+ j. @
0x0800017A 3410 ADDS r4,r4,#0x10, f- f) q( n! ]( M
0x0800017C 42AC CMP r4,r53 L7 v) V" b2 A; ?) z) [2 v& n7 E( q5 O
0x0800017E D3F6 BCC 0x0800016E
0 v3 H n/ ` V, p" ~
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], f- g- ?# b) Z3 @) O! b$ f# A$ ~0 {
0x08000170 F0400301 ORR r3,r0,#0x01! g, }3 \) E I3 `
0x08000174
3 ~) G' Q4 h. F' S
0x08000178 4798 BLX r3

复制代码

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

__scatterload_copy:) `; i8 S3 y6 w* M0 b$ z
0x080002F4 E002 B 0x080002FC& U- L# z' U* G- Z" k' z: F* k
0x080002F6 C808 LDM r0!,{r3}4 L4 d2 Q1 g {( s% l) h
0x080002F8 1F12 SUBS r2,r2,#4- O$ u, |+ k6 _
0x080002FA C108 STM r1!,{r3}
; F7 y3 L" }( B0 W
0x080002FC 2A00 CMP r2,#0x00# G4 I/ s, G2 B3 H& ^
0x080002FE D1FA BNE 0x080002F6, A4 Z7 | O% E, |$ t( u
0x08000300 4770 BX lr
* d1 C4 @# o9 G% j0 V/ i
__scatterload_null:; b/ J# b5 G+ B9 v( G& ?
0x08000302 4770 BX lr& j; R- t1 E- |6 V# X
__scatterload_zeroinit:/ h8 ]; C: `: S" r- Y
0x08000304 2000 MOVS r0,#0x00
- n3 Q. |- n0 m6 e6 z0 e! t9 K6 B
0x08000306 E001 B 0x0800030C+ r* e. r, \/ b7 ^
0x08000308 C101 STM r1!,{r0}4 F+ b, ?, | @( @6 b* i
0x0800030A 1F12 SUBS r2,r2,#4/ d3 ]6 T# I" _7 h& S) I/ I5 C1 j# |) k
0x0800030C 2A00 CMP r2,#0x00
% s" M/ E3 c/ W y @, t
0x0800030E D1FB BNE 0x08000308
& f/ [, {3 o: w+ x9 {3 ?
0x08000310 4770 BX lr

复制代码

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

_main_init:$ T' d- L# E5 }3 N! n
0x08000138 4800 LDR r0,[pc,#0] ; @0x0800013C% t6 F' N9 l, }! Z
0x0800013A 4700 BX r0

复制代码

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

; Vector Table Mapped to Address 0 at Reset1 M' K7 c* V- O2 u, ]. q' y
AREA RESET, DATA, READONLY
. _4 f1 W% t& I$ c& d& m( ]4 B# W
EXPORT __Vectors8 n5 h0 @" j1 c" z# u
EXPORT __Vectors_End8 q5 j. J0 ~& [$ `# O7 [( y" U) F
EXPORT __Vectors_Size
5 ]4 @" J( L5 L8 F9 U
! p8 @) p; P0 Q& f0 p! p% W
__Vectors DCD __initial_sp ; Top of Stack
0 w; _0 b! ]/ e& s
DCD Reset_Handler ; Reset Handler
& v" `2 `7 x5 K1 N- D! s
DCD NMI_Handler ; NMI Handler
- z; o- S* {. h7 S) B1 Q4 d
DCD HardFault_Handler ; Hard Fault Handler5 a# r/ x ^: D( o3 |9 e
DCD MemManage_Handler ; MPU Fault Handler
8 c1 m' _: _2 Z w
DCD BusFault_Handler ; Bus Fault Handler
6 H4 ^6 ^' ^% j L
DCD UsageFault_Handler ; Usage Fault Handler
4 x1 D, B6 {1 p& x4 T4 |$ ] b4 g
DCD 0 ; Reserved
2 a: m9 Y8 g; u/ F x7 I
DCD 0 ; Reserved
+ n2 u6 N' V/ |6 G8 q( p- I" Q
DCD 0 ; Reserved. W7 @( B& h4 Q, r
DCD 0 ; Reserved
" ]4 W- D3 g! B4 r( Q6 b/ W5 _& k# d
DCD SVC_Handler ; SVCall Handler
1 A z- t5 ?& p# ^# n
DCD DebugMon_Handler ; Debug Monitor Handler
. P1 {/ o- D6 E$ x. F) Y( b( E
DCD 0 ; Reserved8 H) `( A5 M4 U- g4 Y
DCD PendSV_Handler ; PendSV Handler
. n- s' c: x f. C- T; B( u5 B
DCD SysTick_Handler ; SysTick Handler7 M* z$ ~: ?2 d& [( }$ f
' t: A2 Z1 x. |2 W; v. ^ q
; External Interrupts9 a: W, V, [& `; Q. j
DCD WWDG_IRQHandler ; Window Watchdog$ V V8 i8 T; r; f
DCD PVD_IRQHandler ; PVD through EXTI Line detect& J2 t& G; f8 U1 J1 U3 F
DCD TAMPER_IRQHandler ; Tamper% C" r0 V2 n: _
DCD RTC_IRQHandler ; RTC
, Z: E: ?+ Q; Q( C. Y/ v
DCD FLASH_IRQHandler ; Flash
/ z: M5 z8 x6 h
DCD RCC_IRQHandler ; RCC7 r- N1 E! h9 M, {
DCD EXTI0_IRQHandler ; EXTI Line 0/ C& Y% L3 f- _; `* c4 g3 a1 u
DCD EXTI1_IRQHandler ; EXTI Line 1* T/ U# _5 z# i: S$ B6 d6 M7 f) \
DCD EXTI2_IRQHandler ; EXTI Line 2+ {/ R9 o9 A: n2 W2 n
DCD EXTI3_IRQHandler ; EXTI Line 3. I) y6 _ D n7 s4 Z
DCD EXTI4_IRQHandler ; EXTI Line 4
8 i) y( f3 m! h+ G2 H& T V
DCD DMA1_Channel1_IRQHandler ; DMA1 Channel 1
& I+ a8 F0 P2 ?- h7 P' F; m# p
DCD DMA1_Channel2_IRQHandler ; DMA1 Channel 2
2 X# {! N8 `5 A t' q
DCD DMA1_Channel3_IRQHandler ; DMA1 Channel 38 I% b, T a/ X
DCD DMA1_Channel4_IRQHandler ; DMA1 Channel 4
' k6 l& X7 W" X- ], |
DCD DMA1_Channel5_IRQHandler ; DMA1 Channel 5" X+ J. J- Y# o4 G) q8 w$ x
DCD DMA1_Channel6_IRQHandler ; DMA1 Channel 69 T: _% g: ^7 L% p$ H' o5 Y* z: W0 H
DCD DMA1_Channel7_IRQHandler ; DMA1 Channel 7
0 A( R0 w f7 p e P5 w2 t
DCD ADC1_2_IRQHandler ; ADC1 & ADC2% R9 J& E, O; ]$ O% @9 ]
DCD USB_HP_CAN1_TX_IRQHandler ; USB High Priority or CAN1 TX
) M9 _& [; @7 ?7 g3 s
DCD USB_LP_CAN1_RX0_IRQHandler ; USB Low Priority or CAN1 RX0
9 B' E# O( S& [! L+ T
DCD CAN1_RX1_IRQHandler ; CAN1 RX1, ]$ o& @& x$ x6 t7 |$ x
DCD CAN1_SCE_IRQHandler ; CAN1 SCE) c# ?( ^6 l; y; ?1 f
DCD EXTI9_5_IRQHandler ; EXTI Line 9..57 l$ E4 X+ n& t5 A4 s2 E
DCD TIM1_BRK_IRQHandler ; TIM1 Break0 h4 b$ ^9 O! l; h* [
DCD TIM1_UP_IRQHandler ; TIM1 Update
4 W% D) ~+ j2 r6 ?& N
DCD TIM1_TRG_COM_IRQHandler ; TIM1 Trigger and Commutation& q+ x2 y( S1 Q/ F4 t; q
DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
/ \) Y m& j& j* o* F. `8 U
DCD TIM2_IRQHandler ; TIM2
/ Z- }) u6 D$ ?! T
DCD TIM3_IRQHandler ; TIM3
3 B- m* O+ k9 _
DCD TIM4_IRQHandler ; TIM42 h( x/ s( f9 V* s j9 `, ~
DCD I2C1_EV_IRQHandler ; I2C1 Event
0 v2 p' e6 }! Q
DCD I2C1_ER_IRQHandler ; I2C1 Error; E! C* W7 [2 J, l
DCD I2C2_EV_IRQHandler ; I2C2 Event
- C+ I" e+ z: e, J* b7 H; q
DCD I2C2_ER_IRQHandler ; I2C2 Error
+ j% q' W9 H, w! q) ^/ N/ V1 G
DCD SPI1_IRQHandler ; SPI1
$ I( u9 b3 k8 F# L" Q0 W/ D! C) t
DCD SPI2_IRQHandler ; SPI2
' C( L! D) v! n, {; I
DCD USART1_IRQHandler ; USART1# m! L1 ~/ k, W( N
DCD USART2_IRQHandler ; USART2
) H" N, N9 D P" t
DCD USART3_IRQHandler ; USART34 E- V# U% O( N/ n# x' d X
DCD EXTI15_10_IRQHandler ; EXTI Line 15..10
2 L7 ?7 r1 O+ h% p8 x9 X/ }1 o. s
DCD RTCAlarm_IRQHandler ; RTC Alarm through EXTI Line" L2 ^ ^7 g9 U2 ]1 E7 X+ d
DCD USBWakeUp_IRQHandler ; USB Wakeup from suspend# Y% `( N& T0 m, v$ I7 o2 q+ y3 j8 n
DCD TIM8_BRK_IRQHandler ; TIM8 Break
; U; q ?7 c6 ]; {
DCD TIM8_UP_IRQHandler ; TIM8 Update* s2 T# p( c8 }# Q: N6 S
DCD TIM8_TRG_COM_IRQHandler ; TIM8 Trigger and Commutation6 J+ ^! x$ A' I) `
DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare
" M' A! b# N5 B
DCD ADC3_IRQHandler ; ADC3
- {2 ^: h8 A8 `+ i: b
DCD FSMC_IRQHandler ; FSMC
/ t5 @1 K, f! m
DCD SDIO_IRQHandler ; SDIO E) H4 H5 C7 C9 v/ r: M% z' g
DCD TIM5_IRQHandler ; TIM5
0 _# N& e/ V6 }+ h
DCD SPI3_IRQHandler ; SPI3( @3 |" R4 l8 }- b
DCD UART4_IRQHandler ; UART4' N9 Q0 J3 @& x' Y( d; I
DCD UART5_IRQHandler ; UART5/ u) i5 E+ _5 M
DCD TIM6_IRQHandler ; TIM6, T) N$ H' d: r3 J, D/ T* f
DCD TIM7_IRQHandler ; TIM77 h4 b/ @8 K' X
DCD DMA2_Channel1_IRQHandler ; DMA2 Channel17 e3 x' _+ I; U% ^
DCD DMA2_Channel2_IRQHandler ; DMA2 Channel2# ~8 Y3 D0 m. c6 h) _
DCD DMA2_Channel3_IRQHandler ; DMA2 Channel31 o3 K9 U" u% H5 I7 e
DCD DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & Channel5+ M/ q2 I$ i$ T4 U. }/ ~* k
__Vectors_End

复制代码

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

startup_stm32f10x_hd.s内容：7 l* O2 j: \/ Z$ g/ D
0 h' ]2 Z+ t8 Z8 l) |# t
NMI_Handler PROC4 X! ]; V6 \7 C% Z
EXPORT NMI_Handler [WEAK]
4 Q3 Q+ {) C; L% S! \- @* C
B .) u x. K6 f6 c
ENDP
& @: u& }4 a( h; k# l( E! C
% ^9 e3 ^8 B' `9 O
, t" r( Q, m/ e! G
stm32f10x_it.c中内容：3 O, y1 O! f9 O$ C: ^8 v
void NMI_Handler(void)6 Y! o+ Q# | d
{# H# Z; z/ M$ T- H! u- V3 T4 a
}

复制代码

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

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

! y! m' D+ d/ p" m) M/ N5 G1 F

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

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

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

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

IF :DEF:__MICROLIB- X. U' ~0 ]3 ^$ W
" G9 L% ^& s1 X
EXPORT __initial_sp
$ a/ c5 v H+ H2 x- P0 k
EXPORT __heap_base
4 g* c$ U/ i- ^0 n7 P
EXPORT __heap_limit
4 u. j: A4 @0 d: g) l) y7 m2 c2 Z
+ G! l& ?3 i) W# J3 e
ELSE
3 g* w% }, r2 L, O, q. V
7 h4 {* q8 M, O. f4 t' X; d( \# {
IMPORT __use_two_region_memory1 Y7 A) U4 ~) f Q- R9 V
EXPORT __user_initial_stackheap
' q' X9 f. [8 g E
& j$ F" L6 Z8 N" S
__user_initial_stackheap# l! W/ s: Z- P1 o3 ]/ {- @0 _
0 A1 [! ?' w. X( i4 f, K
LDR R0, = Heap_Mem
) O4 J5 E- `/ _8 h
LDR R1, =(Stack_Mem + Stack_Size)% Y- w+ q' U0 J2 y! D: F. W% T' f
LDR R2, = (Heap_Mem + Heap_Size)
- b' r$ o, U! [" [
LDR R3, = Stack_Mem
( H1 W% G- \3 c' @9 q
BX LR
% U# L! I- s( M& c/ @, v3 j
0 c+ {, Y- k7 c6 @9 C% E, _2 R R+ L
ALIGN, L5 o6 |; k8 n1 O; Q
* f5 v3 z, B9 Y# p5 D* ~* T1 P# v
ENDIF

复制代码

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

__main:
# g0 ~2 H. `, D' [- Z ?
0x08000130 F000F802 BL.W __scatterload_rt2_thumb_only (0x08000138)
. e4 A u) r! C
0x08000134 F000F83C BL.W __rt_entry_sh (0x080001B0)3 r* }/ C! M( g" u4 S5 G( r2 W
__scatterload_rt2_thumb_only:! B/ ~/ J( j; Q: E1 ?, Q
0x08000138 A00A ADR r0,{pc}+4 ; @0x08000164; z3 }" S) ?$ z7 s D+ v3 Z
0x0800013A E8900C00 LDM r0,{r10-r11}
\; y H8 g* G6 h" ^: a, b
0x0800013E 4482 ADD r10,r10,r02 s U/ X/ j# ]9 v3 t' X
0x08000140 4483 ADD r11,r11,r0
! n3 A7 t! S. T9 ]& q4 L
0x08000142 F1AA0701 SUB r7,r10,#0x01
4 n3 c: S5 F8 g
__scatterload_null:
- u6 R# H# t0 G i7 J0 B
0x08000146 45DA CMP r10,r11' V" O6 C2 Y2 j4 C# L0 H5 Q; G! A
0x08000148 D101 BNE 0x0800014E, _. V8 `+ k3 g' \) Z) v! T2 f5 ?
0x0800014A F000F831 BL.W __rt_entry_sh (0x080001B0)% f' M: b6 l1 b
0x0800014E F2AF0E09 ADR.W lr,{pc}-0x07 ; @0x08000147
$ y8 `1 c6 H. u
0x08000152 E8BA000F LDM r10!,{r0-r3}0 F2 j6 V7 J( S% t- S1 I* Q
0x08000156 F0130F01 TST r3,#0x01
. r; m6 i+ w2 I
0x0800015A BF18 IT NE+ _8 o; @$ Q1 t& s8 C6 j
0x0800015C 1AFB SUBNE r3,r7,r3- L6 Y2 ]# b8 ~* K6 p
0x0800015E F0430301 ORR r3,r3,#0x01( J; ^9 |2 Y) f
0x08000162 4718 BX r3: \. b! o1 {$ u6 g; p5 R( Z& D
0x08000164 0298 LSLS r0,r3,#10; S6 \$ v+ n& u+ ~2 a
0x08000166 0000 MOVS r0,r0
5 h: N- w- f9 F- [+ q# w: x3 _
0x08000168 02B8 LSLS r0,r7,#105 X' D( R: E9 X
0x0800016A 0000 MOVS r0,r03 ]/ i: l# Z) D5 T
__scatterload_copy:* B, F" a9 l1 } A
0x0800016C 3A10 SUBS r2,r2,#0x10* U' d4 p( M' p, ?8 B! ?
0x0800016E BF24 ITT CS
* j j4 g1 z: _ R3 |% _8 g. \6 m
0x08000170 C878 LDMCS r0!,{r3-r6}) R8 e& S$ ]7 r9 f
0x08000172 C178 STMCS r1!,{r3-r6}4 T8 n2 h. Q9 K! S P! ?5 P' B
0x08000174 D8FA BHI __scatterload_copy (0x0800016C)5 I: P$ m( o# R/ `9 S8 t: {
0x08000176 0752 LSLS r2,r2,#29: x0 N& p, }) b' Y
0x08000178 BF24 ITT CS$ ]( V' ]5 u& w% m: \6 U1 `& N6 j' g6 T
0x0800017A C830 LDMCS r0!,{r4-r5}
' ~: {& r$ t6 s; f' v0 s* J) i" P
0x0800017C C130 STMCS r1!,{r4-r5} p+ ^1 D8 \$ O# u4 ~" g5 S/ I
0x0800017E BF44 ITT MI" }7 ?6 g: F4 J$ b8 V
0x08000180 6804 LDRMI r4,[r0,#0x00]
& V; i2 b: s' K% J% M! C
0x08000182 600C STRMI r4,[r1,#0x00]
6 {9 M! v: y/ ~5 Z9 s# e3 s
0x08000184 4770 BX lr
$ ?: a( N9 x" U& J+ A# ~2 T
0x08000186 0000 MOVS r0,r0+ j, s$ D) l. s5 ^: [
__scatterload_zeroinit:4 h$ i) W4 z8 I2 V- v7 r6 m4 B
0x08000188 2300 MOVS r3,#0x00
$ A: p5 B. ^! {0 L
0x0800018A 2400 MOVS r4,#0x000 A3 h- @( D' ]2 ^( A
0x0800018C 2500 MOVS r5,#0x00
& E6 F9 B. o' @" ~
0x0800018E 2600 MOVS r6,#0x00
5 z8 A& R# E/ g* [5 H
0x08000190 3A10 SUBS r2,r2,#0x10
4 C* O) _& \2 V+ q: t7 o' s
0x08000192 BF28 IT CS- Y5 f# c6 V- N) f V. P6 y
0x08000194 C178 STMCS r1!,{r3-r6}
5 }9 C% \- A" o+ r! S# H1 I- n
0x08000196 D8FB BHI 0x08000190& h5 N& U* o; x
0x08000198 0752 LSLS r2,r2,#29
5 y# K, ] e5 ?
0x0800019A BF28 IT CS
* k5 a& q4 V- T( q. J
0x0800019C C130 STMCS r1!,{r4-r5}# {$ ]/ F2 c" u; y# J# I0 j# R
0x0800019E BF48 IT MI% B N' O- _8 F
0x080001A0 600B STRMI r3,[r1,#0x00]
, |6 p& y( Q* Q" ?
0x080001A2 4770 BX lr8 u8 G1 d! t( l6 Y0 M) r/ P
__rt_lib_init:) A8 w' z4 ~$ E
0x080001A4 B51F PUSH {r0-r4,lr}
5 w, t$ @9 h m3 ^, W
0x080001A6 F3AF8000 NOP.W
( ?1 @: `) G% |! m/ s2 n
__rt_lib_init_user_alloc_1:
, @, `7 C/ h0 q, X/ ^; a
0x080001AA BD1F POP {r0-r4,pc}+ a4 ]" G' i, A8 D1 e* K
__rt_lib_shutdown:
6 o2 b5 U* l8 x: T6 s
0x080001AC B510 PUSH {r4,lr}! i7 y. }! L3 F6 U0 E2 M
__rt_lib_shutdown_user_alloc_1:1 _- Z* Q1 t6 e
0x080001AE BD10 POP {r4,pc}
. F1 l# I4 A7 k+ r
__rt_entry_sh:
2 x. i5 j7 D# u2 ^9 I, f
0x080001B0 F000F82F BL.W __user_setup_stackheap (0x08000212)7 N9 e7 q5 Q4 E* n. R" U) x
0x080001B4 4611 MOV r1,r22 p$ A/ s" P0 x5 [
__rt_entry_postsh_1:
- b% A6 {+ [6 f& O6 O: f! z# S
0x080001B6 F7FFFFF5 BL.W __rt_lib_init (0x080001A4)# u" z3 q$ N4 X. G1 e5 q
__rt_entry_postli_1:
7 s. h3 _8 F1 t
0x080001BA F000F919 BL.W main (0x080003F0)