ld/scripttempl/elf.sc

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