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