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