Is it possible to decice the memory area to download on uC and QSPI?

[MPast.1]

Hi,

is it possibile to decide what area of microcontroller to program (the range) while debugging?

I would like to remove QSPI memory update (via loader) because it take too much time.

[unsigned_char_array]

---

@MPast.1 wrote:

Obviously compiler doesn't generate any errors, but only one warning witch tomorrow I will check

---

Did you find a way to get rid of the warning?

[Tesla DeLorean]

Dump the .ELF, understand what specifically it's complaining about. Check the .MAP

Perhaps you can make the linker script describe the entire QSPI section as NOLOAD, or strip the range from the .HEX, or export section specific binaries and just write the one you want.

There are a lot of versatile tools out there, and object files should be college level stuff.

Does the Warning actually matter? It's just a confirmation you know what's going on. You asked the tools to strip content. Did that actually occur? Did data get left in there?

[unsigned_char_array]

Linker file:

ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1);    /* end of RAM */
/* 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
{
  ITCMRAM      (xrw) : ORIGIN = 0x00000000,  LENGTH =   64K
  DTCMRAM      (xrw) : ORIGIN = 0x20000000,  LENGTH =  128K
  FLASH        (rx)  : ORIGIN = 0x08000000,  LENGTH = 1024K
  RAM_D1_ETH   (xrw) : ORIGIN = 0x24000000,  LENGTH =  256
  RAM_D1       (xrw) : ORIGIN = 0x24000100,  LENGTH =  320K-256
  RAM_D2       (xrw) : ORIGIN = 0x30000000,  LENGTH =   16K
  RAM_D2_LWIP  (xrw) : ORIGIN = 0x30004000,  LENGTH =   16K
  RAM_D3       (xrw) : ORIGIN = 0x38000000,  LENGTH =   16K
  
  HYPERRAM     (rw)  : ORIGIN = 0x70000000,  LENGTH =    8M /* 64Mib =  8MiB*/
  OCTOFLASH    (r)   : ORIGIN = 0x90000000,  LENGTH =   32M /*256Mib = 32MiB*/
}

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

  .textoctoflash :
  {
    . = ALIGN(4);
    _octoflash_start = .;  /* create a global symbol at octoflash start */
    *(.textoctoflash)      /* .textoctoflash sections */
    *(.textoctoflash*)     /* .textoctoflash* sections */
    . = ALIGN(4);
    _octoflash_end = .;    /* define a global symbols at end of textoctoflash */
    
  } >OCTOFLASH
  /*>OCTOFLASH AT> FLASH*/

  /* 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 */
  } >RAM_D1 AT> FLASH
  
  .data2 :
  {
    . = ALIGN(4);
    _sdata2 = .;        /* create a global symbol at data start */
    *(.RxDecripSection) /* Ethernet RX DMA Area */
    *(.TxDecripSection) /* Ethernet TX DMA Area */ 
    . = ALIGN(4);
    _edata2 = .;        /* define a global symbol at data end */
  } >RAM_D1_ETH 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;
  } >RAM_D1

  /* 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_D1

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

  .ARM.attributes 0 : { *(.ARM.attributes) }
  ExtFlashSection : { *(.textoctoflash) } >OCTOFLASH

BufferSection (NOLOAD) :
  {
	*(TouchGFX_Framebuffer TouchGFX_Framebuffer.*)
    *(.gnu.linkonce.r.*)
    . = ALIGN(0x8);
	*(Video_RGB_Buffer Video_RGB_Buffer.*)
    *(.gnu.linkonce.r.*)
    . = ALIGN(0x8);
  } >HYPERRAM
  
  .RAM_D2_LWIP :
  {
    . = ALIGN(8);
    PROVIDE ( end = . );
    PROVIDE ( _end = . );
    . = ALIGN(8);
  } >RAM_D2_LWIP  
}

arm-none-eabi-objdump before stripping:

0 .isr_vector 000002cc 08000000 08000000 00010000 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
1 .textoctoflash 00000000 90000000 90000000 000800c0 2**0
CONTENTS
...
26 ExtFlashSection 001df928 90000000 90000000 00090000 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA

It looks the same if I add (NOLOAD) to textoctoflash.

I strip with

arm-none-eabi-objcopy ${ProjName}.elf ${ProjName}_NO_OFLASH.elf --remove-section=.textoctoflash --remove-section=ExtFlashSection

After stripping I get the following arm-none-eabi-objdump output:

0 .isr_vector 000002cc 08000000 08000000 00010000 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
...

Removing ExtFlashSection gives a warning:

warning: empty loadable segment detected at vaddr=0x90000000, is this intentional?

I have a separate launch file for starting a debug session with the modified elf file. This works and doesn't load the external flash. But I just want to know if I can get rid of the warning. I don't want a separate linker file for debugging, so any modification should preserve the ability for the external flash loader to load the external flash with the original launch file without rebuilding.