[deliverable/binutils-gdb.git] / ld / scripttempl / elf.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_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.
#	DATA_PLT - .plt should be in data segment, not text segment.
#	BSS_PLT - .plt should be in bss segment
#	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 "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
test -z "${ELFSIZE}" && ELFSIZE=32
test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
test "$LD_FLAG" = "N" && DATA_ADDR=.
test -n "$CREATE_SHLIB" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
test -z "$CREATE_SHLIB" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
DATA_SEGMENT_ALIGN="ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))"
DATA_SEGMENT_END=""
if test -n "${COMMONPAGESIZE}"; then
  DATA_SEGMENT_ALIGN="DATA_SEGMENT_ALIGN(${MAXPAGESIZE}, ${COMMONPAGESIZE})"
  DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
fi
INTERP=".interp       ${RELOCATING-0} : { *(.interp) }"
PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
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.*}) }"
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
OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	      "${LITTLE_OUTPUT_FORMAT}")
OUTPUT_ARCH(${OUTPUT_ARCH})
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-${RELOCATING+. = ${TEXT_BASE_ADDRESS};}}
  ${CREATE_SHLIB+${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     ${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}

  .init         ${RELOCATING-0} : 
  { 
    ${RELOCATING+${INIT_START}}
    KEEP (*(.init))
    ${RELOCATING+${INIT_END}}
  } =${NOP-0}

  ${DATA_PLT-${BSS_PLT-${PLT}}}
  .text         ${RELOCATING-0} :
  {
    ${RELOCATING+${TEXT_START_SYMBOLS}}
    *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
    /* .gnu.warning sections are handled specially by elf32.em.  */
    *(.gnu.warning)
    ${RELOCATING+${OTHER_TEXT_SECTIONS}}
  } =${NOP-0}
  .fini         ${RELOCATING-0} :
  {
    ${RELOCATING+${FINI_START}}
    KEEP (*(.fini))
    ${RELOCATING+${FINI_END}}
  } =${NOP-0}
  ${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) }

  /* 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-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}

  /* 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} : { *(.preinit_array) }
  ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}

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

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

  .data         ${RELOCATING-0} :
  {
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
    ${CONSTRUCTING+SORT(CONSTRUCTORS)}
  }
  .data1        ${RELOCATING-0} : { *(.data1) }
  .tdata	${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
  .tbss		${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*) *(.tcommon}) }
  .eh_frame     ${RELOCATING-0} : { KEEP (*(.eh_frame)) }
  .gcc_except_table ${RELOCATING-0} : { *(.gcc_except_table) }
  ${WRITABLE_RODATA+${RODATA}}
  ${OTHER_READWRITE_SECTIONS}
  ${TEXT_DYNAMIC-${DYNAMIC}}
  ${RELOCATING+${CTOR}}
  ${RELOCATING+${DTOR}}
  .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
  ${DATA_PLT+${PLT}}
  ${RELOCATING+${OTHER_GOT_SYMBOLS}}
  .got          ${RELOCATING-0} : { *(.got.plt) *(.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_PLT+${PLT}}
  .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}}
}
EOF
Commit	Line	Data
252b5132 RH	1	#
252b5132 RH	2	# Unusual variables checked by this code:
563e308f	3	# NOP - four byte opcode for no-op (defaults to 0)
48459341 L	4	# NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
48459341 L	5	# empty.
252b5132 RH	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)
904ecb2d	13	# OTHER_BSS_SECTIONS - other than .bss .sbss ...
252b5132 RH	14	# OTHER_SECTIONS - at the end
	15	# EXECUTABLE_SYMBOLS - symbols that must be defined for an
	16	# executable (e.g., _DYNAMIC_LINK)
	17	# TEXT_START_SYMBOLS - symbols that appear at the start of the
	18	# .text section.
	19	# DATA_START_SYMBOLS - symbols that appear at the start of the
	20	# .data section.
	21	# OTHER_GOT_SYMBOLS - symbols defined just before .got.
5253f23b AM	22	# OTHER_GOT_SECTIONS - sections just after .got.
5253f23b AM	23	# OTHER_SDATA_SECTIONS - sections just after .sdata.
252b5132 RH	24	# OTHER_BSS_SYMBOLS - symbols that appear at the start of the
	25	# .bss section besides __bss_start.
	26	# DATA_PLT - .plt should be in data segment, not text segment.
6c86c541	27	# BSS_PLT - .plt should be in bss segment
252b5132 RH	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
a8e53fb0	33	# WRITABLE_RODATA - if set, the .rodata section should be writable
904ecb2d JL	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.
465bc359 AM	38	# STACK_ADDR - start of a .stack section.
465bc359 AM	39	# OTHER_END_SYMBOLS - symbols to place right at the end of the script.
252b5132 RH	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
d73e9da0 AS	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
465bc359	62	# .debug_info .gnu.linkonce.wi.foo
13ae64f3 JJ	63	# .tdata .gnu.linkonce.td.foo
13ae64f3 JJ	64	# .tbss .gnu.linkonce.tb.foo
d73e9da0 AS	65	#
d73e9da0 AS	66	# Each of these can also have corresponding .rel.* and .rela.* sections.
9ac4db9c	67
252b5132 RH	68	test -z "$ENTRY" && ENTRY=_start
	69	test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	70	test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	71	if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
	72	test -z "${ELFSIZE}" && ELFSIZE=32
	73	test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
	74	test "$LD_FLAG" = "N" && DATA_ADDR=.
2d13d8c5 JJ	75	test -n "$CREATE_SHLIB" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
2d13d8c5 JJ	76	test -z "$CREATE_SHLIB" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
2d20f7bf	77	DATA_SEGMENT_ALIGN="ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))"
2d13d8c5 JJ	78	DATA_SEGMENT_END=""
2d13d8c5 JJ	79	if test -n "${COMMONPAGESIZE}"; then
2d20f7bf	80	DATA_SEGMENT_ALIGN="DATA_SEGMENT_ALIGN(${MAXPAGESIZE}, ${COMMONPAGESIZE})"
2d13d8c5	81	DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
2d20f7bf	82	fi
465bc359 AM	83	INTERP=".interp ${RELOCATING-0} : { *(.interp) }"
	84	PLT=".plt ${RELOCATING-0} : { *(.plt) }"
	85	DYNAMIC=".dynamic ${RELOCATING-0} : { *(.dynamic) }"
	86	RODATA=".rodata ${RELOCATING-0} : { (.rodata${RELOCATING+ .rodata. .gnu.linkonce.r.*}) }"
48459341 L	87	if test -z "${NO_SMALL_DATA}"; then
	88	SBSS=".sbss ${RELOCATING-0} :
	89	{
	90	${RELOCATING+PROVIDE (__sbss_start = .);}
	91	${RELOCATING+PROVIDE (___sbss_start = .);}
	92	*(.dynsbss)
	93	(.sbss${RELOCATING+ .sbss. .gnu.linkonce.sb.*})
	94	*(.scommon)
	95	${RELOCATING+PROVIDE (__sbss_end = .);}
	96	${RELOCATING+PROVIDE (___sbss_end = .);}
	97	}"
	98	SBSS2=".sbss2 ${RELOCATING-0} : { (.sbss2${RELOCATING+ .sbss2. .gnu.linkonce.sb2.*}) }"
	99	SDATA="/* We want the small data sections together, so single-instruction offsets
	100	can access them all, and initialized data all before uninitialized, so
	101	we can shorten the on-disk segment size. */
	102	.sdata ${RELOCATING-0} :
	103	{
	104	${RELOCATING+${SDATA_START_SYMBOLS}}
	105	(.sdata${RELOCATING+ .sdata. .gnu.linkonce.s.*})
	106	}"
	107	SDATA2=".sdata2 ${RELOCATING-0} : { (.sdata2${RELOCATING+ .sdata2. .gnu.linkonce.s2.*}) }"
	108	REL_SDATA=".rel.sdata ${RELOCATING-0} : { (.rel.sdata${RELOCATING+ .rel.sdata. .rel.gnu.linkonce.s.*}) }
	109	.rela.sdata ${RELOCATING-0} : { (.rela.sdata${RELOCATING+ .rela.sdata. .rela.gnu.linkonce.s.*}) }"
	110	REL_SBSS=".rel.sbss ${RELOCATING-0} : { (.rel.sbss${RELOCATING+ .rel.sbss. .rel.gnu.linkonce.sb.*}) }
	111	.rela.sbss ${RELOCATING-0} : { (.rela.sbss${RELOCATING+ .rela.sbss. .rela.gnu.linkonce.sb.*}) }"
	112	REL_SDATA2=".rel.sdata2 ${RELOCATING-0} : { (.rel.sdata2${RELOCATING+ .rel.sdata2. .rel.gnu.linkonce.s2.*}) }
	113	.rela.sdata2 ${RELOCATING-0} : { (.rela.sdata2${RELOCATING+ .rela.sdata2. .rela.gnu.linkonce.s2.*}) }"
	114	REL_SBSS2=".rel.sbss2 ${RELOCATING-0} : { (.rel.sbss2${RELOCATING+ .rel.sbss2. .rel.gnu.linkonce.sb2.*}) }
	115	.rela.sbss2 ${RELOCATING-0} : { (.rela.sbss2${RELOCATING+ .rela.sbss2. .rela.gnu.linkonce.sb2.*}) }"
	116	fi
465bc359	117	CTOR=".ctors ${CONSTRUCTING-0} :
252b5132 RH	118	{
	119	${CONSTRUCTING+${CTOR_START}}
	120	/* gcc uses crtbegin.o to find the start of
	121	the constructors, so we make sure it is
	122	first. Because this is a wildcard, it
	123	doesn't matter if the user does not
	124	actually link against crtbegin.o; the
	125	linker won't look for a file to match a
	126	wildcard. The wildcard also means that it
	127	doesn't matter which directory crtbegin.o
	128	is in. */
	129
	130	KEEP (*crtbegin.o(.ctors))
	131
	132	/* We don't want to include the .ctor section from
	133	from the crtend.o file until after the sorted ctors.
	134	The .ctor section from the crtend file contains the
	135	end of ctors marker and it must be last */
	136
18625d54	137	KEEP ((EXCLUDE_FILE (crtend.o $OTHER_EXCLUDE_FILES) .ctors))
252b5132 RH	138	KEEP ((SORT(.ctors.)))
	139	KEEP (*(.ctors))
	140	${CONSTRUCTING+${CTOR_END}}
	141	}"
465bc359	142	DTOR=".dtors ${CONSTRUCTING-0} :
252b5132 RH	143	{
	144	${CONSTRUCTING+${DTOR_START}}
	145	KEEP (*crtbegin.o(.dtors))
18625d54	146	KEEP ((EXCLUDE_FILE (crtend.o $OTHER_EXCLUDE_FILES) .dtors))
252b5132 RH	147	KEEP ((SORT(.dtors.)))
	148	KEEP (*(.dtors))
	149	${CONSTRUCTING+${DTOR_END}}
	150	}"
465bc359 AM	151	STACK=" .stack ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
	152	{
	153	${RELOCATING+_stack = .;}
	154	*(.stack)
	155	}"
252b5132 RH	156
	157	# if this is for an embedded system, don't add SIZEOF_HEADERS.
	158	if [ -z "$EMBEDDED" ]; then
	159	test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
	160	else
	161	test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
	162	fi
	163
	164	cat <<EOF
	165	OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	166	"${LITTLE_OUTPUT_FORMAT}")
	167	OUTPUT_ARCH(${OUTPUT_ARCH})
	168	ENTRY(${ENTRY})
	169
	170	${RELOCATING+${LIB_SEARCH_DIRS}}
	171	${RELOCATING+/* Do we need any of these for elf?
	172	__DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}} */}
	173	${RELOCATING+${EXECUTABLE_SYMBOLS}}
	174	${RELOCATING+${INPUT_FILES}}
	175	${RELOCATING- /* For some reason, the Solaris linker makes bad executables
	176	if gld -r is used and the intermediate file has sections starting
	177	at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld
	178	bug. But for now assigning the zero vmas works. */}
	179
	180	SECTIONS
	181	{
	182	/* Read-only sections, merged into text segment: */
	183	${CREATE_SHLIB-${RELOCATING+. = ${TEXT_BASE_ADDRESS};}}
	184	${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
	185	${CREATE_SHLIB-${INTERP}}
	186	${INITIAL_READONLY_SECTIONS}
	187	${TEXT_DYNAMIC+${DYNAMIC}}
465bc359 AM	188	.hash ${RELOCATING-0} : { *(.hash) }
	189	.dynsym ${RELOCATING-0} : { *(.dynsym) }
	190	.dynstr ${RELOCATING-0} : { *(.dynstr) }
	191	.gnu.version ${RELOCATING-0} : { *(.gnu.version) }
	192	.gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
	193	.gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
9e4141bc	194
db6751f2 JJ	195	EOF
	196	if [ "x$COMBRELOC" = x ]; then
	197	COMBRELOCCAT=cat
	198	else
	199	COMBRELOCCAT="cat > $COMBRELOC"
	200	fi
	201	eval $COMBRELOCCAT <<EOF
465bc359 AM	202	.rel.init ${RELOCATING-0} : { *(.rel.init) }
	203	.rela.init ${RELOCATING-0} : { *(.rela.init) }
	204	.rel.text ${RELOCATING-0} : { (.rel.text${RELOCATING+ .rel.text. .rel.gnu.linkonce.t.*}) }
	205	.rela.text ${RELOCATING-0} : { (.rela.text${RELOCATING+ .rela.text. .rela.gnu.linkonce.t.*}) }
	206	.rel.fini ${RELOCATING-0} : { *(.rel.fini) }
	207	.rela.fini ${RELOCATING-0} : { *(.rela.fini) }
	208	.rel.rodata ${RELOCATING-0} : { (.rel.rodata${RELOCATING+ .rel.rodata. .rel.gnu.linkonce.r.*}) }
	209	.rela.rodata ${RELOCATING-0} : { (.rela.rodata${RELOCATING+ .rela.rodata. .rela.gnu.linkonce.r.*}) }
9e4141bc	210	${OTHER_READONLY_RELOC_SECTIONS}
465bc359 AM	211	.rel.data ${RELOCATING-0} : { (.rel.data${RELOCATING+ .rel.data. .rel.gnu.linkonce.d.*}) }
465bc359 AM	212	.rela.data ${RELOCATING-0} : { (.rela.data${RELOCATING+ .rela.data. .rela.gnu.linkonce.d.*}) }
13ae64f3 JJ	213	.rel.tdata ${RELOCATING-0} : { (.rel.tdata${RELOCATING+ .rel.tdata. .rel.gnu.linkonce.td.*}) }
	214	.rela.tdata ${RELOCATING-0} : { (.rela.tdata${RELOCATING+ .rela.tdata. .rela.gnu.linkonce.td.*}) }
	215	.rel.tbss ${RELOCATING-0} : { (.rel.tbss${RELOCATING+ .rel.tbss. .rel.gnu.linkonce.tb.*}) }
	216	.rela.tbss ${RELOCATING-0} : { (.rela.tbss${RELOCATING+ .rela.tbss. .rela.gnu.linkonce.tb.*}) }
465bc359 AM	217	.rel.ctors ${RELOCATING-0} : { *(.rel.ctors) }
	218	.rela.ctors ${RELOCATING-0} : { *(.rela.ctors) }
	219	.rel.dtors ${RELOCATING-0} : { *(.rel.dtors) }
	220	.rela.dtors ${RELOCATING-0} : { *(.rela.dtors) }
	221	.rel.got ${RELOCATING-0} : { *(.rel.got) }
	222	.rela.got ${RELOCATING-0} : { *(.rela.got) }
9e4141bc	223	${OTHER_GOT_RELOC_SECTIONS}
48459341 L	224	${REL_SDATA}
	225	${REL_SBSS}
	226	${REL_SDATA2}
	227	${REL_SBSS2}
465bc359 AM	228	.rel.bss ${RELOCATING-0} : { (.rel.bss${RELOCATING+ .rel.bss. .rel.gnu.linkonce.b.*}) }
465bc359 AM	229	.rela.bss ${RELOCATING-0} : { (.rela.bss${RELOCATING+ .rela.bss. .rela.gnu.linkonce.b.*}) }
db6751f2 JJ	230	EOF
	231	if [ -n "$COMBRELOC" ]; then
	232	cat <<EOF
465bc359	233	.rel.dyn ${RELOCATING-0} :
db6751f2 JJ	234	{
	235	EOF
	236	sed -e '/^[ ][{}][ ]$/d;/:[ ]$/d;/\.rela\./d;s/^.: { \(.\)}$/ \1/' $COMBRELOC
	237	cat <<EOF
	238	}
465bc359	239	.rela.dyn ${RELOCATING-0} :
db6751f2 JJ	240	{
	241	EOF
	242	sed -e '/^[ ][{}][ ]$/d;/:[ ]$/d;/\.rel\./d;s/^.: { \(.\)}/ \1/' $COMBRELOC
	243	cat <<EOF
	244	}
	245	EOF
	246	fi
	247	cat <<EOF
465bc359 AM	248	.rel.plt ${RELOCATING-0} : { *(.rel.plt) }
465bc359 AM	249	.rela.plt ${RELOCATING-0} : { *(.rela.plt) }
9e673ad1	250	${OTHER_PLT_RELOC_SECTIONS}
9e4141bc	251
465bc359	252	.init ${RELOCATING-0} :
4ab10e93	253	{
53db15ed	254	${RELOCATING+${INIT_START}}
4ab10e93	255	KEEP (*(.init))
53db15ed	256	${RELOCATING+${INIT_END}}
4ab10e93 GK	257	} =${NOP-0}
4ab10e93 GK	258
6c86c541	259	${DATA_PLT-${BSS_PLT-${PLT}}}
465bc359	260	.text ${RELOCATING-0} :
252b5132 RH	261	{
252b5132 RH	262	${RELOCATING+${TEXT_START_SYMBOLS}}
465bc359	263	(.text .stub${RELOCATING+ .text. .gnu.linkonce.t.*})
252b5132 RH	264	/* .gnu.warning sections are handled specially by elf32.em. */
252b5132 RH	265	*(.gnu.warning)
252b5132 RH	266	${RELOCATING+${OTHER_TEXT_SECTIONS}}
252b5132 RH	267	} =${NOP-0}
465bc359	268	.fini ${RELOCATING-0} :
904ecb2d	269	{
53db15ed	270	${RELOCATING+${FINI_START}}
904ecb2d	271	KEEP (*(.fini))
53db15ed	272	${RELOCATING+${FINI_END}}
904ecb2d	273	} =${NOP-0}
6c86c541 GK	274	${RELOCATING+PROVIDE (__etext = .);}
	275	${RELOCATING+PROVIDE (_etext = .);}
	276	${RELOCATING+PROVIDE (etext = .);}
a8e53fb0	277	${WRITABLE_RODATA-${RODATA}}
465bc359	278	.rodata1 ${RELOCATING-0} : { *(.rodata1) }
6c86c541 GK	279	${CREATE_SHLIB-${SDATA2}}
6c86c541 GK	280	${CREATE_SHLIB-${SBSS2}}
465bc359	281	${OTHER_READONLY_SECTIONS}
65765700	282	.eh_frame_hdr : { *(.eh_frame_hdr) }
252b5132 RH	283
	284	/* Adjust the address for the data segment. We want to adjust up to
	285	the same address within the page on the next page up. */
2d20f7bf JJ	286	${CREATE_SHLIB-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
2d20f7bf JJ	287	${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
252b5132	288
b5090659 L	289	/* Ensure the __preinit_array_start label is properly aligned. We
	290	could instead move the label definition inside the section, but
	291	the linker would then create the section even if it turns out to
	292	be empty, which isn't pretty. */
	293	${RELOCATING+. = ALIGN(${ALIGNMENT});}
	294	${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_start = .);}}
	295	.preinit_array ${RELOCATING-0} : { *(.preinit_array) }
	296	${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}
	297
	298	${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_start = .);}}
	299	.init_array ${RELOCATING-0} : { *(.init_array) }
	300	${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_end = .);}}
	301
	302	${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_start = .);}}
	303	.fini_array ${RELOCATING-0} : { *(.fini_array) }
	304	${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_end = .);}}
	305
