[thirdparty/binutils-gdb.git] / ld / scripttempl / elfxtensa.sc

#
# Unusual variables checked by this code:
#	NOP - four byte opcode for no-op (defaults to 0)
#	NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
#		empty.
#	DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
#	INITIAL_READONLY_SECTIONS - at start of text segment
#	OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
#		(e.g., .PARISC.milli)
#	OTHER_TEXT_SECTIONS - these get put in .text when relocating
#	OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
#		(e.g., .PARISC.global)
#	OTHER_RELRO_SECTIONS - other than .data.rel.ro ...
#		(e.g. PPC32 .fixup, .got[12])
#	OTHER_BSS_SECTIONS - other than .bss .sbss ...
#	OTHER_SECTIONS - at the end
#	EXECUTABLE_SYMBOLS - symbols that must be defined for an
#		executable (e.g., _DYNAMIC_LINK)
#	TEXT_START_SYMBOLS - symbols that appear at the start of the
#		.text section.
#	DATA_START_SYMBOLS - symbols that appear at the start of the
#		.data section.
#	OTHER_GOT_SYMBOLS - symbols defined just before .got.
#	OTHER_GOT_SECTIONS - sections just after .got.
#	OTHER_SDATA_SECTIONS - sections just after .sdata.
#	OTHER_BSS_SYMBOLS - symbols that appear at the start of the
#		.bss section besides __bss_start.
#	TEXT_DYNAMIC - .dynamic in text segment, not data segment.
#	EMBEDDED - whether this is for an embedded system. 
#	SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
#		start address of shared library.
#	INPUT_FILES - INPUT command of files to always include
#	WRITABLE_RODATA - if set, the .rodata section should be writable
#	INIT_START, INIT_END -  statements just before and just after
# 	combination of .init sections.
#	FINI_START, FINI_END - statements just before and just after
# 	combination of .fini sections.
#	STACK_ADDR - start of a .stack section.
#	OTHER_END_SYMBOLS - symbols to place right at the end of the script.
#
# When adding sections, do note that the names of some sections are used
# when specifying the start address of the next.
#

#  Many sections come in three flavours.  There is the 'real' section,
#  like ".data".  Then there are the per-procedure or per-variable
#  sections, generated by -ffunction-sections and -fdata-sections in GCC,
#  and useful for --gc-sections, which for a variable "foo" might be
#  ".data.foo".  Then there are the linkonce sections, for which the linker
#  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
#  The exact correspondences are:
#
#  Section	Linkonce section
#  .text	.gnu.linkonce.t.foo
#  .rodata	.gnu.linkonce.r.foo
#  .data	.gnu.linkonce.d.foo
#  .bss		.gnu.linkonce.b.foo
#  .sdata	.gnu.linkonce.s.foo
#  .sbss	.gnu.linkonce.sb.foo
#  .sdata2	.gnu.linkonce.s2.foo
#  .sbss2	.gnu.linkonce.sb2.foo
#  .debug_info	.gnu.linkonce.wi.foo
#  .tdata	.gnu.linkonce.td.foo
#  .tbss	.gnu.linkonce.tb.foo
#
#  Each of these can also have corresponding .rel.* and .rela.* sections.

test -z "$ENTRY" && ENTRY=_start
test -z "${ELFSIZE}" && ELFSIZE=32
test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
test "$LD_FLAG" = "N" && DATA_ADDR=.
test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
DATA_SEGMENT_RELRO_END=""
DATA_SEGMENT_END=""
if test -n "${COMMONPAGESIZE}"; then
  DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
  DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
  DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (.);"
fi
INTERP=".interp       ${RELOCATING-0} : { *(.interp) }"
if test -z "$GOT"; then
    GOT=".got          ${RELOCATING-0} : { *(.got) }"
