Download elf to STM32H743 failed when code over 512K , STM32CubeIDE 1.16.0

[SDFSDFDSF]

I use STM32CubeIDE 1.16.0 to do project and use STM32H743.when my code is over 512K, I re-write ld file,but download is failed.

But I use STM32CubeProgrammer to download  the same elf file,it worked!!! 

 

So what's wrong about it ?

[TDK]

What is the full STM32 part number? Is this a custom board?

What is the full error message along with surrounding context?

[SDFSDFDSF]

please check this：

https://shequ.stmicroelectronics.cn/forum.php?mod=viewthread&tid=643862&pid=2662846&page=1&extra=#pid2662846

 

 

 STM is   STM32H743VGT6。

[Pavel A.]

@SDFSDFDSF What is the exact STM32H743 part number? 

 

STM32H743VGxx officially has a hole after 512KB, between bank1 and bank2. But! The hole does not have to exist. This can explain why CubeProgrammer and the debugger behave differently. Officially, your .ld file that does not have the gap after 512KB is wrong for H743xG.

 

[SDFSDFDSF]

So,what I can do when my code size is over 512K?

[Pavel A.]

Divide it to two blocks: 512K in bank1, and 512K in bank2.  You can also use the undocumented space in the gap between the banks, on your own risk.

 

[Pavel A.]

Cannot find your .ld file attached here?

Try something like this:

FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 512K
FLASH2 (rx) : ORIGIN = 0x08100000, LENGTH = 512K

[SDFSDFDSF]

/* Entry Point */

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 = 0x2000 ; /* required amount of heap */

_Min_Stack_Size = 0x2000 ; /* required amount of stack */

 

/* Specify the memory areas */

MEMORY

{

FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1024K

FLASH2 (rx) : ORIGIN = 0x08100000, LENGTH = 512K

DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K

RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K

RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K

RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K

ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K

}

 

/* Define output sections */

SECTIONS

{

/* The startup code goes first into FLASH */

.isr_vector :

{

. = ALIGN(4);

KEEP(*(.isr_vector)) /* Startup code */

. = ALIGN(4);

} >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

 

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

}

 

Why FLASH2 start address is 0x08100000?

0x08000000 ~ 0x08100000 is 1024kbytes.

 

[Pavel A.]

 

>> FLASH | FLASH2

This isn't valid syntax.

To use the FLASH2 you may need to analyze the map file and distribute the source modules between FLASH1 and FLASH2. The ld file will be more complicated, unfortunately. Maybe if you define a single FLASH of 1.5MB, and put a section of 512K at absolute address 0x8080000 before defining other normal sections, it could work too. I haven't tried this for GNU linker.

Or just define all RAM as non-executabe ("rw") and both flash regions as "rx", and remove from .ld file definition of all sections that should go to flash. Then the linker could automatically place stuff.