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