1 # This file is variant of elf.sc. For nds32, because the data will be
2 # classified into different sections according to their size, this script
3 # describe these sections map. The order is ".sdata_d, .sdata_w, .sdata_h,
4 # .sdata_b, , sdata_f, .sbss_f, .sbss_b, .sbss_h, .sbss_w, .sbss_d". In
5 # this order we do not have to consider the alignment issue between these
8 if test -n "$NOP"; then
14 test -z "$RODATA_NAME" && RODATA_NAME=rodata
15 test -z "$SDATA_NAME" && SDATA_NAME=sdata
16 test -z "$SBSS_NAME" && SBSS_NAME=sbss
17 test -z "$BSS_NAME" && BSS_NAME=bss
18 test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
19 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
20 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
21 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
22 test -z "${ELFSIZE}" && ELFSIZE=32
23 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
24 test "$LD_FLAG" = "N" && DATA_ADDR=.
25 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
26 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
27 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
28 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
29 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
30 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
31 DATA_SEGMENT_RELRO_END=""
33 if test -n "${COMMONPAGESIZE}"; then
34 DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
35 DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
36 DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
38 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
39 INITIAL_READONLY_SECTIONS=".interp ${RELOCATING-0} : { *(.interp) }"
41 if test -z "$PLT"; then
42 IPLT=".iplt ${RELOCATING-0} : { *(.iplt) }"
43 PLT=".plt ${RELOCATING-0} : { *(.plt)${IREL_IN_PLT+ *(.iplt)} }
46 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=
47 if test -z "$GOT"; then
48 if test -z "$SEPARATE_GOTPLT"; then
49 GOT=".got ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) *(.got) *(.igot) }"
51 GOT=".got ${RELOCATING-0} : { *(.got) *(.igot) }"
52 GOTPLT=".got.plt ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) }"
55 REL_IFUNC=".rel.ifunc ${RELOCATING-0} : { *(.rel.ifunc) }"
56 RELA_IFUNC=".rela.ifunc ${RELOCATING-0} : { *(.rela.ifunc) }"
57 REL_IPLT=".rel.iplt ${RELOCATING-0} :
59 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
61 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
63 RELA_IPLT=".rela.iplt ${RELOCATING-0} :
65 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
67 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
69 DYNAMIC=".dynamic ${RELOCATING-0} : { *(.dynamic) }"
70 RODATA=".${RODATA_NAME} ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
71 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }"
72 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
73 if test -z "${NO_SMALL_DATA}"; then
74 SBSS=".sbss_b ${RELOCATING-0} :
76 *(.sbss_b${RELOCATING+ .sbss_b.*})
77 *(.scommon_b${RELOCATING+ .scommon_b.*})
78 ${RELOCATING+. = ALIGN(2);}
80 .sbss_h ${RELOCATING-0} :
82 *(.sbss_h${RELOCATING+ .sbss_h.*})
83 *(.scommon_h${RELOCATING+ .scommon_h.*})
84 ${RELOCATING+. = ALIGN(4);}
86 .sbss_w ${RELOCATING-0} :
88 *(.sbss_w${RELOCATING+ .sbss_w.*})
89 *(.scommon_w${RELOCATING+ .scommon_w.*})
92 ${RELOCATING+. = ALIGN(8);}
94 .sbss_d ${RELOCATING-0} :
96 *(.sbss_d${RELOCATING+ .sbss_d.*})
97 *(.scommon_d${RELOCATING+ .scommon_d.*})
98 ${RELOCATING+PROVIDE (__sbss_end = .);}
99 ${RELOCATING+PROVIDE (___sbss_end = .);}
101 SBSS2=".${SBSS_NAME}2 ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
102 SDATA="/* We want the small data sections together, so single-instruction offsets
103 can access them all, and initialized data all before uninitialized, so
104 we can shorten the on-disk segment size. */
105 .${SDATA_NAME} ${RELOCATING-0} :
107 ${RELOCATING+${SDATA_START_SYMBOLS}}
108 ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
109 *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
111 .sdata_d ${RELOCATING-0} :
113 *(.sdata_d${RELOCATING+ .sdata_d.*})
115 .sdata_w ${RELOCATING-0} :
117 *(.sdata_w${RELOCATING+ .sdata_w.*})
119 .sdata_h ${RELOCATING-0} :
121 *(.sdata_h${RELOCATING+ .sdata_h.*})
123 .sdata_b ${RELOCATING-0} :
125 *(.sdata_b${RELOCATING+ .sdata_b.*})
127 .sdata_f ${RELOCATING-0} :
129 *(.sdata_f${RELOCATING+ .sdata_f.*})
131 SDATA2=".${SDATA_NAME}2 ${RELOCATING-0} :
133 ${RELOCATING+${SDATA2_START_SYMBOLS}}
134 *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
136 REL_SDATA=".rel.${SDATA_NAME} ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
137 .rela.${SDATA_NAME} ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
138 REL_SBSS=".rel.${SBSS_NAME} ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
139 .rela.${SBSS_NAME} ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
140 REL_SDATA2=".rel.${SDATA_NAME}2 ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
141 .rela.${SDATA_NAME}2 ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
142 REL_SBSS2=".rel.${SBSS_NAME}2 ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
143 .rela.${SBSS_NAME}2 ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
147 if test -z "${DATA_GOT}"; then
148 if test -n "${NO_SMALL_DATA}"; then
152 if test -z "${SDATA_GOT}"; then
153 if test -z "${NO_SMALL_DATA}"; then
157 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
158 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
159 .rel.ldata ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
160 .rela.ldata ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
161 .rel.lbss ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
162 .rela.lbss ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
163 .rel.lrodata ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
164 .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
165 test "${LARGE_SECTIONS}" = "yes" && LARGE_BSS="
166 .lbss ${RELOCATING-0} :
169 *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
172 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
173 .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
175 *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
177 .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
179 *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
180 ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
182 if test "${ENABLE_INITFINI_ARRAY}" = "yes"; then
183 SORT_INIT_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))"
184 SORT_FINI_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))"
185 CTORS_IN_INIT_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors"
186 DTORS_IN_FINI_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors"
188 SORT_INIT_ARRAY="KEEP (*(SORT(.init_array.*)))"
189 SORT_FINI_ARRAY="KEEP (*(SORT(.fini_array.*)))"
193 INIT_ARRAY=".init_array ${RELOCATING-0} :
195 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
197 KEEP (*(.init_array ${CTORS_IN_INIT_ARRAY}))
198 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
200 FINI_ARRAY=".fini_array ${RELOCATING-0} :
202 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
204 KEEP (*(.fini_array ${DTORS_IN_FINI_ARRAY}))
205 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
207 CTOR=".ctors ${CONSTRUCTING-0} :
209 ${CONSTRUCTING+${CTOR_START}}
210 /* gcc uses crtbegin.o to find the start of
211 the constructors, so we make sure it is
212 first. Because this is a wildcard, it
213 doesn't matter if the user does not
214 actually link against crtbegin.o; the
215 linker won't look for a file to match a
216 wildcard. The wildcard also means that it
217 doesn't matter which directory crtbegin.o
220 KEEP (*crtbegin.o(.ctors))
221 KEEP (*crtbegin?.o(.ctors))
223 /* We don't want to include the .ctor section from
224 the crtend.o file until after the sorted ctors.
225 The .ctor section from the crtend file contains the
226 end of ctors marker and it must be last */
228 KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
229 KEEP (*(SORT(.ctors.*)))
231 ${CONSTRUCTING+${CTOR_END}}
233 DTOR=".dtors ${CONSTRUCTING-0} :
235 ${CONSTRUCTING+${DTOR_START}}
236 KEEP (*crtbegin.o(.dtors))
237 KEEP (*crtbegin?.o(.dtors))
238 KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
239 KEEP (*(SORT(.dtors.*)))
241 ${CONSTRUCTING+${DTOR_END}}
243 STACK=" .stack ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
245 ${RELOCATING+${USER_LABEL_PREFIX}_stack = .;}
249 TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
250 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
252 if [ -z "$SEPARATE_CODE" ]; then
253 SIZEOF_HEADERS_CODE=" + SIZEOF_HEADERS"
258 # if this is for an embedded system, don't add SIZEOF_HEADERS.
259 if [ -z "$EMBEDDED" ]; then
260 test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}${SIZEOF_HEADERS_CODE}"
263 test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
264 NDS32_INIT=".nds32_init : { KEEP(*(.nds32_init)) }"
268 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
269 "${LITTLE_OUTPUT_FORMAT}")
270 OUTPUT_ARCH(${OUTPUT_ARCH})
271 ${RELOCATING+ENTRY(${ENTRY})}
273 ${RELOCATING+${LIB_SEARCH_DIRS}}
274 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
275 ${RELOCATING+${INPUT_FILES}}
276 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
277 if gld -r is used and the intermediate file has sections starting
278 at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld
279 bug. But for now assigning the zero vmas works. */}
283 /* Read-only sections, merged into text segment: */
284 ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
285 /* Sections saved crt0 and crt1. */
287 ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
288 ${CREATE_PIE+${RELOCATING+PROVIDE (__executable_start = ${SHLIB_TEXT_START_ADDR}); . = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
294 ${INITIAL_READONLY_SECTIONS}
295 .note.gnu.build-id : { *(.note.gnu.build-id) }
299 test -n "${SEPARATE_CODE}" || emit_early_ro
301 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
302 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
303 cat > ldscripts/dyntmp.$$ <<EOF
304 ${TEXT_DYNAMIC+${DYNAMIC}}
305 .hash ${RELOCATING-0} : { *(.hash) }
306 .gnu.hash ${RELOCATING-0} : { *(.gnu.hash) }
307 .dynsym ${RELOCATING-0} : { *(.dynsym) }
308 .dynstr ${RELOCATING-0} : { *(.dynstr) }
309 .gnu.version ${RELOCATING-0} : { *(.gnu.version) }
310 .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
311 .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
314 if [ "x$COMBRELOC" = x ]; then
315 COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
317 COMBRELOCCAT="cat > $COMBRELOC"
319 eval $COMBRELOCCAT <<EOF
320 ${INITIAL_RELOC_SECTIONS}
321 .rel.init ${RELOCATING-0} : { *(.rel.init) }
322 .rela.init ${RELOCATING-0} : { *(.rela.init) }
323 .rel.text ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
324 .rela.text ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
325 .rel.fini ${RELOCATING-0} : { *(.rel.fini) }
326 .rela.fini ${RELOCATING-0} : { *(.rela.fini) }
327 .rel.${RODATA_NAME} ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
328 .rela.${RODATA_NAME} ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
329 ${OTHER_READONLY_RELOC_SECTIONS}
330 .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+ .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*}) }
331 .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+ .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*}) }
332 .rel.data ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
333 .rela.data ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
334 ${OTHER_READWRITE_RELOC_SECTIONS}
335 .rel.tdata ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
336 .rela.tdata ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
337 .rel.tbss ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
338 .rela.tbss ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
339 .rel.ctors ${RELOCATING-0} : { *(.rel.ctors) }
340 .rela.ctors ${RELOCATING-0} : { *(.rela.ctors) }
341 .rel.dtors ${RELOCATING-0} : { *(.rel.dtors) }
342 .rela.dtors ${RELOCATING-0} : { *(.rela.dtors) }
343 .rel.got ${RELOCATING-0} : { *(.rel.got) }
344 .rela.got ${RELOCATING-0} : { *(.rela.got) }
345 ${OTHER_GOT_RELOC_SECTIONS}
350 .rel.${BSS_NAME} ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
351 .rela.${BSS_NAME} ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
353 ${IREL_IN_PLT+$REL_IFUNC}
354 ${IREL_IN_PLT+$RELA_IFUNC}
355 ${IREL_IN_PLT-$REL_IPLT}
356 ${IREL_IN_PLT-$RELA_IPLT}
359 if [ -n "$COMBRELOC" ]; then
360 cat >> ldscripts/dyntmp.$$ <<EOF
361 .rel.dyn ${RELOCATING-0} :
364 sed -e '/^[ ]*[{}][ ]*$/d;/:[ ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/ \1/' $COMBRELOC >> ldscripts/dyntmp.$$
365 cat >> ldscripts/dyntmp.$$ <<EOF
367 .rela.dyn ${RELOCATING-0} :
370 sed -e '/^[ ]*[{}][ ]*$/d;/:[ ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/ \1/' $COMBRELOC >> ldscripts/dyntmp.$$
371 cat >> ldscripts/dyntmp.$$ <<EOF
376 cat >> ldscripts/dyntmp.$$ <<EOF
377 .rel.plt ${RELOCATING-0} :
380 ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}}
381 ${IREL_IN_PLT+${RELOCATING+*(.rel.iplt)}}
382 ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}}
384 .rela.plt ${RELOCATING-0} :
387 ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}}
388 ${IREL_IN_PLT+${RELOCATING+*(.rela.iplt)}}
389 ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}}
391 ${OTHER_PLT_RELOC_SECTIONS}
396 if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
397 cat ldscripts/dyntmp.$$
399 if test -z "${NO_REL_RELOCS}"; then
400 sed -e '/^[ ]*\.rela\.[^}]*$/,/}/d' -e '/^[ ]*\.rela\./d' ldscripts/dyntmp.$$
402 if test -z "${NO_RELA_RELOCS}"; then
403 sed -e '/^[ ]*\.rel\.[^}]*$/,/}/d' -e '/^[ ]*\.rel\./d' ldscripts/dyntmp.$$
406 rm -f ldscripts/dyntmp.$$
409 test -n "${NON_ALLOC_DYN}${SEPARATE_CODE}" || emit_dyn
412 .init ${RELOCATING-0} :
414 ${RELOCATING+${INIT_START}}
415 KEEP (*(SORT_NONE(.init)))
416 ${RELOCATING+${INIT_END}}
419 ${TEXT_PLT+${PLT_NEXT_DATA-${PLT}}}
420 ${TINY_READONLY_SECTION}
421 .text ${RELOCATING-0} :
423 ${RELOCATING+${TEXT_START_SYMBOLS}}
424 ${RELOCATING+*(.text.unlikely .text.*_unlikely .text.unlikely.*)}
425 ${RELOCATING+*(.text.exit .text.exit.*)}
426 ${RELOCATING+*(.text.startup .text.startup.*)}
427 ${RELOCATING+*(.text.hot .text.hot.*)}
428 *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
429 /* .gnu.warning sections are handled specially by elf32.em. */
431 ${RELOCATING+${OTHER_TEXT_SECTIONS}}
433 .fini ${RELOCATING-0} :
435 ${RELOCATING+${FINI_START}}
436 KEEP (*(SORT_NONE(.fini)))
437 ${RELOCATING+${FINI_END}}
439 ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
440 ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
441 ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
444 if test -n "${SEPARATE_CODE}"; then
445 if test -n "${RODATA_ADDR}"; then
447 SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR}) + SIZEOF_HEADERS"
449 RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
450 RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR})"
452 if test -n "${SHLIB_RODATA_ADDR}"; then
454 SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR}) + SIZEOF_HEADERS"
456 SHLIB_RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR})"
457 SHLIB_RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
460 /* Adjust the address for the rodata segment. We want to adjust up to
461 the same address within the page on the next page up. */
462 ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${RODATA_ADDR};}}}
463 ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
464 ${CREATE_PIE+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
471 ${WRITABLE_RODATA-${RODATA}}
472 .${RODATA_NAME}1 ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
473 ${CREATE_SHLIB-${SDATA2}}
474 ${CREATE_SHLIB-${SBSS2}}
475 ${OTHER_READONLY_SECTIONS}
476 .eh_frame_hdr : { *(.eh_frame_hdr) }
477 .eh_frame ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
478 .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table
479 .gcc_except_table.*) }
480 /* These sections are generated by the Sun/Oracle C++ compiler. */
481 .exception_ranges ${RELOCATING-0} : ONLY_IF_RO { *(.exception_ranges
482 .exception_ranges*) }
483 ${TEXT_PLT+${PLT_NEXT_DATA+${PLT}}}
485 /* Adjust the address for the data segment. We want to adjust up to
486 the same address within the page on the next page up. */
487 ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
488 ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
489 ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
491 /* Exception handling */
492 .eh_frame ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
493 .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
494 .exception_ranges ${RELOCATING-0} : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
496 /* Thread Local Storage sections */
497 .tdata ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
498 .tbss ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
500 .preinit_array ${RELOCATING-0} :
502 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
503 KEEP (*(.preinit_array))
504 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
506 ${RELOCATING+${INIT_ARRAY}}
507 ${RELOCATING+${FINI_ARRAY}}
508 ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
509 ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
510 .jcr ${RELOCATING-0} : { KEEP (*(.jcr)) }
512 ${RELOCATING+${DATARELRO}}
513 ${OTHER_RELRO_SECTIONS}
514 ${TEXT_DYNAMIC-${DYNAMIC}}
515 ${DATA_GOT+${RELRO_NOW+${GOT}}}
516 ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
517 ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
518 ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
519 ${INITIAL_READWRITE_SECTIONS}
520 ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
521 ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
523 ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
525 /* For _SDA_BASE_ aligment. */
526 ${RELOCATING+. = ALIGN(4);}
528 .data ${RELOCATING-0} :
530 ${RELOCATING+${DATA_START_SYMBOLS}}
531 *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
532 ${CONSTRUCTING+SORT(CONSTRUCTORS)}
534 .data1 ${RELOCATING-0} : { *(.data1) }
535 ${WRITABLE_RODATA+${RODATA}}
536 ${OTHER_READWRITE_SECTIONS}
537 ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
538 ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
539 ${RELOCATING+. = ALIGN(4);}
540 ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
541 ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS+. = .; ${OTHER_GOT_SYMBOLS}}}}
543 ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
545 ${OTHER_SDATA_SECTIONS}
546 ${RELOCATING+. = ALIGN(4);}
547 ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
549 ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
550 ${RELOCATING+${OTHER_BSS_SYMBOLS}}
553 .${BSS_NAME} ${RELOCATING-0} :
556 *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
558 /* Align here to ensure that the .bss section occupies space up to
559 _end. Align after .bss to ensure correct alignment even if the
560 .bss section disappears because there are no input sections.
561 FIXME: Why do we need it? When there is no .bss section, we don't
562 pad the .data section. */
563 ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
565 ${OTHER_BSS_SECTIONS}
566 ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
567 ${RELOCATING+_end = .;}
568 ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
569 ${RELOCATING+. = ALIGN(${ALIGNMENT});}
572 LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
573 SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
576 ${RELOCATING+${CREATE_SHLIB-${CREATE_PIE-${LARGE_DATA_ADDR}}}}
577 ${RELOCATING+${CREATE_SHLIB+${SHLIB_LARGE_DATA_ADDR}}}
578 ${RELOCATING+${CREATE_PIE+${SHLIB_LARGE_DATA_ADDR}}}
580 ${LARGE_BSS_AFTER_BSS-${LARGE_BSS}}
581 ${RELOCATING+. = ALIGN(${ALIGNMENT});}
582 ${RELOCATING+${OTHER_END_SYMBOLS}}
583 ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
584 ${RELOCATING+${DATA_SEGMENT_END}}
587 test -z "${NON_ALLOC_DYN}" || emit_dyn
590 /* Stabs debugging sections. */
591 .stab 0 : { *(.stab) }
592 .stabstr 0 : { *(.stabstr) }
593 .stab.excl 0 : { *(.stab.excl) }
594 .stab.exclstr 0 : { *(.stab.exclstr) }
595 .stab.index 0 : { *(.stab.index) }
596 .stab.indexstr 0 : { *(.stab.indexstr) }
598 .comment 0 : { *(.comment) }
602 . $srcdir/scripttempl/DWARF.sc
609 ${STACK_ADDR+${STACK}}
612 ${RELOCATING+${OTHER_SYMBOLS}}
613 ${RELOCATING+${DISCARDED}}