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

#
# Unusual variables checked by this code:
#	NOP - two byte opcode for no-op (defaults to 0)
#	DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
#	OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
#		(e.g., .PARISC.milli)
#	OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
#		(e.g., .PARISC.global)
#	OTHER_SECTIONS - at the end
#	EXECUTABLE_SYMBOLS - symbols that must be defined for an
#		executable (e.g., _DYNAMIC_LINK)
#	TEXT_START_SYMBOLS - symbols that appear at the start of the
#		.text section.
#	DATA_START_SYMBOLS - symbols that appear at the start of the
#		.data section.
#	OTHER_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.
#
# When adding sections, do note that the names of some sections are used
# when specifying the start address of the next.
#
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}
test "$LD_FLAG" = "N" && DATA_ADDR=.
SBSS2=".sbss2 ${RELOCATING-0} : { *(.sbss2) }"
SDATA2=".sdata2 ${RELOCATING-0} : { *(.sdata2) }"
INTERP=".interp ${RELOCATING-0} : { *(.interp) }"
PLT=".plt ${RELOCATING-0} : { *(.plt) }"
cat <<EOF
OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	      "${LITTLE_OUTPUT_FORMAT}")
OUTPUT_ARCH(${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- /* 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.  */}

${RELOCATING+PROVIDE (__stack = 0);}
SECTIONS
{
  /* Read-only sections, merged into text segment: */
  ${CREATE_SHLIB-${RELOCATING+. = ${TEXT_START_ADDR} + SIZEOF_HEADERS;}}
  ${CREATE_SHLIB+${RELOCATING+. = SIZEOF_HEADERS;}}
  ${CREATE_SHLIB-${INTERP}}
  .hash		${RELOCATING-0} : { *(.hash)		}
  .dynsym	${RELOCATING-0} : { *(.dynsym)		}
  .dynstr	${RELOCATING-0} : { *(.dynstr)		}
  .rela.text   ${RELOCATING-0} :
    { *(.rela.text) *(.rela.gnu.linkonce.t*) }
  .rela.data   ${RELOCATING-0} :
    { *(.rela.data) *(.rela.gnu.linkonce.d*) }
  .rela.rodata ${RELOCATING-0} :
    { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
  .rela.got	${RELOCATING-0} : { *(.rela.got)	}
  .rela.got1	${RELOCATING-0} : { *(.rela.got1)	}
  .rela.got2	${RELOCATING-0} : { *(.rela.got2)	}
  .rela.ctors	${RELOCATING-0} : { *(.rela.ctors)	}
  .rela.dtors	${RELOCATING-0} : { *(.rela.dtors)	}
  .rela.init	${RELOCATING-0} : { *(.rela.init)	}
  .rela.fini	${RELOCATING-0} : { *(.rela.fini)	}
  .rela.bss	${RELOCATING-0} : { *(.rela.bss)	}
  .rela.plt	${RELOCATING-0} : { *(.rela.plt)	}
  .rela.sdata	${RELOCATING-0} : { *(.rela.sdata2)	}
  .rela.sbss	${RELOCATING-0} : { *(.rela.sbss2)	}
  .rela.sdata2	${RELOCATING-0} : { *(.rela.sdata2)	}
  .rela.sbss2	${RELOCATING-0} : { *(.rela.sbss2)	}
  ${DATA_PLT-${PLT}}
  .text    ${RELOCATING-0} :
  {
    ${RELOCATING+${TEXT_START_SYMBOLS}}
    *(.text)
    /* .gnu.warning sections are handled specially by elf32.em.  */
    *(.gnu.warning)
    *(.gnu.linkonce.t*)
  } =${NOP-0}
  .init		${RELOCATING-0} : { *(.init)		} =${NOP-0}
  .fini		${RELOCATING-0} : { *(.fini)		} =${NOP-0}
  .rodata	${RELOCATING-0} : { *(.rodata) *(.gnu.linkonce.r*) }
  .rodata1	${RELOCATING-0} : { *(.rodata1) }
  ${RELOCATING+_etext = .;}
  ${RELOCATING+PROVIDE (etext = .);}
  ${CREATE_SHLIB-${SDATA2}}
  ${CREATE_SHLIB-${SBSS2}}
  ${RELOCATING+${OTHER_READONLY_SECTIONS}}

  /* Adjust the address for the data segment.  We want to adjust up to
     the same address within the page on the next page up.  It would
     be more correct to do this:
       ${RELOCATING+. = ${DATA_ADDR-ALIGN(${MAXPAGESIZE}) + (ALIGN(8) & (${MAXPAGESIZE} - 1))};}
     The current expression does not correctly handle the case of a
     text segment ending precisely at the end of a page; it causes the
     data segment to skip a page.  The above expression does not have
     this problem, but it will currently (2/95) cause BFD to allocate
     a single segment, combining both text and data, for this case.
     This will prevent the text segment from being shared among
     multiple executions of the program; I think that is more
     important than losing a page of the virtual address space (note
     that no actual memory is lost; the page which is skipped can not
     be referenced).  */
  ${RELOCATING+. = ${DATA_ADDR- ALIGN(8) + ${MAXPAGESIZE}};}

  .data  ${RELOCATING-0} :
  {
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data)
    *(.gnu.linkonce.d*)
    ${CONSTRUCTING+CONSTRUCTORS}
  }
  .data1 ${RELOCATING-0} : { *(.data1) }
  ${RELOCATING+${OTHER_READWRITE_SECTIONS}}

  .got1		${RELOCATING-0} : { *(.got1) }
  .dynamic	${RELOCATING-0} : { *(.dynamic) }

  /* Put .ctors and .dtors next to the .got2 section, so that the pointers
     get relocated with -mrelocatable. Also put in the .fixup pointers.
     The current compiler no longer needs this, but keep it around for 2.7.2  */

		${RELOCATING+PROVIDE (_GOT2_START_ = .);}
  .got2		${RELOCATING-0} :  { *(.got2) }

		${RELOCATING+PROVIDE (__CTOR_LIST__ = .);}
  .ctors	${RELOCATING-0} : { *(.ctors) }
		${RELOCATING+PROVIDE (__CTOR_END__ = .);}

		${RELOCATING+PROVIDE (__DTOR_LIST__ = .);}
  .dtors	${RELOCATING-0} : { *(.dtors) }
		${RELOCATING+PROVIDE (__DTOR_END__ = .);}

		${RELOCATING+PROVIDE (_FIXUP_START_ = .);}
  .fixup	${RELOCATING-0} : { *(.fixup) }
		${RELOCATING+PROVIDE (_FIXUP_END_ = .);}
		${RELOCATING+PROVIDE (_GOT2_END_ = .);}

		${RELOCATING+PROVIDE (_GOT_START_ = .);}
  .got		${RELOCATING-0} : { *(.got) }
  .got.plt	${RELOCATING-0} : { *(.got.plt) }
  ${CREATE_SHLIB+${SDATA2}}
  ${CREATE_SHLIB+${SBSS2}}
		${RELOCATING+PROVIDE (_GOT_END_ = .);}

  ${DATA_PLT+${PLT}}
  /* 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} : { *(.sdata) }
  ${RELOCATING+_edata  =  .;}
  ${RELOCATING+PROVIDE (edata = .);}
  .sbss    ${RELOCATING-0} :
  {
    ${RELOCATING+PROVIDE (__sbss_start = .);}
    *(.sbss)
    *(.scommon)
    ${RELOCATING+PROVIDE (__sbss_end = .);}
  }
  .bss     ${RELOCATING-0} :
  {
   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
   ${RELOCATING+PROVIDE (__bss_start = .);}
   *(.dynbss)
   *(.bss)
   *(COMMON)
  }
  ${RELOCATING+_end = . ;}
  ${RELOCATING+PROVIDE (end = .);}

  /* These are needed for ELF backends which have not yet been
     converted to the new style linker.  */
  .stab 0 : { *(.stab) }
  .stabstr 0 : { *(.stabstr) }

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

  /* These must appear regardless of ${RELOCATING}.  */
  ${OTHER_SECTIONS}
}
EOF
Commit	Line	Data
5f16938d MM	1	#
	2	# Unusual variables checked by this code:
	3	# NOP - two byte opcode for no-op (defaults to 0)
	4	# DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
c2b6884b	5	# OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
5f16938d	6	# (e.g., .PARISC.milli)
c2b6884b	7	# OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
5f16938d MM	8	# (e.g., .PARISC.global)
	9	# OTHER_SECTIONS - at the end
	10	# EXECUTABLE_SYMBOLS - symbols that must be defined for an
	11	# executable (e.g., _DYNAMIC_LINK)
	12	# TEXT_START_SYMBOLS - symbols that appear at the start of the
	13	# .text section.
	14	# DATA_START_SYMBOLS - symbols that appear at the start of the
	15	# .data section.
	16	# OTHER_BSS_SYMBOLS - symbols that appear at the start of the
	17	# .bss section besides __bss_start.
	18	# DATA_PLT - .plt should be in data segment, not text segment.
	19	#
	20	# When adding sections, do note that the names of some sections are used
	21	# when specifying the start address of the next.
	22	#
	23	test -z "$ENTRY" && ENTRY=_start
	24	test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	25	test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	26	test "$LD_FLAG" = "N" && DATA_ADDR=.
c56c9218 C	27	SBSS2=".sbss2 ${RELOCATING-0} : { *(.sbss2) }"
	28	SDATA2=".sdata2 ${RELOCATING-0} : { *(.sdata2) }"
	29	INTERP=".interp ${RELOCATING-0} : { *(.interp) }"
	30	PLT=".plt ${RELOCATING-0} : { *(.plt) }"
5f16938d MM	31	cat <<EOF
	32	OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	33	"${LITTLE_OUTPUT_FORMAT}")
	34	OUTPUT_ARCH(${ARCH})
	35	ENTRY(${ENTRY})
	36
	37	${RELOCATING+${LIB_SEARCH_DIRS}}
	38	${RELOCATING+/* Do we need any of these for elf?
	39	__DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}} */}
	40	${RELOCATING+${EXECUTABLE_SYMBOLS}}
	41	${RELOCATING- /* For some reason, the Solaris linker makes bad executables
	42	if gld -r is used and the intermediate file has sections starting
	43	at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld
	44	bug. But for now assigning the zero vmas works. */}
