ld/scripttempl/elf32msp430.sc

   1 # Copyright (C) 2014-2022 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-2022 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     *(.upper.text.* .upper.text)
 175
 176     . = ALIGN(2);
 177     *(SORT_NONE(.fini9))
 178     *(SORT_NONE(.fini8))
 179     *(SORT_NONE(.fini7))
 180     *(SORT_NONE(.fini6))  /* C++ destructors.  */
 181     *(SORT_NONE(.fini5))
 182     *(SORT_NONE(.fini4))
 183     *(SORT_NONE(.fini3))
 184     *(SORT_NONE(.fini2))
 185     *(SORT_NONE(.fini1))
 186     *(SORT_NONE(.fini0))  /* Infinite loop after program termination.  */
 187     *(SORT_NONE(.fini))
 188
 189     _etext = .;}
 190   } ${RELOCATING+ > text}
 191
 192   .rodata ${RELOCATING-0} :
 193   {
 194     ${RELOCATING+. = ALIGN(2);
 195     *(.lower.rodata.* .lower.rodata)
 196
 197     . = ALIGN(2);
 198     *(.plt)}
 199     *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.* .const .const:*})
 200     ${RELOCATING+*(.rodata1)
 201
 202     *(.either.rodata.*) *(.either.rodata)
 203
 204     *(.upper.rodata.* .upper.rodata)
 205
 206     *(.eh_frame_hdr)
 207     KEEP (*(.eh_frame))
 208
 209     KEEP (*(.gcc_except_table)) *(.gcc_except_table.*)
 210
 211     . = ALIGN(2);
 212     PROVIDE (__preinit_array_start = .);
 213     KEEP (*(.preinit_array))
 214     PROVIDE (__preinit_array_end = .);
 215
 216     . = ALIGN(2);
 217     PROVIDE (__init_array_start = .);
 218     KEEP (*(SORT(.init_array.*)))
 219     KEEP (*(.init_array))
 220     PROVIDE (__init_array_end = .);
 221
 222     . = ALIGN(2);
 223     PROVIDE (__fini_array_start = .);
 224     KEEP (*(.fini_array))
 225     KEEP (*(SORT(.fini_array.*)))
 226     PROVIDE (__fini_array_end = .);
 227
 228     /* gcc uses crtbegin.o to find the start of the constructors, so
 229        we make sure it is first.  Because this is a wildcard, it
 230        doesn't matter if the user does not actually link against
 231        crtbegin.o; the linker won't look for a file to match a
 232        wildcard.  The wildcard also means that it doesn't matter which
 233        directory crtbegin.o is in.  */
 234     KEEP (*crtbegin*.o(.ctors))
 235
 236     /* We don't want to include the .ctor section from from the
 237        crtend.o file until after the sorted ctors.  The .ctor section
 238        from the crtend file contains the end of ctors marker and it
 239        must be last */
 240     KEEP (*(EXCLUDE_FILE (*crtend*.o ) .ctors))
 241     KEEP (*(SORT(.ctors.*)))
 242     KEEP (*(.ctors))
 243
 244     KEEP (*crtbegin*.o(.dtors))
 245     KEEP (*(EXCLUDE_FILE (*crtend*.o ) .dtors))
 246     KEEP (*(SORT(.dtors.*)))
 247     KEEP (*(.dtors))}
 248   } ${RELOCATING+ > text}
 249
 250   .vectors ${RELOCATING-0} :
 251   {
 252     ${RELOCATING+ PROVIDE (__vectors_start = .) ; }
 253     *(.vectors${RELOCATING+*})
 254     ${RELOCATING+ _vectors_end = . ; }
 255   } ${RELOCATING+ > vectors}
 256
 257   .data ${RELOCATING-0} :
 258   {
 259     ${RELOCATING+ PROVIDE (__data_start = .) ; }
 260     ${RELOCATING+ PROVIDE (__datastart = .) ; }
 261     ${RELOCATING+. = ALIGN(2);
 262
 263     KEEP (*(.jcr))
 264     *(.data.rel.ro.local) *(.data.rel.ro*)
 265     *(.dynamic)
 266
 267     . = ALIGN(2);
 268     *(.lower.data.* .lower.data)}
 269
 270     *(.data)
 271     ${RELOCATING+*(.data.*)
 272     *(.gnu.linkonce.d*)
 273     KEEP (*(.gnu.linkonce.d.*personality*))
 274     *(.data1)
 275
 276     *(.either.data.* .either.data)
 277
 278     *(.upper.data.* .upper.data)
 279
 280     *(.got.plt) *(.got)
 281     . = ALIGN(2);
 282     *(.sdata .sdata.* .gnu.linkonce.s.*)
 283     . = ALIGN(2);
 284     _edata = .;}
 285   } ${RELOCATING+ > data AT> text}
 286
 287   ${RELOCATING+__romdatastart = LOADADDR(.data);
 288   __romdatacopysize = SIZEOF(.data);}
 289
 290   .bss ${RELOCATING-0}${RELOCATING+SIZEOF(.data) + ADDR(.data)} :
 291   {
 292     ${RELOCATING+. = ALIGN(2);}
 293     ${RELOCATING+ PROVIDE (__bss_start = .); }
 294     ${RELOCATING+ PROVIDE (__bssstart = .);
 295     *(.lower.bss.* .lower.bss)
 296     . = ALIGN(2);}
 297     *(.bss)
 298     ${RELOCATING+*(.either.bss.* .either.bss)
 299     *(.upper.bss.* .upper.bss)
 300     *(COMMON)
 301     PROVIDE (__bss_end = .);}
 302   } ${RELOCATING+ > data}
 303   ${RELOCATING+ PROVIDE (__bsssize = SIZEOF(.bss)); }
 304
 305   /* This section contains data that is not initialized during load,
 306      or during the application's initialization sequence.  */
 307   .noinit ${RELOCATING-0}${RELOCATING+SIZEOF(.bss) + ADDR(.bss)} :
 308   {
 309     ${RELOCATING+. = ALIGN(2);}
 310     ${RELOCATING+ PROVIDE (__noinit_start = .) ; }
 311     *(.noinit${RELOCATING+ .noinit.* .gnu.linkonce.n.*})
 312     ${RELOCATING+. = ALIGN(2);}
 313     ${RELOCATING+ PROVIDE (__noinit_end = .) ; }
 314   } ${RELOCATING+ > data}
 315
 316   /* This section contains data that is initialized during load,
 317      but not during the application's initialization sequence.  */
 318   .persistent ${RELOCATING-0}${RELOCATING+SIZEOF(.noinit) + ADDR(.noinit)} :
 319   {
 320     ${RELOCATING+. = ALIGN(2);}
 321     ${RELOCATING+ PROVIDE (__persistent_start = .) ; }
 322     *(.persistent${RELOCATING+ .persistent.* .gnu.linkonce.p.*})
 323     ${RELOCATING+. = ALIGN(2);}
 324     ${RELOCATING+ PROVIDE (__persistent_end = .) ; }
 325   } ${RELOCATING+ > data}
 326
 327   ${RELOCATING+ _end = . ;  }
 328   ${HEAP_SECTION_MSP430}
 329
 330   /* Stabs for profiling information*/
 331   .profiler 0 : { *(.profiler) }
 332
 333   /* Stabs debugging sections.  */
 334   .stab 0 : { *(.stab) }
 335   .stabstr 0 : { *(.stabstr) }
 336   .stab.excl 0 : { *(.stab.excl) }
 337   .stab.exclstr 0 : { *(.stab.exclstr) }
 338   .stab.index 0 : { *(.stab.index) }
 339   .stab.indexstr 0 : { *(.stab.indexstr) }
 340   .comment 0 : { *(.comment) }
 341 EOF
 342
 343 . $srcdir/scripttempl/DWARF.sc
 344
 345 test -n "${RELOCATING}" && cat <<EOF
 346   .MSP430.attributes 0 :
 347   {
 348     KEEP (*(.MSP430.attributes))
 349     KEEP (*(.gnu.attributes))
 350     KEEP (*(__TI_build_attributes))
 351   }
 352
 353   PROVIDE (__stack = ${STACK}) ;
 354   PROVIDE (__data_start_rom = _etext) ;
 355   PROVIDE (__data_end_rom   = _etext + SIZEOF (.data)) ;
 356   PROVIDE (__noinit_start_rom = _etext + SIZEOF (.data)) ;
 357   PROVIDE (__noinit_end_rom = _etext + SIZEOF (.data) + SIZEOF (.noinit)) ;
 358   PROVIDE (__subdevice_has_heap = ${GOT_HEAP_MSP-0}) ;
 359 EOF
 360
 361 cat <<EOF
 362 }
 363 EOF