[thirdparty/binutils-gdb.git] / ld / scripttempl / elf_chaos.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_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_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=.
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="
    ${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="
    ${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)
  }"

test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"

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};}}
  ${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
  . = ALIGN(0x1000);
  .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
  .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
  ${OTHER_PLT_RELOC_SECTIONS}
  ${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 = .);}
  . = ALIGN(0x1000);
  ${CREATE_SHLIB-${SDATA2}}
  ${CREATE_SHLIB-${SBSS2}}
  ${OTHER_READONLY_SECTIONS}
  .eh_frame_hdr : { *(.eh_frame_hdr) }

  . = ALIGN(0x1000);
  .data         ${RELOCATING-0} :
  {
    *(.rodata .rodata.*)
    *(.rodata1)
    *(.gnu.linkonce.r.*)
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
    ${CONSTRUCTING+SORT(CONSTRUCTORS)}
    KEEP (*(.eh_frame))
    *(.gcc_except_table)
    ${CTOR}
    ${DTOR}
    KEEP (*(.jcr))
  }
  .data1        ${RELOCATING-0} : { *(.data1) }
  . = ALIGN(0x1000);
  .gcc_except_table ${RELOCATING-0} : { *(.gcc_except_table) }
  ${WRITABLE_RODATA+${RODATA}}
  ${OTHER_READWRITE_SECTIONS}
  ${TEXT_DYNAMIC-${DYNAMIC}}
  ${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}}
  . = ALIGN(0x1000);
  .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});}
  }
  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+${OTHER_END_SYMBOLS}}
  ${RELOCATING+_end = .;}
  ${RELOCATING+PROVIDE (end = .);}

  /* Stabs debugging sections.  */
  . = ALIGN(0x1000);
  .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) }

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