Which is the most efficient way/minimal code required to startup a STM32F4? The startup files that come from ST seem to have a lot of unnecessary code.

  • \$\begingroup\$ Remove what you deem "unnecessary" and try to run it... \$\endgroup\$
    – Tyler
    Commented Mar 25, 2016 at 12:03
  • 1
    \$\begingroup\$ chip vendors code attempts to be a one size fits all, which means it fits no one well. They will always be bloated by definition because they are trying to handle all the major use cases for all the peripherals and features they are willing to support. Use their code and you benefit from support from them and others online that use that code. Go your own way and you benefit from size and speed, but it is mostly on you to re-invent that wheel. \$\endgroup\$
    – old_timer
    Commented Mar 25, 2016 at 12:56
  • \$\begingroup\$ Or as Tyler said, cut out the stuff you dont want/need. \$\endgroup\$
    – old_timer
    Commented Mar 25, 2016 at 12:56

3 Answers 3


You may not want to use the vendor-provided start-up code. There are few reassons people do this:

Create more efficient, or less bloated code. Have a special requirement that the vendor code does not meet. You want to know how stuff work. You want some kind of universal code, to use in many different MCUs. You want total control, over you the process. etc..

The following apply to C programs only (no C++, exceptions etc), and Cortex M microcontrollers (regardless of make/model). Also I assume that you use GCC, although there may be no or little difference with other compilers. Finally I use newlib.

Linker Script

The first thing to do is to create a linker script. You have to tell your compiler how to arrange things in memory. I won't get into details about the linker script, as it is a topic on its own.

 * Linker script.

 * Set the output format. Currently set for Cortex M architectures,
 * may need to be modified if the library has to support other MCUs, 
 * or completelly removed.
OUTPUT_FORMAT ("elf32-littlearm", "elf32-bigarm", "elf32-littlearm")

 * Just refering a function included in the vector table, and that
 * it is defined in the same file with it, so the vector table does
 * not get optimized out.

 * ST32F103x8 memory setup.
    FLASH     (rx)  : ORIGIN = 0x00000000, LENGTH = 64k
    RAM     (xrw)   : ORIGIN = 0x20000000, LENGTH = 20k

 * Necessary group so the newlib stubs provided in the library,
 * will correctly be linked with the appropriate newlib functions,
 * and not optimized out, giving errors for undefined symbols.
 * This way the libraries can be fed to the linker in any order.

 * Stack start pointer. Here set to the end of the stack
 * memory, as in most architectures (including all the 
 * new ARM ones), the stack starts from the maximum address
 * and grows towards the bottom.
__stack = ORIGIN(RAM) + LENGTH(RAM);

 * Programm entry function. Used by the debugger only.

 * Memory Allocation Sections
     * For normal programs should evaluate to 0, for placing the vector
     * table at the correct position.
    . = ORIGIN(FLASH);

     * First link the vector table.
    .vectors : ALIGN(4)
        __vectors_start__ = ABSOLUTE(.); 
        *(.after_vectors .after_vectors.*)
    } > FLASH

     * Start of text.
    _text = .;

     * Text section
    .text : ALIGN(4)
    } > FLASH

     * Arm section unwinding.
     * If removed may cause random crashes.
    .ARM.extab :
        *(.ARM.extab* .gnu.linkonce.armextab.*)
    } > FLASH

     * Arm stack unwinding.
     * If removed may cause random crashes.
    .ARM.exidx :
        __exidx_start = .;
        *(.ARM.exidx* .gnu.linkonce.armexidx.*)
        __exidx_end = .;
    } > FLASH

     * Section used by C++ to access eh_frame.
     * Generaly not used, but it doesn't harm to be there.
    .eh_frame_hdr :
    } > FLASH

     * Stack unwinding code.
     * Generaly not used, but it doesn't harm to be there.
    .eh_frame : ONLY_IF_RO
    } > FLASH

     * Read-only data. Consts should also be here.
    .rodata : ALIGN(4)
        . = ALIGN(4);
        __rodata_start__ = .;
        . = ALIGN(4);
        __rodata_end__ = .;
    } > FLASH 

     * End of text.
    _etext = .;

     * Data section.
    .data : ALIGN(4)
        . = ALIGN(4);
        PROVIDE(__textdata__ = LOADADDR(.data));
        PROVIDE(__data_start__ = .);
        . = ALIGN(4);
        PROVIDE(__data_end__ = .);
    } > RAM AT > FLASH

     * BSS section.
    .bss (NOLOAD) : ALIGN(4)
        . = ALIGN(4);
        PROVIDE(_bss_start = .);
        __bss_start__ = .;
        . = ALIGN(4);
        PROVIDE(_bss_end = .);
        __bss_end__ = .;
        PROVIDE(end = .);
    } > RAM

     * Non-initialized variables section.
     * A variable should be explicitly placed
     * here, aiming in speeding-up boot time.
    .noinit (NOLOAD) : ALIGN(4)
        __noinit_start__ = .;
        *(.noinit .noinit.*) 
         . = ALIGN(4) ;
        __noinit_end__ = .;   
    } > RAM

     * Heap section.
    .heap (NOLOAD) :
        . = ALIGN(4);
        __heap_start__ = .;
        __heap_base__ = .;
        __heap_end__ = .;
    } > RAM


