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