[deliverable/binutils-gdb.git] / ld / scripttempl / armbpabi.sc

# This variant of elf.sc is used for ARM BPABI platforms, like Symbian
# OS, where a separate postlinker will operated on the generated
# executable or shared object.

#
# 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_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.
#	PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.
#	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.
#	SEPARATE_GOTPLT - if set, .got.plt should be separate output section,
#		so that .got can be in the RELRO area.  It should be set to
#		the number of bytes in the beginning of .got.plt which can be
#		in the RELRO area as well.
#
# 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$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
DATA_SEGMENT_RELRO_END=""
DATA_SEGMENT_RELRO_GOTPLT_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 (.);"
  if test -n "${SEPARATE_GOTPLT}"; then
    DATA_SEGMENT_RELRO_GOTPLT_END=". = DATA_SEGMENT_RELRO_END (. + ${SEPARATE_GOTPLT});"
  else
    DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (.);"
  fi
fi
INTERP=".interp       0 : { *(.interp) }"
PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
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) }"
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
test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
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-${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;}}
  ${INITIAL_READONLY_SECTIONS}

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_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.*})
    KEEP (*(.text.*personality*))
    /* .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) }
  .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} : { *(.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 = .);}}

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

  ${RELOCATING+${DATARELRO}}
  ${OTHER_RELRO_SECTIONS}
  ${RELOCATING+${DATA_SEGMENT_RELRO_END}}

  ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}

  .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}
  ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
  ${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}}

  /* These sections are not mapped under the BPABI.  */
  .dynamic      0 : { *(.dynamic) }
  .hash         0 : { *(.hash) }
  .dynsym       0 : { *(.dynsym) }
  .dynstr       0 : { *(.dynstr) }
  .gnu.version  0 : { *(.gnu.version) }
  .gnu.version_d 0: { *(.gnu.version_d) }
  .gnu.version_r 0: { *(.gnu.version_r) }
  ${CREATE_SHLIB-${INTERP}}

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