ktr.4: Forgot an .El
[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
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   /* Check TLS symbol.  We don't check undefined symbol introduced by
1089      "ld -u".  */
1090   if ((ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS)
1091       && ELF_ST_TYPE (sym->st_info) != h->type
1092       && oldbfd != NULL)
1093     {
1094       bfd *ntbfd, *tbfd;
1095       bfd_boolean ntdef, tdef;
1096       asection *ntsec, *tsec;
1097
1098       if (h->type == STT_TLS)
1099         {
1100           ntbfd = abfd;
1101           ntsec = sec;
1102           ntdef = newdef;
1103           tbfd = oldbfd;
1104           tsec = oldsec;
1105           tdef = olddef;
1106         }
1107       else
1108         {
1109           ntbfd = oldbfd;
1110           ntsec = oldsec;
1111           ntdef = olddef;
1112           tbfd = abfd;
1113           tsec = sec;
1114           tdef = newdef;
1115         }
1116
1117       if (tdef && ntdef)
1118         (*_bfd_error_handler)
1119           (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1120            tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1121       else if (!tdef && !ntdef)
1122         (*_bfd_error_handler)
1123           (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1124            tbfd, ntbfd, h->root.root.string);
1125       else if (tdef)
1126         (*_bfd_error_handler)
1127           (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1128            tbfd, tsec, ntbfd, h->root.root.string);
1129       else
1130         (*_bfd_error_handler)
1131           (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1132            tbfd, ntbfd, ntsec, h->root.root.string);
1133
1134       bfd_set_error (bfd_error_bad_value);
1135       return FALSE;
1136     }
1137
1138   /* We need to remember if a symbol has a definition in a dynamic
1139      object or is weak in all dynamic objects. Internal and hidden
1140      visibility will make it unavailable to dynamic objects.  */
1141   if (newdyn && !h->dynamic_def)
1142     {
1143       if (!bfd_is_und_section (sec))
1144         h->dynamic_def = 1;
1145       else
1146         {
1147           /* Check if this symbol is weak in all dynamic objects. If it
1148              is the first time we see it in a dynamic object, we mark
1149              if it is weak. Otherwise, we clear it.  */
1150           if (!h->ref_dynamic)
1151             {
1152               if (bind == STB_WEAK)
1153                 h->dynamic_weak = 1;
1154             }
1155           else if (bind != STB_WEAK)
1156             h->dynamic_weak = 0;
1157         }
1158     }
1159
1160   /* If the old symbol has non-default visibility, we ignore the new
1161      definition from a dynamic object.  */
1162   if (newdyn
1163       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1164       && !bfd_is_und_section (sec))
1165     {
1166       *skip = TRUE;
1167       /* Make sure this symbol is dynamic.  */
1168       h->ref_dynamic = 1;
1169       /* A protected symbol has external availability. Make sure it is
1170          recorded as dynamic.
1171
1172          FIXME: Should we check type and size for protected symbol?  */
1173       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1174         return bfd_elf_link_record_dynamic_symbol (info, h);
1175       else
1176         return TRUE;
1177     }
1178   else if (!newdyn
1179            && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1180            && h->def_dynamic)
1181     {
1182       /* If the new symbol with non-default visibility comes from a
1183          relocatable file and the old definition comes from a dynamic
1184          object, we remove the old definition.  */
1185       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1186         {
1187           /* Handle the case where the old dynamic definition is
1188              default versioned.  We need to copy the symbol info from
1189              the symbol with default version to the normal one if it
1190              was referenced before.  */
1191           if (h->ref_regular)
1192             {
1193               struct elf_link_hash_entry *vh = *sym_hash;
1194
1195               vh->root.type = h->root.type;
1196               h->root.type = bfd_link_hash_indirect;
1197               (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
1198               /* Protected symbols will override the dynamic definition
1199                  with default version.  */
1200               if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED)
1201                 {
1202                   h->root.u.i.link = (struct bfd_link_hash_entry *) vh;
1203                   vh->dynamic_def = 1;
1204                   vh->ref_dynamic = 1;
1205                 }
1206               else
1207                 {
1208                   h->root.type = vh->root.type;
1209                   vh->ref_dynamic = 0;
1210                   /* We have to hide it here since it was made dynamic
1211                      global with extra bits when the symbol info was
1212                      copied from the old dynamic definition.  */
1213                   (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
1214                 }
1215               h = vh;
1216             }
1217           else
1218             h = *sym_hash;
1219         }
1220
1221       if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1222           && bfd_is_und_section (sec))
1223         {
1224           /* If the new symbol is undefined and the old symbol was
1225              also undefined before, we need to make sure
1226              _bfd_generic_link_add_one_symbol doesn't mess
1227              up the linker hash table undefs list.  Since the old
1228              definition came from a dynamic object, it is still on the
1229              undefs list.  */
1230           h->root.type = bfd_link_hash_undefined;
1231           h->root.u.undef.abfd = abfd;
1232         }
1233       else
1234         {
1235           h->root.type = bfd_link_hash_new;
1236           h->root.u.undef.abfd = NULL;
1237         }
1238
1239       if (h->def_dynamic)
1240         {
1241           h->def_dynamic = 0;
1242           h->ref_dynamic = 1;
1243           h->dynamic_def = 1;
1244         }
1245       /* FIXME: Should we check type and size for protected symbol?  */
1246       h->size = 0;
1247       h->type = 0;
1248       return TRUE;
1249     }
1250
1251   if (bind == STB_GNU_UNIQUE)
1252     h->unique_global = 1;
1253
1254   /* If a new weak symbol definition comes from a regular file and the
1255      old symbol comes from a dynamic library, we treat the new one as
1256      strong.  Similarly, an old weak symbol definition from a regular
1257      file is treated as strong when the new symbol comes from a dynamic
1258      library.  Further, an old weak symbol from a dynamic library is
1259      treated as strong if the new symbol is from a dynamic library.
1260      This reflects the way glibc's ld.so works.
1261
1262      Do this before setting *type_change_ok or *size_change_ok so that
1263      we warn properly when dynamic library symbols are overridden.  */
1264
1265   if (newdef && !newdyn && olddyn)
1266     newweak = FALSE;
1267   if (olddef && newdyn)
1268     oldweak = FALSE;
1269
1270   /* Allow changes between different types of function symbol.  */
1271   if (newfunc && oldfunc)
1272     *type_change_ok = TRUE;
1273
1274   /* It's OK to change the type if either the existing symbol or the
1275      new symbol is weak.  A type change is also OK if the old symbol
1276      is undefined and the new symbol is defined.  */
1277
1278   if (oldweak
1279       || newweak
1280       || (newdef
1281           && h->root.type == bfd_link_hash_undefined))
1282     *type_change_ok = TRUE;
1283
1284   /* It's OK to change the size if either the existing symbol or the
1285      new symbol is weak, or if the old symbol is undefined.  */
1286
1287   if (*type_change_ok
1288       || h->root.type == bfd_link_hash_undefined)
1289     *size_change_ok = TRUE;
1290
1291   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1292      symbol, respectively, appears to be a common symbol in a dynamic
1293      object.  If a symbol appears in an uninitialized section, and is
1294      not weak, and is not a function, then it may be a common symbol
1295      which was resolved when the dynamic object was created.  We want
1296      to treat such symbols specially, because they raise special
1297      considerations when setting the symbol size: if the symbol
1298      appears as a common symbol in a regular object, and the size in
1299      the regular object is larger, we must make sure that we use the
1300      larger size.  This problematic case can always be avoided in C,
1301      but it must be handled correctly when using Fortran shared
1302      libraries.
1303
1304      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1305      likewise for OLDDYNCOMMON and OLDDEF.
1306
1307      Note that this test is just a heuristic, and that it is quite
1308      possible to have an uninitialized symbol in a shared object which
1309      is really a definition, rather than a common symbol.  This could
1310      lead to some minor confusion when the symbol really is a common
1311      symbol in some regular object.  However, I think it will be
1312      harmless.  */
1313
1314   if (newdyn
1315       && newdef
1316       && !newweak
1317       && (sec->flags & SEC_ALLOC) != 0
1318       && (sec->flags & SEC_LOAD) == 0
1319       && sym->st_size > 0
1320       && !newfunc)
1321     newdyncommon = TRUE;
1322   else
1323     newdyncommon = FALSE;
1324
1325   if (olddyn
1326       && olddef
1327       && h->root.type == bfd_link_hash_defined
1328       && h->def_dynamic
1329       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1330       && (h->root.u.def.section->flags & SEC_LOAD) == 0
1331       && h->size > 0
1332       && !oldfunc)
1333     olddyncommon = TRUE;
1334   else
1335     olddyncommon = FALSE;
1336
1337   /* We now know everything about the old and new symbols.  We ask the
1338      backend to check if we can merge them.  */
1339   if (bed->merge_symbol
1340       && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue,
1341                              pold_alignment, skip, override,
1342                              type_change_ok, size_change_ok,
1343                              &newdyn, &newdef, &newdyncommon, &newweak,
1344                              abfd, &sec,
1345                              &olddyn, &olddef, &olddyncommon, &oldweak,
1346                              oldbfd, &oldsec))
1347     return FALSE;
1348
1349   /* If both the old and the new symbols look like common symbols in a
1350      dynamic object, set the size of the symbol to the larger of the
1351      two.  */
1352
1353   if (olddyncommon
1354       && newdyncommon
1355       && sym->st_size != h->size)
1356     {
1357       /* Since we think we have two common symbols, issue a multiple
1358          common warning if desired.  Note that we only warn if the
1359          size is different.  If the size is the same, we simply let
1360          the old symbol override the new one as normally happens with
1361          symbols defined in dynamic objects.  */
1362
1363       if (! ((*info->callbacks->multiple_common)
1364              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
1365               h->size, abfd, bfd_link_hash_common, sym->st_size)))
1366         return FALSE;
1367
1368       if (sym->st_size > h->size)
1369         h->size = sym->st_size;
1370
1371       *size_change_ok = TRUE;
1372     }
1373
1374   /* If we are looking at a dynamic object, and we have found a
1375      definition, we need to see if the symbol was already defined by
1376      some other object.  If so, we want to use the existing
1377      definition, and we do not want to report a multiple symbol
1378      definition error; we do this by clobbering *PSEC to be
1379      bfd_und_section_ptr.
1380
1381      We treat a common symbol as a definition if the symbol in the
1382      shared library is a function, since common symbols always
1383      represent variables; this can cause confusion in principle, but
1384      any such confusion would seem to indicate an erroneous program or
1385      shared library.  We also permit a common symbol in a regular
1386      object to override a weak symbol in a shared object.  */
1387
1388   if (newdyn
1389       && newdef
1390       && (olddef
1391           || (h->root.type == bfd_link_hash_common
1392               && (newweak || newfunc))))
1393     {
1394       *override = TRUE;
1395       newdef = FALSE;
1396       newdyncommon = FALSE;
1397
1398       *psec = sec = bfd_und_section_ptr;
1399       *size_change_ok = TRUE;
1400
1401       /* If we get here when the old symbol is a common symbol, then
1402          we are explicitly letting it override a weak symbol or
1403          function in a dynamic object, and we don't want to warn about
1404          a type change.  If the old symbol is a defined symbol, a type
1405          change warning may still be appropriate.  */
1406
1407       if (h->root.type == bfd_link_hash_common)
1408         *type_change_ok = TRUE;
1409     }
1410
1411   /* Handle the special case of an old common symbol merging with a
1412      new symbol which looks like a common symbol in a shared object.
1413      We change *PSEC and *PVALUE to make the new symbol look like a
1414      common symbol, and let _bfd_generic_link_add_one_symbol do the
1415      right thing.  */
1416
1417   if (newdyncommon
1418       && h->root.type == bfd_link_hash_common)
1419     {
1420       *override = TRUE;
1421       newdef = FALSE;
1422       newdyncommon = FALSE;
1423       *pvalue = sym->st_size;
1424       *psec = sec = bed->common_section (oldsec);
1425       *size_change_ok = TRUE;
1426     }
1427
1428   /* Skip weak definitions of symbols that are already defined.  */
1429   if (newdef && olddef && newweak)
1430     {
1431       *skip = TRUE;
1432
1433       /* Merge st_other.  If the symbol already has a dynamic index,
1434          but visibility says it should not be visible, turn it into a
1435          local symbol.  */
1436       elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1437       if (h->dynindx != -1)
1438         switch (ELF_ST_VISIBILITY (h->other))
1439           {
1440           case STV_INTERNAL:
1441           case STV_HIDDEN:
1442             (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1443             break;
1444           }
1445     }
1446
1447   /* If the old symbol is from a dynamic object, and the new symbol is
1448      a definition which is not from a dynamic object, then the new
1449      symbol overrides the old symbol.  Symbols from regular files
1450      always take precedence over symbols from dynamic objects, even if
1451      they are defined after the dynamic object in the link.
1452
1453      As above, we again permit a common symbol in a regular object to
1454      override a definition in a shared object if the shared object
1455      symbol is a function or is weak.  */
1456
1457   flip = NULL;
1458   if (!newdyn
1459       && (newdef
1460           || (bfd_is_com_section (sec)
1461               && (oldweak || oldfunc)))
1462       && olddyn
1463       && olddef
1464       && h->def_dynamic)
1465     {
1466       /* Change the hash table entry to undefined, and let
1467          _bfd_generic_link_add_one_symbol do the right thing with the
1468          new definition.  */
1469
1470       h->root.type = bfd_link_hash_undefined;
1471       h->root.u.undef.abfd = h->root.u.def.section->owner;
1472       *size_change_ok = TRUE;
1473
1474       olddef = FALSE;
1475       olddyncommon = FALSE;
1476
1477       /* We again permit a type change when a common symbol may be
1478          overriding a function.  */
1479
1480       if (bfd_is_com_section (sec))
1481         {
1482           if (oldfunc)
1483             {
1484               /* If a common symbol overrides a function, make sure
1485                  that it isn't defined dynamically nor has type
1486                  function.  */
1487               h->def_dynamic = 0;
1488               h->type = STT_NOTYPE;
1489             }
1490           *type_change_ok = TRUE;
1491         }
1492
1493       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1494         flip = *sym_hash;
1495       else
1496         /* This union may have been set to be non-NULL when this symbol
1497            was seen in a dynamic object.  We must force the union to be
1498            NULL, so that it is correct for a regular symbol.  */
1499         h->verinfo.vertree = NULL;
1500     }
1501
1502   /* Handle the special case of a new common symbol merging with an
1503      old symbol that looks like it might be a common symbol defined in
1504      a shared object.  Note that we have already handled the case in
1505      which a new common symbol should simply override the definition
1506      in the shared library.  */
1507
1508   if (! newdyn
1509       && bfd_is_com_section (sec)
1510       && olddyncommon)
1511     {
1512       /* It would be best if we could set the hash table entry to a
1513          common symbol, but we don't know what to use for the section
1514          or the alignment.  */
1515       if (! ((*info->callbacks->multiple_common)
1516              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
1517               h->size, abfd, bfd_link_hash_common, sym->st_size)))
1518         return FALSE;
1519
1520       /* If the presumed common symbol in the dynamic object is
1521          larger, pretend that the new symbol has its size.  */
1522
1523       if (h->size > *pvalue)
1524         *pvalue = h->size;
1525
1526       /* We need to remember the alignment required by the symbol
1527          in the dynamic object.  */
1528       BFD_ASSERT (pold_alignment);
1529       *pold_alignment = h->root.u.def.section->alignment_power;
1530
1531       olddef = FALSE;
1532       olddyncommon = FALSE;
1533
1534       h->root.type = bfd_link_hash_undefined;
1535       h->root.u.undef.abfd = h->root.u.def.section->owner;
1536
1537       *size_change_ok = TRUE;
1538       *type_change_ok = TRUE;
1539
1540       if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1541         flip = *sym_hash;
1542       else
1543         h->verinfo.vertree = NULL;
1544     }
1545
1546   if (flip != NULL)
1547     {
1548       /* Handle the case where we had a versioned symbol in a dynamic
1549          library and now find a definition in a normal object.  In this
1550          case, we make the versioned symbol point to the normal one.  */
1551       flip->root.type = h->root.type;
1552       flip->root.u.undef.abfd = h->root.u.undef.abfd;
1553       h->root.type = bfd_link_hash_indirect;
1554       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1555       (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1556       if (h->def_dynamic)
1557         {
1558           h->def_dynamic = 0;
1559           flip->ref_dynamic = 1;
1560         }
1561     }
1562
1563   return TRUE;
1564 }
1565
1566 /* This function is called to create an indirect symbol from the
1567    default for the symbol with the default version if needed. The
1568    symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE.  We
1569    set DYNSYM if the new indirect symbol is dynamic.  */
1570
1571 static bfd_boolean
1572 _bfd_elf_add_default_symbol (bfd *abfd,
1573                              struct bfd_link_info *info,
1574                              struct elf_link_hash_entry *h,
1575                              const char *name,
1576                              Elf_Internal_Sym *sym,
1577                              asection **psec,
1578                              bfd_vma *value,
1579                              bfd_boolean *dynsym,
1580                              bfd_boolean override)
1581 {
1582   bfd_boolean type_change_ok;
1583   bfd_boolean size_change_ok;
1584   bfd_boolean skip;
1585   char *shortname;
1586   struct elf_link_hash_entry *hi;
1587   struct bfd_link_hash_entry *bh;
1588   const struct elf_backend_data *bed;
1589   bfd_boolean collect;
1590   bfd_boolean dynamic;
1591   char *p;
1592   size_t len, shortlen;
1593   asection *sec;
1594
1595   /* If this symbol has a version, and it is the default version, we
1596      create an indirect symbol from the default name to the fully
1597      decorated name.  This will cause external references which do not
1598      specify a version to be bound to this version of the symbol.  */
1599   p = strchr (name, ELF_VER_CHR);
1600   if (p == NULL || p[1] != ELF_VER_CHR)
1601     return TRUE;
1602
1603   if (override)
1604     {
1605       /* We are overridden by an old definition. We need to check if we
1606          need to create the indirect symbol from the default name.  */
1607       hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE,
1608                                  FALSE, FALSE);
1609       BFD_ASSERT (hi != NULL);
1610       if (hi == h)
1611         return TRUE;
1612       while (hi->root.type == bfd_link_hash_indirect
1613              || hi->root.type == bfd_link_hash_warning)
1614         {
1615           hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1616           if (hi == h)
1617             return TRUE;
1618         }
1619     }
1620
1621   bed = get_elf_backend_data (abfd);
1622   collect = bed->collect;
1623   dynamic = (abfd->flags & DYNAMIC) != 0;
1624
1625   shortlen = p - name;
1626   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1627   if (shortname == NULL)
1628     return FALSE;
1629   memcpy (shortname, name, shortlen);
1630   shortname[shortlen] = '\0';
1631
1632   /* We are going to create a new symbol.  Merge it with any existing
1633      symbol with this name.  For the purposes of the merge, act as
1634      though we were defining the symbol we just defined, although we
1635      actually going to define an indirect symbol.  */
1636   type_change_ok = FALSE;
1637   size_change_ok = FALSE;
1638   sec = *psec;
1639   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1640                               NULL, &hi, &skip, &override,
1641                               &type_change_ok, &size_change_ok))
1642     return FALSE;
1643
1644   if (skip)
1645     goto nondefault;
1646
1647   if (! override)
1648     {
1649       bh = &hi->root;
1650       if (! (_bfd_generic_link_add_one_symbol
1651              (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1652               0, name, FALSE, collect, &bh)))
1653         return FALSE;
1654       hi = (struct elf_link_hash_entry *) bh;
1655     }
1656   else
1657     {
1658       /* In this case the symbol named SHORTNAME is overriding the
1659          indirect symbol we want to add.  We were planning on making
1660          SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1661          is the name without a version.  NAME is the fully versioned
1662          name, and it is the default version.
1663
1664          Overriding means that we already saw a definition for the
1665          symbol SHORTNAME in a regular object, and it is overriding
1666          the symbol defined in the dynamic object.
1667
1668          When this happens, we actually want to change NAME, the
1669          symbol we just added, to refer to SHORTNAME.  This will cause
1670          references to NAME in the shared object to become references
1671          to SHORTNAME in the regular object.  This is what we expect
1672          when we override a function in a shared object: that the
1673          references in the shared object will be mapped to the
1674          definition in the regular object.  */
1675
1676       while (hi->root.type == bfd_link_hash_indirect
1677              || hi->root.type == bfd_link_hash_warning)
1678         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1679
1680       h->root.type = bfd_link_hash_indirect;
1681       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1682       if (h->def_dynamic)
1683         {
1684           h->def_dynamic = 0;
1685           hi->ref_dynamic = 1;
1686           if (hi->ref_regular
1687               || hi->def_regular)
1688             {
1689               if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1690                 return FALSE;
1691             }
1692         }
1693
1694       /* Now set HI to H, so that the following code will set the
1695          other fields correctly.  */
1696       hi = h;
1697     }
1698
1699   /* Check if HI is a warning symbol.  */
1700   if (hi->root.type == bfd_link_hash_warning)
1701     hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1702
1703   /* If there is a duplicate definition somewhere, then HI may not
1704      point to an indirect symbol.  We will have reported an error to
1705      the user in that case.  */
1706
1707   if (hi->root.type == bfd_link_hash_indirect)
1708     {
1709       struct elf_link_hash_entry *ht;
1710
1711       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1712       (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1713
1714       /* See if the new flags lead us to realize that the symbol must
1715          be dynamic.  */
1716       if (! *dynsym)
1717         {
1718           if (! dynamic)
1719             {
1720               if (! info->executable
1721                   || hi->ref_dynamic)
1722                 *dynsym = TRUE;
1723             }
1724           else
1725             {
1726               if (hi->ref_regular)
1727                 *dynsym = TRUE;
1728             }
1729         }
1730     }
1731
1732   /* We also need to define an indirection from the nondefault version
1733      of the symbol.  */
1734
1735 nondefault:
1736   len = strlen (name);
1737   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1738   if (shortname == NULL)
1739     return FALSE;
1740   memcpy (shortname, name, shortlen);
1741   memcpy (shortname + shortlen, p + 1, len - shortlen);
1742
1743   /* Once again, merge with any existing symbol.  */
1744   type_change_ok = FALSE;
1745   size_change_ok = FALSE;
1746   sec = *psec;
1747   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1748                               NULL, &hi, &skip, &override,
1749                               &type_change_ok, &size_change_ok))
1750     return FALSE;
1751
1752   if (skip)
1753     return TRUE;
1754
1755   if (override)
1756     {
1757       /* Here SHORTNAME is a versioned name, so we don't expect to see
1758          the type of override we do in the case above unless it is
1759          overridden by a versioned definition.  */
1760       if (hi->root.type != bfd_link_hash_defined
1761           && hi->root.type != bfd_link_hash_defweak)
1762         (*_bfd_error_handler)
1763           (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1764            abfd, shortname);
1765     }
1766   else
1767     {
1768       bh = &hi->root;
1769       if (! (_bfd_generic_link_add_one_symbol
1770              (info, abfd, shortname, BSF_INDIRECT,
1771               bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1772         return FALSE;
1773       hi = (struct elf_link_hash_entry *) bh;
1774
1775       /* If there is a duplicate definition somewhere, then HI may not
1776          point to an indirect symbol.  We will have reported an error
1777          to the user in that case.  */
1778
1779       if (hi->root.type == bfd_link_hash_indirect)
1780         {
1781           (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1782
1783           /* See if the new flags lead us to realize that the symbol
1784              must be dynamic.  */
1785           if (! *dynsym)
1786             {
1787               if (! dynamic)
1788                 {
1789                   if (! info->executable
1790                       || hi->ref_dynamic)
1791                     *dynsym = TRUE;
1792                 }
1793               else
1794                 {
1795                   if (hi->ref_regular)
1796                     *dynsym = TRUE;
1797                 }
1798             }
1799         }
1800     }
1801
1802   return TRUE;
1803 }
1804 \f
1805 /* This routine is used to export all defined symbols into the dynamic
1806    symbol table.  It is called via elf_link_hash_traverse.  */
1807
1808 static bfd_boolean
1809 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1810 {
1811   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1812
1813   /* Ignore this if we won't export it.  */
1814   if (!eif->info->export_dynamic && !h->dynamic)
1815     return TRUE;
1816
1817   /* Ignore indirect symbols.  These are added by the versioning code.  */
1818   if (h->root.type == bfd_link_hash_indirect)
1819     return TRUE;
1820
1821   if (h->root.type == bfd_link_hash_warning)
1822     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1823
1824   if (h->dynindx == -1
1825       && (h->def_regular
1826           || h->ref_regular))
1827     {
1828       bfd_boolean hide;
1829
1830       if (eif->verdefs == NULL
1831           || (bfd_find_version_for_sym (eif->verdefs, h->root.root.string, &hide)
1832               && !hide))
1833         {
1834           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1835             {
1836               eif->failed = TRUE;
1837               return FALSE;
1838             }
1839         }
1840     }
1841
1842   return TRUE;
1843 }
1844 \f
1845 /* Look through the symbols which are defined in other shared
1846    libraries and referenced here.  Update the list of version
1847    dependencies.  This will be put into the .gnu.version_r section.
1848    This function is called via elf_link_hash_traverse.  */
1849
1850 static bfd_boolean
1851 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1852                                          void *data)
1853 {
1854   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1855   Elf_Internal_Verneed *t;
1856   Elf_Internal_Vernaux *a;
1857   bfd_size_type amt;
1858
1859   if (h->root.type == bfd_link_hash_warning)
1860     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1861
1862   /* We only care about symbols defined in shared objects with version
1863      information.  */
1864   if (!h->def_dynamic
1865       || h->def_regular
1866       || h->dynindx == -1
1867       || h->verinfo.verdef == NULL)
1868     return TRUE;
1869
1870   /* See if we already know about this version.  */
1871   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1872        t != NULL;
1873        t = t->vn_nextref)
1874     {
1875       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1876         continue;
1877
1878       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1879         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1880           return TRUE;
1881
1882       break;
1883     }
1884
1885   /* This is a new version.  Add it to tree we are building.  */
1886
1887   if (t == NULL)
1888     {
1889       amt = sizeof *t;
1890       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1891       if (t == NULL)
1892         {
1893           rinfo->failed = TRUE;
1894           return FALSE;
1895         }
1896
1897       t->vn_bfd = h->verinfo.verdef->vd_bfd;
1898       t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1899       elf_tdata (rinfo->info->output_bfd)->verref = t;
1900     }
1901
1902   amt = sizeof *a;
1903   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1904   if (a == NULL)
1905     {
1906       rinfo->failed = TRUE;
1907       return FALSE;
1908     }
1909
1910   /* Note that we are copying a string pointer here, and testing it
1911      above.  If bfd_elf_string_from_elf_section is ever changed to
1912      discard the string data when low in memory, this will have to be
1913      fixed.  */
1914   a->vna_nodename = h->verinfo.verdef->vd_nodename;
1915
1916   a->vna_flags = h->verinfo.verdef->vd_flags;
1917   a->vna_nextptr = t->vn_auxptr;
1918
1919   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1920   ++rinfo->vers;
1921
1922   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1923
1924   t->vn_auxptr = a;
1925
1926   return TRUE;
1927 }
1928
1929 /* Figure out appropriate versions for all the symbols.  We may not
1930    have the version number script until we have read all of the input
1931    files, so until that point we don't know which symbols should be
1932    local.  This function is called via elf_link_hash_traverse.  */
1933
1934 static bfd_boolean
1935 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1936 {
1937   struct elf_info_failed *sinfo;
1938   struct bfd_link_info *info;
1939   const struct elf_backend_data *bed;
1940   struct elf_info_failed eif;
1941   char *p;
1942   bfd_size_type amt;
1943
1944   sinfo = (struct elf_info_failed *) data;
1945   info = sinfo->info;
1946
1947   if (h->root.type == bfd_link_hash_warning)
1948     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1949
1950   /* Fix the symbol flags.  */
1951   eif.failed = FALSE;
1952   eif.info = info;
1953   if (! _bfd_elf_fix_symbol_flags (h, &eif))
1954     {
1955       if (eif.failed)
1956         sinfo->failed = TRUE;
1957       return FALSE;
1958     }
1959
1960   /* We only need version numbers for symbols defined in regular
1961      objects.  */
1962   if (!h->def_regular)
1963     return TRUE;
1964
1965   bed = get_elf_backend_data (info->output_bfd);
1966   p = strchr (h->root.root.string, ELF_VER_CHR);
1967   if (p != NULL && h->verinfo.vertree == NULL)
1968     {
1969       struct bfd_elf_version_tree *t;
1970       bfd_boolean hidden;
1971
1972       hidden = TRUE;
1973
1974       /* There are two consecutive ELF_VER_CHR characters if this is
1975          not a hidden symbol.  */
1976       ++p;
1977       if (*p == ELF_VER_CHR)
1978         {
1979           hidden = FALSE;
1980           ++p;
1981         }
1982
1983       /* If there is no version string, we can just return out.  */
1984       if (*p == '\0')
1985         {
1986           if (hidden)
1987             h->hidden = 1;
1988           return TRUE;
1989         }
1990
1991       /* Look for the version.  If we find it, it is no longer weak.  */
1992       for (t = sinfo->verdefs; t != NULL; t = t->next)
1993         {
1994           if (strcmp (t->name, p) == 0)
1995             {
1996               size_t len;
1997               char *alc;
1998               struct bfd_elf_version_expr *d;
1999
2000               len = p - h->root.root.string;
2001               alc = (char *) bfd_malloc (len);
2002               if (alc == NULL)
2003                 {
2004                   sinfo->failed = TRUE;
2005                   return FALSE;
2006                 }
2007               memcpy (alc, h->root.root.string, len - 1);
2008               alc[len - 1] = '\0';
2009               if (alc[len - 2] == ELF_VER_CHR)
2010                 alc[len - 2] = '\0';
2011
2012               h->verinfo.vertree = t;
2013               t->used = TRUE;
2014               d = NULL;
2015
2016               if (t->globals.list != NULL)
2017                 d = (*t->match) (&t->globals, NULL, alc);
2018
2019               /* See if there is anything to force this symbol to
2020                  local scope.  */
2021               if (d == NULL && t->locals.list != NULL)
2022                 {
2023                   d = (*t->match) (&t->locals, NULL, alc);
2024                   if (d != NULL
2025                       && h->dynindx != -1
2026                       && ! info->export_dynamic)
2027                     (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2028                 }
2029
2030               free (alc);
2031               break;
2032             }
2033         }
2034
2035       /* If we are building an application, we need to create a
2036          version node for this version.  */
2037       if (t == NULL && info->executable)
2038         {
2039           struct bfd_elf_version_tree **pp;
2040           int version_index;
2041
2042           /* If we aren't going to export this symbol, we don't need
2043              to worry about it.  */
2044           if (h->dynindx == -1)
2045             return TRUE;
2046
2047           amt = sizeof *t;
2048           t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2049           if (t == NULL)
2050             {
2051               sinfo->failed = TRUE;
2052               return FALSE;
2053             }
2054
2055           t->name = p;
2056           t->name_indx = (unsigned int) -1;
2057           t->used = TRUE;
2058
2059           version_index = 1;
2060           /* Don't count anonymous version tag.  */
2061           if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0)
2062             version_index = 0;
2063           for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
2064             ++version_index;
2065           t->vernum = version_index;
2066
2067           *pp = t;
2068
2069           h->verinfo.vertree = t;
2070         }
2071       else if (t == NULL)
2072         {
2073           /* We could not find the version for a symbol when
2074              generating a shared archive.  Return an error.  */
2075           (*_bfd_error_handler)
2076             (_("%B: version node not found for symbol %s"),
2077              info->output_bfd, h->root.root.string);
2078           bfd_set_error (bfd_error_bad_value);
2079           sinfo->failed = TRUE;
2080           return FALSE;
2081         }
2082
2083       if (hidden)
2084         h->hidden = 1;
2085     }
2086
2087   /* If we don't have a version for this symbol, see if we can find
2088      something.  */
2089   if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
2090     {
2091       bfd_boolean hide;
2092
2093       h->verinfo.vertree = bfd_find_version_for_sym (sinfo->verdefs,
2094                                                  h->root.root.string, &hide);
2095       if (h->verinfo.vertree != NULL && hide)
2096         (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2097     }
2098
2099   return TRUE;
2100 }
2101 \f
2102 /* Read and swap the relocs from the section indicated by SHDR.  This
2103    may be either a REL or a RELA section.  The relocations are
2104    translated into RELA relocations and stored in INTERNAL_RELOCS,
2105    which should have already been allocated to contain enough space.
2106    The EXTERNAL_RELOCS are a buffer where the external form of the
2107    relocations should be stored.
2108
2109    Returns FALSE if something goes wrong.  */
2110
2111 static bfd_boolean
2112 elf_link_read_relocs_from_section (bfd *abfd,
2113                                    asection *sec,
2114                                    Elf_Internal_Shdr *shdr,
2115                                    void *external_relocs,
2116                                    Elf_Internal_Rela *internal_relocs)
2117 {
2118   const struct elf_backend_data *bed;
2119   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2120   const bfd_byte *erela;
2121   const bfd_byte *erelaend;
2122   Elf_Internal_Rela *irela;
2123   Elf_Internal_Shdr *symtab_hdr;
2124   size_t nsyms;
2125
2126   /* Position ourselves at the start of the section.  */
2127   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2128     return FALSE;
2129
2130   /* Read the relocations.  */
2131   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2132     return FALSE;
2133
2134   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2135   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2136
2137   bed = get_elf_backend_data (abfd);
2138
2139   /* Convert the external relocations to the internal format.  */
2140   if (shdr->sh_entsize == bed->s->sizeof_rel)
2141     swap_in = bed->s->swap_reloc_in;
2142   else if (shdr->sh_entsize == bed->s->sizeof_rela)
2143     swap_in = bed->s->swap_reloca_in;
2144   else
2145     {
2146       bfd_set_error (bfd_error_wrong_format);
2147       return FALSE;
2148     }
2149
2150   erela = (const bfd_byte *) external_relocs;
2151   erelaend = erela + shdr->sh_size;
2152   irela = internal_relocs;
2153   while (erela < erelaend)
2154     {
2155       bfd_vma r_symndx;
2156
2157       (*swap_in) (abfd, erela, irela);
2158       r_symndx = ELF32_R_SYM (irela->r_info);
2159       if (bed->s->arch_size == 64)
2160         r_symndx >>= 24;
2161       if (nsyms > 0)
2162         {
2163           if ((size_t) r_symndx >= nsyms)
2164             {
2165               (*_bfd_error_handler)
2166                 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2167                    " for offset 0x%lx in section `%A'"),
2168                  abfd, sec,
2169                  (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2170               bfd_set_error (bfd_error_bad_value);
2171               return FALSE;
2172             }
2173         }
2174       else if (r_symndx != STN_UNDEF)
2175         {
2176           (*_bfd_error_handler)
2177             (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2178                " when the object file has no symbol table"),
2179              abfd, sec,
2180              (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2181           bfd_set_error (bfd_error_bad_value);
2182           return FALSE;
2183         }
2184       irela += bed->s->int_rels_per_ext_rel;
2185       erela += shdr->sh_entsize;
2186     }
2187
2188   return TRUE;
2189 }
2190
2191 /* Read and swap the relocs for a section O.  They may have been
2192    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2193    not NULL, they are used as buffers to read into.  They are known to
2194    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2195    the return value is allocated using either malloc or bfd_alloc,
2196    according to the KEEP_MEMORY argument.  If O has two relocation
2197    sections (both REL and RELA relocations), then the REL_HDR
2198    relocations will appear first in INTERNAL_RELOCS, followed by the
2199    RELA_HDR relocations.  */
2200
2201 Elf_Internal_Rela *
2202 _bfd_elf_link_read_relocs (bfd *abfd,
2203                            asection *o,
2204                            void *external_relocs,
2205                            Elf_Internal_Rela *internal_relocs,
2206                            bfd_boolean keep_memory)
2207 {
2208   void *alloc1 = NULL;
2209   Elf_Internal_Rela *alloc2 = NULL;
2210   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2211   struct bfd_elf_section_data *esdo = elf_section_data (o);
2212   Elf_Internal_Rela *internal_rela_relocs;
2213
2214   if (esdo->relocs != NULL)
2215     return esdo->relocs;
2216
2217   if (o->reloc_count == 0)
2218     return NULL;
2219
2220   if (internal_relocs == NULL)
2221     {
2222       bfd_size_type size;
2223
2224       size = o->reloc_count;
2225       size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2226       if (keep_memory)
2227         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2228       else
2229         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2230       if (internal_relocs == NULL)
2231         goto error_return;
2232     }
2233
2234   if (external_relocs == NULL)
2235     {
2236       bfd_size_type size = 0;
2237
2238       if (esdo->rel.hdr)
2239         size += esdo->rel.hdr->sh_size;
2240       if (esdo->rela.hdr)
2241         size += esdo->rela.hdr->sh_size;
2242
2243       alloc1 = bfd_malloc (size);
2244       if (alloc1 == NULL)
2245         goto error_return;
2246       external_relocs = alloc1;
2247     }
2248
2249   internal_rela_relocs = internal_relocs;
2250   if (esdo->rel.hdr)
2251     {
2252       if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2253                                               external_relocs,
2254                                               internal_relocs))
2255         goto error_return;
2256       external_relocs = (((bfd_byte *) external_relocs)
2257                          + esdo->rel.hdr->sh_size);
2258       internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2259                                * bed->s->int_rels_per_ext_rel);
2260     }
2261
2262   if (esdo->rela.hdr
2263       && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2264                                               external_relocs,
2265                                               internal_rela_relocs)))
2266     goto error_return;
2267
2268   /* Cache the results for next time, if we can.  */
2269   if (keep_memory)
2270     esdo->relocs = internal_relocs;
2271
2272   if (alloc1 != NULL)
2273     free (alloc1);
2274
2275   /* Don't free alloc2, since if it was allocated we are passing it
2276      back (under the name of internal_relocs).  */
2277
2278   return internal_relocs;
2279
2280  error_return:
2281   if (alloc1 != NULL)
2282     free (alloc1);
2283   if (alloc2 != NULL)
2284     {
2285       if (keep_memory)
2286         bfd_release (abfd, alloc2);
2287       else
2288         free (alloc2);
2289     }
2290   return NULL;
2291 }
2292
2293 /* Compute the size of, and allocate space for, REL_HDR which is the
2294    section header for a section containing relocations for O.  */
2295
2296 static bfd_boolean
2297 _bfd_elf_link_size_reloc_section (bfd *abfd,
2298                                   struct bfd_elf_section_reloc_data *reldata)
2299 {
2300   Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2301
2302   /* That allows us to calculate the size of the section.  */
2303   rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2304
2305   /* The contents field must last into write_object_contents, so we
2306      allocate it with bfd_alloc rather than malloc.  Also since we
2307      cannot be sure that the contents will actually be filled in,
2308      we zero the allocated space.  */
2309   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2310   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2311     return FALSE;
2312
2313   if (reldata->hashes == NULL && reldata->count)
2314     {
2315       struct elf_link_hash_entry **p;
2316
2317       p = (struct elf_link_hash_entry **)
2318           bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
2319       if (p == NULL)
2320         return FALSE;
2321
2322       reldata->hashes = p;
2323     }
2324
2325   return TRUE;
2326 }
2327
2328 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2329    originated from the section given by INPUT_REL_HDR) to the
2330    OUTPUT_BFD.  */
2331
2332 bfd_boolean
2333 _bfd_elf_link_output_relocs (bfd *output_bfd,
2334                              asection *input_section,
2335                              Elf_Internal_Shdr *input_rel_hdr,
2336                              Elf_Internal_Rela *internal_relocs,
2337                              struct elf_link_hash_entry **rel_hash
2338                                ATTRIBUTE_UNUSED)
2339 {
2340   Elf_Internal_Rela *irela;
2341   Elf_Internal_Rela *irelaend;
2342   bfd_byte *erel;
2343   struct bfd_elf_section_reloc_data *output_reldata;
2344   asection *output_section;
2345   const struct elf_backend_data *bed;
2346   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2347   struct bfd_elf_section_data *esdo;
2348
2349   output_section = input_section->output_section;
2350
2351   bed = get_elf_backend_data (output_bfd);
2352   esdo = elf_section_data (output_section);
2353   if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2354     {
2355       output_reldata = &esdo->rel;
2356       swap_out = bed->s->swap_reloc_out;
2357     }
2358   else if (esdo->rela.hdr
2359            && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2360     {
2361       output_reldata = &esdo->rela;
2362       swap_out = bed->s->swap_reloca_out;
2363     }
2364   else
2365     {
2366       (*_bfd_error_handler)
2367         (_("%B: relocation size mismatch in %B section %A"),
2368          output_bfd, input_section->owner, input_section);
2369       bfd_set_error (bfd_error_wrong_format);
2370       return FALSE;
2371     }
2372
2373   erel = output_reldata->hdr->contents;
2374   erel += output_reldata->count * input_rel_hdr->sh_entsize;
2375   irela = internal_relocs;
2376   irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2377                       * bed->s->int_rels_per_ext_rel);
2378   while (irela < irelaend)
2379     {
2380       (*swap_out) (output_bfd, irela, erel);
2381       irela += bed->s->int_rels_per_ext_rel;
2382       erel += input_rel_hdr->sh_entsize;
2383     }
2384
2385   /* Bump the counter, so that we know where to add the next set of
2386      relocations.  */
2387   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2388
2389   return TRUE;
2390 }
2391 \f
2392 /* Make weak undefined symbols in PIE dynamic.  */
2393
2394 bfd_boolean
2395 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2396                                  struct elf_link_hash_entry *h)
2397 {
2398   if (info->pie
2399       && h->dynindx == -1
2400       && h->root.type == bfd_link_hash_undefweak)
2401     return bfd_elf_link_record_dynamic_symbol (info, h);
2402
2403   return TRUE;
2404 }
2405
2406 /* Fix up the flags for a symbol.  This handles various cases which
2407    can only be fixed after all the input files are seen.  This is
2408    currently called by both adjust_dynamic_symbol and
2409    assign_sym_version, which is unnecessary but perhaps more robust in
2410    the face of future changes.  */
2411
2412 static bfd_boolean
2413 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2414                            struct elf_info_failed *eif)
2415 {
2416   const struct elf_backend_data *bed;
2417
2418   /* If this symbol was mentioned in a non-ELF file, try to set
2419      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2420      permit a non-ELF file to correctly refer to a symbol defined in
2421      an ELF dynamic object.  */
2422   if (h->non_elf)
2423     {
2424       while (h->root.type == bfd_link_hash_indirect)
2425         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2426
2427       if (h->root.type != bfd_link_hash_defined
2428           && h->root.type != bfd_link_hash_defweak)
2429         {
2430           h->ref_regular = 1;
2431           h->ref_regular_nonweak = 1;
2432         }
2433       else
2434         {
2435           if (h->root.u.def.section->owner != NULL
2436               && (bfd_get_flavour (h->root.u.def.section->owner)
2437                   == bfd_target_elf_flavour))
2438             {
2439               h->ref_regular = 1;
2440               h->ref_regular_nonweak = 1;
2441             }
2442           else
2443             h->def_regular = 1;
2444         }
2445
2446       if (h->dynindx == -1
2447           && (h->def_dynamic
2448               || h->ref_dynamic))
2449         {
2450           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2451             {
2452               eif->failed = TRUE;
2453               return FALSE;
2454             }
2455         }
2456     }
2457   else
2458     {
2459       /* Unfortunately, NON_ELF is only correct if the symbol
2460          was first seen in a non-ELF file.  Fortunately, if the symbol
2461          was first seen in an ELF file, we're probably OK unless the
2462          symbol was defined in a non-ELF file.  Catch that case here.
2463          FIXME: We're still in trouble if the symbol was first seen in
2464          a dynamic object, and then later in a non-ELF regular object.  */
2465       if ((h->root.type == bfd_link_hash_defined
2466            || h->root.type == bfd_link_hash_defweak)
2467           && !h->def_regular
2468           && (h->root.u.def.section->owner != NULL
2469               ? (bfd_get_flavour (h->root.u.def.section->owner)
2470                  != bfd_target_elf_flavour)
2471               : (bfd_is_abs_section (h->root.u.def.section)
2472                  && !h->def_dynamic)))
2473         h->def_regular = 1;
2474     }
2475
2476   /* Backend specific symbol fixup.  */
2477   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2478   if (bed->elf_backend_fixup_symbol
2479       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2480     return FALSE;
2481
2482   /* If this is a final link, and the symbol was defined as a common
2483      symbol in a regular object file, and there was no definition in
2484      any dynamic object, then the linker will have allocated space for
2485      the symbol in a common section but the DEF_REGULAR
2486      flag will not have been set.  */
2487   if (h->root.type == bfd_link_hash_defined
2488       && !h->def_regular
2489       && h->ref_regular
2490       && !h->def_dynamic
2491       && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
2492     h->def_regular = 1;
2493
2494   /* If -Bsymbolic was used (which means to bind references to global
2495      symbols to the definition within the shared object), and this
2496      symbol was defined in a regular object, then it actually doesn't
2497      need a PLT entry.  Likewise, if the symbol has non-default
2498      visibility.  If the symbol has hidden or internal visibility, we
2499      will force it local.  */
2500   if (h->needs_plt
2501       && eif->info->shared
2502       && is_elf_hash_table (eif->info->hash)
2503       && (SYMBOLIC_BIND (eif->info, h)
2504           || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2505       && h->def_regular)
2506     {
2507       bfd_boolean force_local;
2508
2509       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2510                      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2511       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2512     }
2513
2514   /* If a weak undefined symbol has non-default visibility, we also
2515      hide it from the dynamic linker.  */
2516   if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2517       && h->root.type == bfd_link_hash_undefweak)
2518     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2519
2520   /* If this is a weak defined symbol in a dynamic object, and we know
2521      the real definition in the dynamic object, copy interesting flags
2522      over to the real definition.  */
2523   if (h->u.weakdef != NULL)
2524     {
2525       struct elf_link_hash_entry *weakdef;
2526
2527       weakdef = h->u.weakdef;
2528       if (h->root.type == bfd_link_hash_indirect)
2529         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2530
2531       BFD_ASSERT (h->root.type == bfd_link_hash_defined
2532                   || h->root.type == bfd_link_hash_defweak);
2533       BFD_ASSERT (weakdef->def_dynamic);
2534
2535       /* If the real definition is defined by a regular object file,
2536          don't do anything special.  See the longer description in
2537          _bfd_elf_adjust_dynamic_symbol, below.  */
2538       if (weakdef->def_regular)
2539         h->u.weakdef = NULL;
2540       else
2541         {
2542           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2543                       || weakdef->root.type == bfd_link_hash_defweak);
2544           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2545         }
2546     }
2547
2548   return TRUE;
2549 }
2550
2551 /* Make the backend pick a good value for a dynamic symbol.  This is
2552    called via elf_link_hash_traverse, and also calls itself
2553    recursively.  */
2554
2555 static bfd_boolean
2556 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2557 {
2558   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2559   bfd *dynobj;
2560   const struct elf_backend_data *bed;
2561
2562   if (! is_elf_hash_table (eif->info->hash))
2563     return FALSE;
2564
2565   if (h->root.type == bfd_link_hash_warning)
2566     {
2567       h->got = elf_hash_table (eif->info)->init_got_offset;
2568       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2569
2570       /* When warning symbols are created, they **replace** the "real"
2571          entry in the hash table, thus we never get to see the real
2572          symbol in a hash traversal.  So look at it now.  */
2573       h = (struct elf_link_hash_entry *) h->root.u.i.link;
2574     }
2575
2576   /* Ignore indirect symbols.  These are added by the versioning code.  */
2577   if (h->root.type == bfd_link_hash_indirect)
2578     return TRUE;
2579
2580   /* Fix the symbol flags.  */
2581   if (! _bfd_elf_fix_symbol_flags (h, eif))
2582     return FALSE;
2583
2584   /* If this symbol does not require a PLT entry, and it is not
2585      defined by a dynamic object, or is not referenced by a regular
2586      object, ignore it.  We do have to handle a weak defined symbol,
2587      even if no regular object refers to it, if we decided to add it
2588      to the dynamic symbol table.  FIXME: Do we normally need to worry
2589      about symbols which are defined by one dynamic object and
2590      referenced by another one?  */
2591   if (!h->needs_plt
2592       && h->type != STT_GNU_IFUNC
2593       && (h->def_regular
2594           || !h->def_dynamic
2595           || (!h->ref_regular
2596               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2597     {
2598       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2599       return TRUE;
2600     }
2601
2602   /* If we've already adjusted this symbol, don't do it again.  This
2603      can happen via a recursive call.  */
2604   if (h->dynamic_adjusted)
2605     return TRUE;
2606
2607   /* Don't look at this symbol again.  Note that we must set this
2608      after checking the above conditions, because we may look at a
2609      symbol once, decide not to do anything, and then get called
2610      recursively later after REF_REGULAR is set below.  */
2611   h->dynamic_adjusted = 1;
2612
2613   /* If this is a weak definition, and we know a real definition, and
2614      the real symbol is not itself defined by a regular object file,
2615      then get a good value for the real definition.  We handle the
2616      real symbol first, for the convenience of the backend routine.
2617
2618      Note that there is a confusing case here.  If the real definition
2619      is defined by a regular object file, we don't get the real symbol
2620      from the dynamic object, but we do get the weak symbol.  If the
2621      processor backend uses a COPY reloc, then if some routine in the
2622      dynamic object changes the real symbol, we will not see that
2623      change in the corresponding weak symbol.  This is the way other
2624      ELF linkers work as well, and seems to be a result of the shared
2625      library model.
2626
2627      I will clarify this issue.  Most SVR4 shared libraries define the
2628      variable _timezone and define timezone as a weak synonym.  The
2629      tzset call changes _timezone.  If you write
2630        extern int timezone;
2631        int _timezone = 5;
2632        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2633      you might expect that, since timezone is a synonym for _timezone,
2634      the same number will print both times.  However, if the processor
2635      backend uses a COPY reloc, then actually timezone will be copied
2636      into your process image, and, since you define _timezone
2637      yourself, _timezone will not.  Thus timezone and _timezone will
2638      wind up at different memory locations.  The tzset call will set
2639      _timezone, leaving timezone unchanged.  */
2640
2641   if (h->u.weakdef != NULL)
2642     {
2643       /* If we get to this point, we know there is an implicit
2644          reference by a regular object file via the weak symbol H.
2645          FIXME: Is this really true?  What if the traversal finds
2646          H->U.WEAKDEF before it finds H?  */
2647       h->u.weakdef->ref_regular = 1;
2648
2649       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2650         return FALSE;
2651     }
2652
2653   /* If a symbol has no type and no size and does not require a PLT
2654      entry, then we are probably about to do the wrong thing here: we
2655      are probably going to create a COPY reloc for an empty object.
2656      This case can arise when a shared object is built with assembly
2657      code, and the assembly code fails to set the symbol type.  */
2658   if (h->size == 0
2659       && h->type == STT_NOTYPE
2660       && !h->needs_plt)
2661     (*_bfd_error_handler)
2662       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2663        h->root.root.string);
2664
2665   dynobj = elf_hash_table (eif->info)->dynobj;
2666   bed = get_elf_backend_data (dynobj);
2667
2668   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2669     {
2670       eif->failed = TRUE;
2671       return FALSE;
2672     }
2673
2674   return TRUE;
2675 }
2676
2677 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2678    DYNBSS.  */
2679
2680 bfd_boolean
2681 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2682                               asection *dynbss)
2683 {
2684   unsigned int power_of_two;
2685   bfd_vma mask;
2686   asection *sec = h->root.u.def.section;
2687
2688   /* The section aligment of definition is the maximum alignment
2689      requirement of symbols defined in the section.  Since we don't
2690      know the symbol alignment requirement, we start with the
2691      maximum alignment and check low bits of the symbol address
2692      for the minimum alignment.  */
2693   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2694   mask = ((bfd_vma) 1 << power_of_two) - 1;
2695   while ((h->root.u.def.value & mask) != 0)
2696     {
2697        mask >>= 1;
2698        --power_of_two;
2699     }
2700
2701   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2702                                                 dynbss))
2703     {
2704       /* Adjust the section alignment if needed.  */
2705       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2706                                        power_of_two))
2707         return FALSE;
2708     }
2709
2710   /* We make sure that the symbol will be aligned properly.  */
2711   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2712
2713   /* Define the symbol as being at this point in DYNBSS.  */
2714   h->root.u.def.section = dynbss;
2715   h->root.u.def.value = dynbss->size;
2716
2717   /* Increment the size of DYNBSS to make room for the symbol.  */
2718   dynbss->size += h->size;
2719
2720   return TRUE;
2721 }
2722
2723 /* Adjust all external symbols pointing into SEC_MERGE sections
2724    to reflect the object merging within the sections.  */
2725
2726 static bfd_boolean
2727 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2728 {
2729   asection *sec;
2730
2731   if (h->root.type == bfd_link_hash_warning)
2732     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2733
2734   if ((h->root.type == bfd_link_hash_defined
2735        || h->root.type == bfd_link_hash_defweak)
2736       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2737       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2738     {
2739       bfd *output_bfd = (bfd *) data;
2740
2741       h->root.u.def.value =
2742         _bfd_merged_section_offset (output_bfd,
2743                                     &h->root.u.def.section,
2744                                     elf_section_data (sec)->sec_info,
2745                                     h->root.u.def.value);
2746     }
2747
2748   return TRUE;
2749 }
2750
2751 /* Returns false if the symbol referred to by H should be considered
2752    to resolve local to the current module, and true if it should be
2753    considered to bind dynamically.  */
2754
2755 bfd_boolean
2756 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2757                            struct bfd_link_info *info,
2758                            bfd_boolean not_local_protected)
2759 {
2760   bfd_boolean binding_stays_local_p;
2761   const struct elf_backend_data *bed;
2762   struct elf_link_hash_table *hash_table;
2763
2764   if (h == NULL)
2765     return FALSE;
2766
2767   while (h->root.type == bfd_link_hash_indirect
2768          || h->root.type == bfd_link_hash_warning)
2769     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2770
2771   /* If it was forced local, then clearly it's not dynamic.  */
2772   if (h->dynindx == -1)
2773     return FALSE;
2774   if (h->forced_local)
2775     return FALSE;
2776
2777   /* Identify the cases where name binding rules say that a
2778      visible symbol resolves locally.  */
2779   binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2780
2781   switch (ELF_ST_VISIBILITY (h->other))
2782     {
2783     case STV_INTERNAL:
2784     case STV_HIDDEN:
2785       return FALSE;
2786
2787     case STV_PROTECTED:
2788       hash_table = elf_hash_table (info);
2789       if (!is_elf_hash_table (hash_table))
2790         return FALSE;
2791
2792       bed = get_elf_backend_data (hash_table->dynobj);
2793
2794       /* Proper resolution for function pointer equality may require
2795          that these symbols perhaps be resolved dynamically, even though
2796          we should be resolving them to the current module.  */
2797       if (!not_local_protected || !bed->is_function_type (h->type))
2798         binding_stays_local_p = TRUE;
2799       break;
2800
2801     default:
2802       break;
2803     }
2804
2805   /* If it isn't defined locally, then clearly it's dynamic.  */
2806   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2807     return TRUE;
2808
2809   /* Otherwise, the symbol is dynamic if binding rules don't tell
2810      us that it remains local.  */
2811   return !binding_stays_local_p;
2812 }
2813
2814 /* Return true if the symbol referred to by H should be considered
2815    to resolve local to the current module, and false otherwise.  Differs
2816    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2817    undefined symbols.  The two functions are virtually identical except
2818    for the place where forced_local and dynindx == -1 are tested.  If
2819    either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2820    the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2821    the symbol is local only for defined symbols.
2822    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2823    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2824    treatment of undefined weak symbols.  For those that do not make
2825    undefined weak symbols dynamic, both functions may return false.  */
2826
2827 bfd_boolean
2828 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2829                               struct bfd_link_info *info,
2830                               bfd_boolean local_protected)
2831 {
2832   const struct elf_backend_data *bed;
2833   struct elf_link_hash_table *hash_table;
2834
2835   /* If it's a local sym, of course we resolve locally.  */
2836   if (h == NULL)
2837     return TRUE;
2838
2839   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2840   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2841       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2842     return TRUE;
2843
2844   /* Common symbols that become definitions don't get the DEF_REGULAR
2845      flag set, so test it first, and don't bail out.  */
2846   if (ELF_COMMON_DEF_P (h))
2847     /* Do nothing.  */;
2848   /* If we don't have a definition in a regular file, then we can't
2849      resolve locally.  The sym is either undefined or dynamic.  */
2850   else if (!h->def_regular)
2851     return FALSE;
2852
2853   /* Forced local symbols resolve locally.  */
2854   if (h->forced_local)
2855     return TRUE;
2856
2857   /* As do non-dynamic symbols.  */
2858   if (h->dynindx == -1)
2859     return TRUE;
2860
2861   /* At this point, we know the symbol is defined and dynamic.  In an
2862      executable it must resolve locally, likewise when building symbolic
2863      shared libraries.  */
2864   if (info->executable || SYMBOLIC_BIND (info, h))
2865     return TRUE;
2866
2867   /* Now deal with defined dynamic symbols in shared libraries.  Ones
2868      with default visibility might not resolve locally.  */
2869   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2870     return FALSE;
2871
2872   hash_table = elf_hash_table (info);
2873   if (!is_elf_hash_table (hash_table))
2874     return TRUE;
2875
2876   bed = get_elf_backend_data (hash_table->dynobj);
2877
2878   /* STV_PROTECTED non-function symbols are local.  */
2879   if (!bed->is_function_type (h->type))
2880     return TRUE;
2881
2882   /* Function pointer equality tests may require that STV_PROTECTED
2883      symbols be treated as dynamic symbols, even when we know that the
2884      dynamic linker will resolve them locally.  */
2885   return local_protected;
2886 }
2887
2888 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2889    aligned.  Returns the first TLS output section.  */
2890
2891 struct bfd_section *
2892 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2893 {
2894   struct bfd_section *sec, *tls;
2895   unsigned int align = 0;
2896
2897   for (sec = obfd->sections; sec != NULL; sec = sec->next)
2898     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2899       break;
2900   tls = sec;
2901
2902   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2903     if (sec->alignment_power > align)
2904       align = sec->alignment_power;
2905
2906   elf_hash_table (info)->tls_sec = tls;
2907
2908   /* Ensure the alignment of the first section is the largest alignment,
2909      so that the tls segment starts aligned.  */
2910   if (tls != NULL)
2911     tls->alignment_power = align;
2912
2913   return tls;
2914 }
2915
2916 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
2917 static bfd_boolean
2918 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2919                                   Elf_Internal_Sym *sym)
2920 {
2921   const struct elf_backend_data *bed;
2922
2923   /* Local symbols do not count, but target specific ones might.  */
2924   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2925       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2926     return FALSE;
2927
2928   bed = get_elf_backend_data (abfd);
2929   /* Function symbols do not count.  */
2930   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2931     return FALSE;
2932
2933   /* If the section is undefined, then so is the symbol.  */
2934   if (sym->st_shndx == SHN_UNDEF)
2935     return FALSE;
2936
2937   /* If the symbol is defined in the common section, then
2938      it is a common definition and so does not count.  */
2939   if (bed->common_definition (sym))
2940     return FALSE;
2941
2942   /* If the symbol is in a target specific section then we
2943      must rely upon the backend to tell us what it is.  */
2944   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2945     /* FIXME - this function is not coded yet:
2946
2947        return _bfd_is_global_symbol_definition (abfd, sym);
2948
2949        Instead for now assume that the definition is not global,
2950        Even if this is wrong, at least the linker will behave
2951        in the same way that it used to do.  */
2952     return FALSE;
2953
2954   return TRUE;
2955 }
2956
2957 /* Search the symbol table of the archive element of the archive ABFD
2958    whose archive map contains a mention of SYMDEF, and determine if
2959    the symbol is defined in this element.  */
2960 static bfd_boolean
2961 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2962 {
2963   Elf_Internal_Shdr * hdr;
2964   bfd_size_type symcount;
2965   bfd_size_type extsymcount;
2966   bfd_size_type extsymoff;
2967   Elf_Internal_Sym *isymbuf;
2968   Elf_Internal_Sym *isym;
2969   Elf_Internal_Sym *isymend;
2970   bfd_boolean result;
2971
2972   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2973   if (abfd == NULL)
2974     return FALSE;
2975
2976   if (! bfd_check_format (abfd, bfd_object))
2977     return FALSE;
2978
2979   /* If we have already included the element containing this symbol in the
2980      link then we do not need to include it again.  Just claim that any symbol
2981      it contains is not a definition, so that our caller will not decide to
2982      (re)include this element.  */
2983   if (abfd->archive_pass)
2984     return FALSE;
2985
2986   /* Select the appropriate symbol table.  */
2987   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2988     hdr = &elf_tdata (abfd)->symtab_hdr;
2989   else
2990     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2991
2992   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2993
2994   /* The sh_info field of the symtab header tells us where the
2995      external symbols start.  We don't care about the local symbols.  */
2996   if (elf_bad_symtab (abfd))
2997     {
2998       extsymcount = symcount;
2999       extsymoff = 0;
3000     }
3001   else
3002     {
3003       extsymcount = symcount - hdr->sh_info;
3004       extsymoff = hdr->sh_info;
3005     }
3006
3007   if (extsymcount == 0)
3008     return FALSE;
3009
3010   /* Read in the symbol table.  */
3011   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3012                                   NULL, NULL, NULL);
3013   if (isymbuf == NULL)
3014     return FALSE;
3015
3016   /* Scan the symbol table looking for SYMDEF.  */
3017   result = FALSE;
3018   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
3019     {
3020       const char *name;
3021
3022       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3023                                               isym->st_name);
3024       if (name == NULL)
3025         break;
3026
3027       if (strcmp (name, symdef->name) == 0)
3028         {
3029           result = is_global_data_symbol_definition (abfd, isym);
3030           break;
3031         }
3032     }
3033
3034   free (isymbuf);
3035
3036   return result;
3037 }
3038 \f
3039 /* Add an entry to the .dynamic table.  */
3040
3041 bfd_boolean
3042 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3043                             bfd_vma tag,
3044                             bfd_vma val)
3045 {
3046   struct elf_link_hash_table *hash_table;
3047   const struct elf_backend_data *bed;
3048   asection *s;
3049   bfd_size_type newsize;
3050   bfd_byte *newcontents;
3051   Elf_Internal_Dyn dyn;
3052
3053   hash_table = elf_hash_table (info);
3054   if (! is_elf_hash_table (hash_table))
3055     return FALSE;
3056
3057   bed = get_elf_backend_data (hash_table->dynobj);
3058   s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3059   BFD_ASSERT (s != NULL);
3060
3061   newsize = s->size + bed->s->sizeof_dyn;
3062   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3063   if (newcontents == NULL)
3064     return FALSE;
3065
3066   dyn.d_tag = tag;
3067   dyn.d_un.d_val = val;
3068   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3069
3070   s->size = newsize;
3071   s->contents = newcontents;
3072
3073   return TRUE;
3074 }
3075
3076 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3077    otherwise just check whether one already exists.  Returns -1 on error,
3078    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3079
3080 static int
3081 elf_add_dt_needed_tag (bfd *abfd,
3082                        struct bfd_link_info *info,
3083                        const char *soname,
3084                        bfd_boolean do_it)
3085 {
3086   struct elf_link_hash_table *hash_table;
3087   bfd_size_type oldsize;
3088   bfd_size_type strindex;
3089
3090   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3091     return -1;
3092
3093   hash_table = elf_hash_table (info);
3094   oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
3095   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3096   if (strindex == (bfd_size_type) -1)
3097     return -1;
3098
3099   if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
3100     {
3101       asection *sdyn;
3102       const struct elf_backend_data *bed;
3103       bfd_byte *extdyn;
3104
3105       bed = get_elf_backend_data (hash_table->dynobj);
3106       sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3107       if (sdyn != NULL)
3108         for (extdyn = sdyn->contents;
3109              extdyn < sdyn->contents + sdyn->size;
3110              extdyn += bed->s->sizeof_dyn)
3111           {
3112             Elf_Internal_Dyn dyn;
3113
3114             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3115             if (dyn.d_tag == DT_NEEDED
3116                 && dyn.d_un.d_val == strindex)
3117               {
3118                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3119                 return 1;
3120               }
3121           }
3122     }
3123
3124   if (do_it)
3125     {
3126       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3127         return -1;
3128
3129       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3130         return -1;
3131     }
3132   else
3133     /* We were just checking for existence of the tag.  */
3134     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3135
3136   return 0;
3137 }
3138
3139 static bfd_boolean
3140 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3141 {
3142   for (; needed != NULL; needed = needed->next)
3143     if (strcmp (soname, needed->name) == 0)
3144       return TRUE;
3145
3146   return FALSE;
3147 }
3148
3149 /* Sort symbol by value and section.  */
3150 static int
3151 elf_sort_symbol (const void *arg1, const void *arg2)
3152 {
3153   const struct elf_link_hash_entry *h1;
3154   const struct elf_link_hash_entry *h2;
3155   bfd_signed_vma vdiff;
3156
3157   h1 = *(const struct elf_link_hash_entry **) arg1;
3158   h2 = *(const struct elf_link_hash_entry **) arg2;
3159   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3160   if (vdiff != 0)
3161     return vdiff > 0 ? 1 : -1;
3162   else
3163     {
3164       long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3165       if (sdiff != 0)
3166         return sdiff > 0 ? 1 : -1;
3167     }
3168   return 0;
3169 }
3170
3171 /* This function is used to adjust offsets into .dynstr for
3172    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3173
3174 static bfd_boolean
3175 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3176 {
3177   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3178
3179   if (h->root.type == bfd_link_hash_warning)
3180     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3181
3182   if (h->dynindx != -1)
3183     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3184   return TRUE;
3185 }
3186
3187 /* Assign string offsets in .dynstr, update all structures referencing
3188    them.  */
3189
3190 static bfd_boolean
3191 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3192 {
3193   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3194   struct elf_link_local_dynamic_entry *entry;
3195   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3196   bfd *dynobj = hash_table->dynobj;
3197   asection *sdyn;
3198   bfd_size_type size;
3199   const struct elf_backend_data *bed;
3200   bfd_byte *extdyn;
3201
3202   _bfd_elf_strtab_finalize (dynstr);
3203   size = _bfd_elf_strtab_size (dynstr);
3204
3205   bed = get_elf_backend_data (dynobj);
3206   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3207   BFD_ASSERT (sdyn != NULL);
3208
3209   /* Update all .dynamic entries referencing .dynstr strings.  */
3210   for (extdyn = sdyn->contents;
3211        extdyn < sdyn->contents + sdyn->size;
3212        extdyn += bed->s->sizeof_dyn)
3213     {
3214       Elf_Internal_Dyn dyn;
3215
3216       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3217       switch (dyn.d_tag)
3218         {
3219         case DT_STRSZ:
3220           dyn.d_un.d_val = size;
3221           break;
3222         case DT_NEEDED:
3223         case DT_SONAME:
3224         case DT_RPATH:
3225         case DT_RUNPATH:
3226         case DT_FILTER:
3227         case DT_AUXILIARY:
3228         case DT_AUDIT:
3229         case DT_DEPAUDIT:
3230           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3231           break;
3232         default:
3233           continue;
3234         }
3235       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3236     }
3237
3238   /* Now update local dynamic symbols.  */
3239   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3240     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3241                                                   entry->isym.st_name);
3242
3243   /* And the rest of dynamic symbols.  */
3244   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3245
3246   /* Adjust version definitions.  */
3247   if (elf_tdata (output_bfd)->cverdefs)
3248     {
3249       asection *s;
3250       bfd_byte *p;
3251       bfd_size_type i;
3252       Elf_Internal_Verdef def;
3253       Elf_Internal_Verdaux defaux;
3254
3255       s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3256       p = s->contents;
3257       do
3258         {
3259           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3260                                    &def);
3261           p += sizeof (Elf_External_Verdef);
3262           if (def.vd_aux != sizeof (Elf_External_Verdef))
3263             continue;
3264           for (i = 0; i < def.vd_cnt; ++i)
3265             {
3266               _bfd_elf_swap_verdaux_in (output_bfd,
3267                                         (Elf_External_Verdaux *) p, &defaux);
3268               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3269                                                         defaux.vda_name);
3270               _bfd_elf_swap_verdaux_out (output_bfd,
3271                                          &defaux, (Elf_External_Verdaux *) p);
3272               p += sizeof (Elf_External_Verdaux);
3273             }
3274         }
3275       while (def.vd_next);
3276     }
3277
3278   /* Adjust version references.  */
3279   if (elf_tdata (output_bfd)->verref)
3280     {
3281       asection *s;
3282       bfd_byte *p;
3283       bfd_size_type i;
3284       Elf_Internal_Verneed need;
3285       Elf_Internal_Vernaux needaux;
3286
3287       s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3288       p = s->contents;
3289       do
3290         {
3291           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3292                                     &need);
3293           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3294           _bfd_elf_swap_verneed_out (output_bfd, &need,
3295                                      (Elf_External_Verneed *) p);
3296           p += sizeof (Elf_External_Verneed);
3297           for (i = 0; i < need.vn_cnt; ++i)
3298             {
3299               _bfd_elf_swap_vernaux_in (output_bfd,
3300                                         (Elf_External_Vernaux *) p, &needaux);
3301               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3302                                                          needaux.vna_name);
3303               _bfd_elf_swap_vernaux_out (output_bfd,
3304                                          &needaux,
3305                                          (Elf_External_Vernaux *) p);
3306               p += sizeof (Elf_External_Vernaux);
3307             }
3308         }
3309       while (need.vn_next);
3310     }
3311
3312   return TRUE;
3313 }
3314 \f
3315 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3316    The default is to only match when the INPUT and OUTPUT are exactly
3317    the same target.  */
3318
3319 bfd_boolean
3320 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3321                                     const bfd_target *output)
3322 {
3323   return input == output;
3324 }
3325
3326 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3327    This version is used when different targets for the same architecture
3328    are virtually identical.  */
3329
3330 bfd_boolean
3331 _bfd_elf_relocs_compatible (const bfd_target *input,
3332                             const bfd_target *output)
3333 {
3334   const struct elf_backend_data *obed, *ibed;
3335
3336   if (input == output)
3337     return TRUE;
3338
3339   ibed = xvec_get_elf_backend_data (input);
3340   obed = xvec_get_elf_backend_data (output);
3341
3342   if (ibed->arch != obed->arch)
3343     return FALSE;
3344
3345   /* If both backends are using this function, deem them compatible.  */
3346   return ibed->relocs_compatible == obed->relocs_compatible;
3347 }
3348
3349 /* Add symbols from an ELF object file to the linker hash table.  */
3350
3351 static bfd_boolean
3352 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3353 {
3354   Elf_Internal_Ehdr *ehdr;
3355   Elf_Internal_Shdr *hdr;
3356   bfd_size_type symcount;
3357   bfd_size_type extsymcount;
3358   bfd_size_type extsymoff;
3359   struct elf_link_hash_entry **sym_hash;
3360   bfd_boolean dynamic;
3361   Elf_External_Versym *extversym = NULL;
3362   Elf_External_Versym *ever;
3363   struct elf_link_hash_entry *weaks;
3364   struct elf_link_hash_entry **nondeflt_vers = NULL;
3365   bfd_size_type nondeflt_vers_cnt = 0;
3366   Elf_Internal_Sym *isymbuf = NULL;
3367   Elf_Internal_Sym *isym;
3368   Elf_Internal_Sym *isymend;
3369   const struct elf_backend_data *bed;
3370   bfd_boolean add_needed;
3371   struct elf_link_hash_table *htab;
3372   bfd_size_type amt;
3373   void *alloc_mark = NULL;
3374   struct bfd_hash_entry **old_table = NULL;
3375   unsigned int old_size = 0;
3376   unsigned int old_count = 0;
3377   void *old_tab = NULL;
3378   void *old_hash;
3379   void *old_ent;
3380   struct bfd_link_hash_entry *old_undefs = NULL;
3381   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3382   long old_dynsymcount = 0;
3383   size_t tabsize = 0;
3384   size_t hashsize = 0;
3385
3386   htab = elf_hash_table (info);
3387   bed = get_elf_backend_data (abfd);
3388
3389   if ((abfd->flags & DYNAMIC) == 0)
3390     dynamic = FALSE;
3391   else
3392     {
3393       dynamic = TRUE;
3394
3395       /* You can't use -r against a dynamic object.  Also, there's no
3396          hope of using a dynamic object which does not exactly match
3397          the format of the output file.  */
3398       if (info->relocatable
3399           || !is_elf_hash_table (htab)
3400           || info->output_bfd->xvec != abfd->xvec)
3401         {
3402           if (info->relocatable)
3403             bfd_set_error (bfd_error_invalid_operation);
3404           else
3405             bfd_set_error (bfd_error_wrong_format);
3406           goto error_return;
3407         }
3408     }
3409
3410   ehdr = elf_elfheader (abfd);
3411   if (info->warn_alternate_em
3412       && bed->elf_machine_code != ehdr->e_machine
3413       && ((bed->elf_machine_alt1 != 0
3414            && ehdr->e_machine == bed->elf_machine_alt1)
3415           || (bed->elf_machine_alt2 != 0
3416               && ehdr->e_machine == bed->elf_machine_alt2)))
3417     info->callbacks->einfo
3418       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3419        ehdr->e_machine, abfd, bed->elf_machine_code);
3420
3421   /* As a GNU extension, any input sections which are named
3422      .gnu.warning.SYMBOL are treated as warning symbols for the given
3423      symbol.  This differs from .gnu.warning sections, which generate
3424      warnings when they are included in an output file.  */
3425   if (info->executable)
3426     {
3427       asection *s;
3428
3429       for (s = abfd->sections; s != NULL; s = s->next)
3430         {
3431           const char *name;
3432
3433           name = bfd_get_section_name (abfd, s);
3434           if (CONST_STRNEQ (name, ".gnu.warning."))
3435             {
3436               char *msg;
3437               bfd_size_type sz;
3438
3439               name += sizeof ".gnu.warning." - 1;
3440
3441               /* If this is a shared object, then look up the symbol
3442                  in the hash table.  If it is there, and it is already
3443                  been defined, then we will not be using the entry
3444                  from this shared object, so we don't need to warn.
3445                  FIXME: If we see the definition in a regular object
3446                  later on, we will warn, but we shouldn't.  The only
3447                  fix is to keep track of what warnings we are supposed
3448                  to emit, and then handle them all at the end of the
3449                  link.  */
3450               if (dynamic)
3451                 {
3452                   struct elf_link_hash_entry *h;
3453
3454                   h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3455
3456                   /* FIXME: What about bfd_link_hash_common?  */
3457                   if (h != NULL
3458                       && (h->root.type == bfd_link_hash_defined
3459                           || h->root.type == bfd_link_hash_defweak))
3460                     {
3461                       /* We don't want to issue this warning.  Clobber
3462                          the section size so that the warning does not
3463                          get copied into the output file.  */
3464                       s->size = 0;
3465                       continue;
3466                     }
3467                 }
3468
3469               sz = s->size;
3470               msg = (char *) bfd_alloc (abfd, sz + 1);
3471               if (msg == NULL)
3472                 goto error_return;
3473
3474               if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3475                 goto error_return;
3476
3477               msg[sz] = '\0';
3478
3479               if (! (_bfd_generic_link_add_one_symbol
3480                      (info, abfd, name, BSF_WARNING, s, 0, msg,
3481                       FALSE, bed->collect, NULL)))
3482                 goto error_return;
3483
3484               if (! info->relocatable)
3485                 {
3486                   /* Clobber the section size so that the warning does
3487                      not get copied into the output file.  */
3488                   s->size = 0;
3489
3490                   /* Also set SEC_EXCLUDE, so that symbols defined in
3491                      the warning section don't get copied to the output.  */
3492                   s->flags |= SEC_EXCLUDE;
3493                 }
3494             }
3495         }
3496     }
3497
3498   add_needed = TRUE;
3499   if (! dynamic)
3500     {
3501       /* If we are creating a shared library, create all the dynamic
3502          sections immediately.  We need to attach them to something,
3503          so we attach them to this BFD, provided it is the right
3504          format.  FIXME: If there are no input BFD's of the same
3505          format as the output, we can't make a shared library.  */
3506       if (info->shared
3507           && is_elf_hash_table (htab)
3508           && info->output_bfd->xvec == abfd->xvec
3509           && !htab->dynamic_sections_created)
3510         {
3511           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3512             goto error_return;
3513         }
3514     }
3515   else if (!is_elf_hash_table (htab))
3516     goto error_return;
3517   else
3518     {
3519       asection *s;
3520       const char *soname = NULL;
3521       char *audit = NULL;
3522       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3523       int ret;
3524
3525       /* ld --just-symbols and dynamic objects don't mix very well.
3526          ld shouldn't allow it.  */
3527       if ((s = abfd->sections) != NULL
3528           && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3529         abort ();
3530
3531       /* If this dynamic lib was specified on the command line with
3532          --as-needed in effect, then we don't want to add a DT_NEEDED
3533          tag unless the lib is actually used.  Similary for libs brought
3534          in by another lib's DT_NEEDED.  When --no-add-needed is used
3535          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3536          any dynamic library in DT_NEEDED tags in the dynamic lib at
3537          all.  */
3538       add_needed = (elf_dyn_lib_class (abfd)
3539                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3540                        | DYN_NO_NEEDED)) == 0;
3541
3542       s = bfd_get_section_by_name (abfd, ".dynamic");
3543       if (s != NULL)
3544         {
3545           bfd_byte *dynbuf;
3546           bfd_byte *extdyn;
3547           unsigned int elfsec;
3548           unsigned long shlink;
3549
3550           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3551             {
3552 error_free_dyn:
3553               free (dynbuf);
3554               goto error_return;
3555             }
3556
3557           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3558           if (elfsec == SHN_BAD)
3559             goto error_free_dyn;
3560           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3561
3562           for (extdyn = dynbuf;
3563                extdyn < dynbuf + s->size;
3564                extdyn += bed->s->sizeof_dyn)
3565             {
3566               Elf_Internal_Dyn dyn;
3567
3568               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3569               if (dyn.d_tag == DT_SONAME)
3570                 {
3571                   unsigned int tagv = dyn.d_un.d_val;
3572                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3573                   if (soname == NULL)
3574                     goto error_free_dyn;
3575                 }
3576               if (dyn.d_tag == DT_NEEDED)
3577                 {
3578                   struct bfd_link_needed_list *n, **pn;
3579                   char *fnm, *anm;
3580                   unsigned int tagv = dyn.d_un.d_val;
3581
3582                   amt = sizeof (struct bfd_link_needed_list);
3583                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3584                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3585                   if (n == NULL || fnm == NULL)
3586                     goto error_free_dyn;
3587                   amt = strlen (fnm) + 1;
3588                   anm = (char *) bfd_alloc (abfd, amt);
3589                   if (anm == NULL)
3590                     goto error_free_dyn;
3591                   memcpy (anm, fnm, amt);
3592                   n->name = anm;
3593                   n->by = abfd;
3594                   n->next = NULL;
3595                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3596                     ;
3597                   *pn = n;
3598                 }
3599               if (dyn.d_tag == DT_RUNPATH)
3600                 {
3601                   struct bfd_link_needed_list *n, **pn;
3602                   char *fnm, *anm;
3603                   unsigned int tagv = dyn.d_un.d_val;
3604
3605                   amt = sizeof (struct bfd_link_needed_list);
3606                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3607                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3608                   if (n == NULL || fnm == NULL)
3609                     goto error_free_dyn;
3610                   amt = strlen (fnm) + 1;
3611                   anm = (char *) bfd_alloc (abfd, amt);
3612                   if (anm == NULL)
3613                     goto error_free_dyn;
3614                   memcpy (anm, fnm, amt);
3615                   n->name = anm;
3616                   n->by = abfd;
3617                   n->next = NULL;
3618                   for (pn = & runpath;
3619                        *pn != NULL;
3620                        pn = &(*pn)->next)
3621                     ;
3622                   *pn = n;
3623                 }
3624               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3625               if (!runpath && dyn.d_tag == DT_RPATH)
3626                 {
3627                   struct bfd_link_needed_list *n, **pn;
3628                   char *fnm, *anm;
3629                   unsigned int tagv = dyn.d_un.d_val;
3630
3631                   amt = sizeof (struct bfd_link_needed_list);
3632                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3633                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3634                   if (n == NULL || fnm == NULL)
3635                     goto error_free_dyn;
3636                   amt = strlen (fnm) + 1;
3637                   anm = (char *) bfd_alloc (abfd, amt);
3638                   if (anm == NULL)
3639                     goto error_free_dyn;
3640                   memcpy (anm, fnm, amt);
3641                   n->name = anm;
3642                   n->by = abfd;
3643                   n->next = NULL;
3644                   for (pn = & rpath;
3645                        *pn != NULL;
3646                        pn = &(*pn)->next)
3647                     ;
3648                   *pn = n;
3649                 }
3650               if (dyn.d_tag == DT_AUDIT)
3651                 {
3652                   unsigned int tagv = dyn.d_un.d_val;
3653                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3654                 }
3655             }
3656
3657           free (dynbuf);
3658         }
3659
3660       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3661          frees all more recently bfd_alloc'd blocks as well.  */
3662       if (runpath)
3663         rpath = runpath;
3664
3665       if (rpath)
3666         {
3667           struct bfd_link_needed_list **pn;
3668           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3669             ;
3670           *pn = rpath;
3671         }
3672
3673       /* We do not want to include any of the sections in a dynamic
3674          object in the output file.  We hack by simply clobbering the
3675          list of sections in the BFD.  This could be handled more
3676          cleanly by, say, a new section flag; the existing
3677          SEC_NEVER_LOAD flag is not the one we want, because that one
3678          still implies that the section takes up space in the output
3679          file.  */
3680       bfd_section_list_clear (abfd);
3681
3682       /* Find the name to use in a DT_NEEDED entry that refers to this
3683          object.  If the object has a DT_SONAME entry, we use it.
3684          Otherwise, if the generic linker stuck something in
3685          elf_dt_name, we use that.  Otherwise, we just use the file
3686          name.  */
3687       if (soname == NULL || *soname == '\0')
3688         {
3689           soname = elf_dt_name (abfd);
3690           if (soname == NULL || *soname == '\0')
3691             soname = bfd_get_filename (abfd);
3692         }
3693
3694       /* Save the SONAME because sometimes the linker emulation code
3695          will need to know it.  */
3696       elf_dt_name (abfd) = soname;
3697
3698       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3699       if (ret < 0)
3700         goto error_return;
3701
3702       /* If we have already included this dynamic object in the
3703          link, just ignore it.  There is no reason to include a
3704          particular dynamic object more than once.  */
3705       if (ret > 0)
3706         return TRUE;
3707
3708       /* Save the DT_AUDIT entry for the linker emulation code. */
3709       elf_dt_audit (abfd) = audit; 
3710     }
3711
3712   /* If this is a dynamic object, we always link against the .dynsym
3713      symbol table, not the .symtab symbol table.  The dynamic linker
3714      will only see the .dynsym symbol table, so there is no reason to
3715      look at .symtab for a dynamic object.  */
3716
3717   if (! dynamic || elf_dynsymtab (abfd) == 0)
3718     hdr = &elf_tdata (abfd)->symtab_hdr;
3719   else
3720     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3721
3722   symcount = hdr->sh_size / bed->s->sizeof_sym;
3723
3724   /* The sh_info field of the symtab header tells us where the
3725      external symbols start.  We don't care about the local symbols at
3726      this point.  */
3727   if (elf_bad_symtab (abfd))
3728     {
3729       extsymcount = symcount;
3730       extsymoff = 0;
3731     }
3732   else
3733     {
3734       extsymcount = symcount - hdr->sh_info;
3735       extsymoff = hdr->sh_info;
3736     }
3737
3738   sym_hash = NULL;
3739   if (extsymcount != 0)
3740     {
3741       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3742                                       NULL, NULL, NULL);
3743       if (isymbuf == NULL)
3744         goto error_return;
3745
3746       /* We store a pointer to the hash table entry for each external
3747          symbol.  */
3748       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3749       sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
3750       if (sym_hash == NULL)
3751         goto error_free_sym;
3752       elf_sym_hashes (abfd) = sym_hash;
3753     }
3754
3755   if (dynamic)
3756     {
3757       /* Read in any version definitions.  */
3758       if (!_bfd_elf_slurp_version_tables (abfd,
3759                                           info->default_imported_symver))
3760         goto error_free_sym;
3761
3762       /* Read in the symbol versions, but don't bother to convert them
3763          to internal format.  */
3764       if (elf_dynversym (abfd) != 0)
3765         {
3766           Elf_Internal_Shdr *versymhdr;
3767
3768           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3769           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3770           if (extversym == NULL)
3771             goto error_free_sym;
3772           amt = versymhdr->sh_size;
3773           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3774               || bfd_bread (extversym, amt, abfd) != amt)
3775             goto error_free_vers;
3776         }
3777     }
3778
3779   /* If we are loading an as-needed shared lib, save the symbol table
3780      state before we start adding symbols.  If the lib turns out
3781      to be unneeded, restore the state.  */
3782   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3783     {
3784       unsigned int i;
3785       size_t entsize;
3786
3787       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3788         {
3789           struct bfd_hash_entry *p;
3790           struct elf_link_hash_entry *h;
3791
3792           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3793             {
3794               h = (struct elf_link_hash_entry *) p;
3795               entsize += htab->root.table.entsize;
3796               if (h->root.type == bfd_link_hash_warning)
3797                 entsize += htab->root.table.entsize;
3798             }
3799         }
3800
3801       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3802       hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
3803       old_tab = bfd_malloc (tabsize + entsize + hashsize);
3804       if (old_tab == NULL)
3805         goto error_free_vers;
3806
3807       /* Remember the current objalloc pointer, so that all mem for
3808          symbols added can later be reclaimed.  */
3809       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3810       if (alloc_mark == NULL)
3811         goto error_free_vers;
3812
3813       /* Make a special call to the linker "notice" function to
3814          tell it that we are about to handle an as-needed lib.  */
3815       if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3816                                        notice_as_needed))
3817         goto error_free_vers;
3818
3819       /* Clone the symbol table and sym hashes.  Remember some
3820          pointers into the symbol table, and dynamic symbol count.  */
3821       old_hash = (char *) old_tab + tabsize;
3822       old_ent = (char *) old_hash + hashsize;
3823       memcpy (old_tab, htab->root.table.table, tabsize);
3824       memcpy (old_hash, sym_hash, hashsize);
3825       old_undefs = htab->root.undefs;
3826       old_undefs_tail = htab->root.undefs_tail;
3827       old_table = htab->root.table.table;
3828       old_size = htab->root.table.size;
3829       old_count = htab->root.table.count;
3830       old_dynsymcount = htab->dynsymcount;
3831
3832       for (i = 0; i < htab->root.table.size; i++)
3833         {
3834           struct bfd_hash_entry *p;
3835           struct elf_link_hash_entry *h;
3836
3837           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3838             {
3839               memcpy (old_ent, p, htab->root.table.entsize);
3840               old_ent = (char *) old_ent + htab->root.table.entsize;
3841               h = (struct elf_link_hash_entry *) p;
3842               if (h->root.type == bfd_link_hash_warning)
3843                 {
3844                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3845                   old_ent = (char *) old_ent + htab->root.table.entsize;
3846                 }
3847             }
3848         }
3849     }
3850
3851   weaks = NULL;
3852   ever = extversym != NULL ? extversym + extsymoff : NULL;
3853   for (isym = isymbuf, isymend = isymbuf + extsymcount;
3854        isym < isymend;
3855        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3856     {
3857       int bind;
3858       bfd_vma value;
3859       asection *sec, *new_sec;
3860       flagword flags;
3861       const char *name;
3862       struct elf_link_hash_entry *h;
3863       bfd_boolean definition;
3864       bfd_boolean size_change_ok;
3865       bfd_boolean type_change_ok;
3866       bfd_boolean new_weakdef;
3867       bfd_boolean override;
3868       bfd_boolean common;
3869       unsigned int old_alignment;
3870       bfd *old_bfd;
3871       bfd * undef_bfd = NULL;
3872
3873       override = FALSE;
3874
3875       flags = BSF_NO_FLAGS;
3876       sec = NULL;
3877       value = isym->st_value;
3878       *sym_hash = NULL;
3879       common = bed->common_definition (isym);
3880
3881       bind = ELF_ST_BIND (isym->st_info);
3882       switch (bind)
3883         {
3884         case STB_LOCAL:
3885           /* This should be impossible, since ELF requires that all
3886              global symbols follow all local symbols, and that sh_info
3887              point to the first global symbol.  Unfortunately, Irix 5
3888              screws this up.  */
3889           continue;
3890
3891         case STB_GLOBAL:
3892           if (isym->st_shndx != SHN_UNDEF && !common)
3893             flags = BSF_GLOBAL;
3894           break;
3895
3896         case STB_WEAK:
3897           flags = BSF_WEAK;
3898           break;
3899
3900         case STB_GNU_UNIQUE:
3901           flags = BSF_GNU_UNIQUE;
3902           break;
3903
3904         default:
3905           /* Leave it up to the processor backend.  */
3906           break;
3907         }
3908
3909       if (isym->st_shndx == SHN_UNDEF)
3910         sec = bfd_und_section_ptr;
3911       else if (isym->st_shndx == SHN_ABS)
3912         sec = bfd_abs_section_ptr;
3913       else if (isym->st_shndx == SHN_COMMON)
3914         {
3915           sec = bfd_com_section_ptr;
3916           /* What ELF calls the size we call the value.  What ELF
3917              calls the value we call the alignment.  */
3918           value = isym->st_size;
3919         }
3920       else
3921         {
3922           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3923           if (sec == NULL)
3924             sec = bfd_abs_section_ptr;
3925           else if (sec->kept_section)
3926             {
3927               /* Symbols from discarded section are undefined.  We keep
3928                  its visibility.  */
3929               sec = bfd_und_section_ptr;
3930               isym->st_shndx = SHN_UNDEF;
3931             }
3932           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3933             value -= sec->vma;
3934         }
3935
3936       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3937                                               isym->st_name);
3938       if (name == NULL)
3939         goto error_free_vers;
3940
3941       if (isym->st_shndx == SHN_COMMON
3942           && ELF_ST_TYPE (isym->st_info) == STT_TLS
3943           && !info->relocatable)
3944         {
3945           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3946
3947           if (tcomm == NULL)
3948             {
3949               tcomm = bfd_make_section_with_flags (abfd, ".tcommon",
3950                                                    (SEC_ALLOC
3951                                                     | SEC_IS_COMMON
3952                                                     | SEC_LINKER_CREATED
3953                                                     | SEC_THREAD_LOCAL));
3954               if (tcomm == NULL)
3955                 goto error_free_vers;
3956             }
3957           sec = tcomm;
3958         }
3959       else if (bed->elf_add_symbol_hook)
3960         {
3961           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3962                                              &sec, &value))
3963             goto error_free_vers;
3964
3965           /* The hook function sets the name to NULL if this symbol
3966              should be skipped for some reason.  */
3967           if (name == NULL)
3968             continue;
3969         }
3970
3971       /* Sanity check that all possibilities were handled.  */
3972       if (sec == NULL)
3973         {
3974           bfd_set_error (bfd_error_bad_value);
3975           goto error_free_vers;
3976         }
3977
3978       if (bfd_is_und_section (sec)
3979           || bfd_is_com_section (sec))
3980         definition = FALSE;
3981       else
3982         definition = TRUE;
3983
3984       size_change_ok = FALSE;
3985       type_change_ok = bed->type_change_ok;
3986       old_alignment = 0;
3987       old_bfd = NULL;
3988       new_sec = sec;
3989
3990       if (is_elf_hash_table (htab))
3991         {
3992           Elf_Internal_Versym iver;
3993           unsigned int vernum = 0;
3994           bfd_boolean skip;
3995
3996           /* If this is a definition of a symbol which was previously
3997              referenced in a non-weak manner then make a note of the bfd
3998              that contained the reference.  This is used if we need to
3999              refer to the source of the reference later on.  */
4000           if (! bfd_is_und_section (sec))
4001             {
4002               h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
4003
4004               if (h != NULL
4005                   && h->root.type == bfd_link_hash_undefined
4006                   && h->root.u.undef.abfd)
4007                 undef_bfd = h->root.u.undef.abfd;
4008             }
4009           
4010           if (ever == NULL)
4011             {
4012               if (info->default_imported_symver)
4013                 /* Use the default symbol version created earlier.  */
4014                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
4015               else
4016                 iver.vs_vers = 0;
4017             }
4018           else
4019             _bfd_elf_swap_versym_in (abfd, ever, &iver);
4020
4021           vernum = iver.vs_vers & VERSYM_VERSION;
4022
4023           /* If this is a hidden symbol, or if it is not version
4024              1, we append the version name to the symbol name.
4025              However, we do not modify a non-hidden absolute symbol
4026              if it is not a function, because it might be the version
4027              symbol itself.  FIXME: What if it isn't?  */
4028           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4029               || (vernum > 1
4030                   && (!bfd_is_abs_section (sec)
4031                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4032             {
4033               const char *verstr;
4034               size_t namelen, verlen, newlen;
4035               char *newname, *p;
4036
4037               if (isym->st_shndx != SHN_UNDEF)
4038                 {
4039                   if (vernum > elf_tdata (abfd)->cverdefs)
4040                     verstr = NULL;
4041                   else if (vernum > 1)
4042                     verstr =
4043                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4044                   else
4045                     verstr = "";
4046
4047                   if (verstr == NULL)
4048                     {
4049                       (*_bfd_error_handler)
4050                         (_("%B: %s: invalid version %u (max %d)"),
4051                          abfd, name, vernum,
4052                          elf_tdata (abfd)->cverdefs);
4053                       bfd_set_error (bfd_error_bad_value);
4054                       goto error_free_vers;
4055                     }
4056                 }
4057               else
4058                 {
4059                   /* We cannot simply test for the number of
4060                      entries in the VERNEED section since the
4061                      numbers for the needed versions do not start
4062                      at 0.  */
4063                   Elf_Internal_Verneed *t;
4064
4065                   verstr = NULL;
4066                   for (t = elf_tdata (abfd)->verref;
4067                        t != NULL;
4068                        t = t->vn_nextref)
4069                     {
4070                       Elf_Internal_Vernaux *a;
4071
4072                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4073                         {
4074                           if (a->vna_other == vernum)
4075                             {
4076                               verstr = a->vna_nodename;
4077                               break;
4078                             }
4079                         }
4080                       if (a != NULL)
4081                         break;
4082                     }
4083                   if (verstr == NULL)
4084                     {
4085                       (*_bfd_error_handler)
4086                         (_("%B: %s: invalid needed version %d"),
4087                          abfd, name, vernum);
4088                       bfd_set_error (bfd_error_bad_value);
4089                       goto error_free_vers;
4090                     }
4091                 }
4092
4093               namelen = strlen (name);
4094               verlen = strlen (verstr);
4095               newlen = namelen + verlen + 2;
4096               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4097                   && isym->st_shndx != SHN_UNDEF)
4098                 ++newlen;
4099
4100               newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4101               if (newname == NULL)
4102                 goto error_free_vers;
4103               memcpy (newname, name, namelen);