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) *(.data.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        from 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+/* Do we need any of these for elf?
 247    __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
 248 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 249 ${RELOCATING+${INPUT_FILES}}
 250 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 251   if gld -r is used and the intermediate file has sections starting
 252   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 253   bug.  But for now assigning the zero vmas works.  */}
 254
 255 SECTIONS
 256 {
 257   /* Read-only sections, merged into text segment: */
 258   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 259   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 260   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 261   ${CREATE_SHLIB-${INTERP}}
 262   ${INITIAL_READONLY_SECTIONS}
 263   ${TEXT_DYNAMIC+${DYNAMIC}}
 264   .hash         ${RELOCATING-0} : { *(.hash) }
 265   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 266   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 267   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 268   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 269   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 270
 271 EOF
 272 if [ "x$COMBRELOC" = x ]; then
 273   COMBRELOCCAT=cat
 274 else
 275   COMBRELOCCAT="cat > $COMBRELOC"
 276 fi
 277 eval $COMBRELOCCAT <<EOF
 278   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 279   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 280   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 281   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 282   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 283   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 284   .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
 285   .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
 286   ${OTHER_READONLY_RELOC_SECTIONS}
 287   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }
 288   .rela.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }
 289   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 290   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 291   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 292   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 293   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 294   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 295   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 296   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 297   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 298   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 299   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 300   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 301   ${OTHER_GOT_RELOC_SECTIONS}
 302   ${REL_SDATA}
 303   ${REL_SBSS}
 304   ${REL_SDATA2}
 305   ${REL_SBSS2}
 306   .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
 307   .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
 308   ${REL_LARGE}
 309 EOF
 310 if [ -n "$COMBRELOC" ]; then
 311 cat <<EOF
 312   .rel.dyn      ${RELOCATING-0} :
 313     {
 314 EOF
 315 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
 316 cat <<EOF
 317     }
 318   .rela.dyn     ${RELOCATING-0} :
 319     {
 320 EOF
 321 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
 322 cat <<EOF
 323     }
 324 EOF
 325 fi
 326 cat <<EOF
 327   .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
 328   .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
 329   ${OTHER_PLT_RELOC_SECTIONS}
 330
 331   .init         ${RELOCATING-0} :
 332   {
 333     ${RELOCATING+${INIT_START}}
 334     KEEP (*(.init))
 335     ${RELOCATING+${INIT_END}}
 336   } =${NOP-0}
 337
 338   ${TEXT_PLT+${PLT}}
 339   .text         ${RELOCATING-0} :
 340   {
 341     ${RELOCATING+${TEXT_START_SYMBOLS}}
 342     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 343     KEEP (*(.text.*personality*))
 344     /* .gnu.warning sections are handled specially by elf32.em.  */
 345     *(.gnu.warning)
 346     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 347   } =${NOP-0}
 348   .fini         ${RELOCATING-0} :
 349   {
 350     ${RELOCATING+${FINI_START}}
 351     KEEP (*(.fini))
 352     ${RELOCATING+${FINI_END}}
 353   } =${NOP-0}
 354   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 355   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 356   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 357   ${WRITABLE_RODATA-${RODATA}}
 358   .rodata1      ${RELOCATING-0} : { *(.rodata1) }
 359   ${CREATE_SHLIB-${SDATA2}}
 360   ${CREATE_SHLIB-${SBSS2}}
 361   ${OTHER_READONLY_SECTIONS}
 362   .eh_frame_hdr : { *(.eh_frame_hdr) }
 363   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 364   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
 365
 366   /* Adjust the address for the data segment.  We want to adjust up to
 367      the same address within the page on the next page up.  */
 368   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 369   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 370   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 371
 372   /* Exception handling  */
 373   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 374   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 375
 376   /* Thread Local Storage sections  */
 377   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 378   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 379
 380   .preinit_array   ${RELOCATING-0} :
 381   {
 382     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_start = .);}}
 383     KEEP (*(.preinit_array))
 384     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_end = .);}}
 385   }
 386   .init_array   ${RELOCATING-0} :
 387   {
 388      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_start = .);}}
 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     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_end = .);}}
 397   }
 398   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 399   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 400   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 401
 402   ${RELOCATING+${DATARELRO}}
 403   ${OTHER_RELRO_SECTIONS}
 404   ${TEXT_DYNAMIC-${DYNAMIC}}
 405   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 406   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 407   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 408   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 409   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 410   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 411
 412   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 413
 414   .data         ${RELOCATING-0} :
 415   {
 416     ${RELOCATING+${DATA_START_SYMBOLS}}
 417     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 418     KEEP (*(.gnu.linkonce.d.*personality*))
 419     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 420   }
 421   .data1        ${RELOCATING-0} : { *(.data1) }
 422   ${WRITABLE_RODATA+${RODATA}}
 423   ${OTHER_READWRITE_SECTIONS}
 424   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 425   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 426   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 427   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS}}}
 428   ${SDATA_GOT+${GOT}}
 429   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 430   ${SDATA}
 431   ${OTHER_SDATA_SECTIONS}
 432   ${RELOCATING+${DATA_END_SYMBOLS-_edata = .; PROVIDE (edata = .);}}
 433   ${RELOCATING+__bss_start = .;}
 434   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 435   ${SBSS}
 436   ${BSS_PLT+${PLT}}
 437   .bss          ${RELOCATING-0} :
 438   {
 439    *(.dynbss)
 440    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
 441    *(COMMON)
 442    /* Align here to ensure that the .bss section occupies space up to
 443       _end.  Align after .bss to ensure correct alignment even if the
 444       .bss section disappears because there are no input sections.
 445       FIXME: Why do we need it? When there is no .bss section, we don't
 446       pad the .data section.  */
 447    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 448   }
 449   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 450   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 451   ${LARGE_SECTIONS}
 452   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 453   ${RELOCATING+${OTHER_END_SYMBOLS}}
 454   ${RELOCATING+_end = .;}
 455   ${RELOCATING+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   ${STACK_ADDR+${STACK}}
 500   ${OTHER_SECTIONS}
 501   ${RELOCATING+${OTHER_SYMBOLS}}
 502   ${RELOCATING+${STACKNOTE}}
 503 }
 504 EOF