* configure.ac (ia64*-*-*vms*): Add support for ld.
[platform/upstream/binutils.git] / 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       /* If the real definition is defined by a regular object file,
2514          don't do anything special.  See the longer description in
2515          _bfd_elf_adjust_dynamic_symbol, below.  */
2516       if (h->u.weakdef->def_regular)
2517         h->u.weakdef = NULL;
2518       else
2519         {
2520           struct elf_link_hash_entry *weakdef = h->u.weakdef;
2521
2522           while (h->root.type == bfd_link_hash_indirect)
2523             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2524
2525           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2526                       || h->root.type == bfd_link_hash_defweak);
2527           BFD_ASSERT (weakdef->def_dynamic);
2528           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2529                       || weakdef->root.type == bfd_link_hash_defweak);
2530           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2531         }
2532     }
2533
2534   return TRUE;
2535 }
2536
2537 /* Make the backend pick a good value for a dynamic symbol.  This is
2538    called via elf_link_hash_traverse, and also calls itself
2539    recursively.  */
2540
2541 static bfd_boolean
2542 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2543 {
2544   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2545   bfd *dynobj;
2546   const struct elf_backend_data *bed;
2547
2548   if (! is_elf_hash_table (eif->info->hash))
2549     return FALSE;
2550
2551   /* Ignore indirect symbols.  These are added by the versioning code.  */
2552   if (h->root.type == bfd_link_hash_indirect)
2553     return TRUE;
2554
2555   /* Fix the symbol flags.  */
2556   if (! _bfd_elf_fix_symbol_flags (h, eif))
2557     return FALSE;
2558
2559   /* If this symbol does not require a PLT entry, and it is not
2560      defined by a dynamic object, or is not referenced by a regular
2561      object, ignore it.  We do have to handle a weak defined symbol,
2562      even if no regular object refers to it, if we decided to add it
2563      to the dynamic symbol table.  FIXME: Do we normally need to worry
2564      about symbols which are defined by one dynamic object and
2565      referenced by another one?  */
2566   if (!h->needs_plt
2567       && h->type != STT_GNU_IFUNC
2568       && (h->def_regular
2569           || !h->def_dynamic
2570           || (!h->ref_regular
2571               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2572     {
2573       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2574       return TRUE;
2575     }
2576
2577   /* If we've already adjusted this symbol, don't do it again.  This
2578      can happen via a recursive call.  */
2579   if (h->dynamic_adjusted)
2580     return TRUE;
2581
2582   /* Don't look at this symbol again.  Note that we must set this
2583      after checking the above conditions, because we may look at a
2584      symbol once, decide not to do anything, and then get called
2585      recursively later after REF_REGULAR is set below.  */
2586   h->dynamic_adjusted = 1;
2587
2588   /* If this is a weak definition, and we know a real definition, and
2589      the real symbol is not itself defined by a regular object file,
2590      then get a good value for the real definition.  We handle the
2591      real symbol first, for the convenience of the backend routine.
2592
2593      Note that there is a confusing case here.  If the real definition
2594      is defined by a regular object file, we don't get the real symbol
2595      from the dynamic object, but we do get the weak symbol.  If the
2596      processor backend uses a COPY reloc, then if some routine in the
2597      dynamic object changes the real symbol, we will not see that
2598      change in the corresponding weak symbol.  This is the way other
2599      ELF linkers work as well, and seems to be a result of the shared
2600      library model.
2601
2602      I will clarify this issue.  Most SVR4 shared libraries define the
2603      variable _timezone and define timezone as a weak synonym.  The
2604      tzset call changes _timezone.  If you write
2605        extern int timezone;
2606        int _timezone = 5;
2607        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2608      you might expect that, since timezone is a synonym for _timezone,
2609      the same number will print both times.  However, if the processor
2610      backend uses a COPY reloc, then actually timezone will be copied
2611      into your process image, and, since you define _timezone
2612      yourself, _timezone will not.  Thus timezone and _timezone will
2613      wind up at different memory locations.  The tzset call will set
2614      _timezone, leaving timezone unchanged.  */
2615
2616   if (h->u.weakdef != NULL)
2617     {
2618       /* If we get to this point, there is an implicit reference to
2619          H->U.WEAKDEF by a regular object file via the weak symbol H.  */
2620       h->u.weakdef->ref_regular = 1;
2621
2622       /* Ensure that the backend adjust_dynamic_symbol function sees
2623          H->U.WEAKDEF before H by recursively calling ourselves.  */
2624       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2625         return FALSE;
2626     }
2627
2628   /* If a symbol has no type and no size and does not require a PLT
2629      entry, then we are probably about to do the wrong thing here: we
2630      are probably going to create a COPY reloc for an empty object.
2631      This case can arise when a shared object is built with assembly
2632      code, and the assembly code fails to set the symbol type.  */
2633   if (h->size == 0
2634       && h->type == STT_NOTYPE
2635       && !h->needs_plt)
2636     (*_bfd_error_handler)
2637       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2638        h->root.root.string);
2639
2640   dynobj = elf_hash_table (eif->info)->dynobj;
2641   bed = get_elf_backend_data (dynobj);
2642
2643   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2644     {
2645       eif->failed = TRUE;
2646       return FALSE;
2647     }
2648
2649   return TRUE;
2650 }
2651
2652 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2653    DYNBSS.  */
2654
2655 bfd_boolean
2656 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2657                               asection *dynbss)
2658 {
2659   unsigned int power_of_two;
2660   bfd_vma mask;
2661   asection *sec = h->root.u.def.section;
2662
2663   /* The section aligment of definition is the maximum alignment
2664      requirement of symbols defined in the section.  Since we don't
2665      know the symbol alignment requirement, we start with the
2666      maximum alignment and check low bits of the symbol address
2667      for the minimum alignment.  */
2668   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2669   mask = ((bfd_vma) 1 << power_of_two) - 1;
2670   while ((h->root.u.def.value & mask) != 0)
2671     {
2672        mask >>= 1;
2673        --power_of_two;
2674     }
2675
2676   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2677                                                 dynbss))
2678     {
2679       /* Adjust the section alignment if needed.  */
2680       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2681                                        power_of_two))
2682         return FALSE;
2683     }
2684
2685   /* We make sure that the symbol will be aligned properly.  */
2686   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2687
2688   /* Define the symbol as being at this point in DYNBSS.  */
2689   h->root.u.def.section = dynbss;
2690   h->root.u.def.value = dynbss->size;
2691
2692   /* Increment the size of DYNBSS to make room for the symbol.  */
2693   dynbss->size += h->size;
2694
2695   return TRUE;
2696 }
2697
2698 /* Adjust all external symbols pointing into SEC_MERGE sections
2699    to reflect the object merging within the sections.  */
2700
2701 static bfd_boolean
2702 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2703 {
2704   asection *sec;
2705
2706   if ((h->root.type == bfd_link_hash_defined
2707        || h->root.type == bfd_link_hash_defweak)
2708       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2709       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2710     {
2711       bfd *output_bfd = (bfd *) data;
2712
2713       h->root.u.def.value =
2714         _bfd_merged_section_offset (output_bfd,
2715                                     &h->root.u.def.section,
2716                                     elf_section_data (sec)->sec_info,
2717                                     h->root.u.def.value);
2718     }
2719
2720   return TRUE;
2721 }
2722
2723 /* Returns false if the symbol referred to by H should be considered
2724    to resolve local to the current module, and true if it should be
2725    considered to bind dynamically.  */
2726
2727 bfd_boolean
2728 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2729                            struct bfd_link_info *info,
2730                            bfd_boolean not_local_protected)
2731 {
2732   bfd_boolean binding_stays_local_p;
2733   const struct elf_backend_data *bed;
2734   struct elf_link_hash_table *hash_table;
2735
2736   if (h == NULL)
2737     return FALSE;
2738
2739   while (h->root.type == bfd_link_hash_indirect
2740          || h->root.type == bfd_link_hash_warning)
2741     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2742
2743   /* If it was forced local, then clearly it's not dynamic.  */
2744   if (h->dynindx == -1)
2745     return FALSE;
2746   if (h->forced_local)
2747     return FALSE;
2748
2749   /* Identify the cases where name binding rules say that a
2750      visible symbol resolves locally.  */
2751   binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2752
2753   switch (ELF_ST_VISIBILITY (h->other))
2754     {
2755     case STV_INTERNAL:
2756     case STV_HIDDEN:
2757       return FALSE;
2758
2759     case STV_PROTECTED:
2760       hash_table = elf_hash_table (info);
2761       if (!is_elf_hash_table (hash_table))
2762         return FALSE;
2763
2764       bed = get_elf_backend_data (hash_table->dynobj);
2765
2766       /* Proper resolution for function pointer equality may require
2767          that these symbols perhaps be resolved dynamically, even though
2768          we should be resolving them to the current module.  */
2769       if (!not_local_protected || !bed->is_function_type (h->type))
2770         binding_stays_local_p = TRUE;
2771       break;
2772
2773     default:
2774       break;
2775     }
2776
2777   /* If it isn't defined locally, then clearly it's dynamic.  */
2778   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2779     return TRUE;
2780
2781   /* Otherwise, the symbol is dynamic if binding rules don't tell
2782      us that it remains local.  */
2783   return !binding_stays_local_p;
2784 }
2785
2786 /* Return true if the symbol referred to by H should be considered
2787    to resolve local to the current module, and false otherwise.  Differs
2788    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2789    undefined symbols.  The two functions are virtually identical except
2790    for the place where forced_local and dynindx == -1 are tested.  If
2791    either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2792    the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2793    the symbol is local only for defined symbols.
2794    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2795    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2796    treatment of undefined weak symbols.  For those that do not make
2797    undefined weak symbols dynamic, both functions may return false.  */
2798
2799 bfd_boolean
2800 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2801                               struct bfd_link_info *info,
2802                               bfd_boolean local_protected)
2803 {
2804   const struct elf_backend_data *bed;
2805   struct elf_link_hash_table *hash_table;
2806
2807   /* If it's a local sym, of course we resolve locally.  */
2808   if (h == NULL)
2809     return TRUE;
2810
2811   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2812   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2813       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2814     return TRUE;
2815
2816   /* Common symbols that become definitions don't get the DEF_REGULAR
2817      flag set, so test it first, and don't bail out.  */
2818   if (ELF_COMMON_DEF_P (h))
2819     /* Do nothing.  */;
2820   /* If we don't have a definition in a regular file, then we can't
2821      resolve locally.  The sym is either undefined or dynamic.  */
2822   else if (!h->def_regular)
2823     return FALSE;
2824
2825   /* Forced local symbols resolve locally.  */
2826   if (h->forced_local)
2827     return TRUE;
2828
2829   /* As do non-dynamic symbols.  */
2830   if (h->dynindx == -1)
2831     return TRUE;
2832
2833   /* At this point, we know the symbol is defined and dynamic.  In an
2834      executable it must resolve locally, likewise when building symbolic
2835      shared libraries.  */
2836   if (info->executable || SYMBOLIC_BIND (info, h))
2837     return TRUE;
2838
2839   /* Now deal with defined dynamic symbols in shared libraries.  Ones
2840      with default visibility might not resolve locally.  */
2841   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2842     return FALSE;
2843
2844   hash_table = elf_hash_table (info);
2845   if (!is_elf_hash_table (hash_table))
2846     return TRUE;
2847
2848   bed = get_elf_backend_data (hash_table->dynobj);
2849
2850   /* STV_PROTECTED non-function symbols are local.  */
2851   if (!bed->is_function_type (h->type))
2852     return TRUE;
2853
2854   /* Function pointer equality tests may require that STV_PROTECTED
2855      symbols be treated as dynamic symbols.  If the address of a
2856      function not defined in an executable is set to that function's
2857      plt entry in the executable, then the address of the function in
2858      a shared library must also be the plt entry in the executable.  */
2859   return local_protected;
2860 }
2861
2862 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2863    aligned.  Returns the first TLS output section.  */
2864
2865 struct bfd_section *
2866 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2867 {
2868   struct bfd_section *sec, *tls;
2869   unsigned int align = 0;
2870
2871   for (sec = obfd->sections; sec != NULL; sec = sec->next)
2872     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2873       break;
2874   tls = sec;
2875
2876   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2877     if (sec->alignment_power > align)
2878       align = sec->alignment_power;
2879
2880   elf_hash_table (info)->tls_sec = tls;
2881
2882   /* Ensure the alignment of the first section is the largest alignment,
2883      so that the tls segment starts aligned.  */
2884   if (tls != NULL)
2885     tls->alignment_power = align;
2886
2887   return tls;
2888 }
2889
2890 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
2891 static bfd_boolean
2892 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2893                                   Elf_Internal_Sym *sym)
2894 {
2895   const struct elf_backend_data *bed;
2896
2897   /* Local symbols do not count, but target specific ones might.  */
2898   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2899       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2900     return FALSE;
2901
2902   bed = get_elf_backend_data (abfd);
2903   /* Function symbols do not count.  */
2904   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2905     return FALSE;
2906
2907   /* If the section is undefined, then so is the symbol.  */
2908   if (sym->st_shndx == SHN_UNDEF)
2909     return FALSE;
2910
2911   /* If the symbol is defined in the common section, then
2912      it is a common definition and so does not count.  */
2913   if (bed->common_definition (sym))
2914     return FALSE;
2915
2916   /* If the symbol is in a target specific section then we
2917      must rely upon the backend to tell us what it is.  */
2918   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2919     /* FIXME - this function is not coded yet:
2920
2921        return _bfd_is_global_symbol_definition (abfd, sym);
2922
2923        Instead for now assume that the definition is not global,
2924        Even if this is wrong, at least the linker will behave
2925        in the same way that it used to do.  */
2926     return FALSE;
2927
2928   return TRUE;
2929 }
2930
2931 /* Search the symbol table of the archive element of the archive ABFD
2932    whose archive map contains a mention of SYMDEF, and determine if
2933    the symbol is defined in this element.  */
2934 static bfd_boolean
2935 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2936 {
2937   Elf_Internal_Shdr * hdr;
2938   bfd_size_type symcount;
2939   bfd_size_type extsymcount;
2940   bfd_size_type extsymoff;
2941   Elf_Internal_Sym *isymbuf;
2942   Elf_Internal_Sym *isym;
2943   Elf_Internal_Sym *isymend;
2944   bfd_boolean result;
2945
2946   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2947   if (abfd == NULL)
2948     return FALSE;
2949
2950   if (! bfd_check_format (abfd, bfd_object))
2951     return FALSE;
2952
2953   /* If we have already included the element containing this symbol in the
2954      link then we do not need to include it again.  Just claim that any symbol
2955      it contains is not a definition, so that our caller will not decide to
2956      (re)include this element.  */
2957   if (abfd->archive_pass)
2958     return FALSE;
2959
2960   /* Select the appropriate symbol table.  */
2961   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2962     hdr = &elf_tdata (abfd)->symtab_hdr;
2963   else
2964     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2965
2966   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2967
2968   /* The sh_info field of the symtab header tells us where the
2969      external symbols start.  We don't care about the local symbols.  */
2970   if (elf_bad_symtab (abfd))
2971     {
2972       extsymcount = symcount;
2973       extsymoff = 0;
2974     }
2975   else
2976     {
2977       extsymcount = symcount - hdr->sh_info;
2978       extsymoff = hdr->sh_info;
2979     }
2980
2981   if (extsymcount == 0)
2982     return FALSE;
2983
2984   /* Read in the symbol table.  */
2985   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
2986                                   NULL, NULL, NULL);
2987   if (isymbuf == NULL)
2988     return FALSE;
2989
2990   /* Scan the symbol table looking for SYMDEF.  */
2991   result = FALSE;
2992   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
2993     {
2994       const char *name;
2995
2996       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
2997                                               isym->st_name);
2998       if (name == NULL)
2999         break;
3000
3001       if (strcmp (name, symdef->name) == 0)
3002         {
3003           result = is_global_data_symbol_definition (abfd, isym);
3004           break;
3005         }
3006     }
3007
3008   free (isymbuf);
3009
3010   return result;
3011 }
3012 \f
3013 /* Add an entry to the .dynamic table.  */
3014
3015 bfd_boolean
3016 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3017                             bfd_vma tag,
3018                             bfd_vma val)
3019 {
3020   struct elf_link_hash_table *hash_table;
3021   const struct elf_backend_data *bed;
3022   asection *s;
3023   bfd_size_type newsize;
3024   bfd_byte *newcontents;
3025   Elf_Internal_Dyn dyn;
3026
3027   hash_table = elf_hash_table (info);
3028   if (! is_elf_hash_table (hash_table))
3029     return FALSE;
3030
3031   bed = get_elf_backend_data (hash_table->dynobj);
3032   s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3033   BFD_ASSERT (s != NULL);
3034
3035   newsize = s->size + bed->s->sizeof_dyn;
3036   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3037   if (newcontents == NULL)
3038     return FALSE;
3039
3040   dyn.d_tag = tag;
3041   dyn.d_un.d_val = val;
3042   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3043
3044   s->size = newsize;
3045   s->contents = newcontents;
3046
3047   return TRUE;
3048 }
3049
3050 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3051    otherwise just check whether one already exists.  Returns -1 on error,
3052    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3053
3054 static int
3055 elf_add_dt_needed_tag (bfd *abfd,
3056                        struct bfd_link_info *info,
3057                        const char *soname,
3058                        bfd_boolean do_it)
3059 {
3060   struct elf_link_hash_table *hash_table;
3061   bfd_size_type oldsize;
3062   bfd_size_type strindex;
3063
3064   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3065     return -1;
3066
3067   hash_table = elf_hash_table (info);
3068   oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
3069   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3070   if (strindex == (bfd_size_type) -1)
3071     return -1;
3072
3073   if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
3074     {
3075       asection *sdyn;
3076       const struct elf_backend_data *bed;
3077       bfd_byte *extdyn;
3078
3079       bed = get_elf_backend_data (hash_table->dynobj);
3080       sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3081       if (sdyn != NULL)
3082         for (extdyn = sdyn->contents;
3083              extdyn < sdyn->contents + sdyn->size;
3084              extdyn += bed->s->sizeof_dyn)
3085           {
3086             Elf_Internal_Dyn dyn;
3087
3088             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3089             if (dyn.d_tag == DT_NEEDED
3090                 && dyn.d_un.d_val == strindex)
3091               {
3092                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3093                 return 1;
3094               }
3095           }
3096     }
3097
3098   if (do_it)
3099     {
3100       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3101         return -1;
3102
3103       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3104         return -1;
3105     }
3106   else
3107     /* We were just checking for existence of the tag.  */
3108     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3109
3110   return 0;
3111 }
3112
3113 static bfd_boolean
3114 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3115 {
3116   for (; needed != NULL; needed = needed->next)
3117     if (strcmp (soname, needed->name) == 0)
3118       return TRUE;
3119
3120   return FALSE;
3121 }
3122
3123 /* Sort symbol by value and section.  */
3124 static int
3125 elf_sort_symbol (const void *arg1, const void *arg2)
3126 {
3127   const struct elf_link_hash_entry *h1;
3128   const struct elf_link_hash_entry *h2;
3129   bfd_signed_vma vdiff;
3130
3131   h1 = *(const struct elf_link_hash_entry **) arg1;
3132   h2 = *(const struct elf_link_hash_entry **) arg2;
3133   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3134   if (vdiff != 0)
3135     return vdiff > 0 ? 1 : -1;
3136   else
3137     {
3138       long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3139       if (sdiff != 0)
3140         return sdiff > 0 ? 1 : -1;
3141     }
3142   return 0;
3143 }
3144
3145 /* This function is used to adjust offsets into .dynstr for
3146    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3147
3148 static bfd_boolean
3149 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3150 {
3151   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3152
3153   if (h->dynindx != -1)
3154     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3155   return TRUE;
3156 }
3157
3158 /* Assign string offsets in .dynstr, update all structures referencing
3159    them.  */
3160
3161 static bfd_boolean
3162 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3163 {
3164   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3165   struct elf_link_local_dynamic_entry *entry;
3166   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3167   bfd *dynobj = hash_table->dynobj;
3168   asection *sdyn;
3169   bfd_size_type size;
3170   const struct elf_backend_data *bed;
3171   bfd_byte *extdyn;
3172
3173   _bfd_elf_strtab_finalize (dynstr);
3174   size = _bfd_elf_strtab_size (dynstr);
3175
3176   bed = get_elf_backend_data (dynobj);
3177   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3178   BFD_ASSERT (sdyn != NULL);
3179
3180   /* Update all .dynamic entries referencing .dynstr strings.  */
3181   for (extdyn = sdyn->contents;
3182        extdyn < sdyn->contents + sdyn->size;
3183        extdyn += bed->s->sizeof_dyn)
3184     {
3185       Elf_Internal_Dyn dyn;
3186
3187       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3188       switch (dyn.d_tag)
3189         {
3190         case DT_STRSZ:
3191           dyn.d_un.d_val = size;
3192           break;
3193         case DT_NEEDED:
3194         case DT_SONAME:
3195         case DT_RPATH:
3196         case DT_RUNPATH:
3197         case DT_FILTER:
3198         case DT_AUXILIARY:
3199         case DT_AUDIT:
3200         case DT_DEPAUDIT:
3201           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3202           break;
3203         default:
3204           continue;
3205         }
3206       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3207     }
3208
3209   /* Now update local dynamic symbols.  */
3210   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3211     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3212                                                   entry->isym.st_name);
3213
3214   /* And the rest of dynamic symbols.  */
3215   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3216
3217   /* Adjust version definitions.  */
3218   if (elf_tdata (output_bfd)->cverdefs)
3219     {
3220       asection *s;
3221       bfd_byte *p;
3222       bfd_size_type i;
3223       Elf_Internal_Verdef def;
3224       Elf_Internal_Verdaux defaux;
3225
3226       s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3227       p = s->contents;
3228       do
3229         {
3230           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3231                                    &def);
3232           p += sizeof (Elf_External_Verdef);
3233           if (def.vd_aux != sizeof (Elf_External_Verdef))
3234             continue;
3235           for (i = 0; i < def.vd_cnt; ++i)
3236             {
3237               _bfd_elf_swap_verdaux_in (output_bfd,
3238                                         (Elf_External_Verdaux *) p, &defaux);
3239               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3240                                                         defaux.vda_name);
3241               _bfd_elf_swap_verdaux_out (output_bfd,
3242                                          &defaux, (Elf_External_Verdaux *) p);
3243               p += sizeof (Elf_External_Verdaux);
3244             }
3245         }
3246       while (def.vd_next);
3247     }
3248
3249   /* Adjust version references.  */
3250   if (elf_tdata (output_bfd)->verref)
3251     {
3252       asection *s;
3253       bfd_byte *p;
3254       bfd_size_type i;
3255       Elf_Internal_Verneed need;
3256       Elf_Internal_Vernaux needaux;
3257
3258       s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3259       p = s->contents;
3260       do
3261         {
3262           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3263                                     &need);
3264           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3265           _bfd_elf_swap_verneed_out (output_bfd, &need,
3266                                      (Elf_External_Verneed *) p);
3267           p += sizeof (Elf_External_Verneed);
3268           for (i = 0; i < need.vn_cnt; ++i)
3269             {
3270               _bfd_elf_swap_vernaux_in (output_bfd,
3271                                         (Elf_External_Vernaux *) p, &needaux);
3272               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3273                                                          needaux.vna_name);
3274               _bfd_elf_swap_vernaux_out (output_bfd,
3275                                          &needaux,
3276                                          (Elf_External_Vernaux *) p);
3277               p += sizeof (Elf_External_Vernaux);
3278             }
3279         }
3280       while (need.vn_next);
3281     }
3282
3283   return TRUE;
3284 }
3285 \f
3286 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3287    The default is to only match when the INPUT and OUTPUT are exactly
3288    the same target.  */
3289
3290 bfd_boolean
3291 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3292                                     const bfd_target *output)
3293 {
3294   return input == output;
3295 }
3296
3297 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3298    This version is used when different targets for the same architecture
3299    are virtually identical.  */
3300
3301 bfd_boolean
3302 _bfd_elf_relocs_compatible (const bfd_target *input,
3303                             const bfd_target *output)
3304 {
3305   const struct elf_backend_data *obed, *ibed;
3306
3307   if (input == output)
3308     return TRUE;
3309
3310   ibed = xvec_get_elf_backend_data (input);
3311   obed = xvec_get_elf_backend_data (output);
3312
3313   if (ibed->arch != obed->arch)
3314     return FALSE;
3315
3316   /* If both backends are using this function, deem them compatible.  */
3317   return ibed->relocs_compatible == obed->relocs_compatible;
3318 }
3319
3320 /* Add symbols from an ELF object file to the linker hash table.  */
3321
3322 static bfd_boolean
3323 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3324 {
3325   Elf_Internal_Ehdr *ehdr;
3326   Elf_Internal_Shdr *hdr;
3327   bfd_size_type symcount;
3328   bfd_size_type extsymcount;
3329   bfd_size_type extsymoff;
3330   struct elf_link_hash_entry **sym_hash;
3331   bfd_boolean dynamic;
3332   Elf_External_Versym *extversym = NULL;
3333   Elf_External_Versym *ever;
3334   struct elf_link_hash_entry *weaks;
3335   struct elf_link_hash_entry **nondeflt_vers = NULL;
3336   bfd_size_type nondeflt_vers_cnt = 0;
3337   Elf_Internal_Sym *isymbuf = NULL;
3338   Elf_Internal_Sym *isym;
3339   Elf_Internal_Sym *isymend;
3340   const struct elf_backend_data *bed;
3341   bfd_boolean add_needed;
3342   struct elf_link_hash_table *htab;
3343   bfd_size_type amt;
3344   void *alloc_mark = NULL;
3345   struct bfd_hash_entry **old_table = NULL;
3346   unsigned int old_size = 0;
3347   unsigned int old_count = 0;
3348   void *old_tab = NULL;
3349   void *old_hash;
3350   void *old_ent;
3351   struct bfd_link_hash_entry *old_undefs = NULL;
3352   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3353   long old_dynsymcount = 0;
3354   size_t tabsize = 0;
3355   size_t hashsize = 0;
3356
3357   htab = elf_hash_table (info);
3358   bed = get_elf_backend_data (abfd);
3359
3360   if ((abfd->flags & DYNAMIC) == 0)
3361     dynamic = FALSE;
3362   else
3363     {
3364       dynamic = TRUE;
3365
3366       /* You can't use -r against a dynamic object.  Also, there's no
3367          hope of using a dynamic object which does not exactly match
3368          the format of the output file.  */
3369       if (info->relocatable
3370           || !is_elf_hash_table (htab)
3371           || info->output_bfd->xvec != abfd->xvec)
3372         {
3373           if (info->relocatable)
3374             bfd_set_error (bfd_error_invalid_operation);
3375           else
3376             bfd_set_error (bfd_error_wrong_format);
3377           goto error_return;
3378         }
3379     }
3380
3381   ehdr = elf_elfheader (abfd);
3382   if (info->warn_alternate_em
3383       && bed->elf_machine_code != ehdr->e_machine
3384       && ((bed->elf_machine_alt1 != 0
3385            && ehdr->e_machine == bed->elf_machine_alt1)
3386           || (bed->elf_machine_alt2 != 0
3387               && ehdr->e_machine == bed->elf_machine_alt2)))
3388     info->callbacks->einfo
3389       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3390        ehdr->e_machine, abfd, bed->elf_machine_code);
3391
3392   /* As a GNU extension, any input sections which are named
3393      .gnu.warning.SYMBOL are treated as warning symbols for the given
3394      symbol.  This differs from .gnu.warning sections, which generate
3395      warnings when they are included in an output file.  */
3396   /* PR 12761: Also generate this warning when building shared libraries.  */
3397   if (info->executable || info->shared)
3398     {
3399       asection *s;
3400
3401       for (s = abfd->sections; s != NULL; s = s->next)
3402         {
3403           const char *name;
3404
3405           name = bfd_get_section_name (abfd, s);
3406           if (CONST_STRNEQ (name, ".gnu.warning."))
3407             {
3408               char *msg;
3409               bfd_size_type sz;
3410
3411               name += sizeof ".gnu.warning." - 1;
3412
3413               /* If this is a shared object, then look up the symbol
3414                  in the hash table.  If it is there, and it is already
3415                  been defined, then we will not be using the entry
3416                  from this shared object, so we don't need to warn.
3417                  FIXME: If we see the definition in a regular object
3418                  later on, we will warn, but we shouldn't.  The only
3419                  fix is to keep track of what warnings we are supposed
3420                  to emit, and then handle them all at the end of the
3421                  link.  */
3422               if (dynamic)
3423                 {
3424                   struct elf_link_hash_entry *h;
3425
3426                   h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3427
3428                   /* FIXME: What about bfd_link_hash_common?  */
3429                   if (h != NULL
3430                       && (h->root.type == bfd_link_hash_defined
3431                           || h->root.type == bfd_link_hash_defweak))
3432                     {
3433                       /* We don't want to issue this warning.  Clobber
3434                          the section size so that the warning does not
3435                          get copied into the output file.  */
3436                       s->size = 0;
3437                       continue;
3438                     }
3439                 }
3440
3441               sz = s->size;
3442               msg = (char *) bfd_alloc (abfd, sz + 1);
3443               if (msg == NULL)
3444                 goto error_return;
3445
3446               if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3447                 goto error_return;
3448
3449               msg[sz] = '\0';
3450
3451               if (! (_bfd_generic_link_add_one_symbol
3452                      (info, abfd, name, BSF_WARNING, s, 0, msg,
3453                       FALSE, bed->collect, NULL)))
3454                 goto error_return;
3455
3456               if (! info->relocatable)
3457                 {
3458                   /* Clobber the section size so that the warning does
3459                      not get copied into the output file.  */
3460                   s->size = 0;
3461
3462                   /* Also set SEC_EXCLUDE, so that symbols defined in
3463                      the warning section don't get copied to the output.  */
3464                   s->flags |= SEC_EXCLUDE;
3465                 }
3466             }
3467         }
3468     }
3469
3470   add_needed = TRUE;
3471   if (! dynamic)
3472     {
3473       /* If we are creating a shared library, create all the dynamic
3474          sections immediately.  We need to attach them to something,
3475          so we attach them to this BFD, provided it is the right
3476          format.  FIXME: If there are no input BFD's of the same
3477          format as the output, we can't make a shared library.  */
3478       if (info->shared
3479           && is_elf_hash_table (htab)
3480           && info->output_bfd->xvec == abfd->xvec
3481           && !htab->dynamic_sections_created)
3482         {
3483           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3484             goto error_return;
3485         }
3486     }
3487   else if (!is_elf_hash_table (htab))
3488     goto error_return;
3489   else
3490     {
3491       asection *s;
3492       const char *soname = NULL;
3493       char *audit = NULL;
3494       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3495       int ret;
3496
3497       /* ld --just-symbols and dynamic objects don't mix very well.
3498          ld shouldn't allow it.  */
3499       if ((s = abfd->sections) != NULL
3500           && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3501         abort ();
3502
3503       /* If this dynamic lib was specified on the command line with
3504          --as-needed in effect, then we don't want to add a DT_NEEDED
3505          tag unless the lib is actually used.  Similary for libs brought
3506          in by another lib's DT_NEEDED.  When --no-add-needed is used
3507          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3508          any dynamic library in DT_NEEDED tags in the dynamic lib at
3509          all.  */
3510       add_needed = (elf_dyn_lib_class (abfd)
3511                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3512                        | DYN_NO_NEEDED)) == 0;
3513
3514       s = bfd_get_section_by_name (abfd, ".dynamic");
3515       if (s != NULL)
3516         {
3517           bfd_byte *dynbuf;
3518           bfd_byte *extdyn;
3519           unsigned int elfsec;
3520           unsigned long shlink;
3521
3522           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3523             {
3524 error_free_dyn:
3525               free (dynbuf);
3526               goto error_return;
3527             }
3528
3529           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3530           if (elfsec == SHN_BAD)
3531             goto error_free_dyn;
3532           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3533
3534           for (extdyn = dynbuf;
3535                extdyn < dynbuf + s->size;
3536                extdyn += bed->s->sizeof_dyn)
3537             {
3538               Elf_Internal_Dyn dyn;
3539
3540               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3541               if (dyn.d_tag == DT_SONAME)
3542                 {
3543                   unsigned int tagv = dyn.d_un.d_val;
3544                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3545                   if (soname == NULL)
3546                     goto error_free_dyn;
3547                 }
3548               if (dyn.d_tag == DT_NEEDED)
3549                 {
3550                   struct bfd_link_needed_list *n, **pn;
3551                   char *fnm, *anm;
3552                   unsigned int tagv = dyn.d_un.d_val;
3553
3554                   amt = sizeof (struct bfd_link_needed_list);
3555                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3556                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3557                   if (n == NULL || fnm == NULL)
3558                     goto error_free_dyn;
3559                   amt = strlen (fnm) + 1;
3560                   anm = (char *) bfd_alloc (abfd, amt);
3561                   if (anm == NULL)
3562                     goto error_free_dyn;
3563                   memcpy (anm, fnm, amt);
3564                   n->name = anm;
3565                   n->by = abfd;
3566                   n->next = NULL;
3567                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3568                     ;
3569                   *pn = n;
3570                 }
3571               if (dyn.d_tag == DT_RUNPATH)
3572                 {
3573                   struct bfd_link_needed_list *n, **pn;
3574                   char *fnm, *anm;
3575                   unsigned int tagv = dyn.d_un.d_val;
3576
3577                   amt = sizeof (struct bfd_link_needed_list);
3578                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3579                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3580                   if (n == NULL || fnm == NULL)
3581                     goto error_free_dyn;
3582                   amt = strlen (fnm) + 1;
3583                   anm = (char *) bfd_alloc (abfd, amt);
3584                   if (anm == NULL)
3585                     goto error_free_dyn;
3586                   memcpy (anm, fnm, amt);
3587                   n->name = anm;
3588                   n->by = abfd;
3589                   n->next = NULL;
3590                   for (pn = & runpath;
3591                        *pn != NULL;
3592                        pn = &(*pn)->next)
3593                     ;
3594                   *pn = n;
3595                 }
3596               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3597               if (!runpath && dyn.d_tag == DT_RPATH)
3598                 {
3599                   struct bfd_link_needed_list *n, **pn;
3600                   char *fnm, *anm;
3601                   unsigned int tagv = dyn.d_un.d_val;
3602
3603                   amt = sizeof (struct bfd_link_needed_list);
3604                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3605                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3606                   if (n == NULL || fnm == NULL)
3607                     goto error_free_dyn;
3608                   amt = strlen (fnm) + 1;
3609                   anm = (char *) bfd_alloc (abfd, amt);
3610                   if (anm == NULL)
3611                     goto error_free_dyn;
3612                   memcpy (anm, fnm, amt);
3613                   n->name = anm;
3614                   n->by = abfd;
3615                   n->next = NULL;
3616                   for (pn = & rpath;
3617                        *pn != NULL;
3618                        pn = &(*pn)->next)
3619                     ;
3620                   *pn = n;
3621                 }
3622               if (dyn.d_tag == DT_AUDIT)
3623                 {
3624                   unsigned int tagv = dyn.d_un.d_val;
3625                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3626                 }
3627             }
3628
3629           free (dynbuf);
3630         }
3631
3632       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3633          frees all more recently bfd_alloc'd blocks as well.  */
3634       if (runpath)
3635         rpath = runpath;
3636
3637       if (rpath)
3638         {
3639           struct bfd_link_needed_list **pn;
3640           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3641             ;
3642           *pn = rpath;
3643         }
3644
3645       /* We do not want to include any of the sections in a dynamic
3646          object in the output file.  We hack by simply clobbering the
3647          list of sections in the BFD.  This could be handled more
3648          cleanly by, say, a new section flag; the existing
3649          SEC_NEVER_LOAD flag is not the one we want, because that one
3650          still implies that the section takes up space in the output
3651          file.  */
3652       bfd_section_list_clear (abfd);
3653
3654       /* Find the name to use in a DT_NEEDED entry that refers to this
3655          object.  If the object has a DT_SONAME entry, we use it.
3656          Otherwise, if the generic linker stuck something in
3657          elf_dt_name, we use that.  Otherwise, we just use the file
3658          name.  */
3659       if (soname == NULL || *soname == '\0')
3660         {
3661           soname = elf_dt_name (abfd);
3662           if (soname == NULL || *soname == '\0')
3663             soname = bfd_get_filename (abfd);
3664         }
3665
3666       /* Save the SONAME because sometimes the linker emulation code
3667          will need to know it.  */
3668       elf_dt_name (abfd) = soname;
3669
3670       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3671       if (ret < 0)
3672         goto error_return;
3673
3674       /* If we have already included this dynamic object in the
3675          link, just ignore it.  There is no reason to include a
3676          particular dynamic object more than once.  */
3677       if (ret > 0)
3678         return TRUE;
3679
3680       /* Save the DT_AUDIT entry for the linker emulation code. */
3681       elf_dt_audit (abfd) = audit; 
3682     }
3683
3684   /* If this is a dynamic object, we always link against the .dynsym
3685      symbol table, not the .symtab symbol table.  The dynamic linker
3686      will only see the .dynsym symbol table, so there is no reason to
3687      look at .symtab for a dynamic object.  */
3688
3689   if (! dynamic || elf_dynsymtab (abfd) == 0)
3690     hdr = &elf_tdata (abfd)->symtab_hdr;
3691   else
3692     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3693
3694   symcount = hdr->sh_size / bed->s->sizeof_sym;
3695
3696   /* The sh_info field of the symtab header tells us where the
3697      external symbols start.  We don't care about the local symbols at
3698      this point.  */
3699   if (elf_bad_symtab (abfd))
3700     {
3701       extsymcount = symcount;
3702       extsymoff = 0;
3703     }
3704   else
3705     {
3706       extsymcount = symcount - hdr->sh_info;
3707       extsymoff = hdr->sh_info;
3708     }
3709
3710   sym_hash = NULL;
3711   if (extsymcount != 0)
3712     {
3713       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3714                                       NULL, NULL, NULL);
3715       if (isymbuf == NULL)
3716         goto error_return;
3717
3718       /* We store a pointer to the hash table entry for each external
3719          symbol.  */
3720       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3721       sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
3722       if (sym_hash == NULL)
3723         goto error_free_sym;
3724       elf_sym_hashes (abfd) = sym_hash;
3725     }
3726
3727   if (dynamic)
3728     {
3729       /* Read in any version definitions.  */
3730       if (!_bfd_elf_slurp_version_tables (abfd,
3731                                           info->default_imported_symver))
3732         goto error_free_sym;
3733
3734       /* Read in the symbol versions, but don't bother to convert them
3735          to internal format.  */
3736       if (elf_dynversym (abfd) != 0)
3737         {
3738           Elf_Internal_Shdr *versymhdr;
3739
3740           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3741           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3742           if (extversym == NULL)
3743             goto error_free_sym;
3744           amt = versymhdr->sh_size;
3745           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3746               || bfd_bread (extversym, amt, abfd) != amt)
3747             goto error_free_vers;
3748         }
3749     }
3750
3751   /* If we are loading an as-needed shared lib, save the symbol table
3752      state before we start adding symbols.  If the lib turns out
3753      to be unneeded, restore the state.  */
3754   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3755     {
3756       unsigned int i;
3757       size_t entsize;
3758
3759       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3760         {
3761           struct bfd_hash_entry *p;
3762           struct elf_link_hash_entry *h;
3763
3764           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3765             {
3766               h = (struct elf_link_hash_entry *) p;
3767               entsize += htab->root.table.entsize;
3768               if (h->root.type == bfd_link_hash_warning)
3769                 entsize += htab->root.table.entsize;
3770             }
3771         }
3772
3773       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3774       hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
3775       old_tab = bfd_malloc (tabsize + entsize + hashsize);
3776       if (old_tab == NULL)
3777         goto error_free_vers;
3778
3779       /* Remember the current objalloc pointer, so that all mem for
3780          symbols added can later be reclaimed.  */
3781       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3782       if (alloc_mark == NULL)
3783         goto error_free_vers;
3784
3785       /* Make a special call to the linker "notice" function to
3786          tell it that we are about to handle an as-needed lib.  */
3787       if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3788                                        notice_as_needed, 0, NULL))
3789         goto error_free_vers;
3790
3791       /* Clone the symbol table and sym hashes.  Remember some
3792          pointers into the symbol table, and dynamic symbol count.  */
3793       old_hash = (char *) old_tab + tabsize;
3794       old_ent = (char *) old_hash + hashsize;
3795       memcpy (old_tab, htab->root.table.table, tabsize);
3796       memcpy (old_hash, sym_hash, hashsize);
3797       old_undefs = htab->root.undefs;
3798       old_undefs_tail = htab->root.undefs_tail;
3799       old_table = htab->root.table.table;
3800       old_size = htab->root.table.size;
3801       old_count = htab->root.table.count;
3802       old_dynsymcount = htab->dynsymcount;
3803
3804       for (i = 0; i < htab->root.table.size; i++)
3805         {
3806           struct bfd_hash_entry *p;
3807           struct elf_link_hash_entry *h;
3808
3809           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3810             {
3811               memcpy (old_ent, p, htab->root.table.entsize);
3812               old_ent = (char *) old_ent + htab->root.table.entsize;
3813               h = (struct elf_link_hash_entry *) p;
3814               if (h->root.type == bfd_link_hash_warning)
3815                 {
3816                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3817                   old_ent = (char *) old_ent + htab->root.table.entsize;
3818                 }
3819             }
3820         }
3821     }
3822
3823   weaks = NULL;
3824   ever = extversym != NULL ? extversym + extsymoff : NULL;
3825   for (isym = isymbuf, isymend = isymbuf + extsymcount;
3826        isym < isymend;
3827        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3828     {
3829       int bind;
3830       bfd_vma value;
3831       asection *sec, *new_sec;
3832       flagword flags;
3833       const char *name;
3834       struct elf_link_hash_entry *h;
3835       bfd_boolean definition;
3836       bfd_boolean size_change_ok;
3837       bfd_boolean type_change_ok;
3838       bfd_boolean new_weakdef;
3839       bfd_boolean override;
3840       bfd_boolean common;
3841       unsigned int old_alignment;
3842       bfd *old_bfd;
3843       bfd * undef_bfd = NULL;
3844
3845       override = FALSE;
3846
3847       flags = BSF_NO_FLAGS;
3848       sec = NULL;
3849       value = isym->st_value;
3850       *sym_hash = NULL;
3851       common = bed->common_definition (isym);
3852
3853       bind = ELF_ST_BIND (isym->st_info);
3854       switch (bind)
3855         {
3856         case STB_LOCAL:
3857           /* This should be impossible, since ELF requires that all
3858              global symbols follow all local symbols, and that sh_info
3859              point to the first global symbol.  Unfortunately, Irix 5
3860              screws this up.  */
3861           continue;
3862
3863         case STB_GLOBAL:
3864           if (isym->st_shndx != SHN_UNDEF && !common)
3865             flags = BSF_GLOBAL;
3866           break;
3867
3868         case STB_WEAK:
3869           flags = BSF_WEAK;
3870           break;
3871
3872         case STB_GNU_UNIQUE:
3873           flags = BSF_GNU_UNIQUE;
3874           break;
3875
3876         default:
3877           /* Leave it up to the processor backend.  */
3878           break;
3879         }
3880
3881       if (isym->st_shndx == SHN_UNDEF)
3882         sec = bfd_und_section_ptr;
3883       else if (isym->st_shndx == SHN_ABS)
3884         sec = bfd_abs_section_ptr;
3885       else if (isym->st_shndx == SHN_COMMON)
3886         {
3887           sec = bfd_com_section_ptr;
3888           /* What ELF calls the size we call the value.  What ELF
3889              calls the value we call the alignment.  */
3890           value = isym->st_size;
3891         }
3892       else
3893         {
3894           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3895           if (sec == NULL)
3896             sec = bfd_abs_section_ptr;
3897           else if (elf_discarded_section (sec))
3898             {
3899               /* Symbols from discarded section are undefined.  We keep
3900                  its visibility.  */
3901               sec = bfd_und_section_ptr;
3902               isym->st_shndx = SHN_UNDEF;
3903             }
3904           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3905             value -= sec->vma;
3906         }
3907
3908       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3909                                               isym->st_name);
3910       if (name == NULL)
3911         goto error_free_vers;
3912
3913       if (isym->st_shndx == SHN_COMMON
3914           && (abfd->flags & BFD_PLUGIN) != 0)
3915         {
3916           asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3917
3918           if (xc == NULL)
3919             {
3920               flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3921                                  | SEC_EXCLUDE);
3922               xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3923               if (xc == NULL)
3924                 goto error_free_vers;
3925             }
3926           sec = xc;
3927         }
3928       else if (isym->st_shndx == SHN_COMMON
3929                && ELF_ST_TYPE (isym->st_info) == STT_TLS
3930                && !info->relocatable)
3931         {
3932           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3933
3934           if (tcomm == NULL)
3935             {
3936               flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3937                                  | SEC_LINKER_CREATED);
3938               tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3939               if (tcomm == NULL)
3940                 goto error_free_vers;
3941             }
3942           sec = tcomm;
3943         }
3944       else if (bed->elf_add_symbol_hook)
3945         {
3946           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3947                                              &sec, &value))
3948             goto error_free_vers;
3949
3950           /* The hook function sets the name to NULL if this symbol
3951              should be skipped for some reason.  */
3952           if (name == NULL)
3953             continue;
3954         }
3955
3956       /* Sanity check that all possibilities were handled.  */
3957       if (sec == NULL)
3958         {
3959           bfd_set_error (bfd_error_bad_value);
3960           goto error_free_vers;
3961         }
3962
3963       if (bfd_is_und_section (sec)
3964           || bfd_is_com_section (sec))
3965         definition = FALSE;
3966       else
3967         definition = TRUE;
3968
3969       size_change_ok = FALSE;
3970       type_change_ok = bed->type_change_ok;
3971       old_alignment = 0;
3972       old_bfd = NULL;
3973       new_sec = sec;
3974
3975       if (is_elf_hash_table (htab))
3976         {
3977           Elf_Internal_Versym iver;
3978           unsigned int vernum = 0;
3979           bfd_boolean skip;
3980
3981           /* If this is a definition of a symbol which was previously
3982              referenced in a non-weak manner then make a note of the bfd
3983              that contained the reference.  This is used if we need to
3984              refer to the source of the reference later on.  */
3985           if (! bfd_is_und_section (sec))
3986             {
3987               h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
3988
3989               if (h != NULL
3990                   && h->root.type == bfd_link_hash_undefined
3991                   && h->root.u.undef.abfd)
3992                 undef_bfd = h->root.u.undef.abfd;
3993             }
3994           
3995           if (ever == NULL)
3996             {
3997               if (info->default_imported_symver)
3998                 /* Use the default symbol version created earlier.  */
3999                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
4000               else
4001                 iver.vs_vers = 0;
4002             }
4003           else
4004             _bfd_elf_swap_versym_in (abfd, ever, &iver);
4005
4006           vernum = iver.vs_vers & VERSYM_VERSION;
4007
4008           /* If this is a hidden symbol, or if it is not version
4009              1, we append the version name to the symbol name.
4010              However, we do not modify a non-hidden absolute symbol
4011              if it is not a function, because it might be the version
4012              symbol itself.  FIXME: What if it isn't?  */
4013           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4014               || (vernum > 1
4015                   && (!bfd_is_abs_section (sec)
4016                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4017             {
4018               const char *verstr;
4019               size_t namelen, verlen, newlen;
4020               char *newname, *p;
4021
4022               if (isym->st_shndx != SHN_UNDEF)
4023                 {
4024                   if (vernum > elf_tdata (abfd)->cverdefs)
4025                     verstr = NULL;
4026                   else if (vernum > 1)
4027                     verstr =
4028                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4029                   else
4030                     verstr = "";
4031
4032                   if (verstr == NULL)
4033                     {
4034                       (*_bfd_error_handler)
4035                         (_("%B: %s: invalid version %u (max %d)"),
4036                          abfd, name, vernum,
4037                          elf_tdata (abfd)->cverdefs);
4038                       bfd_set_error (bfd_error_bad_value);
4039                       goto error_free_vers;
4040                     }
4041                 }
4042               else
4043                 {
4044                   /* We cannot simply test for the number of
4045                      entries in the VERNEED section since the
4046                      numbers for the needed versions do not start
4047                      at 0.  */
4048                   Elf_Internal_Verneed *t;
4049
4050                   verstr = NULL;
4051                   for (t = elf_tdata (abfd)->verref;
4052                        t != NULL;
4053                        t = t->vn_nextref)
4054                     {
4055                       Elf_Internal_Vernaux *a;
4056
4057                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4058                         {
4059                           if (a->vna_other == vernum)
4060                             {
4061                               verstr = a->vna_nodename;
4062                               break;
4063                             }
4064                         }
4065                       if (a != NULL)
4066                         break;
4067                     }
4068                   if (verstr == NULL)
4069                     {
4070                       (*_bfd_error_handler)
4071                         (_("%B: %s: invalid needed version %d"),
4072                          abfd, name, vernum);
4073                       bfd_set_error (bfd_error_bad_value);
4074                       goto error_free_vers;
4075                     }
4076                 }
4077
4078               namelen = strlen (name);
4079               verlen = strlen (verstr);
4080               newlen = namelen + verlen + 2;
4081               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4082                   && isym->st_shndx != SHN_UNDEF)
4083                 ++newlen;
4084
4085               newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4086               if (newname == NULL)
4087                 goto error_free_vers;
4088               memcpy (newname, name, namelen);
4089               p = newname + namelen;
4090               *p++ = ELF_VER_CHR;
4091               /* If this is a defined non-hidden version symbol,
4092                  we add another @ to the name.  This indicates the
4093                  default version of the symbol.  */
4094               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4095                   && isym->st_shndx != SHN_UNDEF)
4096                 *p++ = ELF_VER_CHR;
4097               memcpy (p, verstr, verlen + 1);
4098
4099               name = newname;
4100             }
4101
4102           /* If necessary, make a second attempt to locate the bfd
4103              containing an unresolved, non-weak reference to the
4104              current symbol.  */
4105           if (! bfd_is_und_section (sec) && undef_bfd == NULL)
4106             {
4107               h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
4108
4109               if (h != NULL
4110                   && h->root.type == bfd_link_hash_undefined
4111                   && h->root.u.undef.abfd)
4112                 undef_bfd = h->root.u.undef.abfd;
4113             }
4114
4115           if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec,
4116                                       &value, &old_alignment,
4117                                       sym_hash, &skip, &override,
4118                                       &type_change_ok, &size_change_ok))
4119             goto error_free_vers;
4120
4121           if (skip)
4122             continue;
4123
4124           if (override)
4125             definition = FALSE;
4126
4127           h = *sym_hash;
4128           while (h->root.type == bfd_link_hash_indirect
4129                  || h->root.type == bfd_link_hash_warning)
4130             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4131
4132           /* Remember the old alignment if this is a common symbol, so
4133              that we don't reduce the alignment later on.  We can't
4134              check later, because _bfd_generic_link_add_one_symbol
4135              will set a default for the alignment which we want to
4136              override. We also remember the old bfd where the existing
4137              definition comes from.  */
4138           switch (h->root.type)
4139             {
4140             default:
4141               break;
4142
4143             case bfd_link_hash_defined:
4144             case bfd_link_hash_defweak:
4145               old_bfd = h->root.u.def.section->owner;
4146               break;
4147
4148             case bfd_link_hash_common:
4149               old_bfd = h->root.u.c.p->section->owner;
4150               old_alignment = h->root.u.c.p->alignment_power;
4151               break;
4152             }
4153
4154           if (elf_tdata (abfd)->verdef != NULL
4155               && ! override
4156               && vernum > 1
4157               && definition)
4158             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4159         }
4160
4161       if (! (_bfd_generic_link_add_one_symbol
4162              (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4163               (struct bfd_link_hash_entry **) sym_hash)))
4164         goto error_free_vers;
4165
4166       h = *sym_hash;
4167       while (h->root.type == bfd_link_hash_indirect
4168              || h->root.type == bfd_link_hash_warning)
4169         h = (struct elf_link_hash_entry *) h->root.u.i.link;
4170
4171       *sym_hash = h;
4172       if (is_elf_hash_table (htab))
4173         h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4174
4175       new_weakdef = FALSE;
4176       if (dynamic
4177           && definition
4178           && (flags & BSF_WEAK) != 0
4179           && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4180           && is_elf_hash_table (htab)
4181           && h->u.weakdef == NULL)
4182         {
4183           /* Keep a list of all weak defined non function symbols from
4184              a dynamic object, using the weakdef field.  Later in this
4185              function we will set the weakdef field to the correct
4186              value.  We only put non-function symbols from dynamic
4187              objects on this list, because that happens to be the only
4188              time we need to know the normal symbol corresponding to a
4189              weak symbol, and the information is time consuming to
4190              figure out.  If the weakdef field is not already NULL,
4191              then this symbol was already defined by some previous
4192              dynamic object, and we will be using that previous
4193              definition anyhow.  */
4194
4195           h->u.weakdef = weaks;
4196           weaks = h;
4197           new_weakdef = TRUE;
4198         }
4199
4200       /* Set the alignment of a common symbol.  */
4201       if ((common || bfd_is_com_section (sec))
4202           && h->root.type == bfd_link_hash_common)
4203         {
4204           unsigned int align;
4205
4206           if (common)
4207             align = bfd_log2 (isym->st_value);
4208           else
4209             {
4210               /* The new symbol is a common symbol in a shared object.
4211                  We need to get the alignment from the section.  */
4212               align = new_sec->alignment_power;
4213             }
4214           if (align > old_alignment)
4215             h->root.u.c.p->alignment_power = align;
4216           else
4217             h->root.u.c.p->alignment_power = old_alignment;
4218         }
4219
4220       if (is_elf_hash_table (htab))
4221         {
4222           bfd_boolean dynsym;
4223
4224           /* Check the alignment when a common symbol is involved. This
4225              can change when a common symbol is overridden by a normal
4226              definition or a common symbol is ignored due to the old
4227              normal definition. We need to make sure the maximum
4228              alignment is maintained.  */
4229           if ((old_alignment || common)
4230               && h->root.type != bfd_link_hash_common)
4231             {
4232               unsigned int common_align;
4233               unsigned int normal_align;
4234               unsigned int symbol_align;
4235               bfd *normal_bfd;
4236               bfd *common_bfd;
4237
4238               symbol_align = ffs (h->root.u.def.value) - 1;
4239               if (h->root.u.def.section->owner != NULL
4240                   && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4241                 {
4242                   normal_align = h->root.u.def.section->alignment_power;
4243                   if (normal_align > symbol_align)
4244                     normal_align = symbol_align;
4245                 }
4246               else
4247                 normal_align = symbol_align;
4248
4249               if (old_alignment)
4250                 {
4251                   common_align = old_alignment;
4252                   common_bfd = old_bfd;
4253                   normal_bfd = abfd;
4254                 }
4255               else
4256                 {
4257                   common_align = bfd_log2 (isym->st_value);
4258                   common_bfd = abfd;
4259                   normal_bfd = old_bfd;
4260                 }
4261
4262               if (normal_align < common_align)
4263                 {
4264                   /* PR binutils/2735 */
4265                   if (normal_bfd == NULL)
4266                     (*_bfd_error_handler)
4267                       (_("Warning: alignment %u of common symbol `%s' in %B"
4268                          " is greater than the alignment (%u) of its section %A"),
4269                        common_bfd, h->root.u.def.section,
4270                        1 << common_align, name, 1 << normal_align);
4271                   else
4272                     (*_bfd_error_handler)
4273                       (_("Warning: alignment %u of symbol `%s' in %B"
4274                          " is smaller than %u in %B"),
4275                        normal_bfd, common_bfd,
4276                        1 << normal_align, name, 1 << common_align);
4277                 }
4278             }
4279
4280           /* Remember the symbol size if it isn't undefined.  */
4281           if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
4282               && (definition || h->size == 0))
4283             {
4284               if (h->size != 0
4285                   && h->size != isym->st_size
4286                   && ! size_change_ok)
4287                 (*_bfd_error_handler)
4288                   (_("Warning: size of symbol `%s' changed"
4289                      " from %lu in %B to %lu in %B"),
4290                    old_bfd, abfd,
4291                    name, (unsigned long) h->size,
4292                    (unsigned long) isym->st_size);
4293
4294               h->size = isym->st_size;
4295             }
4296
4297           /* If this is a common symbol, then we always want H->SIZE
4298              to be the size of the common symbol.  The code just above
4299              won't fix the size if a common symbol becomes larger.  We
4300              don't warn about a size change here, because that is
4301              covered by --warn-common.  Allow changed between different
4302              function types.  */
4303           if (h->root.type == bfd_link_hash_common)
4304             h->size = h->root.u.c.size;
4305
4306           if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4307               && (definition || h->type == STT_NOTYPE))
4308             {
4309               unsigned int type = ELF_ST_TYPE (isym->st_info);
4310
4311               /* Turn an IFUNC symbol from a DSO into a normal FUNC
4312                  symbol.  */
4313               if (type == STT_GNU_IFUNC
4314                   && (abfd->flags & DYNAMIC) != 0)
4315                 type = STT_FUNC;
4316
4317               if (h->type != type)
4318                 {
4319                   if (h->type != STT_NOTYPE && ! type_change_ok)
4320                     (*_bfd_error_handler)
4321                       (_("Warning: type of symbol `%s' changed"
4322                          " from %d to %d in %B"),
4323                        abfd, name, h->type, type);
4324
4325                   h->type = type;
4326                 }
4327             }
4328
4329           /* Merge st_other field.  */
4330           elf_merge_st_other (abfd, h, isym, definition, dynamic);
4331
4332           /* Set a flag in the hash table entry indicating the type of
4333              reference or definition we just found.  Keep a count of
4334              the number of dynamic symbols we find.  A dynamic symbol
4335              is one which is referenced or defined by both a regular
4336              object and a shared object.  */
4337           dynsym = FALSE;
4338           if (! dynamic)
4339             {
4340               if (! definition)
4341                 {
4342                   h->ref_regular = 1;
4343                   if (bind != STB_WEAK)
4344                     h->ref_regular_nonweak = 1;
4345                 }
4346               else
4347                 {
4348                   h->def_regular = 1;
4349                   if (h->def_dynamic)
4350                     {
4351                       h->def_dynamic = 0;
4352                       h->ref_dynamic = 1;
4353                     }
4354                 }
4355               if (! info->executable
4356                   || h->def_dynamic
4357                   || h->ref_dynamic)
4358                 dynsym = TRUE;
4359             }
4360           else
4361             {
4362               if (! definition)
4363                 h->ref_dynamic = 1;
4364               else
4365                 {
4366                   h->def_dynamic = 1;
4367                   h->dynamic_def = 1;
4368                 }
4369               if (h->def_regular
4370                   || h->ref_regular
4371                   || (h->u.weakdef != NULL
4372                       && ! new_weakdef
4373                       && h->u.weakdef->dynindx != -1))
4374                 dynsym = TRUE;
4375             }
4376
4377           /* We don't want to make debug symbol dynamic.  */
4378           if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4379             dynsym = FALSE;
4380
4381           /* Nor should we make plugin symbols dynamic.  */
4382           if ((abfd->flags & BFD_PLUGIN) != 0)
4383             dynsym = FALSE;
4384
4385           if (definition)
4386             h->target_internal = isym->st_target_internal;
4387
4388           /* Check to see if we need to add an indirect symbol for
4389              the default name.  */
4390           if (definition || h->root.type == bfd_link_hash_common)
4391             if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4392                                               &sec, &value, &dynsym,
4393                                               override))
4394               goto error_free_vers;
4395
4396           if (definition && !dynamic)
4397             {
4398               char *p = strchr (name, ELF_VER_CHR);
4399               if (p != NULL && p[1] != ELF_VER_CHR)
4400                 {
4401                   /* Queue non-default versions so that .symver x, x@FOO
4402                      aliases can be checked.  */
4403                   if (!nondeflt_vers)
4404                     {
4405                       amt = ((isymend - isym + 1)
4406                              * sizeof (struct elf_link_hash_entry *));
4407                       nondeflt_vers =
4408                           (struct elf_link_hash_entry **) bfd_malloc (amt);
4409                       if (!nondeflt_vers)
4410                         goto error_free_vers;
4411                     }
4412                   nondeflt_vers[nondeflt_vers_cnt++] = h;
4413                 }
4414             }
4415
4416           if (dynsym && h->dynindx == -1)
4417             {
4418               if (! bfd_elf_link_record_dynamic_symbol (info, h))
4419                 goto error_free_vers;
4420               if (h->u.weakdef != NULL
4421                   && ! new_weakdef
4422                   && h->u.weakdef->dynindx == -1)
4423                 {
4424                   if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4425                     goto error_free_vers;
4426                 }
4427             }
4428           else if (dynsym && h->dynindx != -1)
4429             /* If the symbol already has a dynamic index, but
4430                visibility says it should not be visible, turn it into
4431                a local symbol.  */
4432             switch (ELF_ST_VISIBILITY (h->other))
4433               {
4434               case STV_INTERNAL:
4435               case STV_HIDDEN:
4436                 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4437                 dynsym = FALSE;
4438                 break;
4439               }
4440
4441           if (!add_needed
4442               && definition
4443               && ((dynsym
4444                    && h->ref_regular)
4445                   || (h->ref_dynamic
4446                       && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4447                       && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4448             {
4449               int ret;
4450               const char *soname = elf_dt_name (abfd);
4451
4452               /* A symbol from a library loaded via DT_NEEDED of some
4453                  other library is referenced by a regular object.
4454                  Add a DT_NEEDED entry for it.  Issue an error if
4455                  --no-add-needed is used and the reference was not
4456                  a weak one.  */
4457               if (undef_bfd != NULL
4458                   && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4459                 {
4460                   (*_bfd_error_handler)
4461                     (_("%B: undefined reference to symbol '%s'"),
4462                      undef_bfd, name);
4463                   (*_bfd_error_handler)
4464                     (_("note: '%s' is defined in DSO %B so try adding it to the linker command line"),
4465                      abfd, name);
4466                   bfd_set_error (bfd_error_invalid_operation);
4467                   goto error_free_vers;
4468                 }
4469
4470               elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4471                   (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4472
4473               add_needed = TRUE;
4474               ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4475               if (ret < 0)
4476                 goto error_free_vers;
4477
4478               BFD_ASSERT (ret == 0);
4479             }
4480         }
4481     }
4482
4483   if (extversym != NULL)
4484     {
4485       free (extversym);
4486       extversym = NULL;
4487     }
4488
4489   if (isymbuf != NULL)
4490     {
4491       free (isymbuf);
4492       isymbuf = NULL;
4493     }
4494
4495   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4496     {
4497       unsigned int i;
4498
4499       /* Restore the symbol table.  */
4500       if (bed->as_needed_cleanup)
4501         (*bed->as_needed_cleanup) (abfd, info);
4502       old_hash = (char *) old_tab + tabsize;
4503       old_ent = (char *) old_hash + hashsize;
4504       sym_hash = elf_sym_hashes (abfd);
4505       htab->root.table.table = old_table;
4506       htab->root.table.size = old_size;
4507       htab->root.table.count = old_count;
4508       memcpy (htab->root.table.table, old_tab, tabsize);
4509       memcpy (sym_hash, old_hash, hashsize);
4510       htab->root.undefs = old_undefs;
4511       htab->root.undefs_tail = old_undefs_tail;
4512       for (i = 0; i < htab->root.table.size; i++)
4513         {
4514           struct bfd_hash_entry *p;
4515           struct elf_link_hash_entry *h;
4516           bfd_size_type size;
4517           unsigned int alignment_power;
4518
4519           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4520             {
4521               h = (struct elf_link_hash_entry *) p;
4522               if (h->root.type == bfd_link_hash_warning)
4523                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4524               if (h->dynindx >= old_dynsymcount)
4525                 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4526
4527               /* Preserve the maximum alignment and size for common
4528                  symbols even if this dynamic lib isn't on DT_NEEDED
4529                  since it can still be loaded at the run-time by another
4530                  dynamic lib.  */
4531               if (h->root.type == bfd_link_hash_common)
4532                 {
4533                   size = h->root.u.c.size;
4534                   alignment_power = h->root.u.c.p->alignment_power;
4535                 }
4536               else
4537                 {
4538                   size = 0;
4539                   alignment_power = 0;
4540                 }
4541               memcpy (p, old_ent, htab->root.table.entsize);
4542               old_ent = (char *) old_ent + htab->root.table.entsize;
4543               h = (struct elf_link_hash_entry *) p;
4544               if (h->root.type == bfd_link_hash_warning)
4545                 {
4546                   memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4547                   old_ent = (char *) old_ent + htab->root.table.entsize;
4548                 }
4549               else if (h->root.type == bfd_link_hash_common)
4550                 {
4551                   if (size > h->root.u.c.size)
4552                     h->root.u.c.size = size;
4553                   if (alignment_power > h->root.u.c.p->alignment_power)
4554                     h->root.u.c.p->alignment_power = alignment_power;
4555                 }
4556             }
4557         }
4558
4559       /* Make a special call to the linker "notice" function to
4560          tell it that symbols added for crefs may need to be removed.  */
4561       if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4562                                        notice_not_needed, 0, NULL))
4563         goto error_free_vers;
4564
4565       free (old_tab);
4566       objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4567                            alloc_mark);
4568       if (nondeflt_vers != NULL)
4569         free (nondeflt_vers);
4570       return TRUE;
4571     }
4572
4573   if (old_tab != NULL)
4574     {
4575       if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4576                                        notice_needed, 0, NULL))
4577         goto error_free_vers;
4578       free (old_tab);
4579       old_tab = NULL;
4580     }
4581
4582   /* Now that all the symbols from this input file are created, handle
4583      .symver foo, foo@BAR such that any relocs against foo become foo@BAR.  */
4584   if (nondeflt_vers != NULL)
4585     {
4586       bfd_size_type cnt, symidx;
4587
4588       for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4589         {
4590           struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4591           char *shortname, *p;
4592
4593           p = strchr (h->root.root.string, ELF_VER_CHR);
4594           if (p == NULL
4595               || (h->root.type != bfd_link_hash_defined
4596                   && h->root.type != bfd_link_hash_defweak))
4597             continue;
4598
4599           amt = p - h->root.root.string;
4600           shortname = (char *) bfd_malloc (amt + 1);
4601           if (!shortname)
4602             goto error_free_vers;
4603           memcpy (shortname, h->root.root.string, amt);
4604           shortname[amt] = '\0';
4605
4606           hi = (struct elf_link_hash_entry *)
4607                bfd_link_hash_lookup (&htab->root, shortname,
4608                                      FALSE, FALSE, FALSE);
4609           if (hi != NULL
4610               && hi->root.type == h->root.type
4611               && hi->root.u.def.value == h->root.u.def.value
4612               && hi->root.u.def.section == h->root.u.def.section)
4613             {
4614               (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4615               hi->root.type = bfd_link_hash_indirect;
4616               hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4617               (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4618               sym_hash = elf_sym_hashes (abfd);
4619               if (sym_hash)
4620                 for (symidx = 0; symidx < extsymcount; ++symidx)
4621                   if (sym_hash[symidx] == hi)
4622                     {
4623                       sym_hash[symidx] = h;
4624                       break;
4625                     }
4626             }
4627           free (shortname);
4628         }
4629       free (nondeflt_vers);
4630       nondeflt_vers = NULL;
4631     }
4632
4633   /* Now set the weakdefs field correctly for all the weak defined
4634      symbols we found.  The only way to do this is to search all the
4635      symbols.  Since we only need the information for non functions in
4636      dynamic objects, that's the only time we actually put anything on
4637      the list WEAKS.  We need this information so that if a regular
4638      object refers to a symbol defined weakly in a dynamic object, the
4639      real symbol in the dynamic object is also put in the dynamic
4640      symbols; we also must arrange for both symbols to point to the
4641      same memory location.  We could handle the general case of symbol
4642      aliasing, but a general symbol alias can only be generated in
4643      assembler code, handling it correctly would be very time
4644      consuming, and other ELF linkers don't handle general aliasing
4645      either.  */
4646   if (weaks != NULL)
4647     {
4648       struct elf_link_hash_entry **hpp;
4649       struct elf_link_hash_entry **hppend;
4650       struct elf_link_hash_entry **sorted_sym_hash;
4651       struct elf_link_hash_entry *h;
4652       size_t sym_count;
4653
4654       /* Since we have to search the whole symbol list for each weak
4655          defined symbol, search time for N weak defined symbols will be
4656          O(N^2). Binary search will cut it down to O(NlogN).  */
4657       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4658       sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4659       if (sorted_sym_hash == NULL)
4660         goto error_return;
4661       sym_hash = sorted_sym_hash;
4662       hpp = elf_sym_hashes (abfd);
4663       hppend = hpp + extsymcount;
4664       sym_count = 0;
4665       for (; hpp < hppend; hpp++)
4666         {
4667           h = *hpp;
4668           if (h != NULL
4669               && h->root.type == bfd_link_hash_defined
4670               && !bed->is_function_type (h->type))
4671             {
4672               *sym_hash = h;
4673               sym_hash++;
4674               sym_count++;
4675             }
4676         }
4677
4678       qsort (sorted_sym_hash, sym_count,
4679              sizeof (struct elf_link_hash_entry *),
4680              elf_sort_symbol);
4681
4682       while (weaks != NULL)
4683         {
4684           struct elf_link_hash_entry *hlook;
4685           asection *slook;
4686           bfd_vma vlook;
4687           long ilook;
4688           size_t i, j, idx;
4689
4690           hlook = weaks;
4691           weaks = hlook->u.weakdef;
4692           hlook->u.weakdef = NULL;
4693
4694           BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4695                       || hlook->root.type == bfd_link_hash_defweak
4696                       || hlook->root.type == bfd_link_hash_common
4697                       || hlook->root.type == bfd_link_hash_indirect);
4698           slook = hlook->root.u.def.section;
4699           vlook = hlook->root.u.def.value;
4700
4701           ilook = -1;
4702           i = 0;
4703           j = sym_count;
4704           while (i < j)
4705             {
4706               bfd_signed_vma vdiff;
4707               idx = (i + j) / 2;
4708               h = sorted_sym_hash [idx];
4709               vdiff = vlook - h->root.u.def.value;
4710               if (vdiff < 0)
4711                 j = idx;
4712               else if (vdiff > 0)
4713                 i = idx + 1;
4714               else
4715                 {
4716                   long sdiff = slook->id - h->root.u.def.section->id;
4717                   if (sdiff < 0)
4718                     j = idx;
4719                   else if (sdiff > 0)
4720                     i = idx + 1;
4721                   else
4722                     {
4723                       ilook = idx;
4724                       break;
4725                     }
4726                 }
4727             }
4728
4729           /* We didn't find a value/section match.  */
4730           if (ilook == -1)
4731             continue;
4732
4733           for (i = ilook; i < sym_count; i++)
4734             {
4735               h = sorted_sym_hash [i];
4736
4737               /* Stop if value or section doesn't match.  */
4738               if (h->root.u.def.value != vlook
4739                   || h->root.u.def.section != slook)
4740                 break;
4741               else if (h != hlook)
4742                 {
4743                   hlook->u.weakdef = h;
4744
4745                   /* If the weak definition is in the list of dynamic
4746                      symbols, make sure the real definition is put
4747                      there as well.  */
4748                   if (hlook->dynindx != -1 && h->dynindx == -1)
4749                     {
4750                       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4751                         {
4752                         err_free_sym_hash:
4753                           free (sorted_sym_hash);
4754                           goto error_return;
4755                         }
4756                     }
4757
4758                   /* If the real definition is in the list of dynamic
4759                      symbols, make sure the weak definition is put
4760                      there as well.  If we don't do this, then the
4761                      dynamic loader might not merge the entries for the
4762                      real definition and the weak definition.  */
4763                   if (h->dynindx != -1 && hlook->dynindx == -1)
4764                     {
4765                       if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4766                         goto err_free_sym_hash;
4767                     }
4768                   break;
4769                 }
4770             }
4771         }
4772
4773       free (sorted_sym_hash);
4774     }
4775
4776   if (bed->check_directives
4777       && !(*bed->check_directives) (abfd, info))
4778     return FALSE;
4779
4780   /* If this object is the same format as the output object, and it is
4781      not a shared library, then let the backend look through the
4782      relocs.
4783
4784      This is required to build global offset table entries and to
4785      arrange for dynamic relocs.  It is not required for the
4786      particular common case of linking non PIC code, even when linking
4787      against shared libraries, but unfortunately there is no way of
4788      knowing whether an object file has been compiled PIC or not.
4789      Looking through the relocs is not particularly time consuming.
4790      The problem is that we must either (1) keep the relocs in memory,
4791      which causes the linker to require additional runtime memory or
4792      (2) read the relocs twice from the input file, which wastes time.
4793      This would be a good case for using mmap.
4794
4795      I have no idea how to handle linking PIC code into a file of a
4796      different format.  It probably can't be done.  */
4797   if (! dynamic
4798       && is_elf_hash_table (htab)
4799       && bed->check_relocs != NULL
4800       && elf_object_id (abfd) == elf_hash_table_id (htab)
4801       && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4802     {
4803       asection *o;
4804
4805       for (o = abfd->sections; o != NULL; o = o->next)
4806         {
4807           Elf_Internal_Rela *internal_relocs;
4808           bfd_boolean ok;
4809
4810           if ((o->flags & SEC_RELOC) == 0
4811               || o->reloc_count == 0
4812               || ((info->strip == strip_all || info->strip == strip_debugger)
4813                   && (o->flags & SEC_DEBUGGING) != 0)
4814               || bfd_is_abs_section (o->output_section))
4815             continue;
4816
4817           internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4818                                                        info->keep_memory);
4819           if (internal_relocs == NULL)
4820             goto error_return;
4821
4822           ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4823
4824           if (elf_section_data (o)->relocs != internal_relocs)
4825             free (internal_relocs);
4826
4827           if (! ok)
4828             goto error_return;
4829         }
4830     }
4831
4832   /* If this is a non-traditional link, try to optimize the handling
4833      of the .stab/.stabstr sections.  */
4834   if (! dynamic
4835       && ! info->traditional_format
4836       && is_elf_hash_table (htab)
4837       && (info->strip != strip_all && info->strip != strip_debugger))
4838     {
4839       asection *stabstr;
4840
4841       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4842       if (stabstr != NULL)
4843         {
4844           bfd_size_type string_offset = 0;
4845           asection *stab;
4846
4847           for (stab = abfd->sections; stab; stab = stab->next)
4848             if (CONST_STRNEQ (stab->name, ".stab")
4849                 && (!stab->name[5] ||
4850                     (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4851                 && (stab->flags & SEC_MERGE) == 0
4852                 && !bfd_is_abs_section (stab->output_section))
4853               {
4854                 struct bfd_elf_section_data *secdata;
4855
4856                 secdata = elf_section_data (stab);
4857                 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4858                                                stabstr, &secdata->sec_info,
4859                                                &string_offset))
4860                   goto error_return;
4861                 if (secdata->sec_info)
4862                   stab->sec_info_type = ELF_INFO_TYPE_STABS;
4863             }
4864         }
4865     }
4866
4867   if (is_elf_hash_table (htab) && add_needed)
4868     {
4869       /* Add this bfd to the loaded list.  */
4870       struct elf_link_loaded_list *n;
4871
4872       n = (struct elf_link_loaded_list *)
4873           bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
4874       if (n == NULL)
4875         goto error_return;
4876       n->abfd = abfd;
4877       n->next = htab->loaded;
4878       htab->loaded = n;
4879     }
4880
4881   return TRUE;
4882
4883  error_free_vers:
4884   if (old_tab != NULL)
4885     free (old_tab);
4886   if (nondeflt_vers != NULL)
4887     free (nondeflt_vers);
4888   if (extversym != NULL)
4889     free (extversym);
4890  error_free_sym:
4891   if (isymbuf != NULL)
4892     free (isymbuf);
4893  error_return:
4894   return FALSE;
4895 }
4896
4897 /* Return the linker hash table entry of a symbol that might be
4898    satisfied by an archive symbol.  Return -1 on error.  */
4899
4900 struct elf_link_hash_entry *
4901 _bfd_elf_archive_symbol_lookup (bfd *abfd,
4902                                 struct bfd_link_info *info,
4903                                 const char *name)
4904 {
4905   struct elf_link_hash_entry *h;
4906   char *p, *copy;
4907   size_t len, first;
4908
4909   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
4910   if (h != NULL)
4911     return h;
4912
4913   /* If this is a default version (the name contains @@), look up the
4914      symbol again with only one `@' as well as without the version.
4915      The effect is that references to the symbol with and without the
4916      version will be matched by the default symbol in the archive.  */
4917
4918   p = strchr (name, ELF_VER_CHR);
4919   if (p == NULL || p[1] != ELF_VER_CHR)
4920     return h;
4921
4922   /* First check with only one `@'.  */
4923   len = strlen (name);
4924   copy = (char *) bfd_alloc (abfd, len);
4925   if (copy == NULL)
4926     return (struct elf_link_hash_entry *) 0 - 1;
4927
4928   first = p - name + 1;
4929   memcpy (copy, name, first);
4930   memcpy (copy + first, name + first + 1, len - first);
4931
4932   h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
4933   if (h == NULL)
4934     {
4935       /* We also need to check references to the symbol without the
4936          version.  */
4937       copy[first - 1] = '\0';
4938       h = elf_link_hash_lookup (elf_hash_table (info), copy,
4939                                 FALSE, FALSE, TRUE);
4940     }
4941
4942   bfd_release (abfd, copy);
4943   return h;
4944 }
4945
4946 /* Add symbols from an ELF archive file to the linker hash table.  We
4947    don't use _bfd_generic_link_add_archive_symbols because of a
4948    problem which arises on UnixWare.  The UnixWare libc.so is an
4949    archive which includes an entry libc.so.1 which defines a bunch of
4950    symbols.  The libc.so archive also includes a number of other
4951    object files, which also define symbols, some of which are the same
4952    as those defined in libc.so.1.  Correct linking requires that we
4953    consider each object file in turn, and include it if it defines any
4954    symbols we need.  _bfd_generic_link_add_archive_symbols does not do
4955    this; it looks through the list of undefined symbols, and includes
4956    any object file which defines them.  When this algorithm is used on
4957    UnixWare, it winds up pulling in libc.so.1 early and defining a
4958    bunch of symbols.  This means that some of the other objects in the
4959    archive are not included in the link, which is incorrect since they
4960    precede libc.so.1 in the archive.
4961
4962    Fortunately, ELF archive handling is simpler than that done by
4963    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4964    oddities.  In ELF, if we find a symbol in the archive map, and the
4965    symbol is currently undefined, we know that we must pull in that
4966    object file.
4967
4968    Unfortunately, we do have to make multiple passes over the symbol
4969    table until nothing further is resolved.  */
4970
4971 static bfd_boolean
4972 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4973 {
4974   symindex c;
4975   bfd_boolean *defined = NULL;
4976   bfd_boolean *included = NULL;
4977   carsym *symdefs;
4978   bfd_boolean loop;
4979   bfd_size_type amt;
4980   const struct elf_backend_data *bed;
4981   struct elf_link_hash_entry * (*archive_symbol_lookup)
4982     (bfd *, struct bfd_link_info *, const char *);
4983
4984   if (! bfd_has_map (abfd))
4985     {
4986       /* An empty archive is a special case.  */
4987       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4988         return TRUE;
4989       bfd_set_error (bfd_error_no_armap);
4990       return FALSE;
4991     }
4992
4993   /* Keep track of all symbols we know to be already defined, and all
4994      files we know to be already included.  This is to speed up the
4995      second and subsequent passes.  */
4996   c = bfd_ardata (abfd)->symdef_count;
4997   if (c == 0)
4998     return TRUE;
4999   amt = c;
5000   amt *= sizeof (bfd_boolean);
5001   defined = (bfd_boolean *) bfd_zmalloc (amt);
5002   included = (bfd_boolean *) bfd_zmalloc (amt);
5003   if (defined == NULL || included == NULL)
5004     goto error_return;
5005
5006   symdefs = bfd_ardata (abfd)->symdefs;
5007   bed = get_elf_backend_data (abfd);
5008   archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
5009
5010   do
5011     {
5012       file_ptr last;
5013       symindex i;
5014       carsym *symdef;
5015       carsym *symdefend;
5016
5017       loop = FALSE;
5018       last = -1;
5019
5020       symdef = symdefs;
5021       symdefend = symdef + c;
5022       for (i = 0; symdef < symdefend; symdef++, i++)
5023         {
5024           struct elf_link_hash_entry *h;
5025           bfd *element;
5026           struct bfd_link_hash_entry *undefs_tail;
5027           symindex mark;
5028
5029           if (defined[i] || included[i])
5030             continue;
5031           if (symdef->file_offset == last)
5032             {
5033               included[i] = TRUE;
5034               continue;
5035             }
5036
5037           h = archive_symbol_lookup (abfd, info, symdef->name);
5038           if (h == (struct elf_link_hash_entry *) 0 - 1)
5039             goto error_return;
5040
5041           if (h == NULL)
5042             continue;
5043
5044           if (h->root.type == bfd_link_hash_common)
5045             {
5046               /* We currently have a common symbol.  The archive map contains
5047                  a reference to this symbol, so we may want to include it.  We
5048                  only want to include it however, if this archive element
5049                  contains a definition of the symbol, not just another common
5050                  declaration of it.
5051
5052                  Unfortunately some archivers (including GNU ar) will put
5053                  declarations of common symbols into their archive maps, as
5054                  well as real definitions, so we cannot just go by the archive
5055                  map alone.  Instead we must read in the element's symbol
5056                  table and check that to see what kind of symbol definition
5057                  this is.  */
5058               if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5059                 continue;
5060             }
5061           else if (h->root.type != bfd_link_hash_undefined)
5062             {
5063               if (h->root.type != bfd_link_hash_undefweak)
5064                 defined[i] = TRUE;
5065               continue;
5066             }
5067
5068           /* We need to include this archive member.  */
5069           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5070           if (element == NULL)
5071             goto error_return;
5072
5073           if (! bfd_check_format (element, bfd_object))
5074             goto error_return;
5075
5076           /* Doublecheck that we have not included this object
5077              already--it should be impossible, but there may be
5078              something wrong with the archive.  */
5079           if (element->archive_pass != 0)
5080             {
5081               bfd_set_error (bfd_error_bad_value);
5082               goto error_return;
5083             }
5084           element->archive_pass = 1;
5085
5086           undefs_tail = info->hash->undefs_tail;
5087
5088           if (!(*info->callbacks
5089                 ->add_archive_element) (info, element, symdef->name, &element))
5090             goto error_return;
5091           if (!bfd_link_add_symbols (element, info))
5092             goto error_return;
5093
5094           /* If there are any new undefined symbols, we need to make
5095              another pass through the archive in order to see whether
5096              they can be defined.  FIXME: This isn't perfect, because
5097              common symbols wind up on undefs_tail and because an
5098              undefined symbol which is defined later on in this pass
5099              does not require another pass.  This isn't a bug, but it
5100              does make the code less efficient than it could be.  */
5101           if (undefs_tail != info->hash->undefs_tail)
5102             loop = TRUE;
5103
5104           /* Look backward to mark all symbols from this object file
5105              which we have already seen in this pass.  */
5106           mark = i;
5107           do
5108             {
5109               included[mark] = TRUE;
5110               if (mark == 0)
5111                 break;
5112               --mark;
5113             }
5114           while (symdefs[mark].file_offset == symdef->file_offset);
5115
5116           /* We mark subsequent symbols from this object file as we go
5117              on through the loop.  */
5118           last = symdef->file_offset;
5119         }
5120     }
5121   while (loop);
5122
5123   free (defined);
5124   free (included);
5125
5126   return TRUE;
5127
5128  error_return:
5129   if (defined != NULL)
5130     free (defined);
5131   if (included != NULL)
5132     free (included);
5133   return FALSE;
5134 }
5135
5136 /* Given an ELF BFD, add symbols to the global hash table as
5137    appropriate.  */
5138
5139 bfd_boolean
5140 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5141 {
5142   switch (bfd_get_format (abfd))
5143     {
5144     case bfd_object:
5145       return elf_link_add_object_symbols (abfd, info);
5146     case bfd_archive:
5147       return elf_link_add_archive_symbols (abfd, info);
5148     default:
5149       bfd_set_error (bfd_error_wrong_format);
5150       return FALSE;
5151     }
5152 }
5153 \f
5154 struct hash_codes_info
5155 {
5156   unsigned long *hashcodes;
5157   bfd_boolean error;
5158 };
5159
5160 /* This function will be called though elf_link_hash_traverse to store
5161    all hash value of the exported symbols in an array.  */
5162
5163 static bfd_boolean
5164 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5165 {
5166   struct hash_codes_info *inf = (struct hash_codes_info *) data;
5167   const char *name;
5168   char *p;
5169   unsigned long ha;
5170   char *alc = NULL;
5171
5172   /* Ignore indirect symbols.  These are added by the versioning code.  */
5173   if (h->dynindx == -1)
5174     return TRUE;
5175
5176   name = h->root.root.string;
5177   p = strchr (name, ELF_VER_CHR);
5178   if (p != NULL)
5179     {
5180       alc = (char *) bfd_malloc (p - name + 1);
5181       if (alc == NULL)
5182         {
5183           inf->error = TRUE;
5184           return FALSE;
5185         }
5186       memcpy (alc, name, p - name);
5187       alc[p - name] = '\0';
5188       name = alc;
5189     }
5190
5191   /* Compute the hash value.  */
5192   ha = bfd_elf_hash (name);
5193
5194   /* Store the found hash value in the array given as the argument.  */
5195   *(inf->hashcodes)++ = ha;
5196
5197   /* And store it in the struct so that we can put it in the hash table
5198      later.  */
5199   h->u.elf_hash_value = ha;
5200
5201   if (alc != NULL)
5202     free (alc);
5203
5204   return TRUE;
5205 }
5206
5207 struct collect_gnu_hash_codes
5208 {
5209   bfd *output_bfd;
5210   const struct elf_backend_data *bed;
5211   unsigned long int nsyms;
5212   unsigned long int maskbits;
5213   unsigned long int *hashcodes;
5214   unsigned long int *hashval;
5215   unsigned long int *indx;
5216   unsigned long int *counts;
5217   bfd_vma *bitmask;
5218   bfd_byte *contents;
5219   long int min_dynindx;
5220   unsigned long int bucketcount;
5221   unsigned long int symindx;
5222   long int local_indx;
5223   long int shift1, shift2;
5224   unsigned long int mask;
5225   bfd_boolean error;
5226 };
5227
5228 /* This function will be called though elf_link_hash_traverse to store
5229    all hash value of the exported symbols in an array.  */
5230
5231 static bfd_boolean
5232 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5233 {
5234   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5235   const char *name;
5236   char *p;
5237   unsigned long ha;
5238   char *alc = NULL;
5239
5240   /* Ignore indirect symbols.  These are added by the versioning code.  */
5241   if (h->dynindx == -1)
5242     return TRUE;
5243
5244   /* Ignore also local symbols and undefined symbols.  */
5245   if (! (*s->bed->elf_hash_symbol) (h))
5246     return TRUE;
5247
5248   name = h->root.root.string;
5249   p = strchr (name, ELF_VER_CHR);
5250   if (p != NULL)
5251     {
5252       alc = (char *) bfd_malloc (p - name + 1);
5253       if (alc == NULL)
5254         {
5255           s->error = TRUE;
5256           return FALSE;
5257         }
5258       memcpy (alc, name, p - name);
5259       alc[p - name] = '\0';
5260       name = alc;
5261     }
5262
5263   /* Compute the hash value.  */
5264   ha = bfd_elf_gnu_hash (name);
5265
5266   /* Store the found hash value in the array for compute_bucket_count,
5267      and also for .dynsym reordering purposes.  */
5268   s->hashcodes[s->nsyms] = ha;
5269   s->hashval[h->dynindx] = ha;
5270   ++s->nsyms;
5271   if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5272     s->min_dynindx = h->dynindx;
5273
5274   if (alc != NULL)
5275     free (alc);
5276
5277   return TRUE;
5278 }
5279
5280 /* This function will be called though elf_link_hash_traverse to do
5281    final dynaminc symbol renumbering.  */
5282
5283 static bfd_boolean
5284 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5285 {
5286   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5287   unsigned long int bucket;
5288   unsigned long int val;
5289
5290   /* Ignore indirect symbols.  */
5291   if (h->dynindx == -1)
5292     return TRUE;
5293
5294   /* Ignore also local symbols and undefined symbols.  */
5295   if (! (*s->bed->elf_hash_symbol) (h))
5296     {
5297       if (h->dynindx >= s->min_dynindx)
5298         h->dynindx = s->local_indx++;
5299       return TRUE;
5300     }
5301
5302   bucket = s->hashval[h->dynindx] % s->bucketcount;
5303   val = (s->hashval[h->dynindx] >> s->shift1)
5304         & ((s->maskbits >> s->shift1) - 1);
5305   s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5306   s->bitmask[val]
5307     |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5308   val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5309   if (s->counts[bucket] == 1)
5310     /* Last element terminates the chain.  */
5311     val |= 1;
5312   bfd_put_32 (s->output_bfd, val,
5313               s->contents + (s->indx[bucket] - s->symindx) * 4);
5314   --s->counts[bucket];
5315   h->dynindx = s->indx[bucket]++;
5316   return TRUE;
5317 }
5318
5319 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5320
5321 bfd_boolean
5322 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5323 {
5324   return !(h->forced_local
5325            || h->root.type == bfd_link_hash_undefined
5326            || h->root.type == bfd_link_hash_undefweak
5327            || ((h->root.type == bfd_link_hash_defined
5328                 || h->root.type == bfd_link_hash_defweak)
5329                && h->root.u.def.section->output_section == NULL));
5330 }
5331
5332 /* Array used to determine the number of hash table buckets to use
5333    based on the number of symbols there are.  If there are fewer than
5334    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5335    fewer than 37 we use 17 buckets, and so forth.  We never use more
5336    than 32771 buckets.  */
5337
5338 static const size_t elf_buckets[] =
5339 {
5340   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5341   16411, 32771, 0
5342 };
5343
5344 /* Compute bucket count for hashing table.  We do not use a static set
5345    of possible tables sizes anymore.  Instead we determine for all
5346    possible reasonable sizes of the table the outcome (i.e., the
5347    number of collisions etc) and choose the best solution.  The
5348    weighting functions are not too simple to allow the table to grow
5349    without bounds.  Instead one of the weighting factors is the size.
5350    Therefore the result is always a good payoff between few collisions
5351    (= short chain lengths) and table size.  */
5352 static size_t
5353 compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5354                       unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5355                       unsigned long int nsyms,
5356                       int gnu_hash)
5357 {
5358   size_t best_size = 0;
5359   unsigned long int i;
5360
5361   /* We have a problem here.  The following code to optimize the table
5362      size requires an integer type with more the 32 bits.  If
5363      BFD_HOST_U_64_BIT is set we know about such a type.  */
5364 #ifdef BFD_HOST_U_64_BIT
5365   if (info->optimize)
5366     {
5367       size_t minsize;
5368       size_t maxsize;
5369       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5370       bfd *dynobj = elf_hash_table (info)->dynobj;
5371       size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5372       const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5373       unsigned long int *counts;
5374       bfd_size_type amt;
5375       unsigned int no_improvement_count = 0;
5376
5377       /* Possible optimization parameters: if we have NSYMS symbols we say
5378          that the hashing table must at least have NSYMS/4 and at most
5379          2*NSYMS buckets.  */
5380       minsize = nsyms / 4;
5381       if (minsize == 0)
5382         minsize = 1;
5383       best_size = maxsize = nsyms * 2;
5384       if (gnu_hash)
5385         {
5386           if (minsize < 2)
5387             minsize = 2;
5388           if ((best_size & 31) == 0)
5389             ++best_size;
5390         }
5391
5392       /* Create array where we count the collisions in.  We must use bfd_malloc
5393          since the size could be large.  */
5394       amt = maxsize;
5395       amt *= sizeof (unsigned long int);
5396       counts = (unsigned long int *) bfd_malloc (amt);
5397       if (counts == NULL)
5398         return 0;
5399
5400       /* Compute the "optimal" size for the hash table.  The criteria is a
5401          minimal chain length.  The minor criteria is (of course) the size
5402          of the table.  */
5403       for (i = minsize; i < maxsize; ++i)
5404         {
5405           /* Walk through the array of hashcodes and count the collisions.  */
5406           BFD_HOST_U_64_BIT max;
5407           unsigned long int j;
5408           unsigned long int fact;
5409
5410           if (gnu_hash && (i & 31) == 0)
5411             continue;
5412
5413           memset (counts, '\0', i * sizeof (unsigned long int));
5414
5415           /* Determine how often each hash bucket is used.  */
5416           for (j = 0; j < nsyms; ++j)
5417             ++counts[hashcodes[j] % i];
5418
5419           /* For the weight function we need some information about the
5420              pagesize on the target.  This is information need not be 100%
5421              accurate.  Since this information is not available (so far) we
5422              define it here to a reasonable default value.  If it is crucial
5423              to have a better value some day simply define this value.  */
5424 # ifndef BFD_TARGET_PAGESIZE
5425 #  define BFD_TARGET_PAGESIZE   (4096)
5426 # endif
5427
5428           /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5429              and the chains.  */
5430           max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5431
5432 # if 1
5433           /* Variant 1: optimize for short chains.  We add the squares
5434              of all the chain lengths (which favors many small chain
5435              over a few long chains).  */
5436           for (j = 0; j < i; ++j)
5437             max += counts[j] * counts[j];
5438
5439           /* This adds penalties for the overall size of the table.  */
5440           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5441           max *= fact * fact;
5442 # else
5443           /* Variant 2: Optimize a lot more for small table.  Here we
5444              also add squares of the size but we also add penalties for
5445              empty slots (the +1 term).  */
5446           for (j = 0; j < i; ++j)
5447             max += (1 + counts[j]) * (1 + counts[j]);
5448
5449           /* The overall size of the table is considered, but not as
5450              strong as in variant 1, where it is squared.  */
5451           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5452           max *= fact;
5453 # endif
5454
5455           /* Compare with current best results.  */
5456           if (max < best_chlen)
5457             {
5458               best_chlen = max;
5459               best_size = i;
5460               no_improvement_count = 0;
5461             }
5462           /* PR 11843: Avoid futile long searches for the best bucket size
5463              when there are a large number of symbols.  */
5464           else if (++no_improvement_count == 100)
5465             break;
5466         }
5467
5468       free (counts);
5469     }
5470   else
5471 #endif /* defined (BFD_HOST_U_64_BIT) */
5472     {
5473       /* This is the fallback solution if no 64bit type is available or if we
5474          are not supposed to spend much time on optimizations.  We select the
5475          bucket count using a fixed set of numbers.  */
5476       for (i = 0; elf_buckets[i] != 0; i++)
5477         {
5478           best_size = elf_buckets[i];
5479           if (nsyms < elf_buckets[i + 1])
5480             break;
5481         }
5482       if (gnu_hash && best_size < 2)
5483         best_size = 2;
5484     }
5485
5486   return best_size;
5487 }
5488
5489 /* Size any SHT_GROUP section for ld -r.  */
5490
5491 bfd_boolean
5492 _bfd_elf_size_group_sections (struct bfd_link_info *info)
5493 {
5494   bfd *ibfd;
5495
5496   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5497     if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5498         && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5499       return FALSE;
5500   return TRUE;
5501 }
5502
5503 /* Set up the sizes and contents of the ELF dynamic sections.  This is
5504    called by the ELF linker emulation before_allocation routine.  We
5505    must set the sizes of the sections before the linker sets the
5506    addresses of the various sections.  */
5507
5508 bfd_boolean
5509 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5510                                const char *soname,
5511                                const char *rpath,
5512                                const char *filter_shlib,
5513                                const char *audit,
5514                                const char *depaudit,
5515                                const char * const *auxiliary_filters,
5516                                struct bfd_link_info *info,
5517                                asection **sinterpptr)
5518 {
5519   bfd_size_type soname_indx;
5520   bfd *dynobj;
5521   const struct elf_backend_data *bed;
5522   struct elf_info_failed asvinfo;
5523
5524   *sinterpptr = NULL;
5525
5526   soname_indx = (bfd_size_type) -1;
5527
5528   if (!is_elf_hash_table (info->hash))
5529     return TRUE;
5530
5531   bed = get_elf_backend_data (output_bfd);
5532   if (info->execstack)
5533     elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5534   else if (info->noexecstack)
5535     elf_tdata (output_bfd)->stack_flags = PF_R | PF_W;
5536   else
5537     {
5538       bfd *inputobj;
5539       asection *notesec = NULL;
5540       int exec = 0;
5541
5542       for (inputobj = info->input_bfds;
5543            inputobj;
5544            inputobj = inputobj->link_next)
5545         {
5546           asection *s;
5547
5548           if (inputobj->flags
5549               & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5550             continue;
5551           s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5552           if (s)
5553             {
5554               if (s->flags & SEC_CODE)
5555                 exec = PF_X;
5556               notesec = s;
5557             }
5558           else if (bed->default_execstack)
5559             exec = PF_X;
5560         }
5561       if (notesec)
5562         {
5563           elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | exec;
5564           if (exec && info->relocatable
5565               && notesec->output_section != bfd_abs_section_ptr)
5566             notesec->output_section->flags |= SEC_CODE;
5567         }
5568     }
5569
5570   /* Any syms created from now on start with -1 in
5571      got.refcount/offset and plt.refcount/offset.  */
5572   elf_hash_table (info)->init_got_refcount
5573     = elf_hash_table (info)->init_got_offset;
5574   elf_hash_table (info)->init_plt_refcount
5575     = elf_hash_table (info)->init_plt_offset;
5576
5577   if (info->relocatable
5578       && !_bfd_elf_size_group_sections (info))
5579     return FALSE;
5580
5581   /* The backend may have to create some sections regardless of whether
5582      we're dynamic or not.  */
5583   if (bed->elf_backend_always_size_sections
5584       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5585     return FALSE;
5586
5587   if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5588     return FALSE;
5589
5590   dynobj = elf_hash_table (info)->dynobj;
5591
5592   /* If there were no dynamic objects in the link, there is nothing to
5593      do here.  */
5594   if (dynobj == NULL)
5595     return TRUE;
5596
5597   if (elf_hash_table (info)->dynamic_sections_created)
5598     {
5599       struct elf_info_failed eif;
5600       struct elf_link_hash_entry *h;
5601       asection *dynstr;
5602       struct bfd_elf_version_tree *t;
5603       struct bfd_elf_version_expr *d;
5604       asection *s;
5605       bfd_boolean all_defined;
5606
5607       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
5608       BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5609
5610       if (soname != NULL)
5611         {
5612           soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5613                                              soname, TRUE);
5614           if (soname_indx == (bfd_size_type) -1
5615               || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5616             return FALSE;
5617         }
5618
5619       if (info->symbolic)
5620         {
5621           if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5622             return FALSE;
5623           info->flags |= DF_SYMBOLIC;
5624         }
5625
5626       if (rpath != NULL)
5627         {
5628           bfd_size_type indx;
5629
5630           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5631                                       TRUE);
5632           if (indx == (bfd_size_type) -1
5633               || !_bfd_elf_add_dynamic_entry (info, DT_RPATH, indx))
5634             return FALSE;
5635
5636           if  (info->new_dtags)
5637             {
5638               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
5639               if (!_bfd_elf_add_dynamic_entry (info, DT_RUNPATH, indx))
5640                 return FALSE;
5641             }
5642         }
5643
5644       if (filter_shlib != NULL)
5645         {
5646           bfd_size_type indx;
5647
5648           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5649                                       filter_shlib, TRUE);
5650           if (indx == (bfd_size_type) -1
5651               || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5652             return FALSE;
5653         }
5654
5655       if (auxiliary_filters != NULL)
5656         {
5657           const char * const *p;
5658
5659           for (p = auxiliary_filters; *p != NULL; p++)
5660             {
5661               bfd_size_type indx;
5662
5663               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5664                                           *p, TRUE);
5665               if (indx == (bfd_size_type) -1
5666                   || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5667                 return FALSE;
5668             }
5669         }
5670
5671       if (audit != NULL)
5672         {
5673           bfd_size_type indx;
5674
5675           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5676                                       TRUE);
5677           if (indx == (bfd_size_type) -1
5678               || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5679             return FALSE;
5680         }
5681
5682       if (depaudit != NULL)
5683         {
5684           bfd_size_type indx;
5685
5686           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5687                                       TRUE);
5688           if (indx == (bfd_size_type) -1
5689               || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5690             return FALSE;
5691         }
5692
5693       eif.info = info;
5694       eif.failed = FALSE;
5695
5696       /* If we are supposed to export all symbols into the dynamic symbol
5697          table (this is not the normal case), then do so.  */
5698       if (info->export_dynamic
5699           || (info->executable && info->dynamic))
5700         {
5701           elf_link_hash_traverse (elf_hash_table (info),
5702                                   _bfd_elf_export_symbol,
5703                                   &eif);
5704           if (eif.failed)
5705             return FALSE;
5706         }
5707
5708       /* Make all global versions with definition.  */
5709       for (t = info->version_info; t != NULL; t = t->next)
5710         for (d = t->globals.list; d != NULL; d = d->next)
5711           if (!d->symver && d->literal)
5712             {
5713               const char *verstr, *name;
5714               size_t namelen, verlen, newlen;
5715               char *newname, *p, leading_char;
5716               struct elf_link_hash_entry *newh;
5717
5718               leading_char = bfd_get_symbol_leading_char (output_bfd);
5719               name = d->pattern;
5720               namelen = strlen (name) + (leading_char != '\0');
5721               verstr = t->name;
5722               verlen = strlen (verstr);
5723               newlen = namelen + verlen + 3;
5724
5725               newname = (char *) bfd_malloc (newlen);
5726               if (newname == NULL)
5727                 return FALSE;
5728               newname[0] = leading_char;
5729               memcpy (newname + (leading_char != '\0'), name, namelen);
5730
5731               /* Check the hidden versioned definition.  */
5732               p = newname + namelen;
5733               *p++ = ELF_VER_CHR;
5734               memcpy (p, verstr, verlen + 1);
5735               newh = elf_link_hash_lookup (elf_hash_table (info),
5736                                            newname, FALSE, FALSE,
5737                                            FALSE);
5738               if (newh == NULL
5739                   || (newh->root.type != bfd_link_hash_defined
5740                       && newh->root.type != bfd_link_hash_defweak))
5741                 {
5742                   /* Check the default versioned definition.  */
5743                   *p++ = ELF_VER_CHR;
5744                   memcpy (p, verstr, verlen + 1);
5745                   newh = elf_link_hash_lookup (elf_hash_table (info),
5746                                                newname, FALSE, FALSE,
5747                                                FALSE);
5748                 }
5749               free (newname);
5750
5751               /* Mark this version if there is a definition and it is
5752                  not defined in a shared object.  */
5753               if (newh != NULL
5754                   && !newh->def_dynamic
5755                   && (newh->root.type == bfd_link_hash_defined
5756                       || newh->root.type == bfd_link_hash_defweak))
5757                 d->symver = 1;
5758             }
5759
5760       /* Attach all the symbols to their version information.  */
5761       asvinfo.info = info;
5762       asvinfo.failed = FALSE;
5763
5764       elf_link_hash_traverse (elf_hash_table (info),
5765                               _bfd_elf_link_assign_sym_version,
5766                               &asvinfo);
5767       if (asvinfo.failed)
5768         return FALSE;
5769
5770       if (!info->allow_undefined_version)
5771         {
5772           /* Check if all global versions have a definition.  */
5773           all_defined = TRUE;
5774           for (t = info->version_info; t != NULL; t = t->next)
5775             for (d = t->globals.list; d != NULL; d = d->next)
5776               if (d->literal && !d->symver && !d->script)
5777                 {
5778                   (*_bfd_error_handler)
5779                     (_("%s: undefined version: %s"),
5780                      d->pattern, t->name);
5781                   all_defined = FALSE;
5782                 }
5783
5784           if (!all_defined)
5785             {
5786               bfd_set_error (bfd_error_bad_value);
5787               return FALSE;
5788             }
5789         }
5790
5791       /* Find all symbols which were defined in a dynamic object and make
5792          the backend pick a reasonable value for them.  */
5793       elf_link_hash_traverse (elf_hash_table (info),
5794                               _bfd_elf_adjust_dynamic_symbol,
5795                               &eif);
5796       if (eif.failed)
5797         return FALSE;
5798
5799       /* Add some entries to the .dynamic section.  We fill in some of the
5800          values later, in bfd_elf_final_link, but we must add the entries
5801          now so that we know the final size of the .dynamic section.  */
5802
5803       /* If there are initialization and/or finalization functions to
5804          call then add the corresponding DT_INIT/DT_FINI entries.  */
5805       h = (info->init_function
5806            ? elf_link_hash_lookup (elf_hash_table (info),
5807                                    info->init_function, FALSE,
5808                                    FALSE, FALSE)
5809            : NULL);
5810       if (h != NULL
5811           && (h->ref_regular
5812               || h->def_regular))
5813         {
5814           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5815             return FALSE;
5816         }
5817       h = (info->fini_function
5818            ? elf_link_hash_lookup (elf_hash_table (info),
5819                                    info->fini_function, FALSE,
5820                                    FALSE, FALSE)
5821            : NULL);
5822       if (h != NULL
5823           && (h->ref_regular
5824               || h->def_regular))
5825         {
5826           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5827             return FALSE;
5828         }
5829
5830       s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5831       if (s != NULL && s->linker_has_input)
5832         {
5833           /* DT_PREINIT_ARRAY is not allowed in shared library.  */
5834           if (! info->executable)
5835             {
5836               bfd *sub;
5837               asection *o;
5838
5839               for (sub = info->input_bfds; sub != NULL;
5840                    sub = sub->link_next)
5841                 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5842                   for (o = sub->sections; o != NULL; o = o->next)
5843                     if (elf_section_data (o)->this_hdr.sh_type
5844                         == SHT_PREINIT_ARRAY)
5845                       {
5846                         (*_bfd_error_handler)
5847                           (_("%B: .preinit_array section is not allowed in DSO"),
5848                            sub);
5849                         break;
5850                       }
5851
5852               bfd_set_error (bfd_error_nonrepresentable_section);
5853               return FALSE;
5854             }
5855
5856           if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5857               || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5858             return FALSE;
5859         }
5860       s = bfd_get_section_by_name (output_bfd, ".init_array");
5861       if (s != NULL && s->linker_has_input)
5862         {
5863           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5864               || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5865             return FALSE;
5866         }
5867       s = bfd_get_section_by_name (output_bfd, ".fini_array");
5868       if (s != NULL && s->linker_has_input)
5869         {
5870           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5871               || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5872             return FALSE;
5873         }
5874
5875       dynstr = bfd_get_section_by_name (dynobj, ".dynstr");
5876       /* If .dynstr is excluded from the link, we don't want any of
5877          these tags.  Strictly, we should be checking each section
5878          individually;  This quick check covers for the case where
5879          someone does a /DISCARD/ : { *(*) }.  */
5880       if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5881         {
5882           bfd_size_type strsize;
5883
5884           strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5885           if ((info->emit_hash
5886                && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5887               || (info->emit_gnu_hash
5888                   && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5889               || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5890               || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5891               || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5892               || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5893                                               bed->s->sizeof_sym))
5894             return FALSE;
5895         }
5896     }
5897
5898   /* The backend must work out the sizes of all the other dynamic
5899      sections.  */
5900   if (bed->elf_backend_size_dynamic_sections
5901       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5902     return FALSE;
5903
5904   if (elf_hash_table (info)->dynamic_sections_created)
5905     {
5906       unsigned long section_sym_count;
5907       struct bfd_elf_version_tree *verdefs;
5908       asection *s;
5909
5910       /* Set up the version definition section.  */
5911       s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
5912       BFD_ASSERT (s != NULL);
5913
5914       /* We may have created additional version definitions if we are
5915          just linking a regular application.  */
5916       verdefs = info->version_info;
5917
5918       /* Skip anonymous version tag.  */
5919       if (verdefs != NULL && verdefs->vernum == 0)
5920         verdefs = verdefs->next;
5921
5922       if (verdefs == NULL && !info->create_default_symver)
5923         s->flags |= SEC_EXCLUDE;
5924       else
5925         {
5926           unsigned int cdefs;
5927           bfd_size_type size;
5928           struct bfd_elf_version_tree *t;
5929           bfd_byte *p;
5930           Elf_Internal_Verdef def;
5931           Elf_Internal_Verdaux defaux;
5932           struct bfd_link_hash_entry *bh;
5933           struct elf_link_hash_entry *h;
5934           const char *name;
5935
5936           cdefs = 0;
5937           size = 0;
5938
5939           /* Make space for the base version.  */
5940           size += sizeof (Elf_External_Verdef);
5941           size += sizeof (Elf_External_Verdaux);
5942           ++cdefs;
5943
5944           /* Make space for the default version.  */
5945           if (info->create_default_symver)
5946             {
5947               size += sizeof (Elf_External_Verdef);
5948               ++cdefs;
5949             }
5950
5951           for (t = verdefs; t != NULL; t = t->next)
5952             {
5953               struct bfd_elf_version_deps *n;
5954
5955               /* Don't emit base version twice.  */
5956               if (t->vernum == 0)
5957                 continue;
5958
5959               size += sizeof (Elf_External_Verdef);
5960               size += sizeof (Elf_External_Verdaux);
5961               ++cdefs;
5962
5963               for (n = t->deps; n != NULL; n = n->next)
5964                 size += sizeof (Elf_External_Verdaux);
5965             }
5966
5967           s->size = size;
5968           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
5969           if (s->contents == NULL && s->size != 0)
5970             return FALSE;
5971
5972           /* Fill in the version definition section.  */
5973
5974           p = s->contents;
5975
5976           def.vd_version = VER_DEF_CURRENT;
5977           def.vd_flags = VER_FLG_BASE;
5978           def.vd_ndx = 1;
5979           def.vd_cnt = 1;
5980           if (info->create_default_symver)
5981             {
5982               def.vd_aux = 2 * sizeof (Elf_External_Verdef);
5983               def.vd_next = sizeof (Elf_External_Verdef);
5984             }
5985           else
5986             {
5987               def.vd_aux = sizeof (Elf_External_Verdef);
5988               def.vd_next = (sizeof (Elf_External_Verdef)
5989                              + sizeof (Elf_External_Verdaux));
5990             }
5991
5992           if (soname_indx != (bfd_size_type) -1)
5993             {
5994               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
5995                                       soname_indx);
5996               def.vd_hash = bfd_elf_hash (soname);
5997               defaux.vda_name = soname_indx;
5998               name = soname;
5999             }
6000           else
6001             {
6002               bfd_size_type indx;
6003
6004               name = lbasename (output_bfd->filename);
6005               def.vd_hash = bfd_elf_hash (name);
6006               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6007                                           name, FALSE);
6008               if (indx == (bfd_size_type) -1)
6009                 return FALSE;
6010               defaux.vda_name = indx;
6011             }
6012           defaux.vda_next = 0;
6013
6014           _bfd_elf_swap_verdef_out (output_bfd, &def,
6015                                     (Elf_External_Verdef *) p);
6016           p += sizeof (Elf_External_Verdef);
6017           if (info->create_default_symver)
6018             {
6019               /* Add a symbol representing this version.  */
6020               bh = NULL;
6021               if (! (_bfd_generic_link_add_one_symbol
6022                      (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6023                       0, NULL, FALSE,
6024                       get_elf_backend_data (dynobj)->collect, &bh)))
6025                 return FALSE;
6026               h = (struct elf_link_hash_entry *) bh;
6027               h->non_elf = 0;
6028               h->def_regular = 1;
6029               h->type = STT_OBJECT;
6030               h->verinfo.vertree = NULL;
6031
6032               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6033                 return FALSE;
6034
6035               /* Create a duplicate of the base version with the same
6036                  aux block, but different flags.  */
6037               def.vd_flags = 0;
6038               def.vd_ndx = 2;
6039               def.vd_aux = sizeof (Elf_External_Verdef);
6040               if (verdefs)
6041                 def.vd_next = (sizeof (Elf_External_Verdef)
6042                                + sizeof (Elf_External_Verdaux));
6043               else
6044                 def.vd_next = 0;
6045               _bfd_elf_swap_verdef_out (output_bfd, &def,
6046                                         (Elf_External_Verdef *) p);
6047               p += sizeof (Elf_External_Verdef);
6048             }
6049           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6050                                      (Elf_External_Verdaux *) p);
6051           p += sizeof (Elf_External_Verdaux);
6052
6053           for (t = verdefs; t != NULL; t = t->next)
6054             {
6055               unsigned int cdeps;
6056               struct bfd_elf_version_deps *n;
6057
6058               /* Don't emit the base version twice.  */
6059               if (t->vernum == 0)
6060                 continue;
6061
6062               cdeps = 0;
6063               for (n = t->deps; n != NULL; n = n->next)
6064                 ++cdeps;
6065
6066               /* Add a symbol representing this version.  */
6067               bh = NULL;
6068               if (! (_bfd_generic_link_add_one_symbol
6069                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6070                       0, NULL, FALSE,
6071                       get_elf_backend_data (dynobj)->collect, &bh)))
6072                 return FALSE;
6073               h = (struct elf_link_hash_entry *) bh;
6074               h->non_elf = 0;
6075               h->def_regular = 1;
6076               h->type = STT_OBJECT;
6077               h->verinfo.vertree = t;
6078
6079               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6080                 return FALSE;
6081
6082               def.vd_version = VER_DEF_CURRENT;
6083               def.vd_flags = 0;
6084               if (t->globals.list == NULL
6085                   && t->locals.list == NULL
6086                   && ! t->used)
6087                 def.vd_flags |= VER_FLG_WEAK;
6088               def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6089               def.vd_cnt = cdeps + 1;
6090               def.vd_hash = bfd_elf_hash (t->name);
6091               def.vd_aux = sizeof (Elf_External_Verdef);
6092               def.vd_next = 0;
6093
6094               /* If a basever node is next, it *must* be the last node in
6095                  the chain, otherwise Verdef construction breaks.  */
6096               if (t->next != NULL && t->next->vernum == 0)
6097                 BFD_ASSERT (t->next->next == NULL);
6098
6099               if (t->next != NULL && t->next->vernum != 0)
6100                 def.vd_next = (sizeof (Elf_External_Verdef)
6101                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6102
6103               _bfd_elf_swap_verdef_out (output_bfd, &def,
6104                                         (Elf_External_Verdef *) p);
6105               p += sizeof (Elf_External_Verdef);
6106
6107               defaux.vda_name = h->dynstr_index;
6108               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6109                                       h->dynstr_index);
6110               defaux.vda_next = 0;
6111               if (t->deps != NULL)
6112                 defaux.vda_next = sizeof (Elf_External_Verdaux);
6113               t->name_indx = defaux.vda_name;
6114
6115               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6116                                          (Elf_External_Verdaux *) p);
6117               p += sizeof (Elf_External_Verdaux);
6118
6119               for (n = t->deps; n != NULL; n = n->next)
6120                 {
6121                   if (n->version_needed == NULL)
6122                     {
6123                       /* This can happen if there was an error in the
6124                          version script.  */
6125                       defaux.vda_name = 0;
6126                     }
6127                   else
6128                     {
6129                       defaux.vda_name = n->version_needed->name_indx;
6130                       _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6131                                               defaux.vda_name);
6132                     }
6133                   if (n->next == NULL)
6134                     defaux.vda_next = 0;
6135                   else
6136                     defaux.vda_next = sizeof (Elf_External_Verdaux);
6137
6138                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6139                                              (Elf_External_Verdaux *) p);
6140                   p += sizeof (Elf_External_Verdaux);
6141                 }
6142             }
6143
6144           if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6145               || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6146             return FALSE;
6147
6148           elf_tdata (output_bfd)->cverdefs = cdefs;
6149         }
6150
6151       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6152         {
6153           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6154             return FALSE;
6155         }
6156       else if (info->flags & DF_BIND_NOW)
6157         {
6158           if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6159             return FALSE;
6160         }
6161
6162       if (info->flags_1)
6163         {
6164           if (info->executable)
6165             info->flags_1 &= ~ (DF_1_INITFIRST
6166                                 | DF_1_NODELETE
6167                                 | DF_1_NOOPEN);
6168           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6169             return FALSE;
6170         }
6171
6172       /* Work out the size of the version reference section.  */
6173
6174       s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
6175       BFD_ASSERT (s != NULL);
6176       {
6177         struct elf_find_verdep_info sinfo;
6178
6179         sinfo.info = info;
6180         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6181         if (sinfo.vers == 0)
6182           sinfo.vers = 1;
6183         sinfo.failed = FALSE;
6184
6185         elf_link_hash_traverse (elf_hash_table (info),
6186                                 _bfd_elf_link_find_version_dependencies,
6187                                 &sinfo);
6188         if (sinfo.failed)
6189           return FALSE;
6190
6191         if (elf_tdata (output_bfd)->verref == NULL)
6192           s->flags |= SEC_EXCLUDE;
6193         else
6194           {
6195             Elf_Internal_Verneed *t;
6196             unsigned int size;
6197             unsigned int crefs;
6198             bfd_byte *p;
6199
6200             /* Build the version dependency section.  */
6201             size = 0;
6202             crefs = 0;
6203             for (t = elf_tdata (output_bfd)->verref;
6204                  t != NULL;
6205                  t = t->vn_nextref)
6206               {
6207                 Elf_Internal_Vernaux *a;
6208
6209                 size += sizeof (Elf_External_Verneed);
6210                 ++crefs;
6211                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6212                   size += sizeof (Elf_External_Vernaux);
6213               }
6214
6215             s->size = size;
6216             s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6217             if (s->contents == NULL)
6218               return FALSE;
6219
6220             p = s->contents;
6221             for (t = elf_tdata (output_bfd)->verref;
6222                  t != NULL;
6223                  t = t->vn_nextref)
6224               {
6225                 unsigned int caux;
6226                 Elf_Internal_Vernaux *a;
6227                 bfd_size_type indx;
6228
6229                 caux = 0;
6230                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6231                   ++caux;
6232
6233                 t->vn_version = VER_NEED_CURRENT;
6234                 t->vn_cnt = caux;
6235                 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6236                                             elf_dt_name (t->vn_bfd) != NULL
6237                                             ? elf_dt_name (t->vn_bfd)
6238                                             : lbasename (t->vn_bfd->filename),
6239                                             FALSE);
6240                 if (indx == (bfd_size_type) -1)
6241                   return FALSE;
6242                 t->vn_file = indx;
6243                 t->vn_aux = sizeof (Elf_External_Verneed);
6244                 if (t->vn_nextref == NULL)
6245                   t->vn_next = 0;
6246                 else
6247                   t->vn_next = (sizeof (Elf_External_Verneed)
6248                                 + caux * sizeof (Elf_External_Vernaux));
6249
6250                 _bfd_elf_swap_verneed_out (output_bfd, t,
6251                                            (Elf_External_Verneed *) p);
6252                 p += sizeof (Elf_External_Verneed);
6253
6254                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6255                   {
6256                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
6257                     indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6258                                                 a->vna_nodename, FALSE);
6259                     if (indx == (bfd_size_type) -1)
6260                       return FALSE;
6261                     a->vna_name = indx;
6262                     if (a->vna_nextptr == NULL)
6263                       a->vna_next = 0;
6264                     else
6265                       a->vna_next = sizeof (Elf_External_Vernaux);
6266
6267                     _bfd_elf_swap_vernaux_out (output_bfd, a,
6268                                                (Elf_External_Vernaux *) p);
6269                     p += sizeof (Elf_External_Vernaux);
6270                   }
6271               }
6272
6273             if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6274                 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6275               return FALSE;
6276
6277             elf_tdata (output_bfd)->cverrefs = crefs;
6278           }
6279       }
6280
6281       if ((elf_tdata (output_bfd)->cverrefs == 0
6282            && elf_tdata (output_bfd)->cverdefs == 0)
6283           || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6284                                              &section_sym_count) == 0)
6285         {
6286           s = bfd_get_section_by_name (dynobj, ".gnu.version");
6287           s->flags |= SEC_EXCLUDE;
6288         }
6289     }
6290   return TRUE;
6291 }
6292
6293 /* Find the first non-excluded output section.  We'll use its
6294    section symbol for some emitted relocs.  */
6295 void
6296 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6297 {
6298   asection *s;
6299
6300   for (s = output_bfd->sections; s != NULL; s = s->next)
6301     if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6302         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6303       {
6304         elf_hash_table (info)->text_index_section = s;
6305         break;
6306       }
6307 }
6308
6309 /* Find two non-excluded output sections, one for code, one for data.
6310    We'll use their section symbols for some emitted relocs.  */
6311 void
6312 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6313 {
6314   asection *s;
6315
6316   /* Data first, since setting text_index_section changes
6317      _bfd_elf_link_omit_section_dynsym.  */
6318   for (s = output_bfd->sections; s != NULL; s = s->next)
6319     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6320         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6321       {
6322         elf_hash_table (info)->data_index_section = s;
6323         break;
6324       }
6325
6326   for (s = output_bfd->sections; s != NULL; s = s->next)
6327     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6328          == (SEC_ALLOC | SEC_READONLY))
6329         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6330       {
6331         elf_hash_table (info)->text_index_section = s;
6332         break;
6333       }
6334
6335   if (elf_hash_table (info)->text_index_section == NULL)
6336     elf_hash_table (info)->text_index_section
6337       = elf_hash_table (info)->data_index_section;
6338 }
6339
6340 bfd_boolean
6341 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6342 {
6343   const struct elf_backend_data *bed;
6344
6345   if (!is_elf_hash_table (info->hash))
6346     return TRUE;
6347
6348   bed = get_elf_backend_data (output_bfd);
6349   (*bed->elf_backend_init_index_section) (output_bfd, info);
6350
6351   if (elf_hash_table (info)->dynamic_sections_created)
6352     {
6353       bfd *dynobj;
6354       asection *s;
6355       bfd_size_type dynsymcount;
6356       unsigned long section_sym_count;
6357       unsigned int dtagcount;
6358
6359       dynobj = elf_hash_table (info)->dynobj;
6360
6361       /* Assign dynsym indicies.  In a shared library we generate a
6362          section symbol for each output section, which come first.
6363          Next come all of the back-end allocated local dynamic syms,
6364          followed by the rest of the global symbols.  */
6365
6366       dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6367                                                     &section_sym_count);
6368
6369       /* Work out the size of the symbol version section.  */
6370       s = bfd_get_section_by_name (dynobj, ".gnu.version");
6371       BFD_ASSERT (s != NULL);
6372       if (dynsymcount != 0
6373           && (s->flags & SEC_EXCLUDE) == 0)
6374         {
6375           s->size = dynsymcount * sizeof (Elf_External_Versym);
6376           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6377           if (s->contents == NULL)
6378             return FALSE;
6379
6380           if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6381             return FALSE;
6382         }
6383
6384       /* Set the size of the .dynsym and .hash sections.  We counted
6385          the number of dynamic symbols in elf_link_add_object_symbols.
6386          We will build the contents of .dynsym and .hash when we build
6387          the final symbol table, because until then we do not know the
6388          correct value to give the symbols.  We built the .dynstr
6389          section as we went along in elf_link_add_object_symbols.  */
6390       s = bfd_get_section_by_name (dynobj, ".dynsym");
6391       BFD_ASSERT (s != NULL);
6392       s->size = dynsymcount * bed->s->sizeof_sym;
6393
6394       if (dynsymcount != 0)
6395         {
6396           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6397           if (s->contents == NULL)
6398             return FALSE;
6399
6400           /* The first entry in .dynsym is a dummy symbol.
6401              Clear all the section syms, in case we don't output them all.  */
6402           ++section_sym_count;
6403           memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6404         }
6405
6406       elf_hash_table (info)->bucketcount = 0;
6407
6408       /* Compute the size of the hashing table.  As a side effect this
6409          computes the hash values for all the names we export.  */
6410       if (info->emit_hash)
6411         {
6412           unsigned long int *hashcodes;
6413           struct hash_codes_info hashinf;
6414           bfd_size_type amt;
6415           unsigned long int nsyms;
6416           size_t bucketcount;
6417           size_t hash_entry_size;
6418
6419           /* Compute the hash values for all exported symbols.  At the same
6420              time store the values in an array so that we could use them for
6421              optimizations.  */
6422           amt = dynsymcount * sizeof (unsigned long int);
6423           hashcodes = (unsigned long int *) bfd_malloc (amt);
6424           if (hashcodes == NULL)
6425             return FALSE;
6426           hashinf.hashcodes = hashcodes;
6427           hashinf.error = FALSE;
6428
6429           /* Put all hash values in HASHCODES.  */
6430           elf_link_hash_traverse (elf_hash_table (info),
6431                                   elf_collect_hash_codes, &hashinf);
6432           if (hashinf.error)
6433             {
6434               free (hashcodes);
6435               return FALSE;
6436             }
6437
6438           nsyms = hashinf.hashcodes - hashcodes;
6439           bucketcount
6440             = compute_bucket_count (info, hashcodes, nsyms, 0);
6441           free (hashcodes);
6442
6443           if (bucketcount == 0)
6444             return FALSE;
6445
6446           elf_hash_table (info)->bucketcount = bucketcount;
6447
6448           s = bfd_get_section_by_name (dynobj, ".hash");
6449           BFD_ASSERT (s != NULL);
6450           hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6451           s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6452           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6453           if (s->contents == NULL)
6454             return FALSE;
6455
6456           bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6457           bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6458                    s->contents + hash_entry_size);
6459         }
6460
6461       if (info->emit_gnu_hash)
6462         {
6463           size_t i, cnt;
6464           unsigned char *contents;
6465           struct collect_gnu_hash_codes cinfo;
6466           bfd_size_type amt;
6467           size_t bucketcount;
6468
6469           memset (&cinfo, 0, sizeof (cinfo));
6470
6471           /* Compute the hash values for all exported symbols.  At the same
6472              time store the values in an array so that we could use them for
6473              optimizations.  */
6474           amt = dynsymcount * 2 * sizeof (unsigned long int);
6475           cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6476           if (cinfo.hashcodes == NULL)
6477             return FALSE;
6478
6479           cinfo.hashval = cinfo.hashcodes + dynsymcount;
6480           cinfo.min_dynindx = -1;
6481           cinfo.output_bfd = output_bfd;
6482           cinfo.bed = bed;
6483
6484           /* Put all hash values in HASHCODES.  */
6485           elf_link_hash_traverse (elf_hash_table (info),
6486                                   elf_collect_gnu_hash_codes, &cinfo);
6487           if (cinfo.error)
6488             {
6489               free (cinfo.hashcodes);
6490               return FALSE;
6491             }
6492
6493           bucketcount
6494             = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6495
6496           if (bucketcount == 0)
6497             {
6498               free (cinfo.hashcodes);
6499               return FALSE;
6500             }
6501
6502           s = bfd_get_section_by_name (dynobj, ".gnu.hash");
6503           BFD_ASSERT (s != NULL);
6504
6505           if (cinfo.nsyms == 0)
6506             {
6507               /* Empty .gnu.hash section is special.  */
6508               BFD_ASSERT (cinfo.min_dynindx == -1);
6509               free (cinfo.hashcodes);
6510               s->size = 5 * 4 + bed->s->arch_size / 8;
6511               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6512               if (contents == NULL)
6513                 return FALSE;
6514               s->contents = contents;
6515               /* 1 empty bucket.  */
6516               bfd_put_32 (output_bfd, 1, contents);
6517               /* SYMIDX above the special symbol 0.  */
6518               bfd_put_32 (output_bfd, 1, contents + 4);
6519               /* Just one word for bitmask.  */
6520               bfd_put_32 (output_bfd, 1, contents + 8);
6521               /* Only hash fn bloom filter.  */
6522               bfd_put_32 (output_bfd, 0, contents + 12);
6523               /* No hashes are valid - empty bitmask.  */
6524               bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6525               /* No hashes in the only bucket.  */
6526               bfd_put_32 (output_bfd, 0,
6527                           contents + 16 + bed->s->arch_size / 8);
6528             }
6529           else
6530             {
6531               unsigned long int maskwords, maskbitslog2, x;
6532               BFD_ASSERT (cinfo.min_dynindx != -1);
6533
6534               x = cinfo.nsyms;
6535               maskbitslog2 = 1;
6536               while ((x >>= 1) != 0)
6537                 ++maskbitslog2;
6538               if (maskbitslog2 < 3)
6539                 maskbitslog2 = 5;
6540               else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6541                 maskbitslog2 = maskbitslog2 + 3;
6542               else
6543                 maskbitslog2 = maskbitslog2 + 2;
6544               if (bed->s->arch_size == 64)
6545                 {
6546                   if (maskbitslog2 == 5)
6547                     maskbitslog2 = 6;
6548                   cinfo.shift1 = 6;
6549                 }
6550               else
6551                 cinfo.shift1 = 5;
6552               cinfo.mask = (1 << cinfo.shift1) - 1;
6553               cinfo.shift2 = maskbitslog2;
6554               cinfo.maskbits = 1 << maskbitslog2;
6555               maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6556               amt = bucketcount * sizeof (unsigned long int) * 2;
6557               amt += maskwords * sizeof (bfd_vma);
6558               cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6559               if (cinfo.bitmask == NULL)
6560                 {
6561                   free (cinfo.hashcodes);
6562                   return FALSE;
6563                 }
6564
6565               cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6566               cinfo.indx = cinfo.counts + bucketcount;
6567               cinfo.symindx = dynsymcount - cinfo.nsyms;
6568               memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6569
6570               /* Determine how often each hash bucket is used.  */
6571               memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6572               for (i = 0; i < cinfo.nsyms; ++i)
6573                 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6574
6575               for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6576                 if (cinfo.counts[i] != 0)
6577                   {
6578                     cinfo.indx[i] = cnt;
6579                     cnt += cinfo.counts[i];
6580                   }
6581               BFD_ASSERT (cnt == dynsymcount);
6582               cinfo.bucketcount = bucketcount;
6583               cinfo.local_indx = cinfo.min_dynindx;
6584
6585               s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6586               s->size += cinfo.maskbits / 8;
6587               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6588               if (contents == NULL)
6589                 {
6590                   free (cinfo.bitmask);
6591                   free (cinfo.hashcodes);
6592                   return FALSE;
6593                 }
6594
6595               s->contents = contents;
6596               bfd_put_32 (output_bfd, bucketcount, contents);
6597               bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6598               bfd_put_32 (output_bfd, maskwords, contents + 8);
6599               bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6600               contents += 16 + cinfo.maskbits / 8;
6601
6602               for (i = 0; i < bucketcount; ++i)
6603                 {
6604                   if (cinfo.counts[i] == 0)
6605                     bfd_put_32 (output_bfd, 0, contents);
6606                   else
6607                     bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6608                   contents += 4;
6609                 }
6610
6611               cinfo.contents = contents;
6612
6613               /* Renumber dynamic symbols, populate .gnu.hash section.  */
6614               elf_link_hash_traverse (elf_hash_table (info),
6615                                       elf_renumber_gnu_hash_syms, &cinfo);
6616
6617               contents = s->contents + 16;
6618               for (i = 0; i < maskwords; ++i)
6619                 {
6620                   bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6621                            contents);
6622                   contents += bed->s->arch_size / 8;
6623                 }
6624
6625               free (cinfo.bitmask);
6626               free (cinfo.hashcodes);
6627             }
6628         }
6629
6630       s = bfd_get_section_by_name (dynobj, ".dynstr");
6631       BFD_ASSERT (s != NULL);
6632
6633       elf_finalize_dynstr (output_bfd, info);
6634
6635       s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6636
6637       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6638         if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6639           return FALSE;
6640     }
6641
6642   return TRUE;
6643 }
6644 \f
6645 /* Indicate that we are only retrieving symbol values from this
6646    section.  */
6647
6648 void
6649 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
6650 {
6651   if (is_elf_hash_table (info->hash))
6652     sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
6653   _bfd_generic_link_just_syms (sec, info);
6654 }
6655
6656 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
6657
6658 static void
6659 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6660                             asection *sec)
6661 {
6662   BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
6663   sec->sec_info_type = ELF_INFO_TYPE_NONE;
6664 }
6665
6666 /* Finish SHF_MERGE section merging.  */
6667
6668 bfd_boolean
6669 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6670 {
6671   bfd *ibfd;
6672   asection *sec;
6673
6674   if (!is_elf_hash_table (info->hash))
6675     return FALSE;
6676
6677   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6678     if ((ibfd->flags & DYNAMIC) == 0)
6679       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6680         if ((sec->flags & SEC_MERGE) != 0
6681             && !bfd_is_abs_section (sec->output_section))
6682           {
6683             struct bfd_elf_section_data *secdata;
6684
6685             secdata = elf_section_data (sec);
6686             if (! _bfd_add_merge_section (abfd,
6687                                           &elf_hash_table (info)->merge_info,
6688                                           sec, &secdata->sec_info))
6689               return FALSE;
6690             else if (secdata->sec_info)
6691               sec->sec_info_type = ELF_INFO_TYPE_MERGE;
6692           }
6693
6694   if (elf_hash_table (info)->merge_info != NULL)
6695     _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6696                          merge_sections_remove_hook);
6697   return TRUE;
6698 }
6699
6700 /* Create an entry in an ELF linker hash table.  */
6701
6702 struct bfd_hash_entry *
6703 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6704                             struct bfd_hash_table *table,
6705                             const char *string)
6706 {
6707   /* Allocate the structure if it has not already been allocated by a
6708      subclass.  */
6709   if (entry == NULL)
6710     {
6711       entry = (struct bfd_hash_entry *)
6712           bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6713       if (entry == NULL)
6714         return entry;
6715     }
6716
6717   /* Call the allocation method of the superclass.  */
6718   entry = _bfd_link_hash_newfunc (entry, table, string);
6719   if (entry != NULL)
6720     {
6721       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6722       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6723
6724       /* Set local fields.  */
6725       ret->indx = -1;
6726       ret->dynindx = -1;
6727       ret->got = htab->init_got_refcount;
6728       ret->plt = htab->init_plt_refcount;
6729       memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6730                               - offsetof (struct elf_link_hash_entry, size)));
6731       /* Assume that we have been called by a non-ELF symbol reader.
6732          This flag is then reset by the code which reads an ELF input
6733          file.  This ensures that a symbol created by a non-ELF symbol
6734          reader will have the flag set correctly.  */
6735       ret->non_elf = 1;
6736     }
6737
6738   return entry;
6739 }
6740
6741 /* Copy data from an indirect symbol to its direct symbol, hiding the
6742    old indirect symbol.  Also used for copying flags to a weakdef.  */
6743
6744 void
6745 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6746                                   struct elf_link_hash_entry *dir,
6747                                   struct elf_link_hash_entry *ind)
6748 {
6749   struct elf_link_hash_table *htab;
6750
6751   /* Copy down any references that we may have already seen to the
6752      symbol which just became indirect.  */
6753
6754   dir->ref_dynamic |= ind->ref_dynamic;
6755   dir->ref_regular |= ind->ref_regular;
6756   dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6757   dir->non_got_ref |= ind->non_got_ref;
6758   dir->needs_plt |= ind->needs_plt;
6759   dir->pointer_equality_needed |= ind->pointer_equality_needed;
6760
6761   if (ind->root.type != bfd_link_hash_indirect)
6762     return;
6763
6764   /* Copy over the global and procedure linkage table refcount entries.
6765      These may have been already set up by a check_relocs routine.  */
6766   htab = elf_hash_table (info);
6767   if (ind->got.refcount > htab->init_got_refcount.refcount)
6768     {
6769       if (dir->got.refcount < 0)
6770         dir->got.refcount = 0;
6771       dir->got.refcount += ind->got.refcount;
6772       ind->got.refcount = htab->init_got_refcount.refcount;
6773     }
6774
6775   if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6776     {
6777       if (dir->plt.refcount < 0)
6778         dir->plt.refcount = 0;
6779       dir->plt.refcount += ind->plt.refcount;
6780       ind->plt.refcount = htab->init_plt_refcount.refcount;
6781     }
6782
6783   if (ind->dynindx != -1)
6784     {
6785       if (dir->dynindx != -1)
6786         _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6787       dir->dynindx = ind->dynindx;
6788       dir->dynstr_index = ind->dynstr_index;
6789       ind->dynindx = -1;
6790       ind->dynstr_index = 0;
6791     }
6792 }
6793
6794 void
6795 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6796                                 struct elf_link_hash_entry *h,
6797                                 bfd_boolean force_local)
6798 {
6799   /* STT_GNU_IFUNC symbol must go through PLT.  */
6800   if (h->type != STT_GNU_IFUNC)
6801     {
6802       h->plt = elf_hash_table (info)->init_plt_offset;
6803       h->needs_plt = 0;
6804     }
6805   if (force_local)
6806     {
6807       h->forced_local = 1;
6808       if (h->dynindx != -1)
6809         {
6810           h->dynindx = -1;
6811           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6812                                   h->dynstr_index);
6813         }
6814     }
6815 }
6816
6817 /* Initialize an ELF linker hash table.  */
6818
6819 bfd_boolean
6820 _bfd_elf_link_hash_table_init
6821   (struct elf_link_hash_table *table,
6822    bfd *abfd,
6823    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6824                                       struct bfd_hash_table *,
6825                                       const char *),
6826    unsigned int entsize,
6827    enum elf_target_id target_id)
6828 {
6829   bfd_boolean ret;
6830   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6831
6832   memset (table, 0, sizeof * table);
6833   table->init_got_refcount.refcount = can_refcount - 1;
6834   table->init_plt_refcount.refcount = can_refcount - 1;
6835   table->init_got_offset.offset = -(bfd_vma) 1;
6836   table->init_plt_offset.offset = -(bfd_vma) 1;
6837   /* The first dynamic symbol is a dummy.  */
6838   table->dynsymcount = 1;
6839
6840   ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6841
6842   table->root.type = bfd_link_elf_hash_table;
6843   table->hash_table_id = target_id;
6844
6845   return ret;
6846 }
6847
6848 /* Create an ELF linker hash table.  */
6849
6850 struct bfd_link_hash_table *
6851 _bfd_elf_link_hash_table_create (bfd *abfd)
6852 {
6853   struct elf_link_hash_table *ret;
6854   bfd_size_type amt = sizeof (struct elf_link_hash_table);
6855
6856   ret = (struct elf_link_hash_table *) bfd_malloc (amt);
6857   if (ret == NULL)
6858     return NULL;
6859
6860   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6861                                        sizeof (struct elf_link_hash_entry),
6862                                        GENERIC_ELF_DATA))
6863     {
6864       free (ret);
6865       return NULL;
6866     }
6867
6868   return &ret->root;
6869 }
6870
6871 /* This is a hook for the ELF emulation code in the generic linker to
6872    tell the backend linker what file name to use for the DT_NEEDED
6873    entry for a dynamic object.  */
6874
6875 void
6876 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6877 {
6878   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6879       && bfd_get_format (abfd) == bfd_object)
6880     elf_dt_name (abfd) = name;
6881 }
6882
6883 int
6884 bfd_elf_get_dyn_lib_class (bfd *abfd)
6885 {
6886   int lib_class;
6887   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6888       && bfd_get_format (abfd) == bfd_object)
6889     lib_class = elf_dyn_lib_class (abfd);
6890   else
6891     lib_class = 0;
6892   return lib_class;
6893 }
6894
6895 void
6896 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6897 {
6898   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6899       && bfd_get_format (abfd) == bfd_object)
6900     elf_dyn_lib_class (abfd) = lib_class;
6901 }
6902
6903 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
6904    the linker ELF emulation code.  */
6905
6906 struct bfd_link_needed_list *
6907 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6908                          struct bfd_link_info *info)
6909 {
6910   if (! is_elf_hash_table (info->hash))
6911     return NULL;
6912   return elf_hash_table (info)->needed;
6913 }
6914
6915 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
6916    hook for the linker ELF emulation code.  */
6917
6918 struct bfd_link_needed_list *
6919 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6920                           struct bfd_link_info *info)
6921 {
6922   if (! is_elf_hash_table (info->hash))
6923     return NULL;
6924   return elf_hash_table (info)->runpath;
6925 }
6926
6927 /* Get the name actually used for a dynamic object for a link.  This
6928    is the SONAME entry if there is one.  Otherwise, it is the string
6929    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
6930
6931 const char *
6932 bfd_elf_get_dt_soname (bfd *abfd)
6933 {
6934   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6935       && bfd_get_format (abfd) == bfd_object)
6936     return elf_dt_name (abfd);
6937   return NULL;
6938 }
6939
6940 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
6941    the ELF linker emulation code.  */
6942
6943 bfd_boolean
6944 bfd_elf_get_bfd_needed_list (bfd *abfd,
6945                              struct bfd_link_needed_list **pneeded)
6946 {
6947   asection *s;
6948   bfd_byte *dynbuf = NULL;
6949   unsigned int elfsec;
6950   unsigned long shlink;
6951   bfd_byte *extdyn, *extdynend;
6952   size_t extdynsize;
6953   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6954
6955   *pneeded = NULL;
6956
6957   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6958       || bfd_get_format (abfd) != bfd_object)
6959     return TRUE;
6960
6961   s = bfd_get_section_by_name (abfd, ".dynamic");
6962   if (s == NULL || s->size == 0)
6963     return TRUE;
6964
6965   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6966     goto error_return;
6967
6968   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
6969   if (elfsec == SHN_BAD)
6970     goto error_return;
6971
6972   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
6973
6974   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6975   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6976
6977   extdyn = dynbuf;
6978   extdynend = extdyn + s->size;
6979   for (; extdyn < extdynend; extdyn += extdynsize)
6980     {
6981       Elf_Internal_Dyn dyn;
6982
6983       (*swap_dyn_in) (abfd, extdyn, &dyn);
6984
6985       if (dyn.d_tag == DT_NULL)
6986         break;
6987
6988       if (dyn.d_tag == DT_NEEDED)
6989         {
6990           const char *string;
6991           struct bfd_link_needed_list *l;
6992           unsigned int tagv = dyn.d_un.d_val;
6993           bfd_size_type amt;
6994
6995           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
6996           if (string == NULL)
6997             goto error_return;
6998
6999           amt = sizeof *l;
7000           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7001           if (l == NULL)
7002             goto error_return;
7003
7004           l->by = abfd;
7005           l->name = string;
7006           l->next = *pneeded;
7007           *pneeded = l;
7008         }
7009     }
7010
7011   free (dynbuf);
7012
7013   return TRUE;
7014
7015  error_return:
7016   if (dynbuf != NULL)
7017     free (dynbuf);
7018   return FALSE;
7019 }
7020
7021 struct elf_symbuf_symbol
7022 {
7023   unsigned long st_name;        /* Symbol name, index in string tbl */
7024   unsigned char st_info;        /* Type and binding attributes */
7025   unsigned char st_other;       /* Visibilty, and target specific */
7026 };
7027
7028 struct elf_symbuf_head
7029 {
7030   struct elf_symbuf_symbol *ssym;
7031   bfd_size_type count;
7032   unsigned int st_shndx;
7033 };
7034
7035 struct elf_symbol
7036 {
7037   union
7038     {
7039       Elf_Internal_Sym *isym;
7040       struct elf_symbuf_symbol *ssym;
7041     } u;
7042   const char *name;
7043 };
7044
7045 /* Sort references to symbols by ascending section number.  */
7046
7047 static int
7048 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7049 {
7050   const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7051   const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7052
7053   return s1->st_shndx - s2->st_shndx;
7054 }
7055
7056 static int
7057 elf_sym_name_compare (const void *arg1, const void *arg2)
7058 {
7059   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7060   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7061   return strcmp (s1->name, s2->name);
7062 }
7063
7064 static struct elf_symbuf_head *
7065 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7066 {
7067   Elf_Internal_Sym **ind, **indbufend, **indbuf;
7068   struct elf_symbuf_symbol *ssym;
7069   struct elf_symbuf_head *ssymbuf, *ssymhead;
7070   bfd_size_type i, shndx_count, total_size;
7071
7072   indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7073   if (indbuf == NULL)
7074     return NULL;
7075
7076   for (ind = indbuf, i = 0; i < symcount; i++)
7077     if (isymbuf[i].st_shndx != SHN_UNDEF)
7078       *ind++ = &isymbuf[i];
7079   indbufend = ind;
7080
7081   qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7082          elf_sort_elf_symbol);
7083
7084   shndx_count = 0;
7085   if (indbufend > indbuf)
7086     for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7087       if (ind[0]->st_shndx != ind[1]->st_shndx)
7088         shndx_count++;
7089
7090   total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7091                 + (indbufend - indbuf) * sizeof (*ssym));
7092   ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7093   if (ssymbuf == NULL)
7094     {
7095       free (indbuf);
7096       return NULL;
7097     }
7098
7099   ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7100   ssymbuf->ssym = NULL;
7101   ssymbuf->count = shndx_count;
7102   ssymbuf->st_shndx = 0;
7103   for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7104     {
7105       if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7106         {
7107           ssymhead++;
7108           ssymhead->ssym = ssym;
7109           ssymhead->count = 0;
7110           ssymhead->st_shndx = (*ind)->st_shndx;
7111         }
7112       ssym->st_name = (*ind)->st_name;
7113       ssym->st_info = (*ind)->st_info;
7114       ssym->st_other = (*ind)->st_other;
7115       ssymhead->count++;
7116     }
7117   BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7118               && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7119                   == total_size));
7120
7121   free (indbuf);
7122   return ssymbuf;
7123 }
7124
7125 /* Check if 2 sections define the same set of local and global
7126    symbols.  */
7127
7128 static bfd_boolean
7129 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7130                                    struct bfd_link_info *info)
7131 {
7132   bfd *bfd1, *bfd2;
7133   const struct elf_backend_data *bed1, *bed2;
7134   Elf_Internal_Shdr *hdr1, *hdr2;
7135   bfd_size_type symcount1, symcount2;
7136   Elf_Internal_Sym *isymbuf1, *isymbuf2;
7137   struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7138   Elf_Internal_Sym *isym, *isymend;
7139   struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7140   bfd_size_type count1, count2, i;
7141   unsigned int shndx1, shndx2;
7142   bfd_boolean result;
7143
7144   bfd1 = sec1->owner;
7145   bfd2 = sec2->owner;
7146
7147   /* Both sections have to be in ELF.  */
7148   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7149       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7150     return FALSE;
7151
7152   if (elf_section_type (sec1) != elf_section_type (sec2))
7153     return FALSE;
7154
7155   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7156   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7157   if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7158     return FALSE;
7159
7160   bed1 = get_elf_backend_data (bfd1);
7161   bed2 = get_elf_backend_data (bfd2);
7162   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7163   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7164   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7165   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7166
7167   if (symcount1 == 0 || symcount2 == 0)
7168     return FALSE;
7169
7170   result = FALSE;
7171   isymbuf1 = NULL;
7172   isymbuf2 = NULL;
7173   ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7174   ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7175
7176   if (ssymbuf1 == NULL)
7177     {
7178       isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7179                                        NULL, NULL, NULL);
7180       if (isymbuf1 == NULL)
7181         goto done;
7182
7183       if (!info->reduce_memory_overheads)
7184         elf_tdata (bfd1)->symbuf = ssymbuf1
7185           = elf_create_symbuf (symcount1, isymbuf1);
7186     }
7187
7188   if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7189     {
7190       isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7191                                        NULL, NULL, NULL);
7192       if (isymbuf2 == NULL)
7193         goto done;
7194
7195       if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7196         elf_tdata (bfd2)->symbuf = ssymbuf2
7197           = elf_create_symbuf (symcount2, isymbuf2);
7198     }
7199
7200   if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7201     {
7202       /* Optimized faster version.  */
7203       bfd_size_type lo, hi, mid;
7204       struct elf_symbol *symp;
7205       struct elf_symbuf_symbol *ssym, *ssymend;
7206
7207       lo = 0;
7208       hi = ssymbuf1->count;
7209       ssymbuf1++;
7210       count1 = 0;
7211       while (lo < hi)
7212         {
7213           mid = (lo + hi) / 2;
7214           if (shndx1 < ssymbuf1[mid].st_shndx)
7215             hi = mid;
7216           else if (shndx1 > ssymbuf1[mid].st_shndx)
7217             lo = mid + 1;
7218           else
7219             {
7220               count1 = ssymbuf1[mid].count;
7221               ssymbuf1 += mid;
7222               break;
7223             }
7224         }
7225
7226       lo = 0;
7227       hi = ssymbuf2->count;
7228       ssymbuf2++;
7229       count2 = 0;
7230       while (lo < hi)
7231         {
7232           mid = (lo + hi) / 2;
7233           if (shndx2 < ssymbuf2[mid].st_shndx)
7234             hi = mid;
7235           else if (shndx2 > ssymbuf2[mid].st_shndx)
7236             lo = mid + 1;
7237           else
7238             {
7239               count2 = ssymbuf2[mid].count;
7240               ssymbuf2 += mid;
7241               break;
7242             }
7243         }
7244
7245       if (count1 == 0 || count2 == 0 || count1 != count2)
7246         goto done;
7247
7248       symtable1 = (struct elf_symbol *)
7249           bfd_malloc (count1 * sizeof (struct elf_symbol));
7250       symtable2 = (struct elf_symbol *)
7251           bfd_malloc (count2 * sizeof (struct elf_symbol));
7252       if (symtable1 == NULL || symtable2 == NULL)
7253         goto done;
7254
7255       symp = symtable1;
7256       for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7257            ssym < ssymend; ssym++, symp++)
7258         {
7259           symp->u.ssym = ssym;
7260           symp->name = bfd_elf_string_from_elf_section (bfd1,
7261                                                         hdr1->sh_link,
7262                                                         ssym->st_name);
7263         }
7264
7265       symp = symtable2;
7266       for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7267            ssym < ssymend; ssym++, symp++)
7268         {
7269           symp->u.ssym = ssym;
7270           symp->name = bfd_elf_string_from_elf_section (bfd2,
7271                                                         hdr2->sh_link,
7272                                                         ssym->st_name);
7273         }
7274
7275       /* Sort symbol by name.  */
7276       qsort (symtable1, count1, sizeof (struct elf_symbol),
7277              elf_sym_name_compare);
7278       qsort (symtable2, count1, sizeof (struct elf_symbol),
7279              elf_sym_name_compare);
7280
7281       for (i = 0; i < count1; i++)
7282         /* Two symbols must have the same binding, type and name.  */
7283         if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7284             || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7285             || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7286           goto done;
7287
7288       result = TRUE;
7289       goto done;
7290     }
7291
7292   symtable1 = (struct elf_symbol *)
7293       bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7294   symtable2 = (struct elf_symbol *)
7295       bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7296   if (symtable1 == NULL || symtable2 == NULL)
7297     goto done;
7298
7299   /* Count definitions in the section.  */
7300   count1 = 0;
7301   for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7302     if (isym->st_shndx == shndx1)
7303       symtable1[count1++].u.isym = isym;
7304
7305   count2 = 0;
7306   for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7307     if (isym->st_shndx == shndx2)
7308       symtable2[count2++].u.isym = isym;
7309
7310   if (count1 == 0 || count2 == 0 || count1 != count2)
7311     goto done;
7312
7313   for (i = 0; i < count1; i++)
7314     symtable1[i].name
7315       = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7316                                          symtable1[i].u.isym->st_name);
7317
7318   for (i = 0; i < count2; i++)
7319     symtable2[i].name
7320       = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7321                                          symtable2[i].u.isym->st_name);
7322
7323   /* Sort symbol by name.  */
7324   qsort (symtable1, count1, sizeof (struct elf_symbol),
7325          elf_sym_name_compare);
7326   qsort (symtable2, count1, sizeof (struct elf_symbol),
7327          elf_sym_name_compare);
7328
7329   for (i = 0; i < count1; i++)
7330     /* Two symbols must have the same binding, type and name.  */
7331     if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7332         || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7333         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7334       goto done;
7335
7336   result = TRUE;
7337
7338 done:
7339   if (symtable1)
7340     free (symtable1);
7341   if (symtable2)
7342     free (symtable2);
7343   if (isymbuf1)
7344     free (isymbuf1);
7345   if (isymbuf2)
7346     free (isymbuf2);
7347
7348   return result;
7349 }
7350
7351 /* Return TRUE if 2 section types are compatible.  */
7352
7353 bfd_boolean
7354 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7355                                  bfd *bbfd, const asection *bsec)
7356 {
7357   if (asec == NULL
7358       || bsec == NULL
7359       || abfd->xvec->flavour != bfd_target_elf_flavour
7360       || bbfd->xvec->flavour != bfd_target_elf_flavour)
7361     return TRUE;
7362
7363   return elf_section_type (asec) == elf_section_type (bsec);
7364 }
7365 \f
7366 /* Final phase of ELF linker.  */
7367
7368 /* A structure we use to avoid passing large numbers of arguments.  */
7369
7370 struct elf_final_link_info
7371 {
7372   /* General link information.  */
7373   struct bfd_link_info *info;
7374   /* Output BFD.  */
7375   bfd *output_bfd;
7376   /* Symbol string table.  */
7377   struct bfd_strtab_hash *symstrtab;
7378   /* .dynsym section.  */
7379   asection *dynsym_sec;
7380   /* .hash section.  */
7381   asection *hash_sec;
7382   /* symbol version section (.gnu.version).  */
7383   asection *symver_sec;
7384   /* Buffer large enough to hold contents of any section.  */
7385   bfd_byte *contents;
7386   /* Buffer large enough to hold external relocs of any section.  */
7387   void *external_relocs;
7388   /* Buffer large enough to hold internal relocs of any section.  */
7389   Elf_Internal_Rela *internal_relocs;
7390   /* Buffer large enough to hold external local symbols of any input
7391      BFD.  */
7392   bfd_byte *external_syms;
7393   /* And a buffer for symbol section indices.  */
7394   Elf_External_Sym_Shndx *locsym_shndx;
7395   /* Buffer large enough to hold internal local symbols of any input
7396      BFD.  */
7397   Elf_Internal_Sym *internal_syms;
7398   /* Array large enough to hold a symbol index for each local symbol
7399      of any input BFD.  */
7400   long *indices;
7401   /* Array large enough to hold a section pointer for each local
7402      symbol of any input BFD.  */
7403   asection **sections;
7404   /* Buffer to hold swapped out symbols.  */
7405   bfd_byte *symbuf;
7406   /* And one for symbol section indices.  */
7407   Elf_External_Sym_Shndx *symshndxbuf;
7408   /* Number of swapped out symbols in buffer.  */
7409   size_t symbuf_count;
7410   /* Number of symbols which fit in symbuf.  */
7411   size_t symbuf_size;
7412   /* And same for symshndxbuf.  */
7413   size_t shndxbuf_size;
7414 };
7415
7416 /* This struct is used to pass information to elf_link_output_extsym.  */
7417
7418 struct elf_outext_info
7419 {
7420   bfd_boolean failed;
7421   bfd_boolean localsyms;
7422   struct elf_final_link_info *finfo;
7423 };
7424
7425
7426 /* Support for evaluating a complex relocation.
7427
7428    Complex relocations are generalized, self-describing relocations.  The
7429    implementation of them consists of two parts: complex symbols, and the
7430    relocations themselves.
7431
7432    The relocations are use a reserved elf-wide relocation type code (R_RELC
7433    external / BFD_RELOC_RELC internal) and an encoding of relocation field
7434    information (start bit, end bit, word width, etc) into the addend.  This
7435    information is extracted from CGEN-generated operand tables within gas.
7436
7437    Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7438    internal) representing prefix-notation expressions, including but not
7439    limited to those sorts of expressions normally encoded as addends in the
7440    addend field.  The symbol mangling format is:
7441
7442    <node> := <literal>
7443           |  <unary-operator> ':' <node>
7444           |  <binary-operator> ':' <node> ':' <node>
7445           ;
7446
7447    <literal> := 's' <digits=N> ':' <N character symbol name>
7448              |  'S' <digits=N> ':' <N character section name>
7449              |  '#' <hexdigits>
7450              ;
7451
7452    <binary-operator> := as in C
7453    <unary-operator> := as in C, plus "0-" for unambiguous negation.  */
7454
7455 static void
7456 set_symbol_value (bfd *bfd_with_globals,
7457                   Elf_Internal_Sym *isymbuf,
7458                   size_t locsymcount,
7459                   size_t symidx,
7460                   bfd_vma val)
7461 {
7462   struct elf_link_hash_entry **sym_hashes;
7463   struct elf_link_hash_entry *h;
7464   size_t extsymoff = locsymcount;
7465
7466   if (symidx < locsymcount)
7467     {
7468       Elf_Internal_Sym *sym;
7469
7470       sym = isymbuf + symidx;
7471       if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7472         {
7473           /* It is a local symbol: move it to the
7474              "absolute" section and give it a value.  */
7475           sym->st_shndx = SHN_ABS;
7476           sym->st_value = val;
7477           return;
7478         }
7479       BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7480       extsymoff = 0;
7481     }
7482
7483   /* It is a global symbol: set its link type
7484      to "defined" and give it a value.  */
7485
7486   sym_hashes = elf_sym_hashes (bfd_with_globals);
7487   h = sym_hashes [symidx - extsymoff];
7488   while (h->root.type == bfd_link_hash_indirect
7489          || h->root.type == bfd_link_hash_warning)
7490     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7491   h->root.type = bfd_link_hash_defined;
7492   h->root.u.def.value = val;
7493   h->root.u.def.section = bfd_abs_section_ptr;
7494 }
7495
7496 static bfd_boolean
7497 resolve_symbol (const char *name,
7498                 bfd *input_bfd,
7499                 struct elf_final_link_info *finfo,
7500                 bfd_vma *result,
7501                 Elf_Internal_Sym *isymbuf,
7502                 size_t locsymcount)
7503 {
7504   Elf_Internal_Sym *sym;
7505   struct bfd_link_hash_entry *global_entry;
7506   const char *candidate = NULL;
7507   Elf_Internal_Shdr *symtab_hdr;
7508   size_t i;
7509
7510   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7511
7512   for (i = 0; i < locsymcount; ++ i)
7513     {
7514       sym = isymbuf + i;
7515
7516       if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7517         continue;
7518
7519       candidate = bfd_elf_string_from_elf_section (input_bfd,
7520                                                    symtab_hdr->sh_link,
7521                                                    sym->st_name);
7522 #ifdef DEBUG
7523       printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7524               name, candidate, (unsigned long) sym->st_value);
7525 #endif
7526       if (candidate && strcmp (candidate, name) == 0)
7527         {
7528           asection *sec = finfo->sections [i];
7529
7530           *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7531           *result += sec->output_offset + sec->output_section->vma;
7532 #ifdef DEBUG
7533           printf ("Found symbol with value %8.8lx\n",
7534                   (unsigned long) *result);
7535 #endif
7536           return TRUE;
7537         }
7538     }
7539
7540   /* Hmm, haven't found it yet. perhaps it is a global.  */
7541   global_entry = bfd_link_hash_lookup (finfo->info->hash, name,
7542                                        FALSE, FALSE, TRUE);
7543   if (!global_entry)
7544     return FALSE;
7545
7546   if (global_entry->type == bfd_link_hash_defined
7547       || global_entry->type == bfd_link_hash_defweak)
7548     {
7549       *result = (global_entry->u.def.value
7550                  + global_entry->u.def.section->output_section->vma
7551                  + global_entry->u.def.section->output_offset);
7552 #ifdef DEBUG
7553       printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7554               global_entry->root.string, (unsigned long) *result);
7555 #endif
7556       return TRUE;
7557     }
7558
7559   return FALSE;
7560 }
7561
7562 static bfd_boolean
7563 resolve_section (const char *name,
7564                  asection *sections,
7565                  bfd_vma *result)
7566 {
7567   asection *curr;
7568   unsigned int len;
7569
7570   for (curr = sections; curr; curr = curr->next)
7571     if (strcmp (curr->name, name) == 0)
7572       {
7573         *result = curr->vma;
7574         return TRUE;
7575       }
7576
7577   /* Hmm. still haven't found it. try pseudo-section names.  */
7578   for (curr = sections; curr; curr = curr->next)
7579     {
7580       len = strlen (curr->name);
7581       if (len > strlen (name))
7582         continue;
7583
7584       if (strncmp (curr->name, name, len) == 0)
7585         {
7586           if (strncmp (".end", name + len, 4) == 0)
7587             {
7588               *result = curr->vma + curr->size;
7589               return TRUE;
7590             }
7591
7592           /* Insert more pseudo-section names here, if you like.  */
7593         }
7594     }
7595
7596   return FALSE;
7597 }
7598
7599 static void
7600 undefined_reference (const char *reftype, const char *name)
7601 {
7602   _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7603                       reftype, name);
7604 }
7605
7606 static bfd_boolean
7607 eval_symbol (bfd_vma *result,
7608              const char **symp,
7609              bfd *input_bfd,
7610              struct elf_final_link_info *finfo,
7611              bfd_vma dot,
7612              Elf_Internal_Sym *isymbuf,
7613              size_t locsymcount,
7614              int signed_p)
7615 {
7616   size_t len;
7617   size_t symlen;
7618   bfd_vma a;
7619   bfd_vma b;
7620   char symbuf[4096];
7621   const char *sym = *symp;
7622   const char *symend;
7623   bfd_boolean symbol_is_section = FALSE;
7624
7625   len = strlen (sym);
7626   symend = sym + len;
7627
7628   if (len < 1 || len > sizeof (symbuf))
7629     {
7630       bfd_set_error (bfd_error_invalid_operation);
7631       return FALSE;
7632     }
7633
7634   switch (* sym)
7635     {
7636     case '.':
7637       *result = dot;
7638       *symp = sym + 1;
7639       return TRUE;
7640
7641     case '#':
7642       ++sym;
7643       *result = strtoul (sym, (char **) symp, 16);
7644       return TRUE;
7645
7646     case 'S':
7647       symbol_is_section = TRUE;
7648     case 's':
7649       ++sym;
7650       symlen = strtol (sym, (char **) symp, 10);
7651       sym = *symp + 1; /* Skip the trailing ':'.  */
7652
7653       if (symend < sym || symlen + 1 > sizeof (symbuf))
7654         {
7655           bfd_set_error (bfd_error_invalid_operation);
7656           return FALSE;
7657         }
7658
7659       memcpy (symbuf, sym, symlen);
7660       symbuf[symlen] = '\0';
7661       *symp = sym + symlen;
7662
7663       /* Is it always possible, with complex symbols, that gas "mis-guessed"
7664          the symbol as a section, or vice-versa. so we're pretty liberal in our
7665          interpretation here; section means "try section first", not "must be a
7666          section", and likewise with symbol.  */
7667
7668       if (symbol_is_section)
7669         {
7670           if (!resolve_section (symbuf, finfo->output_bfd->sections, result)
7671               && !resolve_symbol (symbuf, input_bfd, finfo, result,
7672                                   isymbuf, locsymcount))
7673             {
7674               undefined_reference ("section", symbuf);
7675               return FALSE;
7676             }
7677         }
7678       else
7679         {
7680           if (!resolve_symbol (symbuf, input_bfd, finfo, result,
7681                                isymbuf, locsymcount)
7682               && !resolve_section (symbuf, finfo->output_bfd->sections,
7683                                    result))
7684             {
7685               undefined_reference ("symbol", symbuf);
7686               return FALSE;
7687             }
7688         }
7689
7690       return TRUE;
7691
7692       /* All that remains are operators.  */
7693
7694 #define UNARY_OP(op)                                            \
7695   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7696     {                                                           \
7697       sym += strlen (#op);                                      \
7698       if (*sym == ':')                                          \
7699         ++sym;                                                  \
7700       *symp = sym;                                              \
7701       if (!eval_symbol (&a, symp, input_bfd, finfo, dot,        \
7702                         isymbuf, locsymcount, signed_p))        \
7703         return FALSE;                                           \
7704       if (signed_p)                                             \
7705         *result = op ((bfd_signed_vma) a);                      \
7706       else                                                      \
7707         *result = op a;                                         \
7708       return TRUE;                                              \
7709     }
7710
7711 #define BINARY_OP(op)                                           \
7712   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7713     {                                                           \
7714       sym += strlen (#op);                                      \
7715       if (*sym == ':')                                          \
7716         ++sym;                                                  \
7717       *symp = sym;                                              \
7718       if (!eval_symbol (&a, symp, input_bfd, finfo, dot,        \
7719                         isymbuf, locsymcount, signed_p))        \
7720         return FALSE;                                           \
7721       ++*symp;                                                  \
7722       if (!eval_symbol (&b, symp, input_bfd, finfo, dot,        \
7723                         isymbuf, locsymcount, signed_p))        \
7724         return FALSE;                                           \
7725       if (signed_p)                                             \
7726         *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7727       else                                                      \
7728         *result = a op b;                                       \
7729       return TRUE;                                              \
7730     }
7731
7732     default:
7733       UNARY_OP  (0-);
7734       BINARY_OP (<<);
7735       BINARY_OP (>>);
7736       BINARY_OP (==);
7737       BINARY_OP (!=);
7738       BINARY_OP (<=);
7739       BINARY_OP (>=);
7740       BINARY_OP (&&);
7741       BINARY_OP (||);
7742       UNARY_OP  (~);
7743       UNARY_OP  (!);
7744       BINARY_OP (*);
7745       BINARY_OP (/);
7746       BINARY_OP (%);
7747       BINARY_OP (^);
7748       BINARY_OP (|);
7749       BINARY_OP (&);
7750       BINARY_OP (+);
7751       BINARY_OP (-);
7752       BINARY_OP (<);
7753       BINARY_OP (>);
7754 #undef UNARY_OP
7755 #undef BINARY_OP
7756       _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7757       bfd_set_error (bfd_error_invalid_operation);
7758       return FALSE;
7759     }
7760 }
7761
7762 static void
7763 put_value (bfd_vma size,
7764            unsigned long chunksz,
7765            bfd *input_bfd,
7766            bfd_vma x,
7767            bfd_byte *location)
7768 {
7769   location += (size - chunksz);
7770
7771   for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7772     {
7773       switch (chunksz)
7774         {
7775         default:
7776         case 0:
7777           abort ();
7778         case 1:
7779           bfd_put_8 (input_bfd, x, location);
7780           break;
7781         case 2:
7782           bfd_put_16 (input_bfd, x, location);
7783           break;
7784         case 4:
7785           bfd_put_32 (input_bfd, x, location);
7786           break;
7787         case 8:
7788 #ifdef BFD64
7789           bfd_put_64 (input_bfd, x, location);
7790 #else
7791           abort ();
7792 #endif
7793           break;
7794         }
7795     }
7796 }
7797
7798 static bfd_vma
7799 get_value (bfd_vma size,
7800            unsigned long chunksz,
7801            bfd *input_bfd,
7802            bfd_byte *location)
7803 {
7804   bfd_vma x = 0;
7805
7806   for (; size; size -= chunksz, location += chunksz)
7807     {
7808       switch (chunksz)
7809         {
7810         default:
7811         case 0:
7812           abort ();
7813         case 1:
7814           x = (x << (8 * chunksz)) | bfd_get_8 (input_bfd, location);
7815           break;
7816         case 2:
7817           x = (x << (8 * chunksz)) | bfd_get_16 (input_bfd, location);
7818           break;
7819         case 4:
7820           x = (x << (8 * chunksz)) | bfd_get_32 (input_bfd, location);
7821           break;
7822         case 8:
7823 #ifdef BFD64
7824           x = (x << (8 * chunksz)) | bfd_get_64 (input_bfd, location);
7825 #else
7826           abort ();
7827 #endif
7828           break;
7829         }
7830     }
7831   return x;
7832 }
7833
7834 static void
7835 decode_complex_addend (unsigned long *start,   /* in bits */
7836                        unsigned long *oplen,   /* in bits */
7837                        unsigned long *len,     /* in bits */
7838                        unsigned long *wordsz,  /* in bytes */
7839                        unsigned long *chunksz, /* in bytes */
7840                        unsigned long *lsb0_p,
7841                        unsigned long *signed_p,
7842                        unsigned long *trunc_p,
7843                        unsigned long encoded)
7844 {
7845   * start     =  encoded        & 0x3F;
7846   * len       = (encoded >>  6) & 0x3F;
7847   * oplen     = (encoded >> 12) & 0x3F;
7848   * wordsz    = (encoded >> 18) & 0xF;
7849   * chunksz   = (encoded >> 22) & 0xF;
7850   * lsb0_p    = (encoded >> 27) & 1;
7851   * signed_p  = (encoded >> 28) & 1;
7852   * trunc_p   = (encoded >> 29) & 1;
7853 }
7854
7855 bfd_reloc_status_type
7856 bfd_elf_perform_complex_relocation (bfd *input_bfd,
7857                                     asection *input_section ATTRIBUTE_UNUSED,
7858                                     bfd_byte *contents,
7859                                     Elf_Internal_Rela *rel,
7860                                     bfd_vma relocation)
7861 {
7862   bfd_vma shift, x, mask;
7863   unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7864   bfd_reloc_status_type r;
7865
7866   /*  Perform this reloc, since it is complex.
7867       (this is not to say that it necessarily refers to a complex
7868       symbol; merely that it is a self-describing CGEN based reloc.
7869       i.e. the addend has the complete reloc information (bit start, end,
7870       word size, etc) encoded within it.).  */
7871
7872   decode_complex_addend (&start, &oplen, &len, &wordsz,
7873                          &chunksz, &lsb0_p, &signed_p,
7874                          &trunc_p, rel->r_addend);
7875
7876   mask = (((1L << (len - 1)) - 1) << 1) | 1;
7877
7878   if (lsb0_p)
7879     shift = (start + 1) - len;
7880   else
7881     shift = (8 * wordsz) - (start + len);
7882
7883   /* FIXME: octets_per_byte.  */
7884   x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7885
7886 #ifdef DEBUG
7887   printf ("Doing complex reloc: "
7888           "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7889           "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7890           "    dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7891           lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7892           oplen, (unsigned long) x, (unsigned long) mask,
7893           (unsigned long) relocation);
7894 #endif
7895
7896   r = bfd_reloc_ok;
7897   if (! trunc_p)
7898     /* Now do an overflow check.  */
7899     r = bfd_check_overflow ((signed_p
7900                              ? complain_overflow_signed
7901                              : complain_overflow_unsigned),
7902                             len, 0, (8 * wordsz),
7903                             relocation);
7904
7905   /* Do the deed.  */
7906   x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7907
7908 #ifdef DEBUG
7909   printf ("           relocation: %8.8lx\n"
7910           "         shifted mask: %8.8lx\n"
7911           " shifted/masked reloc: %8.8lx\n"
7912           "               result: %8.8lx\n",
7913           (unsigned long) relocation, (unsigned long) (mask << shift),
7914           (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
7915 #endif
7916   /* FIXME: octets_per_byte.  */
7917   put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7918   return r;
7919 }
7920
7921 /* When performing a relocatable link, the input relocations are
7922    preserved.  But, if they reference global symbols, the indices
7923    referenced must be updated.  Update all the relocations found in
7924    RELDATA.  */
7925
7926 static void
7927 elf_link_adjust_relocs (bfd *abfd,
7928                         struct bfd_elf_section_reloc_data *reldata)
7929 {
7930   unsigned int i;
7931   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7932   bfd_byte *erela;
7933   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7934   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7935   bfd_vma r_type_mask;
7936   int r_sym_shift;
7937   unsigned int count = reldata->count;
7938   struct elf_link_hash_entry **rel_hash = reldata->hashes;
7939
7940   if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
7941     {
7942       swap_in = bed->s->swap_reloc_in;
7943       swap_out = bed->s->swap_reloc_out;
7944     }
7945   else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
7946     {
7947       swap_in = bed->s->swap_reloca_in;
7948       swap_out = bed->s->swap_reloca_out;
7949     }
7950   else
7951     abort ();
7952
7953   if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
7954     abort ();
7955
7956   if (bed->s->arch_size == 32)
7957     {
7958       r_type_mask = 0xff;
7959       r_sym_shift = 8;
7960     }
7961   else
7962     {
7963       r_type_mask = 0xffffffff;
7964       r_sym_shift = 32;
7965     }
7966
7967   erela = reldata->hdr->contents;
7968   for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
7969     {
7970       Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
7971       unsigned int j;
7972
7973       if (*rel_hash == NULL)
7974         continue;
7975
7976       BFD_ASSERT ((*rel_hash)->indx >= 0);
7977
7978       (*swap_in) (abfd, erela, irela);
7979       for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
7980         irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
7981                            | (irela[j].r_info & r_type_mask));
7982       (*swap_out) (abfd, irela, erela);
7983     }
7984 }
7985
7986 struct elf_link_sort_rela
7987 {
7988   union {
7989     bfd_vma offset;
7990     bfd_vma sym_mask;
7991   } u;
7992   enum elf_reloc_type_class type;
7993   /* We use this as an array of size int_rels_per_ext_rel.  */
7994   Elf_Internal_Rela rela[1];
7995 };
7996
7997 static int
7998 elf_link_sort_cmp1 (const void *A, const void *B)
7999 {
8000   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8001   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8002   int relativea, relativeb;
8003
8004   relativea = a->type == reloc_class_relative;
8005   relativeb = b->type == reloc_class_relative;
8006
8007   if (relativea < relativeb)
8008     return 1;
8009   if (relativea > relativeb)
8010     return -1;
8011   if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8012     return -1;
8013   if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8014     return 1;
8015   if (a->rela->r_offset < b->rela->r_offset)
8016     return -1;
8017   if (a->rela->r_offset > b->rela->r_offset)
8018     return 1;
8019   return 0;
8020 }
8021
8022 static int
8023 elf_link_sort_cmp2 (const void *A, const void *B)
8024 {
8025   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8026   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8027   int copya, copyb;
8028
8029   if (a->u.offset < b->u.offset)
8030     return -1;
8031   if (a->u.offset > b->u.offset)
8032     return 1;
8033   copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
8034   copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
8035   if (copya < copyb)
8036     return -1;
8037   if (copya > copyb)
8038     return 1;
8039   if (a->rela->r_offset < b->rela->r_offset)
8040     return -1;
8041   if (a->rela->r_offset > b->rela->r_offset)
8042     return 1;
8043   return 0;
8044 }
8045
8046 static size_t
8047 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8048 {
8049   asection *dynamic_relocs;
8050   asection *rela_dyn;
8051   asection *rel_dyn;
8052   bfd_size_type count, size;
8053   size_t i, ret, sort_elt, ext_size;
8054   bfd_byte *sort, *s_non_relative, *p;
8055   struct elf_link_sort_rela *sq;
8056   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8057   int i2e = bed->s->int_rels_per_ext_rel;
8058   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8059   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8060   struct bfd_link_order *lo;
8061   bfd_vma r_sym_mask;
8062   bfd_boolean use_rela;
8063
8064   /* Find a dynamic reloc section.  */
8065   rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8066   rel_dyn  = bfd_get_section_by_name (abfd, ".rel.dyn");
8067   if (rela_dyn != NULL && rela_dyn->size > 0
8068       && rel_dyn != NULL && rel_dyn->size > 0)
8069     {
8070       bfd_boolean use_rela_initialised = FALSE;
8071
8072       /* This is just here to stop gcc from complaining.
8073          It's initialization checking code is not perfect.  */
8074       use_rela = TRUE;
8075
8076       /* Both sections are present.  Examine the sizes
8077          of the indirect sections to help us choose.  */
8078       for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8079         if (lo->type == bfd_indirect_link_order)
8080           {
8081             asection *o = lo->u.indirect.section;
8082
8083             if ((o->size % bed->s->sizeof_rela) == 0)
8084               {
8085                 if ((o->size % bed->s->sizeof_rel) == 0)
8086                   /* Section size is divisible by both rel and rela sizes.
8087                      It is of no help to us.  */
8088                   ;
8089                 else
8090                   {
8091                     /* Section size is only divisible by rela.  */
8092                     if (use_rela_initialised && (use_rela == FALSE))
8093                       {
8094                         _bfd_error_handler
8095                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8096                         bfd_set_error (bfd_error_invalid_operation);
8097                         return 0;
8098                       }
8099                     else
8100                       {
8101                         use_rela = TRUE;
8102                         use_rela_initialised = TRUE;
8103                       }
8104                   }
8105               }
8106             else if ((o->size % bed->s->sizeof_rel) == 0)
8107               {
8108                 /* Section size is only divisible by rel.  */
8109                 if (use_rela_initialised && (use_rela == TRUE))
8110                   {
8111                     _bfd_error_handler
8112                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8113                     bfd_set_error (bfd_error_invalid_operation);
8114                     return 0;
8115                   }
8116                 else
8117                   {
8118                     use_rela = FALSE;
8119                     use_rela_initialised = TRUE;
8120                   }
8121               }
8122             else
8123               {
8124                 /* The section size is not divisible by either - something is wrong.  */
8125                 _bfd_error_handler
8126                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8127                 bfd_set_error (bfd_error_invalid_operation);
8128                 return 0;
8129               }
8130           }
8131
8132       for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8133         if (lo->type == bfd_indirect_link_order)
8134           {
8135             asection *o = lo->u.indirect.section;
8136
8137             if ((o->size % bed->s->sizeof_rela) == 0)
8138               {
8139                 if ((o->size % bed->s->sizeof_rel) == 0)
8140                   /* Section size is divisible by both rel and rela sizes.
8141                      It is of no help to us.  */
8142                   ;
8143                 else
8144                   {
8145                     /* Section size is only divisible by rela.  */
8146                     if (use_rela_initialised && (use_rela == FALSE))
8147                       {
8148                         _bfd_error_handler
8149                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8150                         bfd_set_error (bfd_error_invalid_operation);
8151                         return 0;
8152                       }
8153                     else
8154                       {
8155                         use_rela = TRUE;
8156                         use_rela_initialised = TRUE;
8157                       }
8158                   }
8159               }
8160             else if ((o->size % bed->s->sizeof_rel) == 0)
8161               {
8162                 /* Section size is only divisible by rel.  */
8163                 if (use_rela_initialised && (use_rela == TRUE))
8164                   {
8165                     _bfd_error_handler
8166                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8167                     bfd_set_error (bfd_error_invalid_operation);
8168                     return 0;
8169                   }
8170                 else
8171                   {
8172                     use_rela = FALSE;
8173                     use_rela_initialised = TRUE;
8174                   }
8175               }
8176             else
8177               {
8178                 /* The section size is not divisible by either - something is wrong.  */
8179                 _bfd_error_handler
8180                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8181                 bfd_set_error (bfd_error_invalid_operation);
8182                 return 0;
8183               }
8184           }
8185
8186       if (! use_rela_initialised)
8187         /* Make a guess.  */
8188         use_rela = TRUE;
8189     }
8190   else if (rela_dyn != NULL && rela_dyn->size > 0)
8191     use_rela = TRUE;
8192   else if (rel_dyn != NULL && rel_dyn->size > 0)
8193     use_rela = FALSE;
8194   else
8195     return 0;
8196
8197   if (use_rela)
8198     {
8199       dynamic_relocs = rela_dyn;
8200       ext_size = bed->s->sizeof_rela;
8201       swap_in = bed->s->swap_reloca_in;
8202       swap_out = bed->s->swap_reloca_out;
8203     }
8204   else
8205     {
8206       dynamic_relocs = rel_dyn;
8207       ext_size = bed->s->sizeof_rel;
8208       swap_in = bed->s->swap_reloc_in;
8209       swap_out = bed->s->swap_reloc_out;
8210     }
8211
8212   size = 0;
8213   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8214     if (lo->type == bfd_indirect_link_order)
8215       size += lo->u.indirect.section->size;
8216
8217   if (size != dynamic_relocs->size)
8218     return 0;
8219
8220   sort_elt = (sizeof (struct elf_link_sort_rela)
8221               + (i2e - 1) * sizeof (Elf_Internal_Rela));
8222
8223   count = dynamic_relocs->size / ext_size;
8224   if (count == 0)
8225     return 0;
8226   sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8227
8228   if (sort == NULL)
8229     {
8230       (*info->callbacks->warning)
8231         (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8232       return 0;
8233     }
8234
8235   if (bed->s->arch_size == 32)
8236     r_sym_mask = ~(bfd_vma) 0xff;
8237   else
8238     r_sym_mask = ~(bfd_vma) 0xffffffff;
8239
8240   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8241     if (lo->type == bfd_indirect_link_order)
8242       {
8243         bfd_byte *erel, *erelend;
8244         asection *o = lo->u.indirect.section;
8245
8246         if (o->contents == NULL && o->size != 0)
8247           {
8248             /* This is a reloc section that is being handled as a normal
8249                section.  See bfd_section_from_shdr.  We can't combine
8250                relocs in this case.  */
8251             free (sort);
8252             return 0;
8253           }
8254         erel = o->contents;
8255         erelend = o->contents + o->size;
8256         /* FIXME: octets_per_byte.  */
8257         p = sort + o->output_offset / ext_size * sort_elt;
8258
8259         while (erel < erelend)
8260           {
8261             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8262
8263             (*swap_in) (abfd, erel, s->rela);
8264             s->type = (*bed->elf_backend_reloc_type_class) (s->rela);
8265             s->u.sym_mask = r_sym_mask;
8266             p += sort_elt;
8267             erel += ext_size;
8268           }
8269       }
8270
8271   qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8272
8273   for (i = 0, p = sort; i < count; i++, p += sort_elt)
8274     {
8275       struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8276       if (s->type != reloc_class_relative)
8277         break;
8278     }
8279   ret = i;
8280   s_non_relative = p;
8281
8282   sq = (struct elf_link_sort_rela *) s_non_relative;
8283   for (; i < count; i++, p += sort_elt)
8284     {
8285       struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8286       if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8287         sq = sp;
8288       sp->u.offset = sq->rela->r_offset;
8289     }
8290
8291   qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8292
8293   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8294     if (lo->type == bfd_indirect_link_order)
8295       {
8296         bfd_byte *erel, *erelend;
8297         asection *o = lo->u.indirect.section;
8298
8299         erel = o->contents;
8300         erelend = o->contents + o->size;
8301         /* FIXME: octets_per_byte.  */
8302         p = sort + o->output_offset / ext_size * sort_elt;
8303         while (erel < erelend)
8304           {
8305             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8306             (*swap_out) (abfd, s->rela, erel);
8307             p += sort_elt;
8308             erel += ext_size;
8309           }
8310       }
8311
8312   free (sort);
8313   *psec = dynamic_relocs;
8314   return ret;
8315 }
8316
8317 /* Flush the output symbols to the file.  */
8318
8319 static bfd_boolean
8320 elf_link_flush_output_syms (struct elf_final_link_info *finfo,
8321                             const struct elf_backend_data *bed)
8322 {
8323   if (finfo->symbuf_count > 0)
8324     {
8325       Elf_Internal_Shdr *hdr;
8326       file_ptr pos;
8327       bfd_size_type amt;
8328
8329       hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
8330       pos = hdr->sh_offset + hdr->sh_size;
8331       amt = finfo->symbuf_count * bed->s->sizeof_sym;
8332       if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
8333           || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt)
8334         return FALSE;
8335
8336       hdr->sh_size += amt;
8337       finfo->symbuf_count = 0;
8338     }
8339
8340   return TRUE;
8341 }
8342
8343 /* Add a symbol to the output symbol table.  */
8344
8345 static int
8346 elf_link_output_sym (struct elf_final_link_info *finfo,
8347                      const char *name,
8348                      Elf_Internal_Sym *elfsym,
8349                      asection *input_sec,
8350                      struct elf_link_hash_entry *h)
8351 {
8352   bfd_byte *dest;
8353   Elf_External_Sym_Shndx *destshndx;
8354   int (*output_symbol_hook)
8355     (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8356      struct elf_link_hash_entry *);
8357   const struct elf_backend_data *bed;
8358
8359   bed = get_elf_backend_data (finfo->output_bfd);
8360   output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8361   if (output_symbol_hook != NULL)
8362     {
8363       int ret = (*output_symbol_hook) (finfo->info, name, elfsym, input_sec, h);
8364       if (ret != 1)
8365         return ret;
8366     }
8367
8368   if (name == NULL || *name == '\0')
8369     elfsym->st_name = 0;
8370   else if (input_sec->flags & SEC_EXCLUDE)
8371     elfsym->st_name = 0;
8372   else
8373     {
8374       elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
8375                                                             name, TRUE, FALSE);
8376       if (elfsym->st_name == (unsigned long) -1)
8377         return 0;
8378     }
8379
8380   if (finfo->symbuf_count >= finfo->symbuf_size)
8381     {
8382       if (! elf_link_flush_output_syms (finfo, bed))
8383         return 0;
8384     }
8385
8386   dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym;
8387   destshndx = finfo->symshndxbuf;
8388   if (destshndx != NULL)
8389     {
8390       if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size)
8391         {
8392           bfd_size_type amt;
8393
8394           amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8395           destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8396                                                               amt * 2);
8397           if (destshndx == NULL)
8398             return 0;
8399           finfo->symshndxbuf = destshndx;
8400           memset ((char *) destshndx + amt, 0, amt);
8401           finfo->shndxbuf_size *= 2;
8402         }
8403       destshndx += bfd_get_symcount (finfo->output_bfd);
8404     }
8405
8406   bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
8407   finfo->symbuf_count += 1;
8408   bfd_get_symcount (finfo->output_bfd) += 1;
8409
8410   return 1;
8411 }
8412
8413 /* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
8414
8415 static bfd_boolean
8416 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8417 {
8418   if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8419       && sym->st_shndx < SHN_LORESERVE)
8420     {
8421       /* The gABI doesn't support dynamic symbols in output sections
8422          beyond 64k.  */
8423       (*_bfd_error_handler)
8424         (_("%B: Too many sections: %d (>= %d)"),
8425          abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8426       bfd_set_error (bfd_error_nonrepresentable_section);
8427       return FALSE;
8428     }
8429   return TRUE;
8430 }
8431
8432 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8433    allowing an unsatisfied unversioned symbol in the DSO to match a
8434    versioned symbol that would normally require an explicit version.
8435    We also handle the case that a DSO references a hidden symbol
8436    which may be satisfied by a versioned symbol in another DSO.  */
8437
8438 static bfd_boolean
8439 elf_link_check_versioned_symbol (struct bfd_link_info *info,
8440                                  const struct elf_backend_data *bed,
8441                                  struct elf_link_hash_entry *h)
8442 {
8443   bfd *abfd;
8444   struct elf_link_loaded_list *loaded;
8445
8446   if (!is_elf_hash_table (info->hash))
8447     return FALSE;
8448
8449   switch (h->root.type)
8450     {
8451     default:
8452       abfd = NULL;
8453       break;
8454
8455     case bfd_link_hash_undefined:
8456     case bfd_link_hash_undefweak:
8457       abfd = h->root.u.undef.abfd;
8458       if ((abfd->flags & DYNAMIC) == 0
8459           || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8460         return FALSE;
8461       break;
8462
8463     case bfd_link_hash_defined:
8464     case bfd_link_hash_defweak:
8465       abfd = h->root.u.def.section->owner;
8466       break;
8467
8468     case bfd_link_hash_common:
8469       abfd = h->root.u.c.p->section->owner;
8470       break;
8471     }
8472   BFD_ASSERT (abfd != NULL);
8473
8474   for (loaded = elf_hash_table (info)->loaded;
8475        loaded != NULL;
8476        loaded = loaded->next)
8477     {
8478       bfd *input;
8479       Elf_Internal_Shdr *hdr;
8480       bfd_size_type symcount;
8481       bfd_size_type extsymcount;
8482       bfd_size_type extsymoff;
8483       Elf_Internal_Shdr *versymhdr;
8484       Elf_Internal_Sym *isym;
8485       Elf_Internal_Sym *isymend;
8486       Elf_Internal_Sym *isymbuf;
8487       Elf_External_Versym *ever;
8488       Elf_External_Versym *extversym;
8489
8490       input = loaded->abfd;
8491
8492       /* We check each DSO for a possible hidden versioned definition.  */
8493       if (input == abfd
8494           || (input->flags & DYNAMIC) == 0
8495           || elf_dynversym (input) == 0)
8496         continue;
8497
8498       hdr = &elf_tdata (input)->dynsymtab_hdr;
8499
8500       symcount = hdr->sh_size / bed->s->sizeof_sym;
8501       if (elf_bad_symtab (input))
8502         {
8503           extsymcount = symcount;
8504           extsymoff = 0;
8505         }
8506       else
8507         {
8508           extsymcount = symcount - hdr->sh_info;
8509           extsymoff = hdr->sh_info;
8510         }
8511
8512       if (extsymcount == 0)
8513         continue;
8514
8515       isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8516                                       NULL, NULL, NULL);
8517       if (isymbuf == NULL)
8518         return FALSE;
8519
8520       /* Read in any version definitions.  */
8521       versymhdr = &elf_tdata (input)->dynversym_hdr;
8522       extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8523       if (extversym == NULL)
8524         goto error_ret;
8525
8526       if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8527           || (bfd_bread (extversym, versymhdr->sh_size, input)
8528               != versymhdr->sh_size))
8529         {
8530           free (extversym);
8531         error_ret:
8532           free (isymbuf);
8533           return FALSE;
8534         }
8535
8536       ever = extversym + extsymoff;
8537       isymend = isymbuf + extsymcount;
8538       for (isym = isymbuf; isym < isymend; isym++, ever++)
8539         {
8540           const char *name;
8541           Elf_Internal_Versym iver;
8542           unsigned short version_index;
8543
8544           if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8545               || isym->st_shndx == SHN_UNDEF)
8546             continue;
8547
8548           name = bfd_elf_string_from_elf_section (input,
8549                                                   hdr->sh_link,
8550                                                   isym->st_name);
8551           if (strcmp (name, h->root.root.string) != 0)
8552             continue;
8553
8554           _bfd_elf_swap_versym_in (input, ever, &iver);
8555
8556           if ((iver.vs_vers & VERSYM_HIDDEN) == 0
8557               && !(h->def_regular
8558                    && h->forced_local))
8559             {
8560               /* If we have a non-hidden versioned sym, then it should
8561                  have provided a definition for the undefined sym unless
8562                  it is defined in a non-shared object and forced local.
8563                */
8564               abort ();
8565             }
8566
8567           version_index = iver.vs_vers & VERSYM_VERSION;
8568           if (version_index == 1 || version_index == 2)
8569             {
8570               /* This is the base or first version.  We can use it.  */
8571               free (extversym);
8572               free (isymbuf);
8573               return TRUE;
8574             }
8575         }
8576
8577       free (extversym);
8578       free (isymbuf);
8579     }
8580
8581   return FALSE;
8582 }
8583
8584 /* Add an external symbol to the symbol table.  This is called from
8585    the hash table traversal routine.  When generating a shared object,
8586    we go through the symbol table twice.  The first time we output
8587    anything that might have been forced to local scope in a version
8588    script.  The second time we output the symbols that are still
8589    global symbols.  */
8590
8591 static bfd_boolean
8592 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
8593 {
8594   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
8595   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8596   struct elf_final_link_info *finfo = eoinfo->finfo;
8597   bfd_boolean strip;
8598   Elf_Internal_Sym sym;
8599   asection *input_sec;
8600   const struct elf_backend_data *bed;
8601   long indx;
8602   int ret;
8603
8604   if (h->root.type == bfd_link_hash_warning)
8605     {
8606       h = (struct elf_link_hash_entry *) h->root.u.i.link;
8607       if (h->root.type == bfd_link_hash_new)
8608         return TRUE;
8609     }
8610
8611   /* Decide whether to output this symbol in this pass.  */
8612   if (eoinfo->localsyms)
8613     {
8614       if (!h->forced_local)
8615         return TRUE;
8616     }
8617   else
8618     {
8619       if (h->forced_local)
8620         return TRUE;
8621     }
8622
8623   bed = get_elf_backend_data (finfo->output_bfd);
8624
8625   if (h->root.type == bfd_link_hash_undefined)
8626     {
8627       /* If we have an undefined symbol reference here then it must have
8628          come from a shared library that is being linked in.  (Undefined
8629          references in regular files have already been handled unless
8630          they are in unreferenced sections which are removed by garbage
8631          collection).  */
8632       bfd_boolean ignore_undef = FALSE;
8633
8634       /* Some symbols may be special in that the fact that they're
8635          undefined can be safely ignored - let backend determine that.  */
8636       if (bed->elf_backend_ignore_undef_symbol)
8637         ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8638
8639       /* If we are reporting errors for this situation then do so now.  */
8640       if (!ignore_undef
8641           && h->ref_dynamic
8642           && (!h->ref_regular || finfo->info->gc_sections)
8643           && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
8644           && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8645         {
8646           if (! (finfo->info->callbacks->undefined_symbol
8647                  (finfo->info, h->root.root.string,
8648                   h->ref_regular ? NULL : h->root.u.undef.abfd,
8649                   NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
8650             {
8651               bfd_set_error (bfd_error_bad_value);
8652               eoinfo->failed = TRUE;
8653               return FALSE;
8654             }
8655         }
8656     }
8657
8658   /* We should also warn if a forced local symbol is referenced from
8659      shared libraries.  */
8660   if (!finfo->info->relocatable
8661       && finfo->info->executable
8662       && h->forced_local
8663       && h->ref_dynamic
8664       && h->def_regular
8665       && !h->dynamic_def
8666       && !h->dynamic_weak
8667       && ! elf_link_check_versioned_symbol (finfo->info, bed, h))
8668     {
8669       bfd *def_bfd;
8670       const char *msg;
8671
8672       if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
8673         msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
8674       else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
8675         msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
8676       else
8677         msg = _("%B: local symbol `%s' in %B is referenced by DSO");
8678       def_bfd = finfo->output_bfd;
8679       if (h->root.u.def.section != bfd_abs_section_ptr)
8680         def_bfd = h->root.u.def.section->owner;
8681       (*_bfd_error_handler) (msg, finfo->output_bfd, def_bfd,
8682                              h->root.root.string);
8683       bfd_set_error (bfd_error_bad_value);
8684       eoinfo->failed = TRUE;
8685       return FALSE;
8686     }
8687
8688   /* We don't want to output symbols that have never been mentioned by
8689      a regular file, or that we have been told to strip.  However, if
8690      h->indx is set to -2, the symbol is used by a reloc and we must
8691      output it.  */
8692   if (h->indx == -2)
8693     strip = FALSE;
8694   else if ((h->def_dynamic
8695             || h->ref_dynamic
8696             || h->root.type == bfd_link_hash_new)
8697            && !h->def_regular
8698            && !h->ref_regular)
8699     strip = TRUE;
8700   else if (finfo->info->strip == strip_all)
8701     strip = TRUE;
8702   else if (finfo->info->strip == strip_some
8703            && bfd_hash_lookup (finfo->info->keep_hash,
8704                                h->root.root.string, FALSE, FALSE) == NULL)
8705     strip = TRUE;
8706   else if ((h->root.type == bfd_link_hash_defined
8707             || h->root.type == bfd_link_hash_defweak)
8708            && ((finfo->info->strip_discarded
8709                 && elf_discarded_section (h->root.u.def.section))
8710                || (h->root.u.def.section->owner != NULL
8711                    && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
8712     strip = TRUE;
8713   else if ((h->root.type == bfd_link_hash_undefined
8714             || h->root.type == bfd_link_hash_undefweak)
8715            && h->root.u.undef.abfd != NULL
8716            && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
8717     strip = TRUE;
8718   else
8719     strip = FALSE;
8720
8721   /* If we're stripping it, and it's not a dynamic symbol, there's
8722      nothing else to do unless it is a forced local symbol or a
8723      STT_GNU_IFUNC symbol.  */
8724   if (strip
8725       && h->dynindx == -1
8726       && h->type != STT_GNU_IFUNC
8727       && !h->forced_local)
8728     return TRUE;
8729
8730   sym.st_value = 0;
8731   sym.st_size = h->size;
8732   sym.st_other = h->other;
8733   if (h->forced_local)
8734     {
8735       sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8736       /* Turn off visibility on local symbol.  */
8737       sym.st_other &= ~ELF_ST_VISIBILITY (-1);
8738     }
8739   else if (h->unique_global)
8740     sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8741   else if (h->root.type == bfd_link_hash_undefweak
8742            || h->root.type == bfd_link_hash_defweak)
8743     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8744   else
8745     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8746   sym.st_target_internal = h->target_internal;
8747
8748   switch (h->root.type)
8749     {
8750     default:
8751     case bfd_link_hash_new:
8752     case bfd_link_hash_warning:
8753       abort ();
8754       return FALSE;
8755
8756     case bfd_link_hash_undefined:
8757     case bfd_link_hash_undefweak:
8758       input_sec = bfd_und_section_ptr;
8759       sym.st_shndx = SHN_UNDEF;
8760       break;
8761
8762     case bfd_link_hash_defined:
8763     case bfd_link_hash_defweak:
8764       {
8765         input_sec = h->root.u.def.section;
8766         if (input_sec->output_section != NULL)
8767           {
8768             sym.st_shndx =
8769               _bfd_elf_section_from_bfd_section (finfo->output_bfd,
8770                                                  input_sec->output_section);
8771             if (sym.st_shndx == SHN_BAD)
8772               {
8773                 (*_bfd_error_handler)
8774                   (_("%B: could not find output section %A for input section %A"),
8775                    finfo->output_bfd, input_sec->output_section, input_sec);
8776                 bfd_set_error (bfd_error_nonrepresentable_section);
8777                 eoinfo->failed = TRUE;
8778                 return FALSE;
8779               }
8780
8781             /* ELF symbols in relocatable files are section relative,
8782                but in nonrelocatable files they are virtual
8783                addresses.  */
8784             sym.st_value = h->root.u.def.value + input_sec->output_offset;
8785             if (! finfo->info->relocatable)
8786               {
8787                 sym.st_value += input_sec->output_section->vma;
8788                 if (h->type == STT_TLS)
8789                   {
8790                     asection *tls_sec = elf_hash_table (finfo->info)->tls_sec;
8791                     if (tls_sec != NULL)
8792                       sym.st_value -= tls_sec->vma;
8793                     else
8794                       {
8795                         /* The TLS section may have been garbage collected.  */
8796                         BFD_ASSERT (finfo->info->gc_sections
8797                                     && !input_sec->gc_mark);
8798                       }
8799                   }
8800               }
8801           }
8802         else
8803           {
8804             BFD_ASSERT (input_sec->owner == NULL
8805                         || (input_sec->owner->flags & DYNAMIC) != 0);
8806             sym.st_shndx = SHN_UNDEF;
8807             input_sec = bfd_und_section_ptr;
8808           }
8809       }
8810       break;
8811
8812     case bfd_link_hash_common:
8813       input_sec = h->root.u.c.p->section;
8814       sym.st_shndx = bed->common_section_index (input_sec);
8815       sym.st_value = 1 << h->root.u.c.p->alignment_power;
8816       break;
8817
8818     case bfd_link_hash_indirect:
8819       /* These symbols are created by symbol versioning.  They point
8820          to the decorated version of the name.  For example, if the
8821          symbol foo@@GNU_1.2 is the default, which should be used when
8822          foo is used with no version, then we add an indirect symbol
8823          foo which points to foo@@GNU_1.2.  We ignore these symbols,
8824          since the indirected symbol is already in the hash table.  */
8825       return TRUE;
8826     }
8827
8828   /* Give the processor backend a chance to tweak the symbol value,
8829      and also to finish up anything that needs to be done for this
8830      symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
8831      forced local syms when non-shared is due to a historical quirk.
8832      STT_GNU_IFUNC symbol must go through PLT.  */
8833   if ((h->type == STT_GNU_IFUNC
8834        && h->def_regular
8835        && !finfo->info->relocatable)
8836       || ((h->dynindx != -1
8837            || h->forced_local)
8838           && ((finfo->info->shared
8839                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8840                    || h->root.type != bfd_link_hash_undefweak))
8841               || !h->forced_local)
8842           && elf_hash_table (finfo->info)->dynamic_sections_created))
8843     {
8844       if (! ((*bed->elf_backend_finish_dynamic_symbol)
8845              (finfo->output_bfd, finfo->info, h, &sym)))
8846         {
8847           eoinfo->failed = TRUE;
8848           return FALSE;
8849         }
8850     }
8851
8852   /* If we are marking the symbol as undefined, and there are no
8853      non-weak references to this symbol from a regular object, then
8854      mark the symbol as weak undefined; if there are non-weak
8855      references, mark the symbol as strong.  We can't do this earlier,
8856      because it might not be marked as undefined until the
8857      finish_dynamic_symbol routine gets through with it.  */
8858   if (sym.st_shndx == SHN_UNDEF
8859       && h->ref_regular
8860       && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
8861           || ELF_ST_BIND (sym.st_info) == STB_WEAK))
8862     {
8863       int bindtype;
8864       unsigned int type = ELF_ST_TYPE (sym.st_info);
8865
8866       /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8867       if (type == STT_GNU_IFUNC)
8868         type = STT_FUNC;
8869
8870       if (h->ref_regular_nonweak)
8871         bindtype = STB_GLOBAL;
8872       else
8873         bindtype = STB_WEAK;
8874       sym.st_info = ELF_ST_INFO (bindtype, type);
8875     }
8876
8877   /* If this is a symbol defined in a dynamic library, don't use the
8878      symbol size from the dynamic library.  Relinking an executable
8879      against a new library may introduce gratuitous changes in the
8880      executable's symbols if we keep the size.  */
8881   if (sym.st_shndx == SHN_UNDEF
8882       && !h->def_regular
8883       && h->def_dynamic)
8884     sym.st_size = 0;
8885
8886   /* If a non-weak symbol with non-default visibility is not defined
8887      locally, it is a fatal error.  */
8888   if (! finfo->info->relocatable
8889       && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
8890       && ELF_ST_BIND (sym.st_info) != STB_WEAK
8891       && h->root.type == bfd_link_hash_undefined
8892       && !h->def_regular)
8893     {
8894       const char *msg;
8895
8896       if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
8897         msg = _("%B: protected symbol `%s' isn't defined");
8898       else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
8899         msg = _("%B: internal symbol `%s' isn't defined");
8900       else
8901         msg = _("%B: hidden symbol `%s' isn't defined");
8902       (*_bfd_error_handler) (msg, finfo->output_bfd, h->root.root.string);
8903       bfd_set_error (bfd_error_bad_value);
8904       eoinfo->failed = TRUE;
8905       return FALSE;
8906     }
8907
8908   /* If this symbol should be put in the .dynsym section, then put it
8909      there now.  We already know the symbol index.  We also fill in
8910      the entry in the .hash section.  */
8911   if (finfo->dynsym_sec != NULL
8912       && h->dynindx != -1
8913       && elf_hash_table (finfo->info)->dynamic_sections_created)
8914     {
8915       bfd_byte *esym;
8916
8917       sym.st_name = h->dynstr_index;
8918       esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
8919       if (! check_dynsym (finfo->output_bfd, &sym))
8920         {
8921           eoinfo->failed = TRUE;
8922           return FALSE;
8923         }
8924       bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
8925
8926       if (finfo->hash_sec != NULL)
8927         {
8928           size_t hash_entry_size;
8929           bfd_byte *bucketpos;
8930           bfd_vma chain;
8931           size_t bucketcount;
8932           size_t bucket;
8933
8934           bucketcount = elf_hash_table (finfo->info)->bucketcount;
8935           bucket = h->u.elf_hash_value % bucketcount;
8936
8937           hash_entry_size
8938             = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
8939           bucketpos = ((bfd_byte *) finfo->hash_sec->contents
8940                        + (bucket + 2) * hash_entry_size);
8941           chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
8942           bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
8943           bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
8944                    ((bfd_byte *) finfo->hash_sec->contents
8945                     + (bucketcount + 2 + h->dynindx) * hash_entry_size));
8946         }
8947
8948       if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
8949         {
8950           Elf_Internal_Versym iversym;
8951           Elf_External_Versym *eversym;
8952
8953           if (!h->def_regular)
8954             {
8955               if (h->verinfo.verdef == NULL)
8956                 iversym.vs_vers = 0;
8957               else
8958                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
8959             }
8960           else
8961             {
8962               if (h->verinfo.vertree == NULL)
8963                 iversym.vs_vers = 1;
8964               else
8965                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
8966               if (finfo->info->create_default_symver)
8967                 iversym.vs_vers++;
8968             }
8969
8970           if (h->hidden)
8971             iversym.vs_vers |= VERSYM_HIDDEN;
8972
8973           eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
8974           eversym += h->dynindx;
8975           _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
8976         }
8977     }
8978
8979   /* If we're stripping it, then it was just a dynamic symbol, and
8980      there's nothing else to do.  */
8981   if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
8982     return TRUE;
8983
8984   indx = bfd_get_symcount (finfo->output_bfd);
8985   ret = elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec, h);
8986   if (ret == 0)
8987     {
8988       eoinfo->failed = TRUE;
8989       return FALSE;
8990     }
8991   else if (ret == 1)
8992     h->indx = indx;
8993   else if (h->indx == -2)
8994     abort();
8995
8996   return TRUE;
8997 }
8998
8999 /* Return TRUE if special handling is done for relocs in SEC against
9000    symbols defined in discarded sections.  */
9001
9002 static bfd_boolean
9003 elf_section_ignore_discarded_relocs (asection *sec)
9004 {
9005   const struct elf_backend_data *bed;
9006
9007   switch (sec->sec_info_type)
9008     {
9009     case ELF_INFO_TYPE_STABS:
9010     case ELF_INFO_TYPE_EH_FRAME:
9011       return TRUE;
9012     default:
9013       break;
9014     }
9015
9016   bed = get_elf_backend_data (sec->owner);
9017   if (bed->elf_backend_ignore_discarded_relocs != NULL
9018       && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9019     return TRUE;
9020
9021   return FALSE;
9022 }
9023
9024 /* Return a mask saying how ld should treat relocations in SEC against
9025    symbols defined in discarded sections.  If this function returns
9026    COMPLAIN set, ld will issue a warning message.  If this function
9027    returns PRETEND set, and the discarded section was link-once and the
9028    same size as the kept link-once section, ld will pretend that the
9029    symbol was actually defined in the kept section.  Otherwise ld will
9030    zero the reloc (at least that is the intent, but some cooperation by
9031    the target dependent code is needed, particularly for REL targets).  */
9032
9033 unsigned int
9034 _bfd_elf_default_action_discarded (asection *sec)
9035 {
9036   if (sec->flags & SEC_DEBUGGING)
9037     return PRETEND;
9038
9039   if (strcmp (".eh_frame", sec->name) == 0)
9040     return 0;
9041
9042   if (strcmp (".gcc_except_table", sec->name) == 0)
9043     return 0;
9044
9045   return COMPLAIN | PRETEND;
9046 }
9047
9048 /* Find a match between a section and a member of a section group.  */
9049
9050 static asection *
9051 match_group_member (asection *sec, asection *group,
9052                     struct bfd_link_info *info)
9053 {
9054   asection *first = elf_next_in_group (group);
9055   asection *s = first;
9056
9057   while (s != NULL)
9058     {
9059       if (bfd_elf_match_symbols_in_sections (s, sec, info))
9060         return s;
9061
9062       s = elf_next_in_group (s);
9063       if (s == first)
9064         break;
9065     }
9066
9067   return NULL;
9068 }
9069
9070 /* Check if the kept section of a discarded section SEC can be used
9071    to replace it.  Return the replacement if it is OK.  Otherwise return
9072    NULL.  */
9073
9074 asection *
9075 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9076 {
9077   asection *kept;
9078
9079   kept = sec->kept_section;
9080   if (kept != NULL)
9081     {
9082       if ((kept->flags & SEC_GROUP) != 0)
9083         kept = match_group_member (sec, kept, info);
9084       if (kept != NULL
9085           && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9086               != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9087         kept = NULL;
9088       sec->kept_section = kept;
9089     }
9090   return kept;
9091 }
9092
9093 /* Link an input file into the linker output file.  This function
9094    handles all the sections and relocations of the input file at once.
9095    This is so that we only have to read the local symbols once, and
9096    don't have to keep them in memory.  */
9097
9098 static bfd_boolean
9099 elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
9100 {
9101   int (*relocate_section)
9102     (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9103      Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9104   bfd *output_bfd;
9105   Elf_Internal_Shdr *symtab_hdr;
9106   size_t locsymcount;
9107   size_t extsymoff;
9108   Elf_Internal_Sym *isymbuf;
9109   Elf_Internal_Sym *isym;
9110   Elf_Internal_Sym *isymend;
9111   long *pindex;
9112   asection **ppsection;
9113   asection *o;
9114   const struct elf_backend_data *bed;
9115   struct elf_link_hash_entry **sym_hashes;
9116   bfd_size_type address_size;
9117   bfd_vma r_type_mask;
9118   int r_sym_shift;
9119
9120   output_bfd = finfo->output_bfd;
9121   bed = get_elf_backend_data (output_bfd);
9122   relocate_section = bed->elf_backend_relocate_section;
9123
9124   /* If this is a dynamic object, we don't want to do anything here:
9125      we don't want the local symbols, and we don't want the section
9126      contents.  */
9127   if ((input_bfd->flags & DYNAMIC) != 0)
9128     return TRUE;
9129
9130   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9131   if (elf_bad_symtab (input_bfd))
9132     {
9133       locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9134       extsymoff = 0;
9135     }
9136   else
9137     {
9138       locsymcount = symtab_hdr->sh_info;
9139       extsymoff = symtab_hdr->sh_info;
9140     }
9141
9142   /* Read the local symbols.  */
9143   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9144   if (isymbuf == NULL && locsymcount != 0)
9145     {
9146       isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9147                                       finfo->internal_syms,
9148                                       finfo->external_syms,
9149                                       finfo->locsym_shndx);
9150       if (isymbuf == NULL)
9151         return FALSE;
9152     }
9153
9154   /* Find local symbol sections and adjust values of symbols in
9155      SEC_MERGE sections.  Write out those local symbols we know are
9156      going into the output file.  */
9157   isymend = isymbuf + locsymcount;
9158   for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
9159        isym < isymend;
9160        isym++, pindex++, ppsection++)
9161     {
9162       asection *isec;
9163       const char *name;
9164       Elf_Internal_Sym osym;
9165       long indx;
9166       int ret;
9167
9168       *pindex = -1;
9169
9170       if (elf_bad_symtab (input_bfd))
9171         {
9172           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9173             {
9174               *ppsection = NULL;
9175               continue;
9176             }
9177         }
9178
9179       if (isym->st_shndx == SHN_UNDEF)
9180         isec = bfd_und_section_ptr;
9181       else if (isym->st_shndx == SHN_ABS)
9182         isec = bfd_abs_section_ptr;
9183       else if (isym->st_shndx == SHN_COMMON)
9184         isec = bfd_com_section_ptr;
9185       else
9186         {
9187           isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9188           if (isec == NULL)
9189             {
9190               /* Don't attempt to output symbols with st_shnx in the
9191                  reserved range other than SHN_ABS and SHN_COMMON.  */
9192               *ppsection = NULL;
9193               continue;
9194             }
9195           else if (isec->sec_info_type == ELF_INFO_TYPE_MERGE
9196                    && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9197             isym->st_value =
9198               _bfd_merged_section_offset (output_bfd, &isec,
9199                                           elf_section_data (isec)->sec_info,
9200                                           isym->st_value);
9201         }
9202
9203       *ppsection = isec;
9204
9205       /* Don't output the first, undefined, symbol.  */
9206       if (ppsection == finfo->sections)
9207         continue;
9208
9209       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9210         {
9211           /* We never output section symbols.  Instead, we use the
9212              section symbol of the corresponding section in the output
9213              file.  */
9214           continue;
9215         }
9216
9217       /* If we are stripping all symbols, we don't want to output this
9218          one.  */
9219       if (finfo->info->strip == strip_all)
9220         continue;
9221
9222       /* If we are discarding all local symbols, we don't want to
9223          output this one.  If we are generating a relocatable output
9224          file, then some of the local symbols may be required by
9225          relocs; we output them below as we discover that they are
9226          needed.  */
9227       if (finfo->info->discard == discard_all)
9228         continue;
9229
9230       /* If this symbol is defined in a section which we are
9231          discarding, we don't need to keep it.  */
9232       if (isym->st_shndx != SHN_UNDEF
9233           && isym->st_shndx < SHN_LORESERVE
9234           && bfd_section_removed_from_list (output_bfd,
9235                                             isec->output_section))
9236         continue;
9237
9238       /* Get the name of the symbol.  */
9239       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9240                                               isym->st_name);
9241       if (name == NULL)
9242         return FALSE;
9243
9244       /* See if we are discarding symbols with this name.  */
9245       if ((finfo->info->strip == strip_some
9246            && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
9247                == NULL))
9248           || (((finfo->info->discard == discard_sec_merge
9249                 && (isec->flags & SEC_MERGE) && ! finfo->info->relocatable)
9250                || finfo->info->discard == discard_l)
9251               && bfd_is_local_label_name (input_bfd, name)))
9252         continue;
9253
9254       osym = *isym;
9255
9256       /* Adjust the section index for the output file.  */
9257       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9258                                                          isec->output_section);
9259       if (osym.st_shndx == SHN_BAD)
9260         return FALSE;
9261
9262       /* ELF symbols in relocatable files are section relative, but
9263          in executable files they are virtual addresses.  Note that
9264          this code assumes that all ELF sections have an associated
9265          BFD section with a reasonable value for output_offset; below
9266          we assume that they also have a reasonable value for
9267          output_section.  Any special sections must be set up to meet
9268          these requirements.  */
9269       osym.st_value += isec->output_offset;
9270       if (! finfo->info->relocatable)
9271         {
9272           osym.st_value += isec->output_section->vma;
9273           if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9274             {
9275               /* STT_TLS symbols are relative to PT_TLS segment base.  */
9276               BFD_ASSERT (elf_hash_table (finfo->info)->tls_sec != NULL);
9277               osym.st_value -= elf_hash_table (finfo->info)->tls_sec->vma;
9278             }
9279         }
9280
9281       indx = bfd_get_symcount (output_bfd);
9282       ret = elf_link_output_sym (finfo, name, &osym, isec, NULL);
9283       if (ret == 0)
9284         return FALSE;
9285       else if (ret == 1)
9286         *pindex = indx;
9287     }
9288
9289   if (bed->s->arch_size == 32)
9290     {
9291       r_type_mask = 0xff;
9292       r_sym_shift = 8;
9293       address_size = 4;
9294     }
9295   else
9296     {
9297       r_type_mask = 0xffffffff;
9298       r_sym_shift = 32;
9299       address_size = 8;
9300     }
9301
9302   /* Relocate the contents of each section.  */
9303   sym_hashes = elf_sym_hashes (input_bfd);
9304   for (o = input_bfd->sections; o != NULL; o = o->next)
9305     {
9306       bfd_byte *contents;
9307
9308       if (! o->linker_mark)
9309         {
9310           /* This section was omitted from the link.  */
9311           continue;
9312         }
9313
9314       if (finfo->info->relocatable
9315           && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9316         {
9317           /* Deal with the group signature symbol.  */
9318           struct bfd_elf_section_data *sec_data = elf_section_data (o);
9319           unsigned long symndx = sec_data->this_hdr.sh_info;
9320           asection *osec = o->output_section;
9321
9322           if (symndx >= locsymcount
9323               || (elf_bad_symtab (input_bfd)
9324                   && finfo->sections[symndx] == NULL))
9325             {
9326               struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9327               while (h->root.type == bfd_link_hash_indirect
9328                      || h->root.type == bfd_link_hash_warning)
9329                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9330               /* Arrange for symbol to be output.  */
9331               h->indx = -2;
9332               elf_section_data (osec)->this_hdr.sh_info = -2;
9333             }
9334           else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9335             {
9336               /* We'll use the output section target_index.  */
9337               asection *sec = finfo->sections[symndx]->output_section;
9338               elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9339             }
9340           else
9341             {
9342               if (finfo->indices[symndx] == -1)
9343                 {
9344                   /* Otherwise output the local symbol now.  */
9345                   Elf_Internal_Sym sym = isymbuf[symndx];
9346                   asection *sec = finfo->sections[symndx]->output_section;
9347                   const char *name;
9348                   long indx;
9349                   int ret;
9350
9351                   name = bfd_elf_string_from_elf_section (input_bfd,
9352                                                           symtab_hdr->sh_link,
9353                                                           sym.st_name);
9354                   if (name == NULL)
9355                     return FALSE;
9356
9357                   sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9358                                                                     sec);
9359                   if (sym.st_shndx == SHN_BAD)
9360                     return FALSE;
9361
9362                   sym.st_value += o->output_offset;
9363
9364                   indx = bfd_get_symcount (output_bfd);
9365                   ret = elf_link_output_sym (finfo, name, &sym, o, NULL);
9366                   if (ret == 0)
9367                     return FALSE;
9368                   else if (ret == 1)
9369                     finfo->indices[symndx] = indx;
9370                   else
9371                     abort ();
9372                 }
9373               elf_section_data (osec)->this_hdr.sh_info
9374                 = finfo->indices[symndx];
9375             }
9376         }
9377
9378       if ((o->flags & SEC_HAS_CONTENTS) == 0
9379           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9380         continue;
9381
9382       if ((o->flags & SEC_LINKER_CREATED) != 0)
9383         {
9384           /* Section was created by _bfd_elf_link_create_dynamic_sections
9385              or somesuch.  */
9386           continue;
9387         }
9388
9389       /* Get the contents of the section.  They have been cached by a
9390          relaxation routine.  Note that o is a section in an input
9391          file, so the contents field will not have been set by any of
9392          the routines which work on output files.  */
9393       if (elf_section_data (o)->this_hdr.contents != NULL)
9394         contents = elf_section_data (o)->this_hdr.contents;
9395       else
9396         {
9397           contents = finfo->contents;
9398           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
9399             return FALSE;
9400         }
9401
9402       if ((o->flags & SEC_RELOC) != 0)
9403         {
9404           Elf_Internal_Rela *internal_relocs;
9405           Elf_Internal_Rela *rel, *relend;
9406           int action_discarded;
9407           int ret;
9408
9409           /* Get the swapped relocs.  */
9410           internal_relocs
9411             = _bfd_elf_link_read_relocs (input_bfd, o, finfo->external_relocs,
9412                                          finfo->internal_relocs, FALSE);
9413           if (internal_relocs == NULL
9414               && o->reloc_count > 0)
9415             return FALSE;
9416
9417           /* We need to reverse-copy input .ctors/.dtors sections if
9418              they are placed in .init_array/.finit_array for output.  */
9419           if (o->size > address_size
9420               && ((strncmp (o->name, ".ctors", 6) == 0
9421                    && strcmp (o->output_section->name,
9422                               ".init_array") == 0)
9423                   || (strncmp (o->name, ".dtors", 6) == 0
9424                       && strcmp (o->output_section->name,
9425                                  ".fini_array") == 0))
9426               && (o->name[6] == 0 || o->name[6] == '.'))
9427             {
9428               if (o->size != o->reloc_count * address_size)
9429                 {
9430                   (*_bfd_error_handler)
9431                     (_("error: %B: size of section %A is not "
9432                        "multiple of address size"),
9433                      input_bfd, o);
9434                   bfd_set_error (bfd_error_on_input);
9435                   return FALSE;
9436                 }
9437               o->flags |= SEC_ELF_REVERSE_COPY;
9438             }
9439
9440           action_discarded = -1;
9441           if (!elf_section_ignore_discarded_relocs (o))
9442             action_discarded = (*bed->action_discarded) (o);
9443
9444           /* Run through the relocs evaluating complex reloc symbols and
9445              looking for relocs against symbols from discarded sections
9446              or section symbols from removed link-once sections.
9447              Complain about relocs against discarded sections.  Zero
9448              relocs against removed link-once sections.  */
9449
9450           rel = internal_relocs;
9451           relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9452           for ( ; rel < relend; rel++)
9453             {
9454               unsigned long r_symndx = rel->r_info >> r_sym_shift;
9455               unsigned int s_type;
9456               asection **ps, *sec;
9457               struct elf_link_hash_entry *h = NULL;
9458               const char *sym_name;
9459
9460               if (r_symndx == STN_UNDEF)
9461                 continue;
9462
9463               if (r_symndx >= locsymcount
9464                   || (elf_bad_symtab (input_bfd)
9465                       && finfo->sections[r_symndx] == NULL))
9466                 {
9467                   h = sym_hashes[r_symndx - extsymoff];
9468
9469                   /* Badly formatted input files can contain relocs that
9470                      reference non-existant symbols.  Check here so that
9471                      we do not seg fault.  */
9472                   if (h == NULL)
9473                     {
9474                       char buffer [32];
9475
9476                       sprintf_vma (buffer, rel->r_info);
9477                       (*_bfd_error_handler)
9478                         (_("error: %B contains a reloc (0x%s) for section %A "
9479                            "that references a non-existent global symbol"),
9480                          input_bfd, o, buffer);
9481                       bfd_set_error (bfd_error_bad_value);
9482                       return FALSE;
9483                     }
9484
9485                   while (h->root.type == bfd_link_hash_indirect
9486                          || h->root.type == bfd_link_hash_warning)
9487                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9488
9489                   s_type = h->type;
9490
9491                   ps = NULL;
9492                   if (h->root.type == bfd_link_hash_defined
9493                       || h->root.type == bfd_link_hash_defweak)
9494                     ps = &h->root.u.def.section;
9495
9496                   sym_name = h->root.root.string;
9497                 }
9498               else
9499                 {
9500                   Elf_Internal_Sym *sym = isymbuf + r_symndx;
9501
9502                   s_type = ELF_ST_TYPE (sym->st_info);
9503                   ps = &finfo->sections[r_symndx];
9504                   sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9505                                                sym, *ps);
9506                 }
9507
9508               if ((s_type == STT_RELC || s_type == STT_SRELC)
9509                   && !finfo->info->relocatable)
9510                 {
9511                   bfd_vma val;
9512                   bfd_vma dot = (rel->r_offset
9513                                  + o->output_offset + o->output_section->vma);
9514 #ifdef DEBUG
9515                   printf ("Encountered a complex symbol!");
9516                   printf (" (input_bfd %s, section %s, reloc %ld\n",
9517                           input_bfd->filename, o->name,
9518                           (long) (rel - internal_relocs));
9519                   printf (" symbol: idx  %8.8lx, name %s\n",
9520                           r_symndx, sym_name);
9521                   printf (" reloc : info %8.8lx, addr %8.8lx\n",
9522                           (unsigned long) rel->r_info,
9523                           (unsigned long) rel->r_offset);
9524 #endif
9525                   if (!eval_symbol (&val, &sym_name, input_bfd, finfo, dot,
9526                                     isymbuf, locsymcount, s_type == STT_SRELC))
9527                     return FALSE;
9528
9529                   /* Symbol evaluated OK.  Update to absolute value.  */
9530                   set_symbol_value (input_bfd, isymbuf, locsymcount,
9531                                     r_symndx, val);
9532                   continue;
9533                 }
9534
9535               if (action_discarded != -1 && ps != NULL)
9536                 {
9537                   /* Complain if the definition comes from a
9538                      discarded section.  */
9539                   if ((sec = *ps) != NULL && elf_discarded_section (sec))
9540                     {
9541                       BFD_ASSERT (r_symndx != STN_UNDEF);
9542                       if (action_discarded & COMPLAIN)
9543                         (*finfo->info->callbacks->einfo)
9544                           (_("%X`%s' referenced in section `%A' of %B: "
9545                              "defined in discarded section `%A' of %B\n"),
9546                            sym_name, o, input_bfd, sec, sec->owner);
9547
9548                       /* Try to do the best we can to support buggy old
9549                          versions of gcc.  Pretend that the symbol is
9550                          really defined in the kept linkonce section.
9551                          FIXME: This is quite broken.  Modifying the
9552                          symbol here means we will be changing all later
9553                          uses of the symbol, not just in this section.  */
9554                       if (action_discarded & PRETEND)
9555                         {
9556                           asection *kept;
9557
9558                           kept = _bfd_elf_check_kept_section (sec,
9559                                                               finfo->info);
9560                           if (kept != NULL)
9561                             {
9562                               *ps = kept;
9563                               continue;
9564                             }
9565                         }
9566                     }
9567                 }
9568             }
9569
9570           /* Relocate the section by invoking a back end routine.
9571
9572              The back end routine is responsible for adjusting the
9573              section contents as necessary, and (if using Rela relocs
9574              and generating a relocatable output file) adjusting the
9575              reloc addend as necessary.
9576
9577              The back end routine does not have to worry about setting
9578              the reloc address or the reloc symbol index.
9579
9580              The back end routine is given a pointer to the swapped in
9581              internal symbols, and can access the hash table entries
9582              for the external symbols via elf_sym_hashes (input_bfd).
9583
9584              When generating relocatable output, the back end routine
9585              must handle STB_LOCAL/STT_SECTION symbols specially.  The
9586              output symbol is going to be a section symbol
9587              corresponding to the output section, which will require
9588              the addend to be adjusted.  */
9589
9590           ret = (*relocate_section) (output_bfd, finfo->info,
9591                                      input_bfd, o, contents,
9592                                      internal_relocs,
9593                                      isymbuf,
9594                                      finfo->sections);
9595           if (!ret)
9596             return FALSE;
9597
9598           if (ret == 2
9599               || finfo->info->relocatable
9600               || finfo->info->emitrelocations)
9601             {
9602               Elf_Internal_Rela *irela;
9603               Elf_Internal_Rela *irelaend, *irelamid;
9604               bfd_vma last_offset;
9605               struct elf_link_hash_entry **rel_hash;
9606               struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9607               Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9608               unsigned int next_erel;
9609               bfd_boolean rela_normal;
9610               struct bfd_elf_section_data *esdi, *esdo;
9611
9612               esdi = elf_section_data (o);
9613               esdo = elf_section_data (o->output_section);
9614               rela_normal = FALSE;
9615
9616               /* Adjust the reloc addresses and symbol indices.  */
9617
9618               irela = internal_relocs;
9619               irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9620               rel_hash = esdo->rel.hashes + esdo->rel.count;
9621               /* We start processing the REL relocs, if any.  When we reach
9622                  IRELAMID in the loop, we switch to the RELA relocs.  */
9623               irelamid = irela;
9624               if (esdi->rel.hdr != NULL)
9625                 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9626                              * bed->s->int_rels_per_ext_rel);
9627               rel_hash_list = rel_hash;
9628               rela_hash_list = NULL;
9629               last_offset = o->output_offset;
9630               if (!finfo->info->relocatable)
9631                 last_offset += o->output_section->vma;
9632               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9633                 {
9634                   unsigned long r_symndx;
9635                   asection *sec;
9636                   Elf_Internal_Sym sym;
9637
9638                   if (next_erel == bed->s->int_rels_per_ext_rel)
9639                     {
9640                       rel_hash++;
9641                       next_erel = 0;
9642                     }
9643
9644                   if (irela == irelamid)
9645                     {
9646                       rel_hash = esdo->rela.hashes + esdo->rela.count;
9647                       rela_hash_list = rel_hash;
9648                       rela_normal = bed->rela_normal;
9649                     }
9650
9651                   irela->r_offset = _bfd_elf_section_offset (output_bfd,
9652                                                              finfo->info, o,
9653                                                              irela->r_offset);
9654                   if (irela->r_offset >= (bfd_vma) -2)
9655                     {
9656                       /* This is a reloc for a deleted entry or somesuch.
9657                          Turn it into an R_*_NONE reloc, at the same
9658                          offset as the last reloc.  elf_eh_frame.c and
9659                          bfd_elf_discard_info rely on reloc offsets
9660                          being ordered.  */
9661                       irela->r_offset = last_offset;
9662                       irela->r_info = 0;
9663                       irela->r_addend = 0;
9664                       continue;
9665                     }
9666
9667                   irela->r_offset += o->output_offset;
9668
9669                   /* Relocs in an executable have to be virtual addresses.  */
9670                   if (!finfo->info->relocatable)
9671                     irela->r_offset += o->output_section->vma;
9672
9673                   last_offset = irela->r_offset;
9674
9675                   r_symndx = irela->r_info >> r_sym_shift;
9676                   if (r_symndx == STN_UNDEF)
9677                     continue;
9678
9679                   if (r_symndx >= locsymcount
9680                       || (elf_bad_symtab (input_bfd)
9681                           && finfo->sections[r_symndx] == NULL))
9682                     {
9683                       struct elf_link_hash_entry *rh;
9684                       unsigned long indx;
9685
9686                       /* This is a reloc against a global symbol.  We
9687                          have not yet output all the local symbols, so
9688                          we do not know the symbol index of any global
9689                          symbol.  We set the rel_hash entry for this
9690                          reloc to point to the global hash table entry
9691                          for this symbol.  The symbol index is then
9692                          set at the end of bfd_elf_final_link.  */
9693                       indx = r_symndx - extsymoff;
9694                       rh = elf_sym_hashes (input_bfd)[indx];
9695                       while (rh->root.type == bfd_link_hash_indirect
9696                              || rh->root.type == bfd_link_hash_warning)
9697                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
9698
9699                       /* Setting the index to -2 tells
9700                          elf_link_output_extsym that this symbol is
9701                          used by a reloc.  */
9702                       BFD_ASSERT (rh->indx < 0);
9703                       rh->indx = -2;
9704
9705                       *rel_hash = rh;
9706
9707                       continue;
9708                     }
9709
9710                   /* This is a reloc against a local symbol.  */
9711
9712                   *rel_hash = NULL;
9713                   sym = isymbuf[r_symndx];
9714                   sec = finfo->sections[r_symndx];
9715                   if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
9716                     {
9717                       /* I suppose the backend ought to fill in the
9718                          section of any STT_SECTION symbol against a
9719                          processor specific section.  */
9720                       r_symndx = STN_UNDEF;
9721                       if (bfd_is_abs_section (sec))
9722                         ;
9723                       else if (sec == NULL || sec->owner == NULL)
9724                         {
9725                           bfd_set_error (bfd_error_bad_value);
9726                           return FALSE;
9727                         }
9728                       else
9729                         {
9730                           asection *osec = sec->output_section;
9731
9732                           /* If we have discarded a section, the output
9733                              section will be the absolute section.  In
9734                              case of discarded SEC_MERGE sections, use
9735                              the kept section.  relocate_section should
9736                              have already handled discarded linkonce
9737                              sections.  */
9738                           if (bfd_is_abs_section (osec)
9739                               && sec->kept_section != NULL
9740                               && sec->kept_section->output_section != NULL)
9741                             {
9742                               osec = sec->kept_section->output_section;
9743                               irela->r_addend -= osec->vma;
9744                             }
9745
9746                           if (!bfd_is_abs_section (osec))
9747                             {
9748                               r_symndx = osec->target_index;
9749                               if (r_symndx == STN_UNDEF)
9750                                 {
9751                                   irela->r_addend += osec->vma;
9752                                   osec = _bfd_nearby_section (output_bfd, osec,
9753                                                               osec->vma);
9754                                   irela->r_addend -= osec->vma;
9755                                   r_symndx = osec->target_index;
9756                                 }
9757                             }
9758                         }
9759
9760                       /* Adjust the addend according to where the
9761                          section winds up in the output section.  */
9762                       if (rela_normal)
9763                         irela->r_addend += sec->output_offset;
9764                     }
9765                   else
9766                     {
9767                       if (finfo->indices[r_symndx] == -1)
9768                         {
9769                           unsigned long shlink;
9770                           const char *name;
9771                           asection *osec;
9772                           long indx;
9773
9774                           if (finfo->info->strip == strip_all)
9775                             {
9776                               /* You can't do ld -r -s.  */
9777                               bfd_set_error (bfd_error_invalid_operation);
9778                               return FALSE;
9779                             }
9780
9781                           /* This symbol was skipped earlier, but
9782                              since it is needed by a reloc, we
9783                              must output it now.  */
9784                           shlink = symtab_hdr->sh_link;
9785                           name = (bfd_elf_string_from_elf_section
9786                                   (input_bfd, shlink, sym.st_name));
9787                           if (name == NULL)
9788                             return FALSE;
9789
9790                           osec = sec->output_section;
9791                           sym.st_shndx =
9792                             _bfd_elf_section_from_bfd_section (output_bfd,
9793                                                                osec);
9794                           if (sym.st_shndx == SHN_BAD)
9795                             return FALSE;
9796
9797                           sym.st_value += sec->output_offset;
9798                           if (! finfo->info->relocatable)
9799                             {
9800                               sym.st_value += osec->vma;
9801                               if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
9802                                 {
9803                                   /* STT_TLS symbols are relative to PT_TLS
9804                                      segment base.  */
9805                                   BFD_ASSERT (elf_hash_table (finfo->info)
9806                                               ->tls_sec != NULL);
9807                                   sym.st_value -= (elf_hash_table (finfo->info)
9808                                                    ->tls_sec->vma);
9809                                 }
9810                             }
9811
9812                           indx = bfd_get_symcount (output_bfd);
9813                           ret = elf_link_output_sym (finfo, name, &sym, sec,
9814                                                      NULL);
9815                           if (ret == 0)
9816                             return FALSE;
9817                           else if (ret == 1)
9818                             finfo->indices[r_symndx] = indx;
9819                           else
9820                             abort ();
9821                         }
9822
9823                       r_symndx = finfo->indices[r_symndx];
9824                     }
9825
9826                   irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
9827                                    | (irela->r_info & r_type_mask));
9828                 }
9829
9830               /* Swap out the relocs.  */
9831               input_rel_hdr = esdi->rel.hdr;
9832               if (input_rel_hdr && input_rel_hdr->sh_size != 0)
9833                 {
9834                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
9835                                                      input_rel_hdr,
9836                                                      internal_relocs,
9837                                                      rel_hash_list))
9838                     return FALSE;
9839                   internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
9840                                       * bed->s->int_rels_per_ext_rel);
9841                   rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
9842                 }
9843
9844               input_rela_hdr = esdi->rela.hdr;
9845               if (input_rela_hdr && input_rela_hdr->sh_size != 0)
9846                 {
9847                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
9848                                                      input_rela_hdr,
9849                                                      internal_relocs,
9850                                                      rela_hash_list))
9851                     return FALSE;
9852                 }
9853             }
9854         }
9855
9856       /* Write out the modified section contents.  */
9857       if (bed->elf_backend_write_section
9858           && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o,
9859                                                 contents))
9860         {
9861           /* Section written out.  */
9862         }
9863       else switch (o->sec_info_type)
9864         {
9865         case ELF_INFO_TYPE_STABS:
9866           if (! (_bfd_write_section_stabs
9867                  (output_bfd,
9868                   &elf_hash_table (finfo->info)->stab_info,
9869                   o, &elf_section_data (o)->sec_info, contents)))
9870             return FALSE;
9871           break;
9872         case ELF_INFO_TYPE_MERGE:
9873           if (! _bfd_write_merged_section (output_bfd, o,
9874                                            elf_section_data (o)->sec_info))
9875             return FALSE;
9876           break;
9877         case ELF_INFO_TYPE_EH_FRAME:
9878           {
9879             if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info,
9880                                                    o, contents))
9881               return FALSE;
9882           }
9883           break;
9884         default:
9885           {
9886             /* FIXME: octets_per_byte.  */
9887             if (! (o->flags & SEC_EXCLUDE))
9888               {
9889                 file_ptr offset = (file_ptr) o->output_offset;
9890                 bfd_size_type todo = o->size;
9891                 if ((o->flags & SEC_ELF_REVERSE_COPY))
9892                   {
9893                     /* Reverse-copy input section to output.  */
9894                     do
9895                       {
9896                         todo -= address_size;
9897                         if (! bfd_set_section_contents (output_bfd,
9898                                                         o->output_section,
9899                                                         contents + todo,
9900                                                         offset,
9901                                                         address_size))
9902                           return FALSE;
9903                         if (todo == 0)
9904                           break;
9905                         offset += address_size;
9906                       }
9907                     while (1);
9908                   }
9909                 else if (! bfd_set_section_contents (output_bfd,
9910                                                      o->output_section,
9911                                                      contents,
9912                                                      offset, todo))
9913                   return FALSE;
9914               }
9915           }
9916           break;
9917         }
9918     }
9919
9920   return TRUE;
9921 }
9922
9923 /* Generate a reloc when linking an ELF file.  This is a reloc
9924    requested by the linker, and does not come from any input file.  This
9925    is used to build constructor and destructor tables when linking
9926    with -Ur.  */
9927
9928 static bfd_boolean
9929 elf_reloc_link_order (bfd *output_bfd,
9930                       struct bfd_link_info *info,
9931                       asection *output_section,
9932                       struct bfd_link_order *link_order)
9933 {
9934   reloc_howto_type *howto;
9935   long indx;
9936   bfd_vma offset;
9937   bfd_vma addend;
9938   struct bfd_elf_section_reloc_data *reldata;
9939   struct elf_link_hash_entry **rel_hash_ptr;
9940   Elf_Internal_Shdr *rel_hdr;
9941   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9942   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
9943   bfd_byte *erel;
9944   unsigned int i;
9945   struct bfd_elf_section_data *esdo = elf_section_data (output_section);
9946
9947   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
9948   if (howto == NULL)
9949     {
9950       bfd_set_error (bfd_error_bad_value);
9951       return FALSE;
9952     }
9953
9954   addend = link_order->u.reloc.p->addend;
9955
9956   if (esdo->rel.hdr)
9957     reldata = &esdo->rel;
9958   else if (esdo->rela.hdr)
9959     reldata = &esdo->rela;
9960   else
9961     {
9962       reldata = NULL;
9963       BFD_ASSERT (0);
9964     }
9965
9966   /* Figure out the symbol index.  */
9967   rel_hash_ptr = reldata->hashes + reldata->count;
9968   if (link_order->type == bfd_section_reloc_link_order)
9969     {
9970       indx = link_order->u.reloc.p->u.section->target_index;
9971       BFD_ASSERT (indx != 0);
9972       *rel_hash_ptr = NULL;
9973     }
9974   else
9975     {
9976       struct elf_link_hash_entry *h;
9977
9978       /* Treat a reloc against a defined symbol as though it were
9979          actually against the section.  */
9980       h = ((struct elf_link_hash_entry *)
9981            bfd_wrapped_link_hash_lookup (output_bfd, info,
9982                                          link_order->u.reloc.p->u.name,
9983                                          FALSE, FALSE, TRUE));
9984       if (h != NULL
9985           && (h->root.type == bfd_link_hash_defined
9986               || h->root.type == bfd_link_hash_defweak))
9987         {
9988           asection *section;
9989
9990           section = h->root.u.def.section;
9991           indx = section->output_section->target_index;
9992           *rel_hash_ptr = NULL;
9993           /* It seems that we ought to add the symbol value to the
9994              addend here, but in practice it has already been added
9995              because it was passed to constructor_callback.  */
9996           addend += section->output_section->vma + section->output_offset;
9997         }
9998       else if (h != NULL)
9999         {
10000           /* Setting the index to -2 tells elf_link_output_extsym that
10001              this symbol is used by a reloc.  */
10002           h->indx = -2;
10003           *rel_hash_ptr = h;
10004           indx = 0;
10005         }
10006       else
10007         {
10008           if (! ((*info->callbacks->unattached_reloc)
10009                  (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10010             return FALSE;
10011           indx = 0;
10012         }
10013     }
10014
10015   /* If this is an inplace reloc, we must write the addend into the
10016      object file.  */
10017   if (howto->partial_inplace && addend != 0)
10018     {
10019       bfd_size_type size;
10020       bfd_reloc_status_type rstat;
10021       bfd_byte *buf;
10022       bfd_boolean ok;
10023       const char *sym_name;
10024
10025       size = (bfd_size_type) bfd_get_reloc_size (howto);
10026       buf = (bfd_byte *) bfd_zmalloc (size);
10027       if (buf == NULL)
10028         return FALSE;
10029       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10030       switch (rstat)
10031         {
10032         case bfd_reloc_ok:
10033           break;
10034
10035         default:
10036         case bfd_reloc_outofrange:
10037           abort ();
10038
10039         case bfd_reloc_overflow:
10040           if (link_order->type == bfd_section_reloc_link_order)
10041             sym_name = bfd_section_name (output_bfd,
10042                                          link_order->u.reloc.p->u.section);
10043           else
10044             sym_name = link_order->u.reloc.p->u.name;
10045           if (! ((*info->callbacks->reloc_overflow)
10046                  (info, NULL, sym_name, howto->name, addend, NULL,
10047                   NULL, (bfd_vma) 0)))
10048             {
10049               free (buf);
10050               return FALSE;
10051             }
10052           break;
10053         }
10054       ok = bfd_set_section_contents (output_bfd, output_section, buf,
10055                                      link_order->offset, size);
10056       free (buf);
10057       if (! ok)
10058         return FALSE;
10059     }
10060
10061   /* The address of a reloc is relative to the section in a
10062      relocatable file, and is a virtual address in an executable
10063      file.  */
10064   offset = link_order->offset;
10065   if (! info->relocatable)
10066     offset += output_section->vma;
10067
10068   for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10069     {
10070       irel[i].r_offset = offset;
10071       irel[i].r_info = 0;
10072       irel[i].r_addend = 0;
10073     }
10074   if (bed->s->arch_size == 32)
10075     irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10076   else
10077     irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10078
10079   rel_hdr = reldata->hdr;
10080   erel = rel_hdr->contents;
10081   if (rel_hdr->sh_type == SHT_REL)
10082     {
10083       erel += reldata->count * bed->s->sizeof_rel;
10084       (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10085     }
10086   else
10087     {
10088       irel[0].r_addend = addend;
10089       erel += reldata->count * bed->s->sizeof_rela;
10090       (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10091     }
10092
10093   ++reldata->count;
10094
10095   return TRUE;
10096 }
10097
10098
10099 /* Get the output vma of the section pointed to by the sh_link field.  */
10100
10101 static bfd_vma
10102 elf_get_linked_section_vma (struct bfd_link_order *p)
10103 {
10104   Elf_Internal_Shdr **elf_shdrp;
10105   asection *s;
10106   int elfsec;
10107
10108   s = p->u.indirect.section;
10109   elf_shdrp = elf_elfsections (s->owner);
10110   elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10111   elfsec = elf_shdrp[elfsec]->sh_link;
10112   /* PR 290:
10113      The Intel C compiler generates SHT_IA_64_UNWIND with
10114      SHF_LINK_ORDER.  But it doesn't set the sh_link or
10115      sh_info fields.  Hence we could get the situation
10116      where elfsec is 0.  */
10117   if (elfsec == 0)
10118     {
10119       const struct elf_backend_data *bed
10120         = get_elf_backend_data (s->owner);
10121       if (bed->link_order_error_handler)
10122         bed->link_order_error_handler
10123           (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10124       return 0;
10125     }
10126   else
10127     {
10128       s = elf_shdrp[elfsec]->bfd_section;
10129       return s->output_section->vma + s->output_offset;
10130     }
10131 }
10132
10133
10134 /* Compare two sections based on the locations of the sections they are
10135    linked to.  Used by elf_fixup_link_order.  */
10136
10137 static int
10138 compare_link_order (const void * a, const void * b)
10139 {
10140   bfd_vma apos;
10141   bfd_vma bpos;
10142
10143   apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10144   bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10145   if (apos < bpos)
10146     return -1;
10147   return apos > bpos;
10148 }
10149
10150
10151 /* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
10152    order as their linked sections.  Returns false if this could not be done
10153    because an output section includes both ordered and unordered
10154    sections.  Ideally we'd do this in the linker proper.  */
10155
10156 static bfd_boolean
10157 elf_fixup_link_order (bfd *abfd, asection *o)
10158 {
10159   int seen_linkorder;
10160   int seen_other;
10161   int n;
10162   struct bfd_link_order *p;
10163   bfd *sub;
10164   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10165   unsigned elfsec;
10166   struct bfd_link_order **sections;
10167   asection *s, *other_sec, *linkorder_sec;
10168   bfd_vma offset;
10169
10170   other_sec = NULL;
10171   linkorder_sec = NULL;
10172   seen_other = 0;
10173   seen_linkorder = 0;
10174   for (p = o->map_head.link_order; p != NULL; p = p->next)
10175     {
10176       if (p->type == bfd_indirect_link_order)
10177         {
10178           s = p->u.indirect.section;
10179           sub = s->owner;
10180           if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10181               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10182               && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10183               && elfsec < elf_numsections (sub)
10184               && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10185               && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10186             {
10187               seen_linkorder++;
10188               linkorder_sec = s;
10189             }
10190           else
10191             {
10192               seen_other++;
10193               other_sec = s;
10194             }
10195         }
10196       else
10197         seen_other++;
10198
10199       if (seen_other && seen_linkorder)
10200         {
10201           if (other_sec && linkorder_sec)
10202             (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10203                                    o, linkorder_sec,
10204                                    linkorder_sec->owner, other_sec,
10205                                    other_sec->owner);
10206           else
10207             (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10208                                    o);
10209           bfd_set_error (bfd_error_bad_value);
10210           return FALSE;
10211         }
10212     }
10213
10214   if (!seen_linkorder)
10215     return TRUE;
10216
10217   sections = (struct bfd_link_order **)
10218     bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10219   if (sections == NULL)
10220     return FALSE;
10221   seen_linkorder = 0;
10222
10223   for (p = o->map_head.link_order; p != NULL; p = p->next)
10224     {
10225       sections[seen_linkorder++] = p;
10226     }
10227   /* Sort the input sections in the order of their linked section.  */
10228   qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10229          compare_link_order);
10230
10231   /* Change the offsets of the sections.  */
10232   offset = 0;
10233   for (n = 0; n < seen_linkorder; n++)
10234     {
10235       s = sections[n]->u.indirect.section;
10236       offset &= ~(bfd_vma) 0 << s->alignment_power;
10237       s->output_offset = offset;
10238       sections[n]->offset = offset;
10239       /* FIXME: octets_per_byte.  */
10240       offset += sections[n]->size;
10241     }
10242
10243   free (sections);
10244   return TRUE;
10245 }
10246
10247
10248 /* Do the final step of an ELF link.  */
10249
10250 bfd_boolean
10251 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10252 {
10253   bfd_boolean dynamic;
10254   bfd_boolean emit_relocs;
10255   bfd *dynobj;
10256   struct elf_final_link_info finfo;
10257   asection *o;
10258   struct bfd_link_order *p;
10259   bfd *sub;
10260   bfd_size_type max_contents_size;
10261   bfd_size_type max_external_reloc_size;
10262   bfd_size_type max_internal_reloc_count;
10263   bfd_size_type max_sym_count;
10264   bfd_size_type max_sym_shndx_count;
10265   file_ptr off;
10266   Elf_Internal_Sym elfsym;
10267   unsigned int i;
10268   Elf_Internal_Shdr *symtab_hdr;
10269   Elf_Internal_Shdr *symtab_shndx_hdr;
10270   Elf_Internal_Shdr *symstrtab_hdr;
10271   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10272   struct elf_outext_info eoinfo;
10273   bfd_boolean merged;
10274   size_t relativecount = 0;
10275   asection *reldyn = 0;
10276   bfd_size_type amt;
10277   asection *attr_section = NULL;
10278   bfd_vma attr_size = 0;
10279   const char *std_attrs_section;
10280
10281   if (! is_elf_hash_table (info->hash))
10282     return FALSE;
10283
10284   if (info->shared)
10285     abfd->flags |= DYNAMIC;
10286
10287   dynamic = elf_hash_table (info)->dynamic_sections_created;
10288   dynobj = elf_hash_table (info)->dynobj;
10289
10290   emit_relocs = (info->relocatable
10291                  || info->emitrelocations);
10292
10293   finfo.info = info;
10294   finfo.output_bfd = abfd;
10295   finfo.symstrtab = _bfd_elf_stringtab_init ();
10296   if (finfo.symstrtab == NULL)
10297     return FALSE;
10298
10299   if (! dynamic)
10300     {
10301       finfo.dynsym_sec = NULL;
10302       finfo.hash_sec = NULL;
10303       finfo.symver_sec = NULL;
10304     }
10305   else
10306     {
10307       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
10308       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
10309       /* Note that dynsym_sec can be NULL (on VMS).  */
10310       finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
10311       /* Note that it is OK if symver_sec is NULL.  */
10312     }
10313
10314   finfo.contents = NULL;
10315   finfo.external_relocs = NULL;
10316   finfo.internal_relocs = NULL;
10317   finfo.external_syms = NULL;
10318   finfo.locsym_shndx = NULL;
10319   finfo.internal_syms = NULL;
10320   finfo.indices = NULL;
10321   finfo.sections = NULL;
10322   finfo.symbuf = NULL;
10323   finfo.symshndxbuf = NULL;
10324   finfo.symbuf_count = 0;
10325   finfo.shndxbuf_size = 0;
10326
10327   /* The object attributes have been merged.  Remove the input
10328      sections from the link, and set the contents of the output
10329      secton.  */
10330   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10331   for (o = abfd->sections; o != NULL; o = o->next)
10332     {
10333       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10334           || strcmp (o->name, ".gnu.attributes") == 0)
10335         {
10336           for (p = o->map_head.link_order; p != NULL; p = p->next)
10337             {
10338               asection *input_section;
10339
10340               if (p->type != bfd_indirect_link_order)
10341                 continue;
10342               input_section = p->u.indirect.section;
10343               /* Hack: reset the SEC_HAS_CONTENTS flag so that
10344                  elf_link_input_bfd ignores this section.  */
10345               input_section->flags &= ~SEC_HAS_CONTENTS;
10346             }
10347
10348           attr_size = bfd_elf_obj_attr_size (abfd);
10349           if (attr_size)
10350             {
10351               bfd_set_section_size (abfd, o, attr_size);
10352               attr_section = o;
10353               /* Skip this section later on.  */
10354               o->map_head.link_order = NULL;
10355             }
10356           else
10357             o->flags |= SEC_EXCLUDE;
10358         }
10359     }
10360
10361   /* Count up the number of relocations we will output for each output
10362      section, so that we know the sizes of the reloc sections.  We
10363      also figure out some maximum sizes.  */
10364   max_contents_size = 0;
10365   max_external_reloc_size = 0;
10366   max_internal_reloc_count = 0;
10367   max_sym_count = 0;
10368   max_sym_shndx_count = 0;
10369   merged = FALSE;
10370   for (o = abfd->sections; o != NULL; o = o->next)
10371     {
10372       struct bfd_elf_section_data *esdo = elf_section_data (o);
10373       o->reloc_count = 0;
10374
10375       for (p = o->map_head.link_order; p != NULL; p = p->next)
10376         {
10377           unsigned int reloc_count = 0;
10378           struct bfd_elf_section_data *esdi = NULL;
10379
10380           if (p->type == bfd_section_reloc_link_order
10381               || p->type == bfd_symbol_reloc_link_order)
10382             reloc_count = 1;
10383           else if (p->type == bfd_indirect_link_order)
10384             {
10385               asection *sec;
10386
10387               sec = p->u.indirect.section;
10388               esdi = elf_section_data (sec);
10389
10390               /* Mark all sections which are to be included in the
10391                  link.  This will normally be every section.  We need
10392                  to do this so that we can identify any sections which
10393                  the linker has decided to not include.  */
10394               sec->linker_mark = TRUE;
10395
10396               if (sec->flags & SEC_MERGE)
10397                 merged = TRUE;
10398
10399               if (info->relocatable || info->emitrelocations)
10400                 reloc_count = sec->reloc_count;
10401               else if (bed->elf_backend_count_relocs)
10402                 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10403
10404               if (sec->rawsize > max_contents_size)
10405                 max_contents_size = sec->rawsize;
10406               if (sec->size > max_contents_size)
10407                 max_contents_size = sec->size;
10408
10409               /* We are interested in just local symbols, not all
10410                  symbols.  */
10411               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10412                   && (sec->owner->flags & DYNAMIC) == 0)
10413                 {
10414                   size_t sym_count;
10415
10416                   if (elf_bad_symtab (sec->owner))
10417                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10418                                  / bed->s->sizeof_sym);
10419                   else
10420                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10421
10422                   if (sym_count > max_sym_count)
10423                     max_sym_count = sym_count;
10424
10425                   if (sym_count > max_sym_shndx_count
10426                       && elf_symtab_shndx (sec->owner) != 0)
10427                     max_sym_shndx_count = sym_count;
10428
10429                   if ((sec->flags & SEC_RELOC) != 0)
10430                     {
10431                       size_t ext_size = 0;
10432
10433                       if (esdi->rel.hdr != NULL)
10434                         ext_size = esdi->rel.hdr->sh_size;
10435                       if (esdi->rela.hdr != NULL)
10436                         ext_size += esdi->rela.hdr->sh_size;
10437
10438                       if (ext_size > max_external_reloc_size)
10439                         max_external_reloc_size = ext_size;
10440                       if (sec->reloc_count > max_internal_reloc_count)
10441                         max_internal_reloc_count = sec->reloc_count;
10442                     }
10443                 }
10444             }
10445
10446           if (reloc_count == 0)
10447             continue;
10448
10449           o->reloc_count += reloc_count;
10450
10451           if (p->type == bfd_indirect_link_order
10452               && (info->relocatable || info->emitrelocations))
10453             {
10454               if (esdi->rel.hdr)
10455                 esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10456               if (esdi->rela.hdr)
10457                 esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10458             }
10459           else
10460             {
10461               if (o->use_rela_p)
10462                 esdo->rela.count += reloc_count;
10463               else
10464                 esdo->rel.count += reloc_count;
10465             }
10466         }
10467
10468       if (o->reloc_count > 0)
10469         o->flags |= SEC_RELOC;
10470       else
10471         {
10472           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
10473              set it (this is probably a bug) and if it is set
10474              assign_section_numbers will create a reloc section.  */
10475           o->flags &=~ SEC_RELOC;
10476         }
10477
10478       /* If the SEC_ALLOC flag is not set, force the section VMA to
10479          zero.  This is done in elf_fake_sections as well, but forcing
10480          the VMA to 0 here will ensure that relocs against these
10481          sections are handled correctly.  */
10482       if ((o->flags & SEC_ALLOC) == 0
10483           && ! o->user_set_vma)
10484         o->vma = 0;
10485     }
10486
10487   if (! info->relocatable && merged)
10488     elf_link_hash_traverse (elf_hash_table (info),
10489                             _bfd_elf_link_sec_merge_syms, abfd);
10490
10491   /* Figure out the file positions for everything but the symbol table
10492      and the relocs.  We set symcount to force assign_section_numbers
10493      to create a symbol table.  */
10494   bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
10495   BFD_ASSERT (! abfd->output_has_begun);
10496   if (! _bfd_elf_compute_section_file_positions (abfd, info))
10497     goto error_return;
10498
10499   /* Set sizes, and assign file positions for reloc sections.  */
10500   for (o = abfd->sections; o != NULL; o = o->next)
10501     {
10502       struct bfd_elf_section_data *esdo = elf_section_data (o);
10503       if ((o->flags & SEC_RELOC) != 0)
10504         {
10505           if (esdo->rel.hdr
10506               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10507             goto error_return;
10508
10509           if (esdo->rela.hdr
10510               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10511             goto error_return;
10512         }
10513
10514       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10515          to count upwards while actually outputting the relocations.  */
10516       esdo->rel.count = 0;
10517       esdo->rela.count = 0;
10518     }
10519
10520   _bfd_elf_assign_file_positions_for_relocs (abfd);
10521
10522   /* We have now assigned file positions for all the sections except
10523      .symtab and .strtab.  We start the .symtab section at the current
10524      file position, and write directly to it.  We build the .strtab
10525      section in memory.  */
10526   bfd_get_symcount (abfd) = 0;
10527   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10528   /* sh_name is set in prep_headers.  */
10529   symtab_hdr->sh_type = SHT_SYMTAB;
10530   /* sh_flags, sh_addr and sh_size all start off zero.  */
10531   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10532   /* sh_link is set in assign_section_numbers.  */
10533   /* sh_info is set below.  */
10534   /* sh_offset is set just below.  */
10535   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10536
10537   off = elf_tdata (abfd)->next_file_pos;
10538   off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10539
10540   /* Note that at this point elf_tdata (abfd)->next_file_pos is
10541      incorrect.  We do not yet know the size of the .symtab section.
10542      We correct next_file_pos below, after we do know the size.  */
10543
10544   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
10545      continuously seeking to the right position in the file.  */
10546   if (! info->keep_memory || max_sym_count < 20)
10547     finfo.symbuf_size = 20;
10548   else
10549     finfo.symbuf_size = max_sym_count;
10550   amt = finfo.symbuf_size;
10551   amt *= bed->s->sizeof_sym;
10552   finfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10553   if (finfo.symbuf == NULL)
10554     goto error_return;
10555   if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10556     {
10557       /* Wild guess at number of output symbols.  realloc'd as needed.  */
10558       amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10559       finfo.shndxbuf_size = amt;
10560       amt *= sizeof (Elf_External_Sym_Shndx);
10561       finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10562       if (finfo.symshndxbuf == NULL)
10563         goto error_return;
10564     }
10565
10566   /* Start writing out the symbol table.  The first symbol is always a
10567      dummy symbol.  */
10568   if (info->strip != strip_all
10569       || emit_relocs)
10570     {
10571       elfsym.st_value = 0;
10572       elfsym.st_size = 0;
10573       elfsym.st_info = 0;
10574       elfsym.st_other = 0;
10575       elfsym.st_shndx = SHN_UNDEF;
10576       elfsym.st_target_internal = 0;
10577       if (elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr,
10578                                NULL) != 1)
10579         goto error_return;
10580     }
10581
10582   /* Output a symbol for each section.  We output these even if we are
10583      discarding local symbols, since they are used for relocs.  These
10584      symbols have no names.  We store the index of each one in the
10585      index field of the section, so that we can find it again when
10586      outputting relocs.  */
10587   if (info->strip != strip_all
10588       || emit_relocs)
10589     {
10590       elfsym.st_size = 0;
10591       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10592       elfsym.st_other = 0;
10593       elfsym.st_value = 0;
10594       elfsym.st_target_internal = 0;
10595       for (i = 1; i < elf_numsections (abfd); i++)
10596         {
10597           o = bfd_section_from_elf_index (abfd, i);
10598           if (o != NULL)
10599             {
10600               o->target_index = bfd_get_symcount (abfd);
10601               elfsym.st_shndx = i;
10602               if (!info->relocatable)
10603                 elfsym.st_value = o->vma;
10604               if (elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL) != 1)
10605                 goto error_return;
10606             }
10607         }
10608     }
10609
10610   /* Allocate some memory to hold information read in from the input
10611      files.  */
10612   if (max_contents_size != 0)
10613     {
10614       finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10615       if (finfo.contents == NULL)
10616         goto error_return;
10617     }
10618
10619   if (max_external_reloc_size != 0)
10620     {
10621       finfo.external_relocs = bfd_malloc (max_external_reloc_size);
10622       if (finfo.external_relocs == NULL)
10623         goto error_return;
10624     }
10625
10626   if (max_internal_reloc_count != 0)
10627     {
10628       amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10629       amt *= sizeof (Elf_Internal_Rela);
10630       finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10631       if (finfo.internal_relocs == NULL)
10632         goto error_return;
10633     }
10634
10635   if (max_sym_count != 0)
10636     {
10637       amt = max_sym_count * bed->s->sizeof_sym;
10638       finfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10639       if (finfo.external_syms == NULL)
10640         goto error_return;
10641
10642       amt = max_sym_count * sizeof (Elf_Internal_Sym);
10643       finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10644       if (finfo.internal_syms == NULL)
10645         goto error_return;
10646
10647       amt = max_sym_count * sizeof (long);
10648       finfo.indices = (long int *) bfd_malloc (amt);
10649       if (finfo.indices == NULL)
10650         goto error_return;
10651
10652       amt = max_sym_count * sizeof (asection *);
10653       finfo.sections = (asection **) bfd_malloc (amt);
10654       if (finfo.sections == NULL)
10655         goto error_return;
10656     }
10657
10658   if (max_sym_shndx_count != 0)
10659     {
10660       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
10661       finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
10662       if (finfo.locsym_shndx == NULL)
10663         goto error_return;
10664     }
10665
10666   if (elf_hash_table (info)->tls_sec)
10667     {
10668       bfd_vma base, end = 0;
10669       asection *sec;
10670
10671       for (sec = elf_hash_table (info)->tls_sec;
10672            sec && (sec->flags & SEC_THREAD_LOCAL);
10673            sec = sec->next)
10674         {
10675           bfd_size_type size = sec->size;
10676
10677           if (size == 0
10678               && (sec->flags & SEC_HAS_CONTENTS) == 0)
10679             {
10680               struct bfd_link_order *ord = sec->map_tail.link_order;
10681
10682               if (ord != NULL)
10683                 size = ord->offset + ord->size;
10684             }
10685           end = sec->vma + size;
10686         }
10687       base = elf_hash_table (info)->tls_sec->vma;
10688       /* Only align end of TLS section if static TLS doesn't have special
10689          alignment requirements.  */
10690       if (bed->static_tls_alignment == 1)
10691         end = align_power (end,
10692                            elf_hash_table (info)->tls_sec->alignment_power);
10693       elf_hash_table (info)->tls_size = end - base;
10694     }
10695
10696   /* Reorder SHF_LINK_ORDER sections.  */
10697   for (o = abfd->sections; o != NULL; o = o->next)
10698     {
10699       if (!elf_fixup_link_order (abfd, o))
10700         return FALSE;
10701     }
10702
10703   /* Since ELF permits relocations to be against local symbols, we
10704      must have the local symbols available when we do the relocations.
10705      Since we would rather only read the local symbols once, and we
10706      would rather not keep them in memory, we handle all the
10707      relocations for a single input file at the same time.
10708
10709      Unfortunately, there is no way to know the total number of local
10710      symbols until we have seen all of them, and the local symbol
10711      indices precede the global symbol indices.  This means that when
10712      we are generating relocatable output, and we see a reloc against
10713      a global symbol, we can not know the symbol index until we have
10714      finished examining all the local symbols to see which ones we are
10715      going to output.  To deal with this, we keep the relocations in
10716      memory, and don't output them until the end of the link.  This is
10717      an unfortunate waste of memory, but I don't see a good way around
10718      it.  Fortunately, it only happens when performing a relocatable
10719      link, which is not the common case.  FIXME: If keep_memory is set
10720      we could write the relocs out and then read them again; I don't
10721      know how bad the memory loss will be.  */
10722
10723   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10724     sub->output_has_begun = FALSE;
10725   for (o = abfd->sections; o != NULL; o = o->next)
10726     {
10727       for (p = o->map_head.link_order; p != NULL; p = p->next)
10728         {
10729           if (p->type == bfd_indirect_link_order
10730               && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
10731                   == bfd_target_elf_flavour)
10732               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
10733             {
10734               if (! sub->output_has_begun)
10735                 {
10736                   if (! elf_link_input_bfd (&finfo, sub))
10737                     goto error_return;
10738                   sub->output_has_begun = TRUE;
10739                 }
10740             }
10741           else if (p->type == bfd_section_reloc_link_order
10742                    || p->type == bfd_symbol_reloc_link_order)
10743             {
10744               if (! elf_reloc_link_order (abfd, info, o, p))
10745                 goto error_return;
10746             }
10747           else
10748             {
10749               if (! _bfd_default_link_order (abfd, info, o, p))
10750                 {
10751                   if (p->type == bfd_indirect_link_order
10752                       && (bfd_get_flavour (sub)
10753                           == bfd_target_elf_flavour)
10754                       && (elf_elfheader (sub)->e_ident[EI_CLASS]
10755                           != bed->s->elfclass))
10756                     {
10757                       const char *iclass, *oclass;
10758
10759                       if (bed->s->elfclass == ELFCLASS64)
10760                         {
10761                           iclass = "ELFCLASS32";
10762                           oclass = "ELFCLASS64";
10763                         }
10764                       else
10765                         {
10766                           iclass = "ELFCLASS64";
10767                           oclass = "ELFCLASS32";
10768                         }
10769
10770                       bfd_set_error (bfd_error_wrong_format);
10771                       (*_bfd_error_handler)
10772                         (_("%B: file class %s incompatible with %s"),
10773                          sub, iclass, oclass);
10774                     }
10775
10776                   goto error_return;
10777                 }
10778             }
10779         }
10780     }
10781
10782   /* Free symbol buffer if needed.  */
10783   if (!info->reduce_memory_overheads)
10784     {
10785       for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10786         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10787             && elf_tdata (sub)->symbuf)
10788           {
10789             free (elf_tdata (sub)->symbuf);
10790             elf_tdata (sub)->symbuf = NULL;
10791           }
10792     }
10793
10794   /* Output any global symbols that got converted to local in a
10795      version script or due to symbol visibility.  We do this in a
10796      separate step since ELF requires all local symbols to appear
10797      prior to any global symbols.  FIXME: We should only do this if
10798      some global symbols were, in fact, converted to become local.
10799      FIXME: Will this work correctly with the Irix 5 linker?  */
10800   eoinfo.failed = FALSE;
10801   eoinfo.finfo = &finfo;
10802   eoinfo.localsyms = TRUE;
10803   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
10804   if (eoinfo.failed)
10805     return FALSE;
10806
10807   /* If backend needs to output some local symbols not present in the hash
10808      table, do it now.  */
10809   if (bed->elf_backend_output_arch_local_syms)
10810     {
10811       typedef int (*out_sym_func)
10812         (void *, const char *, Elf_Internal_Sym *, asection *,
10813          struct elf_link_hash_entry *);
10814
10815       if (! ((*bed->elf_backend_output_arch_local_syms)
10816              (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10817         return FALSE;
10818     }
10819
10820   /* That wrote out all the local symbols.  Finish up the symbol table
10821      with the global symbols. Even if we want to strip everything we
10822      can, we still need to deal with those global symbols that got
10823      converted to local in a version script.  */
10824
10825   /* The sh_info field records the index of the first non local symbol.  */
10826   symtab_hdr->sh_info = bfd_get_symcount (abfd);
10827
10828   if (dynamic
10829       && finfo.dynsym_sec != NULL
10830       && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
10831     {
10832       Elf_Internal_Sym sym;
10833       bfd_byte *dynsym = finfo.dynsym_sec->contents;
10834       long last_local = 0;
10835
10836       /* Write out the section symbols for the output sections.  */
10837       if (info->shared || elf_hash_table (info)->is_relocatable_executable)
10838         {
10839           asection *s;
10840
10841           sym.st_size = 0;
10842           sym.st_name = 0;
10843           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10844           sym.st_other = 0;
10845           sym.st_target_internal = 0;
10846
10847           for (s = abfd->sections; s != NULL; s = s->next)
10848             {
10849               int indx;
10850               bfd_byte *dest;
10851               long dynindx;
10852
10853               dynindx = elf_section_data (s)->dynindx;
10854               if (dynindx <= 0)
10855                 continue;
10856               indx = elf_section_data (s)->this_idx;
10857               BFD_ASSERT (indx > 0);
10858               sym.st_shndx = indx;
10859               if (! check_dynsym (abfd, &sym))
10860                 return FALSE;
10861               sym.st_value = s->vma;
10862               dest = dynsym + dynindx * bed->s->sizeof_sym;
10863               if (last_local < dynindx)
10864                 last_local = dynindx;
10865               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10866             }
10867         }
10868
10869       /* Write out the local dynsyms.  */
10870       if (elf_hash_table (info)->dynlocal)
10871         {
10872           struct elf_link_local_dynamic_entry *e;
10873           for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
10874             {
10875               asection *s;
10876               bfd_byte *dest;
10877
10878               /* Copy the internal symbol and turn off visibility.
10879                  Note that we saved a word of storage and overwrote
10880                  the original st_name with the dynstr_index.  */
10881               sym = e->isym;
10882               sym.st_other &= ~ELF_ST_VISIBILITY (-1);
10883
10884               s = bfd_section_from_elf_index (e->input_bfd,
10885                                               e->isym.st_shndx);
10886               if (s != NULL)
10887                 {
10888                   sym.st_shndx =
10889                     elf_section_data (s->output_section)->this_idx;
10890                   if (! check_dynsym (abfd, &sym))
10891                     return FALSE;
10892                   sym.st_value = (s->output_section->vma
10893                                   + s->output_offset
10894                                   + e->isym.st_value);
10895                 }
10896
10897               if (last_local < e->dynindx)
10898                 last_local = e->dynindx;
10899
10900               dest = dynsym + e->dynindx * bed->s->sizeof_sym;
10901               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10902             }
10903         }
10904
10905       elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
10906         last_local + 1;
10907     }
10908
10909   /* We get the global symbols from the hash table.  */
10910   eoinfo.failed = FALSE;
10911   eoinfo.localsyms = FALSE;
10912   eoinfo.finfo = &finfo;
10913   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
10914   if (eoinfo.failed)
10915     return FALSE;
10916
10917   /* If backend needs to output some symbols not present in the hash
10918      table, do it now.  */
10919   if (bed->elf_backend_output_arch_syms)
10920     {
10921       typedef int (*out_sym_func)
10922         (void *, const char *, Elf_Internal_Sym *, asection *,
10923          struct elf_link_hash_entry *);
10924
10925       if (! ((*bed->elf_backend_output_arch_syms)
10926              (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10927         return FALSE;
10928     }
10929
10930   /* Flush all symbols to the file.  */
10931   if (! elf_link_flush_output_syms (&finfo, bed))
10932     return FALSE;
10933
10934   /* Now we know the size of the symtab section.  */
10935   off += symtab_hdr->sh_size;
10936
10937   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
10938   if (symtab_shndx_hdr->sh_name != 0)
10939     {
10940       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
10941       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
10942       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
10943       amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
10944       symtab_shndx_hdr->sh_size = amt;
10945
10946       off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
10947                                                        off, TRUE);
10948
10949       if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
10950           || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt))
10951         return FALSE;
10952     }
10953
10954
10955   /* Finish up and write out the symbol string table (.strtab)
10956      section.  */
10957   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
10958   /* sh_name was set in prep_headers.  */
10959   symstrtab_hdr->sh_type = SHT_STRTAB;
10960   symstrtab_hdr->sh_flags = 0;
10961   symstrtab_hdr->sh_addr = 0;
10962   symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
10963   symstrtab_hdr->sh_entsize = 0;
10964   symstrtab_hdr->sh_link = 0;
10965   symstrtab_hdr->sh_info = 0;
10966   /* sh_offset is set just below.  */
10967   symstrtab_hdr->sh_addralign = 1;
10968
10969   off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
10970   elf_tdata (abfd)->next_file_pos = off;
10971
10972   if (bfd_get_symcount (abfd) > 0)
10973     {
10974       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
10975           || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
10976         return FALSE;
10977     }
10978
10979   /* Adjust the relocs to have the correct symbol indices.  */
10980   for (o = abfd->sections; o != NULL; o = o->next)
10981     {
10982       struct bfd_elf_section_data *esdo = elf_section_data (o);
10983       if ((o->flags & SEC_RELOC) == 0)
10984         continue;
10985
10986       if (esdo->rel.hdr != NULL)
10987         elf_link_adjust_relocs (abfd, &esdo->rel);
10988       if (esdo->rela.hdr != NULL)
10989         elf_link_adjust_relocs (abfd, &esdo->rela);
10990
10991       /* Set the reloc_count field to 0 to prevent write_relocs from
10992          trying to swap the relocs out itself.  */
10993       o->reloc_count = 0;
10994     }
10995
10996   if (dynamic && info->combreloc && dynobj != NULL)
10997     relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
10998
10999   /* If we are linking against a dynamic object, or generating a
11000      shared library, finish up the dynamic linking information.  */
11001   if (dynamic)
11002     {
11003       bfd_byte *dyncon, *dynconend;
11004
11005       /* Fix up .dynamic entries.  */
11006       o = bfd_get_section_by_name (dynobj, ".dynamic");
11007       BFD_ASSERT (o != NULL);
11008
11009       dyncon = o->contents;
11010       dynconend = o->contents + o->size;
11011       for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11012         {
11013           Elf_Internal_Dyn dyn;
11014           const char *name;
11015           unsigned int type;
11016
11017           bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11018
11019           switch (dyn.d_tag)
11020             {
11021             default:
11022               continue;
11023             case DT_NULL:
11024               if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11025                 {
11026                   switch (elf_section_data (reldyn)->this_hdr.sh_type)
11027                     {
11028                     case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11029                     case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11030                     default: continue;
11031                     }
11032                   dyn.d_un.d_val = relativecount;
11033                   relativecount = 0;
11034                   break;
11035                 }
11036               continue;
11037
11038             case DT_INIT:
11039               name = info->init_function;
11040               goto get_sym;
11041             case DT_FINI:
11042               name = info->fini_function;
11043             get_sym:
11044               {
11045                 struct elf_link_hash_entry *h;
11046
11047                 h = elf_link_hash_lookup (elf_hash_table (info), name,
11048                                           FALSE, FALSE, TRUE);
11049                 if (h != NULL
11050                     && (h->root.type == bfd_link_hash_defined
11051                         || h->root.type == bfd_link_hash_defweak))
11052                   {
11053                     dyn.d_un.d_ptr = h->root.u.def.value;
11054                     o = h->root.u.def.section;
11055                     if (o->output_section != NULL)
11056                       dyn.d_un.d_ptr += (o->output_section->vma
11057                                          + o->output_offset);
11058                     else
11059                       {
11060                         /* The symbol is imported from another shared
11061                            library and does not apply to this one.  */
11062                         dyn.d_un.d_ptr = 0;
11063                       }
11064                     break;
11065                   }
11066               }
11067               continue;
11068
11069             case DT_PREINIT_ARRAYSZ:
11070               name = ".preinit_array";
11071               goto get_size;
11072             case DT_INIT_ARRAYSZ:
11073               name = ".init_array";
11074               goto get_size;
11075             case DT_FINI_ARRAYSZ:
11076               name = ".fini_array";
11077             get_size:
11078               o = bfd_get_section_by_name (abfd, name);
11079               if (o == NULL)
11080                 {
11081                   (*_bfd_error_handler)
11082                     (_("%B: could not find output section %s"), abfd, name);
11083                   goto error_return;
11084                 }
11085               if (o->size == 0)
11086                 (*_bfd_error_handler)
11087                   (_("warning: %s section has zero size"), name);
11088               dyn.d_un.d_val = o->size;
11089               break;
11090
11091             case DT_PREINIT_ARRAY:
11092               name = ".preinit_array";
11093               goto get_vma;
11094             case DT_INIT_ARRAY:
11095               name = ".init_array";
11096               goto get_vma;
11097             case DT_FINI_ARRAY:
11098               name = ".fini_array";
11099               goto get_vma;
11100
11101             case DT_HASH:
11102               name = ".hash";
11103               goto get_vma;
11104             case DT_GNU_HASH:
11105               name = ".gnu.hash";
11106               goto get_vma;
11107             case DT_STRTAB:
11108               name = ".dynstr";
11109               goto get_vma;
11110             case DT_SYMTAB:
11111               name = ".dynsym";
11112               goto get_vma;
11113             case DT_VERDEF:
11114               name = ".gnu.version_d";
11115               goto get_vma;
11116             case DT_VERNEED:
11117               name = ".gnu.version_r";
11118               goto get_vma;
11119             case DT_VERSYM:
11120               name = ".gnu.version";
11121             get_vma:
11122               o = bfd_get_section_by_name (abfd, name);
11123               if (o == NULL)
11124                 {
11125                   (*_bfd_error_handler)
11126                     (_("%B: could not find output section %s"), abfd, name);
11127                   goto error_return;
11128                 }
11129               if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11130                 {
11131                   (*_bfd_error_handler)
11132                     (_("warning: section '%s' is being made into a note"), name);
11133                   bfd_set_error (bfd_error_nonrepresentable_section);
11134                   goto error_return;
11135                 }
11136               dyn.d_un.d_ptr = o->vma;
11137               break;
11138
11139             case DT_REL:
11140             case DT_RELA:
11141             case DT_RELSZ:
11142             case DT_RELASZ:
11143               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11144                 type = SHT_REL;
11145               else
11146                 type = SHT_RELA;
11147               dyn.d_un.d_val = 0;
11148               dyn.d_un.d_ptr = 0;
11149               for (i = 1; i < elf_numsections (abfd); i++)
11150                 {
11151                   Elf_Internal_Shdr *hdr;
11152
11153                   hdr = elf_elfsections (abfd)[i];
11154                   if (hdr->sh_type == type
11155                       && (hdr->sh_flags & SHF_ALLOC) != 0)
11156                     {
11157                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11158                         dyn.d_un.d_val += hdr->sh_size;
11159                       else
11160                         {
11161                           if (dyn.d_un.d_ptr == 0
11162                               || hdr->sh_addr < dyn.d_un.d_ptr)
11163                             dyn.d_un.d_ptr = hdr->sh_addr;
11164                         }
11165                     }
11166                 }
11167               break;
11168             }
11169           bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11170         }
11171     }
11172
11173   /* If we have created any dynamic sections, then output them.  */
11174   if (dynobj != NULL)
11175     {
11176       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11177         goto error_return;
11178
11179       /* Check for DT_TEXTREL (late, in case the backend removes it).  */
11180       if (((info->warn_shared_textrel && info->shared)
11181            || info->error_textrel)
11182           && (o = bfd_get_section_by_name (dynobj, ".dynamic")) != NULL)
11183         {
11184           bfd_byte *dyncon, *dynconend;
11185
11186           dyncon = o->contents;
11187           dynconend = o->contents + o->size;
11188           for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11189             {
11190               Elf_Internal_Dyn dyn;
11191
11192               bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11193
11194               if (dyn.d_tag == DT_TEXTREL)
11195                 {
11196                   if (info->error_textrel)
11197                     info->callbacks->einfo
11198                       (_("%P%X: read-only segment has dynamic relocations.\n"));
11199                   else
11200                     info->callbacks->einfo
11201                       (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11202                   break;
11203                 }
11204             }
11205         }
11206
11207       for (o = dynobj->sections; o != NULL; o = o->next)
11208         {
11209           if ((o->flags & SEC_HAS_CONTENTS) == 0
11210               || o->size == 0
11211               || o->output_section == bfd_abs_section_ptr)
11212             continue;
11213           if ((o->flags & SEC_LINKER_CREATED) == 0)
11214             {
11215               /* At this point, we are only interested in sections
11216                  created by _bfd_elf_link_create_dynamic_sections.  */
11217               continue;
11218             }
11219           if (elf_hash_table (info)->stab_info.stabstr == o)
11220             continue;
11221           if (elf_hash_table (info)->eh_info.hdr_sec == o)
11222             continue;
11223           if ((elf_section_data (o->output_section)->this_hdr.sh_type
11224                != SHT_STRTAB)
11225               && (strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0))
11226             {
11227               /* FIXME: octets_per_byte.  */
11228               if (! bfd_set_section_contents (abfd, o->output_section,
11229                                               o->contents,
11230                                               (file_ptr) o->output_offset,
11231                                               o->size))
11232                 goto error_return;
11233             }
11234           else
11235             {
11236               /* The contents of the .dynstr section are actually in a
11237                  stringtab.  */
11238               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11239               if (bfd_seek (abfd, off, SEEK_SET) != 0
11240                   || ! _bfd_elf_strtab_emit (abfd,
11241                                              elf_hash_table (info)->dynstr))
11242                 goto error_return;
11243             }
11244         }
11245     }
11246
11247   if (info->relocatable)
11248     {
11249       bfd_boolean failed = FALSE;
11250
11251       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11252       if (failed)
11253         goto error_return;
11254     }
11255
11256   /* If we have optimized stabs strings, output them.  */
11257   if (elf_hash_table (info)->stab_info.stabstr != NULL)
11258     {
11259       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11260         goto error_return;
11261     }
11262
11263   if (info->eh_frame_hdr)
11264     {
11265       if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11266         goto error_return;
11267     }
11268
11269   if (finfo.symstrtab != NULL)
11270     _bfd_stringtab_free (finfo.symstrtab);
11271   if (finfo.contents != NULL)
11272     free (finfo.contents);
11273   if (finfo.external_relocs != NULL)
11274     free (finfo.external_relocs);
11275   if (finfo.internal_relocs != NULL)
11276     free (finfo.internal_relocs);
11277   if (finfo.external_syms != NULL)
11278     free (finfo.external_syms);
11279   if (finfo.locsym_shndx != NULL)
11280     free (finfo.locsym_shndx);
11281   if (finfo.internal_syms != NULL)
11282     free (finfo.internal_syms);
11283   if (finfo.indices != NULL)
11284     free (finfo.indices);
11285   if (finfo.sections != NULL)
11286     free (finfo.sections);
11287   if (finfo.symbuf != NULL)
11288     free (finfo.symbuf);
11289   if (finfo.symshndxbuf != NULL)
11290     free (finfo.symshndxbuf);
11291   for (o = abfd->sections; o != NULL; o = o->next)
11292     {
11293       struct bfd_elf_section_data *esdo = elf_section_data (o);
11294       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
11295         free (esdo->rel.hashes);
11296       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
11297         free (esdo->rela.hashes);
11298     }
11299
11300   elf_tdata (abfd)->linker = TRUE;
11301
11302   if (attr_section)
11303     {
11304       bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11305       if (contents == NULL)
11306         return FALSE;   /* Bail out and fail.  */
11307       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11308       bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11309       free (contents);
11310     }
11311
11312   return TRUE;
11313
11314  error_return:
11315   if (finfo.symstrtab != NULL)
11316     _bfd_stringtab_free (finfo.symstrtab);
11317   if (finfo.contents != NULL)
11318     free (finfo.contents);
11319   if (finfo.external_relocs != NULL)
11320     free (finfo.external_relocs);
11321   if (finfo.internal_relocs != NULL)
11322     free (finfo.internal_relocs);
11323   if (finfo.external_syms != NULL)
11324     free (finfo.external_syms);
11325   if (finfo.locsym_shndx != NULL)
11326     free (finfo.locsym_shndx);
11327   if (finfo.internal_syms != NULL)
11328     free (finfo.internal_syms);
11329   if (finfo.indices != NULL)
11330     free (finfo.indices);
11331   if (finfo.sections != NULL)
11332     free (finfo.sections);
11333   if (finfo.symbuf != NULL)
11334     free (finfo.symbuf);
11335   if (finfo.symshndxbuf != NULL)
11336     free (finfo.symshndxbuf);
11337   for (o = abfd->sections; o != NULL; o = o->next)
11338     {
11339       struct bfd_elf_section_data *esdo = elf_section_data (o);
11340       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
11341         free (esdo->rel.hashes);
11342       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
11343         free (esdo->rela.hashes);
11344     }
11345
11346   return FALSE;
11347 }
11348 \f
11349 /* Initialize COOKIE for input bfd ABFD.  */
11350
11351 static bfd_boolean
11352 init_reloc_cookie (struct elf_reloc_cookie *cookie,
11353                    struct bfd_link_info *info, bfd *abfd)
11354 {
11355   Elf_Internal_Shdr *symtab_hdr;
11356   const struct elf_backend_data *bed;
11357
11358   bed = get_elf_backend_data (abfd);
11359   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11360
11361   cookie->abfd = abfd;
11362   cookie->sym_hashes = elf_sym_hashes (abfd);
11363   cookie->bad_symtab = elf_bad_symtab (abfd);
11364   if (cookie->bad_symtab)
11365     {
11366       cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11367       cookie->extsymoff = 0;
11368     }
11369   else
11370     {
11371       cookie->locsymcount = symtab_hdr->sh_info;
11372       cookie->extsymoff = symtab_hdr->sh_info;
11373     }
11374
11375   if (bed->s->arch_size == 32)
11376     cookie->r_sym_shift = 8;
11377   else
11378     cookie->r_sym_shift = 32;
11379
11380   cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11381   if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11382     {
11383       cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11384                                               cookie->locsymcount, 0,
11385                                               NULL, NULL, NULL);
11386       if (cookie->locsyms == NULL)
11387         {
11388           info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11389           return FALSE;
11390         }
11391       if (info->keep_memory)
11392         symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11393     }
11394   return TRUE;
11395 }
11396
11397 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
11398
11399 static void
11400 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11401 {
11402   Elf_Internal_Shdr *symtab_hdr;
11403
11404   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11405   if (cookie->locsyms != NULL
11406       && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11407     free (cookie->locsyms);
11408 }
11409
11410 /* Initialize the relocation information in COOKIE for input section SEC
11411    of input bfd ABFD.  */
11412
11413 static bfd_boolean
11414 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11415                         struct bfd_link_info *info, bfd *abfd,
11416                         asection *sec)
11417 {
11418   const struct elf_backend_data *bed;
11419
11420   if (sec->reloc_count == 0)
11421     {
11422       cookie->rels = NULL;
11423       cookie->relend = NULL;
11424     }
11425   else
11426     {
11427       bed = get_elf_backend_data (abfd);
11428
11429       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11430                                                 info->keep_memory);
11431       if (cookie->rels == NULL)
11432         return FALSE;
11433       cookie->rel = cookie->rels;
11434       cookie->relend = (cookie->rels
11435                         + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11436     }
11437   cookie->rel = cookie->rels;
11438   return TRUE;
11439 }
11440
11441 /* Free the memory allocated by init_reloc_cookie_rels,
11442    if appropriate.  */
11443
11444 static void
11445 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11446                         asection *sec)
11447 {
11448   if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11449     free (cookie->rels);
11450 }
11451
11452 /* Initialize the whole of COOKIE for input section SEC.  */
11453
11454 static bfd_boolean
11455 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11456                                struct bfd_link_info *info,
11457                                asection *sec)
11458 {
11459   if (!init_reloc_cookie (cookie, info, sec->owner))
11460     goto error1;
11461   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11462     goto error2;
11463   return TRUE;
11464
11465  error2:
11466   fini_reloc_cookie (cookie, sec->owner);
11467  error1:
11468   return FALSE;
11469 }
11470
11471 /* Free the memory allocated by init_reloc_cookie_for_section,
11472    if appropriate.  */
11473
11474 static void
11475 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11476                                asection *sec)
11477 {
11478   fini_reloc_cookie_rels (cookie, sec);
11479   fini_reloc_cookie (cookie, sec->owner);
11480 }
11481 \f
11482 /* Garbage collect unused sections.  */
11483
11484 /* Default gc_mark_hook.  */
11485
11486 asection *
11487 _bfd_elf_gc_mark_hook (asection *sec,
11488                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
11489                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11490                        struct elf_link_hash_entry *h,
11491                        Elf_Internal_Sym *sym)
11492 {
11493   const char *sec_name;
11494
11495   if (h != NULL)
11496     {
11497       switch (h->root.type)
11498         {
11499         case bfd_link_hash_defined:
11500         case bfd_link_hash_defweak:
11501           return h->root.u.def.section;
11502
11503         case bfd_link_hash_common:
11504           return h->root.u.c.p->section;
11505
11506         case bfd_link_hash_undefined:
11507         case bfd_link_hash_undefweak:
11508           /* To work around a glibc bug, keep all XXX input sections
11509              when there is an as yet undefined reference to __start_XXX
11510              or __stop_XXX symbols.  The linker will later define such
11511              symbols for orphan input sections that have a name
11512              representable as a C identifier.  */
11513           if (strncmp (h->root.root.string, "__start_", 8) == 0)
11514             sec_name = h->root.root.string + 8;
11515           else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11516             sec_name = h->root.root.string + 7;
11517           else
11518             sec_name = NULL;
11519
11520           if (sec_name && *sec_name != '\0')
11521             {
11522               bfd *i;
11523               
11524               for (i = info->input_bfds; i; i = i->link_next)
11525                 {
11526                   sec = bfd_get_section_by_name (i, sec_name);
11527                   if (sec)
11528                     sec->flags |= SEC_KEEP;
11529                 }
11530             }
11531           break;
11532
11533         default:
11534           break;
11535         }
11536     }
11537   else
11538     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11539
11540   return NULL;
11541 }
11542
11543 /* COOKIE->rel describes a relocation against section SEC, which is
11544    a section we've decided to keep.  Return the section that contains
11545    the relocation symbol, or NULL if no section contains it.  */
11546
11547 asection *
11548 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11549                        elf_gc_mark_hook_fn gc_mark_hook,
11550                        struct elf_reloc_cookie *cookie)
11551 {
11552   unsigned long r_symndx;
11553   struct elf_link_hash_entry *h;
11554
11555   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11556   if (r_symndx == STN_UNDEF)
11557     return NULL;
11558
11559   if (r_symndx >= cookie->locsymcount
11560       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11561     {
11562       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11563       while (h->root.type == bfd_link_hash_indirect
11564              || h->root.type == bfd_link_hash_warning)
11565         h = (struct elf_link_hash_entry *) h->root.u.i.link;
11566       h->mark = 1;
11567       /* If this symbol is weak and there is a non-weak definition, we
11568          keep the non-weak definition because many backends put
11569          dynamic reloc info on the non-weak definition for code
11570          handling copy relocs.  */
11571       if (h->u.weakdef != NULL)
11572         h->u.weakdef->mark = 1;
11573       return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11574     }
11575
11576   return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11577                           &cookie->locsyms[r_symndx]);
11578 }
11579
11580 /* COOKIE->rel describes a relocation against section SEC, which is
11581    a section we've decided to keep.  Mark the section that contains
11582    the relocation symbol.  */
11583
11584 bfd_boolean
11585 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11586                         asection *sec,
11587                         elf_gc_mark_hook_fn gc_mark_hook,
11588                         struct elf_reloc_cookie *cookie)
11589 {
11590   asection *rsec;
11591
11592   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11593   if (rsec && !rsec->gc_mark)
11594     {
11595       if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
11596           || (rsec->owner->flags & DYNAMIC) != 0)
11597         rsec->gc_mark = 1;
11598       else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11599         return FALSE;
11600     }
11601   return TRUE;
11602 }
11603
11604 /* The mark phase of garbage collection.  For a given section, mark
11605    it and any sections in this section's group, and all the sections
11606    which define symbols to which it refers.  */
11607
11608 bfd_boolean
11609 _bfd_elf_gc_mark (struct bfd_link_info *info,
11610                   asection *sec,
11611                   elf_gc_mark_hook_fn gc_mark_hook)
11612 {
11613   bfd_boolean ret;
11614   asection *group_sec, *eh_frame;
11615
11616   sec->gc_mark = 1;
11617
11618   /* Mark all the sections in the group.  */
11619   group_sec = elf_section_data (sec)->next_in_group;
11620   if (group_sec && !group_sec->gc_mark)
11621     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11622       return FALSE;
11623
11624   /* Look through the section relocs.  */
11625   ret = TRUE;
11626   eh_frame = elf_eh_frame_section (sec->owner);
11627   if ((sec->flags & SEC_RELOC) != 0
11628       && sec->reloc_count > 0
11629       && sec != eh_frame)
11630     {
11631       struct elf_reloc_cookie cookie;
11632
11633       if (!init_reloc_cookie_for_section (&cookie, info, sec))
11634         ret = FALSE;
11635       else
11636         {
11637           for (; cookie.rel < cookie.relend; cookie.rel++)
11638             if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11639               {
11640                 ret = FALSE;
11641                 break;
11642               }
11643           fini_reloc_cookie_for_section (&cookie, sec);
11644         }
11645     }
11646
11647   if (ret && eh_frame && elf_fde_list (sec))
11648     {
11649       struct elf_reloc_cookie cookie;
11650
11651       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11652         ret = FALSE;
11653       else
11654         {
11655           if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11656                                       gc_mark_hook, &cookie))
11657             ret = FALSE;
11658           fini_reloc_cookie_for_section (&cookie, eh_frame);
11659         }
11660     }
11661
11662   return ret;
11663 }
11664
11665 /* Keep debug and special sections.  */
11666
11667 bfd_boolean
11668 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
11669                                  elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
11670 {
11671   bfd *ibfd;
11672
11673   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11674     {
11675       asection *isec;
11676       bfd_boolean some_kept;
11677
11678       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
11679         continue;
11680
11681       /* Ensure all linker created sections are kept, and see whether
11682          any other section is already marked.  */
11683       some_kept = FALSE;
11684       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11685         {
11686           if ((isec->flags & SEC_LINKER_CREATED) != 0)
11687             isec->gc_mark = 1;
11688           else if (isec->gc_mark)
11689             some_kept = TRUE;
11690         }
11691
11692       /* If no section in this file will be kept, then we can
11693          toss out debug sections.  */
11694       if (!some_kept)
11695         continue;
11696
11697       /* Keep debug and special sections like .comment when they are
11698          not part of a group, or when we have single-member groups.  */
11699       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11700         if ((elf_next_in_group (isec) == NULL
11701              || elf_next_in_group (isec) == isec)
11702             && ((isec->flags & SEC_DEBUGGING) != 0
11703                 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0))
11704           isec->gc_mark = 1;
11705     }
11706   return TRUE;
11707 }
11708
11709 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
11710
11711 struct elf_gc_sweep_symbol_info
11712 {
11713   struct bfd_link_info *info;
11714   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
11715                        bfd_boolean);
11716 };
11717
11718 static bfd_boolean
11719 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
11720 {
11721   if (!h->mark
11722       && (((h->root.type == bfd_link_hash_defined
11723             || h->root.type == bfd_link_hash_defweak)
11724            && !(h->def_regular
11725                 && h->root.u.def.section->gc_mark))
11726           || h->root.type == bfd_link_hash_undefined
11727           || h->root.type == bfd_link_hash_undefweak))
11728     {
11729       struct elf_gc_sweep_symbol_info *inf;
11730
11731       inf = (struct elf_gc_sweep_symbol_info *) data;
11732       (*inf->hide_symbol) (inf->info, h, TRUE);
11733       h->def_regular = 0;
11734       h->ref_regular = 0;
11735       h->ref_regular_nonweak = 0;
11736     }
11737
11738   return TRUE;
11739 }
11740
11741 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
11742
11743 typedef bfd_boolean (*gc_sweep_hook_fn)
11744   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
11745
11746 static bfd_boolean
11747 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
11748 {
11749   bfd *sub;
11750   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11751   gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
11752   unsigned long section_sym_count;
11753   struct elf_gc_sweep_symbol_info sweep_info;
11754
11755   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11756     {
11757       asection *o;
11758
11759       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11760         continue;
11761
11762       for (o = sub->sections; o != NULL; o = o->next)
11763         {
11764           /* When any section in a section group is kept, we keep all
11765              sections in the section group.  If the first member of
11766              the section group is excluded, we will also exclude the
11767              group section.  */
11768           if (o->flags & SEC_GROUP)
11769             {
11770               asection *first = elf_next_in_group (o);
11771               o->gc_mark = first->gc_mark;
11772             }
11773
11774           if (o->gc_mark)
11775             continue;
11776
11777           /* Skip sweeping sections already excluded.  */
11778           if (o->flags & SEC_EXCLUDE)
11779             continue;
11780
11781           /* Since this is early in the link process, it is simple
11782              to remove a section from the output.  */
11783           o->flags |= SEC_EXCLUDE;
11784
11785           if (info->print_gc_sections && o->size != 0)
11786             _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
11787
11788           /* But we also have to update some of the relocation
11789              info we collected before.  */
11790           if (gc_sweep_hook
11791               && (o->flags & SEC_RELOC) != 0
11792               && o->reloc_count > 0
11793               && !bfd_is_abs_section (o->output_section))
11794             {
11795               Elf_Internal_Rela *internal_relocs;
11796               bfd_boolean r;
11797
11798               internal_relocs
11799                 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
11800                                              info->keep_memory);
11801               if (internal_relocs == NULL)
11802                 return FALSE;
11803
11804               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
11805
11806               if (elf_section_data (o)->relocs != internal_relocs)
11807                 free (internal_relocs);
11808
11809               if (!r)
11810                 return FALSE;
11811             }
11812         }
11813     }
11814
11815   /* Remove the symbols that were in the swept sections from the dynamic
11816      symbol table.  GCFIXME: Anyone know how to get them out of the
11817      static symbol table as well?  */
11818   sweep_info.info = info;
11819   sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
11820   elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
11821                           &sweep_info);
11822
11823   _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
11824   return TRUE;
11825 }
11826
11827 /* Propagate collected vtable information.  This is called through
11828    elf_link_hash_traverse.  */
11829
11830 static bfd_boolean
11831 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
11832 {
11833   /* Those that are not vtables.  */
11834   if (h->vtable == NULL || h->vtable->parent == NULL)
11835     return TRUE;
11836
11837   /* Those vtables that do not have parents, we cannot merge.  */
11838   if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
11839     return TRUE;
11840
11841   /* If we've already been done, exit.  */
11842   if (h->vtable->used && h->vtable->used[-1])
11843     return TRUE;
11844
11845   /* Make sure the parent's table is up to date.  */
11846   elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
11847
11848   if (h->vtable->used == NULL)
11849     {
11850       /* None of this table's entries were referenced.  Re-use the
11851          parent's table.  */
11852       h->vtable->used = h->vtable->parent->vtable->used;
11853       h->vtable->size = h->vtable->parent->vtable->size;
11854     }
11855   else
11856     {
11857       size_t n;
11858       bfd_boolean *cu, *pu;
11859
11860       /* Or the parent's entries into ours.  */
11861       cu = h->vtable->used;
11862       cu[-1] = TRUE;
11863       pu = h->vtable->parent->vtable->used;
11864       if (pu != NULL)
11865         {
11866           const struct elf_backend_data *bed;
11867           unsigned int log_file_align;
11868
11869           bed = get_elf_backend_data (h->root.u.def.section->owner);
11870           log_file_align = bed->s->log_file_align;
11871           n = h->vtable->parent->vtable->size >> log_file_align;
11872           while (n--)
11873             {
11874               if (*pu)
11875                 *cu = TRUE;
11876               pu++;
11877               cu++;
11878             }
11879         }
11880     }
11881
11882   return TRUE;
11883 }
11884
11885 static bfd_boolean
11886 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
11887 {
11888   asection *sec;
11889   bfd_vma hstart, hend;
11890   Elf_Internal_Rela *relstart, *relend, *rel;
11891   const struct elf_backend_data *bed;
11892   unsigned int log_file_align;
11893
11894   /* Take care of both those symbols that do not describe vtables as
11895      well as those that are not loaded.  */
11896   if (h->vtable == NULL || h->vtable->parent == NULL)
11897     return TRUE;
11898
11899   BFD_ASSERT (h->root.type == bfd_link_hash_defined
11900               || h->root.type == bfd_link_hash_defweak);
11901
11902   sec = h->root.u.def.section;
11903   hstart = h->root.u.def.value;
11904   hend = hstart + h->size;
11905
11906   relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
11907   if (!relstart)
11908     return *(bfd_boolean *) okp = FALSE;
11909   bed = get_elf_backend_data (sec->owner);
11910   log_file_align = bed->s->log_file_align;
11911
11912   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
11913
11914   for (rel = relstart; rel < relend; ++rel)
11915     if (rel->r_offset >= hstart && rel->r_offset < hend)
11916       {
11917         /* If the entry is in use, do nothing.  */
11918         if (h->vtable->used
11919             && (rel->r_offset - hstart) < h->vtable->size)
11920           {
11921             bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
11922             if (h->vtable->used[entry])
11923               continue;
11924           }
11925         /* Otherwise, kill it.  */
11926         rel->r_offset = rel->r_info = rel->r_addend = 0;
11927       }
11928
11929   return TRUE;
11930 }
11931
11932 /* Mark sections containing dynamically referenced symbols.  When
11933    building shared libraries, we must assume that any visible symbol is
11934    referenced.  */
11935
11936 bfd_boolean
11937 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
11938 {
11939   struct bfd_link_info *info = (struct bfd_link_info *) inf;
11940
11941   if ((h->root.type == bfd_link_hash_defined
11942        || h->root.type == bfd_link_hash_defweak)
11943       && (h->ref_dynamic
11944           || ((!info->executable || info->export_dynamic)
11945               && h->def_regular
11946               && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
11947               && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
11948               && (strchr (h->root.root.string, ELF_VER_CHR) != NULL
11949                   || !bfd_hide_sym_by_version (info->version_info,
11950                                                h->root.root.string)))))
11951     h->root.u.def.section->flags |= SEC_KEEP;
11952
11953   return TRUE;
11954 }
11955
11956 /* Keep all sections containing symbols undefined on the command-line,
11957    and the section containing the entry symbol.  */
11958
11959 void
11960 _bfd_elf_gc_keep (struct bfd_link_info *info)
11961 {
11962   struct bfd_sym_chain *sym;
11963
11964   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
11965     {
11966       struct elf_link_hash_entry *h;
11967
11968       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
11969                                 FALSE, FALSE, FALSE);
11970
11971       if (h != NULL
11972           && (h->root.type == bfd_link_hash_defined
11973               || h->root.type == bfd_link_hash_defweak)
11974           && !bfd_is_abs_section (h->root.u.def.section))
11975         h->root.u.def.section->flags |= SEC_KEEP;
11976     }
11977 }
11978
11979 /* Do mark and sweep of unused sections.  */
11980
11981 bfd_boolean
11982 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
11983 {
11984   bfd_boolean ok = TRUE;
11985   bfd *sub;
11986   elf_gc_mark_hook_fn gc_mark_hook;
11987   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11988
11989   if (!bed->can_gc_sections
11990       || !is_elf_hash_table (info->hash))
11991     {
11992       (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
11993       return TRUE;
11994     }
11995
11996   bed->gc_keep (info);
11997
11998   /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
11999      at the .eh_frame section if we can mark the FDEs individually.  */
12000   _bfd_elf_begin_eh_frame_parsing (info);
12001   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12002     {
12003       asection *sec;
12004       struct elf_reloc_cookie cookie;
12005
12006       sec = bfd_get_section_by_name (sub, ".eh_frame");
12007       if (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12008         {
12009           _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12010           if (elf_section_data (sec)->sec_info)
12011             elf_eh_frame_section (sub) = sec;
12012           fini_reloc_cookie_for_section (&cookie, sec);
12013         }
12014     }
12015   _bfd_elf_end_eh_frame_parsing (info);
12016
12017   /* Apply transitive closure to the vtable entry usage info.  */
12018   elf_link_hash_traverse (elf_hash_table (info),
12019                           elf_gc_propagate_vtable_entries_used,
12020                           &ok);
12021   if (!ok)
12022     return FALSE;
12023
12024   /* Kill the vtable relocations that were not used.  */
12025   elf_link_hash_traverse (elf_hash_table (info),
12026                           elf_gc_smash_unused_vtentry_relocs,
12027                           &ok);
12028   if (!ok)
12029     return FALSE;
12030
12031   /* Mark dynamically referenced symbols.  */
12032   if (elf_hash_table (info)->dynamic_sections_created)
12033     elf_link_hash_traverse (elf_hash_table (info),
12034                             bed->gc_mark_dynamic_ref,
12035                             info);
12036
12037   /* Grovel through relocs to find out who stays ...  */
12038   gc_mark_hook = bed->gc_mark_hook;
12039   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12040     {
12041       asection *o;
12042
12043       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12044         continue;
12045
12046       /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12047          Also treat note sections as a root, if the section is not part
12048          of a group.  */
12049       for (o = sub->sections; o != NULL; o = o->next)
12050         if (!o->gc_mark
12051             && (o->flags & SEC_EXCLUDE) == 0
12052             && ((o->flags & SEC_KEEP) != 0
12053                 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12054                     && elf_next_in_group (o) == NULL )))
12055           {
12056             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12057               return FALSE;
12058           }
12059     }
12060
12061   /* Allow the backend to mark additional target specific sections.  */
12062   bed->gc_mark_extra_sections (info, gc_mark_hook);
12063
12064   /* ... and mark SEC_EXCLUDE for those that go.  */
12065   return elf_gc_sweep (abfd, info);
12066 }
12067 \f
12068 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
12069
12070 bfd_boolean
12071 bfd_elf_gc_record_vtinherit (bfd *abfd,
12072                              asection *sec,
12073                              struct elf_link_hash_entry *h,
12074                              bfd_vma offset)
12075 {
12076   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12077   struct elf_link_hash_entry **search, *child;
12078   bfd_size_type extsymcount;
12079   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12080
12081   /* The sh_info field of the symtab header tells us where the
12082      external symbols start.  We don't care about the local symbols at
12083      this point.  */
12084   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12085   if (!elf_bad_symtab (abfd))
12086     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12087
12088   sym_hashes = elf_sym_hashes (abfd);
12089   sym_hashes_end = sym_hashes + extsymcount;
12090
12091   /* Hunt down the child symbol, which is in this section at the same
12092      offset as the relocation.  */
12093   for (search = sym_hashes; search != sym_hashes_end; ++search)
12094     {
12095       if ((child = *search) != NULL
12096           && (child->root.type == bfd_link_hash_defined
12097               || child->root.type == bfd_link_hash_defweak)
12098           && child->root.u.def.section == sec
12099           && child->root.u.def.value == offset)
12100         goto win;
12101     }
12102
12103   (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12104                          abfd, sec, (unsigned long) offset);
12105   bfd_set_error (bfd_error_invalid_operation);
12106   return FALSE;
12107
12108  win:
12109   if (!child->vtable)
12110     {
12111       child->vtable = (struct elf_link_virtual_table_entry *)
12112           bfd_zalloc (abfd, sizeof (*child->vtable));
12113       if (!child->vtable)
12114         return FALSE;
12115     }
12116   if (!h)
12117     {
12118       /* This *should* only be the absolute section.  It could potentially
12119          be that someone has defined a non-global vtable though, which
12120          would be bad.  It isn't worth paging in the local symbols to be
12121          sure though; that case should simply be handled by the assembler.  */
12122
12123       child->vtable->parent = (struct elf_link_hash_entry *) -1;
12124     }
12125   else
12126     child->vtable->parent = h;
12127
12128   return TRUE;
12129 }
12130
12131 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
12132
12133 bfd_boolean
12134 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12135                            asection *sec ATTRIBUTE_UNUSED,
12136                            struct elf_link_hash_entry *h,
12137                            bfd_vma addend)
12138 {
12139   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12140   unsigned int log_file_align = bed->s->log_file_align;
12141
12142   if (!h->vtable)
12143     {
12144       h->vtable = (struct elf_link_virtual_table_entry *)
12145           bfd_zalloc (abfd, sizeof (*h->vtable));
12146       if (!h->vtable)
12147         return FALSE;
12148     }
12149
12150   if (addend >= h->vtable->size)
12151     {
12152       size_t size, bytes, file_align;
12153       bfd_boolean *ptr = h->vtable->used;
12154
12155       /* While the symbol is undefined, we have to be prepared to handle
12156          a zero size.  */
12157       file_align = 1 << log_file_align;
12158       if (h->root.type == bfd_link_hash_undefined)
12159         size = addend + file_align;
12160       else
12161         {
12162           size = h->size;
12163           if (addend >= size)
12164             {
12165               /* Oops!  We've got a reference past the defined end of
12166                  the table.  This is probably a bug -- shall we warn?  */
12167               size = addend + file_align;
12168             }
12169         }
12170       size = (size + file_align - 1) & -file_align;
12171
12172       /* Allocate one extra entry for use as a "done" flag for the
12173          consolidation pass.  */
12174       bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12175
12176       if (ptr)
12177         {
12178           ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12179
12180           if (ptr != NULL)
12181             {
12182               size_t oldbytes;
12183
12184               oldbytes = (((h->vtable->size >> log_file_align) + 1)
12185                           * sizeof (bfd_boolean));
12186               memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12187             }
12188         }
12189       else
12190         ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12191
12192       if (ptr == NULL)
12193         return FALSE;
12194
12195       /* And arrange for that done flag to be at index -1.  */
12196       h->vtable->used = ptr + 1;
12197       h->vtable->size = size;
12198     }
12199
12200   h->vtable->used[addend >> log_file_align] = TRUE;
12201
12202   return TRUE;
12203 }
12204
12205 /* Map an ELF section header flag to its corresponding string.  */
12206 typedef struct
12207 {
12208   char *flag_name;
12209   flagword flag_value;
12210 } elf_flags_to_name_table;
12211
12212 static elf_flags_to_name_table elf_flags_to_names [] =
12213 {
12214   { "SHF_WRITE", SHF_WRITE },
12215   { "SHF_ALLOC", SHF_ALLOC },
12216   { "SHF_EXECINSTR", SHF_EXECINSTR },
12217   { "SHF_MERGE", SHF_MERGE },
12218   { "SHF_STRINGS", SHF_STRINGS },
12219   { "SHF_INFO_LINK", SHF_INFO_LINK},
12220   { "SHF_LINK_ORDER", SHF_LINK_ORDER},
12221   { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12222   { "SHF_GROUP", SHF_GROUP },
12223   { "SHF_TLS", SHF_TLS },
12224   { "SHF_MASKOS", SHF_MASKOS },
12225   { "SHF_EXCLUDE", SHF_EXCLUDE },
12226 };
12227
12228 void
12229 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12230                               struct flag_info *finfo)
12231 {
12232   bfd *output_bfd = info->output_bfd;
12233   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
12234   struct flag_info_list *tf = finfo->flag_list;
12235   int with_hex = 0;
12236   int without_hex = 0;
12237
12238   for (tf = finfo->flag_list; tf != NULL; tf = tf->next)
12239     {
12240       int i;
12241       if (bed->elf_backend_lookup_section_flags_hook)
12242         {
12243           flagword hexval =
12244              (*bed->elf_backend_lookup_section_flags_hook) ((char *) tf->name);
12245
12246           if (hexval != 0)
12247             {
12248               if (tf->with == with_flags)
12249                 with_hex |= hexval;
12250               else if (tf->with == without_flags)
12251                 without_hex |= hexval;
12252               tf->valid = TRUE;
12253               continue;
12254             }
12255         }
12256       for (i = 0; i < 12; i++)
12257         {
12258           if (!strcmp (tf->name, elf_flags_to_names[i].flag_name))
12259             {
12260               if (tf->with == with_flags)
12261                 with_hex |= elf_flags_to_names[i].flag_value;
12262               else if (tf->with == without_flags)
12263                 without_hex |= elf_flags_to_names[i].flag_value;
12264               tf->valid = TRUE;
12265               continue;
12266             }
12267         }
12268       if (tf->valid == FALSE)
12269         {
12270           info->callbacks->einfo 
12271                 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12272           return;
12273         }
12274     }
12275  finfo->flags_initialized = TRUE;
12276  finfo->only_with_flags |= with_hex;
12277  finfo->not_with_flags |= without_hex;
12278
12279  return;
12280 }
12281
12282 struct alloc_got_off_arg {
12283   bfd_vma gotoff;
12284   struct bfd_link_info *info;
12285 };
12286
12287 /* We need a special top-level link routine to convert got reference counts
12288    to real got offsets.  */
12289
12290 static bfd_boolean
12291 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12292 {
12293   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12294   bfd *obfd = gofarg->info->output_bfd;
12295   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12296
12297   if (h->got.refcount > 0)
12298     {
12299       h->got.offset = gofarg->gotoff;
12300       gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12301     }
12302   else
12303     h->got.offset = (bfd_vma) -1;
12304
12305   return TRUE;
12306 }
12307
12308 /* And an accompanying bit to work out final got entry offsets once
12309    we're done.  Should be called from final_link.  */
12310
12311 bfd_boolean
12312 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12313                                         struct bfd_link_info *info)
12314 {
12315   bfd *i;
12316   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12317   bfd_vma gotoff;
12318   struct alloc_got_off_arg gofarg;
12319
12320   BFD_ASSERT (abfd == info->output_bfd);
12321
12322   if (! is_elf_hash_table (info->hash))
12323     return FALSE;
12324
12325   /* The GOT offset is relative to the .got section, but the GOT header is
12326      put into the .got.plt section, if the backend uses it.  */
12327   if (bed->want_got_plt)
12328     gotoff = 0;
12329   else
12330     gotoff = bed->got_header_size;
12331
12332   /* Do the local .got entries first.  */
12333   for (i = info->input_bfds; i; i = i->link_next)
12334     {
12335       bfd_signed_vma *local_got;
12336       bfd_size_type j, locsymcount;
12337       Elf_Internal_Shdr *symtab_hdr;
12338
12339       if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12340         continue;
12341
12342       local_got = elf_local_got_refcounts (i);
12343       if (!local_got)
12344         continue;
12345
12346       symtab_hdr = &elf_tdata (i)->symtab_hdr;
12347       if (elf_bad_symtab (i))
12348         locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12349       else
12350         locsymcount = symtab_hdr->sh_info;
12351
12352       for (j = 0; j < locsymcount; ++j)
12353         {
12354           if (local_got[j] > 0)
12355             {
12356               local_got[j] = gotoff;
12357               gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12358             }
12359           else
12360             local_got[j] = (bfd_vma) -1;
12361         }
12362     }
12363
12364   /* Then the global .got entries.  .plt refcounts are handled by
12365      adjust_dynamic_symbol  */
12366   gofarg.gotoff = gotoff;
12367   gofarg.info = info;
12368   elf_link_hash_traverse (elf_hash_table (info),
12369                           elf_gc_allocate_got_offsets,
12370                           &gofarg);
12371   return TRUE;
12372 }
12373
12374 /* Many folk need no more in the way of final link than this, once
12375    got entry reference counting is enabled.  */
12376
12377 bfd_boolean
12378 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12379 {
12380   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12381     return FALSE;
12382
12383   /* Invoke the regular ELF backend linker to do all the work.  */
12384   return bfd_elf_final_link (abfd, info);
12385 }
12386
12387 bfd_boolean
12388 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12389 {
12390   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12391
12392   if (rcookie->bad_symtab)
12393     rcookie->rel = rcookie->rels;
12394
12395   for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12396     {
12397       unsigned long r_symndx;
12398
12399       if (! rcookie->bad_symtab)
12400         if (rcookie->rel->r_offset > offset)
12401           return FALSE;
12402       if (rcookie->rel->r_offset != offset)
12403         continue;
12404
12405       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12406       if (r_symndx == STN_UNDEF)
12407         return TRUE;
12408
12409       if (r_symndx >= rcookie->locsymcount
12410           || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12411         {
12412           struct elf_link_hash_entry *h;
12413
12414           h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12415
12416           while (h->root.type == bfd_link_hash_indirect
12417                  || h->root.type == bfd_link_hash_warning)
12418             h = (struct elf_link_hash_entry *) h->root.u.i.link;
12419
12420           if ((h->root.type == bfd_link_hash_defined
12421                || h->root.type == bfd_link_hash_defweak)
12422               && elf_discarded_section (h->root.u.def.section))
12423             return TRUE;
12424           else
12425             return FALSE;
12426         }
12427       else
12428         {
12429           /* It's not a relocation against a global symbol,
12430              but it could be a relocation against a local
12431              symbol for a discarded section.  */
12432           asection *isec;
12433           Elf_Internal_Sym *isym;
12434
12435           /* Need to: get the symbol; get the section.  */
12436           isym = &rcookie->locsyms[r_symndx];
12437           isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12438           if (isec != NULL && elf_discarded_section (isec))
12439             return TRUE;
12440         }
12441       return FALSE;
12442     }
12443   return FALSE;
12444 }
12445
12446 /* Discard unneeded references to discarded sections.
12447    Returns TRUE if any section's size was changed.  */
12448 /* This function assumes that the relocations are in sorted order,
12449    which is true for all known assemblers.  */
12450
12451 bfd_boolean
12452 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12453 {
12454   struct elf_reloc_cookie cookie;
12455   asection *stab, *eh;
12456   const struct elf_backend_data *bed;
12457   bfd *abfd;
12458   bfd_boolean ret = FALSE;
12459
12460   if (info->traditional_format
12461       || !is_elf_hash_table (info->hash))
12462     return FALSE;
12463
12464   _bfd_elf_begin_eh_frame_parsing (info);
12465   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
12466     {
12467       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12468         continue;
12469
12470       bed = get_elf_backend_data (abfd);
12471
12472       if ((abfd->flags & DYNAMIC) != 0)
12473         continue;
12474
12475       eh = NULL;
12476       if (!info->relocatable)
12477         {
12478           eh = bfd_get_section_by_name (abfd, ".eh_frame");
12479           if (eh != NULL
12480               && (eh->size == 0
12481                   || bfd_is_abs_section (eh->output_section)))
12482             eh = NULL;
12483         }
12484
12485       stab = bfd_get_section_by_name (abfd, ".stab");
12486       if (stab != NULL
12487           && (stab->size == 0
12488               || bfd_is_abs_section (stab->output_section)
12489               || stab->sec_info_type != ELF_INFO_TYPE_STABS))
12490         stab = NULL;
12491
12492       if (stab == NULL
12493           && eh == NULL
12494           && bed->elf_backend_discard_info == NULL)
12495         continue;
12496
12497       if (!init_reloc_cookie (&cookie, info, abfd))
12498         return FALSE;
12499
12500       if (stab != NULL
12501           && stab->reloc_count > 0
12502           && init_reloc_cookie_rels (&cookie, info, abfd, stab))
12503         {
12504           if (_bfd_discard_section_stabs (abfd, stab,
12505                                           elf_section_data (stab)->sec_info,
12506                                           bfd_elf_reloc_symbol_deleted_p,
12507                                           &cookie))
12508             ret = TRUE;
12509           fini_reloc_cookie_rels (&cookie, stab);
12510         }
12511
12512       if (eh != NULL
12513           && init_reloc_cookie_rels (&cookie, info, abfd, eh))
12514         {
12515           _bfd_elf_parse_eh_frame (abfd, info, eh, &cookie);
12516           if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
12517                                                  bfd_elf_reloc_symbol_deleted_p,
12518                                                  &cookie))
12519             ret = TRUE;
12520           fini_reloc_cookie_rels (&cookie, eh);
12521         }
12522
12523       if (bed->elf_backend_discard_info != NULL
12524           && (*bed->elf_backend_discard_info) (abfd, &cookie, info))
12525         ret = TRUE;
12526
12527       fini_reloc_cookie (&cookie, abfd);
12528     }
12529   _bfd_elf_end_eh_frame_parsing (info);
12530
12531   if (info->eh_frame_hdr
12532       && !info->relocatable
12533       && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12534     ret = TRUE;
12535
12536   return ret;
12537 }
12538
12539 bfd_boolean
12540 _bfd_elf_section_already_linked (bfd *abfd,
12541                                  asection *sec,
12542                                  struct bfd_link_info *info)
12543 {
12544   flagword flags;
12545   const char *name, *key;
12546   struct bfd_section_already_linked *l;
12547   struct bfd_section_already_linked_hash_entry *already_linked_list;
12548
12549   if (sec->output_section == bfd_abs_section_ptr)
12550     return FALSE;
12551
12552   flags = sec->flags;
12553
12554   /* Return if it isn't a linkonce section.  A comdat group section
12555      also has SEC_LINK_ONCE set.  */
12556   if ((flags & SEC_LINK_ONCE) == 0)
12557     return FALSE;
12558
12559   /* Don't put group member sections on our list of already linked
12560      sections.  They are handled as a group via their group section.  */
12561   if (elf_sec_group (sec) != NULL)
12562     return FALSE;
12563
12564   /* For a SHT_GROUP section, use the group signature as the key.  */
12565   name = sec->name;
12566   if ((flags & SEC_GROUP) != 0
12567       && elf_next_in_group (sec) != NULL
12568       && elf_group_name (elf_next_in_group (sec)) != NULL)
12569     key = elf_group_name (elf_next_in_group (sec));
12570   else
12571     {
12572       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
12573       if (CONST_STRNEQ (name, ".gnu.linkonce.")
12574           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12575         key++;
12576       else
12577         /* Must be a user linkonce section that doesn't follow gcc's
12578            naming convention.  In this case we won't be matching
12579            single member groups.  */
12580         key = name;
12581     }
12582
12583   already_linked_list = bfd_section_already_linked_table_lookup (key);
12584
12585   for (l = already_linked_list->entry; l != NULL; l = l->next)
12586     {
12587       /* We may have 2 different types of sections on the list: group
12588          sections with a signature of <key> (<key> is some string),
12589          and linkonce sections named .gnu.linkonce.<type>.<key>.
12590          Match like sections.  LTO plugin sections are an exception.
12591          They are always named .gnu.linkonce.t.<key> and match either
12592          type of section.  */
12593       if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
12594            && ((flags & SEC_GROUP) != 0
12595                || strcmp (name, l->sec->name) == 0))
12596           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
12597         {
12598           /* The section has already been linked.  See if we should
12599              issue a warning.  */
12600           if (!_bfd_handle_already_linked (sec, l, info))
12601             return FALSE;
12602
12603           if (flags & SEC_GROUP)
12604             {
12605               asection *first = elf_next_in_group (sec);
12606               asection *s = first;
12607
12608               while (s != NULL)
12609                 {
12610                   s->output_section = bfd_abs_section_ptr;
12611                   /* Record which group discards it.  */
12612                   s->kept_section = l->sec;
12613                   s = elf_next_in_group (s);
12614                   /* These lists are circular.  */
12615                   if (s == first)
12616                     break;
12617                 }
12618             }
12619
12620           return TRUE;
12621         }
12622     }
12623
12624   /* A single member comdat group section may be discarded by a
12625      linkonce section and vice versa.  */
12626   if ((flags & SEC_GROUP) != 0)
12627     {
12628       asection *first = elf_next_in_group (sec);
12629
12630       if (first != NULL && elf_next_in_group (first) == first)
12631         /* Check this single member group against linkonce sections.  */
12632         for (l = already_linked_list->entry; l != NULL; l = l->next)
12633           if ((l->sec->flags & SEC_GROUP) == 0
12634               && bfd_elf_match_symbols_in_sections (l->sec, first, info))
12635             {
12636               first->output_section = bfd_abs_section_ptr;
12637               first->kept_section = l->sec;
12638               sec->output_section = bfd_abs_section_ptr;
12639               break;
12640             }
12641     }
12642   else
12643     /* Check this linkonce section against single member groups.  */
12644     for (l = already_linked_list->entry; l != NULL; l = l->next)
12645       if (l->sec->flags & SEC_GROUP)
12646         {
12647           asection *first = elf_next_in_group (l->sec);
12648
12649           if (first != NULL
12650               && elf_next_in_group (first) == first
12651               && bfd_elf_match_symbols_in_sections (first, sec, info))
12652             {
12653               sec->output_section = bfd_abs_section_ptr;
12654               sec->kept_section = first;
12655               break;
12656             }
12657         }
12658
12659   /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12660      referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12661      specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12662      prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
12663      matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
12664      but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12665      `.gnu.linkonce.t.F' section from a different bfd not requiring any
12666      `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
12667      The reverse order cannot happen as there is never a bfd with only the
12668      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
12669      matter as here were are looking only for cross-bfd sections.  */
12670
12671   if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
12672     for (l = already_linked_list->entry; l != NULL; l = l->next)
12673       if ((l->sec->flags & SEC_GROUP) == 0
12674           && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
12675         {
12676           if (abfd != l->sec->owner)
12677             sec->output_section = bfd_abs_section_ptr;
12678           break;
12679         }
12680
12681   /* This is the first section with this name.  Record it.  */
12682   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
12683     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
12684   return sec->output_section == bfd_abs_section_ptr;
12685 }
12686
12687 bfd_boolean
12688 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
12689 {
12690   return sym->st_shndx == SHN_COMMON;
12691 }
12692
12693 unsigned int
12694 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
12695 {
12696   return SHN_COMMON;
12697 }
12698
12699 asection *
12700 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
12701 {
12702   return bfd_com_section_ptr;
12703 }
12704
12705 bfd_vma
12706 _bfd_elf_default_got_elt_size (bfd *abfd,
12707                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
12708                                struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
12709                                bfd *ibfd ATTRIBUTE_UNUSED,
12710                                unsigned long symndx ATTRIBUTE_UNUSED)
12711 {
12712   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12713   return bed->s->arch_size / 8;
12714 }
12715
12716 /* Routines to support the creation of dynamic relocs.  */
12717
12718 /* Returns the name of the dynamic reloc section associated with SEC.  */
12719
12720 static const char *
12721 get_dynamic_reloc_section_name (bfd *       abfd,
12722                                 asection *  sec,
12723                                 bfd_boolean is_rela)
12724 {
12725   char *name;
12726   const char *old_name = bfd_get_section_name (NULL, sec);
12727   const char *prefix = is_rela ? ".rela" : ".rel";
12728
12729   if (old_name == NULL)
12730     return NULL;
12731
12732   name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
12733   sprintf (name, "%s%s", prefix, old_name); 
12734
12735   return name;
12736 }
12737
12738 /* Returns the dynamic reloc section associated with SEC.
12739    If necessary compute the name of the dynamic reloc section based
12740    on SEC's name (looked up in ABFD's string table) and the setting
12741    of IS_RELA.  */
12742
12743 asection *
12744 _bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
12745                                     asection *  sec,
12746                                     bfd_boolean is_rela)
12747 {
12748   asection * reloc_sec = elf_section_data (sec)->sreloc;
12749
12750   if (reloc_sec == NULL)
12751     {
12752       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12753
12754       if (name != NULL)
12755         {
12756           reloc_sec = bfd_get_section_by_name (abfd, name);
12757
12758           if (reloc_sec != NULL)
12759             elf_section_data (sec)->sreloc = reloc_sec;
12760         }
12761     }
12762
12763   return reloc_sec;
12764 }
12765
12766 /* Returns the dynamic reloc section associated with SEC.  If the
12767    section does not exist it is created and attached to the DYNOBJ
12768    bfd and stored in the SRELOC field of SEC's elf_section_data
12769    structure.
12770
12771    ALIGNMENT is the alignment for the newly created section and
12772    IS_RELA defines whether the name should be .rela.<SEC's name>
12773    or .rel.<SEC's name>.  The section name is looked up in the
12774    string table associated with ABFD.  */
12775
12776 asection *
12777 _bfd_elf_make_dynamic_reloc_section (asection *         sec,
12778                                      bfd *              dynobj,
12779                                      unsigned int       alignment,
12780                                      bfd *              abfd,
12781                                      bfd_boolean        is_rela)
12782 {
12783   asection * reloc_sec = elf_section_data (sec)->sreloc;
12784
12785   if (reloc_sec == NULL)
12786     {
12787       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12788
12789       if (name == NULL)
12790         return NULL;
12791
12792       reloc_sec = bfd_get_section_by_name (dynobj, name);
12793
12794       if (reloc_sec == NULL)
12795         {
12796           flagword flags;
12797
12798           flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_IN_MEMORY | SEC_LINKER_CREATED);
12799           if ((sec->flags & SEC_ALLOC) != 0)
12800             flags |= SEC_ALLOC | SEC_LOAD;
12801
12802           reloc_sec = bfd_make_section_with_flags (dynobj, name, flags);
12803           if (reloc_sec != NULL)
12804             {
12805               if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
12806                 reloc_sec = NULL;
12807             }
12808         }
12809
12810       elf_section_data (sec)->sreloc = reloc_sec;
12811     }
12812
12813   return reloc_sec;
12814 }
12815
12816 /* Copy the ELF symbol type associated with a linker hash entry.  */
12817 void
12818 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED,
12819     struct bfd_link_hash_entry * hdest,
12820     struct bfd_link_hash_entry * hsrc)
12821 {
12822   struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *)hdest;
12823   struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *)hsrc;
12824
12825   ehdest->type = ehsrc->type;
12826   ehdest->target_internal = ehsrc->target_internal;
12827 }
12828
12829 /* Append a RELA relocation REL to section S in BFD.  */
12830
12831 void
12832 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
12833 {
12834   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12835   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
12836   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
12837   bed->s->swap_reloca_out (abfd, rel, loc);
12838 }
12839
12840 /* Append a REL relocation REL to section S in BFD.  */
12841
12842 void
12843 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
12844 {
12845   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12846   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
12847   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
12848   bed->s->swap_reloca_out (abfd, rel, loc);
12849 }