You may directly use the provided linker script. Some things to note:

  • This is a simplified version of the linker script I use. During stripping-down I may introduced bugs to the code, please double check it.

  • Since I use it for other MCUs than you, you have to change the MEMORY layout to fit your own.

  • You may need to change the libraries linked bellow to link with your own. Here it links against newlib.

Vector Table

You have to include in your code a vector table. This is simply a look-up table of function pointers, that the hardware will jump to automatically in case of an interrupt. This is fairly easy to do in C.

Take a look at the following file. This is for the STM32F103C8 MCU, but it is very easy to change to your needs.

#include "stm32f10x.h"
#include "debug.h"

//Start-up code.
extern void __attribute__((noreturn, weak)) _start (void);

// Default interrupt handler
void __attribute__ ((section(".after_vectors"), noreturn)) __Default_Handler(void);

// Reset handler
void __attribute__ ((section(".after_vectors"), noreturn)) Reset_Handler (void);

/** Non-maskable interrupt (RCC clock security system) */
void NMI_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** All class of fault */
void HardFault_Handler(void) __attribute__ ((interrupt, weak));

/** Memory management */
void MemManage_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Pre-fetch fault, memory access fault */
void BusFault_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Undefined instruction or illegal state */
void UsageFault_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** System service call via SWI instruction */
void SVC_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Debug monitor */
void DebugMon_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Pendable request for system service */
void PendSV_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** System tick timer */
void SysTick_Handler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Window watchdog interrupt */
void WWDG_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** PVD through EXTI line detection interrupt */
void PVD_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Tamper interrupt */
void TAMPER_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** RTC global interrupt */
void RTC_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** Flash global interrupt */
void FLASH_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** RCC global interrupt */
void RCC_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line0 interrupt */
void EXTI0_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line1 interrupt */
void EXTI1_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line2 interrupt */
void EXTI2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line3 interrupt */
void EXTI3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line4 interrupt */
void EXTI4_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel1 global interrupt */
void DMA1_Channel1_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel2 global interrupt */
void DMA1_Channel2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel3 global interrupt */
void DMA1_Channel3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel4 global interrupt */
void DMA1_Channel4_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel5 global interrupt */
void DMA1_Channel5_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel6 global interrupt */
void DMA1_Channel6_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA1 Channel7 global interrupt */
void DMA1_Channel7_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** ADC1 and ADC2 global interrupt */
void ADC1_2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** USB high priority or CAN TX interrupts */
void USB_HP_CAN_TX_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** USB low priority or CAN RX0 interrupts */
void USB_LP_CAN_RX0_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** CAN RX1 interrupt */
void CAN_RX1_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** CAN SCE interrupt */
void CAN_SCE_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line[9:5] interrupts */
void EXTI9_5_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM1 break interrupt */
void TIM1_BRK_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM1 update interrupt */
void TIM1_UP_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM1 trigger and commutation interrupts */
void TIM1_TRG_COM_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM1 capture compare interrupt */
void TIM1_CC_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM2 global interrupt */
void TIM2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM3 global interrupt */
void TIM3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM4 global interrupt */
void TIM4_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** I2C1 event interrupt */
void I2C1_EV_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** I2C1 error interrupt */
void I2C1_ER_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** I2C2 event interrupt */
void I2C2_EV_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** I2C2 error interrupt */
void I2C2_ER_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** SPI1 global interrupt */
void SPI1_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** SPI2 global interrupt */
void SPI2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** USART1 global interrupt */
void USART1_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** USART2 global interrupt */
void USART2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** USART3 global interrupt */
void USART3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** EXTI Line[15:10] interrupts */
void EXTI15_10_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** RTC alarm through EXTI line interrupt */
void RTCAlarm_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** USB wakeup from suspend through EXTI line interrupt */
void USBWakeup_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM8 break interrupt */
void TIM8_BRK_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM8 update interrupt */
void TIM8_UP_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM8 trigger and commutation interrupts */
void TIM8_TRG_COM_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM8 capture compare interrupt */
void TIM8_CC_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** ADC3 global interrupt */
void ADC3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** FSMC global interrupt */
void FSMC_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** SDIO global interrupt */
void SDIO_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM5 global interrupt */
void TIM5_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** SPI3 global interrupt */
void SPI3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** UART4 global interrupt */
void UART4_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** UART5 global interrupt */
void UART5_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM6 global interrupt */
void TIM6_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** TIM7 global interrupt */
void TIM7_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA2 Channel1 global interrupt */
void DMA2_Channel1_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA2 Channel2 global interrupt */
void DMA2_Channel2_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA2 Channel3 global interrupt */
void DMA2_Channel3_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

