startup.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2015-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wempty-translation-unit"
#endif
 
// ----------------------------------------------------------------------------
 
#if defined(__ARM_EABI__)
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os.h>
 
#include <cmsis-plus/diag/trace.h>
 
#include <cmsis_device.h>
 
#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
 
// ----------------------------------------------------------------------------
// This file defines the startup code for a portable embedded
// C/C++ application, built with newlib.
//
// Control reaches here from the reset handler via jump or call.
//
// The actual steps performed by _start are:
// - copy the initialised data region(s)
// - clear the BSS region(s)
// - initialise the system
// - run the preinit/init array (for the C++ static constructors)
// - initialise the arc/argv
// - branch to main()
// - run the fini array (for the C++ static destructors)
// - call _exit(), directly or via exit()
//
// If OS_INCLUDE_STARTUP_INIT_MULTIPLE_RAM_SECTIONS is defined, the
// code is capable of initialising multiple regions.
//
// The normal configuration is standalone, with all support
// functions implemented locally.
//
// For this to be called, the project linker must be configured without
// the startup sequence (-nostartfiles).
// ----------------------------------------------------------------------------
 
#if !defined(OS_INCLUDE_STARTUP_GUARD_CHECKS)
#define OS_BOOL_STARTUP_GUARD_CHECKS (true)
#endif
 
// ----------------------------------------------------------------------------
 
#if !defined(OS_INCLUDE_STARTUP_INIT_MULTIPLE_RAM_SECTIONS)
// Begin address for the initialisation values of the .data section.
// defined in linker script
extern unsigned int _sidata;
// Begin address for the .data section; defined in linker script
extern unsigned int _sdata;
// End address for the .data section; defined in linker script
extern unsigned int _edata;
 
// Begin address for the .bss section; defined in linker script
extern unsigned int __bss_start__;
// End address for the .bss section; defined in linker script
extern unsigned int __bss_end__;
#else
// The following symbols are constructs generated by the linker, indicating
// the location of various points in the "Memory regions initialisation
// arrays". These arrays are created by the linker via the managed linker
// script of each RW data mechanism. It contains the load address, execution
// address and length section and the execution and length of each BSS (zero
// initialised) section.
extern unsigned int __data_regions_array_start;
extern unsigned int __data_regions_array_end;
extern unsigned int __bss_regions_array_start;
extern unsigned int __bss_regions_array_end;
#endif
 
extern unsigned int _Heap_Begin;
extern unsigned long int _Heap_Limit;
extern unsigned long int __stack;
 
extern "C" int
main (int argc, char* argv[]);
 
// ----------------------------------------------------------------------------
 
// Forward declarations
 
extern "C"
{
  // os-hooks.h
  // void
  // _start (void);
 
  static void
  os_initialize_data (unsigned int* from, unsigned int* region_begin,
                      unsigned int* region_end);
 
  static void
  os_initialize_bss (unsigned int* region_begin, unsigned int* region_end);
 
  static void
  os_run_init_array (void);
 
  // Not static since it is called from exit()
  void
  os_run_fini_array (void);
}
 
// ----------------------------------------------------------------------------
 
inline __attribute__ ((always_inline)) void
os_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++;
    }
}
 
inline __attribute__ ((always_inline)) void
os_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;
    }
}
 
// These magic symbols are provided by the linker.
extern void (*__preinit_array_start[]) (void) __attribute__ ((weak));
extern void (*__preinit_array_end[]) (void) __attribute__ ((weak));
extern void (*__init_array_start[]) (void) __attribute__ ((weak));
extern void (*__init_array_end[]) (void) __attribute__ ((weak));
extern void (*__fini_array_start[]) (void) __attribute__ ((weak));
extern void (*__fini_array_end[]) (void) __attribute__ ((weak));
 
