登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›使用C语言实现重写stm32的启动文件

使用C语言实现重写stm32的启动文件

仟仞 前天 16:45
适用型号：stm32f103c8t6
编译器：GCC
传统的启动文件使用汇编语言实现，可读性很低，现在分析其内容，使用C语言重新实现一遍。
首先附上成品，使用C23标准：
  1. #include <stddef.h>
  2. #include <stdint.h>
  3. #include <string.h>
  5. // some macros
  6. #define cast(__value, __type) ((__type)(__value))
  8. #define ptr(__type)           typeof(__type *)
  9. #define array(__type, ...)    typeof(__type[##__VA_ARGS__])
  10. #define func(__ret, ...)      typeof(__ret(__VA_ARGS__))
  11. #define readonly(__type)      typeof(const __type)
  13. /**
  14. * @syntax unified
  15. * @cpu cortex-m3
  16. * @fpu softvfp
  17. * @thumb
  18. */
  20. typedef func(void) inteHandlerType;                    // 定义中断处理函数类型
  21. typedef readonly(ptr(inteHandlerType)) inteVectorType; // 定义中断向量表元素类型
  23. array(inteVectorType) f_pfnVectors; // 声明 中断向量表
  24. inteHandlerType Default_Handler;    // 声明 默认中断处理函数
  25. inteHandlerType Reset_Handler;      // 声明 复位函数
  27. extern func(void) SystemInit; // defined in @system_stm32f1xx.c
  28. extern func(int) main;        // defined in @main.c
  29. extern func(void) __libc_init_array;
  31. static func(void) data_init;
  32. static func(void) bss_init;
  35. // 栈顶地址
  36. /* Highest address of the user mode stack */
  37. extern uint8_t _estack; // 为了和 @sysmem.c 中的定义保持一致，使用uint8_t
  39. // 定义在链接器脚本中的符号
  40. /* defined in linker script */
  41. extern uint32_t _sidata; /* start address for the initialization values of the .data section.*/
  42. /* start address for the .data section. defined in linker script */
  43. extern uint32_t _sdata;
  44. /* end address for the .data section. defined in linker script */
  45. extern uint32_t _edata;
  46. /* start address for the .bss section. defined in linker script */
  47. extern uint32_t _sbss;
  48. /* end address for the .bss section. defined in linker script */
  49. extern uint32_t _ebss;
  51. readonly(uint32_t) BootRAM = 0xF108F85F;
  53. /*******************************************************************************
  54. *
  55. * Provide weak aliases for each Exception handler to the Default_Handler.
  56. * As they are weak aliases, any function with the same name will override
  57. * this definition.
  58. *
  59. *******************************************************************************/
  61. #define __HandlerAttribute [[gnu::weak]] [[gnu::alias("Default_Handler")]]
  63. __HandlerAttribute func(void) NMI_Handler;
  64. __HandlerAttribute func(void) HardFault_Handler;
  65. __HandlerAttribute func(void) MemManage_Handler;
  66. __HandlerAttribute func(void) BusFault_Handler;
  67. __HandlerAttribute func(void) UsageFault_Handler;
  68. __HandlerAttribute func(void) SVC_Handler;
  69. __HandlerAttribute func(void) DebugMon_Handler;
  70. __HandlerAttribute func(void) PendSV_Handler;
  71. __HandlerAttribute func(void) SysTick_Handler;
  72. __HandlerAttribute func(void) WWDG_IRQHandler;
  73. __HandlerAttribute func(void) PVD_IRQHandler;
  74. __HandlerAttribute func(void) TAMPER_IRQHandler;
  75. __HandlerAttribute func(void) RTC_IRQHandler;
  76. __HandlerAttribute func(void) FLASH_IRQHandler;
  77. __HandlerAttribute func(void) RCC_IRQHandler;
  78. __HandlerAttribute func(void) EXTI0_IRQHandler;
  79. __HandlerAttribute func(void) EXTI1_IRQHandler;
  80. __HandlerAttribute func(void) EXTI2_IRQHandler;
  81. __HandlerAttribute func(void) EXTI3_IRQHandler;
  82. __HandlerAttribute func(void) EXTI4_IRQHandler;
  83. __HandlerAttribute func(void) DMA1_Channel1_IRQHandler;
  84. __HandlerAttribute func(void) DMA1_Channel2_IRQHandler;
  85. __HandlerAttribute func(void) DMA1_Channel3_IRQHandler;
  86. __HandlerAttribute func(void) DMA1_Channel4_IRQHandler;
  87. __HandlerAttribute func(void) DMA1_Channel5_IRQHandler;
  88. __HandlerAttribute func(void) DMA1_Channel6_IRQHandler;
  89. __HandlerAttribute func(void) DMA1_Channel7_IRQHandler;
  90. __HandlerAttribute func(void) ADC1_2_IRQHandler;
  91. __HandlerAttribute func(void) USB_HP_CAN1_TX_IRQHandler;
  92. __HandlerAttribute func(void) USB_LP_CAN1_RX0_IRQHandler;
  93. __HandlerAttribute func(void) CAN1_RX1_IRQHandler;
  94. __HandlerAttribute func(void) CAN1_SCE_IRQHandler;
  95. __HandlerAttribute func(void) EXTI9_5_IRQHandler;
  96. __HandlerAttribute func(void) TIM1_BRK_IRQHandler;
  97. __HandlerAttribute func(void) TIM1_UP_IRQHandler;
  98. __HandlerAttribute func(void) TIM1_TRG_COM_IRQHandler;
  99. __HandlerAttribute func(void) TIM1_CC_IRQHandler;
  100. __HandlerAttribute func(void) TIM2_IRQHandler;
  101. __HandlerAttribute func(void) TIM3_IRQHandler;
  102. __HandlerAttribute func(void) TIM4_IRQHandler;
  103. __HandlerAttribute func(void) I2C1_EV_IRQHandler;
  104. __HandlerAttribute func(void) I2C1_ER_IRQHandler;
  105. __HandlerAttribute func(void) I2C2_EV_IRQHandler;
  106. __HandlerAttribute func(void) I2C2_ER_IRQHandler;
  107. __HandlerAttribute func(void) SPI1_IRQHandler;
  108. __HandlerAttribute func(void) SPI2_IRQHandler;
  109. __HandlerAttribute func(void) USART1_IRQHandler;
  110. __HandlerAttribute func(void) USART2_IRQHandler;
  111. __HandlerAttribute func(void) USART3_IRQHandler;
  112. __HandlerAttribute func(void) EXTI15_10_IRQHandler;
  113. __HandlerAttribute func(void) RTC_Alarm_IRQHandler;
  114. __HandlerAttribute func(void) USBWakeUp_IRQHandler;
  116. /******************************************************************************
  117. *
  118. * The minimal vector table for a Cortex M3.  Note that the proper constructs
  119. * must be placed on this to ensure that it ends up at physical address
  120. * 0x0000.0000.
  121. *
  122. ******************************************************************************/
  124. [[gnu::section(".isr_vector")]] // gnu extension to place the vector table in a specific address
  125. array(inteVectorType) f_pfnVectors =
  126.     {
  127.         cast(&_estack, ptr(void)),          /* Stack pointer */
  128.         Reset_Handler,                      /* Reset Handler */
  129.         NMI_Handler,                        /* NMI Handler */
  130.         HardFault_Handler,                  /* Hard Fault Handler */
  131.         MemManage_Handler,                  /* MPU Fault Handler */
  132.         BusFault_Handler,                   /* Bus Fault Handler */
  133.         UsageFault_Handler,                 /* Usage Fault Handler */
  134.         nullptr, nullptr, nullptr, nullptr, /* Reserved */
  135.         SVC_Handler,                        /* SVCall Handler */
  136.         DebugMon_Handler,                   /* Debug Monitor Handler */
  137.         nullptr,                            /* Reserved */
  138.         PendSV_Handler,                     /* PendSV Handler */
  139.         SysTick_Handler,                    /* SysTick Handler */
  141.         /* IRQ Handlers */
  142.         WWDG_IRQHandler,
  143.         PVD_IRQHandler,
  144.         TAMPER_IRQHandler,
  145.         RTC_IRQHandler,
  146.         FLASH_IRQHandler,
  147.         RCC_IRQHandler,
  148.         EXTI0_IRQHandler,
  149.         EXTI1_IRQHandler,
  150.         EXTI2_IRQHandler,
  151.         EXTI3_IRQHandler,
  152.         EXTI4_IRQHandler,
  153.         DMA1_Channel1_IRQHandler,
  154.         DMA1_Channel2_IRQHandler,
  155.         DMA1_Channel3_IRQHandler,
  156.         DMA1_Channel4_IRQHandler,
  157.         DMA1_Channel5_IRQHandler,
  158.         DMA1_Channel6_IRQHandler,
  159.         DMA1_Channel7_IRQHandler,
  160.         ADC1_2_IRQHandler,
  161.         USB_HP_CAN1_TX_IRQHandler,
  162.         USB_LP_CAN1_RX0_IRQHandler,
  163.         CAN1_RX1_IRQHandler,
  164.         CAN1_SCE_IRQHandler,
  165.         EXTI9_5_IRQHandler,
  166.         TIM1_BRK_IRQHandler,
  167.         TIM1_UP_IRQHandler,
  168.         TIM1_TRG_COM_IRQHandler,
  169.         TIM1_CC_IRQHandler,
  170.         TIM2_IRQHandler,
  171.         TIM3_IRQHandler,
  172.         TIM4_IRQHandler,
  173.         I2C1_EV_IRQHandler,
  174.         I2C1_ER_IRQHandler,
  175.         I2C2_EV_IRQHandler,
  176.         I2C2_ER_IRQHandler,
  177.         SPI1_IRQHandler,
  178.         SPI2_IRQHandler,
  179.         USART1_IRQHandler,
  180.         USART2_IRQHandler,
  181.         USART3_IRQHandler,
  182.         EXTI15_10_IRQHandler,
  183.         RTC_Alarm_IRQHandler,
  184.         USBWakeUp_IRQHandler,
  185.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, /* Reserved */
  186.         cast(BootRAM, ptr(void))
  187.         /* @0x108. This is for boot in RAM mode for STM32F10x Medium Density devices. */
  188. };
  190. /**
  191. * @brief  This is the code that gets called when the processor receives an
  192. *         unexpected interrupt.  This simply enters an infinite loop, preserving
  193. *         the system state for examination by a debugger.
  194. *
  195. * @param  None
  196. * @retval : None
  197. */
  198. void Default_Handler(void)
  199. {
  200.     while (true) {
  201.         /* Infinite loop */
  202.     }
  203. }
  205. /**
  206. * @brief  This is the code that gets called when the processor first
  207. *          starts execution following a reset event. Only the absolutely
  208. *          necessary set is performed, after which the application
  209. *          supplied main() routine is called.
  210. * @param  None
  211. * @retval : None
  212. */
  213. [[noreturn]] // the function will never return
  214. void Reset_Handler(void)
  215. {
  216.     /* Call the clock system initialization function */
  217.     SystemInit();
  219.     /* Initialize data and bss sections */
  220.     data_init();
  221.     bss_init();
  223.     /* Call static constructors */
  224.     __libc_init_array();
  226.     /* Call the application's entry point */
  227.     main();
  229.     /* Should never reach here */
  230.     while (true) {
  231.         /* Infinite loop */
  232.     }
  233. }
  235. /**
  236. * @brief data sector initialization function
  237. *
  238. */
  239. static void data_init(void)
  240. {
  241.     auto   src       = cast(&_sidata, ptr(uint8_t)); // flash addr
  242.     auto   dst_start = cast(&_sdata, ptr(uint8_t));  // ram start
  243.     auto   dst_end   = cast(&_edata, ptr(uint8_t));  // ram end
  244.     size_t data_size = dst_end - dst_start;          // get data size
  245.     memcpy(dst_start, src, data_size);               // copy data from flash to ram
  246. }
  248. /**
  249. * @brief bss sector zero initialization function
  250. *
  251. */
  252. /* BSS zero initialization function */
  253. static void bss_init(void)
  254. {
  255.     auto   dst_start = cast(&_sbss, ptr(uint8_t)); // ram start
  256.     auto   dst_end   = cast(&_ebss, ptr(uint8_t)); // ram end
  257.     size_t bss_size  = dst_end - dst_start;        // get bss size
  258.     memset(dst_start, 0x00, bss_size);             // clear bss section
  259. }
