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