// Iterate over all the preinit/init routines (mainly static constructors).
inline __attribute__ ((always_inline)) void
os_run_init_array (void)
{
  trace_printf ("%s()\n", __func__);
 
  int count = __preinit_array_end - __preinit_array_start;
  for (int i = 0; i < count; i++)
    {
      __preinit_array_start[i]();
    }
 
  // If the application needs to run the code in the .init section,
  // please use the startup files, since this requires the code in
  // crti.o and crtn.o to add the function prologue/epilogue.
  //_init(); // DO NOT ENABE THIS!
 
  count = __init_array_end - __init_array_start;
  for (int i = 0; i < count; i++)
    {
      __init_array_start[i]();
    }
}
 
// Run all the cleanup routines (mainly static destructors).
void
os_run_fini_array (void)
{
  trace_printf ("%s()\n", __func__);
 
  int count = __fini_array_end - __fini_array_start;
  for (int i = count; i > 0; i--)
    {
      __fini_array_start[i - 1]();
    }
 
  // If the application needs to run the code in the .fini section,
  // please use the startup files, since this requires the code in
  // crti.o and crtn.o to add the function prologue/epilogue.
  //_fini(); // DO NOT ENABLE THIS!
}
 
#if defined(DEBUG) && (OS_BOOL_STARTUP_GUARD_CHECKS)
 
// These definitions are used to check if the routines used to
// clear the BSS and to copy the initialised DATA perform correctly.
 
#define BSS_GUARD_BAD_VALUE (0xCADEBABA)
 
static uint32_t volatile
    __attribute__ ((section (".bss_begin"))) __bss_begin_guard;
static uint32_t volatile
    __attribute__ ((section (".bss_end"))) __bss_end_guard;
 
#define DATA_GUARD_BAD_VALUE (0xCADEBABA)
#define DATA_BEGIN_GUARD_VALUE (0x12345678)
#define DATA_END_GUARD_VALUE (0x98765432)
 
static uint32_t volatile
    __attribute__ ((section (".data_begin"))) __data_begin_guard
    = DATA_BEGIN_GUARD_VALUE;
 
static uint32_t volatile
    __attribute__ ((section (".data_end"))) __data_end_guard
    = DATA_END_GUARD_VALUE;
 
#endif // defined(DEBUG) && (OS_BOOL_STARTUP_GUARD_CHECKS)
 
