projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PowerPC64 ELFv2 ABI: structure passing / return
[deliverable/binutils-gdb.git] / ld / scripttempl / nds32elf.sc
CommitLineData
35c08157
KLC		 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
6# sections.
7
8if test -n "$NOP"; then
9 FILL="=$NOP"
10else
11 FILL=
12fi
13
14test -z "$RODATA_NAME" && RODATA_NAME=rodata
15test -z "$SDATA_NAME" && SDATA_NAME=sdata
16test -z "$SBSS_NAME" && SBSS_NAME=sbss
17test -z "$BSS_NAME" && BSS_NAME=bss
18test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
19test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
20test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
21if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
22test -z "${ELFSIZE}" && ELFSIZE=32
23test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
24test "$LD_FLAG" = "N" && DATA_ADDR=.
25test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
26test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
27test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
28test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
29test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
30DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
31DATA_SEGMENT_RELRO_END=""
32DATA_SEGMENT_END=""
33if 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}, .);"
37fi
38if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
39 INITIAL_READONLY_SECTIONS=".interp ${RELOCATING-0} : { *(.interp) }"
40fi
41if test -z "$PLT"; then
42 IPLT=".iplt ${RELOCATING-0} : { *(.iplt) }"
43 PLT=".plt ${RELOCATING-0} : { *(.plt)${IREL_IN_PLT+ *(.iplt)} }
44 ${IREL_IN_PLT-$IPLT}"
45fi
46test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=
47if test -z "$GOT"; then
48 if test -z "$SEPARATE_GOTPLT"; then
49 GOT=".got ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) *(.got) *(.igot) }"
50 else
51 GOT=".got ${RELOCATING-0} : { *(.got) *(.igot) }"
52 GOTPLT=".got.plt ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) }"
53 fi
54fi
55REL_IFUNC=".rel.ifunc ${RELOCATING-0} : { *(.rel.ifunc) }"
56RELA_IFUNC=".rela.ifunc ${RELOCATING-0} : { *(.rela.ifunc) }"
57REL_IPLT=".rel.iplt ${RELOCATING-0} :
58 {
59 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
60 *(.rel.iplt)
61 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
62 }"
63RELA_IPLT=".rela.iplt ${RELOCATING-0} :
64 {
65 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
66 *(.rela.iplt)
67 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
68 }"
69DYNAMIC=".dynamic ${RELOCATING-0} : { *(.dynamic) }"
70RODATA=".${RODATA_NAME} ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
71DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }"
72DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
73if test -z "${NO_SMALL_DATA}"; then
74 SBSS=".sbss_b ${RELOCATING-0} :
75 {
76 *(.sbss_b${RELOCATING+ .sbss_b.*})
77 *(.scommon_b${RELOCATING+ .scommon_b.*})
78 ${RELOCATING+. = ALIGN(2);}
79 }
80 .sbss_h ${RELOCATING-0} :
81 {
82 *(.sbss_h${RELOCATING+ .sbss_h.*})
83 *(.scommon_h${RELOCATING+ .scommon_h.*})
84 ${RELOCATING+. = ALIGN(4);}
85 }
86 .sbss_w ${RELOCATING-0} :
87 {
88 *(.sbss_w${RELOCATING+ .sbss_w.*})
89 *(.scommon_w${RELOCATING+ .scommon_w.*})
90 *(.dynsbss)
91 *(.scommon)
92 ${RELOCATING+. = ALIGN(8);}
93 }
94 .sbss_d ${RELOCATING-0} :
95 {
96 *(.sbss_d${RELOCATING+ .sbss_d.*})
97 *(.scommon_d${RELOCATING+ .scommon_d.*})
98 ${RELOCATING+PROVIDE (__sbss_end = .);}
99 ${RELOCATING+PROVIDE (___sbss_end = .);}
100 }"
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} :
106 {
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.*})
110 }
111 .sdata_d ${RELOCATING-0} :
112 {
113 *(.sdata_d${RELOCATING+ .sdata_d.*})
114 }
115 .sdata_w ${RELOCATING-0} :
116 {
117 *(.sdata_w${RELOCATING+ .sdata_w.*})
118 }
119 .sdata_h ${RELOCATING-0} :
120 {
121 *(.sdata_h${RELOCATING+ .sdata_h.*})
122 }
123 .sdata_b ${RELOCATING-0} :
124 {
125 *(.sdata_b${RELOCATING+ .sdata_b.*})
126 }
127 .sdata_f ${RELOCATING-0} :
128 {
129 *(.sdata_f${RELOCATING+ .sdata_f.*})
130 }"
131 SDATA2=".${SDATA_NAME}2 ${RELOCATING-0} :
132 {
133 ${RELOCATING+${SDATA2_START_SYMBOLS}}
134 *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
135 }"
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.*}) }"
144else
145 NO_SMALL_DATA=" "
146fi
147if test -z "${DATA_GOT}"; then
148 if test -n "${NO_SMALL_DATA}"; then
149 DATA_GOT=" "
150 fi
151fi
152if test -z "${SDATA_GOT}"; then
153 if test -z "${NO_SMALL_DATA}"; then
154 SDATA_GOT=" "
155 fi
156fi
157test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
158test "${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.*}) }"
165test "${LARGE_SECTIONS}" = "yes" && LARGE_BSS="
166 .lbss ${RELOCATING-0} :
167 {
168 *(.dynlbss)
169 *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
170 *(LARGE_COMMON)
171 }"
172test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
173 .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
174 {
175 *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
176 }
177 .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
178 {
179 *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
180 ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
181 }"
182if 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"
187else
188 SORT_INIT_ARRAY="KEEP (*(SORT(.init_array.*)))"
189 SORT_FINI_ARRAY="KEEP (*(SORT(.fini_array.*)))"
190 CTORS_IN_INIT_ARRAY=
191 DTORS_IN_FINI_ARRAY=
192fi
193INIT_ARRAY=".init_array ${RELOCATING-0} :
194 {
195 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
196 ${SORT_INIT_ARRAY}
197 KEEP (*(.init_array ${CTORS_IN_INIT_ARRAY}))
198 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
199 }"
200FINI_ARRAY=".fini_array ${RELOCATING-0} :
201 {
202 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
203 ${SORT_FINI_ARRAY}
204 KEEP (*(.fini_array ${DTORS_IN_FINI_ARRAY}))
205 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
206 }"
207CTOR=".ctors ${CONSTRUCTING-0} :
208 {
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
218 is in. */
219
220 KEEP (*crtbegin.o(.ctors))
221 KEEP (*crtbegin?.o(.ctors))
222
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 */
227
228 KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
229 KEEP (*(SORT(.ctors.*)))
230 KEEP (*(.ctors))
231 ${CONSTRUCTING+${CTOR_END}}
232 }"
233DTOR=".dtors ${CONSTRUCTING-0} :
234 {
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.*)))
240 KEEP (*(.dtors))
241 ${CONSTRUCTING+${DTOR_END}}
242 }"
243STACK=" .stack ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
244 {
245 ${RELOCATING+${USER_LABEL_PREFIX}_stack = .;}
246 *(.stack)
247 }"
248
249TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
250SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
251
252if [ -z "$SEPARATE_CODE" ]; then
253 SIZEOF_HEADERS_CODE=" + SIZEOF_HEADERS"
254else
255 SIZEOF_HEADERS_CODE=
256fi
257
258# if this is for an embedded system, don't add SIZEOF_HEADERS.
259if [ -z "$EMBEDDED" ]; then
260 test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}${SIZEOF_HEADERS_CODE}"
261 NDS32_INIT=""
262else
263 test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
264 NDS32_INIT=".nds32_init : { KEEP(*(.nds32_init)) }"
265fi
266
267cat <<EOF
268OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
269 "${LITTLE_OUTPUT_FORMAT}")
270OUTPUT_ARCH(${OUTPUT_ARCH})
271${RELOCATING+ENTRY(${ENTRY})}
272
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. */}
280
281SECTIONS
282{
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. */
286 ${NDS32_INIT}
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};}}
289EOF
290
291emit_early_ro()
292{
293 cat <<EOF
294 ${INITIAL_READONLY_SECTIONS}
295 .note.gnu.build-id : { *(.note.gnu.build-id) }
296EOF
297}
298
299test -n "${SEPARATE_CODE}" || emit_early_ro
300
301test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
302test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
303cat > 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) }
312EOF
313
314if [ "x$COMBRELOC" = x ]; then
315 COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
316else
317 COMBRELOCCAT="cat > $COMBRELOC"
318fi
319eval $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}
346 ${REL_SDATA}
347 ${REL_SBSS}
348 ${REL_SDATA2}
349 ${REL_SBSS2}
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.*}) }
352 ${REL_LARGE}
353 ${IREL_IN_PLT+$REL_IFUNC}
354 ${IREL_IN_PLT+$RELA_IFUNC}
355 ${IREL_IN_PLT-$REL_IPLT}
356 ${IREL_IN_PLT-$RELA_IPLT}
357EOF
358
359if [ -n "$COMBRELOC" ]; then
360cat >> ldscripts/dyntmp.$$ <<EOF
361 .rel.dyn ${RELOCATING-0} :
362 {
363EOF
364sed -e '/^[ ]*[{}][ ]*$/d;/:[ ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/ \1/' $COMBRELOC >> ldscripts/dyntmp.$$
365cat >> ldscripts/dyntmp.$$ <<EOF
366 }
367 .rela.dyn ${RELOCATING-0} :
368 {
369EOF
370sed -e '/^[ ]*[{}][ ]*$/d;/:[ ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/ \1/' $COMBRELOC >> ldscripts/dyntmp.$$
371cat >> ldscripts/dyntmp.$$ <<EOF
372 }
373EOF
374fi
375
376cat >> ldscripts/dyntmp.$$ <<EOF
377 .rel.plt ${RELOCATING-0} :
378 {
379 *(.rel.plt)
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 = .);}}}
383 }
384 .rela.plt ${RELOCATING-0} :
385 {
386 *(.rela.plt)
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 = .);}}}
390 }
391 ${OTHER_PLT_RELOC_SECTIONS}
392EOF
393
394emit_dyn()
395{
396 if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
397 cat ldscripts/dyntmp.$$
398 else
399 if test -z "${NO_REL_RELOCS}"; then
400 sed -e '/^[ ]*\.rela\.[^}]*$/,/}/d' -e '/^[ ]*\.rela\./d' ldscripts/dyntmp.$$
401 fi
402 if test -z "${NO_RELA_RELOCS}"; then
403 sed -e '/^[ ]*\.rel\.[^}]*$/,/}/d' -e '/^[ ]*\.rel\./d' ldscripts/dyntmp.$$
404 fi
405 fi
406 rm -f ldscripts/dyntmp.$$
407}
408
409test -n "${NON_ALLOC_DYN}${SEPARATE_CODE}" || emit_dyn
410
411cat <<EOF
412 .init ${RELOCATING-0} :
413 {
414 ${RELOCATING+${INIT_START}}
415 KEEP (*(SORT_NONE(.init)))
416 ${RELOCATING+${INIT_END}}
417 } ${FILL}
418
419 ${TEXT_PLT+${PLT_NEXT_DATA-${PLT}}}
420 ${TINY_READONLY_SECTION}
421 .text ${RELOCATING-0} :
422 {
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. */
430 *(.gnu.warning)
431 ${RELOCATING+${OTHER_TEXT_SECTIONS}}
432 } ${FILL}
433 .fini ${RELOCATING-0} :
434 {
435 ${RELOCATING+${FINI_START}}
436 KEEP (*(SORT_NONE(.fini)))
437 ${RELOCATING+${FINI_END}}
438 } ${FILL}
439 ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
440 ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
441 ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
442EOF
443
444if test -n "${SEPARATE_CODE}"; then
445 if test -n "${RODATA_ADDR}"; then
446 RODATA_ADDR="\
447SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR}) + SIZEOF_HEADERS"
448 else
449 RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
450 RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR})"
451 fi
452 if test -n "${SHLIB_RODATA_ADDR}"; then
453 SHLIB_RODATA_ADDR="\
454SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR}) + SIZEOF_HEADERS"
455 else
456 SHLIB_RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR})"
457 SHLIB_RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
458 fi
459 cat <<EOF
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};}}
465EOF
466 emit_early_ro
467 emit_dyn
468fi
469
470cat <<EOF
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}}}
484
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}};}}
490
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*) }
495
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)} }
499
500 .preinit_array ${RELOCATING-0} :
501 {
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 = .);}}
505 }
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)) }
511
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}}}
522
523 ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
524
525 /* For _SDA_BASE_ aligment. */
526 ${RELOCATING+. = ALIGN(4);}
527
528 .data ${RELOCATING-0} :
529 {
530 ${RELOCATING+${DATA_START_SYMBOLS}}
531 *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
532 ${CONSTRUCTING+SORT(CONSTRUCTORS)}
533 }
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}}}}
542 ${SDATA_GOT+${GOT}}
543 ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
544 ${SDATA}
545 ${OTHER_SDATA_SECTIONS}
546 ${RELOCATING+. = ALIGN(4);}
547 ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
548 ${RELOCATING+. = .;}
549 ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
550 ${RELOCATING+${OTHER_BSS_SYMBOLS}}
551 ${SBSS}
552 ${BSS_PLT+${PLT}}
553 .${BSS_NAME} ${RELOCATING-0} :
554 {
555 *(.dyn${BSS_NAME})
556 *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
557 *(COMMON)
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);}
564 }
565 ${OTHER_BSS_SECTIONS}
566 ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
567 ${RELOCATING+_end = .;}
568 ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
569 ${RELOCATING+. = ALIGN(${ALIGNMENT});}
570EOF
571
572LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
573SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
574
575 cat <<EOF
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}}}
579 ${LARGE_SECTIONS}
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}}
585EOF
586
587test -z "${NON_ALLOC_DYN}" || emit_dyn
588
589cat <<EOF
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) }
597
598 .comment 0 : { *(.comment) }
599
600EOF
601
602. $srcdir/scripttempl/DWARF.sc
603
604cat <<EOF
605
606 ${TINY_DATA_SECTION}
607 ${TINY_BSS_SECTION}
608
609 ${STACK_ADDR+${STACK}}
610 ${ATTRS_SECTIONS}
611 ${OTHER_SECTIONS}
612 ${RELOCATING+${OTHER_SYMBOLS}}
613 ${RELOCATING+${DISCARDED}}
614}
615EOF
GDB Binutils - Deliverables
This page took 0.049531 seconds and 4 git commands to generate.