fi
DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
DATARELRO=".data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }"
STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
INIT_LIT=".init.literal 0 : { *(.init.literal)	}"
INIT=".init         0 : { *(.init)		}"
FINI_LIT=".fini.literal 0 : { *(.fini.literal)	}"
FINI=".fini         0 : { *(.fini)		}"
if test -z "${NO_SMALL_DATA}"; then
  SBSS=".sbss         ${RELOCATING-0} :
  {
    ${RELOCATING+PROVIDE (__sbss_start = .);}
    ${RELOCATING+PROVIDE (___sbss_start = .);}
    *(.dynsbss)
    *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
    *(.scommon)
    ${RELOCATING+PROVIDE (__sbss_end = .);}
    ${RELOCATING+PROVIDE (___sbss_end = .);}
  }"
  SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
  SDATA="/* We want the small data sections together, so single-instruction offsets
     can access them all, and initialized data all before uninitialized, so
     we can shorten the on-disk segment size.  */
  .sdata        ${RELOCATING-0} : 
  {
    ${RELOCATING+${SDATA_START_SYMBOLS}}
    *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
  }"
  SDATA2=".sdata2       ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }"
  REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
  .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
  REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
  .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
  REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
  .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
  REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
  .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
else
  NO_SMALL_DATA=" "
fi
CTOR=".ctors        ${CONSTRUCTING-0} : 
  {
    ${CONSTRUCTING+${CTOR_START}}
    /* gcc uses crtbegin.o to find the start of
       the constructors, so we make sure it is
       first.  Because this is a wildcard, it
       doesn't matter if the user does not
       actually link against crtbegin.o; the
       linker won't look for a file to match a
       wildcard.  The wildcard also means that it
       doesn't matter which directory crtbegin.o
       is in.  */

    KEEP (*crtbegin*.o(.ctors))

    /* We don't want to include the .ctor section from
       from the crtend.o file until after the sorted ctors.
       The .ctor section from the crtend file contains the
       end of ctors marker and it must be last */

    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .ctors))
    KEEP (*(SORT(.ctors.*)))
    KEEP (*(.ctors))
    ${CONSTRUCTING+${CTOR_END}}
  }"
DTOR=".dtors        ${CONSTRUCTING-0} :
  {
    ${CONSTRUCTING+${DTOR_START}}
    KEEP (*crtbegin*.o(.dtors))
    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .dtors))
    KEEP (*(SORT(.dtors.*)))
    KEEP (*(.dtors))
    ${CONSTRUCTING+${DTOR_END}}
  }"
STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
  {
    ${RELOCATING+_stack = .;}
    *(.stack)
  }"

# if this is for an embedded system, don't add SIZEOF_HEADERS.
if [ -z "$EMBEDDED" ]; then
   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
else
   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
fi

cat <<EOF
ENTRY(${ENTRY})

${RELOCATING+${LIB_SEARCH_DIRS}}
${RELOCATING+/* Do we need any of these for elf?
   __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
${RELOCATING+${EXECUTABLE_SYMBOLS}}
${RELOCATING+${INPUT_FILES}}
${RELOCATING- /* For some reason, the Solaris linker makes bad executables
  if gld -r is used and the intermediate file has sections starting
  at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
  bug.  But for now assigning the zero vmas works.  */}

SECTIONS
{
  /* Read-only sections, merged into text segment: */
  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
  ${CREATE_SHLIB-${INTERP}}
  ${INITIAL_READONLY_SECTIONS}
  ${TEXT_DYNAMIC+${DYNAMIC}}
  .hash         ${RELOCATING-0} : { *(.hash) }
  .dynsym       ${RELOCATING-0} : { *(.dynsym) }
  .dynstr       ${RELOCATING-0} : { *(.dynstr) }
  .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
  .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
  .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }

EOF
if [ "x$COMBRELOC" = x ]; then
  COMBRELOCCAT=cat
else
  COMBRELOCCAT="cat > $COMBRELOC"
