ld/scripttempl/elf32msp430.sc

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