OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [ld/] [scripttempl/] [armbpabi.sc] - Blame information for rev 38

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
# 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 <
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 <
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 <
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 <
406
  .rel.dyn      0 :
407
    {
408
EOF
409
sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
410
cat <
411
    }
412
  .rela.dyn     0 :
413
    {
414
EOF
415
sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
416
cat <
417
    }
418
EOF
419
fi
420
cat <
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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.