Properly mark the plugin symbol undefined
[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                   /* If a plugin symbol is referenced from a non-IR file,
9797                      mark the symbol as undefined, except for symbol for
9798                      linker created section.  */
9799                   if (h->root.non_ir_ref
9800                       && (h->root.type == bfd_link_hash_defined
9801                           || h->root.type == bfd_link_hash_defweak)
9802                       && (h->root.u.def.section->flags
9803                           & SEC_LINKER_CREATED) == 0
9804                       && h->root.u.def.section->owner != NULL
9805                       && (h->root.u.def.section->owner->flags
9806                           & BFD_PLUGIN) != 0)
9807                     {
9808                       h->root.type = bfd_link_hash_undefined;
9809                       h->root.u.undef.abfd = h->root.u.def.section->owner;
9810                     }
9811
9812                   ps = NULL;
9813                   if (h->root.type == bfd_link_hash_defined
9814                       || h->root.type == bfd_link_hash_defweak)
9815                     ps = &h->root.u.def.section;
9816
9817                   sym_name = h->root.root.string;
9818                 }
9819               else
9820                 {
9821                   Elf_Internal_Sym *sym = isymbuf + r_symndx;
9822
9823                   s_type = ELF_ST_TYPE (sym->st_info);
9824                   ps = &flinfo->sections[r_symndx];
9825                   sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9826                                                sym, *ps);
9827                 }
9828
9829               if ((s_type == STT_RELC || s_type == STT_SRELC)
9830                   && !flinfo->info->relocatable)
9831                 {
9832                   bfd_vma val;
9833                   bfd_vma dot = (rel->r_offset
9834                                  + o->output_offset + o->output_section->vma);
9835 #ifdef DEBUG
9836                   printf ("Encountered a complex symbol!");
9837                   printf (" (input_bfd %s, section %s, reloc %ld\n",
9838                           input_bfd->filename, o->name,
9839                           (long) (rel - internal_relocs));
9840                   printf (" symbol: idx  %8.8lx, name %s\n",
9841                           r_symndx, sym_name);
9842                   printf (" reloc : info %8.8lx, addr %8.8lx\n",
9843                           (unsigned long) rel->r_info,
9844                           (unsigned long) rel->r_offset);
9845 #endif
9846                   if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
9847                                     isymbuf, locsymcount, s_type == STT_SRELC))
9848                     return FALSE;
9849
9850                   /* Symbol evaluated OK.  Update to absolute value.  */
9851                   set_symbol_value (input_bfd, isymbuf, locsymcount,
9852                                     r_symndx, val);
9853                   continue;
9854                 }
9855
9856               if (action_discarded != -1 && ps != NULL)
9857                 {
9858                   /* Complain if the definition comes from a
9859                      discarded section.  */
9860                   if ((sec = *ps) != NULL && discarded_section (sec))
9861                     {
9862                       BFD_ASSERT (r_symndx != STN_UNDEF);
9863                       if (action_discarded & COMPLAIN)
9864                         (*flinfo->info->callbacks->einfo)
9865                           (_("%X`%s' referenced in section `%A' of %B: "
9866                              "defined in discarded section `%A' of %B\n"),
9867                            sym_name, o, input_bfd, sec, sec->owner);
9868
9869                       /* Try to do the best we can to support buggy old
9870                          versions of gcc.  Pretend that the symbol is
9871                          really defined in the kept linkonce section.
9872                          FIXME: This is quite broken.  Modifying the
9873                          symbol here means we will be changing all later
9874                          uses of the symbol, not just in this section.  */
9875                       if (action_discarded & PRETEND)
9876                         {
9877                           asection *kept;
9878
9879                           kept = _bfd_elf_check_kept_section (sec,
9880                                                               flinfo->info);
9881                           if (kept != NULL)
9882                             {
9883                               *ps = kept;
9884                               continue;
9885                             }
9886                         }
9887                     }
9888                 }
9889             }
9890
9891           /* Relocate the section by invoking a back end routine.
9892
9893              The back end routine is responsible for adjusting the
9894              section contents as necessary, and (if using Rela relocs
9895              and generating a relocatable output file) adjusting the
9896              reloc addend as necessary.
9897
9898              The back end routine does not have to worry about setting
9899              the reloc address or the reloc symbol index.
9900
9901              The back end routine is given a pointer to the swapped in
9902              internal symbols, and can access the hash table entries
9903              for the external symbols via elf_sym_hashes (input_bfd).
9904
9905              When generating relocatable output, the back end routine
9906              must handle STB_LOCAL/STT_SECTION symbols specially.  The
9907              output symbol is going to be a section symbol
9908              corresponding to the output section, which will require
9909              the addend to be adjusted.  */
9910
9911           ret = (*relocate_section) (output_bfd, flinfo->info,
9912                                      input_bfd, o, contents,
9913                                      internal_relocs,
9914                                      isymbuf,
9915                                      flinfo->sections);
9916           if (!ret)
9917             return FALSE;
9918
9919           if (ret == 2
9920               || flinfo->info->relocatable
9921               || flinfo->info->emitrelocations)
9922             {
9923               Elf_Internal_Rela *irela;
9924               Elf_Internal_Rela *irelaend, *irelamid;
9925               bfd_vma last_offset;
9926               struct elf_link_hash_entry **rel_hash;
9927               struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9928               Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9929               unsigned int next_erel;
9930               bfd_boolean rela_normal;
9931               struct bfd_elf_section_data *esdi, *esdo;
9932
9933               esdi = elf_section_data (o);
9934               esdo = elf_section_data (o->output_section);
9935               rela_normal = FALSE;
9936
9937               /* Adjust the reloc addresses and symbol indices.  */
9938
9939               irela = internal_relocs;
9940               irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9941               rel_hash = esdo->rel.hashes + esdo->rel.count;
9942               /* We start processing the REL relocs, if any.  When we reach
9943                  IRELAMID in the loop, we switch to the RELA relocs.  */
9944               irelamid = irela;
9945               if (esdi->rel.hdr != NULL)
9946                 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9947                              * bed->s->int_rels_per_ext_rel);
9948               rel_hash_list = rel_hash;
9949               rela_hash_list = NULL;
9950               last_offset = o->output_offset;
9951               if (!flinfo->info->relocatable)
9952                 last_offset += o->output_section->vma;
9953               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9954                 {
9955                   unsigned long r_symndx;
9956                   asection *sec;
9957                   Elf_Internal_Sym sym;
9958
9959                   if (next_erel == bed->s->int_rels_per_ext_rel)
9960                     {
9961                       rel_hash++;
9962                       next_erel = 0;
9963                     }
9964
9965                   if (irela == irelamid)
9966                     {
9967                       rel_hash = esdo->rela.hashes + esdo->rela.count;
9968                       rela_hash_list = rel_hash;
9969                       rela_normal = bed->rela_normal;
9970                     }
9971
9972                   irela->r_offset = _bfd_elf_section_offset (output_bfd,
9973                                                              flinfo->info, o,
9974                                                              irela->r_offset);
9975                   if (irela->r_offset >= (bfd_vma) -2)
9976                     {
9977                       /* This is a reloc for a deleted entry or somesuch.
9978                          Turn it into an R_*_NONE reloc, at the same
9979                          offset as the last reloc.  elf_eh_frame.c and
9980                          bfd_elf_discard_info rely on reloc offsets
9981                          being ordered.  */
9982                       irela->r_offset = last_offset;
9983                       irela->r_info = 0;
9984                       irela->r_addend = 0;
9985                       continue;
9986                     }
9987
9988                   irela->r_offset += o->output_offset;
9989
9990                   /* Relocs in an executable have to be virtual addresses.  */
9991                   if (!flinfo->info->relocatable)
9992                     irela->r_offset += o->output_section->vma;
9993
9994                   last_offset = irela->r_offset;
9995
9996                   r_symndx = irela->r_info >> r_sym_shift;
9997                   if (r_symndx == STN_UNDEF)
9998                     continue;
9999
10000                   if (r_symndx >= locsymcount
10001                       || (elf_bad_symtab (input_bfd)
10002                           && flinfo->sections[r_symndx] == NULL))
10003                     {
10004                       struct elf_link_hash_entry *rh;
10005                       unsigned long indx;
10006
10007                       /* This is a reloc against a global symbol.  We
10008                          have not yet output all the local symbols, so
10009                          we do not know the symbol index of any global
10010                          symbol.  We set the rel_hash entry for this
10011                          reloc to point to the global hash table entry
10012                          for this symbol.  The symbol index is then
10013                          set at the end of bfd_elf_final_link.  */
10014                       indx = r_symndx - extsymoff;
10015                       rh = elf_sym_hashes (input_bfd)[indx];
10016                       while (rh->root.type == bfd_link_hash_indirect
10017                              || rh->root.type == bfd_link_hash_warning)
10018                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
10019
10020                       /* Setting the index to -2 tells
10021                          elf_link_output_extsym that this symbol is
10022                          used by a reloc.  */
10023                       BFD_ASSERT (rh->indx < 0);
10024                       rh->indx = -2;
10025
10026                       *rel_hash = rh;
10027
10028                       continue;
10029                     }
10030
10031                   /* This is a reloc against a local symbol.  */
10032
10033                   *rel_hash = NULL;
10034                   sym = isymbuf[r_symndx];
10035                   sec = flinfo->sections[r_symndx];
10036                   if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
10037                     {
10038                       /* I suppose the backend ought to fill in the
10039                          section of any STT_SECTION symbol against a
10040                          processor specific section.  */
10041                       r_symndx = STN_UNDEF;
10042                       if (bfd_is_abs_section (sec))
10043                         ;
10044                       else if (sec == NULL || sec->owner == NULL)
10045                         {
10046                           bfd_set_error (bfd_error_bad_value);
10047                           return FALSE;
10048                         }
10049                       else
10050                         {
10051                           asection *osec = sec->output_section;
10052
10053                           /* If we have discarded a section, the output
10054                              section will be the absolute section.  In
10055                              case of discarded SEC_MERGE sections, use
10056                              the kept section.  relocate_section should
10057                              have already handled discarded linkonce
10058                              sections.  */
10059                           if (bfd_is_abs_section (osec)
10060                               && sec->kept_section != NULL
10061                               && sec->kept_section->output_section != NULL)
10062                             {
10063                               osec = sec->kept_section->output_section;
10064                               irela->r_addend -= osec->vma;
10065                             }
10066
10067                           if (!bfd_is_abs_section (osec))
10068                             {
10069                               r_symndx = osec->target_index;
10070                               if (r_symndx == STN_UNDEF)
10071                                 {
10072                                   irela->r_addend += osec->vma;
10073                                   osec = _bfd_nearby_section (output_bfd, osec,
10074                                                               osec->vma);
10075                                   irela->r_addend -= osec->vma;
10076                                   r_symndx = osec->target_index;
10077                                 }
10078                             }
10079                         }
10080
10081                       /* Adjust the addend according to where the
10082                          section winds up in the output section.  */
10083                       if (rela_normal)
10084                         irela->r_addend += sec->output_offset;
10085                     }
10086                   else
10087                     {
10088                       if (flinfo->indices[r_symndx] == -1)
10089                         {
10090                           unsigned long shlink;
10091                           const char *name;
10092                           asection *osec;
10093                           long indx;
10094
10095                           if (flinfo->info->strip == strip_all)
10096                             {
10097                               /* You can't do ld -r -s.  */
10098                               bfd_set_error (bfd_error_invalid_operation);
10099                               return FALSE;
10100                             }
10101
10102                           /* This symbol was skipped earlier, but
10103                              since it is needed by a reloc, we
10104                              must output it now.  */
10105                           shlink = symtab_hdr->sh_link;
10106                           name = (bfd_elf_string_from_elf_section
10107                                   (input_bfd, shlink, sym.st_name));
10108                           if (name == NULL)
10109                             return FALSE;
10110
10111                           osec = sec->output_section;
10112                           sym.st_shndx =
10113                             _bfd_elf_section_from_bfd_section (output_bfd,
10114                                                                osec);
10115                           if (sym.st_shndx == SHN_BAD)
10116                             return FALSE;
10117
10118                           sym.st_value += sec->output_offset;
10119                           if (!flinfo->info->relocatable)
10120                             {
10121                               sym.st_value += osec->vma;
10122                               if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
10123                                 {
10124                                   /* STT_TLS symbols are relative to PT_TLS
10125                                      segment base.  */
10126                                   BFD_ASSERT (elf_hash_table (flinfo->info)
10127                                               ->tls_sec != NULL);
10128                                   sym.st_value -= (elf_hash_table (flinfo->info)
10129                                                    ->tls_sec->vma);
10130                                 }
10131                             }
10132
10133                           indx = bfd_get_symcount (output_bfd);
10134                           ret = elf_link_output_sym (flinfo, name, &sym, sec,
10135                                                      NULL);
10136                           if (ret == 0)
10137                             return FALSE;
10138                           else if (ret == 1)
10139                             flinfo->indices[r_symndx] = indx;
10140                           else
10141                             abort ();
10142                         }
10143
10144                       r_symndx = flinfo->indices[r_symndx];
10145                     }
10146
10147                   irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
10148                                    | (irela->r_info & r_type_mask));
10149                 }
10150
10151               /* Swap out the relocs.  */
10152               input_rel_hdr = esdi->rel.hdr;
10153               if (input_rel_hdr && input_rel_hdr->sh_size != 0)
10154                 {
10155                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10156                                                      input_rel_hdr,
10157                                                      internal_relocs,
10158                                                      rel_hash_list))
10159                     return FALSE;
10160                   internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
10161                                       * bed->s->int_rels_per_ext_rel);
10162                   rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
10163                 }
10164
10165               input_rela_hdr = esdi->rela.hdr;
10166               if (input_rela_hdr && input_rela_hdr->sh_size != 0)
10167                 {
10168                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10169                                                      input_rela_hdr,
10170                                                      internal_relocs,
10171                                                      rela_hash_list))
10172                     return FALSE;
10173                 }
10174             }
10175         }
10176
10177       /* Write out the modified section contents.  */
10178       if (bed->elf_backend_write_section
10179           && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
10180                                                 contents))
10181         {
10182           /* Section written out.  */
10183         }
10184       else switch (o->sec_info_type)
10185         {
10186         case SEC_INFO_TYPE_STABS:
10187           if (! (_bfd_write_section_stabs
10188                  (output_bfd,
10189                   &elf_hash_table (flinfo->info)->stab_info,
10190                   o, &elf_section_data (o)->sec_info, contents)))
10191             return FALSE;
10192           break;
10193         case SEC_INFO_TYPE_MERGE:
10194           if (! _bfd_write_merged_section (output_bfd, o,
10195                                            elf_section_data (o)->sec_info))
10196             return FALSE;
10197           break;
10198         case SEC_INFO_TYPE_EH_FRAME:
10199           {
10200             if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10201                                                    o, contents))
10202               return FALSE;
10203           }
10204           break;
10205         default:
10206           {
10207             /* FIXME: octets_per_byte.  */
10208             if (! (o->flags & SEC_EXCLUDE))
10209               {
10210                 file_ptr offset = (file_ptr) o->output_offset;
10211                 bfd_size_type todo = o->size;
10212                 if ((o->flags & SEC_ELF_REVERSE_COPY))
10213                   {
10214                     /* Reverse-copy input section to output.  */
10215                     do
10216                       {
10217                         todo -= address_size;
10218                         if (! bfd_set_section_contents (output_bfd,
10219                                                         o->output_section,
10220                                                         contents + todo,
10221                                                         offset,
10222                                                         address_size))
10223                           return FALSE;
10224                         if (todo == 0)
10225                           break;
10226                         offset += address_size;
10227                       }
10228                     while (1);
10229                   }
10230                 else if (! bfd_set_section_contents (output_bfd,
10231                                                      o->output_section,
10232                                                      contents,
10233                                                      offset, todo))
10234                   return FALSE;
10235               }
10236           }
10237           break;
10238         }
10239     }
10240
10241   return TRUE;
10242 }
10243
10244 /* Generate a reloc when linking an ELF file.  This is a reloc
10245    requested by the linker, and does not come from any input file.  This
10246    is used to build constructor and destructor tables when linking
10247    with -Ur.  */
10248
10249 static bfd_boolean
10250 elf_reloc_link_order (bfd *output_bfd,
10251                       struct bfd_link_info *info,
10252                       asection *output_section,
10253                       struct bfd_link_order *link_order)
10254 {
10255   reloc_howto_type *howto;
10256   long indx;
10257   bfd_vma offset;
10258   bfd_vma addend;
10259   struct bfd_elf_section_reloc_data *reldata;
10260   struct elf_link_hash_entry **rel_hash_ptr;
10261   Elf_Internal_Shdr *rel_hdr;
10262   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10263   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10264   bfd_byte *erel;
10265   unsigned int i;
10266   struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10267
10268   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10269   if (howto == NULL)
10270     {
10271       bfd_set_error (bfd_error_bad_value);
10272       return FALSE;
10273     }
10274
10275   addend = link_order->u.reloc.p->addend;
10276
10277   if (esdo->rel.hdr)
10278     reldata = &esdo->rel;
10279   else if (esdo->rela.hdr)
10280     reldata = &esdo->rela;
10281   else
10282     {
10283       reldata = NULL;
10284       BFD_ASSERT (0);
10285     }
10286
10287   /* Figure out the symbol index.  */
10288   rel_hash_ptr = reldata->hashes + reldata->count;
10289   if (link_order->type == bfd_section_reloc_link_order)
10290     {
10291       indx = link_order->u.reloc.p->u.section->target_index;
10292       BFD_ASSERT (indx != 0);
10293       *rel_hash_ptr = NULL;
10294     }
10295   else
10296     {
10297       struct elf_link_hash_entry *h;
10298
10299       /* Treat a reloc against a defined symbol as though it were
10300          actually against the section.  */
10301       h = ((struct elf_link_hash_entry *)
10302            bfd_wrapped_link_hash_lookup (output_bfd, info,
10303                                          link_order->u.reloc.p->u.name,
10304                                          FALSE, FALSE, TRUE));
10305       if (h != NULL
10306           && (h->root.type == bfd_link_hash_defined
10307               || h->root.type == bfd_link_hash_defweak))
10308         {
10309           asection *section;
10310
10311           section = h->root.u.def.section;
10312           indx = section->output_section->target_index;
10313           *rel_hash_ptr = NULL;
10314           /* It seems that we ought to add the symbol value to the
10315              addend here, but in practice it has already been added
10316              because it was passed to constructor_callback.  */
10317           addend += section->output_section->vma + section->output_offset;
10318         }
10319       else if (h != NULL)
10320         {
10321           /* Setting the index to -2 tells elf_link_output_extsym that
10322              this symbol is used by a reloc.  */
10323           h->indx = -2;
10324           *rel_hash_ptr = h;
10325           indx = 0;
10326         }
10327       else
10328         {
10329           if (! ((*info->callbacks->unattached_reloc)
10330                  (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10331             return FALSE;
10332           indx = 0;
10333         }
10334     }
10335
10336   /* If this is an inplace reloc, we must write the addend into the
10337      object file.  */
10338   if (howto->partial_inplace && addend != 0)
10339     {
10340       bfd_size_type size;
10341       bfd_reloc_status_type rstat;
10342       bfd_byte *buf;
10343       bfd_boolean ok;
10344       const char *sym_name;
10345
10346       size = (bfd_size_type) bfd_get_reloc_size (howto);
10347       buf = (bfd_byte *) bfd_zmalloc (size);
10348       if (buf == NULL && size != 0)
10349         return FALSE;
10350       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10351       switch (rstat)
10352         {
10353         case bfd_reloc_ok:
10354           break;
10355
10356         default:
10357         case bfd_reloc_outofrange:
10358           abort ();
10359
10360         case bfd_reloc_overflow:
10361           if (link_order->type == bfd_section_reloc_link_order)
10362             sym_name = bfd_section_name (output_bfd,
10363                                          link_order->u.reloc.p->u.section);
10364           else
10365             sym_name = link_order->u.reloc.p->u.name;
10366           if (! ((*info->callbacks->reloc_overflow)
10367                  (info, NULL, sym_name, howto->name, addend, NULL,
10368                   NULL, (bfd_vma) 0)))
10369             {
10370               free (buf);
10371               return FALSE;
10372             }
10373           break;
10374         }
10375       ok = bfd_set_section_contents (output_bfd, output_section, buf,
10376                                      link_order->offset, size);
10377       free (buf);
10378       if (! ok)
10379         return FALSE;
10380     }
10381
10382   /* The address of a reloc is relative to the section in a
10383      relocatable file, and is a virtual address in an executable
10384      file.  */
10385   offset = link_order->offset;
10386   if (! info->relocatable)
10387     offset += output_section->vma;
10388
10389   for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10390     {
10391       irel[i].r_offset = offset;
10392       irel[i].r_info = 0;
10393       irel[i].r_addend = 0;
10394     }
10395   if (bed->s->arch_size == 32)
10396     irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10397   else
10398     irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10399
10400   rel_hdr = reldata->hdr;
10401   erel = rel_hdr->contents;
10402   if (rel_hdr->sh_type == SHT_REL)
10403     {
10404       erel += reldata->count * bed->s->sizeof_rel;
10405       (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10406     }
10407   else
10408     {
10409       irel[0].r_addend = addend;
10410       erel += reldata->count * bed->s->sizeof_rela;
10411       (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10412     }
10413
10414   ++reldata->count;
10415
10416   return TRUE;
10417 }
10418
10419
10420 /* Get the output vma of the section pointed to by the sh_link field.  */
10421
10422 static bfd_vma
10423 elf_get_linked_section_vma (struct bfd_link_order *p)
10424 {
10425   Elf_Internal_Shdr **elf_shdrp;
10426   asection *s;
10427   int elfsec;
10428
10429   s = p->u.indirect.section;
10430   elf_shdrp = elf_elfsections (s->owner);
10431   elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10432   elfsec = elf_shdrp[elfsec]->sh_link;
10433   /* PR 290:
10434      The Intel C compiler generates SHT_IA_64_UNWIND with
10435      SHF_LINK_ORDER.  But it doesn't set the sh_link or
10436      sh_info fields.  Hence we could get the situation
10437      where elfsec is 0.  */
10438   if (elfsec == 0)
10439     {
10440       const struct elf_backend_data *bed
10441         = get_elf_backend_data (s->owner);
10442       if (bed->link_order_error_handler)
10443         bed->link_order_error_handler
10444           (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10445       return 0;
10446     }
10447   else
10448     {
10449       s = elf_shdrp[elfsec]->bfd_section;
10450       return s->output_section->vma + s->output_offset;
10451     }
10452 }
10453
10454
10455 /* Compare two sections based on the locations of the sections they are
10456    linked to.  Used by elf_fixup_link_order.  */
10457
10458 static int
10459 compare_link_order (const void * a, const void * b)
10460 {
10461   bfd_vma apos;
10462   bfd_vma bpos;
10463
10464   apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10465   bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10466   if (apos < bpos)
10467     return -1;
10468   return apos > bpos;
10469 }
10470
10471
10472 /* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
10473    order as their linked sections.  Returns false if this could not be done
10474    because an output section includes both ordered and unordered
10475    sections.  Ideally we'd do this in the linker proper.  */
10476
10477 static bfd_boolean
10478 elf_fixup_link_order (bfd *abfd, asection *o)
10479 {
10480   int seen_linkorder;
10481   int seen_other;
10482   int n;
10483   struct bfd_link_order *p;
10484   bfd *sub;
10485   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10486   unsigned elfsec;
10487   struct bfd_link_order **sections;
10488   asection *s, *other_sec, *linkorder_sec;
10489   bfd_vma offset;
10490
10491   other_sec = NULL;
10492   linkorder_sec = NULL;
10493   seen_other = 0;
10494   seen_linkorder = 0;
10495   for (p = o->map_head.link_order; p != NULL; p = p->next)
10496     {
10497       if (p->type == bfd_indirect_link_order)
10498         {
10499           s = p->u.indirect.section;
10500           sub = s->owner;
10501           if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10502               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10503               && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10504               && elfsec < elf_numsections (sub)
10505               && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10506               && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10507             {
10508               seen_linkorder++;
10509               linkorder_sec = s;
10510             }
10511           else
10512             {
10513               seen_other++;
10514               other_sec = s;
10515             }
10516         }
10517       else
10518         seen_other++;
10519
10520       if (seen_other && seen_linkorder)
10521         {
10522           if (other_sec && linkorder_sec)
10523             (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10524                                    o, linkorder_sec,
10525                                    linkorder_sec->owner, other_sec,
10526                                    other_sec->owner);
10527           else
10528             (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10529                                    o);
10530           bfd_set_error (bfd_error_bad_value);
10531           return FALSE;
10532         }
10533     }
10534
10535   if (!seen_linkorder)
10536     return TRUE;
10537
10538   sections = (struct bfd_link_order **)
10539     bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10540   if (sections == NULL)
10541     return FALSE;
10542   seen_linkorder = 0;
10543
10544   for (p = o->map_head.link_order; p != NULL; p = p->next)
10545     {
10546       sections[seen_linkorder++] = p;
10547     }
10548   /* Sort the input sections in the order of their linked section.  */
10549   qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10550          compare_link_order);
10551
10552   /* Change the offsets of the sections.  */
10553   offset = 0;
10554   for (n = 0; n < seen_linkorder; n++)
10555     {
10556       s = sections[n]->u.indirect.section;
10557       offset &= ~(bfd_vma) 0 << s->alignment_power;
10558       s->output_offset = offset;
10559       sections[n]->offset = offset;
10560       /* FIXME: octets_per_byte.  */
10561       offset += sections[n]->size;
10562     }
10563
10564   free (sections);
10565   return TRUE;
10566 }
10567
10568 static void
10569 elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
10570 {
10571   asection *o;
10572
10573   if (flinfo->symstrtab != NULL)
10574     _bfd_stringtab_free (flinfo->symstrtab);
10575   if (flinfo->contents != NULL)
10576     free (flinfo->contents);
10577   if (flinfo->external_relocs != NULL)
10578     free (flinfo->external_relocs);
10579   if (flinfo->internal_relocs != NULL)
10580     free (flinfo->internal_relocs);
10581   if (flinfo->external_syms != NULL)
10582     free (flinfo->external_syms);
10583   if (flinfo->locsym_shndx != NULL)
10584     free (flinfo->locsym_shndx);
10585   if (flinfo->internal_syms != NULL)
10586     free (flinfo->internal_syms);
10587   if (flinfo->indices != NULL)
10588     free (flinfo->indices);
10589   if (flinfo->sections != NULL)
10590     free (flinfo->sections);
10591   if (flinfo->symbuf != NULL)
10592     free (flinfo->symbuf);
10593   if (flinfo->symshndxbuf != NULL)
10594     free (flinfo->symshndxbuf);
10595   for (o = obfd->sections; o != NULL; o = o->next)
10596     {
10597       struct bfd_elf_section_data *esdo = elf_section_data (o);
10598       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
10599         free (esdo->rel.hashes);
10600       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
10601         free (esdo->rela.hashes);
10602     }
10603 }
10604
10605 /* Do the final step of an ELF link.  */
10606
10607 bfd_boolean
10608 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10609 {
10610   bfd_boolean dynamic;
10611   bfd_boolean emit_relocs;
10612   bfd *dynobj;
10613   struct elf_final_link_info flinfo;
10614   asection *o;
10615   struct bfd_link_order *p;
10616   bfd *sub;
10617   bfd_size_type max_contents_size;
10618   bfd_size_type max_external_reloc_size;
10619   bfd_size_type max_internal_reloc_count;
10620   bfd_size_type max_sym_count;
10621   bfd_size_type max_sym_shndx_count;
10622   Elf_Internal_Sym elfsym;
10623   unsigned int i;
10624   Elf_Internal_Shdr *symtab_hdr;
10625   Elf_Internal_Shdr *symtab_shndx_hdr;
10626   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10627   struct elf_outext_info eoinfo;
10628   bfd_boolean merged;
10629   size_t relativecount = 0;
10630   asection *reldyn = 0;
10631   bfd_size_type amt;
10632   asection *attr_section = NULL;
10633   bfd_vma attr_size = 0;
10634   const char *std_attrs_section;
10635
10636   if (! is_elf_hash_table (info->hash))
10637     return FALSE;
10638
10639   if (info->shared)
10640     abfd->flags |= DYNAMIC;
10641
10642   dynamic = elf_hash_table (info)->dynamic_sections_created;
10643   dynobj = elf_hash_table (info)->dynobj;
10644
10645   emit_relocs = (info->relocatable
10646                  || info->emitrelocations);
10647
10648   flinfo.info = info;
10649   flinfo.output_bfd = abfd;
10650   flinfo.symstrtab = _bfd_elf_stringtab_init ();
10651   if (flinfo.symstrtab == NULL)
10652     return FALSE;
10653
10654   if (! dynamic)
10655     {
10656       flinfo.dynsym_sec = NULL;
10657       flinfo.hash_sec = NULL;
10658       flinfo.symver_sec = NULL;
10659     }
10660   else
10661     {
10662       flinfo.dynsym_sec = bfd_get_linker_section (dynobj, ".dynsym");
10663       flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
10664       /* Note that dynsym_sec can be NULL (on VMS).  */
10665       flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
10666       /* Note that it is OK if symver_sec is NULL.  */
10667     }
10668
10669   flinfo.contents = NULL;
10670   flinfo.external_relocs = NULL;
10671   flinfo.internal_relocs = NULL;
10672   flinfo.external_syms = NULL;
10673   flinfo.locsym_shndx = NULL;
10674   flinfo.internal_syms = NULL;
10675   flinfo.indices = NULL;
10676   flinfo.sections = NULL;
10677   flinfo.symbuf = NULL;
10678   flinfo.symshndxbuf = NULL;
10679   flinfo.symbuf_count = 0;
10680   flinfo.shndxbuf_size = 0;
10681   flinfo.filesym_count = 0;
10682
10683   /* The object attributes have been merged.  Remove the input
10684      sections from the link, and set the contents of the output
10685      secton.  */
10686   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10687   for (o = abfd->sections; o != NULL; o = o->next)
10688     {
10689       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10690           || strcmp (o->name, ".gnu.attributes") == 0)
10691         {
10692           for (p = o->map_head.link_order; p != NULL; p = p->next)
10693             {
10694               asection *input_section;
10695
10696               if (p->type != bfd_indirect_link_order)
10697                 continue;
10698               input_section = p->u.indirect.section;
10699               /* Hack: reset the SEC_HAS_CONTENTS flag so that
10700                  elf_link_input_bfd ignores this section.  */
10701               input_section->flags &= ~SEC_HAS_CONTENTS;
10702             }
10703
10704           attr_size = bfd_elf_obj_attr_size (abfd);
10705           if (attr_size)
10706             {
10707               bfd_set_section_size (abfd, o, attr_size);
10708               attr_section = o;
10709               /* Skip this section later on.  */
10710               o->map_head.link_order = NULL;
10711             }
10712           else
10713             o->flags |= SEC_EXCLUDE;
10714         }
10715     }
10716
10717   /* Count up the number of relocations we will output for each output
10718      section, so that we know the sizes of the reloc sections.  We
10719      also figure out some maximum sizes.  */
10720   max_contents_size = 0;
10721   max_external_reloc_size = 0;
10722   max_internal_reloc_count = 0;
10723   max_sym_count = 0;
10724   max_sym_shndx_count = 0;
10725   merged = FALSE;
10726   for (o = abfd->sections; o != NULL; o = o->next)
10727     {
10728       struct bfd_elf_section_data *esdo = elf_section_data (o);
10729       o->reloc_count = 0;
10730
10731       for (p = o->map_head.link_order; p != NULL; p = p->next)
10732         {
10733           unsigned int reloc_count = 0;
10734           struct bfd_elf_section_data *esdi = NULL;
10735
10736           if (p->type == bfd_section_reloc_link_order
10737               || p->type == bfd_symbol_reloc_link_order)
10738             reloc_count = 1;
10739           else if (p->type == bfd_indirect_link_order)
10740             {
10741               asection *sec;
10742
10743               sec = p->u.indirect.section;
10744               esdi = elf_section_data (sec);
10745
10746               /* Mark all sections which are to be included in the
10747                  link.  This will normally be every section.  We need
10748                  to do this so that we can identify any sections which
10749                  the linker has decided to not include.  */
10750               sec->linker_mark = TRUE;
10751
10752               if (sec->flags & SEC_MERGE)
10753                 merged = TRUE;
10754
10755               if (esdo->this_hdr.sh_type == SHT_REL
10756                   || esdo->this_hdr.sh_type == SHT_RELA)
10757                 /* Some backends use reloc_count in relocation sections
10758                    to count particular types of relocs.  Of course,
10759                    reloc sections themselves can't have relocations.  */
10760                 reloc_count = 0;
10761               else if (info->relocatable || info->emitrelocations)
10762                 reloc_count = sec->reloc_count;
10763               else if (bed->elf_backend_count_relocs)
10764                 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10765
10766               if (sec->rawsize > max_contents_size)
10767                 max_contents_size = sec->rawsize;
10768               if (sec->size > max_contents_size)
10769                 max_contents_size = sec->size;
10770
10771               /* We are interested in just local symbols, not all
10772                  symbols.  */
10773               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10774                   && (sec->owner->flags & DYNAMIC) == 0)
10775                 {
10776                   size_t sym_count;
10777
10778                   if (elf_bad_symtab (sec->owner))
10779                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10780                                  / bed->s->sizeof_sym);
10781                   else
10782                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10783
10784                   if (sym_count > max_sym_count)
10785                     max_sym_count = sym_count;
10786
10787                   if (sym_count > max_sym_shndx_count
10788                       && elf_symtab_shndx (sec->owner) != 0)
10789                     max_sym_shndx_count = sym_count;
10790
10791                   if ((sec->flags & SEC_RELOC) != 0)
10792                     {
10793                       size_t ext_size = 0;
10794
10795                       if (esdi->rel.hdr != NULL)
10796                         ext_size = esdi->rel.hdr->sh_size;
10797                       if (esdi->rela.hdr != NULL)
10798                         ext_size += esdi->rela.hdr->sh_size;
10799
10800                       if (ext_size > max_external_reloc_size)
10801                         max_external_reloc_size = ext_size;
10802                       if (sec->reloc_count > max_internal_reloc_count)
10803                         max_internal_reloc_count = sec->reloc_count;
10804                     }
10805                 }
10806             }
10807
10808           if (reloc_count == 0)
10809             continue;
10810
10811           o->reloc_count += reloc_count;
10812
10813           if (p->type == bfd_indirect_link_order
10814               && (info->relocatable || info->emitrelocations))
10815             {
10816               if (esdi->rel.hdr)
10817                 esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10818               if (esdi->rela.hdr)
10819                 esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10820             }
10821           else
10822             {
10823               if (o->use_rela_p)
10824                 esdo->rela.count += reloc_count;
10825               else
10826                 esdo->rel.count += reloc_count;
10827             }
10828         }
10829
10830       if (o->reloc_count > 0)
10831         o->flags |= SEC_RELOC;
10832       else
10833         {
10834           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
10835              set it (this is probably a bug) and if it is set
10836              assign_section_numbers will create a reloc section.  */
10837           o->flags &=~ SEC_RELOC;
10838         }
10839
10840       /* If the SEC_ALLOC flag is not set, force the section VMA to
10841          zero.  This is done in elf_fake_sections as well, but forcing
10842          the VMA to 0 here will ensure that relocs against these
10843          sections are handled correctly.  */
10844       if ((o->flags & SEC_ALLOC) == 0
10845           && ! o->user_set_vma)
10846         o->vma = 0;
10847     }
10848
10849   if (! info->relocatable && merged)
10850     elf_link_hash_traverse (elf_hash_table (info),
10851                             _bfd_elf_link_sec_merge_syms, abfd);
10852
10853   /* Figure out the file positions for everything but the symbol table
10854      and the relocs.  We set symcount to force assign_section_numbers
10855      to create a symbol table.  */
10856   bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
10857   BFD_ASSERT (! abfd->output_has_begun);
10858   if (! _bfd_elf_compute_section_file_positions (abfd, info))
10859     goto error_return;
10860
10861   /* Set sizes, and assign file positions for reloc sections.  */
10862   for (o = abfd->sections; o != NULL; o = o->next)
10863     {
10864       struct bfd_elf_section_data *esdo = elf_section_data (o);
10865       if ((o->flags & SEC_RELOC) != 0)
10866         {
10867           if (esdo->rel.hdr
10868               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10869             goto error_return;
10870
10871           if (esdo->rela.hdr
10872               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10873             goto error_return;
10874         }
10875
10876       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10877          to count upwards while actually outputting the relocations.  */
10878       esdo->rel.count = 0;
10879       esdo->rela.count = 0;
10880     }
10881
10882   /* We have now assigned file positions for all the sections except
10883      .symtab, .strtab, and non-loaded reloc sections.  We start the
10884      .symtab section at the current file position, and write directly
10885      to it.  We build the .strtab section in memory.  */
10886   bfd_get_symcount (abfd) = 0;
10887   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10888   /* sh_name is set in prep_headers.  */
10889   symtab_hdr->sh_type = SHT_SYMTAB;
10890   /* sh_flags, sh_addr and sh_size all start off zero.  */
10891   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10892   /* sh_link is set in assign_section_numbers.  */
10893   /* sh_info is set below.  */
10894   /* sh_offset is set just below.  */
10895   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10896
10897   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
10898      continuously seeking to the right position in the file.  */
10899   if (! info->keep_memory || max_sym_count < 20)
10900     flinfo.symbuf_size = 20;
10901   else
10902     flinfo.symbuf_size = max_sym_count;
10903   amt = flinfo.symbuf_size;
10904   amt *= bed->s->sizeof_sym;
10905   flinfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10906   if (flinfo.symbuf == NULL)
10907     goto error_return;
10908   if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10909     {
10910       /* Wild guess at number of output symbols.  realloc'd as needed.  */
10911       amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10912       flinfo.shndxbuf_size = amt;
10913       amt *= sizeof (Elf_External_Sym_Shndx);
10914       flinfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10915       if (flinfo.symshndxbuf == NULL)
10916         goto error_return;
10917     }
10918
10919   if (info->strip != strip_all || emit_relocs)
10920     {
10921       file_ptr off = elf_next_file_pos (abfd);
10922
10923       _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10924
10925       /* Note that at this point elf_next_file_pos (abfd) is
10926          incorrect.  We do not yet know the size of the .symtab section.
10927          We correct next_file_pos below, after we do know the size.  */
10928
10929       /* Start writing out the symbol table.  The first symbol is always a
10930          dummy symbol.  */
10931       elfsym.st_value = 0;
10932       elfsym.st_size = 0;
10933       elfsym.st_info = 0;
10934       elfsym.st_other = 0;
10935       elfsym.st_shndx = SHN_UNDEF;
10936       elfsym.st_target_internal = 0;
10937       if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
10938                                NULL) != 1)
10939         goto error_return;
10940
10941       /* Output a symbol for each section.  We output these even if we are
10942          discarding local symbols, since they are used for relocs.  These
10943          symbols have no names.  We store the index of each one in the
10944          index field of the section, so that we can find it again when
10945          outputting relocs.  */
10946
10947       elfsym.st_size = 0;
10948       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10949       elfsym.st_other = 0;
10950       elfsym.st_value = 0;
10951       elfsym.st_target_internal = 0;
10952       for (i = 1; i < elf_numsections (abfd); i++)
10953         {
10954           o = bfd_section_from_elf_index (abfd, i);
10955           if (o != NULL)
10956             {
10957               o->target_index = bfd_get_symcount (abfd);
10958               elfsym.st_shndx = i;
10959               if (!info->relocatable)
10960                 elfsym.st_value = o->vma;
10961               if (elf_link_output_sym (&flinfo, NULL, &elfsym, o, NULL) != 1)
10962                 goto error_return;
10963             }
10964         }
10965     }
10966
10967   /* Allocate some memory to hold information read in from the input
10968      files.  */
10969   if (max_contents_size != 0)
10970     {
10971       flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10972       if (flinfo.contents == NULL)
10973         goto error_return;
10974     }
10975
10976   if (max_external_reloc_size != 0)
10977     {
10978       flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
10979       if (flinfo.external_relocs == NULL)
10980         goto error_return;
10981     }
10982
10983   if (max_internal_reloc_count != 0)
10984     {
10985       amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10986       amt *= sizeof (Elf_Internal_Rela);
10987       flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10988       if (flinfo.internal_relocs == NULL)
10989         goto error_return;
10990     }
10991
10992   if (max_sym_count != 0)
10993     {
10994       amt = max_sym_count * bed->s->sizeof_sym;
10995       flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10996       if (flinfo.external_syms == NULL)
10997         goto error_return;
10998
10999       amt = max_sym_count * sizeof (Elf_Internal_Sym);
11000       flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
11001       if (flinfo.internal_syms == NULL)
11002         goto error_return;
11003
11004       amt = max_sym_count * sizeof (long);
11005       flinfo.indices = (long int *) bfd_malloc (amt);
11006       if (flinfo.indices == NULL)
11007         goto error_return;
11008
11009       amt = max_sym_count * sizeof (asection *);
11010       flinfo.sections = (asection **) bfd_malloc (amt);
11011       if (flinfo.sections == NULL)
11012         goto error_return;
11013     }
11014
11015   if (max_sym_shndx_count != 0)
11016     {
11017       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
11018       flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
11019       if (flinfo.locsym_shndx == NULL)
11020         goto error_return;
11021     }
11022
11023   if (elf_hash_table (info)->tls_sec)
11024     {
11025       bfd_vma base, end = 0;
11026       asection *sec;
11027
11028       for (sec = elf_hash_table (info)->tls_sec;
11029            sec && (sec->flags & SEC_THREAD_LOCAL);
11030            sec = sec->next)
11031         {
11032           bfd_size_type size = sec->size;
11033
11034           if (size == 0
11035               && (sec->flags & SEC_HAS_CONTENTS) == 0)
11036             {
11037               struct bfd_link_order *ord = sec->map_tail.link_order;
11038
11039               if (ord != NULL)
11040                 size = ord->offset + ord->size;
11041             }
11042           end = sec->vma + size;
11043         }
11044       base = elf_hash_table (info)->tls_sec->vma;
11045       /* Only align end of TLS section if static TLS doesn't have special
11046          alignment requirements.  */
11047       if (bed->static_tls_alignment == 1)
11048         end = align_power (end,
11049                            elf_hash_table (info)->tls_sec->alignment_power);
11050       elf_hash_table (info)->tls_size = end - base;
11051     }
11052
11053   /* Reorder SHF_LINK_ORDER sections.  */
11054   for (o = abfd->sections; o != NULL; o = o->next)
11055     {
11056       if (!elf_fixup_link_order (abfd, o))
11057         return FALSE;
11058     }
11059
11060   /* Since ELF permits relocations to be against local symbols, we
11061      must have the local symbols available when we do the relocations.
11062      Since we would rather only read the local symbols once, and we
11063      would rather not keep them in memory, we handle all the
11064      relocations for a single input file at the same time.
11065
11066      Unfortunately, there is no way to know the total number of local
11067      symbols until we have seen all of them, and the local symbol
11068      indices precede the global symbol indices.  This means that when
11069      we are generating relocatable output, and we see a reloc against
11070      a global symbol, we can not know the symbol index until we have
11071      finished examining all the local symbols to see which ones we are
11072      going to output.  To deal with this, we keep the relocations in
11073      memory, and don't output them until the end of the link.  This is
11074      an unfortunate waste of memory, but I don't see a good way around
11075      it.  Fortunately, it only happens when performing a relocatable
11076      link, which is not the common case.  FIXME: If keep_memory is set
11077      we could write the relocs out and then read them again; I don't
11078      know how bad the memory loss will be.  */
11079
11080   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11081     sub->output_has_begun = FALSE;
11082   for (o = abfd->sections; o != NULL; o = o->next)
11083     {
11084       for (p = o->map_head.link_order; p != NULL; p = p->next)
11085         {
11086           if (p->type == bfd_indirect_link_order
11087               && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
11088                   == bfd_target_elf_flavour)
11089               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
11090             {
11091               if (! sub->output_has_begun)
11092                 {
11093                   if (! elf_link_input_bfd (&flinfo, sub))
11094                     goto error_return;
11095                   sub->output_has_begun = TRUE;
11096                 }
11097             }
11098           else if (p->type == bfd_section_reloc_link_order
11099                    || p->type == bfd_symbol_reloc_link_order)
11100             {
11101               if (! elf_reloc_link_order (abfd, info, o, p))
11102                 goto error_return;
11103             }
11104           else
11105             {
11106               if (! _bfd_default_link_order (abfd, info, o, p))
11107                 {
11108                   if (p->type == bfd_indirect_link_order
11109                       && (bfd_get_flavour (sub)
11110                           == bfd_target_elf_flavour)
11111                       && (elf_elfheader (sub)->e_ident[EI_CLASS]
11112                           != bed->s->elfclass))
11113                     {
11114                       const char *iclass, *oclass;
11115
11116                       if (bed->s->elfclass == ELFCLASS64)
11117                         {
11118                           iclass = "ELFCLASS32";
11119                           oclass = "ELFCLASS64";
11120                         }
11121                       else
11122                         {
11123                           iclass = "ELFCLASS64";
11124                           oclass = "ELFCLASS32";
11125                         }
11126
11127                       bfd_set_error (bfd_error_wrong_format);
11128                       (*_bfd_error_handler)
11129                         (_("%B: file class %s incompatible with %s"),
11130                          sub, iclass, oclass);
11131                     }
11132
11133                   goto error_return;
11134                 }
11135             }
11136         }
11137     }
11138
11139   /* Free symbol buffer if needed.  */
11140   if (!info->reduce_memory_overheads)
11141     {
11142       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11143         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11144             && elf_tdata (sub)->symbuf)
11145           {
11146             free (elf_tdata (sub)->symbuf);
11147             elf_tdata (sub)->symbuf = NULL;
11148           }
11149     }
11150
11151   /* Output any global symbols that got converted to local in a
11152      version script or due to symbol visibility.  We do this in a
11153      separate step since ELF requires all local symbols to appear
11154      prior to any global symbols.  FIXME: We should only do this if
11155      some global symbols were, in fact, converted to become local.
11156      FIXME: Will this work correctly with the Irix 5 linker?  */
11157   eoinfo.failed = FALSE;
11158   eoinfo.flinfo = &flinfo;
11159   eoinfo.localsyms = TRUE;
11160   eoinfo.need_second_pass = FALSE;
11161   eoinfo.second_pass = FALSE;
11162   eoinfo.file_sym_done = FALSE;
11163   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11164   if (eoinfo.failed)
11165     return FALSE;
11166
11167   if (eoinfo.need_second_pass)
11168     {
11169       eoinfo.second_pass = TRUE;
11170       bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11171       if (eoinfo.failed)
11172         return FALSE;
11173     }
11174
11175   /* If backend needs to output some local symbols not present in the hash
11176      table, do it now.  */
11177   if (bed->elf_backend_output_arch_local_syms
11178       && (info->strip != strip_all || emit_relocs))
11179     {
11180       typedef int (*out_sym_func)
11181         (void *, const char *, Elf_Internal_Sym *, asection *,
11182          struct elf_link_hash_entry *);
11183
11184       if (! ((*bed->elf_backend_output_arch_local_syms)
11185              (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11186         return FALSE;
11187     }
11188
11189   /* That wrote out all the local symbols.  Finish up the symbol table
11190      with the global symbols. Even if we want to strip everything we
11191      can, we still need to deal with those global symbols that got
11192      converted to local in a version script.  */
11193
11194   /* The sh_info field records the index of the first non local symbol.  */
11195   symtab_hdr->sh_info = bfd_get_symcount (abfd);
11196
11197   if (dynamic
11198       && flinfo.dynsym_sec != NULL
11199       && flinfo.dynsym_sec->output_section != bfd_abs_section_ptr)
11200     {
11201       Elf_Internal_Sym sym;
11202       bfd_byte *dynsym = flinfo.dynsym_sec->contents;
11203       long last_local = 0;
11204
11205       /* Write out the section symbols for the output sections.  */
11206       if (info->shared || elf_hash_table (info)->is_relocatable_executable)
11207         {
11208           asection *s;
11209
11210           sym.st_size = 0;
11211           sym.st_name = 0;
11212           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11213           sym.st_other = 0;
11214           sym.st_target_internal = 0;
11215
11216           for (s = abfd->sections; s != NULL; s = s->next)
11217             {
11218               int indx;
11219               bfd_byte *dest;
11220               long dynindx;
11221
11222               dynindx = elf_section_data (s)->dynindx;
11223               if (dynindx <= 0)
11224                 continue;
11225               indx = elf_section_data (s)->this_idx;
11226               BFD_ASSERT (indx > 0);
11227               sym.st_shndx = indx;
11228               if (! check_dynsym (abfd, &sym))
11229                 return FALSE;
11230               sym.st_value = s->vma;
11231               dest = dynsym + dynindx * bed->s->sizeof_sym;
11232               if (last_local < dynindx)
11233                 last_local = dynindx;
11234               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11235             }
11236         }
11237
11238       /* Write out the local dynsyms.  */
11239       if (elf_hash_table (info)->dynlocal)
11240         {
11241           struct elf_link_local_dynamic_entry *e;
11242           for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
11243             {
11244               asection *s;
11245               bfd_byte *dest;
11246
11247               /* Copy the internal symbol and turn off visibility.
11248                  Note that we saved a word of storage and overwrote
11249                  the original st_name with the dynstr_index.  */
11250               sym = e->isym;
11251               sym.st_other &= ~ELF_ST_VISIBILITY (-1);
11252
11253               s = bfd_section_from_elf_index (e->input_bfd,
11254                                               e->isym.st_shndx);
11255               if (s != NULL)
11256                 {
11257                   sym.st_shndx =
11258                     elf_section_data (s->output_section)->this_idx;
11259                   if (! check_dynsym (abfd, &sym))
11260                     return FALSE;
11261                   sym.st_value = (s->output_section->vma
11262                                   + s->output_offset
11263                                   + e->isym.st_value);
11264                 }
11265
11266               if (last_local < e->dynindx)
11267                 last_local = e->dynindx;
11268
11269               dest = dynsym + e->dynindx * bed->s->sizeof_sym;
11270               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11271             }
11272         }
11273
11274       elf_section_data (flinfo.dynsym_sec->output_section)->this_hdr.sh_info =
11275         last_local + 1;
11276     }
11277
11278   /* We get the global symbols from the hash table.  */
11279   eoinfo.failed = FALSE;
11280   eoinfo.localsyms = FALSE;
11281   eoinfo.flinfo = &flinfo;
11282   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11283   if (eoinfo.failed)
11284     return FALSE;
11285
11286   /* If backend needs to output some symbols not present in the hash
11287      table, do it now.  */
11288   if (bed->elf_backend_output_arch_syms
11289       && (info->strip != strip_all || emit_relocs))
11290     {
11291       typedef int (*out_sym_func)
11292         (void *, const char *, Elf_Internal_Sym *, asection *,
11293          struct elf_link_hash_entry *);
11294
11295       if (! ((*bed->elf_backend_output_arch_syms)
11296              (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11297         return FALSE;
11298     }
11299
11300   /* Flush all symbols to the file.  */
11301   if (! elf_link_flush_output_syms (&flinfo, bed))
11302     return FALSE;
11303
11304   /* Now we know the size of the symtab section.  */
11305   if (bfd_get_symcount (abfd) > 0)
11306     {
11307       /* Finish up and write out the symbol string table (.strtab)
11308          section.  */
11309       Elf_Internal_Shdr *symstrtab_hdr;
11310       file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
11311
11312       symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
11313       if (symtab_shndx_hdr->sh_name != 0)
11314         {
11315           symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
11316           symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
11317           symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
11318           amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
11319           symtab_shndx_hdr->sh_size = amt;
11320
11321           off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
11322                                                            off, TRUE);
11323
11324           if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
11325               || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
11326             return FALSE;
11327         }
11328
11329       symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
11330       /* sh_name was set in prep_headers.  */
11331       symstrtab_hdr->sh_type = SHT_STRTAB;
11332       symstrtab_hdr->sh_flags = 0;
11333       symstrtab_hdr->sh_addr = 0;
11334       symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
11335       symstrtab_hdr->sh_entsize = 0;
11336       symstrtab_hdr->sh_link = 0;
11337       symstrtab_hdr->sh_info = 0;
11338       /* sh_offset is set just below.  */
11339       symstrtab_hdr->sh_addralign = 1;
11340
11341       off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
11342                                                        off, TRUE);
11343       elf_next_file_pos (abfd) = off;
11344
11345       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
11346           || ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
11347         return FALSE;
11348     }
11349
11350   /* Adjust the relocs to have the correct symbol indices.  */
11351   for (o = abfd->sections; o != NULL; o = o->next)
11352     {
11353       struct bfd_elf_section_data *esdo = elf_section_data (o);
11354       bfd_boolean sort;
11355       if ((o->flags & SEC_RELOC) == 0)
11356         continue;
11357
11358       sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
11359       if (esdo->rel.hdr != NULL)
11360         elf_link_adjust_relocs (abfd, &esdo->rel, sort);
11361       if (esdo->rela.hdr != NULL)
11362         elf_link_adjust_relocs (abfd, &esdo->rela, sort);
11363
11364       /* Set the reloc_count field to 0 to prevent write_relocs from
11365          trying to swap the relocs out itself.  */
11366       o->reloc_count = 0;
11367     }
11368
11369   if (dynamic && info->combreloc && dynobj != NULL)
11370     relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11371
11372   /* If we are linking against a dynamic object, or generating a
11373      shared library, finish up the dynamic linking information.  */
11374   if (dynamic)
11375     {
11376       bfd_byte *dyncon, *dynconend;
11377
11378       /* Fix up .dynamic entries.  */
11379       o = bfd_get_linker_section (dynobj, ".dynamic");
11380       BFD_ASSERT (o != NULL);
11381
11382       dyncon = o->contents;
11383       dynconend = o->contents + o->size;
11384       for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11385         {
11386           Elf_Internal_Dyn dyn;
11387           const char *name;
11388           unsigned int type;
11389
11390           bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11391
11392           switch (dyn.d_tag)
11393             {
11394             default:
11395               continue;
11396             case DT_NULL:
11397               if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11398                 {
11399                   switch (elf_section_data (reldyn)->this_hdr.sh_type)
11400                     {
11401                     case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11402                     case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11403                     default: continue;
11404                     }
11405                   dyn.d_un.d_val = relativecount;
11406                   relativecount = 0;
11407                   break;
11408                 }
11409               continue;
11410
11411             case DT_INIT:
11412               name = info->init_function;
11413               goto get_sym;
11414             case DT_FINI:
11415               name = info->fini_function;
11416             get_sym:
11417               {
11418                 struct elf_link_hash_entry *h;
11419
11420                 h = elf_link_hash_lookup (elf_hash_table (info), name,
11421                                           FALSE, FALSE, TRUE);
11422                 if (h != NULL
11423                     && (h->root.type == bfd_link_hash_defined
11424                         || h->root.type == bfd_link_hash_defweak))
11425                   {
11426                     dyn.d_un.d_ptr = h->root.u.def.value;
11427                     o = h->root.u.def.section;
11428                     if (o->output_section != NULL)
11429                       dyn.d_un.d_ptr += (o->output_section->vma
11430                                          + o->output_offset);
11431                     else
11432                       {
11433                         /* The symbol is imported from another shared
11434                            library and does not apply to this one.  */
11435                         dyn.d_un.d_ptr = 0;
11436                       }
11437                     break;
11438                   }
11439               }
11440               continue;
11441
11442             case DT_PREINIT_ARRAYSZ:
11443               name = ".preinit_array";
11444               goto get_size;
11445             case DT_INIT_ARRAYSZ:
11446               name = ".init_array";
11447               goto get_size;
11448             case DT_FINI_ARRAYSZ:
11449               name = ".fini_array";
11450             get_size:
11451               o = bfd_get_section_by_name (abfd, name);
11452               if (o == NULL)
11453                 {
11454                   (*_bfd_error_handler)
11455                     (_("%B: could not find output section %s"), abfd, name);
11456                   goto error_return;
11457                 }
11458               if (o->size == 0)
11459                 (*_bfd_error_handler)
11460                   (_("warning: %s section has zero size"), name);
11461               dyn.d_un.d_val = o->size;
11462               break;
11463
11464             case DT_PREINIT_ARRAY:
11465               name = ".preinit_array";
11466               goto get_vma;
11467             case DT_INIT_ARRAY:
11468               name = ".init_array";
11469               goto get_vma;
11470             case DT_FINI_ARRAY:
11471               name = ".fini_array";
11472               goto get_vma;
11473
11474             case DT_HASH:
11475               name = ".hash";
11476               goto get_vma;
11477             case DT_GNU_HASH:
11478               name = ".gnu.hash";
11479               goto get_vma;
11480             case DT_STRTAB:
11481               name = ".dynstr";
11482               goto get_vma;
11483             case DT_SYMTAB:
11484               name = ".dynsym";
11485               goto get_vma;
11486             case DT_VERDEF:
11487               name = ".gnu.version_d";
11488               goto get_vma;
11489             case DT_VERNEED:
11490               name = ".gnu.version_r";
11491               goto get_vma;
11492             case DT_VERSYM:
11493               name = ".gnu.version";
11494             get_vma:
11495               o = bfd_get_section_by_name (abfd, name);
11496               if (o == NULL)
11497                 {
11498                   (*_bfd_error_handler)
11499                     (_("%B: could not find output section %s"), abfd, name);
11500                   goto error_return;
11501                 }
11502               if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11503                 {
11504                   (*_bfd_error_handler)
11505                     (_("warning: section '%s' is being made into a note"), name);
11506                   bfd_set_error (bfd_error_nonrepresentable_section);
11507                   goto error_return;
11508                 }
11509               dyn.d_un.d_ptr = o->vma;
11510               break;
11511
11512             case DT_REL:
11513             case DT_RELA:
11514             case DT_RELSZ:
11515             case DT_RELASZ:
11516               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11517                 type = SHT_REL;
11518               else
11519                 type = SHT_RELA;
11520               dyn.d_un.d_val = 0;
11521               dyn.d_un.d_ptr = 0;
11522               for (i = 1; i < elf_numsections (abfd); i++)
11523                 {
11524                   Elf_Internal_Shdr *hdr;
11525
11526                   hdr = elf_elfsections (abfd)[i];
11527                   if (hdr->sh_type == type
11528                       && (hdr->sh_flags & SHF_ALLOC) != 0)
11529                     {
11530                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11531                         dyn.d_un.d_val += hdr->sh_size;
11532                       else
11533                         {
11534                           if (dyn.d_un.d_ptr == 0
11535                               || hdr->sh_addr < dyn.d_un.d_ptr)
11536                             dyn.d_un.d_ptr = hdr->sh_addr;
11537                         }
11538                     }
11539                 }
11540               break;
11541             }
11542           bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11543         }
11544     }
11545
11546   /* If we have created any dynamic sections, then output them.  */
11547   if (dynobj != NULL)
11548     {
11549       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11550         goto error_return;
11551
11552       /* Check for DT_TEXTREL (late, in case the backend removes it).  */
11553       if (((info->warn_shared_textrel && info->shared)
11554            || info->error_textrel)
11555           && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
11556         {
11557           bfd_byte *dyncon, *dynconend;
11558
11559           dyncon = o->contents;
11560           dynconend = o->contents + o->size;
11561           for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11562             {
11563               Elf_Internal_Dyn dyn;
11564
11565               bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11566
11567               if (dyn.d_tag == DT_TEXTREL)
11568                 {
11569                   if (info->error_textrel)
11570                     info->callbacks->einfo
11571                       (_("%P%X: read-only segment has dynamic relocations.\n"));
11572                   else
11573                     info->callbacks->einfo
11574                       (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11575                   break;
11576                 }
11577             }
11578         }
11579
11580       for (o = dynobj->sections; o != NULL; o = o->next)
11581         {
11582           if ((o->flags & SEC_HAS_CONTENTS) == 0
11583               || o->size == 0
11584               || o->output_section == bfd_abs_section_ptr)
11585             continue;
11586           if ((o->flags & SEC_LINKER_CREATED) == 0)
11587             {
11588               /* At this point, we are only interested in sections
11589                  created by _bfd_elf_link_create_dynamic_sections.  */
11590               continue;
11591             }
11592           if (elf_hash_table (info)->stab_info.stabstr == o)
11593             continue;
11594           if (elf_hash_table (info)->eh_info.hdr_sec == o)
11595             continue;
11596           if (strcmp (o->name, ".dynstr") != 0)
11597             {
11598               /* FIXME: octets_per_byte.  */
11599               if (! bfd_set_section_contents (abfd, o->output_section,
11600                                               o->contents,
11601                                               (file_ptr) o->output_offset,
11602                                               o->size))
11603                 goto error_return;
11604             }
11605           else
11606             {
11607               /* The contents of the .dynstr section are actually in a
11608                  stringtab.  */
11609               file_ptr off;
11610
11611               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11612               if (bfd_seek (abfd, off, SEEK_SET) != 0
11613                   || ! _bfd_elf_strtab_emit (abfd,
11614                                              elf_hash_table (info)->dynstr))
11615                 goto error_return;
11616             }
11617         }
11618     }
11619
11620   if (info->relocatable)
11621     {
11622       bfd_boolean failed = FALSE;
11623
11624       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11625       if (failed)
11626         goto error_return;
11627     }
11628
11629   /* If we have optimized stabs strings, output them.  */
11630   if (elf_hash_table (info)->stab_info.stabstr != NULL)
11631     {
11632       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11633         goto error_return;
11634     }
11635
11636   if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11637     goto error_return;
11638
11639   elf_final_link_free (abfd, &flinfo);
11640
11641   elf_linker (abfd) = TRUE;
11642
11643   if (attr_section)
11644     {
11645       bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11646       if (contents == NULL)
11647         return FALSE;   /* Bail out and fail.  */
11648       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11649       bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11650       free (contents);
11651     }
11652
11653   return TRUE;
11654
11655  error_return:
11656   elf_final_link_free (abfd, &flinfo);
11657   return FALSE;
11658 }
11659 \f
11660 /* Initialize COOKIE for input bfd ABFD.  */
11661
11662 static bfd_boolean
11663 init_reloc_cookie (struct elf_reloc_cookie *cookie,
11664                    struct bfd_link_info *info, bfd *abfd)
11665 {
11666   Elf_Internal_Shdr *symtab_hdr;
11667   const struct elf_backend_data *bed;
11668
11669   bed = get_elf_backend_data (abfd);
11670   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11671
11672   cookie->abfd = abfd;
11673   cookie->sym_hashes = elf_sym_hashes (abfd);
11674   cookie->bad_symtab = elf_bad_symtab (abfd);
11675   if (cookie->bad_symtab)
11676     {
11677       cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11678       cookie->extsymoff = 0;
11679     }
11680   else
11681     {
11682       cookie->locsymcount = symtab_hdr->sh_info;
11683       cookie->extsymoff = symtab_hdr->sh_info;
11684     }
11685
11686   if (bed->s->arch_size == 32)
11687     cookie->r_sym_shift = 8;
11688   else
11689     cookie->r_sym_shift = 32;
11690
11691   cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11692   if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11693     {
11694       cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11695                                               cookie->locsymcount, 0,
11696                                               NULL, NULL, NULL);
11697       if (cookie->locsyms == NULL)
11698         {
11699           info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11700           return FALSE;
11701         }
11702       if (info->keep_memory)
11703         symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11704     }
11705   return TRUE;
11706 }
11707
11708 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
11709
11710 static void
11711 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11712 {
11713   Elf_Internal_Shdr *symtab_hdr;
11714
11715   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11716   if (cookie->locsyms != NULL
11717       && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11718     free (cookie->locsyms);
11719 }
11720
11721 /* Initialize the relocation information in COOKIE for input section SEC
11722    of input bfd ABFD.  */
11723
11724 static bfd_boolean
11725 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11726                         struct bfd_link_info *info, bfd *abfd,
11727                         asection *sec)
11728 {
11729   const struct elf_backend_data *bed;
11730
11731   if (sec->reloc_count == 0)
11732     {
11733       cookie->rels = NULL;
11734       cookie->relend = NULL;
11735     }
11736   else
11737     {
11738       bed = get_elf_backend_data (abfd);
11739
11740       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11741                                                 info->keep_memory);
11742       if (cookie->rels == NULL)
11743         return FALSE;
11744       cookie->rel = cookie->rels;
11745       cookie->relend = (cookie->rels
11746                         + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11747     }
11748   cookie->rel = cookie->rels;
11749   return TRUE;
11750 }
11751
11752 /* Free the memory allocated by init_reloc_cookie_rels,
11753    if appropriate.  */
11754
11755 static void
11756 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11757                         asection *sec)
11758 {
11759   if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11760     free (cookie->rels);
11761 }
11762
11763 /* Initialize the whole of COOKIE for input section SEC.  */
11764
11765 static bfd_boolean
11766 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11767                                struct bfd_link_info *info,
11768                                asection *sec)
11769 {
11770   if (!init_reloc_cookie (cookie, info, sec->owner))
11771     goto error1;
11772   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11773     goto error2;
11774   return TRUE;
11775
11776  error2:
11777   fini_reloc_cookie (cookie, sec->owner);
11778  error1:
11779   return FALSE;
11780 }
11781
11782 /* Free the memory allocated by init_reloc_cookie_for_section,
11783    if appropriate.  */
11784
11785 static void
11786 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11787                                asection *sec)
11788 {
11789   fini_reloc_cookie_rels (cookie, sec);
11790   fini_reloc_cookie (cookie, sec->owner);
11791 }
11792 \f
11793 /* Garbage collect unused sections.  */
11794
11795 /* Default gc_mark_hook.  */
11796
11797 asection *
11798 _bfd_elf_gc_mark_hook (asection *sec,
11799                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
11800                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11801                        struct elf_link_hash_entry *h,
11802                        Elf_Internal_Sym *sym)
11803 {
11804   const char *sec_name;
11805
11806   if (h != NULL)
11807     {
11808       switch (h->root.type)
11809         {
11810         case bfd_link_hash_defined:
11811         case bfd_link_hash_defweak:
11812           return h->root.u.def.section;
11813
11814         case bfd_link_hash_common:
11815           return h->root.u.c.p->section;
11816
11817         case bfd_link_hash_undefined:
11818         case bfd_link_hash_undefweak:
11819           /* To work around a glibc bug, keep all XXX input sections
11820              when there is an as yet undefined reference to __start_XXX
11821              or __stop_XXX symbols.  The linker will later define such
11822              symbols for orphan input sections that have a name
11823              representable as a C identifier.  */
11824           if (strncmp (h->root.root.string, "__start_", 8) == 0)
11825             sec_name = h->root.root.string + 8;
11826           else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11827             sec_name = h->root.root.string + 7;
11828           else
11829             sec_name = NULL;
11830
11831           if (sec_name && *sec_name != '\0')
11832             {
11833               bfd *i;
11834
11835               for (i = info->input_bfds; i; i = i->link.next)
11836                 {
11837                   sec = bfd_get_section_by_name (i, sec_name);
11838                   if (sec)
11839                     sec->flags |= SEC_KEEP;
11840                 }
11841             }
11842           break;
11843
11844         default:
11845           break;
11846         }
11847     }
11848   else
11849     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11850
11851   return NULL;
11852 }
11853
11854 /* COOKIE->rel describes a relocation against section SEC, which is
11855    a section we've decided to keep.  Return the section that contains
11856    the relocation symbol, or NULL if no section contains it.  */
11857
11858 asection *
11859 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11860                        elf_gc_mark_hook_fn gc_mark_hook,
11861                        struct elf_reloc_cookie *cookie)
11862 {
11863   unsigned long r_symndx;
11864   struct elf_link_hash_entry *h;
11865
11866   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11867   if (r_symndx == STN_UNDEF)
11868     return NULL;
11869
11870   if (r_symndx >= cookie->locsymcount
11871       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11872     {
11873       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11874       if (h == NULL)
11875         {
11876           info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
11877                                   sec->owner);
11878           return NULL;
11879         }
11880       while (h->root.type == bfd_link_hash_indirect
11881              || h->root.type == bfd_link_hash_warning)
11882         h = (struct elf_link_hash_entry *) h->root.u.i.link;
11883       h->mark = 1;
11884       /* If this symbol is weak and there is a non-weak definition, we
11885          keep the non-weak definition because many backends put
11886          dynamic reloc info on the non-weak definition for code
11887          handling copy relocs.  */
11888       if (h->u.weakdef != NULL)
11889         h->u.weakdef->mark = 1;
11890       return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11891     }
11892
11893   return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11894                           &cookie->locsyms[r_symndx]);
11895 }
11896
11897 /* COOKIE->rel describes a relocation against section SEC, which is
11898    a section we've decided to keep.  Mark the section that contains
11899    the relocation symbol.  */
11900
11901 bfd_boolean
11902 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11903                         asection *sec,
11904                         elf_gc_mark_hook_fn gc_mark_hook,
11905                         struct elf_reloc_cookie *cookie)
11906 {
11907   asection *rsec;
11908
11909   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11910   if (rsec && !rsec->gc_mark)
11911     {
11912       if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
11913           || (rsec->owner->flags & DYNAMIC) != 0)
11914         rsec->gc_mark = 1;
11915       else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11916         return FALSE;
11917     }
11918   return TRUE;
11919 }
11920
11921 /* The mark phase of garbage collection.  For a given section, mark
11922    it and any sections in this section's group, and all the sections
11923    which define symbols to which it refers.  */
11924
11925 bfd_boolean
11926 _bfd_elf_gc_mark (struct bfd_link_info *info,
11927                   asection *sec,
11928                   elf_gc_mark_hook_fn gc_mark_hook)
11929 {
11930   bfd_boolean ret;
11931   asection *group_sec, *eh_frame;
11932
11933   sec->gc_mark = 1;
11934
11935   /* Mark all the sections in the group.  */
11936   group_sec = elf_section_data (sec)->next_in_group;
11937   if (group_sec && !group_sec->gc_mark)
11938     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11939       return FALSE;
11940
11941   /* Look through the section relocs.  */
11942   ret = TRUE;
11943   eh_frame = elf_eh_frame_section (sec->owner);
11944   if ((sec->flags & SEC_RELOC) != 0
11945       && sec->reloc_count > 0
11946       && sec != eh_frame)
11947     {
11948       struct elf_reloc_cookie cookie;
11949
11950       if (!init_reloc_cookie_for_section (&cookie, info, sec))
11951         ret = FALSE;
11952       else
11953         {
11954           for (; cookie.rel < cookie.relend; cookie.rel++)
11955             if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11956               {
11957                 ret = FALSE;
11958                 break;
11959               }
11960           fini_reloc_cookie_for_section (&cookie, sec);
11961         }
11962     }
11963
11964   if (ret && eh_frame && elf_fde_list (sec))
11965     {
11966       struct elf_reloc_cookie cookie;
11967
11968       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11969         ret = FALSE;
11970       else
11971         {
11972           if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11973                                       gc_mark_hook, &cookie))
11974             ret = FALSE;
11975           fini_reloc_cookie_for_section (&cookie, eh_frame);
11976         }
11977     }
11978
11979   return ret;
11980 }
11981
11982 /* Scan and mark sections in a special or debug section group.  */
11983
11984 static void
11985 _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
11986 {
11987   /* Point to first section of section group.  */
11988   asection *ssec;
11989   /* Used to iterate the section group.  */
11990   asection *msec;
11991
11992   bfd_boolean is_special_grp = TRUE;
11993   bfd_boolean is_debug_grp = TRUE;
11994
11995   /* First scan to see if group contains any section other than debug
11996      and special section.  */
11997   ssec = msec = elf_next_in_group (grp);
11998   do
11999     {
12000       if ((msec->flags & SEC_DEBUGGING) == 0)
12001         is_debug_grp = FALSE;
12002
12003       if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
12004         is_special_grp = FALSE;
12005
12006       msec = elf_next_in_group (msec);
12007     }
12008   while (msec != ssec);
12009
12010   /* If this is a pure debug section group or pure special section group,
12011      keep all sections in this group.  */
12012   if (is_debug_grp || is_special_grp)
12013     {
12014       do
12015         {
12016           msec->gc_mark = 1;
12017           msec = elf_next_in_group (msec);
12018         }
12019       while (msec != ssec);
12020     }
12021 }
12022
12023 /* Keep debug and special sections.  */
12024
12025 bfd_boolean
12026 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12027                                  elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
12028 {
12029   bfd *ibfd;
12030
12031   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12032     {
12033       asection *isec;
12034       bfd_boolean some_kept;
12035       bfd_boolean debug_frag_seen;
12036
12037       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12038         continue;
12039
12040       /* Ensure all linker created sections are kept,
12041          see if any other section is already marked,
12042          and note if we have any fragmented debug sections.  */
12043       debug_frag_seen = some_kept = FALSE;
12044       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12045         {
12046           if ((isec->flags & SEC_LINKER_CREATED) != 0)
12047             isec->gc_mark = 1;
12048           else if (isec->gc_mark)
12049             some_kept = TRUE;
12050
12051           if (debug_frag_seen == FALSE
12052               && (isec->flags & SEC_DEBUGGING)
12053               && CONST_STRNEQ (isec->name, ".debug_line."))
12054             debug_frag_seen = TRUE;
12055         }
12056
12057       /* If no section in this file will be kept, then we can
12058          toss out the debug and special sections.  */
12059       if (!some_kept)
12060         continue;
12061
12062       /* Keep debug and special sections like .comment when they are
12063          not part of a group.  Also keep section groups that contain
12064          just debug sections or special sections.  */
12065       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12066         {
12067           if ((isec->flags & SEC_GROUP) != 0)
12068             _bfd_elf_gc_mark_debug_special_section_group (isec);
12069           else if (((isec->flags & SEC_DEBUGGING) != 0
12070                     || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
12071                    && elf_next_in_group (isec) == NULL)
12072             isec->gc_mark = 1;
12073         }
12074
12075       if (! debug_frag_seen)
12076         continue;
12077
12078       /* Look for CODE sections which are going to be discarded,
12079          and find and discard any fragmented debug sections which
12080          are associated with that code section.  */
12081       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12082         if ((isec->flags & SEC_CODE) != 0
12083             && isec->gc_mark == 0)
12084           {
12085             unsigned int ilen;
12086             asection *dsec;
12087
12088             ilen = strlen (isec->name);
12089
12090             /* Association is determined by the name of the debug section
12091                containing the name of the code section as a suffix.  For
12092                example .debug_line.text.foo is a debug section associated
12093                with .text.foo.  */
12094             for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
12095               {
12096                 unsigned int dlen;
12097
12098                 if (dsec->gc_mark == 0
12099                     || (dsec->flags & SEC_DEBUGGING) == 0)
12100                   continue;
12101
12102                 dlen = strlen (dsec->name);
12103
12104                 if (dlen > ilen
12105                     && strncmp (dsec->name + (dlen - ilen),
12106                                 isec->name, ilen) == 0)
12107                   {
12108                     dsec->gc_mark = 0;
12109                     break;
12110                   }
12111               }
12112           }
12113     }
12114   return TRUE;
12115 }
12116
12117 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
12118
12119 struct elf_gc_sweep_symbol_info
12120 {
12121   struct bfd_link_info *info;
12122   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
12123                        bfd_boolean);
12124 };
12125
12126 static bfd_boolean
12127 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
12128 {
12129   if (!h->mark
12130       && (((h->root.type == bfd_link_hash_defined
12131             || h->root.type == bfd_link_hash_defweak)
12132            && !((h->def_regular || ELF_COMMON_DEF_P (h))
12133                 && h->root.u.def.section->gc_mark))
12134           || h->root.type == bfd_link_hash_undefined
12135           || h->root.type == bfd_link_hash_undefweak))
12136     {
12137       struct elf_gc_sweep_symbol_info *inf;
12138
12139       inf = (struct elf_gc_sweep_symbol_info *) data;
12140       (*inf->hide_symbol) (inf->info, h, TRUE);
12141       h->def_regular = 0;
12142       h->ref_regular = 0;
12143       h->ref_regular_nonweak = 0;
12144     }
12145
12146   return TRUE;
12147 }
12148
12149 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
12150
12151 typedef bfd_boolean (*gc_sweep_hook_fn)
12152   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
12153
12154 static bfd_boolean
12155 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
12156 {
12157   bfd *sub;
12158   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12159   gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
12160   unsigned long section_sym_count;
12161   struct elf_gc_sweep_symbol_info sweep_info;
12162
12163   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12164     {
12165       asection *o;
12166
12167       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12168         continue;
12169
12170       for (o = sub->sections; o != NULL; o = o->next)
12171         {
12172           /* When any section in a section group is kept, we keep all
12173              sections in the section group.  If the first member of
12174              the section group is excluded, we will also exclude the
12175              group section.  */
12176           if (o->flags & SEC_GROUP)
12177             {
12178               asection *first = elf_next_in_group (o);
12179               o->gc_mark = first->gc_mark;
12180             }
12181
12182           if (o->gc_mark)
12183             continue;
12184
12185           /* Skip sweeping sections already excluded.  */
12186           if (o->flags & SEC_EXCLUDE)
12187             continue;
12188
12189           /* Since this is early in the link process, it is simple
12190              to remove a section from the output.  */
12191           o->flags |= SEC_EXCLUDE;
12192
12193           if (info->print_gc_sections && o->size != 0)
12194             _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
12195
12196           /* But we also have to update some of the relocation
12197              info we collected before.  */
12198           if (gc_sweep_hook
12199               && (o->flags & SEC_RELOC) != 0
12200               && o->reloc_count != 0
12201               && !((info->strip == strip_all || info->strip == strip_debugger)
12202                    && (o->flags & SEC_DEBUGGING) != 0)
12203               && !bfd_is_abs_section (o->output_section))
12204             {
12205               Elf_Internal_Rela *internal_relocs;
12206               bfd_boolean r;
12207
12208               internal_relocs
12209                 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
12210                                              info->keep_memory);
12211               if (internal_relocs == NULL)
12212                 return FALSE;
12213
12214               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
12215
12216               if (elf_section_data (o)->relocs != internal_relocs)
12217                 free (internal_relocs);
12218
12219               if (!r)
12220                 return FALSE;
12221             }
12222         }
12223     }
12224
12225   /* Remove the symbols that were in the swept sections from the dynamic
12226      symbol table.  GCFIXME: Anyone know how to get them out of the
12227      static symbol table as well?  */
12228   sweep_info.info = info;
12229   sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
12230   elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
12231                           &sweep_info);
12232
12233   _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
12234   return TRUE;
12235 }
12236
12237 /* Propagate collected vtable information.  This is called through
12238    elf_link_hash_traverse.  */
12239
12240 static bfd_boolean
12241 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
12242 {
12243   /* Those that are not vtables.  */
12244   if (h->vtable == NULL || h->vtable->parent == NULL)
12245     return TRUE;
12246
12247   /* Those vtables that do not have parents, we cannot merge.  */
12248   if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
12249     return TRUE;
12250
12251   /* If we've already been done, exit.  */
12252   if (h->vtable->used && h->vtable->used[-1])
12253     return TRUE;
12254
12255   /* Make sure the parent's table is up to date.  */
12256   elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
12257
12258   if (h->vtable->used == NULL)
12259     {
12260       /* None of this table's entries were referenced.  Re-use the
12261          parent's table.  */
12262       h->vtable->used = h->vtable->parent->vtable->used;
12263       h->vtable->size = h->vtable->parent->vtable->size;
12264     }
12265   else
12266     {
12267       size_t n;
12268       bfd_boolean *cu, *pu;
12269
12270       /* Or the parent's entries into ours.  */
12271       cu = h->vtable->used;
12272       cu[-1] = TRUE;
12273       pu = h->vtable->parent->vtable->used;
12274       if (pu != NULL)
12275         {
12276           const struct elf_backend_data *bed;
12277           unsigned int log_file_align;
12278
12279           bed = get_elf_backend_data (h->root.u.def.section->owner);
12280           log_file_align = bed->s->log_file_align;
12281           n = h->vtable->parent->vtable->size >> log_file_align;
12282           while (n--)
12283             {
12284               if (*pu)
12285                 *cu = TRUE;
12286               pu++;
12287               cu++;
12288             }
12289         }
12290     }
12291
12292   return TRUE;
12293 }
12294
12295 static bfd_boolean
12296 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
12297 {
12298   asection *sec;
12299   bfd_vma hstart, hend;
12300   Elf_Internal_Rela *relstart, *relend, *rel;
12301   const struct elf_backend_data *bed;
12302   unsigned int log_file_align;
12303
12304   /* Take care of both those symbols that do not describe vtables as
12305      well as those that are not loaded.  */
12306   if (h->vtable == NULL || h->vtable->parent == NULL)
12307     return TRUE;
12308
12309   BFD_ASSERT (h->root.type == bfd_link_hash_defined
12310               || h->root.type == bfd_link_hash_defweak);
12311
12312   sec = h->root.u.def.section;
12313   hstart = h->root.u.def.value;
12314   hend = hstart + h->size;
12315
12316   relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
12317   if (!relstart)
12318     return *(bfd_boolean *) okp = FALSE;
12319   bed = get_elf_backend_data (sec->owner);
12320   log_file_align = bed->s->log_file_align;
12321
12322   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
12323
12324   for (rel = relstart; rel < relend; ++rel)
12325     if (rel->r_offset >= hstart && rel->r_offset < hend)
12326       {
12327         /* If the entry is in use, do nothing.  */
12328         if (h->vtable->used
12329             && (rel->r_offset - hstart) < h->vtable->size)
12330           {
12331             bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
12332             if (h->vtable->used[entry])
12333               continue;
12334           }
12335         /* Otherwise, kill it.  */
12336         rel->r_offset = rel->r_info = rel->r_addend = 0;
12337       }
12338
12339   return TRUE;
12340 }
12341
12342 /* Mark sections containing dynamically referenced symbols.  When
12343    building shared libraries, we must assume that any visible symbol is
12344    referenced.  */
12345
12346 bfd_boolean
12347 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
12348 {
12349   struct bfd_link_info *info = (struct bfd_link_info *) inf;
12350   struct bfd_elf_dynamic_list *d = info->dynamic_list;
12351
12352   if ((h->root.type == bfd_link_hash_defined
12353        || h->root.type == bfd_link_hash_defweak)
12354       && (h->ref_dynamic
12355           || ((h->def_regular || ELF_COMMON_DEF_P (h))
12356               && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
12357               && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
12358               && (!info->executable
12359                   || info->export_dynamic
12360                   || (h->dynamic
12361                       && d != NULL
12362                       && (*d->match) (&d->head, NULL, h->root.root.string)))
12363               && (strchr (h->root.root.string, ELF_VER_CHR) != NULL
12364                   || !bfd_hide_sym_by_version (info->version_info,
12365                                                h->root.root.string)))))
12366     h->root.u.def.section->flags |= SEC_KEEP;
12367
12368   return TRUE;
12369 }
12370
12371 /* Keep all sections containing symbols undefined on the command-line,
12372    and the section containing the entry symbol.  */
12373
12374 void
12375 _bfd_elf_gc_keep (struct bfd_link_info *info)
12376 {
12377   struct bfd_sym_chain *sym;
12378
12379   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
12380     {
12381       struct elf_link_hash_entry *h;
12382
12383       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
12384                                 FALSE, FALSE, FALSE);
12385
12386       if (h != NULL
12387           && (h->root.type == bfd_link_hash_defined
12388               || h->root.type == bfd_link_hash_defweak)
12389           && !bfd_is_abs_section (h->root.u.def.section))
12390         h->root.u.def.section->flags |= SEC_KEEP;
12391     }
12392 }
12393
12394 /* Do mark and sweep of unused sections.  */
12395
12396 bfd_boolean
12397 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
12398 {
12399   bfd_boolean ok = TRUE;
12400   bfd *sub;
12401   elf_gc_mark_hook_fn gc_mark_hook;
12402   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12403   struct elf_link_hash_table *htab;
12404
12405   if (!bed->can_gc_sections
12406       || !is_elf_hash_table (info->hash))
12407     {
12408       (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12409       return TRUE;
12410     }
12411
12412   bed->gc_keep (info);
12413   htab = elf_hash_table (info);
12414
12415   /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
12416      at the .eh_frame section if we can mark the FDEs individually.  */
12417   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12418     {
12419       asection *sec;
12420       struct elf_reloc_cookie cookie;
12421
12422       sec = bfd_get_section_by_name (sub, ".eh_frame");
12423       while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12424         {
12425           _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12426           if (elf_section_data (sec)->sec_info
12427               && (sec->flags & SEC_LINKER_CREATED) == 0)
12428             elf_eh_frame_section (sub) = sec;
12429           fini_reloc_cookie_for_section (&cookie, sec);
12430           sec = bfd_get_next_section_by_name (sec);
12431         }
12432     }
12433
12434   /* Apply transitive closure to the vtable entry usage info.  */
12435   elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
12436   if (!ok)
12437     return FALSE;
12438
12439   /* Kill the vtable relocations that were not used.  */
12440   elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
12441   if (!ok)
12442     return FALSE;
12443
12444   /* Mark dynamically referenced symbols.  */
12445   if (htab->dynamic_sections_created)
12446     elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info);
12447
12448   /* Grovel through relocs to find out who stays ...  */
12449   gc_mark_hook = bed->gc_mark_hook;
12450   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12451     {
12452       asection *o;
12453
12454       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12455         continue;
12456
12457       /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12458          Also treat note sections as a root, if the section is not part
12459          of a group.  */
12460       for (o = sub->sections; o != NULL; o = o->next)
12461         if (!o->gc_mark
12462             && (o->flags & SEC_EXCLUDE) == 0
12463             && ((o->flags & SEC_KEEP) != 0
12464                 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12465                     && elf_next_in_group (o) == NULL )))
12466           {
12467             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12468               return FALSE;
12469           }
12470     }
12471
12472   /* Allow the backend to mark additional target specific sections.  */
12473   bed->gc_mark_extra_sections (info, gc_mark_hook);
12474
12475   /* ... and mark SEC_EXCLUDE for those that go.  */
12476   return elf_gc_sweep (abfd, info);
12477 }
12478 \f
12479 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
12480
12481 bfd_boolean
12482 bfd_elf_gc_record_vtinherit (bfd *abfd,
12483                              asection *sec,
12484                              struct elf_link_hash_entry *h,
12485                              bfd_vma offset)
12486 {
12487   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12488   struct elf_link_hash_entry **search, *child;
12489   bfd_size_type extsymcount;
12490   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12491
12492   /* The sh_info field of the symtab header tells us where the
12493      external symbols start.  We don't care about the local symbols at
12494      this point.  */
12495   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12496   if (!elf_bad_symtab (abfd))
12497     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12498
12499   sym_hashes = elf_sym_hashes (abfd);
12500   sym_hashes_end = sym_hashes + extsymcount;
12501
12502   /* Hunt down the child symbol, which is in this section at the same
12503      offset as the relocation.  */
12504   for (search = sym_hashes; search != sym_hashes_end; ++search)
12505     {
12506       if ((child = *search) != NULL
12507           && (child->root.type == bfd_link_hash_defined
12508               || child->root.type == bfd_link_hash_defweak)
12509           && child->root.u.def.section == sec
12510           && child->root.u.def.value == offset)
12511         goto win;
12512     }
12513
12514   (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12515                          abfd, sec, (unsigned long) offset);
12516   bfd_set_error (bfd_error_invalid_operation);
12517   return FALSE;
12518
12519  win:
12520   if (!child->vtable)
12521     {
12522       child->vtable = (struct elf_link_virtual_table_entry *)
12523           bfd_zalloc (abfd, sizeof (*child->vtable));
12524       if (!child->vtable)
12525         return FALSE;
12526     }
12527   if (!h)
12528     {
12529       /* This *should* only be the absolute section.  It could potentially
12530          be that someone has defined a non-global vtable though, which
12531          would be bad.  It isn't worth paging in the local symbols to be
12532          sure though; that case should simply be handled by the assembler.  */
12533
12534       child->vtable->parent = (struct elf_link_hash_entry *) -1;
12535     }
12536   else
12537     child->vtable->parent = h;
12538
12539   return TRUE;
12540 }
12541
12542 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
12543
12544 bfd_boolean
12545 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12546                            asection *sec ATTRIBUTE_UNUSED,
12547                            struct elf_link_hash_entry *h,
12548                            bfd_vma addend)
12549 {
12550   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12551   unsigned int log_file_align = bed->s->log_file_align;
12552
12553   if (!h->vtable)
12554     {
12555       h->vtable = (struct elf_link_virtual_table_entry *)
12556           bfd_zalloc (abfd, sizeof (*h->vtable));
12557       if (!h->vtable)
12558         return FALSE;
12559     }
12560
12561   if (addend >= h->vtable->size)
12562     {
12563       size_t size, bytes, file_align;
12564       bfd_boolean *ptr = h->vtable->used;
12565
12566       /* While the symbol is undefined, we have to be prepared to handle
12567          a zero size.  */
12568       file_align = 1 << log_file_align;
12569       if (h->root.type == bfd_link_hash_undefined)
12570         size = addend + file_align;
12571       else
12572         {
12573           size = h->size;
12574           if (addend >= size)
12575             {
12576               /* Oops!  We've got a reference past the defined end of
12577                  the table.  This is probably a bug -- shall we warn?  */
12578               size = addend + file_align;
12579             }
12580         }
12581       size = (size + file_align - 1) & -file_align;
12582
12583       /* Allocate one extra entry for use as a "done" flag for the
12584          consolidation pass.  */
12585       bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12586
12587       if (ptr)
12588         {
12589           ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12590
12591           if (ptr != NULL)
12592             {
12593               size_t oldbytes;
12594
12595               oldbytes = (((h->vtable->size >> log_file_align) + 1)
12596                           * sizeof (bfd_boolean));
12597               memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12598             }
12599         }
12600       else
12601         ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12602
12603       if (ptr == NULL)
12604         return FALSE;
12605
12606       /* And arrange for that done flag to be at index -1.  */
12607       h->vtable->used = ptr + 1;
12608       h->vtable->size = size;
12609     }
12610
12611   h->vtable->used[addend >> log_file_align] = TRUE;
12612
12613   return TRUE;
12614 }
12615
12616 /* Map an ELF section header flag to its corresponding string.  */
12617 typedef struct
12618 {
12619   char *flag_name;
12620   flagword flag_value;
12621 } elf_flags_to_name_table;
12622
12623 static elf_flags_to_name_table elf_flags_to_names [] =
12624 {
12625   { "SHF_WRITE", SHF_WRITE },
12626   { "SHF_ALLOC", SHF_ALLOC },
12627   { "SHF_EXECINSTR", SHF_EXECINSTR },
12628   { "SHF_MERGE", SHF_MERGE },
12629   { "SHF_STRINGS", SHF_STRINGS },
12630   { "SHF_INFO_LINK", SHF_INFO_LINK},
12631   { "SHF_LINK_ORDER", SHF_LINK_ORDER},
12632   { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12633   { "SHF_GROUP", SHF_GROUP },
12634   { "SHF_TLS", SHF_TLS },
12635   { "SHF_MASKOS", SHF_MASKOS },
12636   { "SHF_EXCLUDE", SHF_EXCLUDE },
12637 };
12638
12639 /* Returns TRUE if the section is to be included, otherwise FALSE.  */
12640 bfd_boolean
12641 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12642                               struct flag_info *flaginfo,
12643                               asection *section)
12644 {
12645   const bfd_vma sh_flags = elf_section_flags (section);
12646
12647   if (!flaginfo->flags_initialized)
12648     {
12649       bfd *obfd = info->output_bfd;
12650       const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12651       struct flag_info_list *tf = flaginfo->flag_list;
12652       int with_hex = 0;
12653       int without_hex = 0;
12654
12655       for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
12656         {
12657           unsigned i;
12658           flagword (*lookup) (char *);
12659
12660           lookup = bed->elf_backend_lookup_section_flags_hook;
12661           if (lookup != NULL)
12662             {
12663               flagword hexval = (*lookup) ((char *) tf->name);
12664
12665               if (hexval != 0)
12666                 {
12667                   if (tf->with == with_flags)
12668                     with_hex |= hexval;
12669                   else if (tf->with == without_flags)
12670                     without_hex |= hexval;
12671                   tf->valid = TRUE;
12672                   continue;
12673                 }
12674             }
12675           for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
12676             {
12677               if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
12678                 {
12679                   if (tf->with == with_flags)
12680                     with_hex |= elf_flags_to_names[i].flag_value;
12681                   else if (tf->with == without_flags)
12682                     without_hex |= elf_flags_to_names[i].flag_value;
12683                   tf->valid = TRUE;
12684                   break;
12685                 }
12686             }
12687           if (!tf->valid)
12688             {
12689               info->callbacks->einfo
12690                 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12691               return FALSE;
12692             }
12693         }
12694       flaginfo->flags_initialized = TRUE;
12695       flaginfo->only_with_flags |= with_hex;
12696       flaginfo->not_with_flags |= without_hex;
12697     }
12698
12699   if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
12700     return FALSE;
12701
12702   if ((flaginfo->not_with_flags & sh_flags) != 0)
12703     return FALSE;
12704
12705   return TRUE;
12706 }
12707
12708 struct alloc_got_off_arg {
12709   bfd_vma gotoff;
12710   struct bfd_link_info *info;
12711 };
12712
12713 /* We need a special top-level link routine to convert got reference counts
12714    to real got offsets.  */
12715
12716 static bfd_boolean
12717 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12718 {
12719   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12720   bfd *obfd = gofarg->info->output_bfd;
12721   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12722
12723   if (h->got.refcount > 0)
12724     {
12725       h->got.offset = gofarg->gotoff;
12726       gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12727     }
12728   else
12729     h->got.offset = (bfd_vma) -1;
12730
12731   return TRUE;
12732 }
12733
12734 /* And an accompanying bit to work out final got entry offsets once
12735    we're done.  Should be called from final_link.  */
12736
12737 bfd_boolean
12738 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12739                                         struct bfd_link_info *info)
12740 {
12741   bfd *i;
12742   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12743   bfd_vma gotoff;
12744   struct alloc_got_off_arg gofarg;
12745
12746   BFD_ASSERT (abfd == info->output_bfd);
12747
12748   if (! is_elf_hash_table (info->hash))
12749     return FALSE;
12750
12751   /* The GOT offset is relative to the .got section, but the GOT header is
12752      put into the .got.plt section, if the backend uses it.  */
12753   if (bed->want_got_plt)
12754     gotoff = 0;
12755   else
12756     gotoff = bed->got_header_size;
12757
12758   /* Do the local .got entries first.  */
12759   for (i = info->input_bfds; i; i = i->link.next)
12760     {
12761       bfd_signed_vma *local_got;
12762       bfd_size_type j, locsymcount;
12763       Elf_Internal_Shdr *symtab_hdr;
12764
12765       if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12766         continue;
12767
12768       local_got = elf_local_got_refcounts (i);
12769       if (!local_got)
12770         continue;
12771
12772       symtab_hdr = &elf_tdata (i)->symtab_hdr;
12773       if (elf_bad_symtab (i))
12774         locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12775       else
12776         locsymcount = symtab_hdr->sh_info;
12777
12778       for (j = 0; j < locsymcount; ++j)
12779         {
12780           if (local_got[j] > 0)
12781             {
12782               local_got[j] = gotoff;
12783               gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12784             }
12785           else
12786             local_got[j] = (bfd_vma) -1;
12787         }
12788     }
12789
12790   /* Then the global .got entries.  .plt refcounts are handled by
12791      adjust_dynamic_symbol  */
12792   gofarg.gotoff = gotoff;
12793   gofarg.info = info;
12794   elf_link_hash_traverse (elf_hash_table (info),
12795                           elf_gc_allocate_got_offsets,
12796                           &gofarg);
12797   return TRUE;
12798 }
12799
12800 /* Many folk need no more in the way of final link than this, once
12801    got entry reference counting is enabled.  */
12802
12803 bfd_boolean
12804 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12805 {
12806   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12807     return FALSE;
12808
12809   /* Invoke the regular ELF backend linker to do all the work.  */
12810   return bfd_elf_final_link (abfd, info);
12811 }
12812
12813 bfd_boolean
12814 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12815 {
12816   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12817
12818   if (rcookie->bad_symtab)
12819     rcookie->rel = rcookie->rels;
12820
12821   for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12822     {
12823       unsigned long r_symndx;
12824
12825       if (! rcookie->bad_symtab)
12826         if (rcookie->rel->r_offset > offset)
12827           return FALSE;
12828       if (rcookie->rel->r_offset != offset)
12829         continue;
12830
12831       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12832       if (r_symndx == STN_UNDEF)
12833         return TRUE;
12834
12835       if (r_symndx >= rcookie->locsymcount
12836           || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12837         {
12838           struct elf_link_hash_entry *h;
12839
12840           h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12841
12842           while (h->root.type == bfd_link_hash_indirect
12843                  || h->root.type == bfd_link_hash_warning)
12844             h = (struct elf_link_hash_entry *) h->root.u.i.link;
12845
12846           if ((h->root.type == bfd_link_hash_defined
12847                || h->root.type == bfd_link_hash_defweak)
12848               && (h->root.u.def.section->owner != rcookie->abfd
12849                   || h->root.u.def.section->kept_section != NULL
12850                   || discarded_section (h->root.u.def.section)))
12851             return TRUE;
12852         }
12853       else
12854         {
12855           /* It's not a relocation against a global symbol,
12856              but it could be a relocation against a local
12857              symbol for a discarded section.  */
12858           asection *isec;
12859           Elf_Internal_Sym *isym;
12860
12861           /* Need to: get the symbol; get the section.  */
12862           isym = &rcookie->locsyms[r_symndx];
12863           isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12864           if (isec != NULL
12865               && (isec->kept_section != NULL
12866                   || discarded_section (isec)))
12867             return TRUE;
12868         }
12869       return FALSE;
12870     }
12871   return FALSE;
12872 }
12873
12874 /* Discard unneeded references to discarded sections.
12875    Returns -1 on error, 1 if any section's size was changed, 0 if
12876    nothing changed.  This function assumes that the relocations are in
12877    sorted order, which is true for all known assemblers.  */
12878
12879 int
12880 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12881 {
12882   struct elf_reloc_cookie cookie;
12883   asection *o;
12884   bfd *abfd;
12885   int changed = 0;
12886
12887   if (info->traditional_format
12888       || !is_elf_hash_table (info->hash))
12889     return 0;
12890
12891   o = bfd_get_section_by_name (output_bfd, ".stab");
12892   if (o != NULL)
12893     {
12894       asection *i;
12895
12896       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12897         {
12898           if (i->size == 0
12899               || i->reloc_count == 0
12900               || i->sec_info_type != SEC_INFO_TYPE_STABS)
12901             continue;
12902
12903           abfd = i->owner;
12904           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12905             continue;
12906
12907           if (!init_reloc_cookie_for_section (&cookie, info, i))
12908             return -1;
12909
12910           if (_bfd_discard_section_stabs (abfd, i,
12911                                           elf_section_data (i)->sec_info,
12912                                           bfd_elf_reloc_symbol_deleted_p,
12913                                           &cookie))
12914             changed = 1;
12915
12916           fini_reloc_cookie_for_section (&cookie, i);
12917         }
12918     }
12919
12920   o = bfd_get_section_by_name (output_bfd, ".eh_frame");
12921   if (o != NULL)
12922     {
12923       asection *i;
12924
12925       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12926         {
12927           if (i->size == 0)
12928             continue;
12929
12930           abfd = i->owner;
12931           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12932             continue;
12933
12934           if (!init_reloc_cookie_for_section (&cookie, info, i))
12935             return -1;
12936
12937           _bfd_elf_parse_eh_frame (abfd, info, i, &cookie);
12938           if (_bfd_elf_discard_section_eh_frame (abfd, info, i,
12939                                                  bfd_elf_reloc_symbol_deleted_p,
12940                                                  &cookie))
12941             changed = 1;
12942
12943           fini_reloc_cookie_for_section (&cookie, i);
12944         }
12945     }
12946
12947   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
12948     {
12949       const struct elf_backend_data *bed;
12950
12951       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12952         continue;
12953
12954       bed = get_elf_backend_data (abfd);
12955
12956       if (bed->elf_backend_discard_info != NULL)
12957         {
12958           if (!init_reloc_cookie (&cookie, info, abfd))
12959             return -1;
12960
12961           if ((*bed->elf_backend_discard_info) (abfd, &cookie, info))
12962             changed = 1;
12963
12964           fini_reloc_cookie (&cookie, abfd);
12965         }
12966     }
12967
12968   if (info->eh_frame_hdr
12969       && !info->relocatable
12970       && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12971     changed = 1;
12972
12973   return changed;
12974 }
12975
12976 bfd_boolean
12977 _bfd_elf_section_already_linked (bfd *abfd,
12978                                  asection *sec,
12979                                  struct bfd_link_info *info)
12980 {
12981   flagword flags;
12982   const char *name, *key;
12983   struct bfd_section_already_linked *l;
12984   struct bfd_section_already_linked_hash_entry *already_linked_list;
12985
12986   if (sec->output_section == bfd_abs_section_ptr)
12987     return FALSE;
12988
12989   flags = sec->flags;
12990
12991   /* Return if it isn't a linkonce section.  A comdat group section
12992      also has SEC_LINK_ONCE set.  */
12993   if ((flags & SEC_LINK_ONCE) == 0)
12994     return FALSE;
12995
12996   /* Don't put group member sections on our list of already linked
12997      sections.  They are handled as a group via their group section.  */
12998   if (elf_sec_group (sec) != NULL)
12999     return FALSE;
13000
13001   /* For a SHT_GROUP section, use the group signature as the key.  */
13002   name = sec->name;
13003   if ((flags & SEC_GROUP) != 0
13004       && elf_next_in_group (sec) != NULL
13005       && elf_group_name (elf_next_in_group (sec)) != NULL)
13006     key = elf_group_name (elf_next_in_group (sec));
13007   else
13008     {
13009       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
13010       if (CONST_STRNEQ (name, ".gnu.linkonce.")
13011           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
13012         key++;
13013       else
13014         /* Must be a user linkonce section that doesn't follow gcc's
13015            naming convention.  In this case we won't be matching
13016            single member groups.  */
13017         key = name;
13018     }
13019
13020   already_linked_list = bfd_section_already_linked_table_lookup (key);
13021
13022   for (l = already_linked_list->entry; l != NULL; l = l->next)
13023     {
13024       /* We may have 2 different types of sections on the list: group
13025          sections with a signature of <key> (<key> is some string),
13026          and linkonce sections named .gnu.linkonce.<type>.<key>.
13027          Match like sections.  LTO plugin sections are an exception.
13028          They are always named .gnu.linkonce.t.<key> and match either
13029          type of section.  */
13030       if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
13031            && ((flags & SEC_GROUP) != 0
13032                || strcmp (name, l->sec->name) == 0))
13033           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
13034         {
13035           /* The section has already been linked.  See if we should
13036              issue a warning.  */
13037           if (!_bfd_handle_already_linked (sec, l, info))
13038             return FALSE;
13039
13040           if (flags & SEC_GROUP)
13041             {
13042               asection *first = elf_next_in_group (sec);
13043               asection *s = first;
13044
13045               while (s != NULL)
13046                 {
13047                   s->output_section = bfd_abs_section_ptr;
13048                   /* Record which group discards it.  */
13049                   s->kept_section = l->sec;
13050                   s = elf_next_in_group (s);
13051                   /* These lists are circular.  */
13052                   if (s == first)
13053                     break;
13054                 }
13055             }
13056
13057           return TRUE;
13058         }
13059     }
13060
13061   /* A single member comdat group section may be discarded by a
13062      linkonce section and vice versa.  */
13063   if ((flags & SEC_GROUP) != 0)
13064     {
13065       asection *first = elf_next_in_group (sec);
13066
13067       if (first != NULL && elf_next_in_group (first) == first)
13068         /* Check this single member group against linkonce sections.  */
13069         for (l = already_linked_list->entry; l != NULL; l = l->next)
13070           if ((l->sec->flags & SEC_GROUP) == 0
13071               && bfd_elf_match_symbols_in_sections (l->sec, first, info))
13072             {
13073               first->output_section = bfd_abs_section_ptr;
13074               first->kept_section = l->sec;
13075               sec->output_section = bfd_abs_section_ptr;
13076               break;
13077             }
13078     }
13079   else
13080     /* Check this linkonce section against single member groups.  */
13081     for (l = already_linked_list->entry; l != NULL; l = l->next)
13082       if (l->sec->flags & SEC_GROUP)
13083         {
13084           asection *first = elf_next_in_group (l->sec);
13085
13086           if (first != NULL
13087               && elf_next_in_group (first) == first
13088               && bfd_elf_match_symbols_in_sections (first, sec, info))
13089             {
13090               sec->output_section = bfd_abs_section_ptr;
13091               sec->kept_section = first;
13092               break;
13093             }
13094         }
13095
13096   /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
13097      referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
13098      specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
13099      prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
13100      matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
13101      but its `.gnu.linkonce.t.F' is discarded means we chose one-only
13102      `.gnu.linkonce.t.F' section from a different bfd not requiring any
13103      `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
13104      The reverse order cannot happen as there is never a bfd with only the
13105      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
13106      matter as here were are looking only for cross-bfd sections.  */
13107
13108   if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
13109     for (l = already_linked_list->entry; l != NULL; l = l->next)
13110       if ((l->sec->flags & SEC_GROUP) == 0
13111           && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
13112         {
13113           if (abfd != l->sec->owner)
13114             sec->output_section = bfd_abs_section_ptr;
13115           break;
13116         }
13117
13118   /* This is the first section with this name.  Record it.  */
13119   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
13120     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
13121   return sec->output_section == bfd_abs_section_ptr;
13122 }
13123
13124 bfd_boolean
13125 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
13126 {
13127   return sym->st_shndx == SHN_COMMON;
13128 }
13129
13130 unsigned int
13131 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
13132 {
13133   return SHN_COMMON;
13134 }
13135
13136 asection *
13137 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
13138 {
13139   return bfd_com_section_ptr;
13140 }
13141
13142 bfd_vma
13143 _bfd_elf_default_got_elt_size (bfd *abfd,
13144                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
13145                                struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
13146                                bfd *ibfd ATTRIBUTE_UNUSED,
13147                                unsigned long symndx ATTRIBUTE_UNUSED)
13148 {
13149   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13150   return bed->s->arch_size / 8;
13151 }
13152
13153 /* Routines to support the creation of dynamic relocs.  */
13154
13155 /* Returns the name of the dynamic reloc section associated with SEC.  */
13156
13157 static const char *
13158 get_dynamic_reloc_section_name (bfd *       abfd,
13159                                 asection *  sec,
13160                                 bfd_boolean is_rela)
13161 {
13162   char *name;
13163   const char *old_name = bfd_get_section_name (NULL, sec);
13164   const char *prefix = is_rela ? ".rela" : ".rel";
13165
13166   if (old_name == NULL)
13167     return NULL;
13168
13169   name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
13170   sprintf (name, "%s%s", prefix, old_name);
13171
13172   return name;
13173 }
13174
13175 /* Returns the dynamic reloc section associated with SEC.
13176    If necessary compute the name of the dynamic reloc section based
13177    on SEC's name (looked up in ABFD's string table) and the setting
13178    of IS_RELA.  */
13179
13180 asection *
13181 _bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
13182                                     asection *  sec,
13183                                     bfd_boolean is_rela)
13184 {
13185   asection * reloc_sec = elf_section_data (sec)->sreloc;
13186
13187   if (reloc_sec == NULL)
13188     {
13189       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13190
13191       if (name != NULL)
13192         {
13193           reloc_sec = bfd_get_linker_section (abfd, name);
13194
13195           if (reloc_sec != NULL)
13196             elf_section_data (sec)->sreloc = reloc_sec;
13197         }
13198     }
13199
13200   return reloc_sec;
13201 }
13202
13203 /* Returns the dynamic reloc section associated with SEC.  If the
13204    section does not exist it is created and attached to the DYNOBJ
13205    bfd and stored in the SRELOC field of SEC's elf_section_data
13206    structure.
13207
13208    ALIGNMENT is the alignment for the newly created section and
13209    IS_RELA defines whether the name should be .rela.<SEC's name>
13210    or .rel.<SEC's name>.  The section name is looked up in the
13211    string table associated with ABFD.  */
13212
13213 asection *
13214 _bfd_elf_make_dynamic_reloc_section (asection *         sec,
13215                                      bfd *              dynobj,
13216                                      unsigned int       alignment,
13217                                      bfd *              abfd,
13218                                      bfd_boolean        is_rela)
13219 {
13220   asection * reloc_sec = elf_section_data (sec)->sreloc;
13221
13222   if (reloc_sec == NULL)
13223     {
13224       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13225
13226       if (name == NULL)
13227         return NULL;
13228
13229       reloc_sec = bfd_get_linker_section (dynobj, name);
13230
13231       if (reloc_sec == NULL)
13232         {
13233           flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
13234                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
13235           if ((sec->flags & SEC_ALLOC) != 0)
13236             flags |= SEC_ALLOC | SEC_LOAD;
13237
13238           reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
13239           if (reloc_sec != NULL)
13240             {
13241               /* _bfd_elf_get_sec_type_attr chooses a section type by
13242                  name.  Override as it may be wrong, eg. for a user
13243                  section named "auto" we'll get ".relauto" which is
13244                  seen to be a .rela section.  */
13245               elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
13246               if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
13247                 reloc_sec = NULL;
13248             }
13249         }
13250
13251       elf_section_data (sec)->sreloc = reloc_sec;
13252     }
13253
13254   return reloc_sec;
13255 }
13256
13257 /* Copy the ELF symbol type and other attributes for a linker script
13258    assignment from HSRC to HDEST.  Generally this should be treated as
13259    if we found a strong non-dynamic definition for HDEST (except that
13260    ld ignores multiple definition errors).  */
13261 void
13262 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
13263                                      struct bfd_link_hash_entry *hdest,
13264                                      struct bfd_link_hash_entry *hsrc)
13265 {
13266   struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest;
13267   struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc;
13268   Elf_Internal_Sym isym;
13269
13270   ehdest->type = ehsrc->type;
13271   ehdest->target_internal = ehsrc->target_internal;
13272
13273   isym.st_other = ehsrc->other;
13274   elf_merge_st_other (abfd, ehdest, &isym, TRUE, FALSE);
13275 }
13276
13277 /* Append a RELA relocation REL to section S in BFD.  */
13278
13279 void
13280 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13281 {
13282   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13283   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
13284   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
13285   bed->s->swap_reloca_out (abfd, rel, loc);
13286 }
13287
13288 /* Append a REL relocation REL to section S in BFD.  */
13289
13290 void
13291 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13292 {
13293   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13294   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
13295   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
13296   bed->s->swap_reloc_out (abfd, rel, loc);
13297 }