[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
{ 
  /* Give these a dummy version to work around linker lameness.
     The name used shouldn't matter as these are all local symbols.  */
  __GNU { 
    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.  */

  .preinit_array   ${RELOCATING-0} :
  {
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_start = .);}}
    KEEP (*(.preinit_array))
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_end = .);}}
  }
  .init_array   ${RELOCATING-0} :
  {
    /* SymbianOS uses this symbol.  */
    ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Base = .);}
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_start = .);}}
    KEEP (*(SORT(.init_array.*)))
    KEEP (*(.init_array))
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_end = .);}}
    /* SymbianOS uses this symbol.  */
    ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Limit = .);}
  }
  .fini_array   ${RELOCATING-0} :
  {
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_start = .);}}
    KEEP (*(.fini_array))
    KEEP (*(SORT(.fini_array.*)))
    ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__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});}
  }
  ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
  ${RELOCATING+. = ALIGN(${ALIGNMENT});}
  ${RELOCATING+${OTHER_END_SYMBOLS}}
  ${RELOCATING+_end = .;}
  ${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_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.*}) }
  .rel.init_array  0 : { *(.rel.init_array) }
  .rela.init_array 0 : { *(.rela.init_array) }
  .rel.fini_array  0 : { *(.rel.fini_array) }
  .rela.fini_array 0 : { *(.rela.fini_array) }
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}
  .rel.other    0 : { *(.rel.*) }
  .rela.other   0 : { *(.rela.*) }
  .reli.other   0 : { *(.reli.*) }
}
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	{
c68dac40 PB	145	/* Give these a dummy version to work around linker lameness.
	146	The name used shouldn't matter as these are all local symbols. */
	147	__GNU {
4e5db43b MM	148	local:
	149	Image\$\$ER_RO\$\$Base;
	150	Image\$\$ER_RO\$\$Limit;
	151	SHT\$\$INIT_ARRAY\$\$Base;
	152	SHT\$\$INIT_ARRAY\$\$Limit;
	153	.ARM.exidx\$\$Base;
	154	.ARM.exidx\$\$Limit;
	155	};
	156	}
	157
229fcec5 MM	158	SECTIONS
	159	{
	160	/* Read-only sections, merged into text segment: */
dc4c9c19	161	${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR});}}}
4e5db43b	162
dc4c9c19	163	${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+ . = ${TEXT_BASE_ADDRESS};}}}
ba916c8a MM	164	${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
ba916c8a MM	165	${CREATE_PIE+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
4e5db43b MM	166
	167	/* Define Image\$\$ER_RO\$\$Base. */
	168	${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Base = .);}
	169
229fcec5	170	${INITIAL_READONLY_SECTIONS}
229fcec5 MM	171
229fcec5 MM	172	EOF
229fcec5	173	cat <<EOF
229fcec5 MM	174	.init ${RELOCATING-0} :
	175	{
	176	${RELOCATING+${INIT_START}}
	177	KEEP (*(.init))
	178	${RELOCATING+${INIT_END}}
	179	} =${NOP-0}
229fcec5 MM	180	.text ${RELOCATING-0} :
	181	{
	182	${RELOCATING+${TEXT_START_SYMBOLS}}
	183	(.text .stub${RELOCATING+ .text. .gnu.linkonce.t.*})
	184	KEEP ((.text.personality*))
	185	/* .gnu.warning sections are handled specially by elf32.em. */
	186	*(.gnu.warning)
	187	${RELOCATING+${OTHER_TEXT_SECTIONS}}
	188	} =${NOP-0}
	189	.fini ${RELOCATING-0} :
	190	{
	191	${RELOCATING+${FINI_START}}
	192	KEEP (*(.fini))
	193	${RELOCATING+${FINI_END}}
	194	} =${NOP-0}
dc4c9c19 MM	195	/* The SymbianOS kernel requires that the PLT go at the end of the
	196	text section. */
	197	${DATA_PLT-${BSS_PLT-${PLT}}}
229fcec5 MM	198	${RELOCATING+PROVIDE (__etext = .);}
	199	${RELOCATING+PROVIDE (_etext = .);}
	200	${RELOCATING+PROVIDE (etext = .);}
4e5db43b MM	201
4e5db43b MM	202	/* Define Image\$\$ER_RO\$\$Limit. */
dc4c9c19	203	${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Limit = .);}
4e5db43b	204
229fcec5 MM	205	${WRITABLE_RODATA-${RODATA}}
	206	.rodata1 ${RELOCATING-0} : { *(.rodata1) }
	207	${CREATE_SHLIB-${SDATA2}}
	208	${CREATE_SHLIB-${SBSS2}}
