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