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