/** DMA2 Channel4 and DMA2 Channel5 global interrupts */
void DMA2_Channel4_5_IRQHandler(void) __attribute__ ((interrupt, weak, alias("__Default_Handler")));

// Stack start variable, needed in the vector table.
extern unsigned int __stack;

// Typedef for the vector table entries.
typedef void (* const pHandler)(void);

/** STM32F103 Vector Table */
__attribute__ ((section(".vectors"), used)) pHandler vectors[] =
    (pHandler) &__stack,                // The initial stack pointer
    Reset_Handler,                      // The reset handler
    NMI_Handler,                        // The NMI handler
    HardFault_Handler,                  // The hard fault handler

#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
    MemManage_Handler,                  // The MPU fault handler
    BusFault_Handler,// The bus fault handler
    UsageFault_Handler,// The usage fault handler
    0, 0, 0,                  // Reserved
    0,                                  // Reserved
    0,                                  // Reserved
    0,                                  // Reserved
    0,                                  // Reserved
    SVC_Handler,                        // SVCall handler
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
    DebugMon_Handler,                   // Debug monitor handler
    0,                    // Reserved
    0,                                  // Reserved
    PendSV_Handler,                     // The PendSV handler
    SysTick_Handler,                    // The SysTick handler
    // ----------------------------------------------------------------------
    WWDG_IRQHandler,                    // Window watchdog interrupt
    PVD_IRQHandler,                     // PVD through EXTI line detection interrupt
    TAMPER_IRQHandler,                  // Tamper interrupt
    RTC_IRQHandler,                     // RTC global interrupt
    FLASH_IRQHandler,                   // Flash global interrupt
    RCC_IRQHandler,                     // RCC global interrupt
    EXTI0_IRQHandler,                   // EXTI Line0 interrupt
    EXTI1_IRQHandler,                   // EXTI Line1 interrupt
    EXTI2_IRQHandler,                   // EXTI Line2 interrupt
    EXTI3_IRQHandler,                   // EXTI Line3 interrupt
    EXTI4_IRQHandler,                   // EXTI Line4 interrupt
    DMA1_Channel1_IRQHandler,           // DMA1 Channel1 global interrupt
    DMA1_Channel2_IRQHandler,           // DMA1 Channel2 global interrupt
    DMA1_Channel3_IRQHandler,           // DMA1 Channel3 global interrupt
    DMA1_Channel4_IRQHandler,           // DMA1 Channel4 global interrupt
    DMA1_Channel5_IRQHandler,           // DMA1 Channel5 global interrupt
    DMA1_Channel6_IRQHandler,           // DMA1 Channel6 global interrupt
    DMA1_Channel7_IRQHandler,           // DMA1 Channel7 global interrupt
    ADC1_2_IRQHandler,                  // ADC1 and ADC2 global interrupt
    USB_HP_CAN_TX_IRQHandler,           // USB high priority or CAN TX interrupts
    USB_LP_CAN_RX0_IRQHandler,          // USB low priority or CAN RX0 interrupts
    CAN_RX1_IRQHandler,                 // CAN RX1 interrupt
    CAN_SCE_IRQHandler,                 // CAN SCE interrupt
    EXTI9_5_IRQHandler,                 // EXTI Line[9:5] interrupts
    TIM1_BRK_IRQHandler,                // TIM1 break interrupt
    TIM1_UP_IRQHandler,                 // TIM1 update interrupt
    TIM1_TRG_COM_IRQHandler,            // TIM1 trigger and commutation interrupts
    TIM1_CC_IRQHandler,                 // TIM1 capture compare interrupt
    TIM2_IRQHandler,                    // TIM2 global interrupt
    TIM3_IRQHandler,                    // TIM3 global interrupt
    TIM4_IRQHandler,                    // TIM4 global interrupt
    I2C1_EV_IRQHandler,                 // I2C1 event interrupt
    I2C1_ER_IRQHandler,                 // I2C1 error interrupt
    I2C2_EV_IRQHandler,                 // I2C2 event interrupt
    I2C2_ER_IRQHandler,                 // I2C2 error interrupt
    SPI1_IRQHandler,                    // SPI1 global interrupt
    SPI2_IRQHandler,                    // SPI2 global interrupt
    USART1_IRQHandler,                  // USART1 global interrupt
    USART2_IRQHandler,                  // USART2 global interrupt
    USART3_IRQHandler,                  // USART3 global interrupt
    EXTI15_10_IRQHandler,               // EXTI Line[15:10] interrupts
    RTCAlarm_IRQHandler,                // RTC alarm through EXTI line interrupt
    USBWakeup_IRQHandler,               // USB wakeup from suspend through EXTI line interrupt
    TIM8_BRK_IRQHandler,                // TIM8 break interrupt
    TIM8_UP_IRQHandler,                 // TIM8 update interrupt
    TIM8_TRG_COM_IRQHandler,            // TIM8 trigger and commutation interrupts
    TIM8_CC_IRQHandler,                 // TIM8 capture compare interrupt
    ADC3_IRQHandler,                    // ADC3 global interrupt
    FSMC_IRQHandler,                    // FSMC global interrupt
    SDIO_IRQHandler,                    // SDIO global interrupt
    TIM5_IRQHandler,                    // TIM5 global interrupt
    SPI3_IRQHandler,                    // SPI3 global interrupt
    UART4_IRQHandler,                   // UART4 global interrupt
    UART5_IRQHandler,                   // UART5 global interrupt
    TIM6_IRQHandler,                    // TIM6 global interrupt
    TIM7_IRQHandler,                    // TIM7 global interrupt
    DMA2_Channel1_IRQHandler,           // DMA2 Channel1 global interrupt
    DMA2_Channel2_IRQHandler,           // DMA2 Channel2 global interrupt
    DMA2_Channel3_IRQHandler,           // DMA2 Channel3 global interrupt
    DMA2_Channel4_5_IRQHandler          // DMA2 Channel4 and DMA2 Channel5 global interrupts

