ld/scripttempl/elf.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 # Unusual variables checked by this code:
   8 #       NOP - four byte opcode for no-op (defaults to none)
   9 #       NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
  10 #               empty.
  11 #       SMALL_DATA_CTOR - .ctors contains small data.
  12 #       SMALL_DATA_DTOR - .dtors contains small data.
  13 #       DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
  14 #       INITIAL_READONLY_SECTIONS - at start of text segment
  15 #       OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
  16 #               (e.g., .PARISC.milli)
  17 #       OTHER_TEXT_SECTIONS - these get put in .text when relocating
  18 #       INITIAL_READWRITE_SECTIONS - at start of data segment (after relro)
  19 #       OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
  20 #               (e.g., .PARISC.global)
  21 #       OTHER_RELRO_SECTIONS - other than .data.rel.ro ...
  22 #               (e.g. PPC32 .fixup, .got[12])
  23 #       OTHER_RELRO_SECTIONS_2 - as above, but after .dynamic in text segment
  24 #       OTHER_BSS_SECTIONS - other than .bss .sbss ...
  25 #       ATTRS_SECTIONS - at the end
  26 #       OTHER_SECTIONS - at the end
  27 #       EXECUTABLE_SYMBOLS - symbols that must be defined for an
  28 #               executable (e.g., _DYNAMIC_LINK)
  29 #       TEXT_START_ADDR - the first byte of the text segment, after any
  30 #               headers.
  31 #       TEXT_BASE_ADDRESS - the first byte of the text segment.
  32 #       TEXT_START_SYMBOLS - symbols that appear at the start of the
  33 #               .text section.
  34 #       DATA_START_SYMBOLS - symbols that appear at the start of the
  35 #               .data section.
  36 #       DATA_END_SYMBOLS - symbols that appear at the end of the
  37 #               writeable data sections.
  38 #       OTHER_GOT_SYMBOLS - symbols defined just before .got.
  39 #       OTHER_GOT_SECTIONS - sections just after .got.
  40 #       OTHER_PLT_SECTIONS - sections just after .plt.
  41 #       OTHER_SDATA_SECTIONS - sections just after .sdata.
  42 #       OTHER_BSS_SYMBOLS - symbols that appear at the start of the
  43 #               .bss section besides __bss_start.
  44 #       PLT_NEXT_DATA - .plt next to data segment when .plt is in text segment.
  45 #       DATA_PLT - .plt should be in data segment, not text segment.
  46 #       PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.
  47 #       BSS_PLT - .plt should be in bss segment
  48 #       NO_REL_RELOCS - Don't include .rel.* sections in script
  49 #       NO_RELA_RELOCS - Don't include .rela.* sections in script
  50 #       NON_ALLOC_DYN - Place dynamic sections after data segment.
  51 #       TEXT_DYNAMIC - .dynamic in text segment, not data segment.
  52 #       EMBEDDED - whether this is for an embedded system.
  53 #       SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
  54 #               start address of shared library.
  55 #       INPUT_FILES - INPUT command of files to always include
  56 #       WRITABLE_RODATA - if set, the .rodata section should be writable
  57 #       INIT_START, INIT_END -  statements just before and just after
  58 #       combination of .init sections.
  59 #       FINI_START, FINI_END - statements just before and just after
  60 #       combination of .fini sections.
  61 #       STACK_ADDR - start of a .stack section.
  62 #       OTHER_SYMBOLS - symbols to place right at the end of the script.
  63 #       ETEXT_NAME - name of a symbol for the end of the text section,
  64 #               normally etext.
  65 #       SEPARATE_CODE - if set, .text and similar sections containing
  66 #               actual machine instructions must be in wholly disjoint
  67 #               pages from any other data, including headers
  68 #       SEPARATE_GOTPLT - if set, .got.plt should be separate output section,
  69 #               so that .got can be in the RELRO area.  It should be set to
  70 #               the number of bytes in the beginning of .got.plt which can be
  71 #               in the RELRO area as well.
  72 #       USER_LABEL_PREFIX - prefix to add to user-visible symbols.
  73 #       RODATA_NAME, SDATA_NAME, SBSS_NAME, BSS_NAME - base parts of names
  74 #               for standard sections, without initial "." or suffixes.
  75 #
  76 # When adding sections, do note that the names of some sections are used
  77 # when specifying the start address of the next.
  78 #
  79
  80 #  Many sections come in three flavours.  There is the 'real' section,
  81 #  like ".data".  Then there are the per-procedure or per-variable
  82 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
  83 #  and useful for --gc-sections, which for a variable "foo" might be
  84 #  ".data.foo".  Then there are the linkonce sections, for which the linker
  85 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
  86 #  The exact correspondences are:
  87 #
  88 #  Section      Linkonce section
  89 #  .text        .gnu.linkonce.t.foo
  90 #  .rodata      .gnu.linkonce.r.foo
  91 #  .data        .gnu.linkonce.d.foo
  92 #  .bss         .gnu.linkonce.b.foo
  93 #  .sdata       .gnu.linkonce.s.foo
  94 #  .sbss        .gnu.linkonce.sb.foo
  95 #  .sdata2      .gnu.linkonce.s2.foo
  96 #  .sbss2       .gnu.linkonce.sb2.foo
  97 #  .debug_info  .gnu.linkonce.wi.foo
  98 #  .tdata       .gnu.linkonce.td.foo
  99 #  .tbss        .gnu.linkonce.tb.foo
 100 #  .lrodata     .gnu.linkonce.lr.foo
 101 #  .ldata       .gnu.linkonce.l.foo
 102 #  .lbss        .gnu.linkonce.lb.foo
 103 #
 104 #  Each of these can also have corresponding .rel.* and .rela.* sections.
 105
 106 if test -n "$NOP"; then
 107   FILL="=$NOP"
 108 else
 109   FILL=
 110 fi
 111
 112 test -n "$CREATE_SHLIB$CREATE_PIE" && CREATE_PIC=" "
 113 test -z "$RODATA_NAME" && RODATA_NAME=rodata
 114 test -z "$SDATA_NAME" && SDATA_NAME=sdata
 115 test -z "$SBSS_NAME" && SBSS_NAME=sbss
 116 test -z "$BSS_NAME" && BSS_NAME=bss
 117 test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
 118 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 119 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 120 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
 121 test -z "${ELFSIZE}" && ELFSIZE=32
 122 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
 123 test "$LD_FLAG" = "N" && DATA_ADDR=.
 124 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
 125 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
 126 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
 127 if test -z "$DATA_SEGMENT_ALIGN"; then
 128   test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
 129   test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
 130   DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 131   DATA_SEGMENT_RELRO_END=""
 132   DATA_SEGMENT_END=""
 133   if test -n "${COMMONPAGESIZE}"; then
 134     if test "${SEGMENT_SIZE}" != "${MAXPAGESIZE}"; then
 135       DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
 136     else
 137       DATA_SEGMENT_ALIGN="DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
 138     fi
 139     DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
 140     DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
 141   fi
 142 fi
 143 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
 144   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
 145 fi
 146 if test -z "$PLT"; then
 147   IPLT=".iplt         ${RELOCATING-0} : { *(.iplt) }"
 148   PLT=".plt          ${RELOCATING-0} : { *(.plt)${RELOCATING+${IREL_IN_PLT+ *(.iplt)}} }
 149   ${IREL_IN_PLT-$IPLT}"
 150 fi
 151 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=
 152 if test -z "$GOT"; then
 153   if test -z "$SEPARATE_GOTPLT"; then
 154     GOT=".got          ${RELOCATING-0} : {${RELOCATING+ *(.got.plt) *(.igot.plt)} *(.got)${RELOCATING+ *(.igot)} }"
 155   else
 156     GOT=".got          ${RELOCATING-0} : { *(.got)${RELOCATING+ *(.igot)} }"
 157     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt)${RELOCATING+ *(.igot.plt)} }"
 158   fi
 159 fi
 160 REL_IFUNC=".rel.ifunc    ${RELOCATING-0} : { *(.rel.ifunc) }"
 161 RELA_IFUNC=".rela.ifunc   ${RELOCATING-0} : { *(.rela.ifunc) }"
 162 REL_IPLT=".rel.iplt     ${RELOCATING-0} :
 163     {
 164       ${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
 165       *(.rel.iplt)
 166       ${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
 167     }"
 168 RELA_IPLT=".rela.iplt    ${RELOCATING-0} :
 169     {
 170       ${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
 171       *(.rela.iplt)
 172       ${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
 173     }"
 174 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
 175 RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
 176 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }"
 177 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
 178 if test -z "${NO_SMALL_DATA}"; then
 179   SBSS=".${SBSS_NAME}         ${RELOCATING-0} :
 180   {
 181     ${RELOCATING+${SBSS_START_SYMBOLS}}
 182     ${CREATE_SHLIB+*(.${SBSS_NAME}2 .${SBSS_NAME}2.* .gnu.linkonce.sb2.*)}
 183     ${RELOCATING+*(.dyn${SBSS_NAME})}
 184     *(.${SBSS_NAME}${RELOCATING+ .${SBSS_NAME}.* .gnu.linkonce.sb.*})
 185     ${RELOCATING+*(.scommon)}
 186     ${RELOCATING+${SBSS_END_SYMBOLS}}
 187   }"
 188   SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
 189   SDATA="/* We want the small data sections together, so single-instruction offsets
 190      can access them all, and initialized data all before uninitialized, so
 191      we can shorten the on-disk segment size.  */
 192   .${SDATA_NAME}        ${RELOCATING-0} :
 193   {
 194     ${RELOCATING+${SDATA_START_SYMBOLS}}
 195     ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
 196     *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
 197   }"
 198   SDATA2=".${SDATA_NAME}2       ${RELOCATING-0} :
 199   {
 200     ${RELOCATING+${SDATA2_START_SYMBOLS}}
 201     *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
 202   }"
 203   REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
 204   .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
 205   REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
 206   .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
 207   REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
 208   .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
 209   REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
 210   .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
 211 else
 212   NO_SMALL_DATA=" "
 213 fi
 214 if test -z "${SDATA_GOT}${DATA_GOT}"; then
 215   if test -n "${NO_SMALL_DATA}"; then
 216     DATA_GOT=" "
 217   fi
 218 fi
 219 if test -z "${SDATA_GOT}${DATA_GOT}"; then
 220   if test -z "${NO_SMALL_DATA}"; then
 221     SDATA_GOT=" "
 222   fi
 223 fi
 224 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
 225 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
 226   .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
 227   .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
 228   .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
 229   .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
 230   .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
 231   .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
 232 test "${LARGE_SECTIONS}" = "yes" && LARGE_BSS="
 233   .lbss ${RELOCATING-0} :
 234   {
 235     ${RELOCATING+*(.dynlbss)}
 236     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
 237     ${RELOCATING+*(LARGE_COMMON)}
 238   }"
 239 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
 240   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 241   {
 242     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
 243   }
 244   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 245   {
 246     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
 247     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 248   }"
 249 if test "${ENABLE_INITFINI_ARRAY}" = "yes"; then
 250   SORT_INIT_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))"
 251   SORT_FINI_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))"
 252   CTORS_IN_INIT_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors"
 253   DTORS_IN_FINI_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors"
 254 else
 255   SORT_INIT_ARRAY="KEEP (*(SORT(.init_array.*)))"
 256   SORT_FINI_ARRAY="KEEP (*(SORT(.fini_array.*)))"
 257   CTORS_IN_INIT_ARRAY=
 258   DTORS_IN_FINI_ARRAY=
 259 fi
 260 PREINIT_ARRAY=".preinit_array    :
 261   {
 262     ${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}
 263     KEEP (*(.preinit_array))
 264     ${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}
 265   }"
 266 INIT_ARRAY=".init_array    :
 267   {
 268     ${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}
 269     ${SORT_INIT_ARRAY}
 270     KEEP (*(.init_array ${CTORS_IN_INIT_ARRAY}))
 271     ${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}
 272   }"
 273 FINI_ARRAY=".fini_array    :
 274   {
 275     ${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}
 276     ${SORT_FINI_ARRAY}
 277     KEEP (*(.fini_array ${DTORS_IN_FINI_ARRAY}))
 278     ${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}
 279   }"
 280 CTOR=".ctors        ${CONSTRUCTING-0} :
 281   {
 282     ${CONSTRUCTING+${CTOR_START}}
 283     /* gcc uses crtbegin.o to find the start of
 284        the constructors, so we make sure it is
 285        first.  Because this is a wildcard, it
 286        doesn't matter if the user does not
 287        actually link against crtbegin.o; the
 288        linker won't look for a file to match a
 289        wildcard.  The wildcard also means that it
 290        doesn't matter which directory crtbegin.o
 291        is in.  */
 292
 293     KEEP (*crtbegin.o(.ctors))
 294     KEEP (*crtbegin?.o(.ctors))
 295
 296     /* We don't want to include the .ctor section from
 297        the crtend.o file until after the sorted ctors.
 298        The .ctor section from the crtend file contains the
 299        end of ctors marker and it must be last */
 300
 301     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
 302     KEEP (*(SORT(.ctors.*)))
 303     KEEP (*(.ctors))
 304     ${CONSTRUCTING+${CTOR_END}}
 305   }"
 306 DTOR=".dtors        ${CONSTRUCTING-0} :
 307   {
 308     ${CONSTRUCTING+${DTOR_START}}
 309     KEEP (*crtbegin.o(.dtors))
 310     KEEP (*crtbegin?.o(.dtors))
 311     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
 312     KEEP (*(SORT(.dtors.*)))
 313     KEEP (*(.dtors))
 314     ${CONSTRUCTING+${DTOR_END}}
 315   }"
 316 STACK=".stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 317   {
 318     ${RELOCATING+${USER_LABEL_PREFIX}_stack = .;}
 319     *(.stack)
 320     ${RELOCATING+${STACK_SENTINEL}}
 321   }"
 322
 323 TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
 324 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
 325
 326 # Don't bother with separate code segment when there are data sections
 327 # between .plt and .text.
 328 if test -z "$TINY_READONLY_SECTION"; then
 329   case "$LD_FLAG" in
 330     *textonly*)
 331       SEPARATE_TEXT=" "
 332       TEXT_SEGMENT_ALIGN=". = ALIGN(${MAXPAGESIZE});"
 333       ;;
 334   esac
 335 fi
 336
 337 if [ -z "$SEPARATE_CODE" ]; then
 338   SIZEOF_HEADERS_CODE=" + SIZEOF_HEADERS"
 339 else
 340   SIZEOF_HEADERS_CODE=
 341 fi
 342
 343 # If this is for an embedded system, don't add SIZEOF_HEADERS.
 344 if [ -z "$EMBEDDED" ]; then
 345    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}${SIZEOF_HEADERS_CODE}"
 346 else
 347    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 348 fi
 349
 350 cat <<EOF
 351 /* Copyright (C) 2014-2019 Free Software Foundation, Inc.
 352
 353    Copying and distribution of this script, with or without modification,
 354    are permitted in any medium without royalty provided the copyright
 355    notice and this notice are preserved.  */
 356
 357 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
 358               "${LITTLE_OUTPUT_FORMAT}")
 359 OUTPUT_ARCH(${OUTPUT_ARCH})
 360 ${RELOCATING+ENTRY(${ENTRY})}
 361
 362 ${RELOCATING+${LIB_SEARCH_DIRS}}
 363 ${RELOCATING+${CREATE_SHLIB-${EXECUTABLE_SYMBOLS}}}
 364 ${RELOCATING+${INPUT_FILES}}
 365 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 366   if gld -r is used and the intermediate file has sections starting
 367   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 368   bug.  But for now assigning the zero vmas works.  */}
 369
 370 SECTIONS
 371 {
 372   ${RELOCATING+${SEPARATE_TEXT-/* Read-only sections, merged into text segment: */}}
 373   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 374   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
 375   ${CREATE_PIE+${RELOCATING+PROVIDE (__executable_start = ${SHLIB_TEXT_START_ADDR}); . = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
 376 EOF
 377
 378 emit_early_ro()
 379 {
 380   cat <<EOF
 381   ${INITIAL_READONLY_SECTIONS}
 382   .note.gnu.build-id ${RELOCATING-0}: { *(.note.gnu.build-id) }
 383 EOF
 384 }
 385
 386 test -n "${SEPARATE_CODE}" || emit_early_ro
 387
 388 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
 389 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
 390 cat > ldscripts/dyntmp.$$ <<EOF
 391   ${TEXT_DYNAMIC+${DYNAMIC}}
 392   .hash         ${RELOCATING-0} : { *(.hash) }
 393   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 394   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 395   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 396   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 397   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 398   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 399 EOF
 400
 401 if [ "x$COMBRELOC" = x ]; then
 402   COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
 403 else
 404   COMBRELOCCAT="cat > $COMBRELOC"
 405 fi
 406 eval $COMBRELOCCAT <<EOF
 407   ${INITIAL_RELOC_SECTIONS}
 408   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 409   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 410   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 411   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 412   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 413   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 414   .rel.${RODATA_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
 415   .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
 416   ${OTHER_READONLY_RELOC_SECTIONS}
 417   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+ .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*}) }
 418   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+ .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*}) }
 419   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 420   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 421   ${OTHER_READWRITE_RELOC_SECTIONS}
 422   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 423   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 424   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 425   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 426   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 427   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 428   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 429   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 430   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 431   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 432   ${OTHER_GOT_RELOC_SECTIONS}
 433   ${REL_SDATA}
 434   ${REL_SBSS}
 435   ${REL_SDATA2}
 436   ${REL_SBSS2}
 437   .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
 438   .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
 439   ${REL_LARGE}
 440   ${IREL_IN_PLT+$REL_IFUNC}
 441   ${IREL_IN_PLT+$RELA_IFUNC}
 442   ${IREL_IN_PLT-$REL_IPLT}
 443   ${IREL_IN_PLT-$RELA_IPLT}
 444 EOF
 445
 446 if [ -n "$COMBRELOC" ]; then
 447 cat >> ldscripts/dyntmp.$$ <<EOF
 448   .rel.dyn      ${RELOCATING-0} :
 449     {
 450 EOF
 451 sed -e '/^[      ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;/__rela_iplt_/d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 452 cat >> ldscripts/dyntmp.$$ <<EOF
 453     }
 454   .rela.dyn     ${RELOCATING-0} :
 455     {
 456 EOF
 457 sed -e '/^[      ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;/__rel_iplt_/d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 458 cat >> ldscripts/dyntmp.$$ <<EOF
 459     }
 460 EOF
 461 fi
 462
 463 cat >> ldscripts/dyntmp.$$ <<EOF
 464   .rel.plt      ${RELOCATING-0} :
 465     {
 466       *(.rel.plt)
 467       ${IREL_IN_PLT+${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}}
 468       ${IREL_IN_PLT+${RELOCATING+*(.rel.iplt)}}
 469       ${IREL_IN_PLT+${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}}
 470     }
 471   .rela.plt     ${RELOCATING-0} :
 472     {
 473       *(.rela.plt)
 474       ${IREL_IN_PLT+${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}}
 475       ${IREL_IN_PLT+${RELOCATING+*(.rela.iplt)}}
 476       ${IREL_IN_PLT+${RELOCATING+${CREATE_PIC-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}}
 477     }
 478   ${OTHER_PLT_RELOC_SECTIONS}
 479 EOF
 480
 481 emit_dyn()
 482 {
 483   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 484     cat ldscripts/dyntmp.$$
 485   else
 486     if test -z "${NO_REL_RELOCS}"; then
 487       sed -e '/^[        ]*\.rela\.[^}]*$/,/}/d;/^[      ]*\.rela\./d;/__rela_iplt_/d' ldscripts/dyntmp.$$
 488     fi
 489     if test -z "${NO_RELA_RELOCS}"; then
 490       sed -e '/^[        ]*\.rel\.[^}]*$/,/}/d;/^[       ]*\.rel\./d;/__rel_iplt_/d' ldscripts/dyntmp.$$
 491     fi
 492   fi
 493   rm -f ldscripts/dyntmp.$$
 494 }
 495
 496 test -n "${NON_ALLOC_DYN}${SEPARATE_CODE}" || emit_dyn
 497
 498 cat <<EOF
 499   ${RELOCATING+${TEXT_SEGMENT_ALIGN}}
 500
 501   .init         ${RELOCATING-0}${RELOCATING+${INIT_ADDR}} :
 502   {
 503     ${RELOCATING+${INIT_START}}
 504     KEEP (*(SORT_NONE(.init)))
 505     ${RELOCATING+${INIT_END}}
 506   } ${FILL}
 507
 508   ${TEXT_PLT+${PLT_NEXT_DATA-${PLT} ${OTHER_PLT_SECTIONS}}}
 509   ${TINY_READONLY_SECTION}
 510   .text         ${RELOCATING-0} :
 511   {
 512     ${RELOCATING+${TEXT_START_SYMBOLS}}
 513     ${RELOCATING+*(.text.unlikely .text.*_unlikely .text.unlikely.*)}
 514     ${RELOCATING+*(.text.exit .text.exit.*)}
 515     ${RELOCATING+*(.text.startup .text.startup.*)}
 516     ${RELOCATING+*(.text.hot .text.hot.*)}
 517     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 518     /* .gnu.warning sections are handled specially by elf32.em.  */
 519     *(.gnu.warning)
 520     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 521   } ${FILL}
 522   .fini         ${RELOCATING-0}${RELOCATING+${FINI_ADDR}} :
 523   {
 524     ${RELOCATING+${FINI_START}}
 525     KEEP (*(SORT_NONE(.fini)))
 526     ${RELOCATING+${FINI_END}}
 527   } ${FILL}
 528   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 529   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 530   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 531   ${RELOCATING+${TEXT_SEGMENT_ALIGN}}
 532 EOF
 533
 534 if test -n "${SEPARATE_CODE}${SEPARATE_TEXT}"; then
 535   if test -n "${RODATA_ADDR}"; then
 536     RODATA_ADDR="\
 537 SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR}) + SIZEOF_HEADERS"
 538   else
 539     RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 540     RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR})"
 541   fi
 542   if test -n "${SHLIB_RODATA_ADDR}"; then
 543     SHLIB_RODATA_ADDR="\
 544 SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR}) + SIZEOF_HEADERS"
 545   else
 546     SHLIB_RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 547     SHLIB_RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR})"
 548   fi
 549   cat <<EOF
 550   ${RELOCATING+/* Adjust the address for the rodata segment.  We want to adjust up to
 551      the same address within the page on the next page up.  */
 552   ${CREATE_SHLIB-${CREATE_PIE-. = ${RODATA_ADDR};}}
 553   ${CREATE_SHLIB+. = ${SHLIB_RODATA_ADDR};}
 554   ${CREATE_PIE+. = ${SHLIB_RODATA_ADDR};}}
 555 EOF
 556   if test -n "${SEPARATE_CODE}"; then
 557     emit_early_ro
 558     emit_dyn
 559   fi
 560 fi
 561
 562 cat <<EOF
 563   ${WRITABLE_RODATA-${RODATA}}
 564   .${RODATA_NAME}1      ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
 565   ${CREATE_SHLIB-${SDATA2}}
 566   ${CREATE_SHLIB-${SBSS2}}
 567   ${OTHER_READONLY_SECTIONS}
 568   .eh_frame_hdr ${RELOCATING-0} : { *(.eh_frame_hdr)${RELOCATING+ *(.eh_frame_entry .eh_frame_entry.*)} }
 569   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame))${RELOCATING+ *(.eh_frame.*)} }
 570   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table${RELOCATING+ .gcc_except_table.*}) }
 571   .gnu_extab ${RELOCATING-0} : ONLY_IF_RO { *(.gnu_extab*) }
 572   /* These sections are generated by the Sun/Oracle C++ compiler.  */
 573   .exception_ranges ${RELOCATING-0} : ONLY_IF_RO { *(.exception_ranges${RELOCATING+*}) }
 574   ${TEXT_PLT+${PLT_NEXT_DATA+${PLT} ${OTHER_PLT_SECTIONS}}}
 575
 576   ${RELOCATING+/* Adjust the address for the data segment.  We want to adjust up to
 577      the same address within the page on the next page up.  */}
 578   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 579   ${CREATE_SHLIB+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}
 580   ${CREATE_PIE+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}
 581
 582   /* Exception handling  */
 583   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame))${RELOCATING+ *(.eh_frame.*)} }
 584   .gnu_extab    ${RELOCATING-0} : ONLY_IF_RW { *(.gnu_extab) }
 585   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table${RELOCATING+ .gcc_except_table.*}) }
 586   .exception_ranges ${RELOCATING-0} : ONLY_IF_RW { *(.exception_ranges${RELOCATING+*}) }
 587
 588   /* Thread Local Storage sections  */
 589   .tdata        ${RELOCATING-0} :
 590    {
 591      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__tdata_start = .);}}
 592      *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*})
 593    }
 594   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 595
 596   ${RELOCATING+${PREINIT_ARRAY}}
 597   ${RELOCATING+${INIT_ARRAY}}
 598   ${RELOCATING+${FINI_ARRAY}}
 599   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 600   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 601   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 602
 603   ${RELOCATING+${DATARELRO}}
 604   ${OTHER_RELRO_SECTIONS}
 605   ${TEXT_DYNAMIC-${DYNAMIC}}
 606   ${OTHER_RELRO_SECTIONS_2}
 607   ${DATA_GOT+${RELRO_NOW+${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}}}
 608   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 609   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 610   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 611   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 612   ${INITIAL_READWRITE_SECTIONS}
 613   ${DATA_SDATA+${SDATA}}
 614   ${DATA_SDATA+${OTHER_SDATA_SECTIONS}}
 615   ${DATA_SDATA+${SBSS}}
 616   ${DATA_GOT+${RELRO_NOW-${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}}}
 617   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 618   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 619
 620   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 621
 622   .data         ${RELOCATING-0} :
 623   {
 624     ${RELOCATING+${DATA_START_SYMBOLS}}
 625     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 626     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 627   }
 628   .data1        ${RELOCATING-0} : { *(.data1) }
 629   ${WRITABLE_RODATA+${RODATA}}
 630   ${OTHER_READWRITE_SECTIONS}
 631   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 632   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 633   ${SDATA_GOT+${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}}
 634   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS+. = .; ${OTHER_GOT_SYMBOLS}}}}
 635   ${SDATA_GOT+${GOT}}
 636   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 637   ${DATA_SDATA-${SDATA}}
 638   ${DATA_SDATA-${OTHER_SDATA_SECTIONS}}
 639   ${RELOCATING+${DATA_END_SYMBOLS-${CREATE_SHLIB+PROVIDE (}${USER_LABEL_PREFIX}_edata = .${CREATE_SHLIB+)}; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 640   ${RELOCATING+. = .;}
 641   ${RELOCATING+${CREATE_SHLIB+PROVIDE (}${USER_LABEL_PREFIX}__bss_start = .${CREATE_SHLIB+)};}
 642   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 643   ${DATA_SDATA-${SBSS}}
 644   ${BSS_PLT+${PLT}}
 645   .${BSS_NAME}          ${RELOCATING-0} :
 646   {
 647    ${RELOCATING+*(.dynbss)}
 648    *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
 649    ${RELOCATING+*(COMMON)
 650    /* Align here to ensure that the .bss section occupies space up to
 651       _end.  Align after .bss to ensure correct alignment even if the
 652       .bss section disappears because there are no input sections.
 653       FIXME: Why do we need it? When there is no .bss section, we do not
 654       pad the .data section.  */
 655    . = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 656   }
 657   ${OTHER_BSS_SECTIONS}
 658   ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
 659   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 660   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 661 EOF
 662
 663 LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
 664 SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
 665
 666 cat <<EOF
 667   ${RELOCATING+${CREATE_SHLIB-${CREATE_PIE-${LARGE_DATA_ADDR}}}}
 668   ${CREATE_SHLIB+${SHLIB_LARGE_DATA_ADDR}}
 669   ${CREATE_PIE+${SHLIB_LARGE_DATA_ADDR}}
 670   ${LARGE_SECTIONS}
 671   ${LARGE_BSS_AFTER_BSS-${LARGE_BSS}}
 672   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 673   ${RELOCATING+${OTHER_END_SYMBOLS}}
 674   ${RELOCATING+${END_SYMBOLS-${CREATE_SHLIB+PROVIDE (}${USER_LABEL_PREFIX}_end = .${CREATE_SHLIB+)}; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 675   ${RELOCATING+${DATA_SEGMENT_END}}
 676   ${TINY_DATA_SECTION}
 677   ${TINY_BSS_SECTION}
 678   ${STACK_ADDR+${STACK}}
 679 EOF
 680
 681 test -z "${NON_ALLOC_DYN}" || emit_dyn
 682
 683 cat <<EOF
 684   /* Stabs debugging sections.  */
 685   .stab          0 : { *(.stab) }
 686   .stabstr       0 : { *(.stabstr) }
 687   .stab.excl     0 : { *(.stab.excl) }
 688   .stab.exclstr  0 : { *(.stab.exclstr) }
 689   .stab.index    0 : { *(.stab.index) }
 690   .stab.indexstr 0 : { *(.stab.indexstr) }
 691
 692   .comment       0 : { *(.comment) }
 693
 694   .gnu.build.attributes : { *(.gnu.build.attributes${RELOCATING+ .gnu.build.attributes.*}) }
 695
 696 EOF
 697
 698 . $srcdir/scripttempl/DWARF.sc
 699
 700 cat <<EOF
 701   ${ATTRS_SECTIONS}
 702   ${OTHER_SECTIONS}
 703   ${RELOCATING+${OTHER_SYMBOLS}}
 704   ${RELOCATING+${DISCARDED}}
 705 }
 706 EOF