465bc359	306	.data ${RELOCATING-0} :
252b5132 RH	307	{
252b5132 RH	308	${RELOCATING+${DATA_START_SYMBOLS}}
465bc359	309	(.data${RELOCATING+ .data. .gnu.linkonce.d.*})
252b5132 RH	310	${CONSTRUCTING+SORT(CONSTRUCTORS)}
252b5132 RH	311	}
465bc359	312	.data1 ${RELOCATING-0} : { *(.data1) }
13ae64f3 JJ	313	.tdata ${RELOCATING-0} : { (.tdata${RELOCATING+ .tdata. .gnu.linkonce.td.*}) }
13ae64f3 JJ	314	.tbss ${RELOCATING-0} : { (.tbss${RELOCATING+ .tbss. .gnu.linkonce.tb.) (.tcommon}) }
465bc359 AM	315	.eh_frame ${RELOCATING-0} : { KEEP (*(.eh_frame)) }
465bc359 AM	316	.gcc_except_table ${RELOCATING-0} : { *(.gcc_except_table) }
a8e53fb0	317	${WRITABLE_RODATA+${RODATA}}
465bc359	318	${OTHER_READWRITE_SECTIONS}
5253f23b	319	${TEXT_DYNAMIC-${DYNAMIC}}
252b5132 RH	320	${RELOCATING+${CTOR}}
252b5132 RH	321	${RELOCATING+${DTOR}}
465bc359	322	.jcr ${RELOCATING-0} : { KEEP (*(.jcr)) }
252b5132 RH	323	${DATA_PLT+${PLT}}
252b5132 RH	324	${RELOCATING+${OTHER_GOT_SYMBOLS}}
465bc359 AM	325	.got ${RELOCATING-0} : { (.got.plt) (.got) }
465bc359 AM	326	${OTHER_GOT_SECTIONS}
6c86c541 GK	327	${CREATE_SHLIB+${SDATA2}}
6c86c541 GK	328	${CREATE_SHLIB+${SBSS2}}
48459341	329	${SDATA}
465bc359	330	${OTHER_SDATA_SECTIONS}
9e4141bc	331	${RELOCATING+_edata = .;}
252b5132 RH	332	${RELOCATING+PROVIDE (edata = .);}
	333	${RELOCATING+__bss_start = .;}
	334	${RELOCATING+${OTHER_BSS_SYMBOLS}}
