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