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