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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [ld/] [scripttempl/] [elf64hppa.sc] - Blame information for rev 301

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

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

powered by: WebSVN 2.1.0

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