ld/scripttempl/elf32msp430.sc

   1 # Copyright (C) 2014-2016 Free Software Foundation, Inc.
   2 #
   3 # Copying and distribution of this file, with or without modification,
   4 # are permitted in any medium without royalty provided the copyright
   5 # notice and this notice are preserved.
   6
   7 HEAP_SECTION_MSP430=" "
   8 HEAP_MEMORY_MSP430=" "
   9
  10 if test ${GOT_HEAP_MSP-0} -ne 0
  11 then
  12 HEAP_SECTION_MSP430=".heap ${RELOCATING-0} :
  13   {
  14     ${RELOCATING+ PROVIDE (__heap_data_start = .) ; }
  15     *(.heap*)
  16     ${RELOCATING+ PROVIDE (_heap_data_end = .) ; }
  17     ${RELOCATING+. = ALIGN(2);}
  18     ${RELOCATING+ PROVIDE (__heap_bottom = .) ; }
  19     ${RELOCATING+ PROVIDE (__heap_top = ${HEAP_START} + ${HEAP_LENGTH}) ; }
  20   } ${RELOCATING+ > heap}"
  21 HEAP_MEMORY_MSP430="heap(rwx)           : ORIGIN = $HEAP_START, LENGTH = $HEAP_LENGTH"
  22 fi
  23
  24
  25 cat <<EOF
  26 /* Copyright (C) 2014-2016 Free Software Foundation, Inc.
  27
  28    Copying and distribution of this script, with or without modification,
  29    are permitted in any medium without royalty provided the copyright
  30    notice and this notice are preserved.  */
  31
  32 OUTPUT_FORMAT("${OUTPUT_FORMAT}","${OUTPUT_FORMAT}","${OUTPUT_FORMAT}")
  33 OUTPUT_ARCH(${ARCH})
  34
  35 MEMORY
  36 {
  37   text   (rx)           : ORIGIN = $ROM_START,  LENGTH = $ROM_SIZE
  38   data   (rwx)          : ORIGIN = $RAM_START,  LENGTH = $RAM_SIZE
  39   vectors (rw)          : ORIGIN = 0xffe0,      LENGTH = 0x20
  40   bootloader(rx)        : ORIGIN = 0x0c00,      LENGTH = 1K
  41   infomem(rx)           : ORIGIN = 0x1000,      LENGTH = 256
  42   infomemnobits(rx)     : ORIGIN = 0x1000,      LENGTH = 256
  43   ${HEAP_MEMORY_MSP430}
  44 }
  45
  46 SECTIONS
  47 {
  48   /* Bootloader.  */
  49   .bootloader ${RELOCATING-0} :
  50   {
  51     ${RELOCATING+ PROVIDE (__boot_start = .) ; }
  52     *(.bootloader)
  53     ${RELOCATING+. = ALIGN(2);}
  54     *(.bootloader.*)
  55   } ${RELOCATING+ > bootloader}
  56
  57   /* Information memory.  */
  58   .infomem ${RELOCATING-0} :
  59   {
  60     *(.infomem)
  61     ${RELOCATING+. = ALIGN(2);}
  62     *(.infomem.*)
  63   } ${RELOCATING+ > infomem}
  64
  65   /* Information memory (not loaded into MPU).  */
  66   .infomemnobits ${RELOCATING-0} :
  67   {
  68     *(.infomemnobits)
  69     ${RELOCATING+. = ALIGN(2);}
  70     *(.infomemnobits.*)
  71   } ${RELOCATING+ > infomemnobits}
  72
  73   /* Read-only sections, merged into text segment.  */
  74   ${TEXT_DYNAMIC+${DYNAMIC}}
  75   .hash        ${RELOCATING-0} : { *(.hash)             }
  76   .dynsym      ${RELOCATING-0} : { *(.dynsym)           }
  77   .dynstr      ${RELOCATING-0} : { *(.dynstr)           }
  78   .gnu.version ${RELOCATING-0} : { *(.gnu.version)      }
  79   .gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d)  }
  80   .gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r)  }
  81
  82   .rel.init    ${RELOCATING-0} : { *(.rel.init) }
  83   .rela.init   ${RELOCATING-0} : { *(.rela.init) }
  84   .rel.text    ${RELOCATING-0} :
  85     {
  86       *(.rel.text)
  87       ${RELOCATING+*(.rel.text.*)}
  88       ${RELOCATING+*(.rel.gnu.linkonce.t*)}
  89     }
  90   .rela.text   ${RELOCATING-0} :
  91     {
  92       *(.rela.text)
  93       ${RELOCATING+*(.rela.text.*)}
  94       ${RELOCATING+*(.rela.gnu.linkonce.t*)}
  95     }
  96   .rel.fini    ${RELOCATING-0} : { *(.rel.fini) }
  97   .rela.fini   ${RELOCATING-0} : { *(.rela.fini) }
  98   .rel.rodata  ${RELOCATING-0} :
  99     {
 100       *(.rel.rodata)
 101       ${RELOCATING+*(.rel.rodata.*)}
 102       ${RELOCATING+*(.rel.gnu.linkonce.r*)}
 103     }
 104   .rela.rodata ${RELOCATING-0} :
 105     {
 106       *(.rela.rodata)
 107       ${RELOCATING+*(.rela.rodata.*)}
 108       ${RELOCATING+*(.rela.gnu.linkonce.r*)}
 109     }
 110   .rel.data    ${RELOCATING-0} :
 111     {
 112       *(.rel.data)
 113       ${RELOCATING+*(.rel.data.*)}
 114       ${RELOCATING+*(.rel.gnu.linkonce.d*)}
 115     }
 116   .rela.data   ${RELOCATING-0} :
 117     {
 118       *(.rela.data)
 119       ${RELOCATING+*(.rela.data.*)}
 120       ${RELOCATING+*(.rela.gnu.linkonce.d*)}
 121     }
 122   .rel.ctors   ${RELOCATING-0} : { *(.rel.ctors)        }
 123   .rela.ctors  ${RELOCATING-0} : { *(.rela.ctors)       }
 124   .rel.dtors   ${RELOCATING-0} : { *(.rel.dtors)        }
 125   .rela.dtors  ${RELOCATING-0} : { *(.rela.dtors)       }
 126   .rel.got     ${RELOCATING-0} : { *(.rel.got)          }
 127   .rela.got    ${RELOCATING-0} : { *(.rela.got)         }
 128   .rel.bss     ${RELOCATING-0} : { *(.rel.bss)          }
 129   .rela.bss    ${RELOCATING-0} : { *(.rela.bss)         }
 130   .rel.plt     ${RELOCATING-0} : { *(.rel.plt)          }
 131   .rela.plt    ${RELOCATING-0} : { *(.rela.plt)         }
 132
 133   /* Internal text space.  */
 134   .text :
 135   {
 136     ${RELOCATING+. = ALIGN(2);}
 137     *(SORT_NONE(.init))
 138     *(SORT_NONE(.init0))  /* Start here after reset.  */
 139     *(SORT_NONE(.init1))
 140     *(SORT_NONE(.init2))  /* Copy data loop  */
 141     *(SORT_NONE(.init3))
 142     *(SORT_NONE(.init4))  /* Clear bss  */
 143     *(SORT_NONE(.init5))
 144     *(SORT_NONE(.init6))  /* C++ constructors.  */
 145     *(SORT_NONE(.init7))
 146     *(SORT_NONE(.init8))
 147     *(SORT_NONE(.init9))  /* Call main().  */
 148
 149     ${CONSTRUCTING+ __ctors_start = . ; }
 150     ${CONSTRUCTING+ *(.ctors) }
 151     ${CONSTRUCTING+ __ctors_end = . ; }
 152     ${CONSTRUCTING+ __dtors_start = . ; }
 153     ${CONSTRUCTING+ *(.dtors) }
 154     ${CONSTRUCTING+ __dtors_end = . ; }
 155
 156     ${RELOCATING+. = ALIGN(2);}
 157     *(.lower.text.* .lower.text)
 158
 159     ${RELOCATING+. = ALIGN(2);}
 160     *(.text)
 161     ${RELOCATING+. = ALIGN(2);}
 162     *(.text.*)
 163     ${RELOCATING+. = ALIGN(2);}
 164     *(.text:*)
 165
 166     *(.either.text.* .either.text)
 167
 168     ${RELOCATING+. = ALIGN(2);}
 169     *(SORT_NONE(.fini9))
 170     *(SORT_NONE(.fini8))
 171     *(SORT_NONE(.fini7))
 172     *(SORT_NONE(.fini6))  /* C++ destructors.  */
 173     *(SORT_NONE(.fini5))
 174     *(SORT_NONE(.fini4))
 175     *(SORT_NONE(.fini3))
 176     *(SORT_NONE(.fini2))
 177     *(SORT_NONE(.fini1))
 178     *(SORT_NONE(.fini0))  /* Infinite loop after program termination.  */
 179     *(SORT_NONE(.fini))
 180
 181     _etext = .;
 182   } ${RELOCATING+ > text}
 183
 184   .rodata :
 185   {
 186     ${RELOCATING+. = ALIGN(2);}
 187     *(.lower.rodata.* .lower.rodata)
 188
 189     . = ALIGN(2);
 190     *(.plt)
 191     *(.rodata .rodata.* .gnu.linkonce.r.* .const .const:*)
 192     *(.rodata1)
 193
 194     *(.either.rodata.*) *(.either.rodata)
 195     *(.eh_frame_hdr)
 196     KEEP (*(.eh_frame))
 197
 198     KEEP (*(.gcc_except_table)) *(.gcc_except_table.*)
 199
 200     PROVIDE (__preinit_array_start = .);
 201     KEEP (*(.preinit_array))
 202     PROVIDE (__preinit_array_end = .);
 203
 204     PROVIDE (__init_array_start = .);
 205     KEEP (*(SORT(.init_array.*)))
 206     KEEP (*(.init_array))
 207     PROVIDE (__init_array_end = .);
 208
 209     PROVIDE (__fini_array_start = .);
 210     KEEP (*(.fini_array))
 211     KEEP (*(SORT(.fini_array.*)))
 212     PROVIDE (__fini_array_end = .);
 213     LONG(0); /* Sentinel.  */
 214
 215     /* gcc uses crtbegin.o to find the start of the constructors, so
 216        we make sure it is first.  Because this is a wildcard, it
 217        doesn't matter if the user does not actually link against
 218        crtbegin.o; the linker won't look for a file to match a
 219        wildcard.  The wildcard also means that it doesn't matter which
 220        directory crtbegin.o is in.  */
 221     KEEP (*crtbegin*.o(.ctors))
 222
 223     /* We don't want to include the .ctor section from from the
 224        crtend.o file until after the sorted ctors.  The .ctor section
 225        from the crtend file contains the end of ctors marker and it
 226        must be last */
 227     KEEP (*(EXCLUDE_FILE (*crtend*.o ) .ctors))
 228     KEEP (*(SORT(.ctors.*)))
 229     KEEP (*(.ctors))
 230
 231     KEEP (*crtbegin*.o(.dtors))
 232     KEEP (*(EXCLUDE_FILE (*crtend*.o ) .dtors))
 233     KEEP (*(SORT(.dtors.*)))
 234     KEEP (*(.dtors))
 235   } ${RELOCATING+ > text}
 236
 237   .vectors ${RELOCATING-0}:
 238   {
 239     ${RELOCATING+ PROVIDE (__vectors_start = .) ; }
 240     *(.vectors*)
 241     ${RELOCATING+ _vectors_end = . ; }
 242   } ${RELOCATING+ > vectors}
 243
 244   .data ${RELOCATING-0} :
 245   {
 246     ${RELOCATING+ PROVIDE (__data_start = .) ; }
 247     ${RELOCATING+ PROVIDE (__datastart = .) ; }
 248     ${RELOCATING+. = ALIGN(2);}
 249
 250     KEEP (*(.jcr))
 251     *(.data.rel.ro.local) *(.data.rel.ro*)
 252     *(.dynamic)
 253
 254     ${RELOCATING+. = ALIGN(2);}
 255     *(.lower.data.* .lower.data)
 256
 257     *(.data)
 258     *(.data.*)
 259     *(.gnu.linkonce.d*)
 260     KEEP (*(.gnu.linkonce.d.*personality*))
 261     *(.data1)
 262
 263     *(.either.data.* .either.data)
 264
 265     *(.got.plt) *(.got)
 266     ${RELOCATING+. = ALIGN(2);}
 267     *(.sdata .sdata.* .gnu.linkonce.s.*)
 268     ${RELOCATING+. = ALIGN(2);}
 269     ${RELOCATING+ _edata = . ; }
 270   } ${RELOCATING+ > data ${RELOCATING+AT> text}}
 271
 272   __romdatastart = LOADADDR(.data);
 273   __romdatacopysize = SIZEOF(.data);
 274
 275   .bss ${RELOCATING+ SIZEOF(.data) + ADDR(.data)} :
 276   {
 277     ${RELOCATING+. = ALIGN(2);}
 278     ${RELOCATING+ PROVIDE (__bss_start = .) ; }
 279     *(.lower.bss.* .lower.bss)
 280     ${RELOCATING+. = ALIGN(2);}
 281     *(.bss)
 282     *(.either.bss.* .either.bss)
 283     *(COMMON)
 284     ${RELOCATING+ PROVIDE (__bss_end = .) ; }
 285   } ${RELOCATING+ > data}
 286
 287   .noinit ${RELOCATING+ SIZEOF(.bss) + ADDR(.bss)} :
 288   {
 289     ${RELOCATING+ PROVIDE (__noinit_start = .) ; }
 290     *(.noinit)
 291     ${RELOCATING+ PROVIDE (__noinit_end = .) ; }
 292   } ${RELOCATING+ > data}
 293
 294   .persistent ${RELOCATING+ SIZEOF(.noinit) + ADDR(.noinit)} :
 295   {
 296     ${RELOCATING+ PROVIDE (__persistent_start = .) ; }
 297     *(.persistent)
 298     ${RELOCATING+ PROVIDE (__persistent_end = .) ; }
 299   } ${RELOCATING+ > data}
 300
 301   ${RELOCATING+ _end = . ;  }
 302   ${HEAP_SECTION_MSP430}
 303
 304   /* Stabs for profiling information*/
 305   .profiler 0 : { *(.profiler) }
 306
 307   /* Stabs debugging sections.  */
 308   .stab 0 : { *(.stab) }
 309   .stabstr 0 : { *(.stabstr) }
 310   .stab.excl 0 : { *(.stab.excl) }
 311   .stab.exclstr 0 : { *(.stab.exclstr) }
 312   .stab.index 0 : { *(.stab.index) }
 313   .stab.indexstr 0 : { *(.stab.indexstr) }
 314   .comment 0 : { *(.comment) }
 315 EOF
 316
 317 source $srcdir/scripttempl/DWARF.sc
 318
 319 cat <<EOF
 320   .MP430.attributes 0 :
 321   {
 322     KEEP (*(.MSP430.attributes))
 323     KEEP (*(.gnu.attributes))
 324     KEEP (*(__TI_build_attributes))
 325   }
 326
 327   PROVIDE (__stack = ${STACK}) ;
 328   PROVIDE (__data_start_rom = _etext) ;
 329   PROVIDE (__data_end_rom   = _etext + SIZEOF (.data)) ;
 330   PROVIDE (__noinit_start_rom = _etext + SIZEOF (.data)) ;
 331   PROVIDE (__noinit_end_rom = _etext + SIZEOF (.data) + SIZEOF (.noinit)) ;
 332   PROVIDE (__subdevice_has_heap = ${GOT_HEAP_MSP-0}) ;
 333 }
 334 EOF