tidy _bfd_elf_define_linkage_sym
[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   bed = get_elf_backend_data (abfd);
81   if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
82                                          sec, 0, NULL, FALSE, bed->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->elf_backend_hide_symbol) (info, h, TRUE);
94   return h;
95 }
96
97 bfd_boolean
98 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
99 {
100   flagword flags;
101   asection *s;
102   struct elf_link_hash_entry *h;
103   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
104   struct elf_link_hash_table *htab = elf_hash_table (info);
105
106   /* This function may be called more than once.  */
107   s = bfd_get_linker_section (abfd, ".got");
108   if (s != NULL)
109     return TRUE;
110
111   flags = bed->dynamic_sec_flags;
112
113   s = bfd_make_section_anyway_with_flags (abfd,
114                                           (bed->rela_plts_and_copies_p
115                                            ? ".rela.got" : ".rel.got"),
116                                           (bed->dynamic_sec_flags
117                                            | SEC_READONLY));
118   if (s == NULL
119       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
120     return FALSE;
121   htab->srelgot = s;
122
123   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
124   if (s == NULL
125       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
126     return FALSE;
127   htab->sgot = s;
128
129   if (bed->want_got_plt)
130     {
131       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
132       if (s == NULL
133           || !bfd_set_section_alignment (abfd, s,
134                                          bed->s->log_file_align))
135         return FALSE;
136       htab->sgotplt = s;
137     }
138
139   /* The first bit of the global offset table is the header.  */
140   s->size += bed->got_header_size;
141
142   if (bed->want_got_sym)
143     {
144       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
145          (or .got.plt) section.  We don't do this in the linker script
146          because we don't want to define the symbol if we are not creating
147          a global offset table.  */
148       h = _bfd_elf_define_linkage_sym (abfd, info, s,
149                                        "_GLOBAL_OFFSET_TABLE_");
150       elf_hash_table (info)->hgot = h;
151       if (h == NULL)
152         return FALSE;
153     }
154
155   return TRUE;
156 }
157 \f
158 /* Create a strtab to hold the dynamic symbol names.  */
159 static bfd_boolean
160 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
161 {
162   struct elf_link_hash_table *hash_table;
163
164   hash_table = elf_hash_table (info);
165   if (hash_table->dynobj == NULL)
166     hash_table->dynobj = abfd;
167
168   if (hash_table->dynstr == NULL)
169     {
170       hash_table->dynstr = _bfd_elf_strtab_init ();
171       if (hash_table->dynstr == NULL)
172         return FALSE;
173     }
174   return TRUE;
175 }
176
177 /* Create some sections which will be filled in with dynamic linking
178    information.  ABFD is an input file which requires dynamic sections
179    to be created.  The dynamic sections take up virtual memory space
180    when the final executable is run, so we need to create them before
181    addresses are assigned to the output sections.  We work out the
182    actual contents and size of these sections later.  */
183
184 bfd_boolean
185 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
186 {
187   flagword flags;
188   asection *s;
189   const struct elf_backend_data *bed;
190   struct elf_link_hash_entry *h;
191
192   if (! is_elf_hash_table (info->hash))
193     return FALSE;
194
195   if (elf_hash_table (info)->dynamic_sections_created)
196     return TRUE;
197
198   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
199     return FALSE;
200
201   abfd = elf_hash_table (info)->dynobj;
202   bed = get_elf_backend_data (abfd);
203
204   flags = bed->dynamic_sec_flags;
205
206   /* A dynamically linked executable has a .interp section, but a
207      shared library does not.  */
208   if (info->executable)
209     {
210       s = bfd_make_section_anyway_with_flags (abfd, ".interp",
211                                               flags | SEC_READONLY);
212       if (s == NULL)
213         return FALSE;
214     }
215
216   /* Create sections to hold version informations.  These are removed
217      if they are not needed.  */
218   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
219                                           flags | SEC_READONLY);
220   if (s == NULL
221       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
222     return FALSE;
223
224   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
225                                           flags | SEC_READONLY);
226   if (s == NULL
227       || ! bfd_set_section_alignment (abfd, s, 1))
228     return FALSE;
229
230   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
231                                           flags | SEC_READONLY);
232   if (s == NULL
233       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
234     return FALSE;
235
236   s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
237                                           flags | SEC_READONLY);
238   if (s == NULL
239       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
240     return FALSE;
241
242   s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
243                                           flags | SEC_READONLY);
244   if (s == NULL)
245     return FALSE;
246
247   s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
248   if (s == NULL
249       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
250     return FALSE;
251
252   /* The special symbol _DYNAMIC is always set to the start of the
253      .dynamic section.  We could set _DYNAMIC in a linker script, but we
254      only want to define it if we are, in fact, creating a .dynamic
255      section.  We don't want to define it if there is no .dynamic
256      section, since on some ELF platforms the start up code examines it
257      to decide how to initialize the process.  */
258   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
259   elf_hash_table (info)->hdynamic = h;
260   if (h == NULL)
261     return FALSE;
262
263   if (info->emit_hash)
264     {
265       s = bfd_make_section_anyway_with_flags (abfd, ".hash",
266                                               flags | SEC_READONLY);
267       if (s == NULL
268           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
269         return FALSE;
270       elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
271     }
272
273   if (info->emit_gnu_hash)
274     {
275       s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
276                                               flags | SEC_READONLY);
277       if (s == NULL
278           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
279         return FALSE;
280       /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
281          4 32-bit words followed by variable count of 64-bit words, then
282          variable count of 32-bit words.  */
283       if (bed->s->arch_size == 64)
284         elf_section_data (s)->this_hdr.sh_entsize = 0;
285       else
286         elf_section_data (s)->this_hdr.sh_entsize = 4;
287     }
288
289   /* Let the backend create the rest of the sections.  This lets the
290      backend set the right flags.  The backend will normally create
291      the .got and .plt sections.  */
292   if (bed->elf_backend_create_dynamic_sections == NULL
293       || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
294     return FALSE;
295
296   elf_hash_table (info)->dynamic_sections_created = TRUE;
297
298   return TRUE;
299 }
300
301 /* Create dynamic sections when linking against a dynamic object.  */
302
303 bfd_boolean
304 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
305 {
306   flagword flags, pltflags;
307   struct elf_link_hash_entry *h;
308   asection *s;
309   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
310   struct elf_link_hash_table *htab = elf_hash_table (info);
311
312   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
313      .rel[a].bss sections.  */
314   flags = bed->dynamic_sec_flags;
315
316   pltflags = flags;
317   if (bed->plt_not_loaded)
318     /* We do not clear SEC_ALLOC here because we still want the OS to
319        allocate space for the section; it's just that there's nothing
320        to read in from the object file.  */
321     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
322   else
323     pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
324   if (bed->plt_readonly)
325     pltflags |= SEC_READONLY;
326
327   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
328   if (s == NULL
329       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
330     return FALSE;
331   htab->splt = s;
332
333   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
334      .plt section.  */
335   if (bed->want_plt_sym)
336     {
337       h = _bfd_elf_define_linkage_sym (abfd, info, s,
338                                        "_PROCEDURE_LINKAGE_TABLE_");
339       elf_hash_table (info)->hplt = h;
340       if (h == NULL)
341         return FALSE;
342     }
343
344   s = bfd_make_section_anyway_with_flags (abfd,
345                                           (bed->rela_plts_and_copies_p
346                                            ? ".rela.plt" : ".rel.plt"),
347                                           flags | SEC_READONLY);
348   if (s == NULL
349       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
350     return FALSE;
351   htab->srelplt = s;
352
353   if (! _bfd_elf_create_got_section (abfd, info))
354     return FALSE;
355
356   if (bed->want_dynbss)
357     {
358       /* The .dynbss section is a place to put symbols which are defined
359          by dynamic objects, are referenced by regular objects, and are
360          not functions.  We must allocate space for them in the process
361          image and use a R_*_COPY reloc to tell the dynamic linker to
362          initialize them at run time.  The linker script puts the .dynbss
363          section into the .bss section of the final image.  */
364       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
365                                               (SEC_ALLOC | SEC_LINKER_CREATED));
366       if (s == NULL)
367         return FALSE;
368
369       /* The .rel[a].bss section holds copy relocs.  This section is not
370          normally needed.  We need to create it here, though, so that the
371          linker will map it to an output section.  We can't just create it
372          only if we need it, because we will not know whether we need it
373          until we have seen all the input files, and the first time the
374          main linker code calls BFD after examining all the input files
375          (size_dynamic_sections) the input sections have already been
376          mapped to the output sections.  If the section turns out not to
377          be needed, we can discard it later.  We will never need this
378          section when generating a shared object, since they do not use
379          copy relocs.  */
380       if (! info->shared)
381         {
382           s = bfd_make_section_anyway_with_flags (abfd,
383                                                   (bed->rela_plts_and_copies_p
384                                                    ? ".rela.bss" : ".rel.bss"),
385                                                   flags | SEC_READONLY);
386           if (s == NULL
387               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
388             return FALSE;
389         }
390     }
391
392   return TRUE;
393 }
394 \f
395 /* Record a new dynamic symbol.  We record the dynamic symbols as we
396    read the input files, since we need to have a list of all of them
397    before we can determine the final sizes of the output sections.
398    Note that we may actually call this function even though we are not
399    going to output any dynamic symbols; in some cases we know that a
400    symbol should be in the dynamic symbol table, but only if there is
401    one.  */
402
403 bfd_boolean
404 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
405                                     struct elf_link_hash_entry *h)
406 {
407   if (h->dynindx == -1)
408     {
409       struct elf_strtab_hash *dynstr;
410       char *p;
411       const char *name;
412       bfd_size_type indx;
413
414       /* XXX: The ABI draft says the linker must turn hidden and
415          internal symbols into STB_LOCAL symbols when producing the
416          DSO. However, if ld.so honors st_other in the dynamic table,
417          this would not be necessary.  */
418       switch (ELF_ST_VISIBILITY (h->other))
419         {
420         case STV_INTERNAL:
421         case STV_HIDDEN:
422           if (h->root.type != bfd_link_hash_undefined
423               && h->root.type != bfd_link_hash_undefweak)
424             {
425               h->forced_local = 1;
426               if (!elf_hash_table (info)->is_relocatable_executable)
427                 return TRUE;
428             }
429
430         default:
431           break;
432         }
433
434       h->dynindx = elf_hash_table (info)->dynsymcount;
435       ++elf_hash_table (info)->dynsymcount;
436
437       dynstr = elf_hash_table (info)->dynstr;
438       if (dynstr == NULL)
439         {
440           /* Create a strtab to hold the dynamic symbol names.  */
441           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
442           if (dynstr == NULL)
443             return FALSE;
444         }
445
446       /* We don't put any version information in the dynamic string
447          table.  */
448       name = h->root.root.string;
449       p = strchr (name, ELF_VER_CHR);
450       if (p != NULL)
451         /* We know that the p points into writable memory.  In fact,
452            there are only a few symbols that have read-only names, being
453            those like _GLOBAL_OFFSET_TABLE_ that are created specially
454            by the backends.  Most symbols will have names pointing into
455            an ELF string table read from a file, or to objalloc memory.  */
456         *p = 0;
457
458       indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
459
460       if (p != NULL)
461         *p = ELF_VER_CHR;
462
463       if (indx == (bfd_size_type) -1)
464         return FALSE;
465       h->dynstr_index = indx;
466     }
467
468   return TRUE;
469 }
470 \f
471 /* Mark a symbol dynamic.  */
472
473 static void
474 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
475                                   struct elf_link_hash_entry *h,
476                                   Elf_Internal_Sym *sym)
477 {
478   struct bfd_elf_dynamic_list *d = info->dynamic_list;
479
480   /* It may be called more than once on the same H.  */
481   if(h->dynamic || info->relocatable)
482     return;
483
484   if ((info->dynamic_data
485        && (h->type == STT_OBJECT
486            || (sym != NULL
487                && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
488       || (d != NULL
489           && h->root.type == bfd_link_hash_new
490           && (*d->match) (&d->head, NULL, h->root.root.string)))
491     h->dynamic = 1;
492 }
493
494 /* Record an assignment to a symbol made by a linker script.  We need
495    this in case some dynamic object refers to this symbol.  */
496
497 bfd_boolean
498 bfd_elf_record_link_assignment (bfd *output_bfd,
499                                 struct bfd_link_info *info,
500                                 const char *name,
501                                 bfd_boolean provide,
502                                 bfd_boolean hidden)
503 {
504   struct elf_link_hash_entry *h, *hv;
505   struct elf_link_hash_table *htab;
506   const struct elf_backend_data *bed;
507
508   if (!is_elf_hash_table (info->hash))
509     return TRUE;
510
511   htab = elf_hash_table (info);
512   h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
513   if (h == NULL)
514     return provide;
515
516   switch (h->root.type)
517     {
518     case bfd_link_hash_defined:
519     case bfd_link_hash_defweak:
520     case bfd_link_hash_common:
521       break;
522     case bfd_link_hash_undefweak:
523     case bfd_link_hash_undefined:
524       /* Since we're defining the symbol, don't let it seem to have not
525          been defined.  record_dynamic_symbol and size_dynamic_sections
526          may depend on this.  */
527       h->root.type = bfd_link_hash_new;
528       if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
529         bfd_link_repair_undef_list (&htab->root);
530       break;
531     case bfd_link_hash_new:
532       bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
533       h->non_elf = 0;
534       break;
535     case bfd_link_hash_indirect:
536       /* We had a versioned symbol in a dynamic library.  We make the
537          the versioned symbol point to this one.  */
538       bed = get_elf_backend_data (output_bfd);
539       hv = h;
540       while (hv->root.type == bfd_link_hash_indirect
541              || hv->root.type == bfd_link_hash_warning)
542         hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
543       /* We don't need to update h->root.u since linker will set them
544          later.  */
545       h->root.type = bfd_link_hash_undefined;
546       hv->root.type = bfd_link_hash_indirect;
547       hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
548       (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
549       break;
550     case bfd_link_hash_warning:
551       abort ();
552       break;
553     }
554
555   /* If this symbol is being provided by the linker script, and it is
556      currently defined by a dynamic object, but not by a regular
557      object, then mark it as undefined so that the generic linker will
558      force the correct value.  */
559   if (provide
560       && h->def_dynamic
561       && !h->def_regular)
562     h->root.type = bfd_link_hash_undefined;
563
564   /* If this symbol is not being provided by the linker script, and it is
565      currently defined by a dynamic object, but not by a regular object,
566      then clear out any version information because the symbol will not be
567      associated with the dynamic object any more.  */
568   if (!provide
569       && h->def_dynamic
570       && !h->def_regular)
571     h->verinfo.verdef = NULL;
572
573   h->def_regular = 1;
574
575   if (hidden)
576     {
577       bed = get_elf_backend_data (output_bfd);
578       if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
579         h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
580       (*bed->elf_backend_hide_symbol) (info, h, TRUE);
581     }
582
583   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
584      and executables.  */
585   if (!info->relocatable
586       && h->dynindx != -1
587       && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
588           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
589     h->forced_local = 1;
590
591   if ((h->def_dynamic
592        || h->ref_dynamic
593        || info->shared
594        || (info->executable && elf_hash_table (info)->is_relocatable_executable))
595       && h->dynindx == -1)
596     {
597       if (! bfd_elf_link_record_dynamic_symbol (info, h))
598         return FALSE;
599
600       /* If this is a weak defined symbol, and we know a corresponding
601          real symbol from the same dynamic object, make sure the real
602          symbol is also made into a dynamic symbol.  */
603       if (h->u.weakdef != NULL
604           && h->u.weakdef->dynindx == -1)
605         {
606           if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
607             return FALSE;
608         }
609     }
610
611   return TRUE;
612 }
613
614 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
615    success, and 2 on a failure caused by attempting to record a symbol
616    in a discarded section, eg. a discarded link-once section symbol.  */
617
618 int
619 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
620                                           bfd *input_bfd,
621                                           long input_indx)
622 {
623   bfd_size_type amt;
624   struct elf_link_local_dynamic_entry *entry;
625   struct elf_link_hash_table *eht;
626   struct elf_strtab_hash *dynstr;
627   unsigned long dynstr_index;
628   char *name;
629   Elf_External_Sym_Shndx eshndx;
630   char esym[sizeof (Elf64_External_Sym)];
631
632   if (! is_elf_hash_table (info->hash))
633     return 0;
634
635   /* See if the entry exists already.  */
636   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
637     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
638       return 1;
639
640   amt = sizeof (*entry);
641   entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
642   if (entry == NULL)
643     return 0;
644
645   /* Go find the symbol, so that we can find it's name.  */
646   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
647                              1, input_indx, &entry->isym, esym, &eshndx))
648     {
649       bfd_release (input_bfd, entry);
650       return 0;
651     }
652
653   if (entry->isym.st_shndx != SHN_UNDEF
654       && entry->isym.st_shndx < SHN_LORESERVE)
655     {
656       asection *s;
657
658       s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
659       if (s == NULL || bfd_is_abs_section (s->output_section))
660         {
661           /* We can still bfd_release here as nothing has done another
662              bfd_alloc.  We can't do this later in this function.  */
663           bfd_release (input_bfd, entry);
664           return 2;
665         }
666     }
667
668   name = (bfd_elf_string_from_elf_section
669           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
670            entry->isym.st_name));
671
672   dynstr = elf_hash_table (info)->dynstr;
673   if (dynstr == NULL)
674     {
675       /* Create a strtab to hold the dynamic symbol names.  */
676       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
677       if (dynstr == NULL)
678         return 0;
679     }
680
681   dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
682   if (dynstr_index == (unsigned long) -1)
683     return 0;
684   entry->isym.st_name = dynstr_index;
685
686   eht = elf_hash_table (info);
687
688   entry->next = eht->dynlocal;
689   eht->dynlocal = entry;
690   entry->input_bfd = input_bfd;
691   entry->input_indx = input_indx;
692   eht->dynsymcount++;
693
694   /* Whatever binding the symbol had before, it's now local.  */
695   entry->isym.st_info
696     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
697
698   /* The dynindx will be set at the end of size_dynamic_sections.  */
699
700   return 1;
701 }
702
703 /* Return the dynindex of a local dynamic symbol.  */
704
705 long
706 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
707                                     bfd *input_bfd,
708                                     long input_indx)
709 {
710   struct elf_link_local_dynamic_entry *e;
711
712   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
713     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
714       return e->dynindx;
715   return -1;
716 }
717
718 /* This function is used to renumber the dynamic symbols, if some of
719    them are removed because they are marked as local.  This is called
720    via elf_link_hash_traverse.  */
721
722 static bfd_boolean
723 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
724                                       void *data)
725 {
726   size_t *count = (size_t *) data;
727
728   if (h->forced_local)
729     return TRUE;
730
731   if (h->dynindx != -1)
732     h->dynindx = ++(*count);
733
734   return TRUE;
735 }
736
737
738 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
739    STB_LOCAL binding.  */
740
741 static bfd_boolean
742 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
743                                             void *data)
744 {
745   size_t *count = (size_t *) data;
746
747   if (!h->forced_local)
748     return TRUE;
749
750   if (h->dynindx != -1)
751     h->dynindx = ++(*count);
752
753   return TRUE;
754 }
755
756 /* Return true if the dynamic symbol for a given section should be
757    omitted when creating a shared library.  */
758 bfd_boolean
759 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
760                                    struct bfd_link_info *info,
761                                    asection *p)
762 {
763   struct elf_link_hash_table *htab;
764   asection *ip;
765
766   switch (elf_section_data (p)->this_hdr.sh_type)
767     {
768     case SHT_PROGBITS:
769     case SHT_NOBITS:
770       /* If sh_type is yet undecided, assume it could be
771          SHT_PROGBITS/SHT_NOBITS.  */
772     case SHT_NULL:
773       htab = elf_hash_table (info);
774       if (p == htab->tls_sec)
775         return FALSE;
776
777       if (htab->text_index_section != NULL)
778         return p != htab->text_index_section && p != htab->data_index_section;
779
780       return (htab->dynobj != NULL
781               && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
782               && ip->output_section == p);
783
784       /* There shouldn't be section relative relocations
785          against any other section.  */
786     default:
787       return TRUE;
788     }
789 }
790
791 /* Assign dynsym indices.  In a shared library we generate a section
792    symbol for each output section, which come first.  Next come symbols
793    which have been forced to local binding.  Then all of the back-end
794    allocated local dynamic syms, followed by the rest of the global
795    symbols.  */
796
797 static unsigned long
798 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
799                                 struct bfd_link_info *info,
800                                 unsigned long *section_sym_count)
801 {
802   unsigned long dynsymcount = 0;
803
804   if (info->shared || elf_hash_table (info)->is_relocatable_executable)
805     {
806       const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
807       asection *p;
808       for (p = output_bfd->sections; p ; p = p->next)
809         if ((p->flags & SEC_EXCLUDE) == 0
810             && (p->flags & SEC_ALLOC) != 0
811             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
812           elf_section_data (p)->dynindx = ++dynsymcount;
813         else
814           elf_section_data (p)->dynindx = 0;
815     }
816   *section_sym_count = dynsymcount;
817
818   elf_link_hash_traverse (elf_hash_table (info),
819                           elf_link_renumber_local_hash_table_dynsyms,
820                           &dynsymcount);
821
822   if (elf_hash_table (info)->dynlocal)
823     {
824       struct elf_link_local_dynamic_entry *p;
825       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
826         p->dynindx = ++dynsymcount;
827     }
828
829   elf_link_hash_traverse (elf_hash_table (info),
830                           elf_link_renumber_hash_table_dynsyms,
831                           &dynsymcount);
832
833   /* There is an unused NULL entry at the head of the table which
834      we must account for in our count.  Unless there weren't any
835      symbols, which means we'll have no table at all.  */
836   if (dynsymcount != 0)
837     ++dynsymcount;
838
839   elf_hash_table (info)->dynsymcount = dynsymcount;
840   return dynsymcount;
841 }
842
843 /* Merge st_other field.  */
844
845 static void
846 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
847                     const Elf_Internal_Sym *isym,
848                     bfd_boolean definition, bfd_boolean dynamic)
849 {
850   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
851
852   /* If st_other has a processor-specific meaning, specific
853      code might be needed here.  */
854   if (bed->elf_backend_merge_symbol_attribute)
855     (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
856                                                 dynamic);
857
858   if (!dynamic)
859     {
860       unsigned symvis = ELF_ST_VISIBILITY (isym->st_other);
861       unsigned hvis = ELF_ST_VISIBILITY (h->other);
862
863       /* Keep the most constraining visibility.  Leave the remainder
864          of the st_other field to elf_backend_merge_symbol_attribute.  */
865       if (symvis - 1 < hvis - 1)
866         h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
867     }
868   else if (definition && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT)
869     h->protected_def = 1;
870 }
871
872 /* This function is called when we want to merge a new symbol with an
873    existing symbol.  It handles the various cases which arise when we
874    find a definition in a dynamic object, or when there is already a
875    definition in a dynamic object.  The new symbol is described by
876    NAME, SYM, PSEC, and PVALUE.  We set SYM_HASH to the hash table
877    entry.  We set POLDBFD to the old symbol's BFD.  We set POLD_WEAK
878    if the old symbol was weak.  We set POLD_ALIGNMENT to the alignment
879    of an old common symbol.  We set OVERRIDE if the old symbol is
880    overriding a new definition.  We set TYPE_CHANGE_OK if it is OK for
881    the type to change.  We set SIZE_CHANGE_OK if it is OK for the size
882    to change.  By OK to change, we mean that we shouldn't warn if the
883    type or size does change.  */
884
885 static bfd_boolean
886 _bfd_elf_merge_symbol (bfd *abfd,
887                        struct bfd_link_info *info,
888                        const char *name,
889                        Elf_Internal_Sym *sym,
890                        asection **psec,
891                        bfd_vma *pvalue,
892                        struct elf_link_hash_entry **sym_hash,
893                        bfd **poldbfd,
894                        bfd_boolean *pold_weak,
895                        unsigned int *pold_alignment,
896                        bfd_boolean *skip,
897                        bfd_boolean *override,
898                        bfd_boolean *type_change_ok,
899                        bfd_boolean *size_change_ok)
900 {
901   asection *sec, *oldsec;
902   struct elf_link_hash_entry *h;
903   struct elf_link_hash_entry *hi;
904   struct elf_link_hash_entry *flip;
905   int bind;
906   bfd *oldbfd;
907   bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
908   bfd_boolean newweak, oldweak, newfunc, oldfunc;
909   const struct elf_backend_data *bed;
910
911   *skip = FALSE;
912   *override = FALSE;
913
914   sec = *psec;
915   bind = ELF_ST_BIND (sym->st_info);
916
917   if (! bfd_is_und_section (sec))
918     h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
919   else
920     h = ((struct elf_link_hash_entry *)
921          bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
922   if (h == NULL)
923     return FALSE;
924   *sym_hash = h;
925
926   bed = get_elf_backend_data (abfd);
927
928   /* For merging, we only care about real symbols.  But we need to make
929      sure that indirect symbol dynamic flags are updated.  */
930   hi = h;
931   while (h->root.type == bfd_link_hash_indirect
932          || h->root.type == bfd_link_hash_warning)
933     h = (struct elf_link_hash_entry *) h->root.u.i.link;
934
935   /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
936      existing symbol.  */
937
938   oldbfd = NULL;
939   oldsec = NULL;
940   switch (h->root.type)
941     {
942     default:
943       break;
944
945     case bfd_link_hash_undefined:
946     case bfd_link_hash_undefweak:
947       oldbfd = h->root.u.undef.abfd;
948       break;
949
950     case bfd_link_hash_defined:
951     case bfd_link_hash_defweak:
952       oldbfd = h->root.u.def.section->owner;
953       oldsec = h->root.u.def.section;
954       break;
955
956     case bfd_link_hash_common:
957       oldbfd = h->root.u.c.p->section->owner;
958       oldsec = h->root.u.c.p->section;
959       if (pold_alignment)
960         *pold_alignment = h->root.u.c.p->alignment_power;
961       break;
962     }
963   if (poldbfd && *poldbfd == NULL)
964     *poldbfd = oldbfd;
965
966   /* Differentiate strong and weak symbols.  */
967   newweak = bind == STB_WEAK;
968   oldweak = (h->root.type == bfd_link_hash_defweak
969              || h->root.type == bfd_link_hash_undefweak);
970   if (pold_weak)
971     *pold_weak = oldweak;
972
973   /* This code is for coping with dynamic objects, and is only useful
974      if we are doing an ELF link.  */
975   if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
976     return TRUE;
977
978   /* We have to check it for every instance since the first few may be
979      references and not all compilers emit symbol type for undefined
980      symbols.  */
981   bfd_elf_link_mark_dynamic_symbol (info, h, sym);
982
983   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
984      respectively, is from a dynamic object.  */
985
986   newdyn = (abfd->flags & DYNAMIC) != 0;
987
988   /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
989      syms and defined syms in dynamic libraries respectively.
990      ref_dynamic on the other hand can be set for a symbol defined in
991      a dynamic library, and def_dynamic may not be set;  When the
992      definition in a dynamic lib is overridden by a definition in the
993      executable use of the symbol in the dynamic lib becomes a
994      reference to the executable symbol.  */
995   if (newdyn)
996     {
997       if (bfd_is_und_section (sec))
998         {
999           if (bind != STB_WEAK)
1000             {
1001               h->ref_dynamic_nonweak = 1;
1002               hi->ref_dynamic_nonweak = 1;
1003             }
1004         }
1005       else
1006         {
1007           h->dynamic_def = 1;
1008           hi->dynamic_def = 1;
1009         }
1010     }
1011
1012   /* If we just created the symbol, mark it as being an ELF symbol.
1013      Other than that, there is nothing to do--there is no merge issue
1014      with a newly defined symbol--so we just return.  */
1015
1016   if (h->root.type == bfd_link_hash_new)
1017     {
1018       h->non_elf = 0;
1019       return TRUE;
1020     }
1021
1022   /* In cases involving weak versioned symbols, we may wind up trying
1023      to merge a symbol with itself.  Catch that here, to avoid the
1024      confusion that results if we try to override a symbol with
1025      itself.  The additional tests catch cases like
1026      _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1027      dynamic object, which we do want to handle here.  */
1028   if (abfd == oldbfd
1029       && (newweak || oldweak)
1030       && ((abfd->flags & DYNAMIC) == 0
1031           || !h->def_regular))
1032     return TRUE;
1033
1034   olddyn = FALSE;
1035   if (oldbfd != NULL)
1036     olddyn = (oldbfd->flags & DYNAMIC) != 0;
1037   else if (oldsec != NULL)
1038     {
1039       /* This handles the special SHN_MIPS_{TEXT,DATA} section
1040          indices used by MIPS ELF.  */
1041       olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1042     }
1043
1044   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1045      respectively, appear to be a definition rather than reference.  */
1046
1047   newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1048
1049   olddef = (h->root.type != bfd_link_hash_undefined
1050             && h->root.type != bfd_link_hash_undefweak
1051             && h->root.type != bfd_link_hash_common);
1052
1053   /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1054      respectively, appear to be a function.  */
1055
1056   newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1057              && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1058
1059   oldfunc = (h->type != STT_NOTYPE
1060              && bed->is_function_type (h->type));
1061
1062   /* When we try to create a default indirect symbol from the dynamic
1063      definition with the default version, we skip it if its type and
1064      the type of existing regular definition mismatch.  */
1065   if (pold_alignment == NULL
1066       && newdyn
1067       && newdef
1068       && !olddyn
1069       && (((olddef || h->root.type == bfd_link_hash_common)
1070            && ELF_ST_TYPE (sym->st_info) != h->type
1071            && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1072            && h->type != STT_NOTYPE
1073            && !(newfunc && oldfunc))
1074           || (olddef
1075               && ((h->type == STT_GNU_IFUNC)
1076                   != (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))))
1077     {
1078       *skip = TRUE;
1079       return TRUE;
1080     }
1081
1082   /* Check TLS symbols.  We don't check undefined symbols introduced
1083      by "ld -u" which have no type (and oldbfd NULL), and we don't
1084      check symbols from plugins because they also have no type.  */
1085   if (oldbfd != NULL
1086       && (oldbfd->flags & BFD_PLUGIN) == 0
1087       && (abfd->flags & BFD_PLUGIN) == 0
1088       && ELF_ST_TYPE (sym->st_info) != h->type
1089       && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1090     {
1091       bfd *ntbfd, *tbfd;
1092       bfd_boolean ntdef, tdef;
1093       asection *ntsec, *tsec;
1094
1095       if (h->type == STT_TLS)
1096         {
1097           ntbfd = abfd;
1098           ntsec = sec;
1099           ntdef = newdef;
1100           tbfd = oldbfd;
1101           tsec = oldsec;
1102           tdef = olddef;
1103         }
1104       else
1105         {
1106           ntbfd = oldbfd;
1107           ntsec = oldsec;
1108           ntdef = olddef;
1109           tbfd = abfd;
1110           tsec = sec;
1111           tdef = newdef;
1112         }
1113
1114       if (tdef && ntdef)
1115         (*_bfd_error_handler)
1116           (_("%s: TLS definition in %B section %A "
1117              "mismatches non-TLS definition in %B section %A"),
1118            tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1119       else if (!tdef && !ntdef)
1120         (*_bfd_error_handler)
1121           (_("%s: TLS reference in %B "
1122              "mismatches non-TLS reference in %B"),
1123            tbfd, ntbfd, h->root.root.string);
1124       else if (tdef)
1125         (*_bfd_error_handler)
1126           (_("%s: TLS definition in %B section %A "
1127              "mismatches non-TLS reference in %B"),
1128            tbfd, tsec, ntbfd, h->root.root.string);
1129       else
1130         (*_bfd_error_handler)
1131           (_("%s: TLS reference in %B "
1132              "mismatches non-TLS definition in %B section %A"),
1133            tbfd, ntbfd, ntsec, h->root.root.string);
1134
1135       bfd_set_error (bfd_error_bad_value);
1136       return FALSE;
1137     }
1138
1139   /* If the old symbol has non-default visibility, we ignore the new
1140      definition from a dynamic object.  */
1141   if (newdyn
1142       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1143       && !bfd_is_und_section (sec))
1144     {
1145       *skip = TRUE;
1146       /* Make sure this symbol is dynamic.  */
1147       h->ref_dynamic = 1;
1148       hi->ref_dynamic = 1;
1149       /* A protected symbol has external availability. Make sure it is
1150          recorded as dynamic.
1151
1152          FIXME: Should we check type and size for protected symbol?  */
1153       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1154         return bfd_elf_link_record_dynamic_symbol (info, h);
1155       else
1156         return TRUE;
1157     }
1158   else if (!newdyn
1159            && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1160            && h->def_dynamic)
1161     {
1162       /* If the new symbol with non-default visibility comes from a
1163          relocatable file and the old definition comes from a dynamic
1164          object, we remove the old definition.  */
1165       if (hi->root.type == bfd_link_hash_indirect)
1166         {
1167           /* Handle the case where the old dynamic definition is
1168              default versioned.  We need to copy the symbol info from
1169              the symbol with default version to the normal one if it
1170              was referenced before.  */
1171           if (h->ref_regular)
1172             {
1173               hi->root.type = h->root.type;
1174               h->root.type = bfd_link_hash_indirect;
1175               (*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
1176
1177               h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1178               if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1179                 {
1180                   /* If the new symbol is hidden or internal, completely undo
1181                      any dynamic link state.  */
1182                   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1183                   h->forced_local = 0;
1184                   h->ref_dynamic = 0;
1185                 }
1186               else
1187                 h->ref_dynamic = 1;
1188
1189               h->def_dynamic = 0;
1190               /* FIXME: Should we check type and size for protected symbol?  */
1191               h->size = 0;
1192               h->type = 0;
1193
1194               h = hi;
1195             }
1196           else
1197             h = hi;
1198         }
1199
1200       /* If the old symbol was undefined before, then it will still be
1201          on the undefs list.  If the new symbol is undefined or
1202          common, we can't make it bfd_link_hash_new here, because new
1203          undefined or common symbols will be added to the undefs list
1204          by _bfd_generic_link_add_one_symbol.  Symbols may not be
1205          added twice to the undefs list.  Also, if the new symbol is
1206          undefweak then we don't want to lose the strong undef.  */
1207       if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1208         {
1209           h->root.type = bfd_link_hash_undefined;
1210           h->root.u.undef.abfd = abfd;
1211         }
1212       else
1213         {
1214           h->root.type = bfd_link_hash_new;
1215           h->root.u.undef.abfd = NULL;
1216         }
1217
1218       if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1219         {
1220           /* If the new symbol is hidden or internal, completely undo
1221              any dynamic link state.  */
1222           (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1223           h->forced_local = 0;
1224           h->ref_dynamic = 0;
1225         }
1226       else
1227         h->ref_dynamic = 1;
1228       h->def_dynamic = 0;
1229       /* FIXME: Should we check type and size for protected symbol?  */
1230       h->size = 0;
1231       h->type = 0;
1232       return TRUE;
1233     }
1234
1235   /* If a new weak symbol definition comes from a regular file and the
1236      old symbol comes from a dynamic library, we treat the new one as
1237      strong.  Similarly, an old weak symbol definition from a regular
1238      file is treated as strong when the new symbol comes from a dynamic
1239      library.  Further, an old weak symbol from a dynamic library is
1240      treated as strong if the new symbol is from a dynamic library.
1241      This reflects the way glibc's ld.so works.
1242
1243      Do this before setting *type_change_ok or *size_change_ok so that
1244      we warn properly when dynamic library symbols are overridden.  */
1245
1246   if (newdef && !newdyn && olddyn)
1247     newweak = FALSE;
1248   if (olddef && newdyn)
1249     oldweak = FALSE;
1250
1251   /* Allow changes between different types of function symbol.  */
1252   if (newfunc && oldfunc)
1253     *type_change_ok = TRUE;
1254
1255   /* It's OK to change the type if either the existing symbol or the
1256      new symbol is weak.  A type change is also OK if the old symbol
1257      is undefined and the new symbol is defined.  */
1258
1259   if (oldweak
1260       || newweak
1261       || (newdef
1262           && h->root.type == bfd_link_hash_undefined))
1263     *type_change_ok = TRUE;
1264
1265   /* It's OK to change the size if either the existing symbol or the
1266      new symbol is weak, or if the old symbol is undefined.  */
1267
1268   if (*type_change_ok
1269       || h->root.type == bfd_link_hash_undefined)
1270     *size_change_ok = TRUE;
1271
1272   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1273      symbol, respectively, appears to be a common symbol in a dynamic
1274      object.  If a symbol appears in an uninitialized section, and is
1275      not weak, and is not a function, then it may be a common symbol
1276      which was resolved when the dynamic object was created.  We want
1277      to treat such symbols specially, because they raise special
1278      considerations when setting the symbol size: if the symbol
1279      appears as a common symbol in a regular object, and the size in
1280      the regular object is larger, we must make sure that we use the
1281      larger size.  This problematic case can always be avoided in C,
1282      but it must be handled correctly when using Fortran shared
1283      libraries.
1284
1285      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1286      likewise for OLDDYNCOMMON and OLDDEF.
1287
1288      Note that this test is just a heuristic, and that it is quite
1289      possible to have an uninitialized symbol in a shared object which
1290      is really a definition, rather than a common symbol.  This could
1291      lead to some minor confusion when the symbol really is a common
1292      symbol in some regular object.  However, I think it will be
1293      harmless.  */
1294
1295   if (newdyn
1296       && newdef
1297       && !newweak
1298       && (sec->flags & SEC_ALLOC) != 0
1299       && (sec->flags & SEC_LOAD) == 0
1300       && sym->st_size > 0
1301       && !newfunc)
1302     newdyncommon = TRUE;
1303   else
1304     newdyncommon = FALSE;
1305
1306   if (olddyn
1307       && olddef
1308       && h->root.type == bfd_link_hash_defined
1309       && h->def_dynamic
1310       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1311       && (h->root.u.def.section->flags & SEC_LOAD) == 0
1312       && h->size > 0
1313       && !oldfunc)
1314     olddyncommon = TRUE;
1315   else
1316     olddyncommon = FALSE;
1317
1318   /* We now know everything about the old and new symbols.  We ask the
1319      backend to check if we can merge them.  */
1320   if (bed->merge_symbol != NULL)
1321     {
1322       if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
1323         return FALSE;
1324       sec = *psec;
1325     }
1326
1327   /* If both the old and the new symbols look like common symbols in a
1328      dynamic object, set the size of the symbol to the larger of the
1329      two.  */
1330
1331   if (olddyncommon
1332       && newdyncommon
1333       && sym->st_size != h->size)
1334     {
1335       /* Since we think we have two common symbols, issue a multiple
1336          common warning if desired.  Note that we only warn if the
1337          size is different.  If the size is the same, we simply let
1338          the old symbol override the new one as normally happens with
1339          symbols defined in dynamic objects.  */
1340
1341       if (! ((*info->callbacks->multiple_common)
1342              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1343         return FALSE;
1344
1345       if (sym->st_size > h->size)
1346         h->size = sym->st_size;
1347
1348       *size_change_ok = TRUE;
1349     }
1350
1351   /* If we are looking at a dynamic object, and we have found a
1352      definition, we need to see if the symbol was already defined by
1353      some other object.  If so, we want to use the existing
1354      definition, and we do not want to report a multiple symbol
1355      definition error; we do this by clobbering *PSEC to be
1356      bfd_und_section_ptr.
1357
1358      We treat a common symbol as a definition if the symbol in the
1359      shared library is a function, since common symbols always
1360      represent variables; this can cause confusion in principle, but
1361      any such confusion would seem to indicate an erroneous program or
1362      shared library.  We also permit a common symbol in a regular
1363      object to override a weak symbol in a shared object.  */
1364
1365   if (newdyn
1366       && newdef
1367       && (olddef
1368           || (h->root.type == bfd_link_hash_common
1369               && (newweak || newfunc))))
1370     {
1371       *override = TRUE;
1372       newdef = FALSE;
1373       newdyncommon = FALSE;
1374
1375       *psec = sec = bfd_und_section_ptr;
1376       *size_change_ok = TRUE;
1377
1378       /* If we get here when the old symbol is a common symbol, then
1379          we are explicitly letting it override a weak symbol or
1380          function in a dynamic object, and we don't want to warn about
1381          a type change.  If the old symbol is a defined symbol, a type
1382          change warning may still be appropriate.  */
1383
1384       if (h->root.type == bfd_link_hash_common)
1385         *type_change_ok = TRUE;
1386     }
1387
1388   /* Handle the special case of an old common symbol merging with a
1389      new symbol which looks like a common symbol in a shared object.
1390      We change *PSEC and *PVALUE to make the new symbol look like a
1391      common symbol, and let _bfd_generic_link_add_one_symbol do the
1392      right thing.  */
1393
1394   if (newdyncommon
1395       && h->root.type == bfd_link_hash_common)
1396     {
1397       *override = TRUE;
1398       newdef = FALSE;
1399       newdyncommon = FALSE;
1400       *pvalue = sym->st_size;
1401       *psec = sec = bed->common_section (oldsec);
1402       *size_change_ok = TRUE;
1403     }
1404
1405   /* Skip weak definitions of symbols that are already defined.  */
1406   if (newdef && olddef && newweak)
1407     {
1408       /* Don't skip new non-IR weak syms.  */
1409       if (!(oldbfd != NULL
1410             && (oldbfd->flags & BFD_PLUGIN) != 0
1411             && (abfd->flags & BFD_PLUGIN) == 0))
1412         {
1413           newdef = FALSE;
1414           *skip = TRUE;
1415         }
1416
1417       /* Merge st_other.  If the symbol already has a dynamic index,
1418          but visibility says it should not be visible, turn it into a
1419          local symbol.  */
1420       elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1421       if (h->dynindx != -1)
1422         switch (ELF_ST_VISIBILITY (h->other))
1423           {
1424           case STV_INTERNAL:
1425           case STV_HIDDEN:
1426             (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1427             break;
1428           }
1429     }
1430
1431   /* If the old symbol is from a dynamic object, and the new symbol is
1432      a definition which is not from a dynamic object, then the new
1433      symbol overrides the old symbol.  Symbols from regular files
1434      always take precedence over symbols from dynamic objects, even if
1435      they are defined after the dynamic object in the link.
1436
1437      As above, we again permit a common symbol in a regular object to
1438      override a definition in a shared object if the shared object
1439      symbol is a function or is weak.  */
1440
1441   flip = NULL;
1442   if (!newdyn
1443       && (newdef
1444           || (bfd_is_com_section (sec)
1445               && (oldweak || oldfunc)))
1446       && olddyn
1447       && olddef
1448       && h->def_dynamic)
1449     {
1450       /* Change the hash table entry to undefined, and let
1451          _bfd_generic_link_add_one_symbol do the right thing with the
1452          new definition.  */
1453
1454       h->root.type = bfd_link_hash_undefined;
1455       h->root.u.undef.abfd = h->root.u.def.section->owner;
1456       *size_change_ok = TRUE;
1457
1458       olddef = FALSE;
1459       olddyncommon = FALSE;
1460
1461       /* We again permit a type change when a common symbol may be
1462          overriding a function.  */
1463
1464       if (bfd_is_com_section (sec))
1465         {
1466           if (oldfunc)
1467             {
1468               /* If a common symbol overrides a function, make sure
1469                  that it isn't defined dynamically nor has type
1470                  function.  */
1471               h->def_dynamic = 0;
1472               h->type = STT_NOTYPE;
1473             }
1474           *type_change_ok = TRUE;
1475         }
1476
1477       if (hi->root.type == bfd_link_hash_indirect)
1478         flip = hi;
1479       else
1480         /* This union may have been set to be non-NULL when this symbol
1481            was seen in a dynamic object.  We must force the union to be
1482            NULL, so that it is correct for a regular symbol.  */
1483         h->verinfo.vertree = NULL;
1484     }
1485
1486   /* Handle the special case of a new common symbol merging with an
1487      old symbol that looks like it might be a common symbol defined in
1488      a shared object.  Note that we have already handled the case in
1489      which a new common symbol should simply override the definition
1490      in the shared library.  */
1491
1492   if (! newdyn
1493       && bfd_is_com_section (sec)
1494       && olddyncommon)
1495     {
1496       /* It would be best if we could set the hash table entry to a
1497          common symbol, but we don't know what to use for the section
1498          or the alignment.  */
1499       if (! ((*info->callbacks->multiple_common)
1500              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1501         return FALSE;
1502
1503       /* If the presumed common symbol in the dynamic object is
1504          larger, pretend that the new symbol has its size.  */
1505
1506       if (h->size > *pvalue)
1507         *pvalue = h->size;
1508
1509       /* We need to remember the alignment required by the symbol
1510          in the dynamic object.  */
1511       BFD_ASSERT (pold_alignment);
1512       *pold_alignment = h->root.u.def.section->alignment_power;
1513
1514       olddef = FALSE;
1515       olddyncommon = FALSE;
1516
1517       h->root.type = bfd_link_hash_undefined;
1518       h->root.u.undef.abfd = h->root.u.def.section->owner;
1519
1520       *size_change_ok = TRUE;
1521       *type_change_ok = TRUE;
1522
1523       if (hi->root.type == bfd_link_hash_indirect)
1524         flip = hi;
1525       else
1526         h->verinfo.vertree = NULL;
1527     }
1528
1529   if (flip != NULL)
1530     {
1531       /* Handle the case where we had a versioned symbol in a dynamic
1532          library and now find a definition in a normal object.  In this
1533          case, we make the versioned symbol point to the normal one.  */
1534       flip->root.type = h->root.type;
1535       flip->root.u.undef.abfd = h->root.u.undef.abfd;
1536       h->root.type = bfd_link_hash_indirect;
1537       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1538       (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1539       if (h->def_dynamic)
1540         {
1541           h->def_dynamic = 0;
1542           flip->ref_dynamic = 1;
1543         }
1544     }
1545
1546   return TRUE;
1547 }
1548
1549 /* This function is called to create an indirect symbol from the
1550    default for the symbol with the default version if needed. The
1551    symbol is described by H, NAME, SYM, SEC, and VALUE.  We
1552    set DYNSYM if the new indirect symbol is dynamic.  */
1553
1554 static bfd_boolean
1555 _bfd_elf_add_default_symbol (bfd *abfd,
1556                              struct bfd_link_info *info,
1557                              struct elf_link_hash_entry *h,
1558                              const char *name,
1559                              Elf_Internal_Sym *sym,
1560                              asection *sec,
1561                              bfd_vma value,
1562                              bfd **poldbfd,
1563                              bfd_boolean *dynsym)
1564 {
1565   bfd_boolean type_change_ok;
1566   bfd_boolean size_change_ok;
1567   bfd_boolean skip;
1568   char *shortname;
1569   struct elf_link_hash_entry *hi;
1570   struct bfd_link_hash_entry *bh;
1571   const struct elf_backend_data *bed;
1572   bfd_boolean collect;
1573   bfd_boolean dynamic;
1574   bfd_boolean override;
1575   char *p;
1576   size_t len, shortlen;
1577   asection *tmp_sec;
1578
1579   /* If this symbol has a version, and it is the default version, we
1580      create an indirect symbol from the default name to the fully
1581      decorated name.  This will cause external references which do not
1582      specify a version to be bound to this version of the symbol.  */
1583   p = strchr (name, ELF_VER_CHR);
1584   if (p == NULL || p[1] != ELF_VER_CHR)
1585     return TRUE;
1586
1587   bed = get_elf_backend_data (abfd);
1588   collect = bed->collect;
1589   dynamic = (abfd->flags & DYNAMIC) != 0;
1590
1591   shortlen = p - name;
1592   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1593   if (shortname == NULL)
1594     return FALSE;
1595   memcpy (shortname, name, shortlen);
1596   shortname[shortlen] = '\0';
1597
1598   /* We are going to create a new symbol.  Merge it with any existing
1599      symbol with this name.  For the purposes of the merge, act as
1600      though we were defining the symbol we just defined, although we
1601      actually going to define an indirect symbol.  */
1602   type_change_ok = FALSE;
1603   size_change_ok = FALSE;
1604   tmp_sec = sec;
1605   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1606                               &hi, poldbfd, NULL, NULL, &skip, &override,
1607                               &type_change_ok, &size_change_ok))
1608     return FALSE;
1609
1610   if (skip)
1611     goto nondefault;
1612
1613   if (! override)
1614     {
1615       bh = &hi->root;
1616       if (! (_bfd_generic_link_add_one_symbol
1617              (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1618               0, name, FALSE, collect, &bh)))
1619         return FALSE;
1620       hi = (struct elf_link_hash_entry *) bh;
1621     }
1622   else
1623     {
1624       /* In this case the symbol named SHORTNAME is overriding the
1625          indirect symbol we want to add.  We were planning on making
1626          SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1627          is the name without a version.  NAME is the fully versioned
1628          name, and it is the default version.
1629
1630          Overriding means that we already saw a definition for the
1631          symbol SHORTNAME in a regular object, and it is overriding
1632          the symbol defined in the dynamic object.
1633
1634          When this happens, we actually want to change NAME, the
1635          symbol we just added, to refer to SHORTNAME.  This will cause
1636          references to NAME in the shared object to become references
1637          to SHORTNAME in the regular object.  This is what we expect
1638          when we override a function in a shared object: that the
1639          references in the shared object will be mapped to the
1640          definition in the regular object.  */
1641
1642       while (hi->root.type == bfd_link_hash_indirect
1643              || hi->root.type == bfd_link_hash_warning)
1644         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1645
1646       h->root.type = bfd_link_hash_indirect;
1647       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1648       if (h->def_dynamic)
1649         {
1650           h->def_dynamic = 0;
1651           hi->ref_dynamic = 1;
1652           if (hi->ref_regular
1653               || hi->def_regular)
1654             {
1655               if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1656                 return FALSE;
1657             }
1658         }
1659
1660       /* Now set HI to H, so that the following code will set the
1661          other fields correctly.  */
1662       hi = h;
1663     }
1664
1665   /* Check if HI is a warning symbol.  */
1666   if (hi->root.type == bfd_link_hash_warning)
1667     hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1668
1669   /* If there is a duplicate definition somewhere, then HI may not
1670      point to an indirect symbol.  We will have reported an error to
1671      the user in that case.  */
1672
1673   if (hi->root.type == bfd_link_hash_indirect)
1674     {
1675       struct elf_link_hash_entry *ht;
1676
1677       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1678       (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1679
1680       /* A reference to the SHORTNAME symbol from a dynamic library
1681          will be satisfied by the versioned symbol at runtime.  In
1682          effect, we have a reference to the versioned symbol.  */
1683       ht->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1684       hi->dynamic_def |= ht->dynamic_def;
1685
1686       /* See if the new flags lead us to realize that the symbol must
1687          be dynamic.  */
1688       if (! *dynsym)
1689         {
1690           if (! dynamic)
1691             {
1692               if (! info->executable
1693                   || hi->def_dynamic
1694                   || hi->ref_dynamic)
1695                 *dynsym = TRUE;
1696             }
1697           else
1698             {
1699               if (hi->ref_regular)
1700                 *dynsym = TRUE;
1701             }
1702         }
1703     }
1704
1705   /* We also need to define an indirection from the nondefault version
1706      of the symbol.  */
1707
1708 nondefault:
1709   len = strlen (name);
1710   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1711   if (shortname == NULL)
1712     return FALSE;
1713   memcpy (shortname, name, shortlen);
1714   memcpy (shortname + shortlen, p + 1, len - shortlen);
1715
1716   /* Once again, merge with any existing symbol.  */
1717   type_change_ok = FALSE;
1718   size_change_ok = FALSE;
1719   tmp_sec = sec;
1720   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1721                               &hi, poldbfd, NULL, NULL, &skip, &override,
1722                               &type_change_ok, &size_change_ok))
1723     return FALSE;
1724
1725   if (skip)
1726     return TRUE;
1727
1728   if (override)
1729     {
1730       /* Here SHORTNAME is a versioned name, so we don't expect to see
1731          the type of override we do in the case above unless it is
1732          overridden by a versioned definition.  */
1733       if (hi->root.type != bfd_link_hash_defined
1734           && hi->root.type != bfd_link_hash_defweak)
1735         (*_bfd_error_handler)
1736           (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1737            abfd, shortname);
1738     }
1739   else
1740     {
1741       bh = &hi->root;
1742       if (! (_bfd_generic_link_add_one_symbol
1743              (info, abfd, shortname, BSF_INDIRECT,
1744               bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1745         return FALSE;
1746       hi = (struct elf_link_hash_entry *) bh;
1747
1748       /* If there is a duplicate definition somewhere, then HI may not
1749          point to an indirect symbol.  We will have reported an error
1750          to the user in that case.  */
1751
1752       if (hi->root.type == bfd_link_hash_indirect)
1753         {
1754           (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1755           h->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1756           hi->dynamic_def |= h->dynamic_def;
1757
1758           /* See if the new flags lead us to realize that the symbol
1759              must be dynamic.  */
1760           if (! *dynsym)
1761             {
1762               if (! dynamic)
1763                 {
1764                   if (! info->executable
1765                       || hi->ref_dynamic)
1766                     *dynsym = TRUE;
1767                 }
1768               else
1769                 {
1770                   if (hi->ref_regular)
1771                     *dynsym = TRUE;
1772                 }
1773             }
1774         }
1775     }
1776
1777   return TRUE;
1778 }
1779 \f
1780 /* This routine is used to export all defined symbols into the dynamic
1781    symbol table.  It is called via elf_link_hash_traverse.  */
1782
1783 static bfd_boolean
1784 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1785 {
1786   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1787
1788   /* Ignore indirect symbols.  These are added by the versioning code.  */
1789   if (h->root.type == bfd_link_hash_indirect)
1790     return TRUE;
1791
1792   /* Ignore this if we won't export it.  */
1793   if (!eif->info->export_dynamic && !h->dynamic)
1794     return TRUE;
1795
1796   if (h->dynindx == -1
1797       && (h->def_regular || h->ref_regular)
1798       && ! bfd_hide_sym_by_version (eif->info->version_info,
1799                                     h->root.root.string))
1800     {
1801       if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1802         {
1803           eif->failed = TRUE;
1804           return FALSE;
1805         }
1806     }
1807
1808   return TRUE;
1809 }
1810 \f
1811 /* Look through the symbols which are defined in other shared
1812    libraries and referenced here.  Update the list of version
1813    dependencies.  This will be put into the .gnu.version_r section.
1814    This function is called via elf_link_hash_traverse.  */
1815
1816 static bfd_boolean
1817 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1818                                          void *data)
1819 {
1820   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1821   Elf_Internal_Verneed *t;
1822   Elf_Internal_Vernaux *a;
1823   bfd_size_type amt;
1824
1825   /* We only care about symbols defined in shared objects with version
1826      information.  */
1827   if (!h->def_dynamic
1828       || h->def_regular
1829       || h->dynindx == -1
1830       || h->verinfo.verdef == NULL
1831       || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
1832           & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
1833     return TRUE;
1834
1835   /* See if we already know about this version.  */
1836   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1837        t != NULL;
1838        t = t->vn_nextref)
1839     {
1840       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1841         continue;
1842
1843       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1844         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1845           return TRUE;
1846
1847       break;
1848     }
1849
1850   /* This is a new version.  Add it to tree we are building.  */
1851
1852   if (t == NULL)
1853     {
1854       amt = sizeof *t;
1855       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1856       if (t == NULL)
1857         {
1858           rinfo->failed = TRUE;
1859           return FALSE;
1860         }
1861
1862       t->vn_bfd = h->verinfo.verdef->vd_bfd;
1863       t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1864       elf_tdata (rinfo->info->output_bfd)->verref = t;
1865     }
1866
1867   amt = sizeof *a;
1868   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1869   if (a == NULL)
1870     {
1871       rinfo->failed = TRUE;
1872       return FALSE;
1873     }
1874
1875   /* Note that we are copying a string pointer here, and testing it
1876      above.  If bfd_elf_string_from_elf_section is ever changed to
1877      discard the string data when low in memory, this will have to be
1878      fixed.  */
1879   a->vna_nodename = h->verinfo.verdef->vd_nodename;
1880
1881   a->vna_flags = h->verinfo.verdef->vd_flags;
1882   a->vna_nextptr = t->vn_auxptr;
1883
1884   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1885   ++rinfo->vers;
1886
1887   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1888
1889   t->vn_auxptr = a;
1890
1891   return TRUE;
1892 }
1893
1894 /* Figure out appropriate versions for all the symbols.  We may not
1895    have the version number script until we have read all of the input
1896    files, so until that point we don't know which symbols should be
1897    local.  This function is called via elf_link_hash_traverse.  */
1898
1899 static bfd_boolean
1900 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1901 {
1902   struct elf_info_failed *sinfo;
1903   struct bfd_link_info *info;
1904   const struct elf_backend_data *bed;
1905   struct elf_info_failed eif;
1906   char *p;
1907   bfd_size_type amt;
1908
1909   sinfo = (struct elf_info_failed *) data;
1910   info = sinfo->info;
1911
1912   /* Fix the symbol flags.  */
1913   eif.failed = FALSE;
1914   eif.info = info;
1915   if (! _bfd_elf_fix_symbol_flags (h, &eif))
1916     {
1917       if (eif.failed)
1918         sinfo->failed = TRUE;
1919       return FALSE;
1920     }
1921
1922   /* We only need version numbers for symbols defined in regular
1923      objects.  */
1924   if (!h->def_regular)
1925     return TRUE;
1926
1927   bed = get_elf_backend_data (info->output_bfd);
1928   p = strchr (h->root.root.string, ELF_VER_CHR);
1929   if (p != NULL && h->verinfo.vertree == NULL)
1930     {
1931       struct bfd_elf_version_tree *t;
1932       bfd_boolean hidden;
1933
1934       hidden = TRUE;
1935
1936       /* There are two consecutive ELF_VER_CHR characters if this is
1937          not a hidden symbol.  */
1938       ++p;
1939       if (*p == ELF_VER_CHR)
1940         {
1941           hidden = FALSE;
1942           ++p;
1943         }
1944
1945       /* If there is no version string, we can just return out.  */
1946       if (*p == '\0')
1947         {
1948           if (hidden)
1949             h->hidden = 1;
1950           return TRUE;
1951         }
1952
1953       /* Look for the version.  If we find it, it is no longer weak.  */
1954       for (t = sinfo->info->version_info; t != NULL; t = t->next)
1955         {
1956           if (strcmp (t->name, p) == 0)
1957             {
1958               size_t len;
1959               char *alc;
1960               struct bfd_elf_version_expr *d;
1961
1962               len = p - h->root.root.string;
1963               alc = (char *) bfd_malloc (len);
1964               if (alc == NULL)
1965                 {
1966                   sinfo->failed = TRUE;
1967                   return FALSE;
1968                 }
1969               memcpy (alc, h->root.root.string, len - 1);
1970               alc[len - 1] = '\0';
1971               if (alc[len - 2] == ELF_VER_CHR)
1972                 alc[len - 2] = '\0';
1973
1974               h->verinfo.vertree = t;
1975               t->used = TRUE;
1976               d = NULL;
1977
1978               if (t->globals.list != NULL)
1979                 d = (*t->match) (&t->globals, NULL, alc);
1980
1981               /* See if there is anything to force this symbol to
1982                  local scope.  */
1983               if (d == NULL && t->locals.list != NULL)
1984                 {
1985                   d = (*t->match) (&t->locals, NULL, alc);
1986                   if (d != NULL
1987                       && h->dynindx != -1
1988                       && ! info->export_dynamic)
1989                     (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1990                 }
1991
1992               free (alc);
1993               break;
1994             }
1995         }
1996
1997       /* If we are building an application, we need to create a
1998          version node for this version.  */
1999       if (t == NULL && info->executable)
2000         {
2001           struct bfd_elf_version_tree **pp;
2002           int version_index;
2003
2004           /* If we aren't going to export this symbol, we don't need
2005              to worry about it.  */
2006           if (h->dynindx == -1)
2007             return TRUE;
2008
2009           amt = sizeof *t;
2010           t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2011           if (t == NULL)
2012             {
2013               sinfo->failed = TRUE;
2014               return FALSE;
2015             }
2016
2017           t->name = p;
2018           t->name_indx = (unsigned int) -1;
2019           t->used = TRUE;
2020
2021           version_index = 1;
2022           /* Don't count anonymous version tag.  */
2023           if (sinfo->info->version_info != NULL
2024               && sinfo->info->version_info->vernum == 0)
2025             version_index = 0;
2026           for (pp = &sinfo->info->version_info;
2027                *pp != NULL;
2028                pp = &(*pp)->next)
2029             ++version_index;
2030           t->vernum = version_index;
2031
2032           *pp = t;
2033
2034           h->verinfo.vertree = t;
2035         }
2036       else if (t == NULL)
2037         {
2038           /* We could not find the version for a symbol when
2039              generating a shared archive.  Return an error.  */
2040           (*_bfd_error_handler)
2041             (_("%B: version node not found for symbol %s"),
2042              info->output_bfd, h->root.root.string);
2043           bfd_set_error (bfd_error_bad_value);
2044           sinfo->failed = TRUE;
2045           return FALSE;
2046         }
2047
2048       if (hidden)
2049         h->hidden = 1;
2050     }
2051
2052   /* If we don't have a version for this symbol, see if we can find
2053      something.  */
2054   if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2055     {
2056       bfd_boolean hide;
2057
2058       h->verinfo.vertree
2059         = bfd_find_version_for_sym (sinfo->info->version_info,
2060                                     h->root.root.string, &hide);
2061       if (h->verinfo.vertree != NULL && hide)
2062         (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2063     }
2064
2065   return TRUE;
2066 }
2067 \f
2068 /* Read and swap the relocs from the section indicated by SHDR.  This
2069    may be either a REL or a RELA section.  The relocations are
2070    translated into RELA relocations and stored in INTERNAL_RELOCS,
2071    which should have already been allocated to contain enough space.
2072    The EXTERNAL_RELOCS are a buffer where the external form of the
2073    relocations should be stored.
2074
2075    Returns FALSE if something goes wrong.  */
2076
2077 static bfd_boolean
2078 elf_link_read_relocs_from_section (bfd *abfd,
2079                                    asection *sec,
2080                                    Elf_Internal_Shdr *shdr,
2081                                    void *external_relocs,
2082                                    Elf_Internal_Rela *internal_relocs)
2083 {
2084   const struct elf_backend_data *bed;
2085   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2086   const bfd_byte *erela;
2087   const bfd_byte *erelaend;
2088   Elf_Internal_Rela *irela;
2089   Elf_Internal_Shdr *symtab_hdr;
2090   size_t nsyms;
2091
2092   /* Position ourselves at the start of the section.  */
2093   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2094     return FALSE;
2095
2096   /* Read the relocations.  */
2097   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2098     return FALSE;
2099
2100   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2101   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2102
2103   bed = get_elf_backend_data (abfd);
2104
2105   /* Convert the external relocations to the internal format.  */
2106   if (shdr->sh_entsize == bed->s->sizeof_rel)
2107     swap_in = bed->s->swap_reloc_in;
2108   else if (shdr->sh_entsize == bed->s->sizeof_rela)
2109     swap_in = bed->s->swap_reloca_in;
2110   else
2111     {
2112       bfd_set_error (bfd_error_wrong_format);
2113       return FALSE;
2114     }
2115
2116   erela = (const bfd_byte *) external_relocs;
2117   erelaend = erela + shdr->sh_size;
2118   irela = internal_relocs;
2119   while (erela < erelaend)
2120     {
2121       bfd_vma r_symndx;
2122
2123       (*swap_in) (abfd, erela, irela);
2124       r_symndx = ELF32_R_SYM (irela->r_info);
2125       if (bed->s->arch_size == 64)
2126         r_symndx >>= 24;
2127       if (nsyms > 0)
2128         {
2129           if ((size_t) r_symndx >= nsyms)
2130             {
2131               (*_bfd_error_handler)
2132                 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2133                    " for offset 0x%lx in section `%A'"),
2134                  abfd, sec,
2135                  (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2136               bfd_set_error (bfd_error_bad_value);
2137               return FALSE;
2138             }
2139         }
2140       else if (r_symndx != STN_UNDEF)
2141         {
2142           (*_bfd_error_handler)
2143             (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2144                " when the object file has no symbol table"),
2145              abfd, sec,
2146              (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2147           bfd_set_error (bfd_error_bad_value);
2148           return FALSE;
2149         }
2150       irela += bed->s->int_rels_per_ext_rel;
2151       erela += shdr->sh_entsize;
2152     }
2153
2154   return TRUE;
2155 }
2156
2157 /* Read and swap the relocs for a section O.  They may have been
2158    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2159    not NULL, they are used as buffers to read into.  They are known to
2160    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2161    the return value is allocated using either malloc or bfd_alloc,
2162    according to the KEEP_MEMORY argument.  If O has two relocation
2163    sections (both REL and RELA relocations), then the REL_HDR
2164    relocations will appear first in INTERNAL_RELOCS, followed by the
2165    RELA_HDR relocations.  */
2166
2167 Elf_Internal_Rela *
2168 _bfd_elf_link_read_relocs (bfd *abfd,
2169                            asection *o,
2170                            void *external_relocs,
2171                            Elf_Internal_Rela *internal_relocs,
2172                            bfd_boolean keep_memory)
2173 {
2174   void *alloc1 = NULL;
2175   Elf_Internal_Rela *alloc2 = NULL;
2176   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2177   struct bfd_elf_section_data *esdo = elf_section_data (o);
2178   Elf_Internal_Rela *internal_rela_relocs;
2179
2180   if (esdo->relocs != NULL)
2181     return esdo->relocs;
2182
2183   if (o->reloc_count == 0)
2184     return NULL;
2185
2186   if (internal_relocs == NULL)
2187     {
2188       bfd_size_type size;
2189
2190       size = o->reloc_count;
2191       size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2192       if (keep_memory)
2193         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2194       else
2195         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2196       if (internal_relocs == NULL)
2197         goto error_return;
2198     }
2199
2200   if (external_relocs == NULL)
2201     {
2202       bfd_size_type size = 0;
2203
2204       if (esdo->rel.hdr)
2205         size += esdo->rel.hdr->sh_size;
2206       if (esdo->rela.hdr)
2207         size += esdo->rela.hdr->sh_size;
2208
2209       alloc1 = bfd_malloc (size);
2210       if (alloc1 == NULL)
2211         goto error_return;
2212       external_relocs = alloc1;
2213     }
2214
2215   internal_rela_relocs = internal_relocs;
2216   if (esdo->rel.hdr)
2217     {
2218       if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2219                                               external_relocs,
2220                                               internal_relocs))
2221         goto error_return;
2222       external_relocs = (((bfd_byte *) external_relocs)
2223                          + esdo->rel.hdr->sh_size);
2224       internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2225                                * bed->s->int_rels_per_ext_rel);
2226     }
2227
2228   if (esdo->rela.hdr
2229       && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2230                                               external_relocs,
2231                                               internal_rela_relocs)))
2232     goto error_return;
2233
2234   /* Cache the results for next time, if we can.  */
2235   if (keep_memory)
2236     esdo->relocs = internal_relocs;
2237
2238   if (alloc1 != NULL)
2239     free (alloc1);
2240
2241   /* Don't free alloc2, since if it was allocated we are passing it
2242      back (under the name of internal_relocs).  */
2243
2244   return internal_relocs;
2245
2246  error_return:
2247   if (alloc1 != NULL)
2248     free (alloc1);
2249   if (alloc2 != NULL)
2250     {
2251       if (keep_memory)
2252         bfd_release (abfd, alloc2);
2253       else
2254         free (alloc2);
2255     }
2256   return NULL;
2257 }
2258
2259 /* Compute the size of, and allocate space for, REL_HDR which is the
2260    section header for a section containing relocations for O.  */
2261
2262 static bfd_boolean
2263 _bfd_elf_link_size_reloc_section (bfd *abfd,
2264                                   struct bfd_elf_section_reloc_data *reldata)
2265 {
2266   Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2267
2268   /* That allows us to calculate the size of the section.  */
2269   rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2270
2271   /* The contents field must last into write_object_contents, so we
2272      allocate it with bfd_alloc rather than malloc.  Also since we
2273      cannot be sure that the contents will actually be filled in,
2274      we zero the allocated space.  */
2275   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2276   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2277     return FALSE;
2278
2279   if (reldata->hashes == NULL && reldata->count)
2280     {
2281       struct elf_link_hash_entry **p;
2282
2283       p = ((struct elf_link_hash_entry **)
2284            bfd_zmalloc (reldata->count * sizeof (*p)));
2285       if (p == NULL)
2286         return FALSE;
2287
2288       reldata->hashes = p;
2289     }
2290
2291   return TRUE;
2292 }
2293
2294 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2295    originated from the section given by INPUT_REL_HDR) to the
2296    OUTPUT_BFD.  */
2297
2298 bfd_boolean
2299 _bfd_elf_link_output_relocs (bfd *output_bfd,
2300                              asection *input_section,
2301                              Elf_Internal_Shdr *input_rel_hdr,
2302                              Elf_Internal_Rela *internal_relocs,
2303                              struct elf_link_hash_entry **rel_hash
2304                                ATTRIBUTE_UNUSED)
2305 {
2306   Elf_Internal_Rela *irela;
2307   Elf_Internal_Rela *irelaend;
2308   bfd_byte *erel;
2309   struct bfd_elf_section_reloc_data *output_reldata;
2310   asection *output_section;
2311   const struct elf_backend_data *bed;
2312   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2313   struct bfd_elf_section_data *esdo;
2314
2315   output_section = input_section->output_section;
2316
2317   bed = get_elf_backend_data (output_bfd);
2318   esdo = elf_section_data (output_section);
2319   if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2320     {
2321       output_reldata = &esdo->rel;
2322       swap_out = bed->s->swap_reloc_out;
2323     }
2324   else if (esdo->rela.hdr
2325            && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2326     {
2327       output_reldata = &esdo->rela;
2328       swap_out = bed->s->swap_reloca_out;
2329     }
2330   else
2331     {
2332       (*_bfd_error_handler)
2333         (_("%B: relocation size mismatch in %B section %A"),
2334          output_bfd, input_section->owner, input_section);
2335       bfd_set_error (bfd_error_wrong_format);
2336       return FALSE;
2337     }
2338
2339   erel = output_reldata->hdr->contents;
2340   erel += output_reldata->count * input_rel_hdr->sh_entsize;
2341   irela = internal_relocs;
2342   irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2343                       * bed->s->int_rels_per_ext_rel);
2344   while (irela < irelaend)
2345     {
2346       (*swap_out) (output_bfd, irela, erel);
2347       irela += bed->s->int_rels_per_ext_rel;
2348       erel += input_rel_hdr->sh_entsize;
2349     }
2350
2351   /* Bump the counter, so that we know where to add the next set of
2352      relocations.  */
2353   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2354
2355   return TRUE;
2356 }
2357 \f
2358 /* Make weak undefined symbols in PIE dynamic.  */
2359
2360 bfd_boolean
2361 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2362                                  struct elf_link_hash_entry *h)
2363 {
2364   if (info->pie
2365       && h->dynindx == -1
2366       && h->root.type == bfd_link_hash_undefweak)
2367     return bfd_elf_link_record_dynamic_symbol (info, h);
2368
2369   return TRUE;
2370 }
2371
2372 /* Fix up the flags for a symbol.  This handles various cases which
2373    can only be fixed after all the input files are seen.  This is
2374    currently called by both adjust_dynamic_symbol and
2375    assign_sym_version, which is unnecessary but perhaps more robust in
2376    the face of future changes.  */
2377
2378 static bfd_boolean
2379 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2380                            struct elf_info_failed *eif)
2381 {
2382   const struct elf_backend_data *bed;
2383
2384   /* If this symbol was mentioned in a non-ELF file, try to set
2385      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2386      permit a non-ELF file to correctly refer to a symbol defined in
2387      an ELF dynamic object.  */
2388   if (h->non_elf)
2389     {
2390       while (h->root.type == bfd_link_hash_indirect)
2391         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2392
2393       if (h->root.type != bfd_link_hash_defined
2394           && h->root.type != bfd_link_hash_defweak)
2395         {
2396           h->ref_regular = 1;
2397           h->ref_regular_nonweak = 1;
2398         }
2399       else
2400         {
2401           if (h->root.u.def.section->owner != NULL
2402               && (bfd_get_flavour (h->root.u.def.section->owner)
2403                   == bfd_target_elf_flavour))
2404             {
2405               h->ref_regular = 1;
2406               h->ref_regular_nonweak = 1;
2407             }
2408           else
2409             h->def_regular = 1;
2410         }
2411
2412       if (h->dynindx == -1
2413           && (h->def_dynamic
2414               || h->ref_dynamic))
2415         {
2416           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2417             {
2418               eif->failed = TRUE;
2419               return FALSE;
2420             }
2421         }
2422     }
2423   else
2424     {
2425       /* Unfortunately, NON_ELF is only correct if the symbol
2426          was first seen in a non-ELF file.  Fortunately, if the symbol
2427          was first seen in an ELF file, we're probably OK unless the
2428          symbol was defined in a non-ELF file.  Catch that case here.
2429          FIXME: We're still in trouble if the symbol was first seen in
2430          a dynamic object, and then later in a non-ELF regular object.  */
2431       if ((h->root.type == bfd_link_hash_defined
2432            || h->root.type == bfd_link_hash_defweak)
2433           && !h->def_regular
2434           && (h->root.u.def.section->owner != NULL
2435               ? (bfd_get_flavour (h->root.u.def.section->owner)
2436                  != bfd_target_elf_flavour)
2437               : (bfd_is_abs_section (h->root.u.def.section)
2438                  && !h->def_dynamic)))
2439         h->def_regular = 1;
2440     }
2441
2442   /* Backend specific symbol fixup.  */
2443   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2444   if (bed->elf_backend_fixup_symbol
2445       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2446     return FALSE;
2447
2448   /* If this is a final link, and the symbol was defined as a common
2449      symbol in a regular object file, and there was no definition in
2450      any dynamic object, then the linker will have allocated space for
2451      the symbol in a common section but the DEF_REGULAR
2452      flag will not have been set.  */
2453   if (h->root.type == bfd_link_hash_defined
2454       && !h->def_regular
2455       && h->ref_regular
2456       && !h->def_dynamic
2457       && (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0)
2458     h->def_regular = 1;
2459
2460   /* If -Bsymbolic was used (which means to bind references to global
2461      symbols to the definition within the shared object), and this
2462      symbol was defined in a regular object, then it actually doesn't
2463      need a PLT entry.  Likewise, if the symbol has non-default
2464      visibility.  If the symbol has hidden or internal visibility, we
2465      will force it local.  */
2466   if (h->needs_plt
2467       && eif->info->shared
2468       && is_elf_hash_table (eif->info->hash)
2469       && (SYMBOLIC_BIND (eif->info, h)
2470           || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2471       && h->def_regular)
2472     {
2473       bfd_boolean force_local;
2474
2475       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2476                      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2477       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2478     }
2479
2480   /* If a weak undefined symbol has non-default visibility, we also
2481      hide it from the dynamic linker.  */
2482   if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2483       && h->root.type == bfd_link_hash_undefweak)
2484     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2485
2486   /* If this is a weak defined symbol in a dynamic object, and we know
2487      the real definition in the dynamic object, copy interesting flags
2488      over to the real definition.  */
2489   if (h->u.weakdef != NULL)
2490     {
2491       /* If the real definition is defined by a regular object file,
2492          don't do anything special.  See the longer description in
2493          _bfd_elf_adjust_dynamic_symbol, below.  */
2494       if (h->u.weakdef->def_regular)
2495         h->u.weakdef = NULL;
2496       else
2497         {
2498           struct elf_link_hash_entry *weakdef = h->u.weakdef;
2499
2500           while (h->root.type == bfd_link_hash_indirect)
2501             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2502
2503           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2504                       || h->root.type == bfd_link_hash_defweak);
2505           BFD_ASSERT (weakdef->def_dynamic);
2506           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2507                       || weakdef->root.type == bfd_link_hash_defweak);
2508           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2509         }
2510     }
2511
2512   return TRUE;
2513 }
2514
2515 /* Make the backend pick a good value for a dynamic symbol.  This is
2516    called via elf_link_hash_traverse, and also calls itself
2517    recursively.  */
2518
2519 static bfd_boolean
2520 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2521 {
2522   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2523   bfd *dynobj;
2524   const struct elf_backend_data *bed;
2525
2526   if (! is_elf_hash_table (eif->info->hash))
2527     return FALSE;
2528
2529   /* Ignore indirect symbols.  These are added by the versioning code.  */
2530   if (h->root.type == bfd_link_hash_indirect)
2531     return TRUE;
2532
2533   /* Fix the symbol flags.  */
2534   if (! _bfd_elf_fix_symbol_flags (h, eif))
2535     return FALSE;
2536
2537   /* If this symbol does not require a PLT entry, and it is not
2538      defined by a dynamic object, or is not referenced by a regular
2539      object, ignore it.  We do have to handle a weak defined symbol,
2540      even if no regular object refers to it, if we decided to add it
2541      to the dynamic symbol table.  FIXME: Do we normally need to worry
2542      about symbols which are defined by one dynamic object and
2543      referenced by another one?  */
2544   if (!h->needs_plt
2545       && h->type != STT_GNU_IFUNC
2546       && (h->def_regular
2547           || !h->def_dynamic
2548           || (!h->ref_regular
2549               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2550     {
2551       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2552       return TRUE;
2553     }
2554
2555   /* If we've already adjusted this symbol, don't do it again.  This
2556      can happen via a recursive call.  */
2557   if (h->dynamic_adjusted)
2558     return TRUE;
2559
2560   /* Don't look at this symbol again.  Note that we must set this
2561      after checking the above conditions, because we may look at a
2562      symbol once, decide not to do anything, and then get called
2563      recursively later after REF_REGULAR is set below.  */
2564   h->dynamic_adjusted = 1;
2565
2566   /* If this is a weak definition, and we know a real definition, and
2567      the real symbol is not itself defined by a regular object file,
2568      then get a good value for the real definition.  We handle the
2569      real symbol first, for the convenience of the backend routine.
2570
2571      Note that there is a confusing case here.  If the real definition
2572      is defined by a regular object file, we don't get the real symbol
2573      from the dynamic object, but we do get the weak symbol.  If the
2574      processor backend uses a COPY reloc, then if some routine in the
2575      dynamic object changes the real symbol, we will not see that
2576      change in the corresponding weak symbol.  This is the way other
2577      ELF linkers work as well, and seems to be a result of the shared
2578      library model.
2579
2580      I will clarify this issue.  Most SVR4 shared libraries define the
2581      variable _timezone and define timezone as a weak synonym.  The
2582      tzset call changes _timezone.  If you write
2583        extern int timezone;
2584        int _timezone = 5;
2585        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2586      you might expect that, since timezone is a synonym for _timezone,
2587      the same number will print both times.  However, if the processor
2588      backend uses a COPY reloc, then actually timezone will be copied
2589      into your process image, and, since you define _timezone
2590      yourself, _timezone will not.  Thus timezone and _timezone will
2591      wind up at different memory locations.  The tzset call will set
2592      _timezone, leaving timezone unchanged.  */
2593
2594   if (h->u.weakdef != NULL)
2595     {
2596       /* If we get to this point, there is an implicit reference to
2597          H->U.WEAKDEF by a regular object file via the weak symbol H.  */
2598       h->u.weakdef->ref_regular = 1;
2599
2600       /* Ensure that the backend adjust_dynamic_symbol function sees
2601          H->U.WEAKDEF before H by recursively calling ourselves.  */
2602       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2603         return FALSE;
2604     }
2605
2606   /* If a symbol has no type and no size and does not require a PLT
2607      entry, then we are probably about to do the wrong thing here: we
2608      are probably going to create a COPY reloc for an empty object.
2609      This case can arise when a shared object is built with assembly
2610      code, and the assembly code fails to set the symbol type.  */
2611   if (h->size == 0
2612       && h->type == STT_NOTYPE
2613       && !h->needs_plt)
2614     (*_bfd_error_handler)
2615       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2616        h->root.root.string);
2617
2618   dynobj = elf_hash_table (eif->info)->dynobj;
2619   bed = get_elf_backend_data (dynobj);
2620
2621   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2622     {
2623       eif->failed = TRUE;
2624       return FALSE;
2625     }
2626
2627   return TRUE;
2628 }
2629
2630 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2631    DYNBSS.  */
2632
2633 bfd_boolean
2634 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
2635                               struct elf_link_hash_entry *h,
2636                               asection *dynbss)
2637 {
2638   unsigned int power_of_two;
2639   bfd_vma mask;
2640   asection *sec = h->root.u.def.section;
2641
2642   /* The section aligment of definition is the maximum alignment
2643      requirement of symbols defined in the section.  Since we don't
2644      know the symbol alignment requirement, we start with the
2645      maximum alignment and check low bits of the symbol address
2646      for the minimum alignment.  */
2647   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2648   mask = ((bfd_vma) 1 << power_of_two) - 1;
2649   while ((h->root.u.def.value & mask) != 0)
2650     {
2651        mask >>= 1;
2652        --power_of_two;
2653     }
2654
2655   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2656                                                 dynbss))
2657     {
2658       /* Adjust the section alignment if needed.  */
2659       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2660                                        power_of_two))
2661         return FALSE;
2662     }
2663
2664   /* We make sure that the symbol will be aligned properly.  */
2665   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2666
2667   /* Define the symbol as being at this point in DYNBSS.  */
2668   h->root.u.def.section = dynbss;
2669   h->root.u.def.value = dynbss->size;
2670
2671   /* Increment the size of DYNBSS to make room for the symbol.  */
2672   dynbss->size += h->size;
2673
2674   if (h->protected_def)
2675     {
2676       info->callbacks->einfo
2677         (_("%P: copy reloc against protected `%T' is invalid\n"),
2678          h->root.root.string);
2679       bfd_set_error (bfd_error_bad_value);
2680       return FALSE;
2681     }
2682
2683   return TRUE;
2684 }
2685
2686 /* Adjust all external symbols pointing into SEC_MERGE sections
2687    to reflect the object merging within the sections.  */
2688
2689 static bfd_boolean
2690 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2691 {
2692   asection *sec;
2693
2694   if ((h->root.type == bfd_link_hash_defined
2695        || h->root.type == bfd_link_hash_defweak)
2696       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2697       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
2698     {
2699       bfd *output_bfd = (bfd *) data;
2700
2701       h->root.u.def.value =
2702         _bfd_merged_section_offset (output_bfd,
2703                                     &h->root.u.def.section,
2704                                     elf_section_data (sec)->sec_info,
2705                                     h->root.u.def.value);
2706     }
2707
2708   return TRUE;
2709 }
2710
2711 /* Returns false if the symbol referred to by H should be considered
2712    to resolve local to the current module, and true if it should be
2713    considered to bind dynamically.  */
2714
2715 bfd_boolean
2716 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2717                            struct bfd_link_info *info,
2718                            bfd_boolean not_local_protected)
2719 {
2720   bfd_boolean binding_stays_local_p;
2721   const struct elf_backend_data *bed;
2722   struct elf_link_hash_table *hash_table;
2723
2724   if (h == NULL)
2725     return FALSE;
2726
2727   while (h->root.type == bfd_link_hash_indirect
2728          || h->root.type == bfd_link_hash_warning)
2729     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2730
2731   /* If it was forced local, then clearly it's not dynamic.  */
2732   if (h->dynindx == -1)
2733     return FALSE;
2734   if (h->forced_local)
2735     return FALSE;
2736
2737   /* Identify the cases where name binding rules say that a
2738      visible symbol resolves locally.  */
2739   binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2740
2741   switch (ELF_ST_VISIBILITY (h->other))
2742     {
2743     case STV_INTERNAL:
2744     case STV_HIDDEN:
2745       return FALSE;
2746
2747     case STV_PROTECTED:
2748       hash_table = elf_hash_table (info);
2749       if (!is_elf_hash_table (hash_table))
2750         return FALSE;
2751
2752       bed = get_elf_backend_data (hash_table->dynobj);
2753
2754       /* Proper resolution for function pointer equality may require
2755          that these symbols perhaps be resolved dynamically, even though
2756          we should be resolving them to the current module.  */
2757       if (!not_local_protected || !bed->is_function_type (h->type))
2758         binding_stays_local_p = TRUE;
2759       break;
2760
2761     default:
2762       break;
2763     }
2764
2765   /* If it isn't defined locally, then clearly it's dynamic.  */
2766   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2767     return TRUE;
2768
2769   /* Otherwise, the symbol is dynamic if binding rules don't tell
2770      us that it remains local.  */
2771   return !binding_stays_local_p;
2772 }
2773
2774 /* Return true if the symbol referred to by H should be considered
2775    to resolve local to the current module, and false otherwise.  Differs
2776    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2777    undefined symbols.  The two functions are virtually identical except
2778    for the place where forced_local and dynindx == -1 are tested.  If
2779    either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2780    the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2781    the symbol is local only for defined symbols.
2782    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2783    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2784    treatment of undefined weak symbols.  For those that do not make
2785    undefined weak symbols dynamic, both functions may return false.  */
2786
2787 bfd_boolean
2788 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2789                               struct bfd_link_info *info,
2790                               bfd_boolean local_protected)
2791 {
2792   const struct elf_backend_data *bed;
2793   struct elf_link_hash_table *hash_table;
2794
2795   /* If it's a local sym, of course we resolve locally.  */
2796   if (h == NULL)
2797     return TRUE;
2798
2799   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2800   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2801       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2802     return TRUE;
2803
2804   /* Common symbols that become definitions don't get the DEF_REGULAR
2805      flag set, so test it first, and don't bail out.  */
2806   if (ELF_COMMON_DEF_P (h))
2807     /* Do nothing.  */;
2808   /* If we don't have a definition in a regular file, then we can't
2809      resolve locally.  The sym is either undefined or dynamic.  */
2810   else if (!h->def_regular)
2811     return FALSE;
2812
2813   /* Forced local symbols resolve locally.  */
2814   if (h->forced_local)
2815     return TRUE;
2816
2817   /* As do non-dynamic symbols.  */
2818   if (h->dynindx == -1)
2819     return TRUE;
2820
2821   /* At this point, we know the symbol is defined and dynamic.  In an
2822      executable it must resolve locally, likewise when building symbolic
2823      shared libraries.  */
2824   if (info->executable || SYMBOLIC_BIND (info, h))
2825     return TRUE;
2826
2827   /* Now deal with defined dynamic symbols in shared libraries.  Ones
2828      with default visibility might not resolve locally.  */
2829   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2830     return FALSE;
2831
2832   hash_table = elf_hash_table (info);
2833   if (!is_elf_hash_table (hash_table))
2834     return TRUE;
2835
2836   bed = get_elf_backend_data (hash_table->dynobj);
2837
2838   /* STV_PROTECTED non-function symbols are local.  */
2839   if (!bed->is_function_type (h->type))
2840     return TRUE;
2841
2842   /* Function pointer equality tests may require that STV_PROTECTED
2843      symbols be treated as dynamic symbols.  If the address of a
2844      function not defined in an executable is set to that function's
2845      plt entry in the executable, then the address of the function in
2846      a shared library must also be the plt entry in the executable.  */
2847   return local_protected;
2848 }
2849
2850 /* Caches some TLS segment info, and ensures that the TLS segment vma is
2851    aligned.  Returns the first TLS output section.  */
2852
2853 struct bfd_section *
2854 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2855 {
2856   struct bfd_section *sec, *tls;
2857   unsigned int align = 0;
2858
2859   for (sec = obfd->sections; sec != NULL; sec = sec->next)
2860     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2861       break;
2862   tls = sec;
2863
2864   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2865     if (sec->alignment_power > align)
2866       align = sec->alignment_power;
2867
2868   elf_hash_table (info)->tls_sec = tls;
2869
2870   /* Ensure the alignment of the first section is the largest alignment,
2871      so that the tls segment starts aligned.  */
2872   if (tls != NULL)
2873     tls->alignment_power = align;
2874
2875   return tls;
2876 }
2877
2878 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
2879 static bfd_boolean
2880 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2881                                   Elf_Internal_Sym *sym)
2882 {
2883   const struct elf_backend_data *bed;
2884
2885   /* Local symbols do not count, but target specific ones might.  */
2886   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2887       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2888     return FALSE;
2889
2890   bed = get_elf_backend_data (abfd);
2891   /* Function symbols do not count.  */
2892   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2893     return FALSE;
2894
2895   /* If the section is undefined, then so is the symbol.  */
2896   if (sym->st_shndx == SHN_UNDEF)
2897     return FALSE;
2898
2899   /* If the symbol is defined in the common section, then
2900      it is a common definition and so does not count.  */
2901   if (bed->common_definition (sym))
2902     return FALSE;
2903
2904   /* If the symbol is in a target specific section then we
2905      must rely upon the backend to tell us what it is.  */
2906   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2907     /* FIXME - this function is not coded yet:
2908
2909        return _bfd_is_global_symbol_definition (abfd, sym);
2910
2911        Instead for now assume that the definition is not global,
2912        Even if this is wrong, at least the linker will behave
2913        in the same way that it used to do.  */
2914     return FALSE;
2915
2916   return TRUE;
2917 }
2918
2919 /* Search the symbol table of the archive element of the archive ABFD
2920    whose archive map contains a mention of SYMDEF, and determine if
2921    the symbol is defined in this element.  */
2922 static bfd_boolean
2923 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2924 {
2925   Elf_Internal_Shdr * hdr;
2926   bfd_size_type symcount;
2927   bfd_size_type extsymcount;
2928   bfd_size_type extsymoff;
2929   Elf_Internal_Sym *isymbuf;
2930   Elf_Internal_Sym *isym;
2931   Elf_Internal_Sym *isymend;
2932   bfd_boolean result;
2933
2934   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2935   if (abfd == NULL)
2936     return FALSE;
2937
2938   if (! bfd_check_format (abfd, bfd_object))
2939     return FALSE;
2940
2941   /* Select the appropriate symbol table.  */
2942   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2943     hdr = &elf_tdata (abfd)->symtab_hdr;
2944   else
2945     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2946
2947   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2948
2949   /* The sh_info field of the symtab header tells us where the
2950      external symbols start.  We don't care about the local symbols.  */
2951   if (elf_bad_symtab (abfd))
2952     {
2953       extsymcount = symcount;
2954       extsymoff = 0;
2955     }
2956   else
2957     {
2958       extsymcount = symcount - hdr->sh_info;
2959       extsymoff = hdr->sh_info;
2960     }
2961
2962   if (extsymcount == 0)
2963     return FALSE;
2964
2965   /* Read in the symbol table.  */
2966   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
2967                                   NULL, NULL, NULL);
2968   if (isymbuf == NULL)
2969     return FALSE;
2970
2971   /* Scan the symbol table looking for SYMDEF.  */
2972   result = FALSE;
2973   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
2974     {
2975       const char *name;
2976
2977       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
2978                                               isym->st_name);
2979       if (name == NULL)
2980         break;
2981
2982       if (strcmp (name, symdef->name) == 0)
2983         {
2984           result = is_global_data_symbol_definition (abfd, isym);
2985           break;
2986         }
2987     }
2988
2989   free (isymbuf);
2990
2991   return result;
2992 }
2993 \f
2994 /* Add an entry to the .dynamic table.  */
2995
2996 bfd_boolean
2997 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
2998                             bfd_vma tag,
2999                             bfd_vma val)
3000 {
3001   struct elf_link_hash_table *hash_table;
3002   const struct elf_backend_data *bed;
3003   asection *s;
3004   bfd_size_type newsize;
3005   bfd_byte *newcontents;
3006   Elf_Internal_Dyn dyn;
3007
3008   hash_table = elf_hash_table (info);
3009   if (! is_elf_hash_table (hash_table))
3010     return FALSE;
3011
3012   bed = get_elf_backend_data (hash_table->dynobj);
3013   s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3014   BFD_ASSERT (s != NULL);
3015
3016   newsize = s->size + bed->s->sizeof_dyn;
3017   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3018   if (newcontents == NULL)
3019     return FALSE;
3020
3021   dyn.d_tag = tag;
3022   dyn.d_un.d_val = val;
3023   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3024
3025   s->size = newsize;
3026   s->contents = newcontents;
3027
3028   return TRUE;
3029 }
3030
3031 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3032    otherwise just check whether one already exists.  Returns -1 on error,
3033    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3034
3035 static int
3036 elf_add_dt_needed_tag (bfd *abfd,
3037                        struct bfd_link_info *info,
3038                        const char *soname,
3039                        bfd_boolean do_it)
3040 {
3041   struct elf_link_hash_table *hash_table;
3042   bfd_size_type strindex;
3043
3044   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3045     return -1;
3046
3047   hash_table = elf_hash_table (info);
3048   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3049   if (strindex == (bfd_size_type) -1)
3050     return -1;
3051
3052   if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
3053     {
3054       asection *sdyn;
3055       const struct elf_backend_data *bed;
3056       bfd_byte *extdyn;
3057
3058       bed = get_elf_backend_data (hash_table->dynobj);
3059       sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3060       if (sdyn != NULL)
3061         for (extdyn = sdyn->contents;
3062              extdyn < sdyn->contents + sdyn->size;
3063              extdyn += bed->s->sizeof_dyn)
3064           {
3065             Elf_Internal_Dyn dyn;
3066
3067             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3068             if (dyn.d_tag == DT_NEEDED
3069                 && dyn.d_un.d_val == strindex)
3070               {
3071                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3072                 return 1;
3073               }
3074           }
3075     }
3076
3077   if (do_it)
3078     {
3079       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3080         return -1;
3081
3082       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3083         return -1;
3084     }
3085   else
3086     /* We were just checking for existence of the tag.  */
3087     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3088
3089   return 0;
3090 }
3091
3092 static bfd_boolean
3093 on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3094 {
3095   for (; needed != NULL; needed = needed->next)
3096     if ((elf_dyn_lib_class (needed->by) & DYN_AS_NEEDED) == 0
3097         && strcmp (soname, needed->name) == 0)
3098       return TRUE;
3099
3100   return FALSE;
3101 }
3102
3103 /* Sort symbol by value, section, and size.  */
3104 static int
3105 elf_sort_symbol (const void *arg1, const void *arg2)
3106 {
3107   const struct elf_link_hash_entry *h1;
3108   const struct elf_link_hash_entry *h2;
3109   bfd_signed_vma vdiff;
3110
3111   h1 = *(const struct elf_link_hash_entry **) arg1;
3112   h2 = *(const struct elf_link_hash_entry **) arg2;
3113   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3114   if (vdiff != 0)
3115     return vdiff > 0 ? 1 : -1;
3116   else
3117     {
3118       long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3119       if (sdiff != 0)
3120         return sdiff > 0 ? 1 : -1;
3121     }
3122   vdiff = h1->size - h2->size;
3123   return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
3124 }
3125
3126 /* This function is used to adjust offsets into .dynstr for
3127    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3128
3129 static bfd_boolean
3130 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3131 {
3132   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3133
3134   if (h->dynindx != -1)
3135     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3136   return TRUE;
3137 }
3138
3139 /* Assign string offsets in .dynstr, update all structures referencing
3140    them.  */
3141
3142 static bfd_boolean
3143 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3144 {
3145   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3146   struct elf_link_local_dynamic_entry *entry;
3147   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3148   bfd *dynobj = hash_table->dynobj;
3149   asection *sdyn;
3150   bfd_size_type size;
3151   const struct elf_backend_data *bed;
3152   bfd_byte *extdyn;
3153
3154   _bfd_elf_strtab_finalize (dynstr);
3155   size = _bfd_elf_strtab_size (dynstr);
3156
3157   bed = get_elf_backend_data (dynobj);
3158   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3159   BFD_ASSERT (sdyn != NULL);
3160
3161   /* Update all .dynamic entries referencing .dynstr strings.  */
3162   for (extdyn = sdyn->contents;
3163        extdyn < sdyn->contents + sdyn->size;
3164        extdyn += bed->s->sizeof_dyn)
3165     {
3166       Elf_Internal_Dyn dyn;
3167
3168       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3169       switch (dyn.d_tag)
3170         {
3171         case DT_STRSZ:
3172           dyn.d_un.d_val = size;
3173           break;
3174         case DT_NEEDED:
3175         case DT_SONAME:
3176         case DT_RPATH:
3177         case DT_RUNPATH:
3178         case DT_FILTER:
3179         case DT_AUXILIARY:
3180         case DT_AUDIT:
3181         case DT_DEPAUDIT:
3182           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3183           break;
3184         default:
3185           continue;
3186         }
3187       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3188     }
3189
3190   /* Now update local dynamic symbols.  */
3191   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3192     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3193                                                   entry->isym.st_name);
3194
3195   /* And the rest of dynamic symbols.  */
3196   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3197
3198   /* Adjust version definitions.  */
3199   if (elf_tdata (output_bfd)->cverdefs)
3200     {
3201       asection *s;
3202       bfd_byte *p;
3203       bfd_size_type i;
3204       Elf_Internal_Verdef def;
3205       Elf_Internal_Verdaux defaux;
3206
3207       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
3208       p = s->contents;
3209       do
3210         {
3211           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3212                                    &def);
3213           p += sizeof (Elf_External_Verdef);
3214           if (def.vd_aux != sizeof (Elf_External_Verdef))
3215             continue;
3216           for (i = 0; i < def.vd_cnt; ++i)
3217             {
3218               _bfd_elf_swap_verdaux_in (output_bfd,
3219                                         (Elf_External_Verdaux *) p, &defaux);
3220               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3221                                                         defaux.vda_name);
3222               _bfd_elf_swap_verdaux_out (output_bfd,
3223                                          &defaux, (Elf_External_Verdaux *) p);
3224               p += sizeof (Elf_External_Verdaux);
3225             }
3226         }
3227       while (def.vd_next);
3228     }
3229
3230   /* Adjust version references.  */
3231   if (elf_tdata (output_bfd)->verref)
3232     {
3233       asection *s;
3234       bfd_byte *p;
3235       bfd_size_type i;
3236       Elf_Internal_Verneed need;
3237       Elf_Internal_Vernaux needaux;
3238
3239       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
3240       p = s->contents;
3241       do
3242         {
3243           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3244                                     &need);
3245           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3246           _bfd_elf_swap_verneed_out (output_bfd, &need,
3247                                      (Elf_External_Verneed *) p);
3248           p += sizeof (Elf_External_Verneed);
3249           for (i = 0; i < need.vn_cnt; ++i)
3250             {
3251               _bfd_elf_swap_vernaux_in (output_bfd,
3252                                         (Elf_External_Vernaux *) p, &needaux);
3253               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3254                                                          needaux.vna_name);
3255               _bfd_elf_swap_vernaux_out (output_bfd,
3256                                          &needaux,
3257                                          (Elf_External_Vernaux *) p);
3258               p += sizeof (Elf_External_Vernaux);
3259             }
3260         }
3261       while (need.vn_next);
3262     }
3263
3264   return TRUE;
3265 }
3266 \f
3267 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3268    The default is to only match when the INPUT and OUTPUT are exactly
3269    the same target.  */
3270
3271 bfd_boolean
3272 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3273                                     const bfd_target *output)
3274 {
3275   return input == output;
3276 }
3277
3278 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3279    This version is used when different targets for the same architecture
3280    are virtually identical.  */
3281
3282 bfd_boolean
3283 _bfd_elf_relocs_compatible (const bfd_target *input,
3284                             const bfd_target *output)
3285 {
3286   const struct elf_backend_data *obed, *ibed;
3287
3288   if (input == output)
3289     return TRUE;
3290
3291   ibed = xvec_get_elf_backend_data (input);
3292   obed = xvec_get_elf_backend_data (output);
3293
3294   if (ibed->arch != obed->arch)
3295     return FALSE;
3296
3297   /* If both backends are using this function, deem them compatible.  */
3298   return ibed->relocs_compatible == obed->relocs_compatible;
3299 }
3300
3301 /* Make a special call to the linker "notice" function to tell it that
3302    we are about to handle an as-needed lib, or have finished
3303    processing the lib.  */ 
3304
3305 bfd_boolean
3306 _bfd_elf_notice_as_needed (bfd *ibfd,
3307                            struct bfd_link_info *info,
3308                            enum notice_asneeded_action act)
3309 {
3310   return (*info->callbacks->notice) (info, NULL, NULL, ibfd, NULL, act, 0);
3311 }
3312
3313 /* Add symbols from an ELF object file to the linker hash table.  */
3314
3315 static bfd_boolean
3316 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3317 {
3318   Elf_Internal_Ehdr *ehdr;
3319   Elf_Internal_Shdr *hdr;
3320   bfd_size_type symcount;
3321   bfd_size_type extsymcount;
3322   bfd_size_type extsymoff;
3323   struct elf_link_hash_entry **sym_hash;
3324   bfd_boolean dynamic;
3325   Elf_External_Versym *extversym = NULL;
3326   Elf_External_Versym *ever;
3327   struct elf_link_hash_entry *weaks;
3328   struct elf_link_hash_entry **nondeflt_vers = NULL;
3329   bfd_size_type nondeflt_vers_cnt = 0;
3330   Elf_Internal_Sym *isymbuf = NULL;
3331   Elf_Internal_Sym *isym;
3332   Elf_Internal_Sym *isymend;
3333   const struct elf_backend_data *bed;
3334   bfd_boolean add_needed;
3335   struct elf_link_hash_table *htab;
3336   bfd_size_type amt;
3337   void *alloc_mark = NULL;
3338   struct bfd_hash_entry **old_table = NULL;
3339   unsigned int old_size = 0;
3340   unsigned int old_count = 0;
3341   void *old_tab = NULL;
3342   void *old_ent;
3343   struct bfd_link_hash_entry *old_undefs = NULL;
3344   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3345   long old_dynsymcount = 0;
3346   bfd_size_type old_dynstr_size = 0;
3347   size_t tabsize = 0;
3348   asection *s;
3349   bfd_boolean just_syms;
3350
3351   htab = elf_hash_table (info);
3352   bed = get_elf_backend_data (abfd);
3353
3354   if ((abfd->flags & DYNAMIC) == 0)
3355     dynamic = FALSE;
3356   else
3357     {
3358       dynamic = TRUE;
3359
3360       /* You can't use -r against a dynamic object.  Also, there's no
3361          hope of using a dynamic object which does not exactly match
3362          the format of the output file.  */
3363       if (info->relocatable
3364           || !is_elf_hash_table (htab)
3365           || info->output_bfd->xvec != abfd->xvec)
3366         {
3367           if (info->relocatable)
3368             bfd_set_error (bfd_error_invalid_operation);
3369           else
3370             bfd_set_error (bfd_error_wrong_format);
3371           goto error_return;
3372         }
3373     }
3374
3375   ehdr = elf_elfheader (abfd);
3376   if (info->warn_alternate_em
3377       && bed->elf_machine_code != ehdr->e_machine
3378       && ((bed->elf_machine_alt1 != 0
3379            && ehdr->e_machine == bed->elf_machine_alt1)
3380           || (bed->elf_machine_alt2 != 0
3381               && ehdr->e_machine == bed->elf_machine_alt2)))
3382     info->callbacks->einfo
3383       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3384        ehdr->e_machine, abfd, bed->elf_machine_code);
3385
3386   /* As a GNU extension, any input sections which are named
3387      .gnu.warning.SYMBOL are treated as warning symbols for the given
3388      symbol.  This differs from .gnu.warning sections, which generate
3389      warnings when they are included in an output file.  */
3390   /* PR 12761: Also generate this warning when building shared libraries.  */
3391   for (s = abfd->sections; s != NULL; s = s->next)
3392     {
3393       const char *name;
3394
3395       name = bfd_get_section_name (abfd, s);
3396       if (CONST_STRNEQ (name, ".gnu.warning."))
3397         {
3398           char *msg;
3399           bfd_size_type sz;
3400
3401           name += sizeof ".gnu.warning." - 1;
3402
3403           /* If this is a shared object, then look up the symbol
3404              in the hash table.  If it is there, and it is already
3405              been defined, then we will not be using the entry
3406              from this shared object, so we don't need to warn.
3407              FIXME: If we see the definition in a regular object
3408              later on, we will warn, but we shouldn't.  The only
3409              fix is to keep track of what warnings we are supposed
3410              to emit, and then handle them all at the end of the
3411              link.  */
3412           if (dynamic)
3413             {
3414               struct elf_link_hash_entry *h;
3415
3416               h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3417
3418               /* FIXME: What about bfd_link_hash_common?  */
3419               if (h != NULL
3420                   && (h->root.type == bfd_link_hash_defined
3421                       || h->root.type == bfd_link_hash_defweak))
3422                 continue;
3423             }
3424
3425           sz = s->size;
3426           msg = (char *) bfd_alloc (abfd, sz + 1);
3427           if (msg == NULL)
3428             goto error_return;
3429
3430           if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3431             goto error_return;
3432
3433           msg[sz] = '\0';
3434
3435           if (! (_bfd_generic_link_add_one_symbol
3436                  (info, abfd, name, BSF_WARNING, s, 0, msg,
3437                   FALSE, bed->collect, NULL)))
3438             goto error_return;
3439
3440           if (!info->relocatable && info->executable)
3441             {
3442               /* Clobber the section size so that the warning does
3443                  not get copied into the output file.  */
3444               s->size = 0;
3445
3446               /* Also set SEC_EXCLUDE, so that symbols defined in
3447                  the warning section don't get copied to the output.  */
3448               s->flags |= SEC_EXCLUDE;
3449             }
3450         }
3451     }
3452
3453   just_syms = ((s = abfd->sections) != NULL
3454                && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS);
3455
3456   add_needed = TRUE;
3457   if (! dynamic)
3458     {
3459       /* If we are creating a shared library, create all the dynamic
3460          sections immediately.  We need to attach them to something,
3461          so we attach them to this BFD, provided it is the right
3462          format and is not from ld --just-symbols.  FIXME: If there
3463          are no input BFD's of the same format as the output, we can't
3464          make a shared library.  */
3465       if (!just_syms
3466           && info->shared
3467           && is_elf_hash_table (htab)
3468           && info->output_bfd->xvec == abfd->xvec
3469           && !htab->dynamic_sections_created)
3470         {
3471           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3472             goto error_return;
3473         }
3474     }
3475   else if (!is_elf_hash_table (htab))
3476     goto error_return;
3477   else
3478     {
3479       const char *soname = NULL;
3480       char *audit = NULL;
3481       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3482       int ret;
3483
3484       /* ld --just-symbols and dynamic objects don't mix very well.
3485          ld shouldn't allow it.  */
3486       if (just_syms)
3487         abort ();
3488
3489       /* If this dynamic lib was specified on the command line with
3490          --as-needed in effect, then we don't want to add a DT_NEEDED
3491          tag unless the lib is actually used.  Similary for libs brought
3492          in by another lib's DT_NEEDED.  When --no-add-needed is used
3493          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3494          any dynamic library in DT_NEEDED tags in the dynamic lib at
3495          all.  */
3496       add_needed = (elf_dyn_lib_class (abfd)
3497                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3498                        | DYN_NO_NEEDED)) == 0;
3499
3500       s = bfd_get_section_by_name (abfd, ".dynamic");
3501       if (s != NULL)
3502         {
3503           bfd_byte *dynbuf;
3504           bfd_byte *extdyn;
3505           unsigned int elfsec;
3506           unsigned long shlink;
3507
3508           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3509             {
3510 error_free_dyn:
3511               free (dynbuf);
3512               goto error_return;
3513             }
3514
3515           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3516           if (elfsec == SHN_BAD)
3517             goto error_free_dyn;
3518           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3519
3520           for (extdyn = dynbuf;
3521                extdyn < dynbuf + s->size;
3522                extdyn += bed->s->sizeof_dyn)
3523             {
3524               Elf_Internal_Dyn dyn;
3525
3526               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3527               if (dyn.d_tag == DT_SONAME)
3528                 {
3529                   unsigned int tagv = dyn.d_un.d_val;
3530                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3531                   if (soname == NULL)
3532                     goto error_free_dyn;
3533                 }
3534               if (dyn.d_tag == DT_NEEDED)
3535                 {
3536                   struct bfd_link_needed_list *n, **pn;
3537                   char *fnm, *anm;
3538                   unsigned int tagv = dyn.d_un.d_val;
3539
3540                   amt = sizeof (struct bfd_link_needed_list);
3541                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3542                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3543                   if (n == NULL || fnm == NULL)
3544                     goto error_free_dyn;
3545                   amt = strlen (fnm) + 1;
3546                   anm = (char *) bfd_alloc (abfd, amt);
3547                   if (anm == NULL)
3548                     goto error_free_dyn;
3549                   memcpy (anm, fnm, amt);
3550                   n->name = anm;
3551                   n->by = abfd;
3552                   n->next = NULL;
3553                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3554                     ;
3555                   *pn = n;
3556                 }
3557               if (dyn.d_tag == DT_RUNPATH)
3558                 {
3559                   struct bfd_link_needed_list *n, **pn;
3560                   char *fnm, *anm;
3561                   unsigned int tagv = dyn.d_un.d_val;
3562
3563                   amt = sizeof (struct bfd_link_needed_list);
3564                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3565                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3566                   if (n == NULL || fnm == NULL)
3567                     goto error_free_dyn;
3568                   amt = strlen (fnm) + 1;
3569                   anm = (char *) bfd_alloc (abfd, amt);
3570                   if (anm == NULL)
3571                     goto error_free_dyn;
3572                   memcpy (anm, fnm, amt);
3573                   n->name = anm;
3574                   n->by = abfd;
3575                   n->next = NULL;
3576                   for (pn = & runpath;
3577                        *pn != NULL;
3578                        pn = &(*pn)->next)
3579                     ;
3580                   *pn = n;
3581                 }
3582               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3583               if (!runpath && dyn.d_tag == DT_RPATH)
3584                 {
3585                   struct bfd_link_needed_list *n, **pn;
3586                   char *fnm, *anm;
3587                   unsigned int tagv = dyn.d_un.d_val;
3588
3589                   amt = sizeof (struct bfd_link_needed_list);
3590                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3591                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3592                   if (n == NULL || fnm == NULL)
3593                     goto error_free_dyn;
3594                   amt = strlen (fnm) + 1;
3595                   anm = (char *) bfd_alloc (abfd, amt);
3596                   if (anm == NULL)
3597                     goto error_free_dyn;
3598                   memcpy (anm, fnm, amt);
3599                   n->name = anm;
3600                   n->by = abfd;
3601                   n->next = NULL;
3602                   for (pn = & rpath;
3603                        *pn != NULL;
3604                        pn = &(*pn)->next)
3605                     ;
3606                   *pn = n;
3607                 }
3608               if (dyn.d_tag == DT_AUDIT)
3609                 {
3610                   unsigned int tagv = dyn.d_un.d_val;
3611                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3612                 }
3613             }
3614
3615           free (dynbuf);
3616         }
3617
3618       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3619          frees all more recently bfd_alloc'd blocks as well.  */
3620       if (runpath)
3621         rpath = runpath;
3622
3623       if (rpath)
3624         {
3625           struct bfd_link_needed_list **pn;
3626           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3627             ;
3628           *pn = rpath;
3629         }
3630
3631       /* We do not want to include any of the sections in a dynamic
3632          object in the output file.  We hack by simply clobbering the
3633          list of sections in the BFD.  This could be handled more
3634          cleanly by, say, a new section flag; the existing
3635          SEC_NEVER_LOAD flag is not the one we want, because that one
3636          still implies that the section takes up space in the output
3637          file.  */
3638       bfd_section_list_clear (abfd);
3639
3640       /* Find the name to use in a DT_NEEDED entry that refers to this
3641          object.  If the object has a DT_SONAME entry, we use it.
3642          Otherwise, if the generic linker stuck something in
3643          elf_dt_name, we use that.  Otherwise, we just use the file
3644          name.  */
3645       if (soname == NULL || *soname == '\0')
3646         {
3647           soname = elf_dt_name (abfd);
3648           if (soname == NULL || *soname == '\0')
3649             soname = bfd_get_filename (abfd);
3650         }
3651
3652       /* Save the SONAME because sometimes the linker emulation code
3653          will need to know it.  */
3654       elf_dt_name (abfd) = soname;
3655
3656       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3657       if (ret < 0)
3658         goto error_return;
3659
3660       /* If we have already included this dynamic object in the
3661          link, just ignore it.  There is no reason to include a
3662          particular dynamic object more than once.  */
3663       if (ret > 0)
3664         return TRUE;
3665
3666       /* Save the DT_AUDIT entry for the linker emulation code. */
3667       elf_dt_audit (abfd) = audit;
3668     }
3669
3670   /* If this is a dynamic object, we always link against the .dynsym
3671      symbol table, not the .symtab symbol table.  The dynamic linker
3672      will only see the .dynsym symbol table, so there is no reason to
3673      look at .symtab for a dynamic object.  */
3674
3675   if (! dynamic || elf_dynsymtab (abfd) == 0)
3676     hdr = &elf_tdata (abfd)->symtab_hdr;
3677   else
3678     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3679
3680   symcount = hdr->sh_size / bed->s->sizeof_sym;
3681
3682   /* The sh_info field of the symtab header tells us where the
3683      external symbols start.  We don't care about the local symbols at
3684      this point.  */
3685   if (elf_bad_symtab (abfd))
3686     {
3687       extsymcount = symcount;
3688       extsymoff = 0;
3689     }
3690   else
3691     {
3692       extsymcount = symcount - hdr->sh_info;
3693       extsymoff = hdr->sh_info;
3694     }
3695
3696   sym_hash = elf_sym_hashes (abfd);
3697   if (extsymcount != 0)
3698     {
3699       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3700                                       NULL, NULL, NULL);
3701       if (isymbuf == NULL)
3702         goto error_return;
3703
3704       if (sym_hash == NULL)
3705         {
3706           /* We store a pointer to the hash table entry for each
3707              external symbol.  */
3708           amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3709           sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
3710           if (sym_hash == NULL)
3711             goto error_free_sym;
3712           elf_sym_hashes (abfd) = sym_hash;
3713         }
3714     }
3715
3716   if (dynamic)
3717     {
3718       /* Read in any version definitions.  */
3719       if (!_bfd_elf_slurp_version_tables (abfd,
3720                                           info->default_imported_symver))
3721         goto error_free_sym;
3722
3723       /* Read in the symbol versions, but don't bother to convert them
3724          to internal format.  */
3725       if (elf_dynversym (abfd) != 0)
3726         {
3727           Elf_Internal_Shdr *versymhdr;
3728
3729           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3730           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3731           if (extversym == NULL)
3732             goto error_free_sym;
3733           amt = versymhdr->sh_size;
3734           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3735               || bfd_bread (extversym, amt, abfd) != amt)
3736             goto error_free_vers;
3737         }
3738     }
3739
3740   /* If we are loading an as-needed shared lib, save the symbol table
3741      state before we start adding symbols.  If the lib turns out
3742      to be unneeded, restore the state.  */
3743   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3744     {
3745       unsigned int i;
3746       size_t entsize;
3747
3748       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3749         {
3750           struct bfd_hash_entry *p;
3751           struct elf_link_hash_entry *h;
3752
3753           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3754             {
3755               h = (struct elf_link_hash_entry *) p;
3756               entsize += htab->root.table.entsize;
3757               if (h->root.type == bfd_link_hash_warning)
3758                 entsize += htab->root.table.entsize;
3759             }
3760         }
3761
3762       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3763       old_tab = bfd_malloc (tabsize + entsize);
3764       if (old_tab == NULL)
3765         goto error_free_vers;
3766
3767       /* Remember the current objalloc pointer, so that all mem for
3768          symbols added can later be reclaimed.  */
3769       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3770       if (alloc_mark == NULL)
3771         goto error_free_vers;
3772
3773       /* Make a special call to the linker "notice" function to
3774          tell it that we are about to handle an as-needed lib.  */
3775       if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed))
3776         goto error_free_vers;
3777
3778       /* Clone the symbol table.  Remember some pointers into the
3779          symbol table, and dynamic symbol count.  */
3780       old_ent = (char *) old_tab + tabsize;
3781       memcpy (old_tab, htab->root.table.table, tabsize);
3782       old_undefs = htab->root.undefs;
3783       old_undefs_tail = htab->root.undefs_tail;
3784       old_table = htab->root.table.table;
3785       old_size = htab->root.table.size;
3786       old_count = htab->root.table.count;
3787       old_dynsymcount = htab->dynsymcount;
3788       old_dynstr_size = _bfd_elf_strtab_size (htab->dynstr);
3789
3790       for (i = 0; i < htab->root.table.size; i++)
3791         {
3792           struct bfd_hash_entry *p;
3793           struct elf_link_hash_entry *h;
3794
3795           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3796             {
3797               memcpy (old_ent, p, htab->root.table.entsize);
3798               old_ent = (char *) old_ent + htab->root.table.entsize;
3799               h = (struct elf_link_hash_entry *) p;
3800               if (h->root.type == bfd_link_hash_warning)
3801                 {
3802                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3803                   old_ent = (char *) old_ent + htab->root.table.entsize;
3804                 }
3805             }
3806         }
3807     }
3808
3809   weaks = NULL;
3810   ever = extversym != NULL ? extversym + extsymoff : NULL;
3811   for (isym = isymbuf, isymend = isymbuf + extsymcount;
3812        isym < isymend;
3813        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3814     {
3815       int bind;
3816       bfd_vma value;
3817       asection *sec, *new_sec;
3818       flagword flags;
3819       const char *name;
3820       struct elf_link_hash_entry *h;
3821       struct elf_link_hash_entry *hi;
3822       bfd_boolean definition;
3823       bfd_boolean size_change_ok;
3824       bfd_boolean type_change_ok;
3825       bfd_boolean new_weakdef;
3826       bfd_boolean new_weak;
3827       bfd_boolean old_weak;
3828       bfd_boolean override;
3829       bfd_boolean common;
3830       unsigned int old_alignment;
3831       bfd *old_bfd;
3832
3833       override = FALSE;
3834
3835       flags = BSF_NO_FLAGS;
3836       sec = NULL;
3837       value = isym->st_value;
3838       common = bed->common_definition (isym);
3839
3840       bind = ELF_ST_BIND (isym->st_info);
3841       switch (bind)
3842         {
3843         case STB_LOCAL:
3844           /* This should be impossible, since ELF requires that all
3845              global symbols follow all local symbols, and that sh_info
3846              point to the first global symbol.  Unfortunately, Irix 5
3847              screws this up.  */
3848           continue;
3849
3850         case STB_GLOBAL:
3851           if (isym->st_shndx != SHN_UNDEF && !common)
3852             flags = BSF_GLOBAL;
3853           break;
3854
3855         case STB_WEAK:
3856           flags = BSF_WEAK;
3857           break;
3858
3859         case STB_GNU_UNIQUE:
3860           flags = BSF_GNU_UNIQUE;
3861           break;
3862
3863         default:
3864           /* Leave it up to the processor backend.  */
3865           break;
3866         }
3867
3868       if (isym->st_shndx == SHN_UNDEF)
3869         sec = bfd_und_section_ptr;
3870       else if (isym->st_shndx == SHN_ABS)
3871         sec = bfd_abs_section_ptr;
3872       else if (isym->st_shndx == SHN_COMMON)
3873         {
3874           sec = bfd_com_section_ptr;
3875           /* What ELF calls the size we call the value.  What ELF
3876              calls the value we call the alignment.  */
3877           value = isym->st_size;
3878         }
3879       else
3880         {
3881           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3882           if (sec == NULL)
3883             sec = bfd_abs_section_ptr;
3884           else if (discarded_section (sec))
3885             {
3886               /* Symbols from discarded section are undefined.  We keep
3887                  its visibility.  */
3888               sec = bfd_und_section_ptr;
3889               isym->st_shndx = SHN_UNDEF;
3890             }
3891           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3892             value -= sec->vma;
3893         }
3894
3895       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3896                                               isym->st_name);
3897       if (name == NULL)
3898         goto error_free_vers;
3899
3900       if (isym->st_shndx == SHN_COMMON
3901           && (abfd->flags & BFD_PLUGIN) != 0)
3902         {
3903           asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3904
3905           if (xc == NULL)
3906             {
3907               flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3908                                  | SEC_EXCLUDE);
3909               xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3910               if (xc == NULL)
3911                 goto error_free_vers;
3912             }
3913           sec = xc;
3914         }
3915       else if (isym->st_shndx == SHN_COMMON
3916                && ELF_ST_TYPE (isym->st_info) == STT_TLS
3917                && !info->relocatable)
3918         {
3919           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3920
3921           if (tcomm == NULL)
3922             {
3923               flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3924                                  | SEC_LINKER_CREATED);
3925               tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3926               if (tcomm == NULL)
3927                 goto error_free_vers;
3928             }
3929           sec = tcomm;
3930         }
3931       else if (bed->elf_add_symbol_hook)
3932         {
3933           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3934                                              &sec, &value))
3935             goto error_free_vers;
3936
3937           /* The hook function sets the name to NULL if this symbol
3938              should be skipped for some reason.  */
3939           if (name == NULL)
3940             continue;
3941         }
3942
3943       /* Sanity check that all possibilities were handled.  */
3944       if (sec == NULL)
3945         {
3946           bfd_set_error (bfd_error_bad_value);
3947           goto error_free_vers;
3948         }
3949
3950       /* Silently discard TLS symbols from --just-syms.  There's
3951          no way to combine a static TLS block with a new TLS block
3952          for this executable.  */
3953       if (ELF_ST_TYPE (isym->st_info) == STT_TLS
3954           && sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3955         continue;
3956
3957       if (bfd_is_und_section (sec)
3958           || bfd_is_com_section (sec))
3959         definition = FALSE;
3960       else
3961         definition = TRUE;
3962
3963       size_change_ok = FALSE;
3964       type_change_ok = bed->type_change_ok;
3965       old_weak = FALSE;
3966       old_alignment = 0;
3967       old_bfd = NULL;
3968       new_sec = sec;
3969
3970       if (is_elf_hash_table (htab))
3971         {
3972           Elf_Internal_Versym iver;
3973           unsigned int vernum = 0;
3974           bfd_boolean skip;
3975
3976           if (ever == NULL)
3977             {
3978               if (info->default_imported_symver)
3979                 /* Use the default symbol version created earlier.  */
3980                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
3981               else
3982                 iver.vs_vers = 0;
3983             }
3984           else
3985             _bfd_elf_swap_versym_in (abfd, ever, &iver);
3986
3987           vernum = iver.vs_vers & VERSYM_VERSION;
3988
3989           /* If this is a hidden symbol, or if it is not version
3990              1, we append the version name to the symbol name.
3991              However, we do not modify a non-hidden absolute symbol
3992              if it is not a function, because it might be the version
3993              symbol itself.  FIXME: What if it isn't?  */
3994           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
3995               || (vernum > 1
3996                   && (!bfd_is_abs_section (sec)
3997                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
3998             {
3999               const char *verstr;
4000               size_t namelen, verlen, newlen;
4001               char *newname, *p;
4002
4003               if (isym->st_shndx != SHN_UNDEF)
4004                 {
4005                   if (vernum > elf_tdata (abfd)->cverdefs)
4006                     verstr = NULL;
4007                   else if (vernum > 1)
4008                     verstr =
4009                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4010                   else
4011                     verstr = "";
4012
4013                   if (verstr == NULL)
4014                     {
4015                       (*_bfd_error_handler)
4016                         (_("%B: %s: invalid version %u (max %d)"),
4017                          abfd, name, vernum,
4018                          elf_tdata (abfd)->cverdefs);
4019                       bfd_set_error (bfd_error_bad_value);
4020                       goto error_free_vers;
4021                     }
4022                 }
4023               else
4024                 {
4025                   /* We cannot simply test for the number of
4026                      entries in the VERNEED section since the
4027                      numbers for the needed versions do not start
4028                      at 0.  */
4029                   Elf_Internal_Verneed *t;
4030
4031                   verstr = NULL;
4032                   for (t = elf_tdata (abfd)->verref;
4033                        t != NULL;
4034                        t = t->vn_nextref)
4035                     {
4036                       Elf_Internal_Vernaux *a;
4037
4038                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4039                         {
4040                           if (a->vna_other == vernum)
4041                             {
4042                               verstr = a->vna_nodename;
4043                               break;
4044                             }
4045                         }
4046                       if (a != NULL)
4047                         break;
4048                     }
4049                   if (verstr == NULL)
4050                     {
4051                       (*_bfd_error_handler)
4052                         (_("%B: %s: invalid needed version %d"),
4053                          abfd, name, vernum);
4054                       bfd_set_error (bfd_error_bad_value);
4055                       goto error_free_vers;
4056                     }
4057                 }
4058
4059               namelen = strlen (name);
4060               verlen = strlen (verstr);
4061               newlen = namelen + verlen + 2;
4062               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4063                   && isym->st_shndx != SHN_UNDEF)
4064                 ++newlen;
4065
4066               newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4067               if (newname == NULL)
4068                 goto error_free_vers;
4069               memcpy (newname, name, namelen);
4070               p = newname + namelen;
4071               *p++ = ELF_VER_CHR;
4072               /* If this is a defined non-hidden version symbol,
4073                  we add another @ to the name.  This indicates the
4074                  default version of the symbol.  */
4075               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4076                   && isym->st_shndx != SHN_UNDEF)
4077                 *p++ = ELF_VER_CHR;
4078               memcpy (p, verstr, verlen + 1);
4079
4080               name = newname;
4081             }
4082
4083           /* If this symbol has default visibility and the user has
4084              requested we not re-export it, then mark it as hidden.  */
4085           if (definition
4086               && !dynamic
4087               && abfd->no_export
4088               && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
4089             isym->st_other = (STV_HIDDEN
4090                               | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
4091
4092           if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
4093                                       sym_hash, &old_bfd, &old_weak,
4094                                       &old_alignment, &skip, &override,
4095                                       &type_change_ok, &size_change_ok))
4096             goto error_free_vers;
4097
4098           if (skip)
4099             continue;
4100
4101           if (override)
4102             definition = FALSE;
4103
4104           h = *sym_hash;
4105           while (h->root.type == bfd_link_hash_indirect
4106                  || h->root.type == bfd_link_hash_warning)
4107             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4108
4109           if (elf_tdata (abfd)->verdef != NULL
4110               && vernum > 1
4111               && definition)
4112             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4113         }
4114
4115       if (! (_bfd_generic_link_add_one_symbol
4116              (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4117               (struct bfd_link_hash_entry **) sym_hash)))
4118         goto error_free_vers;
4119
4120       h = *sym_hash;
4121       /* We need to make sure that indirect symbol dynamic flags are
4122          updated.  */
4123       hi = h;
4124       while (h->root.type == bfd_link_hash_indirect
4125              || h->root.type == bfd_link_hash_warning)
4126         h = (struct elf_link_hash_entry *) h->root.u.i.link;
4127
4128       *sym_hash = h;
4129
4130       new_weak = (flags & BSF_WEAK) != 0;
4131       new_weakdef = FALSE;
4132       if (dynamic
4133           && definition
4134           && new_weak
4135           && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4136           && is_elf_hash_table (htab)
4137           && h->u.weakdef == NULL)
4138         {
4139           /* Keep a list of all weak defined non function symbols from
4140              a dynamic object, using the weakdef field.  Later in this
4141              function we will set the weakdef field to the correct
4142              value.  We only put non-function symbols from dynamic
4143              objects on this list, because that happens to be the only
4144              time we need to know the normal symbol corresponding to a
4145              weak symbol, and the information is time consuming to
4146              figure out.  If the weakdef field is not already NULL,
4147              then this symbol was already defined by some previous
4148              dynamic object, and we will be using that previous
4149              definition anyhow.  */
4150
4151           h->u.weakdef = weaks;
4152           weaks = h;
4153           new_weakdef = TRUE;
4154         }
4155
4156       /* Set the alignment of a common symbol.  */
4157       if ((common || bfd_is_com_section (sec))
4158           && h->root.type == bfd_link_hash_common)
4159         {
4160           unsigned int align;
4161
4162           if (common)
4163             align = bfd_log2 (isym->st_value);
4164           else
4165             {
4166               /* The new symbol is a common symbol in a shared object.
4167                  We need to get the alignment from the section.  */
4168               align = new_sec->alignment_power;
4169             }
4170           if (align > old_alignment)
4171             h->root.u.c.p->alignment_power = align;
4172           else
4173             h->root.u.c.p->alignment_power = old_alignment;
4174         }
4175
4176       if (is_elf_hash_table (htab))
4177         {
4178           /* Set a flag in the hash table entry indicating the type of
4179              reference or definition we just found.  A dynamic symbol
4180              is one which is referenced or defined by both a regular
4181              object and a shared object.  */
4182           bfd_boolean dynsym = FALSE;
4183
4184           /* Plugin symbols aren't normal.  Don't set def_regular or
4185              ref_regular for them, or make them dynamic.  */
4186           if ((abfd->flags & BFD_PLUGIN) != 0)
4187             ;
4188           else if (! dynamic)
4189             {
4190               if (! definition)
4191                 {
4192                   h->ref_regular = 1;
4193                   if (bind != STB_WEAK)
4194                     h->ref_regular_nonweak = 1;
4195                 }
4196               else
4197                 {
4198                   h->def_regular = 1;
4199                   if (h->def_dynamic)
4200                     {
4201                       h->def_dynamic = 0;
4202                       h->ref_dynamic = 1;
4203                     }
4204                 }
4205
4206               /* If the indirect symbol has been forced local, don't
4207                  make the real symbol dynamic.  */
4208               if ((h == hi || !hi->forced_local)
4209                   && (! info->executable
4210                       || h->def_dynamic
4211                       || h->ref_dynamic))
4212                 dynsym = TRUE;
4213             }
4214           else
4215             {
4216               if (! definition)
4217                 {
4218                   h->ref_dynamic = 1;
4219                   hi->ref_dynamic = 1;
4220                 }
4221               else
4222                 {
4223                   h->def_dynamic = 1;
4224                   hi->def_dynamic = 1;
4225                 }
4226
4227               /* If the indirect symbol has been forced local, don't
4228                  make the real symbol dynamic.  */
4229               if ((h == hi || !hi->forced_local)
4230                   && (h->def_regular
4231                       || h->ref_regular
4232                       || (h->u.weakdef != NULL
4233                           && ! new_weakdef
4234                           && h->u.weakdef->dynindx != -1)))
4235                 dynsym = TRUE;
4236             }
4237
4238           /* Check to see if we need to add an indirect symbol for
4239              the default name.  */
4240           if (definition
4241               || (!override && h->root.type == bfd_link_hash_common))
4242             if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4243                                               sec, value, &old_bfd, &dynsym))
4244               goto error_free_vers;
4245
4246           /* Check the alignment when a common symbol is involved. This
4247              can change when a common symbol is overridden by a normal
4248              definition or a common symbol is ignored due to the old
4249              normal definition. We need to make sure the maximum
4250              alignment is maintained.  */
4251           if ((old_alignment || common)
4252               && h->root.type != bfd_link_hash_common)
4253             {
4254               unsigned int common_align;
4255               unsigned int normal_align;
4256               unsigned int symbol_align;
4257               bfd *normal_bfd;
4258               bfd *common_bfd;
4259
4260               BFD_ASSERT (h->root.type == bfd_link_hash_defined
4261                           || h->root.type == bfd_link_hash_defweak);
4262
4263               symbol_align = ffs (h->root.u.def.value) - 1;
4264               if (h->root.u.def.section->owner != NULL
4265                   && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4266                 {
4267                   normal_align = h->root.u.def.section->alignment_power;
4268                   if (normal_align > symbol_align)
4269                     normal_align = symbol_align;
4270                 }
4271               else
4272                 normal_align = symbol_align;
4273
4274               if (old_alignment)
4275                 {
4276                   common_align = old_alignment;
4277                   common_bfd = old_bfd;
4278                   normal_bfd = abfd;
4279                 }
4280               else
4281                 {
4282                   common_align = bfd_log2 (isym->st_value);
4283                   common_bfd = abfd;
4284                   normal_bfd = old_bfd;
4285                 }
4286
4287               if (normal_align < common_align)
4288                 {
4289                   /* PR binutils/2735 */
4290                   if (normal_bfd == NULL)
4291                     (*_bfd_error_handler)
4292                       (_("Warning: alignment %u of common symbol `%s' in %B is"
4293                          " greater than the alignment (%u) of its section %A"),
4294                        common_bfd, h->root.u.def.section,
4295                        1 << common_align, name, 1 << normal_align);
4296                   else
4297                     (*_bfd_error_handler)
4298                       (_("Warning: alignment %u of symbol `%s' in %B"
4299                          " is smaller than %u in %B"),
4300                        normal_bfd, common_bfd,
4301                        1 << normal_align, name, 1 << common_align);
4302                 }
4303             }
4304
4305           /* Remember the symbol size if it isn't undefined.  */
4306           if (isym->st_size != 0
4307               && isym->st_shndx != SHN_UNDEF
4308               && (definition || h->size == 0))
4309             {
4310               if (h->size != 0
4311                   && h->size != isym->st_size
4312                   && ! size_change_ok)
4313                 (*_bfd_error_handler)
4314                   (_("Warning: size of symbol `%s' changed"
4315                      " from %lu in %B to %lu in %B"),
4316                    old_bfd, abfd,
4317                    name, (unsigned long) h->size,
4318                    (unsigned long) isym->st_size);
4319
4320               h->size = isym->st_size;
4321             }
4322
4323           /* If this is a common symbol, then we always want H->SIZE
4324              to be the size of the common symbol.  The code just above
4325              won't fix the size if a common symbol becomes larger.  We
4326              don't warn about a size change here, because that is
4327              covered by --warn-common.  Allow changes between different
4328              function types.  */
4329           if (h->root.type == bfd_link_hash_common)
4330             h->size = h->root.u.c.size;
4331
4332           if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4333               && ((definition && !new_weak)
4334                   || (old_weak && h->root.type == bfd_link_hash_common)
4335                   || h->type == STT_NOTYPE))
4336             {
4337               unsigned int type = ELF_ST_TYPE (isym->st_info);
4338
4339               /* Turn an IFUNC symbol from a DSO into a normal FUNC
4340                  symbol.  */
4341               if (type == STT_GNU_IFUNC
4342                   && (abfd->flags & DYNAMIC) != 0)
4343                 type = STT_FUNC;
4344
4345               if (h->type != type)
4346                 {
4347                   if (h->type != STT_NOTYPE && ! type_change_ok)
4348                     (*_bfd_error_handler)
4349                       (_("Warning: type of symbol `%s' changed"
4350                          " from %d to %d in %B"),
4351                        abfd, name, h->type, type);
4352
4353                   h->type = type;
4354                 }
4355             }
4356
4357           /* Merge st_other field.  */
4358           elf_merge_st_other (abfd, h, isym, definition, dynamic);
4359
4360           /* We don't want to make debug symbol dynamic.  */
4361           if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4362             dynsym = FALSE;
4363
4364           /* Nor should we make plugin symbols dynamic.  */
4365           if ((abfd->flags & BFD_PLUGIN) != 0)
4366             dynsym = FALSE;
4367
4368           if (definition)
4369             {
4370               h->target_internal = isym->st_target_internal;
4371               h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4372             }
4373
4374           if (definition && !dynamic)
4375             {
4376               char *p = strchr (name, ELF_VER_CHR);
4377               if (p != NULL && p[1] != ELF_VER_CHR)
4378                 {
4379                   /* Queue non-default versions so that .symver x, x@FOO
4380                      aliases can be checked.  */
4381                   if (!nondeflt_vers)
4382                     {
4383                       amt = ((isymend - isym + 1)
4384                              * sizeof (struct elf_link_hash_entry *));
4385                       nondeflt_vers
4386                         = (struct elf_link_hash_entry **) bfd_malloc (amt);
4387                       if (!nondeflt_vers)
4388                         goto error_free_vers;
4389                     }
4390                   nondeflt_vers[nondeflt_vers_cnt++] = h;
4391                 }
4392             }
4393
4394           if (dynsym && h->dynindx == -1)
4395             {
4396               if (! bfd_elf_link_record_dynamic_symbol (info, h))
4397                 goto error_free_vers;
4398               if (h->u.weakdef != NULL
4399                   && ! new_weakdef
4400                   && h->u.weakdef->dynindx == -1)
4401                 {
4402                   if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4403                     goto error_free_vers;
4404                 }
4405             }
4406           else if (dynsym && h->dynindx != -1)
4407             /* If the symbol already has a dynamic index, but
4408                visibility says it should not be visible, turn it into
4409                a local symbol.  */
4410             switch (ELF_ST_VISIBILITY (h->other))
4411               {
4412               case STV_INTERNAL:
4413               case STV_HIDDEN:
4414                 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4415                 dynsym = FALSE;
4416                 break;
4417               }
4418
4419           /* Don't add DT_NEEDED for references from the dummy bfd.  */
4420           if (!add_needed
4421               && definition
4422               && ((dynsym
4423                    && h->ref_regular_nonweak
4424                    && (old_bfd == NULL
4425                        || (old_bfd->flags & BFD_PLUGIN) == 0))
4426                   || (h->ref_dynamic_nonweak
4427                       && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4428                       && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4429             {
4430               int ret;
4431               const char *soname = elf_dt_name (abfd);
4432
4433               info->callbacks->minfo ("%!", soname, old_bfd,
4434                                       h->root.root.string);
4435
4436               /* A symbol from a library loaded via DT_NEEDED of some
4437                  other library is referenced by a regular object.
4438                  Add a DT_NEEDED entry for it.  Issue an error if
4439                  --no-add-needed is used and the reference was not
4440                  a weak one.  */
4441               if (old_bfd != NULL
4442                   && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4443                 {
4444                   (*_bfd_error_handler)
4445                     (_("%B: undefined reference to symbol '%s'"),
4446                      old_bfd, name);
4447                   bfd_set_error (bfd_error_missing_dso);
4448                   goto error_free_vers;
4449                 }
4450
4451               elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4452                 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4453
4454               add_needed = TRUE;
4455               ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4456               if (ret < 0)
4457                 goto error_free_vers;
4458
4459               BFD_ASSERT (ret == 0);
4460             }
4461         }
4462     }
4463
4464   if (extversym != NULL)
4465     {
4466       free (extversym);
4467       extversym = NULL;
4468     }
4469
4470   if (isymbuf != NULL)
4471     {
4472       free (isymbuf);
4473       isymbuf = NULL;
4474     }
4475
4476   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4477     {
4478       unsigned int i;
4479
4480       /* Restore the symbol table.  */
4481       old_ent = (char *) old_tab + tabsize;
4482       memset (elf_sym_hashes (abfd), 0,
4483               extsymcount * sizeof (struct elf_link_hash_entry *));
4484       htab->root.table.table = old_table;
4485       htab->root.table.size = old_size;
4486       htab->root.table.count = old_count;
4487       memcpy (htab->root.table.table, old_tab, tabsize);
4488       htab->root.undefs = old_undefs;
4489       htab->root.undefs_tail = old_undefs_tail;
4490       _bfd_elf_strtab_restore_size (htab->dynstr, old_dynstr_size);
4491       for (i = 0; i < htab->root.table.size; i++)
4492         {
4493           struct bfd_hash_entry *p;
4494           struct elf_link_hash_entry *h;
4495           bfd_size_type size;
4496           unsigned int alignment_power;
4497
4498           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4499             {
4500               h = (struct elf_link_hash_entry *) p;
4501               if (h->root.type == bfd_link_hash_warning)
4502                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4503               if (h->dynindx >= old_dynsymcount
4504                   && h->dynstr_index < old_dynstr_size)
4505                 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4506
4507               /* Preserve the maximum alignment and size for common
4508                  symbols even if this dynamic lib isn't on DT_NEEDED
4509                  since it can still be loaded at run time by another
4510                  dynamic lib.  */
4511               if (h->root.type == bfd_link_hash_common)
4512                 {
4513                   size = h->root.u.c.size;
4514                   alignment_power = h->root.u.c.p->alignment_power;
4515                 }
4516               else
4517                 {
4518                   size = 0;
4519                   alignment_power = 0;
4520                 }
4521               memcpy (p, old_ent, htab->root.table.entsize);
4522               old_ent = (char *) old_ent + htab->root.table.entsize;
4523               h = (struct elf_link_hash_entry *) p;
4524               if (h->root.type == bfd_link_hash_warning)
4525                 {
4526                   memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4527                   old_ent = (char *) old_ent + htab->root.table.entsize;
4528                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
4529                 }
4530               if (h->root.type == bfd_link_hash_common)
4531                 {
4532                   if (size > h->root.u.c.size)
4533                     h->root.u.c.size = size;
4534                   if (alignment_power > h->root.u.c.p->alignment_power)
4535                     h->root.u.c.p->alignment_power = alignment_power;
4536                 }
4537             }
4538         }
4539
4540       /* Make a special call to the linker "notice" function to
4541          tell it that symbols added for crefs may need to be removed.  */
4542       if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed))
4543         goto error_free_vers;
4544
4545       free (old_tab);
4546       objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4547                            alloc_mark);
4548       if (nondeflt_vers != NULL)
4549         free (nondeflt_vers);
4550       return TRUE;
4551     }
4552
4553   if (old_tab != NULL)
4554     {
4555       if (!(*bed->notice_as_needed) (abfd, info, notice_needed))
4556         goto error_free_vers;
4557       free (old_tab);
4558       old_tab = NULL;
4559     }
4560
4561   /* Now that all the symbols from this input file are created, handle
4562      .symver foo, foo@BAR such that any relocs against foo become foo@BAR.  */
4563   if (nondeflt_vers != NULL)
4564     {
4565       bfd_size_type cnt, symidx;
4566
4567       for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4568         {
4569           struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4570           char *shortname, *p;
4571
4572           p = strchr (h->root.root.string, ELF_VER_CHR);
4573           if (p == NULL
4574               || (h->root.type != bfd_link_hash_defined
4575                   && h->root.type != bfd_link_hash_defweak))
4576             continue;
4577
4578           amt = p - h->root.root.string;
4579           shortname = (char *) bfd_malloc (amt + 1);
4580           if (!shortname)
4581             goto error_free_vers;
4582           memcpy (shortname, h->root.root.string, amt);
4583           shortname[amt] = '\0';
4584
4585           hi = (struct elf_link_hash_entry *)
4586                bfd_link_hash_lookup (&htab->root, shortname,
4587                                      FALSE, FALSE, FALSE);
4588           if (hi != NULL
4589               && hi->root.type == h->root.type
4590               && hi->root.u.def.value == h->root.u.def.value
4591               && hi->root.u.def.section == h->root.u.def.section)
4592             {
4593               (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4594               hi->root.type = bfd_link_hash_indirect;
4595               hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4596               (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4597               sym_hash = elf_sym_hashes (abfd);
4598               if (sym_hash)
4599                 for (symidx = 0; symidx < extsymcount; ++symidx)
4600                   if (sym_hash[symidx] == hi)
4601                     {
4602                       sym_hash[symidx] = h;
4603                       break;
4604                     }
4605             }
4606           free (shortname);
4607         }
4608       free (nondeflt_vers);
4609       nondeflt_vers = NULL;
4610     }
4611
4612   /* Now set the weakdefs field correctly for all the weak defined
4613      symbols we found.  The only way to do this is to search all the
4614      symbols.  Since we only need the information for non functions in
4615      dynamic objects, that's the only time we actually put anything on
4616      the list WEAKS.  We need this information so that if a regular
4617      object refers to a symbol defined weakly in a dynamic object, the
4618      real symbol in the dynamic object is also put in the dynamic
4619      symbols; we also must arrange for both symbols to point to the
4620      same memory location.  We could handle the general case of symbol
4621      aliasing, but a general symbol alias can only be generated in
4622      assembler code, handling it correctly would be very time
4623      consuming, and other ELF linkers don't handle general aliasing
4624      either.  */
4625   if (weaks != NULL)
4626     {
4627       struct elf_link_hash_entry **hpp;
4628       struct elf_link_hash_entry **hppend;
4629       struct elf_link_hash_entry **sorted_sym_hash;
4630       struct elf_link_hash_entry *h;
4631       size_t sym_count;
4632
4633       /* Since we have to search the whole symbol list for each weak
4634          defined symbol, search time for N weak defined symbols will be
4635          O(N^2). Binary search will cut it down to O(NlogN).  */
4636       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4637       sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4638       if (sorted_sym_hash == NULL)
4639         goto error_return;
4640       sym_hash = sorted_sym_hash;
4641       hpp = elf_sym_hashes (abfd);
4642       hppend = hpp + extsymcount;
4643       sym_count = 0;
4644       for (; hpp < hppend; hpp++)
4645         {
4646           h = *hpp;
4647           if (h != NULL
4648               && h->root.type == bfd_link_hash_defined
4649               && !bed->is_function_type (h->type))
4650             {
4651               *sym_hash = h;
4652               sym_hash++;
4653               sym_count++;
4654             }
4655         }
4656
4657       qsort (sorted_sym_hash, sym_count,
4658              sizeof (struct elf_link_hash_entry *),
4659              elf_sort_symbol);
4660
4661       while (weaks != NULL)
4662         {
4663           struct elf_link_hash_entry *hlook;
4664           asection *slook;
4665           bfd_vma vlook;
4666           size_t i, j, idx = 0;
4667
4668           hlook = weaks;
4669           weaks = hlook->u.weakdef;
4670           hlook->u.weakdef = NULL;
4671
4672           BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4673                       || hlook->root.type == bfd_link_hash_defweak
4674                       || hlook->root.type == bfd_link_hash_common
4675                       || hlook->root.type == bfd_link_hash_indirect);
4676           slook = hlook->root.u.def.section;
4677           vlook = hlook->root.u.def.value;
4678
4679           i = 0;
4680           j = sym_count;
4681           while (i != j)
4682             {
4683               bfd_signed_vma vdiff;
4684               idx = (i + j) / 2;
4685               h = sorted_sym_hash[idx];
4686               vdiff = vlook - h->root.u.def.value;
4687               if (vdiff < 0)
4688                 j = idx;
4689               else if (vdiff > 0)
4690                 i = idx + 1;
4691               else
4692                 {
4693                   long sdiff = slook->id - h->root.u.def.section->id;
4694                   if (sdiff < 0)
4695                     j = idx;
4696                   else if (sdiff > 0)
4697                     i = idx + 1;
4698                   else
4699                     break;
4700                 }
4701             }
4702
4703           /* We didn't find a value/section match.  */
4704           if (i == j)
4705             continue;
4706
4707           /* With multiple aliases, or when the weak symbol is already
4708              strongly defined, we have multiple matching symbols and
4709              the binary search above may land on any of them.  Step
4710              one past the matching symbol(s).  */
4711           while (++idx != j)
4712             {
4713               h = sorted_sym_hash[idx];
4714               if (h->root.u.def.section != slook
4715                   || h->root.u.def.value != vlook)
4716                 break;
4717             }
4718
4719           /* Now look back over the aliases.  Since we sorted by size
4720              as well as value and section, we'll choose the one with
4721              the largest size.  */
4722           while (idx-- != i)
4723             {
4724               h = sorted_sym_hash[idx];
4725
4726               /* Stop if value or section doesn't match.  */
4727               if (h->root.u.def.section != slook
4728                   || h->root.u.def.value != vlook)
4729                 break;
4730               else if (h != hlook)
4731                 {
4732                   hlook->u.weakdef = h;
4733
4734                   /* If the weak definition is in the list of dynamic
4735                      symbols, make sure the real definition is put
4736                      there as well.  */
4737                   if (hlook->dynindx != -1 && h->dynindx == -1)
4738                     {
4739                       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4740                         {
4741                         err_free_sym_hash:
4742                           free (sorted_sym_hash);
4743                           goto error_return;
4744                         }
4745                     }
4746
4747                   /* If the real definition is in the list of dynamic
4748                      symbols, make sure the weak definition is put
4749                      there as well.  If we don't do this, then the
4750                      dynamic loader might not merge the entries for the
4751                      real definition and the weak definition.  */
4752                   if (h->dynindx != -1 && hlook->dynindx == -1)
4753                     {
4754                       if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4755                         goto err_free_sym_hash;
4756                     }
4757                   break;
4758                 }
4759             }
4760         }
4761
4762       free (sorted_sym_hash);
4763     }
4764
4765   if (bed->check_directives
4766       && !(*bed->check_directives) (abfd, info))
4767     return FALSE;
4768
4769   /* If this object is the same format as the output object, and it is
4770      not a shared library, then let the backend look through the
4771      relocs.
4772
4773      This is required to build global offset table entries and to
4774      arrange for dynamic relocs.  It is not required for the
4775      particular common case of linking non PIC code, even when linking
4776      against shared libraries, but unfortunately there is no way of
4777      knowing whether an object file has been compiled PIC or not.
4778      Looking through the relocs is not particularly time consuming.
4779      The problem is that we must either (1) keep the relocs in memory,
4780      which causes the linker to require additional runtime memory or
4781      (2) read the relocs twice from the input file, which wastes time.
4782      This would be a good case for using mmap.
4783
4784      I have no idea how to handle linking PIC code into a file of a
4785      different format.  It probably can't be done.  */
4786   if (! dynamic
4787       && is_elf_hash_table (htab)
4788       && bed->check_relocs != NULL
4789       && elf_object_id (abfd) == elf_hash_table_id (htab)
4790       && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4791     {
4792       asection *o;
4793
4794       for (o = abfd->sections; o != NULL; o = o->next)
4795         {
4796           Elf_Internal_Rela *internal_relocs;
4797           bfd_boolean ok;
4798
4799           if ((o->flags & SEC_RELOC) == 0
4800               || o->reloc_count == 0
4801               || ((info->strip == strip_all || info->strip == strip_debugger)
4802                   && (o->flags & SEC_DEBUGGING) != 0)
4803               || bfd_is_abs_section (o->output_section))
4804             continue;
4805
4806           internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4807                                                        info->keep_memory);
4808           if (internal_relocs == NULL)
4809             goto error_return;
4810
4811           ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4812
4813           if (elf_section_data (o)->relocs != internal_relocs)
4814             free (internal_relocs);
4815
4816           if (! ok)
4817             goto error_return;
4818         }
4819     }
4820
4821   /* If this is a non-traditional link, try to optimize the handling
4822      of the .stab/.stabstr sections.  */
4823   if (! dynamic
4824       && ! info->traditional_format
4825       && is_elf_hash_table (htab)
4826       && (info->strip != strip_all && info->strip != strip_debugger))
4827     {
4828       asection *stabstr;
4829
4830       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4831       if (stabstr != NULL)
4832         {
4833           bfd_size_type string_offset = 0;
4834           asection *stab;
4835
4836           for (stab = abfd->sections; stab; stab = stab->next)
4837             if (CONST_STRNEQ (stab->name, ".stab")
4838                 && (!stab->name[5] ||
4839                     (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4840                 && (stab->flags & SEC_MERGE) == 0
4841                 && !bfd_is_abs_section (stab->output_section))
4842               {
4843                 struct bfd_elf_section_data *secdata;
4844
4845                 secdata = elf_section_data (stab);
4846                 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4847                                                stabstr, &secdata->sec_info,
4848                                                &string_offset))
4849                   goto error_return;
4850                 if (secdata->sec_info)
4851                   stab->sec_info_type = SEC_INFO_TYPE_STABS;
4852             }
4853         }
4854     }
4855
4856   if (is_elf_hash_table (htab) && add_needed)
4857     {
4858       /* Add this bfd to the loaded list.  */
4859       struct elf_link_loaded_list *n;
4860
4861       n = (struct elf_link_loaded_list *) bfd_alloc (abfd, sizeof (*n));
4862       if (n == NULL)
4863         goto error_return;
4864       n->abfd = abfd;
4865       n->next = htab->loaded;
4866       htab->loaded = n;
4867     }
4868
4869   return TRUE;
4870
4871  error_free_vers:
4872   if (old_tab != NULL)
4873     free (old_tab);
4874   if (nondeflt_vers != NULL)
4875     free (nondeflt_vers);
4876   if (extversym != NULL)
4877     free (extversym);
4878  error_free_sym:
4879   if (isymbuf != NULL)
4880     free (isymbuf);
4881  error_return:
4882   return FALSE;
4883 }
4884
4885 /* Return the linker hash table entry of a symbol that might be
4886    satisfied by an archive symbol.  Return -1 on error.  */
4887
4888 struct elf_link_hash_entry *
4889 _bfd_elf_archive_symbol_lookup (bfd *abfd,
4890                                 struct bfd_link_info *info,
4891                                 const char *name)
4892 {
4893   struct elf_link_hash_entry *h;
4894   char *p, *copy;
4895   size_t len, first;
4896
4897   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
4898   if (h != NULL)
4899     return h;
4900
4901   /* If this is a default version (the name contains @@), look up the
4902      symbol again with only one `@' as well as without the version.
4903      The effect is that references to the symbol with and without the
4904      version will be matched by the default symbol in the archive.  */
4905
4906   p = strchr (name, ELF_VER_CHR);
4907   if (p == NULL || p[1] != ELF_VER_CHR)
4908     return h;
4909
4910   /* First check with only one `@'.  */
4911   len = strlen (name);
4912   copy = (char *) bfd_alloc (abfd, len);
4913   if (copy == NULL)
4914     return (struct elf_link_hash_entry *) 0 - 1;
4915
4916   first = p - name + 1;
4917   memcpy (copy, name, first);
4918   memcpy (copy + first, name + first + 1, len - first);
4919
4920   h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
4921   if (h == NULL)
4922     {
4923       /* We also need to check references to the symbol without the
4924          version.  */
4925       copy[first - 1] = '\0';
4926       h = elf_link_hash_lookup (elf_hash_table (info), copy,
4927                                 FALSE, FALSE, TRUE);
4928     }
4929
4930   bfd_release (abfd, copy);
4931   return h;
4932 }
4933
4934 /* Add symbols from an ELF archive file to the linker hash table.  We
4935    don't use _bfd_generic_link_add_archive_symbols because we need to
4936    handle versioned symbols.
4937
4938    Fortunately, ELF archive handling is simpler than that done by
4939    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4940    oddities.  In ELF, if we find a symbol in the archive map, and the
4941    symbol is currently undefined, we know that we must pull in that
4942    object file.
4943
4944    Unfortunately, we do have to make multiple passes over the symbol
4945    table until nothing further is resolved.  */
4946
4947 static bfd_boolean
4948 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4949 {
4950   symindex c;
4951   unsigned char *included = NULL;
4952   carsym *symdefs;
4953   bfd_boolean loop;
4954   bfd_size_type amt;
4955   const struct elf_backend_data *bed;
4956   struct elf_link_hash_entry * (*archive_symbol_lookup)
4957     (bfd *, struct bfd_link_info *, const char *);
4958
4959   if (! bfd_has_map (abfd))
4960     {
4961       /* An empty archive is a special case.  */
4962       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4963         return TRUE;
4964       bfd_set_error (bfd_error_no_armap);
4965       return FALSE;
4966     }
4967
4968   /* Keep track of all symbols we know to be already defined, and all
4969      files we know to be already included.  This is to speed up the
4970      second and subsequent passes.  */
4971   c = bfd_ardata (abfd)->symdef_count;
4972   if (c == 0)
4973     return TRUE;
4974   amt = c;
4975   amt *= sizeof (*included);
4976   included = (unsigned char *) bfd_zmalloc (amt);
4977   if (included == NULL)
4978     return FALSE;
4979
4980   symdefs = bfd_ardata (abfd)->symdefs;
4981   bed = get_elf_backend_data (abfd);
4982   archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
4983
4984   do
4985     {
4986       file_ptr last;
4987       symindex i;
4988       carsym *symdef;
4989       carsym *symdefend;
4990
4991       loop = FALSE;
4992       last = -1;
4993
4994       symdef = symdefs;
4995       symdefend = symdef + c;
4996       for (i = 0; symdef < symdefend; symdef++, i++)
4997         {
4998           struct elf_link_hash_entry *h;
4999           bfd *element;
5000           struct bfd_link_hash_entry *undefs_tail;
5001           symindex mark;
5002
5003           if (included[i])
5004             continue;
5005           if (symdef->file_offset == last)
5006             {
5007               included[i] = TRUE;
5008               continue;
5009             }
5010
5011           h = archive_symbol_lookup (abfd, info, symdef->name);
5012           if (h == (struct elf_link_hash_entry *) 0 - 1)
5013             goto error_return;
5014
5015           if (h == NULL)
5016             continue;
5017
5018           if (h->root.type == bfd_link_hash_common)
5019             {
5020               /* We currently have a common symbol.  The archive map contains
5021                  a reference to this symbol, so we may want to include it.  We
5022                  only want to include it however, if this archive element
5023                  contains a definition of the symbol, not just another common
5024                  declaration of it.
5025
5026                  Unfortunately some archivers (including GNU ar) will put
5027                  declarations of common symbols into their archive maps, as
5028                  well as real definitions, so we cannot just go by the archive
5029                  map alone.  Instead we must read in the element's symbol
5030                  table and check that to see what kind of symbol definition
5031                  this is.  */
5032               if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5033                 continue;
5034             }
5035           else if (h->root.type != bfd_link_hash_undefined)
5036             {
5037               if (h->root.type != bfd_link_hash_undefweak)
5038                 /* Symbol must be defined.  Don't check it again.  */
5039                 included[i] = TRUE;
5040               continue;
5041             }
5042
5043           /* We need to include this archive member.  */
5044           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5045           if (element == NULL)
5046             goto error_return;
5047
5048           if (! bfd_check_format (element, bfd_object))
5049             goto error_return;
5050
5051           undefs_tail = info->hash->undefs_tail;
5052
5053           if (!(*info->callbacks
5054                 ->add_archive_element) (info, element, symdef->name, &element))
5055             goto error_return;
5056           if (!bfd_link_add_symbols (element, info))
5057             goto error_return;
5058
5059           /* If there are any new undefined symbols, we need to make
5060              another pass through the archive in order to see whether
5061              they can be defined.  FIXME: This isn't perfect, because
5062              common symbols wind up on undefs_tail and because an
5063              undefined symbol which is defined later on in this pass
5064              does not require another pass.  This isn't a bug, but it
5065              does make the code less efficient than it could be.  */
5066           if (undefs_tail != info->hash->undefs_tail)
5067             loop = TRUE;
5068
5069           /* Look backward to mark all symbols from this object file
5070              which we have already seen in this pass.  */
5071           mark = i;
5072           do
5073             {
5074               included[mark] = TRUE;
5075               if (mark == 0)
5076                 break;
5077               --mark;
5078             }
5079           while (symdefs[mark].file_offset == symdef->file_offset);
5080
5081           /* We mark subsequent symbols from this object file as we go
5082              on through the loop.  */
5083           last = symdef->file_offset;
5084         }
5085     }
5086   while (loop);
5087
5088   free (included);
5089
5090   return TRUE;
5091
5092  error_return:
5093   if (included != NULL)
5094     free (included);
5095   return FALSE;
5096 }
5097
5098 /* Given an ELF BFD, add symbols to the global hash table as
5099    appropriate.  */
5100
5101 bfd_boolean
5102 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5103 {
5104   switch (bfd_get_format (abfd))
5105     {
5106     case bfd_object:
5107       return elf_link_add_object_symbols (abfd, info);
5108     case bfd_archive:
5109       return elf_link_add_archive_symbols (abfd, info);
5110     default:
5111       bfd_set_error (bfd_error_wrong_format);
5112       return FALSE;
5113     }
5114 }
5115 \f
5116 struct hash_codes_info
5117 {
5118   unsigned long *hashcodes;
5119   bfd_boolean error;
5120 };
5121
5122 /* This function will be called though elf_link_hash_traverse to store
5123    all hash value of the exported symbols in an array.  */
5124
5125 static bfd_boolean
5126 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5127 {
5128   struct hash_codes_info *inf = (struct hash_codes_info *) data;
5129   const char *name;
5130   char *p;
5131   unsigned long ha;
5132   char *alc = NULL;
5133
5134   /* Ignore indirect symbols.  These are added by the versioning code.  */
5135   if (h->dynindx == -1)
5136     return TRUE;
5137
5138   name = h->root.root.string;
5139   p = strchr (name, ELF_VER_CHR);
5140   if (p != NULL)
5141     {
5142       alc = (char *) bfd_malloc (p - name + 1);
5143       if (alc == NULL)
5144         {
5145           inf->error = TRUE;
5146           return FALSE;
5147         }
5148       memcpy (alc, name, p - name);
5149       alc[p - name] = '\0';
5150       name = alc;
5151     }
5152
5153   /* Compute the hash value.  */
5154   ha = bfd_elf_hash (name);
5155
5156   /* Store the found hash value in the array given as the argument.  */
5157   *(inf->hashcodes)++ = ha;
5158
5159   /* And store it in the struct so that we can put it in the hash table
5160      later.  */
5161   h->u.elf_hash_value = ha;
5162
5163   if (alc != NULL)
5164     free (alc);
5165
5166   return TRUE;
5167 }
5168
5169 struct collect_gnu_hash_codes
5170 {
5171   bfd *output_bfd;
5172   const struct elf_backend_data *bed;
5173   unsigned long int nsyms;
5174   unsigned long int maskbits;
5175   unsigned long int *hashcodes;
5176   unsigned long int *hashval;
5177   unsigned long int *indx;
5178   unsigned long int *counts;
5179   bfd_vma *bitmask;
5180   bfd_byte *contents;
5181   long int min_dynindx;
5182   unsigned long int bucketcount;
5183   unsigned long int symindx;
5184   long int local_indx;
5185   long int shift1, shift2;
5186   unsigned long int mask;
5187   bfd_boolean error;
5188 };
5189
5190 /* This function will be called though elf_link_hash_traverse to store
5191    all hash value of the exported symbols in an array.  */
5192
5193 static bfd_boolean
5194 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5195 {
5196   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5197   const char *name;
5198   char *p;
5199   unsigned long ha;
5200   char *alc = NULL;
5201
5202   /* Ignore indirect symbols.  These are added by the versioning code.  */
5203   if (h->dynindx == -1)
5204     return TRUE;
5205
5206   /* Ignore also local symbols and undefined symbols.  */
5207   if (! (*s->bed->elf_hash_symbol) (h))
5208     return TRUE;
5209
5210   name = h->root.root.string;
5211   p = strchr (name, ELF_VER_CHR);
5212   if (p != NULL)
5213     {
5214       alc = (char *) bfd_malloc (p - name + 1);
5215       if (alc == NULL)
5216         {
5217           s->error = TRUE;
5218           return FALSE;
5219         }
5220       memcpy (alc, name, p - name);
5221       alc[p - name] = '\0';
5222       name = alc;
5223     }
5224
5225   /* Compute the hash value.  */
5226   ha = bfd_elf_gnu_hash (name);
5227
5228   /* Store the found hash value in the array for compute_bucket_count,
5229      and also for .dynsym reordering purposes.  */
5230   s->hashcodes[s->nsyms] = ha;
5231   s->hashval[h->dynindx] = ha;
5232   ++s->nsyms;
5233   if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5234     s->min_dynindx = h->dynindx;
5235
5236   if (alc != NULL)
5237     free (alc);
5238
5239   return TRUE;
5240 }
5241
5242 /* This function will be called though elf_link_hash_traverse to do
5243    final dynaminc symbol renumbering.  */
5244
5245 static bfd_boolean
5246 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5247 {
5248   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5249   unsigned long int bucket;
5250   unsigned long int val;
5251
5252   /* Ignore indirect symbols.  */
5253   if (h->dynindx == -1)
5254     return TRUE;
5255
5256   /* Ignore also local symbols and undefined symbols.  */
5257   if (! (*s->bed->elf_hash_symbol) (h))
5258     {
5259       if (h->dynindx >= s->min_dynindx)
5260         h->dynindx = s->local_indx++;
5261       return TRUE;
5262     }
5263
5264   bucket = s->hashval[h->dynindx] % s->bucketcount;
5265   val = (s->hashval[h->dynindx] >> s->shift1)
5266         & ((s->maskbits >> s->shift1) - 1);
5267   s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5268   s->bitmask[val]
5269     |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5270   val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5271   if (s->counts[bucket] == 1)
5272     /* Last element terminates the chain.  */
5273     val |= 1;
5274   bfd_put_32 (s->output_bfd, val,
5275               s->contents + (s->indx[bucket] - s->symindx) * 4);
5276   --s->counts[bucket];
5277   h->dynindx = s->indx[bucket]++;
5278   return TRUE;
5279 }
5280
5281 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5282
5283 bfd_boolean
5284 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5285 {
5286   return !(h->forced_local
5287            || h->root.type == bfd_link_hash_undefined
5288            || h->root.type == bfd_link_hash_undefweak
5289            || ((h->root.type == bfd_link_hash_defined
5290                 || h->root.type == bfd_link_hash_defweak)
5291                && h->root.u.def.section->output_section == NULL));
5292 }
5293
5294 /* Array used to determine the number of hash table buckets to use
5295    based on the number of symbols there are.  If there are fewer than
5296    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5297    fewer than 37 we use 17 buckets, and so forth.  We never use more
5298    than 32771 buckets.  */
5299
5300 static const size_t elf_buckets[] =
5301 {
5302   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5303   16411, 32771, 0
5304 };
5305
5306 /* Compute bucket count for hashing table.  We do not use a static set
5307    of possible tables sizes anymore.  Instead we determine for all
5308    possible reasonable sizes of the table the outcome (i.e., the
5309    number of collisions etc) and choose the best solution.  The
5310    weighting functions are not too simple to allow the table to grow
5311    without bounds.  Instead one of the weighting factors is the size.
5312    Therefore the result is always a good payoff between few collisions
5313    (= short chain lengths) and table size.  */
5314 static size_t
5315 compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5316                       unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5317                       unsigned long int nsyms,
5318                       int gnu_hash)
5319 {
5320   size_t best_size = 0;
5321   unsigned long int i;
5322
5323   /* We have a problem here.  The following code to optimize the table
5324      size requires an integer type with more the 32 bits.  If
5325      BFD_HOST_U_64_BIT is set we know about such a type.  */
5326 #ifdef BFD_HOST_U_64_BIT
5327   if (info->optimize)
5328     {
5329       size_t minsize;
5330       size_t maxsize;
5331       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5332       bfd *dynobj = elf_hash_table (info)->dynobj;
5333       size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5334       const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5335       unsigned long int *counts;
5336       bfd_size_type amt;
5337       unsigned int no_improvement_count = 0;
5338
5339       /* Possible optimization parameters: if we have NSYMS symbols we say
5340          that the hashing table must at least have NSYMS/4 and at most
5341          2*NSYMS buckets.  */
5342       minsize = nsyms / 4;
5343       if (minsize == 0)
5344         minsize = 1;
5345       best_size = maxsize = nsyms * 2;
5346       if (gnu_hash)
5347         {
5348           if (minsize < 2)
5349             minsize = 2;
5350           if ((best_size & 31) == 0)
5351             ++best_size;
5352         }
5353
5354       /* Create array where we count the collisions in.  We must use bfd_malloc
5355          since the size could be large.  */
5356       amt = maxsize;
5357       amt *= sizeof (unsigned long int);
5358       counts = (unsigned long int *) bfd_malloc (amt);
5359       if (counts == NULL)
5360         return 0;
5361
5362       /* Compute the "optimal" size for the hash table.  The criteria is a
5363          minimal chain length.  The minor criteria is (of course) the size
5364          of the table.  */
5365       for (i = minsize; i < maxsize; ++i)
5366         {
5367           /* Walk through the array of hashcodes and count the collisions.  */
5368           BFD_HOST_U_64_BIT max;
5369           unsigned long int j;
5370           unsigned long int fact;
5371
5372           if (gnu_hash && (i & 31) == 0)
5373             continue;
5374
5375           memset (counts, '\0', i * sizeof (unsigned long int));
5376
5377           /* Determine how often each hash bucket is used.  */
5378           for (j = 0; j < nsyms; ++j)
5379             ++counts[hashcodes[j] % i];
5380
5381           /* For the weight function we need some information about the
5382              pagesize on the target.  This is information need not be 100%
5383              accurate.  Since this information is not available (so far) we
5384              define it here to a reasonable default value.  If it is crucial
5385              to have a better value some day simply define this value.  */
5386 # ifndef BFD_TARGET_PAGESIZE
5387 #  define BFD_TARGET_PAGESIZE   (4096)
5388 # endif
5389
5390           /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5391              and the chains.  */
5392           max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5393
5394 # if 1
5395           /* Variant 1: optimize for short chains.  We add the squares
5396              of all the chain lengths (which favors many small chain
5397              over a few long chains).  */
5398           for (j = 0; j < i; ++j)
5399             max += counts[j] * counts[j];
5400
5401           /* This adds penalties for the overall size of the table.  */
5402           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5403           max *= fact * fact;
5404 # else
5405           /* Variant 2: Optimize a lot more for small table.  Here we
5406              also add squares of the size but we also add penalties for
5407              empty slots (the +1 term).  */
5408           for (j = 0; j < i; ++j)
5409             max += (1 + counts[j]) * (1 + counts[j]);
5410
5411           /* The overall size of the table is considered, but not as
5412              strong as in variant 1, where it is squared.  */
5413           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5414           max *= fact;
5415 # endif
5416
5417           /* Compare with current best results.  */
5418           if (max < best_chlen)
5419             {
5420               best_chlen = max;
5421               best_size = i;
5422               no_improvement_count = 0;
5423             }
5424           /* PR 11843: Avoid futile long searches for the best bucket size
5425              when there are a large number of symbols.  */
5426           else if (++no_improvement_count == 100)
5427             break;
5428         }
5429
5430       free (counts);
5431     }
5432   else
5433 #endif /* defined (BFD_HOST_U_64_BIT) */
5434     {
5435       /* This is the fallback solution if no 64bit type is available or if we
5436          are not supposed to spend much time on optimizations.  We select the
5437          bucket count using a fixed set of numbers.  */
5438       for (i = 0; elf_buckets[i] != 0; i++)
5439         {
5440           best_size = elf_buckets[i];
5441           if (nsyms < elf_buckets[i + 1])
5442             break;
5443         }
5444       if (gnu_hash && best_size < 2)
5445         best_size = 2;
5446     }
5447
5448   return best_size;
5449 }
5450
5451 /* Size any SHT_GROUP section for ld -r.  */
5452
5453 bfd_boolean
5454 _bfd_elf_size_group_sections (struct bfd_link_info *info)
5455 {
5456   bfd *ibfd;
5457
5458   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5459     if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5460         && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5461       return FALSE;
5462   return TRUE;
5463 }
5464
5465 /* Set a default stack segment size.  The value in INFO wins.  If it
5466    is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5467    undefined it is initialized.  */
5468
5469 bfd_boolean
5470 bfd_elf_stack_segment_size (bfd *output_bfd,
5471                             struct bfd_link_info *info,
5472                             const char *legacy_symbol,
5473                             bfd_vma default_size)
5474 {
5475   struct elf_link_hash_entry *h = NULL;
5476
5477   /* Look for legacy symbol.  */
5478   if (legacy_symbol)
5479     h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
5480                               FALSE, FALSE, FALSE);
5481   if (h && (h->root.type == bfd_link_hash_defined
5482             || h->root.type == bfd_link_hash_defweak)
5483       && h->def_regular
5484       && (h->type == STT_NOTYPE || h->type == STT_OBJECT))
5485     {
5486       /* The symbol has no type if specified on the command line.  */
5487       h->type = STT_OBJECT;
5488       if (info->stacksize)
5489         (*_bfd_error_handler) (_("%B: stack size specified and %s set"),
5490                                output_bfd, legacy_symbol);
5491       else if (h->root.u.def.section != bfd_abs_section_ptr)
5492         (*_bfd_error_handler) (_("%B: %s not absolute"),
5493                                output_bfd, legacy_symbol);
5494       else
5495         info->stacksize = h->root.u.def.value;
5496     }
5497
5498   if (!info->stacksize)
5499     /* If the user didn't set a size, or explicitly inhibit the
5500        size, set it now.  */
5501     info->stacksize = default_size;
5502
5503   /* Provide the legacy symbol, if it is referenced.  */
5504   if (h && (h->root.type == bfd_link_hash_undefined
5505             || h->root.type == bfd_link_hash_undefweak))
5506     {
5507       struct bfd_link_hash_entry *bh = NULL;
5508
5509       if (!(_bfd_generic_link_add_one_symbol
5510             (info, output_bfd, legacy_symbol,
5511              BSF_GLOBAL, bfd_abs_section_ptr,
5512              info->stacksize >= 0 ? info->stacksize : 0,
5513              NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
5514         return FALSE;
5515
5516       h = (struct elf_link_hash_entry *) bh;
5517       h->def_regular = 1;
5518       h->type = STT_OBJECT;
5519     }
5520
5521   return TRUE;
5522 }
5523
5524 /* Set up the sizes and contents of the ELF dynamic sections.  This is
5525    called by the ELF linker emulation before_allocation routine.  We
5526    must set the sizes of the sections before the linker sets the
5527    addresses of the various sections.  */
5528
5529 bfd_boolean
5530 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5531                                const char *soname,
5532                                const char *rpath,
5533                                const char *filter_shlib,
5534                                const char *audit,
5535                                const char *depaudit,
5536                                const char * const *auxiliary_filters,
5537                                struct bfd_link_info *info,
5538                                asection **sinterpptr)
5539 {
5540   bfd_size_type soname_indx;
5541   bfd *dynobj;
5542   const struct elf_backend_data *bed;
5543   struct elf_info_failed asvinfo;
5544
5545   *sinterpptr = NULL;
5546
5547   soname_indx = (bfd_size_type) -1;
5548
5549   if (!is_elf_hash_table (info->hash))
5550     return TRUE;
5551
5552   bed = get_elf_backend_data (output_bfd);
5553
5554   /* Any syms created from now on start with -1 in
5555      got.refcount/offset and plt.refcount/offset.  */
5556   elf_hash_table (info)->init_got_refcount
5557     = elf_hash_table (info)->init_got_offset;
5558   elf_hash_table (info)->init_plt_refcount
5559     = elf_hash_table (info)->init_plt_offset;
5560
5561   if (info->relocatable
5562       && !_bfd_elf_size_group_sections (info))
5563     return FALSE;
5564
5565   /* The backend may have to create some sections regardless of whether
5566      we're dynamic or not.  */
5567   if (bed->elf_backend_always_size_sections
5568       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5569     return FALSE;
5570
5571   /* Determine any GNU_STACK segment requirements, after the backend
5572      has had a chance to set a default segment size.  */
5573   if (info->execstack)
5574     elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
5575   else if (info->noexecstack)
5576     elf_stack_flags (output_bfd) = PF_R | PF_W;
5577   else
5578     {
5579       bfd *inputobj;
5580       asection *notesec = NULL;
5581       int exec = 0;
5582
5583       for (inputobj = info->input_bfds;
5584            inputobj;
5585            inputobj = inputobj->link.next)
5586         {
5587           asection *s;
5588
5589           if (inputobj->flags
5590               & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5591             continue;
5592           s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5593           if (s)
5594             {
5595               if (s->flags & SEC_CODE)
5596                 exec = PF_X;
5597               notesec = s;
5598             }
5599           else if (bed->default_execstack)
5600             exec = PF_X;
5601         }
5602       if (notesec || info->stacksize > 0)
5603         elf_stack_flags (output_bfd) = PF_R | PF_W | exec;
5604       if (notesec && exec && info->relocatable
5605           && notesec->output_section != bfd_abs_section_ptr)
5606         notesec->output_section->flags |= SEC_CODE;
5607     }
5608
5609   dynobj = elf_hash_table (info)->dynobj;
5610
5611   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5612     {
5613       struct elf_info_failed eif;
5614       struct elf_link_hash_entry *h;
5615       asection *dynstr;
5616       struct bfd_elf_version_tree *t;
5617       struct bfd_elf_version_expr *d;
5618       asection *s;
5619       bfd_boolean all_defined;
5620
5621       *sinterpptr = bfd_get_linker_section (dynobj, ".interp");
5622       BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5623
5624       if (soname != NULL)
5625         {
5626           soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5627                                              soname, TRUE);
5628           if (soname_indx == (bfd_size_type) -1
5629               || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5630             return FALSE;
5631         }
5632
5633       if (info->symbolic)
5634         {
5635           if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5636             return FALSE;
5637           info->flags |= DF_SYMBOLIC;
5638         }
5639
5640       if (rpath != NULL)
5641         {
5642           bfd_size_type indx;
5643           bfd_vma tag;
5644
5645           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5646                                       TRUE);
5647           if (indx == (bfd_size_type) -1)
5648             return FALSE;
5649
5650           tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
5651           if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
5652             return FALSE;
5653         }
5654
5655       if (filter_shlib != NULL)
5656         {
5657           bfd_size_type indx;
5658
5659           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5660                                       filter_shlib, TRUE);
5661           if (indx == (bfd_size_type) -1
5662               || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5663             return FALSE;
5664         }
5665
5666       if (auxiliary_filters != NULL)
5667         {
5668           const char * const *p;
5669
5670           for (p = auxiliary_filters; *p != NULL; p++)
5671             {
5672               bfd_size_type indx;
5673
5674               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5675                                           *p, TRUE);
5676               if (indx == (bfd_size_type) -1
5677                   || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5678                 return FALSE;
5679             }
5680         }
5681
5682       if (audit != NULL)
5683         {
5684           bfd_size_type indx;
5685
5686           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5687                                       TRUE);
5688           if (indx == (bfd_size_type) -1
5689               || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5690             return FALSE;
5691         }
5692
5693       if (depaudit != NULL)
5694         {
5695           bfd_size_type indx;
5696
5697           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5698                                       TRUE);
5699           if (indx == (bfd_size_type) -1
5700               || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5701             return FALSE;
5702         }
5703
5704       eif.info = info;
5705       eif.failed = FALSE;
5706
5707       /* If we are supposed to export all symbols into the dynamic symbol
5708          table (this is not the normal case), then do so.  */
5709       if (info->export_dynamic
5710           || (info->executable && info->dynamic))
5711         {
5712           elf_link_hash_traverse (elf_hash_table (info),
5713                                   _bfd_elf_export_symbol,
5714                                   &eif);
5715           if (eif.failed)
5716             return FALSE;
5717         }
5718
5719       /* Make all global versions with definition.  */
5720       for (t = info->version_info; t != NULL; t = t->next)
5721         for (d = t->globals.list; d != NULL; d = d->next)
5722           if (!d->symver && d->literal)
5723             {
5724               const char *verstr, *name;
5725               size_t namelen, verlen, newlen;
5726               char *newname, *p, leading_char;
5727               struct elf_link_hash_entry *newh;
5728
5729               leading_char = bfd_get_symbol_leading_char (output_bfd);
5730               name = d->pattern;
5731               namelen = strlen (name) + (leading_char != '\0');
5732               verstr = t->name;
5733               verlen = strlen (verstr);
5734               newlen = namelen + verlen + 3;
5735
5736               newname = (char *) bfd_malloc (newlen);
5737               if (newname == NULL)
5738                 return FALSE;
5739               newname[0] = leading_char;
5740               memcpy (newname + (leading_char != '\0'), name, namelen);
5741
5742               /* Check the hidden versioned definition.  */
5743               p = newname + namelen;
5744               *p++ = ELF_VER_CHR;
5745               memcpy (p, verstr, verlen + 1);
5746               newh = elf_link_hash_lookup (elf_hash_table (info),
5747                                            newname, FALSE, FALSE,
5748                                            FALSE);
5749               if (newh == NULL
5750                   || (newh->root.type != bfd_link_hash_defined
5751                       && newh->root.type != bfd_link_hash_defweak))
5752                 {
5753                   /* Check the default versioned definition.  */
5754                   *p++ = ELF_VER_CHR;
5755                   memcpy (p, verstr, verlen + 1);
5756                   newh = elf_link_hash_lookup (elf_hash_table (info),
5757                                                newname, FALSE, FALSE,
5758                                                FALSE);
5759                 }
5760               free (newname);
5761
5762               /* Mark this version if there is a definition and it is
5763                  not defined in a shared object.  */
5764               if (newh != NULL
5765                   && !newh->def_dynamic
5766                   && (newh->root.type == bfd_link_hash_defined
5767                       || newh->root.type == bfd_link_hash_defweak))
5768                 d->symver = 1;
5769             }
5770
5771       /* Attach all the symbols to their version information.  */
5772       asvinfo.info = info;
5773       asvinfo.failed = FALSE;
5774
5775       elf_link_hash_traverse (elf_hash_table (info),
5776                               _bfd_elf_link_assign_sym_version,
5777                               &asvinfo);
5778       if (asvinfo.failed)
5779         return FALSE;
5780
5781       if (!info->allow_undefined_version)
5782         {
5783           /* Check if all global versions have a definition.  */
5784           all_defined = TRUE;
5785           for (t = info->version_info; t != NULL; t = t->next)
5786             for (d = t->globals.list; d != NULL; d = d->next)
5787               if (d->literal && !d->symver && !d->script)
5788                 {
5789                   (*_bfd_error_handler)
5790                     (_("%s: undefined version: %s"),
5791                      d->pattern, t->name);
5792                   all_defined = FALSE;
5793                 }
5794
5795           if (!all_defined)
5796             {
5797               bfd_set_error (bfd_error_bad_value);
5798               return FALSE;
5799             }
5800         }
5801
5802       /* Find all symbols which were defined in a dynamic object and make
5803          the backend pick a reasonable value for them.  */
5804       elf_link_hash_traverse (elf_hash_table (info),
5805                               _bfd_elf_adjust_dynamic_symbol,
5806                               &eif);
5807       if (eif.failed)
5808         return FALSE;
5809
5810       /* Add some entries to the .dynamic section.  We fill in some of the
5811          values later, in bfd_elf_final_link, but we must add the entries
5812          now so that we know the final size of the .dynamic section.  */
5813
5814       /* If there are initialization and/or finalization functions to
5815          call then add the corresponding DT_INIT/DT_FINI entries.  */
5816       h = (info->init_function
5817            ? elf_link_hash_lookup (elf_hash_table (info),
5818                                    info->init_function, FALSE,
5819                                    FALSE, FALSE)
5820            : NULL);
5821       if (h != NULL
5822           && (h->ref_regular
5823               || h->def_regular))
5824         {
5825           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5826             return FALSE;
5827         }
5828       h = (info->fini_function
5829            ? elf_link_hash_lookup (elf_hash_table (info),
5830                                    info->fini_function, FALSE,
5831                                    FALSE, FALSE)
5832            : NULL);
5833       if (h != NULL
5834           && (h->ref_regular
5835               || h->def_regular))
5836         {
5837           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5838             return FALSE;
5839         }
5840
5841       s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5842       if (s != NULL && s->linker_has_input)
5843         {
5844           /* DT_PREINIT_ARRAY is not allowed in shared library.  */
5845           if (! info->executable)
5846             {
5847               bfd *sub;
5848               asection *o;
5849
5850               for (sub = info->input_bfds; sub != NULL;
5851                    sub = sub->link.next)
5852                 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5853                   for (o = sub->sections; o != NULL; o = o->next)
5854                     if (elf_section_data (o)->this_hdr.sh_type
5855                         == SHT_PREINIT_ARRAY)
5856                       {
5857                         (*_bfd_error_handler)
5858                           (_("%B: .preinit_array section is not allowed in DSO"),
5859                            sub);
5860                         break;
5861                       }
5862
5863               bfd_set_error (bfd_error_nonrepresentable_section);
5864               return FALSE;
5865             }
5866
5867           if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5868               || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5869             return FALSE;
5870         }
5871       s = bfd_get_section_by_name (output_bfd, ".init_array");
5872       if (s != NULL && s->linker_has_input)
5873         {
5874           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5875               || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5876             return FALSE;
5877         }
5878       s = bfd_get_section_by_name (output_bfd, ".fini_array");
5879       if (s != NULL && s->linker_has_input)
5880         {
5881           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5882               || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5883             return FALSE;
5884         }
5885
5886       dynstr = bfd_get_linker_section (dynobj, ".dynstr");
5887       /* If .dynstr is excluded from the link, we don't want any of
5888          these tags.  Strictly, we should be checking each section
5889          individually;  This quick check covers for the case where
5890          someone does a /DISCARD/ : { *(*) }.  */
5891       if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5892         {
5893           bfd_size_type strsize;
5894
5895           strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5896           if ((info->emit_hash
5897                && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5898               || (info->emit_gnu_hash
5899                   && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5900               || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5901               || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5902               || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5903               || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5904                                               bed->s->sizeof_sym))
5905             return FALSE;
5906         }
5907     }
5908
5909   /* The backend must work out the sizes of all the other dynamic
5910      sections.  */
5911   if (dynobj != NULL
5912       && bed->elf_backend_size_dynamic_sections != NULL
5913       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5914     return FALSE;
5915
5916   if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5917     return FALSE;
5918
5919   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5920     {
5921       unsigned long section_sym_count;
5922       struct bfd_elf_version_tree *verdefs;
5923       asection *s;
5924
5925       /* Set up the version definition section.  */
5926       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
5927       BFD_ASSERT (s != NULL);
5928
5929       /* We may have created additional version definitions if we are
5930          just linking a regular application.  */
5931       verdefs = info->version_info;
5932
5933       /* Skip anonymous version tag.  */
5934       if (verdefs != NULL && verdefs->vernum == 0)
5935         verdefs = verdefs->next;
5936
5937       if (verdefs == NULL && !info->create_default_symver)
5938         s->flags |= SEC_EXCLUDE;
5939       else
5940         {
5941           unsigned int cdefs;
5942           bfd_size_type size;
5943           struct bfd_elf_version_tree *t;
5944           bfd_byte *p;
5945           Elf_Internal_Verdef def;
5946           Elf_Internal_Verdaux defaux;
5947           struct bfd_link_hash_entry *bh;
5948           struct elf_link_hash_entry *h;
5949           const char *name;
5950
5951           cdefs = 0;
5952           size = 0;
5953
5954           /* Make space for the base version.  */
5955           size += sizeof (Elf_External_Verdef);
5956           size += sizeof (Elf_External_Verdaux);
5957           ++cdefs;
5958
5959           /* Make space for the default version.  */
5960           if (info->create_default_symver)
5961             {
5962               size += sizeof (Elf_External_Verdef);
5963               ++cdefs;
5964             }
5965
5966           for (t = verdefs; t != NULL; t = t->next)
5967             {
5968               struct bfd_elf_version_deps *n;
5969
5970               /* Don't emit base version twice.  */
5971               if (t->vernum == 0)
5972                 continue;
5973
5974               size += sizeof (Elf_External_Verdef);
5975               size += sizeof (Elf_External_Verdaux);
5976               ++cdefs;
5977
5978               for (n = t->deps; n != NULL; n = n->next)
5979                 size += sizeof (Elf_External_Verdaux);
5980             }
5981
5982           s->size = size;
5983           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
5984           if (s->contents == NULL && s->size != 0)
5985             return FALSE;
5986
5987           /* Fill in the version definition section.  */
5988
5989           p = s->contents;
5990
5991           def.vd_version = VER_DEF_CURRENT;
5992           def.vd_flags = VER_FLG_BASE;
5993           def.vd_ndx = 1;
5994           def.vd_cnt = 1;
5995           if (info->create_default_symver)
5996             {
5997               def.vd_aux = 2 * sizeof (Elf_External_Verdef);
5998               def.vd_next = sizeof (Elf_External_Verdef);
5999             }
6000           else
6001             {
6002               def.vd_aux = sizeof (Elf_External_Verdef);
6003               def.vd_next = (sizeof (Elf_External_Verdef)
6004                              + sizeof (Elf_External_Verdaux));
6005             }
6006
6007           if (soname_indx != (bfd_size_type) -1)
6008             {
6009               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6010                                       soname_indx);
6011               def.vd_hash = bfd_elf_hash (soname);
6012               defaux.vda_name = soname_indx;
6013               name = soname;
6014             }
6015           else
6016             {
6017               bfd_size_type indx;
6018
6019               name = lbasename (output_bfd->filename);
6020               def.vd_hash = bfd_elf_hash (name);
6021               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6022                                           name, FALSE);
6023               if (indx == (bfd_size_type) -1)
6024                 return FALSE;
6025               defaux.vda_name = indx;
6026             }
6027           defaux.vda_next = 0;
6028
6029           _bfd_elf_swap_verdef_out (output_bfd, &def,
6030                                     (Elf_External_Verdef *) p);
6031           p += sizeof (Elf_External_Verdef);
6032           if (info->create_default_symver)
6033             {
6034               /* Add a symbol representing this version.  */
6035               bh = NULL;
6036               if (! (_bfd_generic_link_add_one_symbol
6037                      (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6038                       0, NULL, FALSE,
6039                       get_elf_backend_data (dynobj)->collect, &bh)))
6040                 return FALSE;
6041               h = (struct elf_link_hash_entry *) bh;
6042               h->non_elf = 0;
6043               h->def_regular = 1;
6044               h->type = STT_OBJECT;
6045               h->verinfo.vertree = NULL;
6046
6047               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6048                 return FALSE;
6049
6050               /* Create a duplicate of the base version with the same
6051                  aux block, but different flags.  */
6052               def.vd_flags = 0;
6053               def.vd_ndx = 2;
6054               def.vd_aux = sizeof (Elf_External_Verdef);
6055               if (verdefs)
6056                 def.vd_next = (sizeof (Elf_External_Verdef)
6057                                + sizeof (Elf_External_Verdaux));
6058               else
6059                 def.vd_next = 0;
6060               _bfd_elf_swap_verdef_out (output_bfd, &def,
6061                                         (Elf_External_Verdef *) p);
6062               p += sizeof (Elf_External_Verdef);
6063             }
6064           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6065                                      (Elf_External_Verdaux *) p);
6066           p += sizeof (Elf_External_Verdaux);
6067
6068           for (t = verdefs; t != NULL; t = t->next)
6069             {
6070               unsigned int cdeps;
6071               struct bfd_elf_version_deps *n;
6072
6073               /* Don't emit the base version twice.  */
6074               if (t->vernum == 0)
6075                 continue;
6076
6077               cdeps = 0;
6078               for (n = t->deps; n != NULL; n = n->next)
6079                 ++cdeps;
6080
6081               /* Add a symbol representing this version.  */
6082               bh = NULL;
6083               if (! (_bfd_generic_link_add_one_symbol
6084                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6085                       0, NULL, FALSE,
6086                       get_elf_backend_data (dynobj)->collect, &bh)))
6087                 return FALSE;
6088               h = (struct elf_link_hash_entry *) bh;
6089               h->non_elf = 0;
6090               h->def_regular = 1;
6091               h->type = STT_OBJECT;
6092               h->verinfo.vertree = t;
6093
6094               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6095                 return FALSE;
6096
6097               def.vd_version = VER_DEF_CURRENT;
6098               def.vd_flags = 0;
6099               if (t->globals.list == NULL
6100                   && t->locals.list == NULL
6101                   && ! t->used)
6102                 def.vd_flags |= VER_FLG_WEAK;
6103               def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6104               def.vd_cnt = cdeps + 1;
6105               def.vd_hash = bfd_elf_hash (t->name);
6106               def.vd_aux = sizeof (Elf_External_Verdef);
6107               def.vd_next = 0;
6108
6109               /* If a basever node is next, it *must* be the last node in
6110                  the chain, otherwise Verdef construction breaks.  */
6111               if (t->next != NULL && t->next->vernum == 0)
6112                 BFD_ASSERT (t->next->next == NULL);
6113
6114               if (t->next != NULL && t->next->vernum != 0)
6115                 def.vd_next = (sizeof (Elf_External_Verdef)
6116                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6117
6118               _bfd_elf_swap_verdef_out (output_bfd, &def,
6119                                         (Elf_External_Verdef *) p);
6120               p += sizeof (Elf_External_Verdef);
6121
6122               defaux.vda_name = h->dynstr_index;
6123               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6124                                       h->dynstr_index);
6125               defaux.vda_next = 0;
6126               if (t->deps != NULL)
6127                 defaux.vda_next = sizeof (Elf_External_Verdaux);
6128               t->name_indx = defaux.vda_name;
6129
6130               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6131                                          (Elf_External_Verdaux *) p);
6132               p += sizeof (Elf_External_Verdaux);
6133
6134               for (n = t->deps; n != NULL; n = n->next)
6135                 {
6136                   if (n->version_needed == NULL)
6137                     {
6138                       /* This can happen if there was an error in the
6139                          version script.  */
6140                       defaux.vda_name = 0;
6141                     }
6142                   else
6143                     {
6144                       defaux.vda_name = n->version_needed->name_indx;
6145                       _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6146                                               defaux.vda_name);
6147                     }
6148                   if (n->next == NULL)
6149                     defaux.vda_next = 0;
6150                   else
6151                     defaux.vda_next = sizeof (Elf_External_Verdaux);
6152
6153                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6154                                              (Elf_External_Verdaux *) p);
6155                   p += sizeof (Elf_External_Verdaux);
6156                 }
6157             }
6158
6159           if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6160               || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6161             return FALSE;
6162
6163           elf_tdata (output_bfd)->cverdefs = cdefs;
6164         }
6165
6166       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6167         {
6168           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6169             return FALSE;
6170         }
6171       else if (info->flags & DF_BIND_NOW)
6172         {
6173           if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6174             return FALSE;
6175         }
6176
6177       if (info->flags_1)
6178         {
6179           if (info->executable)
6180             info->flags_1 &= ~ (DF_1_INITFIRST
6181                                 | DF_1_NODELETE
6182                                 | DF_1_NOOPEN);
6183           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6184             return FALSE;
6185         }
6186
6187       /* Work out the size of the version reference section.  */
6188
6189       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
6190       BFD_ASSERT (s != NULL);
6191       {
6192         struct elf_find_verdep_info sinfo;
6193
6194         sinfo.info = info;
6195         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6196         if (sinfo.vers == 0)
6197           sinfo.vers = 1;
6198         sinfo.failed = FALSE;
6199
6200         elf_link_hash_traverse (elf_hash_table (info),
6201                                 _bfd_elf_link_find_version_dependencies,
6202                                 &sinfo);
6203         if (sinfo.failed)
6204           return FALSE;
6205
6206         if (elf_tdata (output_bfd)->verref == NULL)
6207           s->flags |= SEC_EXCLUDE;
6208         else
6209           {
6210             Elf_Internal_Verneed *t;
6211             unsigned int size;
6212             unsigned int crefs;
6213             bfd_byte *p;
6214
6215             /* Build the version dependency section.  */
6216             size = 0;
6217             crefs = 0;
6218             for (t = elf_tdata (output_bfd)->verref;
6219                  t != NULL;
6220                  t = t->vn_nextref)
6221               {
6222                 Elf_Internal_Vernaux *a;
6223
6224                 size += sizeof (Elf_External_Verneed);
6225                 ++crefs;
6226                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6227                   size += sizeof (Elf_External_Vernaux);
6228               }
6229
6230             s->size = size;
6231             s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6232             if (s->contents == NULL)
6233               return FALSE;
6234
6235             p = s->contents;
6236             for (t = elf_tdata (output_bfd)->verref;
6237                  t != NULL;
6238                  t = t->vn_nextref)
6239               {
6240                 unsigned int caux;
6241                 Elf_Internal_Vernaux *a;
6242                 bfd_size_type indx;
6243
6244                 caux = 0;
6245                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6246                   ++caux;
6247
6248                 t->vn_version = VER_NEED_CURRENT;
6249                 t->vn_cnt = caux;
6250                 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6251                                             elf_dt_name (t->vn_bfd) != NULL
6252                                             ? elf_dt_name (t->vn_bfd)
6253                                             : lbasename (t->vn_bfd->filename),
6254                                             FALSE);
6255                 if (indx == (bfd_size_type) -1)
6256                   return FALSE;
6257                 t->vn_file = indx;
6258                 t->vn_aux = sizeof (Elf_External_Verneed);
6259                 if (t->vn_nextref == NULL)
6260                   t->vn_next = 0;
6261                 else
6262                   t->vn_next = (sizeof (Elf_External_Verneed)
6263                                 + caux * sizeof (Elf_External_Vernaux));
6264
6265                 _bfd_elf_swap_verneed_out (output_bfd, t,
6266                                            (Elf_External_Verneed *) p);
6267                 p += sizeof (Elf_External_Verneed);
6268
6269                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6270                   {
6271                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
6272                     indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6273                                                 a->vna_nodename, FALSE);
6274                     if (indx == (bfd_size_type) -1)
6275                       return FALSE;
6276                     a->vna_name = indx;
6277                     if (a->vna_nextptr == NULL)
6278                       a->vna_next = 0;
6279                     else
6280                       a->vna_next = sizeof (Elf_External_Vernaux);
6281
6282                     _bfd_elf_swap_vernaux_out (output_bfd, a,
6283                                                (Elf_External_Vernaux *) p);
6284                     p += sizeof (Elf_External_Vernaux);
6285                   }
6286               }
6287
6288             if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6289                 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6290               return FALSE;
6291
6292             elf_tdata (output_bfd)->cverrefs = crefs;
6293           }
6294       }
6295
6296       if ((elf_tdata (output_bfd)->cverrefs == 0
6297            && elf_tdata (output_bfd)->cverdefs == 0)
6298           || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6299                                              &section_sym_count) == 0)
6300         {
6301           s = bfd_get_linker_section (dynobj, ".gnu.version");
6302           s->flags |= SEC_EXCLUDE;
6303         }
6304     }
6305   return TRUE;
6306 }
6307
6308 /* Find the first non-excluded output section.  We'll use its
6309    section symbol for some emitted relocs.  */
6310 void
6311 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6312 {
6313   asection *s;
6314
6315   for (s = output_bfd->sections; s != NULL; s = s->next)
6316     if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6317         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6318       {
6319         elf_hash_table (info)->text_index_section = s;
6320         break;
6321       }
6322 }
6323
6324 /* Find two non-excluded output sections, one for code, one for data.
6325    We'll use their section symbols for some emitted relocs.  */
6326 void
6327 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6328 {
6329   asection *s;
6330
6331   /* Data first, since setting text_index_section changes
6332      _bfd_elf_link_omit_section_dynsym.  */
6333   for (s = output_bfd->sections; s != NULL; s = s->next)
6334     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6335         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6336       {
6337         elf_hash_table (info)->data_index_section = s;
6338         break;
6339       }
6340
6341   for (s = output_bfd->sections; s != NULL; s = s->next)
6342     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6343          == (SEC_ALLOC | SEC_READONLY))
6344         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6345       {
6346         elf_hash_table (info)->text_index_section = s;
6347         break;
6348       }
6349
6350   if (elf_hash_table (info)->text_index_section == NULL)
6351     elf_hash_table (info)->text_index_section
6352       = elf_hash_table (info)->data_index_section;
6353 }
6354
6355 bfd_boolean
6356 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6357 {
6358   const struct elf_backend_data *bed;
6359
6360   if (!is_elf_hash_table (info->hash))
6361     return TRUE;
6362
6363   bed = get_elf_backend_data (output_bfd);
6364   (*bed->elf_backend_init_index_section) (output_bfd, info);
6365
6366   if (elf_hash_table (info)->dynamic_sections_created)
6367     {
6368       bfd *dynobj;
6369       asection *s;
6370       bfd_size_type dynsymcount;
6371       unsigned long section_sym_count;
6372       unsigned int dtagcount;
6373
6374       dynobj = elf_hash_table (info)->dynobj;
6375
6376       /* Assign dynsym indicies.  In a shared library we generate a
6377          section symbol for each output section, which come first.
6378          Next come all of the back-end allocated local dynamic syms,
6379          followed by the rest of the global symbols.  */
6380
6381       dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6382                                                     &section_sym_count);
6383
6384       /* Work out the size of the symbol version section.  */
6385       s = bfd_get_linker_section (dynobj, ".gnu.version");
6386       BFD_ASSERT (s != NULL);
6387       if (dynsymcount != 0
6388           && (s->flags & SEC_EXCLUDE) == 0)
6389         {
6390           s->size = dynsymcount * sizeof (Elf_External_Versym);
6391           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6392           if (s->contents == NULL)
6393             return FALSE;
6394
6395           if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6396             return FALSE;
6397         }
6398
6399       /* Set the size of the .dynsym and .hash sections.  We counted
6400          the number of dynamic symbols in elf_link_add_object_symbols.
6401          We will build the contents of .dynsym and .hash when we build
6402          the final symbol table, because until then we do not know the
6403          correct value to give the symbols.  We built the .dynstr
6404          section as we went along in elf_link_add_object_symbols.  */
6405       s = bfd_get_linker_section (dynobj, ".dynsym");
6406       BFD_ASSERT (s != NULL);
6407       s->size = dynsymcount * bed->s->sizeof_sym;
6408
6409       if (dynsymcount != 0)
6410         {
6411           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6412           if (s->contents == NULL)
6413             return FALSE;
6414
6415           /* The first entry in .dynsym is a dummy symbol.
6416              Clear all the section syms, in case we don't output them all.  */
6417           ++section_sym_count;
6418           memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6419         }
6420
6421       elf_hash_table (info)->bucketcount = 0;
6422
6423       /* Compute the size of the hashing table.  As a side effect this
6424          computes the hash values for all the names we export.  */
6425       if (info->emit_hash)
6426         {
6427           unsigned long int *hashcodes;
6428           struct hash_codes_info hashinf;
6429           bfd_size_type amt;
6430           unsigned long int nsyms;
6431           size_t bucketcount;
6432           size_t hash_entry_size;
6433
6434           /* Compute the hash values for all exported symbols.  At the same
6435              time store the values in an array so that we could use them for
6436              optimizations.  */
6437           amt = dynsymcount * sizeof (unsigned long int);
6438           hashcodes = (unsigned long int *) bfd_malloc (amt);
6439           if (hashcodes == NULL)
6440             return FALSE;
6441           hashinf.hashcodes = hashcodes;
6442           hashinf.error = FALSE;
6443
6444           /* Put all hash values in HASHCODES.  */
6445           elf_link_hash_traverse (elf_hash_table (info),
6446                                   elf_collect_hash_codes, &hashinf);
6447           if (hashinf.error)
6448             {
6449               free (hashcodes);
6450               return FALSE;
6451             }
6452
6453           nsyms = hashinf.hashcodes - hashcodes;
6454           bucketcount
6455             = compute_bucket_count (info, hashcodes, nsyms, 0);
6456           free (hashcodes);
6457
6458           if (bucketcount == 0)
6459             return FALSE;
6460
6461           elf_hash_table (info)->bucketcount = bucketcount;
6462
6463           s = bfd_get_linker_section (dynobj, ".hash");
6464           BFD_ASSERT (s != NULL);
6465           hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6466           s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6467           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6468           if (s->contents == NULL)
6469             return FALSE;
6470
6471           bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6472           bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6473                    s->contents + hash_entry_size);
6474         }
6475
6476       if (info->emit_gnu_hash)
6477         {
6478           size_t i, cnt;
6479           unsigned char *contents;
6480           struct collect_gnu_hash_codes cinfo;
6481           bfd_size_type amt;
6482           size_t bucketcount;
6483
6484           memset (&cinfo, 0, sizeof (cinfo));
6485
6486           /* Compute the hash values for all exported symbols.  At the same
6487              time store the values in an array so that we could use them for
6488              optimizations.  */
6489           amt = dynsymcount * 2 * sizeof (unsigned long int);
6490           cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6491           if (cinfo.hashcodes == NULL)
6492             return FALSE;
6493
6494           cinfo.hashval = cinfo.hashcodes + dynsymcount;
6495           cinfo.min_dynindx = -1;
6496           cinfo.output_bfd = output_bfd;
6497           cinfo.bed = bed;
6498
6499           /* Put all hash values in HASHCODES.  */
6500           elf_link_hash_traverse (elf_hash_table (info),
6501                                   elf_collect_gnu_hash_codes, &cinfo);
6502           if (cinfo.error)
6503             {
6504               free (cinfo.hashcodes);
6505               return FALSE;
6506             }
6507
6508           bucketcount
6509             = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6510
6511           if (bucketcount == 0)
6512             {
6513               free (cinfo.hashcodes);
6514               return FALSE;
6515             }
6516
6517           s = bfd_get_linker_section (dynobj, ".gnu.hash");
6518           BFD_ASSERT (s != NULL);
6519
6520           if (cinfo.nsyms == 0)
6521             {
6522               /* Empty .gnu.hash section is special.  */
6523               BFD_ASSERT (cinfo.min_dynindx == -1);
6524               free (cinfo.hashcodes);
6525               s->size = 5 * 4 + bed->s->arch_size / 8;
6526               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6527               if (contents == NULL)
6528                 return FALSE;
6529               s->contents = contents;
6530               /* 1 empty bucket.  */
6531               bfd_put_32 (output_bfd, 1, contents);
6532               /* SYMIDX above the special symbol 0.  */
6533               bfd_put_32 (output_bfd, 1, contents + 4);
6534               /* Just one word for bitmask.  */
6535               bfd_put_32 (output_bfd, 1, contents + 8);
6536               /* Only hash fn bloom filter.  */
6537               bfd_put_32 (output_bfd, 0, contents + 12);
6538               /* No hashes are valid - empty bitmask.  */
6539               bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6540               /* No hashes in the only bucket.  */
6541               bfd_put_32 (output_bfd, 0,
6542                           contents + 16 + bed->s->arch_size / 8);
6543             }
6544           else
6545             {
6546               unsigned long int maskwords, maskbitslog2, x;
6547               BFD_ASSERT (cinfo.min_dynindx != -1);
6548
6549               x = cinfo.nsyms;
6550               maskbitslog2 = 1;
6551               while ((x >>= 1) != 0)
6552                 ++maskbitslog2;
6553               if (maskbitslog2 < 3)
6554                 maskbitslog2 = 5;
6555               else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6556                 maskbitslog2 = maskbitslog2 + 3;
6557               else
6558                 maskbitslog2 = maskbitslog2 + 2;
6559               if (bed->s->arch_size == 64)
6560                 {
6561                   if (maskbitslog2 == 5)
6562                     maskbitslog2 = 6;
6563                   cinfo.shift1 = 6;
6564                 }
6565               else
6566                 cinfo.shift1 = 5;
6567               cinfo.mask = (1 << cinfo.shift1) - 1;
6568               cinfo.shift2 = maskbitslog2;
6569               cinfo.maskbits = 1 << maskbitslog2;
6570               maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6571               amt = bucketcount * sizeof (unsigned long int) * 2;
6572               amt += maskwords * sizeof (bfd_vma);
6573               cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6574               if (cinfo.bitmask == NULL)
6575                 {
6576                   free (cinfo.hashcodes);
6577                   return FALSE;
6578                 }
6579
6580               cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6581               cinfo.indx = cinfo.counts + bucketcount;
6582               cinfo.symindx = dynsymcount - cinfo.nsyms;
6583               memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6584
6585               /* Determine how often each hash bucket is used.  */
6586               memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6587               for (i = 0; i < cinfo.nsyms; ++i)
6588                 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6589
6590               for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6591                 if (cinfo.counts[i] != 0)
6592                   {
6593                     cinfo.indx[i] = cnt;
6594                     cnt += cinfo.counts[i];
6595                   }
6596               BFD_ASSERT (cnt == dynsymcount);
6597               cinfo.bucketcount = bucketcount;
6598               cinfo.local_indx = cinfo.min_dynindx;
6599
6600               s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6601               s->size += cinfo.maskbits / 8;
6602               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6603               if (contents == NULL)
6604                 {
6605                   free (cinfo.bitmask);
6606                   free (cinfo.hashcodes);
6607                   return FALSE;
6608                 }
6609
6610               s->contents = contents;
6611               bfd_put_32 (output_bfd, bucketcount, contents);
6612               bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6613               bfd_put_32 (output_bfd, maskwords, contents + 8);
6614               bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6615               contents += 16 + cinfo.maskbits / 8;
6616
6617               for (i = 0; i < bucketcount; ++i)
6618                 {
6619                   if (cinfo.counts[i] == 0)
6620                     bfd_put_32 (output_bfd, 0, contents);
6621                   else
6622                     bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6623                   contents += 4;
6624                 }
6625
6626               cinfo.contents = contents;
6627
6628               /* Renumber dynamic symbols, populate .gnu.hash section.  */
6629               elf_link_hash_traverse (elf_hash_table (info),
6630                                       elf_renumber_gnu_hash_syms, &cinfo);
6631
6632               contents = s->contents + 16;
6633               for (i = 0; i < maskwords; ++i)
6634                 {
6635                   bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6636                            contents);
6637                   contents += bed->s->arch_size / 8;
6638                 }
6639
6640               free (cinfo.bitmask);
6641               free (cinfo.hashcodes);
6642             }
6643         }
6644
6645       s = bfd_get_linker_section (dynobj, ".dynstr");
6646       BFD_ASSERT (s != NULL);
6647
6648       elf_finalize_dynstr (output_bfd, info);
6649
6650       s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6651
6652       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6653         if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6654           return FALSE;
6655     }
6656
6657   return TRUE;
6658 }
6659 \f
6660 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
6661
6662 static void
6663 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6664                             asection *sec)
6665 {
6666   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
6667   sec->sec_info_type = SEC_INFO_TYPE_NONE;
6668 }
6669
6670 /* Finish SHF_MERGE section merging.  */
6671
6672 bfd_boolean
6673 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6674 {
6675   bfd *ibfd;
6676   asection *sec;
6677
6678   if (!is_elf_hash_table (info->hash))
6679     return FALSE;
6680
6681   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6682     if ((ibfd->flags & DYNAMIC) == 0)
6683       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6684         if ((sec->flags & SEC_MERGE) != 0
6685             && !bfd_is_abs_section (sec->output_section))
6686           {
6687             struct bfd_elf_section_data *secdata;
6688
6689             secdata = elf_section_data (sec);
6690             if (! _bfd_add_merge_section (abfd,
6691                                           &elf_hash_table (info)->merge_info,
6692                                           sec, &secdata->sec_info))
6693               return FALSE;
6694             else if (secdata->sec_info)
6695               sec->sec_info_type = SEC_INFO_TYPE_MERGE;
6696           }
6697
6698   if (elf_hash_table (info)->merge_info != NULL)
6699     _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6700                          merge_sections_remove_hook);
6701   return TRUE;
6702 }
6703
6704 /* Create an entry in an ELF linker hash table.  */
6705
6706 struct bfd_hash_entry *
6707 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6708                             struct bfd_hash_table *table,
6709                             const char *string)
6710 {
6711   /* Allocate the structure if it has not already been allocated by a
6712      subclass.  */
6713   if (entry == NULL)
6714     {
6715       entry = (struct bfd_hash_entry *)
6716         bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6717       if (entry == NULL)
6718         return entry;
6719     }
6720
6721   /* Call the allocation method of the superclass.  */
6722   entry = _bfd_link_hash_newfunc (entry, table, string);
6723   if (entry != NULL)
6724     {
6725       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6726       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6727
6728       /* Set local fields.  */
6729       ret->indx = -1;
6730       ret->dynindx = -1;
6731       ret->got = htab->init_got_refcount;
6732       ret->plt = htab->init_plt_refcount;
6733       memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6734                               - offsetof (struct elf_link_hash_entry, size)));
6735       /* Assume that we have been called by a non-ELF symbol reader.
6736          This flag is then reset by the code which reads an ELF input
6737          file.  This ensures that a symbol created by a non-ELF symbol
6738          reader will have the flag set correctly.  */
6739       ret->non_elf = 1;
6740     }
6741
6742   return entry;
6743 }
6744
6745 /* Copy data from an indirect symbol to its direct symbol, hiding the
6746    old indirect symbol.  Also used for copying flags to a weakdef.  */
6747
6748 void
6749 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6750                                   struct elf_link_hash_entry *dir,
6751                                   struct elf_link_hash_entry *ind)
6752 {
6753   struct elf_link_hash_table *htab;
6754
6755   /* Copy down any references that we may have already seen to the
6756      symbol which just became indirect.  */
6757
6758   dir->ref_dynamic |= ind->ref_dynamic;
6759   dir->ref_regular |= ind->ref_regular;
6760   dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6761   dir->non_got_ref |= ind->non_got_ref;
6762   dir->needs_plt |= ind->needs_plt;
6763   dir->pointer_equality_needed |= ind->pointer_equality_needed;
6764
6765   if (ind->root.type != bfd_link_hash_indirect)
6766     return;
6767
6768   /* Copy over the global and procedure linkage table refcount entries.
6769      These may have been already set up by a check_relocs routine.  */
6770   htab = elf_hash_table (info);
6771   if (ind->got.refcount > htab->init_got_refcount.refcount)
6772     {
6773       if (dir->got.refcount < 0)
6774         dir->got.refcount = 0;
6775       dir->got.refcount += ind->got.refcount;
6776       ind->got.refcount = htab->init_got_refcount.refcount;
6777     }
6778
6779   if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6780     {
6781       if (dir->plt.refcount < 0)
6782         dir->plt.refcount = 0;
6783       dir->plt.refcount += ind->plt.refcount;
6784       ind->plt.refcount = htab->init_plt_refcount.refcount;
6785     }
6786
6787   if (ind->dynindx != -1)
6788     {
6789       if (dir->dynindx != -1)
6790         _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6791       dir->dynindx = ind->dynindx;
6792       dir->dynstr_index = ind->dynstr_index;
6793       ind->dynindx = -1;
6794       ind->dynstr_index = 0;
6795     }
6796 }
6797
6798 void
6799 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6800                                 struct elf_link_hash_entry *h,
6801                                 bfd_boolean force_local)
6802 {
6803   /* STT_GNU_IFUNC symbol must go through PLT.  */
6804   if (h->type != STT_GNU_IFUNC)
6805     {
6806       h->plt = elf_hash_table (info)->init_plt_offset;
6807       h->needs_plt = 0;
6808     }
6809   if (force_local)
6810     {
6811       h->forced_local = 1;
6812       if (h->dynindx != -1)
6813         {
6814           h->dynindx = -1;
6815           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6816                                   h->dynstr_index);
6817         }
6818     }
6819 }
6820
6821 /* Initialize an ELF linker hash table.  *TABLE has been zeroed by our
6822    caller.  */
6823
6824 bfd_boolean
6825 _bfd_elf_link_hash_table_init
6826   (struct elf_link_hash_table *table,
6827    bfd *abfd,
6828    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6829                                       struct bfd_hash_table *,
6830                                       const char *),
6831    unsigned int entsize,
6832    enum elf_target_id target_id)
6833 {
6834   bfd_boolean ret;
6835   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6836
6837   table->init_got_refcount.refcount = can_refcount - 1;
6838   table->init_plt_refcount.refcount = can_refcount - 1;
6839   table->init_got_offset.offset = -(bfd_vma) 1;
6840   table->init_plt_offset.offset = -(bfd_vma) 1;
6841   /* The first dynamic symbol is a dummy.  */
6842   table->dynsymcount = 1;
6843
6844   ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6845
6846   table->root.type = bfd_link_elf_hash_table;
6847   table->hash_table_id = target_id;
6848
6849   return ret;
6850 }
6851
6852 /* Create an ELF linker hash table.  */
6853
6854 struct bfd_link_hash_table *
6855 _bfd_elf_link_hash_table_create (bfd *abfd)
6856 {
6857   struct elf_link_hash_table *ret;
6858   bfd_size_type amt = sizeof (struct elf_link_hash_table);
6859
6860   ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
6861   if (ret == NULL)
6862     return NULL;
6863
6864   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6865                                        sizeof (struct elf_link_hash_entry),
6866                                        GENERIC_ELF_DATA))
6867     {
6868       free (ret);
6869       return NULL;
6870     }
6871   ret->root.hash_table_free = _bfd_elf_link_hash_table_free;
6872
6873   return &ret->root;
6874 }
6875
6876 /* Destroy an ELF linker hash table.  */
6877
6878 void
6879 _bfd_elf_link_hash_table_free (bfd *obfd)
6880 {
6881   struct elf_link_hash_table *htab;
6882
6883   htab = (struct elf_link_hash_table *) obfd->link.hash;
6884   if (htab->dynstr != NULL)
6885     _bfd_elf_strtab_free (htab->dynstr);
6886   _bfd_merge_sections_free (htab->merge_info);
6887   _bfd_generic_link_hash_table_free (obfd);
6888 }
6889
6890 /* This is a hook for the ELF emulation code in the generic linker to
6891    tell the backend linker what file name to use for the DT_NEEDED
6892    entry for a dynamic object.  */
6893
6894 void
6895 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6896 {
6897   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6898       && bfd_get_format (abfd) == bfd_object)
6899     elf_dt_name (abfd) = name;
6900 }
6901
6902 int
6903 bfd_elf_get_dyn_lib_class (bfd *abfd)
6904 {
6905   int lib_class;
6906   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6907       && bfd_get_format (abfd) == bfd_object)
6908     lib_class = elf_dyn_lib_class (abfd);
6909   else
6910     lib_class = 0;
6911   return lib_class;
6912 }
6913
6914 void
6915 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6916 {
6917   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6918       && bfd_get_format (abfd) == bfd_object)
6919     elf_dyn_lib_class (abfd) = lib_class;
6920 }
6921
6922 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
6923    the linker ELF emulation code.  */
6924
6925 struct bfd_link_needed_list *
6926 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6927                          struct bfd_link_info *info)
6928 {
6929   if (! is_elf_hash_table (info->hash))
6930     return NULL;
6931   return elf_hash_table (info)->needed;
6932 }
6933
6934 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
6935    hook for the linker ELF emulation code.  */
6936
6937 struct bfd_link_needed_list *
6938 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6939                           struct bfd_link_info *info)
6940 {
6941   if (! is_elf_hash_table (info->hash))
6942     return NULL;
6943   return elf_hash_table (info)->runpath;
6944 }
6945
6946 /* Get the name actually used for a dynamic object for a link.  This
6947    is the SONAME entry if there is one.  Otherwise, it is the string
6948    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
6949
6950 const char *
6951 bfd_elf_get_dt_soname (bfd *abfd)
6952 {
6953   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6954       && bfd_get_format (abfd) == bfd_object)
6955     return elf_dt_name (abfd);
6956   return NULL;
6957 }
6958
6959 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
6960    the ELF linker emulation code.  */
6961
6962 bfd_boolean
6963 bfd_elf_get_bfd_needed_list (bfd *abfd,
6964                              struct bfd_link_needed_list **pneeded)
6965 {
6966   asection *s;
6967   bfd_byte *dynbuf = NULL;
6968   unsigned int elfsec;
6969   unsigned long shlink;
6970   bfd_byte *extdyn, *extdynend;
6971   size_t extdynsize;
6972   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6973
6974   *pneeded = NULL;
6975
6976   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6977       || bfd_get_format (abfd) != bfd_object)
6978     return TRUE;
6979
6980   s = bfd_get_section_by_name (abfd, ".dynamic");
6981   if (s == NULL || s->size == 0)
6982     return TRUE;
6983
6984   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6985     goto error_return;
6986
6987   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
6988   if (elfsec == SHN_BAD)
6989     goto error_return;
6990
6991   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
6992
6993   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6994   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6995
6996   extdyn = dynbuf;
6997   extdynend = extdyn + s->size;
6998   for (; extdyn < extdynend; extdyn += extdynsize)
6999     {
7000       Elf_Internal_Dyn dyn;
7001
7002       (*swap_dyn_in) (abfd, extdyn, &dyn);
7003
7004       if (dyn.d_tag == DT_NULL)
7005         break;
7006
7007       if (dyn.d_tag == DT_NEEDED)
7008         {
7009           const char *string;
7010           struct bfd_link_needed_list *l;
7011           unsigned int tagv = dyn.d_un.d_val;
7012           bfd_size_type amt;
7013
7014           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
7015           if (string == NULL)
7016             goto error_return;
7017
7018           amt = sizeof *l;
7019           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7020           if (l == NULL)
7021             goto error_return;
7022
7023           l->by = abfd;
7024           l->name = string;
7025           l->next = *pneeded;
7026           *pneeded = l;
7027         }
7028     }
7029
7030   free (dynbuf);
7031
7032   return TRUE;
7033
7034  error_return:
7035   if (dynbuf != NULL)
7036     free (dynbuf);
7037   return FALSE;
7038 }
7039
7040 struct elf_symbuf_symbol
7041 {
7042   unsigned long st_name;        /* Symbol name, index in string tbl */
7043   unsigned char st_info;        /* Type and binding attributes */
7044   unsigned char st_other;       /* Visibilty, and target specific */
7045 };
7046
7047 struct elf_symbuf_head
7048 {
7049   struct elf_symbuf_symbol *ssym;
7050   bfd_size_type count;
7051   unsigned int st_shndx;
7052 };
7053
7054 struct elf_symbol
7055 {
7056   union
7057     {
7058       Elf_Internal_Sym *isym;
7059       struct elf_symbuf_symbol *ssym;
7060     } u;
7061   const char *name;
7062 };
7063
7064 /* Sort references to symbols by ascending section number.  */
7065
7066 static int
7067 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7068 {
7069   const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7070   const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7071
7072   return s1->st_shndx - s2->st_shndx;
7073 }
7074
7075 static int
7076 elf_sym_name_compare (const void *arg1, const void *arg2)
7077 {
7078   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7079   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7080   return strcmp (s1->name, s2->name);
7081 }
7082
7083 static struct elf_symbuf_head *
7084 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7085 {
7086   Elf_Internal_Sym **ind, **indbufend, **indbuf;
7087   struct elf_symbuf_symbol *ssym;
7088   struct elf_symbuf_head *ssymbuf, *ssymhead;
7089   bfd_size_type i, shndx_count, total_size;
7090
7091   indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7092   if (indbuf == NULL)
7093     return NULL;
7094
7095   for (ind = indbuf, i = 0; i < symcount; i++)
7096     if (isymbuf[i].st_shndx != SHN_UNDEF)
7097       *ind++ = &isymbuf[i];
7098   indbufend = ind;
7099
7100   qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7101          elf_sort_elf_symbol);
7102
7103   shndx_count = 0;
7104   if (indbufend > indbuf)
7105     for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7106       if (ind[0]->st_shndx != ind[1]->st_shndx)
7107         shndx_count++;
7108
7109   total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7110                 + (indbufend - indbuf) * sizeof (*ssym));
7111   ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7112   if (ssymbuf == NULL)
7113     {
7114       free (indbuf);
7115       return NULL;
7116     }
7117
7118   ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7119   ssymbuf->ssym = NULL;
7120   ssymbuf->count = shndx_count;
7121   ssymbuf->st_shndx = 0;
7122   for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7123     {
7124       if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7125         {
7126           ssymhead++;
7127           ssymhead->ssym = ssym;
7128           ssymhead->count = 0;
7129           ssymhead->st_shndx = (*ind)->st_shndx;
7130         }
7131       ssym->st_name = (*ind)->st_name;
7132       ssym->st_info = (*ind)->st_info;
7133       ssym->st_other = (*ind)->st_other;
7134       ssymhead->count++;
7135     }
7136   BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7137               && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7138                   == total_size));
7139
7140   free (indbuf);
7141   return ssymbuf;
7142 }
7143
7144 /* Check if 2 sections define the same set of local and global
7145    symbols.  */
7146
7147 static bfd_boolean
7148 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7149                                    struct bfd_link_info *info)
7150 {
7151   bfd *bfd1, *bfd2;
7152   const struct elf_backend_data *bed1, *bed2;
7153   Elf_Internal_Shdr *hdr1, *hdr2;
7154   bfd_size_type symcount1, symcount2;
7155   Elf_Internal_Sym *isymbuf1, *isymbuf2;
7156   struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7157   Elf_Internal_Sym *isym, *isymend;
7158   struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7159   bfd_size_type count1, count2, i;
7160   unsigned int shndx1, shndx2;
7161   bfd_boolean result;
7162
7163   bfd1 = sec1->owner;
7164   bfd2 = sec2->owner;
7165
7166   /* Both sections have to be in ELF.  */
7167   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7168       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7169     return FALSE;
7170
7171   if (elf_section_type (sec1) != elf_section_type (sec2))
7172     return FALSE;
7173
7174   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7175   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7176   if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7177     return FALSE;
7178
7179   bed1 = get_elf_backend_data (bfd1);
7180   bed2 = get_elf_backend_data (bfd2);
7181   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7182   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7183   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7184   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7185
7186   if (symcount1 == 0 || symcount2 == 0)
7187     return FALSE;
7188
7189   result = FALSE;
7190   isymbuf1 = NULL;
7191   isymbuf2 = NULL;
7192   ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7193   ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7194
7195   if (ssymbuf1 == NULL)
7196     {
7197       isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7198                                        NULL, NULL, NULL);
7199       if (isymbuf1 == NULL)
7200         goto done;
7201
7202       if (!info->reduce_memory_overheads)
7203         elf_tdata (bfd1)->symbuf = ssymbuf1
7204           = elf_create_symbuf (symcount1, isymbuf1);
7205     }
7206
7207   if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7208     {
7209       isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7210                                        NULL, NULL, NULL);
7211       if (isymbuf2 == NULL)
7212         goto done;
7213
7214       if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7215         elf_tdata (bfd2)->symbuf = ssymbuf2
7216           = elf_create_symbuf (symcount2, isymbuf2);
7217     }
7218
7219   if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7220     {
7221       /* Optimized faster version.  */
7222       bfd_size_type lo, hi, mid;
7223       struct elf_symbol *symp;
7224       struct elf_symbuf_symbol *ssym, *ssymend;
7225
7226       lo = 0;
7227       hi = ssymbuf1->count;
7228       ssymbuf1++;
7229       count1 = 0;
7230       while (lo < hi)
7231         {
7232           mid = (lo + hi) / 2;
7233           if (shndx1 < ssymbuf1[mid].st_shndx)
7234             hi = mid;
7235           else if (shndx1 > ssymbuf1[mid].st_shndx)
7236             lo = mid + 1;
7237           else
7238             {
7239               count1 = ssymbuf1[mid].count;
7240               ssymbuf1 += mid;
7241               break;
7242             }
7243         }
7244
7245       lo = 0;
7246       hi = ssymbuf2->count;
7247       ssymbuf2++;
7248       count2 = 0;
7249       while (lo < hi)
7250         {
7251           mid = (lo + hi) / 2;
7252           if (shndx2 < ssymbuf2[mid].st_shndx)
7253             hi = mid;
7254           else if (shndx2 > ssymbuf2[mid].st_shndx)
7255             lo = mid + 1;
7256           else
7257             {
7258               count2 = ssymbuf2[mid].count;
7259               ssymbuf2 += mid;
7260               break;
7261             }
7262         }
7263
7264       if (count1 == 0 || count2 == 0 || count1 != count2)
7265         goto done;
7266
7267       symtable1
7268         = (struct elf_symbol *) bfd_malloc (count1 * sizeof (*symtable1));
7269       symtable2
7270         = (struct elf_symbol *) bfd_malloc (count2 * sizeof (*symtable2));
7271       if (symtable1 == NULL || symtable2 == NULL)
7272         goto done;
7273
7274       symp = symtable1;
7275       for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7276            ssym < ssymend; ssym++, symp++)
7277         {
7278           symp->u.ssym = ssym;
7279           symp->name = bfd_elf_string_from_elf_section (bfd1,
7280                                                         hdr1->sh_link,
7281                                                         ssym->st_name);
7282         }
7283
7284       symp = symtable2;
7285       for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7286            ssym < ssymend; ssym++, symp++)
7287         {
7288           symp->u.ssym = ssym;
7289           symp->name = bfd_elf_string_from_elf_section (bfd2,
7290                                                         hdr2->sh_link,
7291                                                         ssym->st_name);
7292         }
7293
7294       /* Sort symbol by name.  */
7295       qsort (symtable1, count1, sizeof (struct elf_symbol),
7296              elf_sym_name_compare);
7297       qsort (symtable2, count1, sizeof (struct elf_symbol),
7298              elf_sym_name_compare);
7299
7300       for (i = 0; i < count1; i++)
7301         /* Two symbols must have the same binding, type and name.  */
7302         if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7303             || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7304             || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7305           goto done;
7306
7307       result = TRUE;
7308       goto done;
7309     }
7310
7311   symtable1 = (struct elf_symbol *)
7312       bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7313   symtable2 = (struct elf_symbol *)
7314       bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7315   if (symtable1 == NULL || symtable2 == NULL)
7316     goto done;
7317
7318   /* Count definitions in the section.  */
7319   count1 = 0;
7320   for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7321     if (isym->st_shndx == shndx1)
7322       symtable1[count1++].u.isym = isym;
7323
7324   count2 = 0;
7325   for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7326     if (isym->st_shndx == shndx2)
7327       symtable2[count2++].u.isym = isym;
7328
7329   if (count1 == 0 || count2 == 0 || count1 != count2)
7330     goto done;
7331
7332   for (i = 0; i < count1; i++)
7333     symtable1[i].name
7334       = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7335                                          symtable1[i].u.isym->st_name);
7336
7337   for (i = 0; i < count2; i++)
7338     symtable2[i].name
7339       = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7340                                          symtable2[i].u.isym->st_name);
7341
7342   /* Sort symbol by name.  */
7343   qsort (symtable1, count1, sizeof (struct elf_symbol),
7344          elf_sym_name_compare);
7345   qsort (symtable2, count1, sizeof (struct elf_symbol),
7346          elf_sym_name_compare);
7347
7348   for (i = 0; i < count1; i++)
7349     /* Two symbols must have the same binding, type and name.  */
7350     if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7351         || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7352         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7353       goto done;
7354
7355   result = TRUE;
7356
7357 done:
7358   if (symtable1)
7359     free (symtable1);
7360   if (symtable2)
7361     free (symtable2);
7362   if (isymbuf1)
7363     free (isymbuf1);
7364   if (isymbuf2)
7365     free (isymbuf2);
7366
7367   return result;
7368 }
7369
7370 /* Return TRUE if 2 section types are compatible.  */
7371
7372 bfd_boolean
7373 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7374                                  bfd *bbfd, const asection *bsec)
7375 {
7376   if (asec == NULL
7377       || bsec == NULL
7378       || abfd->xvec->flavour != bfd_target_elf_flavour
7379       || bbfd->xvec->flavour != bfd_target_elf_flavour)
7380     return TRUE;
7381
7382   return elf_section_type (asec) == elf_section_type (bsec);
7383 }
7384 \f
7385 /* Final phase of ELF linker.  */
7386
7387 /* A structure we use to avoid passing large numbers of arguments.  */
7388
7389 struct elf_final_link_info
7390 {
7391   /* General link information.  */
7392   struct bfd_link_info *info;
7393   /* Output BFD.  */
7394   bfd *output_bfd;
7395   /* Symbol string table.  */
7396   struct bfd_strtab_hash *symstrtab;
7397   /* .dynsym section.  */
7398   asection *dynsym_sec;
7399   /* .hash section.  */
7400   asection *hash_sec;
7401   /* symbol version section (.gnu.version).  */
7402   asection *symver_sec;
7403   /* Buffer large enough to hold contents of any section.  */
7404   bfd_byte *contents;
7405   /* Buffer large enough to hold external relocs of any section.  */
7406   void *external_relocs;
7407   /* Buffer large enough to hold internal relocs of any section.  */
7408   Elf_Internal_Rela *internal_relocs;
7409   /* Buffer large enough to hold external local symbols of any input
7410      BFD.  */
7411   bfd_byte *external_syms;
7412   /* And a buffer for symbol section indices.  */
7413   Elf_External_Sym_Shndx *locsym_shndx;
7414   /* Buffer large enough to hold internal local symbols of any input
7415      BFD.  */
7416   Elf_Internal_Sym *internal_syms;
7417   /* Array large enough to hold a symbol index for each local symbol
7418      of any input BFD.  */
7419   long *indices;
7420   /* Array large enough to hold a section pointer for each local
7421      symbol of any input BFD.  */
7422   asection **sections;
7423   /* Buffer to hold swapped out symbols.  */
7424   bfd_byte *symbuf;
7425   /* And one for symbol section indices.  */
7426   Elf_External_Sym_Shndx *symshndxbuf;
7427   /* Number of swapped out symbols in buffer.  */
7428   size_t symbuf_count;
7429   /* Number of symbols which fit in symbuf.  */
7430   size_t symbuf_size;
7431   /* And same for symshndxbuf.  */
7432   size_t shndxbuf_size;
7433   /* Number of STT_FILE syms seen.  */
7434   size_t filesym_count;
7435 };
7436
7437 /* This struct is used to pass information to elf_link_output_extsym.  */
7438
7439 struct elf_outext_info
7440 {
7441   bfd_boolean failed;
7442   bfd_boolean localsyms;
7443   bfd_boolean file_sym_done;
7444   struct elf_final_link_info *flinfo;
7445 };
7446
7447
7448 /* Support for evaluating a complex relocation.
7449
7450    Complex relocations are generalized, self-describing relocations.  The
7451    implementation of them consists of two parts: complex symbols, and the
7452    relocations themselves.
7453
7454    The relocations are use a reserved elf-wide relocation type code (R_RELC
7455    external / BFD_RELOC_RELC internal) and an encoding of relocation field
7456    information (start bit, end bit, word width, etc) into the addend.  This
7457    information is extracted from CGEN-generated operand tables within gas.
7458
7459    Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7460    internal) representing prefix-notation expressions, including but not
7461    limited to those sorts of expressions normally encoded as addends in the
7462    addend field.  The symbol mangling format is:
7463
7464    <node> := <literal>
7465           |  <unary-operator> ':' <node>
7466           |  <binary-operator> ':' <node> ':' <node>
7467           ;
7468
7469    <literal> := 's' <digits=N> ':' <N character symbol name>
7470              |  'S' <digits=N> ':' <N character section name>
7471              |  '#' <hexdigits>
7472              ;
7473
7474    <binary-operator> := as in C
7475    <unary-operator> := as in C, plus "0-" for unambiguous negation.  */
7476
7477 static void
7478 set_symbol_value (bfd *bfd_with_globals,
7479                   Elf_Internal_Sym *isymbuf,
7480                   size_t locsymcount,
7481                   size_t symidx,
7482                   bfd_vma val)
7483 {
7484   struct elf_link_hash_entry **sym_hashes;
7485   struct elf_link_hash_entry *h;
7486   size_t extsymoff = locsymcount;
7487
7488   if (symidx < locsymcount)
7489     {
7490       Elf_Internal_Sym *sym;
7491
7492       sym = isymbuf + symidx;
7493       if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7494         {
7495           /* It is a local symbol: move it to the
7496              "absolute" section and give it a value.  */
7497           sym->st_shndx = SHN_ABS;
7498           sym->st_value = val;
7499           return;
7500         }
7501       BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7502       extsymoff = 0;
7503     }
7504
7505   /* It is a global symbol: set its link type
7506      to "defined" and give it a value.  */
7507
7508   sym_hashes = elf_sym_hashes (bfd_with_globals);
7509   h = sym_hashes [symidx - extsymoff];
7510   while (h->root.type == bfd_link_hash_indirect
7511          || h->root.type == bfd_link_hash_warning)
7512     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7513   h->root.type = bfd_link_hash_defined;
7514   h->root.u.def.value = val;
7515   h->root.u.def.section = bfd_abs_section_ptr;
7516 }
7517
7518 static bfd_boolean
7519 resolve_symbol (const char *name,
7520                 bfd *input_bfd,
7521                 struct elf_final_link_info *flinfo,
7522                 bfd_vma *result,
7523                 Elf_Internal_Sym *isymbuf,
7524                 size_t locsymcount)
7525 {
7526   Elf_Internal_Sym *sym;
7527   struct bfd_link_hash_entry *global_entry;
7528   const char *candidate = NULL;
7529   Elf_Internal_Shdr *symtab_hdr;
7530   size_t i;
7531
7532   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7533
7534   for (i = 0; i < locsymcount; ++ i)
7535     {
7536       sym = isymbuf + i;
7537
7538       if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7539         continue;
7540
7541       candidate = bfd_elf_string_from_elf_section (input_bfd,
7542                                                    symtab_hdr->sh_link,
7543                                                    sym->st_name);
7544 #ifdef DEBUG
7545       printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7546               name, candidate, (unsigned long) sym->st_value);
7547 #endif
7548       if (candidate && strcmp (candidate, name) == 0)
7549         {
7550           asection *sec = flinfo->sections [i];
7551
7552           *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7553           *result += sec->output_offset + sec->output_section->vma;
7554 #ifdef DEBUG
7555           printf ("Found symbol with value %8.8lx\n",
7556                   (unsigned long) *result);
7557 #endif
7558           return TRUE;
7559         }
7560     }
7561
7562   /* Hmm, haven't found it yet. perhaps it is a global.  */
7563   global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
7564                                        FALSE, FALSE, TRUE);
7565   if (!global_entry)
7566     return FALSE;
7567
7568   if (global_entry->type == bfd_link_hash_defined
7569       || global_entry->type == bfd_link_hash_defweak)
7570     {
7571       *result = (global_entry->u.def.value
7572                  + global_entry->u.def.section->output_section->vma
7573                  + global_entry->u.def.section->output_offset);
7574 #ifdef DEBUG
7575       printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7576               global_entry->root.string, (unsigned long) *result);
7577 #endif
7578       return TRUE;
7579     }
7580
7581   return FALSE;
7582 }
7583
7584 static bfd_boolean
7585 resolve_section (const char *name,
7586                  asection *sections,
7587                  bfd_vma *result)
7588 {
7589   asection *curr;
7590   unsigned int len;
7591
7592   for (curr = sections; curr; curr = curr->next)
7593     if (strcmp (curr->name, name) == 0)
7594       {
7595         *result = curr->vma;
7596         return TRUE;
7597       }
7598
7599   /* Hmm. still haven't found it. try pseudo-section names.  */
7600   for (curr = sections; curr; curr = curr->next)
7601     {
7602       len = strlen (curr->name);
7603       if (len > strlen (name))
7604         continue;
7605
7606       if (strncmp (curr->name, name, len) == 0)
7607         {
7608           if (strncmp (".end", name + len, 4) == 0)
7609             {
7610               *result = curr->vma + curr->size;
7611               return TRUE;
7612             }
7613
7614           /* Insert more pseudo-section names here, if you like.  */
7615         }
7616     }
7617
7618   return FALSE;
7619 }
7620
7621 static void
7622 undefined_reference (const char *reftype, const char *name)
7623 {
7624   _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7625                       reftype, name);
7626 }
7627
7628 static bfd_boolean
7629 eval_symbol (bfd_vma *result,
7630              const char **symp,
7631              bfd *input_bfd,
7632              struct elf_final_link_info *flinfo,
7633              bfd_vma dot,
7634              Elf_Internal_Sym *isymbuf,
7635              size_t locsymcount,
7636              int signed_p)
7637 {
7638   size_t len;
7639   size_t symlen;
7640   bfd_vma a;
7641   bfd_vma b;
7642   char symbuf[4096];
7643   const char *sym = *symp;
7644   const char *symend;
7645   bfd_boolean symbol_is_section = FALSE;
7646
7647   len = strlen (sym);
7648   symend = sym + len;
7649
7650   if (len < 1 || len > sizeof (symbuf))
7651     {
7652       bfd_set_error (bfd_error_invalid_operation);
7653       return FALSE;
7654     }
7655
7656   switch (* sym)
7657     {
7658     case '.':
7659       *result = dot;
7660       *symp = sym + 1;
7661       return TRUE;
7662
7663     case '#':
7664       ++sym;
7665       *result = strtoul (sym, (char **) symp, 16);
7666       return TRUE;
7667
7668     case 'S':
7669       symbol_is_section = TRUE;
7670     case 's':
7671       ++sym;
7672       symlen = strtol (sym, (char **) symp, 10);
7673       sym = *symp + 1; /* Skip the trailing ':'.  */
7674
7675       if (symend < sym || symlen + 1 > sizeof (symbuf))
7676         {
7677           bfd_set_error (bfd_error_invalid_operation);
7678           return FALSE;
7679         }
7680
7681       memcpy (symbuf, sym, symlen);
7682       symbuf[symlen] = '\0';
7683       *symp = sym + symlen;
7684
7685       /* Is it always possible, with complex symbols, that gas "mis-guessed"
7686          the symbol as a section, or vice-versa. so we're pretty liberal in our
7687          interpretation here; section means "try section first", not "must be a
7688          section", and likewise with symbol.  */
7689
7690       if (symbol_is_section)
7691         {
7692           if (!resolve_section (symbuf, flinfo->output_bfd->sections, result)
7693               && !resolve_symbol (symbuf, input_bfd, flinfo, result,
7694                                   isymbuf, locsymcount))
7695             {
7696               undefined_reference ("section", symbuf);
7697               return FALSE;
7698             }
7699         }
7700       else
7701         {
7702           if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
7703                                isymbuf, locsymcount)
7704               && !resolve_section (symbuf, flinfo->output_bfd->sections,
7705                                    result))
7706             {
7707               undefined_reference ("symbol", symbuf);
7708               return FALSE;
7709             }
7710         }
7711
7712       return TRUE;
7713
7714       /* All that remains are operators.  */
7715
7716 #define UNARY_OP(op)                                            \
7717   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7718     {                                                           \
7719       sym += strlen (#op);                                      \
7720       if (*sym == ':')                                          \
7721         ++sym;                                                  \
7722       *symp = sym;                                              \
7723       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
7724                         isymbuf, locsymcount, signed_p))        \
7725         return FALSE;                                           \
7726       if (signed_p)                                             \
7727         *result = op ((bfd_signed_vma) a);                      \
7728       else                                                      \
7729         *result = op a;                                         \
7730       return TRUE;                                              \
7731     }
7732
7733 #define BINARY_OP(op)                                           \
7734   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7735     {                                                           \
7736       sym += strlen (#op);                                      \
7737       if (*sym == ':')                                          \
7738         ++sym;                                                  \
7739       *symp = sym;                                              \
7740       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
7741                         isymbuf, locsymcount, signed_p))        \
7742         return FALSE;                                           \
7743       ++*symp;                                                  \
7744       if (!eval_symbol (&b, symp, input_bfd, flinfo, dot,       \
7745                         isymbuf, locsymcount, signed_p))        \
7746         return FALSE;                                           \
7747       if (signed_p)                                             \
7748         *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7749       else                                                      \
7750         *result = a op b;                                       \
7751       return TRUE;                                              \
7752     }
7753
7754     default:
7755       UNARY_OP  (0-);
7756       BINARY_OP (<<);
7757       BINARY_OP (>>);
7758       BINARY_OP (==);
7759       BINARY_OP (!=);
7760       BINARY_OP (<=);
7761       BINARY_OP (>=);
7762       BINARY_OP (&&);
7763       BINARY_OP (||);
7764       UNARY_OP  (~);
7765       UNARY_OP  (!);
7766       BINARY_OP (*);
7767       BINARY_OP (/);
7768       BINARY_OP (%);
7769       BINARY_OP (^);
7770       BINARY_OP (|);
7771       BINARY_OP (&);
7772       BINARY_OP (+);
7773       BINARY_OP (-);
7774       BINARY_OP (<);
7775       BINARY_OP (>);
7776 #undef UNARY_OP
7777 #undef BINARY_OP
7778       _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7779       bfd_set_error (bfd_error_invalid_operation);
7780       return FALSE;
7781     }
7782 }
7783
7784 static void
7785 put_value (bfd_vma size,
7786            unsigned long chunksz,
7787            bfd *input_bfd,
7788            bfd_vma x,
7789            bfd_byte *location)
7790 {
7791   location += (size - chunksz);
7792
7793   for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7794     {
7795       switch (chunksz)
7796         {
7797         default:
7798         case 0:
7799           abort ();
7800         case 1:
7801           bfd_put_8 (input_bfd, x, location);
7802           break;
7803         case 2:
7804           bfd_put_16 (input_bfd, x, location);
7805           break;
7806         case 4:
7807           bfd_put_32 (input_bfd, x, location);
7808           break;
7809         case 8:
7810 #ifdef BFD64
7811           bfd_put_64 (input_bfd, x, location);
7812 #else
7813           abort ();
7814 #endif
7815           break;
7816         }
7817     }
7818 }
7819
7820 static bfd_vma
7821 get_value (bfd_vma size,
7822            unsigned long chunksz,
7823            bfd *input_bfd,
7824            bfd_byte *location)
7825 {
7826   int shift;
7827   bfd_vma x = 0;
7828
7829   /* Sanity checks.  */
7830   BFD_ASSERT (chunksz <= sizeof (x)
7831               && size >= chunksz
7832               && chunksz != 0
7833               && (size % chunksz) == 0
7834               && input_bfd != NULL
7835               && location != NULL);
7836
7837   if (chunksz == sizeof (x))
7838     {
7839       BFD_ASSERT (size == chunksz);
7840
7841       /* Make sure that we do not perform an undefined shift operation.
7842          We know that size == chunksz so there will only be one iteration
7843          of the loop below.  */
7844       shift = 0;
7845     }
7846   else
7847     shift = 8 * chunksz;
7848
7849   for (; size; size -= chunksz, location += chunksz)
7850     {
7851       switch (chunksz)
7852         {
7853         case 1:
7854           x = (x << shift) | bfd_get_8 (input_bfd, location);
7855           break;
7856         case 2:
7857           x = (x << shift) | bfd_get_16 (input_bfd, location);
7858           break;
7859         case 4:
7860           x = (x << shift) | bfd_get_32 (input_bfd, location);
7861           break;
7862 #ifdef BFD64
7863         case 8:
7864           x = (x << shift) | bfd_get_64 (input_bfd, location);
7865           break;
7866 #endif
7867         default:
7868           abort ();
7869         }
7870     }
7871   return x;
7872 }
7873
7874 static void
7875 decode_complex_addend (unsigned long *start,   /* in bits */
7876                        unsigned long *oplen,   /* in bits */
7877                        unsigned long *len,     /* in bits */
7878                        unsigned long *wordsz,  /* in bytes */
7879                        unsigned long *chunksz, /* in bytes */
7880                        unsigned long *lsb0_p,
7881                        unsigned long *signed_p,
7882                        unsigned long *trunc_p,
7883                        unsigned long encoded)
7884 {
7885   * start     =  encoded        & 0x3F;
7886   * len       = (encoded >>  6) & 0x3F;
7887   * oplen     = (encoded >> 12) & 0x3F;
7888   * wordsz    = (encoded >> 18) & 0xF;
7889   * chunksz   = (encoded >> 22) & 0xF;
7890   * lsb0_p    = (encoded >> 27) & 1;
7891   * signed_p  = (encoded >> 28) & 1;
7892   * trunc_p   = (encoded >> 29) & 1;
7893 }
7894
7895 bfd_reloc_status_type
7896 bfd_elf_perform_complex_relocation (bfd *input_bfd,
7897                                     asection *input_section ATTRIBUTE_UNUSED,
7898                                     bfd_byte *contents,
7899                                     Elf_Internal_Rela *rel,
7900                                     bfd_vma relocation)
7901 {
7902   bfd_vma shift, x, mask;
7903   unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7904   bfd_reloc_status_type r;
7905
7906   /*  Perform this reloc, since it is complex.
7907       (this is not to say that it necessarily refers to a complex
7908       symbol; merely that it is a self-describing CGEN based reloc.
7909       i.e. the addend has the complete reloc information (bit start, end,
7910       word size, etc) encoded within it.).  */
7911
7912   decode_complex_addend (&start, &oplen, &len, &wordsz,
7913                          &chunksz, &lsb0_p, &signed_p,
7914                          &trunc_p, rel->r_addend);
7915
7916   mask = (((1L << (len - 1)) - 1) << 1) | 1;
7917
7918   if (lsb0_p)
7919     shift = (start + 1) - len;
7920   else
7921     shift = (8 * wordsz) - (start + len);
7922
7923   /* FIXME: octets_per_byte.  */
7924   x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7925
7926 #ifdef DEBUG
7927   printf ("Doing complex reloc: "
7928           "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7929           "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7930           "    dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7931           lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7932           oplen, (unsigned long) x, (unsigned long) mask,
7933           (unsigned long) relocation);
7934 #endif
7935
7936   r = bfd_reloc_ok;
7937   if (! trunc_p)
7938     /* Now do an overflow check.  */
7939     r = bfd_check_overflow ((signed_p
7940                              ? complain_overflow_signed
7941                              : complain_overflow_unsigned),
7942                             len, 0, (8 * wordsz),
7943                             relocation);
7944
7945   /* Do the deed.  */
7946   x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7947
7948 #ifdef DEBUG
7949   printf ("           relocation: %8.8lx\n"
7950           "         shifted mask: %8.8lx\n"
7951           " shifted/masked reloc: %8.8lx\n"
7952           "               result: %8.8lx\n",
7953           (unsigned long) relocation, (unsigned long) (mask << shift),
7954           (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
7955 #endif
7956   /* FIXME: octets_per_byte.  */
7957   put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7958   return r;
7959 }
7960
7961 /* qsort comparison functions sorting external relocs by r_offset.  */
7962
7963 static int
7964 cmp_ext32l_r_offset (const void *p, const void *q)
7965 {
7966   union aligned32
7967   {
7968     uint32_t v;
7969     unsigned char c[4];
7970   };
7971   const union aligned32 *a
7972     = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
7973   const union aligned32 *b
7974     = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
7975
7976   uint32_t aval = (  (uint32_t) a->c[0]
7977                    | (uint32_t) a->c[1] << 8
7978                    | (uint32_t) a->c[2] << 16
7979                    | (uint32_t) a->c[3] << 24);
7980   uint32_t bval = (  (uint32_t) b->c[0]
7981                    | (uint32_t) b->c[1] << 8
7982                    | (uint32_t) b->c[2] << 16
7983                    | (uint32_t) b->c[3] << 24);
7984   if (aval < bval)
7985     return -1;
7986   else if (aval > bval)
7987     return 1;
7988   return 0;
7989 }
7990
7991 static int
7992 cmp_ext32b_r_offset (const void *p, const void *q)
7993 {
7994   union aligned32
7995   {
7996     uint32_t v;
7997     unsigned char c[4];
7998   };
7999   const union aligned32 *a
8000     = (const union aligned32 *) ((const Elf32_External_Rel *) p)->r_offset;
8001   const union aligned32 *b
8002     = (const union aligned32 *) ((const Elf32_External_Rel *) q)->r_offset;
8003
8004   uint32_t aval = (  (uint32_t) a->c[0] << 24
8005                    | (uint32_t) a->c[1] << 16
8006                    | (uint32_t) a->c[2] << 8
8007                    | (uint32_t) a->c[3]);
8008   uint32_t bval = (  (uint32_t) b->c[0] << 24
8009                    | (uint32_t) b->c[1] << 16
8010                    | (uint32_t) b->c[2] << 8
8011                    | (uint32_t) b->c[3]);
8012   if (aval < bval)
8013     return -1;
8014   else if (aval > bval)
8015     return 1;
8016   return 0;
8017 }
8018
8019 #ifdef BFD_HOST_64_BIT
8020 static int
8021 cmp_ext64l_r_offset (const void *p, const void *q)
8022 {
8023   union aligned64
8024   {
8025     uint64_t v;
8026     unsigned char c[8];
8027   };
8028   const union aligned64 *a
8029     = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
8030   const union aligned64 *b
8031     = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
8032
8033   uint64_t aval = (  (uint64_t) a->c[0]
8034                    | (uint64_t) a->c[1] << 8
8035                    | (uint64_t) a->c[2] << 16
8036                    | (uint64_t) a->c[3] << 24
8037                    | (uint64_t) a->c[4] << 32
8038                    | (uint64_t) a->c[5] << 40
8039                    | (uint64_t) a->c[6] << 48
8040                    | (uint64_t) a->c[7] << 56);
8041   uint64_t bval = (  (uint64_t) b->c[0]
8042                    | (uint64_t) b->c[1] << 8
8043                    | (uint64_t) b->c[2] << 16
8044                    | (uint64_t) b->c[3] << 24
8045                    | (uint64_t) b->c[4] << 32
8046                    | (uint64_t) b->c[5] << 40
8047                    | (uint64_t) b->c[6] << 48
8048                    | (uint64_t) b->c[7] << 56);
8049   if (aval < bval)
8050     return -1;
8051   else if (aval > bval)
8052     return 1;
8053   return 0;
8054 }
8055
8056 static int
8057 cmp_ext64b_r_offset (const void *p, const void *q)
8058 {
8059   union aligned64
8060   {
8061     uint64_t v;
8062     unsigned char c[8];
8063   };
8064   const union aligned64 *a
8065     = (const union aligned64 *) ((const Elf64_External_Rel *) p)->r_offset;
8066   const union aligned64 *b
8067     = (const union aligned64 *) ((const Elf64_External_Rel *) q)->r_offset;
8068
8069   uint64_t aval = (  (uint64_t) a->c[0] << 56
8070                    | (uint64_t) a->c[1] << 48
8071                    | (uint64_t) a->c[2] << 40
8072                    | (uint64_t) a->c[3] << 32
8073                    | (uint64_t) a->c[4] << 24
8074                    | (uint64_t) a->c[5] << 16
8075                    | (uint64_t) a->c[6] << 8
8076                    | (uint64_t) a->c[7]);
8077   uint64_t bval = (  (uint64_t) b->c[0] << 56
8078                    | (uint64_t) b->c[1] << 48
8079                    | (uint64_t) b->c[2] << 40
8080                    | (uint64_t) b->c[3] << 32
8081                    | (uint64_t) b->c[4] << 24
8082                    | (uint64_t) b->c[5] << 16
8083                    | (uint64_t) b->c[6] << 8
8084                    | (uint64_t) b->c[7]);
8085   if (aval < bval)
8086     return -1;
8087   else if (aval > bval)
8088     return 1;
8089   return 0;
8090 }
8091 #endif
8092
8093 /* When performing a relocatable link, the input relocations are
8094    preserved.  But, if they reference global symbols, the indices
8095    referenced must be updated.  Update all the relocations found in
8096    RELDATA.  */
8097
8098 static void
8099 elf_link_adjust_relocs (bfd *abfd,
8100                         struct bfd_elf_section_reloc_data *reldata,
8101                         bfd_boolean sort)
8102 {
8103   unsigned int i;
8104   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8105   bfd_byte *erela;
8106   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8107   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8108   bfd_vma r_type_mask;
8109   int r_sym_shift;
8110   unsigned int count = reldata->count;
8111   struct elf_link_hash_entry **rel_hash = reldata->hashes;
8112
8113   if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
8114     {
8115       swap_in = bed->s->swap_reloc_in;
8116       swap_out = bed->s->swap_reloc_out;
8117     }
8118   else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
8119     {
8120       swap_in = bed->s->swap_reloca_in;
8121       swap_out = bed->s->swap_reloca_out;
8122     }
8123   else
8124     abort ();
8125
8126   if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
8127     abort ();
8128
8129   if (bed->s->arch_size == 32)
8130     {
8131       r_type_mask = 0xff;
8132       r_sym_shift = 8;
8133     }
8134   else
8135     {
8136       r_type_mask = 0xffffffff;
8137       r_sym_shift = 32;
8138     }
8139
8140   erela = reldata->hdr->contents;
8141   for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
8142     {
8143       Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
8144       unsigned int j;
8145
8146       if (*rel_hash == NULL)
8147         continue;
8148
8149       BFD_ASSERT ((*rel_hash)->indx >= 0);
8150
8151       (*swap_in) (abfd, erela, irela);
8152       for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
8153         irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
8154                            | (irela[j].r_info & r_type_mask));
8155       (*swap_out) (abfd, irela, erela);
8156     }
8157
8158   if (sort)
8159     {
8160       int (*compare) (const void *, const void *);
8161
8162       if (bed->s->arch_size == 32)
8163         {
8164           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8165             compare = cmp_ext32l_r_offset;
8166           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8167             compare = cmp_ext32b_r_offset;
8168           else
8169             abort ();
8170         }
8171       else
8172         {
8173 #ifdef BFD_HOST_64_BIT
8174           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8175             compare = cmp_ext64l_r_offset;
8176           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8177             compare = cmp_ext64b_r_offset;
8178           else
8179 #endif
8180             abort ();
8181         }
8182       qsort (reldata->hdr->contents, count, reldata->hdr->sh_entsize, compare);
8183       free (reldata->hashes);
8184       reldata->hashes = NULL;
8185     }
8186 }
8187
8188 struct elf_link_sort_rela
8189 {
8190   union {
8191     bfd_vma offset;
8192     bfd_vma sym_mask;
8193   } u;
8194   enum elf_reloc_type_class type;
8195   /* We use this as an array of size int_rels_per_ext_rel.  */
8196   Elf_Internal_Rela rela[1];
8197 };
8198
8199 static int
8200 elf_link_sort_cmp1 (const void *A, const void *B)
8201 {
8202   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8203   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8204   int relativea, relativeb;
8205
8206   relativea = a->type == reloc_class_relative;
8207   relativeb = b->type == reloc_class_relative;
8208
8209   if (relativea < relativeb)
8210     return 1;
8211   if (relativea > relativeb)
8212     return -1;
8213   if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8214     return -1;
8215   if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8216     return 1;
8217   if (a->rela->r_offset < b->rela->r_offset)
8218     return -1;
8219   if (a->rela->r_offset > b->rela->r_offset)
8220     return 1;
8221   return 0;
8222 }
8223
8224 static int
8225 elf_link_sort_cmp2 (const void *A, const void *B)
8226 {
8227   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8228   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8229
8230   if (a->type < b->type)
8231     return -1;
8232   if (a->type > b->type)
8233     return 1;
8234   if (a->u.offset < b->u.offset)
8235     return -1;
8236   if (a->u.offset > b->u.offset)
8237     return 1;
8238   if (a->rela->r_offset < b->rela->r_offset)
8239     return -1;
8240   if (a->rela->r_offset > b->rela->r_offset)
8241     return 1;
8242   return 0;
8243 }
8244
8245 static size_t
8246 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8247 {
8248   asection *dynamic_relocs;
8249   asection *rela_dyn;
8250   asection *rel_dyn;
8251   bfd_size_type count, size;
8252   size_t i, ret, sort_elt, ext_size;
8253   bfd_byte *sort, *s_non_relative, *p;
8254   struct elf_link_sort_rela *sq;
8255   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8256   int i2e = bed->s->int_rels_per_ext_rel;
8257   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8258   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8259   struct bfd_link_order *lo;
8260   bfd_vma r_sym_mask;
8261   bfd_boolean use_rela;
8262
8263   /* Find a dynamic reloc section.  */
8264   rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8265   rel_dyn  = bfd_get_section_by_name (abfd, ".rel.dyn");
8266   if (rela_dyn != NULL && rela_dyn->size > 0
8267       && rel_dyn != NULL && rel_dyn->size > 0)
8268     {
8269       bfd_boolean use_rela_initialised = FALSE;
8270
8271       /* This is just here to stop gcc from complaining.
8272          It's initialization checking code is not perfect.  */
8273       use_rela = TRUE;
8274
8275       /* Both sections are present.  Examine the sizes
8276          of the indirect sections to help us choose.  */
8277       for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8278         if (lo->type == bfd_indirect_link_order)
8279           {
8280             asection *o = lo->u.indirect.section;
8281
8282             if ((o->size % bed->s->sizeof_rela) == 0)
8283               {
8284                 if ((o->size % bed->s->sizeof_rel) == 0)
8285                   /* Section size is divisible by both rel and rela sizes.
8286                      It is of no help to us.  */
8287                   ;
8288                 else
8289                   {
8290                     /* Section size is only divisible by rela.  */
8291                     if (use_rela_initialised && (use_rela == FALSE))
8292                       {
8293                         _bfd_error_handler
8294                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8295                         bfd_set_error (bfd_error_invalid_operation);
8296                         return 0;
8297                       }
8298                     else
8299                       {
8300                         use_rela = TRUE;
8301                         use_rela_initialised = TRUE;
8302                       }
8303                   }
8304               }
8305             else if ((o->size % bed->s->sizeof_rel) == 0)
8306               {
8307                 /* Section size is only divisible by rel.  */
8308                 if (use_rela_initialised && (use_rela == TRUE))
8309                   {
8310                     _bfd_error_handler
8311                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8312                     bfd_set_error (bfd_error_invalid_operation);
8313                     return 0;
8314                   }
8315                 else
8316                   {
8317                     use_rela = FALSE;
8318                     use_rela_initialised = TRUE;
8319                   }
8320               }
8321             else
8322               {
8323                 /* The section size is not divisible by either - something is wrong.  */
8324                 _bfd_error_handler
8325                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8326                 bfd_set_error (bfd_error_invalid_operation);
8327                 return 0;
8328               }
8329           }
8330
8331       for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8332         if (lo->type == bfd_indirect_link_order)
8333           {
8334             asection *o = lo->u.indirect.section;
8335
8336             if ((o->size % bed->s->sizeof_rela) == 0)
8337               {
8338                 if ((o->size % bed->s->sizeof_rel) == 0)
8339                   /* Section size is divisible by both rel and rela sizes.
8340                      It is of no help to us.  */
8341                   ;
8342                 else
8343                   {
8344                     /* Section size is only divisible by rela.  */
8345                     if (use_rela_initialised && (use_rela == FALSE))
8346                       {
8347                         _bfd_error_handler
8348                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8349                         bfd_set_error (bfd_error_invalid_operation);
8350                         return 0;
8351                       }
8352                     else
8353                       {
8354                         use_rela = TRUE;
8355                         use_rela_initialised = TRUE;
8356                       }
8357                   }
8358               }
8359             else if ((o->size % bed->s->sizeof_rel) == 0)
8360               {
8361                 /* Section size is only divisible by rel.  */
8362                 if (use_rela_initialised && (use_rela == TRUE))
8363                   {
8364                     _bfd_error_handler
8365                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8366                     bfd_set_error (bfd_error_invalid_operation);
8367                     return 0;
8368                   }
8369                 else
8370                   {
8371                     use_rela = FALSE;
8372                     use_rela_initialised = TRUE;
8373                   }
8374               }
8375             else
8376               {
8377                 /* The section size is not divisible by either - something is wrong.  */
8378                 _bfd_error_handler
8379                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8380                 bfd_set_error (bfd_error_invalid_operation);
8381                 return 0;
8382               }
8383           }
8384
8385       if (! use_rela_initialised)
8386         /* Make a guess.  */
8387         use_rela = TRUE;
8388     }
8389   else if (rela_dyn != NULL && rela_dyn->size > 0)
8390     use_rela = TRUE;
8391   else if (rel_dyn != NULL && rel_dyn->size > 0)
8392     use_rela = FALSE;
8393   else
8394     return 0;
8395
8396   if (use_rela)
8397     {
8398       dynamic_relocs = rela_dyn;
8399       ext_size = bed->s->sizeof_rela;
8400       swap_in = bed->s->swap_reloca_in;
8401       swap_out = bed->s->swap_reloca_out;
8402     }
8403   else
8404     {
8405       dynamic_relocs = rel_dyn;
8406       ext_size = bed->s->sizeof_rel;
8407       swap_in = bed->s->swap_reloc_in;
8408       swap_out = bed->s->swap_reloc_out;
8409     }
8410
8411   size = 0;
8412   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8413     if (lo->type == bfd_indirect_link_order)
8414       size += lo->u.indirect.section->size;
8415
8416   if (size != dynamic_relocs->size)
8417     return 0;
8418
8419   sort_elt = (sizeof (struct elf_link_sort_rela)
8420               + (i2e - 1) * sizeof (Elf_Internal_Rela));
8421
8422   count = dynamic_relocs->size / ext_size;
8423   if (count == 0)
8424     return 0;
8425   sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8426
8427   if (sort == NULL)
8428     {
8429       (*info->callbacks->warning)
8430         (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8431       return 0;
8432     }
8433
8434   if (bed->s->arch_size == 32)
8435     r_sym_mask = ~(bfd_vma) 0xff;
8436   else
8437     r_sym_mask = ~(bfd_vma) 0xffffffff;
8438
8439   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8440     if (lo->type == bfd_indirect_link_order)
8441       {
8442         bfd_byte *erel, *erelend;
8443         asection *o = lo->u.indirect.section;
8444
8445         if (o->contents == NULL && o->size != 0)
8446           {
8447             /* This is a reloc section that is being handled as a normal
8448                section.  See bfd_section_from_shdr.  We can't combine
8449                relocs in this case.  */
8450             free (sort);
8451             return 0;
8452           }
8453         erel = o->contents;
8454         erelend = o->contents + o->size;
8455         /* FIXME: octets_per_byte.  */
8456         p = sort + o->output_offset / ext_size * sort_elt;
8457
8458         while (erel < erelend)
8459           {
8460             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8461
8462             (*swap_in) (abfd, erel, s->rela);
8463             s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
8464             s->u.sym_mask = r_sym_mask;
8465             p += sort_elt;
8466             erel += ext_size;
8467           }
8468       }
8469
8470   qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8471
8472   for (i = 0, p = sort; i < count; i++, p += sort_elt)
8473     {
8474       struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8475       if (s->type != reloc_class_relative)
8476         break;
8477     }
8478   ret = i;
8479   s_non_relative = p;
8480
8481   sq = (struct elf_link_sort_rela *) s_non_relative;
8482   for (; i < count; i++, p += sort_elt)
8483     {
8484       struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8485       if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8486         sq = sp;
8487       sp->u.offset = sq->rela->r_offset;
8488     }
8489
8490   qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8491
8492   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8493     if (lo->type == bfd_indirect_link_order)
8494       {
8495         bfd_byte *erel, *erelend;
8496         asection *o = lo->u.indirect.section;
8497
8498         erel = o->contents;
8499         erelend = o->contents + o->size;
8500         /* FIXME: octets_per_byte.  */
8501         p = sort + o->output_offset / ext_size * sort_elt;
8502         while (erel < erelend)
8503           {
8504             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8505             (*swap_out) (abfd, s->rela, erel);
8506             p += sort_elt;
8507             erel += ext_size;
8508           }
8509       }
8510
8511   free (sort);
8512   *psec = dynamic_relocs;
8513   return ret;
8514 }
8515
8516 /* Flush the output symbols to the file.  */
8517
8518 static bfd_boolean
8519 elf_link_flush_output_syms (struct elf_final_link_info *flinfo,
8520                             const struct elf_backend_data *bed)
8521 {
8522   if (flinfo->symbuf_count > 0)
8523     {
8524       Elf_Internal_Shdr *hdr;
8525       file_ptr pos;
8526       bfd_size_type amt;
8527
8528       hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
8529       pos = hdr->sh_offset + hdr->sh_size;
8530       amt = flinfo->symbuf_count * bed->s->sizeof_sym;
8531       if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) != 0
8532           || bfd_bwrite (flinfo->symbuf, amt, flinfo->output_bfd) != amt)
8533         return FALSE;
8534
8535       hdr->sh_size += amt;
8536       flinfo->symbuf_count = 0;
8537     }
8538
8539   return TRUE;
8540 }
8541
8542 /* Add a symbol to the output symbol table.  */
8543
8544 static int
8545 elf_link_output_sym (struct elf_final_link_info *flinfo,
8546                      const char *name,
8547                      Elf_Internal_Sym *elfsym,
8548                      asection *input_sec,
8549                      struct elf_link_hash_entry *h)
8550 {
8551   bfd_byte *dest;
8552   Elf_External_Sym_Shndx *destshndx;
8553   int (*output_symbol_hook)
8554     (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8555      struct elf_link_hash_entry *);
8556   const struct elf_backend_data *bed;
8557
8558   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
8559
8560   bed = get_elf_backend_data (flinfo->output_bfd);
8561   output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8562   if (output_symbol_hook != NULL)
8563     {
8564       int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
8565       if (ret != 1)
8566         return ret;
8567     }
8568
8569   if (name == NULL || *name == '\0')
8570     elfsym->st_name = 0;
8571   else if (input_sec->flags & SEC_EXCLUDE)
8572     elfsym->st_name = 0;
8573   else
8574     {
8575       elfsym->st_name = (unsigned long) _bfd_stringtab_add (flinfo->symstrtab,
8576                                                             name, TRUE, FALSE);
8577       if (elfsym->st_name == (unsigned long) -1)
8578         return 0;
8579     }
8580
8581   if (flinfo->symbuf_count >= flinfo->symbuf_size)
8582     {
8583       if (! elf_link_flush_output_syms (flinfo, bed))
8584         return 0;
8585     }
8586
8587   dest = flinfo->symbuf + flinfo->symbuf_count * bed->s->sizeof_sym;
8588   destshndx = flinfo->symshndxbuf;
8589   if (destshndx != NULL)
8590     {
8591       if (bfd_get_symcount (flinfo->output_bfd) >= flinfo->shndxbuf_size)
8592         {
8593           bfd_size_type amt;
8594
8595           amt = flinfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8596           destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8597                                                               amt * 2);
8598           if (destshndx == NULL)
8599             return 0;
8600           flinfo->symshndxbuf = destshndx;
8601           memset ((char *) destshndx + amt, 0, amt);
8602           flinfo->shndxbuf_size *= 2;
8603         }
8604       destshndx += bfd_get_symcount (flinfo->output_bfd);
8605     }
8606
8607   bed->s->swap_symbol_out (flinfo->output_bfd, elfsym, dest, destshndx);
8608   flinfo->symbuf_count += 1;
8609   bfd_get_symcount (flinfo->output_bfd) += 1;
8610
8611   return 1;
8612 }
8613
8614 /* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
8615
8616 static bfd_boolean
8617 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8618 {
8619   if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8620       && sym->st_shndx < SHN_LORESERVE)
8621     {
8622       /* The gABI doesn't support dynamic symbols in output sections
8623          beyond 64k.  */
8624       (*_bfd_error_handler)
8625         (_("%B: Too many sections: %d (>= %d)"),
8626          abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8627       bfd_set_error (bfd_error_nonrepresentable_section);
8628       return FALSE;
8629     }
8630   return TRUE;
8631 }
8632
8633 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8634    allowing an unsatisfied unversioned symbol in the DSO to match a
8635    versioned symbol that would normally require an explicit version.
8636    We also handle the case that a DSO references a hidden symbol
8637    which may be satisfied by a versioned symbol in another DSO.  */
8638
8639 static bfd_boolean
8640 elf_link_check_versioned_symbol (struct bfd_link_info *info,
8641                                  const struct elf_backend_data *bed,
8642                                  struct elf_link_hash_entry *h)
8643 {
8644   bfd *abfd;
8645   struct elf_link_loaded_list *loaded;
8646
8647   if (!is_elf_hash_table (info->hash))
8648     return FALSE;
8649
8650   /* Check indirect symbol.  */
8651   while (h->root.type == bfd_link_hash_indirect)
8652     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8653
8654   switch (h->root.type)
8655     {
8656     default:
8657       abfd = NULL;
8658       break;
8659
8660     case bfd_link_hash_undefined:
8661     case bfd_link_hash_undefweak:
8662       abfd = h->root.u.undef.abfd;
8663       if ((abfd->flags & DYNAMIC) == 0
8664           || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8665         return FALSE;
8666       break;
8667
8668     case bfd_link_hash_defined:
8669     case bfd_link_hash_defweak:
8670       abfd = h->root.u.def.section->owner;
8671       break;
8672
8673     case bfd_link_hash_common:
8674       abfd = h->root.u.c.p->section->owner;
8675       break;
8676     }
8677   BFD_ASSERT (abfd != NULL);
8678
8679   for (loaded = elf_hash_table (info)->loaded;
8680        loaded != NULL;
8681        loaded = loaded->next)
8682     {
8683       bfd *input;
8684       Elf_Internal_Shdr *hdr;
8685       bfd_size_type symcount;
8686       bfd_size_type extsymcount;
8687       bfd_size_type extsymoff;
8688       Elf_Internal_Shdr *versymhdr;
8689       Elf_Internal_Sym *isym;
8690       Elf_Internal_Sym *isymend;
8691       Elf_Internal_Sym *isymbuf;
8692       Elf_External_Versym *ever;
8693       Elf_External_Versym *extversym;
8694
8695       input = loaded->abfd;
8696
8697       /* We check each DSO for a possible hidden versioned definition.  */
8698       if (input == abfd
8699           || (input->flags & DYNAMIC) == 0
8700           || elf_dynversym (input) == 0)
8701         continue;
8702
8703       hdr = &elf_tdata (input)->dynsymtab_hdr;
8704
8705       symcount = hdr->sh_size / bed->s->sizeof_sym;
8706       if (elf_bad_symtab (input))
8707         {
8708           extsymcount = symcount;
8709           extsymoff = 0;
8710         }
8711       else
8712         {
8713           extsymcount = symcount - hdr->sh_info;
8714           extsymoff = hdr->sh_info;
8715         }
8716
8717       if (extsymcount == 0)
8718         continue;
8719
8720       isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8721                                       NULL, NULL, NULL);
8722       if (isymbuf == NULL)
8723         return FALSE;
8724
8725       /* Read in any version definitions.  */
8726       versymhdr = &elf_tdata (input)->dynversym_hdr;
8727       extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8728       if (extversym == NULL)
8729         goto error_ret;
8730
8731       if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8732           || (bfd_bread (extversym, versymhdr->sh_size, input)
8733               != versymhdr->sh_size))
8734         {
8735           free (extversym);
8736         error_ret:
8737           free (isymbuf);
8738           return FALSE;
8739         }
8740
8741       ever = extversym + extsymoff;
8742       isymend = isymbuf + extsymcount;
8743       for (isym = isymbuf; isym < isymend; isym++, ever++)
8744         {
8745           const char *name;
8746           Elf_Internal_Versym iver;
8747           unsigned short version_index;
8748
8749           if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8750               || isym->st_shndx == SHN_UNDEF)
8751             continue;
8752
8753           name = bfd_elf_string_from_elf_section (input,
8754                                                   hdr->sh_link,
8755                                                   isym->st_name);
8756           if (strcmp (name, h->root.root.string) != 0)
8757             continue;
8758
8759           _bfd_elf_swap_versym_in (input, ever, &iver);
8760
8761           if ((iver.vs_vers & VERSYM_HIDDEN) == 0
8762               && !(h->def_regular
8763                    && h->forced_local))
8764             {
8765               /* If we have a non-hidden versioned sym, then it should
8766                  have provided a definition for the undefined sym unless
8767                  it is defined in a non-shared object and forced local.
8768                */
8769               abort ();
8770             }
8771
8772           version_index = iver.vs_vers & VERSYM_VERSION;
8773           if (version_index == 1 || version_index == 2)
8774             {
8775               /* This is the base or first version.  We can use it.  */
8776               free (extversym);
8777               free (isymbuf);
8778               return TRUE;
8779             }
8780         }
8781
8782       free (extversym);
8783       free (isymbuf);
8784     }
8785
8786   return FALSE;
8787 }
8788
8789 /* Add an external symbol to the symbol table.  This is called from
8790    the hash table traversal routine.  When generating a shared object,
8791    we go through the symbol table twice.  The first time we output
8792    anything that might have been forced to local scope in a version
8793    script.  The second time we output the symbols that are still
8794    global symbols.  */
8795
8796 static bfd_boolean
8797 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
8798 {
8799   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
8800   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8801   struct elf_final_link_info *flinfo = eoinfo->flinfo;
8802   bfd_boolean strip;
8803   Elf_Internal_Sym sym;
8804   asection *input_sec;
8805   const struct elf_backend_data *bed;
8806   long indx;
8807   int ret;
8808
8809   if (h->root.type == bfd_link_hash_warning)
8810     {
8811       h = (struct elf_link_hash_entry *) h->root.u.i.link;
8812       if (h->root.type == bfd_link_hash_new)
8813         return TRUE;
8814     }
8815
8816   /* Decide whether to output this symbol in this pass.  */
8817   if (eoinfo->localsyms)
8818     {
8819       if (!h->forced_local)
8820         return TRUE;
8821     }
8822   else
8823     {
8824       if (h->forced_local)
8825         return TRUE;
8826     }
8827
8828   bed = get_elf_backend_data (flinfo->output_bfd);
8829
8830   if (h->root.type == bfd_link_hash_undefined)
8831     {
8832       /* If we have an undefined symbol reference here then it must have
8833          come from a shared library that is being linked in.  (Undefined
8834          references in regular files have already been handled unless
8835          they are in unreferenced sections which are removed by garbage
8836          collection).  */
8837       bfd_boolean ignore_undef = FALSE;
8838
8839       /* Some symbols may be special in that the fact that they're
8840          undefined can be safely ignored - let backend determine that.  */
8841       if (bed->elf_backend_ignore_undef_symbol)
8842         ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8843
8844       /* If we are reporting errors for this situation then do so now.  */
8845       if (!ignore_undef
8846           && h->ref_dynamic
8847           && (!h->ref_regular || flinfo->info->gc_sections)
8848           && !elf_link_check_versioned_symbol (flinfo->info, bed, h)
8849           && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8850         {
8851           if (!(flinfo->info->callbacks->undefined_symbol
8852                 (flinfo->info, h->root.root.string,
8853                  h->ref_regular ? NULL : h->root.u.undef.abfd,
8854                  NULL, 0,
8855                  (flinfo->info->unresolved_syms_in_shared_libs
8856                   == RM_GENERATE_ERROR))))
8857             {
8858               bfd_set_error (bfd_error_bad_value);
8859               eoinfo->failed = TRUE;
8860               return FALSE;
8861             }
8862         }
8863     }
8864
8865   /* We should also warn if a forced local symbol is referenced from
8866      shared libraries.  */
8867   if (!flinfo->info->relocatable
8868       && flinfo->info->executable
8869       && h->forced_local
8870       && h->ref_dynamic
8871       && h->def_regular
8872       && !h->dynamic_def
8873       && h->ref_dynamic_nonweak
8874       && !elf_link_check_versioned_symbol (flinfo->info, bed, h))
8875     {
8876       bfd *def_bfd;
8877       const char *msg;
8878       struct elf_link_hash_entry *hi = h;
8879
8880       /* Check indirect symbol.  */
8881       while (hi->root.type == bfd_link_hash_indirect)
8882         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
8883
8884       if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
8885         msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
8886       else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
8887         msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
8888       else
8889         msg = _("%B: local symbol `%s' in %B is referenced by DSO");
8890       def_bfd = flinfo->output_bfd;
8891       if (hi->root.u.def.section != bfd_abs_section_ptr)
8892         def_bfd = hi->root.u.def.section->owner;
8893       (*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
8894                              h->root.root.string);
8895       bfd_set_error (bfd_error_bad_value);
8896       eoinfo->failed = TRUE;
8897       return FALSE;
8898     }
8899
8900   /* We don't want to output symbols that have never been mentioned by
8901      a regular file, or that we have been told to strip.  However, if
8902      h->indx is set to -2, the symbol is used by a reloc and we must
8903      output it.  */
8904   strip = FALSE;
8905   if (h->indx == -2)
8906     ;
8907   else if ((h->def_dynamic
8908             || h->ref_dynamic
8909             || h->root.type == bfd_link_hash_new)
8910            && !h->def_regular
8911            && !h->ref_regular)
8912     strip = TRUE;
8913   else if (flinfo->info->strip == strip_all)
8914     strip = TRUE;
8915   else if (flinfo->info->strip == strip_some
8916            && bfd_hash_lookup (flinfo->info->keep_hash,
8917                                h->root.root.string, FALSE, FALSE) == NULL)
8918     strip = TRUE;
8919   else if ((h->root.type == bfd_link_hash_defined
8920             || h->root.type == bfd_link_hash_defweak)
8921            && ((flinfo->info->strip_discarded
8922                 && discarded_section (h->root.u.def.section))
8923                || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0
8924                    && h->root.u.def.section->owner != NULL
8925                    && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
8926     strip = TRUE;
8927   else if ((h->root.type == bfd_link_hash_undefined
8928             || h->root.type == bfd_link_hash_undefweak)
8929            && h->root.u.undef.abfd != NULL
8930            && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
8931     strip = TRUE;
8932
8933   /* If we're stripping it, and it's not a dynamic symbol, there's
8934      nothing else to do.   However, if it is a forced local symbol or
8935      an ifunc symbol we need to give the backend finish_dynamic_symbol
8936      function a chance to make it dynamic.  */
8937   if (strip
8938       && h->dynindx == -1
8939       && h->type != STT_GNU_IFUNC
8940       && !h->forced_local)
8941     return TRUE;
8942
8943   sym.st_value = 0;
8944   sym.st_size = h->size;
8945   sym.st_other = h->other;
8946   if (h->forced_local)
8947     {
8948       sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8949       /* Turn off visibility on local symbol.  */
8950       sym.st_other &= ~ELF_ST_VISIBILITY (-1);
8951     }
8952   /* Set STB_GNU_UNIQUE only if symbol is defined in regular object.  */
8953   else if (h->unique_global && h->def_regular)
8954     sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8955   else if (h->root.type == bfd_link_hash_undefweak
8956            || h->root.type == bfd_link_hash_defweak)
8957     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8958   else
8959     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8960   sym.st_target_internal = h->target_internal;
8961
8962   switch (h->root.type)
8963     {
8964     default:
8965     case bfd_link_hash_new:
8966     case bfd_link_hash_warning:
8967       abort ();
8968       return FALSE;
8969
8970     case bfd_link_hash_undefined:
8971     case bfd_link_hash_undefweak:
8972       input_sec = bfd_und_section_ptr;
8973       sym.st_shndx = SHN_UNDEF;
8974       break;
8975
8976     case bfd_link_hash_defined:
8977     case bfd_link_hash_defweak:
8978       {
8979         input_sec = h->root.u.def.section;
8980         if (input_sec->output_section != NULL)
8981           {
8982             sym.st_shndx =
8983               _bfd_elf_section_from_bfd_section (flinfo->output_bfd,
8984                                                  input_sec->output_section);
8985             if (sym.st_shndx == SHN_BAD)
8986               {
8987                 (*_bfd_error_handler)
8988                   (_("%B: could not find output section %A for input section %A"),
8989                    flinfo->output_bfd, input_sec->output_section, input_sec);
8990                 bfd_set_error (bfd_error_nonrepresentable_section);
8991                 eoinfo->failed = TRUE;
8992                 return FALSE;
8993               }
8994
8995             /* ELF symbols in relocatable files are section relative,
8996                but in nonrelocatable files they are virtual
8997                addresses.  */
8998             sym.st_value = h->root.u.def.value + input_sec->output_offset;
8999             if (!flinfo->info->relocatable)
9000               {
9001                 sym.st_value += input_sec->output_section->vma;
9002                 if (h->type == STT_TLS)
9003                   {
9004                     asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
9005                     if (tls_sec != NULL)
9006                       sym.st_value -= tls_sec->vma;
9007                   }
9008               }
9009           }
9010         else
9011           {
9012             BFD_ASSERT (input_sec->owner == NULL
9013                         || (input_sec->owner->flags & DYNAMIC) != 0);
9014             sym.st_shndx = SHN_UNDEF;
9015             input_sec = bfd_und_section_ptr;
9016           }
9017       }
9018       break;
9019
9020     case bfd_link_hash_common:
9021       input_sec = h->root.u.c.p->section;
9022       sym.st_shndx = bed->common_section_index (input_sec);
9023       sym.st_value = 1 << h->root.u.c.p->alignment_power;
9024       break;
9025
9026     case bfd_link_hash_indirect:
9027       /* These symbols are created by symbol versioning.  They point
9028          to the decorated version of the name.  For example, if the
9029          symbol foo@@GNU_1.2 is the default, which should be used when
9030          foo is used with no version, then we add an indirect symbol
9031          foo which points to foo@@GNU_1.2.  We ignore these symbols,
9032          since the indirected symbol is already in the hash table.  */
9033       return TRUE;
9034     }
9035
9036   /* Give the processor backend a chance to tweak the symbol value,
9037      and also to finish up anything that needs to be done for this
9038      symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
9039      forced local syms when non-shared is due to a historical quirk.
9040      STT_GNU_IFUNC symbol must go through PLT.  */
9041   if ((h->type == STT_GNU_IFUNC
9042        && h->def_regular
9043        && !flinfo->info->relocatable)
9044       || ((h->dynindx != -1
9045            || h->forced_local)
9046           && ((flinfo->info->shared
9047                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9048                    || h->root.type != bfd_link_hash_undefweak))
9049               || !h->forced_local)
9050           && elf_hash_table (flinfo->info)->dynamic_sections_created))
9051     {
9052       if (! ((*bed->elf_backend_finish_dynamic_symbol)
9053              (flinfo->output_bfd, flinfo->info, h, &sym)))
9054         {
9055           eoinfo->failed = TRUE;
9056           return FALSE;
9057         }
9058     }
9059
9060   /* If we are marking the symbol as undefined, and there are no
9061      non-weak references to this symbol from a regular object, then
9062      mark the symbol as weak undefined; if there are non-weak
9063      references, mark the symbol as strong.  We can't do this earlier,
9064      because it might not be marked as undefined until the
9065      finish_dynamic_symbol routine gets through with it.  */
9066   if (sym.st_shndx == SHN_UNDEF
9067       && h->ref_regular
9068       && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
9069           || ELF_ST_BIND (sym.st_info) == STB_WEAK))
9070     {
9071       int bindtype;
9072       unsigned int type = ELF_ST_TYPE (sym.st_info);
9073
9074       /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9075       if (type == STT_GNU_IFUNC)
9076         type = STT_FUNC;
9077
9078       if (h->ref_regular_nonweak)
9079         bindtype = STB_GLOBAL;
9080       else
9081         bindtype = STB_WEAK;
9082       sym.st_info = ELF_ST_INFO (bindtype, type);
9083     }
9084
9085   /* If this is a symbol defined in a dynamic library, don't use the
9086      symbol size from the dynamic library.  Relinking an executable
9087      against a new library may introduce gratuitous changes in the
9088      executable's symbols if we keep the size.  */
9089   if (sym.st_shndx == SHN_UNDEF
9090       && !h->def_regular
9091       && h->def_dynamic)
9092     sym.st_size = 0;
9093
9094   /* If a non-weak symbol with non-default visibility is not defined
9095      locally, it is a fatal error.  */
9096   if (!flinfo->info->relocatable
9097       && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
9098       && ELF_ST_BIND (sym.st_info) != STB_WEAK
9099       && h->root.type == bfd_link_hash_undefined
9100       && !h->def_regular)
9101     {
9102       const char *msg;
9103
9104       if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
9105         msg = _("%B: protected symbol `%s' isn't defined");
9106       else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
9107         msg = _("%B: internal symbol `%s' isn't defined");
9108       else
9109         msg = _("%B: hidden symbol `%s' isn't defined");
9110       (*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
9111       bfd_set_error (bfd_error_bad_value);
9112       eoinfo->failed = TRUE;
9113       return FALSE;
9114     }
9115
9116   /* If this symbol should be put in the .dynsym section, then put it
9117      there now.  We already know the symbol index.  We also fill in
9118      the entry in the .hash section.  */
9119   if (flinfo->dynsym_sec != NULL
9120       && h->dynindx != -1
9121       && elf_hash_table (flinfo->info)->dynamic_sections_created)
9122     {
9123       bfd_byte *esym;
9124
9125       /* Since there is no version information in the dynamic string,
9126          if there is no version info in symbol version section, we will
9127          have a run-time problem.  */
9128       if (h->verinfo.verdef == NULL)
9129         {
9130           char *p = strrchr (h->root.root.string, ELF_VER_CHR);
9131
9132           if (p && p [1] != '\0')
9133             {
9134               (*_bfd_error_handler)
9135                 (_("%B: No symbol version section for versioned symbol `%s'"),
9136                  flinfo->output_bfd, h->root.root.string);
9137               eoinfo->failed = TRUE;
9138               return FALSE;
9139             }
9140         }
9141
9142       sym.st_name = h->dynstr_index;
9143       esym = flinfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
9144       if (!check_dynsym (flinfo->output_bfd, &sym))
9145         {
9146           eoinfo->failed = TRUE;
9147           return FALSE;
9148         }
9149       bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
9150
9151       if (flinfo->hash_sec != NULL)
9152         {
9153           size_t hash_entry_size;
9154           bfd_byte *bucketpos;
9155           bfd_vma chain;
9156           size_t bucketcount;
9157           size_t bucket;
9158
9159           bucketcount = elf_hash_table (flinfo->info)->bucketcount;
9160           bucket = h->u.elf_hash_value % bucketcount;
9161
9162           hash_entry_size
9163             = elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
9164           bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
9165                        + (bucket + 2) * hash_entry_size);
9166           chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
9167           bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
9168                    bucketpos);
9169           bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
9170                    ((bfd_byte *) flinfo->hash_sec->contents
9171                     + (bucketcount + 2 + h->dynindx) * hash_entry_size));
9172         }
9173
9174       if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
9175         {
9176           Elf_Internal_Versym iversym;
9177           Elf_External_Versym *eversym;
9178
9179           if (!h->def_regular)
9180             {
9181               if (h->verinfo.verdef == NULL
9182                   || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
9183                       & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
9184                 iversym.vs_vers = 0;
9185               else
9186                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
9187             }
9188           else
9189             {
9190               if (h->verinfo.vertree == NULL)
9191                 iversym.vs_vers = 1;
9192               else
9193                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
9194               if (flinfo->info->create_default_symver)
9195                 iversym.vs_vers++;
9196             }
9197
9198           if (h->hidden)
9199             iversym.vs_vers |= VERSYM_HIDDEN;
9200
9201           eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
9202           eversym += h->dynindx;
9203           _bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
9204         }
9205     }
9206
9207   /* If the symbol is undefined, and we didn't output it to .dynsym,
9208      strip it from .symtab too.  Obviously we can't do this for
9209      relocatable output or when needed for --emit-relocs.  */
9210   else if (input_sec == bfd_und_section_ptr
9211            && h->indx != -2
9212            && !flinfo->info->relocatable)
9213     return TRUE;
9214   /* Also strip others that we couldn't earlier due to dynamic symbol
9215      processing.  */
9216   if (strip)
9217     return TRUE;
9218   if ((input_sec->flags & SEC_EXCLUDE) != 0)
9219     return TRUE;
9220
9221   /* Output a FILE symbol so that following locals are not associated
9222      with the wrong input file.  We need one for forced local symbols
9223      if we've seen more than one FILE symbol or when we have exactly
9224      one FILE symbol but global symbols are present in a file other
9225      than the one with the FILE symbol.  We also need one if linker
9226      defined symbols are present.  In practice these conditions are
9227      always met, so just emit the FILE symbol unconditionally.  */
9228   if (eoinfo->localsyms
9229       && !eoinfo->file_sym_done
9230       && eoinfo->flinfo->filesym_count != 0)
9231     {
9232       Elf_Internal_Sym fsym;
9233
9234       memset (&fsym, 0, sizeof (fsym));
9235       fsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9236       fsym.st_shndx = SHN_ABS;
9237       if (!elf_link_output_sym (eoinfo->flinfo, NULL, &fsym,
9238                                 bfd_und_section_ptr, NULL))
9239         return FALSE;
9240
9241       eoinfo->file_sym_done = TRUE;
9242     }
9243
9244   indx = bfd_get_symcount (flinfo->output_bfd);
9245   ret = elf_link_output_sym (flinfo, h->root.root.string, &sym, input_sec, h);
9246   if (ret == 0)
9247     {
9248       eoinfo->failed = TRUE;
9249       return FALSE;
9250     }
9251   else if (ret == 1)
9252     h->indx = indx;
9253   else if (h->indx == -2)
9254     abort();
9255
9256   return TRUE;
9257 }
9258
9259 /* Return TRUE if special handling is done for relocs in SEC against
9260    symbols defined in discarded sections.  */
9261
9262 static bfd_boolean
9263 elf_section_ignore_discarded_relocs (asection *sec)
9264 {
9265   const struct elf_backend_data *bed;
9266
9267   switch (sec->sec_info_type)
9268     {
9269     case SEC_INFO_TYPE_STABS:
9270     case SEC_INFO_TYPE_EH_FRAME:
9271       return TRUE;
9272     default:
9273       break;
9274     }
9275
9276   bed = get_elf_backend_data (sec->owner);
9277   if (bed->elf_backend_ignore_discarded_relocs != NULL
9278       && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9279     return TRUE;
9280
9281   return FALSE;
9282 }
9283
9284 /* Return a mask saying how ld should treat relocations in SEC against
9285    symbols defined in discarded sections.  If this function returns
9286    COMPLAIN set, ld will issue a warning message.  If this function
9287    returns PRETEND set, and the discarded section was link-once and the
9288    same size as the kept link-once section, ld will pretend that the
9289    symbol was actually defined in the kept section.  Otherwise ld will
9290    zero the reloc (at least that is the intent, but some cooperation by
9291    the target dependent code is needed, particularly for REL targets).  */
9292
9293 unsigned int
9294 _bfd_elf_default_action_discarded (asection *sec)
9295 {
9296   if (sec->flags & SEC_DEBUGGING)
9297     return PRETEND;
9298
9299   if (strcmp (".eh_frame", sec->name) == 0)
9300     return 0;
9301
9302   if (strcmp (".gcc_except_table", sec->name) == 0)
9303     return 0;
9304
9305   return COMPLAIN | PRETEND;
9306 }
9307
9308 /* Find a match between a section and a member of a section group.  */
9309
9310 static asection *
9311 match_group_member (asection *sec, asection *group,
9312                     struct bfd_link_info *info)
9313 {
9314   asection *first = elf_next_in_group (group);
9315   asection *s = first;
9316
9317   while (s != NULL)
9318     {
9319       if (bfd_elf_match_symbols_in_sections (s, sec, info))
9320         return s;
9321
9322       s = elf_next_in_group (s);
9323       if (s == first)
9324         break;
9325     }
9326
9327   return NULL;
9328 }
9329
9330 /* Check if the kept section of a discarded section SEC can be used
9331    to replace it.  Return the replacement if it is OK.  Otherwise return
9332    NULL.  */
9333
9334 asection *
9335 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9336 {
9337   asection *kept;
9338
9339   kept = sec->kept_section;
9340   if (kept != NULL)
9341     {
9342       if ((kept->flags & SEC_GROUP) != 0)
9343         kept = match_group_member (sec, kept, info);
9344       if (kept != NULL
9345           && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9346               != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9347         kept = NULL;
9348       sec->kept_section = kept;
9349     }
9350   return kept;
9351 }
9352
9353 /* Link an input file into the linker output file.  This function
9354    handles all the sections and relocations of the input file at once.
9355    This is so that we only have to read the local symbols once, and
9356    don't have to keep them in memory.  */
9357
9358 static bfd_boolean
9359 elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
9360 {
9361   int (*relocate_section)
9362     (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9363      Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9364   bfd *output_bfd;
9365   Elf_Internal_Shdr *symtab_hdr;
9366   size_t locsymcount;
9367   size_t extsymoff;
9368   Elf_Internal_Sym *isymbuf;
9369   Elf_Internal_Sym *isym;
9370   Elf_Internal_Sym *isymend;
9371   long *pindex;
9372   asection **ppsection;
9373   asection *o;
9374   const struct elf_backend_data *bed;
9375   struct elf_link_hash_entry **sym_hashes;
9376   bfd_size_type address_size;
9377   bfd_vma r_type_mask;
9378   int r_sym_shift;
9379   bfd_boolean have_file_sym = FALSE;
9380
9381   output_bfd = flinfo->output_bfd;
9382   bed = get_elf_backend_data (output_bfd);
9383   relocate_section = bed->elf_backend_relocate_section;
9384
9385   /* If this is a dynamic object, we don't want to do anything here:
9386      we don't want the local symbols, and we don't want the section
9387      contents.  */
9388   if ((input_bfd->flags & DYNAMIC) != 0)
9389     return TRUE;
9390
9391   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9392   if (elf_bad_symtab (input_bfd))
9393     {
9394       locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9395       extsymoff = 0;
9396     }
9397   else
9398     {
9399       locsymcount = symtab_hdr->sh_info;
9400       extsymoff = symtab_hdr->sh_info;
9401     }
9402
9403   /* Read the local symbols.  */
9404   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9405   if (isymbuf == NULL && locsymcount != 0)
9406     {
9407       isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9408                                       flinfo->internal_syms,
9409                                       flinfo->external_syms,
9410                                       flinfo->locsym_shndx);
9411       if (isymbuf == NULL)
9412         return FALSE;
9413     }
9414
9415   /* Find local symbol sections and adjust values of symbols in
9416      SEC_MERGE sections.  Write out those local symbols we know are
9417      going into the output file.  */
9418   isymend = isymbuf + locsymcount;
9419   for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
9420        isym < isymend;
9421        isym++, pindex++, ppsection++)
9422     {
9423       asection *isec;
9424       const char *name;
9425       Elf_Internal_Sym osym;
9426       long indx;
9427       int ret;
9428
9429       *pindex = -1;
9430
9431       if (elf_bad_symtab (input_bfd))
9432         {
9433           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9434             {
9435               *ppsection = NULL;
9436               continue;
9437             }
9438         }
9439
9440       if (isym->st_shndx == SHN_UNDEF)
9441         isec = bfd_und_section_ptr;
9442       else if (isym->st_shndx == SHN_ABS)
9443         isec = bfd_abs_section_ptr;
9444       else if (isym->st_shndx == SHN_COMMON)
9445         isec = bfd_com_section_ptr;
9446       else
9447         {
9448           isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9449           if (isec == NULL)
9450             {
9451               /* Don't attempt to output symbols with st_shnx in the
9452                  reserved range other than SHN_ABS and SHN_COMMON.  */
9453               *ppsection = NULL;
9454               continue;
9455             }
9456           else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
9457                    && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9458             isym->st_value =
9459               _bfd_merged_section_offset (output_bfd, &isec,
9460                                           elf_section_data (isec)->sec_info,
9461                                           isym->st_value);
9462         }
9463
9464       *ppsection = isec;
9465
9466       /* Don't output the first, undefined, symbol.  In fact, don't
9467          output any undefined local symbol.  */
9468       if (isec == bfd_und_section_ptr)
9469         continue;
9470
9471       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9472         {
9473           /* We never output section symbols.  Instead, we use the
9474              section symbol of the corresponding section in the output
9475              file.  */
9476           continue;
9477         }
9478
9479       /* If we are stripping all symbols, we don't want to output this
9480          one.  */
9481       if (flinfo->info->strip == strip_all)
9482         continue;
9483
9484       /* If we are discarding all local symbols, we don't want to
9485          output this one.  If we are generating a relocatable output
9486          file, then some of the local symbols may be required by
9487          relocs; we output them below as we discover that they are
9488          needed.  */
9489       if (flinfo->info->discard == discard_all)
9490         continue;
9491
9492       /* If this symbol is defined in a section which we are
9493          discarding, we don't need to keep it.  */
9494       if (isym->st_shndx != SHN_UNDEF
9495           && isym->st_shndx < SHN_LORESERVE
9496           && bfd_section_removed_from_list (output_bfd,
9497                                             isec->output_section))
9498         continue;
9499
9500       /* Get the name of the symbol.  */
9501       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9502                                               isym->st_name);
9503       if (name == NULL)
9504         return FALSE;
9505
9506       /* See if we are discarding symbols with this name.  */
9507       if ((flinfo->info->strip == strip_some
9508            && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
9509                == NULL))
9510           || (((flinfo->info->discard == discard_sec_merge
9511                 && (isec->flags & SEC_MERGE) && !flinfo->info->relocatable)
9512                || flinfo->info->discard == discard_l)
9513               && bfd_is_local_label_name (input_bfd, name)))
9514         continue;
9515
9516       if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
9517         {
9518           if (input_bfd->lto_output)
9519             /* -flto puts a temp file name here.  This means builds
9520                are not reproducible.  Discard the symbol.  */
9521             continue;
9522           have_file_sym = TRUE;
9523           flinfo->filesym_count += 1;
9524         }
9525       if (!have_file_sym)
9526         {
9527           /* In the absence of debug info, bfd_find_nearest_line uses
9528              FILE symbols to determine the source file for local
9529              function symbols.  Provide a FILE symbol here if input
9530              files lack such, so that their symbols won't be
9531              associated with a previous input file.  It's not the
9532              source file, but the best we can do.  */
9533           have_file_sym = TRUE;
9534           flinfo->filesym_count += 1;
9535           memset (&osym, 0, sizeof (osym));
9536           osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9537           osym.st_shndx = SHN_ABS;
9538           if (!elf_link_output_sym (flinfo,
9539                                     (input_bfd->lto_output ? NULL
9540                                      : input_bfd->filename),
9541                                     &osym, bfd_abs_section_ptr, NULL))
9542             return FALSE;
9543         }
9544
9545       osym = *isym;
9546
9547       /* Adjust the section index for the output file.  */
9548       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9549                                                          isec->output_section);
9550       if (osym.st_shndx == SHN_BAD)
9551         return FALSE;
9552
9553       /* ELF symbols in relocatable files are section relative, but
9554          in executable files they are virtual addresses.  Note that
9555          this code assumes that all ELF sections have an associated
9556          BFD section with a reasonable value for output_offset; below
9557          we assume that they also have a reasonable value for
9558          output_section.  Any special sections must be set up to meet
9559          these requirements.  */
9560       osym.st_value += isec->output_offset;
9561       if (!flinfo->info->relocatable)
9562         {
9563           osym.st_value += isec->output_section->vma;
9564           if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9565             {
9566               /* STT_TLS symbols are relative to PT_TLS segment base.  */
9567               BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
9568               osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
9569             }
9570         }
9571
9572       indx = bfd_get_symcount (output_bfd);
9573       ret = elf_link_output_sym (flinfo, name, &osym, isec, NULL);
9574       if (ret == 0)
9575         return FALSE;
9576       else if (ret == 1)
9577         *pindex = indx;
9578     }
9579
9580   if (bed->s->arch_size == 32)
9581     {
9582       r_type_mask = 0xff;
9583       r_sym_shift = 8;
9584       address_size = 4;
9585     }
9586   else
9587     {
9588       r_type_mask = 0xffffffff;
9589       r_sym_shift = 32;
9590       address_size = 8;
9591     }
9592
9593   /* Relocate the contents of each section.  */
9594   sym_hashes = elf_sym_hashes (input_bfd);
9595   for (o = input_bfd->sections; o != NULL; o = o->next)
9596     {
9597       bfd_byte *contents;
9598
9599       if (! o->linker_mark)
9600         {
9601           /* This section was omitted from the link.  */
9602           continue;
9603         }
9604
9605       if (flinfo->info->relocatable
9606           && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9607         {
9608           /* Deal with the group signature symbol.  */
9609           struct bfd_elf_section_data *sec_data = elf_section_data (o);
9610           unsigned long symndx = sec_data->this_hdr.sh_info;
9611           asection *osec = o->output_section;
9612
9613           if (symndx >= locsymcount
9614               || (elf_bad_symtab (input_bfd)
9615                   && flinfo->sections[symndx] == NULL))
9616             {
9617               struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9618               while (h->root.type == bfd_link_hash_indirect
9619                      || h->root.type == bfd_link_hash_warning)
9620                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9621               /* Arrange for symbol to be output.  */
9622               h->indx = -2;
9623               elf_section_data (osec)->this_hdr.sh_info = -2;
9624             }
9625           else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9626             {
9627               /* We'll use the output section target_index.  */
9628               asection *sec = flinfo->sections[symndx]->output_section;
9629               elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9630             }
9631           else
9632             {
9633               if (flinfo->indices[symndx] == -1)
9634                 {
9635                   /* Otherwise output the local symbol now.  */
9636                   Elf_Internal_Sym sym = isymbuf[symndx];
9637                   asection *sec = flinfo->sections[symndx]->output_section;
9638                   const char *name;
9639                   long indx;
9640                   int ret;
9641
9642                   name = bfd_elf_string_from_elf_section (input_bfd,
9643                                                           symtab_hdr->sh_link,
9644                                                           sym.st_name);
9645                   if (name == NULL)
9646                     return FALSE;
9647
9648                   sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9649                                                                     sec);
9650                   if (sym.st_shndx == SHN_BAD)
9651                     return FALSE;
9652
9653                   sym.st_value += o->output_offset;
9654
9655                   indx = bfd_get_symcount (output_bfd);
9656                   ret = elf_link_output_sym (flinfo, name, &sym, o, NULL);
9657                   if (ret == 0)
9658                     return FALSE;
9659                   else if (ret == 1)
9660                     flinfo->indices[symndx] = indx;
9661                   else
9662                     abort ();
9663                 }
9664               elf_section_data (osec)->this_hdr.sh_info
9665                 = flinfo->indices[symndx];
9666             }
9667         }
9668
9669       if ((o->flags & SEC_HAS_CONTENTS) == 0
9670           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9671         continue;
9672
9673       if ((o->flags & SEC_LINKER_CREATED) != 0)
9674         {
9675           /* Section was created by _bfd_elf_link_create_dynamic_sections
9676              or somesuch.  */
9677           continue;
9678         }
9679
9680       /* Get the contents of the section.  They have been cached by a
9681          relaxation routine.  Note that o is a section in an input
9682          file, so the contents field will not have been set by any of
9683          the routines which work on output files.  */
9684       if (elf_section_data (o)->this_hdr.contents != NULL)
9685         {
9686           contents = elf_section_data (o)->this_hdr.contents;
9687           if (bed->caches_rawsize
9688               && o->rawsize != 0
9689               && o->rawsize < o->size)
9690             {
9691               memcpy (flinfo->contents, contents, o->rawsize);
9692               contents = flinfo->contents;
9693             }
9694         }
9695       else
9696         {
9697           contents = flinfo->contents;
9698           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
9699             return FALSE;
9700         }
9701
9702       if ((o->flags & SEC_RELOC) != 0)
9703         {
9704           Elf_Internal_Rela *internal_relocs;
9705           Elf_Internal_Rela *rel, *relend;
9706           int action_discarded;
9707           int ret;
9708
9709           /* Get the swapped relocs.  */
9710           internal_relocs
9711             = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
9712                                          flinfo->internal_relocs, FALSE);
9713           if (internal_relocs == NULL
9714               && o->reloc_count > 0)
9715             return FALSE;
9716
9717           /* We need to reverse-copy input .ctors/.dtors sections if
9718              they are placed in .init_array/.finit_array for output.  */
9719           if (o->size > address_size
9720               && ((strncmp (o->name, ".ctors", 6) == 0
9721                    && strcmp (o->output_section->name,
9722                               ".init_array") == 0)
9723                   || (strncmp (o->name, ".dtors", 6) == 0
9724                       && strcmp (o->output_section->name,
9725                                  ".fini_array") == 0))
9726               && (o->name[6] == 0 || o->name[6] == '.'))
9727             {
9728               if (o->size != o->reloc_count * address_size)
9729                 {
9730                   (*_bfd_error_handler)
9731                     (_("error: %B: size of section %A is not "
9732                        "multiple of address size"),
9733                      input_bfd, o);
9734                   bfd_set_error (bfd_error_on_input);
9735                   return FALSE;
9736                 }
9737               o->flags |= SEC_ELF_REVERSE_COPY;
9738             }
9739
9740           action_discarded = -1;
9741           if (!elf_section_ignore_discarded_relocs (o))
9742             action_discarded = (*bed->action_discarded) (o);
9743
9744           /* Run through the relocs evaluating complex reloc symbols and
9745              looking for relocs against symbols from discarded sections
9746              or section symbols from removed link-once sections.
9747              Complain about relocs against discarded sections.  Zero
9748              relocs against removed link-once sections.  */
9749
9750           rel = internal_relocs;
9751           relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9752           for ( ; rel < relend; rel++)
9753             {
9754               unsigned long r_symndx = rel->r_info >> r_sym_shift;
9755               unsigned int s_type;
9756               asection **ps, *sec;
9757               struct elf_link_hash_entry *h = NULL;
9758               const char *sym_name;
9759
9760               if (r_symndx == STN_UNDEF)
9761                 continue;
9762
9763               if (r_symndx >= locsymcount
9764                   || (elf_bad_symtab (input_bfd)
9765                       && flinfo->sections[r_symndx] == NULL))
9766                 {
9767                   h = sym_hashes[r_symndx - extsymoff];
9768
9769                   /* Badly formatted input files can contain relocs that
9770                      reference non-existant symbols.  Check here so that
9771                      we do not seg fault.  */
9772                   if (h == NULL)
9773                     {
9774                       char buffer [32];
9775
9776                       sprintf_vma (buffer, rel->r_info);
9777                       (*_bfd_error_handler)
9778                         (_("error: %B contains a reloc (0x%s) for section %A "
9779                            "that references a non-existent global symbol"),
9780                          input_bfd, o, buffer);
9781                       bfd_set_error (bfd_error_bad_value);
9782                       return FALSE;
9783                     }
9784
9785                   while (h->root.type == bfd_link_hash_indirect
9786                          || h->root.type == bfd_link_hash_warning)
9787                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9788
9789                   s_type = h->type;
9790
9791                   /* If a plugin symbol is referenced from a non-IR file,
9792                      mark the symbol as undefined.  Note that the
9793                      linker may attach linker created dynamic sections
9794                      to the plugin bfd.  Symbols defined in linker
9795                      created sections are not plugin symbols.  */
9796                   if (h->root.non_ir_ref
9797                       && (h->root.type == bfd_link_hash_defined
9798                           || h->root.type == bfd_link_hash_defweak)
9799                       && (h->root.u.def.section->flags
9800                           & SEC_LINKER_CREATED) == 0
9801                       && h->root.u.def.section->owner != NULL
9802                       && (h->root.u.def.section->owner->flags
9803                           & BFD_PLUGIN) != 0)
9804                     {
9805                       h->root.type = bfd_link_hash_undefined;
9806                       h->root.u.undef.abfd = h->root.u.def.section->owner;
9807                     }
9808
9809                   ps = NULL;
9810                   if (h->root.type == bfd_link_hash_defined
9811                       || h->root.type == bfd_link_hash_defweak)
9812                     ps = &h->root.u.def.section;
9813
9814                   sym_name = h->root.root.string;
9815                 }
9816               else
9817                 {
9818                   Elf_Internal_Sym *sym = isymbuf + r_symndx;
9819
9820                   s_type = ELF_ST_TYPE (sym->st_info);
9821                   ps = &flinfo->sections[r_symndx];
9822                   sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9823                                                sym, *ps);
9824                 }
9825
9826               if ((s_type == STT_RELC || s_type == STT_SRELC)
9827                   && !flinfo->info->relocatable)
9828                 {
9829                   bfd_vma val;
9830                   bfd_vma dot = (rel->r_offset
9831                                  + o->output_offset + o->output_section->vma);
9832 #ifdef DEBUG
9833                   printf ("Encountered a complex symbol!");
9834                   printf (" (input_bfd %s, section %s, reloc %ld\n",
9835                           input_bfd->filename, o->name,
9836                           (long) (rel - internal_relocs));
9837                   printf (" symbol: idx  %8.8lx, name %s\n",
9838                           r_symndx, sym_name);
9839                   printf (" reloc : info %8.8lx, addr %8.8lx\n",
9840                           (unsigned long) rel->r_info,
9841                           (unsigned long) rel->r_offset);
9842 #endif
9843                   if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
9844                                     isymbuf, locsymcount, s_type == STT_SRELC))
9845                     return FALSE;
9846
9847                   /* Symbol evaluated OK.  Update to absolute value.  */
9848                   set_symbol_value (input_bfd, isymbuf, locsymcount,
9849                                     r_symndx, val);
9850                   continue;
9851                 }
9852
9853               if (action_discarded != -1 && ps != NULL)
9854                 {
9855                   /* Complain if the definition comes from a
9856                      discarded section.  */
9857                   if ((sec = *ps) != NULL && discarded_section (sec))
9858                     {
9859                       BFD_ASSERT (r_symndx != STN_UNDEF);
9860                       if (action_discarded & COMPLAIN)
9861                         (*flinfo->info->callbacks->einfo)
9862                           (_("%X`%s' referenced in section `%A' of %B: "
9863                              "defined in discarded section `%A' of %B\n"),
9864                            sym_name, o, input_bfd, sec, sec->owner);
9865
9866                       /* Try to do the best we can to support buggy old
9867                          versions of gcc.  Pretend that the symbol is
9868                          really defined in the kept linkonce section.
9869                          FIXME: This is quite broken.  Modifying the
9870                          symbol here means we will be changing all later
9871                          uses of the symbol, not just in this section.  */
9872                       if (action_discarded & PRETEND)
9873                         {
9874                           asection *kept;
9875
9876                           kept = _bfd_elf_check_kept_section (sec,
9877                                                               flinfo->info);
9878                           if (kept != NULL)
9879                             {
9880                               *ps = kept;
9881                               continue;
9882                             }
9883                         }
9884                     }
9885                 }
9886             }
9887
9888           /* Relocate the section by invoking a back end routine.
9889
9890              The back end routine is responsible for adjusting the
9891              section contents as necessary, and (if using Rela relocs
9892              and generating a relocatable output file) adjusting the
9893              reloc addend as necessary.
9894
9895              The back end routine does not have to worry about setting
9896              the reloc address or the reloc symbol index.
9897
9898              The back end routine is given a pointer to the swapped in
9899              internal symbols, and can access the hash table entries
9900              for the external symbols via elf_sym_hashes (input_bfd).
9901
9902              When generating relocatable output, the back end routine
9903              must handle STB_LOCAL/STT_SECTION symbols specially.  The
9904              output symbol is going to be a section symbol
9905              corresponding to the output section, which will require
9906              the addend to be adjusted.  */
9907
9908           ret = (*relocate_section) (output_bfd, flinfo->info,
9909                                      input_bfd, o, contents,
9910                                      internal_relocs,
9911                                      isymbuf,
9912                                      flinfo->sections);
9913           if (!ret)
9914             return FALSE;
9915
9916           if (ret == 2
9917               || flinfo->info->relocatable
9918               || flinfo->info->emitrelocations)
9919             {
9920               Elf_Internal_Rela *irela;
9921               Elf_Internal_Rela *irelaend, *irelamid;
9922               bfd_vma last_offset;
9923               struct elf_link_hash_entry **rel_hash;
9924               struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9925               Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9926               unsigned int next_erel;
9927               bfd_boolean rela_normal;
9928               struct bfd_elf_section_data *esdi, *esdo;
9929
9930               esdi = elf_section_data (o);
9931               esdo = elf_section_data (o->output_section);
9932               rela_normal = FALSE;
9933
9934               /* Adjust the reloc addresses and symbol indices.  */
9935
9936               irela = internal_relocs;
9937               irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9938               rel_hash = esdo->rel.hashes + esdo->rel.count;
9939               /* We start processing the REL relocs, if any.  When we reach
9940                  IRELAMID in the loop, we switch to the RELA relocs.  */
9941               irelamid = irela;
9942               if (esdi->rel.hdr != NULL)
9943                 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9944                              * bed->s->int_rels_per_ext_rel);
9945               rel_hash_list = rel_hash;
9946               rela_hash_list = NULL;
9947               last_offset = o->output_offset;
9948               if (!flinfo->info->relocatable)
9949                 last_offset += o->output_section->vma;
9950               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9951                 {
9952                   unsigned long r_symndx;
9953                   asection *sec;
9954                   Elf_Internal_Sym sym;
9955
9956                   if (next_erel == bed->s->int_rels_per_ext_rel)
9957                     {
9958                       rel_hash++;
9959                       next_erel = 0;
9960                     }
9961
9962                   if (irela == irelamid)
9963                     {
9964                       rel_hash = esdo->rela.hashes + esdo->rela.count;
9965                       rela_hash_list = rel_hash;
9966                       rela_normal = bed->rela_normal;
9967                     }
9968
9969                   irela->r_offset = _bfd_elf_section_offset (output_bfd,
9970                                                              flinfo->info, o,
9971                                                              irela->r_offset);
9972                   if (irela->r_offset >= (bfd_vma) -2)
9973                     {
9974                       /* This is a reloc for a deleted entry or somesuch.
9975                          Turn it into an R_*_NONE reloc, at the same
9976                          offset as the last reloc.  elf_eh_frame.c and
9977                          bfd_elf_discard_info rely on reloc offsets
9978                          being ordered.  */
9979                       irela->r_offset = last_offset;
9980                       irela->r_info = 0;
9981                       irela->r_addend = 0;
9982                       continue;
9983                     }
9984
9985                   irela->r_offset += o->output_offset;
9986
9987                   /* Relocs in an executable have to be virtual addresses.  */
9988                   if (!flinfo->info->relocatable)
9989                     irela->r_offset += o->output_section->vma;
9990
9991                   last_offset = irela->r_offset;
9992
9993                   r_symndx = irela->r_info >> r_sym_shift;
9994                   if (r_symndx == STN_UNDEF)
9995                     continue;
9996
9997                   if (r_symndx >= locsymcount
9998                       || (elf_bad_symtab (input_bfd)
9999                           && flinfo->sections[r_symndx] == NULL))
10000                     {
10001                       struct elf_link_hash_entry *rh;
10002                       unsigned long indx;
10003
10004                       /* This is a reloc against a global symbol.  We
10005                          have not yet output all the local symbols, so
10006                          we do not know the symbol index of any global
10007                          symbol.  We set the rel_hash entry for this
10008                          reloc to point to the global hash table entry
10009                          for this symbol.  The symbol index is then
10010                          set at the end of bfd_elf_final_link.  */
10011                       indx = r_symndx - extsymoff;
10012                       rh = elf_sym_hashes (input_bfd)[indx];
10013                       while (rh->root.type == bfd_link_hash_indirect
10014                              || rh->root.type == bfd_link_hash_warning)
10015                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
10016
10017                       /* Setting the index to -2 tells
10018                          elf_link_output_extsym that this symbol is
10019                          used by a reloc.  */
10020                       BFD_ASSERT (rh->indx < 0);
10021                       rh->indx = -2;
10022
10023                       *rel_hash = rh;
10024
10025                       continue;
10026                     }
10027
10028                   /* This is a reloc against a local symbol.  */
10029
10030                   *rel_hash = NULL;
10031                   sym = isymbuf[r_symndx];
10032                   sec = flinfo->sections[r_symndx];
10033                   if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
10034                     {
10035                       /* I suppose the backend ought to fill in the
10036                          section of any STT_SECTION symbol against a
10037                          processor specific section.  */
10038                       r_symndx = STN_UNDEF;
10039                       if (bfd_is_abs_section (sec))
10040                         ;
10041                       else if (sec == NULL || sec->owner == NULL)
10042                         {
10043                           bfd_set_error (bfd_error_bad_value);
10044                           return FALSE;
10045                         }
10046                       else
10047                         {
10048                           asection *osec = sec->output_section;
10049
10050                           /* If we have discarded a section, the output
10051                              section will be the absolute section.  In
10052                              case of discarded SEC_MERGE sections, use
10053                              the kept section.  relocate_section should
10054                              have already handled discarded linkonce
10055                              sections.  */
10056                           if (bfd_is_abs_section (osec)
10057                               && sec->kept_section != NULL
10058                               && sec->kept_section->output_section != NULL)
10059                             {
10060                               osec = sec->kept_section->output_section;
10061                               irela->r_addend -= osec->vma;
10062                             }
10063
10064                           if (!bfd_is_abs_section (osec))
10065                             {
10066                               r_symndx = osec->target_index;
10067                               if (r_symndx == STN_UNDEF)
10068                                 {
10069                                   irela->r_addend += osec->vma;
10070                                   osec = _bfd_nearby_section (output_bfd, osec,
10071                                                               osec->vma);
10072                                   irela->r_addend -= osec->vma;
10073                                   r_symndx = osec->target_index;
10074                                 }
10075                             }
10076                         }
10077
10078                       /* Adjust the addend according to where the
10079                          section winds up in the output section.  */
10080                       if (rela_normal)
10081                         irela->r_addend += sec->output_offset;
10082                     }
10083                   else
10084                     {
10085                       if (flinfo->indices[r_symndx] == -1)
10086                         {
10087                           unsigned long shlink;
10088                           const char *name;
10089                           asection *osec;
10090                           long indx;
10091
10092                           if (flinfo->info->strip == strip_all)
10093                             {
10094                               /* You can't do ld -r -s.  */
10095                               bfd_set_error (bfd_error_invalid_operation);
10096                               return FALSE;
10097                             }
10098
10099                           /* This symbol was skipped earlier, but
10100                              since it is needed by a reloc, we
10101                              must output it now.  */
10102                           shlink = symtab_hdr->sh_link;
10103                           name = (bfd_elf_string_from_elf_section
10104                                   (input_bfd, shlink, sym.st_name));
10105                           if (name == NULL)
10106                             return FALSE;
10107
10108                           osec = sec->output_section;
10109                           sym.st_shndx =
10110                             _bfd_elf_section_from_bfd_section (output_bfd,
10111                                                                osec);
10112                           if (sym.st_shndx == SHN_BAD)
10113                             return FALSE;
10114
10115                           sym.st_value += sec->output_offset;
10116                           if (!flinfo->info->relocatable)
10117                             {
10118                               sym.st_value += osec->vma;
10119                               if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
10120                                 {
10121                                   /* STT_TLS symbols are relative to PT_TLS
10122                                      segment base.  */
10123                                   BFD_ASSERT (elf_hash_table (flinfo->info)
10124                                               ->tls_sec != NULL);
10125                                   sym.st_value -= (elf_hash_table (flinfo->info)
10126                                                    ->tls_sec->vma);
10127                                 }
10128                             }
10129
10130                           indx = bfd_get_symcount (output_bfd);
10131                           ret = elf_link_output_sym (flinfo, name, &sym, sec,
10132                                                      NULL);
10133                           if (ret == 0)
10134                             return FALSE;
10135                           else if (ret == 1)
10136                             flinfo->indices[r_symndx] = indx;
10137                           else
10138                             abort ();
10139                         }
10140
10141                       r_symndx = flinfo->indices[r_symndx];
10142                     }
10143
10144                   irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
10145                                    | (irela->r_info & r_type_mask));
10146                 }
10147
10148               /* Swap out the relocs.  */
10149               input_rel_hdr = esdi->rel.hdr;
10150               if (input_rel_hdr && input_rel_hdr->sh_size != 0)
10151                 {
10152                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10153                                                      input_rel_hdr,
10154                                                      internal_relocs,
10155                                                      rel_hash_list))
10156                     return FALSE;
10157                   internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
10158                                       * bed->s->int_rels_per_ext_rel);
10159                   rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
10160                 }
10161
10162               input_rela_hdr = esdi->rela.hdr;
10163               if (input_rela_hdr && input_rela_hdr->sh_size != 0)
10164                 {
10165                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10166                                                      input_rela_hdr,
10167                                                      internal_relocs,
10168                                                      rela_hash_list))
10169                     return FALSE;
10170                 }
10171             }
10172         }
10173
10174       /* Write out the modified section contents.  */
10175       if (bed->elf_backend_write_section
10176           && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
10177                                                 contents))
10178         {
10179           /* Section written out.  */
10180         }
10181       else switch (o->sec_info_type)
10182         {
10183         case SEC_INFO_TYPE_STABS:
10184           if (! (_bfd_write_section_stabs
10185                  (output_bfd,
10186                   &elf_hash_table (flinfo->info)->stab_info,
10187                   o, &elf_section_data (o)->sec_info, contents)))
10188             return FALSE;
10189           break;
10190         case SEC_INFO_TYPE_MERGE:
10191           if (! _bfd_write_merged_section (output_bfd, o,
10192                                            elf_section_data (o)->sec_info))
10193             return FALSE;
10194           break;
10195         case SEC_INFO_TYPE_EH_FRAME:
10196           {
10197             if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10198                                                    o, contents))
10199               return FALSE;
10200           }
10201           break;
10202         default:
10203           {
10204             /* FIXME: octets_per_byte.  */
10205             if (! (o->flags & SEC_EXCLUDE))
10206               {
10207                 file_ptr offset = (file_ptr) o->output_offset;
10208                 bfd_size_type todo = o->size;
10209                 if ((o->flags & SEC_ELF_REVERSE_COPY))
10210                   {
10211                     /* Reverse-copy input section to output.  */
10212                     do
10213                       {
10214                         todo -= address_size;
10215                         if (! bfd_set_section_contents (output_bfd,
10216                                                         o->output_section,
10217                                                         contents + todo,
10218                                                         offset,
10219                                                         address_size))
10220                           return FALSE;
10221                         if (todo == 0)
10222                           break;
10223                         offset += address_size;
10224                       }
10225                     while (1);
10226                   }
10227                 else if (! bfd_set_section_contents (output_bfd,
10228                                                      o->output_section,
10229                                                      contents,
10230                                                      offset, todo))
10231                   return FALSE;
10232               }
10233           }
10234           break;
10235         }
10236     }
10237
10238   return TRUE;
10239 }
10240
10241 /* Generate a reloc when linking an ELF file.  This is a reloc
10242    requested by the linker, and does not come from any input file.  This
10243    is used to build constructor and destructor tables when linking
10244    with -Ur.  */
10245
10246 static bfd_boolean
10247 elf_reloc_link_order (bfd *output_bfd,
10248                       struct bfd_link_info *info,
10249                       asection *output_section,
10250                       struct bfd_link_order *link_order)
10251 {
10252   reloc_howto_type *howto;
10253   long indx;
10254   bfd_vma offset;
10255   bfd_vma addend;
10256   struct bfd_elf_section_reloc_data *reldata;
10257   struct elf_link_hash_entry **rel_hash_ptr;
10258   Elf_Internal_Shdr *rel_hdr;
10259   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10260   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10261   bfd_byte *erel;
10262   unsigned int i;
10263   struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10264
10265   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10266   if (howto == NULL)
10267     {
10268       bfd_set_error (bfd_error_bad_value);
10269       return FALSE;
10270     }
10271
10272   addend = link_order->u.reloc.p->addend;
10273
10274   if (esdo->rel.hdr)
10275     reldata = &esdo->rel;
10276   else if (esdo->rela.hdr)
10277     reldata = &esdo->rela;
10278   else
10279     {
10280       reldata = NULL;
10281       BFD_ASSERT (0);
10282     }
10283
10284   /* Figure out the symbol index.  */
10285   rel_hash_ptr = reldata->hashes + reldata->count;
10286   if (link_order->type == bfd_section_reloc_link_order)
10287     {
10288       indx = link_order->u.reloc.p->u.section->target_index;
10289       BFD_ASSERT (indx != 0);
10290       *rel_hash_ptr = NULL;
10291     }
10292   else
10293     {
10294       struct elf_link_hash_entry *h;
10295
10296       /* Treat a reloc against a defined symbol as though it were
10297          actually against the section.  */
10298       h = ((struct elf_link_hash_entry *)
10299            bfd_wrapped_link_hash_lookup (output_bfd, info,
10300                                          link_order->u.reloc.p->u.name,
10301                                          FALSE, FALSE, TRUE));
10302       if (h != NULL
10303           && (h->root.type == bfd_link_hash_defined
10304               || h->root.type == bfd_link_hash_defweak))
10305         {
10306           asection *section;
10307
10308           section = h->root.u.def.section;
10309           indx = section->output_section->target_index;
10310           *rel_hash_ptr = NULL;
10311           /* It seems that we ought to add the symbol value to the
10312              addend here, but in practice it has already been added
10313              because it was passed to constructor_callback.  */
10314           addend += section->output_section->vma + section->output_offset;
10315         }
10316       else if (h != NULL)
10317         {
10318           /* Setting the index to -2 tells elf_link_output_extsym that
10319              this symbol is used by a reloc.  */
10320           h->indx = -2;
10321           *rel_hash_ptr = h;
10322           indx = 0;
10323         }
10324       else
10325         {
10326           if (! ((*info->callbacks->unattached_reloc)
10327                  (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10328             return FALSE;
10329           indx = 0;
10330         }
10331     }
10332
10333   /* If this is an inplace reloc, we must write the addend into the
10334      object file.  */
10335   if (howto->partial_inplace && addend != 0)
10336     {
10337       bfd_size_type size;
10338       bfd_reloc_status_type rstat;
10339       bfd_byte *buf;
10340       bfd_boolean ok;
10341       const char *sym_name;
10342
10343       size = (bfd_size_type) bfd_get_reloc_size (howto);
10344       buf = (bfd_byte *) bfd_zmalloc (size);
10345       if (buf == NULL && size != 0)
10346         return FALSE;
10347       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10348       switch (rstat)
10349         {
10350         case bfd_reloc_ok:
10351           break;
10352
10353         default:
10354         case bfd_reloc_outofrange:
10355           abort ();
10356
10357         case bfd_reloc_overflow:
10358           if (link_order->type == bfd_section_reloc_link_order)
10359             sym_name = bfd_section_name (output_bfd,
10360                                          link_order->u.reloc.p->u.section);
10361           else
10362             sym_name = link_order->u.reloc.p->u.name;
10363           if (! ((*info->callbacks->reloc_overflow)
10364                  (info, NULL, sym_name, howto->name, addend, NULL,
10365                   NULL, (bfd_vma) 0)))
10366             {
10367               free (buf);
10368               return FALSE;
10369             }
10370           break;
10371         }
10372       ok = bfd_set_section_contents (output_bfd, output_section, buf,
10373                                      link_order->offset, size);
10374       free (buf);
10375       if (! ok)
10376         return FALSE;
10377     }
10378
10379   /* The address of a reloc is relative to the section in a
10380      relocatable file, and is a virtual address in an executable
10381      file.  */
10382   offset = link_order->offset;
10383   if (! info->relocatable)
10384     offset += output_section->vma;
10385
10386   for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10387     {
10388       irel[i].r_offset = offset;
10389       irel[i].r_info = 0;
10390       irel[i].r_addend = 0;
10391     }
10392   if (bed->s->arch_size == 32)
10393     irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10394   else
10395     irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10396
10397   rel_hdr = reldata->hdr;
10398   erel = rel_hdr->contents;
10399   if (rel_hdr->sh_type == SHT_REL)
10400     {
10401       erel += reldata->count * bed->s->sizeof_rel;
10402       (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10403     }
10404   else
10405     {
10406       irel[0].r_addend = addend;
10407       erel += reldata->count * bed->s->sizeof_rela;
10408       (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10409     }
10410
10411   ++reldata->count;
10412
10413   return TRUE;
10414 }
10415
10416
10417 /* Get the output vma of the section pointed to by the sh_link field.  */
10418
10419 static bfd_vma
10420 elf_get_linked_section_vma (struct bfd_link_order *p)
10421 {
10422   Elf_Internal_Shdr **elf_shdrp;
10423   asection *s;
10424   int elfsec;
10425
10426   s = p->u.indirect.section;
10427   elf_shdrp = elf_elfsections (s->owner);
10428   elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10429   elfsec = elf_shdrp[elfsec]->sh_link;
10430   /* PR 290:
10431      The Intel C compiler generates SHT_IA_64_UNWIND with
10432      SHF_LINK_ORDER.  But it doesn't set the sh_link or
10433      sh_info fields.  Hence we could get the situation
10434      where elfsec is 0.  */
10435   if (elfsec == 0)
10436     {
10437       const struct elf_backend_data *bed
10438         = get_elf_backend_data (s->owner);
10439       if (bed->link_order_error_handler)
10440         bed->link_order_error_handler
10441           (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10442       return 0;
10443     }
10444   else
10445     {
10446       s = elf_shdrp[elfsec]->bfd_section;
10447       return s->output_section->vma + s->output_offset;
10448     }
10449 }
10450
10451
10452 /* Compare two sections based on the locations of the sections they are
10453    linked to.  Used by elf_fixup_link_order.  */
10454
10455 static int
10456 compare_link_order (const void * a, const void * b)
10457 {
10458   bfd_vma apos;
10459   bfd_vma bpos;
10460
10461   apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10462   bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10463   if (apos < bpos)
10464     return -1;
10465   return apos > bpos;
10466 }
10467
10468
10469 /* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
10470    order as their linked sections.  Returns false if this could not be done
10471    because an output section includes both ordered and unordered
10472    sections.  Ideally we'd do this in the linker proper.  */
10473
10474 static bfd_boolean
10475 elf_fixup_link_order (bfd *abfd, asection *o)
10476 {
10477   int seen_linkorder;
10478   int seen_other;
10479   int n;
10480   struct bfd_link_order *p;
10481   bfd *sub;
10482   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10483   unsigned elfsec;
10484   struct bfd_link_order **sections;
10485   asection *s, *other_sec, *linkorder_sec;
10486   bfd_vma offset;
10487
10488   other_sec = NULL;
10489   linkorder_sec = NULL;
10490   seen_other = 0;
10491   seen_linkorder = 0;
10492   for (p = o->map_head.link_order; p != NULL; p = p->next)
10493     {
10494       if (p->type == bfd_indirect_link_order)
10495         {
10496           s = p->u.indirect.section;
10497           sub = s->owner;
10498           if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10499               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10500               && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10501               && elfsec < elf_numsections (sub)
10502               && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10503               && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10504             {
10505               seen_linkorder++;
10506               linkorder_sec = s;
10507             }
10508           else
10509             {
10510               seen_other++;
10511               other_sec = s;
10512             }
10513         }
10514       else
10515         seen_other++;
10516
10517       if (seen_other && seen_linkorder)
10518         {
10519           if (other_sec && linkorder_sec)
10520             (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10521                                    o, linkorder_sec,
10522                                    linkorder_sec->owner, other_sec,
10523                                    other_sec->owner);
10524           else
10525             (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10526                                    o);
10527           bfd_set_error (bfd_error_bad_value);
10528           return FALSE;
10529         }
10530     }
10531
10532   if (!seen_linkorder)
10533     return TRUE;
10534
10535   sections = (struct bfd_link_order **)
10536     bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10537   if (sections == NULL)
10538     return FALSE;
10539   seen_linkorder = 0;
10540
10541   for (p = o->map_head.link_order; p != NULL; p = p->next)
10542     {
10543       sections[seen_linkorder++] = p;
10544     }
10545   /* Sort the input sections in the order of their linked section.  */
10546   qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10547          compare_link_order);
10548
10549   /* Change the offsets of the sections.  */
10550   offset = 0;
10551   for (n = 0; n < seen_linkorder; n++)
10552     {
10553       s = sections[n]->u.indirect.section;
10554       offset &= ~(bfd_vma) 0 << s->alignment_power;
10555       s->output_offset = offset;
10556       sections[n]->offset = offset;
10557       /* FIXME: octets_per_byte.  */
10558       offset += sections[n]->size;
10559     }
10560
10561   free (sections);
10562   return TRUE;
10563 }
10564
10565 static void
10566 elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
10567 {
10568   asection *o;
10569
10570   if (flinfo->symstrtab != NULL)
10571     _bfd_stringtab_free (flinfo->symstrtab);
10572   if (flinfo->contents != NULL)
10573     free (flinfo->contents);
10574   if (flinfo->external_relocs != NULL)
10575     free (flinfo->external_relocs);
10576   if (flinfo->internal_relocs != NULL)
10577     free (flinfo->internal_relocs);
10578   if (flinfo->external_syms != NULL)
10579     free (flinfo->external_syms);
10580   if (flinfo->locsym_shndx != NULL)
10581     free (flinfo->locsym_shndx);
10582   if (flinfo->internal_syms != NULL)
10583     free (flinfo->internal_syms);
10584   if (flinfo->indices != NULL)
10585     free (flinfo->indices);
10586   if (flinfo->sections != NULL)
10587     free (flinfo->sections);
10588   if (flinfo->symbuf != NULL)
10589     free (flinfo->symbuf);
10590   if (flinfo->symshndxbuf != NULL)
10591     free (flinfo->symshndxbuf);
10592   for (o = obfd->sections; o != NULL; o = o->next)
10593     {
10594       struct bfd_elf_section_data *esdo = elf_section_data (o);
10595       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
10596         free (esdo->rel.hashes);
10597       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
10598         free (esdo->rela.hashes);
10599     }
10600 }
10601
10602 /* Do the final step of an ELF link.  */
10603
10604 bfd_boolean
10605 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10606 {
10607   bfd_boolean dynamic;
10608   bfd_boolean emit_relocs;
10609   bfd *dynobj;
10610   struct elf_final_link_info flinfo;
10611   asection *o;
10612   struct bfd_link_order *p;
10613   bfd *sub;
10614   bfd_size_type max_contents_size;
10615   bfd_size_type max_external_reloc_size;
10616   bfd_size_type max_internal_reloc_count;
10617   bfd_size_type max_sym_count;
10618   bfd_size_type max_sym_shndx_count;
10619   Elf_Internal_Sym elfsym;
10620   unsigned int i;
10621   Elf_Internal_Shdr *symtab_hdr;
10622   Elf_Internal_Shdr *symtab_shndx_hdr;
10623   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10624   struct elf_outext_info eoinfo;
10625   bfd_boolean merged;
10626   size_t relativecount = 0;
10627   asection *reldyn = 0;
10628   bfd_size_type amt;
10629   asection *attr_section = NULL;
10630   bfd_vma attr_size = 0;
10631   const char *std_attrs_section;
10632
10633   if (! is_elf_hash_table (info->hash))
10634     return FALSE;
10635
10636   if (info->shared)
10637     abfd->flags |= DYNAMIC;
10638
10639   dynamic = elf_hash_table (info)->dynamic_sections_created;
10640   dynobj = elf_hash_table (info)->dynobj;
10641
10642   emit_relocs = (info->relocatable
10643                  || info->emitrelocations);
10644
10645   flinfo.info = info;
10646   flinfo.output_bfd = abfd;
10647   flinfo.symstrtab = _bfd_elf_stringtab_init ();
10648   if (flinfo.symstrtab == NULL)
10649     return FALSE;
10650
10651   if (! dynamic)
10652     {
10653       flinfo.dynsym_sec = NULL;
10654       flinfo.hash_sec = NULL;
10655       flinfo.symver_sec = NULL;
10656     }
10657   else
10658     {
10659       flinfo.dynsym_sec = bfd_get_linker_section (dynobj, ".dynsym");
10660       flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
10661       /* Note that dynsym_sec can be NULL (on VMS).  */
10662       flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
10663       /* Note that it is OK if symver_sec is NULL.  */
10664     }
10665
10666   flinfo.contents = NULL;
10667   flinfo.external_relocs = NULL;
10668   flinfo.internal_relocs = NULL;
10669   flinfo.external_syms = NULL;
10670   flinfo.locsym_shndx = NULL;
10671   flinfo.internal_syms = NULL;
10672   flinfo.indices = NULL;
10673   flinfo.sections = NULL;
10674   flinfo.symbuf = NULL;
10675   flinfo.symshndxbuf = NULL;
10676   flinfo.symbuf_count = 0;
10677   flinfo.shndxbuf_size = 0;
10678   flinfo.filesym_count = 0;
10679
10680   /* The object attributes have been merged.  Remove the input
10681      sections from the link, and set the contents of the output
10682      secton.  */
10683   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10684   for (o = abfd->sections; o != NULL; o = o->next)
10685     {
10686       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10687           || strcmp (o->name, ".gnu.attributes") == 0)
10688         {
10689           for (p = o->map_head.link_order; p != NULL; p = p->next)
10690             {
10691               asection *input_section;
10692
10693               if (p->type != bfd_indirect_link_order)
10694                 continue;
10695               input_section = p->u.indirect.section;
10696               /* Hack: reset the SEC_HAS_CONTENTS flag so that
10697                  elf_link_input_bfd ignores this section.  */
10698               input_section->flags &= ~SEC_HAS_CONTENTS;
10699             }
10700
10701           attr_size = bfd_elf_obj_attr_size (abfd);
10702           if (attr_size)
10703             {
10704               bfd_set_section_size (abfd, o, attr_size);
10705               attr_section = o;
10706               /* Skip this section later on.  */
10707               o->map_head.link_order = NULL;
10708             }
10709           else
10710             o->flags |= SEC_EXCLUDE;
10711         }
10712     }
10713
10714   /* Count up the number of relocations we will output for each output
10715      section, so that we know the sizes of the reloc sections.  We
10716      also figure out some maximum sizes.  */
10717   max_contents_size = 0;
10718   max_external_reloc_size = 0;
10719   max_internal_reloc_count = 0;
10720   max_sym_count = 0;
10721   max_sym_shndx_count = 0;
10722   merged = FALSE;
10723   for (o = abfd->sections; o != NULL; o = o->next)
10724     {
10725       struct bfd_elf_section_data *esdo = elf_section_data (o);
10726       o->reloc_count = 0;
10727
10728       for (p = o->map_head.link_order; p != NULL; p = p->next)
10729         {
10730           unsigned int reloc_count = 0;
10731           struct bfd_elf_section_data *esdi = NULL;
10732
10733           if (p->type == bfd_section_reloc_link_order
10734               || p->type == bfd_symbol_reloc_link_order)
10735             reloc_count = 1;
10736           else if (p->type == bfd_indirect_link_order)
10737             {
10738               asection *sec;
10739
10740               sec = p->u.indirect.section;
10741               esdi = elf_section_data (sec);
10742
10743               /* Mark all sections which are to be included in the
10744                  link.  This will normally be every section.  We need
10745                  to do this so that we can identify any sections which
10746                  the linker has decided to not include.  */
10747               sec->linker_mark = TRUE;
10748
10749               if (sec->flags & SEC_MERGE)
10750                 merged = TRUE;
10751
10752               if (esdo->this_hdr.sh_type == SHT_REL
10753                   || esdo->this_hdr.sh_type == SHT_RELA)
10754                 /* Some backends use reloc_count in relocation sections
10755                    to count particular types of relocs.  Of course,
10756                    reloc sections themselves can't have relocations.  */
10757                 reloc_count = 0;
10758               else if (info->relocatable || info->emitrelocations)
10759                 reloc_count = sec->reloc_count;
10760               else if (bed->elf_backend_count_relocs)
10761                 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10762
10763               if (sec->rawsize > max_contents_size)
10764                 max_contents_size = sec->rawsize;
10765               if (sec->size > max_contents_size)
10766                 max_contents_size = sec->size;
10767
10768               /* We are interested in just local symbols, not all
10769                  symbols.  */
10770               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10771                   && (sec->owner->flags & DYNAMIC) == 0)
10772                 {
10773                   size_t sym_count;
10774
10775                   if (elf_bad_symtab (sec->owner))
10776                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10777                                  / bed->s->sizeof_sym);
10778                   else
10779                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10780
10781                   if (sym_count > max_sym_count)
10782                     max_sym_count = sym_count;
10783
10784                   if (sym_count > max_sym_shndx_count
10785                       && elf_symtab_shndx (sec->owner) != 0)
10786                     max_sym_shndx_count = sym_count;
10787
10788                   if ((sec->flags & SEC_RELOC) != 0)
10789                     {
10790                       size_t ext_size = 0;
10791
10792                       if (esdi->rel.hdr != NULL)
10793                         ext_size = esdi->rel.hdr->sh_size;
10794                       if (esdi->rela.hdr != NULL)
10795                         ext_size += esdi->rela.hdr->sh_size;
10796
10797                       if (ext_size > max_external_reloc_size)
10798                         max_external_reloc_size = ext_size;
10799                       if (sec->reloc_count > max_internal_reloc_count)
10800                         max_internal_reloc_count = sec->reloc_count;
10801                     }
10802                 }
10803             }
10804
10805           if (reloc_count == 0)
10806             continue;
10807
10808           o->reloc_count += reloc_count;
10809
10810           if (p->type == bfd_indirect_link_order
10811               && (info->relocatable || info->emitrelocations))
10812             {
10813               if (esdi->rel.hdr)
10814                 esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10815               if (esdi->rela.hdr)
10816                 esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10817             }
10818           else
10819             {
10820               if (o->use_rela_p)
10821                 esdo->rela.count += reloc_count;
10822               else
10823                 esdo->rel.count += reloc_count;
10824             }
10825         }
10826
10827       if (o->reloc_count > 0)
10828         o->flags |= SEC_RELOC;
10829       else
10830         {
10831           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
10832              set it (this is probably a bug) and if it is set
10833              assign_section_numbers will create a reloc section.  */
10834           o->flags &=~ SEC_RELOC;
10835         }
10836
10837       /* If the SEC_ALLOC flag is not set, force the section VMA to
10838          zero.  This is done in elf_fake_sections as well, but forcing
10839          the VMA to 0 here will ensure that relocs against these
10840          sections are handled correctly.  */
10841       if ((o->flags & SEC_ALLOC) == 0
10842           && ! o->user_set_vma)
10843         o->vma = 0;
10844     }
10845
10846   if (! info->relocatable && merged)
10847     elf_link_hash_traverse (elf_hash_table (info),
10848                             _bfd_elf_link_sec_merge_syms, abfd);
10849
10850   /* Figure out the file positions for everything but the symbol table
10851      and the relocs.  We set symcount to force assign_section_numbers
10852      to create a symbol table.  */
10853   bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
10854   BFD_ASSERT (! abfd->output_has_begun);
10855   if (! _bfd_elf_compute_section_file_positions (abfd, info))
10856     goto error_return;
10857
10858   /* Set sizes, and assign file positions for reloc sections.  */
10859   for (o = abfd->sections; o != NULL; o = o->next)
10860     {
10861       struct bfd_elf_section_data *esdo = elf_section_data (o);
10862       if ((o->flags & SEC_RELOC) != 0)
10863         {
10864           if (esdo->rel.hdr
10865               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10866             goto error_return;
10867
10868           if (esdo->rela.hdr
10869               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10870             goto error_return;
10871         }
10872
10873       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10874          to count upwards while actually outputting the relocations.  */
10875       esdo->rel.count = 0;
10876       esdo->rela.count = 0;
10877     }
10878
10879   /* We have now assigned file positions for all the sections except
10880      .symtab, .strtab, and non-loaded reloc sections.  We start the
10881      .symtab section at the current file position, and write directly
10882      to it.  We build the .strtab section in memory.  */
10883   bfd_get_symcount (abfd) = 0;
10884   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10885   /* sh_name is set in prep_headers.  */
10886   symtab_hdr->sh_type = SHT_SYMTAB;
10887   /* sh_flags, sh_addr and sh_size all start off zero.  */
10888   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10889   /* sh_link is set in assign_section_numbers.  */
10890   /* sh_info is set below.  */
10891   /* sh_offset is set just below.  */
10892   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10893
10894   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
10895      continuously seeking to the right position in the file.  */
10896   if (! info->keep_memory || max_sym_count < 20)
10897     flinfo.symbuf_size = 20;
10898   else
10899     flinfo.symbuf_size = max_sym_count;
10900   amt = flinfo.symbuf_size;
10901   amt *= bed->s->sizeof_sym;
10902   flinfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10903   if (flinfo.symbuf == NULL)
10904     goto error_return;
10905   if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10906     {
10907       /* Wild guess at number of output symbols.  realloc'd as needed.  */
10908       amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10909       flinfo.shndxbuf_size = amt;
10910       amt *= sizeof (Elf_External_Sym_Shndx);
10911       flinfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10912       if (flinfo.symshndxbuf == NULL)
10913         goto error_return;
10914     }
10915
10916   if (info->strip != strip_all || emit_relocs)
10917     {
10918       file_ptr off = elf_next_file_pos (abfd);
10919
10920       _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10921
10922       /* Note that at this point elf_next_file_pos (abfd) is
10923          incorrect.  We do not yet know the size of the .symtab section.
10924          We correct next_file_pos below, after we do know the size.  */
10925
10926       /* Start writing out the symbol table.  The first symbol is always a
10927          dummy symbol.  */
10928       elfsym.st_value = 0;
10929       elfsym.st_size = 0;
10930       elfsym.st_info = 0;
10931       elfsym.st_other = 0;
10932       elfsym.st_shndx = SHN_UNDEF;
10933       elfsym.st_target_internal = 0;
10934       if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
10935                                NULL) != 1)
10936         goto error_return;
10937
10938       /* Output a symbol for each section.  We output these even if we are
10939          discarding local symbols, since they are used for relocs.  These
10940          symbols have no names.  We store the index of each one in the
10941          index field of the section, so that we can find it again when
10942          outputting relocs.  */
10943
10944       elfsym.st_size = 0;
10945       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10946       elfsym.st_other = 0;
10947       elfsym.st_value = 0;
10948       elfsym.st_target_internal = 0;
10949       for (i = 1; i < elf_numsections (abfd); i++)
10950         {
10951           o = bfd_section_from_elf_index (abfd, i);
10952           if (o != NULL)
10953             {
10954               o->target_index = bfd_get_symcount (abfd);
10955               elfsym.st_shndx = i;
10956               if (!info->relocatable)
10957                 elfsym.st_value = o->vma;
10958               if (elf_link_output_sym (&flinfo, NULL, &elfsym, o, NULL) != 1)
10959                 goto error_return;
10960             }
10961         }
10962     }
10963
10964   /* Allocate some memory to hold information read in from the input
10965      files.  */
10966   if (max_contents_size != 0)
10967     {
10968       flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10969       if (flinfo.contents == NULL)
10970         goto error_return;
10971     }
10972
10973   if (max_external_reloc_size != 0)
10974     {
10975       flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
10976       if (flinfo.external_relocs == NULL)
10977         goto error_return;
10978     }
10979
10980   if (max_internal_reloc_count != 0)
10981     {
10982       amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10983       amt *= sizeof (Elf_Internal_Rela);
10984       flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10985       if (flinfo.internal_relocs == NULL)
10986         goto error_return;
10987     }
10988
10989   if (max_sym_count != 0)
10990     {
10991       amt = max_sym_count * bed->s->sizeof_sym;
10992       flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10993       if (flinfo.external_syms == NULL)
10994         goto error_return;
10995
10996       amt = max_sym_count * sizeof (Elf_Internal_Sym);
10997       flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10998       if (flinfo.internal_syms == NULL)
10999         goto error_return;
11000
11001       amt = max_sym_count * sizeof (long);
11002       flinfo.indices = (long int *) bfd_malloc (amt);
11003       if (flinfo.indices == NULL)
11004         goto error_return;
11005
11006       amt = max_sym_count * sizeof (asection *);
11007       flinfo.sections = (asection **) bfd_malloc (amt);
11008       if (flinfo.sections == NULL)
11009         goto error_return;
11010     }
11011
11012   if (max_sym_shndx_count != 0)
11013     {
11014       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
11015       flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
11016       if (flinfo.locsym_shndx == NULL)
11017         goto error_return;
11018     }
11019
11020   if (elf_hash_table (info)->tls_sec)
11021     {
11022       bfd_vma base, end = 0;
11023       asection *sec;
11024
11025       for (sec = elf_hash_table (info)->tls_sec;
11026            sec && (sec->flags & SEC_THREAD_LOCAL);
11027            sec = sec->next)
11028         {
11029           bfd_size_type size = sec->size;
11030
11031           if (size == 0
11032               && (sec->flags & SEC_HAS_CONTENTS) == 0)
11033             {
11034               struct bfd_link_order *ord = sec->map_tail.link_order;
11035
11036               if (ord != NULL)
11037                 size = ord->offset + ord->size;
11038             }
11039           end = sec->vma + size;
11040         }
11041       base = elf_hash_table (info)->tls_sec->vma;
11042       /* Only align end of TLS section if static TLS doesn't have special
11043          alignment requirements.  */
11044       if (bed->static_tls_alignment == 1)
11045         end = align_power (end,
11046                            elf_hash_table (info)->tls_sec->alignment_power);
11047       elf_hash_table (info)->tls_size = end - base;
11048     }
11049
11050   /* Reorder SHF_LINK_ORDER sections.  */
11051   for (o = abfd->sections; o != NULL; o = o->next)
11052     {
11053       if (!elf_fixup_link_order (abfd, o))
11054         return FALSE;
11055     }
11056
11057   /* Since ELF permits relocations to be against local symbols, we
11058      must have the local symbols available when we do the relocations.
11059      Since we would rather only read the local symbols once, and we
11060      would rather not keep them in memory, we handle all the
11061      relocations for a single input file at the same time.
11062
11063      Unfortunately, there is no way to know the total number of local
11064      symbols until we have seen all of them, and the local symbol
11065      indices precede the global symbol indices.  This means that when
11066      we are generating relocatable output, and we see a reloc against
11067      a global symbol, we can not know the symbol index until we have
11068      finished examining all the local symbols to see which ones we are
11069      going to output.  To deal with this, we keep the relocations in
11070      memory, and don't output them until the end of the link.  This is
11071      an unfortunate waste of memory, but I don't see a good way around
11072      it.  Fortunately, it only happens when performing a relocatable
11073      link, which is not the common case.  FIXME: If keep_memory is set
11074      we could write the relocs out and then read them again; I don't
11075      know how bad the memory loss will be.  */
11076
11077   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11078     sub->output_has_begun = FALSE;
11079   for (o = abfd->sections; o != NULL; o = o->next)
11080     {
11081       for (p = o->map_head.link_order; p != NULL; p = p->next)
11082         {
11083           if (p->type == bfd_indirect_link_order
11084               && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
11085                   == bfd_target_elf_flavour)
11086               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
11087             {
11088               if (! sub->output_has_begun)
11089                 {
11090                   if (! elf_link_input_bfd (&flinfo, sub))
11091                     goto error_return;
11092                   sub->output_has_begun = TRUE;
11093                 }
11094             }
11095           else if (p->type == bfd_section_reloc_link_order
11096                    || p->type == bfd_symbol_reloc_link_order)
11097             {
11098               if (! elf_reloc_link_order (abfd, info, o, p))
11099                 goto error_return;
11100             }
11101           else
11102             {
11103               if (! _bfd_default_link_order (abfd, info, o, p))
11104                 {
11105                   if (p->type == bfd_indirect_link_order
11106                       && (bfd_get_flavour (sub)
11107                           == bfd_target_elf_flavour)
11108                       && (elf_elfheader (sub)->e_ident[EI_CLASS]
11109                           != bed->s->elfclass))
11110                     {
11111                       const char *iclass, *oclass;
11112
11113                       if (bed->s->elfclass == ELFCLASS64)
11114                         {
11115                           iclass = "ELFCLASS32";
11116                           oclass = "ELFCLASS64";
11117                         }
11118                       else
11119                         {
11120                           iclass = "ELFCLASS64";
11121                           oclass = "ELFCLASS32";
11122                         }
11123
11124                       bfd_set_error (bfd_error_wrong_format);
11125                       (*_bfd_error_handler)
11126                         (_("%B: file class %s incompatible with %s"),
11127                          sub, iclass, oclass);
11128                     }
11129
11130                   goto error_return;
11131                 }
11132             }
11133         }
11134     }
11135
11136   /* Free symbol buffer if needed.  */
11137   if (!info->reduce_memory_overheads)
11138     {
11139       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11140         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11141             && elf_tdata (sub)->symbuf)
11142           {
11143             free (elf_tdata (sub)->symbuf);
11144             elf_tdata (sub)->symbuf = NULL;
11145           }
11146     }
11147
11148   /* Output any global symbols that got converted to local in a
11149      version script or due to symbol visibility.  We do this in a
11150      separate step since ELF requires all local symbols to appear
11151      prior to any global symbols.  FIXME: We should only do this if
11152      some global symbols were, in fact, converted to become local.
11153      FIXME: Will this work correctly with the Irix 5 linker?  */
11154   eoinfo.failed = FALSE;
11155   eoinfo.flinfo = &flinfo;
11156   eoinfo.localsyms = TRUE;
11157   eoinfo.file_sym_done = FALSE;
11158   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11159   if (eoinfo.failed)
11160     return FALSE;
11161
11162   /* If backend needs to output some local symbols not present in the hash
11163      table, do it now.  */
11164   if (bed->elf_backend_output_arch_local_syms
11165       && (info->strip != strip_all || emit_relocs))
11166     {
11167       typedef int (*out_sym_func)
11168         (void *, const char *, Elf_Internal_Sym *, asection *,
11169          struct elf_link_hash_entry *);
11170
11171       if (! ((*bed->elf_backend_output_arch_local_syms)
11172              (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11173         return FALSE;
11174     }
11175
11176   /* That wrote out all the local symbols.  Finish up the symbol table
11177      with the global symbols. Even if we want to strip everything we
11178      can, we still need to deal with those global symbols that got
11179      converted to local in a version script.  */
11180
11181   /* The sh_info field records the index of the first non local symbol.  */
11182   symtab_hdr->sh_info = bfd_get_symcount (abfd);
11183
11184   if (dynamic
11185       && flinfo.dynsym_sec != NULL
11186       && flinfo.dynsym_sec->output_section != bfd_abs_section_ptr)
11187     {
11188       Elf_Internal_Sym sym;
11189       bfd_byte *dynsym = flinfo.dynsym_sec->contents;
11190       long last_local = 0;
11191
11192       /* Write out the section symbols for the output sections.  */
11193       if (info->shared || elf_hash_table (info)->is_relocatable_executable)
11194         {
11195           asection *s;
11196
11197           sym.st_size = 0;
11198           sym.st_name = 0;
11199           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11200           sym.st_other = 0;
11201           sym.st_target_internal = 0;
11202
11203           for (s = abfd->sections; s != NULL; s = s->next)
11204             {
11205               int indx;
11206               bfd_byte *dest;
11207               long dynindx;
11208
11209               dynindx = elf_section_data (s)->dynindx;
11210               if (dynindx <= 0)
11211                 continue;
11212               indx = elf_section_data (s)->this_idx;
11213               BFD_ASSERT (indx > 0);
11214               sym.st_shndx = indx;
11215               if (! check_dynsym (abfd, &sym))
11216                 return FALSE;
11217               sym.st_value = s->vma;
11218               dest = dynsym + dynindx * bed->s->sizeof_sym;
11219               if (last_local < dynindx)
11220                 last_local = dynindx;
11221               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11222             }
11223         }
11224
11225       /* Write out the local dynsyms.  */
11226       if (elf_hash_table (info)->dynlocal)
11227         {
11228           struct elf_link_local_dynamic_entry *e;
11229           for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
11230             {
11231               asection *s;
11232               bfd_byte *dest;
11233
11234               /* Copy the internal symbol and turn off visibility.
11235                  Note that we saved a word of storage and overwrote
11236                  the original st_name with the dynstr_index.  */
11237               sym = e->isym;
11238               sym.st_other &= ~ELF_ST_VISIBILITY (-1);
11239
11240               s = bfd_section_from_elf_index (e->input_bfd,
11241                                               e->isym.st_shndx);
11242               if (s != NULL)
11243                 {
11244                   sym.st_shndx =
11245                     elf_section_data (s->output_section)->this_idx;
11246                   if (! check_dynsym (abfd, &sym))
11247                     return FALSE;
11248                   sym.st_value = (s->output_section->vma
11249                                   + s->output_offset
11250                                   + e->isym.st_value);
11251                 }
11252
11253               if (last_local < e->dynindx)
11254                 last_local = e->dynindx;
11255
11256               dest = dynsym + e->dynindx * bed->s->sizeof_sym;
11257               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11258             }
11259         }
11260
11261       elf_section_data (flinfo.dynsym_sec->output_section)->this_hdr.sh_info =
11262         last_local + 1;
11263     }
11264
11265   /* We get the global symbols from the hash table.  */
11266   eoinfo.failed = FALSE;
11267   eoinfo.localsyms = FALSE;
11268   eoinfo.flinfo = &flinfo;
11269   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11270   if (eoinfo.failed)
11271     return FALSE;
11272
11273   /* If backend needs to output some symbols not present in the hash
11274      table, do it now.  */
11275   if (bed->elf_backend_output_arch_syms
11276       && (info->strip != strip_all || emit_relocs))
11277     {
11278       typedef int (*out_sym_func)
11279         (void *, const char *, Elf_Internal_Sym *, asection *,
11280          struct elf_link_hash_entry *);
11281
11282       if (! ((*bed->elf_backend_output_arch_syms)
11283              (abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
11284         return FALSE;
11285     }
11286
11287   /* Flush all symbols to the file.  */
11288   if (! elf_link_flush_output_syms (&flinfo, bed))
11289     return FALSE;
11290
11291   /* Now we know the size of the symtab section.  */
11292   if (bfd_get_symcount (abfd) > 0)
11293     {
11294       /* Finish up and write out the symbol string table (.strtab)
11295          section.  */
11296       Elf_Internal_Shdr *symstrtab_hdr;
11297       file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
11298
11299       symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
11300       if (symtab_shndx_hdr->sh_name != 0)
11301         {
11302           symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
11303           symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
11304           symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
11305           amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
11306           symtab_shndx_hdr->sh_size = amt;
11307
11308           off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
11309                                                            off, TRUE);
11310
11311           if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
11312               || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
11313             return FALSE;
11314         }
11315
11316       symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
11317       /* sh_name was set in prep_headers.  */
11318       symstrtab_hdr->sh_type = SHT_STRTAB;
11319       symstrtab_hdr->sh_flags = 0;
11320       symstrtab_hdr->sh_addr = 0;
11321       symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
11322       symstrtab_hdr->sh_entsize = 0;
11323       symstrtab_hdr->sh_link = 0;
11324       symstrtab_hdr->sh_info = 0;
11325       /* sh_offset is set just below.  */
11326       symstrtab_hdr->sh_addralign = 1;
11327
11328       off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
11329                                                        off, TRUE);
11330       elf_next_file_pos (abfd) = off;
11331
11332       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
11333           || ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
11334         return FALSE;
11335     }
11336
11337   /* Adjust the relocs to have the correct symbol indices.  */
11338   for (o = abfd->sections; o != NULL; o = o->next)
11339     {
11340       struct bfd_elf_section_data *esdo = elf_section_data (o);
11341       bfd_boolean sort;
11342       if ((o->flags & SEC_RELOC) == 0)
11343         continue;
11344
11345       sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
11346       if (esdo->rel.hdr != NULL)
11347         elf_link_adjust_relocs (abfd, &esdo->rel, sort);
11348       if (esdo->rela.hdr != NULL)
11349         elf_link_adjust_relocs (abfd, &esdo->rela, sort);
11350
11351       /* Set the reloc_count field to 0 to prevent write_relocs from
11352          trying to swap the relocs out itself.  */
11353       o->reloc_count = 0;
11354     }
11355
11356   if (dynamic && info->combreloc && dynobj != NULL)
11357     relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11358
11359   /* If we are linking against a dynamic object, or generating a
11360      shared library, finish up the dynamic linking information.  */
11361   if (dynamic)
11362     {
11363       bfd_byte *dyncon, *dynconend;
11364
11365       /* Fix up .dynamic entries.  */
11366       o = bfd_get_linker_section (dynobj, ".dynamic");
11367       BFD_ASSERT (o != NULL);
11368
11369       dyncon = o->contents;
11370       dynconend = o->contents + o->size;
11371       for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11372         {
11373           Elf_Internal_Dyn dyn;
11374           const char *name;
11375           unsigned int type;
11376
11377           bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11378
11379           switch (dyn.d_tag)
11380             {
11381             default:
11382               continue;
11383             case DT_NULL:
11384               if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11385                 {
11386                   switch (elf_section_data (reldyn)->this_hdr.sh_type)
11387                     {
11388                     case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11389                     case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11390                     default: continue;
11391                     }
11392                   dyn.d_un.d_val = relativecount;
11393                   relativecount = 0;
11394                   break;
11395                 }
11396               continue;
11397
11398             case DT_INIT:
11399               name = info->init_function;
11400               goto get_sym;
11401             case DT_FINI:
11402               name = info->fini_function;
11403             get_sym:
11404               {
11405                 struct elf_link_hash_entry *h;
11406
11407                 h = elf_link_hash_lookup (elf_hash_table (info), name,
11408                                           FALSE, FALSE, TRUE);
11409                 if (h != NULL
11410                     && (h->root.type == bfd_link_hash_defined
11411                         || h->root.type == bfd_link_hash_defweak))
11412                   {
11413                     dyn.d_un.d_ptr = h->root.u.def.value;
11414                     o = h->root.u.def.section;
11415                     if (o->output_section != NULL)
11416                       dyn.d_un.d_ptr += (o->output_section->vma
11417                                          + o->output_offset);
11418                     else
11419                       {
11420                         /* The symbol is imported from another shared
11421                            library and does not apply to this one.  */
11422                         dyn.d_un.d_ptr = 0;
11423                       }
11424                     break;
11425                   }
11426               }
11427               continue;
11428
11429             case DT_PREINIT_ARRAYSZ:
11430               name = ".preinit_array";
11431               goto get_size;
11432             case DT_INIT_ARRAYSZ:
11433               name = ".init_array";
11434               goto get_size;
11435             case DT_FINI_ARRAYSZ:
11436               name = ".fini_array";
11437             get_size:
11438               o = bfd_get_section_by_name (abfd, name);
11439               if (o == NULL)
11440                 {
11441                   (*_bfd_error_handler)
11442                     (_("%B: could not find output section %s"), abfd, name);
11443                   goto error_return;
11444                 }
11445               if (o->size == 0)
11446                 (*_bfd_error_handler)
11447                   (_("warning: %s section has zero size"), name);
11448               dyn.d_un.d_val = o->size;
11449               break;
11450
11451             case DT_PREINIT_ARRAY:
11452               name = ".preinit_array";
11453               goto get_vma;
11454             case DT_INIT_ARRAY:
11455               name = ".init_array";
11456               goto get_vma;
11457             case DT_FINI_ARRAY:
11458               name = ".fini_array";
11459               goto get_vma;
11460
11461             case DT_HASH:
11462               name = ".hash";
11463               goto get_vma;
11464             case DT_GNU_HASH:
11465               name = ".gnu.hash";
11466               goto get_vma;
11467             case DT_STRTAB:
11468               name = ".dynstr";
11469               goto get_vma;
11470             case DT_SYMTAB:
11471               name = ".dynsym";
11472               goto get_vma;
11473             case DT_VERDEF:
11474               name = ".gnu.version_d";
11475               goto get_vma;
11476             case DT_VERNEED:
11477               name = ".gnu.version_r";
11478               goto get_vma;
11479             case DT_VERSYM:
11480               name = ".gnu.version";
11481             get_vma:
11482               o = bfd_get_section_by_name (abfd, name);
11483               if (o == NULL)
11484                 {
11485                   (*_bfd_error_handler)
11486                     (_("%B: could not find output section %s"), abfd, name);
11487                   goto error_return;
11488                 }
11489               if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11490                 {
11491                   (*_bfd_error_handler)
11492                     (_("warning: section '%s' is being made into a note"), name);
11493                   bfd_set_error (bfd_error_nonrepresentable_section);
11494                   goto error_return;
11495                 }
11496               dyn.d_un.d_ptr = o->vma;
11497               break;
11498
11499             case DT_REL:
11500             case DT_RELA:
11501             case DT_RELSZ:
11502             case DT_RELASZ:
11503               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11504                 type = SHT_REL;
11505               else
11506                 type = SHT_RELA;
11507               dyn.d_un.d_val = 0;
11508               dyn.d_un.d_ptr = 0;
11509               for (i = 1; i < elf_numsections (abfd); i++)
11510                 {
11511                   Elf_Internal_Shdr *hdr;
11512
11513                   hdr = elf_elfsections (abfd)[i];
11514                   if (hdr->sh_type == type
11515                       && (hdr->sh_flags & SHF_ALLOC) != 0)
11516                     {
11517                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11518                         dyn.d_un.d_val += hdr->sh_size;
11519                       else
11520                         {
11521                           if (dyn.d_un.d_ptr == 0
11522                               || hdr->sh_addr < dyn.d_un.d_ptr)
11523                             dyn.d_un.d_ptr = hdr->sh_addr;
11524                         }
11525                     }
11526                 }
11527               break;
11528             }
11529           bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11530         }
11531     }
11532
11533   /* If we have created any dynamic sections, then output them.  */
11534   if (dynobj != NULL)
11535     {
11536       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11537         goto error_return;
11538
11539       /* Check for DT_TEXTREL (late, in case the backend removes it).  */
11540       if (((info->warn_shared_textrel && info->shared)
11541            || info->error_textrel)
11542           && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
11543         {
11544           bfd_byte *dyncon, *dynconend;
11545
11546           dyncon = o->contents;
11547           dynconend = o->contents + o->size;
11548           for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11549             {
11550               Elf_Internal_Dyn dyn;
11551
11552               bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11553
11554               if (dyn.d_tag == DT_TEXTREL)
11555                 {
11556                   if (info->error_textrel)
11557                     info->callbacks->einfo
11558                       (_("%P%X: read-only segment has dynamic relocations.\n"));
11559                   else
11560                     info->callbacks->einfo
11561                       (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11562                   break;
11563                 }
11564             }
11565         }
11566
11567       for (o = dynobj->sections; o != NULL; o = o->next)
11568         {
11569           if ((o->flags & SEC_HAS_CONTENTS) == 0
11570               || o->size == 0
11571               || o->output_section == bfd_abs_section_ptr)
11572             continue;
11573           if ((o->flags & SEC_LINKER_CREATED) == 0)
11574             {
11575               /* At this point, we are only interested in sections
11576                  created by _bfd_elf_link_create_dynamic_sections.  */
11577               continue;
11578             }
11579           if (elf_hash_table (info)->stab_info.stabstr == o)
11580             continue;
11581           if (elf_hash_table (info)->eh_info.hdr_sec == o)
11582             continue;
11583           if (strcmp (o->name, ".dynstr") != 0)
11584             {
11585               /* FIXME: octets_per_byte.  */
11586               if (! bfd_set_section_contents (abfd, o->output_section,
11587                                               o->contents,
11588                                               (file_ptr) o->output_offset,
11589                                               o->size))
11590                 goto error_return;
11591             }
11592           else
11593             {
11594               /* The contents of the .dynstr section are actually in a
11595                  stringtab.  */
11596               file_ptr off;
11597
11598               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11599               if (bfd_seek (abfd, off, SEEK_SET) != 0
11600                   || ! _bfd_elf_strtab_emit (abfd,
11601                                              elf_hash_table (info)->dynstr))
11602                 goto error_return;
11603             }
11604         }
11605     }
11606
11607   if (info->relocatable)
11608     {
11609       bfd_boolean failed = FALSE;
11610
11611       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11612       if (failed)
11613         goto error_return;
11614     }
11615
11616   /* If we have optimized stabs strings, output them.  */
11617   if (elf_hash_table (info)->stab_info.stabstr != NULL)
11618     {
11619       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11620         goto error_return;
11621     }
11622
11623   if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11624     goto error_return;
11625
11626   elf_final_link_free (abfd, &flinfo);
11627
11628   elf_linker (abfd) = TRUE;
11629
11630   if (attr_section)
11631     {
11632       bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11633       if (contents == NULL)
11634         return FALSE;   /* Bail out and fail.  */
11635       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11636       bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11637       free (contents);
11638     }
11639
11640   return TRUE;
11641
11642  error_return:
11643   elf_final_link_free (abfd, &flinfo);
11644   return FALSE;
11645 }
11646 \f
11647 /* Initialize COOKIE for input bfd ABFD.  */
11648
11649 static bfd_boolean
11650 init_reloc_cookie (struct elf_reloc_cookie *cookie,
11651                    struct bfd_link_info *info, bfd *abfd)
11652 {
11653   Elf_Internal_Shdr *symtab_hdr;
11654   const struct elf_backend_data *bed;
11655
11656   bed = get_elf_backend_data (abfd);
11657   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11658
11659   cookie->abfd = abfd;
11660   cookie->sym_hashes = elf_sym_hashes (abfd);
11661   cookie->bad_symtab = elf_bad_symtab (abfd);
11662   if (cookie->bad_symtab)
11663     {
11664       cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11665       cookie->extsymoff = 0;
11666     }
11667   else
11668     {
11669       cookie->locsymcount = symtab_hdr->sh_info;
11670       cookie->extsymoff = symtab_hdr->sh_info;
11671     }
11672
11673   if (bed->s->arch_size == 32)
11674     cookie->r_sym_shift = 8;
11675   else
11676     cookie->r_sym_shift = 32;
11677
11678   cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11679   if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11680     {
11681       cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11682                                               cookie->locsymcount, 0,
11683                                               NULL, NULL, NULL);
11684       if (cookie->locsyms == NULL)
11685         {
11686           info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11687           return FALSE;
11688         }
11689       if (info->keep_memory)
11690         symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11691     }
11692   return TRUE;
11693 }
11694
11695 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
11696
11697 static void
11698 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11699 {
11700   Elf_Internal_Shdr *symtab_hdr;
11701
11702   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11703   if (cookie->locsyms != NULL
11704       && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11705     free (cookie->locsyms);
11706 }
11707
11708 /* Initialize the relocation information in COOKIE for input section SEC
11709    of input bfd ABFD.  */
11710
11711 static bfd_boolean
11712 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11713                         struct bfd_link_info *info, bfd *abfd,
11714                         asection *sec)
11715 {
11716   const struct elf_backend_data *bed;
11717
11718   if (sec->reloc_count == 0)
11719     {
11720       cookie->rels = NULL;
11721       cookie->relend = NULL;
11722     }
11723   else
11724     {
11725       bed = get_elf_backend_data (abfd);
11726
11727       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11728                                                 info->keep_memory);
11729       if (cookie->rels == NULL)
11730         return FALSE;
11731       cookie->rel = cookie->rels;
11732       cookie->relend = (cookie->rels
11733                         + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11734     }
11735   cookie->rel = cookie->rels;
11736   return TRUE;
11737 }
11738
11739 /* Free the memory allocated by init_reloc_cookie_rels,
11740    if appropriate.  */
11741
11742 static void
11743 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11744                         asection *sec)
11745 {
11746   if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11747     free (cookie->rels);
11748 }
11749
11750 /* Initialize the whole of COOKIE for input section SEC.  */
11751
11752 static bfd_boolean
11753 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11754                                struct bfd_link_info *info,
11755                                asection *sec)
11756 {
11757   if (!init_reloc_cookie (cookie, info, sec->owner))
11758     goto error1;
11759   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11760     goto error2;
11761   return TRUE;
11762
11763  error2:
11764   fini_reloc_cookie (cookie, sec->owner);
11765  error1:
11766   return FALSE;
11767 }
11768
11769 /* Free the memory allocated by init_reloc_cookie_for_section,
11770    if appropriate.  */
11771
11772 static void
11773 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11774                                asection *sec)
11775 {
11776   fini_reloc_cookie_rels (cookie, sec);
11777   fini_reloc_cookie (cookie, sec->owner);
11778 }
11779 \f
11780 /* Garbage collect unused sections.  */
11781
11782 /* Default gc_mark_hook.  */
11783
11784 asection *
11785 _bfd_elf_gc_mark_hook (asection *sec,
11786                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
11787                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11788                        struct elf_link_hash_entry *h,
11789                        Elf_Internal_Sym *sym)
11790 {
11791   const char *sec_name;
11792
11793   if (h != NULL)
11794     {
11795       switch (h->root.type)
11796         {
11797         case bfd_link_hash_defined:
11798         case bfd_link_hash_defweak:
11799           return h->root.u.def.section;
11800
11801         case bfd_link_hash_common:
11802           return h->root.u.c.p->section;
11803
11804         case bfd_link_hash_undefined:
11805         case bfd_link_hash_undefweak:
11806           /* To work around a glibc bug, keep all XXX input sections
11807              when there is an as yet undefined reference to __start_XXX
11808              or __stop_XXX symbols.  The linker will later define such
11809              symbols for orphan input sections that have a name
11810              representable as a C identifier.  */
11811           if (strncmp (h->root.root.string, "__start_", 8) == 0)
11812             sec_name = h->root.root.string + 8;
11813           else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11814             sec_name = h->root.root.string + 7;
11815           else
11816             sec_name = NULL;
11817
11818           if (sec_name && *sec_name != '\0')
11819             {
11820               bfd *i;
11821
11822               for (i = info->input_bfds; i; i = i->link.next)
11823                 {
11824                   sec = bfd_get_section_by_name (i, sec_name);
11825                   if (sec)
11826                     sec->flags |= SEC_KEEP;
11827                 }
11828             }
11829           break;
11830
11831         default:
11832           break;
11833         }
11834     }
11835   else
11836     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11837
11838   return NULL;
11839 }
11840
11841 /* COOKIE->rel describes a relocation against section SEC, which is
11842    a section we've decided to keep.  Return the section that contains
11843    the relocation symbol, or NULL if no section contains it.  */
11844
11845 asection *
11846 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11847                        elf_gc_mark_hook_fn gc_mark_hook,
11848                        struct elf_reloc_cookie *cookie)
11849 {
11850   unsigned long r_symndx;
11851   struct elf_link_hash_entry *h;
11852
11853   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11854   if (r_symndx == STN_UNDEF)
11855     return NULL;
11856
11857   if (r_symndx >= cookie->locsymcount
11858       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11859     {
11860       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11861       if (h == NULL)
11862         {
11863           info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
11864                                   sec->owner);
11865           return NULL;
11866         }
11867       while (h->root.type == bfd_link_hash_indirect
11868              || h->root.type == bfd_link_hash_warning)
11869         h = (struct elf_link_hash_entry *) h->root.u.i.link;
11870       h->mark = 1;
11871       /* If this symbol is weak and there is a non-weak definition, we
11872          keep the non-weak definition because many backends put
11873          dynamic reloc info on the non-weak definition for code
11874          handling copy relocs.  */
11875       if (h->u.weakdef != NULL)
11876         h->u.weakdef->mark = 1;
11877       return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11878     }
11879
11880   return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11881                           &cookie->locsyms[r_symndx]);
11882 }
11883
11884 /* COOKIE->rel describes a relocation against section SEC, which is
11885    a section we've decided to keep.  Mark the section that contains
11886    the relocation symbol.  */
11887
11888 bfd_boolean
11889 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11890                         asection *sec,
11891                         elf_gc_mark_hook_fn gc_mark_hook,
11892                         struct elf_reloc_cookie *cookie)
11893 {
11894   asection *rsec;
11895
11896   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11897   if (rsec && !rsec->gc_mark)
11898     {
11899       if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
11900           || (rsec->owner->flags & DYNAMIC) != 0)
11901         rsec->gc_mark = 1;
11902       else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11903         return FALSE;
11904     }
11905   return TRUE;
11906 }
11907
11908 /* The mark phase of garbage collection.  For a given section, mark
11909    it and any sections in this section's group, and all the sections
11910    which define symbols to which it refers.  */
11911
11912 bfd_boolean
11913 _bfd_elf_gc_mark (struct bfd_link_info *info,
11914                   asection *sec,
11915                   elf_gc_mark_hook_fn gc_mark_hook)
11916 {
11917   bfd_boolean ret;
11918   asection *group_sec, *eh_frame;
11919
11920   sec->gc_mark = 1;
11921
11922   /* Mark all the sections in the group.  */
11923   group_sec = elf_section_data (sec)->next_in_group;
11924   if (group_sec && !group_sec->gc_mark)
11925     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11926       return FALSE;
11927
11928   /* Look through the section relocs.  */
11929   ret = TRUE;
11930   eh_frame = elf_eh_frame_section (sec->owner);
11931   if ((sec->flags & SEC_RELOC) != 0
11932       && sec->reloc_count > 0
11933       && sec != eh_frame)
11934     {
11935       struct elf_reloc_cookie cookie;
11936
11937       if (!init_reloc_cookie_for_section (&cookie, info, sec))
11938         ret = FALSE;
11939       else
11940         {
11941           for (; cookie.rel < cookie.relend; cookie.rel++)
11942             if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11943               {
11944                 ret = FALSE;
11945                 break;
11946               }
11947           fini_reloc_cookie_for_section (&cookie, sec);
11948         }
11949     }
11950
11951   if (ret && eh_frame && elf_fde_list (sec))
11952     {
11953       struct elf_reloc_cookie cookie;
11954
11955       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11956         ret = FALSE;
11957       else
11958         {
11959           if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11960                                       gc_mark_hook, &cookie))
11961             ret = FALSE;
11962           fini_reloc_cookie_for_section (&cookie, eh_frame);
11963         }
11964     }
11965
11966   return ret;
11967 }
11968
11969 /* Scan and mark sections in a special or debug section group.  */
11970
11971 static void
11972 _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
11973 {
11974   /* Point to first section of section group.  */
11975   asection *ssec;
11976   /* Used to iterate the section group.  */
11977   asection *msec;
11978
11979   bfd_boolean is_special_grp = TRUE;
11980   bfd_boolean is_debug_grp = TRUE;
11981
11982   /* First scan to see if group contains any section other than debug
11983      and special section.  */
11984   ssec = msec = elf_next_in_group (grp);
11985   do
11986     {
11987       if ((msec->flags & SEC_DEBUGGING) == 0)
11988         is_debug_grp = FALSE;
11989
11990       if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
11991         is_special_grp = FALSE;
11992
11993       msec = elf_next_in_group (msec);
11994     }
11995   while (msec != ssec);
11996
11997   /* If this is a pure debug section group or pure special section group,
11998      keep all sections in this group.  */
11999   if (is_debug_grp || is_special_grp)
12000     {
12001       do
12002         {
12003           msec->gc_mark = 1;
12004           msec = elf_next_in_group (msec);
12005         }
12006       while (msec != ssec);
12007     }
12008 }
12009
12010 /* Keep debug and special sections.  */
12011
12012 bfd_boolean
12013 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12014                                  elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
12015 {
12016   bfd *ibfd;
12017
12018   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12019     {
12020       asection *isec;
12021       bfd_boolean some_kept;
12022       bfd_boolean debug_frag_seen;
12023
12024       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12025         continue;
12026
12027       /* Ensure all linker created sections are kept,
12028          see if any other section is already marked,
12029          and note if we have any fragmented debug sections.  */
12030       debug_frag_seen = some_kept = FALSE;
12031       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12032         {
12033           if ((isec->flags & SEC_LINKER_CREATED) != 0)
12034             isec->gc_mark = 1;
12035           else if (isec->gc_mark)
12036             some_kept = TRUE;
12037
12038           if (debug_frag_seen == FALSE
12039               && (isec->flags & SEC_DEBUGGING)
12040               && CONST_STRNEQ (isec->name, ".debug_line."))
12041             debug_frag_seen = TRUE;
12042         }
12043
12044       /* If no section in this file will be kept, then we can
12045          toss out the debug and special sections.  */
12046       if (!some_kept)
12047         continue;
12048
12049       /* Keep debug and special sections like .comment when they are
12050          not part of a group.  Also keep section groups that contain
12051          just debug sections or special sections.  */
12052       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12053         {
12054           if ((isec->flags & SEC_GROUP) != 0)
12055             _bfd_elf_gc_mark_debug_special_section_group (isec);
12056           else if (((isec->flags & SEC_DEBUGGING) != 0
12057                     || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
12058                    && elf_next_in_group (isec) == NULL)
12059             isec->gc_mark = 1;
12060         }
12061
12062       if (! debug_frag_seen)
12063         continue;
12064
12065       /* Look for CODE sections which are going to be discarded,
12066          and find and discard any fragmented debug sections which
12067          are associated with that code section.  */
12068       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12069         if ((isec->flags & SEC_CODE) != 0
12070             && isec->gc_mark == 0)
12071           {
12072             unsigned int ilen;
12073             asection *dsec;
12074
12075             ilen = strlen (isec->name);
12076
12077             /* Association is determined by the name of the debug section
12078                containing the name of the code section as a suffix.  For
12079                example .debug_line.text.foo is a debug section associated
12080                with .text.foo.  */
12081             for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
12082               {
12083                 unsigned int dlen;
12084
12085                 if (dsec->gc_mark == 0
12086                     || (dsec->flags & SEC_DEBUGGING) == 0)
12087                   continue;
12088
12089                 dlen = strlen (dsec->name);
12090
12091                 if (dlen > ilen
12092                     && strncmp (dsec->name + (dlen - ilen),
12093                                 isec->name, ilen) == 0)
12094                   {
12095                     dsec->gc_mark = 0;
12096                     break;
12097                   }
12098               }
12099           }
12100     }
12101   return TRUE;
12102 }
12103
12104 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
12105
12106 struct elf_gc_sweep_symbol_info
12107 {
12108   struct bfd_link_info *info;
12109   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
12110                        bfd_boolean);
12111 };
12112
12113 static bfd_boolean
12114 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
12115 {
12116   if (!h->mark
12117       && (((h->root.type == bfd_link_hash_defined
12118             || h->root.type == bfd_link_hash_defweak)
12119            && !((h->def_regular || ELF_COMMON_DEF_P (h))
12120                 && h->root.u.def.section->gc_mark))
12121           || h->root.type == bfd_link_hash_undefined
12122           || h->root.type == bfd_link_hash_undefweak))
12123     {
12124       struct elf_gc_sweep_symbol_info *inf;
12125
12126       inf = (struct elf_gc_sweep_symbol_info *) data;
12127       (*inf->hide_symbol) (inf->info, h, TRUE);
12128       h->def_regular = 0;
12129       h->ref_regular = 0;
12130       h->ref_regular_nonweak = 0;
12131     }
12132
12133   return TRUE;
12134 }
12135
12136 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
12137
12138 typedef bfd_boolean (*gc_sweep_hook_fn)
12139   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
12140
12141 static bfd_boolean
12142 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
12143 {
12144   bfd *sub;
12145   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12146   gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
12147   unsigned long section_sym_count;
12148   struct elf_gc_sweep_symbol_info sweep_info;
12149
12150   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12151     {
12152       asection *o;
12153
12154       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12155         continue;
12156
12157       for (o = sub->sections; o != NULL; o = o->next)
12158         {
12159           /* When any section in a section group is kept, we keep all
12160              sections in the section group.  If the first member of
12161              the section group is excluded, we will also exclude the
12162              group section.  */
12163           if (o->flags & SEC_GROUP)
12164             {
12165               asection *first = elf_next_in_group (o);
12166               o->gc_mark = first->gc_mark;
12167             }
12168
12169           if (o->gc_mark)
12170             continue;
12171
12172           /* Skip sweeping sections already excluded.  */
12173           if (o->flags & SEC_EXCLUDE)
12174             continue;
12175
12176           /* Since this is early in the link process, it is simple
12177              to remove a section from the output.  */
12178           o->flags |= SEC_EXCLUDE;
12179
12180           if (info->print_gc_sections && o->size != 0)
12181             _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
12182
12183           /* But we also have to update some of the relocation
12184              info we collected before.  */
12185           if (gc_sweep_hook
12186               && (o->flags & SEC_RELOC) != 0
12187               && o->reloc_count != 0
12188               && !((info->strip == strip_all || info->strip == strip_debugger)
12189                    && (o->flags & SEC_DEBUGGING) != 0)
12190               && !bfd_is_abs_section (o->output_section))
12191             {
12192               Elf_Internal_Rela *internal_relocs;
12193               bfd_boolean r;
12194
12195               internal_relocs
12196                 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
12197                                              info->keep_memory);
12198               if (internal_relocs == NULL)
12199                 return FALSE;
12200
12201               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
12202
12203               if (elf_section_data (o)->relocs != internal_relocs)
12204                 free (internal_relocs);
12205
12206               if (!r)
12207                 return FALSE;
12208             }
12209         }
12210     }
12211
12212   /* Remove the symbols that were in the swept sections from the dynamic
12213      symbol table.  GCFIXME: Anyone know how to get them out of the
12214      static symbol table as well?  */
12215   sweep_info.info = info;
12216   sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
12217   elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
12218                           &sweep_info);
12219
12220   _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
12221   return TRUE;
12222 }
12223
12224 /* Propagate collected vtable information.  This is called through
12225    elf_link_hash_traverse.  */
12226
12227 static bfd_boolean
12228 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
12229 {
12230   /* Those that are not vtables.  */
12231   if (h->vtable == NULL || h->vtable->parent == NULL)
12232     return TRUE;
12233
12234   /* Those vtables that do not have parents, we cannot merge.  */
12235   if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
12236     return TRUE;
12237
12238   /* If we've already been done, exit.  */
12239   if (h->vtable->used && h->vtable->used[-1])
12240     return TRUE;
12241
12242   /* Make sure the parent's table is up to date.  */
12243   elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
12244
12245   if (h->vtable->used == NULL)
12246     {
12247       /* None of this table's entries were referenced.  Re-use the
12248          parent's table.  */
12249       h->vtable->used = h->vtable->parent->vtable->used;
12250       h->vtable->size = h->vtable->parent->vtable->size;
12251     }
12252   else
12253     {
12254       size_t n;
12255       bfd_boolean *cu, *pu;
12256
12257       /* Or the parent's entries into ours.  */
12258       cu = h->vtable->used;
12259       cu[-1] = TRUE;
12260       pu = h->vtable->parent->vtable->used;
12261       if (pu != NULL)
12262         {
12263           const struct elf_backend_data *bed;
12264           unsigned int log_file_align;
12265
12266           bed = get_elf_backend_data (h->root.u.def.section->owner);
12267           log_file_align = bed->s->log_file_align;
12268           n = h->vtable->parent->vtable->size >> log_file_align;
12269           while (n--)
12270             {
12271               if (*pu)
12272                 *cu = TRUE;
12273               pu++;
12274               cu++;
12275             }
12276         }
12277     }
12278
12279   return TRUE;
12280 }
12281
12282 static bfd_boolean
12283 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
12284 {
12285   asection *sec;
12286   bfd_vma hstart, hend;
12287   Elf_Internal_Rela *relstart, *relend, *rel;
12288   const struct elf_backend_data *bed;
12289   unsigned int log_file_align;
12290
12291   /* Take care of both those symbols that do not describe vtables as
12292      well as those that are not loaded.  */
12293   if (h->vtable == NULL || h->vtable->parent == NULL)
12294     return TRUE;
12295
12296   BFD_ASSERT (h->root.type == bfd_link_hash_defined
12297               || h->root.type == bfd_link_hash_defweak);
12298
12299   sec = h->root.u.def.section;
12300   hstart = h->root.u.def.value;
12301   hend = hstart + h->size;
12302
12303   relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
12304   if (!relstart)
12305     return *(bfd_boolean *) okp = FALSE;
12306   bed = get_elf_backend_data (sec->owner);
12307   log_file_align = bed->s->log_file_align;
12308
12309   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
12310
12311   for (rel = relstart; rel < relend; ++rel)
12312     if (rel->r_offset >= hstart && rel->r_offset < hend)
12313       {
12314         /* If the entry is in use, do nothing.  */
12315         if (h->vtable->used
12316             && (rel->r_offset - hstart) < h->vtable->size)
12317           {
12318             bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
12319             if (h->vtable->used[entry])
12320               continue;
12321           }
12322         /* Otherwise, kill it.  */
12323         rel->r_offset = rel->r_info = rel->r_addend = 0;
12324       }
12325
12326   return TRUE;
12327 }
12328
12329 /* Mark sections containing dynamically referenced symbols.  When
12330    building shared libraries, we must assume that any visible symbol is
12331    referenced.  */
12332
12333 bfd_boolean
12334 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
12335 {
12336   struct bfd_link_info *info = (struct bfd_link_info *) inf;
12337   struct bfd_elf_dynamic_list *d = info->dynamic_list;
12338
12339   if ((h->root.type == bfd_link_hash_defined
12340        || h->root.type == bfd_link_hash_defweak)
12341       && (h->ref_dynamic
12342           || ((h->def_regular || ELF_COMMON_DEF_P (h))
12343               && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
12344               && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
12345               && (!info->executable
12346                   || info->export_dynamic
12347                   || (h->dynamic
12348                       && d != NULL
12349                       && (*d->match) (&d->head, NULL, h->root.root.string)))
12350               && (strchr (h->root.root.string, ELF_VER_CHR) != NULL
12351                   || !bfd_hide_sym_by_version (info->version_info,
12352                                                h->root.root.string)))))
12353     h->root.u.def.section->flags |= SEC_KEEP;
12354
12355   return TRUE;
12356 }
12357
12358 /* Keep all sections containing symbols undefined on the command-line,
12359    and the section containing the entry symbol.  */
12360
12361 void
12362 _bfd_elf_gc_keep (struct bfd_link_info *info)
12363 {
12364   struct bfd_sym_chain *sym;
12365
12366   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
12367     {
12368       struct elf_link_hash_entry *h;
12369
12370       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
12371                                 FALSE, FALSE, FALSE);
12372
12373       if (h != NULL
12374           && (h->root.type == bfd_link_hash_defined
12375               || h->root.type == bfd_link_hash_defweak)
12376           && !bfd_is_abs_section (h->root.u.def.section))
12377         h->root.u.def.section->flags |= SEC_KEEP;
12378     }
12379 }
12380
12381 /* Do mark and sweep of unused sections.  */
12382
12383 bfd_boolean
12384 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
12385 {
12386   bfd_boolean ok = TRUE;
12387   bfd *sub;
12388   elf_gc_mark_hook_fn gc_mark_hook;
12389   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12390   struct elf_link_hash_table *htab;
12391
12392   if (!bed->can_gc_sections
12393       || !is_elf_hash_table (info->hash))
12394     {
12395       (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12396       return TRUE;
12397     }
12398
12399   bed->gc_keep (info);
12400   htab = elf_hash_table (info);
12401
12402   /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
12403      at the .eh_frame section if we can mark the FDEs individually.  */
12404   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12405     {
12406       asection *sec;
12407       struct elf_reloc_cookie cookie;
12408
12409       sec = bfd_get_section_by_name (sub, ".eh_frame");
12410       while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12411         {
12412           _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12413           if (elf_section_data (sec)->sec_info
12414               && (sec->flags & SEC_LINKER_CREATED) == 0)
12415             elf_eh_frame_section (sub) = sec;
12416           fini_reloc_cookie_for_section (&cookie, sec);
12417           sec = bfd_get_next_section_by_name (sec);
12418         }
12419     }
12420
12421   /* Apply transitive closure to the vtable entry usage info.  */
12422   elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
12423   if (!ok)
12424     return FALSE;
12425
12426   /* Kill the vtable relocations that were not used.  */
12427   elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
12428   if (!ok)
12429     return FALSE;
12430
12431   /* Mark dynamically referenced symbols.  */
12432   if (htab->dynamic_sections_created)
12433     elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info);
12434
12435   /* Grovel through relocs to find out who stays ...  */
12436   gc_mark_hook = bed->gc_mark_hook;
12437   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12438     {
12439       asection *o;
12440
12441       if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12442         continue;
12443
12444       /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12445          Also treat note sections as a root, if the section is not part
12446          of a group.  */
12447       for (o = sub->sections; o != NULL; o = o->next)
12448         if (!o->gc_mark
12449             && (o->flags & SEC_EXCLUDE) == 0
12450             && ((o->flags & SEC_KEEP) != 0
12451                 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12452                     && elf_next_in_group (o) == NULL )))
12453           {
12454             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12455               return FALSE;
12456           }
12457     }
12458
12459   /* Allow the backend to mark additional target specific sections.  */
12460   bed->gc_mark_extra_sections (info, gc_mark_hook);
12461
12462   /* ... and mark SEC_EXCLUDE for those that go.  */
12463   return elf_gc_sweep (abfd, info);
12464 }
12465 \f
12466 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
12467
12468 bfd_boolean
12469 bfd_elf_gc_record_vtinherit (bfd *abfd,
12470                              asection *sec,
12471                              struct elf_link_hash_entry *h,
12472                              bfd_vma offset)
12473 {
12474   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12475   struct elf_link_hash_entry **search, *child;
12476   bfd_size_type extsymcount;
12477   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12478
12479   /* The sh_info field of the symtab header tells us where the
12480      external symbols start.  We don't care about the local symbols at
12481      this point.  */
12482   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12483   if (!elf_bad_symtab (abfd))
12484     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12485
12486   sym_hashes = elf_sym_hashes (abfd);
12487   sym_hashes_end = sym_hashes + extsymcount;
12488
12489   /* Hunt down the child symbol, which is in this section at the same
12490      offset as the relocation.  */
12491   for (search = sym_hashes; search != sym_hashes_end; ++search)
12492     {
12493       if ((child = *search) != NULL
12494           && (child->root.type == bfd_link_hash_defined
12495               || child->root.type == bfd_link_hash_defweak)
12496           && child->root.u.def.section == sec
12497           && child->root.u.def.value == offset)
12498         goto win;
12499     }
12500
12501   (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12502                          abfd, sec, (unsigned long) offset);
12503   bfd_set_error (bfd_error_invalid_operation);
12504   return FALSE;
12505
12506  win:
12507   if (!child->vtable)
12508     {
12509       child->vtable = ((struct elf_link_virtual_table_entry *)
12510                        bfd_zalloc (abfd, sizeof (*child->vtable)));
12511       if (!child->vtable)
12512         return FALSE;
12513     }
12514   if (!h)
12515     {
12516       /* This *should* only be the absolute section.  It could potentially
12517          be that someone has defined a non-global vtable though, which
12518          would be bad.  It isn't worth paging in the local symbols to be
12519          sure though; that case should simply be handled by the assembler.  */
12520
12521       child->vtable->parent = (struct elf_link_hash_entry *) -1;
12522     }
12523   else
12524     child->vtable->parent = h;
12525
12526   return TRUE;
12527 }
12528
12529 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
12530
12531 bfd_boolean
12532 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12533                            asection *sec ATTRIBUTE_UNUSED,
12534                            struct elf_link_hash_entry *h,
12535                            bfd_vma addend)
12536 {
12537   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12538   unsigned int log_file_align = bed->s->log_file_align;
12539
12540   if (!h->vtable)
12541     {
12542       h->vtable = ((struct elf_link_virtual_table_entry *)
12543                    bfd_zalloc (abfd, sizeof (*h->vtable)));
12544       if (!h->vtable)
12545         return FALSE;
12546     }
12547
12548   if (addend >= h->vtable->size)
12549     {
12550       size_t size, bytes, file_align;
12551       bfd_boolean *ptr = h->vtable->used;
12552
12553       /* While the symbol is undefined, we have to be prepared to handle
12554          a zero size.  */
12555       file_align = 1 << log_file_align;
12556       if (h->root.type == bfd_link_hash_undefined)
12557         size = addend + file_align;
12558       else
12559         {
12560           size = h->size;
12561           if (addend >= size)
12562             {
12563               /* Oops!  We've got a reference past the defined end of
12564                  the table.  This is probably a bug -- shall we warn?  */
12565               size = addend + file_align;
12566             }
12567         }
12568       size = (size + file_align - 1) & -file_align;
12569
12570       /* Allocate one extra entry for use as a "done" flag for the
12571          consolidation pass.  */
12572       bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12573
12574       if (ptr)
12575         {
12576           ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12577
12578           if (ptr != NULL)
12579             {
12580               size_t oldbytes;
12581
12582               oldbytes = (((h->vtable->size >> log_file_align) + 1)
12583                           * sizeof (bfd_boolean));
12584               memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12585             }
12586         }
12587       else
12588         ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12589
12590       if (ptr == NULL)
12591         return FALSE;
12592
12593       /* And arrange for that done flag to be at index -1.  */
12594       h->vtable->used = ptr + 1;
12595       h->vtable->size = size;
12596     }
12597
12598   h->vtable->used[addend >> log_file_align] = TRUE;
12599
12600   return TRUE;
12601 }
12602
12603 /* Map an ELF section header flag to its corresponding string.  */
12604 typedef struct
12605 {
12606   char *flag_name;
12607   flagword flag_value;
12608 } elf_flags_to_name_table;
12609
12610 static elf_flags_to_name_table elf_flags_to_names [] =
12611 {
12612   { "SHF_WRITE", SHF_WRITE },
12613   { "SHF_ALLOC", SHF_ALLOC },
12614   { "SHF_EXECINSTR", SHF_EXECINSTR },
12615   { "SHF_MERGE", SHF_MERGE },
12616   { "SHF_STRINGS", SHF_STRINGS },
12617   { "SHF_INFO_LINK", SHF_INFO_LINK},
12618   { "SHF_LINK_ORDER", SHF_LINK_ORDER},
12619   { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12620   { "SHF_GROUP", SHF_GROUP },
12621   { "SHF_TLS", SHF_TLS },
12622   { "SHF_MASKOS", SHF_MASKOS },
12623   { "SHF_EXCLUDE", SHF_EXCLUDE },
12624 };
12625
12626 /* Returns TRUE if the section is to be included, otherwise FALSE.  */
12627 bfd_boolean
12628 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12629                               struct flag_info *flaginfo,
12630                               asection *section)
12631 {
12632   const bfd_vma sh_flags = elf_section_flags (section);
12633
12634   if (!flaginfo->flags_initialized)
12635     {
12636       bfd *obfd = info->output_bfd;
12637       const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12638       struct flag_info_list *tf = flaginfo->flag_list;
12639       int with_hex = 0;
12640       int without_hex = 0;
12641
12642       for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
12643         {
12644           unsigned i;
12645           flagword (*lookup) (char *);
12646
12647           lookup = bed->elf_backend_lookup_section_flags_hook;
12648           if (lookup != NULL)
12649             {
12650               flagword hexval = (*lookup) ((char *) tf->name);
12651
12652               if (hexval != 0)
12653                 {
12654                   if (tf->with == with_flags)
12655                     with_hex |= hexval;
12656                   else if (tf->with == without_flags)
12657                     without_hex |= hexval;
12658                   tf->valid = TRUE;
12659                   continue;
12660                 }
12661             }
12662           for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
12663             {
12664               if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
12665                 {
12666                   if (tf->with == with_flags)
12667                     with_hex |= elf_flags_to_names[i].flag_value;
12668                   else if (tf->with == without_flags)
12669                     without_hex |= elf_flags_to_names[i].flag_value;
12670                   tf->valid = TRUE;
12671                   break;
12672                 }
12673             }
12674           if (!tf->valid)
12675             {
12676               info->callbacks->einfo
12677                 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12678               return FALSE;
12679             }
12680         }
12681       flaginfo->flags_initialized = TRUE;
12682       flaginfo->only_with_flags |= with_hex;
12683       flaginfo->not_with_flags |= without_hex;
12684     }
12685
12686   if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
12687     return FALSE;
12688
12689   if ((flaginfo->not_with_flags & sh_flags) != 0)
12690     return FALSE;
12691
12692   return TRUE;
12693 }
12694
12695 struct alloc_got_off_arg {
12696   bfd_vma gotoff;
12697   struct bfd_link_info *info;
12698 };
12699
12700 /* We need a special top-level link routine to convert got reference counts
12701    to real got offsets.  */
12702
12703 static bfd_boolean
12704 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12705 {
12706   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12707   bfd *obfd = gofarg->info->output_bfd;
12708   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12709
12710   if (h->got.refcount > 0)
12711     {
12712       h->got.offset = gofarg->gotoff;
12713       gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12714     }
12715   else
12716     h->got.offset = (bfd_vma) -1;
12717
12718   return TRUE;
12719 }
12720
12721 /* And an accompanying bit to work out final got entry offsets once
12722    we're done.  Should be called from final_link.  */
12723
12724 bfd_boolean
12725 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12726                                         struct bfd_link_info *info)
12727 {
12728   bfd *i;
12729   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12730   bfd_vma gotoff;
12731   struct alloc_got_off_arg gofarg;
12732
12733   BFD_ASSERT (abfd == info->output_bfd);
12734
12735   if (! is_elf_hash_table (info->hash))
12736     return FALSE;
12737
12738   /* The GOT offset is relative to the .got section, but the GOT header is
12739      put into the .got.plt section, if the backend uses it.  */
12740   if (bed->want_got_plt)
12741     gotoff = 0;
12742   else
12743     gotoff = bed->got_header_size;
12744
12745   /* Do the local .got entries first.  */
12746   for (i = info->input_bfds; i; i = i->link.next)
12747     {
12748       bfd_signed_vma *local_got;
12749       bfd_size_type j, locsymcount;
12750       Elf_Internal_Shdr *symtab_hdr;
12751
12752       if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12753         continue;
12754
12755       local_got = elf_local_got_refcounts (i);
12756       if (!local_got)
12757         continue;
12758
12759       symtab_hdr = &elf_tdata (i)->symtab_hdr;
12760       if (elf_bad_symtab (i))
12761         locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12762       else
12763         locsymcount = symtab_hdr->sh_info;
12764
12765       for (j = 0; j < locsymcount; ++j)
12766         {
12767           if (local_got[j] > 0)
12768             {
12769               local_got[j] = gotoff;
12770               gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12771             }
12772           else
12773             local_got[j] = (bfd_vma) -1;
12774         }
12775     }
12776
12777   /* Then the global .got entries.  .plt refcounts are handled by
12778      adjust_dynamic_symbol  */
12779   gofarg.gotoff = gotoff;
12780   gofarg.info = info;
12781   elf_link_hash_traverse (elf_hash_table (info),
12782                           elf_gc_allocate_got_offsets,
12783                           &gofarg);
12784   return TRUE;
12785 }
12786
12787 /* Many folk need no more in the way of final link than this, once
12788    got entry reference counting is enabled.  */
12789
12790 bfd_boolean
12791 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12792 {
12793   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12794     return FALSE;
12795
12796   /* Invoke the regular ELF backend linker to do all the work.  */
12797   return bfd_elf_final_link (abfd, info);
12798 }
12799
12800 bfd_boolean
12801 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12802 {
12803   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12804
12805   if (rcookie->bad_symtab)
12806     rcookie->rel = rcookie->rels;
12807
12808   for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12809     {
12810       unsigned long r_symndx;
12811
12812       if (! rcookie->bad_symtab)
12813         if (rcookie->rel->r_offset > offset)
12814           return FALSE;
12815       if (rcookie->rel->r_offset != offset)
12816         continue;
12817
12818       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12819       if (r_symndx == STN_UNDEF)
12820         return TRUE;
12821
12822       if (r_symndx >= rcookie->locsymcount
12823           || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12824         {
12825           struct elf_link_hash_entry *h;
12826
12827           h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12828
12829           while (h->root.type == bfd_link_hash_indirect
12830                  || h->root.type == bfd_link_hash_warning)
12831             h = (struct elf_link_hash_entry *) h->root.u.i.link;
12832
12833           if ((h->root.type == bfd_link_hash_defined
12834                || h->root.type == bfd_link_hash_defweak)
12835               && (h->root.u.def.section->owner != rcookie->abfd
12836                   || h->root.u.def.section->kept_section != NULL
12837                   || discarded_section (h->root.u.def.section)))
12838             return TRUE;
12839         }
12840       else
12841         {
12842           /* It's not a relocation against a global symbol,
12843              but it could be a relocation against a local
12844              symbol for a discarded section.  */
12845           asection *isec;
12846           Elf_Internal_Sym *isym;
12847
12848           /* Need to: get the symbol; get the section.  */
12849           isym = &rcookie->locsyms[r_symndx];
12850           isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12851           if (isec != NULL
12852               && (isec->kept_section != NULL
12853                   || discarded_section (isec)))
12854             return TRUE;
12855         }
12856       return FALSE;
12857     }
12858   return FALSE;
12859 }
12860
12861 /* Discard unneeded references to discarded sections.
12862    Returns -1 on error, 1 if any section's size was changed, 0 if
12863    nothing changed.  This function assumes that the relocations are in
12864    sorted order, which is true for all known assemblers.  */
12865
12866 int
12867 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12868 {
12869   struct elf_reloc_cookie cookie;
12870   asection *o;
12871   bfd *abfd;
12872   int changed = 0;
12873
12874   if (info->traditional_format
12875       || !is_elf_hash_table (info->hash))
12876     return 0;
12877
12878   o = bfd_get_section_by_name (output_bfd, ".stab");
12879   if (o != NULL)
12880     {
12881       asection *i;
12882
12883       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12884         {
12885           if (i->size == 0
12886               || i->reloc_count == 0
12887               || i->sec_info_type != SEC_INFO_TYPE_STABS)
12888             continue;
12889
12890           abfd = i->owner;
12891           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12892             continue;
12893
12894           if (!init_reloc_cookie_for_section (&cookie, info, i))
12895             return -1;
12896
12897           if (_bfd_discard_section_stabs (abfd, i,
12898                                           elf_section_data (i)->sec_info,
12899                                           bfd_elf_reloc_symbol_deleted_p,
12900                                           &cookie))
12901             changed = 1;
12902
12903           fini_reloc_cookie_for_section (&cookie, i);
12904         }
12905     }
12906
12907   o = bfd_get_section_by_name (output_bfd, ".eh_frame");
12908   if (o != NULL)
12909     {
12910       asection *i;
12911
12912       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12913         {
12914           if (i->size == 0)
12915             continue;
12916
12917           abfd = i->owner;
12918           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12919             continue;
12920
12921           if (!init_reloc_cookie_for_section (&cookie, info, i))
12922             return -1;
12923
12924           _bfd_elf_parse_eh_frame (abfd, info, i, &cookie);
12925           if (_bfd_elf_discard_section_eh_frame (abfd, info, i,
12926                                                  bfd_elf_reloc_symbol_deleted_p,
12927                                                  &cookie))
12928             changed = 1;
12929
12930           fini_reloc_cookie_for_section (&cookie, i);
12931         }
12932     }
12933
12934   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
12935     {
12936       const struct elf_backend_data *bed;
12937
12938       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12939         continue;
12940
12941       bed = get_elf_backend_data (abfd);
12942
12943       if (bed->elf_backend_discard_info != NULL)
12944         {
12945           if (!init_reloc_cookie (&cookie, info, abfd))
12946             return -1;
12947
12948           if ((*bed->elf_backend_discard_info) (abfd, &cookie, info))
12949             changed = 1;
12950
12951           fini_reloc_cookie (&cookie, abfd);
12952         }
12953     }
12954
12955   if (info->eh_frame_hdr
12956       && !info->relocatable
12957       && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12958     changed = 1;
12959
12960   return changed;
12961 }
12962
12963 bfd_boolean
12964 _bfd_elf_section_already_linked (bfd *abfd,
12965                                  asection *sec,
12966                                  struct bfd_link_info *info)
12967 {
12968   flagword flags;
12969   const char *name, *key;
12970   struct bfd_section_already_linked *l;
12971   struct bfd_section_already_linked_hash_entry *already_linked_list;
12972
12973   if (sec->output_section == bfd_abs_section_ptr)
12974     return FALSE;
12975
12976   flags = sec->flags;
12977
12978   /* Return if it isn't a linkonce section.  A comdat group section
12979      also has SEC_LINK_ONCE set.  */
12980   if ((flags & SEC_LINK_ONCE) == 0)
12981     return FALSE;
12982
12983   /* Don't put group member sections on our list of already linked
12984      sections.  They are handled as a group via their group section.  */
12985   if (elf_sec_group (sec) != NULL)
12986     return FALSE;
12987
12988   /* For a SHT_GROUP section, use the group signature as the key.  */
12989   name = sec->name;
12990   if ((flags & SEC_GROUP) != 0
12991       && elf_next_in_group (sec) != NULL
12992       && elf_group_name (elf_next_in_group (sec)) != NULL)
12993     key = elf_group_name (elf_next_in_group (sec));
12994   else
12995     {
12996       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
12997       if (CONST_STRNEQ (name, ".gnu.linkonce.")
12998           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12999         key++;
13000       else
13001         /* Must be a user linkonce section that doesn't follow gcc's
13002            naming convention.  In this case we won't be matching
13003            single member groups.  */
13004         key = name;
13005     }
13006
13007   already_linked_list = bfd_section_already_linked_table_lookup (key);
13008
13009   for (l = already_linked_list->entry; l != NULL; l = l->next)
13010     {
13011       /* We may have 2 different types of sections on the list: group
13012          sections with a signature of <key> (<key> is some string),
13013          and linkonce sections named .gnu.linkonce.<type>.<key>.
13014          Match like sections.  LTO plugin sections are an exception.
13015          They are always named .gnu.linkonce.t.<key> and match either
13016          type of section.  */
13017       if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
13018            && ((flags & SEC_GROUP) != 0
13019                || strcmp (name, l->sec->name) == 0))
13020           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
13021         {
13022           /* The section has already been linked.  See if we should
13023              issue a warning.  */
13024           if (!_bfd_handle_already_linked (sec, l, info))
13025             return FALSE;
13026
13027           if (flags & SEC_GROUP)
13028             {
13029               asection *first = elf_next_in_group (sec);
13030               asection *s = first;
13031
13032               while (s != NULL)
13033                 {
13034                   s->output_section = bfd_abs_section_ptr;
13035                   /* Record which group discards it.  */
13036                   s->kept_section = l->sec;
13037                   s = elf_next_in_group (s);
13038                   /* These lists are circular.  */
13039                   if (s == first)
13040                     break;
13041                 }
13042             }
13043
13044           return TRUE;
13045         }
13046     }
13047
13048   /* A single member comdat group section may be discarded by a
13049      linkonce section and vice versa.  */
13050   if ((flags & SEC_GROUP) != 0)
13051     {
13052       asection *first = elf_next_in_group (sec);
13053
13054       if (first != NULL && elf_next_in_group (first) == first)
13055         /* Check this single member group against linkonce sections.  */
13056         for (l = already_linked_list->entry; l != NULL; l = l->next)
13057           if ((l->sec->flags & SEC_GROUP) == 0
13058               && bfd_elf_match_symbols_in_sections (l->sec, first, info))
13059             {
13060               first->output_section = bfd_abs_section_ptr;
13061               first->kept_section = l->sec;
13062               sec->output_section = bfd_abs_section_ptr;
13063               break;
13064             }
13065     }
13066   else
13067     /* Check this linkonce section against single member groups.  */
13068     for (l = already_linked_list->entry; l != NULL; l = l->next)
13069       if (l->sec->flags & SEC_GROUP)
13070         {
13071           asection *first = elf_next_in_group (l->sec);
13072
13073           if (first != NULL
13074               && elf_next_in_group (first) == first
13075               && bfd_elf_match_symbols_in_sections (first, sec, info))
13076             {
13077               sec->output_section = bfd_abs_section_ptr;
13078               sec->kept_section = first;
13079               break;
13080             }
13081         }
13082
13083   /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
13084      referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
13085      specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
13086      prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
13087      matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
13088      but its `.gnu.linkonce.t.F' is discarded means we chose one-only
13089      `.gnu.linkonce.t.F' section from a different bfd not requiring any
13090      `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
13091      The reverse order cannot happen as there is never a bfd with only the
13092      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
13093      matter as here were are looking only for cross-bfd sections.  */
13094
13095   if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
13096     for (l = already_linked_list->entry; l != NULL; l = l->next)
13097       if ((l->sec->flags & SEC_GROUP) == 0
13098           && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
13099         {
13100           if (abfd != l->sec->owner)
13101             sec->output_section = bfd_abs_section_ptr;
13102           break;
13103         }
13104
13105   /* This is the first section with this name.  Record it.  */
13106   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
13107     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
13108   return sec->output_section == bfd_abs_section_ptr;
13109 }
13110
13111 bfd_boolean
13112 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
13113 {
13114   return sym->st_shndx == SHN_COMMON;
13115 }
13116
13117 unsigned int
13118 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
13119 {
13120   return SHN_COMMON;
13121 }
13122
13123 asection *
13124 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
13125 {
13126   return bfd_com_section_ptr;
13127 }
13128
13129 bfd_vma
13130 _bfd_elf_default_got_elt_size (bfd *abfd,
13131                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
13132                                struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
13133                                bfd *ibfd ATTRIBUTE_UNUSED,
13134                                unsigned long symndx ATTRIBUTE_UNUSED)
13135 {
13136   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13137   return bed->s->arch_size / 8;
13138 }
13139
13140 /* Routines to support the creation of dynamic relocs.  */
13141
13142 /* Returns the name of the dynamic reloc section associated with SEC.  */
13143
13144 static const char *
13145 get_dynamic_reloc_section_name (bfd *       abfd,
13146                                 asection *  sec,
13147                                 bfd_boolean is_rela)
13148 {
13149   char *name;
13150   const char *old_name = bfd_get_section_name (NULL, sec);
13151   const char *prefix = is_rela ? ".rela" : ".rel";
13152
13153   if (old_name == NULL)
13154     return NULL;
13155
13156   name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
13157   sprintf (name, "%s%s", prefix, old_name);
13158
13159   return name;
13160 }
13161
13162 /* Returns the dynamic reloc section associated with SEC.
13163    If necessary compute the name of the dynamic reloc section based
13164    on SEC's name (looked up in ABFD's string table) and the setting
13165    of IS_RELA.  */
13166
13167 asection *
13168 _bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
13169                                     asection *  sec,
13170                                     bfd_boolean is_rela)
13171 {
13172   asection * reloc_sec = elf_section_data (sec)->sreloc;
13173
13174   if (reloc_sec == NULL)
13175     {
13176       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13177
13178       if (name != NULL)
13179         {
13180           reloc_sec = bfd_get_linker_section (abfd, name);
13181
13182           if (reloc_sec != NULL)
13183             elf_section_data (sec)->sreloc = reloc_sec;
13184         }
13185     }
13186
13187   return reloc_sec;
13188 }
13189
13190 /* Returns the dynamic reloc section associated with SEC.  If the
13191    section does not exist it is created and attached to the DYNOBJ
13192    bfd and stored in the SRELOC field of SEC's elf_section_data
13193    structure.
13194
13195    ALIGNMENT is the alignment for the newly created section and
13196    IS_RELA defines whether the name should be .rela.<SEC's name>
13197    or .rel.<SEC's name>.  The section name is looked up in the
13198    string table associated with ABFD.  */
13199
13200 asection *
13201 _bfd_elf_make_dynamic_reloc_section (asection *sec,
13202                                      bfd *dynobj,
13203                                      unsigned int alignment,
13204                                      bfd *abfd,
13205                                      bfd_boolean is_rela)
13206 {
13207   asection * reloc_sec = elf_section_data (sec)->sreloc;
13208
13209   if (reloc_sec == NULL)
13210     {
13211       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13212
13213       if (name == NULL)
13214         return NULL;
13215
13216       reloc_sec = bfd_get_linker_section (dynobj, name);
13217
13218       if (reloc_sec == NULL)
13219         {
13220           flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
13221                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
13222           if ((sec->flags & SEC_ALLOC) != 0)
13223             flags |= SEC_ALLOC | SEC_LOAD;
13224
13225           reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
13226           if (reloc_sec != NULL)
13227             {
13228               /* _bfd_elf_get_sec_type_attr chooses a section type by
13229                  name.  Override as it may be wrong, eg. for a user
13230                  section named "auto" we'll get ".relauto" which is
13231                  seen to be a .rela section.  */
13232               elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
13233               if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
13234                 reloc_sec = NULL;
13235             }
13236         }
13237
13238       elf_section_data (sec)->sreloc = reloc_sec;
13239     }
13240
13241   return reloc_sec;
13242 }
13243
13244 /* Copy the ELF symbol type and other attributes for a linker script
13245    assignment from HSRC to HDEST.  Generally this should be treated as
13246    if we found a strong non-dynamic definition for HDEST (except that
13247    ld ignores multiple definition errors).  */
13248 void
13249 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
13250                                      struct bfd_link_hash_entry *hdest,
13251                                      struct bfd_link_hash_entry *hsrc)
13252 {
13253   struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest;
13254   struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc;
13255   Elf_Internal_Sym isym;
13256
13257   ehdest->type = ehsrc->type;
13258   ehdest->target_internal = ehsrc->target_internal;
13259
13260   isym.st_other = ehsrc->other;
13261   elf_merge_st_other (abfd, ehdest, &isym, TRUE, FALSE);
13262 }
13263
13264 /* Append a RELA relocation REL to section S in BFD.  */
13265
13266 void
13267 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13268 {
13269   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13270   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
13271   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
13272   bed->s->swap_reloca_out (abfd, rel, loc);
13273 }
13274
13275 /* Append a REL relocation REL to section S in BFD.  */
13276
13277 void
13278 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13279 {
13280   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13281   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
13282   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
13283   bed->s->swap_reloc_out (abfd, rel, loc);
13284 }