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