tmk_core/tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_Freescale/TARGET_K20XX/TARGET_TEENSY3_1/TOOLCHAIN_GCC_ARM/MK20DX256.ld

   1 /*
   2  * K20DX256 ARM GCC linker script file
   3  */
   4
   5 MEMORY
   6 {
   7   VECTORS (rx) : ORIGIN = 0x00000000, LENGTH = 0x00000400
   8   FLASH_PROTECTION      (rx) : ORIGIN = 0x00000400, LENGTH = 0x00000010
   9   FLASH (rx) : ORIGIN = 0x00000410, LENGTH = 256K - 0x00000410
  10   RAM (rwx) : ORIGIN = 0x1FFF81C0, LENGTH = 64K - 0x1C0
  11 }
  12
  13 /* Linker script to place sections and symbol values. Should be used together
  14  * with other linker script that defines memory regions FLASH and RAM.
  15  * It references following symbols, which must be defined in code:
  16  * _reset_init : Entry of reset handler
  17  *
  18  * It defines following symbols, which code can use without definition:
  19  * __exidx_start
  20  * __exidx_end
  21  * __etext
  22  * __data_start__
  23  * __preinit_array_start
  24  * __preinit_array_end
  25  * __init_array_start
  26  * __init_array_end
  27  * __fini_array_start
  28  * __fini_array_end
  29  * __data_end__
  30  * __bss_start__
  31  * __bss_end__
  32  * __end__
  33  * end
  34  * __HeapLimit
  35  * __StackLimit
  36  * __StackTop
  37  * __stack
  38  */
  39 ENTRY(Reset_Handler)
  40
  41 SECTIONS
  42 {
  43     .isr_vector :
  44     {
  45         . = 0;
  46         __isr_vector = .;
  47         KEEP(*(.isr_vector))
  48         *(.text.Reset_Handler)
  49         *(.text.SystemInit)
  50          . = ALIGN(4);
  51     } > VECTORS
  52
  53     .flash_protect :
  54     {
  55         KEEP(*(.kinetis_flash_config_field))
  56          . = ALIGN(4);
  57     } > FLASH_PROTECTION
  58
  59     .text :
  60     {
  61         *(.text*)
  62
  63         KEEP(*(.init))
  64         KEEP(*(.fini))
  65
  66         /* .ctors */
  67         *crtbegin.o(.ctors)
  68         *crtbegin?.o(.ctors)
  69         *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
  70         *(SORT(.ctors.*))
  71         *(.ctors)
  72
  73         /* .dtors */
  74         *crtbegin.o(.dtors)
  75         *crtbegin?.o(.dtors)
  76         *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
  77         *(SORT(.dtors.*))
  78         *(.dtors)
  79
  80         *(.rodata*)
  81
  82         KEEP(*(.eh_frame*))
  83     } > FLASH
  84
  85     .ARM.extab :
  86     {
  87         *(.ARM.extab* .gnu.linkonce.armextab.*)
  88     } > FLASH
  89
  90     __exidx_start = .;
  91     .ARM.exidx :
  92     {
  93         *(.ARM.exidx* .gnu.linkonce.armexidx.*)
  94     } > FLASH
  95     __exidx_end = .;
  96
  97     __etext = .;
  98
  99     .data : AT (__etext)
 100     {
 101         __data_start__ = .;
 102         *(vtable)
 103         *(.data*)
 104
 105         . = ALIGN(4);
 106         /* preinit data */
 107         PROVIDE_HIDDEN (__preinit_array_start = .);
 108         KEEP(*(.preinit_array))
 109         PROVIDE_HIDDEN (__preinit_array_end = .);
 110
 111         . = ALIGN(4);
 112         /* init data */
 113         PROVIDE_HIDDEN (__init_array_start = .);
 114         KEEP(*(SORT(.init_array.*)))
 115         KEEP(*(.init_array))
 116         PROVIDE_HIDDEN (__init_array_end = .);
 117
 118
 119         . = ALIGN(4);
 120         /* finit data */
 121         PROVIDE_HIDDEN (__fini_array_start = .);
 122         KEEP(*(SORT(.fini_array.*)))
 123         KEEP(*(.fini_array))
 124         PROVIDE_HIDDEN (__fini_array_end = .);
 125
 126         . = ALIGN(4);
 127         /* All data end */
 128         __data_end__ = .;
 129
 130     } > RAM
 131
 132     .bss :
 133     {
 134         __bss_start__ = .;
 135         *(.bss*)
 136         *(COMMON)
 137         __bss_end__ = .;
 138     } > RAM
 139
 140     .heap :
 141     {
 142         __end__ = .;
 143         end = __end__;
 144         *(.heap*)
 145         __HeapLimit = .;
 146     } > RAM
 147
 148     /* .stack_dummy section doesn't contains any symbols. It is only
 149      * used for linker to calculate size of stack sections, and assign
 150      * values to stack symbols later */
 151     .stack_dummy :
 152     {
 153         *(.stack)
 154     } > RAM
 155
 156     /* Set stack top to end of RAM, and stack limit move down by
 157      * size of stack_dummy section */
 158     __StackTop = ORIGIN(RAM) + LENGTH(RAM);
 159     __StackLimit = __StackTop - SIZEOF(.stack_dummy);
 160     PROVIDE(__stack = __StackTop);
 161
 162     /* Check if data + heap + stack exceeds RAM limit */
 163     ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack")
 164 }