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