/** Default exception/interrupt handler */
void __attribute__ ((section(".after_vectors"), noreturn)) __Default_Handler(void)
#ifdef DEBUG
  while (1);


/** Reset handler */
void __attribute__ ((section(".after_vectors"), noreturn)) Reset_Handler(void)


What is happening here. - First I declare my _start function so it can be used bellow. - I declare a default handler for all the interrupts, and the reset handler - I declare all the interrupts handlers needed for my MCU. Note that these functions are just aliases to the default handler, i.e. when any of them is called, the default handler will be called instead. Also they are declared week, so you can override them by your code. If you need any of the handlers, then you redeclare it in your code, and your code will be linked. If you don't need any of them, there is simply a default one and you don't have to do anything. The default handler should be structured as such, that if your application needs a handler but you don't implement it, it will help you in debugging your code, or recover the system if it is in the wild. - I get the __stack symbol declared in the linker script. It is needed in the vector table. - I define the table itself. Note the first entry is a pointer to the start of the stack, and the others are pointers to the handlers. - Finally I provide a simple implementation for the default handler and the reset handler. Note that the reset handler is the one that is called after reset, and that calls the startup code.

Keep in mind that the attribute((section())) in the vector table is absolutely needed, so as the linker will place the table at the correct position (Normally address 0x00000000).

