ld/scripttempl/elf.sc

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