Memory related issue with MCU startup ( __libc_init_array )

Dear Sebastian,

That is an interesting idea. However, I've checked the *.elf file and the linker script and it appears that __init_array is placed in the Flash Section.

You can find the content of my linker file at the very bottom, if it is of any use for you. 

Is there a possibility to debug deeper into bl __libc_init_array?

Kind regards,

Oliver

/* Entry Point */
ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = 0x20018000;    /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x150;      /* required amount of heap  */
_Min_Stack_Size = 0x500; /* required amount of stack */

/* Specify the memory areas */
MEMORY
{
RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 96K
SRAM2 (xrw)      : ORIGIN = 0x10000000, LENGTH = 32K
FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 1022K
FLASH2 (xrw)      : ORIGIN = 0x080FF800, LENGTH = 2K
}

/* Define output sections */
SECTIONS
{
  /* The startup code goes first into FLASH */
  .isr_vector :
  {
    . = ALIGN(8);
    KEEP(*(.isr_vector)) /* Startup code */
    . = ALIGN(8);
  } >FLASH

  /* The program code and other data goes into FLASH */
  .text :
  {
    . = ALIGN(8);
    *(.text)           /* .text sections (code) */
    *(.text*)          /* .text* sections (code) */
    *(.glue_7)         /* glue arm to thumb code */
    *(.glue_7t)        /* glue thumb to arm code */
    *(.eh_frame)

    KEEP (*(.init))
    KEEP (*(.fini))

    . = ALIGN(8);
    _etext = .;        /* define a global symbols at end of code */
  } >FLASH

  /* Constant data goes into FLASH */
  .rodata :
  {
    . = ALIGN(8);
    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
    . = ALIGN(8);
  } >FLASH

  .ARM.extab   : 
  { 
  . = ALIGN(8);
  *(.ARM.extab* .gnu.linkonce.armextab.*)
  . = ALIGN(8);
  } >FLASH
  .ARM : {
	. = ALIGN(8);
    __exidx_start = .;
    *(.ARM.exidx*)
    __exidx_end = .;
	. = ALIGN(8);
  } >FLASH

  .preinit_array     :
  {
	. = ALIGN(8);
    PROVIDE_HIDDEN (__preinit_array_start = .);
    KEEP (*(.preinit_array*))
    PROVIDE_HIDDEN (__preinit_array_end = .);
	. = ALIGN(8);
  } >FLASH
  
  .init_array :
  {
	. = ALIGN(8);
    PROVIDE_HIDDEN (__init_array_start = .);
    KEEP (*(SORT(.init_array.*)))
    KEEP (*(.init_array*))
    PROVIDE_HIDDEN (__init_array_end = .);
	. = ALIGN(8);
  } >FLASH
  .fini_array :
  {
	. = ALIGN(8);
    PROVIDE_HIDDEN (__fini_array_start = .);
    KEEP (*(SORT(.fini_array.*)))
    KEEP (*(.fini_array*))
    PROVIDE_HIDDEN (__fini_array_end = .);
	. = ALIGN(8);
  } >FLASH

    /* program data to be stored in FLASH */
  .flash_storage :
  {
    . = ALIGN(8);
    KEEP(*(.flash_storage)) /* flash storage code */
    . = ALIGN(8);
  } >FLASH2

  /* used by the startup to initialize data */
  _sidata = LOADADDR(.data);

  /* Initialized data sections goes into RAM, load LMA copy after code */
  .data : 
  {
    . = ALIGN(8);
    _sdata = .;        /* create a global symbol at data start */
    *(.data)           /* .data sections */
    *(.data*)          /* .data* sections */

    . = ALIGN(8);
    _edata = .;        /* define a global symbol at data end */
  } >RAM AT> FLASH

  _sisram2 = LOADADDR(.sram2);

  /* SRAM2 section 
  * 
  * IMPORTANT NOTE! 
  * If initialized variables will be placed in this section,
  * the startup code needs to be modified to copy the init-values.  
  */
  .sram2 :
  {
    . = ALIGN(8);
    _ssram2 = .;       /* create a global symbol at sram2 start */
    *(.sram2)
    *(.sram2*)
    
    . = ALIGN(8);
    _esram2 = .;       /* create a global symbol at sram2 end */
  } >SRAM2 AT> FLASH

  
  /* Uninitialized data section */
  . = ALIGN(4);
  .bss :
  {
    /* This is used by the startup in order to initialize the .bss secion */
    _sbss = .;         /* define a global symbol at bss start */
    __bss_start__ = _sbss;
    *(.bss)
    *(.bss*)
    *(COMMON)

    . = ALIGN(4);
    _ebss = .;         /* define a global symbol at bss end */
    __bss_end__ = _ebss;
  } >RAM

  /* User_heap_stack section, used to check that there is enough RAM left */
  ._user_heap_stack :
  {
    . = ALIGN(8);
    PROVIDE ( end = . );
    PROVIDE ( _end = . );
    . = . + _Min_Heap_Size;
    . = . + _Min_Stack_Size;
    . = ALIGN(8);
  } >RAM

  

  /* Remove information from the standard libraries */
  /DISCARD/ :
  {
    libc.a ( * )
    libm.a ( * )
    libgcc.a ( * )
  }

  .ARM.attributes 0 : { *(.ARM.attributes) }
}

Hey Oliver,

well that's the source code of __libc_init_array() 

void
__libc_init_array (void)
{
  size_t count;
  size_t i;

  count = __preinit_array_end - __preinit_array_start;
  for (i = 0; i < count; i++)
    __preinit_array_start[i] ();

  _init ();

  count = __init_array_end - __init_array_start;
  for (i = 0; i < count; i++)
    __init_array_start[i] ();
}

Since your __preinit_array is 0 bytes and _init is also empty with nosys.specs the only thing that gets executed is the __init_array part.
From the "Details" section in your screenshot I take, that the first entry in your 8byte __init_array section is
0x800001b5 and the second one is 0x0.
Since libc_init_array calls both entries as function pointers, calling 0x0 will be a definite Bus/MemFault on the Cortex-M.

I also noticed you have an alignment of 8 bytes for the init_array sections. In my linker scripts I always use 4 since there is no need there to align to double word boundaries. So maybe change that to 4 in your script too.

And I've seen weird behaviours like yours too, when using inline assembler and the code was compiled with no optimization ("O0"), so I always have the

-falign-functions=4

in my default C-Flags.

Give it a try, I'm looking forward to hearing about your results!

/Sebastian

One more little thing: I switched to the official ARM GCC toolchains a while ago because sometimes the ones maintained by the Chipmakers aren't up to date and so, when you have some extra time (just for the future) I'd suggest you migrate to the 7-2018-q2update...

Greetings,

I encountered this issue this week and found this topic as similar.

I bet that your __init_array has a proper size (2 words as function pointers), but second is 0x0 because __init_array_start is somehow shifted !! Im currently tackling this problem and I found that my first element in __init_array_start is just 1 word above from where it should be. Seems like a compiler issue because __init_array_start and __init_array_end are both 1 word shifted, which results in a correct size calculation within Reset_Handler() but leading to a call of the last element which is indeed empty. 

In my case, i had to change my startup code to iterate from __init_array_start[-1] to __init_array_start[count - 2] but unfortunately, this shift is related to a code payload (i.e number of chars in debug messages, because they are padding final image size).

Any news after this thread has started?

Best, 

Ernest