What modifications are needed on the above file.

  • Include the CMSIS file of your MCU
  • If you modify the linker script, change the section names
  • Change the vector table entries to match your MCU
  • Change the handlers prototypes to match your MCU

System Calls

Since I use newlib, it requires you to provide the implementations of some functions. You may implement the printf, scanf etc, but they are not needed. Personally I provide only the following:

_sbrk which is needed by malloc. (No modifications needed)

#include <sys/types.h>
#include <errno.h>

caddr_t __attribute__((used)) _sbrk(int incr)
    extern char __heap_start__; // Defined by the linker.
    extern char __heap_end__; // Defined by the linker.

    static char* current_heap_end;
    char* current_block_address;

    if (current_heap_end == 0)
      current_heap_end = &__heap_start__;

    current_block_address = current_heap_end;

    // Need to align heap to word boundary, else will get
    // hard faults on Cortex-M0. So we assume that heap starts on
    // word boundary, hence make sure we always add a multiple of
    // 4 to it.
    incr = (incr + 3) & (~3); // align value to 4
    if (current_heap_end + incr > &__heap_end__)
      // Heap has overflowed
      errno = ENOMEM;
      return (caddr_t) - 1;

    current_heap_end += incr;

    return (caddr_t) current_block_address;

_exit, which is not needed, but I like the idea. (You may only need to modify the CMSIS include).

#include <sys/types.h>
#include <errno.h>
#include "stm32f10x.h"

void __attribute__((noreturn, used)) _exit(int code)
    (void) code;



Start-up Code

Finally the start-up code!

#include <stdint.h>
#include "stm32f10x.h"
#include "gpio.h"
#include "flash.h"

/** Main program entry point. */
extern int main(void);

/** Exit system call. */
extern void _exit(int code);

/** Initializes the data section. */
static void __attribute__((always_inline)) __initialize_data (unsigned int* from, unsigned int* region_begin, unsigned int* region_end);

/** Initializes the BSS section. */
static void __attribute__((always_inline)) __initialize_bss (unsigned int* region_begin, unsigned int* region_end);

/** Start-up code. */
void __attribute__ ((section(".after_vectors"), noreturn, used)) _start(void);

void _start (void)
    //Before switching on the main oscillator and the PLL,
    //and getting to higher and dangerous frequencies,
    //configuration of the flash controller is necessary.

    //Enable the flash prefetch buffer. Can be achieved when CCLK
    //is lower than 24MHz.

    //Set latency to 2 clock cycles. Necessary for setting the clock
    //to the maximum 72MHz.

    // Initialize hardware right after configuring flash, to switch
    //clock to higher frequency and have the rest of the
    //initializations run faster.

    // Copy the DATA segment from Flash to RAM (inlined).
    __initialize_data(&__textdata__, &__data_start__, &__data_end__);

    // Zero fill the BSS section (inlined).
    __initialize_bss(&__bss_start__, &__bss_end__);

    //Core is running normally, RAM and FLASH are initialized
    //properly, now the system must be fully functional.

    //Update the SystemCoreClock variable.

    // Call the main entry point, and save the exit code.
    int code = main();

    //Main should never return. If it does, let the system exit gracefully.
    _exit (code);

    // Should never reach this, _exit() should have already
    // performed a reset.

static inline void __initialize_data (unsigned int* from, unsigned int* region_begin, unsigned int* region_end)
    // Iterate and copy word by word.
    // It is assumed that the pointers are word aligned.
    unsigned int *p = region_begin;
    while (p < region_end)
        *p++ = *from++;

static inline void __initialize_bss (unsigned int* region_begin, unsigned int* region_end)
    // Iterate and clear word by word.
    // It is assumed that the pointers are word aligned.
    unsigned int *p = region_begin;
    while (p < region_end)
        *p++ = 0;

