1
/* ELF linking support for BFD.
2
Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3
Free Software Foundation, Inc.
5
This file is part of BFD, the Binary File Descriptor library.
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2 of the License, or
10
(at your option) any later version.
12
This program is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
GNU General Public License for more details.
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29
_bfd_elf_create_got_section (abfd, info)
31
struct bfd_link_info *info;
35
struct elf_link_hash_entry *h;
36
struct elf_backend_data *bed = get_elf_backend_data (abfd);
39
/* This function may be called more than once. */
40
if (bfd_get_section_by_name (abfd, ".got") != NULL)
43
switch (bed->s->arch_size)
54
bfd_set_error (bfd_error_bad_value);
58
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
59
| SEC_LINKER_CREATED);
61
s = bfd_make_section (abfd, ".got");
63
|| !bfd_set_section_flags (abfd, s, flags)
64
|| !bfd_set_section_alignment (abfd, s, ptralign))
67
if (bed->want_got_plt)
69
s = bfd_make_section (abfd, ".got.plt");
71
|| !bfd_set_section_flags (abfd, s, flags)
72
|| !bfd_set_section_alignment (abfd, s, ptralign))
76
if (bed->want_got_sym)
78
/* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
79
(or .got.plt) section. We don't do this in the linker script
80
because we don't want to define the symbol if we are not creating
81
a global offset table. */
83
if (!(_bfd_generic_link_add_one_symbol
84
(info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
85
bed->got_symbol_offset, (const char *) NULL, false,
86
bed->collect, (struct bfd_link_hash_entry **) &h)))
88
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
92
&& ! _bfd_elf_link_record_dynamic_symbol (info, h))
95
elf_hash_table (info)->hgot = h;
98
/* The first bit of the global offset table is the header. */
99
s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
104
/* Create dynamic sections when linking against a dynamic object. */
107
_bfd_elf_create_dynamic_sections (abfd, info)
109
struct bfd_link_info *info;
111
flagword flags, pltflags;
112
register asection *s;
113
struct elf_backend_data *bed = get_elf_backend_data (abfd);
116
switch (bed->s->arch_size)
127
bfd_set_error (bfd_error_bad_value);
131
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
132
.rel[a].bss sections. */
134
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
135
| SEC_LINKER_CREATED);
138
pltflags |= SEC_CODE;
139
if (bed->plt_not_loaded)
140
pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
141
if (bed->plt_readonly)
142
pltflags |= SEC_READONLY;
144
s = bfd_make_section (abfd, ".plt");
146
|| ! bfd_set_section_flags (abfd, s, pltflags)
147
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
150
if (bed->want_plt_sym)
152
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
154
struct elf_link_hash_entry *h = NULL;
155
if (! (_bfd_generic_link_add_one_symbol
156
(info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
157
(bfd_vma) 0, (const char *) NULL, false,
158
get_elf_backend_data (abfd)->collect,
159
(struct bfd_link_hash_entry **) &h)))
161
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
162
h->type = STT_OBJECT;
165
&& ! _bfd_elf_link_record_dynamic_symbol (info, h))
169
s = bfd_make_section (abfd,
170
bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
172
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
173
|| ! bfd_set_section_alignment (abfd, s, ptralign))
176
if (! _bfd_elf_create_got_section (abfd, info))
179
if (bed->want_dynbss)
181
/* The .dynbss section is a place to put symbols which are defined
182
by dynamic objects, are referenced by regular objects, and are
183
not functions. We must allocate space for them in the process
184
image and use a R_*_COPY reloc to tell the dynamic linker to
185
initialize them at run time. The linker script puts the .dynbss
186
section into the .bss section of the final image. */
187
s = bfd_make_section (abfd, ".dynbss");
189
|| ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
192
/* The .rel[a].bss section holds copy relocs. This section is not
193
normally needed. We need to create it here, though, so that the
194
linker will map it to an output section. We can't just create it
195
only if we need it, because we will not know whether we need it
196
until we have seen all the input files, and the first time the
197
main linker code calls BFD after examining all the input files
198
(size_dynamic_sections) the input sections have already been
199
mapped to the output sections. If the section turns out not to
200
be needed, we can discard it later. We will never need this
201
section when generating a shared object, since they do not use
205
s = bfd_make_section (abfd,
206
(bed->default_use_rela_p
207
? ".rela.bss" : ".rel.bss"));
209
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
210
|| ! bfd_set_section_alignment (abfd, s, ptralign))
218
/* Record a new dynamic symbol. We record the dynamic symbols as we
219
read the input files, since we need to have a list of all of them
220
before we can determine the final sizes of the output sections.
221
Note that we may actually call this function even though we are not
222
going to output any dynamic symbols; in some cases we know that a
223
symbol should be in the dynamic symbol table, but only if there is
227
_bfd_elf_link_record_dynamic_symbol (info, h)
228
struct bfd_link_info *info;
229
struct elf_link_hash_entry *h;
231
if (h->dynindx == -1)
233
struct elf_strtab_hash *dynstr;
239
/* XXX: The ABI draft says the linker must turn hidden and
240
internal symbols into STB_LOCAL symbols when producing the
241
DSO. However, if ld.so honors st_other in the dynamic table,
242
this would not be necessary. */
243
switch (ELF_ST_VISIBILITY (h->other))
247
if (h->root.type != bfd_link_hash_undefined
248
&& h->root.type != bfd_link_hash_undefweak)
250
h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
258
h->dynindx = elf_hash_table (info)->dynsymcount;
259
++elf_hash_table (info)->dynsymcount;
261
dynstr = elf_hash_table (info)->dynstr;
264
/* Create a strtab to hold the dynamic symbol names. */
265
elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
270
/* We don't put any version information in the dynamic string
272
name = h->root.root.string;
273
p = strchr (name, ELF_VER_CHR);
281
size_t len = p - name + 1;
283
alc = bfd_malloc ((bfd_size_type) len);
286
memcpy (alc, name, len - 1);
292
indx = _bfd_elf_strtab_add (dynstr, name, copy);
297
if (indx == (bfd_size_type) -1)
299
h->dynstr_index = indx;
305
/* Return the dynindex of a local dynamic symbol. */
308
_bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
309
struct bfd_link_info *info;
313
struct elf_link_local_dynamic_entry *e;
315
for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
316
if (e->input_bfd == input_bfd && e->input_indx == input_indx)
321
/* This function is used to renumber the dynamic symbols, if some of
322
them are removed because they are marked as local. This is called
323
via elf_link_hash_traverse. */
325
static boolean elf_link_renumber_hash_table_dynsyms
326
PARAMS ((struct elf_link_hash_entry *, PTR));
329
elf_link_renumber_hash_table_dynsyms (h, data)
330
struct elf_link_hash_entry *h;
333
size_t *count = (size_t *) data;
335
if (h->root.type == bfd_link_hash_warning)
336
h = (struct elf_link_hash_entry *) h->root.u.i.link;
338
if (h->dynindx != -1)
339
h->dynindx = ++(*count);
344
/* Assign dynsym indices. In a shared library we generate a section
345
symbol for each output section, which come first. Next come all of
346
the back-end allocated local dynamic syms, followed by the rest of
347
the global symbols. */
350
_bfd_elf_link_renumber_dynsyms (output_bfd, info)
352
struct bfd_link_info *info;
354
unsigned long dynsymcount = 0;
359
for (p = output_bfd->sections; p ; p = p->next)
360
if ((p->flags & SEC_EXCLUDE) == 0)
361
elf_section_data (p)->dynindx = ++dynsymcount;
364
if (elf_hash_table (info)->dynlocal)
366
struct elf_link_local_dynamic_entry *p;
367
for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
368
p->dynindx = ++dynsymcount;
371
elf_link_hash_traverse (elf_hash_table (info),
372
elf_link_renumber_hash_table_dynsyms,
375
/* There is an unused NULL entry at the head of the table which
376
we must account for in our count. Unless there weren't any
377
symbols, which means we'll have no table at all. */
378
if (dynsymcount != 0)
381
return elf_hash_table (info)->dynsymcount = dynsymcount;
384
/* Create a special linker section, or return a pointer to a linker
385
section already created */
387
elf_linker_section_t *
388
_bfd_elf_create_linker_section (abfd, info, which, defaults)
390
struct bfd_link_info *info;
391
enum elf_linker_section_enum which;
392
elf_linker_section_t *defaults;
394
bfd *dynobj = elf_hash_table (info)->dynobj;
395
elf_linker_section_t *lsect;
397
/* Record the first bfd section that needs the special section */
399
dynobj = elf_hash_table (info)->dynobj = abfd;
401
/* If this is the first time, create the section */
402
lsect = elf_linker_section (dynobj, which);
406
bfd_size_type amt = sizeof (elf_linker_section_t);
408
lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt);
411
elf_linker_section (dynobj, which) = lsect;
412
lsect->which = which;
413
lsect->hole_written_p = false;
415
/* See if the sections already exist */
416
lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
417
if (!s || (s->flags & defaults->flags) != defaults->flags)
419
lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
422
return (elf_linker_section_t *)0;
424
bfd_set_section_flags (dynobj, s, defaults->flags);
425
bfd_set_section_alignment (dynobj, s, lsect->alignment);
427
else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
428
bfd_set_section_alignment (dynobj, s, lsect->alignment);
430
s->_raw_size = align_power (s->_raw_size, lsect->alignment);
432
/* Is there a hole we have to provide? If so check whether the segment is
434
if (lsect->hole_size)
436
lsect->hole_offset = s->_raw_size;
437
s->_raw_size += lsect->hole_size;
438
if (lsect->hole_offset > lsect->max_hole_offset)
440
(*_bfd_error_handler) (_("%s: Section %s is too large to add hole of %ld bytes"),
441
bfd_get_filename (abfd),
443
(long) lsect->hole_size);
445
bfd_set_error (bfd_error_bad_value);
446
return (elf_linker_section_t *)0;
451
fprintf (stderr, "Creating section %s, current size = %ld\n",
452
lsect->name, (long)s->_raw_size);
457
struct elf_link_hash_entry *h = NULL;
459
fprintf (stderr, "Adding %s to section %s\n",
463
h = (struct elf_link_hash_entry *)
464
bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
466
if ((h == NULL || h->root.type == bfd_link_hash_undefined)
467
&& !(_bfd_generic_link_add_one_symbol (info,
473
? s->_raw_size - lsect->hole_size + lsect->sym_offset
474
: lsect->sym_offset),
477
get_elf_backend_data (abfd)->collect,
478
(struct bfd_link_hash_entry **) &h)))
479
return (elf_linker_section_t *)0;
481
if ((defaults->which != LINKER_SECTION_SDATA)
482
&& (defaults->which != LINKER_SECTION_SDATA2))
483
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
485
h->type = STT_OBJECT;
489
&& ! _bfd_elf_link_record_dynamic_symbol (info, h))
490
return (elf_linker_section_t *)0;
495
/* This does not make sense. The sections which may exist in the
496
object file have nothing to do with the sections we want to
499
/* Find the related sections if they have been created */
500
if (lsect->bss_name && !lsect->bss_section)
501
lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
503
if (lsect->rel_name && !lsect->rel_section)
504
lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
510
/* Find a linker generated pointer with a given addend and type. */
512
elf_linker_section_pointers_t *
513
_bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
514
elf_linker_section_pointers_t *linker_pointers;
516
elf_linker_section_enum_t which;
518
for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
520
if (which == linker_pointers->which && addend == linker_pointers->addend)
521
return linker_pointers;
524
return (elf_linker_section_pointers_t *)0;
527
/* Make the .rela section corresponding to the generated linker section. */
530
_bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
532
elf_linker_section_t *lsect;
535
if (lsect->rel_section)
538
lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
539
if (lsect->rel_section == NULL)
541
lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
542
if (lsect->rel_section == NULL
543
|| ! bfd_set_section_flags (dynobj,
551
|| ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
added
removed
binutils/bfd/elflink.c