void __attribute__ ((section (".after_vectors"), noreturn, weak))
_start (void)
{
  // After Reset the Cortex-M processor is in Thread mode,
  // priority is Privileged, and the Stack is set to Main.
 
  // --------------------------------------------------------------------------
 
  // Initialise hardware right after reset, to switch clock to higher
  // frequency and have the rest of the initialisations run faster.
  //
  // Mandatory on platforms like Kinetis, which start with the watch dog
  // enabled and require an early sequence to disable it.
  //
  // Also useful on platform with external RAM, that need to be
  // initialised before filling the BSS section.
 
  os_startup_initialize_hardware_early ();
 
  // Use Old Style DATA and BSS section initialisation,
  // that will manage a single BSS sections.
 
#if defined(DEBUG) && (OS_BOOL_STARTUP_GUARD_CHECKS)
 
  __data_begin_guard = DATA_GUARD_BAD_VALUE;
  __data_end_guard = DATA_GUARD_BAD_VALUE;
 
#endif
 
#if !defined(OS_INCLUDE_STARTUP_INIT_MULTIPLE_RAM_SECTIONS)
 
  // Copy the DATA segment from Flash to RAM (inlined).
  os_initialize_data (&_sidata, &_sdata, &_edata);
 
#else
 
  // Copy the data sections from flash to SRAM.
  for (unsigned int* p = &__data_regions_array_start;
       p < &__data_regions_array_end;)
    {
      unsigned int* from = (unsigned int*)(*p++);
      unsigned int* region_begin = (unsigned int*)(*p++);
      unsigned int* region_end = (unsigned int*)(*p++);
 
      os_initialize_data (from, region_begin, region_end);
    }
 
#endif
 
#if defined(DEBUG) && (OS_BOOL_STARTUP_GUARD_CHECKS)
 
  if ((__data_begin_guard != DATA_BEGIN_GUARD_VALUE)
      || (__data_end_guard != DATA_END_GUARD_VALUE))
    {
      while (true)
        {
          __NOP ();
        }
    }
 
#endif
 
#if defined(DEBUG) && (OS_BOOL_STARTUP_GUARD_CHECKS)
 
  __bss_begin_guard = BSS_GUARD_BAD_VALUE;
  __bss_end_guard = BSS_GUARD_BAD_VALUE;
 
#endif
 
#if !defined(OS_INCLUDE_STARTUP_INIT_MULTIPLE_RAM_SECTIONS)
 
  // Zero fill the BSS section (inlined).
  os_initialize_bss (&__bss_start__, &__bss_end__);
 
#else
 
  // Zero fill all bss segments
  for (unsigned int* p = &__bss_regions_array_start;
       p < &__bss_regions_array_end;)
    {
      unsigned int* region_begin = (unsigned int*)(*p++);
      unsigned int* region_end = (unsigned int*)(*p++);
      os_initialize_bss (region_begin, region_end);
    }
 
#endif
 
#if defined(DEBUG) && (OS_BOOL_STARTUP_GUARD_CHECKS)
 
  if ((__bss_begin_guard != 0) || (__bss_end_guard != 0))
    {
      while (true)
        {
          __NOP ();
        }
    }
 
#endif
 
  // Hook to continue the initialisations. Usually compute and store the
  // clock frequency in the global CMSIS variable, cleared above.
  os_startup_initialize_hardware ();
 
  // Initialise the trace output device. From this moment on,
  // trace_printf() calls are available (including in static constructors).
  trace_initialize ();
 
  trace_puts (""); // Empty line
 
  trace_printf ("Hardware initialised\n");
  trace_printf ("Main stack %p-%p\n", &_Heap_Limit, &__stack);
 
  os_startup_initialize_free_store (
      &_Heap_Begin,
      static_cast<size_t> (reinterpret_cast<char*> (&_Heap_Limit)
                           - reinterpret_cast<char*> (&_Heap_Begin)));
 
  // Get the argc/argv (useful in semihosting configurations).
  int argc;
  char** argv;
  os_startup_initialize_args (&argc, &argv);
 
  // Call the standard library initialisation (mandatory for C++ to
  // execute the constructors for the static objects).
  os_run_init_array ();
  trace_printf ("Static objects constructed\n");
 
#if defined(OS_HAS_INTERRUPTS_STACK)
  os::rtos::interrupts::stack ()->set (
      &_Heap_Limit,
      static_cast<size_t> (reinterpret_cast<char*> (&__stack)
                           - reinterpret_cast<char*> (&_Heap_Limit)));
#endif /* defined(OS_HAS_INTERRUPTS_STACK) */
 
  // Call the main entry point, and save the exit code.
  int code = main (argc, argv);
 
  // Standard program termination;
  // `atexit()` and C++ static destructors are executed.
  exit (code);
  /* NOTREACHED */
}
 
// ----------------------------------------------------------------------------
 
#if !defined(OS_USE_SEMIHOSTING_SYSCALLS)
 
// Semihosting uses a more elaborate version of os_startup_initialize_args()
// to parse args received from host.
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
// This is the standard default implementation for the routine to
// process args. It returns a single empty arg.
//
// For semihosting applications, this is redefined to get the real
// args from the debugger.
//
// The application can redefine it to fetch some args from a
// non-volatile memory.
 
void __attribute__ ((weak))
os_startup_initialize_args (int* p_argc, char*** p_argv)
{
  // By the time we reach this, the data and bss should have been initialised.
 
  // The strings pointed to by the argv array shall be modifiable by the
  // program, and retain their last-stored values between program startup
  // and program termination. (static, no const)
  static char name[] = "";
 
  // The string pointed to by argv[0] represents the program name;
  // argv[0][0] shall be the null character if the program name is not
  // available from the host environment. argv[argc] shall be a null pointer.
  // (static, no const)
  static char* argv[2] = { name, NULL };
 
  *p_argc = 1;
  *p_argv = &argv[0];
 
  return;
}
 
#pragma GCC diagnostic pop
 
#endif /* !defined(OS_USE_SEMIHOSTING_SYSCALLS) */
 
// ----------------------------------------------------------------------------
 
#endif /* defined(__ARM_EABI__) */