Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / ld / scripttempl / elf.sc
1 #
2 # Unusual variables checked by this code:
3 #       NOP - four byte opcode for no-op (defaults to 0)
4 #       NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
5 #               empty.
6 #       SMALL_DATA_CTOR - .ctors contains small data.
7 #       SMALL_DATA_DTOR - .dtors contains small data.
8 #       DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
9 #       INITIAL_READONLY_SECTIONS - at start of text segment
10 #       OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
11 #               (e.g., .PARISC.milli)
12 #       OTHER_TEXT_SECTIONS - these get put in .text when relocating
13 #       OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
14 #               (e.g., .PARISC.global)
15 #       OTHER_RELRO_SECTIONS - other than .data.rel.ro ...
16 #               (e.g. PPC32 .fixup, .got[12])
17 #       OTHER_BSS_SECTIONS - other than .bss .sbss ...
18 #       ATTRS_SECTIONS - at the end
19 #       OTHER_SECTIONS - at the end
20 #       EXECUTABLE_SYMBOLS - symbols that must be defined for an
21 #               executable (e.g., _DYNAMIC_LINK)
22 #       TEXT_START_ADDR - the first byte of the text segment, after any
23 #               headers.
24 #       TEXT_BASE_ADDRESS - the first byte of the text segment.
25 #       TEXT_START_SYMBOLS - symbols that appear at the start of the
26 #               .text section.
27 #       DATA_START_SYMBOLS - symbols that appear at the start of the
28 #               .data section.
29 #       DATA_END_SYMBOLS - symbols that appear at the end of the
30 #               writeable data sections.
31 #       OTHER_GOT_SYMBOLS - symbols defined just before .got.
32 #       OTHER_GOT_SECTIONS - sections just after .got.
33 #       OTHER_SDATA_SECTIONS - sections just after .sdata.
34 #       OTHER_BSS_SYMBOLS - symbols that appear at the start of the
35 #               .bss section besides __bss_start.
36 #       DATA_PLT - .plt should be in data segment, not text segment.
37 #       PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.
38 #       BSS_PLT - .plt should be in bss segment
39 #       NO_REL_RELOCS - Don't include .rel.* sections in script
40 #       NO_RELA_RELOCS - Don't include .rela.* sections in script
41 #       NON_ALLOC_DYN - Place dynamic sections after data segment.
42 #       TEXT_DYNAMIC - .dynamic in text segment, not data segment.
43 #       EMBEDDED - whether this is for an embedded system. 
44 #       SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
45 #               start address of shared library.
46 #       INPUT_FILES - INPUT command of files to always include
47 #       WRITABLE_RODATA - if set, the .rodata section should be writable
48 #       INIT_START, INIT_END -  statements just before and just after
49 #       combination of .init sections.
50 #       FINI_START, FINI_END - statements just before and just after
51 #       combination of .fini sections.
52 #       STACK_ADDR - start of a .stack section.
53 #       OTHER_SYMBOLS - symbols to place right at the end of the script.
54 #       ETEXT_NAME - name of a symbol for the end of the text section,
55 #               normally etext.
56 #       SEPARATE_GOTPLT - if set, .got.plt should be separate output section,
57 #               so that .got can be in the RELRO area.  It should be set to
58 #               the number of bytes in the beginning of .got.plt which can be
59 #               in the RELRO area as well.
60 #       USER_LABEL_PREFIX - prefix to add to user-visible symbols.
61 #       RODATA_NAME, SDATA_NAME, SBSS_NAME, BSS_NAME - base parts of names
62 #               for standard sections, without initial "." or suffixes.
63 #
64 # When adding sections, do note that the names of some sections are used
65 # when specifying the start address of the next.
66 #
67
68 #  Many sections come in three flavours.  There is the 'real' section,
69 #  like ".data".  Then there are the per-procedure or per-variable
70 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
71 #  and useful for --gc-sections, which for a variable "foo" might be
72 #  ".data.foo".  Then there are the linkonce sections, for which the linker
73 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
74 #  The exact correspondences are:
75 #
76 #  Section      Linkonce section
77 #  .text        .gnu.linkonce.t.foo
78 #  .rodata      .gnu.linkonce.r.foo
79 #  .data        .gnu.linkonce.d.foo
80 #  .bss         .gnu.linkonce.b.foo
81 #  .sdata       .gnu.linkonce.s.foo
82 #  .sbss        .gnu.linkonce.sb.foo
83 #  .sdata2      .gnu.linkonce.s2.foo
84 #  .sbss2       .gnu.linkonce.sb2.foo
85 #  .debug_info  .gnu.linkonce.wi.foo
86 #  .tdata       .gnu.linkonce.td.foo
87 #  .tbss        .gnu.linkonce.tb.foo
88 #  .lrodata     .gnu.linkonce.lr.foo
89 #  .ldata       .gnu.linkonce.l.foo
90 #  .lbss        .gnu.linkonce.lb.foo
91 #
92 #  Each of these can also have corresponding .rel.* and .rela.* sections.
93
94 test -z "$RODATA_NAME" && RODATA_NAME=rodata
95 test -z "$SDATA_NAME" && SDATA_NAME=sdata
96 test -z "$SBSS_NAME" && SBSS_NAME=sbss
97 test -z "$BSS_NAME" && BSS_NAME=bss
98 test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
99 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
100 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
101 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
102 test -z "${ELFSIZE}" && ELFSIZE=32
103 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
104 test "$LD_FLAG" = "N" && DATA_ADDR=.
105 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
106 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
107 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
108 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
109 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
110 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
111 DATA_SEGMENT_RELRO_END=""
112 DATA_SEGMENT_END=""
113 if test -n "${COMMONPAGESIZE}"; then
114   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
115   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
116   DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
117 fi
118 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
119   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
120 fi
121 if test -z "$PLT"; then
122   IPLT=".iplt         ${RELOCATING-0} : { *(.iplt) }"
123   PLT=".plt          ${RELOCATING-0} : { *(.plt)${IREL_IN_PLT+ *(.iplt)} }
124   ${IREL_IN_PLT-$IPLT}"
125 fi
126 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=yes
127 if test -z "$GOT"; then
128   if test -z "$SEPARATE_GOTPLT"; then
129     GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) *(.got) *(.igot) }"
130   else
131     GOT=".got          ${RELOCATING-0} : { *(.got) *(.igot) }"
132     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt)  *(.igot.plt) }"
133   fi
134 fi
135 REL_IFUNC=".rel.ifunc    ${RELOCATING-0} : { *(.rel.ifunc) }"
136 RELA_IFUNC=".rela.ifunc   ${RELOCATING-0} : { *(.rela.ifunc) }"
137 REL_IPLT=".rel.iplt     ${RELOCATING-0} :
138     {
139       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
140       *(.rel.iplt)
141       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
142     }"
143 RELA_IPLT=".rela.iplt    ${RELOCATING-0} :
144     {
145       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
146       *(.rela.iplt)
147       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
148     }"
149 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
150 RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
151 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }"
152 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
153 if test -z "${NO_SMALL_DATA}"; then
154   SBSS=".${SBSS_NAME}         ${RELOCATING-0} :
155   {
156     ${RELOCATING+${SBSS_START_SYMBOLS}}
157     ${CREATE_SHLIB+*(.${SBSS_NAME}2 .${SBSS_NAME}2.* .gnu.linkonce.sb2.*)}
158     *(.dyn${SBSS_NAME})
159     *(.${SBSS_NAME}${RELOCATING+ .${SBSS_NAME}.* .gnu.linkonce.sb.*})
160     *(.scommon)
161     ${RELOCATING+${SBSS_END_SYMBOLS}}
162   }"
163   SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
164   SDATA="/* We want the small data sections together, so single-instruction offsets
165      can access them all, and initialized data all before uninitialized, so
166      we can shorten the on-disk segment size.  */
167   .${SDATA_NAME}        ${RELOCATING-0} : 
168   {
169     ${RELOCATING+${SDATA_START_SYMBOLS}}
170     ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
171     *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
172   }"
173   SDATA2=".${SDATA_NAME}2       ${RELOCATING-0} :
174   {
175     ${RELOCATING+${SDATA2_START_SYMBOLS}}
176     *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
177   }"
178   REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
179   .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
180   REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
181   .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
182   REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
183   .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
184   REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
185   .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
186 else
187   NO_SMALL_DATA=" "
188 fi
189 if test -z "${DATA_GOT}"; then
190   if test -n "${NO_SMALL_DATA}"; then
191     DATA_GOT=" "
192   fi
193 fi
194 if test -z "${SDATA_GOT}"; then
195   if test -z "${NO_SMALL_DATA}"; then
196     SDATA_GOT=" "
197   fi
198 fi
199 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
200 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
201   .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
202   .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
203   .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
204   .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
205   .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
206   .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
207 test "${LARGE_SECTIONS}" = "yes" && OTHER_BSS_SECTIONS="
208   ${OTHER_BSS_SECTIONS}
209   .lbss ${RELOCATING-0} :
210   {
211     *(.dynlbss)
212     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
213     *(LARGE_COMMON)
214   }"
215 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
216   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
217   {
218     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
219   }
220   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
221   {
222     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
223     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
224   }"
225 INIT_ARRAY=".init_array   ${RELOCATING-0} :
226   {
227     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
228     KEEP (*(SORT(.init_array.*)))
229     KEEP (*(.init_array))
230     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
231   }"
232 FINI_ARRAY=".fini_array   ${RELOCATING-0} :
233   {
234     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
235     KEEP (*(SORT(.fini_array.*)))
236     KEEP (*(.fini_array))
237     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
238   }"
239 CTOR=".ctors        ${CONSTRUCTING-0} : 
240   {
241     ${CONSTRUCTING+${CTOR_START}}
242     /* gcc uses crtbegin.o to find the start of
243        the constructors, so we make sure it is
244        first.  Because this is a wildcard, it
245        doesn't matter if the user does not
246        actually link against crtbegin.o; the
247        linker won't look for a file to match a
248        wildcard.  The wildcard also means that it
249        doesn't matter which directory crtbegin.o
250        is in.  */
251
252     KEEP (*crtbegin.o(.ctors))
253     KEEP (*crtbegin?.o(.ctors))
254
255     /* We don't want to include the .ctor section from
256        the crtend.o file until after the sorted ctors.
257        The .ctor section from the crtend file contains the
258        end of ctors marker and it must be last */
259
260     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
261     KEEP (*(SORT(.ctors.*)))
262     KEEP (*(.ctors))
263     ${CONSTRUCTING+${CTOR_END}}
264   }"
265 DTOR=".dtors        ${CONSTRUCTING-0} :
266   {
267     ${CONSTRUCTING+${DTOR_START}}
268     KEEP (*crtbegin.o(.dtors))
269     KEEP (*crtbegin?.o(.dtors))
270     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
271     KEEP (*(SORT(.dtors.*)))
272     KEEP (*(.dtors))
273     ${CONSTRUCTING+${DTOR_END}}
274   }"
275 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
276   {
277     ${RELOCATING+${USER_LABEL_PREFIX}_stack = .;}
278     *(.stack)
279   }"
280
281 TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
282 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
283
284 # if this is for an embedded system, don't add SIZEOF_HEADERS.
285 if [ -z "$EMBEDDED" ]; then
286    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
287 else
288    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
289 fi
290
291 cat <<EOF
292 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
293               "${LITTLE_OUTPUT_FORMAT}")
294 OUTPUT_ARCH(${OUTPUT_ARCH})
295 ${RELOCATING+ENTRY(${ENTRY})}
296
297 ${RELOCATING+${LIB_SEARCH_DIRS}}
298 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
299 ${RELOCATING+${INPUT_FILES}}
300 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
301   if gld -r is used and the intermediate file has sections starting
302   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
303   bug.  But for now assigning the zero vmas works.  */}
304
305 SECTIONS
306 {
307   /* Read-only sections, merged into text segment: */
308   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
309   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS;}}
310   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS;}}
311   ${INITIAL_READONLY_SECTIONS}
312   .note.gnu.build-id : { *(.note.gnu.build-id) }
313 EOF
314
315 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
316 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
317 cat > ldscripts/dyntmp.$$ <<EOF
318   ${TEXT_DYNAMIC+${DYNAMIC}}
319   .hash         ${RELOCATING-0} : { *(.hash) }
320   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
321   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
322   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
323   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
324   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
325   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
326 EOF
327
328 if [ "x$COMBRELOC" = x ]; then
329   COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
330 else
331   COMBRELOCCAT="cat > $COMBRELOC"
332 fi
333 eval $COMBRELOCCAT <<EOF
334   ${INITIAL_RELOC_SECTIONS}
335   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
336   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
337   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
338   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
339   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
340   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
341   .rel.${RODATA_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
342   .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
343   ${OTHER_READONLY_RELOC_SECTIONS}
344   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+* .rel.gnu.linkonce.d.rel.ro.*}) }
345   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+* .rela.gnu.linkonce.d.rel.ro.*}) }
346   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
347   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
348   ${OTHER_READWRITE_RELOC_SECTIONS}
349   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
350   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
351   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
352   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
353   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
354   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
355   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
356   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
357   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
358   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
359   ${OTHER_GOT_RELOC_SECTIONS}
360   ${REL_SDATA}
361   ${REL_SBSS}
362   ${REL_SDATA2}
363   ${REL_SBSS2}
364   .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
365   .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
366   ${REL_LARGE}
367   ${IREL_IN_PLT+$REL_IFUNC}
368   ${IREL_IN_PLT+$RELA_IFUNC}
369   ${IREL_IN_PLT-$REL_IPLT}
370   ${IREL_IN_PLT-$RELA_IPLT}
371 EOF
372
373 if [ -n "$COMBRELOC" ]; then
374 cat >> ldscripts/dyntmp.$$ <<EOF
375   .rel.dyn      ${RELOCATING-0} :
376     {
377 EOF
378 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
379 cat >> ldscripts/dyntmp.$$ <<EOF
380     }
381   .rela.dyn     ${RELOCATING-0} :
382     {
383 EOF
384 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
385 cat >> ldscripts/dyntmp.$$ <<EOF
386     }
387 EOF
388 fi
389
390 cat >> ldscripts/dyntmp.$$ <<EOF
391   .rel.plt      ${RELOCATING-0} :
392     {
393       *(.rel.plt)
394       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}}
395       ${IREL_IN_PLT+${RELOCATING+*(.rel.iplt)}}
396       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}}
397     }
398   .rela.plt     ${RELOCATING-0} :
399     {
400       *(.rela.plt)
401       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}}
402       ${IREL_IN_PLT+${RELOCATING+*(.rela.iplt)}}
403       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}}
404     }
405   ${OTHER_PLT_RELOC_SECTIONS}
406 EOF
407
408 if test -z "${NON_ALLOC_DYN}"; then
409   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
410     cat ldscripts/dyntmp.$$
411   else
412     if test -z "${NO_REL_RELOCS}"; then
413       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
414     fi
415     if test -z "${NO_RELA_RELOCS}"; then
416       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
417     fi
418   fi
419   rm -f ldscripts/dyntmp.$$
420 fi
421
422 cat <<EOF
423   .init         ${RELOCATING-0} : 
424   { 
425     ${RELOCATING+${INIT_START}}
426     KEEP (*(.init))
427     ${RELOCATING+${INIT_END}}
428   } =${NOP-0}
429
430   ${TEXT_PLT+${PLT}}
431   ${TINY_READONLY_SECTION}
432   .text         ${RELOCATING-0} :
433   {
434     ${RELOCATING+${TEXT_START_SYMBOLS}}
435     ${RELOCATING+*(.text.unlikely .text.*_unlikely)}
436     ${RELOCATING+*(.text.exit .text.exit.*)}
437     ${RELOCATING+*(.text.startup .text.startup.*)}
438     ${RELOCATING+*(.text.hot .text.hot.*)}
439     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
440     /* .gnu.warning sections are handled specially by elf32.em.  */
441     *(.gnu.warning)
442     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
443   } =${NOP-0}
444   .fini         ${RELOCATING-0} :
445   {
446     ${RELOCATING+${FINI_START}}
447     KEEP (*(.fini))
448     ${RELOCATING+${FINI_END}}
449   } =${NOP-0}
450   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
451   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
452   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
453   ${WRITABLE_RODATA-${RODATA}}
454   .${RODATA_NAME}1      ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
455   ${CREATE_SHLIB-${SDATA2}}
456   ${CREATE_SHLIB-${SBSS2}}
457   ${OTHER_READONLY_SECTIONS}
458   .eh_frame_hdr : { *(.eh_frame_hdr) }
459   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
460   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
461
462   /* Adjust the address for the data segment.  We want to adjust up to
463      the same address within the page on the next page up.  */
464   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
465   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
466   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
467
468   /* Exception handling  */
469   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
470   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
471
472   /* Thread Local Storage sections  */
473   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
474   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
475
476   .preinit_array   ${RELOCATING-0} :
477   {
478     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
479     KEEP (*(.preinit_array))
480     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
481   }
482   ${RELOCATING+${INIT_ARRAY}}
483   ${RELOCATING+${FINI_ARRAY}}
484   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
485   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
486   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
487
488   ${RELOCATING+${DATARELRO}}
489   ${OTHER_RELRO_SECTIONS}
490   ${TEXT_DYNAMIC-${DYNAMIC}}
491   ${DATA_GOT+${RELRO_NOW+${GOT}}}
492   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
493   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
494   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
495   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
496   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
497
498   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
499
500   .data         ${RELOCATING-0} :
501   {
502     ${RELOCATING+${DATA_START_SYMBOLS}}
503     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
504     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
505   }
506   .data1        ${RELOCATING-0} : { *(.data1) }
507   ${WRITABLE_RODATA+${RODATA}}
508   ${OTHER_READWRITE_SECTIONS}
509   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
510   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
511   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
512   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS}}}
513   ${SDATA_GOT+${GOT}}
514   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
515   ${SDATA}
516   ${OTHER_SDATA_SECTIONS}
517   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
518   ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
519   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
520   ${SBSS}
521   ${BSS_PLT+${PLT}}
522   .${BSS_NAME}          ${RELOCATING-0} :
523   {
524    *(.dyn${BSS_NAME})
525    *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
526    *(COMMON)
527    /* Align here to ensure that the .bss section occupies space up to
528       _end.  Align after .bss to ensure correct alignment even if the
529       .bss section disappears because there are no input sections.
530       FIXME: Why do we need it? When there is no .bss section, we don't
531       pad the .data section.  */
532    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
533   }
534   ${OTHER_BSS_SECTIONS}
535   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
536   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
537   ${LARGE_SECTIONS}
538   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
539   ${RELOCATING+${OTHER_END_SYMBOLS}}
540   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
541   ${RELOCATING+${DATA_SEGMENT_END}}
542 EOF
543
544 if test -n "${NON_ALLOC_DYN}"; then
545   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
546     cat ldscripts/dyntmp.$$
547   else
548     if test -z "${NO_REL_RELOCS}"; then
549       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
550     fi
551     if test -z "${NO_RELA_RELOCS}"; then
552       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
553     fi
554   fi
555   rm -f ldscripts/dyntmp.$$
556 fi
557
558 cat <<EOF
559   /* Stabs debugging sections.  */
560   .stab          0 : { *(.stab) }
561   .stabstr       0 : { *(.stabstr) }
562   .stab.excl     0 : { *(.stab.excl) }
563   .stab.exclstr  0 : { *(.stab.exclstr) }
564   .stab.index    0 : { *(.stab.index) }
565   .stab.indexstr 0 : { *(.stab.indexstr) }
566
567   .comment       0 : { *(.comment) }
568
569   /* DWARF debug sections.
570      Symbols in the DWARF debugging sections are relative to the beginning
571      of the section so we begin them at 0.  */
572
573   /* DWARF 1 */
574   .debug          0 : { *(.debug) }
575   .line           0 : { *(.line) }
576
577   /* GNU DWARF 1 extensions */
578   .debug_srcinfo  0 : { *(.debug_srcinfo) }
579   .debug_sfnames  0 : { *(.debug_sfnames) }
580
581   /* DWARF 1.1 and DWARF 2 */
582   .debug_aranges  0 : { *(.debug_aranges) }
583   .debug_pubnames 0 : { *(.debug_pubnames) }
584
585   /* DWARF 2 */
586   .debug_info     0 : { *(.debug_info${RELOCATING+ .gnu.linkonce.wi.*}) }
587   .debug_abbrev   0 : { *(.debug_abbrev) }
588   .debug_line     0 : { *(.debug_line) }
589   .debug_frame    0 : { *(.debug_frame) }
590   .debug_str      0 : { *(.debug_str) }
591   .debug_loc      0 : { *(.debug_loc) }
592   .debug_macinfo  0 : { *(.debug_macinfo) }
593
594   /* SGI/MIPS DWARF 2 extensions */
595   .debug_weaknames 0 : { *(.debug_weaknames) }
596   .debug_funcnames 0 : { *(.debug_funcnames) }
597   .debug_typenames 0 : { *(.debug_typenames) }
598   .debug_varnames  0 : { *(.debug_varnames) }
599
600   /* DWARF 3 */
601   .debug_pubtypes 0 : { *(.debug_pubtypes) }
602   .debug_ranges   0 : { *(.debug_ranges) }
603
604   ${TINY_DATA_SECTION}
605   ${TINY_BSS_SECTION}
606
607   ${STACK_ADDR+${STACK}}
608   ${ATTRS_SECTIONS}
609   ${OTHER_SECTIONS}
610   ${RELOCATING+${OTHER_SYMBOLS}}
611   ${RELOCATING+${DISCARDED}}
612 }
613 EOF