复制代码
以STM32CubeMX生成使用的CMake工具链的stm32f103c8t6的项目为例，有一个启动文件 startup_stm32f103xb.s 和链接器脚本 STM32F103XX_FLASH.ld，启动文件中定义的内容是上电以后执行的第一件事情，而链接器脚本指定程序的链接方式和内存区域分配方式。
首先分析链接器文件：
  1. /* Entry Point */
  2. ENTRY(Reset_Handler)
复制代码
定义了入口函数，也即上电之后执行的第一个函数，此处为 Reset_Handler。
  1. /* Specify the memory areas */
  2. MEMORY
  3. {
  4. RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 20K
  5. FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 64K
  6. }
复制代码
定义了内存区域，分别为：

  • RAM 区域，可执行（x）、可读（r）、可写（w）的区域，大小为 20K；
  • FLASH 区域，可读（r）、可执行（x），大小为 64K，起始地址为 0x8000000。
  1. /* Highest address of the user mode stack */
  2. _estack = ORIGIN(RAM) + LENGTH(RAM);    /* end of RAM */
复制代码
定义程序堆栈起始地址 _estack，由于堆栈是从高地址向低地址延伸，所以起始地址定义为 RAM 区域的结束位置。考虑到寻址方式为“word”，因此在C语言中，可以使用 uint32_t 类型来表示。
  1. /* Generate a link error if heap and stack don't fit into RAM */
  2. _Min_Heap_Size = 0x0;      /* required amount of heap  */
  3. _Min_Stack_Size = 0x400; /* required amount of stack */
