M68K TLS support.
[deliverable/binutils-gdb.git] / ld / scripttempl / armbpabi.sc
1 # This variant of elf.sc is used for ARM BPABI platforms, like Symbian
2 # OS, where a separate postlinker will operated on the generated
3 # executable or shared object. See elf.sc for configuration variables
4 # that apply; only BPABI-specific variables will be noted here.
5
6 test -z "$ENTRY" && ENTRY=_start
7 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
8 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
9 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
10 test -z "${ELFSIZE}" && ELFSIZE=32
11 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
12 test "$LD_FLAG" = "N" && DATA_ADDR=.
13 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
14 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
15 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
16 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
17 DATA_SEGMENT_RELRO_END=""
18 DATA_SEGMENT_RELRO_GOTPLT_END=""
19 DATA_SEGMENT_END=""
20 if test -n "${COMMONPAGESIZE}"; then
21 DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
22 DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
23 if test -n "${SEPARATE_GOTPLT}"; then
24 DATA_SEGMENT_RELRO_GOTPLT_END=". = DATA_SEGMENT_RELRO_END (. + ${SEPARATE_GOTPLT});"
25 else
26 DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (.);"
27 fi
28 fi
29 INTERP=".interp 0 : { *(.interp) }"
30 PLT=".plt ${RELOCATING-0} : { *(.plt) }"
31 RODATA=".rodata ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
32 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }"
33 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) }"
34 if test -z "${NO_SMALL_DATA}"; then
35 SBSS=".sbss ${RELOCATING-0} :
36 {
37 ${RELOCATING+PROVIDE (__sbss_start = .);}
38 ${RELOCATING+PROVIDE (___sbss_start = .);}
39 *(.dynsbss)
40 *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
41 *(.scommon)
42 ${RELOCATING+PROVIDE (__sbss_end = .);}
43 ${RELOCATING+PROVIDE (___sbss_end = .);}
44 }"
45 SBSS2=".sbss2 ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
46 SDATA="/* We want the small data sections together, so single-instruction offsets
47 can access them all, and initialized data all before uninitialized, so
48 we can shorten the on-disk segment size. */
49 .sdata ${RELOCATING-0} :
50 {
51 ${RELOCATING+${SDATA_START_SYMBOLS}}
52 *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
53 }"
54 SDATA2=".sdata2 ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }"
55 REL_SDATA=".rel.sdata ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
56 .rela.sdata ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
57 REL_SBSS=".rel.sbss ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
58 .rela.sbss ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
59 REL_SDATA2=".rel.sdata2 ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
60 .rela.sdata2 ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
61 REL_SBSS2=".rel.sbss2 ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
62 .rela.sbss2 ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
63 else
64 NO_SMALL_DATA=" "
65 fi
66 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
67 CTOR=".ctors ${CONSTRUCTING-0} :
68 {
69 ${CONSTRUCTING+${CTOR_START}}
70 /* gcc uses crtbegin.o to find the start of
71 the constructors, so we make sure it is
72 first. Because this is a wildcard, it
73 doesn't matter if the user does not
74 actually link against crtbegin.o; the
75 linker won't look for a file to match a
76 wildcard. The wildcard also means that it
77 doesn't matter which directory crtbegin.o
78 is in. */
79
80 KEEP (*crtbegin.o(.ctors))
81 KEEP (*crtbegin?.o(.ctors))
82
83 /* We don't want to include the .ctor section from
84 the crtend.o file until after the sorted ctors.
85 The .ctor section from the crtend file contains the
86 end of ctors marker and it must be last */
87
88 KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
89 KEEP (*(SORT(.ctors.*)))
90 KEEP (*(.ctors))
91 ${CONSTRUCTING+${CTOR_END}}
92 }"
93 DTOR=".dtors ${CONSTRUCTING-0} :
94 {
95 ${CONSTRUCTING+${DTOR_START}}
96 KEEP (*crtbegin.o(.dtors))
97 KEEP (*crtbegin?.o(.dtors))
98 KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
99 KEEP (*(SORT(.dtors.*)))
100 KEEP (*(.dtors))
101 ${CONSTRUCTING+${DTOR_END}}
102 }"
103 STACK=" .stack ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
104 {
105 ${RELOCATING+_stack = .;}
106 *(.stack)
107 }"
108
109 TEXT_START_ADDR="SEGMENT_START(\"text\", ${TEXT_START_ADDR})"
110 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text\", ${SHLIB_TEXT_START_ADDR:-0})"
111 DATA_ADDR="SEGMENT_START(\"data\", ${DATA_ADDR-${DATA_SEGMENT_ALIGN}})"
112 SHLIB_DATA_ADDR="SEGMENT_START(\"data\", ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}})"
113
114 # if this is for an embedded system, don't add SIZEOF_HEADERS.
115 if [ -z "$EMBEDDED" ]; then
116 test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
117 SHLIB_BASE_ADDRESS="${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS"
118 else
119 test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
120 SHLIB_BASE_ADDRESS="${SHLIB_TEXT_START_ADDR}"
121 fi
122
123 cat <<EOF
124 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
125 "${LITTLE_OUTPUT_FORMAT}")
126 OUTPUT_ARCH(${OUTPUT_ARCH})
127 ${RELOCATING+ENTRY(${ENTRY})}
128
129 ${RELOCATING+${LIB_SEARCH_DIRS}}
130 ${RELOCATING+/* Do we need any of these for elf?
131 __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}} */}
132 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
133 ${RELOCATING+${INPUT_FILES}}
134 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
135 if gld -r is used and the intermediate file has sections starting
136 at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld
137 bug. But for now assigning the zero vmas works. */}
138
139 /* ARM's proprietary toolchain generate these symbols to match the start
140 and end of particular sections of the image. SymbianOS uses these
141 symbols. We provide them for compatibility with ARM's toolchains.
142 These symbols should be bound locally; each shared object may define
143 its own version of these symbols. */
144
145 VERSION
146 {
147 /* Give these a dummy version to work around linker lameness.
148 The name used shouldn't matter as these are all local symbols. */
149 __GNU {
150 local:
151 Image\$\$ER_RO\$\$Base;
152 Image\$\$ER_RO\$\$Limit;
153 SHT\$\$INIT_ARRAY\$\$Base;
154 SHT\$\$INIT_ARRAY\$\$Limit;
155 .ARM.exidx\$\$Base;
156 .ARM.exidx\$\$Limit;
157 };
158 }
159
160 SECTIONS
161 {
162 /* Read-only sections, merged into text segment: */
163 ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR});}}}
164
165 ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+ . = ${TEXT_BASE_ADDRESS};}}}
166 ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
167 ${CREATE_PIE+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
168
169 /* Define Image\$\$ER_RO\$\$Base. */
170 ${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Base = .);}
171
172 ${INITIAL_READONLY_SECTIONS}
173
174 EOF
175 cat <<EOF
176 .init ${RELOCATING-0} :
177 {
178 ${RELOCATING+${INIT_START}}
179 KEEP (*(.init))
180 ${RELOCATING+${INIT_END}}
181 } =${NOP-0}
182 .text ${RELOCATING-0} :
183 {
184 ${RELOCATING+${TEXT_START_SYMBOLS}}
185 *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
186 /* .gnu.warning sections are handled specially by elf32.em. */
187 *(.gnu.warning)
188 ${RELOCATING+${OTHER_TEXT_SECTIONS}}
189 } =${NOP-0}
190 .fini ${RELOCATING-0} :
191 {
192 ${RELOCATING+${FINI_START}}
193 KEEP (*(.fini))
194 ${RELOCATING+${FINI_END}}
195 } =${NOP-0}
196 /* The SymbianOS kernel requires that the PLT go at the end of the
197 text section. */
198 ${DATA_PLT-${BSS_PLT-${PLT}}}
199 ${RELOCATING+PROVIDE (__etext = .);}
200 ${RELOCATING+PROVIDE (_etext = .);}
201 ${RELOCATING+PROVIDE (etext = .);}
202
203 /* Define Image\$\$ER_RO\$\$Limit. */
204 ${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Limit = .);}
205
206 ${WRITABLE_RODATA-${RODATA}}
207 .rodata1 ${RELOCATING-0} : { *(.rodata1) }
208 ${CREATE_SHLIB-${SDATA2}}
209 ${CREATE_SHLIB-${SBSS2}}
210
211 /* On SymbianOS, put .init_array and friends in the read-only
212 segment; there is no runtime relocation applied to these
213 arrays. */
214
215 .preinit_array ${RELOCATING-0} :
216 {
217 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_start = .);}}
218 KEEP (*(.preinit_array))
219 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_end = .);}}
220 }
221 .init_array ${RELOCATING-0} :
222 {
223 /* SymbianOS uses this symbol. */
224 ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Base = .);}
225 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_start = .);}}
226 KEEP (*(SORT(.init_array.*)))
227 KEEP (*(.init_array))
228 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_end = .);}}
229 /* SymbianOS uses this symbol. */
230 ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Limit = .);}
231 }
232 .fini_array ${RELOCATING-0} :
233 {
234 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_start = .);}}
235 KEEP (*(.fini_array))
236 KEEP (*(SORT(.fini_array.*)))
237 ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_end = .);}}
238 }
239
240 ${OTHER_READONLY_SECTIONS}
241 .eh_frame_hdr : { *(.eh_frame_hdr) }
242 .eh_frame ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
243 .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }
244
245 /* Adjust the address for the data segment. We want to adjust up to
246 the same address within the page on the next page up. */
247 ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR};}}}
248 ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
249 ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
250
251 /* Exception handling */
252 .eh_frame ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
253 .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }
254
255 /* Thread Local Storage sections */
256 .tdata ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
257 .tbss ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
258
259 ${RELOCATING+${CTOR}}
260 ${RELOCATING+${DTOR}}
261 .jcr ${RELOCATING-0} : { KEEP (*(.jcr)) }
262
263 ${RELOCATING+${DATARELRO}}
264 ${OTHER_RELRO_SECTIONS}
265 ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
266
267 ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
268
269 .data ${RELOCATING-0} :
270 {
271 ${RELOCATING+${DATA_START_SYMBOLS}}
272 *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
273 ${CONSTRUCTING+SORT(CONSTRUCTORS)}
274 }
275 .data1 ${RELOCATING-0} : { *(.data1) }
276 ${WRITABLE_RODATA+${RODATA}}
277 ${OTHER_READWRITE_SECTIONS}
278 ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
279 ${CREATE_SHLIB+${SDATA2}}
280 ${CREATE_SHLIB+${SBSS2}}
281 ${SDATA}
282 ${OTHER_SDATA_SECTIONS}
283 ${RELOCATING+_edata = .;}
284 ${RELOCATING+PROVIDE (edata = .);}
285 ${RELOCATING+. = DEFINED(__bss_segment_start) ? __bss_segment_start : .;}
286 ${RELOCATING+__bss_start = .;}
287 ${RELOCATING+${OTHER_BSS_SYMBOLS}}
288 ${SBSS}
289 ${BSS_PLT+${PLT}}
290 .bss ${RELOCATING-0} :
291 {
292 *(.dynbss)
293 *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
294 *(COMMON)
295 /* Align here to ensure that the .bss section occupies space up to
296 _end. Align after .bss to ensure correct alignment even if the
297 .bss section disappears because there are no input sections. */
298 ${RELOCATING+. = ALIGN(${ALIGNMENT});}
299 }
300 ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
301 ${RELOCATING+. = ALIGN(${ALIGNMENT});}
302 ${RELOCATING+${OTHER_END_SYMBOLS}}
303 ${RELOCATING+_end = .;}
304 ${RELOCATING+PROVIDE (end = .);}
305 ${RELOCATING+${DATA_SEGMENT_END}}
306
307 /* These sections are not mapped under the BPABI. */
308 .dynamic 0 : { *(.dynamic) }
309 .hash 0 : { *(.hash) }
310 .dynsym 0 : { *(.dynsym) }
311 .dynstr 0 : { *(.dynstr) }
312 .gnu.version 0 : { *(.gnu.version) }
313 .gnu.version_d 0: { *(.gnu.version_d) }
314 .gnu.version_r 0: { *(.gnu.version_r) }
315 ${CREATE_SHLIB-${INTERP}}
316
317 /* Stabs debugging sections. */
318 .stab 0 : { *(.stab) }
319 .stabstr 0 : { *(.stabstr) }
320 .stab.excl 0 : { *(.stab.excl) }
321 .stab.exclstr 0 : { *(.stab.exclstr) }
322 .stab.index 0 : { *(.stab.index) }
323 .stab.indexstr 0 : { *(.stab.indexstr) }
324
325 .comment 0 : { *(.comment) }
326
327 /* DWARF debug sections.
328 Symbols in the DWARF debugging sections are relative to the beginning
329 of the section so we begin them at 0. */
330
331 /* DWARF 1 */
332 .debug 0 : { *(.debug) }
333 .line 0 : { *(.line) }
334
335 /* GNU DWARF 1 extensions */
336 .debug_srcinfo 0 : { *(.debug_srcinfo) }
337 .debug_sfnames 0 : { *(.debug_sfnames) }
338
339 /* DWARF 1.1 and DWARF 2 */
340 .debug_aranges 0 : { *(.debug_aranges) }
341 .debug_pubnames 0 : { *(.debug_pubnames) }
342
343 /* DWARF 2 */
344 .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
345 .debug_abbrev 0 : { *(.debug_abbrev) }
346 .debug_line 0 : { *(.debug_line) }
347 .debug_frame 0 : { *(.debug_frame) }
348 .debug_str 0 : { *(.debug_str) }
349 .debug_loc 0 : { *(.debug_loc) }
350 .debug_macinfo 0 : { *(.debug_macinfo) }
351
352 /* SGI/MIPS DWARF 2 extensions */
353 .debug_weaknames 0 : { *(.debug_weaknames) }
354 .debug_funcnames 0 : { *(.debug_funcnames) }
355 .debug_typenames 0 : { *(.debug_typenames) }
356 .debug_varnames 0 : { *(.debug_varnames) }
357
358 ${STACK_ADDR+${STACK}}
359 ${OTHER_SECTIONS}
360 ${RELOCATING+${OTHER_SYMBOLS}}
361 ${RELOCATING+${DISCARDED}}
362 EOF
363
364 # These relocations sections are part of the read-only segment in SVR4
365 # executables, but are not mapped in BPABI executables.
366 if [ "x$COMBRELOC" = x ]; then
367 COMBRELOCCAT=cat
368 else
369 COMBRELOCCAT="cat > $COMBRELOC"
370 fi
371 eval $COMBRELOCCAT <<EOF
372 .rel.init 0 : { *(.rel.init) }
373 .rela.init 0 : { *(.rela.init) }
374 .rel.text 0 : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
375 .rela.text 0 : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
376 .rel.fini 0 : { *(.rel.fini) }
377 .rela.fini 0 : { *(.rela.fini) }
378 .rel.rodata 0 : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
379 .rela.rodata 0 : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
380 ${OTHER_READONLY_RELOC_SECTIONS}
381 .rel.data.rel.ro 0 : { *(.rel.data.rel.ro${RELOCATING+*}) }
382 .rela.data.rel.ro 0 : { *(.rel.data.rel.ro${RELOCATING+*}) }
383 .rel.data 0 : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
384 .rela.data 0 : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
385 .rel.tdata 0 : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
386 .rela.tdata 0 : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
387 .rel.tbss 0 : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
388 .rela.tbss 0 : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
389 .rel.ctors 0 : { *(.rel.ctors) }
390 .rela.ctors 0 : { *(.rela.ctors) }
391 .rel.dtors 0 : { *(.rel.dtors) }
392 .rela.dtors 0 : { *(.rela.dtors) }
393 ${REL_SDATA}
394 ${REL_SBSS}
395 ${REL_SDATA2}
396 ${REL_SBSS2}
397 .rel.bss 0 : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
398 .rela.bss 0 : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
399 .rel.init_array 0 : { *(.rel.init_array) }
400 .rela.init_array 0 : { *(.rela.init_array) }
401 .rel.fini_array 0 : { *(.rel.fini_array) }
402 .rela.fini_array 0 : { *(.rela.fini_array) }
403 EOF
404 if [ -n "$COMBRELOC" ]; then
405 cat <<EOF
406 .rel.dyn 0 :
407 {
408 EOF
409 sed -e '/^[ ]*[{}][ ]*$/d;/:[ ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/ \1/' $COMBRELOC
410 cat <<EOF
411 }
412 .rela.dyn 0 :
413 {
414 EOF
415 sed -e '/^[ ]*[{}][ ]*$/d;/:[ ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/ \1/' $COMBRELOC
416 cat <<EOF
417 }
418 EOF
419 fi
420 cat <<EOF
421 .rel.plt 0 : { *(.rel.plt) }
422 .rela.plt 0 : { *(.rela.plt) }
423 ${OTHER_PLT_RELOC_SECTIONS}
424 .rel.other 0 : { *(.rel.*) }
425 .rela.other 0 : { *(.rela.*) }
426 .reli.other 0 : { *(.reli.*) }
427 }
428 EOF
This page took 0.038877 seconds and 4 git commands to generate.