ld/scripttempl/elf.sc

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