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