ld/scripttempl/elfxtensa.sc

   1 #
   2 # Unusual variables checked by this code:
   3 #       NOP - four byte opcode for no-op (defaults to 0)
   4 #       NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
   5 #               empty.
   6 #       SMALL_DATA_CTOR - .ctors contains small data.
   7 #       SMALL_DATA_DTOR - .dtors contains small data.
   8 #       DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
   9 #       INITIAL_READONLY_SECTIONS - at start of text segment
  10 #       OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
  11 #               (e.g., .PARISC.milli)
  12 #       OTHER_TEXT_SECTIONS - these get put in .text when relocating
  13 #       OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
  14 #               (e.g., .PARISC.global)
  15 #       OTHER_RELRO_SECTIONS - other than .data.rel.ro ...
  16 #               (e.g. PPC32 .fixup, .got[12])
  17 #       OTHER_BSS_SECTIONS - other than .bss .sbss ...
  18 #       ATTRS_SECTIONS - at the end
  19 #       OTHER_SECTIONS - at the end
  20 #       EXECUTABLE_SYMBOLS - symbols that must be defined for an
  21 #               executable (e.g., _DYNAMIC_LINK)
  22 #       TEXT_START_ADDR - the first byte of the text segment, after any
  23 #               headers.
  24 #       TEXT_BASE_ADDRESS - the first byte of the text segment.
  25 #       TEXT_START_SYMBOLS - symbols that appear at the start of the
  26 #               .text section.
  27 #       DATA_START_SYMBOLS - symbols that appear at the start of the
  28 #               .data section.
  29 #       DATA_END_SYMBOLS - symbols that appear at the end of the
  30 #               writeable data sections.
  31 #       OTHER_GOT_SYMBOLS - symbols defined just before .got.
  32 #       OTHER_GOT_SECTIONS - sections just after .got.
  33 #       OTHER_SDATA_SECTIONS - sections just after .sdata.
  34 #       OTHER_BSS_SYMBOLS - symbols that appear at the start of the
  35 #               .bss section besides __bss_start.
  36 #       DATA_PLT - .plt should be in data segment, not text segment.
  37 #       PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.
  38 #       BSS_PLT - .plt should be in bss segment
  39 #       NO_REL_RELOCS - Don't include .rel.* sections in script
  40 #       NO_RELA_RELOCS - Don't include .rela.* sections in script
  41 #       NON_ALLOC_DYN - Place dynamic sections after data segment.
  42 #       TEXT_DYNAMIC - .dynamic in text segment, not data segment.
  43 #       EMBEDDED - whether this is for an embedded system.
  44 #       SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
  45 #               start address of shared library.
  46 #       INPUT_FILES - INPUT command of files to always include
  47 #       WRITABLE_RODATA - if set, the .rodata section should be writable
  48 #       INIT_START, INIT_END -  statements just before and just after
  49 #       combination of .init sections.
  50 #       FINI_START, FINI_END - statements just before and just after
  51 #       combination of .fini sections.
  52 #       STACK_ADDR - start of a .stack section.
  53 #       OTHER_SYMBOLS - symbols to place right at the end of the script.
  54 #       ETEXT_NAME - name of a symbol for the end of the text section,
  55 #               normally etext.
  56 #       SEPARATE_GOTPLT - if set, .got.plt should be separate output section,
  57 #               so that .got can be in the RELRO area.  It should be set to
  58 #               the number of bytes in the beginning of .got.plt which can be
  59 #               in the RELRO area as well.
  60 #       USER_LABEL_PREFIX - prefix to add to user-visible symbols.
  61 #
  62 # When adding sections, do note that the names of some sections are used
  63 # when specifying the start address of the next.
  64 #
  65
  66 #  Many sections come in three flavours.  There is the 'real' section,
  67 #  like ".data".  Then there are the per-procedure or per-variable
  68 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
  69 #  and useful for --gc-sections, which for a variable "foo" might be
  70 #  ".data.foo".  Then there are the linkonce sections, for which the linker
  71 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
  72 #  The exact correspondences are:
  73 #
  74 #  Section      Linkonce section
  75 #  .text        .gnu.linkonce.t.foo
  76 #  .rodata      .gnu.linkonce.r.foo
  77 #  .data        .gnu.linkonce.d.foo
  78 #  .bss         .gnu.linkonce.b.foo
  79 #  .sdata       .gnu.linkonce.s.foo
  80 #  .sbss        .gnu.linkonce.sb.foo
  81 #  .sdata2      .gnu.linkonce.s2.foo
  82 #  .sbss2       .gnu.linkonce.sb2.foo
  83 #  .debug_info  .gnu.linkonce.wi.foo
  84 #  .tdata       .gnu.linkonce.td.foo
  85 #  .tbss        .gnu.linkonce.tb.foo
  86 #  .lrodata     .gnu.linkonce.lr.foo
  87 #  .ldata       .gnu.linkonce.l.foo
  88 #  .lbss        .gnu.linkonce.lb.foo
  89 #
  90 # plus exception-handling information for Tensilica's XCC compiler:
  91 #  .xt_except_table .gnu.linkonce.e.foo
  92 #  .xt_except_desc  .gnu.linkonce.h.foo
  93 #
  94 # plus Xtensa-specific literal sections:
  95 #  .literal     .gnu.linkonce.literal.foo
  96 #  .lit4        .gnu.linkonce.lit4.foo
  97 #
  98 # plus Xtensa-specific "property table" sections:
  99 #  .xt.lit      .gnu.linkonce.p.foo
 100 #  .xt.insn     .gnu.linkonce.x.foo (obsolete)
 101 #  .xt.prop     .gnu.linkonce.prop.foo
 102 #
 103 #  Each of these can also have corresponding .rel.* and .rela.* sections.
 104
 105 test -z "$ENTRY" && ENTRY=_start
 106 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 107 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 108 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
 109 test -z "${ELFSIZE}" && ELFSIZE=32
 110 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
 111 test "$LD_FLAG" = "N" && DATA_ADDR=.
 112 test -z "${ETEXT_NAME}" && ETEXT_NAME=etext
 113 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
 114 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
 115 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
 116 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
 117 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 118 DATA_SEGMENT_RELRO_END=""
 119 DATA_SEGMENT_END=""
 120 if test -n "${COMMONPAGESIZE}"; then
 121   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
 122   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
 123   DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
 124 fi
 125 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
 126   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
 127 fi
 128 if test -z "$PLT"; then
 129   PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
 130 fi
 131 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=yes
 132 if test -z "$GOT"; then
 133   if test -z "$SEPARATE_GOTPLT"; then
 134     GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.got) }"
 135   else
 136     GOT=".got          ${RELOCATING-0} : { *(.got) }"
 137     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt) }"
 138   fi
 139 fi
 140 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
 141 RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
 142 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }"
 143 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink)  *(.gnu.lto_*) }"
 144 INIT_LIT=".init.literal 0 : { *(.init.literal)  }"
 145 INIT=".init         0 : { *(.init)              }"
 146 FINI_LIT=".fini.literal 0 : { *(.fini.literal)  }"
 147 FINI=".fini         0 : { *(.fini)              }"
 148 if test -z "${NO_SMALL_DATA}"; then
 149   SBSS=".sbss         ${RELOCATING-0} :
 150   {
 151     ${RELOCATING+${SBSS_START_SYMBOLS}}
 152     ${CREATE_SHLIB+*(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)}
 153     *(.dynsbss)
 154     *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
 155     *(.scommon)
 156     ${RELOCATING+${SBSS_END_SYMBOLS}}
 157   }"
 158   SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
 159   SDATA="/* We want the small data sections together, so single-instruction offsets
 160      can access them all, and initialized data all before uninitialized, so
 161      we can shorten the on-disk segment size.  */
 162   .sdata        ${RELOCATING-0} :
 163   {
 164     ${RELOCATING+${SDATA_START_SYMBOLS}}
 165     ${CREATE_SHLIB+*(.sdata2 .sdata2.* .gnu.linkonce.s2.*)}
 166     *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
 167   }"
 168   SDATA2=".sdata2       ${RELOCATING-0} :
 169   {
 170     ${RELOCATING+${SDATA2_START_SYMBOLS}}
 171     *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*})
 172   }"
 173   REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
 174   .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
 175   REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
 176   .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
 177   REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
 178   .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
 179   REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
 180   .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
 181 else
 182   NO_SMALL_DATA=" "
 183 fi
 184 if test -z "${DATA_GOT}"; then
 185   if test -n "${NO_SMALL_DATA}"; then
 186     DATA_GOT=" "
 187   fi
 188 fi
 189 if test -z "${SDATA_GOT}"; then
 190   if test -z "${NO_SMALL_DATA}"; then
 191     SDATA_GOT=" "
 192   fi
 193 fi
 194 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
 195 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
 196   .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
 197   .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
 198   .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
 199   .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
 200   .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
 201   .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
 202 test "${LARGE_SECTIONS}" = "yes" && OTHER_BSS_SECTIONS="
 203   ${OTHER_BSS_SECTIONS}
 204   .lbss ${RELOCATING-0} :
 205   {
 206     *(.dynlbss)
 207     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
 208     *(LARGE_COMMON)
 209   }"
 210 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
 211   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 212   {
 213     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
 214   }
 215   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 216   {
 217     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
 218     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 219   }"
 220 INIT_ARRAY=".init_array   ${RELOCATING-0} :
 221   {
 222      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
 223      KEEP (*(SORT(.init_array.*)))
 224      KEEP (*(.init_array))
 225      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
 226   }"
 227 FINI_ARRAY=".fini_array   ${RELOCATING-0} :
 228   {
 229     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
 230     KEEP (*(SORT(.fini_array.*)))
 231     KEEP (*(.fini_array))
 232     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
 233   }"
 234 CTOR=".ctors        ${CONSTRUCTING-0} :
 235   {
 236     ${CONSTRUCTING+${CTOR_START}}
 237     /* gcc uses crtbegin.o to find the start of
 238        the constructors, so we make sure it is
 239        first.  Because this is a wildcard, it
 240        doesn't matter if the user does not
 241        actually link against crtbegin.o; the
 242        linker won't look for a file to match a
 243        wildcard.  The wildcard also means that it
 244        doesn't matter which directory crtbegin.o
 245        is in.  */
 246
 247     KEEP (*crtbegin.o(.ctors))
 248     KEEP (*crtbegin?.o(.ctors))
 249
 250     /* We don't want to include the .ctor section from
 251        the crtend.o file until after the sorted ctors.
 252        The .ctor section from the crtend file contains the
 253        end of ctors marker and it must be last */
 254
 255     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
 256     KEEP (*(SORT(.ctors.*)))
 257     KEEP (*(.ctors))
 258     ${CONSTRUCTING+${CTOR_END}}
 259   }"
 260 DTOR=".dtors        ${CONSTRUCTING-0} :
 261   {
 262     ${CONSTRUCTING+${DTOR_START}}
 263     KEEP (*crtbegin.o(.dtors))
 264     KEEP (*crtbegin?.o(.dtors))
 265     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
 266     KEEP (*(SORT(.dtors.*)))
 267     KEEP (*(.dtors))
 268     ${CONSTRUCTING+${DTOR_END}}
 269   }"
 270 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 271   {
 272     ${RELOCATING+_stack = .;}
 273     *(.stack)
 274   }"
 275
 276 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 277 if [ -z "$EMBEDDED" ]; then
 278    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
 279 else
 280    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 281 fi
 282
 283 cat <<EOF
 284 ${RELOCATING+ENTRY(${ENTRY})}
 285
 286 ${RELOCATING+${LIB_SEARCH_DIRS}}
 287 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 288 ${RELOCATING+${INPUT_FILES}}
 289 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 290   if gld -r is used and the intermediate file has sections starting
 291   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 292   bug.  But for now assigning the zero vmas works.  */}
 293
 294 SECTIONS
 295 {
 296   /* Read-only sections, merged into text segment: */
 297   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 298   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 299   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 300   ${INITIAL_READONLY_SECTIONS}
 301   .note.gnu.build-id : { *(.note.gnu.build-id) }
 302 EOF
 303
 304 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
 305 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
 306 cat > ldscripts/dyntmp.$$ <<EOF
 307   ${TEXT_DYNAMIC+${DYNAMIC}}
 308   .hash         ${RELOCATING-0} : { *(.hash) }
 309   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 310   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 311   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 312   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 313   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 314   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 315 EOF
 316
 317 if [ "x$COMBRELOC" = x ]; then
 318   COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
 319 else
 320   COMBRELOCCAT="cat > $COMBRELOC"
 321 fi
 322 eval $COMBRELOCCAT <<EOF
 323   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 324   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 325   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 326   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 327   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 328   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 329   .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
 330   .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
 331   ${OTHER_READONLY_RELOC_SECTIONS}
 332   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+* .rel.gnu.linkonce.d.rel.ro.*}) }
 333   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+* .rela.gnu.linkonce.d.rel.ro.*}) }
 334   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 335   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 336   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 337   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 338   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 339   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 340   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 341   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 342   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 343   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 344   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 345   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 346   ${OTHER_GOT_RELOC_SECTIONS}
 347   ${REL_SDATA}
 348   ${REL_SBSS}
 349   ${REL_SDATA2}
 350   ${REL_SBSS2}
 351   .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
 352   .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
 353   ${REL_LARGE}
 354 EOF
 355
 356 if [ -n "$COMBRELOC" ]; then
 357 cat >> ldscripts/dyntmp.$$ <<EOF
 358   .rel.dyn      ${RELOCATING-0} :
 359     {
 360 EOF
 361 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 362 cat >> ldscripts/dyntmp.$$ <<EOF
 363     }
 364   .rela.dyn     ${RELOCATING-0} :
 365     {
 366 EOF
 367 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 368 cat >> ldscripts/dyntmp.$$ <<EOF
 369     }
 370 EOF
 371 fi
 372
 373 cat >> ldscripts/dyntmp.$$ <<EOF
 374   .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
 375   .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
 376   ${OTHER_PLT_RELOC_SECTIONS}
 377 EOF
 378
 379 if test -z "${NON_ALLOC_DYN}"; then
 380   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 381     cat ldscripts/dyntmp.$$
 382   else
 383     if test -z "${NO_REL_RELOCS}"; then
 384       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
 385     fi
 386     if test -z "${NO_RELA_RELOCS}"; then
 387       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
 388     fi
 389   fi
 390   rm -f ldscripts/dyntmp.$$
 391 fi
 392
 393 cat <<EOF
 394   ${RELOCATING-$INIT_LIT}
 395   ${RELOCATING-$INIT}
 396
 397   ${TEXT_PLT+${PLT}}
 398   ${TINY_READONLY_SECTION}
 399   .text         ${RELOCATING-0} :
 400   {
 401     *(.got.plt* .plt*)
 402
 403     ${RELOCATING+${INIT_START}}
 404     ${RELOCATING+KEEP (*(.init.literal))}
 405     ${RELOCATING+KEEP (*(.init))}
 406     ${RELOCATING+${INIT_END}}
 407
 408     ${RELOCATING+${TEXT_START_SYMBOLS}}
 409     *(.literal .text .stub${RELOCATING+ .literal.* .text.* .gnu.linkonce.literal.* .gnu.linkonce.t.*.literal .gnu.linkonce.t.*})
 410     /* .gnu.warning sections are handled specially by elf32.em.  */
 411     *(.gnu.warning)
 412     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 413
 414     ${RELOCATING+${FINI_START}}
 415     ${RELOCATING+KEEP (*(.fini.literal))}
 416     ${RELOCATING+KEEP (*(.fini))}
 417     ${RELOCATING+${FINI_END}}
 418   } =${NOP-0}
 419
 420   ${RELOCATING-$FINI_LIT}
 421   ${RELOCATING-$FINI}
 422
 423   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 424   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 425   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 426   ${WRITABLE_RODATA-${RODATA}}
 427   .rodata1      ${RELOCATING-0} : { *(.rodata1) }
 428   ${CREATE_SHLIB-${SDATA2}}
 429   ${CREATE_SHLIB-${SBSS2}}
 430   ${OTHER_READONLY_SECTIONS}
 431   .eh_frame_hdr : { *(.eh_frame_hdr) }
 432   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 433   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
 434
 435   /* Adjust the address for the data segment.  We want to adjust up to
 436      the same address within the page on the next page up.  */
 437   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 438   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 439   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 440
 441   /* Exception handling  */
 442   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 443   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 444
 445   /* Thread Local Storage sections  */
 446   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 447   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 448
 449   .preinit_array   ${RELOCATING-0} :
 450   {
 451     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 452     KEEP (*(.preinit_array))
 453     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 454   }
 455   ${RELOCATING+${INIT_ARRAY}}
 456   ${RELOCATING+${FINI_ARRAY}}
 457   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 458   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 459   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 460
 461   ${RELOCATING+${DATARELRO}}
 462   ${OTHER_RELRO_SECTIONS}
 463   ${TEXT_DYNAMIC-${DYNAMIC}}
 464   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 465   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 466   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 467   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 468   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 469   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 470
 471   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 472
 473   .data         ${RELOCATING-0} :
 474   {
 475     ${RELOCATING+${DATA_START_SYMBOLS}}
 476     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 477     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 478   }
 479   .data1        ${RELOCATING-0} : { *(.data1) }
 480   ${WRITABLE_RODATA+${RODATA}}
 481   ${OTHER_READWRITE_SECTIONS}
 482   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 483   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 484   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 485   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS}}}
 486   ${SDATA_GOT+${GOT}}
 487   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 488   ${SDATA}
 489   ${OTHER_SDATA_SECTIONS}
 490   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 491   ${RELOCATING+__bss_start = .;}
 492   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 493   ${SBSS}
 494   ${BSS_PLT+${PLT}}
 495   .bss          ${RELOCATING-0} :
 496   {
 497    *(.dynbss)
 498    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
 499    *(COMMON)
 500    /* Align here to ensure that the .bss section occupies space up to
 501       _end.  Align after .bss to ensure correct alignment even if the
 502       .bss section disappears because there are no input sections.
 503       FIXME: Why do we need it? When there is no .bss section, we don't
 504       pad the .data section.  */
 505    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 506   }
 507   ${OTHER_BSS_SECTIONS}
 508   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 509   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 510   ${LARGE_SECTIONS}
 511   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 512   ${RELOCATING+${OTHER_END_SYMBOLS}}
 513   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 514   ${RELOCATING+${DATA_SEGMENT_END}}
 515 EOF
 516
 517 if test -n "${NON_ALLOC_DYN}"; then
 518   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 519     cat ldscripts/dyntmp.$$
 520   else
 521     if test -z "${NO_REL_RELOCS}"; then
 522       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
 523     fi
 524     if test -z "${NO_RELA_RELOCS}"; then
 525       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
 526     fi
 527   fi
 528   rm -f ldscripts/dyntmp.$$
 529 fi
 530
 531 cat <<EOF
 532   /* Stabs debugging sections.  */
 533   .stab          0 : { *(.stab) }
 534   .stabstr       0 : { *(.stabstr) }
 535   .stab.excl     0 : { *(.stab.excl) }
 536   .stab.exclstr  0 : { *(.stab.exclstr) }
 537   .stab.index    0 : { *(.stab.index) }
 538   .stab.indexstr 0 : { *(.stab.indexstr) }
 539
 540   .comment       0 : { *(.comment) }
 541
 542   /* DWARF debug sections.
 543      Symbols in the DWARF debugging sections are relative to the beginning
 544      of the section so we begin them at 0.  */
 545
 546   /* DWARF 1 */
 547   .debug          0 : { *(.debug) }
 548   .line           0 : { *(.line) }
 549
 550   /* GNU DWARF 1 extensions */
 551   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 552   .debug_sfnames  0 : { *(.debug_sfnames) }
 553
 554   /* DWARF 1.1 and DWARF 2 */
 555   .debug_aranges  0 : { *(.debug_aranges) }
 556   .debug_pubnames 0 : { *(.debug_pubnames) }
 557
 558   /* DWARF 2 */
 559   .debug_info     0 : { *(.debug_info${RELOCATING+ .gnu.linkonce.wi.*}) }
 560   .debug_abbrev   0 : { *(.debug_abbrev) }
 561   .debug_line     0 : { *(.debug_line) }
 562   .debug_frame    0 : { *(.debug_frame) }
 563   .debug_str      0 : { *(.debug_str) }
 564   .debug_loc      0 : { *(.debug_loc) }
 565   .debug_macinfo  0 : { *(.debug_macinfo) }
 566
 567   /* SGI/MIPS DWARF 2 extensions */
 568   .debug_weaknames 0 : { *(.debug_weaknames) }
 569   .debug_funcnames 0 : { *(.debug_funcnames) }
 570   .debug_typenames 0 : { *(.debug_typenames) }
 571   .debug_varnames  0 : { *(.debug_varnames) }
 572
 573   /* DWARF 3 */
 574   .debug_pubtypes 0 : { *(.debug_pubtypes) }
 575   .debug_ranges   0 : { *(.debug_ranges) }
 576
 577   ${TINY_DATA_SECTION}
 578   ${TINY_BSS_SECTION}
 579
 580   ${STACK_ADDR+${STACK}}
 581   ${ATTRS_SECTIONS}
 582   ${OTHER_SECTIONS}
 583   ${RELOCATING+${OTHER_SYMBOLS}}
 584   ${RELOCATING+${DISCARDED}}
 585 }
 586 EOF