复制代码
定义堆和栈的大小。如果需要使用 malloc 等动态内存分配，则分配的内存就位于堆中。此处不用，因此设为0。
然后是段定义：
  1. /* Define output sections */
  2. SECTIONS
  3. {
  4.     /*...... */
  5. }
复制代码
分为几个段：
  1.   /* The startup code goes first into FLASH */
  2.   .isr_vector :
  3.   {
  4.     . = ALIGN(4);
  5.     KEEP(*(.isr_vector)) /* Startup code */
  6.     . = ALIGN(4);
  7.   } >FLASH
复制代码
为中断向量表所在的地址
  1.   /* Constant data goes into FLASH */
  2.   .rodata :
  3.   {
  4.     . = ALIGN(4);
  5.     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
  6.     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
  7.     . = ALIGN(4);
  8.   } >FLASH
复制代码
定义const 变量存放在 Flash 中。
接下来的 .ARM.extab、.ARM、.preinit_array、.init_array、.fini_array 与C++有关，略过。
接着是
  1.   /* used by the startup to initialize data */
  2.   _sidata = LOADADDR(.data);
复制代码
定义符号 _sidata，用于指定 .data 段在Flash中的起始地址，这样就可以在C代码文件中使用这个“变量”
  1.   /* Initialized data sections goes into RAM, load LMA copy after code */
  2.   .data :
  3.   {
  4.     . = ALIGN(4);
  5.     _sdata = .;        /* create a global symbol at data start */
  6.     *(.data)           /* .data sections */
  7.     *(.data*)          /* .data* sections */
  8.     *(.RamFunc)        /* .RamFunc sections */
  9.     *(.RamFunc*)       /* .RamFunc* sections */
  11.     . = ALIGN(4);
  12.   } >RAM AT> FLASH
