ld/scripttempl/elfxtensa.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_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 #       USER_LABEL_PREFIX - prefix to add to user-visible symbols.
  57 #
  58 # When adding sections, do note that the names of some sections are used
  59 # when specifying the start address of the next.
  60 #
  61
  62 #  Many sections come in three flavours.  There is the 'real' section,
  63 #  like ".data".  Then there are the per-procedure or per-variable
  64 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
  65 #  and useful for --gc-sections, which for a variable "foo" might be
  66 #  ".data.foo".  Then there are the linkonce sections, for which the linker
  67 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
  68 #  The exact correspondences are:
  69 #
  70 #  Section      Linkonce section
  71 #  .text        .gnu.linkonce.t.foo
  72 #  .rodata      .gnu.linkonce.r.foo
  73 #  .data        .gnu.linkonce.d.foo
  74 #  .bss         .gnu.linkonce.b.foo
  75 #  .sdata       .gnu.linkonce.s.foo
  76 #  .sbss        .gnu.linkonce.sb.foo
  77 #  .sdata2      .gnu.linkonce.s2.foo
  78 #  .sbss2       .gnu.linkonce.sb2.foo
  79 #  .debug_info  .gnu.linkonce.wi.foo
  80 #  .tdata       .gnu.linkonce.td.foo
  81 #  .tbss        .gnu.linkonce.tb.foo
  82 #  .lrodata     .gnu.linkonce.lr.foo
  83 #  .ldata       .gnu.linkonce.l.foo
  84 #  .lbss        .gnu.linkonce.lb.foo
  85 #
  86 # plus exception-handling information for Tensilica's XCC compiler:
  87 #  .xt_except_table .gnu.linkonce.e.foo
  88 #  .xt_except_desc  .gnu.linkonce.h.foo
  89 #
  90 # plus Xtensa-specific literal sections:
  91 #  .literal     .gnu.linkonce.literal.foo
  92 #  .lit4        .gnu.linkonce.lit4.foo
  93 #
  94 # plus Xtensa-specific "property table" sections:
  95 #  .xt.lit      .gnu.linkonce.p.foo
  96 #  .xt.insn     .gnu.linkonce.x.foo (obsolete)
  97 #  .xt.prop     .gnu.linkonce.prop.foo
  98 #
  99 #  Each of these can also have corresponding .rel.* and .rela.* sections.
 100
 101 test -z "$ENTRY" && ENTRY=_start
 102 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 103 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 104 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
 105 test -z "${ELFSIZE}" && ELFSIZE=32
 106 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
 107 test "$LD_FLAG" = "N" && DATA_ADDR=.
 108 test -z "${ETEXT_NAME}" && ETEXT_NAME=etext
 109 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
 110 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
 111 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
 112 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 113 DATA_SEGMENT_RELRO_END=""
 114 DATA_SEGMENT_END=""
 115 if test -n "${COMMONPAGESIZE}"; then
 116   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
 117   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
 118   DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
 119 fi
 120 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
 121   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
 122 fi
 123 if test -z "$PLT"; then
 124   PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
 125 fi
 126 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=yes
 127 if test -z "$GOT"; then
 128   if test -z "$SEPARATE_GOTPLT"; then
 129     GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.got) }"
 130   else
 131     GOT=".got          ${RELOCATING-0} : { *(.got) }"
 132     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt) }"
 133   fi
 134 fi
 135 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
 136 RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
 137 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }"
 138 STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
 139 INIT_LIT=".init.literal 0 : { *(.init.literal)  }"
 140 INIT=".init         0 : { *(.init)              }"
 141 FINI_LIT=".fini.literal 0 : { *(.fini.literal)  }"
 142 FINI=".fini         0 : { *(.fini)              }"
 143 if test -z "${NO_SMALL_DATA}"; then
 144   SBSS=".sbss         ${RELOCATING-0} :
 145   {
 146     ${RELOCATING+${SBSS_START_SYMBOLS}}
 147     ${CREATE_SHLIB+*(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)}
 148     *(.dynsbss)
 149     *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
 150     *(.scommon)
 151     ${RELOCATING+${SBSS_END_SYMBOLS}}
 152   }"
 153   SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
 154   SDATA="/* We want the small data sections together, so single-instruction offsets
 155      can access them all, and initialized data all before uninitialized, so
 156      we can shorten the on-disk segment size.  */
 157   .sdata        ${RELOCATING-0} :
 158   {
 159     ${RELOCATING+${SDATA_START_SYMBOLS}}
 160     ${CREATE_SHLIB+*(.sdata2 .sdata2.* .gnu.linkonce.s2.*)}
 161     *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
 162   }"
 163   SDATA2=".sdata2       ${RELOCATING-0} :
 164   {
 165     ${RELOCATING+${SDATA2_START_SYMBOLS}}
 166     *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*})
 167   }"
 168   REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
 169   .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
 170   REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
 171   .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
 172   REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
 173   .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
 174   REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
 175   .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
 176 else
 177   NO_SMALL_DATA=" "
 178 fi
 179 if test -z "${DATA_GOT}"; then
 180   if test -n "${NO_SMALL_DATA}"; then
 181     DATA_GOT=" "
 182   fi
 183 fi
 184 if test -z "${SDATA_GOT}"; then
 185   if test -z "${NO_SMALL_DATA}"; then
 186     SDATA_GOT=" "
 187   fi
 188 fi
 189 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
 190 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
 191   .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
 192   .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
 193   .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
 194   .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
 195   .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
 196   .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
 197 test "${LARGE_SECTIONS}" = "yes" && OTHER_BSS_SECTIONS="
 198   ${OTHER_BSS_SECTIONS}
 199   .lbss ${RELOCATING-0} :
 200   {
 201     *(.dynlbss)
 202     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
 203     *(LARGE_COMMON)
 204   }"
 205 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
 206   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 207   {
 208     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
 209   }
 210   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 211   {
 212     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
 213     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 214   }"
 215 CTOR=".ctors        ${CONSTRUCTING-0} :
 216   {
 217     ${CONSTRUCTING+${CTOR_START}}
 218     /* gcc uses crtbegin.o to find the start of
 219        the constructors, so we make sure it is
 220        first.  Because this is a wildcard, it
 221        doesn't matter if the user does not
 222        actually link against crtbegin.o; the
 223        linker won't look for a file to match a
 224        wildcard.  The wildcard also means that it
 225        doesn't matter which directory crtbegin.o
 226        is in.  */
 227
 228     KEEP (*crtbegin.o(.ctors))
 229     KEEP (*crtbegin?.o(.ctors))
 230
 231     /* We don't want to include the .ctor section from
 232        the crtend.o file until after the sorted ctors.
 233        The .ctor section from the crtend file contains the
 234        end of ctors marker and it must be last */
 235
 236     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
 237     KEEP (*(SORT(.ctors.*)))
 238     KEEP (*(.ctors))
 239     ${CONSTRUCTING+${CTOR_END}}
 240   }"
 241 DTOR=".dtors        ${CONSTRUCTING-0} :
 242   {
 243     ${CONSTRUCTING+${DTOR_START}}
 244     KEEP (*crtbegin.o(.dtors))
 245     KEEP (*crtbegin?.o(.dtors))
 246     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
 247     KEEP (*(SORT(.dtors.*)))
 248     KEEP (*(.dtors))
 249     ${CONSTRUCTING+${DTOR_END}}
 250   }"
 251 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 252   {
 253     ${RELOCATING+_stack = .;}
 254     *(.stack)
 255   }"
 256
 257 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 258 if [ -z "$EMBEDDED" ]; then
 259    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
 260 else
 261    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 262 fi
 263
 264 cat <<EOF
 265 ENTRY(${ENTRY})
 266
 267 ${RELOCATING+${LIB_SEARCH_DIRS}}
 268 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 269 ${RELOCATING+${INPUT_FILES}}
 270 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 271   if gld -r is used and the intermediate file has sections starting
 272   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 273   bug.  But for now assigning the zero vmas works.  */}
 274
 275 SECTIONS
 276 {
 277   /* Read-only sections, merged into text segment: */
 278   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 279   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 280   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 281   ${INITIAL_READONLY_SECTIONS}
 282   ${TEXT_DYNAMIC+${DYNAMIC}}
 283   .hash         ${RELOCATING-0} : { *(.hash) }
 284   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 285   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 286   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 287   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 288   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 289   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 290
 291 EOF
 292 if [ "x$COMBRELOC" = x ]; then
 293   COMBRELOCCAT=cat
 294 else
 295   COMBRELOCCAT="cat > $COMBRELOC"
 296 fi
 297 eval $COMBRELOCCAT <<EOF
 298   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 299   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 300   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 301   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 302   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 303   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 304   .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
 305   .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
 306   ${OTHER_READONLY_RELOC_SECTIONS}
 307   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+* .rel.gnu.linkonce.d.rel.ro.*}) }
 308   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+* .rela.gnu.linkonce.d.rel.ro.*}) }
 309   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 310   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 311   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 312   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 313   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 314   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 315   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 316   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 317   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 318   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 319   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 320   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 321   ${OTHER_GOT_RELOC_SECTIONS}
 322   ${REL_SDATA}
 323   ${REL_SBSS}
 324   ${REL_SDATA2}
 325   ${REL_SBSS2}
 326   .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
 327   .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
 328   ${REL_LARGE}
 329 EOF
 330 if [ -n "$COMBRELOC" ]; then
 331 cat <<EOF
 332   .rel.dyn      ${RELOCATING-0} :
 333     {
 334 EOF
 335 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
 336 cat <<EOF
 337     }
 338   .rela.dyn     ${RELOCATING-0} :
 339     {
 340 EOF
 341 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
 342 cat <<EOF
 343     }
 344 EOF
 345 fi
 346 cat <<EOF
 347   .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
 348   .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
 349   ${OTHER_PLT_RELOC_SECTIONS}
 350
 351   ${RELOCATING-$INIT_LIT}
 352   ${RELOCATING-$INIT}
 353
 354   ${TEXT_PLT+${PLT}}
 355   ${TINY_READONLY_SECTION}
 356   .text         ${RELOCATING-0} :
 357   {
 358     *(.got.plt* .plt*)
 359
 360     ${RELOCATING+${INIT_START}}
 361     ${RELOCATING+KEEP (*(.init.literal))}
 362     ${RELOCATING+KEEP (*(.init))}
 363     ${RELOCATING+${INIT_END}}
 364
 365     ${RELOCATING+${TEXT_START_SYMBOLS}}
 366     *(.literal .text .stub${RELOCATING+ .literal.* .text.* .gnu.linkonce.literal.* .gnu.linkonce.t.*.literal .gnu.linkonce.t.*})
 367     KEEP (*(.text.*personality*))
 368     /* .gnu.warning sections are handled specially by elf32.em.  */
 369     *(.gnu.warning)
 370     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 371
 372     ${RELOCATING+${FINI_START}}
 373     ${RELOCATING+KEEP (*(.fini.literal))}
 374     ${RELOCATING+KEEP (*(.fini))}
 375     ${RELOCATING+${FINI_END}}
 376   } =${NOP-0}
 377
 378   ${RELOCATING-$FINI_LIT}
 379   ${RELOCATING-$FINI}
 380
 381   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 382   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 383   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 384   ${WRITABLE_RODATA-${RODATA}}
 385   .rodata1      ${RELOCATING-0} : { *(.rodata1) }
 386   ${CREATE_SHLIB-${SDATA2}}
 387   ${CREATE_SHLIB-${SBSS2}}
 388   ${OTHER_READONLY_SECTIONS}
 389   .eh_frame_hdr : { *(.eh_frame_hdr) }
 390   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 391   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
 392
 393   /* Adjust the address for the data segment.  We want to adjust up to
 394      the same address within the page on the next page up.  */
 395   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 396   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 397   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 398
 399   /* Exception handling  */
 400   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 401   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 402
 403   /* Thread Local Storage sections  */
 404   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 405   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 406
 407   .preinit_array   ${RELOCATING-0} :
 408   {
 409     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 410     KEEP (*(.preinit_array))
 411     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 412   }
 413   .init_array   ${RELOCATING-0} :
 414   {
 415      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
 416      KEEP (*(SORT(.init_array.*)))
 417      KEEP (*(.init_array))
 418      ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
 419   }
 420   .fini_array   ${RELOCATING-0} :
 421   {
 422     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
 423     KEEP (*(.fini_array))
 424     KEEP (*(SORT(.fini_array.*)))
 425     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
 426   }
 427   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 428   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 429   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 430
 431   ${RELOCATING+${DATARELRO}}
 432   ${OTHER_RELRO_SECTIONS}
 433   ${TEXT_DYNAMIC-${DYNAMIC}}
 434   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 435   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 436   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 437   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 438   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 439   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 440
 441   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 442
 443   .data         ${RELOCATING-0} :
 444   {
 445     ${RELOCATING+${DATA_START_SYMBOLS}}
 446     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 447     ${RELOCATING+KEEP (*(.gnu.linkonce.d.*personality*))}
 448     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 449   }
 450   .data1        ${RELOCATING-0} : { *(.data1) }
 451   ${WRITABLE_RODATA+${RODATA}}
 452   ${OTHER_READWRITE_SECTIONS}
 453   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 454   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 455   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 456   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS}}}
 457   ${SDATA_GOT+${GOT}}
 458   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 459   ${SDATA}
 460   ${OTHER_SDATA_SECTIONS}
 461   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 462   ${RELOCATING+__bss_start = .;}
 463   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 464   ${SBSS}
 465   ${BSS_PLT+${PLT}}
 466   .bss          ${RELOCATING-0} :
 467   {
 468    *(.dynbss)
 469    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
 470    *(COMMON)
 471    /* Align here to ensure that the .bss section occupies space up to
 472       _end.  Align after .bss to ensure correct alignment even if the
 473       .bss section disappears because there are no input sections.
 474       FIXME: Why do we need it? When there is no .bss section, we don't
 475       pad the .data section.  */
 476    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 477   }
 478   ${OTHER_BSS_SECTIONS}
 479   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 480   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 481   ${LARGE_SECTIONS}
 482   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 483   ${RELOCATING+${OTHER_END_SYMBOLS}}
 484   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 485   ${RELOCATING+${DATA_SEGMENT_END}}
 486
 487   /* Stabs debugging sections.  */
 488   .stab          0 : { *(.stab) }
 489   .stabstr       0 : { *(.stabstr) }
 490   .stab.excl     0 : { *(.stab.excl) }
 491   .stab.exclstr  0 : { *(.stab.exclstr) }
 492   .stab.index    0 : { *(.stab.index) }
 493   .stab.indexstr 0 : { *(.stab.indexstr) }
 494
 495   .comment       0 : { *(.comment) }
 496
 497   /* DWARF debug sections.
 498      Symbols in the DWARF debugging sections are relative to the beginning
 499      of the section so we begin them at 0.  */
 500
 501   /* DWARF 1 */
 502   .debug          0 : { *(.debug) }
 503   .line           0 : { *(.line) }
 504
 505   /* GNU DWARF 1 extensions */
 506   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 507   .debug_sfnames  0 : { *(.debug_sfnames) }
 508
 509   /* DWARF 1.1 and DWARF 2 */
 510   .debug_aranges  0 : { *(.debug_aranges) }
 511   .debug_pubnames 0 : { *(.debug_pubnames) }
 512
 513   /* DWARF 2 */
 514   .debug_info     0 : { *(.debug_info${RELOCATING+ .gnu.linkonce.wi.*}) }
 515   .debug_abbrev   0 : { *(.debug_abbrev) }
 516   .debug_line     0 : { *(.debug_line) }
 517   .debug_frame    0 : { *(.debug_frame) }
 518   .debug_str      0 : { *(.debug_str) }
 519   .debug_loc      0 : { *(.debug_loc) }
 520   .debug_macinfo  0 : { *(.debug_macinfo) }
 521
 522   /* SGI/MIPS DWARF 2 extensions */
 523   .debug_weaknames 0 : { *(.debug_weaknames) }
 524   .debug_funcnames 0 : { *(.debug_funcnames) }
 525   .debug_typenames 0 : { *(.debug_typenames) }
 526   .debug_varnames  0 : { *(.debug_varnames) }
 527
 528   /* DWARF 3 */
 529   .debug_pubtypes 0 : { *(.debug_pubtypes) }
 530   .debug_ranges   0 : { *(.debug_ranges) }
 531
 532   ${TINY_DATA_SECTION}
 533   ${TINY_BSS_SECTION}
 534
 535   ${STACK_ADDR+${STACK}}
 536   ${OTHER_SECTIONS}
 537   ${RELOCATING+${OTHER_SYMBOLS}}
 538   ${RELOCATING+${STACKNOTE}}
 539 }
 540 EOF