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