复制代码
此处定义了 .data 段，用于存放已经初始化过的全局变量，这些变量的值会存放在Flash中，在程序运行时，在启动文件中将其复制到RAM中的对应位置。
  1.   .bss (NOLOAD) : ALIGN(4)
  2.   {
  3.     *(.bss)
  4.     *(.bss*)
  5.     *(COMMON)
  7.       . = ALIGN(4);
  8.     _ebss = .;         /* define a global symbol at bss end */
  9.     __bss_end__ = _ebss;
  10.       PROVIDE( __bss_end = .);
  11.   } >RAM
复制代码
定义了 .bss 段，用于存放未初始化的全局变量，这些变量的值在程序运行时会被初始化为0。
  1. /* User_heap_stack section, used to check that there is enough RAM left */
  2.   ._user_heap_stack (NOLOAD) :
  3.   {
  4.     . = ALIGN(8);
  5.     PROVIDE ( end = . );
  6.     PROVIDE ( _end = . );
  7.     . = . + _Min_Heap_Size;
  8.     . = . + _Min_Stack_Size;
  9.     . = ALIGN(8);
  10.   } >RAM
复制代码
定义了一个 .user_heap_stack 段，用于堆栈的分配，保存在RAM中。
  1.   /* Remove information from the standard libraries */
  2.   /DISCARD/ :
  3.   {
  4.     libc.a:* ( * )
  5.     libm.a:* ( * )
  6.     libgcc.a:* ( * )
  7.   }
复制代码
移除 libc.a、libm.a、libgcc.a 等标准库符号，因为使用newlib。
接着分析启动文件：
首先是
  1.   .syntax unified
  2.   .cpu cortex-m3
  3.   .fpu softvfp
  4.   .thumb
