ld/scripttempl/elf32msp430.sc

   1 # Copyright (C) 2014-2024 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-2024 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} : ${RELOCATING+ALIGN(2)}
 141   {
 142     ${RELOCATING+
 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} : ${RELOCATING+ALIGN(2)}
 193   {
 194     ${RELOCATING+
 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} : ${RELOCATING+ALIGN(2)}
 258   {
 259     ${RELOCATING+
 260     PROVIDE (__data_start = .) ;
 261     PROVIDE (__datastart = .) ;
 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+ALIGN(SIZEOF(.data) + ADDR(.data), 2)} :
 291   {
 292     ${RELOCATING+ PROVIDE (__bss_start = .); }
 293     ${RELOCATING+ PROVIDE (__bssstart = .);
 294     *(.lower.bss.* .lower.bss)
 295     . = ALIGN(2);}
 296     *(.bss)
 297     ${RELOCATING+*(.either.bss.* .either.bss)
 298     *(.upper.bss.* .upper.bss)
 299     *(COMMON)
 300     PROVIDE (__bss_end = .);}
 301   } ${RELOCATING+ > data}
 302   ${RELOCATING+ PROVIDE (__bsssize = SIZEOF(.bss)); }
 303
 304   /* This section contains data that is not initialized during load,
 305      or during the application's initialization sequence.  */
 306   .noinit ${RELOCATING-0}${RELOCATING+ALIGN(SIZEOF(.bss) + ADDR(.bss), 2)} :
 307   {
 308     ${RELOCATING+ PROVIDE (__noinit_start = .) ; }
 309     *(.noinit${RELOCATING+ .noinit.* .gnu.linkonce.n.*})
 310     ${RELOCATING+. = ALIGN(2);}
 311     ${RELOCATING+ PROVIDE (__noinit_end = .) ; }
 312   } ${RELOCATING+ > data}
 313
 314   /* This section contains data that is initialized during load,
 315      but not during the application's initialization sequence.  */
 316   .persistent ${RELOCATING-0}${RELOCATING+ALIGN(SIZEOF(.noinit) + ADDR(.noinit), 2)} :
 317   {
 318     ${RELOCATING+ PROVIDE (__persistent_start = .) ; }
 319     *(.persistent${RELOCATING+ .persistent.* .gnu.linkonce.p.*})
 320     ${RELOCATING+. = ALIGN(2);}
 321     ${RELOCATING+ PROVIDE (__persistent_end = .) ; }
 322   } ${RELOCATING+ > data}
 323
 324   ${RELOCATING+ _end = . ;  }
 325   ${HEAP_SECTION_MSP430}
 326
 327   /* Stabs for profiling information*/
 328   .profiler 0 : { *(.profiler) }
 329
 330 EOF
 331
 332 source_sh $srcdir/scripttempl/misc-sections.sc
 333 source_sh $srcdir/scripttempl/DWARF.sc
 334
 335 test -n "${RELOCATING}" && cat <<EOF
 336   .MSP430.attributes 0 :
 337   {
 338     KEEP (*(.MSP430.attributes))
 339     KEEP (*(.gnu.attributes))
 340     KEEP (*(__TI_build_attributes))
 341   }
 342
 343   PROVIDE (__stack = ${STACK}) ;
 344   PROVIDE (__data_start_rom = _etext) ;
 345   PROVIDE (__data_end_rom   = _etext + SIZEOF (.data)) ;
 346   PROVIDE (__noinit_start_rom = _etext + SIZEOF (.data)) ;
 347   PROVIDE (__noinit_end_rom = _etext + SIZEOF (.data) + SIZEOF (.noinit)) ;
 348   PROVIDE (__subdevice_has_heap = ${GOT_HEAP_MSP-0}) ;
 349 EOF
 350
 351 cat <<EOF
 352 }
 353 EOF