src/main/target/stm32_flash_f4xx.ld

   1
   2 /* Internal Memory Map*/
   3 MEMORY
   4 {
   5         rom (rx)  : ORIGIN = 0x08000000, LENGTH = 0x00100000
   6         ram (rwx) : ORIGIN = 0x20000000, LENGTH = 0x00020000
   7         ram1 (rwx) : ORIGIN = 0x10000000, LENGTH = 0x00010000
   8 }
   9
  10 _eram = 0x20000000 + 0x00020000;
  11 SECTIONS
  12 {
  13         .text :
  14         {
  15             PROVIDE (isr_vector_table_base = .);
  16                 KEEP(*(.isr_vector))
  17                 *(.text*)
  18
  19                 KEEP(*(.init))
  20                 KEEP(*(.fini))
  21
  22                 /* .ctors */
  23                 *crtbegin.o(.ctors)
  24                 *crtbegin?.o(.ctors)
  25                 *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
  26                 *(SORT(.ctors.*))
  27                 *(.ctors)
  28
  29                 /* .dtors */
  30                 *crtbegin.o(.dtors)
  31                 *crtbegin?.o(.dtors)
  32                 *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
  33                 *(SORT(.dtors.*))
  34                 *(.dtors)
  35
  36                 *(.rodata*)
  37
  38                 KEEP(*(.eh_fram e*))
  39         } > rom
  40
  41         .ARM.extab :
  42         {
  43                 *(.ARM.extab* .gnu.linkonce.armextab.*)
  44         } > rom
  45
  46         __exidx_start = .;
  47         .ARM.exidx :
  48         {
  49                 *(.ARM.exidx* .gnu.linkonce.armexidx.*)
  50         } > rom
  51         __exidx_end = .;
  52         __etext = .;
  53
  54         /* _sidata is used in coide startup code */
  55         _sidata = __etext;
  56
  57         .data : AT (__etext)
  58         {
  59                 __data_start__ = .;
  60
  61                 /* _sdata is used in coide startup code */
  62                 _sdata = __data_start__;
  63
  64                 *(vtable)
  65                 *(.data*)
  66
  67                 . = ALIGN(4);
  68                 /* preinit data */
  69                 PROVIDE_HIDDEN (__preinit_array_start = .);
  70                 KEEP(*(.preinit_array))
  71                 PROVIDE_HIDDEN (__preinit_array_end = .);
  72
  73                 . = ALIGN(4);
  74                 /* init data */
  75                 PROVIDE_HIDDEN (__init_array_start = .);
  76                 KEEP(*(SORT(.init_array.*)))
  77                 KEEP(*(.init_array))
  78                 PROVIDE_HIDDEN (__init_array_end = .);
  79
  80                 . = ALIGN(4);
  81                 /* finit data */
  82                 PROVIDE_HIDDEN (__fini_array_start = .);
  83                 KEEP(*(SORT(.fini_array.*)))
  84                 KEEP(*(.fini_array))
  85                 PROVIDE_HIDDEN (__fini_array_end = .);
  86
  87                 KEEP(*(.jcr*))
  88                 . = ALIGN(4);
  89                 /* All data end */
  90                 __data_end__ = .;
  91
  92                 /* _edata is used in coide startup code */
  93                 _edata = __data_end__;
  94         } > ram
  95
  96         .bss :
  97         {
  98                 . = ALIGN(4);
  99                 __bss_start__ = .;
 100                 _sbss = __bss_start__;
 101                 *(.bss*)
 102                 *(COMMON)
 103                 . = ALIGN(4);
 104                 __bss_end__ = .;
 105                 _ebss = __bss_end__;
 106         } > ram
 107
 108         .heap (COPY):
 109         {
 110                 __end__ = .;
 111                 _end = __end__;
 112                 end = __end__;
 113                 *(.heap*)
 114                 __HeapLimit = .;
 115         } > ram
 116
 117         /* .stack_dummy section doesn't contains any symbols. It is only
 118         * used for linker to calculate size of stack sections, and assign
 119         * values to stack symbols later */
 120         .co_stack (NOLOAD):
 121         {
 122                 . = ALIGN(8);
 123                 *(.co_stack .co_stack.*)
 124         } > ram
 125
 126         /* Set stack top to end of ram , and stack limit move down by
 127         * size of stack_dummy section */
 128         __StackTop = ORIGIN(ram ) + LENGTH(ram );
 129         __StackLimit = __StackTop - SIZEOF(.co_stack);
 130         PROVIDE(__stack = __StackTop);
 131
 132         /* Check if data + heap + stack exceeds ram  limit */
 133         ASSERT(__StackLimit >= __HeapLimit, "region ram  overflowed with stack")
 134 }\r