复制代码
定义了cpu、fpu、指令集等内容，略过。
然后
  1. .global g_pfnVectors
  2. .global Default_Handler
复制代码
相当于C语言中定声明了两个全局变量，第一个是中断向量组，第二个是默认的中断处理函数。中断向量组中是紧凑排列的各种中断函数的入口地址，我们知道所有的中断函数都是 void handler(void) 类型，因此它等价为一个函数指针数组，为了防止不小心修改，可以添加 const 限定符：
  1. typedef void(*const inteFunp)(void);
  2. const inteFunp g_pfnVectors[];
复制代码
然后是
  1. /* start address for the initialization values of the .data section.
  2. defined in linker script */
  3. .word _sidata
  4. /* start address for the .data section. defined in linker script */
  5. .word _sdata
  6. /* end address for the .data section. defined in linker script */
  7. .word _edata
  8. /* start address for the .bss section. defined in linker script */
  9. .word _sbss
  10. /* end address for the .bss section. defined in linker script */
  11. .word _ebss
  13. .equ  BootRAM, 0xF108F85F
复制代码
声明了几个 .word 类型的变量，相当于C语言中的 uint32_t 类型。这些符号定义在链接器脚本中，用于指定各个数据段的起始、终止地址。最后的 .equ  BootRAM, 0xF108F85F 定义了从RAM中启动的地址，需要加在中断向量组的最后。
接着是 Reset_Handler 函数的定义，它是上电之后第一个执行的函数。下面是它的声明：
  1.   .section .text.Reset_Handler // 定义代码段
  2.   .weak Reset_Handlel           // 定义为弱符号
  3.   .type Reset_Handler, %function // 定义为函数类型
复制代码
这一部分可以改写为C代码：
  1. [[gnu::weak]] void Reset_Handler(void);
复制代码
其中 [[gnu::weak]] 是C23语法，用于定义弱符号。
然后是函数体：
  1. Reset_Handler:
  2.     bl SystemInit // 调用 SystemInit 函数
  4.     // 从 Flash 中复制数据到 data 段
  5.     // 清零 bss 段
  7.     bl __libc_init_array // 调用 C++ 静态构造函数
  8.     bl main // 调用 main 函数，进入主程序
  9.     bx lr   // 相当于 main 函数中的 return
复制代码
可以改写为C代码：
  1. void data_init(void);
  2. void bss_init(void);
  4. [[noreturn]] // c23 属性，标记函数永不返回
  5. void Reset_Handler(void){
  6.     SystemInit();
  7.     data_init(); // 复制数据到data段
  8.     bss_init(); // 清零bss段
  9.     __libc_init_array(); // 调用C++静态构造函数
  10.     main(); // 进入主程序
  11.     while(true);
  12. }
复制代码
其中 data_init 和 bss_init 是我们自己定义的两个函数，用于初始化 .data 和 .bss 段，其汇编代码如下：
  1. /* Copy the data segment initializers from flash to SRAM */
  2.   ldr r0, =_sdata    // r0 = _sdata;
  3.   ldr r1, =_edata    // r1 = _edata;
  4.   ldr r2, =_sidata   // r2 = _sidata;
  5.   movs r3, #0        // r3 = 0;
  6.   b LoopCopyDataInit // goto LoopCopyDataInit;
  8. CopyDataInit:        // CopyDataInit:
  9.   ldr r4, [r2, r3]   //   r4 = *(uint32_t*)(r2 + r3);
  10.   str r4, [r0, r3]   //   *(uint32_t*)(r0 + r2) = r4;
  11.                      //   // 两句合起来等价于：
  12.                      //   // *(uint32_t*)(r0 + r2) = *(uint32_t*)(r2 + r2);
  13.   adds r3, r3, #4    //   r3 += 4;
  15. LoopCopyDataInit:    // LoopCopyDataInit:
  16.   adds r4, r0, r3    //   r4 = r0 + r3;
  17.   cmp r4, r1         //   cmp res(r4,r1); // 假设有个enum cmp用于存储两个数字比较情况
  18.   bcc CopyDataInit   //   if(cmp == less){ goto CopyDataInit; }
  20. /* Zero fill the bss segment. */
  21.   ldr r2, =_sbss
  22.   ldr r4, =_ebss
  23.   movs r3, #0
  24.   b LoopFillZerobss
  26. FillZerobss:
  27.   str  r3, [r2]
  28.   adds r2, r2, #4
  30. LoopFillZerobss:
  31.   cmp r2, r4
  32.   bcc FillZerobss
