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