229fcec5	209
dc4c9c19 MM	210	/* On SymbianOS, put .init_array and friends in the read-only
	211	segment; there is no runtime relocation applied to these
	212	arrays. */
229fcec5	213
6f2942ed PB	214	.preinit_array ${RELOCATING-0} :
	215	{
	216	${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_start = .);}}
	217	KEEP (*(.preinit_array))
	218	${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_end = .);}}
	219	}
	220	.init_array ${RELOCATING-0} :
	221	{
	222	/* SymbianOS uses this symbol. */
	223	${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Base = .);}
	224	${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_start = .);}}
	225	KEEP ((SORT(.init_array.)))
	226	KEEP (*(.init_array))
	227	${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_end = .);}}
	228	/* SymbianOS uses this symbol. */
	229	${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Limit = .);}
	230	}
	231	.fini_array ${RELOCATING-0} :
	232	{
	233	${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_start = .);}}
	234	KEEP (*(.fini_array))
	235	KEEP ((SORT(.fini_array.)))
	236	${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_end = .);}}
	237	}
229fcec5	238
dc4c9c19 MM	239	${OTHER_READONLY_SECTIONS}
	240	.eh_frame_hdr : { *(.eh_frame_hdr) }
	241	.eh_frame ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
	242	.gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP ((.gcc_except_table)) (.gcc_except_table.*) }
	243
	244	/* Adjust the address for the data segment. We want to adjust up to
	245	the same address within the page on the next page up. */
	246	${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR};}}}
	247	${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
	248	${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
	249
	250	/* Exception handling */
	251	.eh_frame ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
	252	.gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP ((.gcc_except_table)) (.gcc_except_table.*) }
	253
	254	/* Thread Local Storage sections */
	255	.tdata ${RELOCATING-0} : { (.tdata${RELOCATING+ .tdata. .gnu.linkonce.td.*}) }
	256	.tbss ${RELOCATING-0} : { (.tbss${RELOCATING+ .tbss. .gnu.linkonce.tb.})${RELOCATING+ (.tcommon)} }
	257
229fcec5 MM	258	${RELOCATING+${CTOR}}
	259	${RELOCATING+${DTOR}}
	260	.jcr ${RELOCATING-0} : { KEEP (*(.jcr)) }
	261
	262	${RELOCATING+${DATARELRO}}
	263	${OTHER_RELRO_SECTIONS}
	264	${RELOCATING+${DATA_SEGMENT_RELRO_END}}
	265
	266	${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
	267
	268	.data ${RELOCATING-0} :
	269	{
	270	${RELOCATING+${DATA_START_SYMBOLS}}
	271	(.data${RELOCATING+ .data. .gnu.linkonce.d.*})
	272	KEEP ((.gnu.linkonce.d.personality*))
	273	${CONSTRUCTING+SORT(CONSTRUCTORS)}
	274	}
	275	.data1 ${RELOCATING-0} : { *(.data1) }
	276	${WRITABLE_RODATA+${RODATA}}
	277	${OTHER_READWRITE_SECTIONS}
	278	${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
	279	${CREATE_SHLIB+${SDATA2}}
	280	${CREATE_SHLIB+${SBSS2}}
	281	${SDATA}
	282	${OTHER_SDATA_SECTIONS}
	283	${RELOCATING+_edata = .;}
	284	${RELOCATING+PROVIDE (edata = .);}
ba916c8a	285	${RELOCATING+. = DEFINED(__bss_segment_start) ? __bss_segment_start : .;}
229fcec5 MM	286	${RELOCATING+__bss_start = .;}
	287	${RELOCATING+${OTHER_BSS_SYMBOLS}}
	288	${SBSS}
	289	${BSS_PLT+${PLT}}
	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}}
229fcec5	301	${RELOCATING+. = ALIGN(${ALIGNMENT});}
9f4fb502	302	${RELOCATING+${OTHER_END_SYMBOLS}}
827a1c67	303	${RELOCATING+_end = .;}
229fcec5 MM	304	${RELOCATING+PROVIDE (end = .);}
	305	${RELOCATING+${DATA_SEGMENT_END}}
	306
	307	/* These sections are not mapped under the BPABI. */
	308	.dynamic 0 : { *(.dynamic) }
	309	.hash 0 : { *(.hash) }
	310	.dynsym 0 : { *(.dynsym) }
	311	.dynstr 0 : { *(.dynstr) }
c0042f5d MM	312	.gnu.version 0 : { *(.gnu.version) }
	313	.gnu.version_d 0: { *(.gnu.version_d) }
	314	.gnu.version_r 0: { *(.gnu.version_r) }
229fcec5 MM	315	${CREATE_SHLIB-${INTERP}}
	316
	317	/* Stabs debugging sections. */
	318	.stab 0 : { *(.stab) }
	319	.stabstr 0 : { *(.stabstr) }
	320	.stab.excl 0 : { *(.stab.excl) }
	321	.stab.exclstr 0 : { *(.stab.exclstr) }
	322	.stab.index 0 : { *(.stab.index) }
	323	.stab.indexstr 0 : { *(.stab.indexstr) }
	324
	325	.comment 0 : { *(.comment) }
	326
	327	/* DWARF debug sections.
	328	Symbols in the DWARF debugging sections are relative to the beginning
	329	of the section so we begin them at 0. */
	330
	331	/* DWARF 1 */
	332	.debug 0 : { *(.debug) }
	333	.line 0 : { *(.line) }
	334
	335	/* GNU DWARF 1 extensions */
	336	.debug_srcinfo 0 : { *(.debug_srcinfo) }
	337	.debug_sfnames 0 : { *(.debug_sfnames) }
	338
	339	/* DWARF 1.1 and DWARF 2 */
	340	.debug_aranges 0 : { *(.debug_aranges) }
	341	.debug_pubnames 0 : { *(.debug_pubnames) }
	342
	343	/* DWARF 2 */
	344	.debug_info 0 : { (.debug_info .gnu.linkonce.wi.) }
	345	.debug_abbrev 0 : { *(.debug_abbrev) }
	346	.debug_line 0 : { *(.debug_line) }
	347	.debug_frame 0 : { *(.debug_frame) }
	348	.debug_str 0 : { *(.debug_str) }
	349	.debug_loc 0 : { *(.debug_loc) }
	350	.debug_macinfo 0 : { *(.debug_macinfo) }
	351
	352	/* SGI/MIPS DWARF 2 extensions */
	353	.debug_weaknames 0 : { *(.debug_weaknames) }
	354	.debug_funcnames 0 : { *(.debug_funcnames) }
	355	.debug_typenames 0 : { *(.debug_typenames) }
	356	.debug_varnames 0 : { *(.debug_varnames) }
	357
	358	${STACK_ADDR+${STACK}}
	359	${OTHER_SECTIONS}
827a1c67	360	${RELOCATING+${OTHER_SYMBOLS}}
229fcec5	361	${RELOCATING+${STACKNOTE}}
ba916c8a MM	362	EOF
	363
	364	# These relocations sections are part of the read-only segment in SVR4
	365	# executables, but are not mapped in BPABI executables.
	366	if [ "x$COMBRELOC" = x ]; then
	367	COMBRELOCCAT=cat
	368	else
	369	COMBRELOCCAT="cat > $COMBRELOC"
	370	fi
	371	eval $COMBRELOCCAT <<EOF
	372	.rel.init 0 : { *(.rel.init) }
	373	.rela.init 0 : { *(.rela.init) }
	374	.rel.text 0 : { (.rel.text${RELOCATING+ .rel.text. .rel.gnu.linkonce.t.*}) }
	375	.rela.text 0 : { (.rela.text${RELOCATING+ .rela.text. .rela.gnu.linkonce.t.*}) }
	376	.rel.fini 0 : { *(.rel.fini) }
	377	.rela.fini 0 : { *(.rela.fini) }
	378	.rel.rodata 0 : { (.rel.rodata${RELOCATING+ .rel.rodata. .rel.gnu.linkonce.r.*}) }
	379	.rela.rodata 0 : { (.rela.rodata${RELOCATING+ .rela.rodata. .rela.gnu.linkonce.r.*}) }
	380	${OTHER_READONLY_RELOC_SECTIONS}
	381	.rel.data.rel.ro 0 : { (.rel.data.rel.ro${RELOCATING+}) }
	382	.rela.data.rel.ro 0 : { (.rel.data.rel.ro${RELOCATING+}) }
	383	.rel.data 0 : { (.rel.data${RELOCATING+ .rel.data. .rel.gnu.linkonce.d.*}) }
	384	.rela.data 0 : { (.rela.data${RELOCATING+ .rela.data. .rela.gnu.linkonce.d.*}) }
	385	.rel.tdata 0 : { (.rel.tdata${RELOCATING+ .rel.tdata. .rel.gnu.linkonce.td.*}) }
	386	.rela.tdata 0 : { (.rela.tdata${RELOCATING+ .rela.tdata. .rela.gnu.linkonce.td.*}) }
	387	.rel.tbss 0 : { (.rel.tbss${RELOCATING+ .rel.tbss. .rel.gnu.linkonce.tb.*}) }
	388	.rela.tbss 0 : { (.rela.tbss${RELOCATING+ .rela.tbss. .rela.gnu.linkonce.tb.*}) }
	389	.rel.ctors 0 : { *(.rel.ctors) }
	390	.rela.ctors 0 : { *(.rela.ctors) }
	391	.rel.dtors 0 : { *(.rel.dtors) }
	392	.rela.dtors 0 : { *(.rela.dtors) }
	393	${REL_SDATA}
	394	${REL_SBSS}
	395	${REL_SDATA2}
	396	${REL_SBSS2}
	397	.rel.bss 0 : { (.rel.bss${RELOCATING+ .rel.bss. .rel.gnu.linkonce.b.*}) }
	398	.rela.bss 0 : { (.rela.bss${RELOCATING+ .rela.bss. .rela.gnu.linkonce.b.*}) }
2a2a7c94 JB	399	.rel.init_array 0 : { *(.rel.init_array) }
	400	.rela.init_array 0 : { *(.rela.init_array) }
	401	.rel.fini_array 0 : { *(.rel.fini_array) }
	402	.rela.fini_array 0 : { *(.rela.fini_array) }
ba916c8a MM	403	EOF
	404	if [ -n "$COMBRELOC" ]; then
	405	cat <<EOF
	406	.rel.dyn 0 :
	407	{
	408	EOF
	409	sed -e '/^[ ][{}][ ]$/d;/:[ ]$/d;/\.rela\./d;s/^.: { \(.\)}$/ \1/' $COMBRELOC
	410	cat <<EOF
	411	}
	412	.rela.dyn 0 :
	413	{
	414	EOF
	415	sed -e '/^[ ][{}][ ]$/d;/:[ ]$/d;/\.rel\./d;s/^.: { \(.\)}/ \1/' $COMBRELOC
	416	cat <<EOF
	417	}
	418	EOF
	419	fi
	420	cat <<EOF
	421	.rel.plt 0 : { *(.rel.plt) }
	422	.rela.plt 0 : { *(.rela.plt) }
	423	${OTHER_PLT_RELOC_SECTIONS}
2a2a7c94 JB	424	.rel.other 0 : { (.rel.) }
	425	.rela.other 0 : { (.rela.) }
	426	.reli.other 0 : { (.reli.) }
229fcec5 MM	427	}
229fcec5 MM	428	EOF