fb2a7661 MM	45
fb2a7661 MM	46	${RELOCATING+PROVIDE (__stack = 0);}
5f16938d MM	47	SECTIONS
	48	{
	49	/* Read-only sections, merged into text segment: */
	50	${CREATE_SHLIB-${RELOCATING+. = ${TEXT_START_ADDR} + SIZEOF_HEADERS;}}
	51	${CREATE_SHLIB+${RELOCATING+. = SIZEOF_HEADERS;}}
	52	${CREATE_SHLIB-${INTERP}}
be03dc3e MM	53	.hash ${RELOCATING-0} : { *(.hash) }
	54	.dynsym ${RELOCATING-0} : { *(.dynsym) }
	55	.dynstr ${RELOCATING-0} : { *(.dynstr) }
f5f212fb ILT	56	.rela.text ${RELOCATING-0} :
	57	{ (.rela.text) (.rela.gnu.linkonce.t*) }
	58	.rela.data ${RELOCATING-0} :
	59	{ (.rela.data) (.rela.gnu.linkonce.d*) }
	60	.rela.rodata ${RELOCATING-0} :
	61	{ (.rela.rodata) (.rela.gnu.linkonce.r*) }
be03dc3e	62	.rela.got ${RELOCATING-0} : { *(.rela.got) }
be03dc3e MM	63	.rela.got1 ${RELOCATING-0} : { *(.rela.got1) }
	64	.rela.got2 ${RELOCATING-0} : { *(.rela.got2) }
	65	.rela.ctors ${RELOCATING-0} : { *(.rela.ctors) }
	66	.rela.dtors ${RELOCATING-0} : { *(.rela.dtors) }
	67	.rela.init ${RELOCATING-0} : { *(.rela.init) }
	68	.rela.fini ${RELOCATING-0} : { *(.rela.fini) }
	69	.rela.bss ${RELOCATING-0} : { *(.rela.bss) }
	70	.rela.plt ${RELOCATING-0} : { *(.rela.plt) }
c2b6884b MM	71	.rela.sdata ${RELOCATING-0} : { *(.rela.sdata2) }
	72	.rela.sbss ${RELOCATING-0} : { *(.rela.sbss2) }
	73	.rela.sdata2 ${RELOCATING-0} : { *(.rela.sdata2) }
	74	.rela.sbss2 ${RELOCATING-0} : { *(.rela.sbss2) }
5f16938d MM	75	${DATA_PLT-${PLT}}
	76	.text ${RELOCATING-0} :
	77	{
	78	${RELOCATING+${TEXT_START_SYMBOLS}}
	79	*(.text)
	80	/* .gnu.warning sections are handled specially by elf32.em. */
	81	*(.gnu.warning)
f5f212fb	82	(.gnu.linkonce.t)
5f16938d	83	} =${NOP-0}
28ad0357 MM	84	.init ${RELOCATING-0} : { *(.init) } =${NOP-0}
28ad0357 MM	85	.fini ${RELOCATING-0} : { *(.fini) } =${NOP-0}
f5f212fb	86	.rodata ${RELOCATING-0} : { (.rodata) (.gnu.linkonce.r*) }
c2b6884b	87	.rodata1 ${RELOCATING-0} : { *(.rodata1) }
28ad0357 MM	88	${RELOCATING+_etext = .;}
28ad0357 MM	89	${RELOCATING+PROVIDE (etext = .);}
c56c9218 C	90	${CREATE_SHLIB-${SDATA2}}
c56c9218 C	91	${CREATE_SHLIB-${SBSS2}}
5f16938d MM	92	${RELOCATING+${OTHER_READONLY_SECTIONS}}
5f16938d MM	93
c2b6884b MM	94	/* Adjust the address for the data segment. We want to adjust up to
	95	the same address within the page on the next page up. It would
	96	be more correct to do this:
	97	${RELOCATING+. = ${DATA_ADDR-ALIGN(${MAXPAGESIZE}) + (ALIGN(8) & (${MAXPAGESIZE} - 1))};}
	98	The current expression does not correctly handle the case of a
	99	text segment ending precisely at the end of a page; it causes the
	100	data segment to skip a page. The above expression does not have
	101	this problem, but it will currently (2/95) cause BFD to allocate
	102	a single segment, combining both text and data, for this case.
	103	This will prevent the text segment from being shared among
	104	multiple executions of the program; I think that is more
	105	important than losing a page of the virtual address space (note
	106	that no actual memory is lost; the page which is skipped can not
	107	be referenced). */
5f16938d	108	${RELOCATING+. = ${DATA_ADDR- ALIGN(8) + ${MAXPAGESIZE}};}
c2b6884b	109
5f16938d MM	110	.data ${RELOCATING-0} :
	111	{
	112	${RELOCATING+${DATA_START_SYMBOLS}}
	113	*(.data)
f5f212fb	114	(.gnu.linkonce.d)
5f16938d MM	115	${CONSTRUCTING+CONSTRUCTORS}
	116	}
	117	.data1 ${RELOCATING-0} : { *(.data1) }
	118	${RELOCATING+${OTHER_READWRITE_SECTIONS}}
5f16938d	119
4fe13b2b MM	120	.got1 ${RELOCATING-0} : { *(.got1) }
4fe13b2b MM	121	.dynamic ${RELOCATING-0} : { *(.dynamic) }
dd0f9635	122
86d0248d	123	/* Put .ctors and .dtors next to the .got2 section, so that the pointers
4fe13b2b MM	124	get relocated with -mrelocatable. Also put in the .fixup pointers.
4fe13b2b MM	125	The current compiler no longer needs this, but keep it around for 2.7.2 */
86d0248d	126
4d99a950	127	${RELOCATING+PROVIDE (_GOT2_START_ = .);}
4fe13b2b MM	128	.got2 ${RELOCATING-0} : { *(.got2) }
4fe13b2b MM	129
4d99a950	130	${RELOCATING+PROVIDE (__CTOR_LIST__ = .);}
4fe13b2b	131	.ctors ${RELOCATING-0} : { *(.ctors) }
4d99a950	132	${RELOCATING+PROVIDE (__CTOR_END__ = .);}
4fe13b2b	133
4d99a950	134	${RELOCATING+PROVIDE (__DTOR_LIST__ = .);}
4fe13b2b	135	.dtors ${RELOCATING-0} : { *(.dtors) }
4d99a950	136	${RELOCATING+PROVIDE (__DTOR_END__ = .);}
4fe13b2b	137
4d99a950	138	${RELOCATING+PROVIDE (_FIXUP_START_ = .);}
4fe13b2b	139	.fixup ${RELOCATING-0} : { *(.fixup) }
4d99a950 MM	140	${RELOCATING+PROVIDE (_FIXUP_END_ = .);}
4d99a950 MM	141	${RELOCATING+PROVIDE (_GOT2_END_ = .);}
4fe13b2b	142
4d99a950	143	${RELOCATING+PROVIDE (_GOT_START_ = .);}
4fe13b2b MM	144	.got ${RELOCATING-0} : { *(.got) }
4fe13b2b MM	145	.got.plt ${RELOCATING-0} : { *(.got.plt) }
c56c9218 C	146	${CREATE_SHLIB+${SDATA2}}
c56c9218 C	147	${CREATE_SHLIB+${SBSS2}}
4d99a950	148	${RELOCATING+PROVIDE (_GOT_END_ = .);}
1e4b4b1c	149
5f16938d MM	150	${DATA_PLT+${PLT}}
	151	/* We want the small data sections together, so single-instruction offsets
	152	can access them all, and initialized data all before uninitialized, so
	153	we can shorten the on-disk segment size. */
4d99a950	154	.sdata ${RELOCATING-0} : { *(.sdata) }
5f16938d MM	155	${RELOCATING+_edata = .;}
5f16938d MM	156	${RELOCATING+PROVIDE (edata = .);}
7453a753 MM	157	.sbss ${RELOCATING-0} :
7453a753 MM	158	{
4d99a950	159	${RELOCATING+PROVIDE (__sbss_start = .);}
7453a753 MM	160	*(.sbss)
7453a753 MM	161	*(.scommon)
4d99a950	162	${RELOCATING+PROVIDE (__sbss_end = .);}
7453a753	163	}
5f16938d MM	164	.bss ${RELOCATING-0} :
5f16938d MM	165	{
7453a753	166	${RELOCATING+${OTHER_BSS_SYMBOLS}}
4d99a950	167	${RELOCATING+PROVIDE (__bss_start = .);}
5f16938d MM	168	*(.dynbss)
	169	*(.bss)
	170	*(COMMON)
	171	}
	172	${RELOCATING+_end = . ;}
	173	${RELOCATING+PROVIDE (end = .);}
	174
	175	/* These are needed for ELF backends which have not yet been
	176	converted to the new style linker. */
	177	.stab 0 : { *(.stab) }
	178	.stabstr 0 : { *(.stabstr) }
	179
c2b6884b	180	/* DWARF debug sections.
264677bb JM	181	Symbols in the DWARF debugging sections are relative to the beginning
	182	of the section so we begin them at 0. */
	183
	184	/* DWARF 1 */
c2b6884b	185	.debug 0 : { *(.debug) }
264677bb JM	186	.line 0 : { *(.line) }
	187
	188	/* GNU DWARF 1 extensions */
	189	.debug_srcinfo 0 : { *(.debug_srcinfo) }
	190	.debug_sfnames 0 : { *(.debug_sfnames) }
	191
	192	/* DWARF 1.1 and DWARF 2 */
	193	.debug_aranges 0 : { *(.debug_aranges) }
	194	.debug_pubnames 0 : { *(.debug_pubnames) }
	195
	196	/* DWARF 2 */
9193c60b JM	197	.debug_info 0 : { *(.debug_info) }
	198	.debug_abbrev 0 : { *(.debug_abbrev) }
	199	.debug_line 0 : { *(.debug_line) }
	200	.debug_frame 0 : { *(.debug_frame) }
264677bb JM	201	.debug_str 0 : { *(.debug_str) }
	202	.debug_loc 0 : { *(.debug_loc) }
	203	.debug_macinfo 0 : { *(.debug_macinfo) }
	204
	205	/* SGI/MIPS DWARF 2 extensions */
	206	.debug_weaknames 0 : { *(.debug_weaknames) }
	207	.debug_funcnames 0 : { *(.debug_funcnames) }
	208	.debug_typenames 0 : { *(.debug_typenames) }
	209	.debug_varnames 0 : { *(.debug_varnames) }
c2b6884b	210
5f16938d MM	211	/* These must appear regardless of ${RELOCATING}. */
	212	${OTHER_SECTIONS}
	213	}
	214	EOF