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