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

# This variant of elf.sc is used for ARM BPABI platforms, like Symbian
# OS, where a separate postlinker will operated on the generated
# executable or shared object.  See elf.sc for configuration variables
# that apply; only BPABI-specific variables will be noted here.

test -z "$ENTRY" && ENTRY=_start
test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
test -z "${ELFSIZE}" && ELFSIZE=32
test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
test "$LD_FLAG" = "N" && DATA_ADDR=.
test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
DATA_SEGMENT_RELRO_END=""
DATA_SEGMENT_RELRO_GOTPLT_END=""
DATA_SEGMENT_END=""
if test -n "${COMMONPAGESIZE}"; then
  DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
  DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
  if test -n "${SEPARATE_GOTPLT}"; then
    DATA_SEGMENT_RELRO_GOTPLT_END=". = DATA_SEGMENT_RELRO_END (. + ${SEPARATE_GOTPLT});"
  else
    DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (.);"
  fi
fi
INTERP=".interp       0 : { *(.interp) }"
PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
DATARELRO=".data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }"
STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
if test -z "${NO_SMALL_DATA}"; then
  SBSS=".sbss         ${RELOCATING-0} :
  {
    ${RELOCATING+PROVIDE (__sbss_start = .);}
    ${RELOCATING+PROVIDE (___sbss_start = .);}
    *(.dynsbss)
    *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
    *(.scommon)
    ${RELOCATING+PROVIDE (__sbss_end = .);}
    ${RELOCATING+PROVIDE (___sbss_end = .);}
  }"
  SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
  SDATA="/* We want the small data sections together, so single-instruction offsets
     can access them all, and initialized data all before uninitialized, so
     we can shorten the on-disk segment size.  */
  .sdata        ${RELOCATING-0} : 
  {
    ${RELOCATING+${SDATA_START_SYMBOLS}}
    *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
  }"
  SDATA2=".sdata2       ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }"
  REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
  .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
  REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
  .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
  REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
  .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
  REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
  .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
else
  NO_SMALL_DATA=" "
fi
test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
CTOR=".ctors        ${CONSTRUCTING-0} : 
  {
    ${CONSTRUCTING+${CTOR_START}}
    /* gcc uses crtbegin.o to find the start of
       the constructors, so we make sure it is
       first.  Because this is a wildcard, it
       doesn't matter if the user does not
       actually link against crtbegin.o; the
       linker won't look for a file to match a
       wildcard.  The wildcard also means that it
       doesn't matter which directory crtbegin.o
       is in.  */

    KEEP (*crtbegin*.o(.ctors))

    /* We don't want to include the .ctor section from
       from the crtend.o file until after the sorted ctors.
       The .ctor section from the crtend file contains the
       end of ctors marker and it must be last */

    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .ctors))
    KEEP (*(SORT(.ctors.*)))
    KEEP (*(.ctors))
    ${CONSTRUCTING+${CTOR_END}}
  }"
DTOR=".dtors        ${CONSTRUCTING-0} :
  {
    ${CONSTRUCTING+${DTOR_START}}
    KEEP (*crtbegin*.o(.dtors))
    KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .dtors))
    KEEP (*(SORT(.dtors.*)))
    KEEP (*(.dtors))
    ${CONSTRUCTING+${DTOR_END}}
  }"
STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
  {
    ${RELOCATING+_stack = .;}
    *(.stack)
  }"

TEXT_START_ADDR="SEGMENT_START(\"text\", ${TEXT_START_ADDR})"
SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text\", ${SHLIB_TEXT_START_ADDR:-0})"
DATA_ADDR="SEGMENT_START(\"data\", ${DATA_ADDR-${DATA_SEGMENT_ALIGN}})"
SHLIB_DATA_ADDR="SEGMENT_START(\"data\", ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}})"

# 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"
   SHLIB_BASE_ADDRESS="${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS"
else
   test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
   SHLIB_BASE_ADDRESS="${SHLIB_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.  */}

/* ARM's proprietary toolchain generate these symbols to match the start 
   and end of particular sections of the image.  SymbianOS uses these
   symbols.  We provide them for compatibility with ARM's toolchains.  
   These symbols should be bound locally; each shared object may define 
   its own version of these symbols.  */ 
	
VERSION
{ 
  { 
    local: 
      Image\$\$ER_RO\$\$Base;
      Image\$\$ER_RO\$\$Limit;
      SHT\$\$INIT_ARRAY\$\$Base;
      SHT\$\$INIT_ARRAY\$\$Limit;
      .ARM.exidx\$\$Base;	
      .ARM.exidx\$\$Limit;
  };
}

SECTIONS
{
  /* Read-only sections, merged into text segment: */
  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR});}}}

  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+ . = ${TEXT_BASE_ADDRESS};}}}
  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}

  /* Define Image\$\$ER_RO\$\$Base.  */
  ${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Base = .);}

  ${INITIAL_READONLY_SECTIONS}