What is happening here.

  • First I configure the Flash controller, as this is required by my MCU, before changing frequency. You may add any very basic and needed for your hardware code here. Note that the code placed here should not access any globals in the RAM, as they are not initialized yet. Also note that the MCU still operates at a low frequency, so only call the absolutely needed.
  • Then I call the CMSIS function SystemInit(). This is somewhat portable, that's why I use it. It mostly handles the core, not the MCU ot self, in my specific implementations it only enables the PLL, and sets the MCU to its final high frequency. You may substitute it with your more efficient code, but it is not a big deal.
  • Next step, now that the MCU is fast, is to initialize the RAM. Pretty straight-forward.
  • The MCU is up and running normally now. I just call the CMSIS function SystemCoreClockUpdate(), as I use in my code the SystemCoreClock variable, but it is not needed, just my preference.
  • Finally I call the main function. Your application now executes normally.
  • If the main returns, a call to _exit() is a good practise, to restart your system.

More or less this is it.

  • 4
    \$\begingroup\$ Due to the length of the answer it may seem scary. Also while trying to understand that, you may have to combat your toolchain to get it do what you what. Don't worry, finally you will understand how simple and versatile is the above code. You may be able to port it on any ARM MCU, in just an evening when you understand how things work. Or you may enhance it satisfying your own personal needs easily. \$\endgroup\$ Commented Mar 25, 2016 at 14:36
  • \$\begingroup\$ I think you might want to call __initialize_data() and __initialize_bss() earlier than you do, even though that'll run at slow speed. Otherwise, you have to make sure that SystemInit() and your Flash_*() routines don't use globals at all. \$\endgroup\$ Commented Mar 25, 2016 at 22:40
  • \$\begingroup\$ That's more than I could ask! Thanks for the detailed answer! \$\endgroup\$
    – John
    Commented Mar 25, 2016 at 23:36
  • \$\begingroup\$ It is really nice to have this all in one place. Thanks for your time and knowledge! \$\endgroup\$
    – bitsmack
    Commented Mar 28, 2016 at 16:05
  • \$\begingroup\$ @Pål-Kristian Engstad Exactly. Should have made it more clear. I may edit the answer when I have free time, so those copy-pasting the code are safe. \$\endgroup\$ Commented Mar 29, 2016 at 11:37

The cortex-ms unlike full sized arms, use a vector table. They also do not have modes and banked registers. And for events/interrupts they conform to the ARM coding standard. Which means the bare minimum you need, however you choose to get it there is the first word at address zero is the initial value for the stack pointer, and the second word is the address to branch to on reset. Very easy to do using assembly directives.

.globl _start
.word 0x20001000
.word main

But again you can do whatever you want so long as the first two words have the right values. Note that a thumb address for branching has the lsbit set. It is not really part of the address, it just indicates that we are (staying) in thumb mode.

You have to consume those four bytes with something, but if you have some other code you use to set the stack pointer you dont have to use the vector table, it will load what you put there then you can always change it. There is only one stack pointer though not like full sized/older arms.

The word startup is very vague, so I could have covered it already with those directives or it could take you many thousands more lines of C code to finish starting up your microcontroller depending on what you meant.

Esp with an STM32 you have to clock enable the peripherals you want to use, you have to configure them for what you want them to do and so on. Not really any different than any other microcontroller, except each vendor and product family has different logic and initializes a different way.


Startup files that come from a manufacturer are normally designed to support a C compiler environment. That will include a whole lot of stuff related to setting up the memory map, zero initializing memory, initializing variables and setting up the startup (reset vector).

Some startup files will also include setting up the interrupt vectors and the interrupt controller although some environments I've worked with have this in a separate assembly language file.

Sometimes complexity is seen in a startup file because different models are supported based upon the CPU architecture. The models might be named things like "compact" and "large".

Minimal in the way that you have asked will be driven almost entirely upon what you need. So it really comes down to fully understanding your architecture, needed environment and how your platform works. Then you can either trim down the vendor supplied files to suit your needs OR write your own from scratch.

But, all that said, if you intend to write code in C you are best off just leaving the startup code alone and simply setting things up for the programming model and concentrate your code as starting at main().


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.