1
/* ELF linking support for BFD.
2
Copyright 1995-2013 Free Software Foundation, Inc.
4
This file is part of BFD, the Binary File Descriptor library.
6
This program is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 3 of the License, or
9
(at your option) any later version.
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
GNU General Public License for more details.
16
You should have received a copy of the GNU General Public License
17
along with this program; if not, write to the Free Software
18
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
MA 02110-1301, USA. */
27
#include "safe-ctype.h"
28
#include "libiberty.h"
31
/* This struct is used to pass information to routines called via
32
elf_link_hash_traverse which must return failure. */
34
struct elf_info_failed
36
struct bfd_link_info *info;
40
/* This structure is used to pass information to
41
_bfd_elf_link_find_version_dependencies. */
43
struct elf_find_verdep_info
45
/* General link information. */
46
struct bfd_link_info *info;
47
/* The number of dependencies. */
49
/* Whether we had a failure. */
53
static bfd_boolean _bfd_elf_fix_symbol_flags
54
(struct elf_link_hash_entry *, struct elf_info_failed *);
56
/* Define a symbol in a dynamic linkage section. */
58
struct elf_link_hash_entry *
59
_bfd_elf_define_linkage_sym (bfd *abfd,
60
struct bfd_link_info *info,
64
struct elf_link_hash_entry *h;
65
struct bfd_link_hash_entry *bh;
66
const struct elf_backend_data *bed;
68
h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
71
/* Zap symbol defined in an as-needed lib that wasn't linked.
72
This is a symptom of a larger problem: Absolute symbols
73
defined in shared libraries can't be overridden, because we
74
lose the link to the bfd which is via the symbol section. */
75
h->root.type = bfd_link_hash_new;
79
if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
81
get_elf_backend_data (abfd)->collect,
84
h = (struct elf_link_hash_entry *) bh;
88
h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
90
bed = get_elf_backend_data (abfd);
91
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
96
_bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
100
struct elf_link_hash_entry *h;
101
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
102
struct elf_link_hash_table *htab = elf_hash_table (info);
104
/* This function may be called more than once. */
105
s = bfd_get_linker_section (abfd, ".got");
109
flags = bed->dynamic_sec_flags;
111
s = bfd_make_section_anyway_with_flags (abfd,
112
(bed->rela_plts_and_copies_p
113
? ".rela.got" : ".rel.got"),
114
(bed->dynamic_sec_flags
117
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
121
s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
123
|| !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
127
if (bed->want_got_plt)
129
s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
131
|| !bfd_set_section_alignment (abfd, s,
132
bed->s->log_file_align))
137
/* The first bit of the global offset table is the header. */
138
s->size += bed->got_header_size;
140
if (bed->want_got_sym)
142
/* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
143
(or .got.plt) section. We don't do this in the linker script
144
because we don't want to define the symbol if we are not creating
145
a global offset table. */
146
h = _bfd_elf_define_linkage_sym (abfd, info, s,
147
"_GLOBAL_OFFSET_TABLE_");
148
elf_hash_table (info)->hgot = h;
156
/* Create a strtab to hold the dynamic symbol names. */
158
_bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
160
struct elf_link_hash_table *hash_table;
162
hash_table = elf_hash_table (info);
163
if (hash_table->dynobj == NULL)
164
hash_table->dynobj = abfd;
166
if (hash_table->dynstr == NULL)
168
hash_table->dynstr = _bfd_elf_strtab_init ();
169
if (hash_table->dynstr == NULL)
175
/* Create some sections which will be filled in with dynamic linking
176
information. ABFD is an input file which requires dynamic sections
177
to be created. The dynamic sections take up virtual memory space
178
when the final executable is run, so we need to create them before
179
addresses are assigned to the output sections. We work out the
180
actual contents and size of these sections later. */
183
_bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
187
const struct elf_backend_data *bed;
188
struct elf_link_hash_entry *h;
190
if (! is_elf_hash_table (info->hash))
193
if (elf_hash_table (info)->dynamic_sections_created)
196
if (!_bfd_elf_link_create_dynstrtab (abfd, info))
199
abfd = elf_hash_table (info)->dynobj;
200
bed = get_elf_backend_data (abfd);
202
flags = bed->dynamic_sec_flags;
204
/* A dynamically linked executable has a .interp section, but a
205
shared library does not. */
206
if (info->executable)
208
s = bfd_make_section_anyway_with_flags (abfd, ".interp",
209
flags | SEC_READONLY);
214
/* Create sections to hold version informations. These are removed
215
if they are not needed. */
216
s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
217
flags | SEC_READONLY);
219
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
222
s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
223
flags | SEC_READONLY);
225
|| ! bfd_set_section_alignment (abfd, s, 1))
228
s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
229
flags | SEC_READONLY);
231
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
234
s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
235
flags | SEC_READONLY);
237
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
240
s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
241
flags | SEC_READONLY);
245
s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
247
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
250
/* The special symbol _DYNAMIC is always set to the start of the
251
.dynamic section. We could set _DYNAMIC in a linker script, but we
252
only want to define it if we are, in fact, creating a .dynamic
253
section. We don't want to define it if there is no .dynamic
254
section, since on some ELF platforms the start up code examines it
255
to decide how to initialize the process. */
256
h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
257
elf_hash_table (info)->hdynamic = h;
263
s = bfd_make_section_anyway_with_flags (abfd, ".hash",
264
flags | SEC_READONLY);
266
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
268
elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
271
if (info->emit_gnu_hash)
273
s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
274
flags | SEC_READONLY);
276
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
278
/* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
279
4 32-bit words followed by variable count of 64-bit words, then
280
variable count of 32-bit words. */
281
if (bed->s->arch_size == 64)
282
elf_section_data (s)->this_hdr.sh_entsize = 0;
284
elf_section_data (s)->this_hdr.sh_entsize = 4;
287
/* Let the backend create the rest of the sections. This lets the
288
backend set the right flags. The backend will normally create
289
the .got and .plt sections. */
290
if (bed->elf_backend_create_dynamic_sections == NULL
291
|| ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
294
elf_hash_table (info)->dynamic_sections_created = TRUE;
299
/* Create dynamic sections when linking against a dynamic object. */
302
_bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
304
flagword flags, pltflags;
305
struct elf_link_hash_entry *h;
307
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
308
struct elf_link_hash_table *htab = elf_hash_table (info);
310
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
311
.rel[a].bss sections. */
312
flags = bed->dynamic_sec_flags;
315
if (bed->plt_not_loaded)
316
/* We do not clear SEC_ALLOC here because we still want the OS to
317
allocate space for the section; it's just that there's nothing
318
to read in from the object file. */
319
pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
321
pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
322
if (bed->plt_readonly)
323
pltflags |= SEC_READONLY;
325
s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
327
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
331
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
333
if (bed->want_plt_sym)
335
h = _bfd_elf_define_linkage_sym (abfd, info, s,
336
"_PROCEDURE_LINKAGE_TABLE_");
337
elf_hash_table (info)->hplt = h;
342
s = bfd_make_section_anyway_with_flags (abfd,
343
(bed->rela_plts_and_copies_p
344
? ".rela.plt" : ".rel.plt"),
345
flags | SEC_READONLY);
347
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
351
if (! _bfd_elf_create_got_section (abfd, info))
354
if (bed->want_dynbss)
356
/* The .dynbss section is a place to put symbols which are defined
357
by dynamic objects, are referenced by regular objects, and are
358
not functions. We must allocate space for them in the process
359
image and use a R_*_COPY reloc to tell the dynamic linker to
360
initialize them at run time. The linker script puts the .dynbss
361
section into the .bss section of the final image. */
362
s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
363
(SEC_ALLOC | SEC_LINKER_CREATED));
367
/* The .rel[a].bss section holds copy relocs. This section is not
368
normally needed. We need to create it here, though, so that the
369
linker will map it to an output section. We can't just create it
370
only if we need it, because we will not know whether we need it
371
until we have seen all the input files, and the first time the
372
main linker code calls BFD after examining all the input files
373
(size_dynamic_sections) the input sections have already been
374
mapped to the output sections. If the section turns out not to
375
be needed, we can discard it later. We will never need this
376
section when generating a shared object, since they do not use
380
s = bfd_make_section_anyway_with_flags (abfd,
381
(bed->rela_plts_and_copies_p
382
? ".rela.bss" : ".rel.bss"),
383
flags | SEC_READONLY);
385
|| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
393
/* Record a new dynamic symbol. We record the dynamic symbols as we
394
read the input files, since we need to have a list of all of them
395
before we can determine the final sizes of the output sections.
396
Note that we may actually call this function even though we are not
397
going to output any dynamic symbols; in some cases we know that a
398
symbol should be in the dynamic symbol table, but only if there is
402
bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
403
struct elf_link_hash_entry *h)
405
if (h->dynindx == -1)
407
struct elf_strtab_hash *dynstr;
412
/* XXX: The ABI draft says the linker must turn hidden and
413
internal symbols into STB_LOCAL symbols when producing the
414
DSO. However, if ld.so honors st_other in the dynamic table,
415
this would not be necessary. */
416
switch (ELF_ST_VISIBILITY (h->other))
420
if (h->root.type != bfd_link_hash_undefined
421
&& h->root.type != bfd_link_hash_undefweak)
424
if (!elf_hash_table (info)->is_relocatable_executable)
432
h->dynindx = elf_hash_table (info)->dynsymcount;
433
++elf_hash_table (info)->dynsymcount;
435
dynstr = elf_hash_table (info)->dynstr;
438
/* Create a strtab to hold the dynamic symbol names. */
439
elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
444
/* We don't put any version information in the dynamic string
446
name = h->root.root.string;
447
p = strchr (name, ELF_VER_CHR);
449
/* We know that the p points into writable memory. In fact,
450
there are only a few symbols that have read-only names, being
451
those like _GLOBAL_OFFSET_TABLE_ that are created specially
452
by the backends. Most symbols will have names pointing into
453
an ELF string table read from a file, or to objalloc memory. */
456
indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
461
if (indx == (bfd_size_type) -1)
463
h->dynstr_index = indx;
469
/* Mark a symbol dynamic. */
472
bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
473
struct elf_link_hash_entry *h,
474
Elf_Internal_Sym *sym)
476
struct bfd_elf_dynamic_list *d = info->dynamic_list;
478
/* It may be called more than once on the same H. */
479
if(h->dynamic || info->relocatable)
482
if ((info->dynamic_data
483
&& (h->type == STT_OBJECT
485
&& ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
487
&& h->root.type == bfd_link_hash_new
488
&& (*d->match) (&d->head, NULL, h->root.root.string)))
492
/* Record an assignment to a symbol made by a linker script. We need
493
this in case some dynamic object refers to this symbol. */
496
bfd_elf_record_link_assignment (bfd *output_bfd,
497
struct bfd_link_info *info,
502
struct elf_link_hash_entry *h, *hv;
503
struct elf_link_hash_table *htab;
504
const struct elf_backend_data *bed;
506
if (!is_elf_hash_table (info->hash))
509
htab = elf_hash_table (info);
510
h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
514
switch (h->root.type)
516
case bfd_link_hash_defined:
517
case bfd_link_hash_defweak:
518
case bfd_link_hash_common:
520
case bfd_link_hash_undefweak:
521
case bfd_link_hash_undefined:
522
/* Since we're defining the symbol, don't let it seem to have not
523
been defined. record_dynamic_symbol and size_dynamic_sections
524
may depend on this. */
525
h->root.type = bfd_link_hash_new;
526
if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
527
bfd_link_repair_undef_list (&htab->root);
529
case bfd_link_hash_new:
530
bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
533
case bfd_link_hash_indirect:
534
/* We had a versioned symbol in a dynamic library. We make the
535
the versioned symbol point to this one. */
536
bed = get_elf_backend_data (output_bfd);
538
while (hv->root.type == bfd_link_hash_indirect
539
|| hv->root.type == bfd_link_hash_warning)
540
hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
541
/* We don't need to update h->root.u since linker will set them
543
h->root.type = bfd_link_hash_undefined;
544
hv->root.type = bfd_link_hash_indirect;
545
hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
546
(*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
548
case bfd_link_hash_warning:
553
/* If this symbol is being provided by the linker script, and it is
554
currently defined by a dynamic object, but not by a regular
555
object, then mark it as undefined so that the generic linker will
556
force the correct value. */
560
h->root.type = bfd_link_hash_undefined;
562
/* If this symbol is not being provided by the linker script, and it is
563
currently defined by a dynamic object, but not by a regular object,
564
then clear out any version information because the symbol will not be
565
associated with the dynamic object any more. */
569
h->verinfo.verdef = NULL;
575
bed = get_elf_backend_data (output_bfd);
576
if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
577
h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
578
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
581
/* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
583
if (!info->relocatable
585
&& (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
586
|| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
592
|| (info->executable && elf_hash_table (info)->is_relocatable_executable))
595
if (! bfd_elf_link_record_dynamic_symbol (info, h))
598
/* If this is a weak defined symbol, and we know a corresponding
599
real symbol from the same dynamic object, make sure the real
600
symbol is also made into a dynamic symbol. */
601
if (h->u.weakdef != NULL
602
&& h->u.weakdef->dynindx == -1)
604
if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
612
/* Record a new local dynamic symbol. Returns 0 on failure, 1 on
613
success, and 2 on a failure caused by attempting to record a symbol
614
in a discarded section, eg. a discarded link-once section symbol. */
617
bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
622
struct elf_link_local_dynamic_entry *entry;
623
struct elf_link_hash_table *eht;
624
struct elf_strtab_hash *dynstr;
625
unsigned long dynstr_index;
627
Elf_External_Sym_Shndx eshndx;
628
char esym[sizeof (Elf64_External_Sym)];
630
if (! is_elf_hash_table (info->hash))
633
/* See if the entry exists already. */
634
for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
635
if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
638
amt = sizeof (*entry);
639
entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
643
/* Go find the symbol, so that we can find it's name. */
644
if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
645
1, input_indx, &entry->isym, esym, &eshndx))
647
bfd_release (input_bfd, entry);
651
if (entry->isym.st_shndx != SHN_UNDEF
652
&& entry->isym.st_shndx < SHN_LORESERVE)
656
s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
657
if (s == NULL || bfd_is_abs_section (s->output_section))
659
/* We can still bfd_release here as nothing has done another
660
bfd_alloc. We can't do this later in this function. */
661
bfd_release (input_bfd, entry);
666
name = (bfd_elf_string_from_elf_section
667
(input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
668
entry->isym.st_name));
670
dynstr = elf_hash_table (info)->dynstr;
673
/* Create a strtab to hold the dynamic symbol names. */
674
elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
679
dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
680
if (dynstr_index == (unsigned long) -1)
682
entry->isym.st_name = dynstr_index;
684
eht = elf_hash_table (info);
686
entry->next = eht->dynlocal;
687
eht->dynlocal = entry;
688
entry->input_bfd = input_bfd;
689
entry->input_indx = input_indx;
692
/* Whatever binding the symbol had before, it's now local. */
694
= ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
696
/* The dynindx will be set at the end of size_dynamic_sections. */
701
/* Return the dynindex of a local dynamic symbol. */
704
_bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
708
struct elf_link_local_dynamic_entry *e;
710
for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
711
if (e->input_bfd == input_bfd && e->input_indx == input_indx)
716
/* This function is used to renumber the dynamic symbols, if some of
717
them are removed because they are marked as local. This is called
718
via elf_link_hash_traverse. */
721
elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
724
size_t *count = (size_t *) data;
729
if (h->dynindx != -1)
730
h->dynindx = ++(*count);
736
/* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
737
STB_LOCAL binding. */
740
elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
743
size_t *count = (size_t *) data;
745
if (!h->forced_local)
748
if (h->dynindx != -1)
749
h->dynindx = ++(*count);
754
/* Return true if the dynamic symbol for a given section should be
755
omitted when creating a shared library. */
757
_bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
758
struct bfd_link_info *info,
761
struct elf_link_hash_table *htab;
763
switch (elf_section_data (p)->this_hdr.sh_type)
767
/* If sh_type is yet undecided, assume it could be
768
SHT_PROGBITS/SHT_NOBITS. */
770
htab = elf_hash_table (info);
771
if (p == htab->tls_sec)
774
if (htab->text_index_section != NULL)
775
return p != htab->text_index_section && p != htab->data_index_section;
777
if (strcmp (p->name, ".got") == 0
778
|| strcmp (p->name, ".got.plt") == 0
779
|| strcmp (p->name, ".plt") == 0)
783
if (htab->dynobj != NULL
784
&& (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
785
&& ip->output_section == p)
790
/* There shouldn't be section relative relocations
791
against any other section. */
797
/* Assign dynsym indices. In a shared library we generate a section
798
symbol for each output section, which come first. Next come symbols
799
which have been forced to local binding. Then all of the back-end
800
allocated local dynamic syms, followed by the rest of the global
804
_bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
805
struct bfd_link_info *info,
806
unsigned long *section_sym_count)
808
unsigned long dynsymcount = 0;
810
if (info->shared || elf_hash_table (info)->is_relocatable_executable)
812
const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
814
for (p = output_bfd->sections; p ; p = p->next)
815
if ((p->flags & SEC_EXCLUDE) == 0
816
&& (p->flags & SEC_ALLOC) != 0
817
&& !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
818
elf_section_data (p)->dynindx = ++dynsymcount;
820
elf_section_data (p)->dynindx = 0;
822
*section_sym_count = dynsymcount;
824
elf_link_hash_traverse (elf_hash_table (info),
825
elf_link_renumber_local_hash_table_dynsyms,
828
if (elf_hash_table (info)->dynlocal)
830
struct elf_link_local_dynamic_entry *p;
831
for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
832
p->dynindx = ++dynsymcount;
835
elf_link_hash_traverse (elf_hash_table (info),
836
elf_link_renumber_hash_table_dynsyms,
839
/* There is an unused NULL entry at the head of the table which
840
we must account for in our count. Unless there weren't any
841
symbols, which means we'll have no table at all. */
842
if (dynsymcount != 0)
845
elf_hash_table (info)->dynsymcount = dynsymcount;
849
/* Merge st_other field. */
852
elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
853
Elf_Internal_Sym *isym, bfd_boolean definition,
856
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
858
/* If st_other has a processor-specific meaning, specific
859
code might be needed here. We never merge the visibility
860
attribute with the one from a dynamic object. */
861
if (bed->elf_backend_merge_symbol_attribute)
862
(*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
865
/* If this symbol has default visibility and the user has requested
866
we not re-export it, then mark it as hidden. */
870
|| (abfd->my_archive && abfd->my_archive->no_export))
871
&& ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
872
isym->st_other = (STV_HIDDEN
873
| (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
875
if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0)
877
unsigned char hvis, symvis, other, nvis;
879
/* Only merge the visibility. Leave the remainder of the
880
st_other field to elf_backend_merge_symbol_attribute. */
881
other = h->other & ~ELF_ST_VISIBILITY (-1);
883
/* Combine visibilities, using the most constraining one. */
884
hvis = ELF_ST_VISIBILITY (h->other);
885
symvis = ELF_ST_VISIBILITY (isym->st_other);
891
nvis = hvis < symvis ? hvis : symvis;
893
h->other = other | nvis;
897
/* This function is called when we want to merge a new symbol with an
898
existing symbol. It handles the various cases which arise when we
899
find a definition in a dynamic object, or when there is already a
900
definition in a dynamic object. The new symbol is described by
901
NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table
902
entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK
903
if the old symbol was weak. We set POLD_ALIGNMENT to the alignment
904
of an old common symbol. We set OVERRIDE if the old symbol is
905
overriding a new definition. We set TYPE_CHANGE_OK if it is OK for
906
the type to change. We set SIZE_CHANGE_OK if it is OK for the size
907
to change. By OK to change, we mean that we shouldn't warn if the
908
type or size does change. */
911
_bfd_elf_merge_symbol (bfd *abfd,
912
struct bfd_link_info *info,
914
Elf_Internal_Sym *sym,
917
struct elf_link_hash_entry **sym_hash,
919
bfd_boolean *pold_weak,
920
unsigned int *pold_alignment,
922
bfd_boolean *override,
923
bfd_boolean *type_change_ok,
924
bfd_boolean *size_change_ok)
926
asection *sec, *oldsec;
927
struct elf_link_hash_entry *h;
928
struct elf_link_hash_entry *hi;
929
struct elf_link_hash_entry *flip;
932
bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
933
bfd_boolean newweak, oldweak, newfunc, oldfunc;
934
const struct elf_backend_data *bed;
940
bind = ELF_ST_BIND (sym->st_info);
942
if (! bfd_is_und_section (sec))
943
h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
945
h = ((struct elf_link_hash_entry *)
946
bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
951
bed = get_elf_backend_data (abfd);
953
/* This code is for coping with dynamic objects, and is only useful
954
if we are doing an ELF link. */
955
if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
958
/* For merging, we only care about real symbols. But we need to make
959
sure that indirect symbol dynamic flags are updated. */
961
while (h->root.type == bfd_link_hash_indirect
962
|| h->root.type == bfd_link_hash_warning)
963
h = (struct elf_link_hash_entry *) h->root.u.i.link;
965
/* We have to check it for every instance since the first few may be
966
references and not all compilers emit symbol type for undefined
968
bfd_elf_link_mark_dynamic_symbol (info, h, sym);
970
/* NEWDYN and OLDDYN indicate whether the new or old symbol,
971
respectively, is from a dynamic object. */
973
newdyn = (abfd->flags & DYNAMIC) != 0;
975
/* ref_dynamic_nonweak and dynamic_def flags track actual undefined
976
syms and defined syms in dynamic libraries respectively.
977
ref_dynamic on the other hand can be set for a symbol defined in
978
a dynamic library, and def_dynamic may not be set; When the
979
definition in a dynamic lib is overridden by a definition in the
980
executable use of the symbol in the dynamic lib becomes a
981
reference to the executable symbol. */
984
if (bfd_is_und_section (sec))
986
if (bind != STB_WEAK)
988
h->ref_dynamic_nonweak = 1;
989
hi->ref_dynamic_nonweak = 1;
999
/* If we just created the symbol, mark it as being an ELF symbol.
1000
Other than that, there is nothing to do--there is no merge issue
1001
with a newly defined symbol--so we just return. */
1003
if (h->root.type == bfd_link_hash_new)
1009
/* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1012
switch (h->root.type)
1019
case bfd_link_hash_undefined:
1020
case bfd_link_hash_undefweak:
1021
oldbfd = h->root.u.undef.abfd;
1025
case bfd_link_hash_defined:
1026
case bfd_link_hash_defweak:
1027
oldbfd = h->root.u.def.section->owner;
1028
oldsec = h->root.u.def.section;
1031
case bfd_link_hash_common:
1032
oldbfd = h->root.u.c.p->section->owner;
1033
oldsec = h->root.u.c.p->section;
1035
*pold_alignment = h->root.u.c.p->alignment_power;
1038
if (poldbfd && *poldbfd == NULL)
1041
/* Differentiate strong and weak symbols. */
1042
newweak = bind == STB_WEAK;
1043
oldweak = (h->root.type == bfd_link_hash_defweak
1044
|| h->root.type == bfd_link_hash_undefweak);
1046
*pold_weak = oldweak;
1048
/* In cases involving weak versioned symbols, we may wind up trying
1049
to merge a symbol with itself. Catch that here, to avoid the
1050
confusion that results if we try to override a symbol with
1051
itself. The additional tests catch cases like
1052
_GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1053
dynamic object, which we do want to handle here. */
1055
&& (newweak || oldweak)
1056
&& ((abfd->flags & DYNAMIC) == 0
1057
|| !h->def_regular))
1062
olddyn = (oldbfd->flags & DYNAMIC) != 0;
1063
else if (oldsec != NULL)
1065
/* This handles the special SHN_MIPS_{TEXT,DATA} section
1066
indices used by MIPS ELF. */
1067
olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1070
/* NEWDEF and OLDDEF indicate whether the new or old symbol,
1071
respectively, appear to be a definition rather than reference. */
1073
newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1075
olddef = (h->root.type != bfd_link_hash_undefined
1076
&& h->root.type != bfd_link_hash_undefweak
1077
&& h->root.type != bfd_link_hash_common);
1079
/* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1080
respectively, appear to be a function. */
1082
newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1083
&& bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1085
oldfunc = (h->type != STT_NOTYPE
1086
&& bed->is_function_type (h->type));
1088
/* When we try to create a default indirect symbol from the dynamic
1089
definition with the default version, we skip it if its type and
1090
the type of existing regular definition mismatch. We only do it
1091
if the existing regular definition won't be dynamic. */
1092
if (pold_alignment == NULL
1094
&& !info->export_dynamic
1099
&& (olddef || h->root.type == bfd_link_hash_common)
1100
&& ELF_ST_TYPE (sym->st_info) != h->type
1101
&& ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1102
&& h->type != STT_NOTYPE
1103
&& !(newfunc && oldfunc))
1109
/* Plugin symbol type isn't currently set. Stop bogus errors. */
1110
if (oldbfd != NULL && (oldbfd->flags & BFD_PLUGIN) != 0)
1111
*type_change_ok = TRUE;
1113
/* Check TLS symbol. We don't check undefined symbol introduced by
1115
else if (oldbfd != NULL
1116
&& ELF_ST_TYPE (sym->st_info) != h->type
1117
&& (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1120
bfd_boolean ntdef, tdef;
1121
asection *ntsec, *tsec;
1123
if (h->type == STT_TLS)
1143
(*_bfd_error_handler)
1144
(_("%s: TLS definition in %B section %A "
1145
"mismatches non-TLS definition in %B section %A"),
1146
tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1147
else if (!tdef && !ntdef)
1148
(*_bfd_error_handler)
1149
(_("%s: TLS reference in %B "
1150
"mismatches non-TLS reference in %B"),
1151
tbfd, ntbfd, h->root.root.string);
1153
(*_bfd_error_handler)
1154
(_("%s: TLS definition in %B section %A "
1155
"mismatches non-TLS reference in %B"),
1156
tbfd, tsec, ntbfd, h->root.root.string);
1158
(*_bfd_error_handler)
1159
(_("%s: TLS reference in %B "
1160
"mismatches non-TLS definition in %B section %A"),
1161
tbfd, ntbfd, ntsec, h->root.root.string);
1163
bfd_set_error (bfd_error_bad_value);
1167
/* If the old symbol has non-default visibility, we ignore the new
1168
definition from a dynamic object. */
1170
&& ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1171
&& !bfd_is_und_section (sec))
1174
/* Make sure this symbol is dynamic. */
1176
hi->ref_dynamic = 1;
1177
/* A protected symbol has external availability. Make sure it is
1178
recorded as dynamic.
1180
FIXME: Should we check type and size for protected symbol? */
1181
if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1182
return bfd_elf_link_record_dynamic_symbol (info, h);
1187
&& ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1190
/* If the new symbol with non-default visibility comes from a
1191
relocatable file and the old definition comes from a dynamic
1192
object, we remove the old definition. */
1193
if (hi->root.type == bfd_link_hash_indirect)
1195
/* Handle the case where the old dynamic definition is
1196
default versioned. We need to copy the symbol info from
1197
the symbol with default version to the normal one if it
1198
was referenced before. */
1201
hi->root.type = h->root.type;
1202
h->root.type = bfd_link_hash_indirect;
1203
(*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
1205
h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1206
if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1208
/* If the new symbol is hidden or internal, completely undo
1209
any dynamic link state. */
1210
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
1211
h->forced_local = 0;
1218
/* FIXME: Should we check type and size for protected symbol? */
1228
/* If the old symbol was undefined before, then it will still be
1229
on the undefs list. If the new symbol is undefined or
1230
common, we can't make it bfd_link_hash_new here, because new
1231
undefined or common symbols will be added to the undefs list
1232
by _bfd_generic_link_add_one_symbol. Symbols may not be
1233
added twice to the undefs list. Also, if the new symbol is
1234
undefweak then we don't want to lose the strong undef. */
1235
if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1237
h->root.type = bfd_link_hash_undefined;
1238
h->root.u.undef.abfd = abfd;
1242
h->root.type = bfd_link_hash_new;
1243
h->root.u.undef.abfd = NULL;
1246
if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1248
/* If the new symbol is hidden or internal, completely undo
1249
any dynamic link state. */
1250
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
1251
h->forced_local = 0;
1257
/* FIXME: Should we check type and size for protected symbol? */
1263
/* If a new weak symbol definition comes from a regular file and the
1264
old symbol comes from a dynamic library, we treat the new one as
1265
strong. Similarly, an old weak symbol definition from a regular
1266
file is treated as strong when the new symbol comes from a dynamic
1267
library. Further, an old weak symbol from a dynamic library is
1268
treated as strong if the new symbol is from a dynamic library.
1269
This reflects the way glibc's ld.so works.
1271
Do this before setting *type_change_ok or *size_change_ok so that
1272
we warn properly when dynamic library symbols are overridden. */
1274
if (newdef && !newdyn && olddyn)
1276
if (olddef && newdyn)
1279
/* Allow changes between different types of function symbol. */
1280
if (newfunc && oldfunc)
1281
*type_change_ok = TRUE;
1283
/* It's OK to change the type if either the existing symbol or the
1284
new symbol is weak. A type change is also OK if the old symbol
1285
is undefined and the new symbol is defined. */
1290
&& h->root.type == bfd_link_hash_undefined))
1291
*type_change_ok = TRUE;
1293
/* It's OK to change the size if either the existing symbol or the
1294
new symbol is weak, or if the old symbol is undefined. */
1297
|| h->root.type == bfd_link_hash_undefined)
1298
*size_change_ok = TRUE;
1300
/* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1301
symbol, respectively, appears to be a common symbol in a dynamic
1302
object. If a symbol appears in an uninitialized section, and is
1303
not weak, and is not a function, then it may be a common symbol
1304
which was resolved when the dynamic object was created. We want
1305
to treat such symbols specially, because they raise special
1306
considerations when setting the symbol size: if the symbol
1307
appears as a common symbol in a regular object, and the size in
1308
the regular object is larger, we must make sure that we use the
1309
larger size. This problematic case can always be avoided in C,
1310
but it must be handled correctly when using Fortran shared
1313
Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1314
likewise for OLDDYNCOMMON and OLDDEF.
1316
Note that this test is just a heuristic, and that it is quite
1317
possible to have an uninitialized symbol in a shared object which
1318
is really a definition, rather than a common symbol. This could
1319
lead to some minor confusion when the symbol really is a common
1320
symbol in some regular object. However, I think it will be
1326
&& (sec->flags & SEC_ALLOC) != 0
1327
&& (sec->flags & SEC_LOAD) == 0
1330
newdyncommon = TRUE;
1332
newdyncommon = FALSE;
1336
&& h->root.type == bfd_link_hash_defined
1338
&& (h->root.u.def.section->flags & SEC_ALLOC) != 0
1339
&& (h->root.u.def.section->flags & SEC_LOAD) == 0
1342
olddyncommon = TRUE;
1344
olddyncommon = FALSE;
1346
/* We now know everything about the old and new symbols. We ask the
1347
backend to check if we can merge them. */
1348
if (bed->merge_symbol != NULL)
1350
if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
1355
/* If both the old and the new symbols look like common symbols in a
1356
dynamic object, set the size of the symbol to the larger of the
1361
&& sym->st_size != h->size)
1363
/* Since we think we have two common symbols, issue a multiple
1364
common warning if desired. Note that we only warn if the
1365
size is different. If the size is the same, we simply let
1366
the old symbol override the new one as normally happens with
1367
symbols defined in dynamic objects. */
1369
if (! ((*info->callbacks->multiple_common)
1370
(info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1373
if (sym->st_size > h->size)
1374
h->size = sym->st_size;
1376
*size_change_ok = TRUE;
1379
/* If we are looking at a dynamic object, and we have found a
1380
definition, we need to see if the symbol was already defined by
1381
some other object. If so, we want to use the existing
1382
definition, and we do not want to report a multiple symbol
1383
definition error; we do this by clobbering *PSEC to be
1384
bfd_und_section_ptr.
1386
We treat a common symbol as a definition if the symbol in the
1387
shared library is a function, since common symbols always
1388
represent variables; this can cause confusion in principle, but
1389
any such confusion would seem to indicate an erroneous program or
1390
shared library. We also permit a common symbol in a regular
1391
object to override a weak symbol in a shared object. */
1396
|| (h->root.type == bfd_link_hash_common
1397
&& (newweak || newfunc))))
1401
newdyncommon = FALSE;
1403
*psec = sec = bfd_und_section_ptr;
1404
*size_change_ok = TRUE;
1406
/* If we get here when the old symbol is a common symbol, then
1407
we are explicitly letting it override a weak symbol or
1408
function in a dynamic object, and we don't want to warn about
1409
a type change. If the old symbol is a defined symbol, a type
1410
change warning may still be appropriate. */
1412
if (h->root.type == bfd_link_hash_common)
1413
*type_change_ok = TRUE;
1416
/* Handle the special case of an old common symbol merging with a
1417
new symbol which looks like a common symbol in a shared object.
1418
We change *PSEC and *PVALUE to make the new symbol look like a
1419
common symbol, and let _bfd_generic_link_add_one_symbol do the
1423
&& h->root.type == bfd_link_hash_common)
1427
newdyncommon = FALSE;
1428
*pvalue = sym->st_size;
1429
*psec = sec = bed->common_section (oldsec);
1430
*size_change_ok = TRUE;
1433
/* Skip weak definitions of symbols that are already defined. */
1434
if (newdef && olddef && newweak)
1436
/* Don't skip new non-IR weak syms. */
1437
if (!(oldbfd != NULL
1438
&& (oldbfd->flags & BFD_PLUGIN) != 0
1439
&& (abfd->flags & BFD_PLUGIN) == 0))
1442
/* Merge st_other. If the symbol already has a dynamic index,
1443
but visibility says it should not be visible, turn it into a
1445
elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1446
if (h->dynindx != -1)
1447
switch (ELF_ST_VISIBILITY (h->other))
1451
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
1456
/* If the old symbol is from a dynamic object, and the new symbol is
1457
a definition which is not from a dynamic object, then the new
1458
symbol overrides the old symbol. Symbols from regular files
1459
always take precedence over symbols from dynamic objects, even if
1460
they are defined after the dynamic object in the link.
1462
As above, we again permit a common symbol in a regular object to
1463
override a definition in a shared object if the shared object
1464
symbol is a function or is weak. */
1469
|| (bfd_is_com_section (sec)
1470
&& (oldweak || oldfunc)))
1475
/* Change the hash table entry to undefined, and let
1476
_bfd_generic_link_add_one_symbol do the right thing with the
1479
h->root.type = bfd_link_hash_undefined;
1480
h->root.u.undef.abfd = h->root.u.def.section->owner;
1481
*size_change_ok = TRUE;
1484
olddyncommon = FALSE;
1486
/* We again permit a type change when a common symbol may be
1487
overriding a function. */
1489
if (bfd_is_com_section (sec))
1493
/* If a common symbol overrides a function, make sure
1494
that it isn't defined dynamically nor has type
1497
h->type = STT_NOTYPE;
1499
*type_change_ok = TRUE;
1502
if (hi->root.type == bfd_link_hash_indirect)
1505
/* This union may have been set to be non-NULL when this symbol
1506
was seen in a dynamic object. We must force the union to be
1507
NULL, so that it is correct for a regular symbol. */
1508
h->verinfo.vertree = NULL;
1511
/* Handle the special case of a new common symbol merging with an
1512
old symbol that looks like it might be a common symbol defined in
1513
a shared object. Note that we have already handled the case in
1514
which a new common symbol should simply override the definition
1515
in the shared library. */
1518
&& bfd_is_com_section (sec)
1521
/* It would be best if we could set the hash table entry to a
1522
common symbol, but we don't know what to use for the section
1523
or the alignment. */
1524
if (! ((*info->callbacks->multiple_common)
1525
(info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1528
/* If the presumed common symbol in the dynamic object is
1529
larger, pretend that the new symbol has its size. */
1531
if (h->size > *pvalue)
1534
/* We need to remember the alignment required by the symbol
1535
in the dynamic object. */
1536
BFD_ASSERT (pold_alignment);
1537
*pold_alignment = h->root.u.def.section->alignment_power;
1540
olddyncommon = FALSE;
1542
h->root.type = bfd_link_hash_undefined;
1543
h->root.u.undef.abfd = h->root.u.def.section->owner;
1545
*size_change_ok = TRUE;
1546
*type_change_ok = TRUE;
1548
if (hi->root.type == bfd_link_hash_indirect)
1551
h->verinfo.vertree = NULL;
1556
/* Handle the case where we had a versioned symbol in a dynamic
1557
library and now find a definition in a normal object. In this
1558
case, we make the versioned symbol point to the normal one. */
1559
flip->root.type = h->root.type;
1560
flip->root.u.undef.abfd = h->root.u.undef.abfd;
1561
h->root.type = bfd_link_hash_indirect;
1562
h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1563
(*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1567
flip->ref_dynamic = 1;
1574
/* This function is called to create an indirect symbol from the
1575
default for the symbol with the default version if needed. The
1576
symbol is described by H, NAME, SYM, SEC, and VALUE. We
1577
set DYNSYM if the new indirect symbol is dynamic. */
1580
_bfd_elf_add_default_symbol (bfd *abfd,
1581
struct bfd_link_info *info,
1582
struct elf_link_hash_entry *h,
1584
Elf_Internal_Sym *sym,
1588
bfd_boolean *dynsym)
1590
bfd_boolean type_change_ok;
1591
bfd_boolean size_change_ok;
1594
struct elf_link_hash_entry *hi;
1595
struct bfd_link_hash_entry *bh;
1596
const struct elf_backend_data *bed;
1597
bfd_boolean collect;
1598
bfd_boolean dynamic;
1599
bfd_boolean override;
1601
size_t len, shortlen;
1604
/* If this symbol has a version, and it is the default version, we
1605
create an indirect symbol from the default name to the fully
1606
decorated name. This will cause external references which do not
1607
specify a version to be bound to this version of the symbol. */
1608
p = strchr (name, ELF_VER_CHR);
1609
if (p == NULL || p[1] != ELF_VER_CHR)
1612
bed = get_elf_backend_data (abfd);
1613
collect = bed->collect;
1614
dynamic = (abfd->flags & DYNAMIC) != 0;
1616
shortlen = p - name;
1617
shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1618
if (shortname == NULL)
1620
memcpy (shortname, name, shortlen);
1621
shortname[shortlen] = '\0';
1623
/* We are going to create a new symbol. Merge it with any existing
1624
symbol with this name. For the purposes of the merge, act as
1625
though we were defining the symbol we just defined, although we
1626
actually going to define an indirect symbol. */
1627
type_change_ok = FALSE;
1628
size_change_ok = FALSE;
1630
if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1631
&hi, poldbfd, NULL, NULL, &skip, &override,
1632
&type_change_ok, &size_change_ok))
1641
if (! (_bfd_generic_link_add_one_symbol
1642
(info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1643
0, name, FALSE, collect, &bh)))
1645
hi = (struct elf_link_hash_entry *) bh;
1649
/* In this case the symbol named SHORTNAME is overriding the
1650
indirect symbol we want to add. We were planning on making
1651
SHORTNAME an indirect symbol referring to NAME. SHORTNAME
1652
is the name without a version. NAME is the fully versioned
1653
name, and it is the default version.
1655
Overriding means that we already saw a definition for the
1656
symbol SHORTNAME in a regular object, and it is overriding
1657
the symbol defined in the dynamic object.
1659
When this happens, we actually want to change NAME, the
1660
symbol we just added, to refer to SHORTNAME. This will cause
1661
references to NAME in the shared object to become references
1662
to SHORTNAME in the regular object. This is what we expect
1663
when we override a function in a shared object: that the
1664
references in the shared object will be mapped to the
1665
definition in the regular object. */
1667
while (hi->root.type == bfd_link_hash_indirect
1668
|| hi->root.type == bfd_link_hash_warning)
1669
hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1671
h->root.type = bfd_link_hash_indirect;
1672
h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1676
hi->ref_dynamic = 1;
1680
if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1685
/* Now set HI to H, so that the following code will set the
1686
other fields correctly. */
1690
/* Check if HI is a warning symbol. */
1691
if (hi->root.type == bfd_link_hash_warning)
1692
hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1694
/* If there is a duplicate definition somewhere, then HI may not
1695
point to an indirect symbol. We will have reported an error to
1696
the user in that case. */
1698
if (hi->root.type == bfd_link_hash_indirect)
1700
struct elf_link_hash_entry *ht;
1702
ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1703
(*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1705
/* See if the new flags lead us to realize that the symbol must
1711
if (! info->executable
1718
if (hi->ref_regular)
1724
/* We also need to define an indirection from the nondefault version
1728
len = strlen (name);
1729
shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1730
if (shortname == NULL)
1732
memcpy (shortname, name, shortlen);
1733
memcpy (shortname + shortlen, p + 1, len - shortlen);
1735
/* Once again, merge with any existing symbol. */
1736
type_change_ok = FALSE;
1737
size_change_ok = FALSE;
1739
if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1740
&hi, NULL, NULL, NULL, &skip, &override,
1741
&type_change_ok, &size_change_ok))
1749
/* Here SHORTNAME is a versioned name, so we don't expect to see
1750
the type of override we do in the case above unless it is
1751
overridden by a versioned definition. */
1752
if (hi->root.type != bfd_link_hash_defined
1753
&& hi->root.type != bfd_link_hash_defweak)
1754
(*_bfd_error_handler)
1755
(_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1761
if (! (_bfd_generic_link_add_one_symbol
1762
(info, abfd, shortname, BSF_INDIRECT,
1763
bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1765
hi = (struct elf_link_hash_entry *) bh;
1767
/* If there is a duplicate definition somewhere, then HI may not
1768
point to an indirect symbol. We will have reported an error
1769
to the user in that case. */
1771
if (hi->root.type == bfd_link_hash_indirect)
1773
(*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1775
/* See if the new flags lead us to realize that the symbol
1781
if (! info->executable
1787
if (hi->ref_regular)
1797
/* This routine is used to export all defined symbols into the dynamic
1798
symbol table. It is called via elf_link_hash_traverse. */
1801
_bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1803
struct elf_info_failed *eif = (struct elf_info_failed *) data;
1805
/* Ignore indirect symbols. These are added by the versioning code. */
1806
if (h->root.type == bfd_link_hash_indirect)
1809
/* Ignore this if we won't export it. */
1810
if (!eif->info->export_dynamic && !h->dynamic)
1813
if (h->dynindx == -1
1814
&& (h->def_regular || h->ref_regular)
1815
&& ! bfd_hide_sym_by_version (eif->info->version_info,
1816
h->root.root.string))
1818
if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1828
/* Look through the symbols which are defined in other shared
1829
libraries and referenced here. Update the list of version
1830
dependencies. This will be put into the .gnu.version_r section.
1831
This function is called via elf_link_hash_traverse. */
1834
_bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1837
struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1838
Elf_Internal_Verneed *t;
1839
Elf_Internal_Vernaux *a;
1842
/* We only care about symbols defined in shared objects with version
1847
|| h->verinfo.verdef == NULL)
1850
/* See if we already know about this version. */
1851
for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1855
if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1858
for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1859
if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1865
/* This is a new version. Add it to tree we are building. */
1870
t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1873
rinfo->failed = TRUE;
1877
t->vn_bfd = h->verinfo.verdef->vd_bfd;
1878
t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1879
elf_tdata (rinfo->info->output_bfd)->verref = t;
1883
a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1886
rinfo->failed = TRUE;
1890
/* Note that we are copying a string pointer here, and testing it
1891
above. If bfd_elf_string_from_elf_section is ever changed to
1892
discard the string data when low in memory, this will have to be
1894
a->vna_nodename = h->verinfo.verdef->vd_nodename;
1896
a->vna_flags = h->verinfo.verdef->vd_flags;
1897
a->vna_nextptr = t->vn_auxptr;
1899
h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1902
a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1909
/* Figure out appropriate versions for all the symbols. We may not
1910
have the version number script until we have read all of the input
1911
files, so until that point we don't know which symbols should be
1912
local. This function is called via elf_link_hash_traverse. */
1915
_bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1917
struct elf_info_failed *sinfo;
1918
struct bfd_link_info *info;
1919
const struct elf_backend_data *bed;
1920
struct elf_info_failed eif;
1924
sinfo = (struct elf_info_failed *) data;
1927
/* Fix the symbol flags. */
1930
if (! _bfd_elf_fix_symbol_flags (h, &eif))
1933
sinfo->failed = TRUE;
1937
/* We only need version numbers for symbols defined in regular
1939
if (!h->def_regular)
1942
bed = get_elf_backend_data (info->output_bfd);
1943
p = strchr (h->root.root.string, ELF_VER_CHR);
1944
if (p != NULL && h->verinfo.vertree == NULL)
1946
struct bfd_elf_version_tree *t;
1951
/* There are two consecutive ELF_VER_CHR characters if this is
1952
not a hidden symbol. */
1954
if (*p == ELF_VER_CHR)
1960
/* If there is no version string, we can just return out. */
1968
/* Look for the version. If we find it, it is no longer weak. */
1969
for (t = sinfo->info->version_info; t != NULL; t = t->next)
1971
if (strcmp (t->name, p) == 0)
1975
struct bfd_elf_version_expr *d;
1977
len = p - h->root.root.string;
1978
alc = (char *) bfd_malloc (len);
1981
sinfo->failed = TRUE;
1984
memcpy (alc, h->root.root.string, len - 1);
1985
alc[len - 1] = '\0';
1986
if (alc[len - 2] == ELF_VER_CHR)
1987
alc[len - 2] = '\0';
1989
h->verinfo.vertree = t;
1993
if (t->globals.list != NULL)
1994
d = (*t->match) (&t->globals, NULL, alc);
1996
/* See if there is anything to force this symbol to
1998
if (d == NULL && t->locals.list != NULL)
2000
d = (*t->match) (&t->locals, NULL, alc);
2003
&& ! info->export_dynamic)
2004
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
2012
/* If we are building an application, we need to create a
2013
version node for this version. */
2014
if (t == NULL && info->executable)
2016
struct bfd_elf_version_tree **pp;
2019
/* If we aren't going to export this symbol, we don't need
2020
to worry about it. */
2021
if (h->dynindx == -1)
2025
t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2028
sinfo->failed = TRUE;
2033
t->name_indx = (unsigned int) -1;
2037
/* Don't count anonymous version tag. */
2038
if (sinfo->info->version_info != NULL
2039
&& sinfo->info->version_info->vernum == 0)
2041
for (pp = &sinfo->info->version_info;
2045
t->vernum = version_index;
2049
h->verinfo.vertree = t;
2053
/* We could not find the version for a symbol when
2054
generating a shared archive. Return an error. */
2055
(*_bfd_error_handler)
2056
(_("%B: version node not found for symbol %s"),
2057
info->output_bfd, h->root.root.string);
2058
bfd_set_error (bfd_error_bad_value);
2059
sinfo->failed = TRUE;
2067
/* If we don't have a version for this symbol, see if we can find
2069
if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2074
= bfd_find_version_for_sym (sinfo->info->version_info,
2075
h->root.root.string, &hide);
2076
if (h->verinfo.vertree != NULL && hide)
2077
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
2083
/* Read and swap the relocs from the section indicated by SHDR. This
2084
may be either a REL or a RELA section. The relocations are
2085
translated into RELA relocations and stored in INTERNAL_RELOCS,
2086
which should have already been allocated to contain enough space.
2087
The EXTERNAL_RELOCS are a buffer where the external form of the
2088
relocations should be stored.
2090
Returns FALSE if something goes wrong. */
2093
elf_link_read_relocs_from_section (bfd *abfd,
2095
Elf_Internal_Shdr *shdr,
2096
void *external_relocs,
2097
Elf_Internal_Rela *internal_relocs)
2099
const struct elf_backend_data *bed;
2100
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2101
const bfd_byte *erela;
2102
const bfd_byte *erelaend;
2103
Elf_Internal_Rela *irela;
2104
Elf_Internal_Shdr *symtab_hdr;
2107
/* Position ourselves at the start of the section. */
2108
if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2111
/* Read the relocations. */
2112
if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2115
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2116
nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2118
bed = get_elf_backend_data (abfd);
2120
/* Convert the external relocations to the internal format. */
2121
if (shdr->sh_entsize == bed->s->sizeof_rel)
2122
swap_in = bed->s->swap_reloc_in;
2123
else if (shdr->sh_entsize == bed->s->sizeof_rela)
2124
swap_in = bed->s->swap_reloca_in;
2127
bfd_set_error (bfd_error_wrong_format);
2131
erela = (const bfd_byte *) external_relocs;
2132
erelaend = erela + shdr->sh_size;
2133
irela = internal_relocs;
2134
while (erela < erelaend)
2138
(*swap_in) (abfd, erela, irela);
2139
r_symndx = ELF32_R_SYM (irela->r_info);
2140
if (bed->s->arch_size == 64)
2144
if ((size_t) r_symndx >= nsyms)
2146
(*_bfd_error_handler)
2147
(_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2148
" for offset 0x%lx in section `%A'"),
2150
(unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2151
bfd_set_error (bfd_error_bad_value);
2155
else if (r_symndx != STN_UNDEF)
2157
(*_bfd_error_handler)
2158
(_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2159
" when the object file has no symbol table"),
2161
(unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2162
bfd_set_error (bfd_error_bad_value);
2165
irela += bed->s->int_rels_per_ext_rel;
2166
erela += shdr->sh_entsize;
2172
/* Read and swap the relocs for a section O. They may have been
2173
cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2174
not NULL, they are used as buffers to read into. They are known to
2175
be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
2176
the return value is allocated using either malloc or bfd_alloc,
2177
according to the KEEP_MEMORY argument. If O has two relocation
2178
sections (both REL and RELA relocations), then the REL_HDR
2179
relocations will appear first in INTERNAL_RELOCS, followed by the
2180
RELA_HDR relocations. */
2183
_bfd_elf_link_read_relocs (bfd *abfd,
2185
void *external_relocs,
2186
Elf_Internal_Rela *internal_relocs,
2187
bfd_boolean keep_memory)
2189
void *alloc1 = NULL;
2190
Elf_Internal_Rela *alloc2 = NULL;
2191
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2192
struct bfd_elf_section_data *esdo = elf_section_data (o);
2193
Elf_Internal_Rela *internal_rela_relocs;
2195
if (esdo->relocs != NULL)
2196
return esdo->relocs;
2198
if (o->reloc_count == 0)
2201
if (internal_relocs == NULL)
2205
size = o->reloc_count;
2206
size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2208
internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2210
internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2211
if (internal_relocs == NULL)
2215
if (external_relocs == NULL)
2217
bfd_size_type size = 0;
2220
size += esdo->rel.hdr->sh_size;
2222
size += esdo->rela.hdr->sh_size;
2224
alloc1 = bfd_malloc (size);
2227
external_relocs = alloc1;
2230
internal_rela_relocs = internal_relocs;
2233
if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2237
external_relocs = (((bfd_byte *) external_relocs)
2238
+ esdo->rel.hdr->sh_size);
2239
internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2240
* bed->s->int_rels_per_ext_rel);
2244
&& (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2246
internal_rela_relocs)))
2249
/* Cache the results for next time, if we can. */
2251
esdo->relocs = internal_relocs;
2256
/* Don't free alloc2, since if it was allocated we are passing it
2257
back (under the name of internal_relocs). */
2259
return internal_relocs;
2267
bfd_release (abfd, alloc2);
2274
/* Compute the size of, and allocate space for, REL_HDR which is the
2275
section header for a section containing relocations for O. */
2278
_bfd_elf_link_size_reloc_section (bfd *abfd,
2279
struct bfd_elf_section_reloc_data *reldata)
2281
Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2283
/* That allows us to calculate the size of the section. */
2284
rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2286
/* The contents field must last into write_object_contents, so we
2287
allocate it with bfd_alloc rather than malloc. Also since we
2288
cannot be sure that the contents will actually be filled in,
2289
we zero the allocated space. */
2290
rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2291
if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2294
if (reldata->hashes == NULL && reldata->count)
2296
struct elf_link_hash_entry **p;
2298
p = (struct elf_link_hash_entry **)
2299
bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
2303
reldata->hashes = p;
2309
/* Copy the relocations indicated by the INTERNAL_RELOCS (which
2310
originated from the section given by INPUT_REL_HDR) to the
2314
_bfd_elf_link_output_relocs (bfd *output_bfd,
2315
asection *input_section,
2316
Elf_Internal_Shdr *input_rel_hdr,
2317
Elf_Internal_Rela *internal_relocs,
2318
struct elf_link_hash_entry **rel_hash
2321
Elf_Internal_Rela *irela;
2322
Elf_Internal_Rela *irelaend;
2324
struct bfd_elf_section_reloc_data *output_reldata;
2325
asection *output_section;
2326
const struct elf_backend_data *bed;
2327
void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2328
struct bfd_elf_section_data *esdo;
2330
output_section = input_section->output_section;
2332
bed = get_elf_backend_data (output_bfd);
2333
esdo = elf_section_data (output_section);
2334
if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2336
output_reldata = &esdo->rel;
2337
swap_out = bed->s->swap_reloc_out;
2339
else if (esdo->rela.hdr
2340
&& esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2342
output_reldata = &esdo->rela;
2343
swap_out = bed->s->swap_reloca_out;
2347
(*_bfd_error_handler)
2348
(_("%B: relocation size mismatch in %B section %A"),
2349
output_bfd, input_section->owner, input_section);
2350
bfd_set_error (bfd_error_wrong_format);
2354
erel = output_reldata->hdr->contents;
2355
erel += output_reldata->count * input_rel_hdr->sh_entsize;
2356
irela = internal_relocs;
2357
irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2358
* bed->s->int_rels_per_ext_rel);
2359
while (irela < irelaend)
2361
(*swap_out) (output_bfd, irela, erel);
2362
irela += bed->s->int_rels_per_ext_rel;
2363
erel += input_rel_hdr->sh_entsize;
2366
/* Bump the counter, so that we know where to add the next set of
2368
output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2373
/* Make weak undefined symbols in PIE dynamic. */
2376
_bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2377
struct elf_link_hash_entry *h)
2381
&& h->root.type == bfd_link_hash_undefweak)
2382
return bfd_elf_link_record_dynamic_symbol (info, h);
2387
/* Fix up the flags for a symbol. This handles various cases which
2388
can only be fixed after all the input files are seen. This is
2389
currently called by both adjust_dynamic_symbol and
2390
assign_sym_version, which is unnecessary but perhaps more robust in
2391
the face of future changes. */
2394
_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2395
struct elf_info_failed *eif)
2397
const struct elf_backend_data *bed;
2399
/* If this symbol was mentioned in a non-ELF file, try to set
2400
DEF_REGULAR and REF_REGULAR correctly. This is the only way to
2401
permit a non-ELF file to correctly refer to a symbol defined in
2402
an ELF dynamic object. */
2405
while (h->root.type == bfd_link_hash_indirect)
2406
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2408
if (h->root.type != bfd_link_hash_defined
2409
&& h->root.type != bfd_link_hash_defweak)
2412
h->ref_regular_nonweak = 1;
2416
if (h->root.u.def.section->owner != NULL
2417
&& (bfd_get_flavour (h->root.u.def.section->owner)
2418
== bfd_target_elf_flavour))
2421
h->ref_regular_nonweak = 1;
2427
if (h->dynindx == -1
2431
if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2440
/* Unfortunately, NON_ELF is only correct if the symbol
2441
was first seen in a non-ELF file. Fortunately, if the symbol
2442
was first seen in an ELF file, we're probably OK unless the
2443
symbol was defined in a non-ELF file. Catch that case here.
2444
FIXME: We're still in trouble if the symbol was first seen in
2445
a dynamic object, and then later in a non-ELF regular object. */
2446
if ((h->root.type == bfd_link_hash_defined
2447
|| h->root.type == bfd_link_hash_defweak)
2449
&& (h->root.u.def.section->owner != NULL
2450
? (bfd_get_flavour (h->root.u.def.section->owner)
2451
!= bfd_target_elf_flavour)
2452
: (bfd_is_abs_section (h->root.u.def.section)
2453
&& !h->def_dynamic)))
2457
/* Backend specific symbol fixup. */
2458
bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2459
if (bed->elf_backend_fixup_symbol
2460
&& !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2463
/* If this is a final link, and the symbol was defined as a common
2464
symbol in a regular object file, and there was no definition in
2465
any dynamic object, then the linker will have allocated space for
2466
the symbol in a common section but the DEF_REGULAR
2467
flag will not have been set. */
2468
if (h->root.type == bfd_link_hash_defined
2472
&& (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0)
2475
/* If -Bsymbolic was used (which means to bind references to global
2476
symbols to the definition within the shared object), and this
2477
symbol was defined in a regular object, then it actually doesn't
2478
need a PLT entry. Likewise, if the symbol has non-default
2479
visibility. If the symbol has hidden or internal visibility, we
2480
will force it local. */
2482
&& eif->info->shared
2483
&& is_elf_hash_table (eif->info->hash)
2484
&& (SYMBOLIC_BIND (eif->info, h)
2485
|| ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2488
bfd_boolean force_local;
2490
force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2491
|| ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2492
(*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2495
/* If a weak undefined symbol has non-default visibility, we also
2496
hide it from the dynamic linker. */
2497
if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2498
&& h->root.type == bfd_link_hash_undefweak)
2499
(*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2501
/* If this is a weak defined symbol in a dynamic object, and we know
2502
the real definition in the dynamic object, copy interesting flags
2503
over to the real definition. */
2504
if (h->u.weakdef != NULL)
2506
/* If the real definition is defined by a regular object file,
2507
don't do anything special. See the longer description in
2508
_bfd_elf_adjust_dynamic_symbol, below. */
2509
if (h->u.weakdef->def_regular)
2510
h->u.weakdef = NULL;
2513
struct elf_link_hash_entry *weakdef = h->u.weakdef;
2515
while (h->root.type == bfd_link_hash_indirect)
2516
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2518
BFD_ASSERT (h->root.type == bfd_link_hash_defined
2519
|| h->root.type == bfd_link_hash_defweak);
2520
BFD_ASSERT (weakdef->def_dynamic);
2521
BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2522
|| weakdef->root.type == bfd_link_hash_defweak);
2523
(*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2530
/* Make the backend pick a good value for a dynamic symbol. This is
2531
called via elf_link_hash_traverse, and also calls itself
2535
_bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2537
struct elf_info_failed *eif = (struct elf_info_failed *) data;
2539
const struct elf_backend_data *bed;
2541
if (! is_elf_hash_table (eif->info->hash))
2544
/* Ignore indirect symbols. These are added by the versioning code. */
2545
if (h->root.type == bfd_link_hash_indirect)
2548
/* Fix the symbol flags. */
2549
if (! _bfd_elf_fix_symbol_flags (h, eif))
2552
/* If this symbol does not require a PLT entry, and it is not
2553
defined by a dynamic object, or is not referenced by a regular
2554
object, ignore it. We do have to handle a weak defined symbol,
2555
even if no regular object refers to it, if we decided to add it
2556
to the dynamic symbol table. FIXME: Do we normally need to worry
2557
about symbols which are defined by one dynamic object and
2558
referenced by another one? */
2560
&& h->type != STT_GNU_IFUNC
2564
&& (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2566
h->plt = elf_hash_table (eif->info)->init_plt_offset;
2570
/* If we've already adjusted this symbol, don't do it again. This
2571
can happen via a recursive call. */
2572
if (h->dynamic_adjusted)
2575
/* Don't look at this symbol again. Note that we must set this
2576
after checking the above conditions, because we may look at a
2577
symbol once, decide not to do anything, and then get called
2578
recursively later after REF_REGULAR is set below. */
2579
h->dynamic_adjusted = 1;
2581
/* If this is a weak definition, and we know a real definition, and
2582
the real symbol is not itself defined by a regular object file,
2583
then get a good value for the real definition. We handle the
2584
real symbol first, for the convenience of the backend routine.
2586
Note that there is a confusing case here. If the real definition
2587
is defined by a regular object file, we don't get the real symbol
2588
from the dynamic object, but we do get the weak symbol. If the
2589
processor backend uses a COPY reloc, then if some routine in the
2590
dynamic object changes the real symbol, we will not see that
2591
change in the corresponding weak symbol. This is the way other
2592
ELF linkers work as well, and seems to be a result of the shared
2595
I will clarify this issue. Most SVR4 shared libraries define the
2596
variable _timezone and define timezone as a weak synonym. The
2597
tzset call changes _timezone. If you write
2598
extern int timezone;
2600
int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2601
you might expect that, since timezone is a synonym for _timezone,
2602
the same number will print both times. However, if the processor
2603
backend uses a COPY reloc, then actually timezone will be copied
2604
into your process image, and, since you define _timezone
2605
yourself, _timezone will not. Thus timezone and _timezone will
2606
wind up at different memory locations. The tzset call will set
2607
_timezone, leaving timezone unchanged. */
2609
if (h->u.weakdef != NULL)
2611
/* If we get to this point, there is an implicit reference to
2612
H->U.WEAKDEF by a regular object file via the weak symbol H. */
2613
h->u.weakdef->ref_regular = 1;
2615
/* Ensure that the backend adjust_dynamic_symbol function sees
2616
H->U.WEAKDEF before H by recursively calling ourselves. */
2617
if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2621
/* If a symbol has no type and no size and does not require a PLT
2622
entry, then we are probably about to do the wrong thing here: we
2623
are probably going to create a COPY reloc for an empty object.
2624
This case can arise when a shared object is built with assembly
2625
code, and the assembly code fails to set the symbol type. */
2627
&& h->type == STT_NOTYPE
2629
(*_bfd_error_handler)
2630
(_("warning: type and size of dynamic symbol `%s' are not defined"),
2631
h->root.root.string);
2633
dynobj = elf_hash_table (eif->info)->dynobj;
2634
bed = get_elf_backend_data (dynobj);
2636
if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2645
/* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2649
_bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2652
unsigned int power_of_two;
2654
asection *sec = h->root.u.def.section;
2656
/* The section aligment of definition is the maximum alignment
2657
requirement of symbols defined in the section. Since we don't
2658
know the symbol alignment requirement, we start with the
2659
maximum alignment and check low bits of the symbol address
2660
for the minimum alignment. */
2661
power_of_two = bfd_get_section_alignment (sec->owner, sec);
2662
mask = ((bfd_vma) 1 << power_of_two) - 1;
2663
while ((h->root.u.def.value & mask) != 0)
2669
if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2672
/* Adjust the section alignment if needed. */
2673
if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2678
/* We make sure that the symbol will be aligned properly. */
2679
dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2681
/* Define the symbol as being at this point in DYNBSS. */
2682
h->root.u.def.section = dynbss;
2683
h->root.u.def.value = dynbss->size;
2685
/* Increment the size of DYNBSS to make room for the symbol. */
2686
dynbss->size += h->size;
2691
/* Adjust all external symbols pointing into SEC_MERGE sections
2692
to reflect the object merging within the sections. */
2695
_bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2699
if ((h->root.type == bfd_link_hash_defined
2700
|| h->root.type == bfd_link_hash_defweak)
2701
&& ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2702
&& sec->sec_info_type == SEC_INFO_TYPE_MERGE)
2704
bfd *output_bfd = (bfd *) data;
2706
h->root.u.def.value =
2707
_bfd_merged_section_offset (output_bfd,
2708
&h->root.u.def.section,
2709
elf_section_data (sec)->sec_info,
2710
h->root.u.def.value);
2716
/* Returns false if the symbol referred to by H should be considered
2717
to resolve local to the current module, and true if it should be
2718
considered to bind dynamically. */
2721
_bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2722
struct bfd_link_info *info,
2723
bfd_boolean not_local_protected)
2725
bfd_boolean binding_stays_local_p;
2726
const struct elf_backend_data *bed;
2727
struct elf_link_hash_table *hash_table;
2732
while (h->root.type == bfd_link_hash_indirect
2733
|| h->root.type == bfd_link_hash_warning)
2734
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2736
/* If it was forced local, then clearly it's not dynamic. */
2737
if (h->dynindx == -1)
2739
if (h->forced_local)
2742
/* Identify the cases where name binding rules say that a
2743
visible symbol resolves locally. */
2744
binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2746
switch (ELF_ST_VISIBILITY (h->other))
2753
hash_table = elf_hash_table (info);
2754
if (!is_elf_hash_table (hash_table))
2757
bed = get_elf_backend_data (hash_table->dynobj);
2759
/* Proper resolution for function pointer equality may require
2760
that these symbols perhaps be resolved dynamically, even though
2761
we should be resolving them to the current module. */
2762
if (!not_local_protected || !bed->is_function_type (h->type))
2763
binding_stays_local_p = TRUE;
2770
/* If it isn't defined locally, then clearly it's dynamic. */
2771
if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2774
/* Otherwise, the symbol is dynamic if binding rules don't tell
2775
us that it remains local. */
2776
return !binding_stays_local_p;
2779
/* Return true if the symbol referred to by H should be considered
2780
to resolve local to the current module, and false otherwise. Differs
2781
from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2782
undefined symbols. The two functions are virtually identical except
2783
for the place where forced_local and dynindx == -1 are tested. If
2784
either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2785
the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2786
the symbol is local only for defined symbols.
2787
It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2788
!_bfd_elf_symbol_refs_local_p, except that targets differ in their
2789
treatment of undefined weak symbols. For those that do not make
2790
undefined weak symbols dynamic, both functions may return false. */
2793
_bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2794
struct bfd_link_info *info,
2795
bfd_boolean local_protected)
2797
const struct elf_backend_data *bed;
2798
struct elf_link_hash_table *hash_table;
2800
/* If it's a local sym, of course we resolve locally. */
2804
/* STV_HIDDEN or STV_INTERNAL ones must be local. */
2805
if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2806
|| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2809
/* Common symbols that become definitions don't get the DEF_REGULAR
2810
flag set, so test it first, and don't bail out. */
2811
if (ELF_COMMON_DEF_P (h))
2813
/* If we don't have a definition in a regular file, then we can't
2814
resolve locally. The sym is either undefined or dynamic. */
2815
else if (!h->def_regular)
2818
/* Forced local symbols resolve locally. */
2819
if (h->forced_local)
2822
/* As do non-dynamic symbols. */
2823
if (h->dynindx == -1)
2826
/* At this point, we know the symbol is defined and dynamic. In an
2827
executable it must resolve locally, likewise when building symbolic
2828
shared libraries. */
2829
if (info->executable || SYMBOLIC_BIND (info, h))
2832
/* Now deal with defined dynamic symbols in shared libraries. Ones
2833
with default visibility might not resolve locally. */
2834
if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2837
hash_table = elf_hash_table (info);
2838
if (!is_elf_hash_table (hash_table))
2841
bed = get_elf_backend_data (hash_table->dynobj);
2843
/* STV_PROTECTED non-function symbols are local. */
2844
if (!bed->is_function_type (h->type))
2847
/* Function pointer equality tests may require that STV_PROTECTED
2848
symbols be treated as dynamic symbols. If the address of a
2849
function not defined in an executable is set to that function's
2850
plt entry in the executable, then the address of the function in
2851
a shared library must also be the plt entry in the executable. */
2852
return local_protected;
2855
/* Caches some TLS segment info, and ensures that the TLS segment vma is
2856
aligned. Returns the first TLS output section. */
2858
struct bfd_section *
2859
_bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2861
struct bfd_section *sec, *tls;
2862
unsigned int align = 0;
2864
for (sec = obfd->sections; sec != NULL; sec = sec->next)
2865
if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2869
for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2870
if (sec->alignment_power > align)
2871
align = sec->alignment_power;
2873
elf_hash_table (info)->tls_sec = tls;
2875
/* Ensure the alignment of the first section is the largest alignment,
2876
so that the tls segment starts aligned. */
2878
tls->alignment_power = align;
2883
/* Return TRUE iff this is a non-common, definition of a non-function symbol. */
2885
is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2886
Elf_Internal_Sym *sym)
2888
const struct elf_backend_data *bed;
2890
/* Local symbols do not count, but target specific ones might. */
2891
if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2892
&& ELF_ST_BIND (sym->st_info) < STB_LOOS)
2895
bed = get_elf_backend_data (abfd);
2896
/* Function symbols do not count. */
2897
if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2900
/* If the section is undefined, then so is the symbol. */
2901
if (sym->st_shndx == SHN_UNDEF)
2904
/* If the symbol is defined in the common section, then
2905
it is a common definition and so does not count. */
2906
if (bed->common_definition (sym))
2909
/* If the symbol is in a target specific section then we
2910
must rely upon the backend to tell us what it is. */
2911
if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2912
/* FIXME - this function is not coded yet:
2914
return _bfd_is_global_symbol_definition (abfd, sym);
2916
Instead for now assume that the definition is not global,
2917
Even if this is wrong, at least the linker will behave
2918
in the same way that it used to do. */
2924
/* Search the symbol table of the archive element of the archive ABFD
2925
whose archive map contains a mention of SYMDEF, and determine if
2926
the symbol is defined in this element. */
2928
elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2930
Elf_Internal_Shdr * hdr;
2931
bfd_size_type symcount;
2932
bfd_size_type extsymcount;
2933
bfd_size_type extsymoff;
2934
Elf_Internal_Sym *isymbuf;
2935
Elf_Internal_Sym *isym;
2936
Elf_Internal_Sym *isymend;
2939
abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2943
if (! bfd_check_format (abfd, bfd_object))
2946
/* If we have already included the element containing this symbol in the
2947
link then we do not need to include it again. Just claim that any symbol
2948
it contains is not a definition, so that our caller will not decide to
2949
(re)include this element. */
2950
if (abfd->archive_pass)
2953
/* Select the appropriate symbol table. */
2954
if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2955
hdr = &elf_tdata (abfd)->symtab_hdr;
2957
hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2959
symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2961
/* The sh_info field of the symtab header tells us where the
2962
external symbols start. We don't care about the local symbols. */
2963
if (elf_bad_symtab (abfd))
2965
extsymcount = symcount;
2970
extsymcount = symcount - hdr->sh_info;
2971
extsymoff = hdr->sh_info;
2974
if (extsymcount == 0)
2977
/* Read in the symbol table. */
2978
isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
2980
if (isymbuf == NULL)
2983
/* Scan the symbol table looking for SYMDEF. */
2985
for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
2989
name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
2994
if (strcmp (name, symdef->name) == 0)
2996
result = is_global_data_symbol_definition (abfd, isym);
3006
/* Add an entry to the .dynamic table. */
3009
_bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3013
struct elf_link_hash_table *hash_table;
3014
const struct elf_backend_data *bed;
3016
bfd_size_type newsize;
3017
bfd_byte *newcontents;
3018
Elf_Internal_Dyn dyn;
3020
hash_table = elf_hash_table (info);
3021
if (! is_elf_hash_table (hash_table))
3024
bed = get_elf_backend_data (hash_table->dynobj);
3025
s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3026
BFD_ASSERT (s != NULL);
3028
newsize = s->size + bed->s->sizeof_dyn;
3029
newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3030
if (newcontents == NULL)
3034
dyn.d_un.d_val = val;
3035
bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3038
s->contents = newcontents;
3043
/* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3044
otherwise just check whether one already exists. Returns -1 on error,
3045
1 if a DT_NEEDED tag already exists, and 0 on success. */
3048
elf_add_dt_needed_tag (bfd *abfd,
3049
struct bfd_link_info *info,
3053
struct elf_link_hash_table *hash_table;
3054
bfd_size_type strindex;
3056
if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3059
hash_table = elf_hash_table (info);
3060
strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3061
if (strindex == (bfd_size_type) -1)
3064
if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
3067
const struct elf_backend_data *bed;
3070
bed = get_elf_backend_data (hash_table->dynobj);
3071
sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3073
for (extdyn = sdyn->contents;
3074
extdyn < sdyn->contents + sdyn->size;
3075
extdyn += bed->s->sizeof_dyn)
3077
Elf_Internal_Dyn dyn;
3079
bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3080
if (dyn.d_tag == DT_NEEDED
3081
&& dyn.d_un.d_val == strindex)
3083
_bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3091
if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3094
if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3098
/* We were just checking for existence of the tag. */
3099
_bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3105
on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3107
for (; needed != NULL; needed = needed->next)
3108
if (strcmp (soname, needed->name) == 0)
3114
/* Sort symbol by value, section, and size. */
3116
elf_sort_symbol (const void *arg1, const void *arg2)
3118
const struct elf_link_hash_entry *h1;
3119
const struct elf_link_hash_entry *h2;
3120
bfd_signed_vma vdiff;
3122
h1 = *(const struct elf_link_hash_entry **) arg1;
3123
h2 = *(const struct elf_link_hash_entry **) arg2;
3124
vdiff = h1->root.u.def.value - h2->root.u.def.value;
3126
return vdiff > 0 ? 1 : -1;
3129
long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3131
return sdiff > 0 ? 1 : -1;
3133
vdiff = h1->size - h2->size;
3134
return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
3137
/* This function is used to adjust offsets into .dynstr for
3138
dynamic symbols. This is called via elf_link_hash_traverse. */
3141
elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3143
struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3145
if (h->dynindx != -1)
3146
h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3150
/* Assign string offsets in .dynstr, update all structures referencing
3154
elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3156
struct elf_link_hash_table *hash_table = elf_hash_table (info);
3157
struct elf_link_local_dynamic_entry *entry;
3158
struct elf_strtab_hash *dynstr = hash_table->dynstr;
3159
bfd *dynobj = hash_table->dynobj;
3162
const struct elf_backend_data *bed;
3165
_bfd_elf_strtab_finalize (dynstr);
3166
size = _bfd_elf_strtab_size (dynstr);
3168
bed = get_elf_backend_data (dynobj);
3169
sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3170
BFD_ASSERT (sdyn != NULL);
3172
/* Update all .dynamic entries referencing .dynstr strings. */
3173
for (extdyn = sdyn->contents;
3174
extdyn < sdyn->contents + sdyn->size;
3175
extdyn += bed->s->sizeof_dyn)
3177
Elf_Internal_Dyn dyn;
3179
bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3183
dyn.d_un.d_val = size;
3193
dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3198
bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3201
/* Now update local dynamic symbols. */
3202
for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3203
entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3204
entry->isym.st_name);
3206
/* And the rest of dynamic symbols. */
3207
elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3209
/* Adjust version definitions. */
3210
if (elf_tdata (output_bfd)->cverdefs)
3215
Elf_Internal_Verdef def;
3216
Elf_Internal_Verdaux defaux;
3218
s = bfd_get_linker_section (dynobj, ".gnu.version_d");
3222
_bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3224
p += sizeof (Elf_External_Verdef);
3225
if (def.vd_aux != sizeof (Elf_External_Verdef))
3227
for (i = 0; i < def.vd_cnt; ++i)
3229
_bfd_elf_swap_verdaux_in (output_bfd,
3230
(Elf_External_Verdaux *) p, &defaux);
3231
defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3233
_bfd_elf_swap_verdaux_out (output_bfd,
3234
&defaux, (Elf_External_Verdaux *) p);
3235
p += sizeof (Elf_External_Verdaux);
3238
while (def.vd_next);
3241
/* Adjust version references. */
3242
if (elf_tdata (output_bfd)->verref)
3247
Elf_Internal_Verneed need;
3248
Elf_Internal_Vernaux needaux;
3250
s = bfd_get_linker_section (dynobj, ".gnu.version_r");
3254
_bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3256
need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3257
_bfd_elf_swap_verneed_out (output_bfd, &need,
3258
(Elf_External_Verneed *) p);
3259
p += sizeof (Elf_External_Verneed);
3260
for (i = 0; i < need.vn_cnt; ++i)
3262
_bfd_elf_swap_vernaux_in (output_bfd,
3263
(Elf_External_Vernaux *) p, &needaux);
3264
needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3266
_bfd_elf_swap_vernaux_out (output_bfd,
3268
(Elf_External_Vernaux *) p);
3269
p += sizeof (Elf_External_Vernaux);
3272
while (need.vn_next);
3278
/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3279
The default is to only match when the INPUT and OUTPUT are exactly
3283
_bfd_elf_default_relocs_compatible (const bfd_target *input,
3284
const bfd_target *output)
3286
return input == output;
3289
/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3290
This version is used when different targets for the same architecture
3291
are virtually identical. */
3294
_bfd_elf_relocs_compatible (const bfd_target *input,
3295
const bfd_target *output)
3297
const struct elf_backend_data *obed, *ibed;
3299
if (input == output)
3302
ibed = xvec_get_elf_backend_data (input);
3303
obed = xvec_get_elf_backend_data (output);
3305
if (ibed->arch != obed->arch)
3308
/* If both backends are using this function, deem them compatible. */
3309
return ibed->relocs_compatible == obed->relocs_compatible;
3312
/* Add symbols from an ELF object file to the linker hash table. */
3315
elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3317
Elf_Internal_Ehdr *ehdr;
3318
Elf_Internal_Shdr *hdr;
3319
bfd_size_type symcount;
3320
bfd_size_type extsymcount;
3321
bfd_size_type extsymoff;
3322
struct elf_link_hash_entry **sym_hash;
3323
bfd_boolean dynamic;
3324
Elf_External_Versym *extversym = NULL;
3325
Elf_External_Versym *ever;
3326
struct elf_link_hash_entry *weaks;
3327
struct elf_link_hash_entry **nondeflt_vers = NULL;
3328
bfd_size_type nondeflt_vers_cnt = 0;
3329
Elf_Internal_Sym *isymbuf = NULL;
3330
Elf_Internal_Sym *isym;
3331
Elf_Internal_Sym *isymend;
3332
const struct elf_backend_data *bed;
3333
bfd_boolean add_needed;
3334
struct elf_link_hash_table *htab;
3336
void *alloc_mark = NULL;
3337
struct bfd_hash_entry **old_table = NULL;
3338
unsigned int old_size = 0;
3339
unsigned int old_count = 0;
3340
void *old_tab = NULL;
3342
struct bfd_link_hash_entry *old_undefs = NULL;
3343
struct bfd_link_hash_entry *old_undefs_tail = NULL;
3344
long old_dynsymcount = 0;
3345
bfd_size_type old_dynstr_size = 0;
3348
htab = elf_hash_table (info);
3349
bed = get_elf_backend_data (abfd);
3351
if ((abfd->flags & DYNAMIC) == 0)
3357
/* You can't use -r against a dynamic object. Also, there's no
3358
hope of using a dynamic object which does not exactly match
3359
the format of the output file. */
3360
if (info->relocatable
3361
|| !is_elf_hash_table (htab)
3362
|| info->output_bfd->xvec != abfd->xvec)
3364
if (info->relocatable)
3365
bfd_set_error (bfd_error_invalid_operation);
3367
bfd_set_error (bfd_error_wrong_format);
3372
ehdr = elf_elfheader (abfd);
3373
if (info->warn_alternate_em
3374
&& bed->elf_machine_code != ehdr->e_machine
3375
&& ((bed->elf_machine_alt1 != 0
3376
&& ehdr->e_machine == bed->elf_machine_alt1)
3377
|| (bed->elf_machine_alt2 != 0
3378
&& ehdr->e_machine == bed->elf_machine_alt2)))
3379
info->callbacks->einfo
3380
(_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3381
ehdr->e_machine, abfd, bed->elf_machine_code);
3383
/* As a GNU extension, any input sections which are named
3384
.gnu.warning.SYMBOL are treated as warning symbols for the given
3385
symbol. This differs from .gnu.warning sections, which generate
3386
warnings when they are included in an output file. */
3387
/* PR 12761: Also generate this warning when building shared libraries. */
3388
if (info->executable || info->shared)
3392
for (s = abfd->sections; s != NULL; s = s->next)
3396
name = bfd_get_section_name (abfd, s);
3397
if (CONST_STRNEQ (name, ".gnu.warning."))
3402
name += sizeof ".gnu.warning." - 1;
3404
/* If this is a shared object, then look up the symbol
3405
in the hash table. If it is there, and it is already
3406
been defined, then we will not be using the entry
3407
from this shared object, so we don't need to warn.
3408
FIXME: If we see the definition in a regular object
3409
later on, we will warn, but we shouldn't. The only
3410
fix is to keep track of what warnings we are supposed
3411
to emit, and then handle them all at the end of the
3415
struct elf_link_hash_entry *h;
3417
h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3419
/* FIXME: What about bfd_link_hash_common? */
3421
&& (h->root.type == bfd_link_hash_defined
3422
|| h->root.type == bfd_link_hash_defweak))
3424
/* We don't want to issue this warning. Clobber
3425
the section size so that the warning does not
3426
get copied into the output file. */
3433
msg = (char *) bfd_alloc (abfd, sz + 1);
3437
if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3442
if (! (_bfd_generic_link_add_one_symbol
3443
(info, abfd, name, BSF_WARNING, s, 0, msg,
3444
FALSE, bed->collect, NULL)))
3447
if (! info->relocatable)
3449
/* Clobber the section size so that the warning does
3450
not get copied into the output file. */
3453
/* Also set SEC_EXCLUDE, so that symbols defined in
3454
the warning section don't get copied to the output. */
3455
s->flags |= SEC_EXCLUDE;
3464
/* If we are creating a shared library, create all the dynamic
3465
sections immediately. We need to attach them to something,
3466
so we attach them to this BFD, provided it is the right
3467
format. FIXME: If there are no input BFD's of the same
3468
format as the output, we can't make a shared library. */
3470
&& is_elf_hash_table (htab)
3471
&& info->output_bfd->xvec == abfd->xvec
3472
&& !htab->dynamic_sections_created)
3474
if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3478
else if (!is_elf_hash_table (htab))
3483
const char *soname = NULL;
3485
struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3488
/* ld --just-symbols and dynamic objects don't mix very well.
3489
ld shouldn't allow it. */
3490
if ((s = abfd->sections) != NULL
3491
&& s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3494
/* If this dynamic lib was specified on the command line with
3495
--as-needed in effect, then we don't want to add a DT_NEEDED
3496
tag unless the lib is actually used. Similary for libs brought
3497
in by another lib's DT_NEEDED. When --no-add-needed is used
3498
on a dynamic lib, we don't want to add a DT_NEEDED entry for
3499
any dynamic library in DT_NEEDED tags in the dynamic lib at
3501
add_needed = (elf_dyn_lib_class (abfd)
3502
& (DYN_AS_NEEDED | DYN_DT_NEEDED
3503
| DYN_NO_NEEDED)) == 0;
3505
s = bfd_get_section_by_name (abfd, ".dynamic");
3510
unsigned int elfsec;
3511
unsigned long shlink;
3513
if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3520
elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3521
if (elfsec == SHN_BAD)
3522
goto error_free_dyn;
3523
shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3525
for (extdyn = dynbuf;
3526
extdyn < dynbuf + s->size;
3527
extdyn += bed->s->sizeof_dyn)
3529
Elf_Internal_Dyn dyn;
3531
bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3532
if (dyn.d_tag == DT_SONAME)
3534
unsigned int tagv = dyn.d_un.d_val;
3535
soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3537
goto error_free_dyn;
3539
if (dyn.d_tag == DT_NEEDED)
3541
struct bfd_link_needed_list *n, **pn;
3543
unsigned int tagv = dyn.d_un.d_val;
3545
amt = sizeof (struct bfd_link_needed_list);
3546
n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3547
fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3548
if (n == NULL || fnm == NULL)
3549
goto error_free_dyn;
3550
amt = strlen (fnm) + 1;
3551
anm = (char *) bfd_alloc (abfd, amt);
3553
goto error_free_dyn;
3554
memcpy (anm, fnm, amt);
3558
for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3562
if (dyn.d_tag == DT_RUNPATH)
3564
struct bfd_link_needed_list *n, **pn;
3566
unsigned int tagv = dyn.d_un.d_val;
3568
amt = sizeof (struct bfd_link_needed_list);
3569
n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3570
fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3571
if (n == NULL || fnm == NULL)
3572
goto error_free_dyn;
3573
amt = strlen (fnm) + 1;
3574
anm = (char *) bfd_alloc (abfd, amt);
3576
goto error_free_dyn;
3577
memcpy (anm, fnm, amt);
3581
for (pn = & runpath;
3587
/* Ignore DT_RPATH if we have seen DT_RUNPATH. */
3588
if (!runpath && dyn.d_tag == DT_RPATH)
3590
struct bfd_link_needed_list *n, **pn;
3592
unsigned int tagv = dyn.d_un.d_val;
3594
amt = sizeof (struct bfd_link_needed_list);
3595
n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3596
fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3597
if (n == NULL || fnm == NULL)
3598
goto error_free_dyn;
3599
amt = strlen (fnm) + 1;
3600
anm = (char *) bfd_alloc (abfd, amt);
3602
goto error_free_dyn;
3603
memcpy (anm, fnm, amt);
3613
if (dyn.d_tag == DT_AUDIT)
3615
unsigned int tagv = dyn.d_un.d_val;
3616
audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3623
/* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
3624
frees all more recently bfd_alloc'd blocks as well. */
3630
struct bfd_link_needed_list **pn;
3631
for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3636
/* We do not want to include any of the sections in a dynamic
3637
object in the output file. We hack by simply clobbering the
3638
list of sections in the BFD. This could be handled more
3639
cleanly by, say, a new section flag; the existing
3640
SEC_NEVER_LOAD flag is not the one we want, because that one
3641
still implies that the section takes up space in the output
3643
bfd_section_list_clear (abfd);
3645
/* Find the name to use in a DT_NEEDED entry that refers to this
3646
object. If the object has a DT_SONAME entry, we use it.
3647
Otherwise, if the generic linker stuck something in
3648
elf_dt_name, we use that. Otherwise, we just use the file
3650
if (soname == NULL || *soname == '\0')
3652
soname = elf_dt_name (abfd);
3653
if (soname == NULL || *soname == '\0')
3654
soname = bfd_get_filename (abfd);
3657
/* Save the SONAME because sometimes the linker emulation code
3658
will need to know it. */
3659
elf_dt_name (abfd) = soname;
3661
ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3665
/* If we have already included this dynamic object in the
3666
link, just ignore it. There is no reason to include a
3667
particular dynamic object more than once. */
3671
/* Save the DT_AUDIT entry for the linker emulation code. */
3672
elf_dt_audit (abfd) = audit;
3675
/* If this is a dynamic object, we always link against the .dynsym
3676
symbol table, not the .symtab symbol table. The dynamic linker
3677
will only see the .dynsym symbol table, so there is no reason to
3678
look at .symtab for a dynamic object. */
3680
if (! dynamic || elf_dynsymtab (abfd) == 0)
3681
hdr = &elf_tdata (abfd)->symtab_hdr;
3683
hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3685
symcount = hdr->sh_size / bed->s->sizeof_sym;
3687
/* The sh_info field of the symtab header tells us where the
3688
external symbols start. We don't care about the local symbols at
3690
if (elf_bad_symtab (abfd))
3692
extsymcount = symcount;
3697
extsymcount = symcount - hdr->sh_info;
3698
extsymoff = hdr->sh_info;
3701
sym_hash = elf_sym_hashes (abfd);
3702
if (extsymcount != 0)
3704
isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3706
if (isymbuf == NULL)
3709
if (sym_hash == NULL)
3711
/* We store a pointer to the hash table entry for each
3713
amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3714
sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
3715
if (sym_hash == NULL)
3716
goto error_free_sym;
3717
elf_sym_hashes (abfd) = sym_hash;
3723
/* Read in any version definitions. */
3724
if (!_bfd_elf_slurp_version_tables (abfd,
3725
info->default_imported_symver))
3726
goto error_free_sym;
3728
/* Read in the symbol versions, but don't bother to convert them
3729
to internal format. */
3730
if (elf_dynversym (abfd) != 0)
3732
Elf_Internal_Shdr *versymhdr;
3734
versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3735
extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3736
if (extversym == NULL)
3737
goto error_free_sym;
3738
amt = versymhdr->sh_size;
3739
if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3740
|| bfd_bread (extversym, amt, abfd) != amt)
3741
goto error_free_vers;
3745
/* If we are loading an as-needed shared lib, save the symbol table
3746
state before we start adding symbols. If the lib turns out
3747
to be unneeded, restore the state. */
3748
if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3753
for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3755
struct bfd_hash_entry *p;
3756
struct elf_link_hash_entry *h;
3758
for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3760
h = (struct elf_link_hash_entry *) p;
3761
entsize += htab->root.table.entsize;
3762
if (h->root.type == bfd_link_hash_warning)
3763
entsize += htab->root.table.entsize;
3767
tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3768
old_tab = bfd_malloc (tabsize + entsize);
3769
if (old_tab == NULL)
3770
goto error_free_vers;
3772
/* Remember the current objalloc pointer, so that all mem for
3773
symbols added can later be reclaimed. */
3774
alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3775
if (alloc_mark == NULL)
3776
goto error_free_vers;
3778
/* Make a special call to the linker "notice" function to
3779
tell it that we are about to handle an as-needed lib. */
3780
if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3781
notice_as_needed, 0, NULL))
3782
goto error_free_vers;
3784
/* Clone the symbol table. Remember some pointers into the
3785
symbol table, and dynamic symbol count. */
3786
old_ent = (char *) old_tab + tabsize;
3787
memcpy (old_tab, htab->root.table.table, tabsize);
3788
old_undefs = htab->root.undefs;
3789
old_undefs_tail = htab->root.undefs_tail;
3790
old_table = htab->root.table.table;
3791
old_size = htab->root.table.size;
3792
old_count = htab->root.table.count;
3793
old_dynsymcount = htab->dynsymcount;
3794
old_dynstr_size = _bfd_elf_strtab_size (htab->dynstr);
3796
for (i = 0; i < htab->root.table.size; i++)
3798
struct bfd_hash_entry *p;
3799
struct elf_link_hash_entry *h;
3801
for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3803
memcpy (old_ent, p, htab->root.table.entsize);
3804
old_ent = (char *) old_ent + htab->root.table.entsize;
3805
h = (struct elf_link_hash_entry *) p;
3806
if (h->root.type == bfd_link_hash_warning)
3808
memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3809
old_ent = (char *) old_ent + htab->root.table.entsize;
3816
ever = extversym != NULL ? extversym + extsymoff : NULL;
3817
for (isym = isymbuf, isymend = isymbuf + extsymcount;
3819
isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3823
asection *sec, *new_sec;
3826
struct elf_link_hash_entry *h;
3827
struct elf_link_hash_entry *hi;
3828
bfd_boolean definition;
3829
bfd_boolean size_change_ok;
3830
bfd_boolean type_change_ok;
3831
bfd_boolean new_weakdef;
3832
bfd_boolean new_weak;
3833
bfd_boolean old_weak;
3834
bfd_boolean override;
3836
unsigned int old_alignment;
3841
flags = BSF_NO_FLAGS;
3843
value = isym->st_value;
3844
common = bed->common_definition (isym);
3846
bind = ELF_ST_BIND (isym->st_info);
3850
/* This should be impossible, since ELF requires that all
3851
global symbols follow all local symbols, and that sh_info
3852
point to the first global symbol. Unfortunately, Irix 5
3857
if (isym->st_shndx != SHN_UNDEF && !common)
3865
case STB_GNU_UNIQUE:
3866
flags = BSF_GNU_UNIQUE;
3870
/* Leave it up to the processor backend. */
3874
if (isym->st_shndx == SHN_UNDEF)
3875
sec = bfd_und_section_ptr;
3876
else if (isym->st_shndx == SHN_ABS)
3877
sec = bfd_abs_section_ptr;
3878
else if (isym->st_shndx == SHN_COMMON)
3880
sec = bfd_com_section_ptr;
3881
/* What ELF calls the size we call the value. What ELF
3882
calls the value we call the alignment. */
3883
value = isym->st_size;
3887
sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3889
sec = bfd_abs_section_ptr;
3890
else if (discarded_section (sec))
3892
/* Symbols from discarded section are undefined. We keep
3894
sec = bfd_und_section_ptr;
3895
isym->st_shndx = SHN_UNDEF;
3897
else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3901
name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3904
goto error_free_vers;
3906
if (isym->st_shndx == SHN_COMMON
3907
&& (abfd->flags & BFD_PLUGIN) != 0)
3909
asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3913
flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3915
xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3917
goto error_free_vers;
3921
else if (isym->st_shndx == SHN_COMMON
3922
&& ELF_ST_TYPE (isym->st_info) == STT_TLS
3923
&& !info->relocatable)
3925
asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3929
flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3930
| SEC_LINKER_CREATED);
3931
tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3933
goto error_free_vers;
3937
else if (bed->elf_add_symbol_hook)
3939
if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3941
goto error_free_vers;
3943
/* The hook function sets the name to NULL if this symbol
3944
should be skipped for some reason. */
3949
/* Sanity check that all possibilities were handled. */
3952
bfd_set_error (bfd_error_bad_value);
3953
goto error_free_vers;
3956
/* Silently discard TLS symbols from --just-syms. There's
3957
no way to combine a static TLS block with a new TLS block
3958
for this executable. */
3959
if (ELF_ST_TYPE (isym->st_info) == STT_TLS
3960
&& sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3963
if (bfd_is_und_section (sec)
3964
|| bfd_is_com_section (sec))
3969
size_change_ok = FALSE;
3970
type_change_ok = bed->type_change_ok;
3976
if (is_elf_hash_table (htab))
3978
Elf_Internal_Versym iver;
3979
unsigned int vernum = 0;
3984
if (info->default_imported_symver)
3985
/* Use the default symbol version created earlier. */
3986
iver.vs_vers = elf_tdata (abfd)->cverdefs;
3991
_bfd_elf_swap_versym_in (abfd, ever, &iver);
3993
vernum = iver.vs_vers & VERSYM_VERSION;
3995
/* If this is a hidden symbol, or if it is not version
3996
1, we append the version name to the symbol name.
3997
However, we do not modify a non-hidden absolute symbol
3998
if it is not a function, because it might be the version
3999
symbol itself. FIXME: What if it isn't? */
4000
if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4002
&& (!bfd_is_abs_section (sec)
4003
|| bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4006
size_t namelen, verlen, newlen;
4009
if (isym->st_shndx != SHN_UNDEF)
4011
if (vernum > elf_tdata (abfd)->cverdefs)
4013
else if (vernum > 1)
4015
elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4021
(*_bfd_error_handler)
4022
(_("%B: %s: invalid version %u (max %d)"),
4024
elf_tdata (abfd)->cverdefs);
4025
bfd_set_error (bfd_error_bad_value);
4026
goto error_free_vers;
4031
/* We cannot simply test for the number of
4032
entries in the VERNEED section since the
4033
numbers for the needed versions do not start
4035
Elf_Internal_Verneed *t;
4038
for (t = elf_tdata (abfd)->verref;
4042
Elf_Internal_Vernaux *a;
4044
for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4046
if (a->vna_other == vernum)
4048
verstr = a->vna_nodename;
4057
(*_bfd_error_handler)
4058
(_("%B: %s: invalid needed version %d"),
4059
abfd, name, vernum);
4060
bfd_set_error (bfd_error_bad_value);
4061
goto error_free_vers;
4065
namelen = strlen (name);
4066
verlen = strlen (verstr);
4067
newlen = namelen + verlen + 2;
4068
if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4069
&& isym->st_shndx != SHN_UNDEF)
4072
newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4073
if (newname == NULL)
4074
goto error_free_vers;
4075
memcpy (newname, name, namelen);
4076
p = newname + namelen;
4078
/* If this is a defined non-hidden version symbol,
4079
we add another @ to the name. This indicates the
4080
default version of the symbol. */
4081
if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4082
&& isym->st_shndx != SHN_UNDEF)
4084
memcpy (p, verstr, verlen + 1);
4089
if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
4090
sym_hash, &old_bfd, &old_weak,
4091
&old_alignment, &skip, &override,
4092
&type_change_ok, &size_change_ok))
4093
goto error_free_vers;
4102
while (h->root.type == bfd_link_hash_indirect
4103
|| h->root.type == bfd_link_hash_warning)
4104
h = (struct elf_link_hash_entry *) h->root.u.i.link;
4106
if (elf_tdata (abfd)->verdef != NULL
4109
h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4112
if (! (_bfd_generic_link_add_one_symbol
4113
(info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4114
(struct bfd_link_hash_entry **) sym_hash)))
4115
goto error_free_vers;
4118
/* We need to make sure that indirect symbol dynamic flags are
4121
while (h->root.type == bfd_link_hash_indirect
4122
|| h->root.type == bfd_link_hash_warning)
4123
h = (struct elf_link_hash_entry *) h->root.u.i.link;
4127
new_weak = (flags & BSF_WEAK) != 0;
4128
new_weakdef = FALSE;
4132
&& !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4133
&& is_elf_hash_table (htab)
4134
&& h->u.weakdef == NULL)
4136
/* Keep a list of all weak defined non function symbols from
4137
a dynamic object, using the weakdef field. Later in this
4138
function we will set the weakdef field to the correct
4139
value. We only put non-function symbols from dynamic
4140
objects on this list, because that happens to be the only
4141
time we need to know the normal symbol corresponding to a
4142
weak symbol, and the information is time consuming to
4143
figure out. If the weakdef field is not already NULL,
4144
then this symbol was already defined by some previous
4145
dynamic object, and we will be using that previous
4146
definition anyhow. */
4148
h->u.weakdef = weaks;
4153
/* Set the alignment of a common symbol. */
4154
if ((common || bfd_is_com_section (sec))
4155
&& h->root.type == bfd_link_hash_common)
4160
align = bfd_log2 (isym->st_value);
4163
/* The new symbol is a common symbol in a shared object.
4164
We need to get the alignment from the section. */
4165
align = new_sec->alignment_power;
4167
if (align > old_alignment)
4168
h->root.u.c.p->alignment_power = align;
4170
h->root.u.c.p->alignment_power = old_alignment;
4173
if (is_elf_hash_table (htab))
4175
/* Set a flag in the hash table entry indicating the type of
4176
reference or definition we just found. A dynamic symbol
4177
is one which is referenced or defined by both a regular
4178
object and a shared object. */
4179
bfd_boolean dynsym = FALSE;
4181
/* Plugin symbols aren't normal. Don't set def_regular or
4182
ref_regular for them, or make them dynamic. */
4183
if ((abfd->flags & BFD_PLUGIN) != 0)
4190
if (bind != STB_WEAK)
4191
h->ref_regular_nonweak = 1;
4203
/* If the indirect symbol has been forced local, don't
4204
make the real symbol dynamic. */
4205
if ((h == hi || !hi->forced_local)
4206
&& (! info->executable
4216
hi->ref_dynamic = 1;
4221
hi->def_dynamic = 1;
4224
/* If the indirect symbol has been forced local, don't
4225
make the real symbol dynamic. */
4226
if ((h == hi || !hi->forced_local)
4229
|| (h->u.weakdef != NULL
4231
&& h->u.weakdef->dynindx != -1)))
4235
/* Check to see if we need to add an indirect symbol for
4236
the default name. */
4238
|| (!override && h->root.type == bfd_link_hash_common))
4239
if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4240
sec, value, &old_bfd, &dynsym))
4241
goto error_free_vers;
4243
/* Check the alignment when a common symbol is involved. This
4244
can change when a common symbol is overridden by a normal
4245
definition or a common symbol is ignored due to the old
4246
normal definition. We need to make sure the maximum
4247
alignment is maintained. */
4248
if ((old_alignment || common)
4249
&& h->root.type != bfd_link_hash_common)
4251
unsigned int common_align;
4252
unsigned int normal_align;
4253
unsigned int symbol_align;
4257
BFD_ASSERT (h->root.type == bfd_link_hash_defined
4258
|| h->root.type == bfd_link_hash_defweak);
4260
symbol_align = ffs (h->root.u.def.value) - 1;
4261
if (h->root.u.def.section->owner != NULL
4262
&& (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4264
normal_align = h->root.u.def.section->alignment_power;
4265
if (normal_align > symbol_align)
4266
normal_align = symbol_align;
4269
normal_align = symbol_align;
4273
common_align = old_alignment;
4274
common_bfd = old_bfd;
4279
common_align = bfd_log2 (isym->st_value);
4281
normal_bfd = old_bfd;
4284
if (normal_align < common_align)
4286
/* PR binutils/2735 */
4287
if (normal_bfd == NULL)
4288
(*_bfd_error_handler)
4289
(_("Warning: alignment %u of common symbol `%s' in %B is"
4290
" greater than the alignment (%u) of its section %A"),
4291
common_bfd, h->root.u.def.section,
4292
1 << common_align, name, 1 << normal_align);
4294
(*_bfd_error_handler)
4295
(_("Warning: alignment %u of symbol `%s' in %B"
4296
" is smaller than %u in %B"),
4297
normal_bfd, common_bfd,
4298
1 << normal_align, name, 1 << common_align);
4302
/* Remember the symbol size if it isn't undefined. */
4303
if (isym->st_size != 0
4304
&& isym->st_shndx != SHN_UNDEF
4305
&& (definition || h->size == 0))
4308
&& h->size != isym->st_size
4309
&& ! size_change_ok)
4310
(*_bfd_error_handler)
4311
(_("Warning: size of symbol `%s' changed"
4312
" from %lu in %B to %lu in %B"),
4314
name, (unsigned long) h->size,
4315
(unsigned long) isym->st_size);
4317
h->size = isym->st_size;
4320
/* If this is a common symbol, then we always want H->SIZE
4321
to be the size of the common symbol. The code just above
4322
won't fix the size if a common symbol becomes larger. We
4323
don't warn about a size change here, because that is
4324
covered by --warn-common. Allow changes between different
4326
if (h->root.type == bfd_link_hash_common)
4327
h->size = h->root.u.c.size;
4329
if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4330
&& ((definition && !new_weak)
4331
|| (old_weak && h->root.type == bfd_link_hash_common)
4332
|| h->type == STT_NOTYPE))
4334
unsigned int type = ELF_ST_TYPE (isym->st_info);
4336
/* Turn an IFUNC symbol from a DSO into a normal FUNC
4338
if (type == STT_GNU_IFUNC
4339
&& (abfd->flags & DYNAMIC) != 0)
4342
if (h->type != type)
4344
if (h->type != STT_NOTYPE && ! type_change_ok)
4345
(*_bfd_error_handler)
4346
(_("Warning: type of symbol `%s' changed"
4347
" from %d to %d in %B"),
4348
abfd, name, h->type, type);
4354
/* Merge st_other field. */
4355
elf_merge_st_other (abfd, h, isym, definition, dynamic);
4357
/* We don't want to make debug symbol dynamic. */
4358
if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4361
/* Nor should we make plugin symbols dynamic. */
4362
if ((abfd->flags & BFD_PLUGIN) != 0)
4367
h->target_internal = isym->st_target_internal;
4368
h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4371
if (definition && !dynamic)
4373
char *p = strchr (name, ELF_VER_CHR);
4374
if (p != NULL && p[1] != ELF_VER_CHR)
4376
/* Queue non-default versions so that .symver x, x@FOO
4377
aliases can be checked. */
4380
amt = ((isymend - isym + 1)
4381
* sizeof (struct elf_link_hash_entry *));
4383
(struct elf_link_hash_entry **) bfd_malloc (amt);
4385
goto error_free_vers;
4387
nondeflt_vers[nondeflt_vers_cnt++] = h;
4391
if (dynsym && h->dynindx == -1)
4393
if (! bfd_elf_link_record_dynamic_symbol (info, h))
4394
goto error_free_vers;
4395
if (h->u.weakdef != NULL
4397
&& h->u.weakdef->dynindx == -1)
4399
if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4400
goto error_free_vers;
4403
else if (dynsym && h->dynindx != -1)
4404
/* If the symbol already has a dynamic index, but
4405
visibility says it should not be visible, turn it into
4407
switch (ELF_ST_VISIBILITY (h->other))
4411
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
4416
/* Don't add DT_NEEDED for references from the dummy bfd. */
4420
&& h->ref_regular_nonweak
4422
|| (old_bfd->flags & BFD_PLUGIN) == 0))
4423
|| (h->ref_dynamic_nonweak
4424
&& (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4425
&& !on_needed_list (elf_dt_name (abfd), htab->needed))))
4428
const char *soname = elf_dt_name (abfd);
4430
/* A symbol from a library loaded via DT_NEEDED of some
4431
other library is referenced by a regular object.
4432
Add a DT_NEEDED entry for it. Issue an error if
4433
--no-add-needed is used and the reference was not
4436
&& (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4438
(*_bfd_error_handler)
4439
(_("%B: undefined reference to symbol '%s'"),
4441
bfd_set_error (bfd_error_missing_dso);
4442
goto error_free_vers;
4445
elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4446
(elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4449
ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4451
goto error_free_vers;
4453
BFD_ASSERT (ret == 0);
4458
if (extversym != NULL)
4464
if (isymbuf != NULL)
4470
if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4474
/* Restore the symbol table. */
4475
if (bed->as_needed_cleanup)
4476
(*bed->as_needed_cleanup) (abfd, info);
4477
old_ent = (char *) old_tab + tabsize;
4478
memset (elf_sym_hashes (abfd), 0,
4479
extsymcount * sizeof (struct elf_link_hash_entry *));
4480
htab->root.table.table = old_table;
4481
htab->root.table.size = old_size;
4482
htab->root.table.count = old_count;
4483
memcpy (htab->root.table.table, old_tab, tabsize);
4484
htab->root.undefs = old_undefs;
4485
htab->root.undefs_tail = old_undefs_tail;
4486
_bfd_elf_strtab_restore_size (htab->dynstr, old_dynstr_size);
4487
for (i = 0; i < htab->root.table.size; i++)
4489
struct bfd_hash_entry *p;
4490
struct elf_link_hash_entry *h;
4492
unsigned int alignment_power;
4494
for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4496
h = (struct elf_link_hash_entry *) p;
4497
if (h->root.type == bfd_link_hash_warning)
4498
h = (struct elf_link_hash_entry *) h->root.u.i.link;
4499
if (h->dynindx >= old_dynsymcount
4500
&& h->dynstr_index < old_dynstr_size)
4501
_bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4503
/* Preserve the maximum alignment and size for common
4504
symbols even if this dynamic lib isn't on DT_NEEDED
4505
since it can still be loaded at run time by another
4507
if (h->root.type == bfd_link_hash_common)
4509
size = h->root.u.c.size;
4510
alignment_power = h->root.u.c.p->alignment_power;
4515
alignment_power = 0;
4517
memcpy (p, old_ent, htab->root.table.entsize);
4518
old_ent = (char *) old_ent + htab->root.table.entsize;
4519
h = (struct elf_link_hash_entry *) p;
4520
if (h->root.type == bfd_link_hash_warning)
4522
memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4523
old_ent = (char *) old_ent + htab->root.table.entsize;
4524
h = (struct elf_link_hash_entry *) h->root.u.i.link;
4526
if (h->root.type == bfd_link_hash_common)
4528
if (size > h->root.u.c.size)
4529
h->root.u.c.size = size;
4530
if (alignment_power > h->root.u.c.p->alignment_power)
4531
h->root.u.c.p->alignment_power = alignment_power;
4536
/* Make a special call to the linker "notice" function to
4537
tell it that symbols added for crefs may need to be removed. */
4538
if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4539
notice_not_needed, 0, NULL))
4540
goto error_free_vers;
4543
objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4545
if (nondeflt_vers != NULL)
4546
free (nondeflt_vers);
4550
if (old_tab != NULL)
4552
if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4553
notice_needed, 0, NULL))
4554
goto error_free_vers;
4559
/* Now that all the symbols from this input file are created, handle
4560
.symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
4561
if (nondeflt_vers != NULL)
4563
bfd_size_type cnt, symidx;
4565
for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4567
struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4568
char *shortname, *p;
4570
p = strchr (h->root.root.string, ELF_VER_CHR);
4572
|| (h->root.type != bfd_link_hash_defined
4573
&& h->root.type != bfd_link_hash_defweak))
4576
amt = p - h->root.root.string;
4577
shortname = (char *) bfd_malloc (amt + 1);
4579
goto error_free_vers;
4580
memcpy (shortname, h->root.root.string, amt);
4581
shortname[amt] = '\0';
4583
hi = (struct elf_link_hash_entry *)
4584
bfd_link_hash_lookup (&htab->root, shortname,
4585
FALSE, FALSE, FALSE);
4587
&& hi->root.type == h->root.type
4588
&& hi->root.u.def.value == h->root.u.def.value
4589
&& hi->root.u.def.section == h->root.u.def.section)
4591
(*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4592
hi->root.type = bfd_link_hash_indirect;
4593
hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4594
(*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4595
sym_hash = elf_sym_hashes (abfd);
4597
for (symidx = 0; symidx < extsymcount; ++symidx)
4598
if (sym_hash[symidx] == hi)
4600
sym_hash[symidx] = h;
4606
free (nondeflt_vers);
4607
nondeflt_vers = NULL;
4610
/* Now set the weakdefs field correctly for all the weak defined
4611
symbols we found. The only way to do this is to search all the
4612
symbols. Since we only need the information for non functions in
4613
dynamic objects, that's the only time we actually put anything on
4614
the list WEAKS. We need this information so that if a regular
4615
object refers to a symbol defined weakly in a dynamic object, the
4616
real symbol in the dynamic object is also put in the dynamic
4617
symbols; we also must arrange for both symbols to point to the
4618
same memory location. We could handle the general case of symbol
4619
aliasing, but a general symbol alias can only be generated in
4620
assembler code, handling it correctly would be very time
4621
consuming, and other ELF linkers don't handle general aliasing
4625
struct elf_link_hash_entry **hpp;
4626
struct elf_link_hash_entry **hppend;
4627
struct elf_link_hash_entry **sorted_sym_hash;
4628
struct elf_link_hash_entry *h;
4631
/* Since we have to search the whole symbol list for each weak
4632
defined symbol, search time for N weak defined symbols will be
4633
O(N^2). Binary search will cut it down to O(NlogN). */
4634
amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4635
sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4636
if (sorted_sym_hash == NULL)
4638
sym_hash = sorted_sym_hash;
4639
hpp = elf_sym_hashes (abfd);
4640
hppend = hpp + extsymcount;
4642
for (; hpp < hppend; hpp++)
4646
&& h->root.type == bfd_link_hash_defined
4647
&& !bed->is_function_type (h->type))
4655
qsort (sorted_sym_hash, sym_count,
4656
sizeof (struct elf_link_hash_entry *),
4659
while (weaks != NULL)
4661
struct elf_link_hash_entry *hlook;
4664
size_t i, j, idx = 0;
4667
weaks = hlook->u.weakdef;
4668
hlook->u.weakdef = NULL;
4670
BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4671
|| hlook->root.type == bfd_link_hash_defweak
4672
|| hlook->root.type == bfd_link_hash_common
4673
|| hlook->root.type == bfd_link_hash_indirect);
4674
slook = hlook->root.u.def.section;
4675
vlook = hlook->root.u.def.value;
4681
bfd_signed_vma vdiff;
4683
h = sorted_sym_hash[idx];
4684
vdiff = vlook - h->root.u.def.value;
4691
long sdiff = slook->id - h->root.u.def.section->id;
4701
/* We didn't find a value/section match. */
4705
/* With multiple aliases, or when the weak symbol is already
4706
strongly defined, we have multiple matching symbols and
4707
the binary search above may land on any of them. Step
4708
one past the matching symbol(s). */
4711
h = sorted_sym_hash[idx];
4712
if (h->root.u.def.section != slook
4713
|| h->root.u.def.value != vlook)
4717
/* Now look back over the aliases. Since we sorted by size
4718
as well as value and section, we'll choose the one with
4719
the largest size. */
4722
h = sorted_sym_hash[idx];
4724
/* Stop if value or section doesn't match. */
4725
if (h->root.u.def.section != slook
4726
|| h->root.u.def.value != vlook)
4728
else if (h != hlook)
4730
hlook->u.weakdef = h;
4732
/* If the weak definition is in the list of dynamic
4733
symbols, make sure the real definition is put
4735
if (hlook->dynindx != -1 && h->dynindx == -1)
4737
if (! bfd_elf_link_record_dynamic_symbol (info, h))
4740
free (sorted_sym_hash);
4745
/* If the real definition is in the list of dynamic
4746
symbols, make sure the weak definition is put
4747
there as well. If we don't do this, then the
4748
dynamic loader might not merge the entries for the
4749
real definition and the weak definition. */
4750
if (h->dynindx != -1 && hlook->dynindx == -1)
4752
if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4753
goto err_free_sym_hash;
4760
free (sorted_sym_hash);
4763
if (bed->check_directives
4764
&& !(*bed->check_directives) (abfd, info))
4767
/* If this object is the same format as the output object, and it is
4768
not a shared library, then let the backend look through the
4771
This is required to build global offset table entries and to
4772
arrange for dynamic relocs. It is not required for the
4773
particular common case of linking non PIC code, even when linking
4774
against shared libraries, but unfortunately there is no way of
4775
knowing whether an object file has been compiled PIC or not.
4776
Looking through the relocs is not particularly time consuming.
4777
The problem is that we must either (1) keep the relocs in memory,
4778
which causes the linker to require additional runtime memory or
4779
(2) read the relocs twice from the input file, which wastes time.
4780
This would be a good case for using mmap.
4782
I have no idea how to handle linking PIC code into a file of a
4783
different format. It probably can't be done. */
4785
&& is_elf_hash_table (htab)
4786
&& bed->check_relocs != NULL
4787
&& elf_object_id (abfd) == elf_hash_table_id (htab)
4788
&& (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4792
for (o = abfd->sections; o != NULL; o = o->next)
4794
Elf_Internal_Rela *internal_relocs;
4797
if ((o->flags & SEC_RELOC) == 0
4798
|| o->reloc_count == 0
4799
|| ((info->strip == strip_all || info->strip == strip_debugger)
4800
&& (o->flags & SEC_DEBUGGING) != 0)
4801
|| bfd_is_abs_section (o->output_section))
4804
internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4806
if (internal_relocs == NULL)
4809
ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4811
if (elf_section_data (o)->relocs != internal_relocs)
4812
free (internal_relocs);
4819
/* If this is a non-traditional link, try to optimize the handling
4820
of the .stab/.stabstr sections. */
4822
&& ! info->traditional_format
4823
&& is_elf_hash_table (htab)
4824
&& (info->strip != strip_all && info->strip != strip_debugger))
4828
stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4829
if (stabstr != NULL)
4831
bfd_size_type string_offset = 0;
4834
for (stab = abfd->sections; stab; stab = stab->next)
4835
if (CONST_STRNEQ (stab->name, ".stab")
4836
&& (!stab->name[5] ||
4837
(stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4838
&& (stab->flags & SEC_MERGE) == 0
4839
&& !bfd_is_abs_section (stab->output_section))
4841
struct bfd_elf_section_data *secdata;
4843
secdata = elf_section_data (stab);
4844
if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4845
stabstr, &secdata->sec_info,
4848
if (secdata->sec_info)
4849
stab->sec_info_type = SEC_INFO_TYPE_STABS;
4854
if (is_elf_hash_table (htab) && add_needed)
4856
/* Add this bfd to the loaded list. */
4857
struct elf_link_loaded_list *n;
4859
n = (struct elf_link_loaded_list *)
4860
bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
4864
n->next = htab->loaded;
4871
if (old_tab != NULL)
4873
if (nondeflt_vers != NULL)
4874
free (nondeflt_vers);
4875
if (extversym != NULL)
4878
if (isymbuf != NULL)
4884
/* Return the linker hash table entry of a symbol that might be
4885
satisfied by an archive symbol. Return -1 on error. */
4887
struct elf_link_hash_entry *
4888
_bfd_elf_archive_symbol_lookup (bfd *abfd,
4889
struct bfd_link_info *info,
4892
struct elf_link_hash_entry *h;
4896
h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
4900
/* If this is a default version (the name contains @@), look up the
4901
symbol again with only one `@' as well as without the version.
4902
The effect is that references to the symbol with and without the
4903
version will be matched by the default symbol in the archive. */
4905
p = strchr (name, ELF_VER_CHR);
4906
if (p == NULL || p[1] != ELF_VER_CHR)
4909
/* First check with only one `@'. */
4910
len = strlen (name);
4911
copy = (char *) bfd_alloc (abfd, len);
4913
return (struct elf_link_hash_entry *) 0 - 1;
4915
first = p - name + 1;
4916
memcpy (copy, name, first);
4917
memcpy (copy + first, name + first + 1, len - first);
4919
h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
4922
/* We also need to check references to the symbol without the
4924
copy[first - 1] = '\0';
4925
h = elf_link_hash_lookup (elf_hash_table (info), copy,
4926
FALSE, FALSE, TRUE);
4929
bfd_release (abfd, copy);
4933
/* Add symbols from an ELF archive file to the linker hash table. We
4934
don't use _bfd_generic_link_add_archive_symbols because of a
4935
problem which arises on UnixWare. The UnixWare libc.so is an
4936
archive which includes an entry libc.so.1 which defines a bunch of
4937
symbols. The libc.so archive also includes a number of other
4938
object files, which also define symbols, some of which are the same
4939
as those defined in libc.so.1. Correct linking requires that we
4940
consider each object file in turn, and include it if it defines any
4941
symbols we need. _bfd_generic_link_add_archive_symbols does not do
4942
this; it looks through the list of undefined symbols, and includes
4943
any object file which defines them. When this algorithm is used on
4944
UnixWare, it winds up pulling in libc.so.1 early and defining a
4945
bunch of symbols. This means that some of the other objects in the
4946
archive are not included in the link, which is incorrect since they
4947
precede libc.so.1 in the archive.
4949
Fortunately, ELF archive handling is simpler than that done by
4950
_bfd_generic_link_add_archive_symbols, which has to allow for a.out
4951
oddities. In ELF, if we find a symbol in the archive map, and the
4952
symbol is currently undefined, we know that we must pull in that
4955
Unfortunately, we do have to make multiple passes over the symbol
4956
table until nothing further is resolved. */
4959
elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4962
bfd_boolean *defined = NULL;
4963
bfd_boolean *included = NULL;
4967
const struct elf_backend_data *bed;
4968
struct elf_link_hash_entry * (*archive_symbol_lookup)
4969
(bfd *, struct bfd_link_info *, const char *);
4971
if (! bfd_has_map (abfd))
4973
/* An empty archive is a special case. */
4974
if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4976
bfd_set_error (bfd_error_no_armap);
4980
/* Keep track of all symbols we know to be already defined, and all
4981
files we know to be already included. This is to speed up the
4982
second and subsequent passes. */
4983
c = bfd_ardata (abfd)->symdef_count;
4987
amt *= sizeof (bfd_boolean);
4988
defined = (bfd_boolean *) bfd_zmalloc (amt);
4989
included = (bfd_boolean *) bfd_zmalloc (amt);
4990
if (defined == NULL || included == NULL)
4993
symdefs = bfd_ardata (abfd)->symdefs;
4994
bed = get_elf_backend_data (abfd);
4995
archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
5008
symdefend = symdef + c;
5009
for (i = 0; symdef < symdefend; symdef++, i++)
5011
struct elf_link_hash_entry *h;
5013
struct bfd_link_hash_entry *undefs_tail;
5016
if (defined[i] || included[i])
5018
if (symdef->file_offset == last)
5024
h = archive_symbol_lookup (abfd, info, symdef->name);
5025
if (h == (struct elf_link_hash_entry *) 0 - 1)
5031
if (h->root.type == bfd_link_hash_common)
5033
/* We currently have a common symbol. The archive map contains
5034
a reference to this symbol, so we may want to include it. We
5035
only want to include it however, if this archive element
5036
contains a definition of the symbol, not just another common
5039
Unfortunately some archivers (including GNU ar) will put
5040
declarations of common symbols into their archive maps, as
5041
well as real definitions, so we cannot just go by the archive
5042
map alone. Instead we must read in the element's symbol
5043
table and check that to see what kind of symbol definition
5045
if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5048
else if (h->root.type != bfd_link_hash_undefined)
5050
if (h->root.type != bfd_link_hash_undefweak)
5055
/* We need to include this archive member. */
5056
element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5057
if (element == NULL)
5060
if (! bfd_check_format (element, bfd_object))
5063
/* Doublecheck that we have not included this object
5064
already--it should be impossible, but there may be
5065
something wrong with the archive. */
5066
if (element->archive_pass != 0)
5068
bfd_set_error (bfd_error_bad_value);
5071
element->archive_pass = 1;
5073
undefs_tail = info->hash->undefs_tail;
5075
if (!(*info->callbacks
5076
->add_archive_element) (info, element, symdef->name, &element))
5078
if (!bfd_link_add_symbols (element, info))
5081
/* If there are any new undefined symbols, we need to make
5082
another pass through the archive in order to see whether
5083
they can be defined. FIXME: This isn't perfect, because
5084
common symbols wind up on undefs_tail and because an
5085
undefined symbol which is defined later on in this pass
5086
does not require another pass. This isn't a bug, but it
5087
does make the code less efficient than it could be. */
5088
if (undefs_tail != info->hash->undefs_tail)
5091
/* Look backward to mark all symbols from this object file
5092
which we have already seen in this pass. */
5096
included[mark] = TRUE;
5101
while (symdefs[mark].file_offset == symdef->file_offset);
5103
/* We mark subsequent symbols from this object file as we go
5104
on through the loop. */
5105
last = symdef->file_offset;
5116
if (defined != NULL)
5118
if (included != NULL)
5123
/* Given an ELF BFD, add symbols to the global hash table as
5127
bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5129
switch (bfd_get_format (abfd))
5132
return elf_link_add_object_symbols (abfd, info);
5134
return elf_link_add_archive_symbols (abfd, info);
5136
bfd_set_error (bfd_error_wrong_format);
5141
struct hash_codes_info
5143
unsigned long *hashcodes;
5147
/* This function will be called though elf_link_hash_traverse to store
5148
all hash value of the exported symbols in an array. */
5151
elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5153
struct hash_codes_info *inf = (struct hash_codes_info *) data;
5159
/* Ignore indirect symbols. These are added by the versioning code. */
5160
if (h->dynindx == -1)
5163
name = h->root.root.string;
5164
p = strchr (name, ELF_VER_CHR);
5167
alc = (char *) bfd_malloc (p - name + 1);
5173
memcpy (alc, name, p - name);
5174
alc[p - name] = '\0';
5178
/* Compute the hash value. */
5179
ha = bfd_elf_hash (name);
5181
/* Store the found hash value in the array given as the argument. */
5182
*(inf->hashcodes)++ = ha;
5184
/* And store it in the struct so that we can put it in the hash table
5186
h->u.elf_hash_value = ha;
5194
struct collect_gnu_hash_codes
5197
const struct elf_backend_data *bed;
5198
unsigned long int nsyms;
5199
unsigned long int maskbits;
5200
unsigned long int *hashcodes;
5201
unsigned long int *hashval;
5202
unsigned long int *indx;
5203
unsigned long int *counts;
5206
long int min_dynindx;
5207
unsigned long int bucketcount;
5208
unsigned long int symindx;
5209
long int local_indx;
5210
long int shift1, shift2;
5211
unsigned long int mask;
5215
/* This function will be called though elf_link_hash_traverse to store
5216
all hash value of the exported symbols in an array. */
5219
elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5221
struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5227
/* Ignore indirect symbols. These are added by the versioning code. */
5228
if (h->dynindx == -1)
5231
/* Ignore also local symbols and undefined symbols. */
5232
if (! (*s->bed->elf_hash_symbol) (h))
5235
name = h->root.root.string;
5236
p = strchr (name, ELF_VER_CHR);
5239
alc = (char *) bfd_malloc (p - name + 1);
5245
memcpy (alc, name, p - name);
5246
alc[p - name] = '\0';
5250
/* Compute the hash value. */
5251
ha = bfd_elf_gnu_hash (name);
5253
/* Store the found hash value in the array for compute_bucket_count,
5254
and also for .dynsym reordering purposes. */
5255
s->hashcodes[s->nsyms] = ha;
5256
s->hashval[h->dynindx] = ha;
5258
if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5259
s->min_dynindx = h->dynindx;
5267
/* This function will be called though elf_link_hash_traverse to do
5268
final dynaminc symbol renumbering. */
5271
elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5273
struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5274
unsigned long int bucket;
5275
unsigned long int val;
5277
/* Ignore indirect symbols. */
5278
if (h->dynindx == -1)
5281
/* Ignore also local symbols and undefined symbols. */
5282
if (! (*s->bed->elf_hash_symbol) (h))
5284
if (h->dynindx >= s->min_dynindx)
5285
h->dynindx = s->local_indx++;
5289
bucket = s->hashval[h->dynindx] % s->bucketcount;
5290
val = (s->hashval[h->dynindx] >> s->shift1)
5291
& ((s->maskbits >> s->shift1) - 1);
5292
s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5294
|= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5295
val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5296
if (s->counts[bucket] == 1)
5297
/* Last element terminates the chain. */
5299
bfd_put_32 (s->output_bfd, val,
5300
s->contents + (s->indx[bucket] - s->symindx) * 4);
5301
--s->counts[bucket];
5302
h->dynindx = s->indx[bucket]++;
5306
/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5309
_bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5311
return !(h->forced_local
5312
|| h->root.type == bfd_link_hash_undefined
5313
|| h->root.type == bfd_link_hash_undefweak
5314
|| ((h->root.type == bfd_link_hash_defined
5315
|| h->root.type == bfd_link_hash_defweak)
5316
&& h->root.u.def.section->output_section == NULL));
5319
/* Array used to determine the number of hash table buckets to use
5320
based on the number of symbols there are. If there are fewer than
5321
3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5322
fewer than 37 we use 17 buckets, and so forth. We never use more
5323
than 32771 buckets. */
5325
static const size_t elf_buckets[] =
5327
1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5331
/* Compute bucket count for hashing table. We do not use a static set
5332
of possible tables sizes anymore. Instead we determine for all
5333
possible reasonable sizes of the table the outcome (i.e., the
5334
number of collisions etc) and choose the best solution. The
5335
weighting functions are not too simple to allow the table to grow
5336
without bounds. Instead one of the weighting factors is the size.
5337
Therefore the result is always a good payoff between few collisions
5338
(= short chain lengths) and table size. */
5340
compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5341
unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5342
unsigned long int nsyms,
5345
size_t best_size = 0;
5346
unsigned long int i;
5348
/* We have a problem here. The following code to optimize the table
5349
size requires an integer type with more the 32 bits. If
5350
BFD_HOST_U_64_BIT is set we know about such a type. */
5351
#ifdef BFD_HOST_U_64_BIT
5356
BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5357
bfd *dynobj = elf_hash_table (info)->dynobj;
5358
size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5359
const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5360
unsigned long int *counts;
5362
unsigned int no_improvement_count = 0;
5364
/* Possible optimization parameters: if we have NSYMS symbols we say
5365
that the hashing table must at least have NSYMS/4 and at most
5367
minsize = nsyms / 4;
5370
best_size = maxsize = nsyms * 2;
5375
if ((best_size & 31) == 0)
5379
/* Create array where we count the collisions in. We must use bfd_malloc
5380
since the size could be large. */
5382
amt *= sizeof (unsigned long int);
5383
counts = (unsigned long int *) bfd_malloc (amt);
5387
/* Compute the "optimal" size for the hash table. The criteria is a
5388
minimal chain length. The minor criteria is (of course) the size
5390
for (i = minsize; i < maxsize; ++i)
5392
/* Walk through the array of hashcodes and count the collisions. */
5393
BFD_HOST_U_64_BIT max;
5394
unsigned long int j;
5395
unsigned long int fact;
5397
if (gnu_hash && (i & 31) == 0)
5400
memset (counts, '\0', i * sizeof (unsigned long int));
5402
/* Determine how often each hash bucket is used. */
5403
for (j = 0; j < nsyms; ++j)
5404
++counts[hashcodes[j] % i];
5406
/* For the weight function we need some information about the
5407
pagesize on the target. This is information need not be 100%
5408
accurate. Since this information is not available (so far) we
5409
define it here to a reasonable default value. If it is crucial
5410
to have a better value some day simply define this value. */
5411
# ifndef BFD_TARGET_PAGESIZE
5412
# define BFD_TARGET_PAGESIZE (4096)
5415
/* We in any case need 2 + DYNSYMCOUNT entries for the size values
5417
max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5420
/* Variant 1: optimize for short chains. We add the squares
5421
of all the chain lengths (which favors many small chain
5422
over a few long chains). */
5423
for (j = 0; j < i; ++j)
5424
max += counts[j] * counts[j];
5426
/* This adds penalties for the overall size of the table. */
5427
fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5430
/* Variant 2: Optimize a lot more for small table. Here we
5431
also add squares of the size but we also add penalties for
5432
empty slots (the +1 term). */
5433
for (j = 0; j < i; ++j)
5434
max += (1 + counts[j]) * (1 + counts[j]);
5436
/* The overall size of the table is considered, but not as
5437
strong as in variant 1, where it is squared. */
5438
fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5442
/* Compare with current best results. */
5443
if (max < best_chlen)
5447
no_improvement_count = 0;
5449
/* PR 11843: Avoid futile long searches for the best bucket size
5450
when there are a large number of symbols. */
5451
else if (++no_improvement_count == 100)
5458
#endif /* defined (BFD_HOST_U_64_BIT) */
5460
/* This is the fallback solution if no 64bit type is available or if we
5461
are not supposed to spend much time on optimizations. We select the
5462
bucket count using a fixed set of numbers. */
5463
for (i = 0; elf_buckets[i] != 0; i++)
5465
best_size = elf_buckets[i];
5466
if (nsyms < elf_buckets[i + 1])
5469
if (gnu_hash && best_size < 2)
5476
/* Size any SHT_GROUP section for ld -r. */
5479
_bfd_elf_size_group_sections (struct bfd_link_info *info)
5483
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5484
if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5485
&& !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5490
/* Set a default stack segment size. The value in INFO wins. If it
5491
is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5492
undefined it is initialized. */
5495
bfd_elf_stack_segment_size (bfd *output_bfd,
5496
struct bfd_link_info *info,
5497
const char *legacy_symbol,
5498
bfd_vma default_size)
5500
struct elf_link_hash_entry *h = NULL;
5502
/* Look for legacy symbol. */
5504
h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
5505
FALSE, FALSE, FALSE);
5506
if (h && (h->root.type == bfd_link_hash_defined
5507
|| h->root.type == bfd_link_hash_defweak)
5509
&& (h->type == STT_NOTYPE || h->type == STT_OBJECT))
5511
/* The symbol has no type if specified on the command line. */
5512
h->type = STT_OBJECT;
5513
if (info->stacksize)
5514
(*_bfd_error_handler) (_("%B: stack size specified and %s set"),
5515
output_bfd, legacy_symbol);
5516
else if (h->root.u.def.section != bfd_abs_section_ptr)
5517
(*_bfd_error_handler) (_("%B: %s not absolute"),
5518
output_bfd, legacy_symbol);
5520
info->stacksize = h->root.u.def.value;
5523
if (!info->stacksize)
5524
/* If the user didn't set a size, or explicitly inhibit the
5525
size, set it now. */
5526
info->stacksize = default_size;
5528
/* Provide the legacy symbol, if it is referenced. */
5529
if (h && (h->root.type == bfd_link_hash_undefined
5530
|| h->root.type == bfd_link_hash_undefweak))
5532
struct bfd_link_hash_entry *bh = NULL;
5534
if (!(_bfd_generic_link_add_one_symbol
5535
(info, output_bfd, legacy_symbol,
5536
BSF_GLOBAL, bfd_abs_section_ptr,
5537
info->stacksize >= 0 ? info->stacksize : 0,
5538
NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
5541
h = (struct elf_link_hash_entry *) bh;
5543
h->type = STT_OBJECT;
5549
/* Set up the sizes and contents of the ELF dynamic sections. This is
5550
called by the ELF linker emulation before_allocation routine. We
5551
must set the sizes of the sections before the linker sets the
5552
addresses of the various sections. */
5555
bfd_elf_size_dynamic_sections (bfd *output_bfd,
5558
const char *filter_shlib,
5560
const char *depaudit,
5561
const char * const *auxiliary_filters,
5562
struct bfd_link_info *info,
5563
asection **sinterpptr)
5565
bfd_size_type soname_indx;
5567
const struct elf_backend_data *bed;
5568
struct elf_info_failed asvinfo;
5572
soname_indx = (bfd_size_type) -1;
5574
if (!is_elf_hash_table (info->hash))
5577
bed = get_elf_backend_data (output_bfd);
5579
/* Any syms created from now on start with -1 in
5580
got.refcount/offset and plt.refcount/offset. */
5581
elf_hash_table (info)->init_got_refcount
5582
= elf_hash_table (info)->init_got_offset;
5583
elf_hash_table (info)->init_plt_refcount
5584
= elf_hash_table (info)->init_plt_offset;
5586
if (info->relocatable
5587
&& !_bfd_elf_size_group_sections (info))
5590
/* The backend may have to create some sections regardless of whether
5591
we're dynamic or not. */
5592
if (bed->elf_backend_always_size_sections
5593
&& ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5596
/* Determine any GNU_STACK segment requirements, after the backend
5597
has had a chance to set a default segment size. */
5598
if (info->execstack)
5599
elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
5600
else if (info->noexecstack)
5601
elf_stack_flags (output_bfd) = PF_R | PF_W;
5605
asection *notesec = NULL;
5608
for (inputobj = info->input_bfds;
5610
inputobj = inputobj->link_next)
5615
& (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5617
s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5620
if (s->flags & SEC_CODE)
5624
else if (bed->default_execstack)
5627
if (notesec || info->stacksize > 0)
5628
elf_stack_flags (output_bfd) = PF_R | PF_W | exec;
5629
if (notesec && exec && info->relocatable
5630
&& notesec->output_section != bfd_abs_section_ptr)
5631
notesec->output_section->flags |= SEC_CODE;
5634
dynobj = elf_hash_table (info)->dynobj;
5636
if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5638
struct elf_info_failed eif;
5639
struct elf_link_hash_entry *h;
5641
struct bfd_elf_version_tree *t;
5642
struct bfd_elf_version_expr *d;
5644
bfd_boolean all_defined;
5646
*sinterpptr = bfd_get_linker_section (dynobj, ".interp");
5647
BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5651
soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5653
if (soname_indx == (bfd_size_type) -1
5654
|| !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5660
if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5662
info->flags |= DF_SYMBOLIC;
5670
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5672
if (indx == (bfd_size_type) -1)
5675
tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
5676
if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
5680
if (filter_shlib != NULL)
5684
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5685
filter_shlib, TRUE);
5686
if (indx == (bfd_size_type) -1
5687
|| !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5691
if (auxiliary_filters != NULL)
5693
const char * const *p;
5695
for (p = auxiliary_filters; *p != NULL; p++)
5699
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5701
if (indx == (bfd_size_type) -1
5702
|| !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5711
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5713
if (indx == (bfd_size_type) -1
5714
|| !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5718
if (depaudit != NULL)
5722
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5724
if (indx == (bfd_size_type) -1
5725
|| !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5732
/* If we are supposed to export all symbols into the dynamic symbol
5733
table (this is not the normal case), then do so. */
5734
if (info->export_dynamic
5735
|| (info->executable && info->dynamic))
5737
elf_link_hash_traverse (elf_hash_table (info),
5738
_bfd_elf_export_symbol,
5744
/* Make all global versions with definition. */
5745
for (t = info->version_info; t != NULL; t = t->next)
5746
for (d = t->globals.list; d != NULL; d = d->next)
5747
if (!d->symver && d->literal)
5749
const char *verstr, *name;
5750
size_t namelen, verlen, newlen;
5751
char *newname, *p, leading_char;
5752
struct elf_link_hash_entry *newh;
5754
leading_char = bfd_get_symbol_leading_char (output_bfd);
5756
namelen = strlen (name) + (leading_char != '\0');
5758
verlen = strlen (verstr);
5759
newlen = namelen + verlen + 3;
5761
newname = (char *) bfd_malloc (newlen);
5762
if (newname == NULL)
5764
newname[0] = leading_char;
5765
memcpy (newname + (leading_char != '\0'), name, namelen);
5767
/* Check the hidden versioned definition. */
5768
p = newname + namelen;
5770
memcpy (p, verstr, verlen + 1);
5771
newh = elf_link_hash_lookup (elf_hash_table (info),
5772
newname, FALSE, FALSE,
5775
|| (newh->root.type != bfd_link_hash_defined
5776
&& newh->root.type != bfd_link_hash_defweak))
5778
/* Check the default versioned definition. */
5780
memcpy (p, verstr, verlen + 1);
5781
newh = elf_link_hash_lookup (elf_hash_table (info),
5782
newname, FALSE, FALSE,
5787
/* Mark this version if there is a definition and it is
5788
not defined in a shared object. */
5790
&& !newh->def_dynamic
5791
&& (newh->root.type == bfd_link_hash_defined
5792
|| newh->root.type == bfd_link_hash_defweak))
5796
/* Attach all the symbols to their version information. */
5797
asvinfo.info = info;
5798
asvinfo.failed = FALSE;
5800
elf_link_hash_traverse (elf_hash_table (info),
5801
_bfd_elf_link_assign_sym_version,
5806
if (!info->allow_undefined_version)
5808
/* Check if all global versions have a definition. */
5810
for (t = info->version_info; t != NULL; t = t->next)
5811
for (d = t->globals.list; d != NULL; d = d->next)
5812
if (d->literal && !d->symver && !d->script)
5814
(*_bfd_error_handler)
5815
(_("%s: undefined version: %s"),
5816
d->pattern, t->name);
5817
all_defined = FALSE;
5822
bfd_set_error (bfd_error_bad_value);
5827
/* Find all symbols which were defined in a dynamic object and make
5828
the backend pick a reasonable value for them. */
5829
elf_link_hash_traverse (elf_hash_table (info),
5830
_bfd_elf_adjust_dynamic_symbol,
5835
/* Add some entries to the .dynamic section. We fill in some of the
5836
values later, in bfd_elf_final_link, but we must add the entries
5837
now so that we know the final size of the .dynamic section. */
5839
/* If there are initialization and/or finalization functions to
5840
call then add the corresponding DT_INIT/DT_FINI entries. */
5841
h = (info->init_function
5842
? elf_link_hash_lookup (elf_hash_table (info),
5843
info->init_function, FALSE,
5850
if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5853
h = (info->fini_function
5854
? elf_link_hash_lookup (elf_hash_table (info),
5855
info->fini_function, FALSE,
5862
if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5866
s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5867
if (s != NULL && s->linker_has_input)
5869
/* DT_PREINIT_ARRAY is not allowed in shared library. */
5870
if (! info->executable)
5875
for (sub = info->input_bfds; sub != NULL;
5876
sub = sub->link_next)
5877
if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5878
for (o = sub->sections; o != NULL; o = o->next)
5879
if (elf_section_data (o)->this_hdr.sh_type
5880
== SHT_PREINIT_ARRAY)
5882
(*_bfd_error_handler)
5883
(_("%B: .preinit_array section is not allowed in DSO"),
5888
bfd_set_error (bfd_error_nonrepresentable_section);
5892
if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5893
|| !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5896
s = bfd_get_section_by_name (output_bfd, ".init_array");
5897
if (s != NULL && s->linker_has_input)
5899
if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5900
|| !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5903
s = bfd_get_section_by_name (output_bfd, ".fini_array");
5904
if (s != NULL && s->linker_has_input)
5906
if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5907
|| !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5911
dynstr = bfd_get_linker_section (dynobj, ".dynstr");
5912
/* If .dynstr is excluded from the link, we don't want any of
5913
these tags. Strictly, we should be checking each section
5914
individually; This quick check covers for the case where
5915
someone does a /DISCARD/ : { *(*) }. */
5916
if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5918
bfd_size_type strsize;
5920
strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5921
if ((info->emit_hash
5922
&& !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5923
|| (info->emit_gnu_hash
5924
&& !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5925
|| !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5926
|| !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5927
|| !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5928
|| !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5929
bed->s->sizeof_sym))
5934
/* The backend must work out the sizes of all the other dynamic
5937
&& bed->elf_backend_size_dynamic_sections != NULL
5938
&& ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5941
if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5944
if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5946
unsigned long section_sym_count;
5947
struct bfd_elf_version_tree *verdefs;
5950
/* Set up the version definition section. */
5951
s = bfd_get_linker_section (dynobj, ".gnu.version_d");
5952
BFD_ASSERT (s != NULL);
5954
/* We may have created additional version definitions if we are
5955
just linking a regular application. */
5956
verdefs = info->version_info;
5958
/* Skip anonymous version tag. */
5959
if (verdefs != NULL && verdefs->vernum == 0)
5960
verdefs = verdefs->next;
5962
if (verdefs == NULL && !info->create_default_symver)
5963
s->flags |= SEC_EXCLUDE;
5968
struct bfd_elf_version_tree *t;
5970
Elf_Internal_Verdef def;
5971
Elf_Internal_Verdaux defaux;
5972
struct bfd_link_hash_entry *bh;
5973
struct elf_link_hash_entry *h;
5979
/* Make space for the base version. */
5980
size += sizeof (Elf_External_Verdef);
5981
size += sizeof (Elf_External_Verdaux);
5984
/* Make space for the default version. */
5985
if (info->create_default_symver)
5987
size += sizeof (Elf_External_Verdef);
5991
for (t = verdefs; t != NULL; t = t->next)
5993
struct bfd_elf_version_deps *n;
5995
/* Don't emit base version twice. */
5999
size += sizeof (Elf_External_Verdef);
6000
size += sizeof (Elf_External_Verdaux);
6003
for (n = t->deps; n != NULL; n = n->next)
6004
size += sizeof (Elf_External_Verdaux);
6008
s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6009
if (s->contents == NULL && s->size != 0)
6012
/* Fill in the version definition section. */
6016
def.vd_version = VER_DEF_CURRENT;
6017
def.vd_flags = VER_FLG_BASE;
6020
if (info->create_default_symver)
6022
def.vd_aux = 2 * sizeof (Elf_External_Verdef);
6023
def.vd_next = sizeof (Elf_External_Verdef);
6027
def.vd_aux = sizeof (Elf_External_Verdef);
6028
def.vd_next = (sizeof (Elf_External_Verdef)
6029
+ sizeof (Elf_External_Verdaux));
6032
if (soname_indx != (bfd_size_type) -1)
6034
_bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6036
def.vd_hash = bfd_elf_hash (soname);
6037
defaux.vda_name = soname_indx;
6044
name = lbasename (output_bfd->filename);
6045
def.vd_hash = bfd_elf_hash (name);
6046
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6048
if (indx == (bfd_size_type) -1)
6050
defaux.vda_name = indx;
6052
defaux.vda_next = 0;
6054
_bfd_elf_swap_verdef_out (output_bfd, &def,
6055
(Elf_External_Verdef *) p);
6056
p += sizeof (Elf_External_Verdef);
6057
if (info->create_default_symver)
6059
/* Add a symbol representing this version. */
6061
if (! (_bfd_generic_link_add_one_symbol
6062
(info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6064
get_elf_backend_data (dynobj)->collect, &bh)))
6066
h = (struct elf_link_hash_entry *) bh;
6069
h->type = STT_OBJECT;
6070
h->verinfo.vertree = NULL;
6072
if (! bfd_elf_link_record_dynamic_symbol (info, h))
6075
/* Create a duplicate of the base version with the same
6076
aux block, but different flags. */
6079
def.vd_aux = sizeof (Elf_External_Verdef);
6081
def.vd_next = (sizeof (Elf_External_Verdef)
6082
+ sizeof (Elf_External_Verdaux));
6085
_bfd_elf_swap_verdef_out (output_bfd, &def,
6086
(Elf_External_Verdef *) p);
6087
p += sizeof (Elf_External_Verdef);
6089
_bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6090
(Elf_External_Verdaux *) p);
6091
p += sizeof (Elf_External_Verdaux);
6093
for (t = verdefs; t != NULL; t = t->next)
6096
struct bfd_elf_version_deps *n;
6098
/* Don't emit the base version twice. */
6103
for (n = t->deps; n != NULL; n = n->next)
6106
/* Add a symbol representing this version. */
6108
if (! (_bfd_generic_link_add_one_symbol
6109
(info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6111
get_elf_backend_data (dynobj)->collect, &bh)))
6113
h = (struct elf_link_hash_entry *) bh;
6116
h->type = STT_OBJECT;
6117
h->verinfo.vertree = t;
6119
if (! bfd_elf_link_record_dynamic_symbol (info, h))
6122
def.vd_version = VER_DEF_CURRENT;
6124
if (t->globals.list == NULL
6125
&& t->locals.list == NULL
6127
def.vd_flags |= VER_FLG_WEAK;
6128
def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6129
def.vd_cnt = cdeps + 1;
6130
def.vd_hash = bfd_elf_hash (t->name);
6131
def.vd_aux = sizeof (Elf_External_Verdef);
6134
/* If a basever node is next, it *must* be the last node in
6135
the chain, otherwise Verdef construction breaks. */
6136
if (t->next != NULL && t->next->vernum == 0)
6137
BFD_ASSERT (t->next->next == NULL);
6139
if (t->next != NULL && t->next->vernum != 0)
6140
def.vd_next = (sizeof (Elf_External_Verdef)
6141
+ (cdeps + 1) * sizeof (Elf_External_Verdaux));
6143
_bfd_elf_swap_verdef_out (output_bfd, &def,
6144
(Elf_External_Verdef *) p);
6145
p += sizeof (Elf_External_Verdef);
6147
defaux.vda_name = h->dynstr_index;
6148
_bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6150
defaux.vda_next = 0;
6151
if (t->deps != NULL)
6152
defaux.vda_next = sizeof (Elf_External_Verdaux);
6153
t->name_indx = defaux.vda_name;
6155
_bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6156
(Elf_External_Verdaux *) p);
6157
p += sizeof (Elf_External_Verdaux);
6159
for (n = t->deps; n != NULL; n = n->next)
6161
if (n->version_needed == NULL)
6163
/* This can happen if there was an error in the
6165
defaux.vda_name = 0;
6169
defaux.vda_name = n->version_needed->name_indx;
6170
_bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6173
if (n->next == NULL)
6174
defaux.vda_next = 0;
6176
defaux.vda_next = sizeof (Elf_External_Verdaux);
6178
_bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6179
(Elf_External_Verdaux *) p);
6180
p += sizeof (Elf_External_Verdaux);
6184
if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6185
|| !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6188
elf_tdata (output_bfd)->cverdefs = cdefs;
6191
if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6193
if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6196
else if (info->flags & DF_BIND_NOW)
6198
if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6204
if (info->executable)
6205
info->flags_1 &= ~ (DF_1_INITFIRST
6208
if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6212
/* Work out the size of the version reference section. */
6214
s = bfd_get_linker_section (dynobj, ".gnu.version_r");
6215
BFD_ASSERT (s != NULL);
6217
struct elf_find_verdep_info sinfo;
6220
sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6221
if (sinfo.vers == 0)
6223
sinfo.failed = FALSE;
6225
elf_link_hash_traverse (elf_hash_table (info),
6226
_bfd_elf_link_find_version_dependencies,
6231
if (elf_tdata (output_bfd)->verref == NULL)
6232
s->flags |= SEC_EXCLUDE;
6235
Elf_Internal_Verneed *t;
6240
/* Build the version dependency section. */
6243
for (t = elf_tdata (output_bfd)->verref;
6247
Elf_Internal_Vernaux *a;
6249
size += sizeof (Elf_External_Verneed);
6251
for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6252
size += sizeof (Elf_External_Vernaux);
6256
s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6257
if (s->contents == NULL)
6261
for (t = elf_tdata (output_bfd)->verref;
6266
Elf_Internal_Vernaux *a;
6270
for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6273
t->vn_version = VER_NEED_CURRENT;
6275
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6276
elf_dt_name (t->vn_bfd) != NULL
6277
? elf_dt_name (t->vn_bfd)
6278
: lbasename (t->vn_bfd->filename),
6280
if (indx == (bfd_size_type) -1)
6283
t->vn_aux = sizeof (Elf_External_Verneed);
6284
if (t->vn_nextref == NULL)
6287
t->vn_next = (sizeof (Elf_External_Verneed)
6288
+ caux * sizeof (Elf_External_Vernaux));
6290
_bfd_elf_swap_verneed_out (output_bfd, t,
6291
(Elf_External_Verneed *) p);
6292
p += sizeof (Elf_External_Verneed);
6294
for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6296
a->vna_hash = bfd_elf_hash (a->vna_nodename);
6297
indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6298
a->vna_nodename, FALSE);
6299
if (indx == (bfd_size_type) -1)
6302
if (a->vna_nextptr == NULL)
6305
a->vna_next = sizeof (Elf_External_Vernaux);
6307
_bfd_elf_swap_vernaux_out (output_bfd, a,
6308
(Elf_External_Vernaux *) p);
6309
p += sizeof (Elf_External_Vernaux);
6313
if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6314
|| !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6317
elf_tdata (output_bfd)->cverrefs = crefs;
6321
if ((elf_tdata (output_bfd)->cverrefs == 0
6322
&& elf_tdata (output_bfd)->cverdefs == 0)
6323
|| _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6324
§ion_sym_count) == 0)
6326
s = bfd_get_linker_section (dynobj, ".gnu.version");
6327
s->flags |= SEC_EXCLUDE;
6333
/* Find the first non-excluded output section. We'll use its
6334
section symbol for some emitted relocs. */
6336
_bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6340
for (s = output_bfd->sections; s != NULL; s = s->next)
6341
if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6342
&& !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6344
elf_hash_table (info)->text_index_section = s;
6349
/* Find two non-excluded output sections, one for code, one for data.
6350
We'll use their section symbols for some emitted relocs. */
6352
_bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6356
/* Data first, since setting text_index_section changes
6357
_bfd_elf_link_omit_section_dynsym. */
6358
for (s = output_bfd->sections; s != NULL; s = s->next)
6359
if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6360
&& !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6362
elf_hash_table (info)->data_index_section = s;
6366
for (s = output_bfd->sections; s != NULL; s = s->next)
6367
if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6368
== (SEC_ALLOC | SEC_READONLY))
6369
&& !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6371
elf_hash_table (info)->text_index_section = s;
6375
if (elf_hash_table (info)->text_index_section == NULL)
6376
elf_hash_table (info)->text_index_section
6377
= elf_hash_table (info)->data_index_section;
6381
bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6383
const struct elf_backend_data *bed;
6385
if (!is_elf_hash_table (info->hash))
6388
bed = get_elf_backend_data (output_bfd);
6389
(*bed->elf_backend_init_index_section) (output_bfd, info);
6391
if (elf_hash_table (info)->dynamic_sections_created)
6395
bfd_size_type dynsymcount;
6396
unsigned long section_sym_count;
6397
unsigned int dtagcount;
6399
dynobj = elf_hash_table (info)->dynobj;
6401
/* Assign dynsym indicies. In a shared library we generate a
6402
section symbol for each output section, which come first.
6403
Next come all of the back-end allocated local dynamic syms,
6404
followed by the rest of the global symbols. */
6406
dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6407
§ion_sym_count);
6409
/* Work out the size of the symbol version section. */
6410
s = bfd_get_linker_section (dynobj, ".gnu.version");
6411
BFD_ASSERT (s != NULL);
6412
if (dynsymcount != 0
6413
&& (s->flags & SEC_EXCLUDE) == 0)
6415
s->size = dynsymcount * sizeof (Elf_External_Versym);
6416
s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6417
if (s->contents == NULL)
6420
if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6424
/* Set the size of the .dynsym and .hash sections. We counted
6425
the number of dynamic symbols in elf_link_add_object_symbols.
6426
We will build the contents of .dynsym and .hash when we build
6427
the final symbol table, because until then we do not know the
6428
correct value to give the symbols. We built the .dynstr
6429
section as we went along in elf_link_add_object_symbols. */
6430
s = bfd_get_linker_section (dynobj, ".dynsym");
6431
BFD_ASSERT (s != NULL);
6432
s->size = dynsymcount * bed->s->sizeof_sym;
6434
if (dynsymcount != 0)
6436
s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6437
if (s->contents == NULL)
6440
/* The first entry in .dynsym is a dummy symbol.
6441
Clear all the section syms, in case we don't output them all. */
6442
++section_sym_count;
6443
memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6446
elf_hash_table (info)->bucketcount = 0;
6448
/* Compute the size of the hashing table. As a side effect this
6449
computes the hash values for all the names we export. */
6450
if (info->emit_hash)
6452
unsigned long int *hashcodes;
6453
struct hash_codes_info hashinf;
6455
unsigned long int nsyms;
6457
size_t hash_entry_size;
6459
/* Compute the hash values for all exported symbols. At the same
6460
time store the values in an array so that we could use them for
6462
amt = dynsymcount * sizeof (unsigned long int);
6463
hashcodes = (unsigned long int *) bfd_malloc (amt);
6464
if (hashcodes == NULL)
6466
hashinf.hashcodes = hashcodes;
6467
hashinf.error = FALSE;
6469
/* Put all hash values in HASHCODES. */
6470
elf_link_hash_traverse (elf_hash_table (info),
6471
elf_collect_hash_codes, &hashinf);
6478
nsyms = hashinf.hashcodes - hashcodes;
6480
= compute_bucket_count (info, hashcodes, nsyms, 0);
6483
if (bucketcount == 0)
6486
elf_hash_table (info)->bucketcount = bucketcount;
6488
s = bfd_get_linker_section (dynobj, ".hash");
6489
BFD_ASSERT (s != NULL);
6490
hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6491
s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6492
s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6493
if (s->contents == NULL)
6496
bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6497
bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6498
s->contents + hash_entry_size);
6501
if (info->emit_gnu_hash)
6504
unsigned char *contents;
6505
struct collect_gnu_hash_codes cinfo;
6509
memset (&cinfo, 0, sizeof (cinfo));
6511
/* Compute the hash values for all exported symbols. At the same
6512
time store the values in an array so that we could use them for
6514
amt = dynsymcount * 2 * sizeof (unsigned long int);
6515
cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6516
if (cinfo.hashcodes == NULL)
6519
cinfo.hashval = cinfo.hashcodes + dynsymcount;
6520
cinfo.min_dynindx = -1;
6521
cinfo.output_bfd = output_bfd;
6524
/* Put all hash values in HASHCODES. */
6525
elf_link_hash_traverse (elf_hash_table (info),
6526
elf_collect_gnu_hash_codes, &cinfo);
6529
free (cinfo.hashcodes);
6534
= compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6536
if (bucketcount == 0)
6538
free (cinfo.hashcodes);
6542
s = bfd_get_linker_section (dynobj, ".gnu.hash");
6543
BFD_ASSERT (s != NULL);
6545
if (cinfo.nsyms == 0)
6547
/* Empty .gnu.hash section is special. */
6548
BFD_ASSERT (cinfo.min_dynindx == -1);
6549
free (cinfo.hashcodes);
6550
s->size = 5 * 4 + bed->s->arch_size / 8;
6551
contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6552
if (contents == NULL)
6554
s->contents = contents;
6555
/* 1 empty bucket. */
6556
bfd_put_32 (output_bfd, 1, contents);
6557
/* SYMIDX above the special symbol 0. */
6558
bfd_put_32 (output_bfd, 1, contents + 4);
6559
/* Just one word for bitmask. */
6560
bfd_put_32 (output_bfd, 1, contents + 8);
6561
/* Only hash fn bloom filter. */
6562
bfd_put_32 (output_bfd, 0, contents + 12);
6563
/* No hashes are valid - empty bitmask. */
6564
bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6565
/* No hashes in the only bucket. */
6566
bfd_put_32 (output_bfd, 0,
6567
contents + 16 + bed->s->arch_size / 8);
6571
unsigned long int maskwords, maskbitslog2, x;
6572
BFD_ASSERT (cinfo.min_dynindx != -1);
6576
while ((x >>= 1) != 0)
6578
if (maskbitslog2 < 3)
6580
else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6581
maskbitslog2 = maskbitslog2 + 3;
6583
maskbitslog2 = maskbitslog2 + 2;
6584
if (bed->s->arch_size == 64)
6586
if (maskbitslog2 == 5)
6592
cinfo.mask = (1 << cinfo.shift1) - 1;
6593
cinfo.shift2 = maskbitslog2;
6594
cinfo.maskbits = 1 << maskbitslog2;
6595
maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6596
amt = bucketcount * sizeof (unsigned long int) * 2;
6597
amt += maskwords * sizeof (bfd_vma);
6598
cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6599
if (cinfo.bitmask == NULL)
6601
free (cinfo.hashcodes);
6605
cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6606
cinfo.indx = cinfo.counts + bucketcount;
6607
cinfo.symindx = dynsymcount - cinfo.nsyms;
6608
memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6610
/* Determine how often each hash bucket is used. */
6611
memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6612
for (i = 0; i < cinfo.nsyms; ++i)
6613
++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6615
for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6616
if (cinfo.counts[i] != 0)
6618
cinfo.indx[i] = cnt;
6619
cnt += cinfo.counts[i];
6621
BFD_ASSERT (cnt == dynsymcount);
6622
cinfo.bucketcount = bucketcount;
6623
cinfo.local_indx = cinfo.min_dynindx;
6625
s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6626
s->size += cinfo.maskbits / 8;
6627
contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6628
if (contents == NULL)
6630
free (cinfo.bitmask);
6631
free (cinfo.hashcodes);
6635
s->contents = contents;
6636
bfd_put_32 (output_bfd, bucketcount, contents);
6637
bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6638
bfd_put_32 (output_bfd, maskwords, contents + 8);
6639
bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6640
contents += 16 + cinfo.maskbits / 8;
6642
for (i = 0; i < bucketcount; ++i)
6644
if (cinfo.counts[i] == 0)
6645
bfd_put_32 (output_bfd, 0, contents);
6647
bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6651
cinfo.contents = contents;
6653
/* Renumber dynamic symbols, populate .gnu.hash section. */
6654
elf_link_hash_traverse (elf_hash_table (info),
6655
elf_renumber_gnu_hash_syms, &cinfo);
6657
contents = s->contents + 16;
6658
for (i = 0; i < maskwords; ++i)
6660
bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6662
contents += bed->s->arch_size / 8;
6665
free (cinfo.bitmask);
6666
free (cinfo.hashcodes);
6670
s = bfd_get_linker_section (dynobj, ".dynstr");
6671
BFD_ASSERT (s != NULL);
6673
elf_finalize_dynstr (output_bfd, info);
6675
s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6677
for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6678
if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6685
/* Make sure sec_info_type is cleared if sec_info is cleared too. */
6688
merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6691
BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
6692
sec->sec_info_type = SEC_INFO_TYPE_NONE;
6695
/* Finish SHF_MERGE section merging. */
6698
_bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6703
if (!is_elf_hash_table (info->hash))
6706
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6707
if ((ibfd->flags & DYNAMIC) == 0)
6708
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6709
if ((sec->flags & SEC_MERGE) != 0
6710
&& !bfd_is_abs_section (sec->output_section))
6712
struct bfd_elf_section_data *secdata;
6714
secdata = elf_section_data (sec);
6715
if (! _bfd_add_merge_section (abfd,
6716
&elf_hash_table (info)->merge_info,
6717
sec, &secdata->sec_info))
6719
else if (secdata->sec_info)
6720
sec->sec_info_type = SEC_INFO_TYPE_MERGE;
6723
if (elf_hash_table (info)->merge_info != NULL)
6724
_bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6725
merge_sections_remove_hook);
6729
/* Create an entry in an ELF linker hash table. */
6731
struct bfd_hash_entry *
6732
_bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6733
struct bfd_hash_table *table,
6736
/* Allocate the structure if it has not already been allocated by a
6740
entry = (struct bfd_hash_entry *)
6741
bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6746
/* Call the allocation method of the superclass. */
6747
entry = _bfd_link_hash_newfunc (entry, table, string);
6750
struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6751
struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6753
/* Set local fields. */
6756
ret->got = htab->init_got_refcount;
6757
ret->plt = htab->init_plt_refcount;
6758
memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6759
- offsetof (struct elf_link_hash_entry, size)));
6760
/* Assume that we have been called by a non-ELF symbol reader.
6761
This flag is then reset by the code which reads an ELF input
6762
file. This ensures that a symbol created by a non-ELF symbol
6763
reader will have the flag set correctly. */
6770
/* Copy data from an indirect symbol to its direct symbol, hiding the
6771
old indirect symbol. Also used for copying flags to a weakdef. */
6774
_bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6775
struct elf_link_hash_entry *dir,
6776
struct elf_link_hash_entry *ind)
6778
struct elf_link_hash_table *htab;
6780
/* Copy down any references that we may have already seen to the
6781
symbol which just became indirect. */
6783
dir->ref_dynamic |= ind->ref_dynamic;
6784
dir->ref_regular |= ind->ref_regular;
6785
dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6786
dir->non_got_ref |= ind->non_got_ref;
6787
dir->needs_plt |= ind->needs_plt;
6788
dir->pointer_equality_needed |= ind->pointer_equality_needed;
6790
if (ind->root.type != bfd_link_hash_indirect)
6793
/* Copy over the global and procedure linkage table refcount entries.
6794
These may have been already set up by a check_relocs routine. */
6795
htab = elf_hash_table (info);
6796
if (ind->got.refcount > htab->init_got_refcount.refcount)
6798
if (dir->got.refcount < 0)
6799
dir->got.refcount = 0;
6800
dir->got.refcount += ind->got.refcount;
6801
ind->got.refcount = htab->init_got_refcount.refcount;
6804
if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6806
if (dir->plt.refcount < 0)
6807
dir->plt.refcount = 0;
6808
dir->plt.refcount += ind->plt.refcount;
6809
ind->plt.refcount = htab->init_plt_refcount.refcount;
6812
if (ind->dynindx != -1)
6814
if (dir->dynindx != -1)
6815
_bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6816
dir->dynindx = ind->dynindx;
6817
dir->dynstr_index = ind->dynstr_index;
6819
ind->dynstr_index = 0;
6824
_bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6825
struct elf_link_hash_entry *h,
6826
bfd_boolean force_local)
6828
/* STT_GNU_IFUNC symbol must go through PLT. */
6829
if (h->type != STT_GNU_IFUNC)
6831
h->plt = elf_hash_table (info)->init_plt_offset;
6836
h->forced_local = 1;
6837
if (h->dynindx != -1)
6840
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6846
/* Initialize an ELF linker hash table. *TABLE has been zeroed by our
6850
_bfd_elf_link_hash_table_init
6851
(struct elf_link_hash_table *table,
6853
struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6854
struct bfd_hash_table *,
6856
unsigned int entsize,
6857
enum elf_target_id target_id)
6860
int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6862
table->init_got_refcount.refcount = can_refcount - 1;
6863
table->init_plt_refcount.refcount = can_refcount - 1;
6864
table->init_got_offset.offset = -(bfd_vma) 1;
6865
table->init_plt_offset.offset = -(bfd_vma) 1;
6866
/* The first dynamic symbol is a dummy. */
6867
table->dynsymcount = 1;
6869
ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6871
table->root.type = bfd_link_elf_hash_table;
6872
table->hash_table_id = target_id;
6877
/* Create an ELF linker hash table. */
6879
struct bfd_link_hash_table *
6880
_bfd_elf_link_hash_table_create (bfd *abfd)
6882
struct elf_link_hash_table *ret;
6883
bfd_size_type amt = sizeof (struct elf_link_hash_table);
6885
ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
6889
if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6890
sizeof (struct elf_link_hash_entry),
6900
/* Destroy an ELF linker hash table. */
6903
_bfd_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
6905
struct elf_link_hash_table *htab = (struct elf_link_hash_table *) hash;
6906
if (htab->dynstr != NULL)
6907
_bfd_elf_strtab_free (htab->dynstr);
6908
_bfd_merge_sections_free (htab->merge_info);
6909
_bfd_generic_link_hash_table_free (hash);
6912
/* This is a hook for the ELF emulation code in the generic linker to
6913
tell the backend linker what file name to use for the DT_NEEDED
6914
entry for a dynamic object. */
6917
bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6919
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6920
&& bfd_get_format (abfd) == bfd_object)
6921
elf_dt_name (abfd) = name;
6925
bfd_elf_get_dyn_lib_class (bfd *abfd)
6928
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6929
&& bfd_get_format (abfd) == bfd_object)
6930
lib_class = elf_dyn_lib_class (abfd);
6937
bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6939
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6940
&& bfd_get_format (abfd) == bfd_object)
6941
elf_dyn_lib_class (abfd) = lib_class;
6944
/* Get the list of DT_NEEDED entries for a link. This is a hook for
6945
the linker ELF emulation code. */
6947
struct bfd_link_needed_list *
6948
bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6949
struct bfd_link_info *info)
6951
if (! is_elf_hash_table (info->hash))
6953
return elf_hash_table (info)->needed;
6956
/* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
6957
hook for the linker ELF emulation code. */
6959
struct bfd_link_needed_list *
6960
bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6961
struct bfd_link_info *info)
6963
if (! is_elf_hash_table (info->hash))
6965
return elf_hash_table (info)->runpath;
6968
/* Get the name actually used for a dynamic object for a link. This
6969
is the SONAME entry if there is one. Otherwise, it is the string
6970
passed to bfd_elf_set_dt_needed_name, or it is the filename. */
6973
bfd_elf_get_dt_soname (bfd *abfd)
6975
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6976
&& bfd_get_format (abfd) == bfd_object)
6977
return elf_dt_name (abfd);
6981
/* Get the list of DT_NEEDED entries from a BFD. This is a hook for
6982
the ELF linker emulation code. */
6985
bfd_elf_get_bfd_needed_list (bfd *abfd,
6986
struct bfd_link_needed_list **pneeded)
6989
bfd_byte *dynbuf = NULL;
6990
unsigned int elfsec;
6991
unsigned long shlink;
6992
bfd_byte *extdyn, *extdynend;
6994
void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6998
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6999
|| bfd_get_format (abfd) != bfd_object)
7002
s = bfd_get_section_by_name (abfd, ".dynamic");
7003
if (s == NULL || s->size == 0)
7006
if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
7009
elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
7010
if (elfsec == SHN_BAD)
7013
shlink = elf_elfsections (abfd)[elfsec]->sh_link;
7015
extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
7016
swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
7019
extdynend = extdyn + s->size;
7020
for (; extdyn < extdynend; extdyn += extdynsize)
7022
Elf_Internal_Dyn dyn;
7024
(*swap_dyn_in) (abfd, extdyn, &dyn);
7026
if (dyn.d_tag == DT_NULL)
7029
if (dyn.d_tag == DT_NEEDED)
7032
struct bfd_link_needed_list *l;
7033
unsigned int tagv = dyn.d_un.d_val;
7036
string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
7041
l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7062
struct elf_symbuf_symbol
7064
unsigned long st_name; /* Symbol name, index in string tbl */
7065
unsigned char st_info; /* Type and binding attributes */
7066
unsigned char st_other; /* Visibilty, and target specific */
7069
struct elf_symbuf_head
7071
struct elf_symbuf_symbol *ssym;
7072
bfd_size_type count;
7073
unsigned int st_shndx;
7080
Elf_Internal_Sym *isym;
7081
struct elf_symbuf_symbol *ssym;
7086
/* Sort references to symbols by ascending section number. */
7089
elf_sort_elf_symbol (const void *arg1, const void *arg2)
7091
const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7092
const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7094
return s1->st_shndx - s2->st_shndx;
7098
elf_sym_name_compare (const void *arg1, const void *arg2)
7100
const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7101
const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7102
return strcmp (s1->name, s2->name);
7105
static struct elf_symbuf_head *
7106
elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7108
Elf_Internal_Sym **ind, **indbufend, **indbuf;
7109
struct elf_symbuf_symbol *ssym;
7110
struct elf_symbuf_head *ssymbuf, *ssymhead;
7111
bfd_size_type i, shndx_count, total_size;
7113
indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7117
for (ind = indbuf, i = 0; i < symcount; i++)
7118
if (isymbuf[i].st_shndx != SHN_UNDEF)
7119
*ind++ = &isymbuf[i];
7122
qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7123
elf_sort_elf_symbol);
7126
if (indbufend > indbuf)
7127
for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7128
if (ind[0]->st_shndx != ind[1]->st_shndx)
7131
total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7132
+ (indbufend - indbuf) * sizeof (*ssym));
7133
ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7134
if (ssymbuf == NULL)
7140
ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7141
ssymbuf->ssym = NULL;
7142
ssymbuf->count = shndx_count;
7143
ssymbuf->st_shndx = 0;
7144
for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7146
if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7149
ssymhead->ssym = ssym;
7150
ssymhead->count = 0;
7151
ssymhead->st_shndx = (*ind)->st_shndx;
7153
ssym->st_name = (*ind)->st_name;
7154
ssym->st_info = (*ind)->st_info;
7155
ssym->st_other = (*ind)->st_other;
7158
BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7159
&& (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7166
/* Check if 2 sections define the same set of local and global
7170
bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7171
struct bfd_link_info *info)
7174
const struct elf_backend_data *bed1, *bed2;
7175
Elf_Internal_Shdr *hdr1, *hdr2;
7176
bfd_size_type symcount1, symcount2;
7177
Elf_Internal_Sym *isymbuf1, *isymbuf2;
7178
struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7179
Elf_Internal_Sym *isym, *isymend;
7180
struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7181
bfd_size_type count1, count2, i;
7182
unsigned int shndx1, shndx2;
7188
/* Both sections have to be in ELF. */
7189
if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7190
|| bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7193
if (elf_section_type (sec1) != elf_section_type (sec2))
7196
shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7197
shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7198
if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7201
bed1 = get_elf_backend_data (bfd1);
7202
bed2 = get_elf_backend_data (bfd2);
7203
hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7204
symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7205
hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7206
symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7208
if (symcount1 == 0 || symcount2 == 0)
7214
ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7215
ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7217
if (ssymbuf1 == NULL)
7219
isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7221
if (isymbuf1 == NULL)
7224
if (!info->reduce_memory_overheads)
7225
elf_tdata (bfd1)->symbuf = ssymbuf1
7226
= elf_create_symbuf (symcount1, isymbuf1);
7229
if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7231
isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7233
if (isymbuf2 == NULL)
7236
if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7237
elf_tdata (bfd2)->symbuf = ssymbuf2
7238
= elf_create_symbuf (symcount2, isymbuf2);
7241
if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7243
/* Optimized faster version. */
7244
bfd_size_type lo, hi, mid;
7245
struct elf_symbol *symp;
7246
struct elf_symbuf_symbol *ssym, *ssymend;
7249
hi = ssymbuf1->count;
7254
mid = (lo + hi) / 2;
7255
if (shndx1 < ssymbuf1[mid].st_shndx)
7257
else if (shndx1 > ssymbuf1[mid].st_shndx)
7261
count1 = ssymbuf1[mid].count;
7268
hi = ssymbuf2->count;
7273
mid = (lo + hi) / 2;
7274
if (shndx2 < ssymbuf2[mid].st_shndx)
7276
else if (shndx2 > ssymbuf2[mid].st_shndx)
7280
count2 = ssymbuf2[mid].count;
7286
if (count1 == 0 || count2 == 0 || count1 != count2)
7289
symtable1 = (struct elf_symbol *)
7290
bfd_malloc (count1 * sizeof (struct elf_symbol));
7291
symtable2 = (struct elf_symbol *)
7292
bfd_malloc (count2 * sizeof (struct elf_symbol));
7293
if (symtable1 == NULL || symtable2 == NULL)
7297
for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7298
ssym < ssymend; ssym++, symp++)
7300
symp->u.ssym = ssym;
7301
symp->name = bfd_elf_string_from_elf_section (bfd1,
7307
for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7308
ssym < ssymend; ssym++, symp++)
7310
symp->u.ssym = ssym;
7311
symp->name = bfd_elf_string_from_elf_section (bfd2,
7316
/* Sort symbol by name. */
7317
qsort (symtable1, count1, sizeof (struct elf_symbol),
7318
elf_sym_name_compare);
7319
qsort (symtable2, count1, sizeof (struct elf_symbol),
7320
elf_sym_name_compare);
7322
for (i = 0; i < count1; i++)
7323
/* Two symbols must have the same binding, type and name. */
7324
if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7325
|| symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7326
|| strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7333
symtable1 = (struct elf_symbol *)
7334
bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7335
symtable2 = (struct elf_symbol *)
7336
bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7337
if (symtable1 == NULL || symtable2 == NULL)
7340
/* Count definitions in the section. */
7342
for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7343
if (isym->st_shndx == shndx1)
7344
symtable1[count1++].u.isym = isym;
7347
for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7348
if (isym->st_shndx == shndx2)
7349
symtable2[count2++].u.isym = isym;
7351
if (count1 == 0 || count2 == 0 || count1 != count2)
7354
for (i = 0; i < count1; i++)
7356
= bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7357
symtable1[i].u.isym->st_name);
7359
for (i = 0; i < count2; i++)
7361
= bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7362
symtable2[i].u.isym->st_name);
7364
/* Sort symbol by name. */
7365
qsort (symtable1, count1, sizeof (struct elf_symbol),
7366
elf_sym_name_compare);
7367
qsort (symtable2, count1, sizeof (struct elf_symbol),
7368
elf_sym_name_compare);
7370
for (i = 0; i < count1; i++)
7371
/* Two symbols must have the same binding, type and name. */
7372
if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7373
|| symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7374
|| strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7392
/* Return TRUE if 2 section types are compatible. */
7395
_bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7396
bfd *bbfd, const asection *bsec)
7400
|| abfd->xvec->flavour != bfd_target_elf_flavour
7401
|| bbfd->xvec->flavour != bfd_target_elf_flavour)
7404
return elf_section_type (asec) == elf_section_type (bsec);
7407
/* Final phase of ELF linker. */
7409
/* A structure we use to avoid passing large numbers of arguments. */
7411
struct elf_final_link_info
7413
/* General link information. */
7414
struct bfd_link_info *info;
7417
/* Symbol string table. */
7418
struct bfd_strtab_hash *symstrtab;
7419
/* .dynsym section. */
7420
asection *dynsym_sec;
7421
/* .hash section. */
7423
/* symbol version section (.gnu.version). */
7424
asection *symver_sec;
7425
/* Buffer large enough to hold contents of any section. */
7427
/* Buffer large enough to hold external relocs of any section. */
7428
void *external_relocs;
7429
/* Buffer large enough to hold internal relocs of any section. */
7430
Elf_Internal_Rela *internal_relocs;
7431
/* Buffer large enough to hold external local symbols of any input
7433
bfd_byte *external_syms;
7434
/* And a buffer for symbol section indices. */
7435
Elf_External_Sym_Shndx *locsym_shndx;
7436
/* Buffer large enough to hold internal local symbols of any input
7438
Elf_Internal_Sym *internal_syms;
7439
/* Array large enough to hold a symbol index for each local symbol
7440
of any input BFD. */
7442
/* Array large enough to hold a section pointer for each local
7443
symbol of any input BFD. */
7444
asection **sections;
7445
/* Buffer to hold swapped out symbols. */
7447
/* And one for symbol section indices. */
7448
Elf_External_Sym_Shndx *symshndxbuf;
7449
/* Number of swapped out symbols in buffer. */
7450
size_t symbuf_count;
7451
/* Number of symbols which fit in symbuf. */
7453
/* And same for symshndxbuf. */
7454
size_t shndxbuf_size;
7455
/* Number of STT_FILE syms seen. */
7456
size_t filesym_count;
7459
/* This struct is used to pass information to elf_link_output_extsym. */
7461
struct elf_outext_info
7464
bfd_boolean localsyms;
7465
bfd_boolean need_second_pass;
7466
bfd_boolean second_pass;
7467
struct elf_final_link_info *flinfo;
7471
/* Support for evaluating a complex relocation.
7473
Complex relocations are generalized, self-describing relocations. The
7474
implementation of them consists of two parts: complex symbols, and the
7475
relocations themselves.
7477
The relocations are use a reserved elf-wide relocation type code (R_RELC
7478
external / BFD_RELOC_RELC internal) and an encoding of relocation field
7479
information (start bit, end bit, word width, etc) into the addend. This
7480
information is extracted from CGEN-generated operand tables within gas.
7482
Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7483
internal) representing prefix-notation expressions, including but not
7484
limited to those sorts of expressions normally encoded as addends in the
7485
addend field. The symbol mangling format is:
7488
| <unary-operator> ':' <node>
7489
| <binary-operator> ':' <node> ':' <node>
7492
<literal> := 's' <digits=N> ':' <N character symbol name>
7493
| 'S' <digits=N> ':' <N character section name>
7497
<binary-operator> := as in C
7498
<unary-operator> := as in C, plus "0-" for unambiguous negation. */
7501
set_symbol_value (bfd *bfd_with_globals,
7502
Elf_Internal_Sym *isymbuf,
7507
struct elf_link_hash_entry **sym_hashes;
7508
struct elf_link_hash_entry *h;
7509
size_t extsymoff = locsymcount;
7511
if (symidx < locsymcount)
7513
Elf_Internal_Sym *sym;
7515
sym = isymbuf + symidx;
7516
if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7518
/* It is a local symbol: move it to the
7519
"absolute" section and give it a value. */
7520
sym->st_shndx = SHN_ABS;
7521
sym->st_value = val;
7524
BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7528
/* It is a global symbol: set its link type
7529
to "defined" and give it a value. */
7531
sym_hashes = elf_sym_hashes (bfd_with_globals);
7532
h = sym_hashes [symidx - extsymoff];
7533
while (h->root.type == bfd_link_hash_indirect
7534
|| h->root.type == bfd_link_hash_warning)
7535
h = (struct elf_link_hash_entry *) h->root.u.i.link;
7536
h->root.type = bfd_link_hash_defined;
7537
h->root.u.def.value = val;
7538
h->root.u.def.section = bfd_abs_section_ptr;
7542
resolve_symbol (const char *name,
7544
struct elf_final_link_info *flinfo,
7546
Elf_Internal_Sym *isymbuf,
7549
Elf_Internal_Sym *sym;
7550
struct bfd_link_hash_entry *global_entry;
7551
const char *candidate = NULL;
7552
Elf_Internal_Shdr *symtab_hdr;
7555
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7557
for (i = 0; i < locsymcount; ++ i)
7561
if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7564
candidate = bfd_elf_string_from_elf_section (input_bfd,
7565
symtab_hdr->sh_link,
7568
printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7569
name, candidate, (unsigned long) sym->st_value);
7571
if (candidate && strcmp (candidate, name) == 0)
7573
asection *sec = flinfo->sections [i];
7575
*result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7576
*result += sec->output_offset + sec->output_section->vma;
7578
printf ("Found symbol with value %8.8lx\n",
7579
(unsigned long) *result);
7585
/* Hmm, haven't found it yet. perhaps it is a global. */
7586
global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
7587
FALSE, FALSE, TRUE);
7591
if (global_entry->type == bfd_link_hash_defined
7592
|| global_entry->type == bfd_link_hash_defweak)
7594
*result = (global_entry->u.def.value
7595
+ global_entry->u.def.section->output_section->vma
7596
+ global_entry->u.def.section->output_offset);
7598
printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7599
global_entry->root.string, (unsigned long) *result);
7608
resolve_section (const char *name,
7615
for (curr = sections; curr; curr = curr->next)
7616
if (strcmp (curr->name, name) == 0)
7618
*result = curr->vma;
7622
/* Hmm. still haven't found it. try pseudo-section names. */
7623
for (curr = sections; curr; curr = curr->next)
7625
len = strlen (curr->name);
7626
if (len > strlen (name))
7629
if (strncmp (curr->name, name, len) == 0)
7631
if (strncmp (".end", name + len, 4) == 0)
7633
*result = curr->vma + curr->size;
7637
/* Insert more pseudo-section names here, if you like. */
7645
undefined_reference (const char *reftype, const char *name)
7647
_bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7652
eval_symbol (bfd_vma *result,
7655
struct elf_final_link_info *flinfo,
7657
Elf_Internal_Sym *isymbuf,
7666
const char *sym = *symp;
7668
bfd_boolean symbol_is_section = FALSE;
7673
if (len < 1 || len > sizeof (symbuf))
7675
bfd_set_error (bfd_error_invalid_operation);
7688
*result = strtoul (sym, (char **) symp, 16);
7692
symbol_is_section = TRUE;
7695
symlen = strtol (sym, (char **) symp, 10);
7696
sym = *symp + 1; /* Skip the trailing ':'. */
7698
if (symend < sym || symlen + 1 > sizeof (symbuf))
7700
bfd_set_error (bfd_error_invalid_operation);
7704
memcpy (symbuf, sym, symlen);
7705
symbuf[symlen] = '\0';
7706
*symp = sym + symlen;
7708
/* Is it always possible, with complex symbols, that gas "mis-guessed"
7709
the symbol as a section, or vice-versa. so we're pretty liberal in our
7710
interpretation here; section means "try section first", not "must be a
7711
section", and likewise with symbol. */
7713
if (symbol_is_section)
7715
if (!resolve_section (symbuf, flinfo->output_bfd->sections, result)
7716
&& !resolve_symbol (symbuf, input_bfd, flinfo, result,
7717
isymbuf, locsymcount))
7719
undefined_reference ("section", symbuf);
7725
if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
7726
isymbuf, locsymcount)
7727
&& !resolve_section (symbuf, flinfo->output_bfd->sections,
7730
undefined_reference ("symbol", symbuf);
7737
/* All that remains are operators. */
7739
#define UNARY_OP(op) \
7740
if (strncmp (sym, #op, strlen (#op)) == 0) \
7742
sym += strlen (#op); \
7746
if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7747
isymbuf, locsymcount, signed_p)) \
7750
*result = op ((bfd_signed_vma) a); \
7756
#define BINARY_OP(op) \
7757
if (strncmp (sym, #op, strlen (#op)) == 0) \
7759
sym += strlen (#op); \
7763
if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
7764
isymbuf, locsymcount, signed_p)) \
7767
if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
7768
isymbuf, locsymcount, signed_p)) \
7771
*result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7801
_bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7802
bfd_set_error (bfd_error_invalid_operation);
7808
put_value (bfd_vma size,
7809
unsigned long chunksz,
7814
location += (size - chunksz);
7816
for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7824
bfd_put_8 (input_bfd, x, location);
7827
bfd_put_16 (input_bfd, x, location);
7830
bfd_put_32 (input_bfd, x, location);
7834
bfd_put_64 (input_bfd, x, location);
7844
get_value (bfd_vma size,
7845
unsigned long chunksz,
7852
/* Sanity checks. */
7853
BFD_ASSERT (chunksz <= sizeof (x)
7856
&& (size % chunksz) == 0
7857
&& input_bfd != NULL
7858
&& location != NULL);
7860
if (chunksz == sizeof (x))
7862
BFD_ASSERT (size == chunksz);
7864
/* Make sure that we do not perform an undefined shift operation.
7865
We know that size == chunksz so there will only be one iteration
7866
of the loop below. */
7870
shift = 8 * chunksz;
7872
for (; size; size -= chunksz, location += chunksz)
7877
x = (x << shift) | bfd_get_8 (input_bfd, location);
7880
x = (x << shift) | bfd_get_16 (input_bfd, location);
7883
x = (x << shift) | bfd_get_32 (input_bfd, location);
7887
x = (x << shift) | bfd_get_64 (input_bfd, location);
7898
decode_complex_addend (unsigned long *start, /* in bits */
7899
unsigned long *oplen, /* in bits */
7900
unsigned long *len, /* in bits */
7901
unsigned long *wordsz, /* in bytes */
7902
unsigned long *chunksz, /* in bytes */
7903
unsigned long *lsb0_p,
7904
unsigned long *signed_p,
7905
unsigned long *trunc_p,
7906
unsigned long encoded)
7908
* start = encoded & 0x3F;
7909
* len = (encoded >> 6) & 0x3F;
7910
* oplen = (encoded >> 12) & 0x3F;
7911
* wordsz = (encoded >> 18) & 0xF;
7912
* chunksz = (encoded >> 22) & 0xF;
7913
* lsb0_p = (encoded >> 27) & 1;
7914
* signed_p = (encoded >> 28) & 1;
7915
* trunc_p = (encoded >> 29) & 1;
7918
bfd_reloc_status_type
7919
bfd_elf_perform_complex_relocation (bfd *input_bfd,
7920
asection *input_section ATTRIBUTE_UNUSED,
7922
Elf_Internal_Rela *rel,
7925
bfd_vma shift, x, mask;
7926
unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7927
bfd_reloc_status_type r;
7929
/* Perform this reloc, since it is complex.
7930
(this is not to say that it necessarily refers to a complex
7931
symbol; merely that it is a self-describing CGEN based reloc.
7932
i.e. the addend has the complete reloc information (bit start, end,
7933
word size, etc) encoded within it.). */
7935
decode_complex_addend (&start, &oplen, &len, &wordsz,
7936
&chunksz, &lsb0_p, &signed_p,
7937
&trunc_p, rel->r_addend);
7939
mask = (((1L << (len - 1)) - 1) << 1) | 1;
7942
shift = (start + 1) - len;
7944
shift = (8 * wordsz) - (start + len);
7946
/* FIXME: octets_per_byte. */
7947
x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7950
printf ("Doing complex reloc: "
7951
"lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7952
"chunksz %ld, start %ld, len %ld, oplen %ld\n"
7953
" dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7954
lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7955
oplen, (unsigned long) x, (unsigned long) mask,
7956
(unsigned long) relocation);
7961
/* Now do an overflow check. */
7962
r = bfd_check_overflow ((signed_p
7963
? complain_overflow_signed
7964
: complain_overflow_unsigned),
7965
len, 0, (8 * wordsz),
7969
x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7972
printf (" relocation: %8.8lx\n"
7973
" shifted mask: %8.8lx\n"
7974
" shifted/masked reloc: %8.8lx\n"
7975
" result: %8.8lx\n",
7976
(unsigned long) relocation, (unsigned long) (mask << shift),
7977
(unsigned long) ((relocation & mask) << shift), (unsigned long) x);
7979
/* FIXME: octets_per_byte. */
7980
put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7984
/* When performing a relocatable link, the input relocations are
7985
preserved. But, if they reference global symbols, the indices
7986
referenced must be updated. Update all the relocations found in
7990
elf_link_adjust_relocs (bfd *abfd,
7991
struct bfd_elf_section_reloc_data *reldata)
7994
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7996
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7997
void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7998
bfd_vma r_type_mask;
8000
unsigned int count = reldata->count;
8001
struct elf_link_hash_entry **rel_hash = reldata->hashes;
8003
if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
8005
swap_in = bed->s->swap_reloc_in;
8006
swap_out = bed->s->swap_reloc_out;
8008
else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
8010
swap_in = bed->s->swap_reloca_in;
8011
swap_out = bed->s->swap_reloca_out;
8016
if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
8019
if (bed->s->arch_size == 32)
8026
r_type_mask = 0xffffffff;
8030
erela = reldata->hdr->contents;
8031
for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
8033
Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
8036
if (*rel_hash == NULL)
8039
BFD_ASSERT ((*rel_hash)->indx >= 0);
8041
(*swap_in) (abfd, erela, irela);
8042
for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
8043
irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
8044
| (irela[j].r_info & r_type_mask));
8045
(*swap_out) (abfd, irela, erela);
8049
struct elf_link_sort_rela
8055
enum elf_reloc_type_class type;
8056
/* We use this as an array of size int_rels_per_ext_rel. */
8057
Elf_Internal_Rela rela[1];
8061
elf_link_sort_cmp1 (const void *A, const void *B)
8063
const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8064
const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8065
int relativea, relativeb;
8067
relativea = a->type == reloc_class_relative;
8068
relativeb = b->type == reloc_class_relative;
8070
if (relativea < relativeb)
8072
if (relativea > relativeb)
8074
if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8076
if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8078
if (a->rela->r_offset < b->rela->r_offset)
8080
if (a->rela->r_offset > b->rela->r_offset)
8086
elf_link_sort_cmp2 (const void *A, const void *B)
8088
const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8089
const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8091
if (a->type < b->type)
8093
if (a->type > b->type)
8095
if (a->u.offset < b->u.offset)
8097
if (a->u.offset > b->u.offset)
8099
if (a->rela->r_offset < b->rela->r_offset)
8101
if (a->rela->r_offset > b->rela->r_offset)
8107
elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8109
asection *dynamic_relocs;
8112
bfd_size_type count, size;
8113
size_t i, ret, sort_elt, ext_size;
8114
bfd_byte *sort, *s_non_relative, *p;
8115
struct elf_link_sort_rela *sq;
8116
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8117
int i2e = bed->s->int_rels_per_ext_rel;
8118
void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8119
void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8120
struct bfd_link_order *lo;
8122
bfd_boolean use_rela;
8124
/* Find a dynamic reloc section. */
8125
rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8126
rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn");
8127
if (rela_dyn != NULL && rela_dyn->size > 0
8128
&& rel_dyn != NULL && rel_dyn->size > 0)
8130
bfd_boolean use_rela_initialised = FALSE;
8132
/* This is just here to stop gcc from complaining.
8133
It's initialization checking code is not perfect. */
8136
/* Both sections are present. Examine the sizes
8137
of the indirect sections to help us choose. */
8138
for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8139
if (lo->type == bfd_indirect_link_order)
8141
asection *o = lo->u.indirect.section;
8143
if ((o->size % bed->s->sizeof_rela) == 0)
8145
if ((o->size % bed->s->sizeof_rel) == 0)
8146
/* Section size is divisible by both rel and rela sizes.
8147
It is of no help to us. */
8151
/* Section size is only divisible by rela. */
8152
if (use_rela_initialised && (use_rela == FALSE))
8155
(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8156
bfd_set_error (bfd_error_invalid_operation);
8162
use_rela_initialised = TRUE;
8166
else if ((o->size % bed->s->sizeof_rel) == 0)
8168
/* Section size is only divisible by rel. */
8169
if (use_rela_initialised && (use_rela == TRUE))
8172
(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8173
bfd_set_error (bfd_error_invalid_operation);
8179
use_rela_initialised = TRUE;
8184
/* The section size is not divisible by either - something is wrong. */
8186
(_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8187
bfd_set_error (bfd_error_invalid_operation);
8192
for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8193
if (lo->type == bfd_indirect_link_order)
8195
asection *o = lo->u.indirect.section;
8197
if ((o->size % bed->s->sizeof_rela) == 0)
8199
if ((o->size % bed->s->sizeof_rel) == 0)
8200
/* Section size is divisible by both rel and rela sizes.
8201
It is of no help to us. */
8205
/* Section size is only divisible by rela. */
8206
if (use_rela_initialised && (use_rela == FALSE))
8209
(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8210
bfd_set_error (bfd_error_invalid_operation);
8216
use_rela_initialised = TRUE;
8220
else if ((o->size % bed->s->sizeof_rel) == 0)
8222
/* Section size is only divisible by rel. */
8223
if (use_rela_initialised && (use_rela == TRUE))
8226
(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8227
bfd_set_error (bfd_error_invalid_operation);
8233
use_rela_initialised = TRUE;
8238
/* The section size is not divisible by either - something is wrong. */
8240
(_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8241
bfd_set_error (bfd_error_invalid_operation);
8246
if (! use_rela_initialised)
8250
else if (rela_dyn != NULL && rela_dyn->size > 0)
8252
else if (rel_dyn != NULL && rel_dyn->size > 0)
8259
dynamic_relocs = rela_dyn;
8260
ext_size = bed->s->sizeof_rela;
8261
swap_in = bed->s->swap_reloca_in;
8262
swap_out = bed->s->swap_reloca_out;
8266
dynamic_relocs = rel_dyn;
8267
ext_size = bed->s->sizeof_rel;
8268
swap_in = bed->s->swap_reloc_in;
8269
swap_out = bed->s->swap_reloc_out;
8273
for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8274
if (lo->type == bfd_indirect_link_order)
8275
size += lo->u.indirect.section->size;
8277
if (size != dynamic_relocs->size)
8280
sort_elt = (sizeof (struct elf_link_sort_rela)
8281
+ (i2e - 1) * sizeof (Elf_Internal_Rela));
8283
count = dynamic_relocs->size / ext_size;
8286
sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8290
(*info->callbacks->warning)
8291
(info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8295
if (bed->s->arch_size == 32)
8296
r_sym_mask = ~(bfd_vma) 0xff;
8298
r_sym_mask = ~(bfd_vma) 0xffffffff;
8300
for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8301
if (lo->type == bfd_indirect_link_order)
8303
bfd_byte *erel, *erelend;
8304
asection *o = lo->u.indirect.section;
8306
if (o->contents == NULL && o->size != 0)
8308
/* This is a reloc section that is being handled as a normal
8309
section. See bfd_section_from_shdr. We can't combine
8310
relocs in this case. */
8315
erelend = o->contents + o->size;
8316
/* FIXME: octets_per_byte. */
8317
p = sort + o->output_offset / ext_size * sort_elt;
8319
while (erel < erelend)
8321
struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8323
(*swap_in) (abfd, erel, s->rela);
8324
s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
8325
s->u.sym_mask = r_sym_mask;
8331
qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8333
for (i = 0, p = sort; i < count; i++, p += sort_elt)
8335
struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8336
if (s->type != reloc_class_relative)
8342
sq = (struct elf_link_sort_rela *) s_non_relative;
8343
for (; i < count; i++, p += sort_elt)
8345
struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8346
if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8348
sp->u.offset = sq->rela->r_offset;
8351
qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8353
for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8354
if (lo->type == bfd_indirect_link_order)
8356
bfd_byte *erel, *erelend;
8357
asection *o = lo->u.indirect.section;
8360
erelend = o->contents + o->size;
8361
/* FIXME: octets_per_byte. */
8362
p = sort + o->output_offset / ext_size * sort_elt;
8363
while (erel < erelend)
8365
struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8366
(*swap_out) (abfd, s->rela, erel);
8373
*psec = dynamic_relocs;
8377
/* Flush the output symbols to the file. */
8380
elf_link_flush_output_syms (struct elf_final_link_info *flinfo,
8381
const struct elf_backend_data *bed)
8383
if (flinfo->symbuf_count > 0)
8385
Elf_Internal_Shdr *hdr;
8389
hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
8390
pos = hdr->sh_offset + hdr->sh_size;
8391
amt = flinfo->symbuf_count * bed->s->sizeof_sym;
8392
if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) != 0
8393
|| bfd_bwrite (flinfo->symbuf, amt, flinfo->output_bfd) != amt)
8396
hdr->sh_size += amt;
8397
flinfo->symbuf_count = 0;
8403
/* Add a symbol to the output symbol table. */
8406
elf_link_output_sym (struct elf_final_link_info *flinfo,
8408
Elf_Internal_Sym *elfsym,
8409
asection *input_sec,
8410
struct elf_link_hash_entry *h)
8413
Elf_External_Sym_Shndx *destshndx;
8414
int (*output_symbol_hook)
8415
(struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8416
struct elf_link_hash_entry *);
8417
const struct elf_backend_data *bed;
8419
bed = get_elf_backend_data (flinfo->output_bfd);
8420
output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8421
if (output_symbol_hook != NULL)
8423
int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
8428
if (name == NULL || *name == '\0')
8429
elfsym->st_name = 0;
8430
else if (input_sec->flags & SEC_EXCLUDE)
8431
elfsym->st_name = 0;
8434
elfsym->st_name = (unsigned long) _bfd_stringtab_add (flinfo->symstrtab,
8436
if (elfsym->st_name == (unsigned long) -1)
8440
if (flinfo->symbuf_count >= flinfo->symbuf_size)
8442
if (! elf_link_flush_output_syms (flinfo, bed))
8446
dest = flinfo->symbuf + flinfo->symbuf_count * bed->s->sizeof_sym;
8447
destshndx = flinfo->symshndxbuf;
8448
if (destshndx != NULL)
8450
if (bfd_get_symcount (flinfo->output_bfd) >= flinfo->shndxbuf_size)
8454
amt = flinfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8455
destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8457
if (destshndx == NULL)
8459
flinfo->symshndxbuf = destshndx;
8460
memset ((char *) destshndx + amt, 0, amt);
8461
flinfo->shndxbuf_size *= 2;
8463
destshndx += bfd_get_symcount (flinfo->output_bfd);
8466
bed->s->swap_symbol_out (flinfo->output_bfd, elfsym, dest, destshndx);
8467
flinfo->symbuf_count += 1;
8468
bfd_get_symcount (flinfo->output_bfd) += 1;
8473
/* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
8476
check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8478
if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8479
&& sym->st_shndx < SHN_LORESERVE)
8481
/* The gABI doesn't support dynamic symbols in output sections
8483
(*_bfd_error_handler)
8484
(_("%B: Too many sections: %d (>= %d)"),
8485
abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8486
bfd_set_error (bfd_error_nonrepresentable_section);
8492
/* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8493
allowing an unsatisfied unversioned symbol in the DSO to match a
8494
versioned symbol that would normally require an explicit version.
8495
We also handle the case that a DSO references a hidden symbol
8496
which may be satisfied by a versioned symbol in another DSO. */
8499
elf_link_check_versioned_symbol (struct bfd_link_info *info,
8500
const struct elf_backend_data *bed,
8501
struct elf_link_hash_entry *h)
8504
struct elf_link_loaded_list *loaded;
8506
if (!is_elf_hash_table (info->hash))
8509
/* Check indirect symbol. */
8510
while (h->root.type == bfd_link_hash_indirect)
8511
h = (struct elf_link_hash_entry *) h->root.u.i.link;
8513
switch (h->root.type)
8519
case bfd_link_hash_undefined:
8520
case bfd_link_hash_undefweak:
8521
abfd = h->root.u.undef.abfd;
8522
if ((abfd->flags & DYNAMIC) == 0
8523
|| (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8527
case bfd_link_hash_defined:
8528
case bfd_link_hash_defweak:
8529
abfd = h->root.u.def.section->owner;
8532
case bfd_link_hash_common:
8533
abfd = h->root.u.c.p->section->owner;
8536
BFD_ASSERT (abfd != NULL);
8538
for (loaded = elf_hash_table (info)->loaded;
8540
loaded = loaded->next)
8543
Elf_Internal_Shdr *hdr;
8544
bfd_size_type symcount;
8545
bfd_size_type extsymcount;
8546
bfd_size_type extsymoff;
8547
Elf_Internal_Shdr *versymhdr;
8548
Elf_Internal_Sym *isym;
8549
Elf_Internal_Sym *isymend;
8550
Elf_Internal_Sym *isymbuf;
8551
Elf_External_Versym *ever;
8552
Elf_External_Versym *extversym;
8554
input = loaded->abfd;
8556
/* We check each DSO for a possible hidden versioned definition. */
8558
|| (input->flags & DYNAMIC) == 0
8559
|| elf_dynversym (input) == 0)
8562
hdr = &elf_tdata (input)->dynsymtab_hdr;
8564
symcount = hdr->sh_size / bed->s->sizeof_sym;
8565
if (elf_bad_symtab (input))
8567
extsymcount = symcount;
8572
extsymcount = symcount - hdr->sh_info;
8573
extsymoff = hdr->sh_info;
8576
if (extsymcount == 0)
8579
isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8581
if (isymbuf == NULL)
8584
/* Read in any version definitions. */
8585
versymhdr = &elf_tdata (input)->dynversym_hdr;
8586
extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8587
if (extversym == NULL)
8590
if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8591
|| (bfd_bread (extversym, versymhdr->sh_size, input)
8592
!= versymhdr->sh_size))
8600
ever = extversym + extsymoff;
8601
isymend = isymbuf + extsymcount;
8602
for (isym = isymbuf; isym < isymend; isym++, ever++)
8605
Elf_Internal_Versym iver;
8606
unsigned short version_index;
8608
if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8609
|| isym->st_shndx == SHN_UNDEF)
8612
name = bfd_elf_string_from_elf_section (input,
8615
if (strcmp (name, h->root.root.string) != 0)
8618
_bfd_elf_swap_versym_in (input, ever, &iver);
8620
if ((iver.vs_vers & VERSYM_HIDDEN) == 0
8622
&& h->forced_local))
8624
/* If we have a non-hidden versioned sym, then it should
8625
have provided a definition for the undefined sym unless
8626
it is defined in a non-shared object and forced local.
8631
version_index = iver.vs_vers & VERSYM_VERSION;
8632
if (version_index == 1 || version_index == 2)
8634
/* This is the base or first version. We can use it. */
8648
/* Add an external symbol to the symbol table. This is called from
8649
the hash table traversal routine. When generating a shared object,
8650
we go through the symbol table twice. The first time we output
8651
anything that might have been forced to local scope in a version
8652
script. The second time we output the symbols that are still
8656
elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
8658
struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
8659
struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8660
struct elf_final_link_info *flinfo = eoinfo->flinfo;
8662
Elf_Internal_Sym sym;
8663
asection *input_sec;
8664
const struct elf_backend_data *bed;
8668
if (h->root.type == bfd_link_hash_warning)
8670
h = (struct elf_link_hash_entry *) h->root.u.i.link;
8671
if (h->root.type == bfd_link_hash_new)
8675
/* Decide whether to output this symbol in this pass. */
8676
if (eoinfo->localsyms)
8678
if (!h->forced_local)
8680
if (eoinfo->second_pass
8681
&& !((h->root.type == bfd_link_hash_defined
8682
|| h->root.type == bfd_link_hash_defweak)
8683
&& h->root.u.def.section->output_section != NULL))
8688
if (h->forced_local)
8692
bed = get_elf_backend_data (flinfo->output_bfd);
8694
if (h->root.type == bfd_link_hash_undefined)
8696
/* If we have an undefined symbol reference here then it must have
8697
come from a shared library that is being linked in. (Undefined
8698
references in regular files have already been handled unless
8699
they are in unreferenced sections which are removed by garbage
8701
bfd_boolean ignore_undef = FALSE;
8703
/* Some symbols may be special in that the fact that they're
8704
undefined can be safely ignored - let backend determine that. */
8705
if (bed->elf_backend_ignore_undef_symbol)
8706
ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8708
/* If we are reporting errors for this situation then do so now. */
8711
&& (!h->ref_regular || flinfo->info->gc_sections)
8712
&& !elf_link_check_versioned_symbol (flinfo->info, bed, h)
8713
&& flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8715
if (!(flinfo->info->callbacks->undefined_symbol
8716
(flinfo->info, h->root.root.string,
8717
h->ref_regular ? NULL : h->root.u.undef.abfd,
8719
(flinfo->info->unresolved_syms_in_shared_libs
8720
== RM_GENERATE_ERROR))))
8722
bfd_set_error (bfd_error_bad_value);
8723
eoinfo->failed = TRUE;
8729
/* We should also warn if a forced local symbol is referenced from
8730
shared libraries. */
8731
if (!flinfo->info->relocatable
8732
&& flinfo->info->executable
8737
&& h->ref_dynamic_nonweak
8738
&& !elf_link_check_versioned_symbol (flinfo->info, bed, h))
8742
struct elf_link_hash_entry *hi = h;
8744
/* Check indirect symbol. */
8745
while (hi->root.type == bfd_link_hash_indirect)
8746
hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
8748
if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
8749
msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
8750
else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
8751
msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
8753
msg = _("%B: local symbol `%s' in %B is referenced by DSO");
8754
def_bfd = flinfo->output_bfd;
8755
if (hi->root.u.def.section != bfd_abs_section_ptr)
8756
def_bfd = hi->root.u.def.section->owner;
8757
(*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
8758
h->root.root.string);
8759
bfd_set_error (bfd_error_bad_value);
8760
eoinfo->failed = TRUE;
8764
/* We don't want to output symbols that have never been mentioned by
8765
a regular file, or that we have been told to strip. However, if
8766
h->indx is set to -2, the symbol is used by a reloc and we must
8770
else if ((h->def_dynamic
8772
|| h->root.type == bfd_link_hash_new)
8776
else if (flinfo->info->strip == strip_all)
8778
else if (flinfo->info->strip == strip_some
8779
&& bfd_hash_lookup (flinfo->info->keep_hash,
8780
h->root.root.string, FALSE, FALSE) == NULL)
8782
else if ((h->root.type == bfd_link_hash_defined
8783
|| h->root.type == bfd_link_hash_defweak)
8784
&& ((flinfo->info->strip_discarded
8785
&& discarded_section (h->root.u.def.section))
8786
|| (h->root.u.def.section->owner != NULL
8787
&& (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
8789
else if ((h->root.type == bfd_link_hash_undefined
8790
|| h->root.type == bfd_link_hash_undefweak)
8791
&& h->root.u.undef.abfd != NULL
8792
&& (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
8797
/* If we're stripping it, and it's not a dynamic symbol, there's
8798
nothing else to do unless it is a forced local symbol or a
8799
STT_GNU_IFUNC symbol. */
8802
&& h->type != STT_GNU_IFUNC
8803
&& !h->forced_local)
8807
sym.st_size = h->size;
8808
sym.st_other = h->other;
8809
if (h->forced_local)
8811
sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8812
/* Turn off visibility on local symbol. */
8813
sym.st_other &= ~ELF_ST_VISIBILITY (-1);
8815
/* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */
8816
else if (h->unique_global && h->def_regular)
8817
sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8818
else if (h->root.type == bfd_link_hash_undefweak
8819
|| h->root.type == bfd_link_hash_defweak)
8820
sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8822
sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8823
sym.st_target_internal = h->target_internal;
8825
switch (h->root.type)
8828
case bfd_link_hash_new:
8829
case bfd_link_hash_warning:
8833
case bfd_link_hash_undefined:
8834
case bfd_link_hash_undefweak:
8835
input_sec = bfd_und_section_ptr;
8836
sym.st_shndx = SHN_UNDEF;
8839
case bfd_link_hash_defined:
8840
case bfd_link_hash_defweak:
8842
input_sec = h->root.u.def.section;
8843
if (input_sec->output_section != NULL)
8845
if (eoinfo->localsyms && flinfo->filesym_count == 1)
8847
bfd_boolean second_pass_sym
8848
= (input_sec->owner == flinfo->output_bfd
8849
|| input_sec->owner == NULL
8850
|| (input_sec->flags & SEC_LINKER_CREATED) != 0
8851
|| (input_sec->owner->flags & BFD_LINKER_CREATED) != 0);
8853
eoinfo->need_second_pass |= second_pass_sym;
8854
if (eoinfo->second_pass != second_pass_sym)
8859
_bfd_elf_section_from_bfd_section (flinfo->output_bfd,
8860
input_sec->output_section);
8861
if (sym.st_shndx == SHN_BAD)
8863
(*_bfd_error_handler)
8864
(_("%B: could not find output section %A for input section %A"),
8865
flinfo->output_bfd, input_sec->output_section, input_sec);
8866
bfd_set_error (bfd_error_nonrepresentable_section);
8867
eoinfo->failed = TRUE;
8871
/* ELF symbols in relocatable files are section relative,
8872
but in nonrelocatable files they are virtual
8874
sym.st_value = h->root.u.def.value + input_sec->output_offset;
8875
if (!flinfo->info->relocatable)
8877
sym.st_value += input_sec->output_section->vma;
8878
if (h->type == STT_TLS)
8880
asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
8881
if (tls_sec != NULL)
8882
sym.st_value -= tls_sec->vma;
8885
/* The TLS section may have been garbage collected. */
8886
BFD_ASSERT (flinfo->info->gc_sections
8887
&& !input_sec->gc_mark);
8894
BFD_ASSERT (input_sec->owner == NULL
8895
|| (input_sec->owner->flags & DYNAMIC) != 0);
8896
sym.st_shndx = SHN_UNDEF;
8897
input_sec = bfd_und_section_ptr;
8902
case bfd_link_hash_common:
8903
input_sec = h->root.u.c.p->section;
8904
sym.st_shndx = bed->common_section_index (input_sec);
8905
sym.st_value = 1 << h->root.u.c.p->alignment_power;
8908
case bfd_link_hash_indirect:
8909
/* These symbols are created by symbol versioning. They point
8910
to the decorated version of the name. For example, if the
8911
symbol foo@@GNU_1.2 is the default, which should be used when
8912
foo is used with no version, then we add an indirect symbol
8913
foo which points to foo@@GNU_1.2. We ignore these symbols,
8914
since the indirected symbol is already in the hash table. */
8918
/* Give the processor backend a chance to tweak the symbol value,
8919
and also to finish up anything that needs to be done for this
8920
symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
8921
forced local syms when non-shared is due to a historical quirk.
8922
STT_GNU_IFUNC symbol must go through PLT. */
8923
if ((h->type == STT_GNU_IFUNC
8925
&& !flinfo->info->relocatable)
8926
|| ((h->dynindx != -1
8928
&& ((flinfo->info->shared
8929
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8930
|| h->root.type != bfd_link_hash_undefweak))
8931
|| !h->forced_local)
8932
&& elf_hash_table (flinfo->info)->dynamic_sections_created))
8934
if (! ((*bed->elf_backend_finish_dynamic_symbol)
8935
(flinfo->output_bfd, flinfo->info, h, &sym)))
8937
eoinfo->failed = TRUE;
8942
/* If we are marking the symbol as undefined, and there are no
8943
non-weak references to this symbol from a regular object, then
8944
mark the symbol as weak undefined; if there are non-weak
8945
references, mark the symbol as strong. We can't do this earlier,
8946
because it might not be marked as undefined until the
8947
finish_dynamic_symbol routine gets through with it. */
8948
if (sym.st_shndx == SHN_UNDEF
8950
&& (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
8951
|| ELF_ST_BIND (sym.st_info) == STB_WEAK))
8954
unsigned int type = ELF_ST_TYPE (sym.st_info);
8956
/* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8957
if (type == STT_GNU_IFUNC)
8960
if (h->ref_regular_nonweak)
8961
bindtype = STB_GLOBAL;
8963
bindtype = STB_WEAK;
8964
sym.st_info = ELF_ST_INFO (bindtype, type);
8967
/* If this is a symbol defined in a dynamic library, don't use the
8968
symbol size from the dynamic library. Relinking an executable
8969
against a new library may introduce gratuitous changes in the
8970
executable's symbols if we keep the size. */
8971
if (sym.st_shndx == SHN_UNDEF
8976
/* If a non-weak symbol with non-default visibility is not defined
8977
locally, it is a fatal error. */
8978
if (!flinfo->info->relocatable
8979
&& ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
8980
&& ELF_ST_BIND (sym.st_info) != STB_WEAK
8981
&& h->root.type == bfd_link_hash_undefined
8986
if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
8987
msg = _("%B: protected symbol `%s' isn't defined");
8988
else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
8989
msg = _("%B: internal symbol `%s' isn't defined");
8991
msg = _("%B: hidden symbol `%s' isn't defined");
8992
(*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
8993
bfd_set_error (bfd_error_bad_value);
8994
eoinfo->failed = TRUE;
8998
/* If this symbol should be put in the .dynsym section, then put it
8999
there now. We already know the symbol index. We also fill in
9000
the entry in the .hash section. */
9001
if (flinfo->dynsym_sec != NULL
9003
&& elf_hash_table (flinfo->info)->dynamic_sections_created)
9007
/* Since there is no version information in the dynamic string,
9008
if there is no version info in symbol version section, we will
9009
have a run-time problem. */
9010
if (h->verinfo.verdef == NULL)
9012
char *p = strrchr (h->root.root.string, ELF_VER_CHR);
9014
if (p && p [1] != '\0')
9016
(*_bfd_error_handler)
9017
(_("%B: No symbol version section for versioned symbol `%s'"),
9018
flinfo->output_bfd, h->root.root.string);
9019
eoinfo->failed = TRUE;
9024
sym.st_name = h->dynstr_index;
9025
esym = flinfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
9026
if (!check_dynsym (flinfo->output_bfd, &sym))
9028
eoinfo->failed = TRUE;
9031
bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
9033
if (flinfo->hash_sec != NULL)
9035
size_t hash_entry_size;
9036
bfd_byte *bucketpos;
9041
bucketcount = elf_hash_table (flinfo->info)->bucketcount;
9042
bucket = h->u.elf_hash_value % bucketcount;
9045
= elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
9046
bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
9047
+ (bucket + 2) * hash_entry_size);
9048
chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
9049
bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
9051
bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
9052
((bfd_byte *) flinfo->hash_sec->contents
9053
+ (bucketcount + 2 + h->dynindx) * hash_entry_size));
9056
if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
9058
Elf_Internal_Versym iversym;
9059
Elf_External_Versym *eversym;
9061
if (!h->def_regular)
9063
if (h->verinfo.verdef == NULL)
9064
iversym.vs_vers = 0;
9066
iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
9070
if (h->verinfo.vertree == NULL)
9071
iversym.vs_vers = 1;
9073
iversym.vs_vers = h->verinfo.vertree->vernum + 1;
9074
if (flinfo->info->create_default_symver)
9079
iversym.vs_vers |= VERSYM_HIDDEN;
9081
eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
9082
eversym += h->dynindx;
9083
_bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
9087
/* If we're stripping it, then it was just a dynamic symbol, and
9088
there's nothing else to do. */
9089
if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
9092
indx = bfd_get_symcount (flinfo->output_bfd);
9093
ret = elf_link_output_sym (flinfo, h->root.root.string, &sym, input_sec, h);
9096
eoinfo->failed = TRUE;
9101
else if (h->indx == -2)
9107
/* Return TRUE if special handling is done for relocs in SEC against
9108
symbols defined in discarded sections. */
9111
elf_section_ignore_discarded_relocs (asection *sec)
9113
const struct elf_backend_data *bed;
9115
switch (sec->sec_info_type)
9117
case SEC_INFO_TYPE_STABS:
9118
case SEC_INFO_TYPE_EH_FRAME:
9124
bed = get_elf_backend_data (sec->owner);
9125
if (bed->elf_backend_ignore_discarded_relocs != NULL
9126
&& (*bed->elf_backend_ignore_discarded_relocs) (sec))
9132
/* Return a mask saying how ld should treat relocations in SEC against
9133
symbols defined in discarded sections. If this function returns
9134
COMPLAIN set, ld will issue a warning message. If this function
9135
returns PRETEND set, and the discarded section was link-once and the
9136
same size as the kept link-once section, ld will pretend that the
9137
symbol was actually defined in the kept section. Otherwise ld will
9138
zero the reloc (at least that is the intent, but some cooperation by
9139
the target dependent code is needed, particularly for REL targets). */
9142
_bfd_elf_default_action_discarded (asection *sec)
9144
if (sec->flags & SEC_DEBUGGING)
9147
if (strcmp (".eh_frame", sec->name) == 0)
9150
if (strcmp (".gcc_except_table", sec->name) == 0)
9153
return COMPLAIN | PRETEND;
9156
/* Find a match between a section and a member of a section group. */
9159
match_group_member (asection *sec, asection *group,
9160
struct bfd_link_info *info)
9162
asection *first = elf_next_in_group (group);
9163
asection *s = first;
9167
if (bfd_elf_match_symbols_in_sections (s, sec, info))
9170
s = elf_next_in_group (s);
9178
/* Check if the kept section of a discarded section SEC can be used
9179
to replace it. Return the replacement if it is OK. Otherwise return
9183
_bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9187
kept = sec->kept_section;
9190
if ((kept->flags & SEC_GROUP) != 0)
9191
kept = match_group_member (sec, kept, info);
9193
&& ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9194
!= (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9196
sec->kept_section = kept;
9201
/* Link an input file into the linker output file. This function
9202
handles all the sections and relocations of the input file at once.
9203
This is so that we only have to read the local symbols once, and
9204
don't have to keep them in memory. */
9207
elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
9209
int (*relocate_section)
9210
(bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9211
Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9213
Elf_Internal_Shdr *symtab_hdr;
9216
Elf_Internal_Sym *isymbuf;
9217
Elf_Internal_Sym *isym;
9218
Elf_Internal_Sym *isymend;
9220
asection **ppsection;
9222
const struct elf_backend_data *bed;
9223
struct elf_link_hash_entry **sym_hashes;
9224
bfd_size_type address_size;
9225
bfd_vma r_type_mask;
9227
bfd_boolean have_file_sym = FALSE;
9229
output_bfd = flinfo->output_bfd;
9230
bed = get_elf_backend_data (output_bfd);
9231
relocate_section = bed->elf_backend_relocate_section;
9233
/* If this is a dynamic object, we don't want to do anything here:
9234
we don't want the local symbols, and we don't want the section
9236
if ((input_bfd->flags & DYNAMIC) != 0)
9239
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9240
if (elf_bad_symtab (input_bfd))
9242
locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9247
locsymcount = symtab_hdr->sh_info;
9248
extsymoff = symtab_hdr->sh_info;
9251
/* Read the local symbols. */
9252
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9253
if (isymbuf == NULL && locsymcount != 0)
9255
isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9256
flinfo->internal_syms,
9257
flinfo->external_syms,
9258
flinfo->locsym_shndx);
9259
if (isymbuf == NULL)
9263
/* Find local symbol sections and adjust values of symbols in
9264
SEC_MERGE sections. Write out those local symbols we know are
9265
going into the output file. */
9266
isymend = isymbuf + locsymcount;
9267
for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
9269
isym++, pindex++, ppsection++)
9273
Elf_Internal_Sym osym;
9279
if (elf_bad_symtab (input_bfd))
9281
if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9288
if (isym->st_shndx == SHN_UNDEF)
9289
isec = bfd_und_section_ptr;
9290
else if (isym->st_shndx == SHN_ABS)
9291
isec = bfd_abs_section_ptr;
9292
else if (isym->st_shndx == SHN_COMMON)
9293
isec = bfd_com_section_ptr;
9296
isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9299
/* Don't attempt to output symbols with st_shnx in the
9300
reserved range other than SHN_ABS and SHN_COMMON. */
9304
else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
9305
&& ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9307
_bfd_merged_section_offset (output_bfd, &isec,
9308
elf_section_data (isec)->sec_info,
9314
/* Don't output the first, undefined, symbol. */
9315
if (ppsection == flinfo->sections)
9318
if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9320
/* We never output section symbols. Instead, we use the
9321
section symbol of the corresponding section in the output
9326
/* If we are stripping all symbols, we don't want to output this
9328
if (flinfo->info->strip == strip_all)
9331
/* If we are discarding all local symbols, we don't want to
9332
output this one. If we are generating a relocatable output
9333
file, then some of the local symbols may be required by
9334
relocs; we output them below as we discover that they are
9336
if (flinfo->info->discard == discard_all)
9339
/* If this symbol is defined in a section which we are
9340
discarding, we don't need to keep it. */
9341
if (isym->st_shndx != SHN_UNDEF
9342
&& isym->st_shndx < SHN_LORESERVE
9343
&& bfd_section_removed_from_list (output_bfd,
9344
isec->output_section))
9347
/* Get the name of the symbol. */
9348
name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9353
/* See if we are discarding symbols with this name. */
9354
if ((flinfo->info->strip == strip_some
9355
&& (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
9357
|| (((flinfo->info->discard == discard_sec_merge
9358
&& (isec->flags & SEC_MERGE) && !flinfo->info->relocatable)
9359
|| flinfo->info->discard == discard_l)
9360
&& bfd_is_local_label_name (input_bfd, name)))
9363
if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
9365
have_file_sym = TRUE;
9366
flinfo->filesym_count += 1;
9370
/* In the absence of debug info, bfd_find_nearest_line uses
9371
FILE symbols to determine the source file for local
9372
function symbols. Provide a FILE symbol here if input
9373
files lack such, so that their symbols won't be
9374
associated with a previous input file. It's not the
9375
source file, but the best we can do. */
9376
have_file_sym = TRUE;
9377
flinfo->filesym_count += 1;
9378
memset (&osym, 0, sizeof (osym));
9379
osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9380
osym.st_shndx = SHN_ABS;
9381
if (!elf_link_output_sym (flinfo, input_bfd->filename, &osym,
9382
bfd_abs_section_ptr, NULL))
9388
/* Adjust the section index for the output file. */
9389
osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9390
isec->output_section);
9391
if (osym.st_shndx == SHN_BAD)
9394
/* ELF symbols in relocatable files are section relative, but
9395
in executable files they are virtual addresses. Note that
9396
this code assumes that all ELF sections have an associated
9397
BFD section with a reasonable value for output_offset; below
9398
we assume that they also have a reasonable value for
9399
output_section. Any special sections must be set up to meet
9400
these requirements. */
9401
osym.st_value += isec->output_offset;
9402
if (!flinfo->info->relocatable)
9404
osym.st_value += isec->output_section->vma;
9405
if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9407
/* STT_TLS symbols are relative to PT_TLS segment base. */
9408
BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
9409
osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
9413
indx = bfd_get_symcount (output_bfd);
9414
ret = elf_link_output_sym (flinfo, name, &osym, isec, NULL);
9421
if (bed->s->arch_size == 32)
9429
r_type_mask = 0xffffffff;
9434
/* Relocate the contents of each section. */
9435
sym_hashes = elf_sym_hashes (input_bfd);
9436
for (o = input_bfd->sections; o != NULL; o = o->next)
9440
if (! o->linker_mark)
9442
/* This section was omitted from the link. */
9446
if (flinfo->info->relocatable
9447
&& (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9449
/* Deal with the group signature symbol. */
9450
struct bfd_elf_section_data *sec_data = elf_section_data (o);
9451
unsigned long symndx = sec_data->this_hdr.sh_info;
9452
asection *osec = o->output_section;
9454
if (symndx >= locsymcount
9455
|| (elf_bad_symtab (input_bfd)
9456
&& flinfo->sections[symndx] == NULL))
9458
struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9459
while (h->root.type == bfd_link_hash_indirect
9460
|| h->root.type == bfd_link_hash_warning)
9461
h = (struct elf_link_hash_entry *) h->root.u.i.link;
9462
/* Arrange for symbol to be output. */
9464
elf_section_data (osec)->this_hdr.sh_info = -2;
9466
else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9468
/* We'll use the output section target_index. */
9469
asection *sec = flinfo->sections[symndx]->output_section;
9470
elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9474
if (flinfo->indices[symndx] == -1)
9476
/* Otherwise output the local symbol now. */
9477
Elf_Internal_Sym sym = isymbuf[symndx];
9478
asection *sec = flinfo->sections[symndx]->output_section;
9483
name = bfd_elf_string_from_elf_section (input_bfd,
9484
symtab_hdr->sh_link,
9489
sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9491
if (sym.st_shndx == SHN_BAD)
9494
sym.st_value += o->output_offset;
9496
indx = bfd_get_symcount (output_bfd);
9497
ret = elf_link_output_sym (flinfo, name, &sym, o, NULL);
9501
flinfo->indices[symndx] = indx;
9505
elf_section_data (osec)->this_hdr.sh_info
9506
= flinfo->indices[symndx];
9510
if ((o->flags & SEC_HAS_CONTENTS) == 0
9511
|| (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9514
if ((o->flags & SEC_LINKER_CREATED) != 0)
9516
/* Section was created by _bfd_elf_link_create_dynamic_sections
9521
/* Get the contents of the section. They have been cached by a
9522
relaxation routine. Note that o is a section in an input
9523
file, so the contents field will not have been set by any of
9524
the routines which work on output files. */
9525
if (elf_section_data (o)->this_hdr.contents != NULL)
9526
contents = elf_section_data (o)->this_hdr.contents;
9529
contents = flinfo->contents;
9530
if (! bfd_get_full_section_contents (input_bfd, o, &contents))
9534
if ((o->flags & SEC_RELOC) != 0)
9536
Elf_Internal_Rela *internal_relocs;
9537
Elf_Internal_Rela *rel, *relend;
9538
int action_discarded;
9541
/* Get the swapped relocs. */
9543
= _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
9544
flinfo->internal_relocs, FALSE);
9545
if (internal_relocs == NULL
9546
&& o->reloc_count > 0)
9549
/* We need to reverse-copy input .ctors/.dtors sections if
9550
they are placed in .init_array/.finit_array for output. */
9551
if (o->size > address_size
9552
&& ((strncmp (o->name, ".ctors", 6) == 0
9553
&& strcmp (o->output_section->name,
9554
".init_array") == 0)
9555
|| (strncmp (o->name, ".dtors", 6) == 0
9556
&& strcmp (o->output_section->name,
9557
".fini_array") == 0))
9558
&& (o->name[6] == 0 || o->name[6] == '.'))
9560
if (o->size != o->reloc_count * address_size)
9562
(*_bfd_error_handler)
9563
(_("error: %B: size of section %A is not "
9564
"multiple of address size"),
9566
bfd_set_error (bfd_error_on_input);
9569
o->flags |= SEC_ELF_REVERSE_COPY;
9572
action_discarded = -1;
9573
if (!elf_section_ignore_discarded_relocs (o))
9574
action_discarded = (*bed->action_discarded) (o);
9576
/* Run through the relocs evaluating complex reloc symbols and
9577
looking for relocs against symbols from discarded sections
9578
or section symbols from removed link-once sections.
9579
Complain about relocs against discarded sections. Zero
9580
relocs against removed link-once sections. */
9582
rel = internal_relocs;
9583
relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9584
for ( ; rel < relend; rel++)
9586
unsigned long r_symndx = rel->r_info >> r_sym_shift;
9587
unsigned int s_type;
9588
asection **ps, *sec;
9589
struct elf_link_hash_entry *h = NULL;
9590
const char *sym_name;
9592
if (r_symndx == STN_UNDEF)
9595
if (r_symndx >= locsymcount
9596
|| (elf_bad_symtab (input_bfd)
9597
&& flinfo->sections[r_symndx] == NULL))
9599
h = sym_hashes[r_symndx - extsymoff];
9601
/* Badly formatted input files can contain relocs that
9602
reference non-existant symbols. Check here so that
9603
we do not seg fault. */
9608
sprintf_vma (buffer, rel->r_info);
9609
(*_bfd_error_handler)
9610
(_("error: %B contains a reloc (0x%s) for section %A "
9611
"that references a non-existent global symbol"),
9612
input_bfd, o, buffer);
9613
bfd_set_error (bfd_error_bad_value);
9617
while (h->root.type == bfd_link_hash_indirect
9618
|| h->root.type == bfd_link_hash_warning)
9619
h = (struct elf_link_hash_entry *) h->root.u.i.link;
9624
if (h->root.type == bfd_link_hash_defined
9625
|| h->root.type == bfd_link_hash_defweak)
9626
ps = &h->root.u.def.section;
9628
sym_name = h->root.root.string;
9632
Elf_Internal_Sym *sym = isymbuf + r_symndx;
9634
s_type = ELF_ST_TYPE (sym->st_info);
9635
ps = &flinfo->sections[r_symndx];
9636
sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9640
if ((s_type == STT_RELC || s_type == STT_SRELC)
9641
&& !flinfo->info->relocatable)
9644
bfd_vma dot = (rel->r_offset
9645
+ o->output_offset + o->output_section->vma);
9647
printf ("Encountered a complex symbol!");
9648
printf (" (input_bfd %s, section %s, reloc %ld\n",
9649
input_bfd->filename, o->name,
9650
(long) (rel - internal_relocs));
9651
printf (" symbol: idx %8.8lx, name %s\n",
9652
r_symndx, sym_name);
9653
printf (" reloc : info %8.8lx, addr %8.8lx\n",
9654
(unsigned long) rel->r_info,
9655
(unsigned long) rel->r_offset);
9657
if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
9658
isymbuf, locsymcount, s_type == STT_SRELC))
9661
/* Symbol evaluated OK. Update to absolute value. */
9662
set_symbol_value (input_bfd, isymbuf, locsymcount,
9667
if (action_discarded != -1 && ps != NULL)
9669
/* Complain if the definition comes from a
9670
discarded section. */
9671
if ((sec = *ps) != NULL && discarded_section (sec))
9673
BFD_ASSERT (r_symndx != STN_UNDEF);
9674
if (action_discarded & COMPLAIN)
9675
(*flinfo->info->callbacks->einfo)
9676
(_("%X`%s' referenced in section `%A' of %B: "
9677
"defined in discarded section `%A' of %B\n"),
9678
sym_name, o, input_bfd, sec, sec->owner);
9680
/* Try to do the best we can to support buggy old
9681
versions of gcc. Pretend that the symbol is
9682
really defined in the kept linkonce section.
9683
FIXME: This is quite broken. Modifying the
9684
symbol here means we will be changing all later
9685
uses of the symbol, not just in this section. */
9686
if (action_discarded & PRETEND)
9690
kept = _bfd_elf_check_kept_section (sec,
9702
/* Relocate the section by invoking a back end routine.
9704
The back end routine is responsible for adjusting the
9705
section contents as necessary, and (if using Rela relocs
9706
and generating a relocatable output file) adjusting the
9707
reloc addend as necessary.
9709
The back end routine does not have to worry about setting
9710
the reloc address or the reloc symbol index.
9712
The back end routine is given a pointer to the swapped in
9713
internal symbols, and can access the hash table entries
9714
for the external symbols via elf_sym_hashes (input_bfd).
9716
When generating relocatable output, the back end routine
9717
must handle STB_LOCAL/STT_SECTION symbols specially. The
9718
output symbol is going to be a section symbol
9719
corresponding to the output section, which will require
9720
the addend to be adjusted. */
9722
ret = (*relocate_section) (output_bfd, flinfo->info,
9723
input_bfd, o, contents,
9731
|| flinfo->info->relocatable
9732
|| flinfo->info->emitrelocations)
9734
Elf_Internal_Rela *irela;
9735
Elf_Internal_Rela *irelaend, *irelamid;
9736
bfd_vma last_offset;
9737
struct elf_link_hash_entry **rel_hash;
9738
struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9739
Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9740
unsigned int next_erel;
9741
bfd_boolean rela_normal;
9742
struct bfd_elf_section_data *esdi, *esdo;
9744
esdi = elf_section_data (o);
9745
esdo = elf_section_data (o->output_section);
9746
rela_normal = FALSE;
9748
/* Adjust the reloc addresses and symbol indices. */
9750
irela = internal_relocs;
9751
irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9752
rel_hash = esdo->rel.hashes + esdo->rel.count;
9753
/* We start processing the REL relocs, if any. When we reach
9754
IRELAMID in the loop, we switch to the RELA relocs. */
9756
if (esdi->rel.hdr != NULL)
9757
irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9758
* bed->s->int_rels_per_ext_rel);
9759
rel_hash_list = rel_hash;
9760
rela_hash_list = NULL;
9761
last_offset = o->output_offset;
9762
if (!flinfo->info->relocatable)
9763
last_offset += o->output_section->vma;
9764
for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9766
unsigned long r_symndx;
9768
Elf_Internal_Sym sym;
9770
if (next_erel == bed->s->int_rels_per_ext_rel)
9776
if (irela == irelamid)
9778
rel_hash = esdo->rela.hashes + esdo->rela.count;
9779
rela_hash_list = rel_hash;
9780
rela_normal = bed->rela_normal;
9783
irela->r_offset = _bfd_elf_section_offset (output_bfd,
9786
if (irela->r_offset >= (bfd_vma) -2)
9788
/* This is a reloc for a deleted entry or somesuch.
9789
Turn it into an R_*_NONE reloc, at the same
9790
offset as the last reloc. elf_eh_frame.c and
9791
bfd_elf_discard_info rely on reloc offsets
9793
irela->r_offset = last_offset;
9795
irela->r_addend = 0;
9799
irela->r_offset += o->output_offset;
9801
/* Relocs in an executable have to be virtual addresses. */
9802
if (!flinfo->info->relocatable)
9803
irela->r_offset += o->output_section->vma;
9805
last_offset = irela->r_offset;
9807
r_symndx = irela->r_info >> r_sym_shift;
9808
if (r_symndx == STN_UNDEF)
9811
if (r_symndx >= locsymcount
9812
|| (elf_bad_symtab (input_bfd)
9813
&& flinfo->sections[r_symndx] == NULL))
9815
struct elf_link_hash_entry *rh;
9818
/* This is a reloc against a global symbol. We
9819
have not yet output all the local symbols, so
9820
we do not know the symbol index of any global
9821
symbol. We set the rel_hash entry for this
9822
reloc to point to the global hash table entry
9823
for this symbol. The symbol index is then
9824
set at the end of bfd_elf_final_link. */
9825
indx = r_symndx - extsymoff;
9826
rh = elf_sym_hashes (input_bfd)[indx];
9827
while (rh->root.type == bfd_link_hash_indirect
9828
|| rh->root.type == bfd_link_hash_warning)
9829
rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
9831
/* Setting the index to -2 tells
9832
elf_link_output_extsym that this symbol is
9834
BFD_ASSERT (rh->indx < 0);
9842
/* This is a reloc against a local symbol. */
9845
sym = isymbuf[r_symndx];
9846
sec = flinfo->sections[r_symndx];
9847
if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
9849
/* I suppose the backend ought to fill in the
9850
section of any STT_SECTION symbol against a
9851
processor specific section. */
9852
r_symndx = STN_UNDEF;
9853
if (bfd_is_abs_section (sec))
9855
else if (sec == NULL || sec->owner == NULL)
9857
bfd_set_error (bfd_error_bad_value);
9862
asection *osec = sec->output_section;
9864
/* If we have discarded a section, the output
9865
section will be the absolute section. In
9866
case of discarded SEC_MERGE sections, use
9867
the kept section. relocate_section should
9868
have already handled discarded linkonce
9870
if (bfd_is_abs_section (osec)
9871
&& sec->kept_section != NULL
9872
&& sec->kept_section->output_section != NULL)
9874
osec = sec->kept_section->output_section;
9875
irela->r_addend -= osec->vma;
9878
if (!bfd_is_abs_section (osec))
9880
r_symndx = osec->target_index;
9881
if (r_symndx == STN_UNDEF)
9883
irela->r_addend += osec->vma;
9884
osec = _bfd_nearby_section (output_bfd, osec,
9886
irela->r_addend -= osec->vma;
9887
r_symndx = osec->target_index;
9892
/* Adjust the addend according to where the
9893
section winds up in the output section. */
9895
irela->r_addend += sec->output_offset;
9899
if (flinfo->indices[r_symndx] == -1)
9901
unsigned long shlink;
9906
if (flinfo->info->strip == strip_all)
9908
/* You can't do ld -r -s. */
9909
bfd_set_error (bfd_error_invalid_operation);
9913
/* This symbol was skipped earlier, but
9914
since it is needed by a reloc, we
9915
must output it now. */
9916
shlink = symtab_hdr->sh_link;
9917
name = (bfd_elf_string_from_elf_section
9918
(input_bfd, shlink, sym.st_name));
9922
osec = sec->output_section;
9924
_bfd_elf_section_from_bfd_section (output_bfd,
9926
if (sym.st_shndx == SHN_BAD)
9929
sym.st_value += sec->output_offset;
9930
if (!flinfo->info->relocatable)
9932
sym.st_value += osec->vma;
9933
if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
9935
/* STT_TLS symbols are relative to PT_TLS
9937
BFD_ASSERT (elf_hash_table (flinfo->info)
9939
sym.st_value -= (elf_hash_table (flinfo->info)
9944
indx = bfd_get_symcount (output_bfd);
9945
ret = elf_link_output_sym (flinfo, name, &sym, sec,
9950
flinfo->indices[r_symndx] = indx;
9955
r_symndx = flinfo->indices[r_symndx];
9958
irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
9959
| (irela->r_info & r_type_mask));
9962
/* Swap out the relocs. */
9963
input_rel_hdr = esdi->rel.hdr;
9964
if (input_rel_hdr && input_rel_hdr->sh_size != 0)
9966
if (!bed->elf_backend_emit_relocs (output_bfd, o,
9971
internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
9972
* bed->s->int_rels_per_ext_rel);
9973
rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
9976
input_rela_hdr = esdi->rela.hdr;
9977
if (input_rela_hdr && input_rela_hdr->sh_size != 0)
9979
if (!bed->elf_backend_emit_relocs (output_bfd, o,
9988
/* Write out the modified section contents. */
9989
if (bed->elf_backend_write_section
9990
&& (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
9993
/* Section written out. */
9995
else switch (o->sec_info_type)
9997
case SEC_INFO_TYPE_STABS:
9998
if (! (_bfd_write_section_stabs
10000
&elf_hash_table (flinfo->info)->stab_info,
10001
o, &elf_section_data (o)->sec_info, contents)))
10004
case SEC_INFO_TYPE_MERGE:
10005
if (! _bfd_write_merged_section (output_bfd, o,
10006
elf_section_data (o)->sec_info))
10009
case SEC_INFO_TYPE_EH_FRAME:
10011
if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10018
/* FIXME: octets_per_byte. */
10019
if (! (o->flags & SEC_EXCLUDE))
10021
file_ptr offset = (file_ptr) o->output_offset;
10022
bfd_size_type todo = o->size;
10023
if ((o->flags & SEC_ELF_REVERSE_COPY))
10025
/* Reverse-copy input section to output. */
10028
todo -= address_size;
10029
if (! bfd_set_section_contents (output_bfd,
10037
offset += address_size;
10041
else if (! bfd_set_section_contents (output_bfd,
10055
/* Generate a reloc when linking an ELF file. This is a reloc
10056
requested by the linker, and does not come from any input file. This
10057
is used to build constructor and destructor tables when linking
10061
elf_reloc_link_order (bfd *output_bfd,
10062
struct bfd_link_info *info,
10063
asection *output_section,
10064
struct bfd_link_order *link_order)
10066
reloc_howto_type *howto;
10070
struct bfd_elf_section_reloc_data *reldata;
10071
struct elf_link_hash_entry **rel_hash_ptr;
10072
Elf_Internal_Shdr *rel_hdr;
10073
const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10074
Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10077
struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10079
howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10082
bfd_set_error (bfd_error_bad_value);
10086
addend = link_order->u.reloc.p->addend;
10089
reldata = &esdo->rel;
10090
else if (esdo->rela.hdr)
10091
reldata = &esdo->rela;
10098
/* Figure out the symbol index. */
10099
rel_hash_ptr = reldata->hashes + reldata->count;
10100
if (link_order->type == bfd_section_reloc_link_order)
10102
indx = link_order->u.reloc.p->u.section->target_index;
10103
BFD_ASSERT (indx != 0);
10104
*rel_hash_ptr = NULL;
10108
struct elf_link_hash_entry *h;
10110
/* Treat a reloc against a defined symbol as though it were
10111
actually against the section. */
10112
h = ((struct elf_link_hash_entry *)
10113
bfd_wrapped_link_hash_lookup (output_bfd, info,
10114
link_order->u.reloc.p->u.name,
10115
FALSE, FALSE, TRUE));
10117
&& (h->root.type == bfd_link_hash_defined
10118
|| h->root.type == bfd_link_hash_defweak))
10122
section = h->root.u.def.section;
10123
indx = section->output_section->target_index;
10124
*rel_hash_ptr = NULL;
10125
/* It seems that we ought to add the symbol value to the
10126
addend here, but in practice it has already been added
10127
because it was passed to constructor_callback. */
10128
addend += section->output_section->vma + section->output_offset;
10130
else if (h != NULL)
10132
/* Setting the index to -2 tells elf_link_output_extsym that
10133
this symbol is used by a reloc. */
10140
if (! ((*info->callbacks->unattached_reloc)
10141
(info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10147
/* If this is an inplace reloc, we must write the addend into the
10149
if (howto->partial_inplace && addend != 0)
10151
bfd_size_type size;
10152
bfd_reloc_status_type rstat;
10155
const char *sym_name;
10157
size = (bfd_size_type) bfd_get_reloc_size (howto);
10158
buf = (bfd_byte *) bfd_zmalloc (size);
10161
rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10168
case bfd_reloc_outofrange:
10171
case bfd_reloc_overflow:
10172
if (link_order->type == bfd_section_reloc_link_order)
10173
sym_name = bfd_section_name (output_bfd,
10174
link_order->u.reloc.p->u.section);
10176
sym_name = link_order->u.reloc.p->u.name;
10177
if (! ((*info->callbacks->reloc_overflow)
10178
(info, NULL, sym_name, howto->name, addend, NULL,
10179
NULL, (bfd_vma) 0)))
10186
ok = bfd_set_section_contents (output_bfd, output_section, buf,
10187
link_order->offset, size);
10193
/* The address of a reloc is relative to the section in a
10194
relocatable file, and is a virtual address in an executable
10196
offset = link_order->offset;
10197
if (! info->relocatable)
10198
offset += output_section->vma;
10200
for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10202
irel[i].r_offset = offset;
10203
irel[i].r_info = 0;
10204
irel[i].r_addend = 0;
10206
if (bed->s->arch_size == 32)
10207
irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10209
irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10211
rel_hdr = reldata->hdr;
10212
erel = rel_hdr->contents;
10213
if (rel_hdr->sh_type == SHT_REL)
10215
erel += reldata->count * bed->s->sizeof_rel;
10216
(*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10220
irel[0].r_addend = addend;
10221
erel += reldata->count * bed->s->sizeof_rela;
10222
(*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10231
/* Get the output vma of the section pointed to by the sh_link field. */
10234
elf_get_linked_section_vma (struct bfd_link_order *p)
10236
Elf_Internal_Shdr **elf_shdrp;
10240
s = p->u.indirect.section;
10241
elf_shdrp = elf_elfsections (s->owner);
10242
elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10243
elfsec = elf_shdrp[elfsec]->sh_link;
10245
The Intel C compiler generates SHT_IA_64_UNWIND with
10246
SHF_LINK_ORDER. But it doesn't set the sh_link or
10247
sh_info fields. Hence we could get the situation
10248
where elfsec is 0. */
10251
const struct elf_backend_data *bed
10252
= get_elf_backend_data (s->owner);
10253
if (bed->link_order_error_handler)
10254
bed->link_order_error_handler
10255
(_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10260
s = elf_shdrp[elfsec]->bfd_section;
10261
return s->output_section->vma + s->output_offset;
10266
/* Compare two sections based on the locations of the sections they are
10267
linked to. Used by elf_fixup_link_order. */
10270
compare_link_order (const void * a, const void * b)
10275
apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10276
bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10279
return apos > bpos;
10283
/* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
10284
order as their linked sections. Returns false if this could not be done
10285
because an output section includes both ordered and unordered
10286
sections. Ideally we'd do this in the linker proper. */
10289
elf_fixup_link_order (bfd *abfd, asection *o)
10291
int seen_linkorder;
10294
struct bfd_link_order *p;
10296
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10298
struct bfd_link_order **sections;
10299
asection *s, *other_sec, *linkorder_sec;
10303
linkorder_sec = NULL;
10305
seen_linkorder = 0;
10306
for (p = o->map_head.link_order; p != NULL; p = p->next)
10308
if (p->type == bfd_indirect_link_order)
10310
s = p->u.indirect.section;
10312
if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10313
&& elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10314
&& (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10315
&& elfsec < elf_numsections (sub)
10316
&& elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10317
&& elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10331
if (seen_other && seen_linkorder)
10333
if (other_sec && linkorder_sec)
10334
(*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10336
linkorder_sec->owner, other_sec,
10339
(*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10341
bfd_set_error (bfd_error_bad_value);
10346
if (!seen_linkorder)
10349
sections = (struct bfd_link_order **)
10350
bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10351
if (sections == NULL)
10353
seen_linkorder = 0;
10355
for (p = o->map_head.link_order; p != NULL; p = p->next)
10357
sections[seen_linkorder++] = p;
10359
/* Sort the input sections in the order of their linked section. */
10360
qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10361
compare_link_order);
10363
/* Change the offsets of the sections. */
10365
for (n = 0; n < seen_linkorder; n++)
10367
s = sections[n]->u.indirect.section;
10368
offset &= ~(bfd_vma) 0 << s->alignment_power;
10369
s->output_offset = offset;
10370
sections[n]->offset = offset;
10371
/* FIXME: octets_per_byte. */
10372
offset += sections[n]->size;
10380
elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
10384
if (flinfo->symstrtab != NULL)
10385
_bfd_stringtab_free (flinfo->symstrtab);
10386
if (flinfo->contents != NULL)
10387
free (flinfo->contents);
10388
if (flinfo->external_relocs != NULL)
10389
free (flinfo->external_relocs);
10390
if (flinfo->internal_relocs != NULL)
10391
free (flinfo->internal_relocs);
10392
if (flinfo->external_syms != NULL)
10393
free (flinfo->external_syms);
10394
if (flinfo->locsym_shndx != NULL)
10395
free (flinfo->locsym_shndx);
10396
if (flinfo->internal_syms != NULL)
10397
free (flinfo->internal_syms);
10398
if (flinfo->indices != NULL)
10399
free (flinfo->indices);
10400
if (flinfo->sections != NULL)
10401
free (flinfo->sections);
10402
if (flinfo->symbuf != NULL)
10403
free (flinfo->symbuf);
10404
if (flinfo->symshndxbuf != NULL)
10405
free (flinfo->symshndxbuf);
10406
for (o = obfd->sections; o != NULL; o = o->next)
10408
struct bfd_elf_section_data *esdo = elf_section_data (o);
10409
if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
10410
free (esdo->rel.hashes);
10411
if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
10412
free (esdo->rela.hashes);
10416
/* Do the final step of an ELF link. */
10419
bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10421
bfd_boolean dynamic;
10422
bfd_boolean emit_relocs;
10424
struct elf_final_link_info flinfo;
10426
struct bfd_link_order *p;
10428
bfd_size_type max_contents_size;
10429
bfd_size_type max_external_reloc_size;
10430
bfd_size_type max_internal_reloc_count;
10431
bfd_size_type max_sym_count;
10432
bfd_size_type max_sym_shndx_count;
10434
Elf_Internal_Sym elfsym;
10436
Elf_Internal_Shdr *symtab_hdr;
10437
Elf_Internal_Shdr *symtab_shndx_hdr;
10438
Elf_Internal_Shdr *symstrtab_hdr;
10439
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10440
struct elf_outext_info eoinfo;
10441
bfd_boolean merged;
10442
size_t relativecount = 0;
10443
asection *reldyn = 0;
10445
asection *attr_section = NULL;
10446
bfd_vma attr_size = 0;
10447
const char *std_attrs_section;
10449
if (! is_elf_hash_table (info->hash))
10453
abfd->flags |= DYNAMIC;
10455
dynamic = elf_hash_table (info)->dynamic_sections_created;
10456
dynobj = elf_hash_table (info)->dynobj;
10458
emit_relocs = (info->relocatable
10459
|| info->emitrelocations);
10461
flinfo.info = info;
10462
flinfo.output_bfd = abfd;
10463
flinfo.symstrtab = _bfd_elf_stringtab_init ();
10464
if (flinfo.symstrtab == NULL)
10469
flinfo.dynsym_sec = NULL;
10470
flinfo.hash_sec = NULL;
10471
flinfo.symver_sec = NULL;
10475
flinfo.dynsym_sec = bfd_get_linker_section (dynobj, ".dynsym");
10476
flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
10477
/* Note that dynsym_sec can be NULL (on VMS). */
10478
flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
10479
/* Note that it is OK if symver_sec is NULL. */
10482
flinfo.contents = NULL;
10483
flinfo.external_relocs = NULL;
10484
flinfo.internal_relocs = NULL;
10485
flinfo.external_syms = NULL;
10486
flinfo.locsym_shndx = NULL;
10487
flinfo.internal_syms = NULL;
10488
flinfo.indices = NULL;
10489
flinfo.sections = NULL;
10490
flinfo.symbuf = NULL;
10491
flinfo.symshndxbuf = NULL;
10492
flinfo.symbuf_count = 0;
10493
flinfo.shndxbuf_size = 0;
10494
flinfo.filesym_count = 0;
10496
/* The object attributes have been merged. Remove the input
10497
sections from the link, and set the contents of the output
10499
std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10500
for (o = abfd->sections; o != NULL; o = o->next)
10502
if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10503
|| strcmp (o->name, ".gnu.attributes") == 0)
10505
for (p = o->map_head.link_order; p != NULL; p = p->next)
10507
asection *input_section;
10509
if (p->type != bfd_indirect_link_order)
10511
input_section = p->u.indirect.section;
10512
/* Hack: reset the SEC_HAS_CONTENTS flag so that
10513
elf_link_input_bfd ignores this section. */
10514
input_section->flags &= ~SEC_HAS_CONTENTS;
10517
attr_size = bfd_elf_obj_attr_size (abfd);
10520
bfd_set_section_size (abfd, o, attr_size);
10522
/* Skip this section later on. */
10523
o->map_head.link_order = NULL;
10526
o->flags |= SEC_EXCLUDE;
10530
/* Count up the number of relocations we will output for each output
10531
section, so that we know the sizes of the reloc sections. We
10532
also figure out some maximum sizes. */
10533
max_contents_size = 0;
10534
max_external_reloc_size = 0;
10535
max_internal_reloc_count = 0;
10537
max_sym_shndx_count = 0;
10539
for (o = abfd->sections; o != NULL; o = o->next)
10541
struct bfd_elf_section_data *esdo = elf_section_data (o);
10542
o->reloc_count = 0;
10544
for (p = o->map_head.link_order; p != NULL; p = p->next)
10546
unsigned int reloc_count = 0;
10547
struct bfd_elf_section_data *esdi = NULL;
10549
if (p->type == bfd_section_reloc_link_order
10550
|| p->type == bfd_symbol_reloc_link_order)
10552
else if (p->type == bfd_indirect_link_order)
10556
sec = p->u.indirect.section;
10557
esdi = elf_section_data (sec);
10559
/* Mark all sections which are to be included in the
10560
link. This will normally be every section. We need
10561
to do this so that we can identify any sections which
10562
the linker has decided to not include. */
10563
sec->linker_mark = TRUE;
10565
if (sec->flags & SEC_MERGE)
10568
if (esdo->this_hdr.sh_type == SHT_REL
10569
|| esdo->this_hdr.sh_type == SHT_RELA)
10570
/* Some backends use reloc_count in relocation sections
10571
to count particular types of relocs. Of course,
10572
reloc sections themselves can't have relocations. */
10574
else if (info->relocatable || info->emitrelocations)
10575
reloc_count = sec->reloc_count;
10576
else if (bed->elf_backend_count_relocs)
10577
reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10579
if (sec->rawsize > max_contents_size)
10580
max_contents_size = sec->rawsize;
10581
if (sec->size > max_contents_size)
10582
max_contents_size = sec->size;
10584
/* We are interested in just local symbols, not all
10586
if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10587
&& (sec->owner->flags & DYNAMIC) == 0)
10591
if (elf_bad_symtab (sec->owner))
10592
sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10593
/ bed->s->sizeof_sym);
10595
sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10597
if (sym_count > max_sym_count)
10598
max_sym_count = sym_count;
10600
if (sym_count > max_sym_shndx_count
10601
&& elf_symtab_shndx (sec->owner) != 0)
10602
max_sym_shndx_count = sym_count;
10604
if ((sec->flags & SEC_RELOC) != 0)
10606
size_t ext_size = 0;
10608
if (esdi->rel.hdr != NULL)
10609
ext_size = esdi->rel.hdr->sh_size;
10610
if (esdi->rela.hdr != NULL)
10611
ext_size += esdi->rela.hdr->sh_size;
10613
if (ext_size > max_external_reloc_size)
10614
max_external_reloc_size = ext_size;
10615
if (sec->reloc_count > max_internal_reloc_count)
10616
max_internal_reloc_count = sec->reloc_count;
10621
if (reloc_count == 0)
10624
o->reloc_count += reloc_count;
10626
if (p->type == bfd_indirect_link_order
10627
&& (info->relocatable || info->emitrelocations))
10630
esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10631
if (esdi->rela.hdr)
10632
esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10637
esdo->rela.count += reloc_count;
10639
esdo->rel.count += reloc_count;
10643
if (o->reloc_count > 0)
10644
o->flags |= SEC_RELOC;
10647
/* Explicitly clear the SEC_RELOC flag. The linker tends to
10648
set it (this is probably a bug) and if it is set
10649
assign_section_numbers will create a reloc section. */
10650
o->flags &=~ SEC_RELOC;
10653
/* If the SEC_ALLOC flag is not set, force the section VMA to
10654
zero. This is done in elf_fake_sections as well, but forcing
10655
the VMA to 0 here will ensure that relocs against these
10656
sections are handled correctly. */
10657
if ((o->flags & SEC_ALLOC) == 0
10658
&& ! o->user_set_vma)
10662
if (! info->relocatable && merged)
10663
elf_link_hash_traverse (elf_hash_table (info),
10664
_bfd_elf_link_sec_merge_syms, abfd);
10666
/* Figure out the file positions for everything but the symbol table
10667
and the relocs. We set symcount to force assign_section_numbers
10668
to create a symbol table. */
10669
bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
10670
BFD_ASSERT (! abfd->output_has_begun);
10671
if (! _bfd_elf_compute_section_file_positions (abfd, info))
10674
/* Set sizes, and assign file positions for reloc sections. */
10675
for (o = abfd->sections; o != NULL; o = o->next)
10677
struct bfd_elf_section_data *esdo = elf_section_data (o);
10678
if ((o->flags & SEC_RELOC) != 0)
10681
&& !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10685
&& !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10689
/* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10690
to count upwards while actually outputting the relocations. */
10691
esdo->rel.count = 0;
10692
esdo->rela.count = 0;
10695
_bfd_elf_assign_file_positions_for_relocs (abfd);
10697
/* We have now assigned file positions for all the sections except
10698
.symtab and .strtab. We start the .symtab section at the current
10699
file position, and write directly to it. We build the .strtab
10700
section in memory. */
10701
bfd_get_symcount (abfd) = 0;
10702
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10703
/* sh_name is set in prep_headers. */
10704
symtab_hdr->sh_type = SHT_SYMTAB;
10705
/* sh_flags, sh_addr and sh_size all start off zero. */
10706
symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10707
/* sh_link is set in assign_section_numbers. */
10708
/* sh_info is set below. */
10709
/* sh_offset is set just below. */
10710
symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10712
off = elf_next_file_pos (abfd);
10713
off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10715
/* Note that at this point elf_next_file_pos (abfd) is
10716
incorrect. We do not yet know the size of the .symtab section.
10717
We correct next_file_pos below, after we do know the size. */
10719
/* Allocate a buffer to hold swapped out symbols. This is to avoid
10720
continuously seeking to the right position in the file. */
10721
if (! info->keep_memory || max_sym_count < 20)
10722
flinfo.symbuf_size = 20;
10724
flinfo.symbuf_size = max_sym_count;
10725
amt = flinfo.symbuf_size;
10726
amt *= bed->s->sizeof_sym;
10727
flinfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10728
if (flinfo.symbuf == NULL)
10730
if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10732
/* Wild guess at number of output symbols. realloc'd as needed. */
10733
amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10734
flinfo.shndxbuf_size = amt;
10735
amt *= sizeof (Elf_External_Sym_Shndx);
10736
flinfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10737
if (flinfo.symshndxbuf == NULL)
10741
/* Start writing out the symbol table. The first symbol is always a
10743
if (info->strip != strip_all
10746
elfsym.st_value = 0;
10747
elfsym.st_size = 0;
10748
elfsym.st_info = 0;
10749
elfsym.st_other = 0;
10750
elfsym.st_shndx = SHN_UNDEF;
10751
elfsym.st_target_internal = 0;
10752
if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
10757
/* Output a symbol for each section. We output these even if we are
10758
discarding local symbols, since they are used for relocs. These
10759
symbols have no names. We store the index of each one in the
10760
index field of the section, so that we can find it again when
10761
outputting relocs. */
10762
if (info->strip != strip_all
10765
elfsym.st_size = 0;
10766
elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10767
elfsym.st_other = 0;
10768
elfsym.st_value = 0;
10769
elfsym.st_target_internal = 0;
10770
for (i = 1; i < elf_numsections (abfd); i++)
10772
o = bfd_section_from_elf_index (abfd, i);
10775
o->target_index = bfd_get_symcount (abfd);
10776
elfsym.st_shndx = i;
10777
if (!info->relocatable)
10778
elfsym.st_value = o->vma;
10779
if (elf_link_output_sym (&flinfo, NULL, &elfsym, o, NULL) != 1)
10785
/* Allocate some memory to hold information read in from the input
10787
if (max_contents_size != 0)
10789
flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10790
if (flinfo.contents == NULL)
10794
if (max_external_reloc_size != 0)
10796
flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
10797
if (flinfo.external_relocs == NULL)
10801
if (max_internal_reloc_count != 0)
10803
amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10804
amt *= sizeof (Elf_Internal_Rela);
10805
flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10806
if (flinfo.internal_relocs == NULL)
10810
if (max_sym_count != 0)
10812
amt = max_sym_count * bed->s->sizeof_sym;
10813
flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10814
if (flinfo.external_syms == NULL)
10817
amt = max_sym_count * sizeof (Elf_Internal_Sym);
10818
flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10819
if (flinfo.internal_syms == NULL)
10822
amt = max_sym_count * sizeof (long);
10823
flinfo.indices = (long int *) bfd_malloc (amt);
10824
if (flinfo.indices == NULL)
10827
amt = max_sym_count * sizeof (asection *);
10828
flinfo.sections = (asection **) bfd_malloc (amt);
10829
if (flinfo.sections == NULL)
10833
if (max_sym_shndx_count != 0)
10835
amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
10836
flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
10837
if (flinfo.locsym_shndx == NULL)
10841
if (elf_hash_table (info)->tls_sec)
10843
bfd_vma base, end = 0;
10846
for (sec = elf_hash_table (info)->tls_sec;
10847
sec && (sec->flags & SEC_THREAD_LOCAL);
10850
bfd_size_type size = sec->size;
10853
&& (sec->flags & SEC_HAS_CONTENTS) == 0)
10855
struct bfd_link_order *ord = sec->map_tail.link_order;
10858
size = ord->offset + ord->size;
10860
end = sec->vma + size;
10862
base = elf_hash_table (info)->tls_sec->vma;
10863
/* Only align end of TLS section if static TLS doesn't have special
10864
alignment requirements. */
10865
if (bed->static_tls_alignment == 1)
10866
end = align_power (end,
10867
elf_hash_table (info)->tls_sec->alignment_power);
10868
elf_hash_table (info)->tls_size = end - base;
10871
/* Reorder SHF_LINK_ORDER sections. */
10872
for (o = abfd->sections; o != NULL; o = o->next)
10874
if (!elf_fixup_link_order (abfd, o))
10878
/* Since ELF permits relocations to be against local symbols, we
10879
must have the local symbols available when we do the relocations.
10880
Since we would rather only read the local symbols once, and we
10881
would rather not keep them in memory, we handle all the
10882
relocations for a single input file at the same time.
10884
Unfortunately, there is no way to know the total number of local
10885
symbols until we have seen all of them, and the local symbol
10886
indices precede the global symbol indices. This means that when
10887
we are generating relocatable output, and we see a reloc against
10888
a global symbol, we can not know the symbol index until we have
10889
finished examining all the local symbols to see which ones we are
10890
going to output. To deal with this, we keep the relocations in
10891
memory, and don't output them until the end of the link. This is
10892
an unfortunate waste of memory, but I don't see a good way around
10893
it. Fortunately, it only happens when performing a relocatable
10894
link, which is not the common case. FIXME: If keep_memory is set
10895
we could write the relocs out and then read them again; I don't
10896
know how bad the memory loss will be. */
10898
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10899
sub->output_has_begun = FALSE;
10900
for (o = abfd->sections; o != NULL; o = o->next)
10902
for (p = o->map_head.link_order; p != NULL; p = p->next)
10904
if (p->type == bfd_indirect_link_order
10905
&& (bfd_get_flavour ((sub = p->u.indirect.section->owner))
10906
== bfd_target_elf_flavour)
10907
&& elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
10909
if (! sub->output_has_begun)
10911
if (! elf_link_input_bfd (&flinfo, sub))
10913
sub->output_has_begun = TRUE;
10916
else if (p->type == bfd_section_reloc_link_order
10917
|| p->type == bfd_symbol_reloc_link_order)
10919
if (! elf_reloc_link_order (abfd, info, o, p))
10924
if (! _bfd_default_link_order (abfd, info, o, p))
10926
if (p->type == bfd_indirect_link_order
10927
&& (bfd_get_flavour (sub)
10928
== bfd_target_elf_flavour)
10929
&& (elf_elfheader (sub)->e_ident[EI_CLASS]
10930
!= bed->s->elfclass))
10932
const char *iclass, *oclass;
10934
if (bed->s->elfclass == ELFCLASS64)
10936
iclass = "ELFCLASS32";
10937
oclass = "ELFCLASS64";
10941
iclass = "ELFCLASS64";
10942
oclass = "ELFCLASS32";
10945
bfd_set_error (bfd_error_wrong_format);
10946
(*_bfd_error_handler)
10947
(_("%B: file class %s incompatible with %s"),
10948
sub, iclass, oclass);
10957
/* Free symbol buffer if needed. */
10958
if (!info->reduce_memory_overheads)
10960
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10961
if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10962
&& elf_tdata (sub)->symbuf)
10964
free (elf_tdata (sub)->symbuf);
10965
elf_tdata (sub)->symbuf = NULL;
10969
/* Output a FILE symbol so that following locals are not associated
10970
with the wrong input file. */
10971
memset (&elfsym, 0, sizeof (elfsym));
10972
elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
10973
elfsym.st_shndx = SHN_ABS;
10975
if (flinfo.filesym_count > 1
10976
&& !elf_link_output_sym (&flinfo, NULL, &elfsym,
10977
bfd_und_section_ptr, NULL))
10980
/* Output any global symbols that got converted to local in a
10981
version script or due to symbol visibility. We do this in a
10982
separate step since ELF requires all local symbols to appear
10983
prior to any global symbols. FIXME: We should only do this if
10984
some global symbols were, in fact, converted to become local.
10985
FIXME: Will this work correctly with the Irix 5 linker? */
10986
eoinfo.failed = FALSE;
10987
eoinfo.flinfo = &flinfo;
10988
eoinfo.localsyms = TRUE;
10989
eoinfo.need_second_pass = FALSE;
10990
eoinfo.second_pass = FALSE;
10991
bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
10995
if (flinfo.filesym_count == 1
10996
&& !elf_link_output_sym (&flinfo, NULL, &elfsym,
10997
bfd_und_section_ptr, NULL))
11000
if (eoinfo.need_second_pass)
11002
eoinfo.second_pass = TRUE;
11003
bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11008
/* If backend needs to output some local symbols not present in the hash
11009
table, do it now. */
11010
if (bed->elf_backend_output_arch_local_syms)
11012
typedef int (*out_sym_func)
11013
(void *, const char *, Elf_Internal_Sym *, asection *,
11014
struct elf_link_hash_entry *);
11016
if (! ((*bed->elf_backend_output_arch_local_syms)
11017
(abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11021
/* That wrote out all the local symbols. Finish up the symbol table
11022
with the global symbols. Even if we want to strip everything we
11023
can, we still need to deal with those global symbols that got
11024
converted to local in a version script. */
11026
/* The sh_info field records the index of the first non local symbol. */
11027
symtab_hdr->sh_info = bfd_get_symcount (abfd);
11030
&& flinfo.dynsym_sec != NULL
11031
&& flinfo.dynsym_sec->output_section != bfd_abs_section_ptr)
11033
Elf_Internal_Sym sym;
11034
bfd_byte *dynsym = flinfo.dynsym_sec->contents;
11035
long last_local = 0;
11037
/* Write out the section symbols for the output sections. */
11038
if (info->shared || elf_hash_table (info)->is_relocatable_executable)
11044
sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11046
sym.st_target_internal = 0;
11048
for (s = abfd->sections; s != NULL; s = s->next)
11054
dynindx = elf_section_data (s)->dynindx;
11057
indx = elf_section_data (s)->this_idx;
11058
BFD_ASSERT (indx > 0);
11059
sym.st_shndx = indx;
11060
if (! check_dynsym (abfd, &sym))
11062
sym.st_value = s->vma;
11063
dest = dynsym + dynindx * bed->s->sizeof_sym;
11064
if (last_local < dynindx)
11065
last_local = dynindx;
11066
bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11070
/* Write out the local dynsyms. */
11071
if (elf_hash_table (info)->dynlocal)
11073
struct elf_link_local_dynamic_entry *e;
11074
for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
11079
/* Copy the internal symbol and turn off visibility.
11080
Note that we saved a word of storage and overwrote
11081
the original st_name with the dynstr_index. */
11083
sym.st_other &= ~ELF_ST_VISIBILITY (-1);
11085
s = bfd_section_from_elf_index (e->input_bfd,
11090
elf_section_data (s->output_section)->this_idx;
11091
if (! check_dynsym (abfd, &sym))
11093
sym.st_value = (s->output_section->vma
11095
+ e->isym.st_value);
11098
if (last_local < e->dynindx)
11099
last_local = e->dynindx;
11101
dest = dynsym + e->dynindx * bed->s->sizeof_sym;
11102
bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11106
elf_section_data (flinfo.dynsym_sec->output_section)->this_hdr.sh_info =
11110
/* We get the global symbols from the hash table. */
11111
eoinfo.failed = FALSE;
11112
eoinfo.localsyms = FALSE;
11113
eoinfo.flinfo = &flinfo;
11114
bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11118
/* If backend needs to output some symbols not present in the hash
11119
table, do it now. */
11120
if (bed->elf_backend_output_arch_syms)
11122
typedef int (*out_sym_func)
11123
(void *, const char *, Elf_Internal_Sym *, asection *,
11124
struct elf_link_hash_entry *);
11126
if (! ((*bed->elf_backend_output_arch_syms)
11127
(abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11131
/* Flush all symbols to the file. */
11132
if (! elf_link_flush_output_syms (&flinfo, bed))
11135
/* Now we know the size of the symtab section. */
11136
off += symtab_hdr->sh_size;
11138
symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
11139
if (symtab_shndx_hdr->sh_name != 0)
11141
symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
11142
symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
11143
symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
11144
amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
11145
symtab_shndx_hdr->sh_size = amt;
11147
off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
11150
if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
11151
|| (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
11156
/* Finish up and write out the symbol string table (.strtab)
11158
symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
11159
/* sh_name was set in prep_headers. */
11160
symstrtab_hdr->sh_type = SHT_STRTAB;
11161
symstrtab_hdr->sh_flags = 0;
11162
symstrtab_hdr->sh_addr = 0;
11163
symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
11164
symstrtab_hdr->sh_entsize = 0;
11165
symstrtab_hdr->sh_link = 0;
11166
symstrtab_hdr->sh_info = 0;
11167
/* sh_offset is set just below. */
11168
symstrtab_hdr->sh_addralign = 1;
11170
off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
11171
elf_next_file_pos (abfd) = off;
11173
if (bfd_get_symcount (abfd) > 0)
11175
if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
11176
|| ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
11180
/* Adjust the relocs to have the correct symbol indices. */
11181
for (o = abfd->sections; o != NULL; o = o->next)
11183
struct bfd_elf_section_data *esdo = elf_section_data (o);
11184
if ((o->flags & SEC_RELOC) == 0)
11187
if (esdo->rel.hdr != NULL)
11188
elf_link_adjust_relocs (abfd, &esdo->rel);
11189
if (esdo->rela.hdr != NULL)
11190
elf_link_adjust_relocs (abfd, &esdo->rela);
11192
/* Set the reloc_count field to 0 to prevent write_relocs from
11193
trying to swap the relocs out itself. */
11194
o->reloc_count = 0;
11197
if (dynamic && info->combreloc && dynobj != NULL)
11198
relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11200
/* If we are linking against a dynamic object, or generating a
11201
shared library, finish up the dynamic linking information. */
11204
bfd_byte *dyncon, *dynconend;
11206
/* Fix up .dynamic entries. */
11207
o = bfd_get_linker_section (dynobj, ".dynamic");
11208
BFD_ASSERT (o != NULL);
11210
dyncon = o->contents;
11211
dynconend = o->contents + o->size;
11212
for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11214
Elf_Internal_Dyn dyn;
11218
bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11225
if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11227
switch (elf_section_data (reldyn)->this_hdr.sh_type)
11229
case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11230
case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11233
dyn.d_un.d_val = relativecount;
11240
name = info->init_function;
11243
name = info->fini_function;
11246
struct elf_link_hash_entry *h;
11248
h = elf_link_hash_lookup (elf_hash_table (info), name,
11249
FALSE, FALSE, TRUE);
11251
&& (h->root.type == bfd_link_hash_defined
11252
|| h->root.type == bfd_link_hash_defweak))
11254
dyn.d_un.d_ptr = h->root.u.def.value;
11255
o = h->root.u.def.section;
11256
if (o->output_section != NULL)
11257
dyn.d_un.d_ptr += (o->output_section->vma
11258
+ o->output_offset);
11261
/* The symbol is imported from another shared
11262
library and does not apply to this one. */
11263
dyn.d_un.d_ptr = 0;
11270
case DT_PREINIT_ARRAYSZ:
11271
name = ".preinit_array";
11273
case DT_INIT_ARRAYSZ:
11274
name = ".init_array";
11276
case DT_FINI_ARRAYSZ:
11277
name = ".fini_array";
11279
o = bfd_get_section_by_name (abfd, name);
11282
(*_bfd_error_handler)
11283
(_("%B: could not find output section %s"), abfd, name);
11287
(*_bfd_error_handler)
11288
(_("warning: %s section has zero size"), name);
11289
dyn.d_un.d_val = o->size;
11292
case DT_PREINIT_ARRAY:
11293
name = ".preinit_array";
11295
case DT_INIT_ARRAY:
11296
name = ".init_array";
11298
case DT_FINI_ARRAY:
11299
name = ".fini_array";
11306
name = ".gnu.hash";
11315
name = ".gnu.version_d";
11318
name = ".gnu.version_r";
11321
name = ".gnu.version";
11323
o = bfd_get_section_by_name (abfd, name);
11326
(*_bfd_error_handler)
11327
(_("%B: could not find output section %s"), abfd, name);
11330
if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11332
(*_bfd_error_handler)
11333
(_("warning: section '%s' is being made into a note"), name);
11334
bfd_set_error (bfd_error_nonrepresentable_section);
11337
dyn.d_un.d_ptr = o->vma;
11344
if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11348
dyn.d_un.d_val = 0;
11349
dyn.d_un.d_ptr = 0;
11350
for (i = 1; i < elf_numsections (abfd); i++)
11352
Elf_Internal_Shdr *hdr;
11354
hdr = elf_elfsections (abfd)[i];
11355
if (hdr->sh_type == type
11356
&& (hdr->sh_flags & SHF_ALLOC) != 0)
11358
if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11359
dyn.d_un.d_val += hdr->sh_size;
11362
if (dyn.d_un.d_ptr == 0
11363
|| hdr->sh_addr < dyn.d_un.d_ptr)
11364
dyn.d_un.d_ptr = hdr->sh_addr;
11370
bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11374
/* If we have created any dynamic sections, then output them. */
11375
if (dynobj != NULL)
11377
if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11380
/* Check for DT_TEXTREL (late, in case the backend removes it). */
11381
if (((info->warn_shared_textrel && info->shared)
11382
|| info->error_textrel)
11383
&& (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
11385
bfd_byte *dyncon, *dynconend;
11387
dyncon = o->contents;
11388
dynconend = o->contents + o->size;
11389
for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11391
Elf_Internal_Dyn dyn;
11393
bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11395
if (dyn.d_tag == DT_TEXTREL)
11397
if (info->error_textrel)
11398
info->callbacks->einfo
11399
(_("%P%X: read-only segment has dynamic relocations.\n"));
11401
info->callbacks->einfo
11402
(_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11408
for (o = dynobj->sections; o != NULL; o = o->next)
11410
if ((o->flags & SEC_HAS_CONTENTS) == 0
11412
|| o->output_section == bfd_abs_section_ptr)
11414
if ((o->flags & SEC_LINKER_CREATED) == 0)
11416
/* At this point, we are only interested in sections
11417
created by _bfd_elf_link_create_dynamic_sections. */
11420
if (elf_hash_table (info)->stab_info.stabstr == o)
11422
if (elf_hash_table (info)->eh_info.hdr_sec == o)
11424
if (strcmp (o->name, ".dynstr") != 0)
11426
/* FIXME: octets_per_byte. */
11427
if (! bfd_set_section_contents (abfd, o->output_section,
11429
(file_ptr) o->output_offset,
11435
/* The contents of the .dynstr section are actually in a
11437
off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11438
if (bfd_seek (abfd, off, SEEK_SET) != 0
11439
|| ! _bfd_elf_strtab_emit (abfd,
11440
elf_hash_table (info)->dynstr))
11446
if (info->relocatable)
11448
bfd_boolean failed = FALSE;
11450
bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11455
/* If we have optimized stabs strings, output them. */
11456
if (elf_hash_table (info)->stab_info.stabstr != NULL)
11458
if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11462
if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11465
elf_final_link_free (abfd, &flinfo);
11467
elf_linker (abfd) = TRUE;
11471
bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11472
if (contents == NULL)
11473
return FALSE; /* Bail out and fail. */
11474
bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11475
bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11482
elf_final_link_free (abfd, &flinfo);
11486
/* Initialize COOKIE for input bfd ABFD. */
11489
init_reloc_cookie (struct elf_reloc_cookie *cookie,
11490
struct bfd_link_info *info, bfd *abfd)
11492
Elf_Internal_Shdr *symtab_hdr;
11493
const struct elf_backend_data *bed;
11495
bed = get_elf_backend_data (abfd);
11496
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11498
cookie->abfd = abfd;
11499
cookie->sym_hashes = elf_sym_hashes (abfd);
11500
cookie->bad_symtab = elf_bad_symtab (abfd);
11501
if (cookie->bad_symtab)
11503
cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11504
cookie->extsymoff = 0;
11508
cookie->locsymcount = symtab_hdr->sh_info;
11509
cookie->extsymoff = symtab_hdr->sh_info;
11512
if (bed->s->arch_size == 32)
11513
cookie->r_sym_shift = 8;
11515
cookie->r_sym_shift = 32;
11517
cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11518
if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11520
cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11521
cookie->locsymcount, 0,
11523
if (cookie->locsyms == NULL)
11525
info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11528
if (info->keep_memory)
11529
symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11534
/* Free the memory allocated by init_reloc_cookie, if appropriate. */
11537
fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11539
Elf_Internal_Shdr *symtab_hdr;
11541
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11542
if (cookie->locsyms != NULL
11543
&& symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11544
free (cookie->locsyms);
11547
/* Initialize the relocation information in COOKIE for input section SEC
11548
of input bfd ABFD. */
11551
init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11552
struct bfd_link_info *info, bfd *abfd,
11555
const struct elf_backend_data *bed;
11557
if (sec->reloc_count == 0)
11559
cookie->rels = NULL;
11560
cookie->relend = NULL;
11564
bed = get_elf_backend_data (abfd);
11566
cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11567
info->keep_memory);
11568
if (cookie->rels == NULL)
11570
cookie->rel = cookie->rels;
11571
cookie->relend = (cookie->rels
11572
+ sec->reloc_count * bed->s->int_rels_per_ext_rel);
11574
cookie->rel = cookie->rels;
11578
/* Free the memory allocated by init_reloc_cookie_rels,
11582
fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11585
if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11586
free (cookie->rels);
11589
/* Initialize the whole of COOKIE for input section SEC. */
11592
init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11593
struct bfd_link_info *info,
11596
if (!init_reloc_cookie (cookie, info, sec->owner))
11598
if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11603
fini_reloc_cookie (cookie, sec->owner);
11608
/* Free the memory allocated by init_reloc_cookie_for_section,
11612
fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11615
fini_reloc_cookie_rels (cookie, sec);
11616
fini_reloc_cookie (cookie, sec->owner);
11619
/* Garbage collect unused sections. */
11621
/* Default gc_mark_hook. */
11624
_bfd_elf_gc_mark_hook (asection *sec,
11625
struct bfd_link_info *info ATTRIBUTE_UNUSED,
11626
Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11627
struct elf_link_hash_entry *h,
11628
Elf_Internal_Sym *sym)
11630
const char *sec_name;
11634
switch (h->root.type)
11636
case bfd_link_hash_defined:
11637
case bfd_link_hash_defweak:
11638
return h->root.u.def.section;
11640
case bfd_link_hash_common:
11641
return h->root.u.c.p->section;
11643
case bfd_link_hash_undefined:
11644
case bfd_link_hash_undefweak:
11645
/* To work around a glibc bug, keep all XXX input sections
11646
when there is an as yet undefined reference to __start_XXX
11647
or __stop_XXX symbols. The linker will later define such
11648
symbols for orphan input sections that have a name
11649
representable as a C identifier. */
11650
if (strncmp (h->root.root.string, "__start_", 8) == 0)
11651
sec_name = h->root.root.string + 8;
11652
else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11653
sec_name = h->root.root.string + 7;
11657
if (sec_name && *sec_name != '\0')
11661
for (i = info->input_bfds; i; i = i->link_next)
11663
sec = bfd_get_section_by_name (i, sec_name);
11665
sec->flags |= SEC_KEEP;
11675
return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11680
/* COOKIE->rel describes a relocation against section SEC, which is
11681
a section we've decided to keep. Return the section that contains
11682
the relocation symbol, or NULL if no section contains it. */
11685
_bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11686
elf_gc_mark_hook_fn gc_mark_hook,
11687
struct elf_reloc_cookie *cookie)
11689
unsigned long r_symndx;
11690
struct elf_link_hash_entry *h;
11692
r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11693
if (r_symndx == STN_UNDEF)
11696
if (r_symndx >= cookie->locsymcount
11697
|| ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11699
h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11700
while (h->root.type == bfd_link_hash_indirect
11701
|| h->root.type == bfd_link_hash_warning)
11702
h = (struct elf_link_hash_entry *) h->root.u.i.link;
11704
/* If this symbol is weak and there is a non-weak definition, we
11705
keep the non-weak definition because many backends put
11706
dynamic reloc info on the non-weak definition for code
11707
handling copy relocs. */
11708
if (h->u.weakdef != NULL)
11709
h->u.weakdef->mark = 1;
11710
return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11713
return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11714
&cookie->locsyms[r_symndx]);
11717
/* COOKIE->rel describes a relocation against section SEC, which is
11718
a section we've decided to keep. Mark the section that contains
11719
the relocation symbol. */
11722
_bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11724
elf_gc_mark_hook_fn gc_mark_hook,
11725
struct elf_reloc_cookie *cookie)
11729
rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11730
if (rsec && !rsec->gc_mark)
11732
if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
11733
|| (rsec->owner->flags & DYNAMIC) != 0)
11735
else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11741
/* The mark phase of garbage collection. For a given section, mark
11742
it and any sections in this section's group, and all the sections
11743
which define symbols to which it refers. */
11746
_bfd_elf_gc_mark (struct bfd_link_info *info,
11748
elf_gc_mark_hook_fn gc_mark_hook)
11751
asection *group_sec, *eh_frame;
11755
/* Mark all the sections in the group. */
11756
group_sec = elf_section_data (sec)->next_in_group;
11757
if (group_sec && !group_sec->gc_mark)
11758
if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11761
/* Look through the section relocs. */
11763
eh_frame = elf_eh_frame_section (sec->owner);
11764
if ((sec->flags & SEC_RELOC) != 0
11765
&& sec->reloc_count > 0
11766
&& sec != eh_frame)
11768
struct elf_reloc_cookie cookie;
11770
if (!init_reloc_cookie_for_section (&cookie, info, sec))
11774
for (; cookie.rel < cookie.relend; cookie.rel++)
11775
if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11780
fini_reloc_cookie_for_section (&cookie, sec);
11784
if (ret && eh_frame && elf_fde_list (sec))
11786
struct elf_reloc_cookie cookie;
11788
if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11792
if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11793
gc_mark_hook, &cookie))
11795
fini_reloc_cookie_for_section (&cookie, eh_frame);
11802
/* Keep debug and special sections. */
11805
_bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
11806
elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
11810
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11813
bfd_boolean some_kept;
11814
bfd_boolean debug_frag_seen;
11816
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
11819
/* Ensure all linker created sections are kept,
11820
see if any other section is already marked,
11821
and note if we have any fragmented debug sections. */
11822
debug_frag_seen = some_kept = FALSE;
11823
for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11825
if ((isec->flags & SEC_LINKER_CREATED) != 0)
11827
else if (isec->gc_mark)
11830
if (debug_frag_seen == FALSE
11831
&& (isec->flags & SEC_DEBUGGING)
11832
&& CONST_STRNEQ (isec->name, ".debug_line."))
11833
debug_frag_seen = TRUE;
11836
/* If no section in this file will be kept, then we can
11837
toss out the debug and special sections. */
11841
/* Keep debug and special sections like .comment when they are
11842
not part of a group, or when we have single-member groups. */
11843
for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11844
if ((elf_next_in_group (isec) == NULL
11845
|| elf_next_in_group (isec) == isec)
11846
&& ((isec->flags & SEC_DEBUGGING) != 0
11847
|| (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0))
11850
if (! debug_frag_seen)
11853
/* Look for CODE sections which are going to be discarded,
11854
and find and discard any fragmented debug sections which
11855
are associated with that code section. */
11856
for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11857
if ((isec->flags & SEC_CODE) != 0
11858
&& isec->gc_mark == 0)
11863
ilen = strlen (isec->name);
11865
/* Association is determined by the name of the debug section
11866
containing the name of the code section as a suffix. For
11867
example .debug_line.text.foo is a debug section associated
11869
for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
11873
if (dsec->gc_mark == 0
11874
|| (dsec->flags & SEC_DEBUGGING) == 0)
11877
dlen = strlen (dsec->name);
11880
&& strncmp (dsec->name + (dlen - ilen),
11881
isec->name, ilen) == 0)
11892
/* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
11894
struct elf_gc_sweep_symbol_info
11896
struct bfd_link_info *info;
11897
void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
11902
elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
11905
&& (((h->root.type == bfd_link_hash_defined
11906
|| h->root.type == bfd_link_hash_defweak)
11907
&& !(h->def_regular
11908
&& h->root.u.def.section->gc_mark))
11909
|| h->root.type == bfd_link_hash_undefined
11910
|| h->root.type == bfd_link_hash_undefweak))
11912
struct elf_gc_sweep_symbol_info *inf;
11914
inf = (struct elf_gc_sweep_symbol_info *) data;
11915
(*inf->hide_symbol) (inf->info, h, TRUE);
11916
h->def_regular = 0;
11917
h->ref_regular = 0;
11918
h->ref_regular_nonweak = 0;
11924
/* The sweep phase of garbage collection. Remove all garbage sections. */
11926
typedef bfd_boolean (*gc_sweep_hook_fn)
11927
(bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
11930
elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
11933
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11934
gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
11935
unsigned long section_sym_count;
11936
struct elf_gc_sweep_symbol_info sweep_info;
11938
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11942
if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11945
for (o = sub->sections; o != NULL; o = o->next)
11947
/* When any section in a section group is kept, we keep all
11948
sections in the section group. If the first member of
11949
the section group is excluded, we will also exclude the
11951
if (o->flags & SEC_GROUP)
11953
asection *first = elf_next_in_group (o);
11954
o->gc_mark = first->gc_mark;
11960
/* Skip sweeping sections already excluded. */
11961
if (o->flags & SEC_EXCLUDE)
11964
/* Since this is early in the link process, it is simple
11965
to remove a section from the output. */
11966
o->flags |= SEC_EXCLUDE;
11968
if (info->print_gc_sections && o->size != 0)
11969
_bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
11971
/* But we also have to update some of the relocation
11972
info we collected before. */
11974
&& (o->flags & SEC_RELOC) != 0
11975
&& o->reloc_count > 0
11976
&& !bfd_is_abs_section (o->output_section))
11978
Elf_Internal_Rela *internal_relocs;
11982
= _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
11983
info->keep_memory);
11984
if (internal_relocs == NULL)
11987
r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
11989
if (elf_section_data (o)->relocs != internal_relocs)
11990
free (internal_relocs);
11998
/* Remove the symbols that were in the swept sections from the dynamic
11999
symbol table. GCFIXME: Anyone know how to get them out of the
12000
static symbol table as well? */
12001
sweep_info.info = info;
12002
sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
12003
elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
12006
_bfd_elf_link_renumber_dynsyms (abfd, info, §ion_sym_count);
12010
/* Propagate collected vtable information. This is called through
12011
elf_link_hash_traverse. */
12014
elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
12016
/* Those that are not vtables. */
12017
if (h->vtable == NULL || h->vtable->parent == NULL)
12020
/* Those vtables that do not have parents, we cannot merge. */
12021
if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
12024
/* If we've already been done, exit. */
12025
if (h->vtable->used && h->vtable->used[-1])
12028
/* Make sure the parent's table is up to date. */
12029
elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
12031
if (h->vtable->used == NULL)
12033
/* None of this table's entries were referenced. Re-use the
12035
h->vtable->used = h->vtable->parent->vtable->used;
12036
h->vtable->size = h->vtable->parent->vtable->size;
12041
bfd_boolean *cu, *pu;
12043
/* Or the parent's entries into ours. */
12044
cu = h->vtable->used;
12046
pu = h->vtable->parent->vtable->used;
12049
const struct elf_backend_data *bed;
12050
unsigned int log_file_align;
12052
bed = get_elf_backend_data (h->root.u.def.section->owner);
12053
log_file_align = bed->s->log_file_align;
12054
n = h->vtable->parent->vtable->size >> log_file_align;
12069
elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
12072
bfd_vma hstart, hend;
12073
Elf_Internal_Rela *relstart, *relend, *rel;
12074
const struct elf_backend_data *bed;
12075
unsigned int log_file_align;
12077
/* Take care of both those symbols that do not describe vtables as
12078
well as those that are not loaded. */
12079
if (h->vtable == NULL || h->vtable->parent == NULL)
12082
BFD_ASSERT (h->root.type == bfd_link_hash_defined
12083
|| h->root.type == bfd_link_hash_defweak);
12085
sec = h->root.u.def.section;
12086
hstart = h->root.u.def.value;
12087
hend = hstart + h->size;
12089
relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
12091
return *(bfd_boolean *) okp = FALSE;
12092
bed = get_elf_backend_data (sec->owner);
12093
log_file_align = bed->s->log_file_align;
12095
relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
12097
for (rel = relstart; rel < relend; ++rel)
12098
if (rel->r_offset >= hstart && rel->r_offset < hend)
12100
/* If the entry is in use, do nothing. */
12101
if (h->vtable->used
12102
&& (rel->r_offset - hstart) < h->vtable->size)
12104
bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
12105
if (h->vtable->used[entry])
12108
/* Otherwise, kill it. */
12109
rel->r_offset = rel->r_info = rel->r_addend = 0;
12115
/* Mark sections containing dynamically referenced symbols. When
12116
building shared libraries, we must assume that any visible symbol is
12120
bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
12122
struct bfd_link_info *info = (struct bfd_link_info *) inf;
12124
if ((h->root.type == bfd_link_hash_defined
12125
|| h->root.type == bfd_link_hash_defweak)
12127
|| ((!info->executable || info->export_dynamic)
12129
&& ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
12130
&& ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
12131
&& (strchr (h->root.root.string, ELF_VER_CHR) != NULL
12132
|| !bfd_hide_sym_by_version (info->version_info,
12133
h->root.root.string)))))
12134
h->root.u.def.section->flags |= SEC_KEEP;
12139
/* Keep all sections containing symbols undefined on the command-line,
12140
and the section containing the entry symbol. */
12143
_bfd_elf_gc_keep (struct bfd_link_info *info)
12145
struct bfd_sym_chain *sym;
12147
for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
12149
struct elf_link_hash_entry *h;
12151
h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
12152
FALSE, FALSE, FALSE);
12155
&& (h->root.type == bfd_link_hash_defined
12156
|| h->root.type == bfd_link_hash_defweak)
12157
&& !bfd_is_abs_section (h->root.u.def.section))
12158
h->root.u.def.section->flags |= SEC_KEEP;
12162
/* Do mark and sweep of unused sections. */
12165
bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
12167
bfd_boolean ok = TRUE;
12169
elf_gc_mark_hook_fn gc_mark_hook;
12170
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12172
if (!bed->can_gc_sections
12173
|| !is_elf_hash_table (info->hash))
12175
(*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12179
bed->gc_keep (info);
12181
/* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
12182
at the .eh_frame section if we can mark the FDEs individually. */
12183
_bfd_elf_begin_eh_frame_parsing (info);
12184
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12187
struct elf_reloc_cookie cookie;
12189
sec = bfd_get_section_by_name (sub, ".eh_frame");
12190
while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12192
_bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12193
if (elf_section_data (sec)->sec_info
12194
&& (sec->flags & SEC_LINKER_CREATED) == 0)
12195
elf_eh_frame_section (sub) = sec;
12196
fini_reloc_cookie_for_section (&cookie, sec);
12197
sec = bfd_get_next_section_by_name (sec);
12200
_bfd_elf_end_eh_frame_parsing (info);
12202
/* Apply transitive closure to the vtable entry usage info. */
12203
elf_link_hash_traverse (elf_hash_table (info),
12204
elf_gc_propagate_vtable_entries_used,
12209
/* Kill the vtable relocations that were not used. */
12210
elf_link_hash_traverse (elf_hash_table (info),
12211
elf_gc_smash_unused_vtentry_relocs,
12216
/* Mark dynamically referenced symbols. */
12217
if (elf_hash_table (info)->dynamic_sections_created)
12218
elf_link_hash_traverse (elf_hash_table (info),
12219
bed->gc_mark_dynamic_ref,
12222
/* Grovel through relocs to find out who stays ... */
12223
gc_mark_hook = bed->gc_mark_hook;
12224
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12228
if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12231
/* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12232
Also treat note sections as a root, if the section is not part
12234
for (o = sub->sections; o != NULL; o = o->next)
12236
&& (o->flags & SEC_EXCLUDE) == 0
12237
&& ((o->flags & SEC_KEEP) != 0
12238
|| (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12239
&& elf_next_in_group (o) == NULL )))
12241
if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12246
/* Allow the backend to mark additional target specific sections. */
12247
bed->gc_mark_extra_sections (info, gc_mark_hook);
12249
/* ... and mark SEC_EXCLUDE for those that go. */
12250
return elf_gc_sweep (abfd, info);
12253
/* Called from check_relocs to record the existence of a VTINHERIT reloc. */
12256
bfd_elf_gc_record_vtinherit (bfd *abfd,
12258
struct elf_link_hash_entry *h,
12261
struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12262
struct elf_link_hash_entry **search, *child;
12263
bfd_size_type extsymcount;
12264
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12266
/* The sh_info field of the symtab header tells us where the
12267
external symbols start. We don't care about the local symbols at
12269
extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12270
if (!elf_bad_symtab (abfd))
12271
extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12273
sym_hashes = elf_sym_hashes (abfd);
12274
sym_hashes_end = sym_hashes + extsymcount;
12276
/* Hunt down the child symbol, which is in this section at the same
12277
offset as the relocation. */
12278
for (search = sym_hashes; search != sym_hashes_end; ++search)
12280
if ((child = *search) != NULL
12281
&& (child->root.type == bfd_link_hash_defined
12282
|| child->root.type == bfd_link_hash_defweak)
12283
&& child->root.u.def.section == sec
12284
&& child->root.u.def.value == offset)
12288
(*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12289
abfd, sec, (unsigned long) offset);
12290
bfd_set_error (bfd_error_invalid_operation);
12294
if (!child->vtable)
12296
child->vtable = (struct elf_link_virtual_table_entry *)
12297
bfd_zalloc (abfd, sizeof (*child->vtable));
12298
if (!child->vtable)
12303
/* This *should* only be the absolute section. It could potentially
12304
be that someone has defined a non-global vtable though, which
12305
would be bad. It isn't worth paging in the local symbols to be
12306
sure though; that case should simply be handled by the assembler. */
12308
child->vtable->parent = (struct elf_link_hash_entry *) -1;
12311
child->vtable->parent = h;
12316
/* Called from check_relocs to record the existence of a VTENTRY reloc. */
12319
bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12320
asection *sec ATTRIBUTE_UNUSED,
12321
struct elf_link_hash_entry *h,
12324
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12325
unsigned int log_file_align = bed->s->log_file_align;
12329
h->vtable = (struct elf_link_virtual_table_entry *)
12330
bfd_zalloc (abfd, sizeof (*h->vtable));
12335
if (addend >= h->vtable->size)
12337
size_t size, bytes, file_align;
12338
bfd_boolean *ptr = h->vtable->used;
12340
/* While the symbol is undefined, we have to be prepared to handle
12342
file_align = 1 << log_file_align;
12343
if (h->root.type == bfd_link_hash_undefined)
12344
size = addend + file_align;
12348
if (addend >= size)
12350
/* Oops! We've got a reference past the defined end of
12351
the table. This is probably a bug -- shall we warn? */
12352
size = addend + file_align;
12355
size = (size + file_align - 1) & -file_align;
12357
/* Allocate one extra entry for use as a "done" flag for the
12358
consolidation pass. */
12359
bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12363
ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12369
oldbytes = (((h->vtable->size >> log_file_align) + 1)
12370
* sizeof (bfd_boolean));
12371
memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12375
ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12380
/* And arrange for that done flag to be at index -1. */
12381
h->vtable->used = ptr + 1;
12382
h->vtable->size = size;
12385
h->vtable->used[addend >> log_file_align] = TRUE;
12390
/* Map an ELF section header flag to its corresponding string. */
12394
flagword flag_value;
12395
} elf_flags_to_name_table;
12397
static elf_flags_to_name_table elf_flags_to_names [] =
12399
{ "SHF_WRITE", SHF_WRITE },
12400
{ "SHF_ALLOC", SHF_ALLOC },
12401
{ "SHF_EXECINSTR", SHF_EXECINSTR },
12402
{ "SHF_MERGE", SHF_MERGE },
12403
{ "SHF_STRINGS", SHF_STRINGS },
12404
{ "SHF_INFO_LINK", SHF_INFO_LINK},
12405
{ "SHF_LINK_ORDER", SHF_LINK_ORDER},
12406
{ "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12407
{ "SHF_GROUP", SHF_GROUP },
12408
{ "SHF_TLS", SHF_TLS },
12409
{ "SHF_MASKOS", SHF_MASKOS },
12410
{ "SHF_EXCLUDE", SHF_EXCLUDE },
12413
/* Returns TRUE if the section is to be included, otherwise FALSE. */
12415
bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12416
struct flag_info *flaginfo,
12419
const bfd_vma sh_flags = elf_section_flags (section);
12421
if (!flaginfo->flags_initialized)
12423
bfd *obfd = info->output_bfd;
12424
const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12425
struct flag_info_list *tf = flaginfo->flag_list;
12427
int without_hex = 0;
12429
for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
12432
flagword (*lookup) (char *);
12434
lookup = bed->elf_backend_lookup_section_flags_hook;
12435
if (lookup != NULL)
12437
flagword hexval = (*lookup) ((char *) tf->name);
12441
if (tf->with == with_flags)
12442
with_hex |= hexval;
12443
else if (tf->with == without_flags)
12444
without_hex |= hexval;
12449
for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
12451
if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
12453
if (tf->with == with_flags)
12454
with_hex |= elf_flags_to_names[i].flag_value;
12455
else if (tf->with == without_flags)
12456
without_hex |= elf_flags_to_names[i].flag_value;
12463
info->callbacks->einfo
12464
(_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12468
flaginfo->flags_initialized = TRUE;
12469
flaginfo->only_with_flags |= with_hex;
12470
flaginfo->not_with_flags |= without_hex;
12473
if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
12476
if ((flaginfo->not_with_flags & sh_flags) != 0)
12482
struct alloc_got_off_arg {
12484
struct bfd_link_info *info;
12487
/* We need a special top-level link routine to convert got reference counts
12488
to real got offsets. */
12491
elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12493
struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12494
bfd *obfd = gofarg->info->output_bfd;
12495
const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12497
if (h->got.refcount > 0)
12499
h->got.offset = gofarg->gotoff;
12500
gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12503
h->got.offset = (bfd_vma) -1;
12508
/* And an accompanying bit to work out final got entry offsets once
12509
we're done. Should be called from final_link. */
12512
bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12513
struct bfd_link_info *info)
12516
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12518
struct alloc_got_off_arg gofarg;
12520
BFD_ASSERT (abfd == info->output_bfd);
12522
if (! is_elf_hash_table (info->hash))
12525
/* The GOT offset is relative to the .got section, but the GOT header is
12526
put into the .got.plt section, if the backend uses it. */
12527
if (bed->want_got_plt)
12530
gotoff = bed->got_header_size;
12532
/* Do the local .got entries first. */
12533
for (i = info->input_bfds; i; i = i->link_next)
12535
bfd_signed_vma *local_got;
12536
bfd_size_type j, locsymcount;
12537
Elf_Internal_Shdr *symtab_hdr;
12539
if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12542
local_got = elf_local_got_refcounts (i);
12546
symtab_hdr = &elf_tdata (i)->symtab_hdr;
12547
if (elf_bad_symtab (i))
12548
locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12550
locsymcount = symtab_hdr->sh_info;
12552
for (j = 0; j < locsymcount; ++j)
12554
if (local_got[j] > 0)
12556
local_got[j] = gotoff;
12557
gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12560
local_got[j] = (bfd_vma) -1;
12564
/* Then the global .got entries. .plt refcounts are handled by
12565
adjust_dynamic_symbol */
12566
gofarg.gotoff = gotoff;
12567
gofarg.info = info;
12568
elf_link_hash_traverse (elf_hash_table (info),
12569
elf_gc_allocate_got_offsets,
12574
/* Many folk need no more in the way of final link than this, once
12575
got entry reference counting is enabled. */
12578
bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12580
if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12583
/* Invoke the regular ELF backend linker to do all the work. */
12584
return bfd_elf_final_link (abfd, info);
12588
bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12590
struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12592
if (rcookie->bad_symtab)
12593
rcookie->rel = rcookie->rels;
12595
for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12597
unsigned long r_symndx;
12599
if (! rcookie->bad_symtab)
12600
if (rcookie->rel->r_offset > offset)
12602
if (rcookie->rel->r_offset != offset)
12605
r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12606
if (r_symndx == STN_UNDEF)
12609
if (r_symndx >= rcookie->locsymcount
12610
|| ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12612
struct elf_link_hash_entry *h;
12614
h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12616
while (h->root.type == bfd_link_hash_indirect
12617
|| h->root.type == bfd_link_hash_warning)
12618
h = (struct elf_link_hash_entry *) h->root.u.i.link;
12620
if ((h->root.type == bfd_link_hash_defined
12621
|| h->root.type == bfd_link_hash_defweak)
12622
&& discarded_section (h->root.u.def.section))
12629
/* It's not a relocation against a global symbol,
12630
but it could be a relocation against a local
12631
symbol for a discarded section. */
12633
Elf_Internal_Sym *isym;
12635
/* Need to: get the symbol; get the section. */
12636
isym = &rcookie->locsyms[r_symndx];
12637
isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12638
if (isec != NULL && discarded_section (isec))
12646
/* Discard unneeded references to discarded sections.
12647
Returns TRUE if any section's size was changed. */
12648
/* This function assumes that the relocations are in sorted order,
12649
which is true for all known assemblers. */
12652
bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12654
struct elf_reloc_cookie cookie;
12655
asection *stab, *eh;
12656
const struct elf_backend_data *bed;
12658
bfd_boolean ret = FALSE;
12660
if (info->traditional_format
12661
|| !is_elf_hash_table (info->hash))
12664
_bfd_elf_begin_eh_frame_parsing (info);
12665
for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
12667
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12670
bed = get_elf_backend_data (abfd);
12673
if (!info->relocatable)
12675
eh = bfd_get_section_by_name (abfd, ".eh_frame");
12678
|| bfd_is_abs_section (eh->output_section)))
12679
eh = bfd_get_next_section_by_name (eh);
12682
stab = bfd_get_section_by_name (abfd, ".stab");
12684
&& (stab->size == 0
12685
|| bfd_is_abs_section (stab->output_section)
12686
|| stab->sec_info_type != SEC_INFO_TYPE_STABS))
12691
&& bed->elf_backend_discard_info == NULL)
12694
if (!init_reloc_cookie (&cookie, info, abfd))
12698
&& stab->reloc_count > 0
12699
&& init_reloc_cookie_rels (&cookie, info, abfd, stab))
12701
if (_bfd_discard_section_stabs (abfd, stab,
12702
elf_section_data (stab)->sec_info,
12703
bfd_elf_reloc_symbol_deleted_p,
12706
fini_reloc_cookie_rels (&cookie, stab);
12710
&& init_reloc_cookie_rels (&cookie, info, abfd, eh))
12712
_bfd_elf_parse_eh_frame (abfd, info, eh, &cookie);
12713
if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
12714
bfd_elf_reloc_symbol_deleted_p,
12717
fini_reloc_cookie_rels (&cookie, eh);
12718
eh = bfd_get_next_section_by_name (eh);
12721
if (bed->elf_backend_discard_info != NULL
12722
&& (*bed->elf_backend_discard_info) (abfd, &cookie, info))
12725
fini_reloc_cookie (&cookie, abfd);
12727
_bfd_elf_end_eh_frame_parsing (info);
12729
if (info->eh_frame_hdr
12730
&& !info->relocatable
12731
&& _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12738
_bfd_elf_section_already_linked (bfd *abfd,
12740
struct bfd_link_info *info)
12743
const char *name, *key;
12744
struct bfd_section_already_linked *l;
12745
struct bfd_section_already_linked_hash_entry *already_linked_list;
12747
if (sec->output_section == bfd_abs_section_ptr)
12750
flags = sec->flags;
12752
/* Return if it isn't a linkonce section. A comdat group section
12753
also has SEC_LINK_ONCE set. */
12754
if ((flags & SEC_LINK_ONCE) == 0)
12757
/* Don't put group member sections on our list of already linked
12758
sections. They are handled as a group via their group section. */
12759
if (elf_sec_group (sec) != NULL)
12762
/* For a SHT_GROUP section, use the group signature as the key. */
12764
if ((flags & SEC_GROUP) != 0
12765
&& elf_next_in_group (sec) != NULL
12766
&& elf_group_name (elf_next_in_group (sec)) != NULL)
12767
key = elf_group_name (elf_next_in_group (sec));
12770
/* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */
12771
if (CONST_STRNEQ (name, ".gnu.linkonce.")
12772
&& (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12775
/* Must be a user linkonce section that doesn't follow gcc's
12776
naming convention. In this case we won't be matching
12777
single member groups. */
12781
already_linked_list = bfd_section_already_linked_table_lookup (key);
12783
for (l = already_linked_list->entry; l != NULL; l = l->next)
12785
/* We may have 2 different types of sections on the list: group
12786
sections with a signature of <key> (<key> is some string),
12787
and linkonce sections named .gnu.linkonce.<type>.<key>.
12788
Match like sections. LTO plugin sections are an exception.
12789
They are always named .gnu.linkonce.t.<key> and match either
12790
type of section. */
12791
if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
12792
&& ((flags & SEC_GROUP) != 0
12793
|| strcmp (name, l->sec->name) == 0))
12794
|| (l->sec->owner->flags & BFD_PLUGIN) != 0)
12796
/* The section has already been linked. See if we should
12797
issue a warning. */
12798
if (!_bfd_handle_already_linked (sec, l, info))
12801
if (flags & SEC_GROUP)
12803
asection *first = elf_next_in_group (sec);
12804
asection *s = first;
12808
s->output_section = bfd_abs_section_ptr;
12809
/* Record which group discards it. */
12810
s->kept_section = l->sec;
12811
s = elf_next_in_group (s);
12812
/* These lists are circular. */
12822
/* A single member comdat group section may be discarded by a
12823
linkonce section and vice versa. */
12824
if ((flags & SEC_GROUP) != 0)
12826
asection *first = elf_next_in_group (sec);
12828
if (first != NULL && elf_next_in_group (first) == first)
12829
/* Check this single member group against linkonce sections. */
12830
for (l = already_linked_list->entry; l != NULL; l = l->next)
12831
if ((l->sec->flags & SEC_GROUP) == 0
12832
&& bfd_elf_match_symbols_in_sections (l->sec, first, info))
12834
first->output_section = bfd_abs_section_ptr;
12835
first->kept_section = l->sec;
12836
sec->output_section = bfd_abs_section_ptr;
12841
/* Check this linkonce section against single member groups. */
12842
for (l = already_linked_list->entry; l != NULL; l = l->next)
12843
if (l->sec->flags & SEC_GROUP)
12845
asection *first = elf_next_in_group (l->sec);
12848
&& elf_next_in_group (first) == first
12849
&& bfd_elf_match_symbols_in_sections (first, sec, info))
12851
sec->output_section = bfd_abs_section_ptr;
12852
sec->kept_section = first;
12857
/* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12858
referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12859
specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12860
prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
12861
matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
12862
but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12863
`.gnu.linkonce.t.F' section from a different bfd not requiring any
12864
`.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
12865
The reverse order cannot happen as there is never a bfd with only the
12866
`.gnu.linkonce.r.F' section. The order of sections in a bfd does not
12867
matter as here were are looking only for cross-bfd sections. */
12869
if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
12870
for (l = already_linked_list->entry; l != NULL; l = l->next)
12871
if ((l->sec->flags & SEC_GROUP) == 0
12872
&& CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
12874
if (abfd != l->sec->owner)
12875
sec->output_section = bfd_abs_section_ptr;
12879
/* This is the first section with this name. Record it. */
12880
if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
12881
info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
12882
return sec->output_section == bfd_abs_section_ptr;
12886
_bfd_elf_common_definition (Elf_Internal_Sym *sym)
12888
return sym->st_shndx == SHN_COMMON;
12892
_bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
12898
_bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
12900
return bfd_com_section_ptr;
12904
_bfd_elf_default_got_elt_size (bfd *abfd,
12905
struct bfd_link_info *info ATTRIBUTE_UNUSED,
12906
struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
12907
bfd *ibfd ATTRIBUTE_UNUSED,
12908
unsigned long symndx ATTRIBUTE_UNUSED)
12910
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12911
return bed->s->arch_size / 8;
12914
/* Routines to support the creation of dynamic relocs. */
12916
/* Returns the name of the dynamic reloc section associated with SEC. */
12918
static const char *
12919
get_dynamic_reloc_section_name (bfd * abfd,
12921
bfd_boolean is_rela)
12924
const char *old_name = bfd_get_section_name (NULL, sec);
12925
const char *prefix = is_rela ? ".rela" : ".rel";
12927
if (old_name == NULL)
12930
name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
12931
sprintf (name, "%s%s", prefix, old_name);
12936
/* Returns the dynamic reloc section associated with SEC.
12937
If necessary compute the name of the dynamic reloc section based
12938
on SEC's name (looked up in ABFD's string table) and the setting
12942
_bfd_elf_get_dynamic_reloc_section (bfd * abfd,
12944
bfd_boolean is_rela)
12946
asection * reloc_sec = elf_section_data (sec)->sreloc;
12948
if (reloc_sec == NULL)
12950
const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12954
reloc_sec = bfd_get_linker_section (abfd, name);
12956
if (reloc_sec != NULL)
12957
elf_section_data (sec)->sreloc = reloc_sec;
12964
/* Returns the dynamic reloc section associated with SEC. If the
12965
section does not exist it is created and attached to the DYNOBJ
12966
bfd and stored in the SRELOC field of SEC's elf_section_data
12969
ALIGNMENT is the alignment for the newly created section and
12970
IS_RELA defines whether the name should be .rela.<SEC's name>
12971
or .rel.<SEC's name>. The section name is looked up in the
12972
string table associated with ABFD. */
12975
_bfd_elf_make_dynamic_reloc_section (asection * sec,
12977
unsigned int alignment,
12979
bfd_boolean is_rela)
12981
asection * reloc_sec = elf_section_data (sec)->sreloc;
12983
if (reloc_sec == NULL)
12985
const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12990
reloc_sec = bfd_get_linker_section (dynobj, name);
12992
if (reloc_sec == NULL)
12994
flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
12995
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
12996
if ((sec->flags & SEC_ALLOC) != 0)
12997
flags |= SEC_ALLOC | SEC_LOAD;
12999
reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
13000
if (reloc_sec != NULL)
13002
/* _bfd_elf_get_sec_type_attr chooses a section type by
13003
name. Override as it may be wrong, eg. for a user
13004
section named "auto" we'll get ".relauto" which is
13005
seen to be a .rela section. */
13006
elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
13007
if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
13012
elf_section_data (sec)->sreloc = reloc_sec;
13018
/* Copy the ELF symbol type associated with a linker hash entry. */
13020
_bfd_elf_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED,
13021
struct bfd_link_hash_entry * hdest,
13022
struct bfd_link_hash_entry * hsrc)
13024
struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *)hdest;
13025
struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *)hsrc;
13027
ehdest->type = ehsrc->type;
13028
ehdest->target_internal = ehsrc->target_internal;
13031
/* Append a RELA relocation REL to section S in BFD. */
13034
elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13036
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13037
bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
13038
BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
13039
bed->s->swap_reloca_out (abfd, rel, loc);
13042
/* Append a REL relocation REL to section S in BFD. */
13045
elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13047
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13048
bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
13049
BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
13050
bed->s->swap_reloc_out (abfd, rel, loc);
added
removed
binutils-2.23.52.20130611/bfd/elflink.c
