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   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 264   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 265   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 266   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 267   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 268   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 269
 270 EOF
 271 if [ "x$COMBRELOC" = x ]; then
 272   COMBRELOCCAT=cat
 273 else
 274   COMBRELOCCAT="cat > $COMBRELOC"
 275 fi
 276 eval $COMBRELOCCAT <<EOF
 277   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 278   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 279   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 280   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 281   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 282   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 283   .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
 284   .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
 285   ${OTHER_READONLY_RELOC_SECTIONS}
 286   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+* .rel.gnu.linkonce.d.rel.ro.*}) }
 287   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+* .rela.gnu.linkonce.d.rel.ro.*}) }
 288   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 289   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 290   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 291   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 292   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 293   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 294   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 295   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 296   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 297   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 298   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 299   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 300   ${OTHER_GOT_RELOC_SECTIONS}
 301   ${REL_SDATA}
 302   ${REL_SBSS}
 303   ${REL_SDATA2}
 304   ${REL_SBSS2}
 305   .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
 306   .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
 307   ${REL_LARGE}
 308 EOF
 309 if [ -n "$COMBRELOC" ]; then
 310 cat <<EOF
 311   .rel.dyn      ${RELOCATING-0} :
 312     {
 313 EOF
 314 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
 315 cat <<EOF
 316     }
 317   .rela.dyn     ${RELOCATING-0} :
 318     {
 319 EOF
 320 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
 321 cat <<EOF
 322     }
 323 EOF
 324 fi
 325 cat <<EOF
 326   .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
 327   .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
 328   ${OTHER_PLT_RELOC_SECTIONS}
 329
 330   .init         ${RELOCATING-0} :
 331   {
 332     ${RELOCATING+${INIT_START}}
 333     KEEP (*(.init))
 334     ${RELOCATING+${INIT_END}}
 335   } =${NOP-0}
 336
 337   ${TEXT_PLT+${PLT}}
 338   ${TINY_READONLY_SECTION}
 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 (*(SORT(.init_array.*)))
 390      KEEP (*(.init_array))
 391      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_end = .);}}
 392   }
 393   .fini_array   ${RELOCATING-0} :
 394   {
 395     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_start = .);}}
 396     KEEP (*(.fini_array))
 397     KEEP (*(SORT(.fini_array.*)))
 398     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_end = .);}}
 399   }
 400   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 401   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 402   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 403
 404   ${RELOCATING+${DATARELRO}}
 405   ${OTHER_RELRO_SECTIONS}
 406   ${TEXT_DYNAMIC-${DYNAMIC}}
 407   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 408   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 409   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 410   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 411   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 412   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 413
 414   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 415
 416   .data         ${RELOCATING-0} :
 417   {
 418     ${RELOCATING+${DATA_START_SYMBOLS}}
 419     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 420     KEEP (*(.gnu.linkonce.d.*personality*))
 421     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 422   }
 423   .data1        ${RELOCATING-0} : { *(.data1) }
 424   ${WRITABLE_RODATA+${RODATA}}
 425   ${OTHER_READWRITE_SECTIONS}
 426   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 427   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 428   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 429   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS}}}
 430   ${SDATA_GOT+${GOT}}
 431   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 432   ${SDATA}
 433   ${OTHER_SDATA_SECTIONS}
 434   ${RELOCATING+${DATA_END_SYMBOLS-_edata = .; PROVIDE (edata = .);}}
 435   ${RELOCATING+__bss_start = .;}
 436   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 437   ${SBSS}
 438   ${BSS_PLT+${PLT}}
 439   .bss          ${RELOCATING-0} :
 440   {
 441    *(.dynbss)
 442    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
 443    *(COMMON)
 444    /* Align here to ensure that the .bss section occupies space up to
 445       _end.  Align after .bss to ensure correct alignment even if the
 446       .bss section disappears because there are no input sections.
 447       FIXME: Why do we need it? When there is no .bss section, we don't
 448       pad the .data section.  */
 449    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 450   }
 451   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 452   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 453   ${LARGE_SECTIONS}
 454   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 455   ${RELOCATING+${OTHER_END_SYMBOLS}}
 456   ${RELOCATING+${END_SYMBOLS-_end = .; PROVIDE (end = .);}}
 457   ${RELOCATING+${DATA_SEGMENT_END}}
 458
 459   /* Stabs debugging sections.  */
 460   .stab          0 : { *(.stab) }
 461   .stabstr       0 : { *(.stabstr) }
 462   .stab.excl     0 : { *(.stab.excl) }
 463   .stab.exclstr  0 : { *(.stab.exclstr) }
 464   .stab.index    0 : { *(.stab.index) }
 465   .stab.indexstr 0 : { *(.stab.indexstr) }
 466
 467   .comment       0 : { *(.comment) }
 468
 469   /* DWARF debug sections.
 470      Symbols in the DWARF debugging sections are relative to the beginning
 471      of the section so we begin them at 0.  */
 472
 473   /* DWARF 1 */
 474   .debug          0 : { *(.debug) }
 475   .line           0 : { *(.line) }
 476
 477   /* GNU DWARF 1 extensions */
 478   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 479   .debug_sfnames  0 : { *(.debug_sfnames) }
 480
 481   /* DWARF 1.1 and DWARF 2 */
 482   .debug_aranges  0 : { *(.debug_aranges) }
 483   .debug_pubnames 0 : { *(.debug_pubnames) }
 484
 485   /* DWARF 2 */
 486   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
 487   .debug_abbrev   0 : { *(.debug_abbrev) }
 488   .debug_line     0 : { *(.debug_line) }
 489   .debug_frame    0 : { *(.debug_frame) }
 490   .debug_str      0 : { *(.debug_str) }
 491   .debug_loc      0 : { *(.debug_loc) }
 492   .debug_macinfo  0 : { *(.debug_macinfo) }
 493
 494   /* SGI/MIPS DWARF 2 extensions */
 495   .debug_weaknames 0 : { *(.debug_weaknames) }
 496   .debug_funcnames 0 : { *(.debug_funcnames) }
 497   .debug_typenames 0 : { *(.debug_typenames) }
 498   .debug_varnames  0 : { *(.debug_varnames) }
 499
 500   ${TINY_DATA_SECTION}
 501   ${TINY_BSS_SECTION}
 502
 503   ${STACK_ADDR+${STACK}}
 504   ${OTHER_SECTIONS}
 505   ${RELOCATING+${OTHER_SYMBOLS}}
 506   ${RELOCATING+${STACKNOTE}}
 507 }
 508 EOF