[thirdparty/binutils-gdb.git] / ld / scripttempl / elfarc.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 we request a big endian toolchain, give a big endian linker
test "${ARC_ENDIAN}" == "big" && OUTPUT_FORMAT=${BIG_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=""
DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
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 (.);"
fi
INTERP=".interp       ${RELOCATING-0} : { *(.interp) }"
PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
test -z "$GOT" && GOT=".got          ${RELOCATING-0} : {${RELOCATING+ *(.got.plt)} *(.got) }"
DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
if test -z "${NO_SMALL_DATA}"; then
  SBSS=".sbss         ${RELOCATING-0} :
  {
    ${RELOCATING+PROVIDE (__sbss_start = .);}
    ${RELOCATING+PROVIDE (___sbss_start = .);}
    ${RELOCATING+*(.dynsbss)}
    *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
    ${RELOCATING+*(.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})
${RELOCATING+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     ${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 (*(SORT_NONE(.init)))
    ${RELOCATING+${INIT_END}}
  } =${NOP-0}

  ${DATA_PLT-${BSS_PLT-${PLT}}}
  .jlitab       ${RELOCATING-0} :
  {
    ${RELOCATING+${JLI_START_TABLE}}
    ${RELOCATING+jlitab*.o(.jlitab*)}
    *(.jlitab${RELOCATING+*})
  } =${NOP-0}
  .text         ${RELOCATING-0} :
  {
    ${RELOCATING+${TEXT_START_SYMBOLS}}
    *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
    /* .gnu.warning sections are handled specially by elf.em.  */
    *(.gnu.warning)
    ${RELOCATING+${OTHER_TEXT_SECTIONS}}
  } =${NOP-0}
  .text.init ${RELOCATING-0} :
  {
    *(.text.init)
  } =${NOP-0}
  .fini         ${RELOCATING-0} :
  {
    ${RELOCATING+${FINI_START}}
    KEEP (*(SORT_NONE(.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 ${RELOCATING-0} : { *(.eh_frame_hdr) }
  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table${RELOCATING+ .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  */
  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table${RELOCATING+ .gcc_except_table.*}) }

  /* 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)}
  }
  .data.init  ${RELOCATING-0} :
  {
    *(.data.init)
  }
  .data1        ${RELOCATING-0} : { *(.data1) }
  .tdata	${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
  .tbss		${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.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}
  ${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} :
  {
    ${RELOCATING+*(.dynbss)}
    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
    ${RELOCATING+*(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.  */
    . = ALIGN(${ALIGNMENT});}
  }
  ${OTHER_BSS_SECTIONS}
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+_end = .;}
  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
  ${RELOCATING+PROVIDE (end = .);}
  ${RELOCATING+${DATA_SEGMENT_END}}
EOF

test -n "${RELOCATING}" && cat <<EOF
  /* We want to be able to set a default stack / heap size in a dejagnu
     board description file, but override it for selected test cases.
     The options appear in the wrong order to do this with a single symbol -
     ldflags comes after flags injected with per-file stanzas, and thus
     the setting from ldflags prevails.  */
  .heap :
  {
	__start_heap = . ;
	. = . + (DEFINED(__HEAP_SIZE) ? __HEAP_SIZE : (DEFINED(__DEFAULT_HEAP_SIZE) ? __DEFAULT_HEAP_SIZE : 20k)) ;
	__end_heap = . ;
  }

  . = ALIGN(0x8);
  .stack :
  {
	__stack = . ;
	. = . + (DEFINED(__STACK_SIZE) ? __STACK_SIZE : (DEFINED(__DEFAULT_STACK_SIZE) ? __DEFAULT_STACK_SIZE : 64k)) ;
	__stack_top = . ;
  }
EOF

cat <<EOF
  /* 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${RELOCATING+ .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) }

  /* ARC Extension Sections */
  .arcextmap	  0 : { *(.gnu.linkonce.arcextmap.*) }

  ${OTHER_SECTIONS}
  ${RELOCATING+${OTHER_END_SYMBOLS}}
  ${RELOCATING+${STACKNOTE}}
}
EOF
Commit	Line	Data
886a2506 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)
	13	# OTHER_BSS_SECTIONS - other than .bss .sbss ...
	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.
	22	# OTHER_GOT_SECTIONS - sections just after .got.
	23	# OTHER_SDATA_SECTIONS - sections just after .sdata.
	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.
	27	# BSS_PLT - .plt should be in bss segment
	28	# TEXT_DYNAMIC - .dynamic in text segment, not data segment.
6c19b93b	29	# EMBEDDED - whether this is for an embedded system.
886a2506 NC	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
6c19b93b	35	# combination of .init sections.
886a2506	36	# FINI_START, FINI_END - statements just before and just after
6c19b93b	37	# combination of .fini sections.
886a2506 NC	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 "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	70	test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	71	# If we request a big endian toolchain, give a big endian linker
	72	test "${ARC_ENDIAN}" == "big" && OUTPUT_FORMAT=${BIG_OUTPUT_FORMAT}
	73	if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
	74	test -z "${ELFSIZE}" && ELFSIZE=32
	75	test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
	76	test "$LD_FLAG" = "N" && DATA_ADDR=.
	77	test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
	78	test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
	79	DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
	80	DATA_SEGMENT_END=""
	81	if test -n "${COMMONPAGESIZE}"; then
	82	DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
	83	DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
	84	fi
	85	INTERP=".interp ${RELOCATING-0} : { *(.interp) }"
	86	PLT=".plt ${RELOCATING-0} : { *(.plt) }"
2bf2bf23	87	test -z "$GOT" && GOT=".got ${RELOCATING-0} : {${RELOCATING+ (.got.plt)} (.got) }"
886a2506 NC	88	DYNAMIC=".dynamic ${RELOCATING-0} : { *(.dynamic) }"
	89	RODATA=".rodata ${RELOCATING-0} : { (.rodata${RELOCATING+ .rodata. .gnu.linkonce.r.*}) }"
	90	STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
	91	if test -z "${NO_SMALL_DATA}"; then
	92	SBSS=".sbss ${RELOCATING-0} :
	93	{
	94	${RELOCATING+PROVIDE (__sbss_start = .);}
	95	${RELOCATING+PROVIDE (___sbss_start = .);}
2bf2bf23	96	${RELOCATING+*(.dynsbss)}
886a2506	97	(.sbss${RELOCATING+ .sbss. .gnu.linkonce.sb.*})
2bf2bf23	98	${RELOCATING+*(.scommon)}
886a2506 NC	99	${RELOCATING+PROVIDE (__sbss_end = .);}
	100	${RELOCATING+PROVIDE (___sbss_end = .);}
	101	}"
	102	SBSS2=".sbss2 ${RELOCATING-0} : { (.sbss2${RELOCATING+ .sbss2. .gnu.linkonce.sb2.*}) }"
	103	SDATA="/* We want the small data sections together, so single-instruction offsets
	104	can access them all, and initialized data all before uninitialized, so
	105	we can shorten the on-disk segment size. */
6c19b93b	106	.sdata ${RELOCATING-0} :
886a2506 NC	107	{
	108	${RELOCATING+${SDATA_START_SYMBOLS}}
	109	(.sdata${RELOCATING+ .sdata. .gnu.linkonce.s.*})
	110	}"
	111	SDATA2=".sdata2 ${RELOCATING-0} : { (.sdata2${RELOCATING+ .sdata2. .gnu.linkonce.s2.*}) }"
	112	REL_SDATA=".rel.sdata ${RELOCATING-0} : { (.rel.sdata${RELOCATING+ .rel.sdata. .rel.gnu.linkonce.s.*}) }
	113	.rela.sdata ${RELOCATING-0} : { (.rela.sdata${RELOCATING+ .rela.sdata. .rela.gnu.linkonce.s.*}) }"
	114	REL_SBSS=".rel.sbss ${RELOCATING-0} : { (.rel.sbss${RELOCATING+ .rel.sbss. .rel.gnu.linkonce.sb.*}) }
	115	.rela.sbss ${RELOCATING-0} : { (.rela.sbss${RELOCATING+ .rela.sbss. .rela.gnu.linkonce.sb.*}) }"
	116	REL_SDATA2=".rel.sdata2 ${RELOCATING-0} : { (.rel.sdata2${RELOCATING+ .rel.sdata2. .rel.gnu.linkonce.s2.*}) }
	117	.rela.sdata2 ${RELOCATING-0} : { (.rela.sdata2${RELOCATING+ .rela.sdata2. .rela.gnu.linkonce.s2.*}) }"
	118	REL_SBSS2=".rel.sbss2 ${RELOCATING-0} : { (.rel.sbss2${RELOCATING+ .rel.sbss2. .rel.gnu.linkonce.sb2.*}) }
	119	.rela.sbss2 ${RELOCATING-0} : { (.rela.sbss2${RELOCATING+ .rela.sbss2. .rela.gnu.linkonce.sb2.*}) }"
	120	fi
6c19b93b	121	CTOR=".ctors ${CONSTRUCTING-0} :
886a2506 NC	122	{
	123	${CONSTRUCTING+${CTOR_START}}
	124	/* gcc uses crtbegin.o to find the start of
	125	the constructors, so we make sure it is
	126	first. Because this is a wildcard, it
	127	doesn't matter if the user does not
	128	actually link against crtbegin.o; the
	129	linker won't look for a file to match a
	130	wildcard. The wildcard also means that it
	131	doesn't matter which directory crtbegin.o
	132	is in. */
	133
	134	KEEP (crtbegin.o(.ctors))
	135
	136	/* We don't want to include the .ctor section from
	137	from the crtend.o file until after the sorted ctors.
	138	The .ctor section from the crtend file contains the
	139	end of ctors marker and it must be last */
	140
	141	KEEP ((EXCLUDE_FILE (crtend*.o $OTHER_EXCLUDE_FILES) .ctors))
	142	KEEP ((SORT(.ctors.)))
	143	KEEP (*(.ctors))
	144	${CONSTRUCTING+${CTOR_END}}
	145	}"
	146	DTOR=".dtors ${CONSTRUCTING-0} :
	147	{
	148	${CONSTRUCTING+${DTOR_START}}
	149	KEEP (crtbegin.o(.dtors))
	150	KEEP ((EXCLUDE_FILE (crtend*.o $OTHER_EXCLUDE_FILES) .dtors))
	151	KEEP ((SORT(.dtors.)))
	152	KEEP (*(.dtors))
	153	${CONSTRUCTING+${DTOR_END}}
	154	}"
	155	STACK=" .stack ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
	156	{
	157	${RELOCATING+_stack = .;}
	158	*(.stack)
	159	}"
	160
	161	# if this is for an embedded system, don't add SIZEOF_HEADERS.
	162	if [ -z "$EMBEDDED" ]; then
	163	test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
	164	else
	165	test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
	166	fi
	167
	168	cat <<EOF
	169	OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	170	"${LITTLE_OUTPUT_FORMAT}")
	171	OUTPUT_ARCH(${OUTPUT_ARCH})
	172	${RELOCATING+ENTRY(${ENTRY})}
	173
	174	${RELOCATING+${LIB_SEARCH_DIRS}}
	175	${RELOCATING+/* Do we need any of these for elf?
	176	__DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}} */}
	177	${RELOCATING+${EXECUTABLE_SYMBOLS}}
	178	${RELOCATING+${INPUT_FILES}}
	179	${RELOCATING- /* For some reason, the Solaris linker makes bad executables
	180	if gld -r is used and the intermediate file has sections starting
	181	at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld
	182	bug. But for now assigning the zero vmas works. */}
	183
	184	SECTIONS
	185	{
186	/* Read-only sections, merged into text segment: */
187	${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
188	${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
189	${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
190	${CREATE_SHLIB-${INTERP}}
191	${INITIAL_READONLY_SECTIONS}
192	${TEXT_DYNAMIC+${DYNAMIC}}
193	.hash ${RELOCATING-0} : { *(.hash) }
194	.dynsym ${RELOCATING-0} : { *(.dynsym) }
195	.dynstr ${RELOCATING-0} : { *(.dynstr) }
196	.gnu.version ${RELOCATING-0} : { *(.gnu.version) }
197	.gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
198	.gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
199
200	EOF
201	if [ "x$COMBRELOC" = x ]; then
202	COMBRELOCCAT=cat
203	else
204	COMBRELOCCAT="cat > $COMBRELOC"
205	fi
206	eval $COMBRELOCCAT <<EOF
207	.rel.init ${RELOCATING-0} : { *(.rel.init) }
208	.rela.init ${RELOCATING-0} : { *(.rela.init) }
209	.rel.text ${RELOCATING-0} : { (.rel.text${RELOCATING+ .rel.text. .rel.gnu.linkonce.t.*}) }
210	.rela.text ${RELOCATING-0} : { (.rela.text${RELOCATING+ .rela.text. .rela.gnu.linkonce.t.*}) }
211	.rel.fini ${RELOCATING-0} : { *(.rel.fini) }
212	.rela.fini ${RELOCATING-0} : { *(.rela.fini) }
213	.rel.rodata ${RELOCATING-0} : { (.rel.rodata${RELOCATING+ .rel.rodata. .rel.gnu.linkonce.r.*}) }
214	.rela.rodata ${RELOCATING-0} : { (.rela.rodata${RELOCATING+ .rela.rodata. .rela.gnu.linkonce.r.*}) }
215	${OTHER_READONLY_RELOC_SECTIONS}
216	.rel.data ${RELOCATING-0} : { (.rel.data${RELOCATING+ .rel.data. .rel.gnu.linkonce.d.*}) }
217	.rela.data ${RELOCATING-0} : { (.rela.data${RELOCATING+ .rela.data. .rela.gnu.linkonce.d.*}) }
218	.rel.tdata ${RELOCATING-0} : { (.rel.tdata${RELOCATING+ .rel.tdata. .rel.gnu.linkonce.td.*}) }
219	.rela.tdata ${RELOCATING-0} : { (.rela.tdata${RELOCATING+ .rela.tdata. .rela.gnu.linkonce.td.*}) }
220	.rel.tbss ${RELOCATING-0} : { (.rel.tbss${RELOCATING+ .rel.tbss. .rel.gnu.linkonce.tb.*}) }
221	.rela.tbss ${RELOCATING-0} : { (.rela.tbss${RELOCATING+ .rela.tbss. .rela.gnu.linkonce.tb.*}) }
222	.rel.ctors ${RELOCATING-0} : { *(.rel.ctors) }
223	.rela.ctors ${RELOCATING-0} : { *(.rela.ctors) }
224	.rel.dtors ${RELOCATING-0} : { *(.rel.dtors) }
225	.rela.dtors ${RELOCATING-0} : { *(.rela.dtors) }
226	.rel.got ${RELOCATING-0} : { *(.rel.got) }
227	.rela.got ${RELOCATING-0} : { *(.rela.got) }
228	${OTHER_GOT_RELOC_SECTIONS}
229	${REL_SDATA}
230	${REL_SBSS}
231	${REL_SDATA2}
232	${REL_SBSS2}
233	.rel.bss ${RELOCATING-0} : { (.rel.bss${RELOCATING+ .rel.bss. .rel.gnu.linkonce.b.*}) }
234	.rela.bss ${RELOCATING-0} : { (.rela.bss${RELOCATING+ .rela.bss. .rela.gnu.linkonce.b.*}) }
235	EOF
236	if [ -n "$COMBRELOC" ]; then
237	cat <<EOF
238	.rel.dyn ${RELOCATING-0} :
239	{
240	EOF
6c19b93b	241	sed -e '/^[ ][{}][ ]$/d;/:[ ]$/d;/\.rela\./d;s/^.: { \(.\)}$/ \1/' $COMBRELOC
886a2506 NC	242	cat <<EOF
	243	}
	244	.rela.dyn ${RELOCATING-0} :
	245	{
	246	EOF
6c19b93b	247	sed -e '/^[ ][{}][ ]$/d;/:[ ]$/d;/\.rel\./d;s/^.: { \(.\)}/ \1/' $COMBRELOC
886a2506 NC	248	cat <<EOF
	249	}
	250	EOF
	251	fi
	252	cat <<EOF
	253	.rel.plt ${RELOCATING-0} : { *(.rel.plt) }
	254	.rela.plt ${RELOCATING-0} : { *(.rela.plt) }
	255	${OTHER_PLT_RELOC_SECTIONS}
	256
6c19b93b AM	257	.init ${RELOCATING-0} :
6c19b93b AM	258	{
886a2506	259	${RELOCATING+${INIT_START}}
2d3181c7	260	KEEP (*(SORT_NONE(.init)))
886a2506 NC	261	${RELOCATING+${INIT_END}}
	262	} =${NOP-0}
	263
	264	${DATA_PLT-${BSS_PLT-${PLT}}}
684d5a10 JEM	265	.jlitab ${RELOCATING-0} :
	266	{
	267	${RELOCATING+${JLI_START_TABLE}}
2bf2bf23 AM	268	${RELOCATING+jlitab.o(.jlitab)}
2bf2bf23 AM	269	(.jlitab${RELOCATING+})
684d5a10	270	} =${NOP-0}
886a2506 NC	271	.text ${RELOCATING-0} :
	272	{
	273	${RELOCATING+${TEXT_START_SYMBOLS}}
	274	(.text .stub${RELOCATING+ .text. .gnu.linkonce.t.*})
075a2b89	275	/* .gnu.warning sections are handled specially by elf.em. */
886a2506 NC	276	*(.gnu.warning)
	277	${RELOCATING+${OTHER_TEXT_SECTIONS}}
	278	} =${NOP-0}
	279	.text.init ${RELOCATING-0} :
	280	{
	281	*(.text.init)
	282	} =${NOP-0}
	283	.fini ${RELOCATING-0} :
	284	{
	285	${RELOCATING+${FINI_START}}
2d3181c7	286	KEEP (*(SORT_NONE(.fini)))
886a2506 NC	287	${RELOCATING+${FINI_END}}
	288	} =${NOP-0}
	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}
c2e86386	297	.eh_frame_hdr ${RELOCATING-0} : { *(.eh_frame_hdr) }
2bf2bf23	298	.gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { (.gcc_except_table${RELOCATING+ .gcc_except_table.}) }
886a2506 NC	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 */
2bf2bf23	307	.gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { (.gcc_except_table${RELOCATING+ .gcc_except_table.}) }
886a2506 NC	308
	309	/* Ensure the __preinit_array_start label is properly aligned. We
	310	could instead move the label definition inside the section, but
	311	the linker would then create the section even if it turns out to
	312	be empty, which isn't pretty. */
	313	${RELOCATING+. = ALIGN(${ALIGNMENT});}
	314	${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_start = .);}}
	315	.preinit_array ${RELOCATING-0} : { *(.preinit_array) }
	316	${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}
	317
	318	${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_start = .);}}
	319	.init_array ${RELOCATING-0} : { *(.init_array) }
	320	${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_end = .);}}
	321
	322	${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_start = .);}}
	323	.fini_array ${RELOCATING-0} : { *(.fini_array) }
	324	${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_end = .);}}
	325
	326	.data ${RELOCATING-0} :
	327	{
	328	${RELOCATING+${DATA_START_SYMBOLS}}
	329	(.data${RELOCATING+ .data. .gnu.linkonce.d.*})
	330	${CONSTRUCTING+SORT(CONSTRUCTORS)}
	331	}
	332	.data.init ${RELOCATING-0} :
	333	{
	334	*(.data.init)
	335	}
	336	.data1 ${RELOCATING-0} : { *(.data1) }
	337	.tdata ${RELOCATING-0} : { (.tdata${RELOCATING+ .tdata. .gnu.linkonce.td.*}) }
	338	.tbss ${RELOCATING-0} : { (.tbss${RELOCATING+ .tbss. .gnu.linkonce.tb.})${RELOCATING+ (.tcommon)} }
	339	.eh_frame ${RELOCATING-0} : { KEEP (*(.eh_frame)) }
	340	.gcc_except_table ${RELOCATING-0} : { *(.gcc_except_table) }
	341	${WRITABLE_RODATA+${RODATA}}
	342	${OTHER_READWRITE_SECTIONS}
	343	${TEXT_DYNAMIC-${DYNAMIC}}
	344	${RELOCATING+${CTOR}}
	345	${RELOCATING+${DTOR}}
	346	.jcr ${RELOCATING-0} : { KEEP (*(.jcr)) }
	347	${DATA_PLT+${PLT}}
	348	${RELOCATING+${OTHER_GOT_SYMBOLS}}
	349	${GOT}
	350	${OTHER_GOT_SECTIONS}
	351	${CREATE_SHLIB+${SDATA2}}
	352	${CREATE_SHLIB+${SBSS2}}
	353	${SDATA}
	354	${OTHER_SDATA_SECTIONS}
	355	${RELOCATING+_edata = .;}
	356	${RELOCATING+PROVIDE (edata = .);}
	357	${RELOCATING+__bss_start = .;}
	358	${RELOCATING+${OTHER_BSS_SYMBOLS}}
	359	${SBSS}
	360	${BSS_PLT+${PLT}}
	361	.bss ${RELOCATING-0} :
	362	{
2bf2bf23 AM	363	${RELOCATING+*(.dynbss)}
	364	(.bss${RELOCATING+ .bss. .gnu.linkonce.b.*})
	365	${RELOCATING+*(COMMON)
	366	/* Align here to ensure that the .bss section occupies space up to
	367	_end. Align after .bss to ensure correct alignment even if the
	368	.bss section disappears because there are no input sections. */
	369	. = ALIGN(${ALIGNMENT});}
886a2506 NC	370	}
	371	${OTHER_BSS_SECTIONS}
	372	${RELOCATING+. = ALIGN(${ALIGNMENT});}
	373	${RELOCATING+_end = .;}
	374	${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
	375	${RELOCATING+PROVIDE (end = .);}
	376	${RELOCATING+${DATA_SEGMENT_END}}
2bf2bf23	377	EOF
886a2506	378
2bf2bf23	379	test -n "${RELOCATING}" && cat <<EOF
886a2506 NC	380	/* We want to be able to set a default stack / heap size in a dejagnu
	381	board description file, but override it for selected test cases.
	382	The options appear in the wrong order to do this with a single symbol -
	383	ldflags comes after flags injected with per-file stanzas, and thus
	384	the setting from ldflags prevails. */
2bf2bf23	385	.heap :
886a2506	386	{
2bf2bf23 AM	387	__start_heap = . ;
	388	. = . + (DEFINED(__HEAP_SIZE) ? __HEAP_SIZE : (DEFINED(__DEFAULT_HEAP_SIZE) ? __DEFAULT_HEAP_SIZE : 20k)) ;
	389	__end_heap = . ;
886a2506 NC	390	}
886a2506 NC	391
2bf2bf23 AM	392	. = ALIGN(0x8);
2bf2bf23 AM	393	.stack :
886a2506	394	{
2bf2bf23 AM	395	__stack = . ;
	396	. = . + (DEFINED(__STACK_SIZE) ? __STACK_SIZE : (DEFINED(__DEFAULT_STACK_SIZE) ? __DEFAULT_STACK_SIZE : 64k)) ;
	397	__stack_top = . ;
886a2506	398	}
2bf2bf23	399	EOF
886a2506	400
2bf2bf23	401	cat <<EOF
886a2506 NC	402	/* Stabs debugging sections. */
	403	.stab 0 : { *(.stab) }
	404	.stabstr 0 : { *(.stabstr) }
	405	.stab.excl 0 : { *(.stab.excl) }
	406	.stab.exclstr 0 : { *(.stab.exclstr) }
	407	.stab.index 0 : { *(.stab.index) }
	408	.stab.indexstr 0 : { *(.stab.indexstr) }
	409
	410	.comment 0 : { *(.comment) }
	411
	412	/* DWARF debug sections.
	413	Symbols in the DWARF debugging sections are relative to the beginning
	414	of the section so we begin them at 0. */
	415
	416	/* DWARF 1 */
	417	.debug 0 : { *(.debug) }
	418	.line 0 : { *(.line) }
	419
	420	/* GNU DWARF 1 extensions */
	421	.debug_srcinfo 0 : { *(.debug_srcinfo) }
	422	.debug_sfnames 0 : { *(.debug_sfnames) }
	423
	424	/* DWARF 1.1 and DWARF 2 */
	425	.debug_aranges 0 : { *(.debug_aranges) }
	426	.debug_pubnames 0 : { *(.debug_pubnames) }
	427
	428	/* DWARF 2 */
2bf2bf23	429	.debug_info 0 : { (.debug_info${RELOCATING+ .gnu.linkonce.wi.}) }
886a2506 NC	430	.debug_abbrev 0 : { *(.debug_abbrev) }
	431	.debug_line 0 : { *(.debug_line) }
	432	.debug_frame 0 : { *(.debug_frame) }
	433	.debug_str 0 : { *(.debug_str) }
	434	.debug_loc 0 : { *(.debug_loc) }
	435	.debug_macinfo 0 : { *(.debug_macinfo) }
	436
	437	/* SGI/MIPS DWARF 2 extensions */
	438	.debug_weaknames 0 : { *(.debug_weaknames) }
	439	.debug_funcnames 0 : { *(.debug_funcnames) }
	440	.debug_typenames 0 : { *(.debug_typenames) }
	441	.debug_varnames 0 : { *(.debug_varnames) }
	442
	443	/* ARC Extension Sections */
	444	.arcextmap 0 : { (.gnu.linkonce.arcextmap.) }
	445
886a2506 NC	446	${OTHER_SECTIONS}
	447	${RELOCATING+${OTHER_END_SYMBOLS}}
	448	${RELOCATING+${STACKNOTE}}
	449	}
	450	EOF