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