STM32H7 spi6 BDMA use sram4 Hard Fault

debugging BDMA find sram1 sram2 sram3 sram4 not use , it trigger interrupt
STM32_IRQ_HARDFAULT interrupt number is 3 use hello wold test
MEMORY
{
ITCM_RAM (rwx) : ORIGIN = 0x00000000, LENGTH = 64K
FLASH (rx) : ORIGIN = 0x08020000, LENGTH = 1917K
DTCM1_RAM (rwx) : ORIGIN = 0x20000000, LENGTH = 64K
DTCM2_RAM (rwx) : ORIGIN = 0x20010000, LENGTH = 64K
AXI_SRAM (rwx) : ORIGIN = 0x24000000, LENGTH = 512K /* D1 domain AXI bus /
SRAM1 (rwx) : ORIGIN = 0x30000000, LENGTH = 128K /
D2 domain AHB bus /
SRAM2 (rwx) : ORIGIN = 0x30020000, LENGTH = 128K /
D2 domain AHB bus /
SRAM3 (rwx) : ORIGIN = 0x30040000, LENGTH = 32K /
D2 domain AHB bus /
SRAM4 (rwx) : ORIGIN = 0x38000000, LENGTH = 64K /
D3 domain */
BKPRAM (rwx) : ORIGIN = 0x38800000, LENGTH = 4K
}

OUTPUT_ARCH(arm)
EXTERN(_vectors)
ENTRY(_stext)

/*

  • Ensure that abort() is present in the final object. The exception handling
  • code pulled in by libgcc.a requires it (and that code cannot be easily avoided).
    */
    EXTERN(abort)
    EXTERN(_bootdelay_signature)

SECTIONS
{
.text : {
_stext = ABSOLUTE(.);
(.vectors)
. = ALIGN(32);
/

This signature provides the bootloader with a way to delay booting
*/
_bootdelay_signature = ABSOLUTE(.);
FILL(0xffecc2925d7d05c5)
. += 8;
(.text .text.)
*(.fixup)
*(.gnu.warning)
(.rodata .rodata.)
(.gnu.linkonce.t.)
*(.glue_7)
*(.glue_7t)
*(.got)
*(.gcc_except_table)
(.gnu.linkonce.r.)
_etext = ABSOLUTE(.);

	/*
	 * This is a hack to make the newlib libm __errno() call
	 * use the NuttX get_errno_ptr() function.
	 */
	__errno = get_errno_ptr;
} > FLASH

/*
 * Init functions (static constructors and the like)
 */
.init_section : {
	_sinit = ABSOLUTE(.);
	KEEP(*(.init_array .init_array.*))
	_einit = ABSOLUTE(.);
} > FLASH

/*
 * Construction data for parameters.
 */
__param ALIGN(4): {
	__param_start = ABSOLUTE(.);
	KEEP(*(__param*))
	__param_end = ABSOLUTE(.);
} > FLASH

.ARM.extab : {
	*(.ARM.extab*)
} > FLASH

__exidx_start = ABSOLUTE(.);
.ARM.exidx : {
	*(.ARM.exidx*)
} > FLASH
__exidx_end = ABSOLUTE(.);

_eronly = ABSOLUTE(.);

.data : {
	_sdata = ABSOLUTE(.);
	*(.data .data.*)
	*(.gnu.linkonce.d.*)
	CONSTRUCTORS
	_edata = ABSOLUTE(.);
} > AXI_SRAM AT > FLASH

.bss : {
	_sbss = ABSOLUTE(.);
	*(.bss .bss.*)
	*(.gnu.linkonce.b.*)
	*(COMMON)
	. = ALIGN(4);
	_ebss = ABSOLUTE(.);
} > AXI_SRAM

.sram1 (NOLOAD) :
{
. = ALIGN(4);
*(.sram1)
*(.sram1.*)
. = ALIGN(4);
__sram1_free__ = .;

} > SRAM1
/* Emit the the D3 power domain section for locating BDMA data */
.sram4 (NOLOAD) : ALIGN(4)
{
	. = ALIGN(4);
	*(.sram4)
	*(.sram4.*)
	. = ALIGN(4);
	__sram4_free__ = .;
} > SRAM4

.bkpram (NOLOAD) :
{
} > BKPRAM

/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_info 0 : { *(.debug_info) }
.debug_line 0 : { *(.debug_line) }
.debug_pubnames 0 : { *(.debug_pubnames) }
.debug_aranges 0 : { *(.debug_aranges) }

}

#include “hello_example.h”

#include <px4_platform_common/app.h>

#include <px4_platform_common/init.h>

#include <stdio.h>

static uint32_t kk[2] locate_data(".sram4");

static uint32_t qq locate_data(".bss");

int PX4_MAIN(int argc, char **argv)

{

px4::init(argc, argv, “hello”);

printf(“hello\n”);

kk[0] = 1222;

kk[1] = 4567;

qq = 12345;

uint32_t dd = 9876;

printf("%d %x\n", kk[0], &kk[0]);

printf("%d %x\n", qq, &qq);

printf("%d %x\n", dd, &dd);

// HelloExample hello;

// hello.main();

printf(“goodbye\n”);

return 0;

}

You never return from main. There is nothing to return to, so it hard faults.