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

#
# Unusual variables checked by this code:
#	NOP - four byte opcode for no-op (defaults to 0)
#	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)
#	ATTRS_SECTIONS - at the end
#	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
#  .tdata	.gnu.linkonce.td.foo
#  .tbss	.gnu.linkonce.tb.foo
#
#  Each of these can also have corresponding .rel.* and .rela.* sections.

test -z "$ENTRY" && ENTRY=_start
test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
test -z "${ELFSIZE}" && ELFSIZE=32
test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
test "$LD_FLAG" = "N" && DATA_ADDR=.
test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
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    ALIGN(4) : { *(.interp) }"
    PLT=".plt            : { *(.plt) } :dynamic :dyn"
DYNAMIC=".dynamic        : { *(.dynamic) } :dynamic :dyn"
 RODATA=".rodata    ALIGN(4) : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.directive)  *(.gnu.lto_*) }"
test -z "$GOT" && GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.got) } :dynamic :dyn"
INIT_ARRAY=".init_array   ${RELOCATING-0} :
  {
     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_start = .);}}
     KEEP (*(SORT(.init_array.*)))
     KEEP (*(.init_array))
     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_end = .);}}
  }"
FINI_ARRAY=".fini_array   ${RELOCATING-0} :
  {
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_start = .);}}
    KEEP (*(SORT(.fini_array.*)))
    KEEP (*(.fini_array))
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_end = .);}}
  }"
CTOR=".ctors     ALIGN(4) : 
  {
    ${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))
    KEEP (*crtbegin?.o(.ctors))

    /* We don't want to include the .ctor section 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 *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
    KEEP (*(SORT(.ctors.*)))
    KEEP (*(.ctors))
    ${CONSTRUCTING+${CTOR_END}}
  } :text"
DTOR=".dtors        ALIGN(4) :
  {
    ${CONSTRUCTING+${DTOR_START}}
    KEEP (*crtbegin.o(.dtors))
    KEEP (*crtbegin?.o(.dtors))
    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
    KEEP (*(SORT(.dtors.*)))
    KEEP (*(.dtors))
    ${CONSTRUCTING+${DTOR_END}}
  } :text"
STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
  {
    ${RELOCATING+_stack = .;}
    *(.stack)
  } :data"

# 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.  */}

PHDRS
{
  headers PT_PHDR PHDRS ;
  text    PT_LOAD ;
  data    PT_LOAD ;
  dyn     PT_LOAD FLAGS (0) ;
  dynamic PT_DYNAMIC ;
}

SECTIONS
{
  /* Read-only sections, merged into text segment: */
  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${TEXT_BASE_ADDRESS};}}}
  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0};}}
  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0};}}
  ${CREATE_SHLIB-${INTERP}}
  
  ${INITIAL_READONLY_SECTIONS}

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

  .text ALIGN(4) :
  {
    ${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}
  
  ${RELOCATING+${CTOR}}
  ${RELOCATING+${DTOR}}
  
  .fini ALIGN(4) :
  {
    ${RELOCATING+${FINI_START}}
    KEEP (*(.fini))
    ${RELOCATING+${FINI_END}}
  } =${NOP-0}
  
  ${RELOCATING+PROVIDE (__etext = .);}
  ${RELOCATING+PROVIDE (_etext = .);}
  ${RELOCATING+PROVIDE (etext = .);}
  
  ${WRITABLE_RODATA-${RODATA}}
  .rodata1 ALIGN(4) : { *(.rodata1) }
  
  ExportTable  ALIGN(4) : { KEEP (*(ExportTable)) }
  .eh_frame_hdr ALIGN(4) : { *(.eh_frame_hdr) } :text

  /* Adjust the address for the data segment.  We want to adjust up to
     the same address within the page on the next page up.  */
  . = ALIGN(128) + (. & (128 - 1));
  .preinit_array   ${RELOCATING-0} :
  {
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_start = .);}}
    KEEP (*(.preinit_array))
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_end = .);}}
  }
  ${RELOCATING+${INIT_ARRAY}}
  ${RELOCATING+${FINI_ARRAY}}

  ${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}};}}

  .data  ALIGN(4) :
  {
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
    ${CONSTRUCTING+SORT(CONSTRUCTORS)}
  } :data
  
  .data1            ALIGN(4) : { *(.data1) } :data
  .tdata	    ALIGN(4) : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) } :data
  .tbss		    ALIGN(4) : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} } :data
  .eh_frame         ALIGN(4) : { KEEP (*(.eh_frame)) } :data
  .gcc_except_table ALIGN(4) : { *(.gcc_except_table) } :data
  ${WRITABLE_RODATA+${RODATA}}
  ${OTHER_READWRITE_SECTIONS}
  ${SDATA}
  ${OTHER_SDATA_SECTIONS}
  ${RELOCATING+_edata = .;}
  ${RELOCATING+PROVIDE (edata = .);}
  ${RELOCATING+__bss_start = .;}
  ${RELOCATING+${OTHER_BSS_SYMBOLS}}
  ${BSS_PLT+${PLT}}
  .bss  ALIGN(4) :
  {
   *(.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});}
  } :data
  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+${OTHER_END_SYMBOLS}}
  ${RELOCATING+_end = .;}
  ${RELOCATING+PROVIDE (end = .);}
  ${RELOCATING+${DATA_SEGMENT_END}}

  ${TEXT_DYNAMIC-${DYNAMIC}}
  ${TEXT_DYNAMIC+${DYNAMIC}}
  .hash         ${RELOCATING-0} : { *(.hash) } :dynamic :dyn
  .dynsym       ${RELOCATING-0} : { *(.dynsym) } :dynamic :dyn
  .dynstr       ${RELOCATING-0} : { *(.dynstr) } :dynamic :dyn
  ${DATA_PLT-${BSS_PLT-${PLT}}}
  .got.plt	  : { *(.got.plt) } :dynamic :dyn
  .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.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}


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