ld/scripttempl/elfxtensa.sc

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