startup.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2015-2023 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__) */