复制代码
改写为C代码如下：
  1. extern uint32_t &_sdata;
  2. extern uint32_t &_edata;
  3. extern uint32_t &_sidata;
  5. uint32_t data_start = _sdata;   // data段的起始地址
  6. uint32_t data_end = _edata;     // data段的结束地址
  7. uint32_t source_addr = _sidata; // flash中data的数据的起始地址
  8. uint32_t offset = 0;
  10. // 以 word 为单位，也即4字节为单位，从 flash 中拷贝数据到 ram 中
  11. while(offset< data_end){
  12.     uint32_t *src = (uint32_t *)(source_addr + offset);
  13.     uint32_t *dst = (uint32_t *)(data_start + offset);
  15.     *dst = *src;
  16.     offset += 4; // 指针偏移4字节，也即一个 word 的长度
  17. }
  19. // 清零部分略
复制代码
可以看到，本质上就是把 flash 中的数据拷贝到 ram 中，拷贝的长度为 _edata - _sdata，源地址为 flash 中的 _sidata，目的地址为 ram 中的 _sdata。清零部分同理，只不过是把拷贝改为设置为0.
因此，可以借助C库函数 memcpy 和 memset 来实现 data_init 和 bss_init 函数：
  1. /* Data copy function */
  2. static void data_init(void)
  3. {
  4.     size_t data_size = _edata - _sdata; // get data size
  5.     memcpy(_sdata, _sidata, data_size); // copy data from flash to ram
  6. }
  8. /* BSS zero initialization function */
  9. static void bss_init(void)
  10. {
  11.     size_t bss_size = _ebss - _sbss; // get bss size
  12.     memset(_sbss, 0x00, bss_size);   // clear bss section
  13. }
复制代码
然后是 Default_Handler 函数：
  1. /**
  2. * @brief  This is the code that gets called when the processor receives an
  3. *         unexpected interrupt.  This simply enters an infinite loop, preserving
  4. *         the system state for examination by a debugger.
  5. *
  6. * @param  None
  7. * @retval : None
  8. */
  9.     .section .text.Default_Handler,"ax",%progbits
  10. Default_Handler:
  11. Infinite_Loop:
  12.   b Infinite_Loop
  13.   .size Default_Handler, .-Default_Handler
复制代码
它是中断处理函数的默认实现，当发生未知中断时，它会进入一个无限循环，保持系统状态，等待调试器来查看。C语言实现为：
  1. void Default_Handler(void){
  2.   while(true){}
  3. }
复制代码
最后是中断向量组定义：
  1. /******************************************************************************
  2. *
  3. * The minimal vector table for a Cortex M3.  Note that the proper constructs
  4. * must be placed on this to ensure that it ends up at physical address
  5. * 0x0000.0000.
  6. *
  7. ******************************************************************************/
  8.   .section .isr_vector,"a",%progbits
  9.   .type g_pfnVectors, %object
  10.   .size g_pfnVectors, .-g_pfnVectors
  13. g_pfnVectors:
  14.   .word _estack
  15.   .word Reset_Handler
  17.   // ......
  19.   .word BootRAM          /* @0x108. This is for boot in RAM mode for
  20.                             STM32F10x Medium Density devices. */
复制代码
以及其弱符号定义：
  1.   .weak NMI_Handler
  2.   .thumb_set NMI_Handler,Default_Handler
  4.   .weak HardFault_Handler
  5.   .thumb_set HardFault_Handler,Default_Handler
  7.   .weak MemManage_Handler
  8.   .thumb_set MemManage_Handler,Default_Handler
  10.   // ......
复制代码
改写为C代码：
  1. // 函数声明
  2. [[gnu::weak]] [[gnu::alias("Default_Handler")]] func(void) NMI_Handler;
  3. [[gnu::weak]] [[gnu::alias("Default_Handler")]] func(void) HardFault_Handler;
  4. // ......
  5. [[gnu::weak]] [[gnu::alias("Default_Handler")]] func(void) USBWakeUp_IRQHandler;
  7. // 向量组定义
  8. [[gnu::section(".isr_vector")]]  
  9. const (*const f_pfnVectors[]) = {
  10.   (void(*)void)&_estack,
  11.   Reset_Handler,
  12.   // ...///
  13.   (void(*)void)BootRAM
  14. };
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
仟仞
前天 16:45

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