tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_RENESAS/TARGET_RZ_A1H/TOOLCHAIN_GCC_ARM/RZA1H.ld

   1 /* Linker script for mbed RZ_A1H */
   2
   3 /* Linker script to configure memory regions. */
   4 MEMORY
   5 {
   6   ROM   (rx)  : ORIGIN = 0x00000000, LENGTH = 0x02000000
   7   BOOT_LOADER (rx) : ORIGIN = 0x18000000, LENGTH = 0x00004000
   8   SFLASH (rx) : ORIGIN = 0x18004000, LENGTH = 0x07FFC000
   9   L_TTB (rw)  : ORIGIN = 0x20000000, LENGTH = 0x00004000
  10   RAM (rwx) : ORIGIN = 0x20020000, LENGTH = 0x00700000
  11   RAM_NC (rwx) : ORIGIN = 0x20900000, LENGTH = 0x00100000
  12 }
  13
  14 /* Linker script to place sections and symbol values. Should be used together
  15  * with other linker script that defines memory regions FLASH and RAM.
  16  * It references following symbols, which must be defined in code:
  17  *   Reset_Handler : Entry of reset handler
  18  *
  19  * It defines following symbols, which code can use without definition:
  20  *   __exidx_start
  21  *   __exidx_end
  22  *   __etext
  23  *   __data_start__
  24  *   __preinit_array_start
  25  *   __preinit_array_end
  26  *   __init_array_start
  27  *   __init_array_end
  28  *   __fini_array_start
  29  *   __fini_array_end
  30  *   __data_end__
  31  *   __bss_start__
  32  *   __bss_end__
  33  *   __end__
  34  *   end
  35  *   __HeapLimit
  36  *   __StackLimit
  37  *   __StackTop
  38  *   __stack
  39  */
  40 ENTRY(Reset_Handler)
  41
  42 SECTIONS
  43 {
  44     .boot :
  45     {
  46         KEEP(*(.boot_loader))
  47     } > BOOT_LOADER
  48
  49     .text :
  50     {
  51
  52         Image$$VECTORS$$Base = .;
  53         * (RESET)
  54         Image$$VECTORS$$Limit = .;
  55         . += 0x00000400;
  56
  57         KEEP(*(.isr_vector))
  58         *(SVC_TABLE)
  59         *(.text*)
  60
  61         KEEP(*(.init))
  62         KEEP(*(.fini))
  63
  64         /* .ctors */
  65         *crtbegin.o(.ctors)
  66         *crtbegin?.o(.ctors)
  67         *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
  68         *(SORT(.ctors.*))
  69         *(.ctors)
  70
  71         /* .dtors */
  72         *crtbegin.o(.dtors)
  73         *crtbegin?.o(.dtors)
  74         *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
  75         *(SORT(.dtors.*))
  76         *(.dtors)
  77
  78         Image$$RO_DATA$$Base = .;
  79         *(.rodata*)
  80         Image$$RO_DATA$$Limit = .;
  81
  82         KEEP(*(.eh_frame*))
  83     } > SFLASH
  84
  85     .ARM.extab :
  86     {
  87         *(.ARM.extab* .gnu.linkonce.armextab.*)
  88     } > SFLASH
  89
  90     __exidx_start = .;
  91     .ARM.exidx :
  92     {
  93         *(.ARM.exidx* .gnu.linkonce.armexidx.*)
  94     } > SFLASH
  95     __exidx_end = .;
  96
  97
  98     .copy.table :
  99     {
 100         . = ALIGN(4);
 101         __copy_table_start__ = .;
 102         LONG (__etext)
 103         LONG (__data_start__)
 104         LONG (__data_end__ - __data_start__)
 105         LONG (__etext2)
 106         LONG (__nc_data_start)
 107         LONG (__nc_data_end - __nc_data_start)
 108         __copy_table_end__ = .;
 109     } > SFLASH
 110
 111     .zero.table :
 112     {
 113         . = ALIGN(4);
 114         __zero_table_start__ = .;
 115         LONG (__bss_start__)
 116         LONG (__bss_end__ - __bss_start__)
 117         LONG (__nc_bss_start)
 118         LONG (__nc_bss_end - __nc_bss_start)
 119         __zero_table_end__ = .;
 120     } > SFLASH
 121
 122     __etext = .;
 123
 124     .ttb :
 125     {
 126         Image$$TTB$$ZI$$Base = .;
 127         . += 0x00004000;
 128         Image$$TTB$$ZI$$Limit = .;
 129     } > L_TTB
 130
 131     .data : AT (__etext)
 132     {
 133         Image$$RW_DATA$$Base = .;
 134         __data_start__ = .;
 135         *(vtable)
 136         *(.data*)
 137         Image$$RW_DATA$$Limit = .;
 138
 139         . = ALIGN(4);
 140         /* preinit data */
 141         PROVIDE (__preinit_array_start = .);
 142         KEEP(*(.preinit_array))
 143         PROVIDE (__preinit_array_end = .);
 144
 145         . = ALIGN(4);
 146         /* init data */
 147         PROVIDE (__init_array_start = .);
 148         KEEP(*(SORT(.init_array.*)))
 149         KEEP(*(.init_array))
 150         PROVIDE (__init_array_end = .);
 151
 152
 153         . = ALIGN(4);
 154         /* finit data */
 155         PROVIDE (__fini_array_start = .);
 156         KEEP(*(SORT(.fini_array.*)))
 157         KEEP(*(.fini_array))
 158         PROVIDE (__fini_array_end = .);
 159
 160         . = ALIGN(4);
 161         /* All data end */
 162         __data_end__ = .;
 163
 164     } > RAM
 165
 166
 167     .bss ALIGN(0x400):
 168     {
 169         Image$$ZI_DATA$$Base = .;
 170         __bss_start__ = .;
 171         *(.bss*)
 172         *(COMMON)
 173         __bss_end__ = .;
 174         Image$$ZI_DATA$$Limit = .;
 175     } > RAM
 176
 177
 178     .heap :
 179     {
 180         __end__ = .;
 181         end = __end__;
 182         *(.heap*)
 183         __HeapLimit = .;
 184     } > RAM
 185
 186     /* .stack_dummy section doesn't contains any symbols. It is only
 187      * used for linker to calculate size of stack sections, and assign
 188      * values to stack symbols later */
 189     .stack_dummy :
 190     {
 191         *(.stack)
 192     } > RAM
 193
 194     __etext2 = __etext + SIZEOF(.data);
 195     .nc_data : AT (__etext2)
 196     {
 197         Image$$RW_DATA_NC$$Base = .;
 198         __nc_data_start = .;
 199         *(NC_DATA)
 200
 201         . = ALIGN(4);
 202         __nc_data_end = .;
 203         Image$$RW_DATA_NC$$Limit = .;
 204     } > RAM_NC
 205
 206     .nc_bss (NOLOAD) :
 207     {
 208         Image$$ZI_DATA_NC$$Base = .;
 209         __nc_bss_start = .;
 210         *(NC_BSS)
 211
 212         . = ALIGN(4);
 213         __nc_bss_end = .;
 214         Image$$ZI_DATA_NC$$Limit = .;
 215     } > RAM_NC
 216
 217     /* Set stack top to end of RAM, and stack limit move down by
 218      * size of stack_dummy section */
 219     __StackTop = ORIGIN(RAM) + LENGTH(RAM);
 220     __StackLimit = __StackTop - SIZEOF(.stack_dummy);
 221     PROVIDE(__stack = __StackTop);
 222
 223     /* Check if data + heap + stack exceeds RAM limit */
 224     ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack")
 225
 226
 227 }