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/] [elf.sc] - Blame information for rev 179

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

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

powered by: WebSVN 2.1.0

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