Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / bfd / elflink.c
1 /* ELF linking support for BFD.
2    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3    2005, 2006, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5
6    This file is part of BFD, the Binary File Descriptor library.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #define ARCH_SIZE 0
28 #include "elf-bfd.h"
29 #include "safe-ctype.h"
30 #include "libiberty.h"
31 #include "objalloc.h"
32
33 /* This struct is used to pass information to routines called via
34    elf_link_hash_traverse which must return failure.  */
35
36 struct elf_info_failed
37 {
38   struct bfd_link_info *info;
39   struct bfd_elf_version_tree *verdefs;
40   bfd_boolean failed;
41 };
42
43 /* This structure is used to pass information to
44    _bfd_elf_link_find_version_dependencies.  */
45
46 struct elf_find_verdep_info
47 {
48   /* General link information.  */
49   struct bfd_link_info *info;
50   /* The number of dependencies.  */
51   unsigned int vers;
52   /* Whether we had a failure.  */
53   bfd_boolean failed;
54 };
55
56 static bfd_boolean _bfd_elf_fix_symbol_flags
57   (struct elf_link_hash_entry *, struct elf_info_failed *);
58
59 /* Define a symbol in a dynamic linkage section.  */
60
61 struct elf_link_hash_entry *
62 _bfd_elf_define_linkage_sym (bfd *abfd,
63                              struct bfd_link_info *info,
64                              asection *sec,
65                              const char *name)
66 {
67   struct elf_link_hash_entry *h;
68   struct bfd_link_hash_entry *bh;
69   const struct elf_backend_data *bed;
70
71   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
72   if (h != NULL)
73     {
74       /* Zap symbol defined in an as-needed lib that wasn't linked.
75          This is a symptom of a larger problem:  Absolute symbols
76          defined in shared libraries can't be overridden, because we
77          lose the link to the bfd which is via the symbol section.  */
78       h->root.type = bfd_link_hash_new;
79     }
80
81   bh = &h->root;
82   if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
83                                          sec, 0, NULL, FALSE,
84                                          get_elf_backend_data (abfd)->collect,
85                                          &bh))
86     return NULL;
87   h = (struct elf_link_hash_entry *) bh;
88   h->def_regular = 1;
89   h->non_elf = 0;
90   h->type = STT_OBJECT;
91   h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
92
93   bed = get_elf_backend_data (abfd);
94   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
95   return h;
96 }
97
98 bfd_boolean
99 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
100 {
101   flagword flags;
102   asection *s;
103   struct elf_link_hash_entry *h;
104   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
105   struct elf_link_hash_table *htab = elf_hash_table (info);
106
107   /* This function may be called more than once.  */
108   s = bfd_get_section_by_name (abfd, ".got");
109   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
110     return TRUE;
111
112   flags = bed->dynamic_sec_flags;
113
114   s = bfd_make_section_with_flags (abfd,
115                                    (bed->rela_plts_and_copies_p
116                                     ? ".rela.got" : ".rel.got"),
117                                    (bed->dynamic_sec_flags
118                                     | SEC_READONLY));
119   if (s == NULL
120       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
121     return FALSE;
122   htab->srelgot = s;
123
124   s = bfd_make_section_with_flags (abfd, ".got", flags);
125   if (s == NULL
126       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
127     return FALSE;
128   htab->sgot = s;
129
130   if (bed->want_got_plt)
131     {
132       s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
133       if (s == NULL
134           || !bfd_set_section_alignment (abfd, s,
135                                          bed->s->log_file_align))
136         return FALSE;
137       htab->sgotplt = s;
138     }
139
140   /* The first bit of the global offset table is the header.  */
141   s->size += bed->got_header_size;
142
143   if (bed->want_got_sym)
144     {
145       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
146          (or .got.plt) section.  We don't do this in the linker script
147          because we don't want to define the symbol if we are not creating
148          a global offset table.  */
149       h = _bfd_elf_define_linkage_sym (abfd, info, s,
150                                        "_GLOBAL_OFFSET_TABLE_");
151       elf_hash_table (info)->hgot = h;
152       if (h == NULL)
153         return FALSE;
154     }
155
156   return TRUE;
157 }
158 \f
159 /* Create a strtab to hold the dynamic symbol names.  */
160 static bfd_boolean
161 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
162 {
163   struct elf_link_hash_table *hash_table;
164
165   hash_table = elf_hash_table (info);
166   if (hash_table->dynobj == NULL)
167     hash_table->dynobj = abfd;
168
169   if (hash_table->dynstr == NULL)
170     {
171       hash_table->dynstr = _bfd_elf_strtab_init ();
172       if (hash_table->dynstr == NULL)
173         return FALSE;
174     }
175   return TRUE;
176 }
177
178 /* Create some sections which will be filled in with dynamic linking
179    information.  ABFD is an input file which requires dynamic sections
180    to be created.  The dynamic sections take up virtual memory space
181    when the final executable is run, so we need to create them before
182    addresses are assigned to the output sections.  We work out the
183    actual contents and size of these sections later.  */
184
185 bfd_boolean
186 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
187 {
188   flagword flags;
189   asection *s;
190   const struct elf_backend_data *bed;
191
192   if (! is_elf_hash_table (info->hash))
193     return FALSE;
194
195   if (elf_hash_table (info)->dynamic_sections_created)
196     return TRUE;
197
198   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
199     return FALSE;
200
201   abfd = elf_hash_table (info)->dynobj;
202   bed = get_elf_backend_data (abfd);
203
204   flags = bed->dynamic_sec_flags;
205
206   /* A dynamically linked executable has a .interp section, but a
207      shared library does not.  */
208   if (info->executable)
209     {
210       s = bfd_make_section_with_flags (abfd, ".interp",
211                                        flags | SEC_READONLY);
212       if (s == NULL)
213         return FALSE;
214     }
215
216   /* Create sections to hold version informations.  These are removed
217      if they are not needed.  */
218   s = bfd_make_section_with_flags (abfd, ".gnu.version_d",
219                                    flags | SEC_READONLY);
220   if (s == NULL
221       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
222     return FALSE;
223
224   s = bfd_make_section_with_flags (abfd, ".gnu.version",
225                                    flags | SEC_READONLY);
226   if (s == NULL
227       || ! bfd_set_section_alignment (abfd, s, 1))
228     return FALSE;
229
230   s = bfd_make_section_with_flags (abfd, ".gnu.version_r",
231                                    flags | SEC_READONLY);
232   if (s == NULL
233       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
234     return FALSE;
235
236   s = bfd_make_section_with_flags (abfd, ".dynsym",
237                                    flags | SEC_READONLY);
238   if (s == NULL
239       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
240     return FALSE;
241
242   s = bfd_make_section_with_flags (abfd, ".dynstr",
243                                    flags | SEC_READONLY);
244   if (s == NULL)
245     return FALSE;
246
247   s = bfd_make_section_with_flags (abfd, ".dynamic", flags);
248   if (s == NULL
249       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
250     return FALSE;
251
252   /* The special symbol _DYNAMIC is always set to the start of the
253      .dynamic section.  We could set _DYNAMIC in a linker script, but we
254      only want to define it if we are, in fact, creating a .dynamic
255      section.  We don't want to define it if there is no .dynamic
256      section, since on some ELF platforms the start up code examines it
257      to decide how to initialize the process.  */
258   if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"))
259     return FALSE;
260
261   if (info->emit_hash)
262     {
263       s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY);
264       if (s == NULL
265           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
266         return FALSE;
267       elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
268     }
269
270   if (info->emit_gnu_hash)
271     {
272       s = bfd_make_section_with_flags (abfd, ".gnu.hash",
273                                        flags | SEC_READONLY);
274       if (s == NULL
275           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
276         return FALSE;
277       /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
278          4 32-bit words followed by variable count of 64-bit words, then
279          variable count of 32-bit words.  */
280       if (bed->s->arch_size == 64)
281         elf_section_data (s)->this_hdr.sh_entsize = 0;
282       else
283         elf_section_data (s)->this_hdr.sh_entsize = 4;
284     }
285
286   /* Let the backend create the rest of the sections.  This lets the
287      backend set the right flags.  The backend will normally create
288      the .got and .plt sections.  */
289   if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
290     return FALSE;
291
292   elf_hash_table (info)->dynamic_sections_created = TRUE;
293
294   return TRUE;
295 }
296
297 /* Create dynamic sections when linking against a dynamic object.  */
298
299 bfd_boolean
300 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
301 {
302   flagword flags, pltflags;
303   struct elf_link_hash_entry *h;
304   asection *s;
305   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
306   struct elf_link_hash_table *htab = elf_hash_table (info);
307
308   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
309      .rel[a].bss sections.  */
310   flags = bed->dynamic_sec_flags;
311
312   pltflags = flags;
313   if (bed->plt_not_loaded)
314     /* We do not clear SEC_ALLOC here because we still want the OS to
315        allocate space for the section; it's just that there's nothing
316        to read in from the object file.  */
317     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
318   else
319     pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
320   if (bed->plt_readonly)
321     pltflags |= SEC_READONLY;
322
323   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
324   if (s == NULL
325       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
326     return FALSE;
327   htab->splt = s;
328
329   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
330      .plt section.  */
331   if (bed->want_plt_sym)
332     {
333       h = _bfd_elf_define_linkage_sym (abfd, info, s,
334                                        "_PROCEDURE_LINKAGE_TABLE_");
335       elf_hash_table (info)->hplt = h;
336       if (h == NULL)
337         return FALSE;
338     }
339
340   s = bfd_make_section_with_flags (abfd,
341                                    (bed->rela_plts_and_copies_p
342                                     ? ".rela.plt" : ".rel.plt"),
343                                    flags | SEC_READONLY);
344   if (s == NULL
345       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
346     return FALSE;
347   htab->srelplt = s;
348
349   if (! _bfd_elf_create_got_section (abfd, info))
350     return FALSE;
351
352   if (bed->want_dynbss)
353     {
354       /* The .dynbss section is a place to put symbols which are defined
355          by dynamic objects, are referenced by regular objects, and are
356          not functions.  We must allocate space for them in the process
357          image and use a R_*_COPY reloc to tell the dynamic linker to
358          initialize them at run time.  The linker script puts the .dynbss
359          section into the .bss section of the final image.  */
360       s = bfd_make_section_with_flags (abfd, ".dynbss",
361                                        (SEC_ALLOC
362                                         | SEC_LINKER_CREATED));
363       if (s == NULL)
364         return FALSE;
365
366       /* The .rel[a].bss section holds copy relocs.  This section is not
367          normally needed.  We need to create it here, though, so that the
368          linker will map it to an output section.  We can't just create it
369          only if we need it, because we will not know whether we need it
370          until we have seen all the input files, and the first time the
371          main linker code calls BFD after examining all the input files
372          (size_dynamic_sections) the input sections have already been
373          mapped to the output sections.  If the section turns out not to
374          be needed, we can discard it later.  We will never need this
375          section when generating a shared object, since they do not use
376          copy relocs.  */
377       if (! info->shared)
378         {
379           s = bfd_make_section_with_flags (abfd,
380                                            (bed->rela_plts_and_copies_p
381                                             ? ".rela.bss" : ".rel.bss"),
382                                            flags | SEC_READONLY);
383           if (s == NULL
384               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
385             return FALSE;
386         }
387     }
388
389   return TRUE;
390 }
391 \f
392 /* Record a new dynamic symbol.  We record the dynamic symbols as we
393    read the input files, since we need to have a list of all of them
394    before we can determine the final sizes of the output sections.
395    Note that we may actually call this function even though we are not
396    going to output any dynamic symbols; in some cases we know that a
397    symbol should be in the dynamic symbol table, but only if there is
398    one.  */
399
400 bfd_boolean
401 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
402                                     struct elf_link_hash_entry *h)
403 {
404   if (h->dynindx == -1)
405     {
406       struct elf_strtab_hash *dynstr;
407       char *p;
408       const char *name;
409       bfd_size_type indx;
410
411       /* XXX: The ABI draft says the linker must turn hidden and
412          internal symbols into STB_LOCAL symbols when producing the
413          DSO. However, if ld.so honors st_other in the dynamic table,
414          this would not be necessary.  */
415       switch (ELF_ST_VISIBILITY (h->other))
416         {
417         case STV_INTERNAL:
418         case STV_HIDDEN:
419           if (h->root.type != bfd_link_hash_undefined
420               && h->root.type != bfd_link_hash_undefweak)
421             {
422               h->forced_local = 1;
423               if (!elf_hash_table (info)->is_relocatable_executable)
424                 return TRUE;
425             }
426
427         default:
428           break;
429         }
430
431       h->dynindx = elf_hash_table (info)->dynsymcount;
432       ++elf_hash_table (info)->dynsymcount;
433
434       dynstr = elf_hash_table (info)->dynstr;
435       if (dynstr == NULL)
436         {
437           /* Create a strtab to hold the dynamic symbol names.  */
438           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
439           if (dynstr == NULL)
440             return FALSE;
441         }
442
443       /* We don't put any version information in the dynamic string
444          table.  */
445       name = h->root.root.string;
446       p = strchr (name, ELF_VER_CHR);
447       if (p != NULL)
448         /* We know that the p points into writable memory.  In fact,
449            there are only a few symbols that have read-only names, being
450            those like _GLOBAL_OFFSET_TABLE_ that are created specially
451            by the backends.  Most symbols will have names pointing into
452            an ELF string table read from a file, or to objalloc memory.  */
453         *p = 0;
454
455       indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
456
457       if (p != NULL)
458         *p = ELF_VER_CHR;
459
460       if (indx == (bfd_size_type) -1)
461         return FALSE;
462       h->dynstr_index = indx;
463     }
464
465   return TRUE;
466 }
467 \f
468 /* Mark a symbol dynamic.  */
469
470 static void
471 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
472                                   struct elf_link_hash_entry *h,
473                                   Elf_Internal_Sym *sym)
474 {
475   struct bfd_elf_dynamic_list *d = info->dynamic_list;
476
477   /* It may be called more than once on the same H.  */
478   if(h->dynamic || info->relocatable)
479     return;
480
481   if ((info->dynamic_data
482        && (h->type == STT_OBJECT
483            || (sym != NULL
484                && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
485       || (d != NULL
486           && h->root.type == bfd_link_hash_new
487           && (*d->match) (&d->head, NULL, h->root.root.string)))
488     h->dynamic = 1;
489 }
490
491 /* Record an assignment to a symbol made by a linker script.  We need
492    this in case some dynamic object refers to this symbol.  */
493
494 bfd_boolean
495 bfd_elf_record_link_assignment (bfd *output_bfd,
496                                 struct bfd_link_info *info,
497                                 const char *name,
498                                 bfd_boolean provide,
499                                 bfd_boolean hidden)
500 {
501   struct elf_link_hash_entry *h, *hv;
502   struct elf_link_hash_table *htab;
503   const struct elf_backend_data *bed;
504
505   if (!is_elf_hash_table (info->hash))
506     return TRUE;
507
508   htab = elf_hash_table (info);
509   h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
510   if (h == NULL)
511     return provide;
512
513   switch (h->root.type)
514     {
515     case bfd_link_hash_defined:
516     case bfd_link_hash_defweak:
517     case bfd_link_hash_common:
518       break;
519     case bfd_link_hash_undefweak:
520     case bfd_link_hash_undefined:
521       /* Since we're defining the symbol, don't let it seem to have not
522          been defined.  record_dynamic_symbol and size_dynamic_sections
523          may depend on this.  */
524       h->root.type = bfd_link_hash_new;
525       if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
526         bfd_link_repair_undef_list (&htab->root);
527       break;
528     case bfd_link_hash_new:
529       bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
530       h->non_elf = 0;
531       break;
532     case bfd_link_hash_indirect:
533       /* We had a versioned symbol in a dynamic library.  We make the
534          the versioned symbol point to this one.  */
535       bed = get_elf_backend_data (output_bfd);
536       hv = h;
537       while (hv->root.type == bfd_link_hash_indirect
538              || hv->root.type == bfd_link_hash_warning)
539         hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
540       /* We don't need to update h->root.u since linker will set them
541          later.  */
542       h->root.type = bfd_link_hash_undefined;
543       hv->root.type = bfd_link_hash_indirect;
544       hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
545       (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
546       break;
547     case bfd_link_hash_warning:
548       abort ();
549       break;
550     }
551
552   /* If this symbol is being provided by the linker script, and it is
553      currently defined by a dynamic object, but not by a regular
554      object, then mark it as undefined so that the generic linker will
555      force the correct value.  */
556   if (provide
557       && h->def_dynamic
558       && !h->def_regular)
559     h->root.type = bfd_link_hash_undefined;
560
561   /* If this symbol is not being provided by the linker script, and it is
562      currently defined by a dynamic object, but not by a regular object,
563      then clear out any version information because the symbol will not be
564      associated with the dynamic object any more.  */
565   if (!provide
566       && h->def_dynamic
567       && !h->def_regular)
568     h->verinfo.verdef = NULL;
569
570   h->def_regular = 1;
571
572   if (provide && hidden)
573     {
574       bed = get_elf_backend_data (output_bfd);
575       h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
576       (*bed->elf_backend_hide_symbol) (info, h, TRUE);
577     }
578
579   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
580      and executables.  */
581   if (!info->relocatable
582       && h->dynindx != -1
583       && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
584           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
585     h->forced_local = 1;
586
587   if ((h->def_dynamic
588        || h->ref_dynamic
589        || info->shared
590        || (info->executable && elf_hash_table (info)->is_relocatable_executable))
591       && h->dynindx == -1)
592     {
593       if (! bfd_elf_link_record_dynamic_symbol (info, h))
594         return FALSE;
595
596       /* If this is a weak defined symbol, and we know a corresponding
597          real symbol from the same dynamic object, make sure the real
598          symbol is also made into a dynamic symbol.  */
599       if (h->u.weakdef != NULL
600           && h->u.weakdef->dynindx == -1)
601         {
602           if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
603             return FALSE;
604         }
605     }
606
607   return TRUE;
608 }
609
610 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
611    success, and 2 on a failure caused by attempting to record a symbol
612    in a discarded section, eg. a discarded link-once section symbol.  */
613
614 int
615 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
616                                           bfd *input_bfd,
617                                           long input_indx)
618 {
619   bfd_size_type amt;
620   struct elf_link_local_dynamic_entry *entry;
621   struct elf_link_hash_table *eht;
622   struct elf_strtab_hash *dynstr;
623   unsigned long dynstr_index;
624   char *name;
625   Elf_External_Sym_Shndx eshndx;
626   char esym[sizeof (Elf64_External_Sym)];
627
628   if (! is_elf_hash_table (info->hash))
629     return 0;
630
631   /* See if the entry exists already.  */
632   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
633     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
634       return 1;
635
636   amt = sizeof (*entry);
637   entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
638   if (entry == NULL)
639     return 0;
640
641   /* Go find the symbol, so that we can find it's name.  */
642   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
643                              1, input_indx, &entry->isym, esym, &eshndx))
644     {
645       bfd_release (input_bfd, entry);
646       return 0;
647     }
648
649   if (entry->isym.st_shndx != SHN_UNDEF
650       && entry->isym.st_shndx < SHN_LORESERVE)
651     {
652       asection *s;
653
654       s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
655       if (s == NULL || bfd_is_abs_section (s->output_section))
656         {
657           /* We can still bfd_release here as nothing has done another
658              bfd_alloc.  We can't do this later in this function.  */
659           bfd_release (input_bfd, entry);
660           return 2;
661         }
662     }
663
664   name = (bfd_elf_string_from_elf_section
665           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
666            entry->isym.st_name));
667
668   dynstr = elf_hash_table (info)->dynstr;
669   if (dynstr == NULL)
670     {
671       /* Create a strtab to hold the dynamic symbol names.  */
672       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
673       if (dynstr == NULL)
674         return 0;
675     }
676
677   dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
678   if (dynstr_index == (unsigned long) -1)
679     return 0;
680   entry->isym.st_name = dynstr_index;
681
682   eht = elf_hash_table (info);
683
684   entry->next = eht->dynlocal;
685   eht->dynlocal = entry;
686   entry->input_bfd = input_bfd;
687   entry->input_indx = input_indx;
688   eht->dynsymcount++;
689
690   /* Whatever binding the symbol had before, it's now local.  */
691   entry->isym.st_info
692     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
693
694   /* The dynindx will be set at the end of size_dynamic_sections.  */
695
696   return 1;
697 }
698
699 /* Return the dynindex of a local dynamic symbol.  */
700
701 long
702 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
703                                     bfd *input_bfd,
704                                     long input_indx)
705 {
706   struct elf_link_local_dynamic_entry *e;
707
708   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
709     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
710       return e->dynindx;
711   return -1;
712 }
713
714 /* This function is used to renumber the dynamic symbols, if some of
715    them are removed because they are marked as local.  This is called
716    via elf_link_hash_traverse.  */
717
718 static bfd_boolean
719 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
720                                       void *data)
721 {
722   size_t *count = (size_t *) data;
723
724   if (h->root.type == bfd_link_hash_warning)
725     h = (struct elf_link_hash_entry *) h->root.u.i.link;
726
727   if (h->forced_local)
728     return TRUE;
729
730   if (h->dynindx != -1)
731     h->dynindx = ++(*count);
732
733   return TRUE;
734 }
735
736
737 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
738    STB_LOCAL binding.  */
739
740 static bfd_boolean
741 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
742                                             void *data)
743 {
744   size_t *count = (size_t *) data;
745
746   if (h->root.type == bfd_link_hash_warning)
747     h = (struct elf_link_hash_entry *) h->root.u.i.link;
748
749   if (!h->forced_local)
750     return TRUE;
751
752   if (h->dynindx != -1)
753     h->dynindx = ++(*count);
754
755   return TRUE;
756 }
757
758 /* Return true if the dynamic symbol for a given section should be
759    omitted when creating a shared library.  */
760 bfd_boolean
761 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
762                                    struct bfd_link_info *info,
763                                    asection *p)
764 {
765   struct elf_link_hash_table *htab;
766
767   switch (elf_section_data (p)->this_hdr.sh_type)
768     {
769     case SHT_PROGBITS:
770     case SHT_NOBITS:
771       /* If sh_type is yet undecided, assume it could be
772          SHT_PROGBITS/SHT_NOBITS.  */
773     case SHT_NULL:
774       htab = elf_hash_table (info);
775       if (p == htab->tls_sec)
776         return FALSE;
777
778       if (htab->text_index_section != NULL)
779         return p != htab->text_index_section && p != htab->data_index_section;
780
781       if (strcmp (p->name, ".got") == 0
782           || strcmp (p->name, ".got.plt") == 0
783           || strcmp (p->name, ".plt") == 0)
784         {
785           asection *ip;
786
787           if (htab->dynobj != NULL
788               && (ip = bfd_get_section_by_name (htab->dynobj, p->name)) != NULL
789               && (ip->flags & SEC_LINKER_CREATED)
790               && ip->output_section == p)
791             return TRUE;
792         }
793       return FALSE;
794
795       /* There shouldn't be section relative relocations
796          against any other section.  */
797     default:
798       return TRUE;
799     }
800 }
801
802 /* Assign dynsym indices.  In a shared library we generate a section
803    symbol for each output section, which come first.  Next come symbols
804    which have been forced to local binding.  Then all of the back-end
805    allocated local dynamic syms, followed by the rest of the global
806    symbols.  */
807
808 static unsigned long
809 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
810                                 struct bfd_link_info *info,
811                                 unsigned long *section_sym_count)
812 {
813   unsigned long dynsymcount = 0;
814
815   if (info->shared || elf_hash_table (info)->is_relocatable_executable)
816     {
817       const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
818       asection *p;
819       for (p = output_bfd->sections; p ; p = p->next)
820         if ((p->flags & SEC_EXCLUDE) == 0
821             && (p->flags & SEC_ALLOC) != 0
822             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
823           elf_section_data (p)->dynindx = ++dynsymcount;
824         else
825           elf_section_data (p)->dynindx = 0;
826     }
827   *section_sym_count = dynsymcount;
828
829   elf_link_hash_traverse (elf_hash_table (info),
830                           elf_link_renumber_local_hash_table_dynsyms,
831                           &dynsymcount);
832
833   if (elf_hash_table (info)->dynlocal)
834     {
835       struct elf_link_local_dynamic_entry *p;
836       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
837         p->dynindx = ++dynsymcount;
838     }
839
840   elf_link_hash_traverse (elf_hash_table (info),
841                           elf_link_renumber_hash_table_dynsyms,
842                           &dynsymcount);
843
844   /* There is an unused NULL entry at the head of the table which
845      we must account for in our count.  Unless there weren't any
846      symbols, which means we'll have no table at all.  */
847   if (dynsymcount != 0)
848     ++dynsymcount;
849
850   elf_hash_table (info)->dynsymcount = dynsymcount;
851   return dynsymcount;
852 }
853
854 /* Merge st_other field.  */
855
856 static void
857 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
858                     Elf_Internal_Sym *isym, bfd_boolean definition,
859                     bfd_boolean dynamic)
860 {
861   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
862
863   /* If st_other has a processor-specific meaning, specific
864      code might be needed here. We never merge the visibility
865      attribute with the one from a dynamic object.  */
866   if (bed->elf_backend_merge_symbol_attribute)
867     (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
868                                                 dynamic);
869
870   /* If this symbol has default visibility and the user has requested
871      we not re-export it, then mark it as hidden.  */
872   if (definition
873       && !dynamic
874       && (abfd->no_export
875           || (abfd->my_archive && abfd->my_archive->no_export))
876       && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
877     isym->st_other = (STV_HIDDEN
878                       | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
879
880   if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0)
881     {
882       unsigned char hvis, symvis, other, nvis;
883
884       /* Only merge the visibility. Leave the remainder of the
885          st_other field to elf_backend_merge_symbol_attribute.  */
886       other = h->other & ~ELF_ST_VISIBILITY (-1);
887
888       /* Combine visibilities, using the most constraining one.  */
889       hvis = ELF_ST_VISIBILITY (h->other);
890       symvis = ELF_ST_VISIBILITY (isym->st_other);
891       if (! hvis)
892         nvis = symvis;
893       else if (! symvis)
894         nvis = hvis;
895       else
896         nvis = hvis < symvis ? hvis : symvis;
897
898       h->other = other | nvis;
899     }
900 }
901
902 /* This function is called when we want to define a new symbol.  It
903    handles the various cases which arise when we find a definition in
904    a dynamic object, or when there is already a definition in a
905    dynamic object.  The new symbol is described by NAME, SYM, PSEC,
906    and PVALUE.  We set SYM_HASH to the hash table entry.  We set
907    OVERRIDE if the old symbol is overriding a new definition.  We set
908    TYPE_CHANGE_OK if it is OK for the type to change.  We set
909    SIZE_CHANGE_OK if it is OK for the size to change.  By OK to
910    change, we mean that we shouldn't warn if the type or size does
911    change.  We set POLD_ALIGNMENT if an old common symbol in a dynamic
912    object is overridden by a regular object.  */
913
914 bfd_boolean
915 _bfd_elf_merge_symbol (bfd *abfd,
916                        struct bfd_link_info *info,
917                        const char *name,
918                        Elf_Internal_Sym *sym,
919                        asection **psec,
920                        bfd_vma *pvalue,
921                        unsigned int *pold_alignment,
922                        struct elf_link_hash_entry **sym_hash,
923                        bfd_boolean *skip,
924                        bfd_boolean *override,
925                        bfd_boolean *type_change_ok,
926                        bfd_boolean *size_change_ok)
927 {
928   asection *sec, *oldsec;
929   struct elf_link_hash_entry *h;
930   struct elf_link_hash_entry *flip;
931   int bind;
932   bfd *oldbfd;
933   bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
934   bfd_boolean newweak, oldweak, newfunc, oldfunc;
935   const struct elf_backend_data *bed;
936
937   *skip = FALSE;
938   *override = FALSE;
939
940   sec = *psec;
941   bind = ELF_ST_BIND (sym->st_info);
942
943   /* Silently discard TLS symbols from --just-syms.  There's no way to
944      combine a static TLS block with a new TLS block for this executable.  */
945   if (ELF_ST_TYPE (sym->st_info) == STT_TLS
946       && sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
947     {
948       *skip = TRUE;
949       return TRUE;
950     }
951
952   if (! bfd_is_und_section (sec))
953     h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
954   else
955     h = ((struct elf_link_hash_entry *)
956          bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
957   if (h == NULL)
958     return FALSE;
959   *sym_hash = h;
960
961   bed = get_elf_backend_data (abfd);
962
963   /* This code is for coping with dynamic objects, and is only useful
964      if we are doing an ELF link.  */
965   if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
966     return TRUE;
967
968   /* For merging, we only care about real symbols.  */
969
970   while (h->root.type == bfd_link_hash_indirect
971          || h->root.type == bfd_link_hash_warning)
972     h = (struct elf_link_hash_entry *) h->root.u.i.link;
973
974   /* We have to check it for every instance since the first few may be
975      refereences and not all compilers emit symbol type for undefined
976      symbols.  */
977   bfd_elf_link_mark_dynamic_symbol (info, h, sym);
978
979   /* If we just created the symbol, mark it as being an ELF symbol.
980      Other than that, there is nothing to do--there is no merge issue
981      with a newly defined symbol--so we just return.  */
982
983   if (h->root.type == bfd_link_hash_new)
984     {
985       h->non_elf = 0;
986       return TRUE;
987     }
988
989   /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
990      existing symbol.  */
991
992   switch (h->root.type)
993     {
994     default:
995       oldbfd = NULL;
996       oldsec = NULL;
997       break;
998
999     case bfd_link_hash_undefined:
1000     case bfd_link_hash_undefweak:
1001       oldbfd = h->root.u.undef.abfd;
1002       oldsec = NULL;
1003       break;
1004
1005     case bfd_link_hash_defined:
1006     case bfd_link_hash_defweak:
1007       oldbfd = h->root.u.def.section->owner;
1008       oldsec = h->root.u.def.section;
1009       break;
1010
1011     case bfd_link_hash_common:
1012       oldbfd = h->root.u.c.p->section->owner;
1013       oldsec = h->root.u.c.p->section;
1014       break;
1015     }
1016
1017   /* Differentiate strong and weak symbols.  */
1018   newweak = bind == STB_WEAK;
1019   oldweak = (h->root.type == bfd_link_hash_defweak
1020              || h->root.type == bfd_link_hash_undefweak);
1021
1022   /* In cases involving weak versioned symbols, we may wind up trying
1023      to merge a symbol with itself.  Catch that here, to avoid the
1024      confusion that results if we try to override a symbol with
1025      itself.  The additional tests catch cases like
1026      _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1027      dynamic object, which we do want to handle here.  */
1028   if (abfd == oldbfd
1029       && (newweak || oldweak)
1030       && ((abfd->flags & DYNAMIC) == 0
1031           || !h->def_regular))
1032     return TRUE;
1033
1034   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1035      respectively, is from a dynamic object.  */
1036
1037   newdyn = (abfd->flags & DYNAMIC) != 0;
1038
1039   olddyn = FALSE;
1040   if (oldbfd != NULL)
1041     olddyn = (oldbfd->flags & DYNAMIC) != 0;
1042   else if (oldsec != NULL)
1043     {
1044       /* This handles the special SHN_MIPS_{TEXT,DATA} section
1045          indices used by MIPS ELF.  */
1046       olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1047     }
1048
1049   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1050      respectively, appear to be a definition rather than reference.  */
1051
1052   newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1053
1054   olddef = (h->root.type != bfd_link_hash_undefined
1055             && h->root.type != bfd_link_hash_undefweak
1056             && h->root.type != bfd_link_hash_common);
1057
1058   /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1059      respectively, appear to be a function.  */
1060
1061   newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1062              && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1063
1064   oldfunc = (h->type != STT_NOTYPE
1065              && bed->is_function_type (h->type));
1066
1067   /* When we try to create a default indirect symbol from the dynamic
1068      definition with the default version, we skip it if its type and
1069      the type of existing regular definition mismatch.  We only do it
1070      if the existing regular definition won't be dynamic.  */
1071   if (pold_alignment == NULL
1072       && !info->shared
1073       && !info->export_dynamic
1074       && !h->ref_dynamic
1075       && newdyn
1076       && newdef
1077       && !olddyn
1078       && (olddef || h->root.type == bfd_link_hash_common)
1079       && ELF_ST_TYPE (sym->st_info) != h->type
1080       && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1081       && h->type != STT_NOTYPE
1082       && !(newfunc && oldfunc))
1083     {
1084       *skip = TRUE;
1085       return TRUE;
1086     }
1087
1088   /* Plugin symbol type isn't currently set.  Stop bogus errors.  */
1089   if (oldbfd != NULL && (oldbfd->flags & BFD_PLUGIN) != 0)
1090     *type_change_ok = TRUE;
1091
1092   /* Check TLS symbol.  We don't check undefined symbol introduced by
1093      "ld -u".  */
1094   else if (oldbfd != NULL
1095            && ELF_ST_TYPE (sym->st_info) != h->type
1096            && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1097     {
1098       bfd *ntbfd, *tbfd;
1099       bfd_boolean ntdef, tdef;
1100       asection *ntsec, *tsec;
1101
1102       if (h->type == STT_TLS)
1103         {
1104           ntbfd = abfd;
1105           ntsec = sec;
1106           ntdef = newdef;
1107           tbfd = oldbfd;
1108           tsec = oldsec;
1109           tdef = olddef;
1110         }
1111       else
1112         {
1113           ntbfd = oldbfd;
1114           ntsec = oldsec;
1115           ntdef = olddef;
1116           tbfd = abfd;
1117           tsec = sec;
1118           tdef = newdef;
1119         }
1120
1121       if (tdef && ntdef)
1122         (*_bfd_error_handler)
1123           (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1124            tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1125       else if (!tdef && !ntdef)
1126         (*_bfd_error_handler)
1127           (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1128            tbfd, ntbfd, h->root.root.string);
1129       else if (tdef)
1130         (*_bfd_error_handler)
1131           (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1132            tbfd, tsec, ntbfd, h->root.root.string);
1133       else
1134         (*_bfd_error_handler)
1135           (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1136            tbfd, ntbfd, ntsec, h->root.root.string);
1137
1138       bfd_set_error (bfd_error_bad_value);
1139       return FALSE;
1140     }
1141
1142   /* We need to remember if a symbol has a definition in a dynamic
1143      object or is weak in all dynamic objects. Internal and hidden
1144      visibility will make it unavailable to dynamic objects.  */
1145   if (newdyn && !h->dynamic_def)
1146     {
1147       if (!bfd_is_und_section (sec))
1148         h->dynamic_def = 1;
1149       else
1150         {
1151           /* Check if this symbol is weak in all dynamic objects. If it
1152              is the first time we see it in a dynamic object, we mark
1153              if it is weak. Otherwise, we clear it.  */
1154           if (!h->ref_dynamic)
1155             {
1156               if (bind == STB_WEAK)
1157                 h->dynamic_weak = 1;
1158             }
1159           else if (bind != STB_WEAK)
1160             h->dynamic_weak = 0;
1161         }
1162     }
1163
1164   /* If the old symbol has non-default visibility, we ignore the new
1165      definition from a dynamic object.  */
1166   if (newdyn
1167       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1168       && !bfd_is_und_section (sec))
1169     {
1170       *skip = TRUE;
1171       /* Make sure this symbol is dynamic.  */
1172       h->ref_dynamic = 1;
1173       /* A protected symbol has external availability. Make sure it is
1174          recorded as dynamic.
1175
1176          FIXME: Should we check type and size for protected symbol?  */
1177       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1178         return bfd_elf_link_record_dynamic_symbol (info, h);
1179       else
1180         return TRUE;
1181     }
1182   else if (!newdyn
1183            && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1184            && h->def_dynamic)
1185     {
1186       /* If the new symbol with non-default visibility comes from a
1187          relocatable file and the old definition comes from a dynamic
1188          object, we remove the old definition.  */
1189       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1190         {
1191           /* Handle the case where the old dynamic definition is
1192              default versioned.  We need to copy the symbol info from
1193              the symbol with default version to the normal one if it
1194              was referenced before.  */
1195           if (h->ref_regular)
1196             {
1197               struct elf_link_hash_entry *vh = *sym_hash;
1198
1199               vh->root.type = h->root.type;
1200               h->root.type = bfd_link_hash_indirect;
1201               (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
1202               /* Protected symbols will override the dynamic definition
1203                  with default version.  */
1204               if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED)
1205                 {
1206                   h->root.u.i.link = (struct bfd_link_hash_entry *) vh;
1207                   vh->dynamic_def = 1;
1208                   vh->ref_dynamic = 1;
1209                 }
1210               else
1211                 {
1212                   h->root.type = vh->root.type;
1213                   vh->ref_dynamic = 0;
1214                   /* We have to hide it here since it was made dynamic
1215                      global with extra bits when the symbol info was
1216                      copied from the old dynamic definition.  */
1217                   (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
1218                 }
1219               h = vh;
1220             }
1221           else
1222             h = *sym_hash;
1223         }
1224
1225       if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1226           && bfd_is_und_section (sec))
1227         {
1228           /* If the new symbol is undefined and the old symbol was
1229              also undefined before, we need to make sure
1230              _bfd_generic_link_add_one_symbol doesn't mess
1231              up the linker hash table undefs list.  Since the old
1232              definition came from a dynamic object, it is still on the
1233              undefs list.  */
1234           h->root.type = bfd_link_hash_undefined;
1235           h->root.u.undef.abfd = abfd;
1236         }
1237       else
1238         {
1239           h->root.type = bfd_link_hash_new;
1240           h->root.u.undef.abfd = NULL;
1241         }
1242
1243       if (h->def_dynamic)
1244         {
1245           h->def_dynamic = 0;
1246           h->ref_dynamic = 1;
1247           h->dynamic_def = 1;
1248         }
1249       /* FIXME: Should we check type and size for protected symbol?  */
1250       h->size = 0;
1251       h->type = 0;
1252       return TRUE;
1253     }
1254
1255   if (bind == STB_GNU_UNIQUE)
1256     h->unique_global = 1;
1257
1258   /* If a new weak symbol definition comes from a regular file and the
1259      old symbol comes from a dynamic library, we treat the new one as
1260      strong.  Similarly, an old weak symbol definition from a regular
1261      file is treated as strong when the new symbol comes from a dynamic
1262      library.  Further, an old weak symbol from a dynamic library is
1263      treated as strong if the new symbol is from a dynamic library.
1264      This reflects the way glibc's ld.so works.
1265
1266      Do this before setting *type_change_ok or *size_change_ok so that
1267      we warn properly when dynamic library symbols are overridden.  */
1268
1269   if (newdef && !newdyn && olddyn)
1270     newweak = FALSE;
1271   if (olddef && newdyn)
1272     oldweak = FALSE;
1273
1274   /* Allow changes between different types of function symbol.  */
1275   if (newfunc && oldfunc)
1276     *type_change_ok = TRUE;
1277
1278   /* It's OK to change the type if either the existing symbol or the
1279      new symbol is weak.  A type change is also OK if the old symbol
1280      is undefined and the new symbol is defined.  */
1281
1282   if (oldweak
1283       || newweak
1284       || (newdef
1285           && h->root.type == bfd_link_hash_undefined))
1286     *type_change_ok = TRUE;
1287
1288   /* It's OK to change the size if either the existing symbol or the
1289      new symbol is weak, or if the old symbol is undefined.  */
1290
1291   if (*type_change_ok
1292       || h->root.type == bfd_link_hash_undefined)
1293     *size_change_ok = TRUE;
1294
1295   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1296      symbol, respectively, appears to be a common symbol in a dynamic
1297      object.  If a symbol appears in an uninitialized section, and is
1298      not weak, and is not a function, then it may be a common symbol
1299      which was resolved when the dynamic object was created.  We want
1300      to treat such symbols specially, because they raise special
1301      considerations when setting the symbol size: if the symbol
1302      appears as a common symbol in a regular object, and the size in
1303      the regular object is larger, we must make sure that we use the
1304      larger size.  This problematic case can always be avoided in C,
1305      but it must be handled correctly when using Fortran shared
1306      libraries.
1307
1308      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1309      likewise for OLDDYNCOMMON and OLDDEF.
1310
1311      Note that this test is just a heuristic, and that it is quite
1312      possible to have an uninitialized symbol in a shared object which
1313      is really a definition, rather than a common symbol.  This could
1314      lead to some minor confusion when the symbol really is a common
1315      symbol in some regular object.  However, I think it will be
1316      harmless.  */
1317
1318   if (newdyn
1319       && newdef
1320       && !newweak
1321       && (sec->flags & SEC_ALLOC) != 0
1322       && (sec->flags & SEC_LOAD) == 0
1323       && sym->st_size > 0
1324       && !newfunc)
1325     newdyncommon = TRUE;
1326   else
1327     newdyncommon = FALSE;
1328
1329   if (olddyn
1330       && olddef
1331       && h->root.type == bfd_link_hash_defined
1332       && h->def_dynamic
1333       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1334       && (h->root.u.def.section->flags & SEC_LOAD) == 0
1335       && h->size > 0
1336       && !oldfunc)
1337     olddyncommon = TRUE;
1338   else
1339     olddyncommon = FALSE;
1340
1341   /* We now know everything about the old and new symbols.  We ask the
1342      backend to check if we can merge them.  */
1343   if (bed->merge_symbol
1344       && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue,
1345                              pold_alignment, skip, override,
1346                              type_change_ok, size_change_ok,
1347                              &newdyn, &newdef, &newdyncommon, &newweak,
1348                              abfd, &sec,
1349                              &olddyn, &olddef, &olddyncommon, &oldweak,
1350                              oldbfd, &oldsec))
1351     return FALSE;
1352
1353   /* If both the old and the new symbols look like common symbols in a
1354      dynamic object, set the size of the symbol to the larger of the
1355      two.  */
1356
1357   if (olddyncommon
1358       && newdyncommon
1359       && sym->st_size != h->size)
1360     {
1361       /* Since we think we have two common symbols, issue a multiple
1362          common warning if desired.  Note that we only warn if the
1363          size is different.  If the size is the same, we simply let
1364          the old symbol override the new one as normally happens with
1365          symbols defined in dynamic objects.  */
1366
1367       if (! ((*info->callbacks->multiple_common)
1368              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1369         return FALSE;
1370
1371       if (sym->st_size > h->size)
1372         h->size = sym->st_size;
1373
1374       *size_change_ok = TRUE;
1375     }
1376
1377   /* If we are looking at a dynamic object, and we have found a
1378      definition, we need to see if the symbol was already defined by
1379      some other object.  If so, we want to use the existing
1380      definition, and we do not want to report a multiple symbol
1381      definition error; we do this by clobbering *PSEC to be
1382      bfd_und_section_ptr.
1383
1384      We treat a common symbol as a definition if the symbol in the
1385      shared library is a function, since common symbols always
1386      represent variables; this can cause confusion in principle, but
1387      any such confusion would seem to indicate an erroneous program or
1388      shared library.  We also permit a common symbol in a regular
1389      object to override a weak symbol in a shared object.  */
1390
1391   if (newdyn
1392       && newdef
1393       && (olddef
1394           || (h->root.type == bfd_link_hash_common
1395               && (newweak || newfunc))))
1396     {
1397       *override = TRUE;
1398       newdef = FALSE;
1399       newdyncommon = FALSE;
1400
1401       *psec = sec = bfd_und_section_ptr;
1402       *size_change_ok = TRUE;
1403
1404       /* If we get here when the old symbol is a common symbol, then
1405          we are explicitly letting it override a weak symbol or
1406          function in a dynamic object, and we don't want to warn about
1407          a type change.  If the old symbol is a defined symbol, a type
1408          change warning may still be appropriate.  */
1409
1410       if (h->root.type == bfd_link_hash_common)
1411         *type_change_ok = TRUE;
1412     }
1413
1414   /* Handle the special case of an old common symbol merging with a
1415      new symbol which looks like a common symbol in a shared object.
1416      We change *PSEC and *PVALUE to make the new symbol look like a
1417      common symbol, and let _bfd_generic_link_add_one_symbol do the
1418      right thing.  */
1419
1420   if (newdyncommon
1421       && h->root.type == bfd_link_hash_common)
1422     {
1423       *override = TRUE;
1424       newdef = FALSE;
1425       newdyncommon = FALSE;
1426       *pvalue = sym->st_size;
1427       *psec = sec = bed->common_section (oldsec);
1428       *size_change_ok = TRUE;
1429     }
1430
1431   /* Skip weak definitions of symbols that are already defined.  */
1432   if (newdef && olddef && newweak)
1433     {
1434       /* Don't skip new non-IR weak syms.  */
1435       if (!(oldbfd != NULL
1436             && (oldbfd->flags & BFD_PLUGIN) != 0
1437             && (abfd->flags & BFD_PLUGIN) == 0))
1438         *skip = TRUE;
1439
1440       /* Merge st_other.  If the symbol already has a dynamic index,
1441          but visibility says it should not be visible, turn it into a
1442          local symbol.  */
1443       elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1444       if (h->dynindx != -1)
1445         switch (ELF_ST_VISIBILITY (h->other))
1446           {
1447           case STV_INTERNAL:
1448           case STV_HIDDEN:
1449             (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1450             break;
1451           }
1452     }
1453
1454   /* If the old symbol is from a dynamic object, and the new symbol is
1455      a definition which is not from a dynamic object, then the new
1456      symbol overrides the old symbol.  Symbols from regular files
1457      always take precedence over symbols from dynamic objects, even if
1458      they are defined after the dynamic object in the link.
1459
1460      As above, we again permit a common symbol in a regular object to
1461      override a definition in a shared object if the shared object
1462      symbol is a function or is weak.  */
1463
1464   flip = NULL;
1465   if (!newdyn
1466       && (newdef
1467           || (bfd_is_com_section (sec)
1468               && (oldweak || oldfunc)))
1469       && olddyn
1470       && olddef
1471       && h->def_dynamic)
1472     {
1473       /* Change the hash table entry to undefined, and let
1474          _bfd_generic_link_add_one_symbol do the right thing with the
1475          new definition.  */
1476
1477       h->root.type = bfd_link_hash_undefined;
1478       h->root.u.undef.abfd = h->root.u.def.section->owner;
1479       *size_change_ok = TRUE;
1480
1481       olddef = FALSE;
1482       olddyncommon = FALSE;
1483
1484       /* We again permit a type change when a common symbol may be
1485          overriding a function.  */
1486
1487       if (bfd_is_com_section (sec))
1488         {
1489           if (oldfunc)
1490             {
1491               /* If a common symbol overrides a function, make sure
1492                  that it isn't defined dynamically nor has type
1493                  function.  */
1494               h->def_dynamic = 0;
1495               h->type = STT_NOTYPE;
1496             }
1497           *type_change_ok = TRUE;
1498         }
1499
1500       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1501         flip = *sym_hash;
1502       else
1503         /* This union may have been set to be non-NULL when this symbol
1504            was seen in a dynamic object.  We must force the union to be
1505            NULL, so that it is correct for a regular symbol.  */
1506         h->verinfo.vertree = NULL;
1507     }
1508
1509   /* Handle the special case of a new common symbol merging with an
1510      old symbol that looks like it might be a common symbol defined in
1511      a shared object.  Note that we have already handled the case in
1512      which a new common symbol should simply override the definition
1513      in the shared library.  */
1514
1515   if (! newdyn
1516       && bfd_is_com_section (sec)
1517       && olddyncommon)
1518     {
1519       /* It would be best if we could set the hash table entry to a
1520          common symbol, but we don't know what to use for the section
1521          or the alignment.  */
1522       if (! ((*info->callbacks->multiple_common)
1523              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1524         return FALSE;
1525
1526       /* If the presumed common symbol in the dynamic object is
1527          larger, pretend that the new symbol has its size.  */
1528
1529       if (h->size > *pvalue)
1530         *pvalue = h->size;
1531
1532       /* We need to remember the alignment required by the symbol
1533          in the dynamic object.  */
1534       BFD_ASSERT (pold_alignment);
1535       *pold_alignment = h->root.u.def.section->alignment_power;
1536
1537       olddef = FALSE;
1538       olddyncommon = FALSE;
1539
1540       h->root.type = bfd_link_hash_undefined;
1541       h->root.u.undef.abfd = h->root.u.def.section->owner;
1542
1543       *size_change_ok = TRUE;
1544       *type_change_ok = TRUE;
1545
1546       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1547         flip = *sym_hash;
1548       else
1549         h->verinfo.vertree = NULL;
1550     }
1551
1552   if (flip != NULL)
1553     {
1554       /* Handle the case where we had a versioned symbol in a dynamic
1555          library and now find a definition in a normal object.  In this
1556          case, we make the versioned symbol point to the normal one.  */
1557       flip->root.type = h->root.type;
1558       flip->root.u.undef.abfd = h->root.u.undef.abfd;
1559       h->root.type = bfd_link_hash_indirect;
1560       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1561       (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1562       if (h->def_dynamic)
1563         {
1564           h->def_dynamic = 0;
1565           flip->ref_dynamic = 1;
1566         }
1567     }
1568
1569   return TRUE;
1570 }
1571
1572 /* This function is called to create an indirect symbol from the
1573    default for the symbol with the default version if needed. The
1574    symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE.  We
1575    set DYNSYM if the new indirect symbol is dynamic.  */
1576
1577 static bfd_boolean
1578 _bfd_elf_add_default_symbol (bfd *abfd,
1579                              struct bfd_link_info *info,
1580                              struct elf_link_hash_entry *h,
1581                              const char *name,
1582                              Elf_Internal_Sym *sym,
1583                              asection **psec,
1584                              bfd_vma *value,
1585                              bfd_boolean *dynsym,
1586                              bfd_boolean override)
1587 {
1588   bfd_boolean type_change_ok;
1589   bfd_boolean size_change_ok;
1590   bfd_boolean skip;
1591   char *shortname;
1592   struct elf_link_hash_entry *hi;
1593   struct bfd_link_hash_entry *bh;
1594   const struct elf_backend_data *bed;
1595   bfd_boolean collect;
1596   bfd_boolean dynamic;
1597   char *p;
1598   size_t len, shortlen;
1599   asection *sec;
1600
1601   /* If this symbol has a version, and it is the default version, we
1602      create an indirect symbol from the default name to the fully
1603      decorated name.  This will cause external references which do not
1604      specify a version to be bound to this version of the symbol.  */
1605   p = strchr (name, ELF_VER_CHR);
1606   if (p == NULL || p[1] != ELF_VER_CHR)
1607     return TRUE;
1608
1609   if (override)
1610     {
1611       /* We are overridden by an old definition. We need to check if we
1612          need to create the indirect symbol from the default name.  */
1613       hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE,
1614                                  FALSE, FALSE);
1615       BFD_ASSERT (hi != NULL);
1616       if (hi == h)
1617         return TRUE;
1618       while (hi->root.type == bfd_link_hash_indirect
1619              || hi->root.type == bfd_link_hash_warning)
1620         {
1621           hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1622           if (hi == h)
1623             return TRUE;
1624         }
1625     }
1626
1627   bed = get_elf_backend_data (abfd);
1628   collect = bed->collect;
1629   dynamic = (abfd->flags & DYNAMIC) != 0;
1630
1631   shortlen = p - name;
1632   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1633   if (shortname == NULL)
1634     return FALSE;
1635   memcpy (shortname, name, shortlen);
1636   shortname[shortlen] = '\0';
1637
1638   /* We are going to create a new symbol.  Merge it with any existing
1639      symbol with this name.  For the purposes of the merge, act as
1640      though we were defining the symbol we just defined, although we
1641      actually going to define an indirect symbol.  */
1642   type_change_ok = FALSE;
1643   size_change_ok = FALSE;
1644   sec = *psec;
1645   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1646                               NULL, &hi, &skip, &override,
1647                               &type_change_ok, &size_change_ok))
1648     return FALSE;
1649
1650   if (skip)
1651     goto nondefault;
1652
1653   if (! override)
1654     {
1655       bh = &hi->root;
1656       if (! (_bfd_generic_link_add_one_symbol
1657              (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1658               0, name, FALSE, collect, &bh)))
1659         return FALSE;
1660       hi = (struct elf_link_hash_entry *) bh;
1661     }
1662   else
1663     {
1664       /* In this case the symbol named SHORTNAME is overriding the
1665          indirect symbol we want to add.  We were planning on making
1666          SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1667          is the name without a version.  NAME is the fully versioned
1668          name, and it is the default version.
1669
1670          Overriding means that we already saw a definition for the
1671          symbol SHORTNAME in a regular object, and it is overriding
1672          the symbol defined in the dynamic object.
1673
1674          When this happens, we actually want to change NAME, the
1675          symbol we just added, to refer to SHORTNAME.  This will cause
1676          references to NAME in the shared object to become references
1677          to SHORTNAME in the regular object.  This is what we expect
1678          when we override a function in a shared object: that the
1679          references in the shared object will be mapped to the
1680          definition in the regular object.  */
1681
1682       while (hi->root.type == bfd_link_hash_indirect
1683              || hi->root.type == bfd_link_hash_warning)
1684         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1685
1686       h->root.type = bfd_link_hash_indirect;
1687       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1688       if (h->def_dynamic)
1689         {
1690           h->def_dynamic = 0;
1691           hi->ref_dynamic = 1;
1692           if (hi->ref_regular
1693               || hi->def_regular)
1694             {
1695               if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1696                 return FALSE;
1697             }
1698         }
1699
1700       /* Now set HI to H, so that the following code will set the
1701          other fields correctly.  */
1702       hi = h;
1703     }
1704
1705   /* Check if HI is a warning symbol.  */
1706   if (hi->root.type == bfd_link_hash_warning)
1707     hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1708
1709   /* If there is a duplicate definition somewhere, then HI may not
1710      point to an indirect symbol.  We will have reported an error to
1711      the user in that case.  */
1712
1713   if (hi->root.type == bfd_link_hash_indirect)
1714     {
1715       struct elf_link_hash_entry *ht;
1716
1717       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1718       (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1719
1720       /* See if the new flags lead us to realize that the symbol must
1721          be dynamic.  */
1722       if (! *dynsym)
1723         {
1724           if (! dynamic)
1725             {
1726               if (! info->executable
1727                   || hi->ref_dynamic)
1728                 *dynsym = TRUE;
1729             }
1730           else
1731             {
1732               if (hi->ref_regular)
1733                 *dynsym = TRUE;
1734             }
1735         }
1736     }
1737
1738   /* We also need to define an indirection from the nondefault version
1739      of the symbol.  */
1740
1741 nondefault:
1742   len = strlen (name);
1743   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1744   if (shortname == NULL)
1745     return FALSE;
1746   memcpy (shortname, name, shortlen);
1747   memcpy (shortname + shortlen, p + 1, len - shortlen);
1748
1749   /* Once again, merge with any existing symbol.  */
1750   type_change_ok = FALSE;
1751   size_change_ok = FALSE;
1752   sec = *psec;
1753   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1754                               NULL, &hi, &skip, &override,
1755                               &type_change_ok, &size_change_ok))
1756     return FALSE;
1757
1758   if (skip)
1759     return TRUE;
1760
1761   if (override)
1762     {
1763       /* Here SHORTNAME is a versioned name, so we don't expect to see
1764          the type of override we do in the case above unless it is
1765          overridden by a versioned definition.  */
1766       if (hi->root.type != bfd_link_hash_defined
1767           && hi->root.type != bfd_link_hash_defweak)
1768         (*_bfd_error_handler)
1769           (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1770            abfd, shortname);
1771     }
1772   else
1773     {
1774       bh = &hi->root;
1775       if (! (_bfd_generic_link_add_one_symbol
1776              (info, abfd, shortname, BSF_INDIRECT,
1777               bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1778         return FALSE;
1779       hi = (struct elf_link_hash_entry *) bh;
1780
1781       /* If there is a duplicate definition somewhere, then HI may not
1782          point to an indirect symbol.  We will have reported an error
1783          to the user in that case.  */
1784
1785       if (hi->root.type == bfd_link_hash_indirect)
1786         {
1787           (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1788
1789           /* See if the new flags lead us to realize that the symbol
1790              must be dynamic.  */
1791           if (! *dynsym)
1792             {
1793               if (! dynamic)
1794                 {
1795                   if (! info->executable
1796                       || hi->ref_dynamic)
1797                     *dynsym = TRUE;
1798                 }
1799               else
1800                 {
1801                   if (hi->ref_regular)
1802                     *dynsym = TRUE;
1803                 }
1804             }
1805         }
1806     }
1807
1808   return TRUE;
1809 }
1810 \f
1811 /* This routine is used to export all defined symbols into the dynamic
1812    symbol table.  It is called via elf_link_hash_traverse.  */
1813
1814 static bfd_boolean
1815 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1816 {
1817   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1818
1819   /* Ignore this if we won't export it.  */
1820   if (!eif->info->export_dynamic && !h->dynamic)
1821     return TRUE;
1822
1823   /* Ignore indirect symbols.  These are added by the versioning code.  */
1824   if (h->root.type == bfd_link_hash_indirect)
1825     return TRUE;
1826
1827   if (h->root.type == bfd_link_hash_warning)
1828     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1829
1830   if (h->dynindx == -1
1831       && (h->def_regular
1832           || h->ref_regular))
1833     {
1834       bfd_boolean hide;
1835
1836       if (eif->verdefs == NULL
1837           || (bfd_find_version_for_sym (eif->verdefs, h->root.root.string, &hide)
1838               && !hide))
1839         {
1840           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1841             {
1842               eif->failed = TRUE;
1843               return FALSE;
1844             }
1845         }
1846     }
1847
1848   return TRUE;
1849 }
1850 \f
1851 /* Look through the symbols which are defined in other shared
1852    libraries and referenced here.  Update the list of version
1853    dependencies.  This will be put into the .gnu.version_r section.
1854    This function is called via elf_link_hash_traverse.  */
1855
1856 static bfd_boolean
1857 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1858                                          void *data)
1859 {
1860   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1861   Elf_Internal_Verneed *t;
1862   Elf_Internal_Vernaux *a;
1863   bfd_size_type amt;
1864
1865   if (h->root.type == bfd_link_hash_warning)
1866     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1867
1868   /* We only care about symbols defined in shared objects with version
1869      information.  */
1870   if (!h->def_dynamic
1871       || h->def_regular
1872       || h->dynindx == -1
1873       || h->verinfo.verdef == NULL)
1874     return TRUE;
1875
1876   /* See if we already know about this version.  */
1877   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1878        t != NULL;
1879        t = t->vn_nextref)
1880     {
1881       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1882         continue;
1883
1884       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1885         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1886           return TRUE;
1887
1888       break;
1889     }
1890
1891   /* This is a new version.  Add it to tree we are building.  */
1892
1893   if (t == NULL)
1894     {
1895       amt = sizeof *t;
1896       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1897       if (t == NULL)
1898         {
1899           rinfo->failed = TRUE;
1900           return FALSE;
1901         }
1902
1903       t->vn_bfd = h->verinfo.verdef->vd_bfd;
1904       t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1905       elf_tdata (rinfo->info->output_bfd)->verref = t;
1906     }
1907
1908   amt = sizeof *a;
1909   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1910   if (a == NULL)
1911     {
1912       rinfo->failed = TRUE;
1913       return FALSE;
1914     }
1915
1916   /* Note that we are copying a string pointer here, and testing it
1917      above.  If bfd_elf_string_from_elf_section is ever changed to
1918      discard the string data when low in memory, this will have to be
1919      fixed.  */
1920   a->vna_nodename = h->verinfo.verdef->vd_nodename;
1921
1922   a->vna_flags = h->verinfo.verdef->vd_flags;
1923   a->vna_nextptr = t->vn_auxptr;
1924
1925   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1926   ++rinfo->vers;
1927
1928   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1929
1930   t->vn_auxptr = a;
1931
1932   return TRUE;
1933 }
1934
1935 /* Figure out appropriate versions for all the symbols.  We may not
1936    have the version number script until we have read all of the input
1937    files, so until that point we don't know which symbols should be
1938    local.  This function is called via elf_link_hash_traverse.  */
1939
1940 static bfd_boolean
1941 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1942 {
1943   struct elf_info_failed *sinfo;
1944   struct bfd_link_info *info;
1945   const struct elf_backend_data *bed;
1946   struct elf_info_failed eif;
1947   char *p;
1948   bfd_size_type amt;
1949
1950   sinfo = (struct elf_info_failed *) data;
1951   info = sinfo->info;
1952
1953   if (h->root.type == bfd_link_hash_warning)
1954     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1955
1956   /* Fix the symbol flags.  */
1957   eif.failed = FALSE;
1958   eif.info = info;
1959   if (! _bfd_elf_fix_symbol_flags (h, &eif))
1960     {
1961       if (eif.failed)
1962         sinfo->failed = TRUE;
1963       return FALSE;
1964     }
1965
1966   /* We only need version numbers for symbols defined in regular
1967      objects.  */
1968   if (!h->def_regular)
1969     return TRUE;
1970
1971   bed = get_elf_backend_data (info->output_bfd);
1972   p = strchr (h->root.root.string, ELF_VER_CHR);
1973   if (p != NULL && h->verinfo.vertree == NULL)
1974     {
1975       struct bfd_elf_version_tree *t;
1976       bfd_boolean hidden;
1977
1978       hidden = TRUE;
1979
1980       /* There are two consecutive ELF_VER_CHR characters if this is
1981          not a hidden symbol.  */
1982       ++p;
1983       if (*p == ELF_VER_CHR)
1984         {
1985           hidden = FALSE;
1986           ++p;
1987         }
1988
1989       /* If there is no version string, we can just return out.  */
1990       if (*p == '\0')
1991         {
1992           if (hidden)
1993             h->hidden = 1;
1994           return TRUE;
1995         }
1996
1997       /* Look for the version.  If we find it, it is no longer weak.  */
1998       for (t = sinfo->verdefs; t != NULL; t = t->next)
1999         {
2000           if (strcmp (t->name, p) == 0)
2001             {
2002               size_t len;
2003               char *alc;
2004               struct bfd_elf_version_expr *d;
2005
2006               len = p - h->root.root.string;
2007               alc = (char *) bfd_malloc (len);
2008               if (alc == NULL)
2009                 {
2010                   sinfo->failed = TRUE;
2011                   return FALSE;
2012                 }
2013               memcpy (alc, h->root.root.string, len - 1);
2014               alc[len - 1] = '\0';
2015               if (alc[len - 2] == ELF_VER_CHR)
2016                 alc[len - 2] = '\0';
2017
2018               h->verinfo.vertree = t;
2019               t->used = TRUE;
2020               d = NULL;
2021
2022               if (t->globals.list != NULL)
2023                 d = (*t->match) (&t->globals, NULL, alc);
2024
2025               /* See if there is anything to force this symbol to
2026                  local scope.  */
2027               if (d == NULL && t->locals.list != NULL)
2028                 {
2029                   d = (*t->match) (&t->locals, NULL, alc);
2030                   if (d != NULL
2031                       && h->dynindx != -1
2032                       && ! info->export_dynamic)
2033                     (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2034                 }
2035
2036               free (alc);
2037               break;
2038             }
2039         }
2040
2041       /* If we are building an application, we need to create a
2042          version node for this version.  */
2043       if (t == NULL && info->executable)
2044         {
2045           struct bfd_elf_version_tree **pp;
2046           int version_index;
2047
2048           /* If we aren't going to export this symbol, we don't need
2049              to worry about it.  */
2050           if (h->dynindx == -1)
2051             return TRUE;
2052
2053           amt = sizeof *t;
2054           t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2055           if (t == NULL)
2056             {
2057               sinfo->failed = TRUE;
2058               return FALSE;
2059             }
2060
2061           t->name = p;
2062           t->name_indx = (unsigned int) -1;
2063           t->used = TRUE;
2064
2065           version_index = 1;
2066           /* Don't count anonymous version tag.  */
2067           if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
2068             version_index = 0;
2069           for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
2070             ++version_index;
2071           t->vernum = version_index;
2072
2073           *pp = t;
2074
2075           h->verinfo.vertree = t;
2076         }
2077       else if (t == NULL)
2078         {
2079           /* We could not find the version for a symbol when
2080              generating a shared archive.  Return an error.  */
2081           (*_bfd_error_handler)
2082             (_("%B: version node not found for symbol %s"),
2083              info->output_bfd, h->root.root.string);
2084           bfd_set_error (bfd_error_bad_value);
2085           sinfo->failed = TRUE;
2086           return FALSE;
2087         }
2088
2089       if (hidden)
2090         h->hidden = 1;
2091     }
2092
2093   /* If we don't have a version for this symbol, see if we can find
2094      something.  */
2095   if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
2096     {
2097       bfd_boolean hide;
2098
2099       h->verinfo.vertree = bfd_find_version_for_sym (sinfo->verdefs,
2100                                                  h->root.root.string, &hide);
2101       if (h->verinfo.vertree != NULL && hide)
2102         (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2103     }
2104
2105   return TRUE;
2106 }
2107 \f
2108 /* Read and swap the relocs from the section indicated by SHDR.  This
2109    may be either a REL or a RELA section.  The relocations are
2110    translated into RELA relocations and stored in INTERNAL_RELOCS,
2111    which should have already been allocated to contain enough space.
2112    The EXTERNAL_RELOCS are a buffer where the external form of the
2113    relocations should be stored.
2114
2115    Returns FALSE if something goes wrong.  */
2116
2117 static bfd_boolean
2118 elf_link_read_relocs_from_section (bfd *abfd,
2119                                    asection *sec,
2120                                    Elf_Internal_Shdr *shdr,
2121                                    void *external_relocs,
2122                                    Elf_Internal_Rela *internal_relocs)
2123 {
2124   const struct elf_backend_data *bed;
2125   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2126   const bfd_byte *erela;
2127   const bfd_byte *erelaend;
2128   Elf_Internal_Rela *irela;
2129   Elf_Internal_Shdr *symtab_hdr;
2130   size_t nsyms;
2131
2132   /* Position ourselves at the start of the section.  */
2133   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2134     return FALSE;
2135
2136   /* Read the relocations.  */
2137   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2138     return FALSE;
2139
2140   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2141   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2142
2143   bed = get_elf_backend_data (abfd);
2144
2145   /* Convert the external relocations to the internal format.  */
2146   if (shdr->sh_entsize == bed->s->sizeof_rel)
2147     swap_in = bed->s->swap_reloc_in;
2148   else if (shdr->sh_entsize == bed->s->sizeof_rela)
2149     swap_in = bed->s->swap_reloca_in;
2150   else
2151     {
2152       bfd_set_error (bfd_error_wrong_format);
2153       return FALSE;
2154     }
2155
2156   erela = (const bfd_byte *) external_relocs;
2157   erelaend = erela + shdr->sh_size;
2158   irela = internal_relocs;
2159   while (erela < erelaend)
2160     {
2161       bfd_vma r_symndx;
2162
2163       (*swap_in) (abfd, erela, irela);
2164       r_symndx = ELF32_R_SYM (irela->r_info);
2165       if (bed->s->arch_size == 64)
2166         r_symndx >>= 24;
2167       if (nsyms > 0)
2168         {
2169           if ((size_t) r_symndx >= nsyms)
2170             {
2171               (*_bfd_error_handler)
2172                 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2173                    " for offset 0x%lx in section `%A'"),
2174                  abfd, sec,
2175                  (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2176               bfd_set_error (bfd_error_bad_value);
2177               return FALSE;
2178             }
2179         }
2180       else if (r_symndx != STN_UNDEF)
2181         {
2182           (*_bfd_error_handler)
2183             (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2184                " when the object file has no symbol table"),
2185              abfd, sec,
2186              (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2187           bfd_set_error (bfd_error_bad_value);
2188           return FALSE;
2189         }
2190       irela += bed->s->int_rels_per_ext_rel;
2191       erela += shdr->sh_entsize;
2192     }
2193
2194   return TRUE;
2195 }
2196
2197 /* Read and swap the relocs for a section O.  They may have been
2198    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2199    not NULL, they are used as buffers to read into.  They are known to
2200    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2201    the return value is allocated using either malloc or bfd_alloc,
2202    according to the KEEP_MEMORY argument.  If O has two relocation
2203    sections (both REL and RELA relocations), then the REL_HDR
2204    relocations will appear first in INTERNAL_RELOCS, followed by the
2205    RELA_HDR relocations.  */
2206
2207 Elf_Internal_Rela *
2208 _bfd_elf_link_read_relocs (bfd *abfd,
2209                            asection *o,
2210                            void *external_relocs,
2211                            Elf_Internal_Rela *internal_relocs,
2212                            bfd_boolean keep_memory)
2213 {
2214   void *alloc1 = NULL;
2215   Elf_Internal_Rela *alloc2 = NULL;
2216   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2217   struct bfd_elf_section_data *esdo = elf_section_data (o);
2218   Elf_Internal_Rela *internal_rela_relocs;
2219
2220   if (esdo->relocs != NULL)
2221     return esdo->relocs;
2222
2223   if (o->reloc_count == 0)
2224     return NULL;
2225
2226   if (internal_relocs == NULL)
2227     {
2228       bfd_size_type size;
2229
2230       size = o->reloc_count;
2231       size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2232       if (keep_memory)
2233         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2234       else
2235         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2236       if (internal_relocs == NULL)
2237         goto error_return;
2238     }
2239
2240   if (external_relocs == NULL)
2241     {
2242       bfd_size_type size = 0;
2243
2244       if (esdo->rel.hdr)
2245         size += esdo->rel.hdr->sh_size;
2246       if (esdo->rela.hdr)
2247         size += esdo->rela.hdr->sh_size;
2248
2249       alloc1 = bfd_malloc (size);
2250       if (alloc1 == NULL)
2251         goto error_return;
2252       external_relocs = alloc1;
2253     }
2254
2255   internal_rela_relocs = internal_relocs;
2256   if (esdo->rel.hdr)
2257     {
2258       if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2259                                               external_relocs,
2260                                               internal_relocs))
2261         goto error_return;
2262       external_relocs = (((bfd_byte *) external_relocs)
2263                          + esdo->rel.hdr->sh_size);
2264       internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2265                                * bed->s->int_rels_per_ext_rel);
2266     }
2267
2268   if (esdo->rela.hdr
2269       && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2270                                               external_relocs,
2271                                               internal_rela_relocs)))
2272     goto error_return;
2273
2274   /* Cache the results for next time, if we can.  */
2275   if (keep_memory)
2276     esdo->relocs = internal_relocs;
2277
2278   if (alloc1 != NULL)
2279     free (alloc1);
2280
2281   /* Don't free alloc2, since if it was allocated we are passing it
2282      back (under the name of internal_relocs).  */
2283
2284   return internal_relocs;
2285
2286  error_return:
2287   if (alloc1 != NULL)
2288     free (alloc1);
2289   if (alloc2 != NULL)
2290     {
2291       if (keep_memory)
2292         bfd_release (abfd, alloc2);
2293       else
2294         free (alloc2);
2295     }
2296   return NULL;
2297 }
2298
2299 /* Compute the size of, and allocate space for, REL_HDR which is the
2300    section header for a section containing relocations for O.  */
2301
2302 static bfd_boolean
2303 _bfd_elf_link_size_reloc_section (bfd *abfd,
2304                                   struct bfd_elf_section_reloc_data *reldata)
2305 {
2306   Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2307
2308   /* That allows us to calculate the size of the section.  */
2309   rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2310
2311   /* The contents field must last into write_object_contents, so we
2312      allocate it with bfd_alloc rather than malloc.  Also since we
2313      cannot be sure that the contents will actually be filled in,
2314      we zero the allocated space.  */
2315   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2316   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2317     return FALSE;
2318
2319   if (reldata->hashes == NULL && reldata->count)
2320     {
2321       struct elf_link_hash_entry **p;
2322
2323       p = (struct elf_link_hash_entry **)
2324           bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
2325       if (p == NULL)
2326         return FALSE;
2327
2328       reldata->hashes = p;
2329     }
2330
2331   return TRUE;
2332 }
2333
2334 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2335    originated from the section given by INPUT_REL_HDR) to the
2336    OUTPUT_BFD.  */
2337
2338 bfd_boolean
2339 _bfd_elf_link_output_relocs (bfd *output_bfd,
2340                              asection *input_section,
2341                              Elf_Internal_Shdr *input_rel_hdr,
2342                              Elf_Internal_Rela *internal_relocs,
2343                              struct elf_link_hash_entry **rel_hash
2344                                ATTRIBUTE_UNUSED)
2345 {
2346   Elf_Internal_Rela *irela;
2347   Elf_Internal_Rela *irelaend;
2348   bfd_byte *erel;
2349   struct bfd_elf_section_reloc_data *output_reldata;
2350   asection *output_section;
2351   const struct elf_backend_data *bed;
2352   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2353   struct bfd_elf_section_data *esdo;
2354
2355   output_section = input_section->output_section;
2356
2357   bed = get_elf_backend_data (output_bfd);
2358   esdo = elf_section_data (output_section);
2359   if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2360     {
2361       output_reldata = &esdo->rel;
2362       swap_out = bed->s->swap_reloc_out;
2363     }
2364   else if (esdo->rela.hdr
2365            && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2366     {
2367       output_reldata = &esdo->rela;
2368       swap_out = bed->s->swap_reloca_out;
2369     }
2370   else
2371     {
2372       (*_bfd_error_handler)
2373         (_("%B: relocation size mismatch in %B section %A"),
2374          output_bfd, input_section->owner, input_section);
2375       bfd_set_error (bfd_error_wrong_format);
2376       return FALSE;
2377     }
2378
2379   erel = output_reldata->hdr->contents;
2380   erel += output_reldata->count * input_rel_hdr->sh_entsize;
2381   irela = internal_relocs;
2382   irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2383                       * bed->s->int_rels_per_ext_rel);
2384   while (irela < irelaend)
2385     {
2386       (*swap_out) (output_bfd, irela, erel);
2387       irela += bed->s->int_rels_per_ext_rel;
2388       erel += input_rel_hdr->sh_entsize;
2389     }
2390
2391   /* Bump the counter, so that we know where to add the next set of
2392      relocations.  */
2393   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2394
2395   return TRUE;
2396 }
2397 \f
2398 /* Make weak undefined symbols in PIE dynamic.  */
2399
2400 bfd_boolean
2401 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2402                                  struct elf_link_hash_entry *h)
2403 {
2404   if (info->pie
2405       && h->dynindx == -1
2406       && h->root.type == bfd_link_hash_undefweak)
2407     return bfd_elf_link_record_dynamic_symbol (info, h);
2408
2409   return TRUE;
2410 }
2411
2412 /* Fix up the flags for a symbol.  This handles various cases which
2413    can only be fixed after all the input files are seen.  This is
2414    currently called by both adjust_dynamic_symbol and
2415    assign_sym_version, which is unnecessary but perhaps more robust in
2416    the face of future changes.  */
2417
2418 static bfd_boolean
2419 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2420                            struct elf_info_failed *eif)
2421 {
2422   const struct elf_backend_data *bed;
2423
2424   /* If this symbol was mentioned in a non-ELF file, try to set
2425      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2426      permit a non-ELF file to correctly refer to a symbol defined in
2427      an ELF dynamic object.  */
2428   if (h->non_elf)
2429     {
2430       while (h->root.type == bfd_link_hash_indirect)
2431         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2432
2433       if (h->root.type != bfd_link_hash_defined
2434           && h->root.type != bfd_link_hash_defweak)
2435         {
2436           h->ref_regular = 1;
2437           h->ref_regular_nonweak = 1;
2438         }
2439       else
2440         {
2441           if (h->root.u.def.section->owner != NULL
2442               && (bfd_get_flavour (h->root.u.def.section->owner)
2443                   == bfd_target_elf_flavour))
2444             {
2445               h->ref_regular = 1;
2446               h->ref_regular_nonweak = 1;
2447             }
2448           else
2449             h->def_regular = 1;
2450         }
2451
2452       if (h->dynindx == -1
2453           && (h->def_dynamic
2454               || h->ref_dynamic))
2455         {
2456           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2457             {
2458               eif->failed = TRUE;
2459               return FALSE;
2460             }
2461         }
2462     }
2463   else
2464     {
2465       /* Unfortunately, NON_ELF is only correct if the symbol
2466          was first seen in a non-ELF file.  Fortunately, if the symbol
2467          was first seen in an ELF file, we're probably OK unless the
2468          symbol was defined in a non-ELF file.  Catch that case here.
2469          FIXME: We're still in trouble if the symbol was first seen in
2470          a dynamic object, and then later in a non-ELF regular object.  */
2471       if ((h->root.type == bfd_link_hash_defined
2472            || h->root.type == bfd_link_hash_defweak)
2473           && !h->def_regular
2474           && (h->root.u.def.section->owner != NULL
2475               ? (bfd_get_flavour (h->root.u.def.section->owner)
2476                  != bfd_target_elf_flavour)
2477               : (bfd_is_abs_section (h->root.u.def.section)
2478                  && !h->def_dynamic)))
2479         h->def_regular = 1;
2480     }
2481
2482   /* Backend specific symbol fixup.  */
2483   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2484   if (bed->elf_backend_fixup_symbol
2485       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2486     return FALSE;
2487
2488   /* If this is a final link, and the symbol was defined as a common
2489      symbol in a regular object file, and there was no definition in
2490      any dynamic object, then the linker will have allocated space for
2491      the symbol in a common section but the DEF_REGULAR
2492      flag will not have been set.  */
2493   if (h->root.type == bfd_link_hash_defined
2494       && !h->def_regular
2495       && h->ref_regular
2496       && !h->def_dynamic
2497       && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
2498     h->def_regular = 1;
2499
2500   /* If -Bsymbolic was used (which means to bind references to global
2501      symbols to the definition within the shared object), and this
2502      symbol was defined in a regular object, then it actually doesn't
2503      need a PLT entry.  Likewise, if the symbol has non-default
2504      visibility.  If the symbol has hidden or internal visibility, we
2505      will force it local.  */
2506   if (h->needs_plt
2507       && eif->info->shared
2508       && is_elf_hash_table (eif->info->hash)
2509       && (SYMBOLIC_BIND (eif->info, h)
2510           || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2511       && h->def_regular)
2512     {
2513       bfd_boolean force_local;
2514
2515       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2516                      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2517       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2518     }
2519
2520   /* If a weak undefined symbol has non-default visibility, we also
2521      hide it from the dynamic linker.  */
2522   if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2523       && h->root.type == bfd_link_hash_undefweak)
2524     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2525
2526   /* If this is a weak defined symbol in a dynamic object, and we know
2527      the real definition in the dynamic object, copy interesting flags
2528      over to the real definition.  */
2529   if (h->u.weakdef != NULL)
2530     {
2531       struct elf_link_hash_entry *weakdef;
2532
2533       weakdef = h->u.weakdef;
2534       if (h->root.type == bfd_link_hash_indirect)
2535         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2536
2537       BFD_ASSERT (h->root.type == bfd_link_hash_defined
2538                   || h->root.type == bfd_link_hash_defweak);
2539       BFD_ASSERT (weakdef->def_dynamic);
2540
2541       /* If the real definition is defined by a regular object file,
2542          don't do anything special.  See the longer description in
2543          _bfd_elf_adjust_dynamic_symbol, below.  */
2544       if (weakdef->def_regular)
2545         h->u.weakdef = NULL;
2546       else
2547         {
2548           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2549                       || weakdef->root.type == bfd_link_hash_defweak);
2550           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2551         }
2552     }
2553
2554   return TRUE;
2555 }
2556
2557 /* Make the backend pick a good value for a dynamic symbol.  This is
2558    called via elf_link_hash_traverse, and also calls itself
2559    recursively.  */
2560
2561 static bfd_boolean
2562 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2563 {
2564   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2565   bfd *dynobj;
2566   const struct elf_backend_data *bed;
2567
2568   if (! is_elf_hash_table (eif->info->hash))
2569     return FALSE;
2570
2571   if (h->root.type == bfd_link_hash_warning)
2572     {
2573       h->got = elf_hash_table (eif->info)->init_got_offset;
2574       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2575
2576       /* When warning symbols are created, they **replace** the "real"
2577          entry in the hash table, thus we never get to see the real
2578          symbol in a hash traversal.  So look at it now.  */
2579       h = (struct elf_link_hash_entry *) h->root.u.i.link;
2580     }
2581
2582   /* Ignore indirect symbols.  These are added by the versioning code.  */
2583   if (h->root.type == bfd_link_hash_indirect)
2584     return TRUE;
2585
2586   /* Fix the symbol flags.  */
2587   if (! _bfd_elf_fix_symbol_flags (h, eif))
2588     return FALSE;
2589
2590   /* If this symbol does not require a PLT entry, and it is not
2591      defined by a dynamic object, or is not referenced by a regular
2592      object, ignore it.  We do have to handle a weak defined symbol,
2593      even if no regular object refers to it, if we decided to add it
2594      to the dynamic symbol table.  FIXME: Do we normally need to worry
2595      about symbols which are defined by one dynamic object and
2596      referenced by another one?  */
2597   if (!h->needs_plt
2598       && h->type != STT_GNU_IFUNC
2599       && (h->def_regular
2600           || !h->def_dynamic
2601           || (!h->ref_regular
2602               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2603     {
2604       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2605       return TRUE;
2606     }
2607
2608   /* If we've already adjusted this symbol, don't do it again.  This
2609      can happen via a recursive call.  */
2610   if (h->dynamic_adjusted)
2611     return TRUE;
2612
2613   /* Don't look at this symbol again.  Note that we must set this
2614      after checking the above conditions, because we may look at a
2615      symbol once, decide not to do anything, and then get called
2616      recursively later after REF_REGULAR is set below.  */
2617   h->dynamic_adjusted = 1;
2618
2619   /* If this is a weak definition, and we know a real definition, and
2620      the real symbol is not itself defined by a regular object file,
2621      then get a good value for the real definition.  We handle the
2622      real symbol first, for the convenience of the backend routine.
2623
2624      Note that there is a confusing case here.  If the real definition
2625      is defined by a regular object file, we don't get the real symbol
2626      from the dynamic object, but we do get the weak symbol.  If the
2627      processor backend uses a COPY reloc, then if some routine in the
2628      dynamic object changes the real symbol, we will not see that
2629      change in the corresponding weak symbol.  This is the way other
2630      ELF linkers work as well, and seems to be a result of the shared
2631      library model.
2632
2633      I will clarify this issue.  Most SVR4 shared libraries define the
2634      variable _timezone and define timezone as a weak synonym.  The
2635      tzset call changes _timezone.  If you write
2636        extern int timezone;
2637        int _timezone = 5;
2638        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2639      you might expect that, since timezone is a synonym for _timezone,
2640      the same number will print both times.  However, if the processor
2641      backend uses a COPY reloc, then actually timezone will be copied
2642      into your process image, and, since you define _timezone
2643      yourself, _timezone will not.  Thus timezone and _timezone will
2644      wind up at different memory locations.  The tzset call will set
2645      _timezone, leaving timezone unchanged.  */
2646
2647   if (h->u.weakdef != NULL)
2648     {
2649       /* If we get to this point, we know there is an implicit
2650          reference by a regular object file via the weak symbol H.
2651          FIXME: Is this really true?  What if the traversal finds
2652          H->U.WEAKDEF before it finds H?  */
2653       h->u.weakdef->ref_regular = 1;
2654
2655       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2656         return FALSE;
2657     }
2658
2659   /* If a symbol has no type and no size and does not require a PLT
2660      entry, then we are probably about to do the wrong thing here: we
2661      are probably going to create a COPY reloc for an empty object.
2662      This case can arise when a shared object is built with assembly
2663      code, and the assembly code fails to set the symbol type.  */
2664   if (h->size == 0
2665       && h->type == STT_NOTYPE
2666       && !h->needs_plt)
2667     (*_bfd_error_handler)
2668       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2669        h->root.root.string);
2670
2671   dynobj = elf_hash_table (eif->info)->dynobj;
2672   bed = get_elf_backend_data (dynobj);
2673
2674   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2675     {
2676       eif->failed = TRUE;
2677       return FALSE;
2678     }
2679
2680   return TRUE;
2681 }
2682
2683 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2684    DYNBSS.  */
2685
2686 bfd_boolean
2687 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2688                               asection *dynbss)
2689 {
2690   unsigned int power_of_two;
2691   bfd_vma mask;
2692   asection *sec = h->root.u.def.section;
2693
2694   /* The section aligment of definition is the maximum alignment
2695      requirement of symbols defined in the section.  Since we don't
2696      know the symbol alignment requirement, we start with the
2697      maximum alignment and check low bits of the symbol address
2698      for the minimum alignment.  */
2699   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2700   mask = ((bfd_vma) 1 << power_of_two) - 1;
2701   while ((h->root.u.def.value & mask) != 0)
2702     {
2703        mask >>= 1;
2704        --power_of_two;
2705     }
2706
2707   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2708                                                 dynbss))
2709     {
2710       /* Adjust the section alignment if needed.  */
2711       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2712                                        power_of_two))
2713         return FALSE;
2714     }
2715
2716   /* We make sure that the symbol will be aligned properly.  */
2717   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2718
2719   /* Define the symbol as being at this point in DYNBSS.  */
2720   h->root.u.def.section = dynbss;
2721   h->root.u.def.value = dynbss->size;
2722
2723   /* Increment the size of DYNBSS to make room for the symbol.  */
2724   dynbss->size += h->size;
2725
2726   return TRUE;
2727 }
2728
2729 /* Adjust all external symbols pointing into SEC_MERGE sections
2730    to reflect the object merging within the sections.  */
2731
2732 static bfd_boolean
2733 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2734 {
2735   asection *sec;
2736
2737   if (h->root.type == bfd_link_hash_warning)
2738     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2739
2740   if ((h->root.type == bfd_link_hash_defined
2741        || h->root.type == bfd_link_hash_defweak)
2742       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2743       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2744     {
2745       bfd *output_bfd = (bfd *) data;
2746
2747       h->root.u.def.value =
2748         _bfd_merged_section_offset (output_bfd,
2749                                     &h->root.u.def.section,
2750                                     elf_section_data (sec)->sec_info,
2751                                     h->root.u.def.value);
2752     }
2753
2754   return TRUE;
2755 }
2756
2757 /* Returns false if the symbol referred to by H should be considered
2758    to resolve local to the current module, and true if it should be
2759    considered to bind dynamically.  */
2760
2761 bfd_boolean
2762 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2763                            struct bfd_link_info *info,
2764                            bfd_boolean not_local_protected)
2765 {
2766   bfd_boolean binding_stays_local_p;
2767   const struct elf_backend_data *bed;
2768   struct elf_link_hash_table *hash_table;
2769
2770   if (h == NULL)
2771     return FALSE;
2772
2773   while (h->root.type == bfd_link_hash_indirect
2774          || h->root.type == bfd_link_hash_warning)
2775     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2776
2777   /* If it was forced local, then clearly it's not dynamic.  */
2778   if (h->dynindx == -1)
2779     return FALSE;
2780   if (h->forced_local)
2781     return FALSE;
2782
2783   /* Identify the cases where name binding rules say that a
2784      visible symbol resolves locally.  */
2785   binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2786
2787   switch (ELF_ST_VISIBILITY (h->other))
2788     {
2789     case STV_INTERNAL:
2790     case STV_HIDDEN:
2791       return FALSE;
2792
2793     case STV_PROTECTED:
2794       hash_table = elf_hash_table (info);
2795       if (!is_elf_hash_table (hash_table))
2796         return FALSE;
2797
2798       bed = get_elf_backend_data (hash_table->dynobj);
2799
2800       /* Proper resolution for function pointer equality may require
2801          that these symbols perhaps be resolved dynamically, even though
2802          we should be resolving them to the current module.  */
2803       if (!not_local_protected || !bed->is_function_type (h->type))
2804         binding_stays_local_p = TRUE;
2805       break;
2806
2807     default:
2808       break;
2809     }
2810
2811   /* If it isn't defined locally, then clearly it's dynamic.  */
2812   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2813     return TRUE;
2814
2815   /* Otherwise, the symbol is dynamic if binding rules don't tell
2816      us that it remains local.  */
2817   return !binding_stays_local_p;
2818 }
2819
2820 /* Return true if the symbol referred to by H should be considered
2821    to resolve local to the current module, and false otherwise.  Differs
2822    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2823    undefined symbols.  The two functions are virtually identical except
2824    for the place where forced_local and dynindx == -1 are tested.  If
2825    either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2826    the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2827    the symbol is local only for defined symbols.
2828    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2829    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2830    treatment of undefined weak symbols.  For those that do not make
2831    undefined weak symbols dynamic, both functions may return false.  */
2832
2833 bfd_boolean
2834 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2835                               struct bfd_link_info *info,
2836                               bfd_boolean local_protected)
2837 {
2838   const struct elf_backend_data *bed;
2839   struct elf_link_hash_table *hash_table;
2840
2841   /* If it's a local sym, of course we resolve locally.  */
2842   if (h == NULL)
2843     return TRUE;
2844
2845   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2846   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2847       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2848     return TRUE;
2849
2850   /* Common symbols that become definitions don't get the DEF_REGULAR
2851      flag set, so test it first, and don't bail out.  */
2852   if (ELF_COMMON_DEF_P (h))
2853     /* Do nothing.  */;
2854   /* If we don't have a definition in a regular file, then we can't
2855      resolve locally.  The sym is either undefined or dynamic.  */
2856   else if (!h->def_regular)
2857     return FALSE;
2858
2859   /* Forced local symbols resolve locally.  */
2860   if (h->forced_local)
2861     return TRUE;
2862
2863   /* As do non-dynamic symbols.  */
2864   if (h->dynindx == -1)
2865     return TRUE;
2866
2867   /* At this point, we know the symbol is defined and dynamic.  In an
2868      executable it must resolve locally, likewise when building symbolic
2869      shared libraries.  */
2870   if (info->executable || SYMBOLIC_BIND (info, h))
2871     return TRUE;
2872
2873   /* Now deal with defined dynamic symbols in shared libraries.  Ones
2874      with default visibility might not resolve locally.  */
2875   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2876     return FALSE;
2877
2878   hash_table = elf_hash_table (info);
2879   if (!is_elf_hash_table (hash_table))
2880     return TRUE;
2881
2882   bed = get_elf_backend_data (hash_table->dynobj);
2883
2884   /* STV_PROTECTED non-function symbols are local.  */
2885   if (!bed->is_function_type (h->type))
2886     return TRUE;
2887
2888   /* Function pointer equality tests may require that STV_PROTECTED
2889      symbols be treated as dynamic symbols.  If the address of a
2890      function not defined in an executable is set to that function's
2891      plt entry in the executable, then the address of the function in
2892      a shared library must also be the plt entry in the executable.  */
2893   return local_protected;
2894 }
2895
2896 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2897    aligned.  Returns the first TLS output section.  */
2898
2899 struct bfd_section *
2900 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2901 {
2902   struct bfd_section *sec, *tls;
2903   unsigned int align = 0;
2904
2905   for (sec = obfd->sections; sec != NULL; sec = sec->next)
2906     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2907       break;
2908   tls = sec;
2909
2910   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2911     if (sec->alignment_power > align)
2912       align = sec->alignment_power;
2913
2914   elf_hash_table (info)->tls_sec = tls;
2915
2916   /* Ensure the alignment of the first section is the largest alignment,
2917      so that the tls segment starts aligned.  */
2918   if (tls != NULL)
2919     tls->alignment_power = align;
2920
2921   return tls;
2922 }
2923
2924 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
2925 static bfd_boolean
2926 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2927                                   Elf_Internal_Sym *sym)
2928 {
2929   const struct elf_backend_data *bed;
2930
2931   /* Local symbols do not count, but target specific ones might.  */
2932   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2933       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2934     return FALSE;
2935
2936   bed = get_elf_backend_data (abfd);
2937   /* Function symbols do not count.  */
2938   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2939     return FALSE;
2940
2941   /* If the section is undefined, then so is the symbol.  */
2942   if (sym->st_shndx == SHN_UNDEF)
2943     return FALSE;
2944
2945   /* If the symbol is defined in the common section, then
2946      it is a common definition and so does not count.  */
2947   if (bed->common_definition (sym))
2948     return FALSE;
2949
2950   /* If the symbol is in a target specific section then we
2951      must rely upon the backend to tell us what it is.  */
2952   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2953     /* FIXME - this function is not coded yet:
2954
2955        return _bfd_is_global_symbol_definition (abfd, sym);
2956
2957        Instead for now assume that the definition is not global,
2958        Even if this is wrong, at least the linker will behave
2959        in the same way that it used to do.  */
2960     return FALSE;
2961
2962   return TRUE;
2963 }
2964
2965 /* Search the symbol table of the archive element of the archive ABFD
2966    whose archive map contains a mention of SYMDEF, and determine if
2967    the symbol is defined in this element.  */
2968 static bfd_boolean
2969 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2970 {
2971   Elf_Internal_Shdr * hdr;
2972   bfd_size_type symcount;
2973   bfd_size_type extsymcount;
2974   bfd_size_type extsymoff;
2975   Elf_Internal_Sym *isymbuf;
2976   Elf_Internal_Sym *isym;
2977   Elf_Internal_Sym *isymend;
2978   bfd_boolean result;
2979
2980   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2981   if (abfd == NULL)
2982     return FALSE;
2983
2984   if (! bfd_check_format (abfd, bfd_object))
2985     return FALSE;
2986
2987   /* If we have already included the element containing this symbol in the
2988      link then we do not need to include it again.  Just claim that any symbol
2989      it contains is not a definition, so that our caller will not decide to
2990      (re)include this element.  */
2991   if (abfd->archive_pass)
2992     return FALSE;
2993
2994   /* Select the appropriate symbol table.  */
2995   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2996     hdr = &elf_tdata (abfd)->symtab_hdr;
2997   else
2998     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2999
3000   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3001
3002   /* The sh_info field of the symtab header tells us where the
3003      external symbols start.  We don't care about the local symbols.  */
3004   if (elf_bad_symtab (abfd))
3005     {
3006       extsymcount = symcount;
3007       extsymoff = 0;
3008     }
3009   else
3010     {
3011       extsymcount = symcount - hdr->sh_info;
3012       extsymoff = hdr->sh_info;
3013     }
3014
3015   if (extsymcount == 0)
3016     return FALSE;
3017
3018   /* Read in the symbol table.  */
3019   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3020                                   NULL, NULL, NULL);
3021   if (isymbuf == NULL)
3022     return FALSE;
3023
3024   /* Scan the symbol table looking for SYMDEF.  */
3025   result = FALSE;
3026   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
3027     {
3028       const char *name;
3029
3030       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3031                                               isym->st_name);
3032       if (name == NULL)
3033         break;
3034
3035       if (strcmp (name, symdef->name) == 0)
3036         {
3037           result = is_global_data_symbol_definition (abfd, isym);
3038           break;
3039         }
3040     }
3041
3042   free (isymbuf);
3043
3044   return result;
3045 }
3046 \f
3047 /* Add an entry to the .dynamic table.  */
3048
3049 bfd_boolean
3050 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3051                             bfd_vma tag,
3052                             bfd_vma val)
3053 {
3054   struct elf_link_hash_table *hash_table;
3055   const struct elf_backend_data *bed;
3056   asection *s;
3057   bfd_size_type newsize;
3058   bfd_byte *newcontents;
3059   Elf_Internal_Dyn dyn;
3060
3061   hash_table = elf_hash_table (info);
3062   if (! is_elf_hash_table (hash_table))
3063     return FALSE;
3064
3065   bed = get_elf_backend_data (hash_table->dynobj);
3066   s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3067   BFD_ASSERT (s != NULL);
3068
3069   newsize = s->size + bed->s->sizeof_dyn;
3070   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3071   if (newcontents == NULL)
3072     return FALSE;
3073
3074   dyn.d_tag = tag;
3075   dyn.d_un.d_val = val;
3076   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3077
3078   s->size = newsize;
3079   s->contents = newcontents;
3080
3081   return TRUE;
3082 }
3083
3084 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3085    otherwise just check whether one already exists.  Returns -1 on error,
3086    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3087
3088 static int
3089 elf_add_dt_needed_tag (bfd *abfd,
3090                        struct bfd_link_info *info,
3091                        const char *soname,
3092                        bfd_boolean do_it)
3093 {
3094   struct elf_link_hash_table *hash_table;
3095   bfd_size_type oldsize;
3096   bfd_size_type strindex;
3097
3098   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3099     return -1;
3100
3101   hash_table = elf_hash_table (info);
3102   oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
3103   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3104   if (strindex == (bfd_size_type) -1)
3105     return -1;
3106
3107   if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
3108     {
3109       asection *sdyn;
3110       const struct elf_backend_data *bed;
3111       bfd_byte *extdyn;
3112
3113       bed = get_elf_backend_data (hash_table->dynobj);
3114       sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3115       if (sdyn != NULL)
3116         for (extdyn = sdyn->contents;
3117              extdyn < sdyn->contents + sdyn->size;
3118              extdyn += bed->s->sizeof_dyn)
3119           {
3120             Elf_Internal_Dyn dyn;
3121
3122             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3123             if (dyn.d_tag == DT_NEEDED
3124                 && dyn.d_un.d_val == strindex)
3125               {
3126                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3127                 return 1;
3128               }
3129           }
3130     }
3131
3132   if (do_it)
3133     {
3134       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3135         return -1;
3136
3137       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3138         return -1;
3139     }
3140   else
3141     /* We were just checking for existence of the tag.  */
3142     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3143
3144   return 0;
3145 }
3146
3147 static bfd_boolean
3148 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3149 {
3150   for (; needed != NULL; needed = needed->next)
3151     if (strcmp (soname, needed->name) == 0)
3152       return TRUE;
3153
3154   return FALSE;
3155 }
3156
3157 /* Sort symbol by value and section.  */
3158 static int
3159 elf_sort_symbol (const void *arg1, const void *arg2)
3160 {
3161   const struct elf_link_hash_entry *h1;
3162   const struct elf_link_hash_entry *h2;
3163   bfd_signed_vma vdiff;
3164
3165   h1 = *(const struct elf_link_hash_entry **) arg1;
3166   h2 = *(const struct elf_link_hash_entry **) arg2;
3167   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3168   if (vdiff != 0)
3169     return vdiff > 0 ? 1 : -1;
3170   else
3171     {
3172       long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3173       if (sdiff != 0)
3174         return sdiff > 0 ? 1 : -1;
3175     }
3176   return 0;
3177 }
3178
3179 /* This function is used to adjust offsets into .dynstr for
3180    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3181
3182 static bfd_boolean
3183 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3184 {
3185   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3186
3187   if (h->root.type == bfd_link_hash_warning)
3188     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3189
3190   if (h->dynindx != -1)
3191     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3192   return TRUE;
3193 }
3194
3195 /* Assign string offsets in .dynstr, update all structures referencing
3196    them.  */
3197
3198 static bfd_boolean
3199 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3200 {
3201   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3202   struct elf_link_local_dynamic_entry *entry;
3203   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3204   bfd *dynobj = hash_table->dynobj;
3205   asection *sdyn;
3206   bfd_size_type size;
3207   const struct elf_backend_data *bed;
3208   bfd_byte *extdyn;
3209
3210   _bfd_elf_strtab_finalize (dynstr);
3211   size = _bfd_elf_strtab_size (dynstr);
3212
3213   bed = get_elf_backend_data (dynobj);
3214   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3215   BFD_ASSERT (sdyn != NULL);
3216
3217   /* Update all .dynamic entries referencing .dynstr strings.  */
3218   for (extdyn = sdyn->contents;
3219        extdyn < sdyn->contents + sdyn->size;
3220        extdyn += bed->s->sizeof_dyn)
3221     {
3222       Elf_Internal_Dyn dyn;
3223
3224       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3225       switch (dyn.d_tag)
3226         {
3227         case DT_STRSZ:
3228           dyn.d_un.d_val = size;
3229           break;
3230         case DT_NEEDED:
3231         case DT_SONAME:
3232         case DT_RPATH:
3233         case DT_RUNPATH:
3234         case DT_FILTER:
3235         case DT_AUXILIARY:
3236         case DT_AUDIT:
3237         case DT_DEPAUDIT:
3238           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3239           break;
3240         default:
3241           continue;
3242         }
3243       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3244     }
3245
3246   /* Now update local dynamic symbols.  */
3247   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3248     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3249                                                   entry->isym.st_name);
3250
3251   /* And the rest of dynamic symbols.  */
3252   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3253
3254   /* Adjust version definitions.  */
3255   if (elf_tdata (output_bfd)->cverdefs)
3256     {
3257       asection *s;
3258       bfd_byte *p;
3259       bfd_size_type i;
3260       Elf_Internal_Verdef def;
3261       Elf_Internal_Verdaux defaux;
3262
3263       s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3264       p = s->contents;
3265       do
3266         {
3267           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3268                                    &def);
3269           p += sizeof (Elf_External_Verdef);
3270           if (def.vd_aux != sizeof (Elf_External_Verdef))
3271             continue;
3272           for (i = 0; i < def.vd_cnt; ++i)
3273             {
3274               _bfd_elf_swap_verdaux_in (output_bfd,
3275                                         (Elf_External_Verdaux *) p, &defaux);
3276               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3277                                                         defaux.vda_name);
3278               _bfd_elf_swap_verdaux_out (output_bfd,
3279                                          &defaux, (Elf_External_Verdaux *) p);
3280               p += sizeof (Elf_External_Verdaux);
3281             }
3282         }
3283       while (def.vd_next);
3284     }
3285
3286   /* Adjust version references.  */
3287   if (elf_tdata (output_bfd)->verref)
3288     {
3289       asection *s;
3290       bfd_byte *p;
3291       bfd_size_type i;
3292       Elf_Internal_Verneed need;
3293       Elf_Internal_Vernaux needaux;
3294
3295       s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3296       p = s->contents;
3297       do
3298         {
3299           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3300                                     &need);
3301           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3302           _bfd_elf_swap_verneed_out (output_bfd, &need,
3303                                      (Elf_External_Verneed *) p);
3304           p += sizeof (Elf_External_Verneed);
3305           for (i = 0; i < need.vn_cnt; ++i)
3306             {
3307               _bfd_elf_swap_vernaux_in (output_bfd,
3308                                         (Elf_External_Vernaux *) p, &needaux);
3309               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3310                                                          needaux.vna_name);
3311               _bfd_elf_swap_vernaux_out (output_bfd,
3312                                          &needaux,
3313                                          (Elf_External_Vernaux *) p);
3314               p += sizeof (Elf_External_Vernaux);
3315             }
3316         }
3317       while (need.vn_next);
3318     }
3319
3320   return TRUE;
3321 }
3322 \f
3323 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3324    The default is to only match when the INPUT and OUTPUT are exactly
3325    the same target.  */
3326
3327 bfd_boolean
3328 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3329                                     const bfd_target *output)
3330 {
3331   return input == output;
3332 }
3333
3334 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3335    This version is used when different targets for the same architecture
3336    are virtually identical.  */
3337
3338 bfd_boolean
3339 _bfd_elf_relocs_compatible (const bfd_target *input,
3340                             const bfd_target *output)
3341 {
3342   const struct elf_backend_data *obed, *ibed;
3343
3344   if (input == output)
3345     return TRUE;
3346
3347   ibed = xvec_get_elf_backend_data (input);
3348   obed = xvec_get_elf_backend_data (output);
3349
3350   if (ibed->arch != obed->arch)
3351     return FALSE;
3352
3353   /* If both backends are using this function, deem them compatible.  */
3354   return ibed->relocs_compatible == obed->relocs_compatible;
3355 }
3356
3357 /* Add symbols from an ELF object file to the linker hash table.  */
3358
3359 static bfd_boolean
3360 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3361 {
3362   Elf_Internal_Ehdr *ehdr;
3363   Elf_Internal_Shdr *hdr;
3364   bfd_size_type symcount;
3365   bfd_size_type extsymcount;
3366   bfd_size_type extsymoff;
3367   struct elf_link_hash_entry **sym_hash;
3368   bfd_boolean dynamic;
3369   Elf_External_Versym *extversym = NULL;
3370   Elf_External_Versym *ever;
3371   struct elf_link_hash_entry *weaks;
3372   struct elf_link_hash_entry **nondeflt_vers = NULL;
3373   bfd_size_type nondeflt_vers_cnt = 0;
3374   Elf_Internal_Sym *isymbuf = NULL;
3375   Elf_Internal_Sym *isym;
3376   Elf_Internal_Sym *isymend;
3377   const struct elf_backend_data *bed;
3378   bfd_boolean add_needed;
3379   struct elf_link_hash_table *htab;
3380   bfd_size_type amt;
3381   void *alloc_mark = NULL;
3382   struct bfd_hash_entry **old_table = NULL;
3383   unsigned int old_size = 0;
3384   unsigned int old_count = 0;
3385   void *old_tab = NULL;
3386   void *old_hash;
3387   void *old_ent;
3388   struct bfd_link_hash_entry *old_undefs = NULL;
3389   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3390   long old_dynsymcount = 0;
3391   size_t tabsize = 0;
3392   size_t hashsize = 0;
3393
3394   htab = elf_hash_table (info);
3395   bed = get_elf_backend_data (abfd);
3396
3397   if ((abfd->flags & DYNAMIC) == 0)
3398     dynamic = FALSE;
3399   else
3400     {
3401       dynamic = TRUE;
3402
3403       /* You can't use -r against a dynamic object.  Also, there's no
3404          hope of using a dynamic object which does not exactly match
3405          the format of the output file.  */
3406       if (info->relocatable
3407           || !is_elf_hash_table (htab)
3408           || info->output_bfd->xvec != abfd->xvec)
3409         {
3410           if (info->relocatable)
3411             bfd_set_error (bfd_error_invalid_operation);
3412           else
3413             bfd_set_error (bfd_error_wrong_format);
3414           goto error_return;
3415         }
3416     }
3417
3418   ehdr = elf_elfheader (abfd);
3419   if (info->warn_alternate_em
3420       && bed->elf_machine_code != ehdr->e_machine
3421       && ((bed->elf_machine_alt1 != 0
3422            && ehdr->e_machine == bed->elf_machine_alt1)
3423           || (bed->elf_machine_alt2 != 0
3424               && ehdr->e_machine == bed->elf_machine_alt2)))
3425     info->callbacks->einfo
3426       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3427        ehdr->e_machine, abfd, bed->elf_machine_code);
3428
3429   /* As a GNU extension, any input sections which are named
3430      .gnu.warning.SYMBOL are treated as warning symbols for the given
3431      symbol.  This differs from .gnu.warning sections, which generate
3432      warnings when they are included in an output file.  */
3433   if (info->executable)
3434     {
3435       asection *s;
3436
3437       for (s = abfd->sections; s != NULL; s = s->next)
3438         {
3439           const char *name;
3440
3441           name = bfd_get_section_name (abfd, s);
3442           if (CONST_STRNEQ (name, ".gnu.warning."))
3443             {
3444               char *msg;
3445               bfd_size_type sz;
3446
3447               name += sizeof ".gnu.warning." - 1;
3448
3449               /* If this is a shared object, then look up the symbol
3450                  in the hash table.  If it is there, and it is already
3451                  been defined, then we will not be using the entry
3452                  from this shared object, so we don't need to warn.
3453                  FIXME: If we see the definition in a regular object
3454                  later on, we will warn, but we shouldn't.  The only
3455                  fix is to keep track of what warnings we are supposed
3456                  to emit, and then handle them all at the end of the
3457                  link.  */
3458               if (dynamic)
3459                 {
3460                   struct elf_link_hash_entry *h;
3461
3462                   h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3463
3464                   /* FIXME: What about bfd_link_hash_common?  */
3465                   if (h != NULL
3466                       && (h->root.type == bfd_link_hash_defined
3467                           || h->root.type == bfd_link_hash_defweak))
3468                     {
3469                       /* We don't want to issue this warning.  Clobber
3470                          the section size so that the warning does not
3471                          get copied into the output file.  */
3472                       s->size = 0;
3473                       continue;
3474                     }
3475                 }
3476
3477               sz = s->size;
3478               msg = (char *) bfd_alloc (abfd, sz + 1);
3479               if (msg == NULL)
3480                 goto error_return;
3481
3482               if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3483                 goto error_return;
3484
3485               msg[sz] = '\0';
3486
3487               if (! (_bfd_generic_link_add_one_symbol
3488                      (info, abfd, name, BSF_WARNING, s, 0, msg,
3489                       FALSE, bed->collect, NULL)))
3490                 goto error_return;
3491
3492               if (! info->relocatable)
3493                 {
3494                   /* Clobber the section size so that the warning does
3495                      not get copied into the output file.  */
3496                   s->size = 0;
3497
3498                   /* Also set SEC_EXCLUDE, so that symbols defined in
3499                      the warning section don't get copied to the output.  */
3500                   s->flags |= SEC_EXCLUDE;
3501                 }
3502             }
3503         }
3504     }
3505
3506   add_needed = TRUE;
3507   if (! dynamic)
3508     {
3509       /* If we are creating a shared library, create all the dynamic
3510          sections immediately.  We need to attach them to something,
3511          so we attach them to this BFD, provided it is the right
3512          format.  FIXME: If there are no input BFD's of the same
3513          format as the output, we can't make a shared library.  */
3514       if (info->shared
3515           && is_elf_hash_table (htab)
3516           && info->output_bfd->xvec == abfd->xvec
3517           && !htab->dynamic_sections_created)
3518         {
3519           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3520             goto error_return;
3521         }
3522     }
3523   else if (!is_elf_hash_table (htab))
3524     goto error_return;
3525   else
3526     {
3527       asection *s;
3528       const char *soname = NULL;
3529       char *audit = NULL;
3530       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3531       int ret;
3532
3533       /* ld --just-symbols and dynamic objects don't mix very well.
3534          ld shouldn't allow it.  */
3535       if ((s = abfd->sections) != NULL
3536           && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3537         abort ();
3538
3539       /* If this dynamic lib was specified on the command line with
3540          --as-needed in effect, then we don't want to add a DT_NEEDED
3541          tag unless the lib is actually used.  Similary for libs brought
3542          in by another lib's DT_NEEDED.  When --no-add-needed is used
3543          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3544          any dynamic library in DT_NEEDED tags in the dynamic lib at
3545          all.  */
3546       add_needed = (elf_dyn_lib_class (abfd)
3547                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3548                        | DYN_NO_NEEDED)) == 0;
3549
3550       s = bfd_get_section_by_name (abfd, ".dynamic");
3551       if (s != NULL)
3552         {
3553           bfd_byte *dynbuf;
3554           bfd_byte *extdyn;
3555           unsigned int elfsec;
3556           unsigned long shlink;
3557
3558           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3559             {
3560 error_free_dyn:
3561               free (dynbuf);
3562               goto error_return;
3563             }
3564
3565           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3566           if (elfsec == SHN_BAD)
3567             goto error_free_dyn;
3568           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3569
3570           for (extdyn = dynbuf;
3571                extdyn < dynbuf + s->size;
3572                extdyn += bed->s->sizeof_dyn)
3573             {
3574               Elf_Internal_Dyn dyn;
3575
3576               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3577               if (dyn.d_tag == DT_SONAME)
3578                 {
3579                   unsigned int tagv = dyn.d_un.d_val;
3580                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3581                   if (soname == NULL)
3582                     goto error_free_dyn;
3583                 }
3584               if (dyn.d_tag == DT_NEEDED)
3585                 {
3586                   struct bfd_link_needed_list *n, **pn;
3587                   char *fnm, *anm;
3588                   unsigned int tagv = dyn.d_un.d_val;
3589
3590                   amt = sizeof (struct bfd_link_needed_list);
3591                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3592                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3593                   if (n == NULL || fnm == NULL)
3594                     goto error_free_dyn;
3595                   amt = strlen (fnm) + 1;
3596                   anm = (char *) bfd_alloc (abfd, amt);
3597                   if (anm == NULL)
3598                     goto error_free_dyn;
3599                   memcpy (anm, fnm, amt);
3600                   n->name = anm;
3601                   n->by = abfd;
3602                   n->next = NULL;
3603                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3604                     ;
3605                   *pn = n;
3606                 }
3607               if (dyn.d_tag == DT_RUNPATH)
3608                 {
3609                   struct bfd_link_needed_list *n, **pn;
3610                   char *fnm, *anm;
3611                   unsigned int tagv = dyn.d_un.d_val;
3612
3613                   amt = sizeof (struct bfd_link_needed_list);
3614                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3615                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3616                   if (n == NULL || fnm == NULL)
3617                     goto error_free_dyn;
3618                   amt = strlen (fnm) + 1;
3619                   anm = (char *) bfd_alloc (abfd, amt);
3620                   if (anm == NULL)
3621                     goto error_free_dyn;
3622                   memcpy (anm, fnm, amt);
3623                   n->name = anm;
3624                   n->by = abfd;
3625                   n->next = NULL;
3626                   for (pn = & runpath;
3627                        *pn != NULL;
3628                        pn = &(*pn)->next)
3629                     ;
3630                   *pn = n;
3631                 }
3632               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3633               if (!runpath && dyn.d_tag == DT_RPATH)
3634                 {
3635                   struct bfd_link_needed_list *n, **pn;
3636                   char *fnm, *anm;
3637                   unsigned int tagv = dyn.d_un.d_val;
3638
3639                   amt = sizeof (struct bfd_link_needed_list);
3640                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3641                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3642                   if (n == NULL || fnm == NULL)
3643                     goto error_free_dyn;
3644                   amt = strlen (fnm) + 1;
3645                   anm = (char *) bfd_alloc (abfd, amt);
3646                   if (anm == NULL)
3647                     goto error_free_dyn;
3648                   memcpy (anm, fnm, amt);
3649                   n->name = anm;
3650                   n->by = abfd;
3651                   n->next = NULL;
3652                   for (pn = & rpath;
3653                        *pn != NULL;
3654                        pn = &(*pn)->next)
3655                     ;
3656                   *pn = n;
3657                 }
3658               if (dyn.d_tag == DT_AUDIT)
3659                 {
3660                   unsigned int tagv = dyn.d_un.d_val;
3661                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3662                 }
3663             }
3664
3665           free (dynbuf);
3666         }
3667
3668       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3669          frees all more recently bfd_alloc'd blocks as well.  */
3670       if (runpath)
3671         rpath = runpath;
3672
3673       if (rpath)
3674         {
3675           struct bfd_link_needed_list **pn;
3676           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3677             ;
3678           *pn = rpath;
3679         }
3680
3681       /* We do not want to include any of the sections in a dynamic
3682          object in the output file.  We hack by simply clobbering the
3683          list of sections in the BFD.  This could be handled more
3684          cleanly by, say, a new section flag; the existing
3685          SEC_NEVER_LOAD flag is not the one we want, because that one
3686          still implies that the section takes up space in the output
3687          file.  */
3688       bfd_section_list_clear (abfd);
3689
3690       /* Find the name to use in a DT_NEEDED entry that refers to this
3691          object.  If the object has a DT_SONAME entry, we use it.
3692          Otherwise, if the generic linker stuck something in
3693          elf_dt_name, we use that.  Otherwise, we just use the file
3694          name.  */
3695       if (soname == NULL || *soname == '\0')
3696         {
3697           soname = elf_dt_name (abfd);
3698           if (soname == NULL || *soname == '\0')
3699             soname = bfd_get_filename (abfd);
3700         }
3701
3702       /* Save the SONAME because sometimes the linker emulation code
3703          will need to know it.  */
3704       elf_dt_name (abfd) = soname;
3705
3706       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3707       if (ret < 0)
3708         goto error_return;
3709
3710       /* If we have already included this dynamic object in the
3711          link, just ignore it.  There is no reason to include a
3712          particular dynamic object more than once.  */
3713       if (ret > 0)
3714         return TRUE;
3715
3716       /* Save the DT_AUDIT entry for the linker emulation code. */
3717       elf_dt_audit (abfd) = audit; 
3718     }
3719
3720   /* If this is a dynamic object, we always link against the .dynsym
3721      symbol table, not the .symtab symbol table.  The dynamic linker
3722      will only see the .dynsym symbol table, so there is no reason to
3723      look at .symtab for a dynamic object.  */
3724
3725   if (! dynamic || elf_dynsymtab (abfd) == 0)
3726     hdr = &elf_tdata (abfd)->symtab_hdr;
3727   else
3728     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3729
3730   symcount = hdr->sh_size / bed->s->sizeof_sym;
3731
3732   /* The sh_info field of the symtab header tells us where the
3733      external symbols start.  We don't care about the local symbols at
3734      this point.  */
3735   if (elf_bad_symtab (abfd))
3736     {
3737       extsymcount = symcount;
3738       extsymoff = 0;
3739     }
3740   else
3741     {
3742       extsymcount = symcount - hdr->sh_info;
3743       extsymoff = hdr->sh_info;
3744     }
3745
3746   sym_hash = NULL;
3747   if (extsymcount != 0)
3748     {
3749       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3750                                       NULL, NULL, NULL);
3751       if (isymbuf == NULL)
3752         goto error_return;
3753
3754       /* We store a pointer to the hash table entry for each external
3755          symbol.  */
3756       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3757       sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
3758       if (sym_hash == NULL)
3759         goto error_free_sym;
3760       elf_sym_hashes (abfd) = sym_hash;
3761     }
3762
3763   if (dynamic)
3764     {
3765       /* Read in any version definitions.  */
3766       if (!_bfd_elf_slurp_version_tables (abfd,
3767                                           info->default_imported_symver))
3768         goto error_free_sym;
3769
3770       /* Read in the symbol versions, but don't bother to convert them
3771          to internal format.  */
3772       if (elf_dynversym (abfd) != 0)
3773         {
3774           Elf_Internal_Shdr *versymhdr;
3775
3776           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3777           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3778           if (extversym == NULL)
3779             goto error_free_sym;
3780           amt = versymhdr->sh_size;
3781           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3782               || bfd_bread (extversym, amt, abfd) != amt)
3783             goto error_free_vers;
3784         }
3785     }
3786
3787   /* If we are loading an as-needed shared lib, save the symbol table
3788      state before we start adding symbols.  If the lib turns out
3789      to be unneeded, restore the state.  */
3790   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3791     {
3792       unsigned int i;
3793       size_t entsize;
3794
3795       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3796         {
3797           struct bfd_hash_entry *p;
3798           struct elf_link_hash_entry *h;
3799
3800           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3801             {
3802               h = (struct elf_link_hash_entry *) p;
3803               entsize += htab->root.table.entsize;
3804               if (h->root.type == bfd_link_hash_warning)
3805                 entsize += htab->root.table.entsize;
3806             }
3807         }
3808
3809       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3810       hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
3811       old_tab = bfd_malloc (tabsize + entsize + hashsize);
3812       if (old_tab == NULL)
3813         goto error_free_vers;
3814
3815       /* Remember the current objalloc pointer, so that all mem for
3816          symbols added can later be reclaimed.  */
3817       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3818       if (alloc_mark == NULL)
3819         goto error_free_vers;
3820
3821       /* Make a special call to the linker "notice" function to
3822          tell it that we are about to handle an as-needed lib.  */
3823       if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3824                                        notice_as_needed, 0, NULL))
3825         goto error_free_vers;
3826
3827       /* Clone the symbol table and sym hashes.  Remember some
3828          pointers into the symbol table, and dynamic symbol count.  */
3829       old_hash = (char *) old_tab + tabsize;
3830       old_ent = (char *) old_hash + hashsize;
3831       memcpy (old_tab, htab->root.table.table, tabsize);
3832       memcpy (old_hash, sym_hash, hashsize);
3833       old_undefs = htab->root.undefs;
3834       old_undefs_tail = htab->root.undefs_tail;
3835       old_table = htab->root.table.table;
3836       old_size = htab->root.table.size;
3837       old_count = htab->root.table.count;
3838       old_dynsymcount = htab->dynsymcount;
3839
3840       for (i = 0; i < htab->root.table.size; i++)
3841         {
3842           struct bfd_hash_entry *p;
3843           struct elf_link_hash_entry *h;
3844
3845           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3846             {
3847               memcpy (old_ent, p, htab->root.table.entsize);
3848               old_ent = (char *) old_ent + htab->root.table.entsize;
3849               h = (struct elf_link_hash_entry *) p;
3850               if (h->root.type == bfd_link_hash_warning)
3851                 {
3852                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3853                   old_ent = (char *) old_ent + htab->root.table.entsize;
3854                 }
3855             }
3856         }
3857     }
3858
3859   weaks = NULL;
3860   ever = extversym != NULL ? extversym + extsymoff : NULL;
3861   for (isym = isymbuf, isymend = isymbuf + extsymcount;
3862        isym < isymend;
3863        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3864     {
3865       int bind;
3866       bfd_vma value;
3867       asection *sec, *new_sec;
3868       flagword flags;
3869       const char *name;
3870       struct elf_link_hash_entry *h;
3871       bfd_boolean definition;
3872       bfd_boolean size_change_ok;
3873       bfd_boolean type_change_ok;
3874       bfd_boolean new_weakdef;
3875       bfd_boolean override;
3876       bfd_boolean common;
3877       unsigned int old_alignment;
3878       bfd *old_bfd;
3879       bfd * undef_bfd = NULL;
3880
3881       override = FALSE;
3882
3883       flags = BSF_NO_FLAGS;
3884       sec = NULL;
3885       value = isym->st_value;
3886       *sym_hash = NULL;
3887       common = bed->common_definition (isym);
3888
3889       bind = ELF_ST_BIND (isym->st_info);
3890       switch (bind)
3891         {
3892         case STB_LOCAL:
3893           /* This should be impossible, since ELF requires that all
3894              global symbols follow all local symbols, and that sh_info
3895              point to the first global symbol.  Unfortunately, Irix 5
3896              screws this up.  */
3897           continue;
3898
3899         case STB_GLOBAL:
3900           if (isym->st_shndx != SHN_UNDEF && !common)
3901             flags = BSF_GLOBAL;
3902           break;
3903
3904         case STB_WEAK:
3905           flags = BSF_WEAK;
3906           break;
3907
3908         case STB_GNU_UNIQUE:
3909           flags = BSF_GNU_UNIQUE;
3910           break;
3911
3912         default:
3913           /* Leave it up to the processor backend.  */
3914           break;
3915         }
3916
3917       if (isym->st_shndx == SHN_UNDEF)
3918         sec = bfd_und_section_ptr;
3919       else if (isym->st_shndx == SHN_ABS)
3920         sec = bfd_abs_section_ptr;
3921       else if (isym->st_shndx == SHN_COMMON)
3922         {
3923           sec = bfd_com_section_ptr;
3924           /* What ELF calls the size we call the value.  What ELF
3925              calls the value we call the alignment.  */
3926           value = isym->st_size;
3927         }
3928       else
3929         {
3930           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3931           if (sec == NULL)
3932             sec = bfd_abs_section_ptr;
3933           else if (sec->kept_section)
3934             {
3935               /* Symbols from discarded section are undefined.  We keep
3936                  its visibility.  */
3937               sec = bfd_und_section_ptr;
3938               isym->st_shndx = SHN_UNDEF;
3939             }
3940           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3941             value -= sec->vma;
3942         }
3943
3944       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3945                                               isym->st_name);
3946       if (name == NULL)
3947         goto error_free_vers;
3948
3949       if (isym->st_shndx == SHN_COMMON
3950           && (abfd->flags & BFD_PLUGIN) != 0)
3951         {
3952           asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3953
3954           if (xc == NULL)
3955             {
3956               flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3957                                  | SEC_EXCLUDE);
3958               xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3959               if (xc == NULL)
3960                 goto error_free_vers;
3961             }
3962           sec = xc;
3963         }
3964       else if (isym->st_shndx == SHN_COMMON
3965                && ELF_ST_TYPE (isym->st_info) == STT_TLS
3966                && !info->relocatable)
3967         {
3968           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3969
3970           if (tcomm == NULL)
3971             {
3972               flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3973                                  | SEC_LINKER_CREATED);
3974               tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3975               if (tcomm == NULL)
3976                 goto error_free_vers;
3977             }
3978           sec = tcomm;
3979         }
3980       else if (bed->elf_add_symbol_hook)
3981         {
3982           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3983                                              &sec, &value))
3984             goto error_free_vers;
3985
3986           /* The hook function sets the name to NULL if this symbol
3987              should be skipped for some reason.  */
3988           if (name == NULL)
3989             continue;
3990         }
3991
3992       /* Sanity check that all possibilities were handled.  */
3993       if (sec == NULL)
3994         {
3995           bfd_set_error (bfd_error_bad_value);
3996           goto error_free_vers;
3997         }
3998
3999       if (bfd_is_und_section (sec)
4000           || bfd_is_com_section (sec))
4001         definition = FALSE;
4002       else
4003         definition = TRUE;
4004
4005       size_change_ok = FALSE;
4006       type_change_ok = bed->type_change_ok;
4007       old_alignment = 0;
4008       old_bfd = NULL;
4009       new_sec = sec;
4010
4011       if (is_elf_hash_table (htab))
4012         {
4013           Elf_Internal_Versym iver;
4014           unsigned int vernum = 0;
4015           bfd_boolean skip;
4016
4017           /* If this is a definition of a symbol which was previously
4018              referenced in a non-weak manner then make a note of the bfd
4019              that contained the reference.  This is used if we need to
4020              refer to the source of the reference later on.  */
4021           if (! bfd_is_und_section (sec))
4022             {
4023               h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
4024
4025               if (h != NULL
4026                   && h->root.type == bfd_link_hash_undefined
4027                   && h->root.u.undef.abfd)
4028                 undef_bfd = h->root.u.undef.abfd;
4029             }
4030           
4031           if (ever == NULL)
4032             {
4033               if (info->default_imported_symver)
4034                 /* Use the default symbol version created earlier.  */
4035                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
4036               else
4037                 iver.vs_vers = 0;
4038             }
4039           else
4040             _bfd_elf_swap_versym_in (abfd, ever, &iver);
4041
4042           vernum = iver.vs_vers & VERSYM_VERSION;
4043
4044           /* If this is a hidden symbol, or if it is not version
4045              1, we append the version name to the symbol name.
4046              However, we do not modify a non-hidden absolute symbol
4047              if it is not a function, because it might be the version
4048              symbol itself.  FIXME: What if it isn't?  */
4049           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4050               || (vernum > 1
4051                   && (!bfd_is_abs_section (sec)
4052                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4053             {
4054               const char *verstr;
4055               size_t namelen, verlen, newlen;
4056               char *newname, *p;
4057
4058               if (isym->st_shndx != SHN_UNDEF)
4059                 {
4060                   if (vernum > elf_tdata (abfd)->cverdefs)
4061                     verstr = NULL;
4062                   else if (vernum > 1)
4063                     verstr =
4064                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4065                   else
4066                     verstr = "";
4067
4068                   if (verstr == NULL)
4069                     {
4070                       (*_bfd_error_handler)
4071                         (_("%B: %s: invalid version %u (max %d)"),
4072                          abfd, name, vernum,
4073                          elf_tdata (abfd)->cverdefs);
4074                       bfd_set_error (bfd_error_bad_value);
4075                       goto error_free_vers;
4076                     }
4077                 }
4078               else
4079                 {
4080                   /* We cannot simply test for the number of
4081                      entries in the VERNEED section since the
4082                      numbers for the needed versions do not start
4083                      at 0.  */
4084                   Elf_Internal_Verneed *t;
4085
4086                   verstr = NULL;
4087                   for (t = elf_tdata (abfd)->verref;
4088                        t != NULL;
4089                        t = t->vn_nextref)
4090                     {
4091                       Elf_Internal_Vernaux *a;
4092
4093                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4094                         {
4095                           if (a->vna_other == vernum)
4096                             {
4097                               verstr = a->vna_nodename;
4098                               break;
4099                             }
4100                         }
4101                       if (a != NULL)
4102                         break;
4103                     }
4104                   if (verstr == NULL)
4105                     {
4106                       (*_bfd_error_handler)