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