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