(STM32WB55) Generated Binary is too large. Expected <100kB but get >500kB.

[TomC]

I have added a partition (MY_MEMORY) to my flash to store a static library (littlefs) so that I don't have to include it in the firmware that is updated over the air however the output binary file for the project is very large. I have reviewed this post which describes a similar problem however the given solution has not worked in my case.

/*
******************************************************************************
**
**  File        : LinkerScript.ld
**
**  Author      : STM32CubeIDE
**
**  Abstract    : Linker script for STM32WB55xG Device
**                      1024Kbytes FLASH
**                      256Kbytes RAM
**
**                Set heap size, stack size and stack location according
**                to application requirements.
**
**                Set memory bank area and size if external memory is used.
**
**  Target      : STMicroelectronics STM32
**
**  Distribution: The file is distributed as is without any warranty
**                of any kind.
**
*****************************************************************************
** @attention
**
** Copyright (c) 2023 STMicroelectronics.
** All rights reserved.
**
** This software is licensed under terms that can be found in the LICENSE file
** in the root directory of this software component.
** If no LICENSE file comes with this software, it is provided AS-IS.
**
*****************************************************************************
*/

/* Entry Point */
ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = ORIGIN(RAM1) + LENGTH(RAM1);    /* end of RAM1 */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200;  /* required amount of heap  */
_Min_Stack_Size = 0x400; /* required amount of stack */

/* Specify the memory areas */
MEMORY
{
FLASH (rx)                 : ORIGIN = 0x08009000, LENGTH = 176K
MY_MEMORY (rx)	           : ORIGIN = 0x08081000, LENGTH = 64K
RAM1 (xrw)                 : ORIGIN = 0x20000008, LENGTH = 0x2FFF8
RAM_SHARED (xrw)           : ORIGIN = 0x20030000, LENGTH = 10K

}

/* Define output sections */
SECTIONS
{
  /*  Make sure that the LFS flash region contents fit into the region. */
  /*ASSERT(LENGTH(LFS_FLASH_REGION) >= (__littlefs_section_end__ - __littlefs_section_start__),"Static lib section doesn't fit in allocated flash region.")*/
  
  /* The startup code goes first into FLASH */
  .isr_vector :
  {
    . = ALIGN(4);
    KEEP(*(.isr_vector)) /* Startup code */ 
    . = ALIGN(4);
  } >FLASH
  
  .API_SHARED 0x08081000:
  {
    . = ALIGN(4);
	*(.text.lfs*)
	*(.text.add)
	. = ALIGN(4);
  } > MY_MEMORY
  
  /* The program code and other data goes into FLASH */
  .text :
  {
    . = ALIGN(4);
    *(.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(4);
    _etext = .;        /* define a global symbols at end of code */
  } >FLASH

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

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

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

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

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

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

  /* Uninitialized data section */
  . = ALIGN(4);
  .bss :
  {
    /* This is used by the startup in order to initialize the .bss section */
    _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;
  } >RAM1

  /* 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);
  } >RAM1

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

  .ARM.attributes 0       : { *(.ARM.attributes) }
   MAPPING_TABLE (NOLOAD) : { *(MAPPING_TABLE) } >RAM_SHARED
   MB_MEM1 (NOLOAD)       : { *(MB_MEM1) } >RAM_SHARED

   /* used by the startup to initialize .MB_MEM2 data */
  _siMB_MEM2 = LOADADDR(.MB_MEM2);
  .MB_MEM2 (NOLOAD):
  {
    _sMB_MEM2 = . ;
    *(MB_MEM2) ;
    _eMB_MEM2 = . ;
  } >RAM_SHARED AT> FLASH
}

[LCE]

Your addresses seem a little off, although I don't know that MCU:

FLASH (rx)                 : ORIGIN = 0x08009000, LENGTH = 176K
MY_MEMORY (rx)	           : ORIGIN = 0x08081000, LENGTH = 64K

 FLASH starts at 0x08009000, and MY_MEMORY 0x08081000, which is a difference of about 500k...

[TDK]

BIN files aren't able to store data from separate places like this without filling in the data between them. Use a HEX or ELF file, or create a separate BIN file for each memory section.

[TomC · Accepted solution]

Thanks for your response TDK. I ended up getting around the problem by first loading the micro with the binary that was generated with the linker script below. This binary loads LittleFS to 0x08081000 and will be about 20kB larger because of it.

 .API_SHARED 0x08081000:
  {
    . = ALIGN(4);
	*(.text.lfs*)
	*(.text.add)
	. = ALIGN(4);
  } > MY_MEMORY

Then when I generate the firmware that will be updated with OTA I use the linker script below which contains the keyword NOLOAD. This binary will look to 0x08081000 for LittleFS functions but not actually compile any LittleFS code, meaning the generated OTA binary is smaller.

 .API_SHARED 0x08081000 (NOLOAD):
  {
    . = ALIGN(4);
	*(.text.lfs*)
	*(.text.add)
	. = ALIGN(4);
  } > MY_MEMORY

[TomC]

Hi LCE thank you for your response, indeed as you say the addresses are non-standard due to the inclusion of a bootloader at 0x0800000 and some firmware staging slots between 0x08009000 and 0x08081000.