fi
eval $COMBRELOCCAT <<EOF
  .rel.init     ${RELOCATING-0} : { *(.rel.init) }
  .rela.init    ${RELOCATING-0} : { *(.rela.init) }
  .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
  .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
  .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
  .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
  .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
  .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
  ${OTHER_READONLY_RELOC_SECTIONS}
  .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }
  .rela.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+*}) }
  .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
  .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
  .rel.tdata	${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
  .rela.tdata	${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
  .rel.tbss	${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
  .rela.tbss	${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
  .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
  .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
  .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
  .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
  .rel.got      ${RELOCATING-0} : { *(.rel.got) }
  .rela.got     ${RELOCATING-0} : { *(.rela.got) }
  ${OTHER_GOT_RELOC_SECTIONS}
  ${REL_SDATA}
  ${REL_SBSS}
  ${REL_SDATA2}
  ${REL_SBSS2}
  .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
  .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
EOF
if [ -n "$COMBRELOC" ]; then
cat <<EOF
  .rel.dyn      ${RELOCATING-0} :
    {
EOF
sed -e '/^[ 	]*[{}][ 	]*$/d;/:[ 	]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
cat <<EOF
    }
  .rela.dyn     ${RELOCATING-0} :
    {
EOF
sed -e '/^[ 	]*[{}][ 	]*$/d;/:[ 	]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
cat <<EOF
    }
EOF
fi
cat <<EOF
  .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
  .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
  ${OTHER_PLT_RELOC_SECTIONS}

  ${RELOCATING-$INIT_LIT}
  ${RELOCATING-$INIT}

  .text         ${RELOCATING-0} :
  {
    *(.got.plt* .plt*)

    ${RELOCATING+${INIT_START}}
    ${RELOCATING+KEEP (*(.init.literal))}
    ${RELOCATING+KEEP (*(.init))}
    ${RELOCATING+${INIT_END}}

    ${RELOCATING+${TEXT_START_SYMBOLS}}
    *(.literal .text .stub${RELOCATING+ .text.* .gnu.linkonce.literal.* .gnu.linkonce.t.*.literal .gnu.linkonce.t.*})
    KEEP (*(.text.*personality*))
    /* .gnu.warning sections are handled specially by elf32.em.  */
    *(.gnu.warning)
    ${RELOCATING+${OTHER_TEXT_SECTIONS}}

    ${RELOCATING+${FINI_START}}
    ${RELOCATING+KEEP (*(.fini.literal))}
    ${RELOCATING+KEEP (*(.fini))}
    ${RELOCATING+${FINI_END}}
  } =${NOP-0}

  ${RELOCATING-$FINI_LIT}
  ${RELOCATING-$FINI}

  ${RELOCATING+PROVIDE (__etext = .);}
  ${RELOCATING+PROVIDE (_etext = .);}
  ${RELOCATING+PROVIDE (etext = .);}
  ${WRITABLE_RODATA-${RODATA}}
  .rodata1      ${RELOCATING-0} : { *(.rodata1) }
  ${CREATE_SHLIB-${SDATA2}}
  ${CREATE_SHLIB-${SBSS2}}
  ${OTHER_READONLY_SECTIONS}
  .eh_frame_hdr : { *(.eh_frame_hdr) }
  .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }

  /* Adjust the address for the data segment.  We want to adjust up to
     the same address within the page on the next page up.  */
  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}

  /* Exception handling  */
  .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }

  /* Thread Local Storage sections  */
  .tdata	${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
  .tbss		${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }

  /* Ensure the __preinit_array_start label is properly aligned.  We
     could instead move the label definition inside the section, but
     the linker would then create the section even if it turns out to
     be empty, which isn't pretty.  */
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_start = .);}}
  .preinit_array   ${RELOCATING-0} : { KEEP (*(.preinit_array)) }
  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}

  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_start = .);}}
  .init_array   ${RELOCATING-0} : { KEEP (*(.init_array)) }
  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_end = .);}}

  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_start = .);}}
  .fini_array   ${RELOCATING-0} : { KEEP (*(.fini_array)) }
  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_end = .);}}

  ${RELOCATING+${CTOR}}
  ${RELOCATING+${DTOR}}
  .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }

  ${RELOCATING+${DATARELRO}}
  ${OTHER_RELRO_SECTIONS}
  ${TEXT_DYNAMIC-${DYNAMIC}}
  ${NO_SMALL_DATA+${GOT}}
  ${RELOCATING+${DATA_SEGMENT_RELRO_END}}

  .data         ${RELOCATING-0} :
  {
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
    KEEP (*(.gnu.linkonce.d.*personality*))
    ${CONSTRUCTING+SORT(CONSTRUCTORS)}
  }
  .data1        ${RELOCATING-0} : { *(.data1) }
  ${WRITABLE_RODATA+${RODATA}}
  ${OTHER_READWRITE_SECTIONS}
  ${RELOCATING+${OTHER_GOT_SYMBOLS}}
  ${NO_SMALL_DATA-${GOT}}
  ${OTHER_GOT_SECTIONS}
  ${CREATE_SHLIB+${SDATA2}}
  ${CREATE_SHLIB+${SBSS2}}
  ${SDATA}
  ${OTHER_SDATA_SECTIONS}
  ${RELOCATING+_edata = .;}
  ${RELOCATING+PROVIDE (edata = .);}
  ${RELOCATING+__bss_start = .;}
  ${RELOCATING+${OTHER_BSS_SYMBOLS}}
  ${SBSS}
  .bss          ${RELOCATING-0} :
  {
   *(.dynbss)
   *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
   *(COMMON)
   /* Align here to ensure that the .bss section occupies space up to
      _end.  Align after .bss to ensure correct alignment even if the
      .bss section disappears because there are no input sections.  */
   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  }
  ${OTHER_BSS_SECTIONS}
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+_end = .;}
  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
  ${RELOCATING+PROVIDE (end = .);}
  ${RELOCATING+${DATA_SEGMENT_END}}

  /* Stabs debugging sections.  */
  .stab          0 : { *(.stab) }
  .stabstr       0 : { *(.stabstr) }
  .stab.excl     0 : { *(.stab.excl) }
  .stab.exclstr  0 : { *(.stab.exclstr) }
  .stab.index    0 : { *(.stab.index) }
  .stab.indexstr 0 : { *(.stab.indexstr) }

  .comment       0 : { *(.comment) }

  /* DWARF debug sections.
     Symbols in the DWARF debugging sections are relative to the beginning
     of the section so we begin them at 0.  */

  /* DWARF 1 */
  .debug          0 : { *(.debug) }
  .line           0 : { *(.line) }

  /* GNU DWARF 1 extensions */
  .debug_srcinfo  0 : { *(.debug_srcinfo) }
  .debug_sfnames  0 : { *(.debug_sfnames) }

  /* DWARF 1.1 and DWARF 2 */
  .debug_aranges  0 : { *(.debug_aranges) }
  .debug_pubnames 0 : { *(.debug_pubnames) }

  /* DWARF 2 */
  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
  .debug_abbrev   0 : { *(.debug_abbrev) }
  .debug_line     0 : { *(.debug_line) }
  .debug_frame    0 : { *(.debug_frame) }
  .debug_str      0 : { *(.debug_str) }
  .debug_loc      0 : { *(.debug_loc) }
  .debug_macinfo  0 : { *(.debug_macinfo) }

  /* SGI/MIPS DWARF 2 extensions */
  .debug_weaknames 0 : { *(.debug_weaknames) }
  .debug_funcnames 0 : { *(.debug_funcnames) }
  .debug_typenames 0 : { *(.debug_typenames) }
  .debug_varnames  0 : { *(.debug_varnames) }

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