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