EOF
cat <<EOF
  .init         ${RELOCATING-0} : 
  { 
    ${RELOCATING+${INIT_START}}
    KEEP (*(.init))
    ${RELOCATING+${INIT_END}}
  } =${NOP-0}
  .text         ${RELOCATING-0} :
  {
    ${RELOCATING+${TEXT_START_SYMBOLS}}
    *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
    KEEP (*(.text.*personality*))
    /* .gnu.warning sections are handled specially by elf32.em.  */
    *(.gnu.warning)
    ${RELOCATING+${OTHER_TEXT_SECTIONS}}
  } =${NOP-0}
  .fini         ${RELOCATING-0} :
  {
    ${RELOCATING+${FINI_START}}
    KEEP (*(.fini))
    ${RELOCATING+${FINI_END}}
  } =${NOP-0}
  /* The SymbianOS kernel requires that the PLT go at the end of the
     text section.  */
  ${DATA_PLT-${BSS_PLT-${PLT}}}
  ${RELOCATING+PROVIDE (__etext = .);}
  ${RELOCATING+PROVIDE (_etext = .);}
  ${RELOCATING+PROVIDE (etext = .);}

  /* Define Image\$\$ER_RO\$\$Limit.  */
  ${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Limit = .);}

  ${WRITABLE_RODATA-${RODATA}}
  .rodata1      ${RELOCATING-0} : { *(.rodata1) }
  ${CREATE_SHLIB-${SDATA2}}
  ${CREATE_SHLIB-${SBSS2}}

  /* On SymbianOS, put  .init_array and friends in the read-only
     segment; there is no runtime relocation applied to these
     arrays.  */

  /* 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 = .);}}
  /* SymbianOS uses this symbol.  */
  ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Base = .);}
  .init_array   ${RELOCATING-0} : { *(.init_array) }
  /* SymbianOS uses this symbol.  */
  ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Limit = .);}
  ${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 = .);}}

  ${OTHER_READONLY_SECTIONS}
  .eh_frame_hdr : { *(.eh_frame_hdr) }
  .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }

  /* Adjust the address for the data segment.  We want to adjust up to
     the same address within the page on the next page up.  */
  ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR};}}}
  ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
  ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}

  /* Exception handling  */
  .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
  .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }

  /* Thread Local Storage sections  */
  .tdata	${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
  .tbss		${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }

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

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

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

  .data         ${RELOCATING-0} :
  {
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
    KEEP (*(.gnu.linkonce.d.*personality*))
    ${CONSTRUCTING+SORT(CONSTRUCTORS)}
  }
  .data1        ${RELOCATING-0} : { *(.data1) }
  ${WRITABLE_RODATA+${RODATA}}
  ${OTHER_READWRITE_SECTIONS}
  ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
  ${CREATE_SHLIB+${SDATA2}}
  ${CREATE_SHLIB+${SBSS2}}
  ${SDATA}
  ${OTHER_SDATA_SECTIONS}
  ${RELOCATING+_edata = .;}
  ${RELOCATING+PROVIDE (edata = .);}
  ${RELOCATING+. = DEFINED(__bss_segment_start) ? __bss_segment_start : .;}
  ${RELOCATING+__bss_start = .;}
  ${RELOCATING+${OTHER_BSS_SYMBOLS}}
  ${SBSS}
  ${BSS_PLT+${PLT}}
  .bss          ${RELOCATING-0} :
  {
   *(.dynbss)
   *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
   *(COMMON)
   /* Align here to ensure that the .bss section occupies space up to
      _end.  Align after .bss to ensure correct alignment even if the
      .bss section disappears because there are no input sections.  */
   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  }
  ${OTHER_BSS_SECTIONS}
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+_end = .;}
  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
  ${RELOCATING+PROVIDE (end = .);}
  ${RELOCATING+${DATA_SEGMENT_END}}

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

  /* Stabs debugging sections.  */
  .stab          0 : { *(.stab) }
  .stabstr       0 : { *(.stabstr) }
  .stab.excl     0 : { *(.stab.excl) }
  .stab.exclstr  0 : { *(.stab.exclstr) }
  .stab.index    0 : { *(.stab.index) }
  .stab.indexstr 0 : { *(.stab.indexstr) }

  .comment       0 : { *(.comment) }

  /* DWARF debug sections.
     Symbols in the DWARF debugging sections are relative to the beginning
     of the section so we begin them at 0.  */

  /* DWARF 1 */
  .debug          0 : { *(.debug) }
  .line           0 : { *(.line) }

  /* GNU DWARF 1 extensions */
  .debug_srcinfo  0 : { *(.debug_srcinfo) }
  .debug_sfnames  0 : { *(.debug_sfnames) }

  /* DWARF 1.1 and DWARF 2 */
  .debug_aranges  0 : { *(.debug_aranges) }
  .debug_pubnames 0 : { *(.debug_pubnames) }

  /* DWARF 2 */
  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
  .debug_abbrev   0 : { *(.debug_abbrev) }
  .debug_line     0 : { *(.debug_line) }
  .debug_frame    0 : { *(.debug_frame) }
  .debug_str      0 : { *(.debug_str) }
  .debug_loc      0 : { *(.debug_loc) }
  .debug_macinfo  0 : { *(.debug_macinfo) }

  /* SGI/MIPS DWARF 2 extensions */
  .debug_weaknames 0 : { *(.debug_weaknames) }
  .debug_funcnames 0 : { *(.debug_funcnames) }
  .debug_typenames 0 : { *(.debug_typenames) }
  .debug_varnames  0 : { *(.debug_varnames) }

  ${STACK_ADDR+${STACK}}
  ${OTHER_SECTIONS}
  ${RELOCATING+${OTHER_END_SYMBOLS}}
  ${RELOCATING+${STACKNOTE}}
EOF

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