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 #       RODATA_NAME, SDATA_NAME, SBSS_NAME, BSS_NAME - base parts of names
  62 #               for standard sections, without initial "." or suffixes.
  63 #
  64 # When adding sections, do note that the names of some sections are used
  65 # when specifying the start address of the next.
  66 #
  67
  68 #  Many sections come in three flavours.  There is the 'real' section,
  69 #  like ".data".  Then there are the per-procedure or per-variable
  70 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
  71 #  and useful for --gc-sections, which for a variable "foo" might be
  72 #  ".data.foo".  Then there are the linkonce sections, for which the linker
  73 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
  74 #  The exact correspondences are:
  75 #
  76 #  Section      Linkonce section
  77 #  .text        .gnu.linkonce.t.foo
  78 #  .rodata      .gnu.linkonce.r.foo
  79 #  .data        .gnu.linkonce.d.foo
  80 #  .bss         .gnu.linkonce.b.foo
  81 #  .sdata       .gnu.linkonce.s.foo
  82 #  .sbss        .gnu.linkonce.sb.foo
  83 #  .sdata2      .gnu.linkonce.s2.foo
  84 #  .sbss2       .gnu.linkonce.sb2.foo
  85 #  .debug_info  .gnu.linkonce.wi.foo
  86 #  .tdata       .gnu.linkonce.td.foo
  87 #  .tbss        .gnu.linkonce.tb.foo
  88 #  .lrodata     .gnu.linkonce.lr.foo
  89 #  .ldata       .gnu.linkonce.l.foo
  90 #  .lbss        .gnu.linkonce.lb.foo
  91 #
  92 #  Each of these can also have corresponding .rel.* and .rela.* sections.
  93
  94 test -z "$RODATA_NAME" && RODATA_NAME=rodata
  95 test -z "$SDATA_NAME" && SDATA_NAME=sdata
  96 test -z "$SBSS_NAME" && SBSS_NAME=sbss
  97 test -z "$BSS_NAME" && BSS_NAME=bss
  98 test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
  99 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 100 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 101 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
 102 test -z "${ELFSIZE}" && ELFSIZE=32
 103 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
 104 test "$LD_FLAG" = "N" && DATA_ADDR=.
 105 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
 106 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
 107 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
 108 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
 109 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
 110 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 111 DATA_SEGMENT_RELRO_END=""
 112 DATA_SEGMENT_END=""
 113 if test -n "${COMMONPAGESIZE}"; then
 114   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
 115   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
 116   DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
 117 fi
 118 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
 119   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
 120 fi
 121 if test -z "$PLT"; then
 122   IPLT=".iplt         ${RELOCATING-0} : { *(.iplt) }"
 123   PLT=".plt          ${RELOCATING-0} : { *(.plt)${IREL_IN_PLT+ *(.iplt)} }
 124   ${IREL_IN_PLT-$IPLT}"
 125 fi
 126 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=yes
 127 if test -z "$GOT"; then
 128   if test -z "$SEPARATE_GOTPLT"; then
 129     GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) *(.got) *(.igot) }"
 130   else
 131     GOT=".got          ${RELOCATING-0} : { *(.got) *(.igot) }"
 132     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt)  *(.igot.plt) }"
 133   fi
 134 fi
 135 REL_IFUNC=".rel.ifunc    ${RELOCATING-0} : { *(.rel.ifunc) }"
 136 RELA_IFUNC=".rela.ifunc   ${RELOCATING-0} : { *(.rela.ifunc) }"
 137 REL_IPLT=".rel.iplt     ${RELOCATING-0} :
 138     {
 139       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
 140       *(.rel.iplt)
 141       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
 142     }"
 143 RELA_IPLT=".rela.iplt    ${RELOCATING-0} :
 144     {
 145       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
 146       *(.rela.iplt)
 147       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
 148     }"
 149 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
 150 RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
 151 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }"
 152 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
 153 if test -z "${NO_SMALL_DATA}"; then
 154   SBSS=".${SBSS_NAME}         ${RELOCATING-0} :
 155   {
 156     ${RELOCATING+${SBSS_START_SYMBOLS}}
 157     ${CREATE_SHLIB+*(.${SBSS_NAME}2 .${SBSS_NAME}2.* .gnu.linkonce.sb2.*)}
 158     *(.dyn${SBSS_NAME})
 159     *(.${SBSS_NAME}${RELOCATING+ .${SBSS_NAME}.* .gnu.linkonce.sb.*})
 160     *(.scommon)
 161     ${RELOCATING+${SBSS_END_SYMBOLS}}
 162   }"
 163   SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .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_NAME}        ${RELOCATING-0} :
 168   {
 169     ${RELOCATING+${SDATA_START_SYMBOLS}}
 170     ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
 171     *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
 172   }"
 173   SDATA2=".${SDATA_NAME}2       ${RELOCATING-0} :
 174   {
 175     ${RELOCATING+${SDATA2_START_SYMBOLS}}
 176     *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
 177   }"
 178   REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
 179   .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
 180   REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
 181   .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
 182   REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
 183   .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
 184   REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
 185   .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .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   }"
 280
 281 TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
 282 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
 283
 284 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 285 if [ -z "$EMBEDDED" ]; then
 286    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
 287 else
 288    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 289 fi
 290
 291 cat <<EOF
 292 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
 293               "${LITTLE_OUTPUT_FORMAT}")
 294 OUTPUT_ARCH(${OUTPUT_ARCH})
 295 ${RELOCATING+ENTRY(${ENTRY})}
 296
 297 ${RELOCATING+${LIB_SEARCH_DIRS}}
 298 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 299 ${RELOCATING+${INPUT_FILES}}
 300 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 301   if gld -r is used and the intermediate file has sections starting
 302   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 303   bug.  But for now assigning the zero vmas works.  */}
 304
 305 SECTIONS
 306 {
 307   /* Read-only sections, merged into text segment: */
 308   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 309   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS;}}
 310   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS;}}
 311   ${INITIAL_READONLY_SECTIONS}
 312   .note.gnu.build-id : { *(.note.gnu.build-id) }
 313 EOF
 314
 315 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
 316 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
 317 cat > ldscripts/dyntmp.$$ <<EOF
 318   ${TEXT_DYNAMIC+${DYNAMIC}}
 319   .hash         ${RELOCATING-0} : { *(.hash) }
 320   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 321   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 322   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 323   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 324   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 325   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 326 EOF
 327
 328 if [ "x$COMBRELOC" = x ]; then
 329   COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
 330 else
 331   COMBRELOCCAT="cat > $COMBRELOC"
 332 fi
 333 eval $COMBRELOCCAT <<EOF
 334   ${INITIAL_RELOC_SECTIONS}
 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_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
 342   .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
 343   ${OTHER_READONLY_RELOC_SECTIONS}
 344   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+* .rel.gnu.linkonce.d.rel.ro.*}) }
 345   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+* .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   ${OTHER_READWRITE_RELOC_SECTIONS}
 349   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 350   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 351   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 352   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 353   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 354   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 355   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 356   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 357   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 358   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 359   ${OTHER_GOT_RELOC_SECTIONS}
 360   ${REL_SDATA}
 361   ${REL_SBSS}
 362   ${REL_SDATA2}
 363   ${REL_SBSS2}
 364   .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
 365   .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
 366   ${REL_LARGE}
 367   ${IREL_IN_PLT+$REL_IFUNC}
 368   ${IREL_IN_PLT+$RELA_IFUNC}
 369   ${IREL_IN_PLT-$REL_IPLT}
 370   ${IREL_IN_PLT-$RELA_IPLT}
 371 EOF
 372
 373 if [ -n "$COMBRELOC" ]; then
 374 cat >> ldscripts/dyntmp.$$ <<EOF
 375   .rel.dyn      ${RELOCATING-0} :
 376     {
 377 EOF
 378 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 379 cat >> ldscripts/dyntmp.$$ <<EOF
 380     }
 381   .rela.dyn     ${RELOCATING-0} :
 382     {
 383 EOF
 384 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 385 cat >> ldscripts/dyntmp.$$ <<EOF
 386     }
 387 EOF
 388 fi
 389
 390 cat >> ldscripts/dyntmp.$$ <<EOF
 391   .rel.plt      ${RELOCATING-0} :
 392     {
 393       *(.rel.plt)
 394       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}}
 395       ${IREL_IN_PLT+${RELOCATING+*(.rel.iplt)}}
 396       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}}
 397     }
 398   .rela.plt     ${RELOCATING-0} :
 399     {
 400       *(.rela.plt)
 401       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}}
 402       ${IREL_IN_PLT+${RELOCATING+*(.rela.iplt)}}
 403       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}}
 404     }
 405   ${OTHER_PLT_RELOC_SECTIONS}
 406 EOF
 407
 408 if test -z "${NON_ALLOC_DYN}"; then
 409   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 410     cat ldscripts/dyntmp.$$
 411   else
 412     if test -z "${NO_REL_RELOCS}"; then
 413       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
 414     fi
 415     if test -z "${NO_RELA_RELOCS}"; then
 416       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
 417     fi
 418   fi
 419   rm -f ldscripts/dyntmp.$$
 420 fi
 421
 422 cat <<EOF
 423   .init         ${RELOCATING-0} :
 424   {
 425     ${RELOCATING+${INIT_START}}
 426     KEEP (*(.init))
 427     ${RELOCATING+${INIT_END}}
 428   } =${NOP-0}
 429
 430   ${TEXT_PLT+${PLT}}
 431   ${TINY_READONLY_SECTION}
 432   .text         ${RELOCATING-0} :
 433   {
 434     ${RELOCATING+${TEXT_START_SYMBOLS}}
 435     ${RELOCATING+*(.text.unlikely .text.*_unlikely)}
 436     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 437     /* .gnu.warning sections are handled specially by elf32.em.  */
 438     *(.gnu.warning)
 439     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 440   } =${NOP-0}
 441   .fini         ${RELOCATING-0} :
 442   {
 443     ${RELOCATING+${FINI_START}}
 444     KEEP (*(.fini))
 445     ${RELOCATING+${FINI_END}}
 446   } =${NOP-0}
 447   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 448   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 449   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 450   ${WRITABLE_RODATA-${RODATA}}
 451   .${RODATA_NAME}1      ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
 452   ${CREATE_SHLIB-${SDATA2}}
 453   ${CREATE_SHLIB-${SBSS2}}
 454   ${OTHER_READONLY_SECTIONS}
 455   .eh_frame_hdr : { *(.eh_frame_hdr) }
 456   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 457   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
 458
 459   /* Adjust the address for the data segment.  We want to adjust up to
 460      the same address within the page on the next page up.  */
 461   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 462   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 463   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 464
 465   /* Exception handling  */
 466   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 467   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 468
 469   /* Thread Local Storage sections  */
 470   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 471   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 472
 473   .preinit_array   ${RELOCATING-0} :
 474   {
 475     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 476     KEEP (*(.preinit_array))
 477     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 478   }
 479   ${RELOCATING+${INIT_ARRAY}}
 480   ${RELOCATING+${FINI_ARRAY}}
 481   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 482   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 483   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 484
 485   ${RELOCATING+${DATARELRO}}
 486   ${OTHER_RELRO_SECTIONS}
 487   ${TEXT_DYNAMIC-${DYNAMIC}}
 488   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 489   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 490   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 491   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 492   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 493   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 494
 495   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 496
 497   .data         ${RELOCATING-0} :
 498   {
 499     ${RELOCATING+${DATA_START_SYMBOLS}}
 500     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 501     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 502   }
 503   .data1        ${RELOCATING-0} : { *(.data1) }
 504   ${WRITABLE_RODATA+${RODATA}}
 505   ${OTHER_READWRITE_SECTIONS}
 506   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 507   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 508   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 509   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS}}}
 510   ${SDATA_GOT+${GOT}}
 511   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 512   ${SDATA}
 513   ${OTHER_SDATA_SECTIONS}
 514   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 515   ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
 516   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 517   ${SBSS}
 518   ${BSS_PLT+${PLT}}
 519   .${BSS_NAME}          ${RELOCATING-0} :
 520   {
 521    *(.dyn${BSS_NAME})
 522    *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
 523    *(COMMON)
 524    /* Align here to ensure that the .bss section occupies space up to
 525       _end.  Align after .bss to ensure correct alignment even if the
 526       .bss section disappears because there are no input sections.
 527       FIXME: Why do we need it? When there is no .bss section, we don't
 528       pad the .data section.  */
 529    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 530   }
 531   ${OTHER_BSS_SECTIONS}
 532   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 533   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 534   ${LARGE_SECTIONS}
 535   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 536   ${RELOCATING+${OTHER_END_SYMBOLS}}
 537   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 538   ${RELOCATING+${DATA_SEGMENT_END}}
 539 EOF
 540
 541 if test -n "${NON_ALLOC_DYN}"; then
 542   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 543     cat ldscripts/dyntmp.$$
 544   else
 545     if test -z "${NO_REL_RELOCS}"; then
 546       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
 547     fi
 548     if test -z "${NO_RELA_RELOCS}"; then
 549       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
 550     fi
 551   fi
 552   rm -f ldscripts/dyntmp.$$
 553 fi
 554
 555 cat <<EOF
 556   /* Stabs debugging sections.  */
 557   .stab          0 : { *(.stab) }
 558   .stabstr       0 : { *(.stabstr) }
 559   .stab.excl     0 : { *(.stab.excl) }
 560   .stab.exclstr  0 : { *(.stab.exclstr) }
 561   .stab.index    0 : { *(.stab.index) }
 562   .stab.indexstr 0 : { *(.stab.indexstr) }
 563
 564   .comment       0 : { *(.comment) }
 565
 566   /* DWARF debug sections.
 567      Symbols in the DWARF debugging sections are relative to the beginning
 568      of the section so we begin them at 0.  */
 569
 570   /* DWARF 1 */
 571   .debug          0 : { *(.debug) }
 572   .line           0 : { *(.line) }
 573
 574   /* GNU DWARF 1 extensions */
 575   .debug_srcinfo  0 : { *(.debug_srcinfo .zdebug_srcinfo) }
 576   .debug_sfnames  0 : { *(.debug_sfnames .zdebug_sfnames) }
 577
 578   /* DWARF 1.1 and DWARF 2 */
 579   .debug_aranges  0 : { *(.debug_aranges .zdebug_aranges) }
 580   .debug_pubnames 0 : { *(.debug_pubnames .zdebug_pubnames) }
 581
 582   /* DWARF 2 */
 583   .debug_info     0 : { *(.debug_info${RELOCATING+ .gnu.linkonce.wi.*} .zdebug_info) }
 584   .debug_abbrev   0 : { *(.debug_abbrev .zdebug_abbrev) }
 585   .debug_line     0 : { *(.debug_line .zdebug_line) }
 586   .debug_frame    0 : { *(.debug_frame .zdebug_frame) }
 587   .debug_str      0 : { *(.debug_str .zdebug_str) }
 588   .debug_loc      0 : { *(.debug_loc .zdebug_loc) }
 589   .debug_macinfo  0 : { *(.debug_macinfo .zdebug_macinfo) }
 590
 591   /* SGI/MIPS DWARF 2 extensions */
 592   .debug_weaknames 0 : { *(.debug_weaknames .zdebug_weaknames) }
 593   .debug_funcnames 0 : { *(.debug_funcnames .zdebug_funcnames) }
 594   .debug_typenames 0 : { *(.debug_typenames .zdebug_typenames) }
 595   .debug_varnames  0 : { *(.debug_varnames .zdebug_varnames) }
 596
 597   /* DWARF 3 */
 598   .debug_pubtypes 0 : { *(.debug_pubtypes .zdebug_pubtypes) }
 599   .debug_ranges   0 : { *(.debug_ranges .zdebug_ranges) }
 600
 601   ${TINY_DATA_SECTION}
 602   ${TINY_BSS_SECTION}
 603
 604   ${STACK_ADDR+${STACK}}
 605   ${ATTRS_SECTIONS}
 606   ${OTHER_SECTIONS}
 607   ${RELOCATING+${OTHER_SYMBOLS}}
 608   ${RELOCATING+${DISCARDED}}
 609 }
 610 EOF