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