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