Fix garbage collection of common symbols
[external/binutils.git] / bfd / elflink.c
1 /* ELF linking support for BFD.
2    Copyright (C) 1995-2015 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfd_stdint.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #define ARCH_SIZE 0
27 #include "elf-bfd.h"
28 #include "safe-ctype.h"
29 #include "libiberty.h"
30 #include "objalloc.h"
31
32 /* This struct is used to pass information to routines called via
33    elf_link_hash_traverse which must return failure.  */
34
35 struct elf_info_failed
36 {
37   struct bfd_link_info *info;
38   bfd_boolean failed;
39 };
40
41 /* This structure is used to pass information to
42    _bfd_elf_link_find_version_dependencies.  */
43
44 struct elf_find_verdep_info
45 {
46   /* General link information.  */
47   struct bfd_link_info *info;
48   /* The number of dependencies.  */
49   unsigned int vers;
50   /* Whether we had a failure.  */
51   bfd_boolean failed;
52 };
53
54 static bfd_boolean _bfd_elf_fix_symbol_flags
55   (struct elf_link_hash_entry *, struct elf_info_failed *);
56
57 /* Define a symbol in a dynamic linkage section.  */
58
59 struct elf_link_hash_entry *
60 _bfd_elf_define_linkage_sym (bfd *abfd,
61                              struct bfd_link_info *info,
62                              asection *sec,
63                              const char *name)
64 {
65   struct elf_link_hash_entry *h;
66   struct bfd_link_hash_entry *bh;
67   const struct elf_backend_data *bed;
68
69   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
70   if (h != NULL)
71     {
72       /* Zap symbol defined in an as-needed lib that wasn't linked.
73          This is a symptom of a larger problem:  Absolute symbols
74          defined in shared libraries can't be overridden, because we
75          lose the link to the bfd which is via the symbol section.  */
76       h->root.type = bfd_link_hash_new;
77     }
78
79   bh = &h->root;
80   if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
81                                          sec, 0, NULL, FALSE,
82                                          get_elf_backend_data (abfd)->collect,
83                                          &bh))
84     return NULL;
85   h = (struct elf_link_hash_entry *) bh;
86   h->def_regular = 1;
87   h->non_elf = 0;
88   h->root.linker_def = 1;
89   h->type = STT_OBJECT;
90   if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
91     h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
92
93   bed = get_elf_backend_data (abfd);
94   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
95   return h;
96 }
97
98 bfd_boolean
99 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
100 {
101   flagword flags;
102   asection *s;
103   struct elf_link_hash_entry *h;
104   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
105   struct elf_link_hash_table *htab = elf_hash_table (info);
106
107   /* This function may be called more than once.  */
108   s = bfd_get_linker_section (abfd, ".got");
109   if (s != NULL)
110     return TRUE;
111
112   flags = bed->dynamic_sec_flags;
113
114   s = bfd_make_section_anyway_with_flags (abfd,
115                                           (bed->rela_plts_and_copies_p
116                                            ? ".rela.got" : ".rel.got"),
117                                           (bed->dynamic_sec_flags
118                                            | SEC_READONLY));
119   if (s == NULL
120       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
121     return FALSE;
122   htab->srelgot = s;
123
124   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
125   if (s == NULL
126       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
127     return FALSE;
128   htab->sgot = s;
129
130   if (bed->want_got_plt)
131     {
132       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
133       if (s == NULL
134           || !bfd_set_section_alignment (abfd, s,
135                                          bed->s->log_file_align))
136         return FALSE;
137       htab->sgotplt = s;
138     }
139
140   /* The first bit of the global offset table is the header.  */
141   s->size += bed->got_header_size;
142
143   if (bed->want_got_sym)
144     {
145       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
146          (or .got.plt) section.  We don't do this in the linker script
147          because we don't want to define the symbol if we are not creating
148          a global offset table.  */
149       h = _bfd_elf_define_linkage_sym (abfd, info, s,
150                                        "_GLOBAL_OFFSET_TABLE_");
151       elf_hash_table (info)->hgot = h;
152       if (h == NULL)
153         return FALSE;
154     }
155
156   return TRUE;
157 }
158 \f
159 /* Create a strtab to hold the dynamic symbol names.  */
160 static bfd_boolean
161 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
162 {
163   struct elf_link_hash_table *hash_table;
164
165   hash_table = elf_hash_table (info);
166   if (hash_table->dynobj == NULL)
167     hash_table->dynobj = abfd;
168
169   if (hash_table->dynstr == NULL)
170     {
171       hash_table->dynstr = _bfd_elf_strtab_init ();
172       if (hash_table->dynstr == NULL)
173         return FALSE;
174     }
175   return TRUE;
176 }
177
178 /* Create some sections which will be filled in with dynamic linking
179    information.  ABFD is an input file which requires dynamic sections
180    to be created.  The dynamic sections take up virtual memory space
181    when the final executable is run, so we need to create them before
182    addresses are assigned to the output sections.  We work out the
183    actual contents and size of these sections later.  */
184
185 bfd_boolean
186 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
187 {
188   flagword flags;
189   asection *s;
190   const struct elf_backend_data *bed;
191   struct elf_link_hash_entry *h;
192
193   if (! is_elf_hash_table (info->hash))
194     return FALSE;
195
196   if (elf_hash_table (info)->dynamic_sections_created)
197     return TRUE;
198
199   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
200     return FALSE;
201
202   abfd = elf_hash_table (info)->dynobj;
203   bed = get_elf_backend_data (abfd);
204
205   flags = bed->dynamic_sec_flags;
206
207   /* A dynamically linked executable has a .interp section, but a
208      shared library does not.  */
209   if (info->executable)
210     {
211       s = bfd_make_section_anyway_with_flags (abfd, ".interp",
212                                               flags | SEC_READONLY);
213       if (s == NULL)
214         return FALSE;
215     }
216
217   /* Create sections to hold version informations.  These are removed
218      if they are not needed.  */
219   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
220                                           flags | SEC_READONLY);
221   if (s == NULL
222       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
223     return FALSE;
224
225   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
226                                           flags | SEC_READONLY);
227   if (s == NULL
228       || ! bfd_set_section_alignment (abfd, s, 1))
229     return FALSE;
230
231   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
232                                           flags | SEC_READONLY);
233   if (s == NULL
234       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
235     return FALSE;
236
237   s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
238                                           flags | SEC_READONLY);
239   if (s == NULL
240       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
241     return FALSE;
242
243   s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
244                                           flags | SEC_READONLY);
245   if (s == NULL)
246     return FALSE;
247
248   s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
249   if (s == NULL
250       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
251     return FALSE;
252
253   /* The special symbol _DYNAMIC is always set to the start of the
254      .dynamic section.  We could set _DYNAMIC in a linker script, but we
255      only want to define it if we are, in fact, creating a .dynamic
256      section.  We don't want to define it if there is no .dynamic
257      section, since on some ELF platforms the start up code examines it
258      to decide how to initialize the process.  */
259   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
260   elf_hash_table (info)->hdynamic = h;
261   if (h == NULL)
262     return FALSE;
263
264   if (info->emit_hash)
265     {
266       s = bfd_make_section_anyway_with_flags (abfd, ".hash",
267                                               flags | SEC_READONLY);
268       if (s == NULL
269           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
270         return FALSE;
271       elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
272     }
273
274   if (info->emit_gnu_hash)
275     {
276       s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
277                                               flags | SEC_READONLY);
278       if (s == NULL
279           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
280         return FALSE;
281       /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
282          4 32-bit words followed by variable count of 64-bit words, then
283          variable count of 32-bit words.  */
284       if (bed->s->arch_size == 64)
285         elf_section_data (s)->this_hdr.sh_entsize = 0;
286       else
287         elf_section_data (s)->this_hdr.sh_entsize = 4;
288     }
289
290   /* Let the backend create the rest of the sections.  This lets the
291      backend set the right flags.  The backend will normally create
292      the .got and .plt sections.  */
293   if (bed->elf_backend_create_dynamic_sections == NULL
294       || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
295     return FALSE;
296
297   elf_hash_table (info)->dynamic_sections_created = TRUE;
298
299   return TRUE;
300 }
301
302 /* Create dynamic sections when linking against a dynamic object.  */
303
304 bfd_boolean
305 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
306 {
307   flagword flags, pltflags;
308   struct elf_link_hash_entry *h;
309   asection *s;
310   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
311   struct elf_link_hash_table *htab = elf_hash_table (info);
312
313   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
314      .rel[a].bss sections.  */
315   flags = bed->dynamic_sec_flags;
316
317   pltflags = flags;
318   if (bed->plt_not_loaded)
319     /* We do not clear SEC_ALLOC here because we still want the OS to
320        allocate space for the section; it's just that there's nothing
321        to read in from the object file.  */
322     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
323   else
324     pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
325   if (bed->plt_readonly)
326     pltflags |= SEC_READONLY;
327
328   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
329   if (s == NULL
330       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
331     return FALSE;
332   htab->splt = s;
333
334   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
335      .plt section.  */
336   if (bed->want_plt_sym)
337     {
338       h = _bfd_elf_define_linkage_sym (abfd, info, s,
339                                        "_PROCEDURE_LINKAGE_TABLE_");
340       elf_hash_table (info)->hplt = h;
341       if (h == NULL)
342         return FALSE;
343     }
344
345   s = bfd_make_section_anyway_with_flags (abfd,
346                                           (bed->rela_plts_and_copies_p
347                                            ? ".rela.plt" : ".rel.plt"),
348                                           flags | SEC_READONLY);
349   if (s == NULL
350       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
351     return FALSE;
352   htab->srelplt = s;
353
354   if (! _bfd_elf_create_got_section (abfd, info))
355     return FALSE;
356
357   if (bed->want_dynbss)
358     {
359       /* The .dynbss section is a place to put symbols which are defined
360          by dynamic objects, are referenced by regular objects, and are
361          not functions.  We must allocate space for them in the process
362          image and use a R_*_COPY reloc to tell the dynamic linker to
363          initialize them at run time.  The linker script puts the .dynbss
364          section into the .bss section of the final image.  */
365       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
366                                               (SEC_ALLOC | SEC_LINKER_CREATED));
367       if (s == NULL)
368         return FALSE;
369
370       /* The .rel[a].bss section holds copy relocs.  This section is not
371          normally needed.  We need to create it here, though, so that the
372          linker will map it to an output section.  We can't just create it
373          only if we need it, because we will not know whether we need it
374          until we have seen all the input files, and the first time the
375          main linker code calls BFD after examining all the input files
376          (size_dynamic_sections) the input sections have already been
377          mapped to the output sections.  If the section turns out not to
378          be needed, we can discard it later.  We will never need this
379          section when generating a shared object, since they do not use
380          copy relocs.  */
381       if (! info->shared)
382         {
383           s = bfd_make_section_anyway_with_flags (abfd,
384                                                   (bed->rela_plts_and_copies_p
385                                                    ? ".rela.bss" : ".rel.bss"),
386                                                   flags | SEC_READONLY);
387           if (s == NULL
388               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
389             return FALSE;
390         }
391     }
392
393   return TRUE;
394 }
395 \f
396 /* Record a new dynamic symbol.  We record the dynamic symbols as we
397    read the input files, since we need to have a list of all of them
398    before we can determine the final sizes of the output sections.
399    Note that we may actually call this function even though we are not
400    going to output any dynamic symbols; in some cases we know that a
401    symbol should be in the dynamic symbol table, but only if there is
402    one.  */
403
404 bfd_boolean
405 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
406                                     struct elf_link_hash_entry *h)
407 {
408   if (h->dynindx == -1)
409     {
410       struct elf_strtab_hash *dynstr;
411       char *p;
412       const char *name;
413       bfd_size_type indx;
414
415       /* XXX: The ABI draft says the linker must turn hidden and
416          internal symbols into STB_LOCAL symbols when producing the
417          DSO. However, if ld.so honors st_other in the dynamic table,
418          this would not be necessary.  */
419       switch (ELF_ST_VISIBILITY (h->other))
420         {
421         case STV_INTERNAL:
422         case STV_HIDDEN:
423           if (h->root.type != bfd_link_hash_undefined
424               && h->root.type != bfd_link_hash_undefweak)
425             {
426               h->forced_local = 1;
427               if (!elf_hash_table (info)->is_relocatable_executable)
428                 return TRUE;
429             }
430
431         default:
432           break;
433         }
434
435       h->dynindx = elf_hash_table (info)->dynsymcount;
436       ++elf_hash_table (info)->dynsymcount;
437
438       dynstr = elf_hash_table (info)->dynstr;
439       if (dynstr == NULL)
440         {
441           /* Create a strtab to hold the dynamic symbol names.  */
442           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
443           if (dynstr == NULL)
444             return FALSE;
445         }
446
447       /* We don't put any version information in the dynamic string
448          table.  */
449       name = h->root.root.string;
450       p = strchr (name, ELF_VER_CHR);
451       if (p != NULL)
452         /* We know that the p points into writable memory.  In fact,
453            there are only a few symbols that have read-only names, being
454            those like _GLOBAL_OFFSET_TABLE_ that are created specially
455            by the backends.  Most symbols will have names pointing into
456            an ELF string table read from a file, or to objalloc memory.  */
457         *p = 0;
458
459       indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
460
461       if (p != NULL)
462         *p = ELF_VER_CHR;
463
464       if (indx == (bfd_size_type) -1)
465         return FALSE;
466       h->dynstr_index = indx;
467     }
468
469   return TRUE;
470 }
471 \f
472 /* Mark a symbol dynamic.  */
473
474 static void
475 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
476                                   struct elf_link_hash_entry *h,
477                                   Elf_Internal_Sym *sym)
478 {
479   struct bfd_elf_dynamic_list *d = info->dynamic_list;
480
481   /* It may be called more than once on the same H.  */
482   if(h->dynamic || info->relocatable)
483     return;
484
485   if ((info->dynamic_data
486        && (h->type == STT_OBJECT
487            || (sym != NULL
488                && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
489       || (d != NULL
490           && h->root.type == bfd_link_hash_new
491           && (*d->match) (&d->head, NULL, h->root.root.string)))
492     h->dynamic = 1;
493 }
494
495 /* Record an assignment to a symbol made by a linker script.  We need
496    this in case some dynamic object refers to this symbol.  */
497
498 bfd_boolean
499 bfd_elf_record_link_assignment (bfd *output_bfd,
500                                 struct bfd_link_info *info,
501                                 const char *name,
502                                 bfd_boolean provide,
503                                 bfd_boolean hidden)
504 {
505   struct elf_link_hash_entry *h, *hv;
506   struct elf_link_hash_table *htab;
507   const struct elf_backend_data *bed;
508
509   if (!is_elf_hash_table (info->hash))
510     return TRUE;
511
512   htab = elf_hash_table (info);
513   h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
514   if (h == NULL)
515     return provide;
516
517   switch (h->root.type)
518     {
519     case bfd_link_hash_defined:
520     case bfd_link_hash_defweak:
521     case bfd_link_hash_common:
522       break;
523     case bfd_link_hash_undefweak:
524     case bfd_link_hash_undefined:
525       /* Since we're defining the symbol, don't let it seem to have not
526          been defined.  record_dynamic_symbol and size_dynamic_sections
527          may depend on this.  */
528       h->root.type = bfd_link_hash_new;
529       if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
530         bfd_link_repair_undef_list (&htab->root);
531       break;
532     case bfd_link_hash_new:
533       bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
534       h->non_elf = 0;
535       break;
536     case bfd_link_hash_indirect:
537       /* We had a versioned symbol in a dynamic library.  We make the
538          the versioned symbol point to this one.  */
539       bed = get_elf_backend_data (output_bfd);
540       hv = h;
541       while (hv->root.type == bfd_link_hash_indirect
542              || hv->root.type == bfd_link_hash_warning)
543         hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
544       /* We don't need to update h->root.u since linker will set them
545          later.  */
546       h->root.type = bfd_link_hash_undefined;
547       hv->root.type = bfd_link_hash_indirect;
548       hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
549       (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
550       break;
551     case bfd_link_hash_warning:
552       abort ();
553       break;
554     }
555
556   /* If this symbol is being provided by the linker script, and it is
557      currently defined by a dynamic object, but not by a regular
558      object, then mark it as undefined so that the generic linker will
559      force the correct value.  */
560   if (provide
561       && h->def_dynamic
562       && !h->def_regular)
563     h->root.type = bfd_link_hash_undefined;
564
565   /* If this symbol is not being provided by the linker script, and it is
566      currently defined by a dynamic object, but not by a regular object,
567      then clear out any version information because the symbol will not be
568      associated with the dynamic object any more.  */
569   if (!provide
570       && h->def_dynamic
571       && !h->def_regular)
572     h->verinfo.verdef = NULL;
573
574   h->def_regular = 1;
575
576   if (hidden)
577     {
578       bed = get_elf_backend_data (output_bfd);
579       if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
580         h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
581       (*bed->elf_backend_hide_symbol) (info, h, TRUE);
582     }
583
584   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
585      and executables.  */
586   if (!info->relocatable
587       && h->dynindx != -1
588       && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
589           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
590     h->forced_local = 1;
591
592   if ((h->def_dynamic
593        || h->ref_dynamic
594        || info->shared
595        || (info->executable && elf_hash_table (info)->is_relocatable_executable))
596       && h->dynindx == -1)
597     {
598       if (! bfd_elf_link_record_dynamic_symbol (info, h))
599         return FALSE;
600
601       /* If this is a weak defined symbol, and we know a corresponding
602          real symbol from the same dynamic object, make sure the real
603          symbol is also made into a dynamic symbol.  */
604       if (h->u.weakdef != NULL
605           && h->u.weakdef->dynindx == -1)
606         {
607           if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
608             return FALSE;
609         }
610     }
611
612   return TRUE;
613 }
614
615 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
616    success, and 2 on a failure caused by attempting to record a symbol
617    in a discarded section, eg. a discarded link-once section symbol.  */
618
619 int
620 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
621                                           bfd *input_bfd,
622                                           long input_indx)
623 {
624   bfd_size_type amt;
625   struct elf_link_local_dynamic_entry *entry;
626   struct elf_link_hash_table *eht;
627   struct elf_strtab_hash *dynstr;
628   unsigned long dynstr_index;
629   char *name;
630   Elf_External_Sym_Shndx eshndx;
631   char esym[sizeof (Elf64_External_Sym)];
632
633   if (! is_elf_hash_table (info->hash))
634     return 0;
635
636   /* See if the entry exists already.  */
637   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
638     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
639       return 1;
640
641   amt = sizeof (*entry);
642   entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
643   if (entry == NULL)
644     return 0;
645
646   /* Go find the symbol, so that we can find it's name.  */
647   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
648                              1, input_indx, &entry->isym, esym, &eshndx))
649     {
650       bfd_release (input_bfd, entry);
651       return 0;
652     }
653
654   if (entry->isym.st_shndx != SHN_UNDEF
655       && entry->isym.st_shndx < SHN_LORESERVE)
656     {
657       asection *s;
658
659       s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
660       if (s == NULL || bfd_is_abs_section (s->output_section))
661         {
662           /* We can still bfd_release here as nothing has done another
663              bfd_alloc.  We can't do this later in this function.  */
664           bfd_release (input_bfd, entry);
665           return 2;
666         }
667     }
668
669   name = (bfd_elf_string_from_elf_section
670           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
671            entry->isym.st_name));
672
673   dynstr = elf_hash_table (info)->dynstr;
674   if (dynstr == NULL)
675     {
676       /* Create a strtab to hold the dynamic symbol names.  */
677       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
678       if (dynstr == NULL)
679         return 0;
680     }
681
682   dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
683   if (dynstr_index == (unsigned long) -1)
684     return 0;
685   entry->isym.st_name = dynstr_index;
686
687   eht = elf_hash_table (info);
688
689   entry->next = eht->dynlocal;
690   eht->dynlocal = entry;
691   entry->input_bfd = input_bfd;
692   entry->input_indx = input_indx;
693   eht->dynsymcount++;
694
695   /* Whatever binding the symbol had before, it's now local.  */
696   entry->isym.st_info
697     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
698
699   /* The dynindx will be set at the end of size_dynamic_sections.  */
700
701   return 1;
702 }
703
704 /* Return the dynindex of a local dynamic symbol.  */
705
706 long
707 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
708                                     bfd *input_bfd,
709                                     long input_indx)
710 {
711   struct elf_link_local_dynamic_entry *e;
712
713   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
714     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
715       return e->dynindx;
716   return -1;
717 }
718
719 /* This function is used to renumber the dynamic symbols, if some of
720    them are removed because they are marked as local.  This is called
721    via elf_link_hash_traverse.  */
722
723 static bfd_boolean
724 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
725                                       void *data)
726 {
727   size_t *count = (size_t *) data;
728
729   if (h->forced_local)
730     return TRUE;
731
732   if (h->dynindx != -1)
733     h->dynindx = ++(*count);
734
735   return TRUE;
736 }
737
738
739 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
740    STB_LOCAL binding.  */
741
742 static bfd_boolean
743 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
744                                             void *data)
745 {
746   size_t *count = (size_t *) data;
747
748   if (!h->forced_local)
749     return TRUE;
750
751   if (h->dynindx != -1)
752     h->dynindx = ++(*count);
753
754   return TRUE;
755 }
756
757 /* Return true if the dynamic symbol for a given section should be
758    omitted when creating a shared library.  */
759 bfd_boolean
760 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
761                                    struct bfd_link_info *info,
762                                    asection *p)
763 {
764   struct elf_link_hash_table *htab;
765   asection *ip;
766
767   switch (elf_section_data (p)->this_hdr.sh_type)
768     {
769     case SHT_PROGBITS:
770     case SHT_NOBITS:
771       /* If sh_type is yet undecided, assume it could be
772          SHT_PROGBITS/SHT_NOBITS.  */
773     case SHT_NULL:
774       htab = elf_hash_table (info);
775       if (p == htab->tls_sec)
776         return FALSE;
777
778       if (htab->text_index_section != NULL)
779         return p != htab->text_index_section && p != htab->data_index_section;
780
781       return (htab->dynobj != NULL
782               && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
783               && ip->output_section == p);
784
785       /* There shouldn't be section relative relocations
786          against any other section.  */
787     default:
788       return TRUE;
789     }
790 }
791
792 /* Assign dynsym indices.  In a shared library we generate a section
793    symbol for each output section, which come first.  Next come symbols
794    which have been forced to local binding.  Then all of the back-end
795    allocated local dynamic syms, followed by the rest of the global
796    symbols.  */
797
798 static unsigned long
799 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
800                                 struct bfd_link_info *info,
801                                 unsigned long *section_sym_count)
802 {
803   unsigned long dynsymcount = 0;
804
805   if (info->shared || elf_hash_table (info)->is_relocatable_executable)
806     {
807       const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
808       asection *p;
809       for (p = output_bfd->sections; p ; p = p->next)
810         if ((p->flags & SEC_EXCLUDE) == 0
811             && (p->flags & SEC_ALLOC) != 0
812             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
813           elf_section_data (p)->dynindx = ++dynsymcount;
814         else
815           elf_section_data (p)->dynindx = 0;
816     }
817   *section_sym_count = dynsymcount;
818
819   elf_link_hash_traverse (elf_hash_table (info),
820                           elf_link_renumber_local_hash_table_dynsyms,
821                           &dynsymcount);
822
823   if (elf_hash_table (info)->dynlocal)
824     {
825       struct elf_link_local_dynamic_entry *p;
826       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
827         p->dynindx = ++dynsymcount;
828     }
829
830   elf_link_hash_traverse (elf_hash_table (info),
831                           elf_link_renumber_hash_table_dynsyms,
832                           &dynsymcount);
833
834   /* There is an unused NULL entry at the head of the table which
835      we must account for in our count.  Unless there weren't any
836      symbols, which means we'll have no table at all.  */
837   if (dynsymcount != 0)
838     ++dynsymcount;
839
840   elf_hash_table (info)->dynsymcount = dynsymcount;
841   return dynsymcount;
842 }
843
844 /* Merge st_other field.  */
845
846 static void
847 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
848                     const Elf_Internal_Sym *isym,
849                     bfd_boolean definition, bfd_boolean dynamic)
850 {
851   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
852
853   /* If st_other has a processor-specific meaning, specific
854      code might be needed here.  */
855   if (bed->elf_backend_merge_symbol_attribute)
856     (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
857                                                 dynamic);
858
859   if (!dynamic)
860     {
861       unsigned symvis = ELF_ST_VISIBILITY (isym->st_other);
862       unsigned hvis = ELF_ST_VISIBILITY (h->other);
863
864       /* Keep the most constraining visibility.  Leave the remainder
865          of the st_other field to elf_backend_merge_symbol_attribute.  */
866       if (symvis - 1 < hvis - 1)
867         h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
868     }
869   else if (definition && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT)
870     h->protected_def = 1;
871 }
872
873 /* This function is called when we want to merge a new symbol with an
874    existing symbol.  It handles the various cases which arise when we
875    find a definition in a dynamic object, or when there is already a
876    definition in a dynamic object.  The new symbol is described by
877    NAME, SYM, PSEC, and PVALUE.  We set SYM_HASH to the hash table
878    entry.  We set POLDBFD to the old symbol's BFD.  We set POLD_WEAK
879    if the old symbol was weak.  We set POLD_ALIGNMENT to the alignment
880    of an old common symbol.  We set OVERRIDE if the old symbol is
881    overriding a new definition.  We set TYPE_CHANGE_OK if it is OK for
882    the type to change.  We set SIZE_CHANGE_OK if it is OK for the size
883    to change.  By OK to change, we mean that we shouldn't warn if the
884    type or size does change.  */
885
886 static bfd_boolean
887 _bfd_elf_merge_symbol (bfd *abfd,
888                        struct bfd_link_info *info,
889                        const char *name,
890                        Elf_Internal_Sym *sym,
891                        asection **psec,
892                        bfd_vma *pvalue,
893                        struct elf_link_hash_entry **sym_hash,
894                        bfd **poldbfd,
895                        bfd_boolean *pold_weak,
896                        unsigned int *pold_alignment,
897                        bfd_boolean *skip,
898                        bfd_boolean *override,
899                        bfd_boolean *type_change_ok,
900                        bfd_boolean *size_change_ok)
901 {
902   asection *sec, *oldsec;
903   struct elf_link_hash_entry *h;
904   struct elf_link_hash_entry *hi;
905   struct elf_link_hash_entry *flip;
906   int bind;
907   bfd *oldbfd;
908   bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
909   bfd_boolean newweak, oldweak, newfunc, oldfunc;
910   const struct elf_backend_data *bed;
911
912   *skip = FALSE;
913   *override = FALSE;
914
915   sec = *psec;
916   bind = ELF_ST_BIND (sym->st_info);
917
918   if (! bfd_is_und_section (sec))
919     h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
920   else
921     h = ((struct elf_link_hash_entry *)
922          bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
923   if (h == NULL)
924     return FALSE;
925   *sym_hash = h;
926
927   bed = get_elf_backend_data (abfd);
928
929   /* For merging, we only care about real symbols.  But we need to make
930      sure that indirect symbol dynamic flags are updated.  */
931   hi = h;
932   while (h->root.type == bfd_link_hash_indirect
933          || h->root.type == bfd_link_hash_warning)
934     h = (struct elf_link_hash_entry *) h->root.u.i.link;
935
936   /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
937      existing symbol.  */
938
939   oldbfd = NULL;
940   oldsec = NULL;
941   switch (h->root.type)
942     {
943     default:
944       break;
945
946     case bfd_link_hash_undefined:
947     case bfd_link_hash_undefweak:
948       oldbfd = h->root.u.undef.abfd;
949       break;
950
951     case bfd_link_hash_defined:
952     case bfd_link_hash_defweak:
953       oldbfd = h->root.u.def.section->owner;
954       oldsec = h->root.u.def.section;
955       break;
956
957     case bfd_link_hash_common:
958       oldbfd = h->root.u.c.p->section->owner;
959       oldsec = h->root.u.c.p->section;
960       if (pold_alignment)
961         *pold_alignment = h->root.u.c.p->alignment_power;
962       break;
963     }
964   if (poldbfd && *poldbfd == NULL)
965     *poldbfd = oldbfd;
966
967   /* Differentiate strong and weak symbols.  */
968   newweak = bind == STB_WEAK;
969   oldweak = (h->root.type == bfd_link_hash_defweak
970              || h->root.type == bfd_link_hash_undefweak);
971   if (pold_weak)
972     *pold_weak = oldweak;
973
974   /* This code is for coping with dynamic objects, and is only useful
975      if we are doing an ELF link.  */
976   if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
977     return TRUE;
978
979   /* We have to check it for every instance since the first few may be
980      references and not all compilers emit symbol type for undefined
981      symbols.  */
982   bfd_elf_link_mark_dynamic_symbol (info, h, sym);
983
984   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
985      respectively, is from a dynamic object.  */
986
987   newdyn = (abfd->flags & DYNAMIC) != 0;
988
989   /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
990      syms and defined syms in dynamic libraries respectively.
991      ref_dynamic on the other hand can be set for a symbol defined in
992      a dynamic library, and def_dynamic may not be set;  When the
993      definition in a dynamic lib is overridden by a definition in the
994      executable use of the symbol in the dynamic lib becomes a
995      reference to the executable symbol.  */
996   if (newdyn)
997     {
998       if (bfd_is_und_section (sec))
999         {
1000           if (bind != STB_WEAK)
1001             {
1002               h->ref_dynamic_nonweak = 1;
1003               hi->ref_dynamic_nonweak = 1;
1004             }
1005         }
1006       else
1007         {
1008           h->dynamic_def = 1;
1009           hi->dynamic_def = 1;
1010         }
1011     }
1012
1013   /* If we just created the symbol, mark it as being an ELF symbol.
1014      Other than that, there is nothing to do--there is no merge issue
1015      with a newly defined symbol--so we just return.  */
1016
1017   if (h->root.type == bfd_link_hash_new)
1018     {
1019       h->non_elf = 0;
1020       return TRUE;
1021     }
1022
1023   /* In cases involving weak versioned symbols, we may wind up trying
1024      to merge a symbol with itself.  Catch that here, to avoid the
1025      confusion that results if we try to override a symbol with
1026      itself.  The additional tests catch cases like
1027      _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1028      dynamic object, which we do want to handle here.  */
1029   if (abfd == oldbfd
1030       && (newweak || oldweak)
1031       && ((abfd->flags & DYNAMIC) == 0
1032           || !h->def_regular))
1033     return TRUE;
1034
1035   olddyn = FALSE;
1036   if (oldbfd != NULL)
1037     olddyn = (oldbfd->flags & DYNAMIC) != 0;
1038   else if (oldsec != NULL)
1039     {
1040       /* This handles the special SHN_MIPS_{TEXT,DATA} section
1041          indices used by MIPS ELF.  */
1042       olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1043     }
1044
1045   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1046      respectively, appear to be a definition rather than reference.  */
1047
1048   newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1049
1050   olddef = (h->root.type != bfd_link_hash_undefined
1051             && h->root.type != bfd_link_hash_undefweak
1052             && h->root.type != bfd_link_hash_common);
1053
1054   /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1055      respectively, appear to be a function.  */
1056
1057   newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1058              && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1059
1060   oldfunc = (h->type != STT_NOTYPE
1061              && bed->is_function_type (h->type));
1062
1063   /* When we try to create a default indirect symbol from the dynamic
1064      definition with the default version, we skip it if its type and
1065      the type of existing regular definition mismatch.  */
1066   if (pold_alignment == NULL
1067       && newdyn
1068       && newdef
1069       && !olddyn
1070       && (((olddef || h->root.type == bfd_link_hash_common)
1071            && ELF_ST_TYPE (sym->st_info) != h->type
1072            && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1073            && h->type != STT_NOTYPE
1074            && !(newfunc && oldfunc))
1075           || (olddef
1076               && ((h->type == STT_GNU_IFUNC)
1077                   != (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))))
1078     {
1079       *skip = TRUE;
1080       return TRUE;
1081     }
1082
1083   /* Check TLS symbols.  We don't check undefined symbols introduced
1084      by "ld -u" which have no type (and oldbfd NULL), and we don't
1085      check symbols from plugins because they also have no type.  */
1086   if (oldbfd != NULL
1087       && (oldbfd->flags & BFD_PLUGIN) == 0
1088       && (abfd->flags & BFD_PLUGIN) == 0
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 "
1118              "mismatches non-TLS definition in %B section %A"),
1119            tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1120       else if (!tdef && !ntdef)
1121         (*_bfd_error_handler)
1122           (_("%s: TLS reference in %B "
1123              "mismatches non-TLS reference in %B"),
1124            tbfd, ntbfd, h->root.root.string);
1125       else if (tdef)
1126         (*_bfd_error_handler)
1127           (_("%s: TLS definition in %B section %A "
1128              "mismatches non-TLS reference in %B"),
1129            tbfd, tsec, ntbfd, h->root.root.string);
1130       else
1131         (*_bfd_error_handler)
1132           (_("%s: TLS reference in %B "
1133              "mismatches non-TLS definition in %B section %A"),
1134            tbfd, ntbfd, ntsec, h->root.root.string);
1135
1136       bfd_set_error (bfd_error_bad_value);
1137       return FALSE;
1138     }
1139
1140   /* If the old symbol has non-default visibility, we ignore the new
1141      definition from a dynamic object.  */
1142   if (newdyn
1143       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1144       && !bfd_is_und_section (sec))
1145     {
1146       *skip = TRUE;
1147       /* Make sure this symbol is dynamic.  */
1148       h->ref_dynamic = 1;
1149       hi->ref_dynamic = 1;
1150       /* A protected symbol has external availability. Make sure it is
1151          recorded as dynamic.
1152
1153          FIXME: Should we check type and size for protected symbol?  */
1154       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1155         return bfd_elf_link_record_dynamic_symbol (info, h);
1156       else
1157         return TRUE;
1158     }
1159   else if (!newdyn
1160            && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1161            && h->def_dynamic)
1162     {
1163       /* If the new symbol with non-default visibility comes from a
1164          relocatable file and the old definition comes from a dynamic
1165          object, we remove the old definition.  */
1166       if (hi->root.type == bfd_link_hash_indirect)
1167         {
1168           /* Handle the case where the old dynamic definition is
1169              default versioned.  We need to copy the symbol info from
1170              the symbol with default version to the normal one if it
1171              was referenced before.  */
1172           if (h->ref_regular)
1173             {
1174               hi->root.type = h->root.type;
1175               h->root.type = bfd_link_hash_indirect;
1176               (*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
1177
1178               h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1179               if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1180                 {
1181                   /* If the new symbol is hidden or internal, completely undo
1182                      any dynamic link state.  */
1183                   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1184                   h->forced_local = 0;
1185                   h->ref_dynamic = 0;
1186                 }
1187               else
1188                 h->ref_dynamic = 1;
1189
1190               h->def_dynamic = 0;
1191               /* FIXME: Should we check type and size for protected symbol?  */
1192               h->size = 0;
1193               h->type = 0;
1194
1195               h = hi;
1196             }
1197           else
1198             h = hi;
1199         }
1200
1201       /* If the old symbol was undefined before, then it will still be
1202          on the undefs list.  If the new symbol is undefined or
1203          common, we can't make it bfd_link_hash_new here, because new
1204          undefined or common symbols will be added to the undefs list
1205          by _bfd_generic_link_add_one_symbol.  Symbols may not be
1206          added twice to the undefs list.  Also, if the new symbol is
1207          undefweak then we don't want to lose the strong undef.  */
1208       if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1209         {
1210           h->root.type = bfd_link_hash_undefined;
1211           h->root.u.undef.abfd = abfd;
1212         }
1213       else
1214         {
1215           h->root.type = bfd_link_hash_new;
1216           h->root.u.undef.abfd = NULL;
1217         }
1218
1219       if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1220         {
1221           /* If the new symbol is hidden or internal, completely undo
1222              any dynamic link state.  */
1223           (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1224           h->forced_local = 0;
1225           h->ref_dynamic = 0;
1226         }
1227       else
1228         h->ref_dynamic = 1;
1229       h->def_dynamic = 0;
1230       /* FIXME: Should we check type and size for protected symbol?  */
1231       h->size = 0;
1232       h->type = 0;
1233       return TRUE;
1234     }
1235
1236   /* If a new weak symbol definition comes from a regular file and the
1237      old symbol comes from a dynamic library, we treat the new one as
1238      strong.  Similarly, an old weak symbol definition from a regular
1239      file is treated as strong when the new symbol comes from a dynamic
1240      library.  Further, an old weak symbol from a dynamic library is
1241      treated as strong if the new symbol is from a dynamic library.
1242      This reflects the way glibc's ld.so works.
1243
1244      Do this before setting *type_change_ok or *size_change_ok so that
1245      we warn properly when dynamic library symbols are overridden.  */
1246
1247   if (newdef && !newdyn && olddyn)
1248     newweak = FALSE;
1249   if (olddef && newdyn)
1250     oldweak = FALSE;
1251
1252   /* Allow changes between different types of function symbol.  */
1253   if (newfunc && oldfunc)
1254     *type_change_ok = TRUE;
1255
1256   /* It's OK to change the type if either the existing symbol or the
1257      new symbol is weak.  A type change is also OK if the old symbol
1258      is undefined and the new symbol is defined.  */
1259
1260   if (oldweak
1261       || newweak
1262       || (newdef
1263           && h->root.type == bfd_link_hash_undefined))
1264     *type_change_ok = TRUE;
1265
1266   /* It's OK to change the size if either the existing symbol or the
1267      new symbol is weak, or if the old symbol is undefined.  */
1268
1269   if (*type_change_ok
1270       || h->root.type == bfd_link_hash_undefined)
1271     *size_change_ok = TRUE;
1272
1273   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1274      symbol, respectively, appears to be a common symbol in a dynamic
1275      object.  If a symbol appears in an uninitialized section, and is
1276      not weak, and is not a function, then it may be a common symbol
1277      which was resolved when the dynamic object was created.  We want
1278      to treat such symbols specially, because they raise special
1279      considerations when setting the symbol size: if the symbol
1280      appears as a common symbol in a regular object, and the size in
1281      the regular object is larger, we must make sure that we use the
1282      larger size.  This problematic case can always be avoided in C,
1283      but it must be handled correctly when using Fortran shared
1284      libraries.
1285
1286      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1287      likewise for OLDDYNCOMMON and OLDDEF.
1288
1289      Note that this test is just a heuristic, and that it is quite
1290      possible to have an uninitialized symbol in a shared object which
1291      is really a definition, rather than a common symbol.  This could
1292      lead to some minor confusion when the symbol really is a common
1293      symbol in some regular object.  However, I think it will be
1294      harmless.  */
1295
1296   if (newdyn
1297       && newdef
1298       && !newweak
1299       && (sec->flags & SEC_ALLOC) != 0
1300       && (sec->flags & SEC_LOAD) == 0
1301       && sym->st_size > 0
1302       && !newfunc)
1303     newdyncommon = TRUE;
1304   else
1305     newdyncommon = FALSE;
1306
1307   if (olddyn
1308       && olddef
1309       && h->root.type == bfd_link_hash_defined
1310       && h->def_dynamic
1311       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1312       && (h->root.u.def.section->flags & SEC_LOAD) == 0
1313       && h->size > 0
1314       && !oldfunc)
1315     olddyncommon = TRUE;
1316   else
1317     olddyncommon = FALSE;
1318
1319   /* We now know everything about the old and new symbols.  We ask the
1320      backend to check if we can merge them.  */
1321   if (bed->merge_symbol != NULL)
1322     {
1323       if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
1324         return FALSE;
1325       sec = *psec;
1326     }
1327
1328   /* If both the old and the new symbols look like common symbols in a
1329      dynamic object, set the size of the symbol to the larger of the
1330      two.  */
1331
1332   if (olddyncommon
1333       && newdyncommon
1334       && sym->st_size != h->size)
1335     {
1336       /* Since we think we have two common symbols, issue a multiple
1337          common warning if desired.  Note that we only warn if the
1338          size is different.  If the size is the same, we simply let
1339          the old symbol override the new one as normally happens with
1340          symbols defined in dynamic objects.  */
1341
1342       if (! ((*info->callbacks->multiple_common)
1343              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1344         return FALSE;
1345
1346       if (sym->st_size > h->size)
1347         h->size = sym->st_size;
1348
1349       *size_change_ok = TRUE;
1350     }
1351
1352   /* If we are looking at a dynamic object, and we have found a
1353      definition, we need to see if the symbol was already defined by
1354      some other object.  If so, we want to use the existing
1355      definition, and we do not want to report a multiple symbol
1356      definition error; we do this by clobbering *PSEC to be
1357      bfd_und_section_ptr.
1358
1359      We treat a common symbol as a definition if the symbol in the
1360      shared library is a function, since common symbols always
1361      represent variables; this can cause confusion in principle, but
1362      any such confusion would seem to indicate an erroneous program or
1363      shared library.  We also permit a common symbol in a regular
1364      object to override a weak symbol in a shared object.  */
1365
1366   if (newdyn
1367       && newdef
1368       && (olddef
1369           || (h->root.type == bfd_link_hash_common
1370               && (newweak || newfunc))))
1371     {
1372       *override = TRUE;
1373       newdef = FALSE;
1374       newdyncommon = FALSE;
1375
1376       *psec = sec = bfd_und_section_ptr;
1377       *size_change_ok = TRUE;
1378
1379       /* If we get here when the old symbol is a common symbol, then
1380          we are explicitly letting it override a weak symbol or
1381          function in a dynamic object, and we don't want to warn about
1382          a type change.  If the old symbol is a defined symbol, a type
1383          change warning may still be appropriate.  */
1384
1385       if (h->root.type == bfd_link_hash_common)
1386         *type_change_ok = TRUE;
1387     }
1388
1389   /* Handle the special case of an old common symbol merging with a
1390      new symbol which looks like a common symbol in a shared object.
1391      We change *PSEC and *PVALUE to make the new symbol look like a
1392      common symbol, and let _bfd_generic_link_add_one_symbol do the
1393      right thing.  */
1394
1395   if (newdyncommon
1396       && h->root.type == bfd_link_hash_common)
1397     {
1398       *override = TRUE;
1399       newdef = FALSE;
1400       newdyncommon = FALSE;
1401       *pvalue = sym->st_size;
1402       *psec = sec = bed->common_section (oldsec);
1403       *size_change_ok = TRUE;
1404     }
1405
1406   /* Skip weak definitions of symbols that are already defined.  */
1407   if (newdef && olddef && newweak)
1408     {
1409       /* Don't skip new non-IR weak syms.  */
1410       if (!(oldbfd != NULL
1411             && (oldbfd->flags & BFD_PLUGIN) != 0
1412             && (abfd->flags & BFD_PLUGIN) == 0))
1413         {
1414           newdef = FALSE;
1415           *skip = TRUE;
1416         }
1417
1418       /* Merge st_other.  If the symbol already has a dynamic index,
1419          but visibility says it should not be visible, turn it into a
1420          local symbol.  */
1421       elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1422       if (h->dynindx != -1)
1423         switch (ELF_ST_VISIBILITY (h->other))
1424           {
1425           case STV_INTERNAL:
1426           case STV_HIDDEN:
1427             (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1428             break;
1429           }
1430     }
1431
1432   /* If the old symbol is from a dynamic object, and the new symbol is
1433      a definition which is not from a dynamic object, then the new
1434      symbol overrides the old symbol.  Symbols from regular files
1435      always take precedence over symbols from dynamic objects, even if
1436      they are defined after the dynamic object in the link.
1437
1438      As above, we again permit a common symbol in a regular object to
1439      override a definition in a shared object if the shared object
1440      symbol is a function or is weak.  */
1441
1442   flip = NULL;
1443   if (!newdyn
1444       && (newdef
1445           || (bfd_is_com_section (sec)
1446               && (oldweak || oldfunc)))
1447       && olddyn
1448       && olddef
1449       && h->def_dynamic)
1450     {
1451       /* Change the hash table entry to undefined, and let
1452          _bfd_generic_link_add_one_symbol do the right thing with the
1453          new definition.  */
1454
1455       h->root.type = bfd_link_hash_undefined;
1456       h->root.u.undef.abfd = h->root.u.def.section->owner;
1457       *size_change_ok = TRUE;
1458
1459       olddef = FALSE;
1460       olddyncommon = FALSE;
1461
1462       /* We again permit a type change when a common symbol may be
1463          overriding a function.  */
1464
1465       if (bfd_is_com_section (sec))
1466         {
1467           if (oldfunc)
1468             {
1469               /* If a common symbol overrides a function, make sure
1470                  that it isn't defined dynamically nor has type
1471                  function.  */
1472               h->def_dynamic = 0;
1473               h->type = STT_NOTYPE;
1474             }
1475           *type_change_ok = TRUE;
1476         }
1477
1478       if (hi->root.type == bfd_link_hash_indirect)
1479         flip = hi;
1480       else
1481         /* This union may have been set to be non-NULL when this symbol
1482            was seen in a dynamic object.  We must force the union to be
1483            NULL, so that it is correct for a regular symbol.  */
1484         h->verinfo.vertree = NULL;
1485     }
1486
1487   /* Handle the special case of a new common symbol merging with an
1488      old symbol that looks like it might be a common symbol defined in
1489      a shared object.  Note that we have already handled the case in
1490      which a new common symbol should simply override the definition
1491      in the shared library.  */
1492
1493   if (! newdyn
1494       && bfd_is_com_section (sec)
1495       && olddyncommon)
1496     {
1497       /* It would be best if we could set the hash table entry to a
1498          common symbol, but we don't know what to use for the section
1499          or the alignment.  */
1500       if (! ((*info->callbacks->multiple_common)
1501              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1502         return FALSE;
1503
1504       /* If the presumed common symbol in the dynamic object is
1505          larger, pretend that the new symbol has its size.  */
1506
1507       if (h->size > *pvalue)
1508         *pvalue = h->size;
1509
1510       /* We need to remember the alignment required by the symbol
1511          in the dynamic object.  */
1512       BFD_ASSERT (pold_alignment);
1513       *pold_alignment = h->root.u.def.section->alignment_power;
1514
1515       olddef = FALSE;
1516       olddyncommon = FALSE;
1517
1518       h->root.type = bfd_link_hash_undefined;
1519       h->root.u.undef.abfd = h->root.u.def.section->owner;
1520
1521       *size_change_ok = TRUE;
1522       *type_change_ok = TRUE;
1523
1524       if (hi->root.type == bfd_link_hash_indirect)
1525         flip = hi;
1526       else
1527         h->verinfo.vertree = NULL;
1528     }
1529
1530   if (flip != NULL)
1531     {
1532       /* Handle the case where we had a versioned symbol in a dynamic
1533          library and now find a definition in a normal object.  In this
1534          case, we make the versioned symbol point to the normal one.  */
1535       flip->root.type = h->root.type;
1536       flip->root.u.undef.abfd = h->root.u.undef.abfd;
1537       h->root.type = bfd_link_hash_indirect;
1538       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1539       (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1540       if (h->def_dynamic)
1541         {
1542           h->def_dynamic = 0;
1543           flip->ref_dynamic = 1;
1544         }
1545     }
1546
1547   return TRUE;
1548 }
1549
1550 /* This function is called to create an indirect symbol from the
1551    default for the symbol with the default version if needed. The
1552    symbol is described by H, NAME, SYM, SEC, and VALUE.  We
1553    set DYNSYM if the new indirect symbol is dynamic.  */
1554
1555 static bfd_boolean
1556 _bfd_elf_add_default_symbol (bfd *abfd,
1557                              struct bfd_link_info *info,
1558                              struct elf_link_hash_entry *h,
1559                              const char *name,
1560                              Elf_Internal_Sym *sym,
1561                              asection *sec,
1562                              bfd_vma value,
1563                              bfd **poldbfd,
1564                              bfd_boolean *dynsym)
1565 {
1566   bfd_boolean type_change_ok;
1567   bfd_boolean size_change_ok;
1568   bfd_boolean skip;
1569   char *shortname;
1570   struct elf_link_hash_entry *hi;
1571   struct bfd_link_hash_entry *bh;
1572   const struct elf_backend_data *bed;
1573   bfd_boolean collect;
1574   bfd_boolean dynamic;
1575   bfd_boolean override;
1576   char *p;
1577   size_t len, shortlen;
1578   asection *tmp_sec;
1579
1580   /* If this symbol has a version, and it is the default version, we
1581      create an indirect symbol from the default name to the fully
1582      decorated name.  This will cause external references which do not
1583      specify a version to be bound to this version of the symbol.  */
1584   p = strchr (name, ELF_VER_CHR);
1585   if (p == NULL || p[1] != ELF_VER_CHR)
1586     return TRUE;
1587
1588   bed = get_elf_backend_data (abfd);
1589   collect = bed->collect;
1590   dynamic = (abfd->flags & DYNAMIC) != 0;
1591
1592   shortlen = p - name;
1593   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1594   if (shortname == NULL)
1595     return FALSE;
1596   memcpy (shortname, name, shortlen);
1597   shortname[shortlen] = '\0';
1598
1599   /* We are going to create a new symbol.  Merge it with any existing
1600      symbol with this name.  For the purposes of the merge, act as
1601      though we were defining the symbol we just defined, although we
1602      actually going to define an indirect symbol.  */
1603   type_change_ok = FALSE;
1604   size_change_ok = FALSE;
1605   tmp_sec = sec;
1606   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1607                               &hi, poldbfd, NULL, NULL, &skip, &override,
1608                               &type_change_ok, &size_change_ok))
1609     return FALSE;
1610
1611   if (skip)
1612     goto nondefault;
1613
1614   if (! override)
1615     {
1616       bh = &hi->root;
1617       if (! (_bfd_generic_link_add_one_symbol
1618              (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1619               0, name, FALSE, collect, &bh)))
1620         return FALSE;
1621       hi = (struct elf_link_hash_entry *) bh;
1622     }
1623   else
1624     {
1625       /* In this case the symbol named SHORTNAME is overriding the
1626          indirect symbol we want to add.  We were planning on making
1627          SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1628          is the name without a version.  NAME is the fully versioned
1629          name, and it is the default version.
1630
1631          Overriding means that we already saw a definition for the
1632          symbol SHORTNAME in a regular object, and it is overriding
1633          the symbol defined in the dynamic object.
1634
1635          When this happens, we actually want to change NAME, the
1636          symbol we just added, to refer to SHORTNAME.  This will cause
1637          references to NAME in the shared object to become references
1638          to SHORTNAME in the regular object.  This is what we expect
1639          when we override a function in a shared object: that the
1640          references in the shared object will be mapped to the
1641          definition in the regular object.  */
1642
1643       while (hi->root.type == bfd_link_hash_indirect
1644              || hi->root.type == bfd_link_hash_warning)
1645         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1646
1647       h->root.type = bfd_link_hash_indirect;
1648       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1649       if (h->def_dynamic)
1650         {
1651           h->def_dynamic = 0;
1652           hi->ref_dynamic = 1;
1653           if (hi->ref_regular
1654               || hi->def_regular)
1655             {
1656               if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1657                 return FALSE;
1658             }
1659         }
1660
1661       /* Now set HI to H, so that the following code will set the
1662          other fields correctly.  */
1663       hi = h;
1664     }
1665
1666   /* Check if HI is a warning symbol.  */
1667   if (hi->root.type == bfd_link_hash_warning)
1668     hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1669
1670   /* If there is a duplicate definition somewhere, then HI may not
1671      point to an indirect symbol.  We will have reported an error to
1672      the user in that case.  */
1673
1674   if (hi->root.type == bfd_link_hash_indirect)
1675     {
1676       struct elf_link_hash_entry *ht;
1677
1678       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1679       (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1680
1681       /* A reference to the SHORTNAME symbol from a dynamic library
1682          will be satisfied by the versioned symbol at runtime.  In
1683          effect, we have a reference to the versioned symbol.  */
1684       ht->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1685       hi->dynamic_def |= ht->dynamic_def;
1686
1687       /* See if the new flags lead us to realize that the symbol must
1688          be dynamic.  */
1689       if (! *dynsym)
1690         {
1691           if (! dynamic)
1692             {
1693               if (! info->executable
1694                   || hi->def_dynamic
1695                   || hi->ref_dynamic)
1696                 *dynsym = TRUE;
1697             }
1698           else
1699             {
1700               if (hi->ref_regular)
1701                 *dynsym = TRUE;
1702             }
1703         }
1704     }
1705
1706   /* We also need to define an indirection from the nondefault version
1707      of the symbol.  */
1708
1709 nondefault:
1710   len = strlen (name);
1711   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1712   if (shortname == NULL)
1713     return FALSE;
1714   memcpy (shortname, name, shortlen);
1715   memcpy (shortname + shortlen, p + 1, len - shortlen);
1716
1717   /* Once again, merge with any existing symbol.  */
1718   type_change_ok = FALSE;
1719   size_change_ok = FALSE;
1720   tmp_sec = sec;
1721   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1722                               &hi, poldbfd, NULL, NULL, &skip, &override,
1723                               &type_change_ok, &size_change_ok))
1724     return FALSE;
1725
1726   if (skip)
1727     return TRUE;
1728
1729   if (override)
1730     {
1731       /* Here SHORTNAME is a versioned name, so we don't expect to see
1732          the type of override we do in the case above unless it is
1733          overridden by a versioned definition.  */
1734       if (hi->root.type != bfd_link_hash_defined
1735           && hi->root.type != bfd_link_hash_defweak)
1736         (*_bfd_error_handler)
1737           (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1738            abfd, shortname);
1739     }
1740   else
1741     {
1742       bh = &hi->root;
1743       if (! (_bfd_generic_link_add_one_symbol
1744              (info, abfd, shortname, BSF_INDIRECT,
1745               bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1746         return FALSE;
1747       hi = (struct elf_link_hash_entry *) bh;
1748
1749       /* If there is a duplicate definition somewhere, then HI may not
1750          point to an indirect symbol.  We will have reported an error
1751          to the user in that case.  */
1752
1753       if (hi->root.type == bfd_link_hash_indirect)
1754         {
1755           (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1756           h->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1757           hi->dynamic_def |= h->dynamic_def;
1758
1759           /* See if the new flags lead us to realize that the symbol
1760              must be dynamic.  */
1761           if (! *dynsym)
1762             {
1763               if (! dynamic)
1764                 {
1765                   if (! info->executable
1766                       || hi->ref_dynamic)
1767                     *dynsym = TRUE;
1768                 }
1769               else
1770                 {
1771                   if (hi->ref_regular)
1772                     *dynsym = TRUE;
1773                 }
1774             }
1775         }
1776     }
1777
1778   return TRUE;
1779 }
1780 \f
1781 /* This routine is used to export all defined symbols into the dynamic
1782    symbol table.  It is called via elf_link_hash_traverse.  */
1783
1784 static bfd_boolean
1785 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1786 {
1787   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1788
1789   /* Ignore indirect symbols.  These are added by the versioning code.  */
1790   if (h->root.type == bfd_link_hash_indirect)
1791     return TRUE;
1792
1793   /* Ignore this if we won't export it.  */
1794   if (!eif->info->export_dynamic && !h->dynamic)
1795     return TRUE;
1796
1797   if (h->dynindx == -1
1798       && (h->def_regular || h->ref_regular)
1799       && ! bfd_hide_sym_by_version (eif->info->version_info,
1800                                     h->root.root.string))
1801     {
1802       if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1803         {
1804           eif->failed = TRUE;
1805           return FALSE;
1806         }
1807     }
1808
1809   return TRUE;
1810 }
1811 \f
1812 /* Look through the symbols which are defined in other shared
1813    libraries and referenced here.  Update the list of version
1814    dependencies.  This will be put into the .gnu.version_r section.
1815    This function is called via elf_link_hash_traverse.  */
1816
1817 static bfd_boolean
1818 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1819                                          void *data)
1820 {
1821   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1822   Elf_Internal_Verneed *t;
1823   Elf_Internal_Vernaux *a;
1824   bfd_size_type amt;
1825
1826   /* We only care about symbols defined in shared objects with version
1827      information.  */
1828   if (!h->def_dynamic
1829       || h->def_regular
1830       || h->dynindx == -1
1831       || h->verinfo.verdef == NULL
1832       || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
1833           & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
1834     return TRUE;
1835
1836   /* See if we already know about this version.  */
1837   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1838        t != NULL;
1839        t = t->vn_nextref)
1840     {
1841       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1842         continue;
1843
1844       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1845         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1846           return TRUE;
1847
1848       break;
1849     }
1850
1851   /* This is a new version.  Add it to tree we are building.  */
1852
1853   if (t == NULL)
1854     {
1855       amt = sizeof *t;
1856       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1857       if (t == NULL)
1858         {
1859           rinfo->failed = TRUE;
1860           return FALSE;
1861         }
1862
1863       t->vn_bfd = h->verinfo.verdef->vd_bfd;
1864       t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1865       elf_tdata (rinfo->info->output_bfd)->verref = t;
1866     }
1867
1868   amt = sizeof *a;
1869   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1870   if (a == NULL)
1871     {
1872       rinfo->failed = TRUE;
1873       return FALSE;
1874     }
1875
1876   /* Note that we are copying a string pointer here, and testing it
1877      above.  If bfd_elf_string_from_elf_section is ever changed to
1878      discard the string data when low in memory, this will have to be
1879      fixed.  */
1880   a->vna_nodename = h->verinfo.verdef->vd_nodename;
1881
1882   a->vna_flags = h->verinfo.verdef->vd_flags;
1883   a->vna_nextptr = t->vn_auxptr;
1884
1885   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1886   ++rinfo->vers;
1887
1888   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1889
1890   t->vn_auxptr = a;
1891
1892   return TRUE;
1893 }
1894
1895 /* Figure out appropriate versions for all the symbols.  We may not
1896    have the version number script until we have read all of the input
1897    files, so until that point we don't know which symbols should be
1898    local.  This function is called via elf_link_hash_traverse.  */
1899
1900 static bfd_boolean
1901 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1902 {
1903   struct elf_info_failed *sinfo;
1904   struct bfd_link_info *info;
1905   const struct elf_backend_data *bed;
1906   struct elf_info_failed eif;
1907   char *p;
1908   bfd_size_type amt;
1909
1910   sinfo = (struct elf_info_failed *) data;
1911   info = sinfo->info;
1912
1913   /* Fix the symbol flags.  */
1914   eif.failed = FALSE;
1915   eif.info = info;
1916   if (! _bfd_elf_fix_symbol_flags (h, &eif))
1917     {
1918       if (eif.failed)
1919         sinfo->failed = TRUE;
1920       return FALSE;
1921     }
1922
1923   /* We only need version numbers for symbols defined in regular
1924      objects.  */
1925   if (!h->def_regular)
1926     return TRUE;
1927
1928   bed = get_elf_backend_data (info->output_bfd);
1929   p = strchr (h->root.root.string, ELF_VER_CHR);
1930   if (p != NULL && h->verinfo.vertree == NULL)
1931     {
1932       struct bfd_elf_version_tree *t;
1933       bfd_boolean hidden;
1934
1935       hidden = TRUE;
1936
1937       /* There are two consecutive ELF_VER_CHR characters if this is
1938          not a hidden symbol.  */
1939       ++p;
1940       if (*p == ELF_VER_CHR)
1941         {
1942           hidden = FALSE;
1943           ++p;
1944         }
1945
1946       /* If there is no version string, we can just return out.  */
1947       if (*p == '\0')
1948         {
1949           if (hidden)
1950             h->hidden = 1;
1951           return TRUE;
1952         }
1953
1954       /* Look for the version.  If we find it, it is no longer weak.  */
1955       for (t = sinfo->info->version_info; t != NULL; t = t->next)
1956         {
1957           if (strcmp (t->name, p) == 0)
1958             {
1959               size_t len;
1960               char *alc;
1961               struct bfd_elf_version_expr *d;
1962
1963               len = p - h->root.root.string;
1964               alc = (char *) bfd_malloc (len);
1965               if (alc == NULL)
1966                 {
1967                   sinfo->failed = TRUE;
1968                   return FALSE;
1969                 }
1970               memcpy (alc, h->root.root.string, len - 1);
1971               alc[len - 1] = '\0';
1972               if (alc[len - 2] == ELF_VER_CHR)
1973                 alc[len - 2] = '\0';
1974
1975               h->verinfo.vertree = t;
1976               t->used = TRUE;
1977               d = NULL;
1978
1979               if (t->globals.list != NULL)
1980                 d = (*t->match) (&t->globals, NULL, alc);
1981
1982               /* See if there is anything to force this symbol to
1983                  local scope.  */
1984               if (d == NULL && t->locals.list != NULL)
1985                 {
1986                   d = (*t->match) (&t->locals, NULL, alc);
1987                   if (d != NULL
1988                       && h->dynindx != -1
1989                       && ! info->export_dynamic)
1990                     (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1991                 }
1992
1993               free (alc);
1994               break;
1995             }
1996         }
1997
1998       /* If we are building an application, we need to create a
1999          version node for this version.  */
2000       if (t == NULL && info->executable)
2001         {
2002           struct bfd_elf_version_tree **pp;
2003           int version_index;
2004
2005           /* If we aren't going to export this symbol, we don't need
2006              to worry about it.  */
2007           if (h->dynindx == -1)
2008             return TRUE;
2009
2010           amt = sizeof *t;
2011           t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2012           if (t == NULL)
2013             {
2014               sinfo->failed = TRUE;
2015               return FALSE;
2016             }
2017
2018           t->name = p;
2019           t->name_indx = (unsigned int) -1;
2020           t->used = TRUE;
2021
2022           version_index = 1;
2023           /* Don't count anonymous version tag.  */
2024           if (sinfo->info->version_info != NULL
2025               && sinfo->info->version_info->vernum == 0)
2026             version_index = 0;
2027           for (pp = &sinfo->info->version_info;
2028                *pp != NULL;
2029                pp = &(*pp)->next)
2030             ++version_index;
2031           t->vernum = version_index;
2032
2033           *pp = t;
2034
2035           h->verinfo.vertree = t;
2036         }
2037       else if (t == NULL)
2038         {
2039           /* We could not find the version for a symbol when
2040              generating a shared archive.  Return an error.  */
2041           (*_bfd_error_handler)
2042             (_("%B: version node not found for symbol %s"),
2043              info->output_bfd, h->root.root.string);
2044           bfd_set_error (bfd_error_bad_value);
2045           sinfo->failed = TRUE;
2046           return FALSE;
2047         }
2048
2049       if (hidden)
2050         h->hidden = 1;
2051     }
2052
2053   /* If we don't have a version for this symbol, see if we can find
2054      something.  */
2055   if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2056     {
2057       bfd_boolean hide;
2058
2059       h->verinfo.vertree
2060         = bfd_find_version_for_sym (sinfo->info->version_info,
2061                                     h->root.root.string, &hide);
2062       if (h->verinfo.vertree != NULL && hide)
2063         (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2064     }
2065
2066   return TRUE;
2067 }
2068 \f
2069 /* Read and swap the relocs from the section indicated by SHDR.  This
2070    may be either a REL or a RELA section.  The relocations are
2071    translated into RELA relocations and stored in INTERNAL_RELOCS,
2072    which should have already been allocated to contain enough space.
2073    The EXTERNAL_RELOCS are a buffer where the external form of the
2074    relocations should be stored.
2075
2076    Returns FALSE if something goes wrong.  */
2077
2078 static bfd_boolean
2079 elf_link_read_relocs_from_section (bfd *abfd,
2080                                    asection *sec,
2081                                    Elf_Internal_Shdr *shdr,
2082                                    void *external_relocs,
2083                                    Elf_Internal_Rela *internal_relocs)
2084 {
2085   const struct elf_backend_data *bed;
2086   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2087   const bfd_byte *erela;
2088   const bfd_byte *erelaend;
2089   Elf_Internal_Rela *irela;
2090   Elf_Internal_Shdr *symtab_hdr;
2091   size_t nsyms;
2092
2093   /* Position ourselves at the start of the section.  */
2094   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2095     return FALSE;
2096
2097   /* Read the relocations.  */
2098   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2099     return FALSE;
2100
2101   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2102   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2103
2104   bed = get_elf_backend_data (abfd);
2105
2106   /* Convert the external relocations to the internal format.  */
2107   if (shdr->sh_entsize == bed->s->sizeof_rel)
2108     swap_in = bed->s->swap_reloc_in;
2109   else if (shdr->sh_entsize == bed->s->sizeof_rela)
2110     swap_in = bed->s->swap_reloca_in;
2111   else
2112     {
2113       bfd_set_error (bfd_error_wrong_format);
2114       return FALSE;
2115     }
2116
2117   erela = (const bfd_byte *) external_relocs;
2118   erelaend = erela + shdr->sh_size;
2119   irela = internal_relocs;
2120   while (erela < erelaend)
2121     {
2122       bfd_vma r_symndx;
2123
2124       (*swap_in) (abfd, erela, irela);
2125       r_symndx = ELF32_R_SYM (irela->r_info);
2126       if (bed->s->arch_size == 64)
2127         r_symndx >>= 24;
2128       if (nsyms > 0)
2129         {
2130           if ((size_t) r_symndx >= nsyms)
2131             {
2132               (*_bfd_error_handler)
2133                 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2134                    " for offset 0x%lx in section `%A'"),
2135                  abfd, sec,
2136                  (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2137               bfd_set_error (bfd_error_bad_value);
2138               return FALSE;
2139             }
2140         }
2141       else if (r_symndx != STN_UNDEF)
2142         {
2143           (*_bfd_error_handler)
2144             (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2145                " when the object file has no symbol table"),
2146              abfd, sec,
2147              (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2148           bfd_set_error (bfd_error_bad_value);
2149           return FALSE;
2150         }
2151       irela += bed->s->int_rels_per_ext_rel;
2152       erela += shdr->sh_entsize;
2153     }
2154
2155   return TRUE;
2156 }
2157
2158 /* Read and swap the relocs for a section O.  They may have been
2159    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2160    not NULL, they are used as buffers to read into.  They are known to
2161    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2162    the return value is allocated using either malloc or bfd_alloc,
2163    according to the KEEP_MEMORY argument.  If O has two relocation
2164    sections (both REL and RELA relocations), then the REL_HDR
2165    relocations will appear first in INTERNAL_RELOCS, followed by the
2166    RELA_HDR relocations.  */
2167
2168 Elf_Internal_Rela *
2169 _bfd_elf_link_read_relocs (bfd *abfd,
2170                            asection *o,
2171                            void *external_relocs,
2172                            Elf_Internal_Rela *internal_relocs,
2173                            bfd_boolean keep_memory)
2174 {
2175   void *alloc1 = NULL;
2176   Elf_Internal_Rela *alloc2 = NULL;
2177   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2178   struct bfd_elf_section_data *esdo = elf_section_data (o);
2179   Elf_Internal_Rela *internal_rela_relocs;
2180
2181   if (esdo->relocs != NULL)
2182     return esdo->relocs;
2183
2184   if (o->reloc_count == 0)
2185     return NULL;
2186
2187   if (internal_relocs == NULL)
2188     {
2189       bfd_size_type size;
2190
2191       size = o->reloc_count;
2192       size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2193       if (keep_memory)
2194         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2195       else
2196         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2197       if (internal_relocs == NULL)
2198         goto error_return;
2199     }
2200
2201   if (external_relocs == NULL)
2202     {
2203       bfd_size_type size = 0;
2204
2205       if (esdo->rel.hdr)
2206         size += esdo->rel.hdr->sh_size;
2207       if (esdo->rela.hdr)
2208         size += esdo->rela.hdr->sh_size;
2209
2210       alloc1 = bfd_malloc (size);
2211       if (alloc1 == NULL)
2212         goto error_return;
2213       external_relocs = alloc1;
2214     }
2215
2216   internal_rela_relocs = internal_relocs;
2217   if (esdo->rel.hdr)
2218     {
2219       if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2220                                               external_relocs,
2221                                               internal_relocs))
2222         goto error_return;
2223       external_relocs = (((bfd_byte *) external_relocs)
2224                          + esdo->rel.hdr->sh_size);
2225       internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2226                                * bed->s->int_rels_per_ext_rel);
2227     }
2228
2229   if (esdo->rela.hdr
2230       && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2231                                               external_relocs,
2232                                               internal_rela_relocs)))
2233     goto error_return;
2234
2235   /* Cache the results for next time, if we can.  */
2236   if (keep_memory)
2237     esdo->relocs = internal_relocs;
2238
2239   if (alloc1 != NULL)
2240     free (alloc1);
2241
2242   /* Don't free alloc2, since if it was allocated we are passing it
2243      back (under the name of internal_relocs).  */
2244
2245   return internal_relocs;
2246
2247  error_return:
2248   if (alloc1 != NULL)
2249     free (alloc1);
2250   if (alloc2 != NULL)
2251     {
2252       if (keep_memory)
2253         bfd_release (abfd, alloc2);
2254       else
2255         free (alloc2);
2256     }
2257   return NULL;
2258 }
2259
2260 /* Compute the size of, and allocate space for, REL_HDR which is the
2261    section header for a section containing relocations for O.  */
2262
2263 static bfd_boolean
2264 _bfd_elf_link_size_reloc_section (bfd *abfd,
2265                                   struct bfd_elf_section_reloc_data *reldata)
2266 {
2267   Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2268
2269   /* That allows us to calculate the size of the section.  */
2270   rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2271
2272   /* The contents field must last into write_object_contents, so we
2273      allocate it with bfd_alloc rather than malloc.  Also since we
2274      cannot be sure that the contents will actually be filled in,
2275      we zero the allocated space.  */
2276   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2277   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2278     return FALSE;
2279
2280   if (reldata->hashes == NULL && reldata->count)
2281     {
2282       struct elf_link_hash_entry **p;
2283
2284       p = (struct elf_link_hash_entry **)
2285           bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
2286       if (p == NULL)
2287         return FALSE;
2288
2289       reldata->hashes = p;
2290     }
2291
2292   return TRUE;
2293 }
2294
2295 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2296    originated from the section given by INPUT_REL_HDR) to the
2297    OUTPUT_BFD.  */
2298
2299 bfd_boolean
2300 _bfd_elf_link_output_relocs (bfd *output_bfd,
2301                              asection *input_section,
2302                              Elf_Internal_Shdr *input_rel_hdr,
2303                              Elf_Internal_Rela *internal_relocs,
2304                              struct elf_link_hash_entry **rel_hash
2305                                ATTRIBUTE_UNUSED)
2306 {
2307   Elf_Internal_Rela *irela;
2308   Elf_Internal_Rela *irelaend;
2309   bfd_byte *erel;
2310   struct bfd_elf_section_reloc_data *output_reldata;
2311   asection *output_section;
2312   const struct elf_backend_data *bed;
2313   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2314   struct bfd_elf_section_data *esdo;
2315
2316   output_section = input_section->output_section;
2317
2318   bed = get_elf_backend_data (output_bfd);
2319   esdo = elf_section_data (output_section);
2320   if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2321     {
2322       output_reldata = &esdo->rel;
2323       swap_out = bed->s->swap_reloc_out;
2324     }
2325   else if (esdo->rela.hdr
2326            && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2327     {
2328       output_reldata = &esdo->rela;
2329       swap_out = bed->s->swap_reloca_out;
2330     }
2331   else
2332     {
2333       (*_bfd_error_handler)
2334         (_("%B: relocation size mismatch in %B section %A"),
2335          output_bfd, input_section->owner, input_section);
2336       bfd_set_error (bfd_error_wrong_format);
2337       return FALSE;
2338     }
2339
2340   erel = output_reldata->hdr->contents;
2341   erel += output_reldata->count * input_rel_hdr->sh_entsize;
2342   irela = internal_relocs;
2343   irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2344                       * bed->s->int_rels_per_ext_rel);
2345   while (irela < irelaend)
2346     {
2347       (*swap_out) (output_bfd, irela, erel);
2348       irela += bed->s->int_rels_per_ext_rel;
2349       erel += input_rel_hdr->sh_entsize;
2350     }
2351
2352   /* Bump the counter, so that we know where to add the next set of
2353      relocations.  */
2354   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2355
2356   return TRUE;
2357 }
2358 \f
2359 /* Make weak undefined symbols in PIE dynamic.  */
2360
2361 bfd_boolean
2362 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2363                                  struct elf_link_hash_entry *h)
2364 {
2365   if (info->pie
2366       && h->dynindx == -1
2367       && h->root.type == bfd_link_hash_undefweak)
2368     return bfd_elf_link_record_dynamic_symbol (info, h);
2369
2370   return TRUE;
2371 }
2372
2373 /* Fix up the flags for a symbol.  This handles various cases which
2374    can only be fixed after all the input files are seen.  This is
2375    currently called by both adjust_dynamic_symbol and
2376    assign_sym_version, which is unnecessary but perhaps more robust in
2377    the face of future changes.  */
2378
2379 static bfd_boolean
2380 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2381                            struct elf_info_failed *eif)
2382 {
2383   const struct elf_backend_data *bed;
2384
2385   /* If this symbol was mentioned in a non-ELF file, try to set
2386      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2387      permit a non-ELF file to correctly refer to a symbol defined in
2388      an ELF dynamic object.  */
2389   if (h->non_elf)
2390     {
2391       while (h->root.type == bfd_link_hash_indirect)
2392         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2393
2394       if (h->root.type != bfd_link_hash_defined
2395           && h->root.type != bfd_link_hash_defweak)
2396         {
2397           h->ref_regular = 1;
2398           h->ref_regular_nonweak = 1;
2399         }
2400       else
2401         {
2402           if (h->root.u.def.section->owner != NULL
2403               && (bfd_get_flavour (h->root.u.def.section->owner)
2404                   == bfd_target_elf_flavour))
2405             {
2406               h->ref_regular = 1;
2407               h->ref_regular_nonweak = 1;
2408             }
2409           else
2410             h->def_regular = 1;
2411         }
2412
2413       if (h->dynindx == -1
2414           && (h->def_dynamic
2415               || h->ref_dynamic))
2416         {
2417           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2418             {
2419               eif->failed = TRUE;
2420               return FALSE;
2421             }
2422         }
2423     }
2424   else
2425     {
2426       /* Unfortunately, NON_ELF is only correct if the symbol
2427          was first seen in a non-ELF file.  Fortunately, if the symbol
2428          was first seen in an ELF file, we're probably OK unless the
2429          symbol was defined in a non-ELF file.  Catch that case here.
2430          FIXME: We're still in trouble if the symbol was first seen in
2431          a dynamic object, and then later in a non-ELF regular object.  */
2432       if ((h->root.type == bfd_link_hash_defined
2433            || h->root.type == bfd_link_hash_defweak)
2434           && !h->def_regular
2435           && (h->root.u.def.section->owner != NULL
2436               ? (bfd_get_flavour (h->root.u.def.section->owner)
2437                  != bfd_target_elf_flavour)
2438               : (bfd_is_abs_section (h->root.u.def.section)
2439                  && !h->def_dynamic)))
2440         h->def_regular = 1;
2441     }
2442
2443   /* Backend specific symbol fixup.  */
2444   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2445   if (bed->elf_backend_fixup_symbol
2446       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2447     return FALSE;
2448
2449   /* If this is a final link, and the symbol was defined as a common
2450      symbol in a regular object file, and there was no definition in
2451      any dynamic object, then the linker will have allocated space for
2452      the symbol in a common section but the DEF_REGULAR
2453      flag will not have been set.  */
2454   if (h->root.type == bfd_link_hash_defined
2455       && !h->def_regular
2456       && h->ref_regular
2457       && !h->def_dynamic
2458       && (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0)
2459     h->def_regular = 1;
2460
2461   /* If -Bsymbolic was used (which means to bind references to global
2462      symbols to the definition within the shared object), and this
2463      symbol was defined in a regular object, then it actually doesn't
2464      need a PLT entry.  Likewise, if the symbol has non-default
2465      visibility.  If the symbol has hidden or internal visibility, we
2466      will force it local.  */
2467   if (h->needs_plt
2468       && eif->info->shared
2469       && is_elf_hash_table (eif->info->hash)
2470       && (SYMBOLIC_BIND (eif->info, h)
2471           || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2472       && h->def_regular)
2473     {
2474       bfd_boolean force_local;
2475
2476       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2477                      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2478       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2479     }
2480
2481   /* If a weak undefined symbol has non-default visibility, we also
2482      hide it from the dynamic linker.  */
2483   if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2484       && h->root.type == bfd_link_hash_undefweak)
2485     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2486
2487   /* If this is a weak defined symbol in a dynamic object, and we know
2488      the real definition in the dynamic object, copy interesting flags
2489      over to the real definition.  */
2490   if (h->u.weakdef != NULL)
2491     {
2492       /* If the real definition is defined by a regular object file,
2493          don't do anything special.  See the longer description in
2494          _bfd_elf_adjust_dynamic_symbol, below.  */
2495       if (h->u.weakdef->def_regular)
2496         h->u.weakdef = NULL;
2497       else
2498         {
2499           struct elf_link_hash_entry *weakdef = h->u.weakdef;
2500
2501           while (h->root.type == bfd_link_hash_indirect)
2502             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2503
2504           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2505                       || h->root.type == bfd_link_hash_defweak);
2506           BFD_ASSERT (weakdef->def_dynamic);
2507           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2508                       || weakdef->root.type == bfd_link_hash_defweak);
2509           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2510         }
2511     }
2512
2513   return TRUE;
2514 }
2515
2516 /* Make the backend pick a good value for a dynamic symbol.  This is
2517    called via elf_link_hash_traverse, and also calls itself
2518    recursively.  */
2519
2520 static bfd_boolean
2521 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2522 {
2523   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2524   bfd *dynobj;
2525   const struct elf_backend_data *bed;
2526
2527   if (! is_elf_hash_table (eif->info->hash))
2528     return FALSE;
2529
2530   /* Ignore indirect symbols.  These are added by the versioning code.  */
2531   if (h->root.type == bfd_link_hash_indirect)
2532     return TRUE;
2533
2534   /* Fix the symbol flags.  */
2535   if (! _bfd_elf_fix_symbol_flags (h, eif))
2536     return FALSE;
2537
2538   /* If this symbol does not require a PLT entry, and it is not
2539      defined by a dynamic object, or is not referenced by a regular
2540      object, ignore it.  We do have to handle a weak defined symbol,
2541      even if no regular object refers to it, if we decided to add it
2542      to the dynamic symbol table.  FIXME: Do we normally need to worry
2543      about symbols which are defined by one dynamic object and
2544      referenced by another one?  */
2545   if (!h->needs_plt
2546       && h->type != STT_GNU_IFUNC
2547       && (h->def_regular
2548           || !h->def_dynamic
2549           || (!h->ref_regular
2550               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2551     {
2552       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2553       return TRUE;
2554     }
2555
2556   /* If we've already adjusted this symbol, don't do it again.  This
2557      can happen via a recursive call.  */
2558   if (h->dynamic_adjusted)
2559     return TRUE;
2560
2561   /* Don't look at this symbol again.  Note that we must set this
2562      after checking the above conditions, because we may look at a
2563      symbol once, decide not to do anything, and then get called
2564      recursively later after REF_REGULAR is set below.  */
2565   h->dynamic_adjusted = 1;
2566
2567   /* If this is a weak definition, and we know a real definition, and
2568      the real symbol is not itself defined by a regular object file,
2569      then get a good value for the real definition.  We handle the
2570      real symbol first, for the convenience of the backend routine.
2571
2572      Note that there is a confusing case here.  If the real definition
2573      is defined by a regular object file, we don't get the real symbol
2574      from the dynamic object, but we do get the weak symbol.  If the
2575      processor backend uses a COPY reloc, then if some routine in the
2576      dynamic object changes the real symbol, we will not see that
2577      change in the corresponding weak symbol.  This is the way other
2578      ELF linkers work as well, and seems to be a result of the shared
2579      library model.
2580
2581      I will clarify this issue.  Most SVR4 shared libraries define the
2582      variable _timezone and define timezone as a weak synonym.  The
2583      tzset call changes _timezone.  If you write
2584        extern int timezone;
2585        int _timezone = 5;
2586        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2587      you might expect that, since timezone is a synonym for _timezone,
2588      the same number will print both times.  However, if the processor
2589      backend uses a COPY reloc, then actually timezone will be copied
2590      into your process image, and, since you define _timezone
2591      yourself, _timezone will not.  Thus timezone and _timezone will
2592      wind up at different memory locations.  The tzset call will set
2593      _timezone, leaving timezone unchanged.  */
2594
2595   if (h->u.weakdef != NULL)
2596     {
2597       /* If we get to this point, there is an implicit reference to
2598          H->U.WEAKDEF by a regular object file via the weak symbol H.  */
2599       h->u.weakdef->ref_regular = 1;
2600
2601       /* Ensure that the backend adjust_dynamic_symbol function sees
2602          H->U.WEAKDEF before H by recursively calling ourselves.  */
2603       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2604         return FALSE;
2605     }
2606
2607   /* If a symbol has no type and no size and does not require a PLT
2608      entry, then we are probably about to do the wrong thing here: we
2609      are probably going to create a COPY reloc for an empty object.
2610      This case can arise when a shared object is built with assembly
2611      code, and the assembly code fails to set the symbol type.  */
2612   if (h->size == 0
2613       && h->type == STT_NOTYPE
2614       && !h->needs_plt)
2615     (*_bfd_error_handler)
2616       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2617        h->root.root.string);
2618
2619   dynobj = elf_hash_table (eif->info)->dynobj;
2620   bed = get_elf_backend_data (dynobj);
2621
2622   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2623     {
2624       eif->failed = TRUE;
2625       return FALSE;
2626     }
2627
2628   return TRUE;
2629 }
2630
2631 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2632    DYNBSS.  */
2633
2634 bfd_boolean
2635 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
2636                               struct elf_link_hash_entry *h,
2637                               asection *dynbss)
2638 {
2639   unsigned int power_of_two;
2640   bfd_vma mask;
2641   asection *sec = h->root.u.def.section;
2642
2643   /* The section aligment of definition is the maximum alignment
2644      requirement of symbols defined in the section.  Since we don't
2645      know the symbol alignment requirement, we start with the
2646      maximum alignment and check low bits of the symbol address
2647      for the minimum alignment.  */
2648   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2649   mask = ((bfd_vma) 1 << power_of_two) - 1;
2650   while ((h->root.u.def.value & mask) != 0)
2651     {
2652        mask >>= 1;
2653        --power_of_two;
2654     }
2655
2656   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2657                                                 dynbss))
2658     {
2659       /* Adjust the section alignment if needed.  */
2660       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2661                                        power_of_two))
2662         return FALSE;
2663     }
2664
2665   /* We make sure that the symbol will be aligned properly.  */
2666   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2667
2668   /* Define the symbol as being at this point in DYNBSS.  */
2669   h->root.u.def.section = dynbss;
2670   h->root.u.def.value = dynbss->size;
2671
2672   /* Increment the size of DYNBSS to make room for the symbol.  */
2673   dynbss->size += h->size;
2674
2675   if (h->protected_def)
2676     {
2677       info->callbacks->einfo
2678         (_("%P: copy reloc against protected `%T' is invalid\n"),
2679          h->root.root.string);
2680       bfd_set_error (bfd_error_bad_value);
2681       return FALSE;
2682     }
2683
2684   return TRUE;
2685 }
2686
2687 /* Adjust all external symbols pointing into SEC_MERGE sections
2688    to reflect the object merging within the sections.  */
2689
2690 static bfd_boolean
2691 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2692 {
2693   asection *sec;
2694
2695   if ((h->root.type == bfd_link_hash_defined
2696        || h->root.type == bfd_link_hash_defweak)
2697       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2698       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
2699     {
2700       bfd *output_bfd = (bfd *) data;
2701
2702       h->root.u.def.value =
2703         _bfd_merged_section_offset (output_bfd,
2704                                     &h->root.u.def.section,
2705                                     elf_section_data (sec)->sec_info,
2706                                     h->root.u.def.value);
2707     }
2708
2709   return TRUE;
2710 }
2711
2712 /* Returns false if the symbol referred to by H should be considered
2713    to resolve local to the current module, and true if it should be
2714    considered to bind dynamically.  */
2715
2716 bfd_boolean
2717 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2718                            struct bfd_link_info *info,
2719                            bfd_boolean not_local_protected)
2720 {
2721   bfd_boolean binding_stays_local_p;
2722   const struct elf_backend_data *bed;
2723   struct elf_link_hash_table *hash_table;
2724
2725   if (h == NULL)
2726     return FALSE;
2727
2728   while (h->root.type == bfd_link_hash_indirect
2729          || h->root.type == bfd_link_hash_warning)
2730     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2731
2732   /* If it was forced local, then clearly it's not dynamic.  */
2733   if (h->dynindx == -1)
2734     return FALSE;
2735   if (h->forced_local)
2736     return FALSE;
2737
2738   /* Identify the cases where name binding rules say that a
2739      visible symbol resolves locally.  */
2740   binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2741
2742   switch (ELF_ST_VISIBILITY (h->other))
2743     {
2744     case STV_INTERNAL:
2745     case STV_HIDDEN:
2746       return FALSE;
2747
2748     case STV_PROTECTED:
2749       hash_table = elf_hash_table (info);
2750       if (!is_elf_hash_table (hash_table))
2751         return FALSE;
2752
2753       bed = get_elf_backend_data (hash_table->dynobj);
2754
2755       /* Proper resolution for function pointer equality may require
2756          that these symbols perhaps be resolved dynamically, even though
2757          we should be resolving them to the current module.  */
2758       if (!not_local_protected || !bed->is_function_type (h->type))
2759         binding_stays_local_p = TRUE;
2760       break;
2761
2762     default:
2763       break;
2764     }
2765
2766   /* If it isn't defined locally, then clearly it's dynamic.  */
2767   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2768     return TRUE;
2769
2770   /* Otherwise, the symbol is dynamic if binding rules don't tell
2771      us that it remains local.  */
2772   return !binding_stays_local_p;
2773 }
2774
2775 /* Return true if the symbol referred to by H should be considered
2776    to resolve local to the current module, and false otherwise.  Differs
2777    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2778    undefined symbols.  The two functions are virtually identical except
2779    for the place where forced_local and dynindx == -1 are tested.  If
2780    either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2781    the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2782    the symbol is local only for defined symbols.
2783    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2784    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2785    treatment of undefined weak symbols.  For those that do not make
2786    undefined weak symbols dynamic, both functions may return false.  */
2787
2788 bfd_boolean
2789 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2790                               struct bfd_link_info *info,
2791                               bfd_boolean local_protected)
2792 {
2793   const struct elf_backend_data *bed;
2794   struct elf_link_hash_table *hash_table;
2795
2796   /* If it's a local sym, of course we resolve locally.  */
2797   if (h == NULL)
2798     return TRUE;
2799
2800   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2801   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2802       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2803     return TRUE;
2804
2805   /* Common symbols that become definitions don't get the DEF_REGULAR
2806      flag set, so test it first, and don't bail out.  */
2807   if (ELF_COMMON_DEF_P (h))
2808     /* Do nothing.  */;
2809   /* If we don't have a definition in a regular file, then we can't
2810      resolve locally.  The sym is either undefined or dynamic.  */
2811   else if (!h->def_regular)
2812     return FALSE;
2813
2814   /* Forced local symbols resolve locally.  */
2815   if (h->forced_local)
2816     return TRUE;
2817
2818   /* As do non-dynamic symbols.  */
2819   if (h->dynindx == -1)
2820     return TRUE;
2821
2822   /* At this point, we know the symbol is defined and dynamic.  In an
2823      executable it must resolve locally, likewise when building symbolic
2824      shared libraries.  */
2825   if (info->executable || SYMBOLIC_BIND (info, h))
2826     return TRUE;
2827
2828   /* Now deal with defined dynamic symbols in shared libraries.  Ones
2829      with default visibility might not resolve locally.  */
2830   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2831     return FALSE;
2832
2833   hash_table = elf_hash_table (info);
2834   if (!is_elf_hash_table (hash_table))
2835     return TRUE;
2836
2837   bed = get_elf_backend_data (hash_table->dynobj);
2838
2839   /* STV_PROTECTED non-function symbols are local.  */
2840   if (!bed->is_function_type (h->type))
2841     return TRUE;
2842
2843   /* Function pointer equality tests may require that STV_PROTECTED
2844      symbols be treated as dynamic symbols.  If the address of a
2845      function not defined in an executable is set to that function's
2846      plt entry in the executable, then the address of the function in
2847      a shared library must also be the plt entry in the executable.  */
2848   return local_protected;
2849 }
2850
2851 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2852    aligned.  Returns the first TLS output section.  */
2853
2854 struct bfd_section *
2855 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2856 {
2857   struct bfd_section *sec, *tls;
2858   unsigned int align = 0;
2859
2860   for (sec = obfd->sections; sec != NULL; sec = sec->next)
2861     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2862       break;
2863   tls = sec;
2864
2865   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2866     if (sec->alignment_power > align)
2867       align = sec->alignment_power;
2868
2869   elf_hash_table (info)->tls_sec = tls;
2870
2871   /* Ensure the alignment of the first section is the largest alignment,
2872      so that the tls segment starts aligned.  */
2873   if (tls != NULL)
2874     tls->alignment_power = align;
2875
2876   return tls;
2877 }
2878
2879 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
2880 static bfd_boolean
2881 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2882                                   Elf_Internal_Sym *sym)
2883 {
2884   const struct elf_backend_data *bed;
2885
2886   /* Local symbols do not count, but target specific ones might.  */
2887   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2888       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2889     return FALSE;
2890
2891   bed = get_elf_backend_data (abfd);
2892   /* Function symbols do not count.  */
2893   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2894     return FALSE;
2895
2896   /* If the section is undefined, then so is the symbol.  */
2897   if (sym->st_shndx == SHN_UNDEF)
2898     return FALSE;
2899
2900   /* If the symbol is defined in the common section, then
2901      it is a common definition and so does not count.  */
2902   if (bed->common_definition (sym))
2903     return FALSE;
2904
2905   /* If the symbol is in a target specific section then we
2906      must rely upon the backend to tell us what it is.  */
2907   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2908     /* FIXME - this function is not coded yet:
2909
2910        return _bfd_is_global_symbol_definition (abfd, sym);
2911
2912        Instead for now assume that the definition is not global,
2913        Even if this is wrong, at least the linker will behave
2914        in the same way that it used to do.  */
2915     return FALSE;
2916
2917   return TRUE;
2918 }
2919
2920 /* Search the symbol table of the archive element of the archive ABFD
2921    whose archive map contains a mention of SYMDEF, and determine if
2922    the symbol is defined in this element.  */
2923 static bfd_boolean
2924 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2925 {
2926   Elf_Internal_Shdr * hdr;
2927   bfd_size_type symcount;
2928   bfd_size_type extsymcount;
2929   bfd_size_type extsymoff;
2930   Elf_Internal_Sym *isymbuf;
2931   Elf_Internal_Sym *isym;
2932   Elf_Internal_Sym *isymend;
2933   bfd_boolean result;
2934
2935   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2936   if (abfd == NULL)
2937     return FALSE;
2938
2939   if (! bfd_check_format (abfd, bfd_object))
2940     return FALSE;
2941
2942   /* Select the appropriate symbol table.  */
2943   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2944     hdr = &elf_tdata (abfd)->symtab_hdr;
2945   else
2946     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2947
2948   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2949
2950   /* The sh_info field of the symtab header tells us where the
2951      external symbols start.  We don't care about the local symbols.  */
2952   if (elf_bad_symtab (abfd))
2953     {
2954       extsymcount = symcount;
2955       extsymoff = 0;
2956     }
2957   else
2958     {
2959       extsymcount = symcount - hdr->sh_info;
2960       extsymoff = hdr->sh_info;
2961     }
2962
2963   if (extsymcount == 0)
2964     return FALSE;
2965
2966   /* Read in the symbol table.  */
2967   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
2968                                   NULL, NULL, NULL);
2969   if (isymbuf == NULL)
2970     return FALSE;
2971
2972   /* Scan the symbol table looking for SYMDEF.  */
2973   result = FALSE;
2974   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
2975     {
2976       const char *name;
2977
2978       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
2979                                               isym->st_name);
2980       if (name == NULL)
2981         break;
2982
2983       if (strcmp (name, symdef->name) == 0)
2984         {
2985           result = is_global_data_symbol_definition (abfd, isym);
2986           break;
2987         }
2988     }
2989
2990   free (isymbuf);
2991
2992   return result;
2993 }
2994 \f
2995 /* Add an entry to the .dynamic table.  */
2996
2997 bfd_boolean
2998 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
2999                             bfd_vma tag,
3000                             bfd_vma val)
3001 {
3002   struct elf_link_hash_table *hash_table;
3003   const struct elf_backend_data *bed;
3004   asection *s;
3005   bfd_size_type newsize;
3006   bfd_byte *newcontents;
3007   Elf_Internal_Dyn dyn;
3008
3009   hash_table = elf_hash_table (info);
3010   if (! is_elf_hash_table (hash_table))
3011     return FALSE;
3012
3013   bed = get_elf_backend_data (hash_table->dynobj);
3014   s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3015   BFD_ASSERT (s != NULL);
3016
3017   newsize = s->size + bed->s->sizeof_dyn;
3018   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3019   if (newcontents == NULL)
3020     return FALSE;
3021
3022   dyn.d_tag = tag;
3023   dyn.d_un.d_val = val;
3024   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3025
3026   s->size = newsize;
3027   s->contents = newcontents;
3028
3029   return TRUE;
3030 }
3031
3032 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3033    otherwise just check whether one already exists.  Returns -1 on error,
3034    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3035
3036 static int
3037 elf_add_dt_needed_tag (bfd *abfd,
3038                        struct bfd_link_info *info,
3039                        const char *soname,
3040                        bfd_boolean do_it)
3041 {
3042   struct elf_link_hash_table *hash_table;
3043   bfd_size_type strindex;
3044
3045   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3046     return -1;
3047
3048   hash_table = elf_hash_table (info);
3049   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3050   if (strindex == (bfd_size_type) -1)
3051     return -1;
3052
3053   if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
3054     {
3055       asection *sdyn;
3056       const struct elf_backend_data *bed;
3057       bfd_byte *extdyn;
3058
3059       bed = get_elf_backend_data (hash_table->dynobj);
3060       sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3061       if (sdyn != NULL)
3062         for (extdyn = sdyn->contents;
3063              extdyn < sdyn->contents + sdyn->size;
3064              extdyn += bed->s->sizeof_dyn)
3065           {
3066             Elf_Internal_Dyn dyn;
3067
3068             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3069             if (dyn.d_tag == DT_NEEDED
3070                 && dyn.d_un.d_val == strindex)
3071               {
3072                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3073                 return 1;
3074               }
3075           }
3076     }
3077
3078   if (do_it)
3079     {
3080       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3081         return -1;
3082
3083       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3084         return -1;
3085     }
3086   else
3087     /* We were just checking for existence of the tag.  */
3088     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3089
3090   return 0;
3091 }
3092
3093 static bfd_boolean
3094 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3095 {
3096   for (; needed != NULL; needed = needed->next)
3097     if ((elf_dyn_lib_class (needed->by) & DYN_AS_NEEDED) == 0
3098         && strcmp (soname, needed->name) == 0)
3099       return TRUE;
3100
3101   return FALSE;
3102 }
3103
3104 /* Sort symbol by value, section, and size.  */
3105 static int
3106 elf_sort_symbol (const void *arg1, const void *arg2)
3107 {
3108   const struct elf_link_hash_entry *h1;
3109   const struct elf_link_hash_entry *h2;
3110   bfd_signed_vma vdiff;
3111
3112   h1 = *(const struct elf_link_hash_entry **) arg1;
3113   h2 = *(const struct elf_link_hash_entry **) arg2;
3114   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3115   if (vdiff != 0)
3116     return vdiff > 0 ? 1 : -1;
3117   else
3118     {
3119       long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3120       if (sdiff != 0)
3121         return sdiff > 0 ? 1 : -1;
3122     }
3123   vdiff = h1->size - h2->size;
3124   return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
3125 }
3126
3127 /* This function is used to adjust offsets into .dynstr for
3128    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3129
3130 static bfd_boolean
3131 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3132 {
3133   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3134
3135   if (h->dynindx != -1)
3136     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3137   return TRUE;
3138 }
3139
3140 /* Assign string offsets in .dynstr, update all structures referencing
3141    them.  */
3142
3143 static bfd_boolean
3144 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3145 {
3146   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3147   struct elf_link_local_dynamic_entry *entry;
3148   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3149   bfd *dynobj = hash_table->dynobj;
3150   asection *sdyn;
3151   bfd_size_type size;
3152   const struct elf_backend_data *bed;
3153   bfd_byte *extdyn;
3154
3155   _bfd_elf_strtab_finalize (dynstr);
3156   size = _bfd_elf_strtab_size (dynstr);
3157
3158   bed = get_elf_backend_data (dynobj);
3159   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3160   BFD_ASSERT (sdyn != NULL);
3161
3162   /* Update all .dynamic entries referencing .dynstr strings.  */
3163   for (extdyn = sdyn->contents;
3164        extdyn < sdyn->contents + sdyn->size;
3165        extdyn += bed->s->sizeof_dyn)
3166     {
3167       Elf_Internal_Dyn dyn;
3168
3169       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3170       switch (dyn.d_tag)
3171         {
3172         case DT_STRSZ:
3173           dyn.d_un.d_val = size;
3174           break;
3175         case DT_NEEDED:
3176         case DT_SONAME:
3177         case DT_RPATH:
3178         case DT_RUNPATH:
3179         case DT_FILTER:
3180         case DT_AUXILIARY:
3181         case DT_AUDIT:
3182         case DT_DEPAUDIT:
3183           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3184           break;
3185         default:
3186           continue;
3187         }
3188       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3189     }
3190
3191   /* Now update local dynamic symbols.  */
3192   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3193     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3194                                                   entry->isym.st_name);
3195
3196   /* And the rest of dynamic symbols.  */
3197   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3198
3199   /* Adjust version definitions.  */
3200   if (elf_tdata (output_bfd)->cverdefs)
3201     {
3202       asection *s;
3203       bfd_byte *p;
3204       bfd_size_type i;
3205       Elf_Internal_Verdef def;
3206       Elf_Internal_Verdaux defaux;
3207
3208       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
3209       p = s->contents;
3210       do
3211         {
3212           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3213                                    &def);
3214           p += sizeof (Elf_External_Verdef);
3215           if (def.vd_aux != sizeof (Elf_External_Verdef))
3216             continue;
3217           for (i = 0; i < def.vd_cnt; ++i)
3218             {
3219               _bfd_elf_swap_verdaux_in (output_bfd,
3220                                         (Elf_External_Verdaux *) p, &defaux);
3221               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3222                                                         defaux.vda_name);
3223               _bfd_elf_swap_verdaux_out (output_bfd,
3224                                          &defaux, (Elf_External_Verdaux *) p);
3225               p += sizeof (Elf_External_Verdaux);
3226             }
3227         }
3228       while (def.vd_next);
3229     }
3230
3231   /* Adjust version references.  */
3232   if (elf_tdata (output_bfd)->verref)
3233     {
3234       asection *s;
3235       bfd_byte *p;
3236       bfd_size_type i;
3237       Elf_Internal_Verneed need;
3238       Elf_Internal_Vernaux needaux;
3239
3240       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
3241       p = s->contents;
3242       do
3243         {
3244           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3245                                     &need);
3246           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3247           _bfd_elf_swap_verneed_out (output_bfd, &need,
3248                                      (Elf_External_Verneed *) p);
3249           p += sizeof (Elf_External_Verneed);
3250           for (i = 0; i < need.vn_cnt; ++i)
3251             {
3252               _bfd_elf_swap_vernaux_in (output_bfd,
3253                                         (Elf_External_Vernaux *) p, &needaux);
3254               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3255                                                          needaux.vna_name);
3256               _bfd_elf_swap_vernaux_out (output_bfd,
3257                                          &needaux,
3258                                          (Elf_External_Vernaux *) p);
3259               p += sizeof (Elf_External_Vernaux);
3260             }
3261         }
3262       while (need.vn_next);
3263     }
3264
3265   return TRUE;
3266 }
3267 \f
3268 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3269    The default is to only match when the INPUT and OUTPUT are exactly
3270    the same target.  */
3271
3272 bfd_boolean
3273 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3274                                     const bfd_target *output)
3275 {
3276   return input == output;
3277 }
3278
3279 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3280    This version is used when different targets for the same architecture
3281    are virtually identical.  */
3282
3283 bfd_boolean
3284 _bfd_elf_relocs_compatible (const bfd_target *input,
3285                             const bfd_target *output)
3286 {
3287   const struct elf_backend_data *obed, *ibed;
3288
3289   if (input == output)
3290     return TRUE;
3291
3292   ibed = xvec_get_elf_backend_data (input);
3293   obed = xvec_get_elf_backend_data (output);
3294
3295   if (ibed->arch != obed->arch)
3296     return FALSE;
3297
3298   /* If both backends are using this function, deem them compatible.  */
3299   return ibed->relocs_compatible == obed->relocs_compatible;
3300 }
3301
3302 /* Make a special call to the linker "notice" function to tell it that
3303    we are about to handle an as-needed lib, or have finished
3304    processing the lib.  */ 
3305
3306 bfd_boolean
3307 _bfd_elf_notice_as_needed (bfd *ibfd,
3308                            struct bfd_link_info *info,
3309                            enum notice_asneeded_action act)
3310 {
3311   return (*info->callbacks->notice) (info, NULL, NULL, ibfd, NULL, act, 0);
3312 }
3313
3314 /* Add symbols from an ELF object file to the linker hash table.  */
3315
3316 static bfd_boolean
3317 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3318 {
3319   Elf_Internal_Ehdr *ehdr;
3320   Elf_Internal_Shdr *hdr;
3321   bfd_size_type symcount;
3322   bfd_size_type extsymcount;
3323   bfd_size_type extsymoff;
3324   struct elf_link_hash_entry **sym_hash;
3325   bfd_boolean dynamic;
3326   Elf_External_Versym *extversym = NULL;
3327   Elf_External_Versym *ever;
3328   struct elf_link_hash_entry *weaks;
3329   struct elf_link_hash_entry **nondeflt_vers = NULL;
3330   bfd_size_type nondeflt_vers_cnt = 0;
3331   Elf_Internal_Sym *isymbuf = NULL;
3332   Elf_Internal_Sym *isym;
3333   Elf_Internal_Sym *isymend;
3334   const struct elf_backend_data *bed;
3335   bfd_boolean add_needed;
3336   struct elf_link_hash_table *htab;
3337   bfd_size_type amt;
3338   void *alloc_mark = NULL;
3339   struct bfd_hash_entry **old_table = NULL;
3340   unsigned int old_size = 0;
3341   unsigned int old_count = 0;
3342   void *old_tab = NULL;
3343   void *old_ent;
3344   struct bfd_link_hash_entry *old_undefs = NULL;
3345   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3346   long old_dynsymcount = 0;
3347   bfd_size_type old_dynstr_size = 0;
3348   size_t tabsize = 0;
3349   asection *s;
3350   bfd_boolean just_syms;
3351
3352   htab = elf_hash_table (info);
3353   bed = get_elf_backend_data (abfd);
3354
3355   if ((abfd->flags & DYNAMIC) == 0)
3356     dynamic = FALSE;
3357   else
3358     {
3359       dynamic = TRUE;
3360
3361       /* You can't use -r against a dynamic object.  Also, there's no
3362          hope of using a dynamic object which does not exactly match
3363          the format of the output file.  */
3364       if (info->relocatable
3365           || !is_elf_hash_table (htab)
3366           || info->output_bfd->xvec != abfd->xvec)
3367         {
3368           if (info->relocatable)
3369             bfd_set_error (bfd_error_invalid_operation);
3370           else
3371             bfd_set_error (bfd_error_wrong_format);
3372           goto error_return;
3373         }
3374     }
3375
3376   ehdr = elf_elfheader (abfd);
3377   if (info->warn_alternate_em
3378       && bed->elf_machine_code != ehdr->e_machine
3379       && ((bed->elf_machine_alt1 != 0
3380            && ehdr->e_machine == bed->elf_machine_alt1)
3381           || (bed->elf_machine_alt2 != 0
3382               && ehdr->e_machine == bed->elf_machine_alt2)))
3383     info->callbacks->einfo
3384       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3385        ehdr->e_machine, abfd, bed->elf_machine_code);
3386
3387   /* As a GNU extension, any input sections which are named
3388      .gnu.warning.SYMBOL are treated as warning symbols for the given
3389      symbol.  This differs from .gnu.warning sections, which generate
3390      warnings when they are included in an output file.  */
3391   /* PR 12761: Also generate this warning when building shared libraries.  */
3392   for (s = abfd->sections; s != NULL; s = s->next)
3393     {
3394       const char *name;
3395
3396       name = bfd_get_section_name (abfd, s);
3397       if (CONST_STRNEQ (name, ".gnu.warning."))
3398         {
3399           char *msg;
3400           bfd_size_type sz;
3401
3402           name += sizeof ".gnu.warning." - 1;
3403
3404           /* If this is a shared object, then look up the symbol
3405              in the hash table.  If it is there, and it is already
3406              been defined, then we will not be using the entry
3407              from this shared object, so we don't need to warn.
3408              FIXME: If we see the definition in a regular object
3409              later on, we will warn, but we shouldn't.  The only
3410              fix is to keep track of what warnings we are supposed
3411              to emit, and then handle them all at the end of the
3412              link.  */
3413           if (dynamic)
3414             {
3415               struct elf_link_hash_entry *h;
3416
3417               h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3418
3419               /* FIXME: What about bfd_link_hash_common?  */
3420               if (h != NULL
3421                   && (h->root.type == bfd_link_hash_defined
3422                       || h->root.type == bfd_link_hash_defweak))
3423                 continue;
3424             }
3425
3426           sz = s->size;
3427           msg = (char *) bfd_alloc (abfd, sz + 1);
3428           if (msg == NULL)
3429             goto error_return;
3430
3431           if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3432             goto error_return;
3433
3434           msg[sz] = '\0';
3435
3436           if (! (_bfd_generic_link_add_one_symbol
3437                  (info, abfd, name, BSF_WARNING, s, 0, msg,
3438                   FALSE, bed->collect, NULL)))
3439             goto error_return;
3440
3441           if (!info->relocatable && info->executable)
3442             {
3443               /* Clobber the section size so that the warning does
3444                  not get copied into the output file.  */
3445               s->size = 0;
3446
3447               /* Also set SEC_EXCLUDE, so that symbols defined in
3448                  the warning section don't get copied to the output.  */
3449               s->flags |= SEC_EXCLUDE;
3450             }
3451         }
3452     }
3453
3454   just_syms = ((s = abfd->sections) != NULL
3455                && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS);
3456
3457   add_needed = TRUE;
3458   if (! dynamic)
3459     {
3460       /* If we are creating a shared library, create all the dynamic
3461          sections immediately.  We need to attach them to something,
3462          so we attach them to this BFD, provided it is the right
3463          format and is not from ld --just-symbols.  FIXME: If there
3464          are no input BFD's of the same format as the output, we can't
3465          make a shared library.  */
3466       if (!just_syms
3467           && info->shared
3468           && is_elf_hash_table (htab)
3469           && info->output_bfd->xvec == abfd->xvec
3470           && !htab->dynamic_sections_created)
3471         {
3472           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3473             goto error_return;
3474         }
3475     }
3476   else if (!is_elf_hash_table (htab))
3477     goto error_return;
3478   else
3479     {
3480       const char *soname = NULL;
3481       char *audit = NULL;
3482       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3483       int ret;
3484
3485       /* ld --just-symbols and dynamic objects don't mix very well.
3486          ld shouldn't allow it.  */
3487       if (just_syms)
3488         abort ();
3489
3490       /* If this dynamic lib was specified on the command line with
3491          --as-needed in effect, then we don't want to add a DT_NEEDED
3492          tag unless the lib is actually used.  Similary for libs brought
3493          in by another lib's DT_NEEDED.  When --no-add-needed is used
3494          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3495          any dynamic library in DT_NEEDED tags in the dynamic lib at
3496          all.  */
3497       add_needed = (elf_dyn_lib_class (abfd)
3498                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3499                        | DYN_NO_NEEDED)) == 0;
3500
3501       s = bfd_get_section_by_name (abfd, ".dynamic");
3502       if (s != NULL)
3503         {
3504           bfd_byte *dynbuf;
3505           bfd_byte *extdyn;
3506           unsigned int elfsec;
3507           unsigned long shlink;
3508
3509           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3510             {
3511 error_free_dyn:
3512               free (dynbuf);
3513               goto error_return;
3514             }
3515
3516           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3517           if (elfsec == SHN_BAD)
3518             goto error_free_dyn;
3519           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3520
3521           for (extdyn = dynbuf;
3522                extdyn < dynbuf + s->size;
3523                extdyn += bed->s->sizeof_dyn)
3524             {
3525               Elf_Internal_Dyn dyn;
3526
3527               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3528               if (dyn.d_tag == DT_SONAME)
3529                 {
3530                   unsigned int tagv = dyn.d_un.d_val;
3531                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3532                   if (soname == NULL)
3533                     goto error_free_dyn;
3534                 }
3535               if (dyn.d_tag == DT_NEEDED)
3536                 {
3537                   struct bfd_link_needed_list *n, **pn;
3538                   char *fnm, *anm;
3539                   unsigned int tagv = dyn.d_un.d_val;
3540
3541                   amt = sizeof (struct bfd_link_needed_list);
3542                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3543                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3544                   if (n == NULL || fnm == NULL)
3545                     goto error_free_dyn;
3546                   amt = strlen (fnm) + 1;
3547                   anm = (char *) bfd_alloc (abfd, amt);
3548                   if (anm == NULL)
3549                     goto error_free_dyn;
3550                   memcpy (anm, fnm, amt);
3551                   n->name = anm;
3552                   n->by = abfd;
3553                   n->next = NULL;
3554                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3555                     ;
3556                   *pn = n;
3557                 }
3558               if (dyn.d_tag == DT_RUNPATH)
3559                 {
3560                   struct bfd_link_needed_list *n, **pn;
3561                   char *fnm, *anm;
3562                   unsigned int tagv = dyn.d_un.d_val;
3563
3564                   amt = sizeof (struct bfd_link_needed_list);
3565                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3566                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3567                   if (n == NULL || fnm == NULL)
3568                     goto error_free_dyn;
3569                   amt = strlen (fnm) + 1;
3570                   anm = (char *) bfd_alloc (abfd, amt);
3571                   if (anm == NULL)
3572                     goto error_free_dyn;
3573                   memcpy (anm, fnm, amt);
3574                   n->name = anm;
3575                   n->by = abfd;
3576                   n->next = NULL;
3577                   for (pn = & runpath;
3578                        *pn != NULL;
3579                        pn = &(*pn)->next)
3580                     ;
3581                   *pn = n;
3582                 }
3583               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3584               if (!runpath && dyn.d_tag == DT_RPATH)
3585                 {
3586                   struct bfd_link_needed_list *n, **pn;
3587                   char *fnm, *anm;
3588                   unsigned int tagv = dyn.d_un.d_val;
3589
3590                   amt = sizeof (struct bfd_link_needed_list);
3591                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3592                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3593                   if (n == NULL || fnm == NULL)
3594                     goto error_free_dyn;
3595                   amt = strlen (fnm) + 1;
3596                   anm = (char *) bfd_alloc (abfd, amt);
3597                   if (anm == NULL)
3598                     goto error_free_dyn;
3599                   memcpy (anm, fnm, amt);
3600                   n->name = anm;
3601                   n->by = abfd;
3602                   n->next = NULL;
3603                   for (pn = & rpath;
3604                        *pn != NULL;
3605                        pn = &(*pn)->next)
3606                     ;
3607                   *pn = n;
3608                 }
3609               if (dyn.d_tag == DT_AUDIT)
3610                 {
3611                   unsigned int tagv = dyn.d_un.d_val;
3612                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3613                 }
3614             }
3615
3616           free (dynbuf);
3617         }
3618
3619       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3620          frees all more recently bfd_alloc'd blocks as well.  */
3621       if (runpath)
3622         rpath = runpath;
3623
3624       if (rpath)
3625         {
3626           struct bfd_link_needed_list **pn;
3627           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3628             ;
3629           *pn = rpath;
3630         }
3631
3632       /* We do not want to include any of the sections in a dynamic
3633          object in the output file.  We hack by simply clobbering the
3634          list of sections in the BFD.  This could be handled more
3635          cleanly by, say, a new section flag; the existing
3636          SEC_NEVER_LOAD flag is not the one we want, because that one
3637          still implies that the section takes up space in the output
3638          file.  */
3639       bfd_section_list_clear (abfd);
3640
3641       /* Find the name to use in a DT_NEEDED entry that refers to this
3642          object.  If the object has a DT_SONAME entry, we use it.
3643          Otherwise, if the generic linker stuck something in
3644          elf_dt_name, we use that.  Otherwise, we just use the file
3645          name.  */
3646       if (soname == NULL || *soname == '\0')
3647         {
3648           soname = elf_dt_name (abfd);
3649           if (soname == NULL || *soname == '\0')
3650             soname = bfd_get_filename (abfd);
3651         }
3652
3653       /* Save the SONAME because sometimes the linker emulation code
3654          will need to know it.  */
3655       elf_dt_name (abfd) = soname;
3656
3657       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3658       if (ret < 0)
3659         goto error_return;
3660
3661       /* If we have already included this dynamic object in the
3662          link, just ignore it.  There is no reason to include a
3663          particular dynamic object more than once.  */
3664       if (ret > 0)
3665         return TRUE;
3666
3667       /* Save the DT_AUDIT entry for the linker emulation code. */
3668       elf_dt_audit (abfd) = audit;
3669     }
3670
3671   /* If this is a dynamic object, we always link against the .dynsym
3672      symbol table, not the .symtab symbol table.  The dynamic linker
3673      will only see the .dynsym symbol table, so there is no reason to
3674      look at .symtab for a dynamic object.  */
3675
3676   if (! dynamic || elf_dynsymtab (abfd) == 0)
3677     hdr = &elf_tdata (abfd)->symtab_hdr;
3678   else
3679     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3680
3681   symcount = hdr->sh_size / bed->s->sizeof_sym;
3682
3683   /* The sh_info field of the symtab header tells us where the
3684      external symbols start.  We don't care about the local symbols at
3685      this point.  */
3686   if (elf_bad_symtab (abfd))
3687     {
3688       extsymcount = symcount;
3689       extsymoff = 0;
3690     }
3691   else
3692     {
3693       extsymcount = symcount - hdr->sh_info;
3694       extsymoff = hdr->sh_info;
3695     }
3696
3697   sym_hash = elf_sym_hashes (abfd);
3698   if (extsymcount != 0)
3699     {
3700       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3701                                       NULL, NULL, NULL);
3702       if (isymbuf == NULL)
3703         goto error_return;
3704
3705       if (sym_hash == NULL)
3706         {
3707           /* We store a pointer to the hash table entry for each
3708              external symbol.  */
3709           amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3710           sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
3711           if (sym_hash == NULL)
3712             goto error_free_sym;
3713           elf_sym_hashes (abfd) = sym_hash;
3714         }
3715     }
3716
3717   if (dynamic)
3718     {
3719       /* Read in any version definitions.  */
3720       if (!_bfd_elf_slurp_version_tables (abfd,
3721                                           info->default_imported_symver))
3722         goto error_free_sym;
3723
3724       /* Read in the symbol versions, but don't bother to convert them
3725          to internal format.  */
3726       if (elf_dynversym (abfd) != 0)
3727         {
3728           Elf_Internal_Shdr *versymhdr;
3729
3730           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3731           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3732           if (extversym == NULL)
3733             goto error_free_sym;
3734           amt = versymhdr->sh_size;
3735           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3736               || bfd_bread (extversym, amt, abfd) != amt)
3737             goto error_free_vers;
3738         }
3739     }
3740
3741   /* If we are loading an as-needed shared lib, save the symbol table
3742      state before we start adding symbols.  If the lib turns out
3743      to be unneeded, restore the state.  */
3744   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3745     {
3746       unsigned int i;
3747       size_t entsize;
3748
3749       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3750         {
3751           struct bfd_hash_entry *p;
3752           struct elf_link_hash_entry *h;
3753
3754           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3755             {
3756               h = (struct elf_link_hash_entry *) p;
3757               entsize += htab->root.table.entsize;
3758               if (h->root.type == bfd_link_hash_warning)
3759                 entsize += htab->root.table.entsize;
3760             }
3761         }
3762
3763       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3764       old_tab = bfd_malloc (tabsize + entsize);
3765       if (old_tab == NULL)
3766         goto error_free_vers;
3767
3768       /* Remember the current objalloc pointer, so that all mem for
3769          symbols added can later be reclaimed.  */
3770       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3771       if (alloc_mark == NULL)
3772         goto error_free_vers;
3773
3774       /* Make a special call to the linker "notice" function to
3775          tell it that we are about to handle an as-needed lib.  */
3776       if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed))
3777         goto error_free_vers;
3778
3779       /* Clone the symbol table.  Remember some pointers into the
3780          symbol table, and dynamic symbol count.  */
3781       old_ent = (char *) old_tab + tabsize;
3782       memcpy (old_tab, htab->root.table.table, tabsize);
3783       old_undefs = htab->root.undefs;
3784       old_undefs_tail = htab->root.undefs_tail;
3785       old_table = htab->root.table.table;
3786       old_size = htab->root.table.size;
3787       old_count = htab->root.table.count;
3788       old_dynsymcount = htab->dynsymcount;
3789       old_dynstr_size = _bfd_elf_strtab_size (htab->dynstr);
3790
3791       for (i = 0; i < htab->root.table.size; i++)
3792         {
3793           struct bfd_hash_entry *p;
3794           struct elf_link_hash_entry *h;
3795
3796           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3797             {
3798               memcpy (old_ent, p, htab->root.table.entsize);
3799               old_ent = (char *) old_ent + htab->root.table.entsize;
3800               h = (struct elf_link_hash_entry *) p;
3801               if (h->root.type == bfd_link_hash_warning)
3802                 {
3803                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3804                   old_ent = (char *) old_ent + htab->root.table.entsize;
3805                 }
3806             }
3807         }
3808     }
3809
3810   weaks = NULL;
3811   ever = extversym != NULL ? extversym + extsymoff : NULL;
3812   for (isym = isymbuf, isymend = isymbuf + extsymcount;
3813        isym < isymend;
3814        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3815     {
3816       int bind;
3817       bfd_vma value;
3818       asection *sec, *new_sec;
3819       flagword flags;
3820       const char *name;
3821       struct elf_link_hash_entry *h;
3822       struct elf_link_hash_entry *hi;
3823       bfd_boolean definition;
3824       bfd_boolean size_change_ok;
3825       bfd_boolean type_change_ok;
3826       bfd_boolean new_weakdef;
3827       bfd_boolean new_weak;
3828       bfd_boolean old_weak;
3829       bfd_boolean override;
3830       bfd_boolean common;
3831       unsigned int old_alignment;
3832       bfd *old_bfd;
3833
3834       override = FALSE;
3835
3836       flags = BSF_NO_FLAGS;
3837       sec = NULL;
3838       value = isym->st_value;
3839       common = bed->common_definition (isym);
3840
3841       bind = ELF_ST_BIND (isym->st_info);
3842       switch (bind)
3843         {
3844         case STB_LOCAL:
3845           /* This should be impossible, since ELF requires that all
3846              global symbols follow all local symbols, and that sh_info
3847              point to the first global symbol.  Unfortunately, Irix 5
3848              screws this up.  */
3849           continue;
3850
3851         case STB_GLOBAL:
3852           if (isym->st_shndx != SHN_UNDEF && !common)
3853             flags = BSF_GLOBAL;
3854           break;
3855
3856         case STB_WEAK:
3857           flags = BSF_WEAK;
3858           break;
3859
3860         case STB_GNU_UNIQUE:
3861           flags = BSF_GNU_UNIQUE;
3862           break;
3863
3864         default:
3865           /* Leave it up to the processor backend.  */
3866           break;
3867         }
3868
3869       if (isym->st_shndx == SHN_UNDEF)
3870         sec = bfd_und_section_ptr;
3871       else if (isym->st_shndx == SHN_ABS)
3872         sec = bfd_abs_section_ptr;
3873       else if (isym->st_shndx == SHN_COMMON)
3874         {
3875           sec = bfd_com_section_ptr;
3876           /* What ELF calls the size we call the value.  What ELF
3877              calls the value we call the alignment.  */
3878           value = isym->st_size;
3879         }
3880       else
3881         {
3882           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3883           if (sec == NULL)
3884             sec = bfd_abs_section_ptr;
3885           else if (discarded_section (sec))
3886             {
3887               /* Symbols from discarded section are undefined.  We keep
3888                  its visibility.  */
3889               sec = bfd_und_section_ptr;
3890               isym->st_shndx = SHN_UNDEF;
3891             }
3892           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3893             value -= sec->vma;
3894         }
3895
3896       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3897                                               isym->st_name);
3898       if (name == NULL)
3899         goto error_free_vers;
3900
3901       if (isym->st_shndx == SHN_COMMON
3902           && (abfd->flags & BFD_PLUGIN) != 0)
3903         {
3904           asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3905
3906           if (xc == NULL)
3907             {
3908               flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3909                                  | SEC_EXCLUDE);
3910               xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3911               if (xc == NULL)
3912                 goto error_free_vers;
3913             }
3914           sec = xc;
3915         }
3916       else if (isym->st_shndx == SHN_COMMON
3917                && ELF_ST_TYPE (isym->st_info) == STT_TLS
3918                && !info->relocatable)
3919         {
3920           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3921
3922           if (tcomm == NULL)
3923             {
3924               flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3925                                  | SEC_LINKER_CREATED);
3926               tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3927               if (tcomm == NULL)
3928                 goto error_free_vers;
3929             }
3930           sec = tcomm;
3931         }
3932       else if (bed->elf_add_symbol_hook)
3933         {
3934           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3935                                              &sec, &value))
3936             goto error_free_vers;
3937
3938           /* The hook function sets the name to NULL if this symbol
3939              should be skipped for some reason.  */
3940           if (name == NULL)
3941             continue;
3942         }
3943
3944       /* Sanity check that all possibilities were handled.  */
3945       if (sec == NULL)
3946         {
3947           bfd_set_error (bfd_error_bad_value);
3948           goto error_free_vers;
3949         }
3950
3951       /* Silently discard TLS symbols from --just-syms.  There's
3952          no way to combine a static TLS block with a new TLS block
3953          for this executable.  */
3954       if (ELF_ST_TYPE (isym->st_info) == STT_TLS
3955           && sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3956         continue;
3957
3958       if (bfd_is_und_section (sec)
3959           || bfd_is_com_section (sec))
3960         definition = FALSE;
3961       else
3962         definition = TRUE;
3963
3964       size_change_ok = FALSE;
3965       type_change_ok = bed->type_change_ok;
3966       old_weak = FALSE;
3967       old_alignment = 0;
3968       old_bfd = NULL;
3969       new_sec = sec;
3970
3971       if (is_elf_hash_table (htab))
3972         {
3973           Elf_Internal_Versym iver;
3974           unsigned int vernum = 0;
3975           bfd_boolean skip;
3976
3977           if (ever == NULL)
3978             {
3979               if (info->default_imported_symver)
3980                 /* Use the default symbol version created earlier.  */
3981                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
3982               else
3983                 iver.vs_vers = 0;
3984             }
3985           else
3986             _bfd_elf_swap_versym_in (abfd, ever, &iver);
3987
3988           vernum = iver.vs_vers & VERSYM_VERSION;
3989
3990           /* If this is a hidden symbol, or if it is not version
3991              1, we append the version name to the symbol name.
3992              However, we do not modify a non-hidden absolute symbol
3993              if it is not a function, because it might be the version
3994              symbol itself.  FIXME: What if it isn't?  */
3995           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
3996               || (vernum > 1
3997                   && (!bfd_is_abs_section (sec)
3998                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
3999             {
4000               const char *verstr;
4001               size_t namelen, verlen, newlen;
4002               char *newname, *p;
4003
4004               if (isym->st_shndx != SHN_UNDEF)
4005                 {
4006                   if (vernum > elf_tdata (abfd)->cverdefs)
4007                     verstr = NULL;
4008                   else if (vernum > 1)
4009                     verstr =
4010                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4011                   else
4012                     verstr = "";
4013
4014                   if (verstr == NULL)
4015                     {
4016                       (*_bfd_error_handler)
4017                         (_("%B: %s: invalid version %u (max %d)"),
4018                          abfd, name, vernum,
4019                          elf_tdata (abfd)->cverdefs);
4020                       bfd_set_error (bfd_error_bad_value);
4021                       goto error_free_vers;
4022                     }
4023                 }
4024               else
4025                 {
4026                   /* We cannot simply test for the number of
4027                      entries in the VERNEED section since the
4028                      numbers for the needed versions do not start
4029                      at 0.  */
4030                   Elf_Internal_Verneed *t;
4031
4032                   verstr = NULL;
4033                   for (t = elf_tdata (abfd)->verref;
4034                        t != NULL;
4035                        t = t->vn_nextref)
4036                     {
4037                       Elf_Internal_Vernaux *a;
4038
4039                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4040                         {
4041                           if (a->vna_other == vernum)
4042                             {
4043                               verstr = a->vna_nodename;
4044                               break;
4045                             }
4046                         }
4047                       if (a != NULL)
4048                         break;
4049                     }
4050                   if (verstr == NULL)
4051                     {
4052                       (*_bfd_error_handler)
4053                         (_("%B: %s: invalid needed version %d"),
4054                          abfd, name, vernum);
4055                       bfd_set_error (bfd_error_bad_value);
4056                       goto error_free_vers;
4057                     }
4058                 }
4059
4060               namelen = strlen (name);
4061               verlen = strlen (verstr);
4062               newlen = namelen + verlen + 2;
4063               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4064                   && isym->st_shndx != SHN_UNDEF)
4065                 ++newlen;
4066
4067               newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4068               if (newname == NULL)
4069                 goto error_free_vers;
4070               memcpy (newname, name, namelen);
4071               p = newname + namelen;
4072               *p++ = ELF_VER_CHR;
4073               /* If this is a defined non-hidden version symbol,
4074                  we add another @ to the name.  This indicates the
4075                  default version of the symbol.  */
4076               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4077                   && isym->st_shndx != SHN_UNDEF)
4078                 *p++ = ELF_VER_CHR;
4079               memcpy (p, verstr, verlen + 1);
4080
4081               name = newname;
4082             }
4083
4084           /* If this symbol has default visibility and the user has
4085              requested we not re-export it, then mark it as hidden.  */
4086           if (definition
4087               && !dynamic
4088               && (abfd->no_export
4089                   || (abfd->my_archive && abfd->my_archive->no_export))
4090               && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
4091             isym->st_other = (STV_HIDDEN
4092                               | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
4093
4094           if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
4095                                       sym_hash, &old_bfd, &old_weak,
4096                                       &old_alignment, &skip, &override,
4097                                       &type_change_ok, &size_change_ok))
4098             goto error_free_vers;
4099
4100           if (skip)
4101             continue;
4102
4103           if (override)
4104             definition = FALSE;
4105
4106           h = *sym_hash;
4107           while (h->root.type == bfd_link_hash_indirect
4108                  || h->root.type == bfd_link_hash_warning)
4109             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4110
4111           if (elf_tdata (abfd)->verdef != NULL
4112               && vernum > 1
4113               && definition)
4114             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4115         }
4116
4117       if (! (_bfd_generic_link_add_one_symbol
4118              (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4119               (struct bfd_link_hash_entry **) sym_hash)))
4120         goto error_free_vers;
4121
4122       h = *sym_hash;
4123       /* We need to make sure that indirect symbol dynamic flags are
4124          updated.  */
4125       hi = h;
4126       while (h->root.type == bfd_link_hash_indirect
4127              || h->root.type == bfd_link_hash_warning)
4128         h = (struct elf_link_hash_entry *) h->root.u.i.link;
4129
4130       *sym_hash = h;
4131
4132       new_weak = (flags & BSF_WEAK) != 0;
4133       new_weakdef = FALSE;
4134       if (dynamic
4135           && definition
4136           && new_weak
4137           && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4138           && is_elf_hash_table (htab)
4139           && h->u.weakdef == NULL)
4140         {
4141           /* Keep a list of all weak defined non function symbols from
4142              a dynamic object, using the weakdef field.  Later in this
4143              function we will set the weakdef field to the correct
4144              value.  We only put non-function symbols from dynamic
4145              objects on this list, because that happens to be the only
4146              time we need to know the normal symbol corresponding to a
4147              weak symbol, and the information is time consuming to
4148              figure out.  If the weakdef field is not already NULL,
4149              then this symbol was already defined by some previous
4150              dynamic object, and we will be using that previous
4151              definition anyhow.  */
4152
4153           h->u.weakdef = weaks;
4154           weaks = h;
4155           new_weakdef = TRUE;
4156         }
4157
4158       /* Set the alignment of a common symbol.  */
4159       if ((common || bfd_is_com_section (sec))
4160           && h->root.type == bfd_link_hash_common)
4161         {
4162           unsigned int align;
4163
4164           if (common)
4165             align = bfd_log2 (isym->st_value);
4166           else
4167             {
4168               /* The new symbol is a common symbol in a shared object.
4169                  We need to get the alignment from the section.  */
4170               align = new_sec->alignment_power;
4171             }
4172           if (align > old_alignment)
4173             h->root.u.c.p->alignment_power = align;
4174           else
4175             h->root.u.c.p->alignment_power = old_alignment;
4176         }
4177
4178       if (is_elf_hash_table (htab))
4179         {
4180           /* Set a flag in the hash table entry indicating the type of
4181              reference or definition we just found.  A dynamic symbol
4182              is one which is referenced or defined by both a regular
4183              object and a shared object.  */
4184           bfd_boolean dynsym = FALSE;
4185
4186           /* Plugin symbols aren't normal.  Don't set def_regular or
4187              ref_regular for them, or make them dynamic.  */
4188           if ((abfd->flags & BFD_PLUGIN) != 0)
4189             ;
4190           else if (! dynamic)
4191             {
4192               if (! definition)
4193                 {
4194                   h->ref_regular = 1;
4195                   if (bind != STB_WEAK)
4196                     h->ref_regular_nonweak = 1;
4197                 }
4198               else
4199                 {
4200                   h->def_regular = 1;
4201                   if (h->def_dynamic)
4202                     {
4203                       h->def_dynamic = 0;
4204                       h->ref_dynamic = 1;
4205                     }
4206                 }
4207
4208               /* If the indirect symbol has been forced local, don't
4209                  make the real symbol dynamic.  */
4210               if ((h == hi || !hi->forced_local)
4211                   && (! info->executable
4212                       || h->def_dynamic
4213                       || h->ref_dynamic))
4214                 dynsym = TRUE;
4215             }
4216           else
4217             {
4218               if (! definition)
4219                 {
4220                   h->ref_dynamic = 1;
4221                   hi->ref_dynamic = 1;
4222                 }
4223               else
4224                 {
4225                   h->def_dynamic = 1;
4226                   hi->def_dynamic = 1;
4227                 }
4228
4229               /* If the indirect symbol has been forced local, don't
4230                  make the real symbol dynamic.  */
4231               if ((h == hi || !hi->forced_local)
4232                   && (h->def_regular
4233                       || h->ref_regular
4234                       || (h->u.weakdef != NULL
4235                           && ! new_weakdef
4236                           && h->u.weakdef->dynindx != -1)))
4237                 dynsym = TRUE;
4238             }
4239
4240           /* Check to see if we need to add an indirect symbol for
4241              the default name.  */
4242           if (definition
4243               || (!override && h->root.type == bfd_link_hash_common))
4244             if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4245                                               sec, value, &old_bfd, &dynsym))
4246               goto error_free_vers;
4247
4248           /* Check the alignment when a common symbol is involved. This
4249              can change when a common symbol is overridden by a normal
4250              definition or a common symbol is ignored due to the old
4251              normal definition. We need to make sure the maximum
4252              alignment is maintained.  */
4253           if ((old_alignment || common)
4254               && h->root.type != bfd_link_hash_common)
4255             {
4256               unsigned int common_align;
4257               unsigned int normal_align;
4258               unsigned int symbol_align;
4259               bfd *normal_bfd;
4260               bfd *common_bfd;
4261
4262               BFD_ASSERT (h->root.type == bfd_link_hash_defined
4263                           || h->root.type == bfd_link_hash_defweak);
4264
4265               symbol_align = ffs (h->root.u.def.value) - 1;
4266               if (h->root.u.def.section->owner != NULL
4267                   && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4268                 {
4269                   normal_align = h->root.u.def.section->alignment_power;
4270                   if (normal_align > symbol_align)
4271                     normal_align = symbol_align;
4272                 }
4273               else
4274                 normal_align = symbol_align;
4275
4276               if (old_alignment)
4277                 {
4278                   common_align = old_alignment;
4279                   common_bfd = old_bfd;
4280                   normal_bfd = abfd;
4281                 }
4282               else
4283                 {
4284                   common_align = bfd_log2 (isym->st_value);
4285                   common_bfd = abfd;
4286                   normal_bfd = old_bfd;
4287                 }
4288
4289               if (normal_align < common_align)
4290                 {
4291                   /* PR binutils/2735 */
4292                   if (normal_bfd == NULL)
4293                     (*_bfd_error_handler)
4294                       (_("Warning: alignment %u of common symbol `%s' in %B is"
4295                          " greater than the alignment (%u) of its section %A"),
4296                        common_bfd, h->root.u.def.section,
4297                        1 << common_align, name, 1 << normal_align);
4298                   else
4299                     (*_bfd_error_handler)
4300                       (_("Warning: alignment %u of symbol `%s' in %B"
4301                          " is smaller than %u in %B"),
4302                        normal_bfd, common_bfd,
4303                        1 << normal_align, name, 1 << common_align);
4304                 }
4305             }
4306
4307           /* Remember the symbol size if it isn't undefined.  */
4308           if (isym->st_size != 0
4309               && isym->st_shndx != SHN_UNDEF
4310               && (definition || h->size == 0))
4311             {
4312               if (h->size != 0
4313                   && h->size != isym->st_size
4314                   && ! size_change_ok)
4315                 (*_bfd_error_handler)
4316                   (_("Warning: size of symbol `%s' changed"
4317                      " from %lu in %B to %lu in %B"),
4318                    old_bfd, abfd,
4319                    name, (unsigned long) h->size,
4320                    (unsigned long) isym->st_size);
4321
4322               h->size = isym->st_size;
4323             }
4324
4325           /* If this is a common symbol, then we always want H->SIZE
4326              to be the size of the common symbol.  The code just above
4327              won't fix the size if a common symbol becomes larger.  We
4328              don't warn about a size change here, because that is
4329              covered by --warn-common.  Allow changes between different
4330              function types.  */
4331           if (h->root.type == bfd_link_hash_common)
4332             h->size = h->root.u.c.size;
4333
4334           if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4335               && ((definition && !new_weak)
4336                   || (old_weak && h->root.type == bfd_link_hash_common)
4337                   || h->type == STT_NOTYPE))
4338             {
4339               unsigned int type = ELF_ST_TYPE (isym->st_info);
4340
4341               /* Turn an IFUNC symbol from a DSO into a normal FUNC
4342                  symbol.  */
4343               if (type == STT_GNU_IFUNC
4344                   && (abfd->flags & DYNAMIC) != 0)
4345                 type = STT_FUNC;
4346
4347               if (h->type != type)
4348                 {
4349                   if (h->type != STT_NOTYPE && ! type_change_ok)
4350                     (*_bfd_error_handler)
4351                       (_("Warning: type of symbol `%s' changed"
4352                          " from %d to %d in %B"),
4353                        abfd, name, h->type, type);
4354
4355                   h->type = type;
4356                 }
4357             }
4358
4359           /* Merge st_other field.  */
4360           elf_merge_st_other (abfd, h, isym, definition, dynamic);
4361
4362           /* We don't want to make debug symbol dynamic.  */
4363           if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4364             dynsym = FALSE;
4365
4366           /* Nor should we make plugin symbols dynamic.  */
4367           if ((abfd->flags & BFD_PLUGIN) != 0)
4368             dynsym = FALSE;
4369
4370           if (definition)
4371             {
4372               h->target_internal = isym->st_target_internal;
4373               h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4374             }
4375
4376           if (definition && !dynamic)
4377             {
4378               char *p = strchr (name, ELF_VER_CHR);
4379               if (p != NULL && p[1] != ELF_VER_CHR)
4380                 {
4381                   /* Queue non-default versions so that .symver x, x@FOO
4382                      aliases can be checked.  */
4383                   if (!nondeflt_vers)
4384                     {
4385                       amt = ((isymend - isym + 1)
4386                              * sizeof (struct elf_link_hash_entry *));
4387                       nondeflt_vers =
4388                           (struct elf_link_hash_entry **) bfd_malloc (amt);
4389                       if (!nondeflt_vers)
4390                         goto error_free_vers;
4391                     }
4392                   nondeflt_vers[nondeflt_vers_cnt++] = h;
4393                 }
4394             }
4395
4396           if (dynsym && h->dynindx == -1)
4397             {
4398               if (! bfd_elf_link_record_dynamic_symbol (info, h))
4399                 goto error_free_vers;
4400               if (h->u.weakdef != NULL
4401                   && ! new_weakdef
4402                   && h->u.weakdef->dynindx == -1)
4403                 {
4404                   if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4405                     goto error_free_vers;
4406                 }
4407             }
4408           else if (dynsym && h->dynindx != -1)
4409             /* If the symbol already has a dynamic index, but
4410                visibility says it should not be visible, turn it into
4411                a local symbol.  */
4412             switch (ELF_ST_VISIBILITY (h->other))
4413               {
4414               case STV_INTERNAL:
4415               case STV_HIDDEN:
4416                 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4417                 dynsym = FALSE;
4418                 break;
4419               }
4420
4421           /* Don't add DT_NEEDED for references from the dummy bfd.  */
4422           if (!add_needed
4423               && definition
4424               && ((dynsym
4425                    && h->ref_regular_nonweak
4426                    && (old_bfd == NULL
4427                        || (old_bfd->flags & BFD_PLUGIN) == 0))
4428                   || (h->ref_dynamic_nonweak
4429                       && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4430                       && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4431             {
4432               int ret;
4433               const char *soname = elf_dt_name (abfd);
4434
4435               info->callbacks->minfo ("%!", soname, old_bfd,
4436                                       h->root.root.string);
4437
4438               /* A symbol from a library loaded via DT_NEEDED of some
4439                  other library is referenced by a regular object.
4440                  Add a DT_NEEDED entry for it.  Issue an error if
4441                  --no-add-needed is used and the reference was not
4442                  a weak one.  */
4443               if (old_bfd != NULL
4444                   && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4445                 {
4446                   (*_bfd_error_handler)
4447                     (_("%B: undefined reference to symbol '%s'"),
4448                      old_bfd, name);
4449                   bfd_set_error (bfd_error_missing_dso);
4450                   goto error_free_vers;
4451                 }
4452
4453               elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4454                   (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4455
4456               add_needed = TRUE;
4457               ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4458               if (ret < 0)
4459                 goto error_free_vers;
4460
4461               BFD_ASSERT (ret == 0);
4462             }
4463         }
4464     }
4465
4466   if (extversym != NULL)
4467     {
4468       free (extversym);
4469       extversym = NULL;
4470     }
4471
4472   if (isymbuf != NULL)
4473     {
4474       free (isymbuf);
4475       isymbuf = NULL;
4476     }
4477
4478   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4479     {
4480       unsigned int i;
4481
4482       /* Restore the symbol table.  */
4483       old_ent = (char *) old_tab + tabsize;
4484       memset (elf_sym_hashes (abfd), 0,
4485               extsymcount * sizeof (struct elf_link_hash_entry *));
4486       htab->root.table.table = old_table;
4487       htab->root.table.size = old_size;
4488       htab->root.table.count = old_count;
4489       memcpy (htab->root.table.table, old_tab, tabsize);
4490       htab->root.undefs = old_undefs;
4491       htab->root.undefs_tail = old_undefs_tail;
4492       _bfd_elf_strtab_restore_size (htab->dynstr, old_dynstr_size);
4493       for (i = 0; i < htab->root.table.size; i++)
4494         {
4495           struct bfd_hash_entry *p;
4496           struct elf_link_hash_entry *h;
4497           bfd_size_type size;
4498           unsigned int alignment_power;
4499
4500           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4501             {
4502               h = (struct elf_link_hash_entry *) p;
4503               if (h->root.type == bfd_link_hash_warning)
4504                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4505               if (h->dynindx >= old_dynsymcount
4506                   && h->dynstr_index < old_dynstr_size)
4507                 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4508
4509               /* Preserve the maximum alignment and size for common
4510                  symbols even if this dynamic lib isn't on DT_NEEDED
4511                  since it can still be loaded at run time by another
4512                  dynamic lib.  */
4513               if (h->root.type == bfd_link_hash_common)
4514                 {
4515                   size = h->root.u.c.size;
4516                   alignment_power = h->root.u.c.p->alignment_power;
4517                 }
4518               else
4519                 {
4520                   size = 0;
4521                   alignment_power = 0;
4522                 }
4523               memcpy (p, old_ent, htab->root.table.entsize);
4524               old_ent = (char *) old_ent + htab->root.table.entsize;
4525               h = (struct elf_link_hash_entry *) p;
4526               if (h->root.type == bfd_link_hash_warning)
4527                 {
4528                   memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4529                   old_ent = (char *) old_ent + htab->root.table.entsize;
4530                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
4531                 }
4532               if (h->root.type == bfd_link_hash_common)
4533                 {
4534                   if (size > h->root.u.c.size)
4535                     h->root.u.c.size = size;
4536                   if (alignment_power > h->root.u.c.p->alignment_power)
4537                     h->root.u.c.p->alignment_power = alignment_power;
4538                 }
4539             }
4540         }
4541
4542       /* Make a special call to the linker "notice" function to
4543          tell it that symbols added for crefs may need to be removed.  */
4544       if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed))
4545         goto error_free_vers;
4546
4547       free (old_tab);
4548       objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4549                            alloc_mark);
4550       if (nondeflt_vers != NULL)
4551         free (nondeflt_vers);
4552       return TRUE;
4553     }
4554
4555   if (old_tab != NULL)
4556     {
4557       if (!(*bed->notice_as_needed) (abfd, info, notice_needed))
4558         goto error_free_vers;
4559       free (old_tab);
4560       old_tab = NULL;
4561     }
4562
4563   /* Now that all the symbols from this input file are created, handle
4564      .symver foo, foo@BAR such that any relocs against foo become foo@BAR.  */
4565   if (nondeflt_vers != NULL)
4566     {
4567       bfd_size_type cnt, symidx;
4568
4569       for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4570         {
4571           struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4572           char *shortname, *p;
4573
4574           p = strchr (h->root.root.string, ELF_VER_CHR);
4575           if (p == NULL
4576               || (h->root.type != bfd_link_hash_defined
4577                   && h->root.type != bfd_link_hash_defweak))
4578             continue;
4579
4580           amt = p - h->root.root.string;
4581           shortname = (char *) bfd_malloc (amt + 1);
4582           if (!shortname)
4583             goto error_free_vers;
4584           memcpy (shortname, h->root.root.string, amt);
4585           shortname[amt] = '\0';
4586
4587           hi = (struct elf_link_hash_entry *)
4588                bfd_link_hash_lookup (&htab->root, shortname,
4589                                      FALSE, FALSE, FALSE);
4590           if (hi != NULL
4591               && hi->root.type == h->root.type
4592               && hi->root.u.def.value == h->root.u.def.value
4593               && hi->root.u.def.section == h->root.u.def.section)
4594             {
4595               (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4596               hi->root.type = bfd_link_hash_indirect;
4597               hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4598               (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4599               sym_hash = elf_sym_hashes (abfd);
4600               if (sym_hash)
4601                 for (symidx = 0; symidx < extsymcount; ++symidx)
4602                   if (sym_hash[symidx] == hi)
4603                     {
4604                       sym_hash[symidx] = h;
4605                       break;
4606                     }
4607             }
4608           free (shortname);
4609         }
4610       free (nondeflt_vers);
4611       nondeflt_vers = NULL;
4612     }
4613
4614   /* Now set the weakdefs field correctly for all the weak defined
4615      symbols we found.  The only way to do this is to search all the
4616      symbols.  Since we only need the information for non functions in
4617      dynamic objects, that's the only time we actually put anything on
4618      the list WEAKS.  We need this information so that if a regular
4619      object refers to a symbol defined weakly in a dynamic object, the
4620      real symbol in the dynamic object is also put in the dynamic
4621      symbols; we also must arrange for both symbols to point to the
4622      same memory location.  We could handle the general case of symbol
4623      aliasing, but a general symbol alias can only be generated in
4624      assembler code, handling it correctly would be very time
4625      consuming, and other ELF linkers don't handle general aliasing
4626      either.  */
4627   if (weaks != NULL)
4628     {
4629       struct elf_link_hash_entry **hpp;
4630       struct elf_link_hash_entry **hppend;
4631       struct elf_link_hash_entry **sorted_sym_hash;
4632       struct elf_link_hash_entry *h;
4633       size_t sym_count;
4634
4635       /* Since we have to search the whole symbol list for each weak
4636          defined symbol, search time for N weak defined symbols will be
4637          O(N^2). Binary search will cut it down to O(NlogN).  */
4638       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4639       sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4640       if (sorted_sym_hash == NULL)
4641         goto error_return;
4642       sym_hash = sorted_sym_hash;
4643       hpp = elf_sym_hashes (abfd);
4644       hppend = hpp + extsymcount;
4645       sym_count = 0;
4646       for (; hpp < hppend; hpp++)
4647         {
4648           h = *hpp;
4649           if (h != NULL
4650               && h->root.type == bfd_link_hash_defined
4651               && !bed->is_function_type (h->type))
4652             {
4653               *sym_hash = h;
4654               sym_hash++;
4655               sym_count++;
4656             }
4657         }
4658
4659       qsort (sorted_sym_hash, sym_count,
4660              sizeof (struct elf_link_hash_entry *),
4661              elf_sort_symbol);
4662
4663       while (weaks != NULL)
4664         {
4665           struct elf_link_hash_entry *hlook;
4666           asection *slook;
4667           bfd_vma vlook;
4668           size_t i, j, idx = 0;
4669
4670           hlook = weaks;
4671           weaks = hlook->u.weakdef;
4672           hlook->u.weakdef = NULL;
4673
4674           BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4675                       || hlook->root.type == bfd_link_hash_defweak
4676                       || hlook->root.type == bfd_link_hash_common
4677                       || hlook->root.type == bfd_link_hash_indirect);
4678           slook = hlook->root.u.def.section;
4679           vlook = hlook->root.u.def.value;
4680
4681           i = 0;
4682           j = sym_count;
4683           while (i != j)
4684             {
4685               bfd_signed_vma vdiff;
4686               idx = (i + j) / 2;
4687               h = sorted_sym_hash[idx];
4688               vdiff = vlook - h->root.u.def.value;
4689               if (vdiff < 0)
4690                 j = idx;
4691               else if (vdiff > 0)
4692                 i = idx + 1;
4693               else
4694                 {
4695                   long sdiff = slook->id - h->root.u.def.section->id;
4696                   if (sdiff < 0)
4697                     j = idx;
4698                   else if (sdiff > 0)
4699                     i = idx + 1;
4700                   else
4701                     break;
4702                 }
4703             }
4704
4705           /* We didn't find a value/section match.  */
4706           if (i == j)
4707             continue;
4708
4709           /* With multiple aliases, or when the weak symbol is already
4710              strongly defined, we have multiple matching symbols and
4711              the binary search above may land on any of them.  Step
4712              one past the matching symbol(s).  */
4713           while (++idx != j)
4714             {
4715               h = sorted_sym_hash[idx];
4716               if (h->root.u.def.section != slook
4717                   || h->root.u.def.value != vlook)
4718                 break;
4719             }
4720
4721           /* Now look back over the aliases.  Since we sorted by size
4722              as well as value and section, we'll choose the one with
4723              the largest size.  */
4724           while (idx-- != i)
4725             {
4726               h = sorted_sym_hash[idx];
4727
4728               /* Stop if value or section doesn't match.  */
4729               if (h->root.u.def.section != slook
4730                   || h->root.u.def.value != vlook)
4731                 break;
4732               else if (h != hlook)
4733                 {
4734                   hlook->u.weakdef = h;
4735
4736                   /* If the weak definition is in the list of dynamic
4737                      symbols, make sure the real definition is put
4738                      there as well.  */
4739                   if (hlook->dynindx != -1 && h->dynindx == -1)
4740                     {
4741                       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4742                         {
4743                         err_free_sym_hash:
4744                           free (sorted_sym_hash);
4745                           goto error_return;
4746                         }
4747                     }
4748
4749                   /* If the real definition is in the list of dynamic
4750                      symbols, make sure the weak definition is put
4751                      there as well.  If we don't do this, then the
4752                      dynamic loader might not merge the entries for the
4753                      real definition and the weak definition.  */
4754                   if (h->dynindx != -1 && hlook->dynindx == -1)
4755                     {
4756                       if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4757                         goto err_free_sym_hash;
4758                     }
4759                   break;
4760                 }
4761             }
4762         }
4763
4764       free (sorted_sym_hash);
4765     }
4766
4767   if (bed->check_directives
4768       && !(*bed->check_directives) (abfd, info))
4769     return FALSE;
4770
4771   /* If this object is the same format as the output object, and it is
4772      not a shared library, then let the backend look through the
4773      relocs.
4774
4775      This is required to build global offset table entries and to
4776      arrange for dynamic relocs.  It is not required for the
4777      particular common case of linking non PIC code, even when linking
4778      against shared libraries, but unfortunately there is no way of
4779      knowing whether an object file has been compiled PIC or not.
4780      Looking through the relocs is not particularly time consuming.
4781      The problem is that we must either (1) keep the relocs in memory,
4782      which causes the linker to require additional runtime memory or
4783      (2) read the relocs twice from the input file, which wastes time.
4784      This would be a good case for using mmap.
4785
4786      I have no idea how to handle linking PIC code into a file of a
4787      different format.  It probably can't be done.  */
4788   if (! dynamic
4789       && is_elf_hash_table (htab)
4790       && bed->check_relocs != NULL
4791       && elf_object_id (abfd) == elf_hash_table_id (htab)
4792       && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4793     {
4794       asection *o;
4795
4796       for (o = abfd->sections; o != NULL; o = o->next)
4797         {
4798           Elf_Internal_Rela *internal_relocs;
4799           bfd_boolean ok;
4800
4801           if ((o->flags & SEC_RELOC) == 0
4802               || o->reloc_count == 0
4803               || ((info->strip == strip_all || info->strip == strip_debugger)
4804                   && (o->flags & SEC_DEBUGGING) != 0)
4805               || bfd_is_abs_section (o->output_section))
4806             continue;
4807
4808           internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4809                                                        info->keep_memory);
4810           if (internal_relocs == NULL)
4811             goto error_return;
4812
4813           ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4814
4815           if (elf_section_data (o)->relocs != internal_relocs)
4816             free (internal_relocs);
4817
4818           if (! ok)
4819             goto error_return;
4820         }
4821     }
4822
4823   /* If this is a non-traditional link, try to optimize the handling
4824      of the .stab/.stabstr sections.  */
4825   if (! dynamic
4826       && ! info->traditional_format
4827       && is_elf_hash_table (htab)
4828       && (info->strip != strip_all && info->strip != strip_debugger))
4829     {
4830       asection *stabstr;
4831
4832       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4833       if (stabstr != NULL)
4834         {
4835           bfd_size_type string_offset = 0;
4836           asection *stab;
4837
4838           for (stab = abfd->sections; stab; stab = stab->next)
4839             if (CONST_STRNEQ (stab->name, ".stab")
4840                 && (!stab->name[5] ||
4841                     (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4842                 && (stab->flags & SEC_MERGE) == 0
4843                 && !bfd_is_abs_section (stab->output_section))
4844               {
4845                 struct bfd_elf_section_data *secdata;
4846
4847                 secdata = elf_section_data (stab);
4848                 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4849                                                stabstr, &secdata->sec_info,
4850                                                &string_offset))
4851                   goto error_return;
4852                 if (secdata->sec_info)
4853                   stab->sec_info_type = SEC_INFO_TYPE_STABS;
4854             }
4855         }
4856     }
4857
4858   if (is_elf_hash_table (htab) && add_needed)
4859     {
4860       /* Add this bfd to the loaded list.  */
4861       struct elf_link_loaded_list *n;
4862
4863       n = (struct elf_link_loaded_list *)
4864           bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
4865       if (n == NULL)
4866         goto error_return;
4867       n->abfd = abfd;
4868       n->next = htab->loaded;
4869       htab->loaded = n;
4870     }
4871
4872   return TRUE;
4873
4874  error_free_vers:
4875   if (old_tab != NULL)
4876     free (old_tab);
4877   if (nondeflt_vers != NULL)
4878     free (nondeflt_vers);
4879   if (extversym != NULL)
4880     free (extversym);
4881  error_free_sym:
4882   if (isymbuf != NULL)
4883     free (isymbuf);
4884  error_return:
4885   return FALSE;
4886 }
4887
4888 /* Return the linker hash table entry of a symbol that might be
4889    satisfied by an archive symbol.  Return -1 on error.  */
4890
4891 struct elf_link_hash_entry *
4892 _bfd_elf_archive_symbol_lookup (bfd *abfd,
4893                                 struct bfd_link_info *info,
4894                                 const char *name)
4895 {
4896   struct elf_link_hash_entry *h;
4897   char *p, *copy;
4898   size_t len, first;
4899
4900   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
4901   if (h != NULL)
4902     return h;
4903
4904   /* If this is a default version (the name contains @@), look up the
4905      symbol again with only one `@' as well as without the version.
4906      The effect is that references to the symbol with and without the
4907      version will be matched by the default symbol in the archive.  */
4908
4909   p = strchr (name, ELF_VER_CHR);
4910   if (p == NULL || p[1] != ELF_VER_CHR)
4911     return h;
4912
4913   /* First check with only one `@'.  */
4914   len = strlen (name);
4915   copy = (char *) bfd_alloc (abfd, len);
4916   if (copy == NULL)
4917     return (struct elf_link_hash_entry *) 0 - 1;
4918
4919   first = p - name + 1;
4920   memcpy (copy, name, first);
4921   memcpy (copy + first, name + first + 1, len - first);
4922
4923   h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
4924   if (h == NULL)
4925     {
4926       /* We also need to check references to the symbol without the
4927          version.  */
4928       copy[first - 1] = '\0';
4929       h = elf_link_hash_lookup (elf_hash_table (info), copy,
4930                                 FALSE, FALSE, TRUE);
4931     }
4932
4933   bfd_release (abfd, copy);
4934   return h;
4935 }
4936
4937 /* Add symbols from an ELF archive file to the linker hash table.  We
4938    don't use _bfd_generic_link_add_archive_symbols because we need to
4939    handle versioned symbols.
4940
4941    Fortunately, ELF archive handling is simpler than that done by
4942    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4943    oddities.  In ELF, if we find a symbol in the archive map, and the
4944    symbol is currently undefined, we know that we must pull in that
4945    object file.
4946
4947    Unfortunately, we do have to make multiple passes over the symbol
4948    table until nothing further is resolved.  */
4949
4950 static bfd_boolean
4951 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4952 {
4953   symindex c;
4954   unsigned char *included = NULL;
4955   carsym *symdefs;
4956   bfd_boolean loop;
4957   bfd_size_type amt;
4958   const struct elf_backend_data *bed;
4959   struct elf_link_hash_entry * (*archive_symbol_lookup)
4960     (bfd *, struct bfd_link_info *, const char *);
4961
4962   if (! bfd_has_map (abfd))
4963     {
4964       /* An empty archive is a special case.  */
4965       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4966         return TRUE;
4967       bfd_set_error (bfd_error_no_armap);
4968       return FALSE;
4969     }
4970
4971   /* Keep track of all symbols we know to be already defined, and all
4972      files we know to be already included.  This is to speed up the
4973      second and subsequent passes.  */
4974   c = bfd_ardata (abfd)->symdef_count;
4975   if (c == 0)
4976     return TRUE;
4977   amt = c;
4978   amt *= sizeof (*included);
4979   included = (unsigned char *) bfd_zmalloc (amt);
4980   if (included == NULL)
4981     return FALSE;
4982
4983   symdefs = bfd_ardata (abfd)->symdefs;
4984   bed = get_elf_backend_data (abfd);
4985   archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
4986
4987   do
4988     {
4989       file_ptr last;
4990       symindex i;
4991       carsym *symdef;
4992       carsym *symdefend;
4993
4994       loop = FALSE;
4995       last = -1;
4996
4997       symdef = symdefs;
4998       symdefend = symdef + c;
4999       for (i = 0; symdef < symdefend; symdef++, i++)
5000         {
5001           struct elf_link_hash_entry *h;
5002           bfd *element;
5003           struct bfd_link_hash_entry *undefs_tail;
5004           symindex mark;
5005
5006           if (included[i])
5007             continue;
5008           if (symdef->file_offset == last)
5009             {
5010               included[i] = TRUE;
5011               continue;
5012             }
5013
5014           h = archive_symbol_lookup (abfd, info, symdef->name);
5015           if (h == (struct elf_link_hash_entry *) 0 - 1)
5016             goto error_return;
5017
5018           if (h == NULL)
5019             continue;
5020
5021           if (h->root.type == bfd_link_hash_common)
5022             {
5023               /* We currently have a common symbol.  The archive map contains
5024                  a reference to this symbol, so we may want to include it.  We
5025                  only want to include it however, if this archive element
5026                  contains a definition of the symbol, not just another common
5027                  declaration of it.
5028
5029                  Unfortunately some archivers (including GNU ar) will put
5030                  declarations of common symbols into their archive maps, as
5031                  well as real definitions, so we cannot just go by the archive
5032                  map alone.  Instead we must read in the element's symbol
5033                  table and check that to see what kind of symbol definition
5034                  this is.  */
5035               if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5036                 continue;
5037             }
5038           else if (h->root.type != bfd_link_hash_undefined)
5039             {
5040               if (h->root.type != bfd_link_hash_undefweak)
5041                 /* Symbol must be defined.  Don't check it again.  */
5042                 included[i] = TRUE;
5043               continue;
5044             }
5045
5046           /* We need to include this archive member.  */
5047           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5048           if (element == NULL)
5049             goto error_return;
5050
5051           if (! bfd_check_format (element, bfd_object))
5052             goto error_return;
5053
5054           undefs_tail = info->hash->undefs_tail;
5055
5056           if (!(*info->callbacks
5057                 ->add_archive_element) (info, element, symdef->name, &element))
5058             goto error_return;
5059           if (!bfd_link_add_symbols (element, info))
5060             goto error_return;
5061
5062           /* If there are any new undefined symbols, we need to make
5063              another pass through the archive in order to see whether
5064              they can be defined.  FIXME: This isn't perfect, because
5065              common symbols wind up on undefs_tail and because an
5066              undefined symbol which is defined later on in this pass
5067              does not require another pass.  This isn't a bug, but it
5068              does make the code less efficient than it could be.  */
5069           if (undefs_tail != info->hash->undefs_tail)
5070             loop = TRUE;
5071
5072           /* Look backward to mark all symbols from this object file
5073              which we have already seen in this pass.  */
5074           mark = i;
5075           do
5076             {
5077               included[mark] = TRUE;
5078               if (mark == 0)
5079                 break;
5080               --mark;
5081             }
5082           while (symdefs[mark].file_offset == symdef->file_offset);
5083
5084           /* We mark subsequent symbols from this object file as we go
5085              on through the loop.  */
5086           last = symdef->file_offset;
5087         }
5088     }
5089   while (loop);
5090
5091   free (included);
5092
5093   return TRUE;
5094
5095  error_return:
5096   if (included != NULL)
5097     free (included);
5098   return FALSE;
5099 }
5100
5101 /* Given an ELF BFD, add symbols to the global hash table as
5102    appropriate.  */
5103
5104 bfd_boolean
5105 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5106 {
5107   switch (bfd_get_format (abfd))
5108     {
5109     case bfd_object:
5110       return elf_link_add_object_symbols (abfd, info);
5111     case bfd_archive:
5112       return elf_link_add_archive_symbols (abfd, info);
5113     default:
5114       bfd_set_error (bfd_error_wrong_format);
5115       return FALSE;
5116     }
5117 }
5118 \f
5119 struct hash_codes_info
5120 {
5121   unsigned long *hashcodes;
5122   bfd_boolean error;
5123 };
5124
5125 /* This function will be called though elf_link_hash_traverse to store
5126    all hash value of the exported symbols in an array.  */
5127
5128 static bfd_boolean
5129 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5130 {
5131   struct hash_codes_info *inf = (struct hash_codes_info *) data;
5132   const char *name;
5133   char *p;
5134   unsigned long ha;
5135   char *alc = NULL;
5136
5137   /* Ignore indirect symbols.  These are added by the versioning code.  */
5138   if (h->dynindx == -1)
5139     return TRUE;
5140
5141   name = h->root.root.string;
5142   p = strchr (name, ELF_VER_CHR);
5143   if (p != NULL)
5144     {
5145       alc = (char *) bfd_malloc (p - name + 1);
5146       if (alc == NULL)
5147         {
5148           inf->error = TRUE;
5149           return FALSE;
5150         }
5151       memcpy (alc, name, p - name);
5152       alc[p - name] = '\0';
5153       name = alc;
5154     }
5155
5156   /* Compute the hash value.  */
5157   ha = bfd_elf_hash (name);
5158
5159   /* Store the found hash value in the array given as the argument.  */
5160   *(inf->hashcodes)++ = ha;
5161
5162   /* And store it in the struct so that we can put it in the hash table
5163      later.  */
5164   h->u.elf_hash_value = ha;
5165
5166   if (alc != NULL)
5167     free (alc);
5168
5169   return TRUE;
5170 }
5171
5172 struct collect_gnu_hash_codes
5173 {
5174   bfd *output_bfd;
5175   const struct elf_backend_data *bed;
5176   unsigned long int nsyms;
5177   unsigned long int maskbits;
5178   unsigned long int *hashcodes;
5179   unsigned long int *hashval;
5180   unsigned long int *indx;
5181   unsigned long int *counts;
5182   bfd_vma *bitmask;
5183   bfd_byte *contents;
5184   long int min_dynindx;
5185   unsigned long int bucketcount;
5186   unsigned long int symindx;
5187   long int local_indx;
5188   long int shift1, shift2;
5189   unsigned long int mask;
5190   bfd_boolean error;
5191 };
5192
5193 /* This function will be called though elf_link_hash_traverse to store
5194    all hash value of the exported symbols in an array.  */
5195
5196 static bfd_boolean
5197 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5198 {
5199   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5200   const char *name;
5201   char *p;
5202   unsigned long ha;
5203   char *alc = NULL;
5204
5205   /* Ignore indirect symbols.  These are added by the versioning code.  */
5206   if (h->dynindx == -1)
5207     return TRUE;
5208
5209   /* Ignore also local symbols and undefined symbols.  */
5210   if (! (*s->bed->elf_hash_symbol) (h))
5211     return TRUE;
5212
5213   name = h->root.root.string;
5214   p = strchr (name, ELF_VER_CHR);
5215   if (p != NULL)
5216     {
5217       alc = (char *) bfd_malloc (p - name + 1);
5218       if (alc == NULL)
5219         {
5220           s->error = TRUE;
5221           return FALSE;
5222         }
5223       memcpy (alc, name, p - name);
5224       alc[p - name] = '\0';
5225       name = alc;
5226     }
5227
5228   /* Compute the hash value.  */
5229   ha = bfd_elf_gnu_hash (name);
5230
5231   /* Store the found hash value in the array for compute_bucket_count,
5232      and also for .dynsym reordering purposes.  */
5233   s->hashcodes[s->nsyms] = ha;
5234   s->hashval[h->dynindx] = ha;
5235   ++s->nsyms;
5236   if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5237     s->min_dynindx = h->dynindx;
5238
5239   if (alc != NULL)
5240     free (alc);
5241
5242   return TRUE;
5243 }
5244
5245 /* This function will be called though elf_link_hash_traverse to do
5246    final dynaminc symbol renumbering.  */
5247
5248 static bfd_boolean
5249 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5250 {
5251   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5252   unsigned long int bucket;
5253   unsigned long int val;
5254
5255   /* Ignore indirect symbols.  */
5256   if (h->dynindx == -1)
5257     return TRUE;
5258
5259   /* Ignore also local symbols and undefined symbols.  */
5260   if (! (*s->bed->elf_hash_symbol) (h))
5261     {
5262       if (h->dynindx >= s->min_dynindx)
5263         h->dynindx = s->local_indx++;
5264       return TRUE;
5265     }
5266
5267   bucket = s->hashval[h->dynindx] % s->bucketcount;
5268   val = (s->hashval[h->dynindx] >> s->shift1)
5269         & ((s->maskbits >> s->shift1) - 1);
5270   s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5271   s->bitmask[val]
5272     |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5273   val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5274   if (s->counts[bucket] == 1)
5275     /* Last element terminates the chain.  */
5276     val |= 1;
5277   bfd_put_32 (s->output_bfd, val,
5278               s->contents + (s->indx[bucket] - s->symindx) * 4);
5279   --s->counts[bucket];
5280   h->dynindx = s->indx[bucket]++;
5281   return TRUE;
5282 }
5283
5284 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5285
5286 bfd_boolean
5287 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5288 {
5289   return !(h->forced_local
5290            || h->root.type == bfd_link_hash_undefined
5291            || h->root.type == bfd_link_hash_undefweak
5292            || ((h->root.type == bfd_link_hash_defined
5293                 || h->root.type == bfd_link_hash_defweak)
5294                && h->root.u.def.section->output_section == NULL));
5295 }
5296
5297 /* Array used to determine the number of hash table buckets to use
5298    based on the number of symbols there are.  If there are fewer than
5299    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5300    fewer than 37 we use 17 buckets, and so forth.  We never use more
5301    than 32771 buckets.  */
5302
5303 static const size_t elf_buckets[] =
5304 {
5305   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5306   16411, 32771, 0
5307 };
5308
5309 /* Compute bucket count for hashing table.  We do not use a static set
5310    of possible tables sizes anymore.  Instead we determine for all
5311    possible reasonable sizes of the table the outcome (i.e., the
5312    number of collisions etc) and choose the best solution.  The
5313    weighting functions are not too simple to allow the table to grow
5314    without bounds.  Instead one of the weighting factors is the size.
5315    Therefore the result is always a good payoff between few collisions
5316    (= short chain lengths) and table size.  */
5317 static size_t
5318 compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5319                       unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5320                       unsigned long int nsyms,
5321                       int gnu_hash)
5322 {
5323   size_t best_size = 0;
5324   unsigned long int i;
5325
5326   /* We have a problem here.  The following code to optimize the table
5327      size requires an integer type with more the 32 bits.  If
5328      BFD_HOST_U_64_BIT is set we know about such a type.  */
5329 #ifdef BFD_HOST_U_64_BIT
5330   if (info->optimize)
5331     {
5332       size_t minsize;
5333       size_t maxsize;
5334       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5335       bfd *dynobj = elf_hash_table (info)->dynobj;
5336       size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5337       const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5338       unsigned long int *counts;
5339       bfd_size_type amt;
5340       unsigned int no_improvement_count = 0;
5341
5342       /* Possible optimization parameters: if we have NSYMS symbols we say
5343          that the hashing table must at least have NSYMS/4 and at most
5344          2*NSYMS buckets.  */
5345       minsize = nsyms / 4;
5346       if (minsize == 0)
5347         minsize = 1;
5348       best_size = maxsize = nsyms * 2;
5349       if (gnu_hash)
5350         {
5351           if (minsize < 2)
5352             minsize = 2;
5353           if ((best_size & 31) == 0)
5354             ++best_size;
5355         }
5356
5357       /* Create array where we count the collisions in.  We must use bfd_malloc
5358          since the size could be large.  */
5359       amt = maxsize;
5360       amt *= sizeof (unsigned long int);
5361       counts = (unsigned long int *) bfd_malloc (amt);
5362       if (counts == NULL)
5363         return 0;
5364
5365       /* Compute the "optimal" size for the hash table.  The criteria is a
5366          minimal chain length.  The minor criteria is (of course) the size
5367          of the table.  */
5368       for (i = minsize; i < maxsize; ++i)
5369         {
5370           /* Walk through the array of hashcodes and count the collisions.  */
5371           BFD_HOST_U_64_BIT max;
5372           unsigned long int j;
5373           unsigned long int fact;
5374
5375           if (gnu_hash && (i & 31) == 0)
5376             continue;
5377
5378           memset (counts, '\0', i * sizeof (unsigned long int));
5379
5380           /* Determine how often each hash bucket is used.  */
5381           for (j = 0; j < nsyms; ++j)
5382             ++counts[hashcodes[j] % i];
5383
5384           /* For the weight function we need some information about the
5385              pagesize on the target.  This is information need not be 100%
5386              accurate.  Since this information is not available (so far) we
5387              define it here to a reasonable default value.  If it is crucial
5388              to have a better value some day simply define this value.  */
5389 # ifndef BFD_TARGET_PAGESIZE
5390 #  define BFD_TARGET_PAGESIZE   (4096)
5391 # endif
5392
5393           /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5394              and the chains.  */
5395           max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5396
5397 # if 1
5398           /* Variant 1: optimize for short chains.  We add the squares
5399              of all the chain lengths (which favors many small chain
5400              over a few long chains).  */
5401           for (j = 0; j < i; ++j)
5402             max += counts[j] * counts[j];
5403
5404           /* This adds penalties for the overall size of the table.  */
5405           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5406           max *= fact * fact;
5407 # else
5408           /* Variant 2: Optimize a lot more for small table.  Here we
5409              also add squares of the size but we also add penalties for
5410              empty slots (the +1 term).  */
5411           for (j = 0; j < i; ++j)
5412             max += (1 + counts[j]) * (1 + counts[j]);
5413
5414           /* The overall size of the table is considered, but not as
5415              strong as in variant 1, where it is squared.  */
5416           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5417           max *= fact;
5418 # endif
5419
5420           /* Compare with current best results.  */
5421           if (max < best_chlen)
5422             {
5423               best_chlen = max;
5424               best_size = i;
5425               no_improvement_count = 0;
5426             }
5427           /* PR 11843: Avoid futile long searches for the best bucket size
5428              when there are a large number of symbols.  */
5429           else if (++no_improvement_count == 100)
5430             break;
5431         }
5432
5433       free (counts);
5434     }
5435   else
5436 #endif /* defined (BFD_HOST_U_64_BIT) */
5437     {
5438       /* This is the fallback solution if no 64bit type is available or if we
5439          are not supposed to spend much time on optimizations.  We select the
5440          bucket count using a fixed set of numbers.  */
5441       for (i = 0; elf_buckets[i] != 0; i++)
5442         {
5443           best_size = elf_buckets[i];
5444           if (nsyms < elf_buckets[i + 1])
5445             break;
5446         }
5447       if (gnu_hash && best_size < 2)
5448         best_size = 2;
5449     }
5450
5451   return best_size;
5452 }
5453
5454 /* Size any SHT_GROUP section for ld -r.  */
5455
5456 bfd_boolean
5457 _bfd_elf_size_group_sections (struct bfd_link_info *info)
5458 {
5459   bfd *ibfd;
5460
5461   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5462     if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5463         && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5464       return FALSE;
5465   return TRUE;
5466 }
5467
5468 /* Set a default stack segment size.  The value in INFO wins.  If it
5469    is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5470    undefined it is initialized.  */
5471
5472 bfd_boolean
5473 bfd_elf_stack_segment_size (bfd *output_bfd,
5474                             struct bfd_link_info *info,
5475                             const char *legacy_symbol,
5476                             bfd_vma default_size)
5477 {
5478   struct elf_link_hash_entry *h = NULL;
5479
5480   /* Look for legacy symbol.  */
5481   if (legacy_symbol)
5482     h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
5483                               FALSE, FALSE, FALSE);
5484   if (h && (h->root.type == bfd_link_hash_defined
5485             || h->root.type == bfd_link_hash_defweak)
5486       && h->def_regular
5487       && (h->type == STT_NOTYPE || h->type == STT_OBJECT))
5488     {
5489       /* The symbol has no type if specified on the command line.  */
5490       h->type = STT_OBJECT;
5491       if (info->stacksize)
5492         (*_bfd_error_handler) (_("%B: stack size specified and %s set"),
5493                                output_bfd, legacy_symbol);
5494       else if (h->root.u.def.section != bfd_abs_section_ptr)
5495         (*_bfd_error_handler) (_("%B: %s not absolute"),
5496                                output_bfd, legacy_symbol);
5497       else
5498         info->stacksize = h->root.u.def.value;
5499     }
5500
5501   if (!info->stacksize)
5502     /* If the user didn't set a size, or explicitly inhibit the
5503        size, set it now.  */
5504     info->stacksize = default_size;
5505
5506   /* Provide the legacy symbol, if it is referenced.  */
5507   if (h && (h->root.type == bfd_link_hash_undefined
5508             || h->root.type == bfd_link_hash_undefweak))
5509     {
5510       struct bfd_link_hash_entry *bh = NULL;
5511
5512       if (!(_bfd_generic_link_add_one_symbol
5513             (info, output_bfd, legacy_symbol,
5514              BSF_GLOBAL, bfd_abs_section_ptr,
5515              info->stacksize >= 0 ? info->stacksize : 0,
5516              NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
5517         return FALSE;
5518
5519       h = (struct elf_link_hash_entry *) bh;
5520       h->def_regular = 1;
5521       h->type = STT_OBJECT;
5522     }
5523
5524   return TRUE;
5525 }
5526
5527 /* Set up the sizes and contents of the ELF dynamic sections.  This is
5528    called by the ELF linker emulation before_allocation routine.  We
5529    must set the sizes of the sections before the linker sets the
5530    addresses of the various sections.  */
5531
5532 bfd_boolean
5533 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5534                                const char *soname,
5535                                const char *rpath,
5536                                const char *filter_shlib,
5537                                const char *audit,
5538                                const char *depaudit,
5539                                const char * const *auxiliary_filters,
5540                                struct bfd_link_info *info,
5541                                asection **sinterpptr)
5542 {
5543   bfd_size_type soname_indx;
5544   bfd *dynobj;
5545   const struct elf_backend_data *bed;
5546   struct elf_info_failed asvinfo;
5547
5548   *sinterpptr = NULL;
5549
5550   soname_indx = (bfd_size_type) -1;
5551
5552   if (!is_elf_hash_table (info->hash))
5553     return TRUE;
5554
5555   bed = get_elf_backend_data (output_bfd);
5556
5557   /* Any syms created from now on start with -1 in
5558      got.refcount/offset and plt.refcount/offset.  */
5559   elf_hash_table (info)->init_got_refcount
5560     = elf_hash_table (info)->init_got_offset;
5561   elf_hash_table (info)->init_plt_refcount
5562     = elf_hash_table (info)->init_plt_offset;
5563
5564   if (info->relocatable
5565       && !_bfd_elf_size_group_sections (info))
5566     return FALSE;
5567
5568   /* The backend may have to create some sections regardless of whether
5569      we're dynamic or not.  */
5570   if (bed->elf_backend_always_size_sections
5571       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5572     return FALSE;
5573
5574   /* Determine any GNU_STACK segment requirements, after the backend
5575      has had a chance to set a default segment size.  */
5576   if (info->execstack)
5577     elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
5578   else if (info->noexecstack)
5579     elf_stack_flags (output_bfd) = PF_R | PF_W;
5580   else
5581     {
5582       bfd *inputobj;
5583       asection *notesec = NULL;
5584       int exec = 0;
5585
5586       for (inputobj = info->input_bfds;
5587            inputobj;
5588            inputobj = inputobj->link.next)
5589         {
5590           asection *s;
5591
5592           if (inputobj->flags
5593               & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5594             continue;
5595           s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5596           if (s)
5597             {
5598               if (s->flags & SEC_CODE)
5599                 exec = PF_X;
5600               notesec = s;
5601             }
5602           else if (bed->default_execstack)
5603             exec = PF_X;
5604         }
5605       if (notesec || info->stacksize > 0)
5606         elf_stack_flags (output_bfd) = PF_R | PF_W | exec;
5607       if (notesec && exec && info->relocatable
5608           && notesec->output_section != bfd_abs_section_ptr)
5609         notesec->output_section->flags |= SEC_CODE;
5610     }
5611
5612   dynobj = elf_hash_table (info)->dynobj;
5613
5614   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5615     {
5616       struct elf_info_failed eif;
5617       struct elf_link_hash_entry *h;
5618       asection *dynstr;
5619       struct bfd_elf_version_tree *t;
5620       struct bfd_elf_version_expr *d;
5621       asection *s;
5622       bfd_boolean all_defined;
5623
5624       *sinterpptr = bfd_get_linker_section (dynobj, ".interp");
5625       BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5626
5627       if (soname != NULL)
5628         {
5629           soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5630                                              soname, TRUE);
5631           if (soname_indx == (bfd_size_type) -1
5632               || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5633             return FALSE;
5634         }
5635
5636       if (info->symbolic)
5637         {
5638           if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5639             return FALSE;
5640           info->flags |= DF_SYMBOLIC;
5641         }
5642
5643       if (rpath != NULL)
5644         {
5645           bfd_size_type indx;
5646           bfd_vma tag;
5647
5648           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5649                                       TRUE);
5650           if (indx == (bfd_size_type) -1)
5651             return FALSE;
5652
5653           tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
5654           if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
5655             return FALSE;
5656         }
5657
5658       if (filter_shlib != NULL)
5659         {
5660           bfd_size_type indx;
5661
5662           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5663                                       filter_shlib, TRUE);
5664           if (indx == (bfd_size_type) -1
5665               || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5666             return FALSE;
5667         }
5668
5669       if (auxiliary_filters != NULL)
5670         {
5671           const char * const *p;
5672
5673           for (p = auxiliary_filters; *p != NULL; p++)
5674             {
5675               bfd_size_type indx;
5676
5677               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5678                                           *p, TRUE);
5679               if (indx == (bfd_size_type) -1
5680                   || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5681                 return FALSE;
5682             }
5683         }
5684
5685       if (audit != NULL)
5686         {
5687           bfd_size_type indx;
5688
5689           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5690                                       TRUE);
5691           if (indx == (bfd_size_type) -1
5692               || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5693             return FALSE;
5694         }
5695
5696       if (depaudit != NULL)
5697         {
5698           bfd_size_type indx;
5699
5700           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5701                                       TRUE);
5702           if (indx == (bfd_size_type) -1
5703               || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5704             return FALSE;
5705         }
5706
5707       eif.info = info;
5708       eif.failed = FALSE;
5709
5710       /* If we are supposed to export all symbols into the dynamic symbol
5711          table (this is not the normal case), then do so.  */
5712       if (info->export_dynamic
5713           || (info->executable && info->dynamic))
5714         {
5715           elf_link_hash_traverse (elf_hash_table (info),
5716                                   _bfd_elf_export_symbol,
5717                                   &eif);
5718           if (eif.failed)
5719             return FALSE;
5720         }
5721
5722       /* Make all global versions with definition.  */
5723       for (t = info->version_info; t != NULL; t = t->next)
5724         for (d = t->globals.list; d != NULL; d = d->next)
5725           if (!d->symver && d->literal)
5726             {
5727               const char *verstr, *name;
5728               size_t namelen, verlen, newlen;
5729               char *newname, *p, leading_char;
5730               struct elf_link_hash_entry *newh;
5731
5732               leading_char = bfd_get_symbol_leading_char (output_bfd);
5733               name = d->pattern;
5734               namelen = strlen (name) + (leading_char != '\0');
5735               verstr = t->name;
5736               verlen = strlen (verstr);
5737               newlen = namelen + verlen + 3;
5738
5739               newname = (char *) bfd_malloc (newlen);
5740               if (newname == NULL)
5741                 return FALSE;
5742               newname[0] = leading_char;
5743               memcpy (newname + (leading_char != '\0'), name, namelen);
5744
5745               /* Check the hidden versioned definition.  */
5746               p = newname + namelen;
5747               *p++ = ELF_VER_CHR;
5748               memcpy (p, verstr, verlen + 1);
5749               newh = elf_link_hash_lookup (elf_hash_table (info),
5750                                            newname, FALSE, FALSE,
5751                                            FALSE);
5752               if (newh == NULL
5753                   || (newh->root.type != bfd_link_hash_defined
5754                       && newh->root.type != bfd_link_hash_defweak))
5755                 {
5756                   /* Check the default versioned definition.  */
5757                   *p++ = ELF_VER_CHR;
5758                   memcpy (p, verstr, verlen + 1);
5759                   newh = elf_link_hash_lookup (elf_hash_table (info),
5760                                                newname, FALSE, FALSE,
5761                                                FALSE);
5762                 }
5763               free (newname);
5764
5765               /* Mark this version if there is a definition and it is
5766                  not defined in a shared object.  */
5767               if (newh != NULL
5768                   && !newh->def_dynamic
5769                   && (newh->root.type == bfd_link_hash_defined
5770                       || newh->root.type == bfd_link_hash_defweak))
5771                 d->symver = 1;
5772             }
5773
5774       /* Attach all the symbols to their version information.  */
5775       asvinfo.info = info;
5776       asvinfo.failed = FALSE;
5777
5778       elf_link_hash_traverse (elf_hash_table (info),
5779                               _bfd_elf_link_assign_sym_version,
5780                               &asvinfo);
5781       if (asvinfo.failed)
5782         return FALSE;
5783
5784       if (!info->allow_undefined_version)
5785         {
5786           /* Check if all global versions have a definition.  */
5787           all_defined = TRUE;
5788           for (t = info->version_info; t != NULL; t = t->next)
5789             for (d = t->globals.list; d != NULL; d = d->next)
5790               if (d->literal && !d->symver && !d->script)
5791                 {
5792                   (*_bfd_error_handler)
5793                     (_("%s: undefined version: %s"),
5794                      d->pattern, t->name);
5795                   all_defined = FALSE;
5796                 }
5797
5798           if (!all_defined)
5799             {
5800               bfd_set_error (bfd_error_bad_value);
5801               return FALSE;
5802             }
5803         }
5804
5805       /* Find all symbols which were defined in a dynamic object and make
5806          the backend pick a reasonable value for them.  */
5807       elf_link_hash_traverse (elf_hash_table (info),
5808                               _bfd_elf_adjust_dynamic_symbol,
5809                               &eif);
5810       if (eif.failed)
5811         return FALSE;
5812
5813       /* Add some entries to the .dynamic section.  We fill in some of the
5814          values later, in bfd_elf_final_link, but we must add the entries
5815          now so that we know the final size of the .dynamic section.  */
5816
5817       /* If there are initialization and/or finalization functions to
5818          call then add the corresponding DT_INIT/DT_FINI entries.  */
5819       h = (info->init_function
5820            ? elf_link_hash_lookup (elf_hash_table (info),
5821                                    info->init_function, FALSE,
5822                                    FALSE, FALSE)
5823            : NULL);
5824       if (h != NULL
5825           && (h->ref_regular
5826               || h->def_regular))
5827         {
5828           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5829             return FALSE;
5830         }
5831       h = (info->fini_function
5832            ? elf_link_hash_lookup (elf_hash_table (info),
5833                                    info->fini_function, FALSE,
5834                                    FALSE, FALSE)
5835            : NULL);
5836       if (h != NULL
5837           && (h->ref_regular
5838               || h->def_regular))
5839         {
5840           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5841             return FALSE;
5842         }
5843
5844       s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5845       if (s != NULL && s->linker_has_input)
5846         {
5847           /* DT_PREINIT_ARRAY is not allowed in shared library.  */
5848           if (! info->executable)
5849             {
5850               bfd *sub;
5851               asection *o;
5852
5853               for (sub = info->input_bfds; sub != NULL;
5854                    sub = sub->link.next)
5855                 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5856                   for (o = sub->sections; o != NULL; o = o->next)
5857                     if (elf_section_data (o)->this_hdr.sh_type
5858                         == SHT_PREINIT_ARRAY)
5859                       {
5860                         (*_bfd_error_handler)
5861                           (_("%B: .preinit_array section is not allowed in DSO"),
5862                            sub);
5863                         break;
5864                       }
5865
5866               bfd_set_error (bfd_error_nonrepresentable_section);
5867               return FALSE;
5868             }
5869
5870           if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5871               || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5872             return FALSE;
5873         }
5874       s = bfd_get_section_by_name (output_bfd, ".init_array");
5875       if (s != NULL && s->linker_has_input)
5876         {
5877           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5878               || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5879             return FALSE;
5880         }
5881       s = bfd_get_section_by_name (output_bfd, ".fini_array");
5882       if (s != NULL && s->linker_has_input)
5883         {
5884           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5885               || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5886             return FALSE;
5887         }
5888
5889       dynstr = bfd_get_linker_section (dynobj, ".dynstr");
5890       /* If .dynstr is excluded from the link, we don't want any of
5891          these tags.  Strictly, we should be checking each section
5892          individually;  This quick check covers for the case where
5893          someone does a /DISCARD/ : { *(*) }.  */
5894       if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5895         {
5896           bfd_size_type strsize;
5897
5898           strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5899           if ((info->emit_hash
5900                && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5901               || (info->emit_gnu_hash
5902                   && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5903               || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5904               || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5905               || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5906               || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5907                                               bed->s->sizeof_sym))
5908             return FALSE;
5909         }
5910     }
5911
5912   /* The backend must work out the sizes of all the other dynamic
5913      sections.  */
5914   if (dynobj != NULL
5915       && bed->elf_backend_size_dynamic_sections != NULL
5916       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5917     return FALSE;
5918
5919   if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5920     return FALSE;
5921
5922   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5923     {
5924       unsigned long section_sym_count;
5925       struct bfd_elf_version_tree *verdefs;
5926       asection *s;
5927
5928       /* Set up the version definition section.  */
5929       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
5930       BFD_ASSERT (s != NULL);
5931
5932       /* We may have created additional version definitions if we are
5933          just linking a regular application.  */
5934       verdefs = info->version_info;
5935
5936       /* Skip anonymous version tag.  */
5937       if (verdefs != NULL && verdefs->vernum == 0)
5938         verdefs = verdefs->next;
5939
5940       if (verdefs == NULL && !info->create_default_symver)
5941         s->flags |= SEC_EXCLUDE;
5942       else
5943         {
5944           unsigned int cdefs;
5945           bfd_size_type size;
5946           struct bfd_elf_version_tree *t;
5947           bfd_byte *p;
5948           Elf_Internal_Verdef def;
5949           Elf_Internal_Verdaux defaux;
5950           struct bfd_link_hash_entry *bh;
5951           struct elf_link_hash_entry *h;
5952           const char *name;
5953
5954           cdefs = 0;
5955           size = 0;
5956
5957           /* Make space for the base version.  */
5958           size += sizeof (Elf_External_Verdef);
5959           size += sizeof (Elf_External_Verdaux);
5960           ++cdefs;
5961
5962           /* Make space for the default version.  */
5963           if (info->create_default_symver)
5964             {
5965               size += sizeof (Elf_External_Verdef);
5966               ++cdefs;
5967             }
5968
5969           for (t = verdefs; t != NULL; t = t->next)
5970             {
5971               struct bfd_elf_version_deps *n;
5972
5973               /* Don't emit base version twice.  */
5974               if (t->vernum == 0)
5975                 continue;
5976
5977               size += sizeof (Elf_External_Verdef);
5978               size += sizeof (Elf_External_Verdaux);
5979               ++cdefs;
5980
5981               for (n = t->deps; n != NULL; n = n->next)
5982                 size += sizeof (Elf_External_Verdaux);
5983             }
5984
5985           s->size = size;
5986           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
5987           if (s->contents == NULL && s->size != 0)
5988             return FALSE;
5989
5990           /* Fill in the version definition section.  */
5991
5992           p = s->contents;
5993
5994           def.vd_version = VER_DEF_CURRENT;
5995           def.vd_flags = VER_FLG_BASE;
5996           def.vd_ndx = 1;
5997           def.vd_cnt = 1;
5998           if (info->create_default_symver)
5999             {
6000               def.vd_aux = 2 * sizeof (Elf_External_Verdef);
6001               def.vd_next = sizeof (Elf_External_Verdef);
6002             }
6003           else
6004             {
6005               def.vd_aux = sizeof (Elf_External_Verdef);
6006               def.vd_next = (sizeof (Elf_External_Verdef)
6007                              + sizeof (Elf_External_Verdaux));
6008             }
6009
6010           if (soname_indx != (bfd_size_type) -1)
6011             {
6012               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6013                                       soname_indx);
6014               def.vd_hash = bfd_elf_hash (soname);
6015               defaux.vda_name = soname_indx;
6016               name = soname;
6017             }
6018           else
6019             {
6020               bfd_size_type indx;
6021
6022               name = lbasename (output_bfd->filename);
6023               def.vd_hash = bfd_elf_hash (name);
6024               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6025                                           name, FALSE);
6026               if (indx == (bfd_size_type) -1)
6027                 return FALSE;
6028               defaux.vda_name = indx;
6029             }
6030           defaux.vda_next = 0;
6031
6032           _bfd_elf_swap_verdef_out (output_bfd, &def,
6033                                     (Elf_External_Verdef *) p);
6034           p += sizeof (Elf_External_Verdef);
6035           if (info->create_default_symver)
6036             {
6037               /* Add a symbol representing this version.  */
6038               bh = NULL;
6039               if (! (_bfd_generic_link_add_one_symbol
6040                      (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6041                       0, NULL, FALSE,
6042                       get_elf_backend_data (dynobj)->collect, &bh)))
6043                 return FALSE;
6044               h = (struct elf_link_hash_entry *) bh;
6045               h->non_elf = 0;
6046               h->def_regular = 1;
6047               h->type = STT_OBJECT;
6048               h->verinfo.vertree = NULL;
6049
6050               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6051                 return FALSE;
6052
6053               /* Create a duplicate of the base version with the same
6054                  aux block, but different flags.  */
6055               def.vd_flags = 0;
6056               def.vd_ndx = 2;
6057               def.vd_aux = sizeof (Elf_External_Verdef);
6058               if (verdefs)
6059                 def.vd_next = (sizeof (Elf_External_Verdef)
6060                                + sizeof (Elf_External_Verdaux));
6061               else
6062                 def.vd_next = 0;
6063               _bfd_elf_swap_verdef_out (output_bfd, &def,
6064                                         (Elf_External_Verdef *) p);
6065               p += sizeof (Elf_External_Verdef);
6066             }
6067           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6068                                      (Elf_External_Verdaux *) p);
6069           p += sizeof (Elf_External_Verdaux);
6070
6071           for (t = verdefs; t != NULL; t = t->next)
6072             {
6073               unsigned int cdeps;
6074               struct bfd_elf_version_deps *n;
6075
6076               /* Don't emit the base version twice.  */
6077               if (t->vernum == 0)
6078                 continue;
6079
6080               cdeps = 0;
6081               for (n = t->deps; n != NULL; n = n->next)
6082                 ++cdeps;
6083
6084               /* Add a symbol representing this version.  */
6085               bh = NULL;
6086               if (! (_bfd_generic_link_add_one_symbol
6087                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6088                       0, NULL, FALSE,
6089                       get_elf_backend_data (dynobj)->collect, &bh)))
6090                 return FALSE;
6091               h = (struct elf_link_hash_entry *) bh;
6092               h->non_elf = 0;
6093               h->def_regular = 1;
6094               h->type = STT_OBJECT;
6095               h->verinfo.vertree = t;
6096
6097               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6098                 return FALSE;
6099
6100               def.vd_version = VER_DEF_CURRENT;
6101               def.vd_flags = 0;
6102               if (t->globals.list == NULL
6103                   && t->locals.list == NULL
6104                   && ! t->used)
6105                 def.vd_flags |= VER_FLG_WEAK;
6106               def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6107               def.vd_cnt = cdeps + 1;
6108               def.vd_hash = bfd_elf_hash (t->name);
6109               def.vd_aux = sizeof (Elf_External_Verdef);
6110               def.vd_next = 0;
6111
6112               /* If a basever node is next, it *must* be the last node in
6113                  the chain, otherwise Verdef construction breaks.  */
6114               if (t->next != NULL && t->next->vernum == 0)
6115                 BFD_ASSERT (t->next->next == NULL);
6116
6117               if (t->next != NULL && t->next->vernum != 0)
6118                 def.vd_next = (sizeof (Elf_External_Verdef)
6119                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6120
6121               _bfd_elf_swap_verdef_out (output_bfd, &def,
6122                                         (Elf_External_Verdef *) p);
6123               p += sizeof (Elf_External_Verdef);
6124
6125               defaux.vda_name = h->dynstr_index;
6126               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6127                                       h->dynstr_index);
6128               defaux.vda_next = 0;
6129               if (t->deps != NULL)
6130                 defaux.vda_next = sizeof (Elf_External_Verdaux);
6131               t->name_indx = defaux.vda_name;
6132
6133               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6134                                          (Elf_External_Verdaux *) p);
6135               p += sizeof (Elf_External_Verdaux);
6136
6137               for (n = t->deps; n != NULL; n = n->next)
6138                 {
6139                   if (n->version_needed == NULL)
6140                     {
6141                       /* This can happen if there was an error in the
6142                          version script.  */
6143                       defaux.vda_name = 0;
6144                     }
6145                   else
6146                     {
6147                       defaux.vda_name = n->version_needed->name_indx;
6148                       _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6149                                               defaux.vda_name);
6150                     }
6151                   if (n->next == NULL)
6152                     defaux.vda_next = 0;
6153                   else
6154                     defaux.vda_next = sizeof (Elf_External_Verdaux);
6155
6156                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6157                                              (Elf_External_Verdaux *) p);
6158                   p += sizeof (Elf_External_Verdaux);
6159                 }
6160             }
6161
6162           if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6163               || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6164             return FALSE;
6165
6166           elf_tdata (output_bfd)->cverdefs = cdefs;
6167         }
6168
6169       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6170         {
6171           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6172             return FALSE;
6173         }
6174       else if (info->flags & DF_BIND_NOW)
6175         {
6176           if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6177             return FALSE;
6178         }
6179
6180       if (info->flags_1)
6181         {
6182           if (info->executable)
6183             info->flags_1 &= ~ (DF_1_INITFIRST
6184                                 | DF_1_NODELETE
6185                                 | DF_1_NOOPEN);
6186           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6187             return FALSE;
6188         }
6189
6190       /* Work out the size of the version reference section.  */
6191
6192       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
6193       BFD_ASSERT (s != NULL);
6194       {
6195         struct elf_find_verdep_info sinfo;
6196
6197         sinfo.info = info;
6198         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6199         if (sinfo.vers == 0)
6200           sinfo.vers = 1;
6201         sinfo.failed = FALSE;
6202
6203         elf_link_hash_traverse (elf_hash_table (info),
6204                                 _bfd_elf_link_find_version_dependencies,
6205                                 &sinfo);
6206         if (sinfo.failed)
6207           return FALSE;
6208
6209         if (elf_tdata (output_bfd)->verref == NULL)
6210           s->flags |= SEC_EXCLUDE;
6211         else
6212           {
6213             Elf_Internal_Verneed *t;
6214             unsigned int size;
6215             unsigned int crefs;
6216             bfd_byte *p;
6217
6218             /* Build the version dependency section.  */
6219             size = 0;
6220             crefs = 0;
6221             for (t = elf_tdata (output_bfd)->verref;
6222                  t != NULL;
6223                  t = t->vn_nextref)
6224               {
6225                 Elf_Internal_Vernaux *a;
6226
6227                 size += sizeof (Elf_External_Verneed);
6228                 ++crefs;
6229                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6230                   size += sizeof (Elf_External_Vernaux);
6231               }
6232
6233             s->size = size;
6234             s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6235             if (s->contents == NULL)
6236               return FALSE;
6237
6238             p = s->contents;
6239             for (t = elf_tdata (output_bfd)->verref;
6240                  t != NULL;
6241                  t = t->vn_nextref)
6242               {
6243                 unsigned int caux;
6244                 Elf_Internal_Vernaux *a;
6245                 bfd_size_type indx;
6246
6247                 caux = 0;
6248                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6249                   ++caux;
6250
6251                 t->vn_version = VER_NEED_CURRENT;
6252                 t->vn_cnt = caux;
6253                 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6254                                             elf_dt_name (t->vn_bfd) != NULL
6255                                             ? elf_dt_name (t->vn_bfd)
6256                                             : lbasename (t->vn_bfd->filename),
6257                                             FALSE);
6258                 if (indx == (bfd_size_type) -1)
6259                   return FALSE;
6260                 t->vn_file = indx;
6261                 t->vn_aux = sizeof (Elf_External_Verneed);
6262                 if (t->vn_nextref == NULL)
6263                   t->vn_next = 0;
6264                 else
6265                   t->vn_next = (sizeof (Elf_External_Verneed)
6266                                 + caux * sizeof (Elf_External_Vernaux));
6267
6268                 _bfd_elf_swap_verneed_out (output_bfd, t,
6269                                            (Elf_External_Verneed *) p);
6270                 p += sizeof (Elf_External_Verneed);
6271
6272                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6273                   {
6274                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
6275                     indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6276                                                 a->vna_nodename, FALSE);
6277                     if (indx == (bfd_size_type) -1)
6278                       return FALSE;
6279                     a->vna_name = indx;
6280                     if (a->vna_nextptr == NULL)
6281                       a->vna_next = 0;
6282                     else
6283                       a->vna_next = sizeof (Elf_External_Vernaux);
6284
6285                     _bfd_elf_swap_vernaux_out (output_bfd, a,
6286                                                (Elf_External_Vernaux *) p);
6287                     p += sizeof (Elf_External_Vernaux);
6288                   }
6289               }
6290
6291             if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6292                 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6293               return FALSE;
6294
6295             elf_tdata (output_bfd)->cverrefs = crefs;
6296           }
6297       }
6298
6299       if ((elf_tdata (output_bfd)->cverrefs == 0
6300            && elf_tdata (output_bfd)->cverdefs == 0)
6301           || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6302                                              &section_sym_count) == 0)
6303         {
6304           s = bfd_get_linker_section (dynobj, ".gnu.version");
6305           s->flags |= SEC_EXCLUDE;
6306         }
6307     }
6308   return TRUE;
6309 }
6310
6311 /* Find the first non-excluded output section.  We'll use its
6312    section symbol for some emitted relocs.  */
6313 void
6314 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6315 {
6316   asection *s;
6317
6318   for (s = output_bfd->sections; s != NULL; s = s->next)
6319     if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6320         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6321       {
6322         elf_hash_table (info)->text_index_section = s;
6323         break;
6324       }
6325 }
6326
6327 /* Find two non-excluded output sections, one for code, one for data.
6328    We'll use their section symbols for some emitted relocs.  */
6329 void
6330 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6331 {
6332   asection *s;
6333
6334   /* Data first, since setting text_index_section changes
6335      _bfd_elf_link_omit_section_dynsym.  */
6336   for (s = output_bfd->sections; s != NULL; s = s->next)
6337     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6338         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6339       {
6340         elf_hash_table (info)->data_index_section = s;
6341         break;
6342       }
6343
6344   for (s = output_bfd->sections; s != NULL; s = s->next)
6345     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6346          == (SEC_ALLOC | SEC_READONLY))
6347         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6348       {
6349         elf_hash_table (info)->text_index_section = s;
6350         break;
6351       }
6352
6353   if (elf_hash_table (info)->text_index_section == NULL)
6354     elf_hash_table (info)->text_index_section
6355       = elf_hash_table (info)->data_index_section;
6356 }
6357
6358 bfd_boolean
6359 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6360 {
6361   const struct elf_backend_data *bed;
6362
6363   if (!is_elf_hash_table (info->hash))
6364     return TRUE;
6365
6366   bed = get_elf_backend_data (output_bfd);
6367   (*bed->elf_backend_init_index_section) (output_bfd, info);
6368
6369   if (elf_hash_table (info)->dynamic_sections_created)
6370     {
6371       bfd *dynobj;
6372       asection *s;
6373       bfd_size_type dynsymcount;
6374       unsigned long section_sym_count;
6375       unsigned int dtagcount;
6376
6377       dynobj = elf_hash_table (info)->dynobj;
6378
6379       /* Assign dynsym indicies.  In a shared library we generate a
6380          section symbol for each output section, which come first.
6381          Next come all of the back-end allocated local dynamic syms,
6382          followed by the rest of the global symbols.  */
6383
6384       dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6385                                                     &section_sym_count);
6386
6387       /* Work out the size of the symbol version section.  */
6388       s = bfd_get_linker_section (dynobj, ".gnu.version");
6389       BFD_ASSERT (s != NULL);
6390       if (dynsymcount != 0
6391           && (s->flags & SEC_EXCLUDE) == 0)
6392         {
6393           s->size = dynsymcount * sizeof (Elf_External_Versym);
6394           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6395           if (s->contents == NULL)
6396             return FALSE;
6397
6398           if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6399             return FALSE;
6400         }
6401
6402       /* Set the size of the .dynsym and .hash sections.  We counted
6403          the number of dynamic symbols in elf_link_add_object_symbols.
6404          We will build the contents of .dynsym and .hash when we build
6405          the final symbol table, because until then we do not know the
6406          correct value to give the symbols.  We built the .dynstr
6407          section as we went along in elf_link_add_object_symbols.  */
6408       s = bfd_get_linker_section (dynobj, ".dynsym");
6409       BFD_ASSERT (s != NULL);
6410       s->size = dynsymcount * bed->s->sizeof_sym;
6411
6412       if (dynsymcount != 0)
6413         {
6414           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6415           if (s->contents == NULL)
6416             return FALSE;
6417
6418           /* The first entry in .dynsym is a dummy symbol.
6419              Clear all the section syms, in case we don't output them all.  */
6420           ++section_sym_count;
6421           memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6422         }
6423
6424       elf_hash_table (info)->bucketcount = 0;
6425
6426       /* Compute the size of the hashing table.  As a side effect this
6427          computes the hash values for all the names we export.  */
6428       if (info->emit_hash)
6429         {
6430           unsigned long int *hashcodes;
6431           struct hash_codes_info hashinf;
6432           bfd_size_type amt;
6433           unsigned long int nsyms;
6434           size_t bucketcount;
6435           size_t hash_entry_size;
6436
6437           /* Compute the hash values for all exported symbols.  At the same
6438              time store the values in an array so that we could use them for
6439              optimizations.  */
6440           amt = dynsymcount * sizeof (unsigned long int);
6441           hashcodes = (unsigned long int *) bfd_malloc (amt);
6442           if (hashcodes == NULL)
6443             return FALSE;
6444           hashinf.hashcodes = hashcodes;
6445           hashinf.error = FALSE;
6446
6447           /* Put all hash values in HASHCODES.  */
6448           elf_link_hash_traverse (elf_hash_table (info),
6449                                   elf_collect_hash_codes, &hashinf);
6450           if (hashinf.error)
6451             {
6452               free (hashcodes);
6453               return FALSE;
6454             }
6455
6456           nsyms = hashinf.hashcodes - hashcodes;
6457           bucketcount
6458             = compute_bucket_count (info, hashcodes, nsyms, 0);
6459           free (hashcodes);
6460
6461           if (bucketcount == 0)
6462             return FALSE;
6463
6464           elf_hash_table (info)->bucketcount = bucketcount;
6465
6466           s = bfd_get_linker_section (dynobj, ".hash");
6467           BFD_ASSERT (s != NULL);
6468           hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6469           s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6470           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6471           if (s->contents == NULL)
6472             return FALSE;
6473
6474           bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6475           bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6476                    s->contents + hash_entry_size);
6477         }
6478
6479       if (info->emit_gnu_hash)
6480         {
6481           size_t i, cnt;
6482           unsigned char *contents;
6483           struct collect_gnu_hash_codes cinfo;
6484           bfd_size_type amt;
6485           size_t bucketcount;
6486
6487           memset (&cinfo, 0, sizeof (cinfo));
6488
6489           /* Compute the hash values for all exported symbols.  At the same
6490              time store the values in an array so that we could use them for
6491              optimizations.  */
6492           amt = dynsymcount * 2 * sizeof (unsigned long int);
6493           cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6494           if (cinfo.hashcodes == NULL)
6495             return FALSE;
6496
6497           cinfo.hashval = cinfo.hashcodes + dynsymcount;
6498           cinfo.min_dynindx = -1;
6499           cinfo.output_bfd = output_bfd;
6500           cinfo.bed = bed;
6501
6502           /* Put all hash values in HASHCODES.  */
6503           elf_link_hash_traverse (elf_hash_table (info),
6504                                   elf_collect_gnu_hash_codes, &cinfo);
6505           if (cinfo.error)
6506             {
6507               free (cinfo.hashcodes);
6508               return FALSE;
6509             }
6510
6511           bucketcount
6512             = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6513
6514           if (bucketcount == 0)
6515             {
6516               free (cinfo.hashcodes);
6517               return FALSE;
6518             }
6519
6520           s = bfd_get_linker_section (dynobj, ".gnu.hash");
6521           BFD_ASSERT (s != NULL);
6522
6523           if (cinfo.nsyms == 0)
6524             {
6525               /* Empty .gnu.hash section is special.  */
6526               BFD_ASSERT (cinfo.min_dynindx == -1);
6527               free (cinfo.hashcodes);
6528               s->size = 5 * 4 + bed->s->arch_size / 8;
6529               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6530               if (contents == NULL)
6531                 return FALSE;
6532               s->contents = contents;
6533               /* 1 empty bucket.  */
6534               bfd_put_32 (output_bfd, 1, contents);
6535               /* SYMIDX above the special symbol 0.  */
6536               bfd_put_32 (output_bfd, 1, contents + 4);
6537               /* Just one word for bitmask.  */
6538               bfd_put_32 (output_bfd, 1, contents + 8);
6539               /* Only hash fn bloom filter.  */
6540               bfd_put_32 (output_bfd, 0, contents + 12);
6541               /* No hashes are valid - empty bitmask.  */
6542               bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6543               /* No hashes in the only bucket.  */
6544               bfd_put_32 (output_bfd, 0,
6545                           contents + 16 + bed->s->arch_size / 8);
6546             }
6547           else
6548             {
6549               unsigned long int maskwords, maskbitslog2, x;
6550               BFD_ASSERT (cinfo.min_dynindx != -1);
6551
6552               x = cinfo.nsyms;
6553               maskbitslog2 = 1;
6554               while ((x >>= 1) != 0)
6555                 ++maskbitslog2;
6556               if (maskbitslog2 < 3)
6557                 maskbitslog2 = 5;
6558               else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6559                 maskbitslog2 = maskbitslog2 + 3;
6560               else
6561                 maskbitslog2 = maskbitslog2 + 2;
6562               if (bed->s->arch_size == 64)
6563                 {
6564                   if (maskbitslog2 == 5)
6565                     maskbitslog2 = 6;
6566                   cinfo.shift1 = 6;
6567                 }
6568               else
6569                 cinfo.shift1 = 5;
6570               cinfo.mask = (1 << cinfo.shift1) - 1;
6571               cinfo.shift2 = maskbitslog2;
6572               cinfo.maskbits = 1 << maskbitslog2;
6573               maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6574               amt = bucketcount * sizeof (unsigned long int) * 2;
6575               amt += maskwords * sizeof (bfd_vma);
6576               cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6577               if (cinfo.bitmask == NULL)
6578                 {
6579                   free (cinfo.hashcodes);
6580                   return FALSE;
6581                 }
6582
6583               cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6584               cinfo.indx = cinfo.counts + bucketcount;
6585               cinfo.symindx = dynsymcount - cinfo.nsyms;
6586               memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6587
6588               /* Determine how often each hash bucket is used.  */
6589               memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6590               for (i = 0; i < cinfo.nsyms; ++i)
6591                 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6592
6593               for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6594                 if (cinfo.counts[i] != 0)
6595                   {
6596                     cinfo.indx[i] = cnt;
6597                     cnt += cinfo.counts[i];
6598                   }
6599               BFD_ASSERT (cnt == dynsymcount);
6600               cinfo.bucketcount = bucketcount;
6601               cinfo.local_indx = cinfo.min_dynindx;
6602
6603               s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6604               s->size += cinfo.maskbits / 8;
6605               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6606               if (contents == NULL)
6607                 {
6608                   free (cinfo.bitmask);
6609                   free (cinfo.hashcodes);
6610                   return FALSE;
6611                 }
6612
6613               s->contents = contents;
6614               bfd_put_32 (output_bfd, bucketcount, contents);
6615               bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6616               bfd_put_32 (output_bfd, maskwords, contents + 8);
6617               bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6618               contents += 16 + cinfo.maskbits / 8;
6619
6620               for (i = 0; i < bucketcount; ++i)
6621                 {
6622                   if (cinfo.counts[i] == 0)
6623                     bfd_put_32 (output_bfd, 0, contents);
6624                   else
6625                     bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6626                   contents += 4;
6627                 }
6628
6629               cinfo.contents = contents;
6630
6631               /* Renumber dynamic symbols, populate .gnu.hash section.  */
6632               elf_link_hash_traverse (elf_hash_table (info),
6633                                       elf_renumber_gnu_hash_syms, &cinfo);
6634
6635               contents = s->contents + 16;
6636               for (i = 0; i < maskwords; ++i)
6637                 {
6638                   bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6639                            contents);
6640                   contents += bed->s->arch_size / 8;
6641                 }
6642
6643               free (cinfo.bitmask);
6644               free (cinfo.hashcodes);
6645             }
6646         }
6647
6648       s = bfd_get_linker_section (dynobj, ".dynstr");
6649       BFD_ASSERT (s != NULL);
6650
6651       elf_finalize_dynstr (output_bfd, info);
6652
6653       s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6654
6655       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6656         if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6657           return FALSE;
6658     }
6659
6660   return TRUE;
6661 }
6662 \f
6663 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
6664
6665 static void
6666 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6667                             asection *sec)
6668 {
6669   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
6670   sec->sec_info_type = SEC_INFO_TYPE_NONE;
6671 }
6672
6673 /* Finish SHF_MERGE section merging.  */
6674
6675 bfd_boolean
6676 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6677 {
6678   bfd *ibfd;
6679   asection *sec;
6680
6681   if (!is_elf_hash_table (info->hash))
6682     return FALSE;
6683
6684   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6685     if ((ibfd->flags & DYNAMIC) == 0)
6686       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6687         if ((sec->flags & SEC_MERGE) != 0
6688             && !bfd_is_abs_section (sec->output_section))
6689           {
6690             struct bfd_elf_section_data *secdata;
6691
6692             secdata = elf_section_data (sec);
6693             if (! _bfd_add_merge_section (abfd,
6694                                           &elf_hash_table (info)->merge_info,
6695                                           sec, &secdata->sec_info))
6696               return FALSE;
6697             else if (secdata->sec_info)
6698               sec->sec_info_type = SEC_INFO_TYPE_MERGE;
6699           }
6700
6701   if (elf_hash_table (info)->merge_info != NULL)
6702     _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6703                          merge_sections_remove_hook);
6704   return TRUE;
6705 }
6706
6707 /* Create an entry in an ELF linker hash table.  */
6708
6709 struct bfd_hash_entry *
6710 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6711                             struct bfd_hash_table *table,
6712                             const char *string)
6713 {
6714   /* Allocate the structure if it has not already been allocated by a
6715      subclass.  */
6716   if (entry == NULL)
6717     {
6718       entry = (struct bfd_hash_entry *)
6719           bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6720       if (entry == NULL)
6721         return entry;
6722     }
6723
6724   /* Call the allocation method of the superclass.  */
6725   entry = _bfd_link_hash_newfunc (entry, table, string);
6726   if (entry != NULL)
6727     {
6728       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6729       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6730
6731       /* Set local fields.  */
6732       ret->indx = -1;
6733       ret->dynindx = -1;
6734       ret->got = htab->init_got_refcount;
6735       ret->plt = htab->init_plt_refcount;
6736       memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6737                               - offsetof (struct elf_link_hash_entry, size)));
6738       /* Assume that we have been called by a non-ELF symbol reader.
6739          This flag is then reset by the code which reads an ELF input
6740          file.  This ensures that a symbol created by a non-ELF symbol
6741          reader will have the flag set correctly.  */
6742       ret->non_elf = 1;
6743     }
6744
6745   return entry;
6746 }
6747
6748 /* Copy data from an indirect symbol to its direct symbol, hiding the
6749    old indirect symbol.  Also used for copying flags to a weakdef.  */
6750
6751 void
6752 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6753                                   struct elf_link_hash_entry *dir,
6754                                   struct elf_link_hash_entry *ind)
6755 {
6756   struct elf_link_hash_table *htab;
6757
6758   /* Copy down any references that we may have already seen to the
6759      symbol which just became indirect.  */
6760
6761   dir->ref_dynamic |= ind->ref_dynamic;
6762   dir->ref_regular |= ind->ref_regular;
6763   dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6764   dir->non_got_ref |= ind->non_got_ref;
6765   dir->needs_plt |= ind->needs_plt;
6766   dir->pointer_equality_needed |= ind->pointer_equality_needed;
6767
6768   if (ind->root.type != bfd_link_hash_indirect)
6769     return;
6770
6771   /* Copy over the global and procedure linkage table refcount entries.
6772      These may have been already set up by a check_relocs routine.  */
6773   htab = elf_hash_table (info);
6774   if (ind->got.refcount > htab->init_got_refcount.refcount)
6775     {
6776       if (dir->got.refcount < 0)
6777         dir->got.refcount = 0;
6778       dir->got.refcount += ind->got.refcount;
6779       ind->got.refcount = htab->init_got_refcount.refcount;
6780     }
6781
6782   if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6783     {
6784       if (dir->plt.refcount < 0)
6785         dir->plt.refcount = 0;
6786       dir->plt.refcount += ind->plt.refcount;
6787       ind->plt.refcount = htab->init_plt_refcount.refcount;
6788     }
6789
6790   if (ind->dynindx != -1)
6791     {
6792       if (dir->dynindx != -1)
6793         _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6794       dir->dynindx = ind->dynindx;
6795       dir->dynstr_index = ind->dynstr_index;
6796       ind->dynindx = -1;
6797       ind->dynstr_index = 0;
6798     }
6799 }
6800
6801 void
6802 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6803                                 struct elf_link_hash_entry *h,
6804                                 bfd_boolean force_local)
6805 {
6806   /* STT_GNU_IFUNC symbol must go through PLT.  */
6807   if (h->type != STT_GNU_IFUNC)
6808     {
6809       h->plt = elf_hash_table (info)->init_plt_offset;
6810       h->needs_plt = 0;
6811     }
6812   if (force_local)
6813     {
6814       h->forced_local = 1;
6815       if (h->dynindx != -1)
6816         {
6817           h->dynindx = -1;
6818           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6819                                   h->dynstr_index);
6820         }
6821     }
6822 }
6823
6824 /* Initialize an ELF linker hash table.  *TABLE has been zeroed by our
6825    caller.  */
6826
6827 bfd_boolean
6828 _bfd_elf_link_hash_table_init
6829   (struct elf_link_hash_table *table,
6830    bfd *abfd,
6831    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6832                                       struct bfd_hash_table *,
6833                                       const char *),
6834    unsigned int entsize,
6835    enum elf_target_id target_id)
6836 {
6837   bfd_boolean ret;
6838   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6839
6840   table->init_got_refcount.refcount = can_refcount - 1;
6841   table->init_plt_refcount.refcount = can_refcount - 1;
6842   table->init_got_offset.offset = -(bfd_vma) 1;
6843   table->init_plt_offset.offset = -(bfd_vma) 1;
6844   /* The first dynamic symbol is a dummy.  */
6845   table->dynsymcount = 1;
6846
6847   ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6848
6849   table->root.type = bfd_link_elf_hash_table;
6850   table->hash_table_id = target_id;
6851
6852   return ret;
6853 }
6854
6855 /* Create an ELF linker hash table.  */
6856
6857 struct bfd_link_hash_table *
6858 _bfd_elf_link_hash_table_create (bfd *abfd)
6859 {
6860   struct elf_link_hash_table *ret;
6861   bfd_size_type amt = sizeof (struct elf_link_hash_table);
6862
6863   ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
6864   if (ret == NULL)
6865     return NULL;
6866
6867   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6868                                        sizeof (struct elf_link_hash_entry),
6869                                        GENERIC_ELF_DATA))
6870     {
6871       free (ret);
6872       return NULL;
6873     }
6874   ret->root.hash_table_free = _bfd_elf_link_hash_table_free;
6875
6876   return &ret->root;
6877 }
6878
6879 /* Destroy an ELF linker hash table.  */
6880
6881 void
6882 _bfd_elf_link_hash_table_free (bfd *obfd)
6883 {
6884   struct elf_link_hash_table *htab;
6885
6886   htab = (struct elf_link_hash_table *) obfd->link.hash;
6887   if (htab->dynstr != NULL)
6888     _bfd_elf_strtab_free (htab->dynstr);
6889   _bfd_merge_sections_free (htab->merge_info);
6890   _bfd_generic_link_hash_table_free (obfd);
6891 }
6892
6893 /* This is a hook for the ELF emulation code in the generic linker to
6894    tell the backend linker what file name to use for the DT_NEEDED
6895    entry for a dynamic object.  */
6896
6897 void
6898 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6899 {
6900   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6901       && bfd_get_format (abfd) == bfd_object)
6902     elf_dt_name (abfd) = name;
6903 }
6904
6905 int
6906 bfd_elf_get_dyn_lib_class (bfd *abfd)
6907 {
6908   int lib_class;
6909   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6910       && bfd_get_format (abfd) == bfd_object)
6911     lib_class = elf_dyn_lib_class (abfd);
6912   else
6913     lib_class = 0;
6914   return lib_class;
6915 }
6916
6917 void
6918 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6919 {
6920   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6921       && bfd_get_format (abfd) == bfd_object)
6922     elf_dyn_lib_class (abfd) = lib_class;
6923 }
6924
6925 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
6926    the linker ELF emulation code.  */
6927
6928 struct bfd_link_needed_list *
6929 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6930                          struct bfd_link_info *info)
6931 {
6932   if (! is_elf_hash_table (info->hash))
6933     return NULL;
6934   return elf_hash_table (info)->needed;
6935 }
6936
6937 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
6938    hook for the linker ELF emulation code.  */
6939
6940 struct bfd_link_needed_list *
6941 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6942                           struct bfd_link_info *info)
6943 {
6944   if (! is_elf_hash_table (info->hash))
6945     return NULL;
6946   return elf_hash_table (info)->runpath;
6947 }
6948
6949 /* Get the name actually used for a dynamic object for a link.  This
6950    is the SONAME entry if there is one.  Otherwise, it is the string
6951    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
6952
6953 const char *
6954 bfd_elf_get_dt_soname (bfd *abfd)
6955 {
6956   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6957       && bfd_get_format (abfd) == bfd_object)
6958     return elf_dt_name (abfd);
6959   return NULL;
6960 }
6961
6962 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
6963    the ELF linker emulation code.  */
6964
6965 bfd_boolean
6966 bfd_elf_get_bfd_needed_list (bfd *abfd,
6967                              struct bfd_link_needed_list **pneeded)
6968 {
6969   asection *s;
6970   bfd_byte *dynbuf = NULL;
6971   unsigned int elfsec;
6972   unsigned long shlink;
6973   bfd_byte *extdyn, *extdynend;
6974   size_t extdynsize;
6975   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6976
6977   *pneeded = NULL;
6978
6979   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6980       || bfd_get_format (abfd) != bfd_object)
6981     return TRUE;
6982
6983   s = bfd_get_section_by_name (abfd, ".dynamic");
6984   if (s == NULL || s->size == 0)
6985     return TRUE;
6986
6987   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6988     goto error_return;
6989
6990   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
6991   if (elfsec == SHN_BAD)
6992     goto error_return;
6993
6994   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
6995
6996   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6997   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6998
6999   extdyn = dynbuf;
7000   extdynend = extdyn + s->size;
7001   for (; extdyn < extdynend; extdyn += extdynsize)
7002     {
7003       Elf_Internal_Dyn dyn;
7004
7005       (*swap_dyn_in) (abfd, extdyn, &dyn);
7006
7007       if (dyn.d_tag == DT_NULL)
7008         break;
7009
7010       if (dyn.d_tag == DT_NEEDED)
7011         {
7012           const char *string;
7013           struct bfd_link_needed_list *l;
7014           unsigned int tagv = dyn.d_un.d_val;
7015           bfd_size_type amt;
7016
7017           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
7018           if (string == NULL)
7019             goto error_return;
7020
7021           amt = sizeof *l;
7022           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7023           if (l == NULL)
7024             goto error_return;
7025
7026           l->by = abfd;
7027           l->name = string;
7028           l->next = *pneeded;
7029           *pneeded = l;
7030         }
7031     }
7032
7033   free (dynbuf);
7034
7035   return TRUE;
7036
7037  error_return:
7038   if (dynbuf != NULL)
7039     free (dynbuf);
7040   return FALSE;
7041 }
7042
7043 struct elf_symbuf_symbol
7044 {
7045   unsigned long st_name;        /* Symbol name, index in string tbl */
7046   unsigned char st_info;        /* Type and binding attributes */
7047   unsigned char st_other;       /* Visibilty, and target specific */
7048 };
7049
7050 struct elf_symbuf_head
7051 {
7052   struct elf_symbuf_symbol *ssym;
7053   bfd_size_type count;
7054   unsigned int st_shndx;
7055 };
7056
7057 struct elf_symbol
7058 {
7059   union
7060     {
7061       Elf_Internal_Sym *isym;
7062       struct elf_symbuf_symbol *ssym;
7063     } u;
7064   const char *name;
7065 };
7066
7067 /* Sort references to symbols by ascending section number.  */
7068
7069 static int
7070 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7071 {
7072   const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7073   const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7074
7075   return s1->st_shndx - s2->st_shndx;
7076 }
7077
7078 static int
7079 elf_sym_name_compare (const void *arg1, const void *arg2)
7080 {
7081   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7082   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7083   return strcmp (s1->name, s2->name);
7084 }
7085
7086 static struct elf_symbuf_head *
7087 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7088 {
7089   Elf_Internal_Sym **ind, **indbufend, **indbuf;
7090   struct elf_symbuf_symbol *ssym;
7091   struct elf_symbuf_head *ssymbuf, *ssymhead;
7092   bfd_size_type i, shndx_count, total_size;
7093
7094   indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7095   if (indbuf == NULL)
7096     return NULL;
7097
7098   for (ind = indbuf, i = 0; i < symcount; i++)
7099     if (isymbuf[i].st_shndx != SHN_UNDEF)
7100       *ind++ = &isymbuf[i];
7101   indbufend = ind;
7102
7103   qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7104          elf_sort_elf_symbol);
7105
7106   shndx_count = 0;
7107   if (indbufend > indbuf)
7108     for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7109       if (ind[0]->st_shndx != ind[1]->st_shndx)
7110         shndx_count++;
7111
7112   total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7113                 + (indbufend - indbuf) * sizeof (*ssym));
7114   ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7115   if (ssymbuf == NULL)
7116     {
7117       free (indbuf);
7118       return NULL;
7119     }
7120
7121   ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7122   ssymbuf->ssym = NULL;
7123   ssymbuf->count = shndx_count;
7124   ssymbuf->st_shndx = 0;
7125   for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7126     {
7127       if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7128         {
7129           ssymhead++;
7130           ssymhead->ssym = ssym;
7131           ssymhead->count = 0;
7132           ssymhead->st_shndx = (*ind)->st_shndx;
7133         }
7134       ssym->st_name = (*ind)->st_name;
7135       ssym->st_info = (*ind)->st_info;
7136       ssym->st_other = (*ind)->st_other;
7137       ssymhead->count++;
7138     }
7139   BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7140               && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7141                   == total_size));
7142
7143   free (indbuf);
7144   return ssymbuf;
7145 }
7146
7147 /* Check if 2 sections define the same set of local and global
7148    symbols.  */
7149
7150 static bfd_boolean
7151 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7152                                    struct bfd_link_info *info)
7153 {
7154   bfd *bfd1, *bfd2;
7155   const struct elf_backend_data *bed1, *bed2;
7156   Elf_Internal_Shdr *hdr1, *hdr2;
7157   bfd_size_type symcount1, symcount2;
7158   Elf_Internal_Sym *isymbuf1, *isymbuf2;
7159   struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7160   Elf_Internal_Sym *isym, *isymend;
7161   struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7162   bfd_size_type count1, count2, i;
7163   unsigned int shndx1, shndx2;
7164   bfd_boolean result;
7165
7166   bfd1 = sec1->owner;
7167   bfd2 = sec2->owner;
7168
7169   /* Both sections have to be in ELF.  */
7170   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7171       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7172     return FALSE;
7173
7174   if (elf_section_type (sec1) != elf_section_type (sec2))
7175     return FALSE;
7176
7177   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7178   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7179   if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7180     return FALSE;
7181
7182   bed1 = get_elf_backend_data (bfd1);
7183   bed2 = get_elf_backend_data (bfd2);
7184   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7185   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7186   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7187   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7188
7189   if (symcount1 == 0 || symcount2 == 0)
7190     return FALSE;
7191
7192   result = FALSE;
7193   isymbuf1 = NULL;
7194   isymbuf2 = NULL;
7195   ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7196   ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7197
7198   if (ssymbuf1 == NULL)
7199     {
7200       isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7201                                        NULL, NULL, NULL);
7202       if (isymbuf1 == NULL)
7203         goto done;
7204
7205       if (!info->reduce_memory_overheads)
7206         elf_tdata (bfd1)->symbuf = ssymbuf1
7207           = elf_create_symbuf (symcount1, isymbuf1);
7208     }
7209
7210   if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7211     {
7212       isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7213                                        NULL, NULL, NULL);
7214       if (isymbuf2 == NULL)
7215         goto done;
7216
7217       if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7218         elf_tdata (bfd2)->symbuf = ssymbuf2
7219           = elf_create_symbuf (symcount2, isymbuf2);
7220     }
7221
7222   if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7223     {
7224       /* Optimized faster version.  */
7225       bfd_size_type lo, hi, mid;
7226       struct elf_symbol *symp;
7227       struct elf_symbuf_symbol *ssym, *ssymend;
7228
7229       lo = 0;
7230       hi = ssymbuf1->count;
7231       ssymbuf1++;
7232       count1 = 0;
7233       while (lo < hi)
7234         {
7235           mid = (lo + hi) / 2;
7236           if (shndx1 < ssymbuf1[mid].st_shndx)
7237             hi = mid;
7238           else if (shndx1 > ssymbuf1[mid].st_shndx)
7239             lo = mid + 1;
7240           else
7241             {
7242               count1 = ssymbuf1[mid].count;
7243               ssymbuf1 += mid;
7244               break;
7245             }
7246         }
7247
7248       lo = 0;
7249       hi = ssymbuf2->count;
7250       ssymbuf2++;
7251       count2 = 0;
7252       while (lo < hi)
7253         {
7254           mid = (lo + hi) / 2;
7255           if (shndx2 < ssymbuf2[mid].st_shndx)
7256             hi = mid;
7257           else if (shndx2 > ssymbuf2[mid].st_shndx)
7258             lo = mid + 1;
7259           else
7260             {
7261               count2 = ssymbuf2[mid].count;
7262               ssymbuf2 += mid;
7263               break;
7264             }
7265         }
7266
7267       if (count1 == 0 || count2 == 0 || count1 != count2)
7268         goto done;
7269
7270       symtable1 = (struct elf_symbol *)
7271           bfd_malloc (count1 * sizeof (struct elf_symbol));
7272       symtable2 = (struct elf_symbol *)
7273           bfd_malloc (count2 * sizeof (struct elf_symbol));
7274       if (symtable1 == NULL || symtable2 == NULL)
7275         goto done;
7276
7277       symp = symtable1;
7278       for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7279            ssym < ssymend; ssym++, symp++)
7280         {
7281           symp->u.ssym = ssym;
7282           symp->name = bfd_elf_string_from_elf_section (bfd1,
7283                                                         hdr1->sh_link,
7284                                                         ssym->st_name);
7285         }
7286
7287       symp = symtable2;
7288       for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7289            ssym < ssymend; ssym++, symp++)
7290         {
7291           symp->u.ssym = ssym;
7292           symp->name = bfd_elf_string_from_elf_section (bfd2,
7293                                                         hdr2->sh_link,
7294                                                         ssym->st_name);
7295         }
7296
7297       /* Sort symbol by name.  */
7298       qsort (symtable1, count1, sizeof (struct elf_symbol),
7299              elf_sym_name_compare);
7300       qsort (symtable2, count1, sizeof (struct elf_symbol),
7301              elf_sym_name_compare);
7302
7303       for (i = 0; i < count1; i++)
7304         /* Two symbols must have the same binding, type and name.  */
7305         if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7306             || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7307             || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7308           goto done;
7309
7310       result = TRUE;
7311       goto done;
7312     }
7313
7314   symtable1 = (struct elf_symbol *)
7315       bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7316   symtable2 = (struct elf_symbol *)
7317       bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7318   if (symtable1 == NULL || symtable2 == NULL)
7319     goto done;
7320
7321   /* Count definitions in the section.  */
7322   count1 = 0;
7323   for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7324     if (isym->st_shndx == shndx1)
7325       symtable1[count1++].u.isym = isym;
7326
7327   count2 = 0;
7328   for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7329     if (isym->st_shndx == shndx2)
7330       symtable2[count2++].u.isym = isym;
7331
7332   if (count1 == 0 || count2 == 0 || count1 != count2)
7333     goto done;
7334
7335   for (i = 0; i < count1; i++)
7336     symtable1[i].name
7337       = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7338                                          symtable1[i].u.isym->st_name);
7339
7340   for (i = 0; i < count2; i++)
7341     symtable2[i].name
7342       = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7343                                          symtable2[i].u.isym->st_name);
7344
7345   /* Sort symbol by name.  */
7346   qsort (symtable1, count1, sizeof (struct elf_symbol),
7347          elf_sym_name_compare);
7348   qsort (symtable2, count1, sizeof (struct elf_symbol),
7349          elf_sym_name_compare);
7350
7351   for (i = 0; i < count1; i++)
7352     /* Two symbols must have the same binding, type and name.  */
7353     if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7354         || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7355         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7356       goto done;
7357
7358   result = TRUE;
7359
7360 done:
7361   if (symtable1)
7362     free (symtable1);
7363   if (symtable2)
7364     free (symtable2);
7365   if (isymbuf1)
7366     free (isymbuf1);
7367   if (isymbuf2)
7368     free (isymbuf2);
7369
7370   return result;
7371 }
7372
7373 /* Return TRUE if 2 section types are compatible.  */
7374
7375 bfd_boolean
7376 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7377                                  bfd *bbfd, const asection *bsec)
7378 {
7379   if (asec == NULL
7380       || bsec == NULL
7381       || abfd->xvec->flavour != bfd_target_elf_flavour
7382       || bbfd->xvec->flavour != bfd_target_elf_flavour)
7383     return TRUE;
7384
7385   return elf_section_type (asec) == elf_section_type (bsec);
7386 }
7387 \f
7388 /* Final phase of ELF linker.  */
7389
7390 /* A structure we use to avoid passing large numbers of arguments.  */
7391
7392 struct elf_final_link_info
7393 {
7394   /* General link information.  */
7395   struct bfd_link_info *info;
7396   /* Output BFD.  */
7397   bfd *output_bfd;
7398   /* Symbol string table.  */
7399   struct bfd_strtab_hash *symstrtab;
7400   /* .dynsym section.  */
7401   asection *dynsym_sec;
7402   /* .hash section.  */
7403   asection *hash_sec;
7404   /* symbol version section (.gnu.version).  */
7405   asection *symver_sec;
7406   /* Buffer large enough to hold contents of any section.  */
7407   bfd_byte *contents;
7408   /* Buffer large enough to hold external relocs of any section.  */
7409   void *external_relocs;
7410   /* Buffer large enough to hold internal relocs of any section.  */
7411   Elf_Internal_Rela *internal_relocs;
7412   /* Buffer large enough to hold external local symbols of any input
7413      BFD.  */
7414   bfd_byte *external_syms;
7415   /* And a buffer for symbol section indices.  */
7416   Elf_External_Sym_Shndx *locsym_shndx;
7417   /* Buffer large enough to hold internal local symbols of any input
7418      BFD.  */
7419   Elf_Internal_Sym *internal_syms;
7420   /* Array large enough to hold a symbol index for each local symbol
7421      of any input BFD.  */
7422   long *indices;
7423   /* Array large enough to hold a section pointer for each local
7424      symbol of any input BFD.  */
7425   asection **sections;
7426   /* Buffer to hold swapped out symbols.  */
7427   bfd_byte *symbuf;
7428   /* And one for symbol section indices.  */
7429   Elf_External_Sym_Shndx *symshndxbuf;
7430   /* Number of swapped out symbols in buffer.  */
7431   size_t symbuf_count;
7432   /* Number of symbols which fit in symbuf.  */
7433   size_t symbuf_size;
7434   /* And same for symshndxbuf.  */
7435   size_t shndxbuf_size;
7436   /* Number of STT_FILE syms seen.  */
7437   size_t filesym_count;
7438 };
7439
7440 /* This struct is used to pass information to elf_link_output_extsym.  */
7441
7442 struct elf_outext_info
7443 {
7444   bfd_boolean failed;
7445   bfd_boolean localsyms;
7446   bfd_boolean need_second_pass;
7447   bfd_boolean second_pass;
7448   bfd_boolean file_sym_done;
7449   struct elf_final_link_info *flinfo;
7450 };
7451
7452
7453 /* Support for evaluating a complex relocation.
7454
7455    Complex relocations are generalized, self-describing relocations.  The
7456    implementation of them consists of two parts: complex symbols, and the
7457    relocations themselves.
7458
7459    The relocations are use a reserved elf-wide relocation type code (R_RELC
7460    external / BFD_RELOC_RELC internal) and an encoding of relocation field
7461    information (start bit, end bit, word width, etc) into the addend.  This
7462    information is extracted from CGEN-generated operand tables within gas.
7463
7464    Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7465    internal) representing prefix-notation expressions, including but not
7466    limited to those sorts of expressions normally encoded as addends in the
7467    addend field.  The symbol mangling format is:
7468
7469    <node> := <literal>
7470           |  <unary-operator> ':' <node>
7471           |  <binary-operator> ':' <node> ':' <node>
7472           ;
7473
7474    <literal> := 's' <digits=N> ':' <N character symbol name>
7475              |  'S' <digits=N> ':' <N character section name>
7476              |  '#' <hexdigits>
7477              ;
7478
7479    <binary-operator> := as in C
7480    <unary-operator> := as in C, plus "0-" for unambiguous negation.  */
7481
7482 static void
7483 set_symbol_value (bfd *bfd_with_globals,
7484                   Elf_Internal_Sym *isymbuf,
7485                   size_t locsymcount,
7486                   size_t symidx,
7487                   bfd_vma val)
7488 {
7489   struct elf_link_hash_entry **sym_hashes;
7490   struct elf_link_hash_entry *h;
7491   size_t extsymoff = locsymcount;
7492
7493   if (symidx < locsymcount)
7494     {
7495       Elf_Internal_Sym *sym;
7496
7497       sym = isymbuf + symidx;
7498       if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7499         {
7500           /* It is a local symbol: move it to the
7501              "absolute" section and give it a value.  */
7502           sym->st_shndx = SHN_ABS;
7503           sym->st_value = val;
7504           return;
7505         }
7506       BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7507       extsymoff = 0;
7508     }
7509
7510   /* It is a global symbol: set its link type
7511      to "defined" and give it a value.  */
7512
7513   sym_hashes = elf_sym_hashes (bfd_with_globals);
7514   h = sym_hashes [symidx - extsymoff];
7515   while (h->root.type == bfd_link_hash_indirect
7516          || h->root.type == bfd_link_hash_warning)
7517     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7518   h->root.type = bfd_link_hash_defined;
7519   h->root.u.def.value = val;
7520   h->root.u.def.section = bfd_abs_section_ptr;
7521 }
7522
7523 static bfd_boolean
7524 resolve_symbol (const char *name,
7525                 bfd *input_bfd,
7526                 struct elf_final_link_info *flinfo,
7527                 bfd_vma *result,
7528                 Elf_Internal_Sym *isymbuf,
7529                 size_t locsymcount)
7530 {
7531   Elf_Internal_Sym *sym;
7532   struct bfd_link_hash_entry *global_entry;
7533   const char *candidate = NULL;
7534   Elf_Internal_Shdr *symtab_hdr;
7535   size_t i;
7536
7537   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7538
7539   for (i = 0; i < locsymcount; ++ i)
7540     {
7541       sym = isymbuf + i;
7542
7543       if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7544         continue;
7545
7546       candidate = bfd_elf_string_from_elf_section (input_bfd,
7547                                                    symtab_hdr->sh_link,
7548                                                    sym->st_name);
7549 #ifdef DEBUG
7550       printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7551               name, candidate, (unsigned long) sym->st_value);
7552 #endif
7553       if (candidate && strcmp (candidate, name) == 0)
7554         {
7555           asection *sec = flinfo->sections [i];
7556
7557           *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7558           *result += sec->output_offset + sec->output_section->vma;
7559 #ifdef DEBUG
7560           printf ("Found symbol with value %8.8lx\n",
7561                   (unsigned long) *result);
7562 #endif
7563           return TRUE;
7564         }
7565     }
7566
7567   /* Hmm, haven't found it yet. perhaps it is a global.  */
7568   global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
7569                                        FALSE, FALSE, TRUE);
7570   if (!global_entry)
7571     return FALSE;
7572
7573   if (global_entry->type == bfd_link_hash_defined
7574       || global_entry->type == bfd_link_hash_defweak)
7575     {
7576       *result = (global_entry->u.def.value
7577                  + global_entry->u.def.section->output_section->vma
7578                  + global_entry->u.def.section->output_offset);
7579 #ifdef DEBUG
7580       printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7581               global_entry->root.string, (unsigned long) *result);
7582 #endif
7583       return TRUE;
7584     }
7585
7586   return FALSE;
7587 }
7588
7589 static bfd_boolean
7590 resolve_section (const char *name,
7591                  asection *sections,
7592                  bfd_vma *result)
7593 {
7594   asection *curr;
7595   unsigned int len;
7596
7597   for (curr = sections; curr; curr = curr->next)
7598     if (strcmp (curr->name, name) == 0)
7599       {
7600         *result = curr->vma;
7601         return TRUE;
7602       }
7603
7604   /* Hmm. still haven't found it. try pseudo-section names.  */
7605   for (curr = sections; curr; curr = curr->next)
7606     {
7607       len = strlen (curr->name);
7608       if (len > strlen (name))
7609         continue;
7610
7611       if (strncmp (curr->name, name, len) == 0)
7612         {
7613           if (strncmp (".end", name + len, 4) == 0)
7614             {
7615               *result = curr->vma + curr->size;
7616               return TRUE;
7617             }
7618
7619           /* Insert more pseudo-section names here, if you like.  */
7620         }
7621     }
7622
7623   return FALSE;
7624 }
7625
7626 static void
7627 undefined_reference (const char *reftype, const char *name)
7628 {
7629   _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7630                       reftype, name);
7631 }
7632
7633 static bfd_boolean
7634 eval_symbol (bfd_vma *result,
7635              const char **symp,
7636              bfd *input_bfd,
7637              struct elf_final_link_info *flinfo,
7638              bfd_vma dot,
7639              Elf_Internal_Sym *isymbuf,
7640              size_t locsymcount,
7641              int signed_p)
7642 {
7643   size_t len;
7644   size_t symlen;
7645   bfd_vma a;
7646   bfd_vma b;
7647   char symbuf[4096];
7648   const char *sym = *symp;
7649   const char *symend;
7650   bfd_boolean symbol_is_section = FALSE;
7651
7652   len = strlen (sym);
7653   symend = sym + len;
7654
7655   if (len < 1 || len > sizeof (symbuf))
7656     {
7657       bfd_set_error (bfd_error_invalid_operation);
7658       return FALSE;
7659     }
7660
7661   switch (* sym)
7662     {
7663     case '.':
7664       *result = dot;
7665       *symp = sym + 1;
7666       return TRUE;
7667
7668     case '#':
7669       ++sym;
7670       *result = strtoul (sym, (char **) symp, 16);
7671       return TRUE;
7672
7673     case 'S':
7674       symbol_is_section = TRUE;
7675     case 's':
7676       ++sym;
7677       symlen = strtol (sym, (char **) symp, 10);
7678       sym = *symp + 1; /* Skip the trailing ':'.  */
7679
7680       if (symend < sym || symlen + 1 > sizeof (symbuf))
7681         {
7682           bfd_set_error (bfd_error_invalid_operation);
7683           return FALSE;
7684         }
7685
7686       memcpy (symbuf, sym, symlen);
7687       symbuf[symlen] = '\0';
7688       *symp = sym + symlen;
7689
7690       /* Is it always possible, with complex symbols, that gas "mis-guessed"
7691          the symbol as a section, or vice-versa. so we're pretty liberal in our
7692          interpretation here; section means "try section first", not "must be a
7693          section", and likewise with symbol.  */
7694
7695       if (symbol_is_section)
7696         {
7697           if (!resolve_section (symbuf, flinfo->output_bfd->sections, result)
7698               && !resolve_symbol (symbuf, input_bfd, flinfo, result,
7699                                   isymbuf, locsymcount))
7700             {
7701               undefined_reference ("section", symbuf);
7702               return FALSE;
7703             }
7704         }
7705       else
7706         {
7707           if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
7708                                isymbuf, locsymcount)
7709               && !resolve_section (symbuf, flinfo->output_bfd->sections,
7710                                    result))
7711             {
7712               undefined_reference ("symbol", symbuf);
7713               return FALSE;
7714             }
7715         }
7716
7717       return TRUE;
7718
7719       /* All that remains are operators.  */
7720
7721 #define UNARY_OP(op)                                            \
7722   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7723     {                                                           \
7724       sym += strlen (#op);                                      \
7725       if (*sym == ':')                                          \
7726         ++sym;                                                  \
7727       *symp = sym;                                              \
7728       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
7729                         isymbuf, locsymcount, signed_p))        \
7730         return FALSE;                                           \
7731       if (signed_p)                                             \
7732         *result = op ((bfd_signed_vma) a);                      \
7733       else                                                      \
7734         *result = op a;                                         \
7735       return TRUE;                                              \
7736     }
7737
7738 #define BINARY_OP(op)                                           \
7739   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7740     {                                                           \
7741       sym += strlen (#op);                                      \
7742       if (*sym == ':')                                          \
7743         ++sym;                                                  \
7744       *symp = sym;                                              \
7745       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
7746                         isymbuf, locsymcount, signed_p))        \
7747         return FALSE;                                           \
7748       ++*symp;                                                  \
7749       if (!eval_symbol (&b, symp, input_bfd, flinfo, dot,       \
7750                         isymbuf, locsymcount, signed_p))        \
7751         return FALSE;                                           \
7752       if (signed_p)                                             \
7753         *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7754       else                                                      \
7755         *result = a op b;                                       \
7756       return TRUE;                                              \
7757     }
7758
7759     default:
7760       UNARY_OP  (0-);
7761       BINARY_OP (<<);
7762       BINARY_OP (>>);
7763       BINARY_OP (==);
7764       BINARY_OP (!=);
7765       BINARY_OP (<=);
7766       BINARY_OP (>=);
7767       BINARY_OP (&&);
7768       BINARY_OP (||);
7769       UNARY_OP  (~);
7770       UNARY_OP  (!);
7771       BINARY_OP (*);
7772       BINARY_OP (/);
7773       BINARY_OP (%);
7774       BINARY_OP (^);
7775       BINARY_OP (|);
7776       BINARY_OP (&);
7777       BINARY_OP (+);
7778       BINARY_OP (-);
7779       BINARY_OP (<);
7780       BINARY_OP (>);
7781 #undef UNARY_OP
7782 #undef BINARY_OP
7783       _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7784       bfd_set_error (bfd_error_invalid_operation);
7785       return FALSE;
7786     }
7787 }
7788
7789 static void
7790 put_value (bfd_vma size,
7791            unsigned long chunksz,
7792            bfd *input_bfd,
7793            bfd_vma x,
7794            bfd_byte *location)
7795 {
7796   location += (size - chunksz);
7797
7798   for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7799     {
7800       switch (chunksz)
7801         {
7802         default:
7803         case 0:
7804           abort ();
7805         case 1:
7806           bfd_put_8 (input_bfd, x, location);
7807           break;
7808         case 2:
7809           bfd_put_16 (input_bfd, x, location);
7810           break;
7811         case 4:
7812           bfd_put_32 (input_bfd, x, location);
7813           break;
7814         case 8:
7815 #ifdef BFD64
7816           bfd_put_64 (input_bfd, x, location);
7817 #else
7818           abort ();
7819 #endif
7820           break;
7821         }
7822     }
7823 }
7824
7825 static bfd_vma
7826 get_value (bfd_vma size,
7827            unsigned long chunksz,
7828            bfd *input_bfd,
7829            bfd_byte *location)
7830 {
7831   int shift;
7832   bfd_vma x = 0;
7833
7834   /* Sanity checks.  */
7835   BFD_ASSERT (chunksz <= sizeof (x)
7836               && size >= chunksz
7837               && chunksz != 0
7838               && (size % chunksz) == 0
7839               && input_bfd != NULL
7840               && location != NULL);
7841
7842   if (chunksz == sizeof (x))
7843     {
7844       BFD_ASSERT (size == chunksz);
7845
7846       /* Make sure that we do not perform an undefined shift operation.
7847          We know that size == chunksz so there will only be one iteration
7848          of the loop below.  */
7849       shift = 0;
7850     }
7851   else
7852     shift = 8 * chunksz;
7853
7854   for (; size; size -= chunksz, location += chunksz)
7855     {
7856       switch (chunksz)
7857         {
7858         case 1:
7859           x = (x << shift) | bfd_get_8 (input_bfd, location);
7860           break;
7861         case 2:
7862           x = (x << shift) | bfd_get_16 (input_bfd, location);
7863           break;
7864         case 4:
7865           x = (x << shift) | bfd_get_32 (input_bfd, location);
7866           break;
7867 #ifdef BFD64
7868         case 8:
7869           x = (x << shift) | bfd_get_64 (input_bfd, location);
7870           break;
7871 #endif
7872         default:
7873           abort ();
7874         }
7875     }
7876   return x;
7877 }
7878
7879 static void
7880 decode_complex_addend (unsigned long *start,   /* in bits */
7881                        unsigned long *oplen,   /* in bits */
7882                        unsigned long *len,     /* in bits */
7883                        unsigned long *wordsz,  /* in bytes */
7884                        unsigned long *chunksz, /* in bytes */
7885                        unsigned long *lsb0_p,
7886                        unsigned long *signed_p,
7887                        unsigned long *trunc_p,
7888                        unsigned long encoded)
7889 {
7890   * start     =  encoded        & 0x3F;
7891   * len       = (encoded >>  6) & 0x3F;
7892   * oplen     = (encoded >> 12) & 0x3F;
7893   * wordsz    = (encoded >> 18) & 0xF;
7894   * chunksz   = (encoded >> 22) & 0xF;
7895   * lsb0_p    = (encoded >> 27) & 1;
7896   * signed_p  = (encoded >> 28) & 1;
7897   * trunc_p   = (encoded >> 29) & 1;
7898 }
7899
7900 bfd_reloc_status_type
7901 bfd_elf_perform_complex_relocation (bfd *input_bfd,
7902                                     asection *input_section ATTRIBUTE_UNUSED,
7903                                     bfd_byte *contents,
7904                                     Elf_Internal_Rela *rel,
7905                                     bfd_vma relocation)
7906 {
7907   bfd_vma shift, x, mask;
7908   unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7909   bfd_reloc_status_type r;
7910
7911   /*  Perform this reloc, since it is complex.
7912       (this is not to say that it necessarily refers to a complex
7913       symbol; merely that it is a self-describing CGEN based reloc.
7914       i.e. the addend has the complete reloc information (bit start, end,
7915       word size, etc) encoded within it.).  */
7916
7917   decode_complex_addend (&start, &oplen, &len, &wordsz,
7918                          &chunksz, &lsb0_p, &signed_p,
7919                          &trunc_p, rel->r_addend);
7920
7921   mask = (((1L << (len - 1)) - 1) << 1) | 1;
7922
7923   if (lsb0_p)
7924     shift = (start + 1) - len;
7925   else
7926     shift = (8 * wordsz) - (start + len);
7927
7928   /* FIXME: octets_per_byte.  */
7929   x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7930
7931 #ifdef DEBUG
7932   printf ("Doing complex reloc: "
7933           "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7934           "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7935           "    dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7936           lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7937           oplen, (unsigned long) x, (unsigned long) mask,
7938           (unsigned long) relocation);
7939 #endif
7940
7941   r = bfd_reloc_ok;
7942   if (! trunc_p)
7943     /* Now do an overflow check.  */
7944     r = bfd_check_overflow ((signed_p
7945                              ? complain_overflow_signed
7946                              : complain_overflow_unsigned),
7947                             len, 0, (8 * wordsz),
7948                             relocation);
7949
7950   /* Do the deed.  */
7951   x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7952
7953 #ifdef DEBUG
7954   printf ("           relocation: %8.8lx\n"
7955           "         shifted mask: %8.8lx\n"
7956           " shifted/masked reloc: %8.8lx\n"
7957           "               result: %8.8lx\n",
7958           (unsigned long) relocation, (unsigned long) (mask << shift),
7959           (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
7960 #endif
7961   /* FIXME: octets_per_byte.  */
7962   put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7963   return r;
7964 }
7965
7966 /* qsort comparison functions sorting external relocs by r_offset.  */
7967
7968 static int
7969 cmp_ext32l_r_offset (const void *p, const void *q)
7970 {
7971   union aligned32
7972   {
7973     uint32_t v;
7974     unsigned char c[4];
7975   };
7976   const union aligned32 *a
7977     = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
7978   const union aligned32 *b
7979     = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
7980
7981   uint32_t aval = (  (uint32_t) a->c[0]
7982                    | (uint32_t) a->c[1] << 8
7983                    | (uint32_t) a->c[2] << 16
7984                    | (uint32_t) a->c[3] << 24);
7985   uint32_t bval = (  (uint32_t) b->c[0]
7986                    | (uint32_t) b->c[1] << 8
7987                    | (uint32_t) b->c[2] << 16
7988                    | (uint32_t) b->c[3] << 24);
7989   if (aval < bval)
7990     return -1;
7991   else if (aval > bval)
7992     return 1;
7993   return 0;
7994 }
7995
7996 static int
7997 cmp_ext32b_r_offset (const void *p, const void *q)
7998 {
7999   union aligned32
8000   {
8001     uint32_t v;
8002     unsigned char c[4];
8003   };
8004   const union aligned32 *a
8005     = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
8006   const union aligned32 *b
8007     = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
8008
8009   uint32_t aval = (  (uint32_t) a->c[0] << 24
8010                    | (uint32_t) a->c[1] << 16
8011                    | (uint32_t) a->c[2] << 8
8012                    | (uint32_t) a->c[3]);
8013   uint32_t bval = (  (uint32_t) b->c[0] << 24
8014                    | (uint32_t) b->c[1] << 16
8015                    | (uint32_t) b->c[2] << 8
8016                    | (uint32_t) b->c[3]);
8017   if (aval < bval)
8018     return -1;
8019   else if (aval > bval)
8020     return 1;
8021   return 0;
8022 }
8023
8024 #ifdef BFD_HOST_64_BIT
8025 static int
8026 cmp_ext64l_r_offset (const void *p, const void *q)
8027 {
8028   union aligned64
8029   {
8030     uint64_t v;
8031     unsigned char c[8];
8032   };
8033   const union aligned64 *a
8034     = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
8035   const union aligned64 *b
8036     = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
8037
8038   uint64_t aval = (  (uint64_t) a->c[0]
8039                    | (uint64_t) a->c[1] << 8
8040                    | (uint64_t) a->c[2] << 16
8041                    | (uint64_t) a->c[3] << 24
8042                    | (uint64_t) a->c[4] << 32
8043                    | (uint64_t) a->c[5] << 40
8044                    | (uint64_t) a->c[6] << 48
8045                    | (uint64_t) a->c[7] << 56);
8046   uint64_t bval = (  (uint64_t) b->c[0]
8047                    | (uint64_t) b->c[1] << 8
8048                    | (uint64_t) b->c[2] << 16
8049                    | (uint64_t) b->c[3] << 24
8050                    | (uint64_t) b->c[4] << 32
8051                    | (uint64_t) b->c[5] << 40
8052                    | (uint64_t) b->c[6] << 48
8053                    | (uint64_t) b->c[7] << 56);
8054   if (aval < bval)
8055     return -1;
8056   else if (aval > bval)
8057     return 1;
8058   return 0;
8059 }
8060
8061 static int
8062 cmp_ext64b_r_offset (const void *p, const void *q)
8063 {
8064   union aligned64
8065   {
8066     uint64_t v;
8067     unsigned char c[8];
8068   };
8069   const union aligned64 *a
8070     = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
8071   const union aligned64 *b
8072     = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
8073
8074   uint64_t aval = (  (uint64_t) a->c[0] << 56
8075                    | (uint64_t) a->c[1] << 48
8076                    | (uint64_t) a->c[2] << 40
8077                    | (uint64_t) a->c[3] << 32
8078                    | (uint64_t) a->c[4] << 24
8079                    | (uint64_t) a->c[5] << 16
8080                    | (uint64_t) a->c[6] << 8
8081                    | (uint64_t) a->c[7]);
8082   uint64_t bval = (  (uint64_t) b->c[0] << 56
8083                    | (uint64_t) b->c[1] << 48
8084                    | (uint64_t) b->c[2] << 40
8085                    | (uint64_t) b->c[3] << 32
8086                    | (uint64_t) b->c[4] << 24
8087                    | (uint64_t) b->c[5] << 16
8088                    | (uint64_t) b->c[6] << 8
8089                    | (uint64_t) b->c[7]);
8090   if (aval < bval)
8091     return -1;
8092   else if (aval > bval)
8093     return 1;
8094   return 0;
8095 }
8096 #endif
8097
8098 /* When performing a relocatable link, the input relocations are
8099    preserved.  But, if they reference global symbols, the indices
8100    referenced must be updated.  Update all the relocations found in
8101    RELDATA.  */
8102
8103 static void
8104 elf_link_adjust_relocs (bfd *abfd,
8105                         struct bfd_elf_section_reloc_data *reldata,
8106                         bfd_boolean sort)
8107 {
8108   unsigned int i;
8109   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8110   bfd_byte *erela;
8111   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8112   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8113   bfd_vma r_type_mask;
8114   int r_sym_shift;
8115   unsigned int count = reldata->count;
8116   struct elf_link_hash_entry **rel_hash = reldata->hashes;
8117
8118   if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
8119     {
8120       swap_in = bed->s->swap_reloc_in;
8121       swap_out = bed->s->swap_reloc_out;
8122     }
8123   else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
8124     {
8125       swap_in = bed->s->swap_reloca_in;
8126       swap_out = bed->s->swap_reloca_out;
8127     }
8128   else
8129     abort ();
8130
8131   if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
8132     abort ();
8133
8134   if (bed->s->arch_size == 32)
8135     {
8136       r_type_mask = 0xff;
8137       r_sym_shift = 8;
8138     }
8139   else
8140     {
8141       r_type_mask = 0xffffffff;
8142       r_sym_shift = 32;
8143     }
8144
8145   erela = reldata->hdr->contents;
8146   for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
8147     {
8148       Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
8149       unsigned int j;
8150
8151       if (*rel_hash == NULL)
8152         continue;
8153
8154       BFD_ASSERT ((*rel_hash)->indx >= 0);
8155
8156       (*swap_in) (abfd, erela, irela);
8157       for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
8158         irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
8159                            | (irela[j].r_info & r_type_mask));
8160       (*swap_out) (abfd, irela, erela);
8161     }
8162
8163   if (sort)
8164     {
8165       int (*compare) (const void *, const void *);
8166
8167       if (bed->s->arch_size == 32)
8168         {
8169           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8170             compare = cmp_ext32l_r_offset;
8171           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8172             compare = cmp_ext32b_r_offset;
8173           else
8174             abort ();
8175         }
8176       else
8177         {
8178 #ifdef BFD_HOST_64_BIT
8179           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8180             compare = cmp_ext64l_r_offset;
8181           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8182             compare = cmp_ext64b_r_offset;
8183           else
8184 #endif
8185             abort ();
8186         }
8187       qsort (reldata->hdr->contents, count, reldata->hdr->sh_entsize, compare);
8188       free (reldata->hashes);
8189       reldata->hashes = NULL;
8190     }
8191 }
8192
8193 struct elf_link_sort_rela
8194 {
8195   union {
8196     bfd_vma offset;
8197     bfd_vma sym_mask;
8198   } u;
8199   enum elf_reloc_type_class type;
8200   /* We use this as an array of size int_rels_per_ext_rel.  */
8201   Elf_Internal_Rela rela[1];
8202 };
8203
8204 static int
8205 elf_link_sort_cmp1 (const void *A, const void *B)
8206 {
8207   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8208   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8209   int relativea, relativeb;
8210
8211   relativea = a->type == reloc_class_relative;
8212   relativeb = b->type == reloc_class_relative;
8213
8214   if (relativea < relativeb)
8215     return 1;
8216   if (relativea > relativeb)
8217     return -1;
8218   if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8219     return -1;
8220   if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8221     return 1;
8222   if (a->rela->r_offset < b->rela->r_offset)
8223     return -1;
8224   if (a->rela->r_offset > b->rela->r_offset)
8225     return 1;
8226   return 0;
8227 }
8228
8229 static int
8230 elf_link_sort_cmp2 (const void *A, const void *B)
8231 {
8232   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8233   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8234
8235   if (a->type < b->type)
8236     return -1;
8237   if (a->type > b->type)
8238     return 1;
8239   if (a->u.offset < b->u.offset)
8240     return -1;
8241   if (a->u.offset > b->u.offset)
8242     return 1;
8243   if (a->rela->r_offset < b->rela->r_offset)
8244     return -1;
8245   if (a->rela->r_offset > b->rela->r_offset)
8246     return 1;
8247   return 0;
8248 }
8249
8250 static size_t
8251 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8252 {
8253   asection *dynamic_relocs;
8254   asection *rela_dyn;
8255   asection *rel_dyn;
8256   bfd_size_type count, size;
8257   size_t i, ret, sort_elt, ext_size;
8258   bfd_byte *sort, *s_non_relative, *p;
8259   struct elf_link_sort_rela *sq;
8260   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8261   int i2e = bed->s->int_rels_per_ext_rel;
8262   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8263   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8264   struct bfd_link_order *lo;
8265   bfd_vma r_sym_mask;
8266   bfd_boolean use_rela;
8267
8268   /* Find a dynamic reloc section.  */
8269   rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8270   rel_dyn  = bfd_get_section_by_name (abfd, ".rel.dyn");
8271   if (rela_dyn != NULL && rela_dyn->size > 0
8272       && rel_dyn != NULL && rel_dyn->size > 0)
8273     {
8274       bfd_boolean use_rela_initialised = FALSE;
8275
8276       /* This is just here to stop gcc from complaining.
8277          It's initialization checking code is not perfect.  */
8278       use_rela = TRUE;
8279
8280       /* Both sections are present.  Examine the sizes
8281          of the indirect sections to help us choose.  */
8282       for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8283         if (lo->type == bfd_indirect_link_order)
8284           {
8285             asection *o = lo->u.indirect.section;
8286
8287             if ((o->size % bed->s->sizeof_rela) == 0)
8288               {
8289                 if ((o->size % bed->s->sizeof_rel) == 0)
8290                   /* Section size is divisible by both rel and rela sizes.
8291                      It is of no help to us.  */
8292                   ;
8293                 else
8294                   {
8295                     /* Section size is only divisible by rela.  */
8296                     if (use_rela_initialised && (use_rela == FALSE))
8297                       {
8298                         _bfd_error_handler
8299                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8300                         bfd_set_error (bfd_error_invalid_operation);
8301                         return 0;
8302                       }
8303                     else
8304                       {
8305                         use_rela = TRUE;
8306                         use_rela_initialised = TRUE;
8307                       }
8308                   }
8309               }
8310             else if ((o->size % bed->s->sizeof_rel) == 0)
8311               {
8312                 /* Section size is only divisible by rel.  */
8313                 if (use_rela_initialised && (use_rela == TRUE))
8314                   {
8315                     _bfd_error_handler
8316                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8317                     bfd_set_error (bfd_error_invalid_operation);
8318                     return 0;
8319                   }
8320                 else
8321                   {
8322                     use_rela = FALSE;
8323                     use_rela_initialised = TRUE;
8324                   }
8325               }
8326             else
8327               {
8328                 /* The section size is not divisible by either - something is wrong.  */
8329                 _bfd_error_handler
8330                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8331                 bfd_set_error (bfd_error_invalid_operation);
8332                 return 0;
8333               }
8334           }
8335
8336       for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8337         if (lo->type == bfd_indirect_link_order)
8338           {
8339             asection *o = lo->u.indirect.section;
8340
8341             if ((o->size % bed->s->sizeof_rela) == 0)
8342               {
8343                 if ((o->size % bed->s->sizeof_rel) == 0)
8344                   /* Section size is divisible by both rel and rela sizes.
8345                      It is of no help to us.  */
8346                   ;
8347                 else
8348                   {
8349                     /* Section size is only divisible by rela.  */
8350                     if (use_rela_initialised && (use_rela == FALSE))
8351                       {
8352                         _bfd_error_handler
8353                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8354                         bfd_set_error (bfd_error_invalid_operation);
8355                         return 0;
8356                       }
8357                     else
8358                       {
8359                         use_rela = TRUE;
8360                         use_rela_initialised = TRUE;
8361                       }
8362                   }
8363               }
8364             else if ((o->size % bed->s->sizeof_rel) == 0)
8365               {
8366                 /* Section size is only divisible by rel.  */
8367                 if (use_rela_initialised && (use_rela == TRUE))
8368                   {
8369                     _bfd_error_handler
8370                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8371                     bfd_set_error (bfd_error_invalid_operation);
8372                     return 0;
8373                   }
8374                 else
8375                   {
8376                     use_rela = FALSE;
8377                     use_rela_initialised = TRUE;
8378                   }
8379               }
8380             else
8381               {
8382                 /* The section size is not divisible by either - something is wrong.  */
8383                 _bfd_error_handler
8384                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8385                 bfd_set_error (bfd_error_invalid_operation);
8386                 return 0;
8387               }
8388           }
8389
8390       if (! use_rela_initialised)
8391         /* Make a guess.  */
8392         use_rela = TRUE;
8393     }
8394   else if (rela_dyn != NULL && rela_dyn->size > 0)
8395     use_rela = TRUE;
8396   else if (rel_dyn != NULL && rel_dyn->size > 0)
8397     use_rela = FALSE;
8398   else
8399     return 0;
8400
8401   if (use_rela)
8402     {
8403       dynamic_relocs = rela_dyn;
8404       ext_size = bed->s->sizeof_rela;
8405       swap_in = bed->s->swap_reloca_in;
8406       swap_out = bed->s->swap_reloca_out;
8407     }
8408   else
8409     {
8410       dynamic_relocs = rel_dyn;
8411       ext_size = bed->s->sizeof_rel;
8412       swap_in = bed->s->swap_reloc_in;
8413       swap_out = bed->s->swap_reloc_out;
8414     }
8415
8416   size = 0;
8417   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8418     if (lo->type == bfd_indirect_link_order)
8419       size += lo->u.indirect.section->size;
8420
8421   if (size != dynamic_relocs->size)
8422     return 0;
8423
8424   sort_elt = (sizeof (struct elf_link_sort_rela)
8425               + (i2e - 1) * sizeof (Elf_Internal_Rela));
8426
8427   count = dynamic_relocs->size / ext_size;
8428   if (count == 0)
8429     return 0;
8430   sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8431
8432   if (sort == NULL)
8433     {
8434       (*info->callbacks->warning)
8435         (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8436       return 0;
8437     }
8438
8439   if (bed->s->arch_size == 32)
8440     r_sym_mask = ~(bfd_vma) 0xff;
8441   else
8442     r_sym_mask = ~(bfd_vma) 0xffffffff;
8443
8444   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8445     if (lo->type == bfd_indirect_link_order)
8446       {
8447         bfd_byte *erel, *erelend;
8448         asection *o = lo->u.indirect.section;
8449
8450         if (o->contents == NULL && o->size != 0)
8451           {
8452             /* This is a reloc section that is being handled as a normal
8453                section.  See bfd_section_from_shdr.  We can't combine
8454                relocs in this case.  */
8455             free (sort);
8456             return 0;
8457           }
8458         erel = o->contents;
8459         erelend = o->contents + o->size;
8460         /* FIXME: octets_per_byte.  */
8461         p = sort + o->output_offset / ext_size * sort_elt;
8462
8463         while (erel < erelend)
8464           {
8465             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8466
8467             (*swap_in) (abfd, erel, s->rela);
8468             s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
8469             s->u.sym_mask = r_sym_mask;
8470             p += sort_elt;
8471             erel += ext_size;
8472           }
8473       }
8474
8475   qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8476
8477   for (i = 0, p = sort; i < count; i++, p += sort_elt)
8478     {
8479       struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8480       if (s->type != reloc_class_relative)
8481         break;
8482     }
8483   ret = i;
8484   s_non_relative = p;
8485
8486   sq = (struct elf_link_sort_rela *) s_non_relative;
8487   for (; i < count; i++, p += sort_elt)
8488     {
8489       struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8490       if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8491         sq = sp;
8492       sp->u.offset = sq->rela->r_offset;
8493     }
8494
8495   qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8496
8497   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8498     if (lo->type == bfd_indirect_link_order)
8499       {
8500         bfd_byte *erel, *erelend;
8501         asection *o = lo->u.indirect.section;
8502
8503         erel = o->contents;
8504         erelend = o->contents + o->size;
8505         /* FIXME: octets_per_byte.  */
8506         p = sort + o->output_offset / ext_size * sort_elt;
8507         while (erel < erelend)
8508           {
8509             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8510             (*swap_out) (abfd, s->rela, erel);
8511             p += sort_elt;
8512             erel += ext_size;
8513           }
8514       }
8515
8516   free (sort);
8517   *psec = dynamic_relocs;
8518   return ret;
8519 }
8520
8521 /* Flush the output symbols to the file.  */
8522
8523 static bfd_boolean
8524 elf_link_flush_output_syms (struct elf_final_link_info *flinfo,
8525                             const struct elf_backend_data *bed)
8526 {
8527   if (flinfo->symbuf_count > 0)
8528     {
8529       Elf_Internal_Shdr *hdr;
8530       file_ptr pos;
8531       bfd_size_type amt;
8532
8533       hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
8534       pos = hdr->sh_offset + hdr->sh_size;
8535       amt = flinfo->symbuf_count * bed->s->sizeof_sym;
8536       if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) != 0
8537           || bfd_bwrite (flinfo->symbuf, amt, flinfo->output_bfd) != amt)
8538         return FALSE;
8539
8540       hdr->sh_size += amt;
8541       flinfo->symbuf_count = 0;
8542     }
8543
8544   return TRUE;
8545 }
8546
8547 /* Add a symbol to the output symbol table.  */
8548
8549 static int
8550 elf_link_output_sym (struct elf_final_link_info *flinfo,
8551                      const char *name,
8552                      Elf_Internal_Sym *elfsym,
8553                      asection *input_sec,
8554                      struct elf_link_hash_entry *h)
8555 {
8556   bfd_byte *dest;
8557   Elf_External_Sym_Shndx *destshndx;
8558   int (*output_symbol_hook)
8559     (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8560      struct elf_link_hash_entry *);
8561   const struct elf_backend_data *bed;
8562
8563   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
8564
8565   bed = get_elf_backend_data (flinfo->output_bfd);
8566   output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8567   if (output_symbol_hook != NULL)
8568     {
8569       int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
8570       if (ret != 1)
8571         return ret;
8572     }
8573
8574   if (name == NULL || *name == '\0')
8575     elfsym->st_name = 0;
8576   else if (input_sec->flags & SEC_EXCLUDE)
8577     elfsym->st_name = 0;
8578   else
8579     {
8580       elfsym->st_name = (unsigned long) _bfd_stringtab_add (flinfo->symstrtab,
8581                                                             name, TRUE, FALSE);
8582       if (elfsym->st_name == (unsigned long) -1)
8583         return 0;
8584     }
8585
8586   if (flinfo->symbuf_count >= flinfo->symbuf_size)
8587     {
8588       if (! elf_link_flush_output_syms (flinfo, bed))
8589         return 0;
8590     }
8591
8592   dest = flinfo->symbuf + flinfo->symbuf_count * bed->s->sizeof_sym;
8593   destshndx = flinfo->symshndxbuf;
8594   if (destshndx != NULL)
8595     {
8596       if (bfd_get_symcount (flinfo->output_bfd) >= flinfo->shndxbuf_size)
8597         {
8598           bfd_size_type amt;
8599
8600           amt = flinfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8601           destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8602                                                               amt * 2);
8603           if (destshndx == NULL)
8604             return 0;
8605           flinfo->symshndxbuf = destshndx;
8606           memset ((char *) destshndx + amt, 0, amt);
8607           flinfo->shndxbuf_size *= 2;
8608         }
8609       destshndx += bfd_get_symcount (flinfo->output_bfd);
8610     }
8611
8612   bed->s->swap_symbol_out (flinfo->output_bfd, elfsym, dest, destshndx);
8613   flinfo->symbuf_count += 1;
8614   bfd_get_symcount (flinfo->output_bfd) += 1;
8615
8616   return 1;
8617 }
8618
8619 /* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
8620
8621 static bfd_boolean
8622 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8623 {
8624   if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8625       && sym->st_shndx < SHN_LORESERVE)
8626     {
8627       /* The gABI doesn't support dynamic symbols in output sections
8628          beyond 64k.  */
8629       (*_bfd_error_handler)
8630         (_("%B: Too many sections: %d (>= %d)"),
8631          abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8632       bfd_set_error (bfd_error_nonrepresentable_section);
8633       return FALSE;
8634     }
8635   return TRUE;
8636 }
8637
8638 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8639    allowing an unsatisfied unversioned symbol in the DSO to match a
8640    versioned symbol that would normally require an explicit version.
8641    We also handle the case that a DSO references a hidden symbol
8642    which may be satisfied by a versioned symbol in another DSO.  */
8643
8644 static bfd_boolean
8645 elf_link_check_versioned_symbol (struct bfd_link_info *info,
8646                                  const struct elf_backend_data *bed,
8647                                  struct elf_link_hash_entry *h)
8648 {
8649   bfd *abfd;
8650   struct elf_link_loaded_list *loaded;
8651
8652   if (!is_elf_hash_table (info->hash))
8653     return FALSE;
8654
8655   /* Check indirect symbol.  */
8656   while (h->root.type == bfd_link_hash_indirect)
8657     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8658
8659   switch (h->root.type)
8660     {
8661     default:
8662       abfd = NULL;
8663       break;
8664
8665     case bfd_link_hash_undefined:
8666     case bfd_link_hash_undefweak:
8667       abfd = h->root.u.undef.abfd;
8668       if ((abfd->flags & DYNAMIC) == 0
8669           || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8670         return FALSE;
8671       break;
8672
8673     case bfd_link_hash_defined:
8674     case bfd_link_hash_defweak:
8675       abfd = h->root.u.def.section->owner;
8676       break;
8677
8678     case bfd_link_hash_common:
8679       abfd = h->root.u.c.p->section->owner;
8680       break;
8681     }
8682   BFD_ASSERT (abfd != NULL);
8683
8684   for (loaded = elf_hash_table (info)->loaded;
8685        loaded != NULL;
8686        loaded = loaded->next)
8687     {
8688       bfd *input;
8689       Elf_Internal_Shdr *hdr;
8690       bfd_size_type symcount;
8691       bfd_size_type extsymcount;
8692       bfd_size_type extsymoff;
8693       Elf_Internal_Shdr *versymhdr;
8694       Elf_Internal_Sym *isym;
8695       Elf_Internal_Sym *isymend;
8696       Elf_Internal_Sym *isymbuf;
8697       Elf_External_Versym *ever;
8698       Elf_External_Versym *extversym;
8699
8700       input = loaded->abfd;
8701
8702       /* We check each DSO for a possible hidden versioned definition.  */
8703       if (input == abfd
8704           || (input->flags & DYNAMIC) == 0
8705           || elf_dynversym (input) == 0)
8706         continue;
8707
8708       hdr = &elf_tdata (input)->dynsymtab_hdr;
8709
8710       symcount = hdr->sh_size / bed->s->sizeof_sym;
8711       if (elf_bad_symtab (input))
8712         {
8713           extsymcount = symcount;
8714           extsymoff = 0;
8715         }
8716       else
8717         {
8718           extsymcount = symcount - hdr->sh_info;
8719           extsymoff = hdr->sh_info;
8720         }
8721
8722       if (extsymcount == 0)
8723         continue;
8724
8725       isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8726                                       NULL, NULL, NULL);
8727       if (isymbuf == NULL)
8728         return FALSE;
8729
8730       /* Read in any version definitions.  */
8731       versymhdr = &elf_tdata (input)->dynversym_hdr;
8732       extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8733       if (extversym == NULL)
8734         goto error_ret;
8735
8736       if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8737           || (bfd_bread (extversym, versymhdr->sh_size, input)
8738               != versymhdr->sh_size))
8739         {
8740           free (extversym);
8741         error_ret:
8742           free (isymbuf);
8743           return FALSE;
8744         }
8745
8746       ever = extversym + extsymoff;
8747       isymend = isymbuf + extsymcount;
8748       for (isym = isymbuf; isym < isymend; isym++, ever++)
8749         {
8750           const char *name;
8751           Elf_Internal_Versym iver;
8752           unsigned short version_index;
8753
8754           if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8755               || isym->st_shndx == SHN_UNDEF)
8756             continue;
8757
8758           name = bfd_elf_string_from_elf_section (input,
8759                                                   hdr->sh_link,
8760                                                   isym->st_name);
8761           if (strcmp (name, h->root.root.string) != 0)
8762             continue;
8763
8764           _bfd_elf_swap_versym_in (input, ever, &iver);
8765
8766           if ((iver.vs_vers & VERSYM_HIDDEN) == 0
8767               && !(h->def_regular
8768                    && h->forced_local))
8769             {
8770               /* If we have a non-hidden versioned sym, then it should
8771                  have provided a definition for the undefined sym unless
8772                  it is defined in a non-shared object and forced local.
8773                */
8774               abort ();
8775             }
8776
8777           version_index = iver.vs_vers & VERSYM_VERSION;
8778           if (version_index == 1 || version_index == 2)
8779             {
8780               /* This is the base or first version.  We can use it.  */
8781               free (extversym);
8782               free (isymbuf);
8783               return TRUE;
8784             }
8785         }
8786
8787       free (extversym);
8788       free (isymbuf);
8789     }
8790
8791   return FALSE;
8792 }
8793
8794 /* Add an external symbol to the symbol table.  This is called from
8795    the hash table traversal routine.  When generating a shared object,
8796    we go through the symbol table twice.  The first time we output
8797    anything that might have been forced to local scope in a version
8798    script.  The second time we output the symbols that are still
8799    global symbols.  */
8800
8801 static bfd_boolean
8802 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
8803 {
8804   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
8805   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8806   struct elf_final_link_info *flinfo = eoinfo->flinfo;
8807   bfd_boolean strip;
8808   Elf_Internal_Sym sym;
8809   asection *input_sec;
8810   const struct elf_backend_data *bed;
8811   long indx;
8812   int ret;
8813
8814   if (h->root.type == bfd_link_hash_warning)
8815     {
8816       h = (struct elf_link_hash_entry *) h->root.u.i.link;
8817       if (h->root.type == bfd_link_hash_new)
8818         return TRUE;
8819     }
8820
8821   /* Decide whether to output this symbol in this pass.  */
8822   if (eoinfo->localsyms)
8823     {
8824       if (!h->forced_local)
8825         return TRUE;
8826       if (eoinfo->second_pass
8827           && !((h->root.type == bfd_link_hash_defined
8828                 || h->root.type == bfd_link_hash_defweak)
8829                && h->root.u.def.section->output_section != NULL))
8830         return TRUE;
8831
8832       if (!eoinfo->file_sym_done
8833           && (eoinfo->second_pass ? eoinfo->flinfo->filesym_count == 1
8834                                   : eoinfo->flinfo->filesym_count > 1))
8835         {
8836           /* Output a FILE symbol so that following locals are not associated
8837              with the wrong input file.  */
8838           memset (&sym, 0, sizeof (sym));
8839           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8840           sym.st_shndx = SHN_ABS;
8841           if (!elf_link_output_sym (eoinfo->flinfo, NULL, &sym,
8842                                     bfd_und_section_ptr, NULL))
8843             return FALSE;
8844
8845           eoinfo->file_sym_done = TRUE;
8846         }
8847     }
8848   else
8849     {
8850       if (h->forced_local)
8851         return TRUE;
8852     }
8853
8854   bed = get_elf_backend_data (flinfo->output_bfd);
8855
8856   if (h->root.type == bfd_link_hash_undefined)
8857     {
8858       /* If we have an undefined symbol reference here then it must have
8859          come from a shared library that is being linked in.  (Undefined
8860          references in regular files have already been handled unless
8861          they are in unreferenced sections which are removed by garbage
8862          collection).  */
8863       bfd_boolean ignore_undef = FALSE;
8864
8865       /* Some symbols may be special in that the fact that they're
8866          undefined can be safely ignored - let backend determine that.  */
8867       if (bed->elf_backend_ignore_undef_symbol)
8868         ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8869
8870       /* If we are reporting errors for this situation then do so now.  */
8871       if (!ignore_undef
8872           && h->ref_dynamic
8873           && (!h->ref_regular || flinfo->info->gc_sections)
8874           && !elf_link_check_versioned_symbol (flinfo->info, bed, h)
8875           && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8876         {
8877           if (!(flinfo->info->callbacks->undefined_symbol
8878                 (flinfo->info, h->root.root.string,
8879                  h->ref_regular ? NULL : h->root.u.undef.abfd,
8880                  NULL, 0,
8881                  (flinfo->info->unresolved_syms_in_shared_libs
8882                   == RM_GENERATE_ERROR))))
8883             {
8884               bfd_set_error (bfd_error_bad_value);
8885               eoinfo->failed = TRUE;
8886               return FALSE;
8887             }
8888         }
8889     }
8890
8891   /* We should also warn if a forced local symbol is referenced from
8892      shared libraries.  */
8893   if (!flinfo->info->relocatable
8894       && flinfo->info->executable
8895       && h->forced_local
8896       && h->ref_dynamic
8897       && h->def_regular
8898       && !h->dynamic_def
8899       && h->ref_dynamic_nonweak
8900       && !elf_link_check_versioned_symbol (flinfo->info, bed, h))
8901     {
8902       bfd *def_bfd;
8903       const char *msg;
8904       struct elf_link_hash_entry *hi = h;
8905
8906       /* Check indirect symbol.  */
8907       while (hi->root.type == bfd_link_hash_indirect)
8908         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
8909
8910       if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
8911         msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
8912       else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
8913         msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
8914       else
8915         msg = _("%B: local symbol `%s' in %B is referenced by DSO");
8916       def_bfd = flinfo->output_bfd;
8917       if (hi->root.u.def.section != bfd_abs_section_ptr)
8918         def_bfd = hi->root.u.def.section->owner;
8919       (*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
8920                              h->root.root.string);
8921       bfd_set_error (bfd_error_bad_value);
8922       eoinfo->failed = TRUE;
8923       return FALSE;
8924     }
8925
8926   /* We don't want to output symbols that have never been mentioned by
8927      a regular file, or that we have been told to strip.  However, if
8928      h->indx is set to -2, the symbol is used by a reloc and we must
8929      output it.  */
8930   if (h->indx == -2)
8931     strip = FALSE;
8932   else if ((h->def_dynamic
8933             || h->ref_dynamic
8934             || h->root.type == bfd_link_hash_new)
8935            && !h->def_regular
8936            && !h->ref_regular)
8937     strip = TRUE;
8938   else if (flinfo->info->strip == strip_all)
8939     strip = TRUE;
8940   else if (flinfo->info->strip == strip_some
8941            && bfd_hash_lookup (flinfo->info->keep_hash,
8942                                h->root.root.string, FALSE, FALSE) == NULL)
8943     strip = TRUE;
8944   else if ((h->root.type == bfd_link_hash_defined
8945             || h->root.type == bfd_link_hash_defweak)
8946            && ((flinfo->info->strip_discarded
8947                 && discarded_section (h->root.u.def.section))
8948                || (h->root.u.def.section->owner != NULL
8949                    && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
8950     strip = TRUE;
8951   else if ((h->root.type == bfd_link_hash_undefined
8952             || h->root.type == bfd_link_hash_undefweak)
8953            && h->root.u.undef.abfd != NULL
8954            && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
8955     strip = TRUE;
8956   else
8957     strip = FALSE;
8958
8959   /* If we're stripping it, and it's not a dynamic symbol, there's
8960      nothing else to do unless it is a forced local symbol or a
8961      STT_GNU_IFUNC symbol.  */
8962   if (strip
8963       && h->dynindx == -1
8964       && h->type != STT_GNU_IFUNC
8965       && !h->forced_local)
8966     return TRUE;
8967
8968   sym.st_value = 0;
8969   sym.st_size = h->size;
8970   sym.st_other = h->other;
8971   if (h->forced_local)
8972     {
8973       sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8974       /* Turn off visibility on local symbol.  */
8975       sym.st_other &= ~ELF_ST_VISIBILITY (-1);
8976     }
8977   /* Set STB_GNU_UNIQUE only if symbol is defined in regular object.  */
8978   else if (h->unique_global && h->def_regular)
8979     sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8980   else if (h->root.type == bfd_link_hash_undefweak
8981            || h->root.type == bfd_link_hash_defweak)
8982     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8983   else
8984     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8985   sym.st_target_internal = h->target_internal;
8986
8987   switch (h->root.type)
8988     {
8989     default:
8990     case bfd_link_hash_new:
8991     case bfd_link_hash_warning:
8992       abort ();
8993       return FALSE;
8994
8995     case bfd_link_hash_undefined:
8996     case bfd_link_hash_undefweak:
8997       input_sec = bfd_und_section_ptr;
8998       sym.st_shndx = SHN_UNDEF;
8999       break;
9000
9001     case bfd_link_hash_defined:
9002     case bfd_link_hash_defweak:
9003       {
9004         input_sec = h->root.u.def.section;
9005         if (input_sec->output_section != NULL)
9006           {
9007             if (eoinfo->localsyms && flinfo->filesym_count == 1)
9008               {
9009                 bfd_boolean second_pass_sym
9010                   = (input_sec->owner == flinfo->output_bfd
9011                      || input_sec->owner == NULL
9012                      || (input_sec->flags & SEC_LINKER_CREATED) != 0
9013                      || (input_sec->owner->flags & BFD_LINKER_CREATED) != 0);
9014
9015                 eoinfo->need_second_pass |= second_pass_sym;
9016                 if (eoinfo->second_pass != second_pass_sym)
9017                   return TRUE;
9018               }
9019
9020             sym.st_shndx =
9021               _bfd_elf_section_from_bfd_section (flinfo->output_bfd,
9022                                                  input_sec->output_section);
9023             if (sym.st_shndx == SHN_BAD)
9024               {
9025                 (*_bfd_error_handler)
9026                   (_("%B: could not find output section %A for input section %A"),
9027                    flinfo->output_bfd, input_sec->output_section, input_sec);
9028                 bfd_set_error (bfd_error_nonrepresentable_section);
9029                 eoinfo->failed = TRUE;
9030                 return FALSE;
9031               }
9032
9033             /* ELF symbols in relocatable files are section relative,
9034                but in nonrelocatable files they are virtual
9035                addresses.  */
9036             sym.st_value = h->root.u.def.value + input_sec->output_offset;
9037             if (!flinfo->info->relocatable)
9038               {
9039                 sym.st_value += input_sec->output_section->vma;
9040                 if (h->type == STT_TLS)
9041                   {
9042                     asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
9043                     if (tls_sec != NULL)
9044                       sym.st_value -= tls_sec->vma;
9045                     else
9046                       {
9047                         /* The TLS section may have been garbage collected.  */
9048                         BFD_ASSERT (flinfo->info->gc_sections
9049                                     && !input_sec->gc_mark);
9050                       }
9051                   }
9052               }
9053           }
9054         else
9055           {
9056             BFD_ASSERT (input_sec->owner == NULL
9057                         || (input_sec->owner->flags & DYNAMIC) != 0);
9058             sym.st_shndx = SHN_UNDEF;
9059             input_sec = bfd_und_section_ptr;
9060           }
9061       }
9062       break;
9063
9064     case bfd_link_hash_common:
9065       input_sec = h->root.u.c.p->section;
9066       sym.st_shndx = bed->common_section_index (input_sec);
9067       sym.st_value = 1 << h->root.u.c.p->alignment_power;
9068       break;
9069
9070     case bfd_link_hash_indirect:
9071       /* These symbols are created by symbol versioning.  They point
9072          to the decorated version of the name.  For example, if the
9073          symbol foo@@GNU_1.2 is the default, which should be used when
9074          foo is used with no version, then we add an indirect symbol
9075          foo which points to foo@@GNU_1.2.  We ignore these symbols,
9076          since the indirected symbol is already in the hash table.  */
9077       return TRUE;
9078     }
9079
9080   /* Give the processor backend a chance to tweak the symbol value,
9081      and also to finish up anything that needs to be done for this
9082      symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
9083      forced local syms when non-shared is due to a historical quirk.
9084      STT_GNU_IFUNC symbol must go through PLT.  */
9085   if ((h->type == STT_GNU_IFUNC
9086        && h->def_regular
9087        && !flinfo->info->relocatable)
9088       || ((h->dynindx != -1
9089            || h->forced_local)
9090           && ((flinfo->info->shared
9091                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9092                    || h->root.type != bfd_link_hash_undefweak))
9093               || !h->forced_local)
9094           && elf_hash_table (flinfo->info)->dynamic_sections_created))
9095     {
9096       if (! ((*bed->elf_backend_finish_dynamic_symbol)
9097              (flinfo->output_bfd, flinfo->info, h, &sym)))
9098         {
9099           eoinfo->failed = TRUE;
9100           return FALSE;
9101         }
9102     }
9103
9104   /* If we are marking the symbol as undefined, and there are no
9105      non-weak references to this symbol from a regular object, then
9106      mark the symbol as weak undefined; if there are non-weak
9107      references, mark the symbol as strong.  We can't do this earlier,
9108      because it might not be marked as undefined until the
9109      finish_dynamic_symbol routine gets through with it.  */
9110   if (sym.st_shndx == SHN_UNDEF
9111       && h->ref_regular
9112       && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
9113           || ELF_ST_BIND (sym.st_info) == STB_WEAK))
9114     {
9115       int bindtype;
9116       unsigned int type = ELF_ST_TYPE (sym.st_info);
9117
9118       /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9119       if (type == STT_GNU_IFUNC)
9120         type = STT_FUNC;
9121
9122       if (h->ref_regular_nonweak)
9123         bindtype = STB_GLOBAL;
9124       else
9125         bindtype = STB_WEAK;
9126       sym.st_info = ELF_ST_INFO (bindtype, type);
9127     }
9128
9129   /* If this is a symbol defined in a dynamic library, don't use the
9130      symbol size from the dynamic library.  Relinking an executable
9131      against a new library may introduce gratuitous changes in the
9132      executable's symbols if we keep the size.  */
9133   if (sym.st_shndx == SHN_UNDEF
9134       && !h->def_regular
9135       && h->def_dynamic)
9136     sym.st_size = 0;
9137
9138   /* If a non-weak symbol with non-default visibility is not defined
9139      locally, it is a fatal error.  */
9140   if (!flinfo->info->relocatable
9141       && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
9142       && ELF_ST_BIND (sym.st_info) != STB_WEAK
9143       && h->root.type == bfd_link_hash_undefined
9144       && !h->def_regular)
9145     {
9146       const char *msg;
9147
9148       if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
9149         msg = _("%B: protected symbol `%s' isn't defined");
9150       else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
9151         msg = _("%B: internal symbol `%s' isn't defined");
9152       else
9153         msg = _("%B: hidden symbol `%s' isn't defined");
9154       (*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
9155       bfd_set_error (bfd_error_bad_value);
9156       eoinfo->failed = TRUE;
9157       return FALSE;
9158     }
9159
9160   /* If this symbol should be put in the .dynsym section, then put it
9161      there now.  We already know the symbol index.  We also fill in
9162      the entry in the .hash section.  */
9163   if (flinfo->dynsym_sec != NULL
9164       && h->dynindx != -1
9165       && elf_hash_table (flinfo->info)->dynamic_sections_created)
9166     {
9167       bfd_byte *esym;
9168
9169       /* Since there is no version information in the dynamic string,
9170          if there is no version info in symbol version section, we will
9171          have a run-time problem.  */
9172       if (h->verinfo.verdef == NULL)
9173         {
9174           char *p = strrchr (h->root.root.string, ELF_VER_CHR);
9175
9176           if (p && p [1] != '\0')
9177             {
9178               (*_bfd_error_handler)
9179                 (_("%B: No symbol version section for versioned symbol `%s'"),
9180                  flinfo->output_bfd, h->root.root.string);
9181               eoinfo->failed = TRUE;
9182               return FALSE;
9183             }
9184         }
9185
9186       sym.st_name = h->dynstr_index;
9187       esym = flinfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
9188       if (!check_dynsym (flinfo->output_bfd, &sym))
9189         {
9190           eoinfo->failed = TRUE;
9191           return FALSE;
9192         }
9193       bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
9194
9195       if (flinfo->hash_sec != NULL)
9196         {
9197           size_t hash_entry_size;
9198           bfd_byte *bucketpos;
9199           bfd_vma chain;
9200           size_t bucketcount;
9201           size_t bucket;
9202
9203           bucketcount = elf_hash_table (flinfo->info)->bucketcount;
9204           bucket = h->u.elf_hash_value % bucketcount;
9205
9206           hash_entry_size
9207             = elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
9208           bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
9209                        + (bucket + 2) * hash_entry_size);
9210           chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
9211           bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
9212                    bucketpos);
9213           bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
9214                    ((bfd_byte *) flinfo->hash_sec->contents
9215                     + (bucketcount + 2 + h->dynindx) * hash_entry_size));
9216         }
9217
9218       if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
9219         {
9220           Elf_Internal_Versym iversym;
9221           Elf_External_Versym *eversym;
9222
9223           if (!h->def_regular)
9224             {
9225               if (h->verinfo.verdef == NULL
9226                   || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
9227                       & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
9228                 iversym.vs_vers = 0;
9229               else
9230                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
9231             }
9232           else
9233             {
9234               if (h->verinfo.vertree == NULL)
9235                 iversym.vs_vers = 1;
9236               else
9237                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
9238               if (flinfo->info->create_default_symver)
9239                 iversym.vs_vers++;
9240             }
9241
9242           if (h->hidden)
9243             iversym.vs_vers |= VERSYM_HIDDEN;
9244
9245           eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
9246           eversym += h->dynindx;
9247           _bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
9248         }
9249     }
9250
9251   /* If we're stripping it, then it was just a dynamic symbol, and
9252      there's nothing else to do.  */
9253   if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
9254     return TRUE;
9255
9256   indx = bfd_get_symcount (flinfo->output_bfd);
9257   ret = elf_link_output_sym (flinfo, h->root.root.string, &sym, input_sec, h);
9258   if (ret == 0)
9259     {
9260       eoinfo->failed = TRUE;
9261       return FALSE;
9262     }
9263   else if (ret == 1)
9264     h->indx = indx;
9265   else if (h->indx == -2)
9266     abort();
9267
9268   return TRUE;
9269 }
9270
9271 /* Return TRUE if special handling is done for relocs in SEC against
9272    symbols defined in discarded sections.  */
9273
9274 static bfd_boolean
9275 elf_section_ignore_discarded_relocs (asection *sec)
9276 {
9277   const struct elf_backend_data *bed;
9278
9279   switch (sec->sec_info_type)
9280     {
9281     case SEC_INFO_TYPE_STABS:
9282     case SEC_INFO_TYPE_EH_FRAME:
9283       return TRUE;
9284     default:
9285       break;
9286     }
9287
9288   bed = get_elf_backend_data (sec->owner);
9289   if (bed->elf_backend_ignore_discarded_relocs != NULL
9290       && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9291     return TRUE;
9292
9293   return FALSE;
9294 }
9295
9296 /* Return a mask saying how ld should treat relocations in SEC against
9297    symbols defined in discarded sections.  If this function returns
9298    COMPLAIN set, ld will issue a warning message.  If this function
9299    returns PRETEND set, and the discarded section was link-once and the
9300    same size as the kept link-once section, ld will pretend that the
9301    symbol was actually defined in the kept section.  Otherwise ld will
9302    zero the reloc (at least that is the intent, but some cooperation by
9303    the target dependent code is needed, particularly for REL targets).  */
9304
9305 unsigned int
9306 _bfd_elf_default_action_discarded (asection *sec)
9307 {
9308   if (sec->flags & SEC_DEBUGGING)
9309     return PRETEND;
9310
9311   if (strcmp (".eh_frame", sec->name) == 0)
9312     return 0;
9313
9314   if (strcmp (".gcc_except_table", sec->name) == 0)
9315     return 0;
9316
9317   return COMPLAIN | PRETEND;
9318 }
9319
9320 /* Find a match between a section and a member of a section group.  */
9321
9322 static asection *
9323 match_group_member (asection *sec, asection *group,
9324                     struct bfd_link_info *info)
9325 {
9326   asection *first = elf_next_in_group (group);
9327   asection *s = first;
9328
9329   while (s != NULL)
9330     {
9331       if (bfd_elf_match_symbols_in_sections (s, sec, info))
9332         return s;
9333
9334       s = elf_next_in_group (s);
9335       if (s == first)
9336         break;
9337     }
9338
9339   return NULL;
9340 }
9341
9342 /* Check if the kept section of a discarded section SEC can be used
9343    to replace it.  Return the replacement if it is OK.  Otherwise return
9344    NULL.  */
9345
9346 asection *
9347 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9348 {
9349   asection *kept;
9350
9351   kept = sec->kept_section;
9352   if (kept != NULL)
9353     {
9354       if ((kept->flags & SEC_GROUP) != 0)
9355         kept = match_group_member (sec, kept, info);
9356       if (kept != NULL
9357           && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9358               != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9359         kept = NULL;
9360       sec->kept_section = kept;
9361     }
9362   return kept;
9363 }
9364
9365 /* Link an input file into the linker output file.  This function
9366    handles all the sections and relocations of the input file at once.
9367    This is so that we only have to read the local symbols once, and
9368    don't have to keep them in memory.  */
9369
9370 static bfd_boolean
9371 elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
9372 {
9373   int (*relocate_section)
9374     (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9375      Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9376   bfd *output_bfd;
9377   Elf_Internal_Shdr *symtab_hdr;
9378   size_t locsymcount;
9379   size_t extsymoff;
9380   Elf_Internal_Sym *isymbuf;
9381   Elf_Internal_Sym *isym;
9382   Elf_Internal_Sym *isymend;
9383   long *pindex;
9384   asection **ppsection;
9385   asection *o;
9386   const struct elf_backend_data *bed;
9387   struct elf_link_hash_entry **sym_hashes;
9388   bfd_size_type address_size;
9389   bfd_vma r_type_mask;
9390   int r_sym_shift;
9391   bfd_boolean have_file_sym = FALSE;
9392
9393   output_bfd = flinfo->output_bfd;
9394   bed = get_elf_backend_data (output_bfd);
9395   relocate_section = bed->elf_backend_relocate_section;
9396
9397   /* If this is a dynamic object, we don't want to do anything here:
9398      we don't want the local symbols, and we don't want the section
9399      contents.  */
9400   if ((input_bfd->flags & DYNAMIC) != 0)
9401     return TRUE;
9402
9403   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9404   if (elf_bad_symtab (input_bfd))
9405     {
9406       locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9407       extsymoff = 0;
9408     }
9409   else
9410     {
9411       locsymcount = symtab_hdr->sh_info;
9412       extsymoff = symtab_hdr->sh_info;
9413     }
9414
9415   /* Read the local symbols.  */
9416   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9417   if (isymbuf == NULL && locsymcount != 0)
9418     {
9419       isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9420                                       flinfo->internal_syms,
9421                                       flinfo->external_syms,
9422                                       flinfo->locsym_shndx);
9423       if (isymbuf == NULL)
9424         return FALSE;
9425     }
9426
9427   /* Find local symbol sections and adjust values of symbols in
9428      SEC_MERGE sections.  Write out those local symbols we know are
9429      going into the output file.  */
9430   isymend = isymbuf + locsymcount;
9431   for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
9432        isym < isymend;
9433        isym++, pindex++, ppsection++)
9434     {
9435       asection *isec;
9436       const char *name;
9437       Elf_Internal_Sym osym;
9438       long indx;
9439       int ret;
9440
9441       *pindex = -1;
9442
9443       if (elf_bad_symtab (input_bfd))
9444         {
9445           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9446             {
9447               *ppsection = NULL;
9448               continue;
9449             }
9450         }
9451
9452       if (isym->st_shndx == SHN_UNDEF)
9453         isec = bfd_und_section_ptr;
9454       else if (isym->st_shndx == SHN_ABS)
9455         isec = bfd_abs_section_ptr;
9456       else if (isym->st_shndx == SHN_COMMON)
9457         isec = bfd_com_section_ptr;
9458       else
9459         {
9460           isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9461           if (isec == NULL)
9462             {
9463               /* Don't attempt to output symbols with st_shnx in the
9464                  reserved range other than SHN_ABS and SHN_COMMON.  */
9465               *ppsection = NULL;
9466               continue;
9467             }
9468           else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
9469                    && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9470             isym->st_value =
9471               _bfd_merged_section_offset (output_bfd, &isec,
9472                                           elf_section_data (isec)->sec_info,
9473                                           isym->st_value);
9474         }
9475
9476       *ppsection = isec;
9477
9478       /* Don't output the first, undefined, symbol.  */
9479       if (ppsection == flinfo->sections)
9480         continue;
9481
9482       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9483         {
9484           /* We never output section symbols.  Instead, we use the
9485              section symbol of the corresponding section in the output
9486              file.  */
9487           continue;
9488         }
9489
9490       /* If we are stripping all symbols, we don't want to output this
9491          one.  */
9492       if (flinfo->info->strip == strip_all)
9493         continue;
9494
9495       /* If we are discarding all local symbols, we don't want to
9496          output this one.  If we are generating a relocatable output
9497          file, then some of the local symbols may be required by
9498          relocs; we output them below as we discover that they are
9499          needed.  */
9500       if (flinfo->info->discard == discard_all)
9501         continue;
9502
9503       /* If this symbol is defined in a section which we are
9504          discarding, we don't need to keep it.  */
9505       if (isym->st_shndx != SHN_UNDEF
9506           && isym->st_shndx < SHN_LORESERVE
9507           && bfd_section_removed_from_list (output_bfd,
9508                                             isec->output_section))
9509         continue;
9510
9511       /* Get the name of the symbol.  */
9512       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9513                                               isym->st_name);
9514       if (name == NULL)
9515         return FALSE;
9516
9517       /* See if we are discarding symbols with this name.  */
9518       if ((flinfo->info->strip == strip_some
9519            && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
9520                == NULL))
9521           || (((flinfo->info->discard == discard_sec_merge
9522                 && (isec->flags & SEC_MERGE) && !flinfo->info->relocatable)
9523                || flinfo->info->discard == discard_l)
9524               && bfd_is_local_label_name (input_bfd, name)))
9525         continue;
9526
9527       if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
9528         {
9529           have_file_sym = TRUE;
9530           flinfo->filesym_count += 1;
9531         }
9532       if (!have_file_sym)
9533         {
9534           /* In the absence of debug info, bfd_find_nearest_line uses
9535              FILE symbols to determine the source file for local
9536              function symbols.  Provide a FILE symbol here if input
9537              files lack such, so that their symbols won't be
9538              associated with a previous input file.  It's not the
9539              source file, but the best we can do.  */
9540           have_file_sym = TRUE;
9541           flinfo->filesym_count += 1;
9542           memset (&osym, 0, sizeof (osym));
9543           osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9544           osym.st_shndx = SHN_ABS;
9545           if (!elf_link_output_sym (flinfo, input_bfd->filename, &osym,
9546                                     bfd_abs_section_ptr, NULL))
9547             return FALSE;
9548         }
9549
9550       osym = *isym;
9551
9552       /* Adjust the section index for the output file.  */
9553       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9554                                                          isec->output_section);
9555       if (osym.st_shndx == SHN_BAD)
9556         return FALSE;
9557
9558       /* ELF symbols in relocatable files are section relative, but
9559          in executable files they are virtual addresses.  Note that
9560          this code assumes that all ELF sections have an associated
9561          BFD section with a reasonable value for output_offset; below
9562          we assume that they also have a reasonable value for
9563          output_section.  Any special sections must be set up to meet
9564          these requirements.  */
9565       osym.st_value += isec->output_offset;
9566       if (!flinfo->info->relocatable)
9567         {
9568           osym.st_value += isec->output_section->vma;
9569           if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9570             {
9571               /* STT_TLS symbols are relative to PT_TLS segment base.  */
9572               BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
9573               osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
9574             }
9575         }
9576
9577       indx = bfd_get_symcount (output_bfd);
9578       ret = elf_link_output_sym (flinfo, name, &osym, isec, NULL);
9579       if (ret == 0)
9580         return FALSE;
9581       else if (ret == 1)
9582         *pindex = indx;
9583     }
9584
9585   if (bed->s->arch_size == 32)
9586     {
9587       r_type_mask = 0xff;
9588       r_sym_shift = 8;
9589       address_size = 4;
9590     }
9591   else
9592     {
9593       r_type_mask = 0xffffffff;
9594       r_sym_shift = 32;
9595       address_size = 8;
9596     }
9597
9598   /* Relocate the contents of each section.  */
9599   sym_hashes = elf_sym_hashes (input_bfd);
9600   for (o = input_bfd->sections; o != NULL; o = o->next)
9601     {
9602       bfd_byte *contents;
9603
9604       if (! o->linker_mark)
9605         {
9606           /* This section was omitted from the link.  */
9607           continue;
9608         }
9609
9610       if (flinfo->info->relocatable
9611           && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9612         {
9613           /* Deal with the group signature symbol.  */
9614           struct bfd_elf_section_data *sec_data = elf_section_data (o);
9615           unsigned long symndx = sec_data->this_hdr.sh_info;
9616           asection *osec = o->output_section;
9617
9618           if (symndx >= locsymcount
9619               || (elf_bad_symtab (input_bfd)
9620                   && flinfo->sections[symndx] == NULL))
9621             {
9622               struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9623               while (h->root.type == bfd_link_hash_indirect
9624                      || h->root.type == bfd_link_hash_warning)
9625                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9626               /* Arrange for symbol to be output.  */
9627               h->indx = -2;
9628               elf_section_data (osec)->this_hdr.sh_info = -2;
9629             }
9630           else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9631             {
9632               /* We'll use the output section target_index.  */
9633               asection *sec = flinfo->sections[symndx]->output_section;
9634               elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9635             }
9636           else
9637             {
9638               if (flinfo->indices[symndx] == -1)
9639                 {
9640                   /* Otherwise output the local symbol now.  */
9641                   Elf_Internal_Sym sym = isymbuf[symndx];
9642                   asection *sec = flinfo->sections[symndx]->output_section;
9643                   const char *name;
9644                   long indx;
9645                   int ret;
9646
9647                   name = bfd_elf_string_from_elf_section (input_bfd,
9648                                                           symtab_hdr->sh_link,
9649                                                           sym.st_name);
9650                   if (name == NULL)
9651                     return FALSE;
9652
9653                   sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9654                                                                     sec);
9655                   if (sym.st_shndx == SHN_BAD)
9656                     return FALSE;
9657
9658                   sym.st_value += o->output_offset;
9659
9660                   indx = bfd_get_symcount (output_bfd);
9661                   ret = elf_link_output_sym (flinfo, name, &sym, o, NULL);
9662                   if (ret == 0)
9663                     return FALSE;
9664                   else if (ret == 1)
9665                     flinfo->indices[symndx] = indx;
9666                   else
9667                     abort ();
9668                 }
9669               elf_section_data (osec)->this_hdr.sh_info
9670                 = flinfo->indices[symndx];
9671             }
9672         }
9673
9674       if ((o->flags & SEC_HAS_CONTENTS) == 0
9675           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9676         continue;
9677
9678       if ((o->flags & SEC_LINKER_CREATED) != 0)
9679         {
9680           /* Section was created by _bfd_elf_link_create_dynamic_sections
9681              or somesuch.  */
9682           continue;
9683         }
9684
9685       /* Get the contents of the section.  They have been cached by a
9686          relaxation routine.  Note that o is a section in an input
9687          file, so the contents field will not have been set by any of
9688          the routines which work on output files.  */
9689       if (elf_section_data (o)->this_hdr.contents != NULL)
9690         {
9691           contents = elf_section_data (o)->this_hdr.contents;
9692           if (bed->caches_rawsize
9693               && o->rawsize != 0
9694               && o->rawsize < o->size)
9695             {
9696               memcpy (flinfo->contents, contents, o->rawsize);
9697               contents = flinfo->contents;
9698             }
9699         }
9700       else
9701         {
9702           contents = flinfo->contents;
9703           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
9704             return FALSE;
9705         }
9706
9707       if ((o->flags & SEC_RELOC) != 0)
9708         {
9709           Elf_Internal_Rela *internal_relocs;
9710           Elf_Internal_Rela *rel, *relend;
9711           int action_discarded;
9712           int ret;
9713
9714           /* Get the swapped relocs.  */
9715           internal_relocs
9716             = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
9717                                          flinfo->internal_relocs, FALSE);
9718           if (internal_relocs == NULL
9719               && o->reloc_count > 0)
9720             return FALSE;
9721
9722           /* We need to reverse-copy input .ctors/.dtors sections if
9723              they are placed in .init_array/.finit_array for output.  */
9724           if (o->size > address_size
9725               && ((strncmp (o->name, ".ctors", 6) == 0
9726                    && strcmp (o->output_section->name,
9727                               ".init_array") == 0)
9728                   || (strncmp (o->name, ".dtors", 6) == 0
9729                       && strcmp (o->output_section->name,
9730                                  ".fini_array") == 0))
9731               && (o->name[6] == 0 || o->name[6] == '.'))
9732             {
9733               if (o->size != o->reloc_count * address_size)
9734                 {
9735                   (*_bfd_error_handler)
9736                     (_("error: %B: size of section %A is not "
9737                        "multiple of address size"),
9738                      input_bfd, o);
9739                   bfd_set_error (bfd_error_on_input);
9740                   return FALSE;
9741                 }
9742               o->flags |= SEC_ELF_REVERSE_COPY;
9743             }
9744
9745           action_discarded = -1;
9746           if (!elf_section_ignore_discarded_relocs (o))
9747             action_discarded = (*bed->action_discarded) (o);
9748
9749           /* Run through the relocs evaluating complex reloc symbols and
9750              looking for relocs against symbols from discarded sections
9751              or section symbols from removed link-once sections.
9752              Complain about relocs against discarded sections.  Zero
9753              relocs against removed link-once sections.  */
9754
9755           rel = internal_relocs;
9756           relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9757           for ( ; rel < relend; rel++)
9758             {
9759               unsigned long r_symndx = rel->r_info >> r_sym_shift;
9760               unsigned int s_type;
9761               asection **ps, *sec;
9762               struct elf_link_hash_entry *h = NULL;
9763               const char *sym_name;
9764
9765               if (r_symndx == STN_UNDEF)
9766                 continue;
9767
9768               if (r_symndx >= locsymcount
9769                   || (elf_bad_symtab (input_bfd)
9770                       && flinfo->sections[r_symndx] == NULL))
9771                 {
9772                   h = sym_hashes[r_symndx - extsymoff];
9773
9774                   /* Badly formatted input files can contain relocs that
9775                      reference non-existant symbols.  Check here so that
9776                      we do not seg fault.  */
9777                   if (h == NULL)
9778                     {
9779                       char buffer [32];
9780
9781                       sprintf_vma (buffer, rel->r_info);
9782                       (*_bfd_error_handler)
9783                         (_("error: %B contains a reloc (0x%s) for section %A "
9784                            "that references a non-existent global symbol"),
9785                          input_bfd, o, buffer);
9786                       bfd_set_error (bfd_error_bad_value);
9787                       return FALSE;
9788                     }
9789
9790                   while (h->root.type == bfd_link_hash_indirect
9791                          || h->root.type == bfd_link_hash_warning)
9792                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9793
9794                   s_type = h->type;
9795
9796                   ps = NULL;
9797                   if (h->root.type == bfd_link_hash_defined
9798                       || h->root.type == bfd_link_hash_defweak)
9799                     ps = &h->root.u.def.section;
9800
9801                   sym_name = h->root.root.string;
9802                 }
9803               else
9804                 {
9805                   Elf_Internal_Sym *sym = isymbuf + r_symndx;
9806
9807                   s_type = ELF_ST_TYPE (sym->st_info);
9808                   ps = &flinfo->sections[r_symndx];
9809                   sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9810                                                sym, *ps);
9811                 }
9812
9813               if ((s_type == STT_RELC || s_type == STT_SRELC)
9814                   && !flinfo->info->relocatable)
9815                 {
9816                   bfd_vma val;
9817                   bfd_vma dot = (rel->r_offset
9818                                  + o->output_offset + o->output_section->vma);
9819 #ifdef DEBUG
9820                   printf ("Encountered a complex symbol!");
9821                   printf (" (input_bfd %s, section %s, reloc %ld\n",
9822                           input_bfd->filename, o->name,
9823                           (long) (rel - internal_relocs));
9824                   printf (" symbol: idx  %8.8lx, name %s\n",
9825                           r_symndx, sym_name);
9826                   printf (" reloc : info %8.8lx, addr %8.8lx\n",
9827                           (unsigned long) rel->r_info,
9828                           (unsigned long) rel->r_offset);
9829 #endif
9830                   if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
9831                                     isymbuf, locsymcount, s_type == STT_SRELC))
9832                     return FALSE;
9833
9834                   /* Symbol evaluated OK.  Update to absolute value.  */
9835                   set_symbol_value (input_bfd, isymbuf, locsymcount,
9836                                     r_symndx, val);
9837                   continue;
9838                 }
9839
9840               if (action_discarded != -1 && ps != NULL)
9841                 {
9842                   /* Complain if the definition comes from a
9843                      discarded section.  */
9844                   if ((sec = *ps) != NULL && discarded_section (sec))
9845                     {
9846                       BFD_ASSERT (r_symndx != STN_UNDEF);
9847                       if (action_discarded & COMPLAIN)
9848                         (*flinfo->info->callbacks->einfo)
9849                           (_("%X`%s' referenced in section `%A' of %B: "
9850                              "defined in discarded section `%A' of %B\n"),
9851                            sym_name, o, input_bfd, sec, sec->owner);
9852
9853                       /* Try to do the best we can to support buggy old
9854                          versions of gcc.  Pretend that the symbol is
9855                          really defined in the kept linkonce section.
9856                          FIXME: This is quite broken.  Modifying the
9857                          symbol here means we will be changing all later
9858                          uses of the symbol, not just in this section.  */
9859                       if (action_discarded & PRETEND)
9860                         {
9861                           asection *kept;
9862
9863                           kept = _bfd_elf_check_kept_section (sec,
9864                                                               flinfo->info);
9865                           if (kept != NULL)
9866                             {
9867                               *ps = kept;
9868                               continue;
9869                             }
9870                         }
9871                     }
9872                 }
9873             }
9874
9875           /* Relocate the section by invoking a back end routine.
9876
9877              The back end routine is responsible for adjusting the
9878              section contents as necessary, and (if using Rela relocs
9879              and generating a relocatable output file) adjusting the
9880              reloc addend as necessary.
9881
9882              The back end routine does not have to worry about setting
9883              the reloc address or the reloc symbol index.
9884
9885              The back end routine is given a pointer to the swapped in
9886              internal symbols, and can access the hash table entries
9887              for the external symbols via elf_sym_hashes (input_bfd).
9888
9889              When generating relocatable output, the back end routine
9890              must handle STB_LOCAL/STT_SECTION symbols specially.  The
9891              output symbol is going to be a section symbol
9892              corresponding to the output section, which will require
9893              the addend to be adjusted.  */
9894
9895           ret = (*relocate_section) (output_bfd, flinfo->info,
9896                                      input_bfd, o, contents,
9897                                      internal_relocs,
9898                                      isymbuf,
9899                                      flinfo->sections);
9900           if (!ret)
9901             return FALSE;
9902
9903           if (ret == 2
9904               || flinfo->info->relocatable
9905               || flinfo->info->emitrelocations)
9906             {
9907               Elf_Internal_Rela *irela;
9908               Elf_Internal_Rela *irelaend, *irelamid;
9909               bfd_vma last_offset;
9910               struct elf_link_hash_entry **rel_hash;
9911               struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9912               Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9913               unsigned int next_erel;
9914               bfd_boolean rela_normal;
9915               struct bfd_elf_section_data *esdi, *esdo;
9916
9917               esdi = elf_section_data (o);
9918               esdo = elf_section_data (o->output_section);
9919               rela_normal = FALSE;
9920
9921               /* Adjust the reloc addresses and symbol indices.  */
9922
9923               irela = internal_relocs;
9924               irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9925               rel_hash = esdo->rel.hashes + esdo->rel.count;
9926               /* We start processing the REL relocs, if any.  When we reach
9927                  IRELAMID in the loop, we switch to the RELA relocs.  */
9928               irelamid = irela;
9929               if (esdi->rel.hdr != NULL)
9930                 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9931                              * bed->s->int_rels_per_ext_rel);
9932               rel_hash_list = rel_hash;
9933               rela_hash_list = NULL;
9934               last_offset = o->output_offset;
9935               if (!flinfo->info->relocatable)
9936                 last_offset += o->output_section->vma;
9937               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9938                 {
9939                   unsigned long r_symndx;
9940                   asection *sec;
9941                   Elf_Internal_Sym sym;
9942
9943                   if (next_erel == bed->s->int_rels_per_ext_rel)
9944                     {
9945                       rel_hash++;
9946                       next_erel = 0;
9947                     }
9948
9949                   if (irela == irelamid)
9950                     {
9951                       rel_hash = esdo->rela.hashes + esdo->rela.count;
9952                       rela_hash_list = rel_hash;
9953                       rela_normal = bed->rela_normal;
9954                     }
9955
9956                   irela->r_offset = _bfd_elf_section_offset (output_bfd,
9957                                                              flinfo->info, o,
9958                                                              irela->r_offset);
9959                   if (irela->r_offset >= (bfd_vma) -2)
9960                     {
9961                       /* This is a reloc for a deleted entry or somesuch.
9962                          Turn it into an R_*_NONE reloc, at the same
9963                          offset as the last reloc.  elf_eh_frame.c and
9964                          bfd_elf_discard_info rely on reloc offsets
9965                          being ordered.  */
9966                       irela->r_offset = last_offset;
9967                       irela->r_info = 0;
9968                       irela->r_addend = 0;
9969                       continue;
9970                     }
9971
9972                   irela->r_offset += o->output_offset;
9973
9974                   /* Relocs in an executable have to be virtual addresses.  */
9975                   if (!flinfo->info->relocatable)
9976                     irela->r_offset += o->output_section->vma;
9977
9978                   last_offset = irela->r_offset;
9979
9980                   r_symndx = irela->r_info >> r_sym_shift;
9981                   if (r_symndx == STN_UNDEF)
9982                     continue;
9983
9984                   if (r_symndx >= locsymcount
9985                       || (elf_bad_symtab (input_bfd)
9986                           && flinfo->sections[r_symndx] == NULL))
9987                     {
9988                       struct elf_link_hash_entry *rh;
9989                       unsigned long indx;
9990
9991                       /* This is a reloc against a global symbol.  We
9992                          have not yet output all the local symbols, so
9993                          we do not know the symbol index of any global
9994                          symbol.  We set the rel_hash entry for this
9995                          reloc to point to the global hash table entry
9996                          for this symbol.  The symbol index is then
9997                          set at the end of bfd_elf_final_link.  */
9998                       indx = r_symndx - extsymoff;
9999                       rh = elf_sym_hashes (input_bfd)[indx];
10000                       while (rh->root.type == bfd_link_hash_indirect
10001                              || rh->root.type == bfd_link_hash_warning)
10002                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
10003
10004                       /* Setting the index to -2 tells
10005                          elf_link_output_extsym that this symbol is
10006                          used by a reloc.  */
10007                       BFD_ASSERT (rh->indx < 0);
10008                       rh->indx = -2;
10009
10010                       *rel_hash = rh;
10011
10012                       continue;
10013                     }
10014
10015                   /* This is a reloc against a local symbol.  */
10016
10017                   *rel_hash = NULL;
10018                   sym = isymbuf[r_symndx];
10019                   sec = flinfo->sections[r_symndx];
10020                   if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
10021                     {
10022                       /* I suppose the backend ought to fill in the
10023                          section of any STT_SECTION symbol against a
10024                          processor specific section.  */
10025                       r_symndx = STN_UNDEF;
10026                       if (bfd_is_abs_section (sec))
10027                         ;
10028                       else if (sec == NULL || sec->owner == NULL)
10029                         {
10030                           bfd_set_error (bfd_error_bad_value);
10031                           return FALSE;
10032                         }
10033                       else
10034                         {
10035                           asection *osec = sec->output_section;
10036
10037                           /* If we have discarded a section, the output
10038                              section will be the absolute section.  In
10039                              case of discarded SEC_MERGE sections, use
10040                              the kept section.  relocate_section should
10041                              have already handled discarded linkonce
10042                              sections.  */
10043                           if (bfd_is_abs_section (osec)
10044                               && sec->kept_section != NULL
10045                               && sec->kept_section->output_section != NULL)
10046                             {
10047                               osec = sec->kept_section->output_section;
10048                               irela->r_addend -= osec->vma;
10049                             }
10050
10051                           if (!bfd_is_abs_section (osec))
10052                             {
10053                               r_symndx = osec->target_index;
10054                               if (r_symndx == STN_UNDEF)
10055                                 {
10056                                   irela->r_addend += osec->vma;
10057                                   osec = _bfd_nearby_section (output_bfd, osec,
10058                                                               osec->vma);
10059                                   irela->r_addend -= osec->vma;
10060                                   r_symndx = osec->target_index;
10061                                 }
10062                             }
10063                         }
10064
10065                       /* Adjust the addend according to where the
10066                          section winds up in the output section.  */
10067                       if (rela_normal)
10068                         irela->r_addend += sec->output_offset;
10069                     }
10070                   else
10071                     {
10072                       if (flinfo->indices[r_symndx] == -1)
10073                         {
10074                           unsigned long shlink;
10075                           const char *name;
10076                           asection *osec;
10077                           long indx;
10078
10079                           if (flinfo->info->strip == strip_all)
10080                             {
10081                               /* You can't do ld -r -s.  */
10082                               bfd_set_error (bfd_error_invalid_operation);
10083                               return FALSE;
10084                             }
10085
10086                           /* This symbol was skipped earlier, but
10087                              since it is needed by a reloc, we
10088                              must output it now.  */
10089                           shlink = symtab_hdr->sh_link;
10090                           name = (bfd_elf_string_from_elf_section
10091                                   (input_bfd, shlink, sym.st_name));
10092                           if (name == NULL)
10093                             return FALSE;
10094
10095                           osec = sec->output_section;
10096                           sym.st_shndx =
10097                             _bfd_elf_section_from_bfd_section (output_bfd,
10098                                                                osec);
10099                           if (sym.st_shndx == SHN_BAD)
10100                             return FALSE;
10101
10102                           sym.st_value += sec->output_offset;
10103                           if (!flinfo->info->relocatable)
10104                             {
10105                               sym.st_value += osec->vma;
10106                               if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
10107                                 {
10108                                   /* STT_TLS symbols are relative to PT_TLS
10109                                      segment base.  */
10110                                   BFD_ASSERT (elf_hash_table (flinfo->info)
10111                                               ->tls_sec != NULL);
10112                                   sym.st_value -= (elf_hash_table (flinfo->info)
10113                                                    ->tls_sec->vma);
10114                                 }
10115                             }
10116
10117                           indx = bfd_get_symcount (output_bfd);
10118                           ret = elf_link_output_sym (flinfo, name, &sym, sec,
10119                                                      NULL);
10120                           if (ret == 0)
10121                             return FALSE;
10122                           else if (ret == 1)
10123                             flinfo->indices[r_symndx] = indx;
10124                           else
10125                             abort ();
10126                         }
10127
10128                       r_symndx = flinfo->indices[r_symndx];
10129                     }
10130
10131                   irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
10132                                    | (irela->r_info & r_type_mask));
10133                 }
10134
10135               /* Swap out the relocs.  */
10136               input_rel_hdr = esdi->rel.hdr;
10137               if (input_rel_hdr && input_rel_hdr->sh_size != 0)
10138                 {
10139                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10140                                                      input_rel_hdr,
10141                                                      internal_relocs,
10142                                                      rel_hash_list))
10143                     return FALSE;
10144                   internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
10145                                       * bed->s->int_rels_per_ext_rel);
10146                   rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
10147                 }
10148
10149               input_rela_hdr = esdi->rela.hdr;
10150               if (input_rela_hdr && input_rela_hdr->sh_size != 0)
10151                 {
10152                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10153                                                      input_rela_hdr,
10154                                                      internal_relocs,
10155                                                      rela_hash_list))
10156                     return FALSE;
10157                 }
10158             }
10159         }
10160
10161       /* Write out the modified section contents.  */
10162       if (bed->elf_backend_write_section
10163           && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
10164                                                 contents))
10165         {
10166           /* Section written out.  */
10167         }
10168       else switch (o->sec_info_type)
10169         {
10170         case SEC_INFO_TYPE_STABS:
10171           if (! (_bfd_write_section_stabs
10172                  (output_bfd,
10173                   &elf_hash_table (flinfo->info)->stab_info,
10174                   o, &elf_section_data (o)->sec_info, contents)))
10175             return FALSE;
10176           break;
10177         case SEC_INFO_TYPE_MERGE:
10178           if (! _bfd_write_merged_section (output_bfd, o,
10179                                            elf_section_data (o)->sec_info))
10180             return FALSE;
10181           break;
10182         case SEC_INFO_TYPE_EH_FRAME:
10183           {
10184             if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10185                                                    o, contents))
10186               return FALSE;
10187           }
10188           break;
10189         default:
10190           {
10191             /* FIXME: octets_per_byte.  */
10192             if (! (o->flags & SEC_EXCLUDE))
10193               {
10194                 file_ptr offset = (file_ptr) o->output_offset;
10195                 bfd_size_type todo = o->size;
10196                 if ((o->flags & SEC_ELF_REVERSE_COPY))
10197                   {
10198                     /* Reverse-copy input section to output.  */
10199                     do
10200                       {
10201                         todo -= address_size;
10202                         if (! bfd_set_section_contents (output_bfd,
10203                                                         o->output_section,
10204                                                         contents + todo,
10205                                                         offset,
10206                                                         address_size))
10207                           return FALSE;
10208                         if (todo == 0)
10209                           break;
10210                         offset += address_size;
10211                       }
10212                     while (1);
10213                   }
10214                 else if (! bfd_set_section_contents (output_bfd,
10215                                                      o->output_section,
10216                                                      contents,
10217                                                      offset, todo))
10218                   return FALSE;
10219               }
10220           }
10221           break;
10222         }
10223     }
10224
10225   return TRUE;
10226 }
10227
10228 /* Generate a reloc when linking an ELF file.  This is a reloc
10229    requested by the linker, and does not come from any input file.  This
10230    is used to build constructor and destructor tables when linking
10231    with -Ur.  */
10232
10233 static bfd_boolean
10234 elf_reloc_link_order (bfd *output_bfd,
10235                       struct bfd_link_info *info,
10236                       asection *output_section,
10237                       struct bfd_link_order *link_order)
10238 {
10239   reloc_howto_type *howto;
10240   long indx;
10241   bfd_vma offset;
10242   bfd_vma addend;
10243   struct bfd_elf_section_reloc_data *reldata;
10244   struct elf_link_hash_entry **rel_hash_ptr;
10245   Elf_Internal_Shdr *rel_hdr;
10246   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10247   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10248   bfd_byte *erel;
10249   unsigned int i;
10250   struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10251
10252   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10253   if (howto == NULL)
10254     {
10255       bfd_set_error (bfd_error_bad_value);
10256       return FALSE;
10257     }
10258
10259   addend = link_order->u.reloc.p->addend;
10260
10261   if (esdo->rel.hdr)
10262     reldata = &esdo->rel;
10263   else if (esdo->rela.hdr)
10264     reldata = &esdo->rela;
10265   else
10266     {
10267       reldata = NULL;
10268       BFD_ASSERT (0);
10269     }
10270
10271   /* Figure out the symbol index.  */
10272   rel_hash_ptr = reldata->hashes + reldata->count;
10273   if (link_order->type == bfd_section_reloc_link_order)
10274     {
10275       indx = link_order->u.reloc.p->u.section->target_index;
10276       BFD_ASSERT (indx != 0);
10277       *rel_hash_ptr = NULL;
10278     }
10279   else
10280     {
10281       struct elf_link_hash_entry *h;
10282
10283       /* Treat a reloc against a defined symbol as though it were
10284          actually against the section.  */
10285       h = ((struct elf_link_hash_entry *)
10286            bfd_wrapped_link_hash_lookup (output_bfd, info,
10287                                          link_order->u.reloc.p->u.name,
10288                                          FALSE, FALSE, TRUE));
10289       if (h != NULL
10290           && (h->root.type == bfd_link_hash_defined
10291               || h->root.type == bfd_link_hash_defweak))
10292         {
10293           asection *section;
10294
10295           section = h->root.u.def.section;
10296           indx = section->output_section->target_index;
10297           *rel_hash_ptr = NULL;
10298           /* It seems that we ought to add the symbol value to the
10299              addend here, but in practice it has already been added
10300              because it was passed to constructor_callback.  */
10301           addend += section->output_section->vma + section->output_offset;
10302         }
10303       else if (h != NULL)
10304         {
10305           /* Setting the index to -2 tells elf_link_output_extsym that
10306              this symbol is used by a reloc.  */
10307           h->indx = -2;
10308           *rel_hash_ptr = h;
10309           indx = 0;
10310         }
10311       else
10312         {
10313           if (! ((*info->callbacks->unattached_reloc)
10314                  (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10315             return FALSE;
10316           indx = 0;
10317         }
10318     }
10319
10320   /* If this is an inplace reloc, we must write the addend into the
10321      object file.  */
10322   if (howto->partial_inplace && addend != 0)
10323     {
10324       bfd_size_type size;
10325       bfd_reloc_status_type rstat;
10326       bfd_byte *buf;
10327       bfd_boolean ok;
10328       const char *sym_name;
10329
10330       size = (bfd_size_type) bfd_get_reloc_size (howto);
10331       buf = (bfd_byte *) bfd_zmalloc (size);
10332       if (buf == NULL && size != 0)
10333         return FALSE;
10334       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10335       switch (rstat)
10336         {
10337         case bfd_reloc_ok:
10338           break;
10339
10340         default:
10341         case bfd_reloc_outofrange:
10342           abort ();
10343
10344         case bfd_reloc_overflow:
10345           if (link_order->type == bfd_section_reloc_link_order)
10346             sym_name = bfd_section_name (output_bfd,
10347                                          link_order->u.reloc.p->u.section);
10348           else
10349             sym_name = link_order->u.reloc.p->u.name;
10350           if (! ((*info->callbacks->reloc_overflow)
10351                  (info, NULL, sym_name, howto->name, addend, NULL,
10352                   NULL, (bfd_vma) 0)))
10353             {
10354               free (buf);
10355               return FALSE;
10356             }
10357           break;
10358         }
10359       ok = bfd_set_section_contents (output_bfd, output_section, buf,
10360                                      link_order->offset, size);
10361       free (buf);
10362       if (! ok)
10363         return FALSE;
10364     }
10365
10366   /* The address of a reloc is relative to the section in a
10367      relocatable file, and is a virtual address in an executable
10368      file.  */
10369   offset = link_order->offset;
10370   if (! info->relocatable)
10371     offset += output_section->vma;
10372
10373   for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10374     {
10375       irel[i].r_offset = offset;
10376       irel[i].r_info = 0;
10377       irel[i].r_addend = 0;
10378     }
10379   if (bed->s->arch_size == 32)
10380     irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10381   else
10382     irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10383
10384   rel_hdr = reldata->hdr;
10385   erel = rel_hdr->contents;
10386   if (rel_hdr->sh_type == SHT_REL)
10387     {
10388       erel += reldata->count * bed->s->sizeof_rel;
10389       (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10390     }
10391   else
10392     {
10393       irel[0].r_addend = addend;
10394       erel += reldata->count * bed->s->sizeof_rela;
10395       (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10396     }
10397
10398   ++reldata->count;
10399
10400   return TRUE;
10401 }
10402
10403
10404 /* Get the output vma of the section pointed to by the sh_link field.  */
10405
10406 static bfd_vma
10407 elf_get_linked_section_vma (struct bfd_link_order *p)
10408 {
10409   Elf_Internal_Shdr **elf_shdrp;
10410   asection *s;
10411   int elfsec;
10412
10413   s = p->u.indirect.section;
10414   elf_shdrp = elf_elfsections (s->owner);
10415   elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10416   elfsec = elf_shdrp[elfsec]->sh_link;
10417   /* PR 290:
10418      The Intel C compiler generates SHT_IA_64_UNWIND with
10419      SHF_LINK_ORDER.  But it doesn't set the sh_link or
10420      sh_info fields.  Hence we could get the situation
10421      where elfsec is 0.  */
10422   if (elfsec == 0)
10423     {
10424       const struct elf_backend_data *bed
10425         = get_elf_backend_data (s->owner);
10426       if (bed->link_order_error_handler)
10427         bed->link_order_error_handler
10428           (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10429       return 0;
10430     }
10431   else
10432     {
10433       s = elf_shdrp[elfsec]->bfd_section;
10434       return s->output_section->vma + s->output_offset;
10435     }
10436 }
10437
10438
10439 /* Compare two sections based on the locations of the sections they are
10440    linked to.  Used by elf_fixup_link_order.  */
10441
10442 static int
10443 compare_link_order (const void * a, const void * b)
10444 {
10445   bfd_vma apos;
10446   bfd_vma bpos;
10447
10448   apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10449   bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10450   if (apos < bpos)
10451     return -1;
10452   return apos > bpos;
10453 }
10454
10455
10456 /* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
10457    order as their linked sections.  Returns false if this could not be done
10458    because an output section includes both ordered and unordered
10459    sections.  Ideally we'd do this in the linker proper.  */
10460
10461 static bfd_boolean
10462 elf_fixup_link_order (bfd *abfd, asection *o)
10463 {
10464   int seen_linkorder;
10465   int seen_other;
10466   int n;
10467   struct bfd_link_order *p;
10468   bfd *sub;
10469   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10470   unsigned elfsec;
10471   struct bfd_link_order **sections;
10472   asection *s, *other_sec, *linkorder_sec;
10473   bfd_vma offset;
10474
10475   other_sec = NULL;
10476   linkorder_sec = NULL;
10477   seen_other = 0;
10478   seen_linkorder = 0;
10479   for (p = o->map_head.link_order; p != NULL; p = p->next)
10480     {
10481       if (p->type == bfd_indirect_link_order)
10482         {
10483           s = p->u.indirect.section;
10484           sub = s->owner;
10485           if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10486               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10487               && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10488               && elfsec < elf_numsections (sub)
10489               && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10490               && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10491             {
10492               seen_linkorder++;
10493               linkorder_sec = s;
10494             }
10495           else
10496             {
10497               seen_other++;
10498               other_sec = s;
10499             }
10500         }
10501       else
10502         seen_other++;
10503
10504       if (seen_other && seen_linkorder)
10505         {
10506           if (other_sec && linkorder_sec)
10507             (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10508                                    o, linkorder_sec,
10509                                    linkorder_sec->owner, other_sec,
10510                                    other_sec->owner);
10511           else
10512             (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10513                                    o);
10514           bfd_set_error (bfd_error_bad_value);
10515           return FALSE;
10516         }
10517     }
10518
10519   if (!seen_linkorder)
10520     return TRUE;
10521
10522   sections = (struct bfd_link_order **)
10523     bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10524   if (sections == NULL)
10525     return FALSE;
10526   seen_linkorder = 0;
10527
10528   for (p = o->map_head.link_order; p != NULL; p = p->next)
10529     {
10530       sections[seen_linkorder++] = p;
10531     }
10532   /* Sort the input sections in the order of their linked section.  */
10533   qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10534          compare_link_order);
10535
10536   /* Change the offsets of the sections.  */
10537   offset = 0;
10538   for (n = 0; n < seen_linkorder; n++)
10539     {
10540       s = sections[n]->u.indirect.section;
10541       offset &= ~(bfd_vma) 0 << s->alignment_power;
10542       s->output_offset = offset;
10543       sections[n]->offset = offset;
10544       /* FIXME: octets_per_byte.  */
10545       offset += sections[n]->size;
10546     }
10547
10548   free (sections);
10549   return TRUE;
10550 }
10551
10552 static void
10553 elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
10554 {
10555   asection *o;
10556
10557   if (flinfo->symstrtab != NULL)
10558     _bfd_stringtab_free (flinfo->symstrtab);
10559   if (flinfo->contents != NULL)
10560     free (flinfo->contents);
10561   if (flinfo->external_relocs != NULL)
10562     free (flinfo->external_relocs);
10563   if (flinfo->internal_relocs != NULL)
10564     free (flinfo->internal_relocs);
10565   if (flinfo->external_syms != NULL)
10566     free (flinfo->external_syms);
10567   if (flinfo->locsym_shndx != NULL)
10568     free (flinfo->locsym_shndx);
10569   if (flinfo->internal_syms != NULL)
10570     free (flinfo->internal_syms);
10571   if (flinfo->indices != NULL)
10572     free (flinfo->indices);
10573   if (flinfo->sections != NULL)
10574     free (flinfo->sections);
10575   if (flinfo->symbuf != NULL)
10576     free (flinfo->symbuf);
10577   if (flinfo->symshndxbuf != NULL)
10578     free (flinfo->symshndxbuf);
10579   for (o = obfd->sections; o != NULL; o = o->next)
10580     {
10581       struct bfd_elf_section_data *esdo = elf_section_data (o);
10582       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
10583         free (esdo->rel.hashes);
10584       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
10585         free (esdo->rela.hashes);
10586     }
10587 }
10588
10589 /* Do the final step of an ELF link.  */
10590
10591 bfd_boolean
10592 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10593 {
10594   bfd_boolean dynamic;
10595   bfd_boolean emit_relocs;
10596   bfd *dynobj;
10597   struct elf_final_link_info flinfo;
10598   asection *o;
10599   struct bfd_link_order *p;
10600   bfd *sub;
10601   bfd_size_type max_contents_size;
10602   bfd_size_type max_external_reloc_size;
10603   bfd_size_type max_internal_reloc_count;
10604   bfd_size_type max_sym_count;
10605   bfd_size_type max_sym_shndx_count;
10606   Elf_Internal_Sym elfsym;
10607   unsigned int i;
10608   Elf_Internal_Shdr *symtab_hdr;
10609   Elf_Internal_Shdr *symtab_shndx_hdr;
10610   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10611   struct elf_outext_info eoinfo;
10612   bfd_boolean merged;
10613   size_t relativecount = 0;
10614   asection *reldyn = 0;
10615   bfd_size_type amt;
10616   asection *attr_section = NULL;
10617   bfd_vma attr_size = 0;
10618   const char *std_attrs_section;
10619
10620   if (! is_elf_hash_table (info->hash))
10621     return FALSE;
10622
10623   if (info->shared)
10624     abfd->flags |= DYNAMIC;
10625
10626   dynamic = elf_hash_table (info)->dynamic_sections_created;
10627   dynobj = elf_hash_table (info)->dynobj;
10628
10629   emit_relocs = (info->relocatable
10630                  || info->emitrelocations);
10631
10632   flinfo.info = info;
10633   flinfo.output_bfd = abfd;
10634   flinfo.symstrtab = _bfd_elf_stringtab_init ();
10635   if (flinfo.symstrtab == NULL)
10636     return FALSE;
10637
10638   if (! dynamic)
10639     {
10640       flinfo.dynsym_sec = NULL;
10641       flinfo.hash_sec = NULL;
10642       flinfo.symver_sec = NULL;
10643     }
10644   else
10645     {
10646       flinfo.dynsym_sec = bfd_get_linker_section (dynobj, ".dynsym");
10647       flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
10648       /* Note that dynsym_sec can be NULL (on VMS).  */
10649       flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
10650       /* Note that it is OK if symver_sec is NULL.  */
10651     }
10652
10653   flinfo.contents = NULL;
10654   flinfo.external_relocs = NULL;
10655   flinfo.internal_relocs = NULL;
10656   flinfo.external_syms = NULL;
10657   flinfo.locsym_shndx = NULL;
10658   flinfo.internal_syms = NULL;
10659   flinfo.indices = NULL;
10660   flinfo.sections = NULL;
10661   flinfo.symbuf = NULL;
10662   flinfo.symshndxbuf = NULL;
10663   flinfo.symbuf_count = 0;
10664   flinfo.shndxbuf_size = 0;
10665   flinfo.filesym_count = 0;
10666
10667   /* The object attributes have been merged.  Remove the input
10668      sections from the link, and set the contents of the output
10669      secton.  */
10670   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10671   for (o = abfd->sections; o != NULL; o = o->next)
10672     {
10673       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10674           || strcmp (o->name, ".gnu.attributes") == 0)
10675         {
10676           for (p = o->map_head.link_order; p != NULL; p = p->next)
10677             {
10678               asection *input_section;
10679
10680               if (p->type != bfd_indirect_link_order)
10681                 continue;
10682               input_section = p->u.indirect.section;
10683               /* Hack: reset the SEC_HAS_CONTENTS flag so that
10684                  elf_link_input_bfd ignores this section.  */
10685               input_section->flags &= ~SEC_HAS_CONTENTS;
10686             }
10687
10688           attr_size = bfd_elf_obj_attr_size (abfd);
10689           if (attr_size)
10690             {
10691               bfd_set_section_size (abfd, o, attr_size);
10692               attr_section = o;
10693               /* Skip this section later on.  */
10694               o->map_head.link_order = NULL;
10695             }
10696           else
10697             o->flags |= SEC_EXCLUDE;
10698         }
10699     }
10700
10701   /* Count up the number of relocations we will output for each output
10702      section, so that we know the sizes of the reloc sections.  We
10703      also figure out some maximum sizes.  */
10704   max_contents_size = 0;
10705   max_external_reloc_size = 0;
10706   max_internal_reloc_count = 0;
10707   max_sym_count = 0;
10708   max_sym_shndx_count = 0;
10709   merged = FALSE;
10710   for (o = abfd->sections; o != NULL; o = o->next)
10711     {
10712       struct bfd_elf_section_data *esdo = elf_section_data (o);
10713       o->reloc_count = 0;
10714
10715       for (p = o->map_head.link_order; p != NULL; p = p->next)
10716         {
10717           unsigned int reloc_count = 0;
10718           struct bfd_elf_section_data *esdi = NULL;
10719
10720           if (p->type == bfd_section_reloc_link_order
10721               || p->type == bfd_symbol_reloc_link_order)
10722             reloc_count = 1;
10723           else if (p->type == bfd_indirect_link_order)
10724             {
10725               asection *sec;
10726
10727               sec = p->u.indirect.section;
10728               esdi = elf_section_data (sec);
10729
10730               /* Mark all sections which are to be included in the
10731                  link.  This will normally be every section.  We need
10732                  to do this so that we can identify any sections which
10733                  the linker has decided to not include.  */
10734               sec->linker_mark = TRUE;
10735
10736               if (sec->flags & SEC_MERGE)
10737                 merged = TRUE;
10738
10739               if (esdo->this_hdr.sh_type == SHT_REL
10740                   || esdo->this_hdr.sh_type == SHT_RELA)
10741                 /* Some backends use reloc_count in relocation sections
10742                    to count particular types of relocs.  Of course,
10743                    reloc sections themselves can't have relocations.  */
10744                 reloc_count = 0;
10745               else if (info->relocatable || info->emitrelocations)
10746                 reloc_count = sec->reloc_count;
10747               else if (bed->elf_backend_count_relocs)
10748                 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10749
10750               if (sec->rawsize > max_contents_size)
10751                 max_contents_size = sec->rawsize;
10752               if (sec->size > max_contents_size)
10753                 max_contents_size = sec->size;
10754
10755               /* We are interested in just local symbols, not all
10756                  symbols.  */
10757               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10758                   && (sec->owner->flags & DYNAMIC) == 0)
10759                 {
10760                   size_t sym_count;
10761
10762                   if (elf_bad_symtab (sec->owner))
10763                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10764                                  / bed->s->sizeof_sym);
10765                   else
10766                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10767
10768                   if (sym_count > max_sym_count)
10769                     max_sym_count = sym_count;
10770
10771                   if (sym_count > max_sym_shndx_count
10772                       && elf_symtab_shndx (sec->owner) != 0)
10773                     max_sym_shndx_count = sym_count;
10774
10775                   if ((sec->flags & SEC_RELOC) != 0)
10776                     {
10777                       size_t ext_size = 0;
10778
10779                       if (esdi->rel.hdr != NULL)
10780                         ext_size = esdi->rel.hdr->sh_size;
10781                       if (esdi->rela.hdr != NULL)
10782                         ext_size += esdi->rela.hdr->sh_size;
10783
10784                       if (ext_size > max_external_reloc_size)
10785                         max_external_reloc_size = ext_size;
10786                       if (sec->reloc_count > max_internal_reloc_count)
10787                         max_internal_reloc_count = sec->reloc_count;
10788                     }
10789                 }
10790             }
10791
10792           if (reloc_count == 0)
10793             continue;
10794
10795           o->reloc_count += reloc_count;
10796
10797           if (p->type == bfd_indirect_link_order
10798               && (info->relocatable || info->emitrelocations))
10799             {
10800               if (esdi->rel.hdr)
10801                 esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10802               if (esdi->rela.hdr)
10803                 esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10804             }
10805           else
10806             {
10807               if (o->use_rela_p)
10808                 esdo->rela.count += reloc_count;
10809               else
10810                 esdo->rel.count += reloc_count;
10811             }
10812         }
10813
10814       if (o->reloc_count > 0)
10815         o->flags |= SEC_RELOC;
10816       else
10817         {
10818           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
10819              set it (this is probably a bug) and if it is set
10820              assign_section_numbers will create a reloc section.  */
10821           o->flags &=~ SEC_RELOC;
10822         }
10823
10824       /* If the SEC_ALLOC flag is not set, force the section VMA to
10825          zero.  This is done in elf_fake_sections as well, but forcing
10826          the VMA to 0 here will ensure that relocs against these
10827          sections are handled correctly.  */
10828       if ((o->flags & SEC_ALLOC) == 0
10829           && ! o->user_set_vma)
10830         o->vma = 0;
10831     }
10832
10833   if (! info->relocatable && merged)
10834     elf_link_hash_traverse (elf_hash_table (info),
10835                             _bfd_elf_link_sec_merge_syms, abfd);
10836
10837   /* Figure out the file positions for everything but the symbol table
10838      and the relocs.  We set symcount to force assign_section_numbers
10839      to create a symbol table.  */
10840   bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
10841   BFD_ASSERT (! abfd->output_has_begun);
10842   if (! _bfd_elf_compute_section_file_positions (abfd, info))
10843     goto error_return;
10844
10845   /* Set sizes, and assign file positions for reloc sections.  */
10846   for (o = abfd->sections; o != NULL; o = o->next)
10847     {
10848       struct bfd_elf_section_data *esdo = elf_section_data (o);
10849       if ((o->flags & SEC_RELOC) != 0)
10850         {
10851           if (esdo->rel.hdr
10852               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10853             goto error_return;
10854
10855           if (esdo->rela.hdr
10856               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10857             goto error_return;
10858         }
10859
10860       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10861          to count upwards while actually outputting the relocations.  */
10862       esdo->rel.count = 0;
10863       esdo->rela.count = 0;
10864     }
10865
10866   /* We have now assigned file positions for all the sections except
10867      .symtab, .strtab, and non-loaded reloc sections.  We start the
10868      .symtab section at the current file position, and write directly
10869      to it.  We build the .strtab section in memory.  */
10870   bfd_get_symcount (abfd) = 0;
10871   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10872   /* sh_name is set in prep_headers.  */
10873   symtab_hdr->sh_type = SHT_SYMTAB;
10874   /* sh_flags, sh_addr and sh_size all start off zero.  */
10875   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10876   /* sh_link is set in assign_section_numbers.  */
10877   /* sh_info is set below.  */
10878   /* sh_offset is set just below.  */
10879   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10880
10881   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
10882      continuously seeking to the right position in the file.  */
10883   if (! info->keep_memory || max_sym_count < 20)
10884     flinfo.symbuf_size = 20;
10885   else
10886     flinfo.symbuf_size = max_sym_count;
10887   amt = flinfo.symbuf_size;
10888   amt *= bed->s->sizeof_sym;
10889   flinfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10890   if (flinfo.symbuf == NULL)
10891     goto error_return;
10892   if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10893     {
10894       /* Wild guess at number of output symbols.  realloc'd as needed.  */
10895       amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10896       flinfo.shndxbuf_size = amt;
10897       amt *= sizeof (Elf_External_Sym_Shndx);
10898       flinfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10899       if (flinfo.symshndxbuf == NULL)
10900         goto error_return;
10901     }
10902
10903   if (info->strip != strip_all || emit_relocs)
10904     {
10905       file_ptr off = elf_next_file_pos (abfd);
10906
10907       _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10908
10909       /* Note that at this point elf_next_file_pos (abfd) is
10910          incorrect.  We do not yet know the size of the .symtab section.
10911          We correct next_file_pos below, after we do know the size.  */
10912
10913       /* Start writing out the symbol table.  The first symbol is always a
10914          dummy symbol.  */
10915       elfsym.st_value = 0;
10916       elfsym.st_size = 0;
10917       elfsym.st_info = 0;
10918       elfsym.st_other = 0;
10919       elfsym.st_shndx = SHN_UNDEF;
10920       elfsym.st_target_internal = 0;
10921       if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
10922                                NULL) != 1)
10923         goto error_return;
10924
10925       /* Output a symbol for each section.  We output these even if we are
10926          discarding local symbols, since they are used for relocs.  These
10927          symbols have no names.  We store the index of each one in the
10928          index field of the section, so that we can find it again when
10929          outputting relocs.  */
10930
10931       elfsym.st_size = 0;
10932       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10933       elfsym.st_other = 0;
10934       elfsym.st_value = 0;
10935       elfsym.st_target_internal = 0;
10936       for (i = 1; i < elf_numsections (abfd); i++)
10937         {
10938           o = bfd_section_from_elf_index (abfd, i);
10939           if (o != NULL)
10940             {
10941               o->target_index = bfd_get_symcount (abfd);
10942               elfsym.st_shndx = i;
10943               if (!info->relocatable)
10944                 elfsym.st_value = o->vma;
10945               if (elf_link_output_sym (&flinfo, NULL, &elfsym, o, NULL) != 1)
10946                 goto error_return;
10947             }
10948         }
10949     }
10950
10951   /* Allocate some memory to hold information read in from the input
10952      files.  */
10953   if (max_contents_size != 0)
10954     {
10955       flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10956       if (flinfo.contents == NULL)
10957         goto error_return;
10958     }
10959
10960   if (max_external_reloc_size != 0)
10961     {
10962       flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
10963       if (flinfo.external_relocs == NULL)
10964         goto error_return;
10965     }
10966
10967   if (max_internal_reloc_count != 0)
10968     {
10969       amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10970       amt *= sizeof (Elf_Internal_Rela);
10971       flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10972       if (flinfo.internal_relocs == NULL)
10973         goto error_return;
10974     }
10975
10976   if (max_sym_count != 0)
10977     {
10978       amt = max_sym_count * bed->s->sizeof_sym;
10979       flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10980       if (flinfo.external_syms == NULL)
10981         goto error_return;
10982
10983       amt = max_sym_count * sizeof (Elf_Internal_Sym);
10984       flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10985       if (flinfo.internal_syms == NULL)
10986         goto error_return;
10987
10988       amt = max_sym_count * sizeof (long);
10989       flinfo.indices = (long int *) bfd_malloc (amt);
10990       if (flinfo.indices == NULL)
10991         goto error_return;
10992
10993       amt = max_sym_count * sizeof (asection *);
10994       flinfo.sections = (asection **) bfd_malloc (amt);
10995       if (flinfo.sections == NULL)
10996         goto error_return;
10997     }
10998
10999   if (max_sym_shndx_count != 0)
11000     {
11001       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
11002       flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
11003       if (flinfo.locsym_shndx == NULL)
11004         goto error_return;
11005     }
11006
11007   if (elf_hash_table (info)->tls_sec)
11008     {
11009       bfd_vma base, end = 0;
11010       asection *sec;
11011
11012       for (sec = elf_hash_table (info)->tls_sec;
11013            sec && (sec->flags & SEC_THREAD_LOCAL);
11014            sec = sec->next)
11015         {
11016           bfd_size_type size = sec->size;
11017
11018           if (size == 0
11019               && (sec->flags & SEC_HAS_CONTENTS) == 0)
11020             {
11021               struct bfd_link_order *ord = sec->map_tail.link_order;
11022
11023               if (ord != NULL)
11024                 size = ord->offset + ord->size;
11025             }
11026           end = sec->vma + size;
11027         }
11028       base = elf_hash_table (info)->tls_sec->vma;
11029       /* Only align end of TLS section if static TLS doesn't have special
11030          alignment requirements.  */
11031       if (bed->static_tls_alignment == 1)
11032         end = align_power (end,
11033                            elf_hash_table (info)->tls_sec->alignment_power);
11034       elf_hash_table (info)->tls_size = end - base;
11035     }
11036
11037   /* Reorder SHF_LINK_ORDER sections.  */
11038   for (o = abfd->sections; o != NULL; o = o->next)
11039     {
11040       if (!elf_fixup_link_order (abfd, o))
11041         return FALSE;
11042     }
11043
11044   /* Since ELF permits relocations to be against local symbols, we
11045      must have the local symbols available when we do the relocations.
11046      Since we would rather only read the local symbols once, and we
11047      would rather not keep them in memory, we handle all the
11048      relocations for a single input file at the same time.
11049
11050      Unfortunately, there is no way to know the total number of local
11051      symbols until we have seen all of them, and the local symbol
11052      indices precede the global symbol indices.  This means that when
11053      we are generating relocatable output, and we see a reloc against
11054      a global symbol, we can not know the symbol index until we have
11055      finished examining all the local symbols to see which ones we are
11056      going to output.  To deal with this, we keep the relocations in
11057      memory, and don't output them until the end of the link.  This is
11058      an unfortunate waste of memory, but I don't see a good way around
11059      it.  Fortunately, it only happens when performing a relocatable
11060      link, which is not the common case.  FIXME: If keep_memory is set
11061      we could write the relocs out and then read them again; I don't
11062      know how bad the memory loss will be.  */
11063
11064   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11065     sub->output_has_begun = FALSE;
11066   for (o = abfd->sections; o != NULL; o = o->next)
11067     {
11068       for (p = o->map_head.link_order; p != NULL; p = p->next)
11069         {
11070           if (p->type == bfd_indirect_link_order
11071               && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
11072                   == bfd_target_elf_flavour)
11073               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
11074             {
11075               if (! sub->output_has_begun)
11076                 {
11077                   if (! elf_link_input_bfd (&flinfo, sub))
11078                     goto error_return;
11079                   sub->output_has_begun = TRUE;
11080                 }
11081             }
11082           else if (p->type == bfd_section_reloc_link_order
11083                    || p->type == bfd_symbol_reloc_link_order)
11084             {
11085               if (! elf_reloc_link_order (abfd, info, o, p))
11086                 goto error_return;
11087             }
11088           else
11089             {
11090               if (! _bfd_default_link_order (abfd, info, o, p))
11091                 {
11092                   if (p->type == bfd_indirect_link_order
11093                       && (bfd_get_flavour (sub)
11094                           == bfd_target_elf_flavour)
11095                       && (elf_elfheader (sub)->e_ident[EI_CLASS]
11096                           != bed->s->elfclass))
11097                     {
11098                       const char *iclass, *oclass;
11099
11100                       if (bed->s->elfclass == ELFCLASS64)
11101                         {
11102                           iclass = "ELFCLASS32";
11103                           oclass = "ELFCLASS64";
11104                         }
11105                       else
11106                         {
11107                           iclass = "ELFCLASS64";
11108                           oclass = "ELFCLASS32";
11109                         }
11110
11111                       bfd_set_error (bfd_error_wrong_format);
11112                       (*_bfd_error_handler)
11113                         (_("%B: file class %s incompatible with %s"),
11114                          sub, iclass, oclass);
11115                     }
11116
11117                   goto error_return;
11118                 }
11119             }
11120         }
11121     }
11122
11123   /* Free symbol buffer if needed.  */
11124   if (!info->reduce_memory_overheads)
11125     {
11126       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11127         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11128             && elf_tdata (sub)->symbuf)
11129           {
11130             free (elf_tdata (sub)->symbuf);
11131             elf_tdata (sub)->symbuf = NULL;
11132           }
11133     }
11134
11135   /* Output any global symbols that got converted to local in a
11136      version script or due to symbol visibility.  We do this in a
11137      separate step since ELF requires all local symbols to appear
11138      prior to any global symbols.  FIXME: We should only do this if
11139      some global symbols were, in fact, converted to become local.
11140      FIXME: Will this work correctly with the Irix 5 linker?  */
11141   eoinfo.failed = FALSE;
11142   eoinfo.flinfo = &flinfo;
11143   eoinfo.localsyms = TRUE;
11144   eoinfo.need_second_pass = FALSE;
11145   eoinfo.second_pass = FALSE;
11146   eoinfo.file_sym_done = FALSE;
11147   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11148   if (eoinfo.failed)
11149     return FALSE;
11150
11151   if (eoinfo.need_second_pass)
11152     {
11153       eoinfo.second_pass = TRUE;
11154       bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11155       if (eoinfo.failed)
11156         return FALSE;
11157     }
11158
11159   /* If backend needs to output some local symbols not present in the hash
11160      table, do it now.  */
11161   if (bed->elf_backend_output_arch_local_syms
11162       && (info->strip != strip_all || emit_relocs))
11163     {
11164       typedef int (*out_sym_func)
11165         (void *, const char *, Elf_Internal_Sym *, asection *,
11166          struct elf_link_hash_entry *);
11167
11168       if (! ((*bed->elf_backend_output_arch_local_syms)
11169              (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11170         return FALSE;
11171     }
11172
11173   /* That wrote out all the local symbols.  Finish up the symbol table
11174      with the global symbols. Even if we want to strip everything we
11175      can, we still need to deal with those global symbols that got
11176      converted to local in a version script.  */
11177
11178   /* The sh_info field records the index of the first non local symbol.  */
11179   symtab_hdr->sh_info = bfd_get_symcount (abfd);
11180
11181   if (dynamic
11182       && flinfo.dynsym_sec != NULL
11183       && flinfo.dynsym_sec->output_section != bfd_abs_section_ptr)
11184     {
11185       Elf_Internal_Sym sym;
11186       bfd_byte *dynsym = flinfo.dynsym_sec->contents;
11187       long last_local = 0;
11188
11189       /* Write out the section symbols for the output sections.  */
11190       if (info->shared || elf_hash_table (info)->is_relocatable_executable)
11191         {
11192           asection *s;
11193
11194           sym.st_size = 0;
11195           sym.st_name = 0;
11196           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11197           sym.st_other = 0;
11198           sym.st_target_internal = 0;
11199
11200           for (s = abfd->sections; s != NULL; s = s->next)
11201             {
11202               int indx;
11203               bfd_byte *dest;
11204               long dynindx;
11205
11206               dynindx = elf_section_data (s)->dynindx;
11207               if (dynindx <= 0)
11208                 continue;
11209               indx = elf_section_data (s)->this_idx;
11210               BFD_ASSERT (indx > 0);
11211               sym.st_shndx = indx;
11212               if (! check_dynsym (abfd, &sym))
11213                 return FALSE;
11214               sym.st_value = s->vma;
11215               dest = dynsym + dynindx * bed->s->sizeof_sym;
11216               if (last_local < dynindx)
11217                 last_local = dynindx;
11218               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11219             }
11220         }
11221
11222       /* Write out the local dynsyms.  */
11223       if (elf_hash_table (info)->dynlocal)
11224         {
11225           struct elf_link_local_dynamic_entry *e;
11226           for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
11227             {
11228               asection *s;
11229               bfd_byte *dest;
11230
11231               /* Copy the internal symbol and turn off visibility.
11232                  Note that we saved a word of storage and overwrote
11233                  the original st_name with the dynstr_index.  */
11234               sym = e->isym;
11235               sym.st_other &= ~ELF_ST_VISIBILITY (-1);
11236
11237               s = bfd_section_from_elf_index (e->input_bfd,
11238                                               e->isym.st_shndx);
11239               if (s != NULL)
11240                 {
11241                   sym.st_shndx =
11242                     elf_section_data (s->output_section)->this_idx;
11243                   if (! check_dynsym (abfd, &sym))
11244                     return FALSE;
11245                   sym.st_value = (s->output_section->vma
11246                                   + s->output_offset
11247                                   + e->isym.st_value);
11248                 }
11249
11250               if (last_local < e->dynindx)
11251                 last_local = e->dynindx;
11252
11253               dest = dynsym + e->dynindx * bed->s->sizeof_sym;
11254               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11255             }
11256         }
11257
11258       elf_section_data (flinfo.dynsym_sec->output_section)->this_hdr.sh_info =
11259         last_local + 1;
11260     }
11261
11262   /* We get the global symbols from the hash table.  */
11263   eoinfo.failed = FALSE;
11264   eoinfo.localsyms = FALSE;
11265   eoinfo.flinfo = &flinfo;
11266   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11267   if (eoinfo.failed)
11268     return FALSE;
11269
11270   /* If backend needs to output some symbols not present in the hash
11271      table, do it now.  */
11272   if (bed->elf_backend_output_arch_syms
11273       && (info->strip != strip_all || emit_relocs))
11274     {
11275       typedef int (*out_sym_func)
11276         (void *, const char *, Elf_Internal_Sym *, asection *,
11277          struct elf_link_hash_entry *);
11278
11279       if (! ((*bed->elf_backend_output_arch_syms)
11280              (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11281         return FALSE;
11282     }
11283
11284   /* Flush all symbols to the file.  */
11285   if (! elf_link_flush_output_syms (&flinfo, bed))
11286     return FALSE;
11287
11288   /* Now we know the size of the symtab section.  */
11289   if (bfd_get_symcount (abfd) > 0)
11290     {
11291       /* Finish up and write out the symbol string table (.strtab)
11292          section.  */
11293       Elf_Internal_Shdr *symstrtab_hdr;
11294       file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
11295
11296       symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
11297       if (symtab_shndx_hdr->sh_name != 0)
11298         {
11299           symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
11300           symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
11301           symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
11302           amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
11303           symtab_shndx_hdr->sh_size = amt;
11304
11305           off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
11306                                                            off, TRUE);
11307
11308           if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
11309               || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
11310             return FALSE;
11311         }
11312
11313       symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
11314       /* sh_name was set in prep_headers.  */
11315       symstrtab_hdr->sh_type = SHT_STRTAB;
11316       symstrtab_hdr->sh_flags = 0;
11317       symstrtab_hdr->sh_addr = 0;
11318       symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
11319       symstrtab_hdr->sh_entsize = 0;
11320       symstrtab_hdr->sh_link = 0;
11321       symstrtab_hdr->sh_info = 0;
11322       /* sh_offset is set just below.  */
11323       symstrtab_hdr->sh_addralign = 1;
11324
11325       off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
11326                                                        off, TRUE);
11327       elf_next_file_pos (abfd) = off;
11328
11329       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
11330           || ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
11331         return FALSE;
11332     }
11333
11334   /* Adjust the relocs to have the correct symbol indices.  */
11335   for (o = abfd->sections; o != NULL; o = o->next)
11336     {
11337       struct bfd_elf_section_data *esdo = elf_section_data (o);
11338       bfd_boolean sort;
11339       if ((o->flags & SEC_RELOC) == 0)
11340         continue;
11341
11342       sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
11343       if (esdo->rel.hdr != NULL)
11344         elf_link_adjust_relocs (abfd, &esdo->rel, sort);
11345       if (esdo->rela.hdr != NULL)
11346         elf_link_adjust_relocs (abfd, &esdo->rela, sort);
11347
11348       /* Set the reloc_count field to 0 to prevent write_relocs from
11349          trying to swap the relocs out itself.  */
11350       o->reloc_count = 0;
11351     }
11352
11353   if (dynamic && info->combreloc && dynobj != NULL)
11354     relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11355
11356   /* If we are linking against a dynamic object, or generating a
11357      shared library, finish up the dynamic linking information.  */
11358   if (dynamic)
11359     {
11360       bfd_byte *dyncon, *dynconend;
11361
11362       /* Fix up .dynamic entries.  */
11363       o = bfd_get_linker_section (dynobj, ".dynamic");
11364       BFD_ASSERT (o != NULL);
11365
11366       dyncon = o->contents;
11367       dynconend = o->contents + o->size;
11368       for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11369         {
11370           Elf_Internal_Dyn dyn;
11371           const char *name;
11372           unsigned int type;
11373
11374           bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11375
11376           switch (dyn.d_tag)
11377             {
11378             default:
11379               continue;
11380             case DT_NULL:
11381               if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11382                 {
11383                   switch (elf_section_data (reldyn)->this_hdr.sh_type)
11384                     {
11385                     case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11386                     case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11387                     default: continue;
11388                     }
11389                   dyn.d_un.d_val = relativecount;
11390                   relativecount = 0;
11391                   break;
11392                 }
11393               continue;
11394
11395             case DT_INIT:
11396               name = info->init_function;
11397               goto get_sym;
11398             case DT_FINI:
11399               name = info->fini_function;
11400             get_sym:
11401               {
11402                 struct elf_link_hash_entry *h;
11403
11404                 h = elf_link_hash_lookup (elf_hash_table (info), name,
11405                                           FALSE, FALSE, TRUE);
11406                 if (h != NULL
11407                     && (h->root.type == bfd_link_hash_defined
11408                         || h->root.type == bfd_link_hash_defweak))
11409                   {
11410                     dyn.d_un.d_ptr = h->root.u.def.value;
11411                     o = h->root.u.def.section;
11412                     if (o->output_section != NULL)
11413                       dyn.d_un.d_ptr += (o->output_section->vma
11414                                          + o->output_offset);
11415                     else
11416                       {
11417                         /* The symbol is imported from another shared
11418                            library and does not apply to this one.  */
11419                         dyn.d_un.d_ptr = 0;
11420                       }
11421                     break;
11422                   }
11423               }
11424               continue;
11425
11426             case DT_PREINIT_ARRAYSZ:
11427               name = ".preinit_array";
11428               goto get_size;
11429             case DT_INIT_ARRAYSZ:
11430               name = ".init_array";
11431               goto get_size;
11432             case DT_FINI_ARRAYSZ:
11433               name = ".fini_array";
11434             get_size:
11435               o = bfd_get_section_by_name (abfd, name);
11436               if (o == NULL)
11437                 {
11438                   (*_bfd_error_handler)
11439                     (_("%B: could not find output section %s"), abfd, name);
11440                   goto error_return;
11441                 }
11442               if (o->size == 0)
11443                 (*_bfd_error_handler)
11444                   (_("warning: %s section has zero size"), name);
11445               dyn.d_un.d_val = o->size;
11446               break;
11447
11448             case DT_PREINIT_ARRAY:
11449               name = ".preinit_array";
11450               goto get_vma;
11451             case DT_INIT_ARRAY:
11452               name = ".init_array";
11453               goto get_vma;
11454             case DT_FINI_ARRAY:
11455               name = ".fini_array";
11456               goto get_vma;
11457
11458             case DT_HASH:
11459               name = ".hash";
11460               goto get_vma;
11461             case DT_GNU_HASH:
11462               name = ".gnu.hash";
11463               goto get_vma;
11464             case DT_STRTAB:
11465               name = ".dynstr";
11466               goto get_vma;
11467             case DT_SYMTAB:
11468               name = ".dynsym";
11469               goto get_vma;
11470             case DT_VERDEF:
11471               name = ".gnu.version_d";
11472               goto get_vma;
11473             case DT_VERNEED:
11474               name = ".gnu.version_r";
11475               goto get_vma;
11476             case DT_VERSYM:
11477               name = ".gnu.version";
11478             get_vma:
11479               o = bfd_get_section_by_name (abfd, name);
11480               if (o == NULL)
11481                 {
11482                   (*_bfd_error_handler)
11483                     (_("%B: could not find output section %s"), abfd, name);
11484                   goto error_return;
11485                 }
11486               if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11487                 {
11488                   (*_bfd_error_handler)
11489                     (_("warning: section '%s' is being made into a note"), name);
11490                   bfd_set_error (bfd_error_nonrepresentable_section);
11491                   goto error_return;
11492                 }
11493               dyn.d_un.d_ptr = o->vma;
11494               break;
11495
11496             case DT_REL:
11497             case DT_RELA:
11498             case DT_RELSZ:
11499             case DT_RELASZ:
11500               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11501                 type = SHT_REL;
11502               else
11503                 type = SHT_RELA;
11504               dyn.d_un.d_val = 0;
11505               dyn.d_un.d_ptr = 0;
11506               for (i = 1; i < elf_numsections (abfd); i++)
11507                 {
11508                   Elf_Internal_Shdr *hdr;
11509
11510                   hdr = elf_elfsections (abfd)[i];
11511                   if (hdr->sh_type == type
11512                       && (hdr->sh_flags & SHF_ALLOC) != 0)
11513                     {
11514                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11515                         dyn.d_un.d_val += hdr->sh_size;
11516                       else
11517                         {
11518                           if (dyn.d_un.d_ptr == 0
11519                               || hdr->sh_addr < dyn.d_un.d_ptr)
11520                             dyn.d_un.d_ptr = hdr->sh_addr;
11521                         }
11522                     }
11523                 }
11524               break;
11525             }
11526           bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11527         }
11528     }
11529
11530   /* If we have created any dynamic sections, then output them.  */
11531   if (dynobj != NULL)
11532     {
11533       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11534         goto error_return;
11535
11536       /* Check for DT_TEXTREL (late, in case the backend removes it).  */
11537       if (((info->warn_shared_textrel && info->shared)
11538            || info->error_textrel)
11539           && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
11540         {
11541           bfd_byte *dyncon, *dynconend;
11542
11543           dyncon = o->contents;
11544           dynconend = o->contents + o->size;
11545           for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11546             {
11547               Elf_Internal_Dyn dyn;
11548
11549               bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11550
11551               if (dyn.d_tag == DT_TEXTREL)
11552                 {
11553                   if (info->error_textrel)
11554                     info->callbacks->einfo
11555                       (_("%P%X: read-only segment has dynamic relocations.\n"));
11556                   else
11557                     info->callbacks->einfo
11558                       (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11559                   break;
11560                 }
11561             }
11562         }
11563
11564       for (o = dynobj->sections; o != NULL; o = o->next)
11565         {
11566           if ((o->flags & SEC_HAS_CONTENTS) == 0
11567               || o->size == 0
11568               || o->output_section == bfd_abs_section_ptr)
11569             continue;
11570           if ((o->flags & SEC_LINKER_CREATED) == 0)
11571             {
11572               /* At this point, we are only interested in sections
11573                  created by _bfd_elf_link_create_dynamic_sections.  */
11574               continue;
11575             }
11576           if (elf_hash_table (info)->stab_info.stabstr == o)
11577             continue;
11578           if (elf_hash_table (info)->eh_info.hdr_sec == o)
11579             continue;
11580           if (strcmp (o->name, ".dynstr") != 0)
11581             {
11582               /* FIXME: octets_per_byte.  */
11583               if (! bfd_set_section_contents (abfd, o->output_section,
11584                                               o->contents,
11585                                               (file_ptr) o->output_offset,
11586                                               o->size))
11587                 goto error_return;
11588             }
11589           else
11590             {
11591               /* The contents of the .dynstr section are actually in a
11592                  stringtab.  */
11593               file_ptr off;
11594
11595               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11596               if (bfd_seek (abfd, off, SEEK_SET) != 0
11597                   || ! _bfd_elf_strtab_emit (abfd,
11598                                              elf_hash_table (info)->dynstr))
11599                 goto error_return;
11600             }
11601         }
11602     }
11603
11604   if (info->relocatable)
11605     {
11606       bfd_boolean failed = FALSE;
11607
11608       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11609       if (failed)
11610         goto error_return;
11611     }
11612
11613   /* If we have optimized stabs strings, output them.  */
11614   if (elf_hash_table (info)->stab_info.stabstr != NULL)
11615     {
11616       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11617         goto error_return;
11618     }
11619
11620   if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11621     goto error_return;
11622
11623   elf_final_link_free (abfd, &flinfo);
11624
11625   elf_linker (abfd) = TRUE;
11626
11627   if (attr_section)
11628     {
11629       bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11630       if (contents == NULL)
11631         return FALSE;   /* Bail out and fail.  */
11632       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11633       bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11634       free (contents);
11635     }
11636
11637   return TRUE;
11638
11639  error_return:
11640   elf_final_link_free (abfd, &flinfo);
11641   return FALSE;
11642 }
11643 \f
11644 /* Initialize COOKIE for input bfd ABFD.  */
11645
11646 static bfd_boolean
11647 init_reloc_cookie (struct elf_reloc_cookie *cookie,
11648                    struct bfd_link_info *info, bfd *abfd)
11649 {
11650   Elf_Internal_Shdr *symtab_hdr;
11651   const struct elf_backend_data *bed;
11652
11653   bed = get_elf_backend_data (abfd);
11654   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11655
11656   cookie->abfd = abfd;
11657   cookie->sym_hashes = elf_sym_hashes (abfd);
11658   cookie->bad_symtab = elf_bad_symtab (abfd);
11659   if (cookie->bad_symtab)
11660     {
11661       cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11662       cookie->extsymoff = 0;
11663     }
11664   else
11665     {
11666       cookie->locsymcount = symtab_hdr->sh_info;
11667       cookie->extsymoff = symtab_hdr->sh_info;
11668     }
11669
11670   if (bed->s->arch_size == 32)
11671     cookie->r_sym_shift = 8;
11672   else
11673     cookie->r_sym_shift = 32;
11674
11675   cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11676   if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11677     {
11678       cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11679                                               cookie->locsymcount, 0,
11680                                               NULL, NULL, NULL);
11681       if (cookie->locsyms == NULL)
11682         {
11683           info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11684           return FALSE;
11685         }
11686       if (info->keep_memory)
11687         symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11688     }
11689   return TRUE;
11690 }
11691
11692 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
11693
11694 static void
11695 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11696 {
11697   Elf_Internal_Shdr *symtab_hdr;
11698
11699   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11700   if (cookie->locsyms != NULL
11701       && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11702     free (cookie->locsyms);
11703 }
11704
11705 /* Initialize the relocation information in COOKIE for input section SEC
11706    of input bfd ABFD.  */
11707
11708 static bfd_boolean
11709 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11710                         struct bfd_link_info *info, bfd *abfd,
11711                         asection *sec)
11712 {
11713   const struct elf_backend_data *bed;
11714
11715   if (sec->reloc_count == 0)
11716     {
11717       cookie->rels = NULL;
11718       cookie->relend = NULL;
11719     }
11720   else
11721     {
11722       bed = get_elf_backend_data (abfd);
11723
11724       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11725                                                 info->keep_memory);
11726       if (cookie->rels == NULL)
11727         return FALSE;
11728       cookie->rel = cookie->rels;
11729       cookie->relend = (cookie->rels
11730                         + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11731     }
11732   cookie->rel = cookie->rels;
11733   return TRUE;
11734 }
11735
11736 /* Free the memory allocated by init_reloc_cookie_rels,
11737    if appropriate.  */
11738
11739 static void
11740 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11741                         asection *sec)
11742 {
11743   if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11744     free (cookie->rels);
11745 }
11746
11747 /* Initialize the whole of COOKIE for input section SEC.  */
11748
11749 static bfd_boolean
11750 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11751                                struct bfd_link_info *info,
11752                                asection *sec)
11753 {
11754   if (!init_reloc_cookie (cookie, info, sec->owner))
11755     goto error1;
11756   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11757     goto error2;
11758   return TRUE;
11759
11760  error2:
11761   fini_reloc_cookie (cookie, sec->owner);
11762  error1:
11763   return FALSE;
11764 }
11765
11766 /* Free the memory allocated by init_reloc_cookie_for_section,
11767    if appropriate.  */
11768
11769 static void
11770 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11771                                asection *sec)
11772 {
11773   fini_reloc_cookie_rels (cookie, sec);
11774   fini_reloc_cookie (cookie, sec->owner);
11775 }
11776 \f
11777 /* Garbage collect unused sections.  */
11778
11779 /* Default gc_mark_hook.  */
11780
11781 asection *
11782 _bfd_elf_gc_mark_hook (asection *sec,
11783                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
11784                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11785                        struct elf_link_hash_entry *h,
11786                        Elf_Internal_Sym *sym)
11787 {
11788   const char *sec_name;
11789
11790   if (h != NULL)
11791     {
11792       switch (h->root.type)
11793         {
11794         case bfd_link_hash_defined:
11795         case bfd_link_hash_defweak:
11796           return h->root.u.def.section;
11797
11798         case bfd_link_hash_common:
11799           return h->root.u.c.p->section;
11800
11801         case bfd_link_hash_undefined:
11802         case bfd_link_hash_undefweak:
11803           /* To work around a glibc bug, keep all XXX input sections
11804              when there is an as yet undefined reference to __start_XXX
11805              or __stop_XXX symbols.  The linker will later define such
11806              symbols for orphan input sections that have a name
11807              representable as a C identifier.  */
11808           if (strncmp (h->root.root.string, "__start_", 8) == 0)
11809             sec_name = h->root.root.string + 8;
11810           else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11811             sec_name = h->root.root.string + 7;
11812           else
11813             sec_name = NULL;
11814
11815           if (sec_name && *sec_name != '\0')
11816             {
11817               bfd *i;
11818
11819               for (i = info->input_bfds; i; i = i->link.next)
11820                 {
11821                   sec = bfd_get_section_by_name (i, sec_name);
11822                   if (sec)
11823                     sec->flags |= SEC_KEEP;
11824                 }
11825             }
11826           break;
11827
11828         default:
11829           break;
11830         }
11831     }
11832   else
11833     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11834
11835   return NULL;
11836 }
11837
11838 /* COOKIE->rel describes a relocation against section SEC, which is
11839    a section we've decided to keep.  Return the section that contains
11840    the relocation symbol, or NULL if no section contains it.  */
11841
11842 asection *
11843 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11844                        elf_gc_mark_hook_fn gc_mark_hook,
11845                        struct elf_reloc_cookie *cookie)
11846 {
11847   unsigned long r_symndx;
11848   struct elf_link_hash_entry *h;
11849
11850   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11851   if (r_symndx == STN_UNDEF)
11852     return NULL;
11853
11854   if (r_symndx >= cookie->locsymcount
11855       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11856     {
11857       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11858       if (h == NULL)
11859         {
11860           info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
11861                                   sec->owner);
11862           return NULL;
11863         }
11864       while (h->root.type == bfd_link_hash_indirect
11865              || h->root.type == bfd_link_hash_warning)
11866         h = (struct elf_link_hash_entry *) h->root.u.i.link;
11867       h->mark = 1;
11868       /* If this symbol is weak and there is a non-weak definition, we
11869          keep the non-weak definition because many backends put
11870          dynamic reloc info on the non-weak definition for code
11871          handling copy relocs.  */
11872       if (h->u.weakdef != NULL)
11873         h->u.weakdef->mark = 1;
11874       return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11875     }
11876
11877   return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11878                           &cookie->locsyms[r_symndx]);
11879 }
11880
11881 /* COOKIE->rel describes a relocation against section SEC, which is
11882    a section we've decided to keep.  Mark the section that contains
11883    the relocation symbol.  */
11884
11885 bfd_boolean
11886 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11887                         asection *sec,
11888                         elf_gc_mark_hook_fn gc_mark_hook,
11889                         struct elf_reloc_cookie *cookie)
11890 {
11891   asection *rsec;
11892
11893   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11894   if (rsec && !rsec->gc_mark)
11895     {
11896       if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
11897           || (rsec->owner->flags & DYNAMIC) != 0)
11898         rsec->gc_mark = 1;
11899       else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11900         return FALSE;
11901     }
11902   return TRUE;
11903 }
11904
11905 /* The mark phase of garbage collection.  For a given section, mark
11906    it and any sections in this section's group, and all the sections
11907    which define symbols to which it refers.  */
11908
11909 bfd_boolean
11910 _bfd_elf_gc_mark (struct bfd_link_info *info,
11911                   asection *sec,
11912                   elf_gc_mark_hook_fn gc_mark_hook)
11913 {
11914   bfd_boolean ret;
11915   asection *group_sec, *eh_frame;
11916
11917   sec->gc_mark = 1;
11918
11919   /* Mark all the sections in the group.  */
11920   group_sec = elf_section_data (sec)->next_in_group;
11921   if (group_sec && !group_sec->gc_mark)
11922     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11923       return FALSE;
11924
11925   /* Look through the section relocs.  */
11926   ret = TRUE;
11927   eh_frame = elf_eh_frame_section (sec->owner);
11928   if ((sec->flags & SEC_RELOC) != 0
11929       && sec->reloc_count > 0
11930       && sec != eh_frame)
11931     {
11932       struct elf_reloc_cookie cookie;
11933
11934       if (!init_reloc_cookie_for_section (&cookie, info, sec))
11935         ret = FALSE;
11936       else
11937         {
11938           for (; cookie.rel < cookie.relend; cookie.rel++)
11939             if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11940               {
11941                 ret = FALSE;
11942                 break;
11943               }
11944           fini_reloc_cookie_for_section (&cookie, sec);
11945         }
11946     }
11947
11948   if (ret && eh_frame && elf_fde_list (sec))
11949     {
11950       struct elf_reloc_cookie cookie;
11951
11952       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11953         ret = FALSE;
11954       else
11955         {
11956           if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11957                                       gc_mark_hook, &cookie))
11958             ret = FALSE;
11959           fini_reloc_cookie_for_section (&cookie, eh_frame);
11960         }
11961     }
11962
11963   return ret;
11964 }
11965
11966 /* Scan and mark sections in a special or debug section group.  */
11967
11968 static void
11969 _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
11970 {
11971   /* Point to first section of section group.  */
11972   asection *ssec;
11973   /* Used to iterate the section group.  */
11974   asection *msec;
11975
11976   bfd_boolean is_special_grp = TRUE;
11977   bfd_boolean is_debug_grp = TRUE;
11978
11979   /* First scan to see if group contains any section other than debug
11980      and special section.  */
11981   ssec = msec = elf_next_in_group (grp);
11982   do
11983     {
11984       if ((msec->flags & SEC_DEBUGGING) == 0)
11985         is_debug_grp = FALSE;
11986
11987       if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
11988         is_special_grp = FALSE;
11989
11990       msec = elf_next_in_group (msec);
11991     }
11992   while (msec != ssec);
11993
11994   /* If this is a pure debug section group or pure special section group,
11995      keep all sections in this group.  */
11996   if (is_debug_grp || is_special_grp)
11997     {
11998       do
11999         {
12000           msec->gc_mark = 1;
12001           msec = elf_next_in_group (msec);
12002         }
12003       while (msec != ssec);
12004     }
12005 }
12006
12007 /* Keep debug and special sections.  */
12008
12009 bfd_boolean
12010 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12011                                  elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
12012 {
12013   bfd *ibfd;
12014
12015   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12016     {
12017       asection *isec;
12018       bfd_boolean some_kept;
12019       bfd_boolean debug_frag_seen;
12020
12021       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12022         continue;
12023
12024       /* Ensure all linker created sections are kept,
12025          see if any other section is already marked,
12026          and note if we have any fragmented debug sections.  */
12027       debug_frag_seen = some_kept = FALSE;
12028       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12029         {
12030           if ((isec->flags & SEC_LINKER_CREATED) != 0)
12031             isec->gc_mark = 1;
12032           else if (isec->gc_mark)
12033             some_kept = TRUE;
12034
12035           if (debug_frag_seen == FALSE
12036               && (isec->flags & SEC_DEBUGGING)
12037               && CONST_STRNEQ (isec->name, ".debug_line."))
12038             debug_frag_seen = TRUE;
12039         }
12040
12041       /* If no section in this file will be kept, then we can
12042          toss out the debug and special sections.  */
12043       if (!some_kept)
12044         continue;
12045
12046       /* Keep debug and special sections like .comment when they are
12047          not part of a group.  Also keep section groups that contain
12048          just debug sections or special sections.  */
12049       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12050         {
12051           if ((isec->flags & SEC_GROUP) != 0)
12052             _bfd_elf_gc_mark_debug_special_section_group (isec);
12053           else if (((isec->flags & SEC_DEBUGGING) != 0
12054                     || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
12055                    && elf_next_in_group (isec) == NULL)
12056             isec->gc_mark = 1;
12057         }
12058
12059       if (! debug_frag_seen)
12060         continue;
12061
12062       /* Look for CODE sections which are going to be discarded,
12063          and find and discard any fragmented debug sections which
12064          are associated with that code section.  */
12065       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12066         if ((isec->flags & SEC_CODE) != 0
12067             && isec->gc_mark == 0)
12068           {
12069             unsigned int ilen;
12070             asection *dsec;
12071
12072             ilen = strlen (isec->name);
12073
12074             /* Association is determined by the name of the debug section
12075                containing the name of the code section as a suffix.  For
12076                example .debug_line.text.foo is a debug section associated
12077                with .text.foo.  */
12078             for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
12079               {
12080                 unsigned int dlen;
12081
12082                 if (dsec->gc_mark == 0
12083                     || (dsec->flags & SEC_DEBUGGING) == 0)
12084                   continue;
12085
12086                 dlen = strlen (dsec->name);
12087
12088                 if (dlen > ilen
12089                     && strncmp (dsec->name + (dlen - ilen),
12090                                 isec->name, ilen) == 0)
12091                   {
12092                     dsec->gc_mark = 0;
12093                     break;
12094                   }
12095               }
12096           }
12097     }
12098   return TRUE;
12099 }
12100
12101 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
12102
12103 struct elf_gc_sweep_symbol_info
12104 {
12105   struct bfd_link_info *info;
12106   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
12107                        bfd_boolean);
12108 };
12109
12110 static bfd_boolean
12111 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
12112 {
12113   if (!h->mark
12114       && (((h->root.type == bfd_link_hash_defined
12115             || h->root.type == bfd_link_hash_defweak)
12116            && !((h->def_regular || ELF_COMMON_DEF_P (h))
12117                 && h->root.u.def.section->gc_mark))
12118           || h->root.type == bfd_link_hash_undefined
12119           || h->root.type == bfd_link_hash_undefweak))
12120     {
12121       struct elf_gc_sweep_symbol_info *inf;
12122
12123       inf = (struct elf_gc_sweep_symbol_info *) data;
12124       (*inf->hide_symbol) (inf->info, h, TRUE);
12125       h->def_regular = 0;
12126       h->ref_regular = 0;
12127       h->ref_regular_nonweak = 0;
12128     }
12129
12130   return TRUE;
12131 }
12132
12133 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
12134
12135 typedef bfd_boolean (*gc_sweep_hook_fn)
12136   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
12137
12138 static bfd_boolean
12139 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
12140 {
12141   bfd *sub;
12142   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12143   gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
12144   unsigned long section_sym_count;
12145   struct elf_gc_sweep_symbol_info sweep_info;
12146
12147   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12148     {
12149       asection *o;
12150
12151       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12152         continue;
12153
12154       for (o = sub->sections; o != NULL; o = o->next)
12155         {
12156           /* When any section in a section group is kept, we keep all
12157              sections in the section group.  If the first member of
12158              the section group is excluded, we will also exclude the
12159              group section.  */
12160           if (o->flags & SEC_GROUP)
12161             {
12162               asection *first = elf_next_in_group (o);
12163               o->gc_mark = first->gc_mark;
12164             }
12165
12166           if (o->gc_mark)
12167             continue;
12168
12169           /* Skip sweeping sections already excluded.  */
12170           if (o->flags & SEC_EXCLUDE)
12171             continue;
12172
12173           /* Since this is early in the link process, it is simple
12174              to remove a section from the output.  */
12175           o->flags |= SEC_EXCLUDE;
12176
12177           if (info->print_gc_sections && o->size != 0)
12178             _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
12179
12180           /* But we also have to update some of the relocation
12181              info we collected before.  */
12182           if (gc_sweep_hook
12183               && (o->flags & SEC_RELOC) != 0
12184               && o->reloc_count != 0
12185               && !((info->strip == strip_all || info->strip == strip_debugger)
12186                    && (o->flags & SEC_DEBUGGING) != 0)
12187               && !bfd_is_abs_section (o->output_section))
12188             {
12189               Elf_Internal_Rela *internal_relocs;
12190               bfd_boolean r;
12191
12192               internal_relocs
12193                 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
12194                                              info->keep_memory);
12195               if (internal_relocs == NULL)
12196                 return FALSE;
12197
12198               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
12199
12200               if (elf_section_data (o)->relocs != internal_relocs)
12201                 free (internal_relocs);
12202
12203               if (!r)
12204                 return FALSE;
12205             }
12206         }
12207     }
12208
12209   /* Remove the symbols that were in the swept sections from the dynamic
12210      symbol table.  GCFIXME: Anyone know how to get them out of the
12211      static symbol table as well?  */
12212   sweep_info.info = info;
12213   sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
12214   elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
12215                           &sweep_info);
12216
12217   _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
12218   return TRUE;
12219 }
12220
12221 /* Propagate collected vtable information.  This is called through
12222    elf_link_hash_traverse.  */
12223
12224 static bfd_boolean
12225 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
12226 {
12227   /* Those that are not vtables.  */
12228   if (h->vtable == NULL || h->vtable->parent == NULL)
12229     return TRUE;
12230
12231   /* Those vtables that do not have parents, we cannot merge.  */
12232   if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
12233     return TRUE;
12234
12235   /* If we've already been done, exit.  */
12236   if (h->vtable->used && h->vtable->used[-1])
12237     return TRUE;
12238
12239   /* Make sure the parent's table is up to date.  */
12240   elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
12241
12242   if (h->vtable->used == NULL)
12243     {
12244       /* None of this table's entries were referenced.  Re-use the
12245          parent's table.  */
12246       h->vtable->used = h->vtable->parent->vtable->used;
12247       h->vtable->size = h->vtable->parent->vtable->size;
12248     }
12249   else
12250     {
12251       size_t n;
12252       bfd_boolean *cu, *pu;
12253
12254       /* Or the parent's entries into ours.  */
12255       cu = h->vtable->used;
12256       cu[-1] = TRUE;
12257       pu = h->vtable->parent->vtable->used;
12258       if (pu != NULL)
12259         {
12260           const struct elf_backend_data *bed;
12261           unsigned int log_file_align;
12262
12263           bed = get_elf_backend_data (h->root.u.def.section->owner);
12264           log_file_align = bed->s->log_file_align;
12265           n = h->vtable->parent->vtable->size >> log_file_align;
12266           while (n--)
12267             {
12268               if (*pu)
12269                 *cu = TRUE;
12270               pu++;
12271               cu++;
12272             }
12273         }
12274     }
12275
12276   return TRUE;
12277 }
12278
12279 static bfd_boolean
12280 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
12281 {
12282   asection *sec;
12283   bfd_vma hstart, hend;
12284   Elf_Internal_Rela *relstart, *relend, *rel;
12285   const struct elf_backend_data *bed;
12286   unsigned int log_file_align;
12287
12288   /* Take care of both those symbols that do not describe vtables as
12289      well as those that are not loaded.  */
12290   if (h->vtable == NULL || h->vtable->parent == NULL)
12291     return TRUE;
12292
12293   BFD_ASSERT (h->root.type == bfd_link_hash_defined
12294               || h->root.type == bfd_link_hash_defweak);
12295
12296   sec = h->root.u.def.section;
12297   hstart = h->root.u.def.value;
12298   hend = hstart + h->size;
12299
12300   relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
12301   if (!relstart)
12302     return *(bfd_boolean *) okp = FALSE;
12303   bed = get_elf_backend_data (sec->owner);
12304   log_file_align = bed->s->log_file_align;
12305
12306   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
12307
12308   for (rel = relstart; rel < relend; ++rel)
12309     if (rel->r_offset >= hstart && rel->r_offset < hend)
12310       {
12311         /* If the entry is in use, do nothing.  */
12312         if (h->vtable->used
12313             && (rel->r_offset - hstart) < h->vtable->size)
12314           {
12315             bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
12316             if (h->vtable->used[entry])
12317               continue;
12318           }
12319         /* Otherwise, kill it.  */
12320         rel->r_offset = rel->r_info = rel->r_addend = 0;
12321       }
12322
12323   return TRUE;
12324 }
12325
12326 /* Mark sections containing dynamically referenced symbols.  When
12327    building shared libraries, we must assume that any visible symbol is
12328    referenced.  */
12329
12330 bfd_boolean
12331 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
12332 {
12333   struct bfd_link_info *info = (struct bfd_link_info *) inf;
12334   struct bfd_elf_dynamic_list *d = info->dynamic_list;
12335
12336   if ((h->root.type == bfd_link_hash_defined
12337        || h->root.type == bfd_link_hash_defweak)
12338       && (h->ref_dynamic
12339           || ((h->def_regular || ELF_COMMON_DEF_P (h))
12340               && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
12341               && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
12342               && (!info->executable
12343                   || info->export_dynamic
12344                   || (h->dynamic
12345                       && d != NULL
12346                       && (*d->match) (&d->head, NULL, h->root.root.string)))
12347               && (strchr (h->root.root.string, ELF_VER_CHR) != NULL
12348                   || !bfd_hide_sym_by_version (info->version_info,
12349                                                h->root.root.string)))))
12350     h->root.u.def.section->flags |= SEC_KEEP;
12351
12352   return TRUE;
12353 }
12354
12355 /* Keep all sections containing symbols undefined on the command-line,
12356    and the section containing the entry symbol.  */
12357
12358 void
12359 _bfd_elf_gc_keep (struct bfd_link_info *info)
12360 {
12361   struct bfd_sym_chain *sym;
12362
12363   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
12364     {
12365       struct elf_link_hash_entry *h;
12366
12367       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
12368                                 FALSE, FALSE, FALSE);
12369
12370       if (h != NULL
12371           && (h->root.type == bfd_link_hash_defined
12372               || h->root.type == bfd_link_hash_defweak)
12373           && !bfd_is_abs_section (h->root.u.def.section))
12374         h->root.u.def.section->flags |= SEC_KEEP;
12375     }
12376 }
12377
12378 /* Do mark and sweep of unused sections.  */
12379
12380 bfd_boolean
12381 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
12382 {
12383   bfd_boolean ok = TRUE;
12384   bfd *sub;
12385   elf_gc_mark_hook_fn gc_mark_hook;
12386   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12387   struct elf_link_hash_table *htab;
12388
12389   if (!bed->can_gc_sections
12390       || !is_elf_hash_table (info->hash))
12391     {
12392       (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12393       return TRUE;
12394     }
12395
12396   bed->gc_keep (info);
12397   htab = elf_hash_table (info);
12398
12399   /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
12400      at the .eh_frame section if we can mark the FDEs individually.  */
12401   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12402     {
12403       asection *sec;
12404       struct elf_reloc_cookie cookie;
12405
12406       sec = bfd_get_section_by_name (sub, ".eh_frame");
12407       while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12408         {
12409           _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12410           if (elf_section_data (sec)->sec_info
12411               && (sec->flags & SEC_LINKER_CREATED) == 0)
12412             elf_eh_frame_section (sub) = sec;
12413           fini_reloc_cookie_for_section (&cookie, sec);
12414           sec = bfd_get_next_section_by_name (sec);
12415         }
12416     }
12417
12418   /* Apply transitive closure to the vtable entry usage info.  */
12419   elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
12420   if (!ok)
12421     return FALSE;
12422
12423   /* Kill the vtable relocations that were not used.  */
12424   elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
12425   if (!ok)
12426     return FALSE;
12427
12428   /* Mark dynamically referenced symbols.  */
12429   if (htab->dynamic_sections_created)
12430     elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info);
12431
12432   /* Grovel through relocs to find out who stays ...  */
12433   gc_mark_hook = bed->gc_mark_hook;
12434   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12435     {
12436       asection *o;
12437
12438       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12439         continue;
12440
12441       /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12442          Also treat note sections as a root, if the section is not part
12443          of a group.  */
12444       for (o = sub->sections; o != NULL; o = o->next)
12445         if (!o->gc_mark
12446             && (o->flags & SEC_EXCLUDE) == 0
12447             && ((o->flags & SEC_KEEP) != 0
12448                 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12449                     && elf_next_in_group (o) == NULL )))
12450           {
12451             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12452               return FALSE;
12453           }
12454     }
12455
12456   /* Allow the backend to mark additional target specific sections.  */
12457   bed->gc_mark_extra_sections (info, gc_mark_hook);
12458
12459   /* ... and mark SEC_EXCLUDE for those that go.  */
12460   return elf_gc_sweep (abfd, info);
12461 }
12462 \f
12463 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
12464
12465 bfd_boolean
12466 bfd_elf_gc_record_vtinherit (bfd *abfd,
12467                              asection *sec,
12468                              struct elf_link_hash_entry *h,
12469                              bfd_vma offset)
12470 {
12471   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12472   struct elf_link_hash_entry **search, *child;
12473   bfd_size_type extsymcount;
12474   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12475
12476   /* The sh_info field of the symtab header tells us where the
12477      external symbols start.  We don't care about the local symbols at
12478      this point.  */
12479   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12480   if (!elf_bad_symtab (abfd))
12481     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12482
12483   sym_hashes = elf_sym_hashes (abfd);
12484   sym_hashes_end = sym_hashes + extsymcount;
12485
12486   /* Hunt down the child symbol, which is in this section at the same
12487      offset as the relocation.  */
12488   for (search = sym_hashes; search != sym_hashes_end; ++search)
12489     {
12490       if ((child = *search) != NULL
12491           && (child->root.type == bfd_link_hash_defined
12492               || child->root.type == bfd_link_hash_defweak)
12493           && child->root.u.def.section == sec
12494           && child->root.u.def.value == offset)
12495         goto win;
12496     }
12497
12498   (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12499                          abfd, sec, (unsigned long) offset);
12500   bfd_set_error (bfd_error_invalid_operation);
12501   return FALSE;
12502
12503  win:
12504   if (!child->vtable)
12505     {
12506       child->vtable = (struct elf_link_virtual_table_entry *)
12507           bfd_zalloc (abfd, sizeof (*child->vtable));
12508       if (!child->vtable)
12509         return FALSE;
12510     }
12511   if (!h)
12512     {
12513       /* This *should* only be the absolute section.  It could potentially
12514          be that someone has defined a non-global vtable though, which
12515          would be bad.  It isn't worth paging in the local symbols to be
12516          sure though; that case should simply be handled by the assembler.  */
12517
12518       child->vtable->parent = (struct elf_link_hash_entry *) -1;
12519     }
12520   else
12521     child->vtable->parent = h;
12522
12523   return TRUE;
12524 }
12525
12526 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
12527
12528 bfd_boolean
12529 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12530                            asection *sec ATTRIBUTE_UNUSED,
12531                            struct elf_link_hash_entry *h,
12532                            bfd_vma addend)
12533 {
12534   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12535   unsigned int log_file_align = bed->s->log_file_align;
12536
12537   if (!h->vtable)
12538     {
12539       h->vtable = (struct elf_link_virtual_table_entry *)
12540           bfd_zalloc (abfd, sizeof (*h->vtable));
12541       if (!h->vtable)
12542         return FALSE;
12543     }
12544
12545   if (addend >= h->vtable->size)
12546     {
12547       size_t size, bytes, file_align;
12548       bfd_boolean *ptr = h->vtable->used;
12549
12550       /* While the symbol is undefined, we have to be prepared to handle
12551          a zero size.  */
12552       file_align = 1 << log_file_align;
12553       if (h->root.type == bfd_link_hash_undefined)
12554         size = addend + file_align;
12555       else
12556         {
12557           size = h->size;
12558           if (addend >= size)
12559             {
12560               /* Oops!  We've got a reference past the defined end of
12561                  the table.  This is probably a bug -- shall we warn?  */
12562               size = addend + file_align;
12563             }
12564         }
12565       size = (size + file_align - 1) & -file_align;
12566
12567       /* Allocate one extra entry for use as a "done" flag for the
12568          consolidation pass.  */
12569       bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12570
12571       if (ptr)
12572         {
12573           ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12574
12575           if (ptr != NULL)
12576             {
12577               size_t oldbytes;
12578
12579               oldbytes = (((h->vtable->size >> log_file_align) + 1)
12580                           * sizeof (bfd_boolean));
12581               memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12582             }
12583         }
12584       else
12585         ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12586
12587       if (ptr == NULL)
12588         return FALSE;
12589
12590       /* And arrange for that done flag to be at index -1.  */
12591       h->vtable->used = ptr + 1;
12592       h->vtable->size = size;
12593     }
12594
12595   h->vtable->used[addend >> log_file_align] = TRUE;
12596
12597   return TRUE;
12598 }
12599
12600 /* Map an ELF section header flag to its corresponding string.  */
12601 typedef struct
12602 {
12603   char *flag_name;
12604   flagword flag_value;
12605 } elf_flags_to_name_table;
12606
12607 static elf_flags_to_name_table elf_flags_to_names [] =
12608 {
12609   { "SHF_WRITE", SHF_WRITE },
12610   { "SHF_ALLOC", SHF_ALLOC },
12611   { "SHF_EXECINSTR", SHF_EXECINSTR },
12612   { "SHF_MERGE", SHF_MERGE },
12613   { "SHF_STRINGS", SHF_STRINGS },
12614   { "SHF_INFO_LINK", SHF_INFO_LINK},
12615   { "SHF_LINK_ORDER", SHF_LINK_ORDER},
12616   { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12617   { "SHF_GROUP", SHF_GROUP },
12618   { "SHF_TLS", SHF_TLS },
12619   { "SHF_MASKOS", SHF_MASKOS },
12620   { "SHF_EXCLUDE", SHF_EXCLUDE },
12621 };
12622
12623 /* Returns TRUE if the section is to be included, otherwise FALSE.  */
12624 bfd_boolean
12625 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12626                               struct flag_info *flaginfo,
12627                               asection *section)
12628 {
12629   const bfd_vma sh_flags = elf_section_flags (section);
12630
12631   if (!flaginfo->flags_initialized)
12632     {
12633       bfd *obfd = info->output_bfd;
12634       const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12635       struct flag_info_list *tf = flaginfo->flag_list;
12636       int with_hex = 0;
12637       int without_hex = 0;
12638
12639       for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
12640         {
12641           unsigned i;
12642           flagword (*lookup) (char *);
12643
12644           lookup = bed->elf_backend_lookup_section_flags_hook;
12645           if (lookup != NULL)
12646             {
12647               flagword hexval = (*lookup) ((char *) tf->name);
12648
12649               if (hexval != 0)
12650                 {
12651                   if (tf->with == with_flags)
12652                     with_hex |= hexval;
12653                   else if (tf->with == without_flags)
12654                     without_hex |= hexval;
12655                   tf->valid = TRUE;
12656                   continue;
12657                 }
12658             }
12659           for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
12660             {
12661               if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
12662                 {
12663                   if (tf->with == with_flags)
12664                     with_hex |= elf_flags_to_names[i].flag_value;
12665                   else if (tf->with == without_flags)
12666                     without_hex |= elf_flags_to_names[i].flag_value;
12667                   tf->valid = TRUE;
12668                   break;
12669                 }
12670             }
12671           if (!tf->valid)
12672             {
12673               info->callbacks->einfo
12674                 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12675               return FALSE;
12676             }
12677         }
12678       flaginfo->flags_initialized = TRUE;
12679       flaginfo->only_with_flags |= with_hex;
12680       flaginfo->not_with_flags |= without_hex;
12681     }
12682
12683   if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
12684     return FALSE;
12685
12686   if ((flaginfo->not_with_flags & sh_flags) != 0)
12687     return FALSE;
12688
12689   return TRUE;
12690 }
12691
12692 struct alloc_got_off_arg {
12693   bfd_vma gotoff;
12694   struct bfd_link_info *info;
12695 };
12696
12697 /* We need a special top-level link routine to convert got reference counts
12698    to real got offsets.  */
12699
12700 static bfd_boolean
12701 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12702 {
12703   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12704   bfd *obfd = gofarg->info->output_bfd;
12705   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12706
12707   if (h->got.refcount > 0)
12708     {
12709       h->got.offset = gofarg->gotoff;
12710       gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12711     }
12712   else
12713     h->got.offset = (bfd_vma) -1;
12714
12715   return TRUE;
12716 }
12717
12718 /* And an accompanying bit to work out final got entry offsets once
12719    we're done.  Should be called from final_link.  */
12720
12721 bfd_boolean
12722 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12723                                         struct bfd_link_info *info)
12724 {
12725   bfd *i;
12726   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12727   bfd_vma gotoff;
12728   struct alloc_got_off_arg gofarg;
12729
12730   BFD_ASSERT (abfd == info->output_bfd);
12731
12732   if (! is_elf_hash_table (info->hash))
12733     return FALSE;
12734
12735   /* The GOT offset is relative to the .got section, but the GOT header is
12736      put into the .got.plt section, if the backend uses it.  */
12737   if (bed->want_got_plt)
12738     gotoff = 0;
12739   else
12740     gotoff = bed->got_header_size;
12741
12742   /* Do the local .got entries first.  */
12743   for (i = info->input_bfds; i; i = i->link.next)
12744     {
12745       bfd_signed_vma *local_got;
12746       bfd_size_type j, locsymcount;
12747       Elf_Internal_Shdr *symtab_hdr;
12748
12749       if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12750         continue;
12751
12752       local_got = elf_local_got_refcounts (i);
12753       if (!local_got)
12754         continue;
12755
12756       symtab_hdr = &elf_tdata (i)->symtab_hdr;
12757       if (elf_bad_symtab (i))
12758         locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12759       else
12760         locsymcount = symtab_hdr->sh_info;
12761
12762       for (j = 0; j < locsymcount; ++j)
12763         {
12764           if (local_got[j] > 0)
12765             {
12766               local_got[j] = gotoff;
12767               gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12768             }
12769           else
12770             local_got[j] = (bfd_vma) -1;
12771         }
12772     }
12773
12774   /* Then the global .got entries.  .plt refcounts are handled by
12775      adjust_dynamic_symbol  */
12776   gofarg.gotoff = gotoff;
12777   gofarg.info = info;
12778   elf_link_hash_traverse (elf_hash_table (info),
12779                           elf_gc_allocate_got_offsets,
12780                           &gofarg);
12781   return TRUE;
12782 }
12783
12784 /* Many folk need no more in the way of final link than this, once
12785    got entry reference counting is enabled.  */
12786
12787 bfd_boolean
12788 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12789 {
12790   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12791     return FALSE;
12792
12793   /* Invoke the regular ELF backend linker to do all the work.  */
12794   return bfd_elf_final_link (abfd, info);
12795 }
12796
12797 bfd_boolean
12798 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12799 {
12800   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12801
12802   if (rcookie->bad_symtab)
12803     rcookie->rel = rcookie->rels;
12804
12805   for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12806     {
12807       unsigned long r_symndx;
12808
12809       if (! rcookie->bad_symtab)
12810         if (rcookie->rel->r_offset > offset)
12811           return FALSE;
12812       if (rcookie->rel->r_offset != offset)
12813         continue;
12814
12815       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12816       if (r_symndx == STN_UNDEF)
12817         return TRUE;
12818
12819       if (r_symndx >= rcookie->locsymcount
12820           || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12821         {
12822           struct elf_link_hash_entry *h;
12823
12824           h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12825
12826           while (h->root.type == bfd_link_hash_indirect
12827                  || h->root.type == bfd_link_hash_warning)
12828             h = (struct elf_link_hash_entry *) h->root.u.i.link;
12829
12830           if ((h->root.type == bfd_link_hash_defined
12831                || h->root.type == bfd_link_hash_defweak)
12832               && (h->root.u.def.section->owner != rcookie->abfd
12833                   || h->root.u.def.section->kept_section != NULL
12834                   || discarded_section (h->root.u.def.section)))
12835             return TRUE;
12836         }
12837       else
12838         {
12839           /* It's not a relocation against a global symbol,
12840              but it could be a relocation against a local
12841              symbol for a discarded section.  */
12842           asection *isec;
12843           Elf_Internal_Sym *isym;
12844
12845           /* Need to: get the symbol; get the section.  */
12846           isym = &rcookie->locsyms[r_symndx];
12847           isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12848           if (isec != NULL
12849               && (isec->kept_section != NULL
12850                   || discarded_section (isec)))
12851             return TRUE;
12852         }
12853       return FALSE;
12854     }
12855   return FALSE;
12856 }
12857
12858 /* Discard unneeded references to discarded sections.
12859    Returns -1 on error, 1 if any section's size was changed, 0 if
12860    nothing changed.  This function assumes that the relocations are in
12861    sorted order, which is true for all known assemblers.  */
12862
12863 int
12864 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12865 {
12866   struct elf_reloc_cookie cookie;
12867   asection *o;
12868   bfd *abfd;
12869   int changed = 0;
12870
12871   if (info->traditional_format
12872       || !is_elf_hash_table (info->hash))
12873     return 0;
12874
12875   o = bfd_get_section_by_name (output_bfd, ".stab");
12876   if (o != NULL)
12877     {
12878       asection *i;
12879
12880       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12881         {
12882           if (i->size == 0
12883               || i->reloc_count == 0
12884               || i->sec_info_type != SEC_INFO_TYPE_STABS)
12885             continue;
12886
12887           abfd = i->owner;
12888           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12889             continue;
12890
12891           if (!init_reloc_cookie_for_section (&cookie, info, i))
12892             return -1;
12893
12894           if (_bfd_discard_section_stabs (abfd, i,
12895                                           elf_section_data (i)->sec_info,
12896                                           bfd_elf_reloc_symbol_deleted_p,
12897                                           &cookie))
12898             changed = 1;
12899
12900           fini_reloc_cookie_for_section (&cookie, i);
12901         }
12902     }
12903
12904   o = bfd_get_section_by_name (output_bfd, ".eh_frame");
12905   if (o != NULL)
12906     {
12907       asection *i;
12908
12909       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12910         {
12911           if (i->size == 0)
12912             continue;
12913
12914           abfd = i->owner;
12915           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12916             continue;
12917
12918           if (!init_reloc_cookie_for_section (&cookie, info, i))
12919             return -1;
12920
12921           _bfd_elf_parse_eh_frame (abfd, info, i, &cookie);
12922           if (_bfd_elf_discard_section_eh_frame (abfd, info, i,
12923                                                  bfd_elf_reloc_symbol_deleted_p,
12924                                                  &cookie))
12925             changed = 1;
12926
12927           fini_reloc_cookie_for_section (&cookie, i);
12928         }
12929     }
12930
12931   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
12932     {
12933       const struct elf_backend_data *bed;
12934
12935       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12936         continue;
12937
12938       bed = get_elf_backend_data (abfd);
12939
12940       if (bed->elf_backend_discard_info != NULL)
12941         {
12942           if (!init_reloc_cookie (&cookie, info, abfd))
12943             return -1;
12944
12945           if ((*bed->elf_backend_discard_info) (abfd, &cookie, info))
12946             changed = 1;
12947
12948           fini_reloc_cookie (&cookie, abfd);
12949         }
12950     }
12951
12952   if (info->eh_frame_hdr
12953       && !info->relocatable
12954       && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12955     changed = 1;
12956
12957   return changed;
12958 }
12959
12960 bfd_boolean
12961 _bfd_elf_section_already_linked (bfd *abfd,
12962                                  asection *sec,
12963                                  struct bfd_link_info *info)
12964 {
12965   flagword flags;
12966   const char *name, *key;
12967   struct bfd_section_already_linked *l;
12968   struct bfd_section_already_linked_hash_entry *already_linked_list;
12969
12970   if (sec->output_section == bfd_abs_section_ptr)
12971     return FALSE;
12972
12973   flags = sec->flags;
12974
12975   /* Return if it isn't a linkonce section.  A comdat group section
12976      also has SEC_LINK_ONCE set.  */
12977   if ((flags & SEC_LINK_ONCE) == 0)
12978     return FALSE;
12979
12980   /* Don't put group member sections on our list of already linked
12981      sections.  They are handled as a group via their group section.  */
12982   if (elf_sec_group (sec) != NULL)
12983     return FALSE;
12984
12985   /* For a SHT_GROUP section, use the group signature as the key.  */
12986   name = sec->name;
12987   if ((flags & SEC_GROUP) != 0
12988       && elf_next_in_group (sec) != NULL
12989       && elf_group_name (elf_next_in_group (sec)) != NULL)
12990     key = elf_group_name (elf_next_in_group (sec));
12991   else
12992     {
12993       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
12994       if (CONST_STRNEQ (name, ".gnu.linkonce.")
12995           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12996         key++;
12997       else
12998         /* Must be a user linkonce section that doesn't follow gcc's
12999            naming convention.  In this case we won't be matching
13000            single member groups.  */
13001         key = name;
13002     }
13003
13004   already_linked_list = bfd_section_already_linked_table_lookup (key);
13005
13006   for (l = already_linked_list->entry; l != NULL; l = l->next)
13007     {
13008       /* We may have 2 different types of sections on the list: group
13009          sections with a signature of <key> (<key> is some string),
13010          and linkonce sections named .gnu.linkonce.<type>.<key>.
13011          Match like sections.  LTO plugin sections are an exception.
13012          They are always named .gnu.linkonce.t.<key> and match either
13013          type of section.  */
13014       if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
13015            && ((flags & SEC_GROUP) != 0
13016                || strcmp (name, l->sec->name) == 0))
13017           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
13018         {
13019           /* The section has already been linked.  See if we should
13020              issue a warning.  */
13021           if (!_bfd_handle_already_linked (sec, l, info))
13022             return FALSE;
13023
13024           if (flags & SEC_GROUP)
13025             {
13026               asection *first = elf_next_in_group (sec);
13027               asection *s = first;
13028
13029               while (s != NULL)
13030                 {
13031                   s->output_section = bfd_abs_section_ptr;
13032                   /* Record which group discards it.  */
13033                   s->kept_section = l->sec;
13034                   s = elf_next_in_group (s);
13035                   /* These lists are circular.  */
13036                   if (s == first)
13037                     break;
13038                 }
13039             }
13040
13041           return TRUE;
13042         }
13043     }
13044
13045   /* A single member comdat group section may be discarded by a
13046      linkonce section and vice versa.  */
13047   if ((flags & SEC_GROUP) != 0)
13048     {
13049       asection *first = elf_next_in_group (sec);
13050
13051       if (first != NULL && elf_next_in_group (first) == first)
13052         /* Check this single member group against linkonce sections.  */
13053         for (l = already_linked_list->entry; l != NULL; l = l->next)
13054           if ((l->sec->flags & SEC_GROUP) == 0
13055               && bfd_elf_match_symbols_in_sections (l->sec, first, info))
13056             {
13057               first->output_section = bfd_abs_section_ptr;
13058               first->kept_section = l->sec;
13059               sec->output_section = bfd_abs_section_ptr;
13060               break;
13061             }
13062     }
13063   else
13064     /* Check this linkonce section against single member groups.  */
13065     for (l = already_linked_list->entry; l != NULL; l = l->next)
13066       if (l->sec->flags & SEC_GROUP)
13067         {
13068           asection *first = elf_next_in_group (l->sec);
13069
13070           if (first != NULL
13071               && elf_next_in_group (first) == first
13072               && bfd_elf_match_symbols_in_sections (first, sec, info))
13073             {
13074               sec->output_section = bfd_abs_section_ptr;
13075               sec->kept_section = first;
13076               break;
13077             }
13078         }
13079
13080   /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
13081      referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
13082      specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
13083      prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
13084      matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
13085      but its `.gnu.linkonce.t.F' is discarded means we chose one-only
13086      `.gnu.linkonce.t.F' section from a different bfd not requiring any
13087      `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
13088      The reverse order cannot happen as there is never a bfd with only the
13089      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
13090      matter as here were are looking only for cross-bfd sections.  */
13091
13092   if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
13093     for (l = already_linked_list->entry; l != NULL; l = l->next)
13094       if ((l->sec->flags & SEC_GROUP) == 0
13095           && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
13096         {
13097           if (abfd != l->sec->owner)
13098             sec->output_section = bfd_abs_section_ptr;
13099           break;
13100         }
13101
13102   /* This is the first section with this name.  Record it.  */
13103   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
13104     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
13105   return sec->output_section == bfd_abs_section_ptr;
13106 }
13107
13108 bfd_boolean
13109 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
13110 {
13111   return sym->st_shndx == SHN_COMMON;
13112 }
13113
13114 unsigned int
13115 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
13116 {
13117   return SHN_COMMON;
13118 }
13119
13120 asection *
13121 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
13122 {
13123   return bfd_com_section_ptr;
13124 }
13125
13126 bfd_vma
13127 _bfd_elf_default_got_elt_size (bfd *abfd,
13128                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
13129                                struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
13130                                bfd *ibfd ATTRIBUTE_UNUSED,
13131                                unsigned long symndx ATTRIBUTE_UNUSED)
13132 {
13133   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13134   return bed->s->arch_size / 8;
13135 }
13136
13137 /* Routines to support the creation of dynamic relocs.  */
13138
13139 /* Returns the name of the dynamic reloc section associated with SEC.  */
13140
13141 static const char *
13142 get_dynamic_reloc_section_name (bfd *       abfd,
13143                                 asection *  sec,
13144                                 bfd_boolean is_rela)
13145 {
13146   char *name;
13147   const char *old_name = bfd_get_section_name (NULL, sec);
13148   const char *prefix = is_rela ? ".rela" : ".rel";
13149
13150   if (old_name == NULL)
13151     return NULL;
13152
13153   name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
13154   sprintf (name, "%s%s", prefix, old_name);
13155
13156   return name;
13157 }
13158
13159 /* Returns the dynamic reloc section associated with SEC.
13160    If necessary compute the name of the dynamic reloc section based
13161    on SEC's name (looked up in ABFD's string table) and the setting
13162    of IS_RELA.  */
13163
13164 asection *
13165 _bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
13166                                     asection *  sec,
13167                                     bfd_boolean is_rela)
13168 {
13169   asection * reloc_sec = elf_section_data (sec)->sreloc;
13170
13171   if (reloc_sec == NULL)
13172     {
13173       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13174
13175       if (name != NULL)
13176         {
13177           reloc_sec = bfd_get_linker_section (abfd, name);
13178
13179           if (reloc_sec != NULL)
13180             elf_section_data (sec)->sreloc = reloc_sec;
13181         }
13182     }
13183
13184   return reloc_sec;
13185 }
13186
13187 /* Returns the dynamic reloc section associated with SEC.  If the
13188    section does not exist it is created and attached to the DYNOBJ
13189    bfd and stored in the SRELOC field of SEC's elf_section_data
13190    structure.
13191
13192    ALIGNMENT is the alignment for the newly created section and
13193    IS_RELA defines whether the name should be .rela.<SEC's name>
13194    or .rel.<SEC's name>.  The section name is looked up in the
13195    string table associated with ABFD.  */
13196
13197 asection *
13198 _bfd_elf_make_dynamic_reloc_section (asection *         sec,
13199                                      bfd *              dynobj,
13200                                      unsigned int       alignment,
13201                                      bfd *              abfd,
13202                                      bfd_boolean        is_rela)
13203 {
13204   asection * reloc_sec = elf_section_data (sec)->sreloc;
13205
13206   if (reloc_sec == NULL)
13207     {
13208       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13209
13210       if (name == NULL)
13211         return NULL;
13212
13213       reloc_sec = bfd_get_linker_section (dynobj, name);
13214
13215       if (reloc_sec == NULL)
13216         {
13217           flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
13218                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
13219           if ((sec->flags & SEC_ALLOC) != 0)
13220             flags |= SEC_ALLOC | SEC_LOAD;
13221
13222           reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
13223           if (reloc_sec != NULL)
13224             {
13225               /* _bfd_elf_get_sec_type_attr chooses a section type by
13226                  name.  Override as it may be wrong, eg. for a user
13227                  section named "auto" we'll get ".relauto" which is
13228                  seen to be a .rela section.  */
13229               elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
13230               if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
13231                 reloc_sec = NULL;
13232             }
13233         }
13234
13235       elf_section_data (sec)->sreloc = reloc_sec;
13236     }
13237
13238   return reloc_sec;
13239 }
13240
13241 /* Copy the ELF symbol type and other attributes for a linker script
13242    assignment from HSRC to HDEST.  Generally this should be treated as
13243    if we found a strong non-dynamic definition for HDEST (except that
13244    ld ignores multiple definition errors).  */
13245 void
13246 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
13247                                      struct bfd_link_hash_entry *hdest,
13248                                      struct bfd_link_hash_entry *hsrc)
13249 {
13250   struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest;
13251   struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc;
13252   Elf_Internal_Sym isym;
13253
13254   ehdest->type = ehsrc->type;
13255   ehdest->target_internal = ehsrc->target_internal;
13256
13257   isym.st_other = ehsrc->other;
13258   elf_merge_st_other (abfd, ehdest, &isym, TRUE, FALSE);
13259 }
13260
13261 /* Append a RELA relocation REL to section S in BFD.  */
13262
13263 void
13264 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13265 {
13266   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13267   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
13268   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
13269   bed->s->swap_reloca_out (abfd, rel, loc);
13270 }
13271
13272 /* Append a REL relocation REL to section S in BFD.  */
13273
13274 void
13275 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13276 {
13277   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13278   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
13279   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
13280   bed->s->swap_reloc_out (abfd, rel, loc);
13281 }