48459341	335	${SBSS}
6c86c541	336	${BSS_PLT+${PLT}}
465bc359	337	.bss ${RELOCATING-0} :
252b5132 RH	338	{
252b5132 RH	339	*(.dynbss)
465bc359	340	(.bss${RELOCATING+ .bss. .gnu.linkonce.b.*})
252b5132 RH	341	*(COMMON)
	342	/* Align here to ensure that the .bss section occupies space up to
	343	_end. Align after .bss to ensure correct alignment even if the
	344	.bss section disappears because there are no input sections. */
	345	${RELOCATING+. = ALIGN(${ALIGNMENT});}
	346	}
465bc359	347	${OTHER_BSS_SECTIONS}
252b5132	348	${RELOCATING+. = ALIGN(${ALIGNMENT});}
9e4141bc	349	${RELOCATING+_end = .;}
252b5132 RH	350	${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
252b5132 RH	351	${RELOCATING+PROVIDE (end = .);}
2d13d8c5	352	${RELOCATING+${DATA_SEGMENT_END}}
252b5132 RH	353
252b5132 RH	354	/* Stabs debugging sections. */
465bc359 AM	355	.stab 0 : { *(.stab) }
	356	.stabstr 0 : { *(.stabstr) }
	357	.stab.excl 0 : { *(.stab.excl) }
	358	.stab.exclstr 0 : { *(.stab.exclstr) }
	359	.stab.index 0 : { *(.stab.index) }
252b5132 RH	360	.stab.indexstr 0 : { *(.stab.indexstr) }
252b5132 RH	361
465bc359	362	.comment 0 : { *(.comment) }
252b5132 RH	363
	364	/* DWARF debug sections.
	365	Symbols in the DWARF debugging sections are relative to the beginning
	366	of the section so we begin them at 0. */
	367
	368	/* DWARF 1 */
	369	.debug 0 : { *(.debug) }
	370	.line 0 : { *(.line) }
	371
	372	/* GNU DWARF 1 extensions */
	373	.debug_srcinfo 0 : { *(.debug_srcinfo) }
	374	.debug_sfnames 0 : { *(.debug_sfnames) }
	375
	376	/* DWARF 1.1 and DWARF 2 */
	377	.debug_aranges 0 : { *(.debug_aranges) }
	378	.debug_pubnames 0 : { *(.debug_pubnames) }
	379
	380	/* DWARF 2 */
465bc359	381	.debug_info 0 : { (.debug_info .gnu.linkonce.wi.) }
252b5132 RH	382	.debug_abbrev 0 : { *(.debug_abbrev) }
	383	.debug_line 0 : { *(.debug_line) }
	384	.debug_frame 0 : { *(.debug_frame) }
	385	.debug_str 0 : { *(.debug_str) }
	386	.debug_loc 0 : { *(.debug_loc) }
	387	.debug_macinfo 0 : { *(.debug_macinfo) }
	388
	389	/* SGI/MIPS DWARF 2 extensions */
	390	.debug_weaknames 0 : { *(.debug_weaknames) }
	391	.debug_funcnames 0 : { *(.debug_funcnames) }
	392	.debug_typenames 0 : { *(.debug_typenames) }
	393	.debug_varnames 0 : { *(.debug_varnames) }
	394
465bc359	395	${STACK_ADDR+${STACK}}
252b5132	396	${OTHER_SECTIONS}
465bc359	397	${RELOCATING+${OTHER_END_SYMBOLS}}
252b5132 RH	398	}
252b5132 RH	399	EOF