PR21910, segfault in common symbol override test when hash-style=gnu
[external/binutils.git] / bfd / elflink.c
1 /* ELF linking support for BFD.
2    Copyright (C) 1995-2017 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfd_stdint.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #define ARCH_SIZE 0
27 #include "elf-bfd.h"
28 #include "safe-ctype.h"
29 #include "libiberty.h"
30 #include "objalloc.h"
31 #if BFD_SUPPORTS_PLUGINS
32 #include "plugin-api.h"
33 #include "plugin.h"
34 #endif
35
36 /* This struct is used to pass information to routines called via
37    elf_link_hash_traverse which must return failure.  */
38
39 struct elf_info_failed
40 {
41   struct bfd_link_info *info;
42   bfd_boolean failed;
43 };
44
45 /* This structure is used to pass information to
46    _bfd_elf_link_find_version_dependencies.  */
47
48 struct elf_find_verdep_info
49 {
50   /* General link information.  */
51   struct bfd_link_info *info;
52   /* The number of dependencies.  */
53   unsigned int vers;
54   /* Whether we had a failure.  */
55   bfd_boolean failed;
56 };
57
58 static bfd_boolean _bfd_elf_fix_symbol_flags
59   (struct elf_link_hash_entry *, struct elf_info_failed *);
60
61 asection *
62 _bfd_elf_section_for_symbol (struct elf_reloc_cookie *cookie,
63                              unsigned long r_symndx,
64                              bfd_boolean discard)
65 {
66   if (r_symndx >= cookie->locsymcount
67       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
68     {
69       struct elf_link_hash_entry *h;
70
71       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
72
73       while (h->root.type == bfd_link_hash_indirect
74              || h->root.type == bfd_link_hash_warning)
75         h = (struct elf_link_hash_entry *) h->root.u.i.link;
76
77       if ((h->root.type == bfd_link_hash_defined
78            || h->root.type == bfd_link_hash_defweak)
79            && discarded_section (h->root.u.def.section))
80         return h->root.u.def.section;
81       else
82         return NULL;
83     }
84   else
85     {
86       /* It's not a relocation against a global symbol,
87          but it could be a relocation against a local
88          symbol for a discarded section.  */
89       asection *isec;
90       Elf_Internal_Sym *isym;
91
92       /* Need to: get the symbol; get the section.  */
93       isym = &cookie->locsyms[r_symndx];
94       isec = bfd_section_from_elf_index (cookie->abfd, isym->st_shndx);
95       if (isec != NULL
96           && discard ? discarded_section (isec) : 1)
97         return isec;
98      }
99   return NULL;
100 }
101
102 /* Define a symbol in a dynamic linkage section.  */
103
104 struct elf_link_hash_entry *
105 _bfd_elf_define_linkage_sym (bfd *abfd,
106                              struct bfd_link_info *info,
107                              asection *sec,
108                              const char *name)
109 {
110   struct elf_link_hash_entry *h;
111   struct bfd_link_hash_entry *bh;
112   const struct elf_backend_data *bed;
113
114   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
115   if (h != NULL)
116     {
117       /* Zap symbol defined in an as-needed lib that wasn't linked.
118          This is a symptom of a larger problem:  Absolute symbols
119          defined in shared libraries can't be overridden, because we
120          lose the link to the bfd which is via the symbol section.  */
121       h->root.type = bfd_link_hash_new;
122       bh = &h->root;
123     }
124   else
125     bh = NULL;
126
127   bed = get_elf_backend_data (abfd);
128   if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
129                                          sec, 0, NULL, FALSE, bed->collect,
130                                          &bh))
131     return NULL;
132   h = (struct elf_link_hash_entry *) bh;
133   BFD_ASSERT (h != NULL);
134   h->def_regular = 1;
135   h->non_elf = 0;
136   h->root.linker_def = 1;
137   h->type = STT_OBJECT;
138   if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
139     h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
140
141   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
142   return h;
143 }
144
145 bfd_boolean
146 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
147 {
148   flagword flags;
149   asection *s;
150   struct elf_link_hash_entry *h;
151   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
152   struct elf_link_hash_table *htab = elf_hash_table (info);
153
154   /* This function may be called more than once.  */
155   if (htab->sgot != NULL)
156     return TRUE;
157
158   flags = bed->dynamic_sec_flags;
159
160   s = bfd_make_section_anyway_with_flags (abfd,
161                                           (bed->rela_plts_and_copies_p
162                                            ? ".rela.got" : ".rel.got"),
163                                           (bed->dynamic_sec_flags
164                                            | SEC_READONLY));
165   if (s == NULL
166       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
167     return FALSE;
168   htab->srelgot = s;
169
170   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
171   if (s == NULL
172       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
173     return FALSE;
174   htab->sgot = s;
175
176   if (bed->want_got_plt)
177     {
178       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
179       if (s == NULL
180           || !bfd_set_section_alignment (abfd, s,
181                                          bed->s->log_file_align))
182         return FALSE;
183       htab->sgotplt = s;
184     }
185
186   /* The first bit of the global offset table is the header.  */
187   s->size += bed->got_header_size;
188
189   if (bed->want_got_sym)
190     {
191       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
192          (or .got.plt) section.  We don't do this in the linker script
193          because we don't want to define the symbol if we are not creating
194          a global offset table.  */
195       h = _bfd_elf_define_linkage_sym (abfd, info, s,
196                                        "_GLOBAL_OFFSET_TABLE_");
197       elf_hash_table (info)->hgot = h;
198       if (h == NULL)
199         return FALSE;
200     }
201
202   return TRUE;
203 }
204 \f
205 /* Create a strtab to hold the dynamic symbol names.  */
206 static bfd_boolean
207 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
208 {
209   struct elf_link_hash_table *hash_table;
210
211   hash_table = elf_hash_table (info);
212   if (hash_table->dynobj == NULL)
213     {
214       /* We may not set dynobj, an input file holding linker created
215          dynamic sections to abfd, which may be a dynamic object with
216          its own dynamic sections.  We need to find a normal input file
217          to hold linker created sections if possible.  */
218       if ((abfd->flags & (DYNAMIC | BFD_PLUGIN)) != 0)
219         {
220           bfd *ibfd;
221           asection *s;
222           for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
223             if ((ibfd->flags
224                  & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
225                 && bfd_get_flavour (ibfd) == bfd_target_elf_flavour
226                 && !((s = ibfd->sections) != NULL
227                      && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS))
228               {
229                 abfd = ibfd;
230                 break;
231               }
232         }
233       hash_table->dynobj = abfd;
234     }
235
236   if (hash_table->dynstr == NULL)
237     {
238       hash_table->dynstr = _bfd_elf_strtab_init ();
239       if (hash_table->dynstr == NULL)
240         return FALSE;
241     }
242   return TRUE;
243 }
244
245 /* Create some sections which will be filled in with dynamic linking
246    information.  ABFD is an input file which requires dynamic sections
247    to be created.  The dynamic sections take up virtual memory space
248    when the final executable is run, so we need to create them before
249    addresses are assigned to the output sections.  We work out the
250    actual contents and size of these sections later.  */
251
252 bfd_boolean
253 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
254 {
255   flagword flags;
256   asection *s;
257   const struct elf_backend_data *bed;
258   struct elf_link_hash_entry *h;
259
260   if (! is_elf_hash_table (info->hash))
261     return FALSE;
262
263   if (elf_hash_table (info)->dynamic_sections_created)
264     return TRUE;
265
266   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
267     return FALSE;
268
269   abfd = elf_hash_table (info)->dynobj;
270   bed = get_elf_backend_data (abfd);
271
272   flags = bed->dynamic_sec_flags;
273
274   /* A dynamically linked executable has a .interp section, but a
275      shared library does not.  */
276   if (bfd_link_executable (info) && !info->nointerp)
277     {
278       s = bfd_make_section_anyway_with_flags (abfd, ".interp",
279                                               flags | SEC_READONLY);
280       if (s == NULL)
281         return FALSE;
282     }
283
284   /* Create sections to hold version informations.  These are removed
285      if they are not needed.  */
286   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
287                                           flags | SEC_READONLY);
288   if (s == NULL
289       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
290     return FALSE;
291
292   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
293                                           flags | SEC_READONLY);
294   if (s == NULL
295       || ! bfd_set_section_alignment (abfd, s, 1))
296     return FALSE;
297
298   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
299                                           flags | SEC_READONLY);
300   if (s == NULL
301       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
302     return FALSE;
303
304   s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
305                                           flags | SEC_READONLY);
306   if (s == NULL
307       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
308     return FALSE;
309   elf_hash_table (info)->dynsym = s;
310
311   s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
312                                           flags | SEC_READONLY);
313   if (s == NULL)
314     return FALSE;
315
316   s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
317   if (s == NULL
318       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
319     return FALSE;
320
321   /* The special symbol _DYNAMIC is always set to the start of the
322      .dynamic section.  We could set _DYNAMIC in a linker script, but we
323      only want to define it if we are, in fact, creating a .dynamic
324      section.  We don't want to define it if there is no .dynamic
325      section, since on some ELF platforms the start up code examines it
326      to decide how to initialize the process.  */
327   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
328   elf_hash_table (info)->hdynamic = h;
329   if (h == NULL)
330     return FALSE;
331
332   if (info->emit_hash)
333     {
334       s = bfd_make_section_anyway_with_flags (abfd, ".hash",
335                                               flags | SEC_READONLY);
336       if (s == NULL
337           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
338         return FALSE;
339       elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
340     }
341
342   if (info->emit_gnu_hash)
343     {
344       s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
345                                               flags | SEC_READONLY);
346       if (s == NULL
347           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
348         return FALSE;
349       /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
350          4 32-bit words followed by variable count of 64-bit words, then
351          variable count of 32-bit words.  */
352       if (bed->s->arch_size == 64)
353         elf_section_data (s)->this_hdr.sh_entsize = 0;
354       else
355         elf_section_data (s)->this_hdr.sh_entsize = 4;
356     }
357
358   /* Let the backend create the rest of the sections.  This lets the
359      backend set the right flags.  The backend will normally create
360      the .got and .plt sections.  */
361   if (bed->elf_backend_create_dynamic_sections == NULL
362       || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
363     return FALSE;
364
365   elf_hash_table (info)->dynamic_sections_created = TRUE;
366
367   return TRUE;
368 }
369
370 /* Create dynamic sections when linking against a dynamic object.  */
371
372 bfd_boolean
373 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
374 {
375   flagword flags, pltflags;
376   struct elf_link_hash_entry *h;
377   asection *s;
378   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
379   struct elf_link_hash_table *htab = elf_hash_table (info);
380
381   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
382      .rel[a].bss sections.  */
383   flags = bed->dynamic_sec_flags;
384
385   pltflags = flags;
386   if (bed->plt_not_loaded)
387     /* We do not clear SEC_ALLOC here because we still want the OS to
388        allocate space for the section; it's just that there's nothing
389        to read in from the object file.  */
390     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
391   else
392     pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
393   if (bed->plt_readonly)
394     pltflags |= SEC_READONLY;
395
396   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
397   if (s == NULL
398       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
399     return FALSE;
400   htab->splt = s;
401
402   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
403      .plt section.  */
404   if (bed->want_plt_sym)
405     {
406       h = _bfd_elf_define_linkage_sym (abfd, info, s,
407                                        "_PROCEDURE_LINKAGE_TABLE_");
408       elf_hash_table (info)->hplt = h;
409       if (h == NULL)
410         return FALSE;
411     }
412
413   s = bfd_make_section_anyway_with_flags (abfd,
414                                           (bed->rela_plts_and_copies_p
415                                            ? ".rela.plt" : ".rel.plt"),
416                                           flags | SEC_READONLY);
417   if (s == NULL
418       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
419     return FALSE;
420   htab->srelplt = s;
421
422   if (! _bfd_elf_create_got_section (abfd, info))
423     return FALSE;
424
425   if (bed->want_dynbss)
426     {
427       /* The .dynbss section is a place to put symbols which are defined
428          by dynamic objects, are referenced by regular objects, and are
429          not functions.  We must allocate space for them in the process
430          image and use a R_*_COPY reloc to tell the dynamic linker to
431          initialize them at run time.  The linker script puts the .dynbss
432          section into the .bss section of the final image.  */
433       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
434                                               SEC_ALLOC | SEC_LINKER_CREATED);
435       if (s == NULL)
436         return FALSE;
437       htab->sdynbss = s;
438
439       if (bed->want_dynrelro)
440         {
441           /* Similarly, but for symbols that were originally in read-only
442              sections.  This section doesn't really need to have contents,
443              but make it like other .data.rel.ro sections.  */
444           s = bfd_make_section_anyway_with_flags (abfd, ".data.rel.ro",
445                                                   flags);
446           if (s == NULL)
447             return FALSE;
448           htab->sdynrelro = s;
449         }
450
451       /* The .rel[a].bss section holds copy relocs.  This section is not
452          normally needed.  We need to create it here, though, so that the
453          linker will map it to an output section.  We can't just create it
454          only if we need it, because we will not know whether we need it
455          until we have seen all the input files, and the first time the
456          main linker code calls BFD after examining all the input files
457          (size_dynamic_sections) the input sections have already been
458          mapped to the output sections.  If the section turns out not to
459          be needed, we can discard it later.  We will never need this
460          section when generating a shared object, since they do not use
461          copy relocs.  */
462       if (bfd_link_executable (info))
463         {
464           s = bfd_make_section_anyway_with_flags (abfd,
465                                                   (bed->rela_plts_and_copies_p
466                                                    ? ".rela.bss" : ".rel.bss"),
467                                                   flags | SEC_READONLY);
468           if (s == NULL
469               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
470             return FALSE;
471           htab->srelbss = s;
472
473           if (bed->want_dynrelro)
474             {
475               s = (bfd_make_section_anyway_with_flags
476                    (abfd, (bed->rela_plts_and_copies_p
477                            ? ".rela.data.rel.ro" : ".rel.data.rel.ro"),
478                     flags | SEC_READONLY));
479               if (s == NULL
480                   || ! bfd_set_section_alignment (abfd, s,
481                                                   bed->s->log_file_align))
482                 return FALSE;
483               htab->sreldynrelro = s;
484             }
485         }
486     }
487
488   return TRUE;
489 }
490 \f
491 /* Record a new dynamic symbol.  We record the dynamic symbols as we
492    read the input files, since we need to have a list of all of them
493    before we can determine the final sizes of the output sections.
494    Note that we may actually call this function even though we are not
495    going to output any dynamic symbols; in some cases we know that a
496    symbol should be in the dynamic symbol table, but only if there is
497    one.  */
498
499 bfd_boolean
500 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
501                                     struct elf_link_hash_entry *h)
502 {
503   if (h->dynindx == -1)
504     {
505       struct elf_strtab_hash *dynstr;
506       char *p;
507       const char *name;
508       size_t indx;
509
510       /* XXX: The ABI draft says the linker must turn hidden and
511          internal symbols into STB_LOCAL symbols when producing the
512          DSO. However, if ld.so honors st_other in the dynamic table,
513          this would not be necessary.  */
514       switch (ELF_ST_VISIBILITY (h->other))
515         {
516         case STV_INTERNAL:
517         case STV_HIDDEN:
518           if (h->root.type != bfd_link_hash_undefined
519               && h->root.type != bfd_link_hash_undefweak)
520             {
521               h->forced_local = 1;
522               if (!elf_hash_table (info)->is_relocatable_executable)
523                 return TRUE;
524             }
525
526         default:
527           break;
528         }
529
530       h->dynindx = elf_hash_table (info)->dynsymcount;
531       ++elf_hash_table (info)->dynsymcount;
532
533       dynstr = elf_hash_table (info)->dynstr;
534       if (dynstr == NULL)
535         {
536           /* Create a strtab to hold the dynamic symbol names.  */
537           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
538           if (dynstr == NULL)
539             return FALSE;
540         }
541
542       /* We don't put any version information in the dynamic string
543          table.  */
544       name = h->root.root.string;
545       p = strchr (name, ELF_VER_CHR);
546       if (p != NULL)
547         /* We know that the p points into writable memory.  In fact,
548            there are only a few symbols that have read-only names, being
549            those like _GLOBAL_OFFSET_TABLE_ that are created specially
550            by the backends.  Most symbols will have names pointing into
551            an ELF string table read from a file, or to objalloc memory.  */
552         *p = 0;
553
554       indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
555
556       if (p != NULL)
557         *p = ELF_VER_CHR;
558
559       if (indx == (size_t) -1)
560         return FALSE;
561       h->dynstr_index = indx;
562     }
563
564   return TRUE;
565 }
566 \f
567 /* Mark a symbol dynamic.  */
568
569 static void
570 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
571                                   struct elf_link_hash_entry *h,
572                                   Elf_Internal_Sym *sym)
573 {
574   struct bfd_elf_dynamic_list *d = info->dynamic_list;
575
576   /* It may be called more than once on the same H.  */
577   if(h->dynamic || bfd_link_relocatable (info))
578     return;
579
580   if ((info->dynamic_data
581        && (h->type == STT_OBJECT
582            || h->type == STT_COMMON
583            || (sym != NULL
584                && (ELF_ST_TYPE (sym->st_info) == STT_OBJECT
585                    || ELF_ST_TYPE (sym->st_info) == STT_COMMON))))
586       || (d != NULL
587           && h->non_elf
588           && (*d->match) (&d->head, NULL, h->root.root.string)))
589     h->dynamic = 1;
590 }
591
592 /* Record an assignment to a symbol made by a linker script.  We need
593    this in case some dynamic object refers to this symbol.  */
594
595 bfd_boolean
596 bfd_elf_record_link_assignment (bfd *output_bfd,
597                                 struct bfd_link_info *info,
598                                 const char *name,
599                                 bfd_boolean provide,
600                                 bfd_boolean hidden)
601 {
602   struct elf_link_hash_entry *h, *hv;
603   struct elf_link_hash_table *htab;
604   const struct elf_backend_data *bed;
605
606   if (!is_elf_hash_table (info->hash))
607     return TRUE;
608
609   htab = elf_hash_table (info);
610   h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
611   if (h == NULL)
612     return provide;
613
614   if (h->root.type == bfd_link_hash_warning)
615     h = (struct elf_link_hash_entry *) h->root.u.i.link;
616
617   if (h->versioned == unknown)
618     {
619       /* Set versioned if symbol version is unknown.  */
620       char *version = strrchr (name, ELF_VER_CHR);
621       if (version)
622         {
623           if (version > name && version[-1] != ELF_VER_CHR)
624             h->versioned = versioned_hidden;
625           else
626             h->versioned = versioned;
627         }
628     }
629
630   /* Symbols defined in a linker script but not referenced anywhere
631      else will have non_elf set.  */
632   if (h->non_elf)
633     {
634       bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
635       h->non_elf = 0;
636     }
637
638   switch (h->root.type)
639     {
640     case bfd_link_hash_defined:
641     case bfd_link_hash_defweak:
642     case bfd_link_hash_common:
643       break;
644     case bfd_link_hash_undefweak:
645     case bfd_link_hash_undefined:
646       /* Since we're defining the symbol, don't let it seem to have not
647          been defined.  record_dynamic_symbol and size_dynamic_sections
648          may depend on this.  */
649       h->root.type = bfd_link_hash_new;
650       if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
651         bfd_link_repair_undef_list (&htab->root);
652       break;
653     case bfd_link_hash_new:
654       break;
655     case bfd_link_hash_indirect:
656       /* We had a versioned symbol in a dynamic library.  We make the
657          the versioned symbol point to this one.  */
658       bed = get_elf_backend_data (output_bfd);
659       hv = h;
660       while (hv->root.type == bfd_link_hash_indirect
661              || hv->root.type == bfd_link_hash_warning)
662         hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
663       /* We don't need to update h->root.u since linker will set them
664          later.  */
665       h->root.type = bfd_link_hash_undefined;
666       hv->root.type = bfd_link_hash_indirect;
667       hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
668       (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
669       break;
670     default:
671       BFD_FAIL ();
672       return FALSE;
673     }
674
675   /* If this symbol is being provided by the linker script, and it is
676      currently defined by a dynamic object, but not by a regular
677      object, then mark it as undefined so that the generic linker will
678      force the correct value.  */
679   if (provide
680       && h->def_dynamic
681       && !h->def_regular)
682     h->root.type = bfd_link_hash_undefined;
683
684   /* If this symbol is not being provided by the linker script, and it is
685      currently defined by a dynamic object, but not by a regular object,
686      then clear out any version information because the symbol will not be
687      associated with the dynamic object any more.  */
688   if (!provide
689       && h->def_dynamic
690       && !h->def_regular)
691     h->verinfo.verdef = NULL;
692
693   /* Make sure this symbol is not garbage collected.  */
694   h->mark = 1;
695
696   h->def_regular = 1;
697
698   if (hidden)
699     {
700       bed = get_elf_backend_data (output_bfd);
701       if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
702         h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
703       (*bed->elf_backend_hide_symbol) (info, h, TRUE);
704     }
705
706   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
707      and executables.  */
708   if (!bfd_link_relocatable (info)
709       && h->dynindx != -1
710       && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
711           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
712     h->forced_local = 1;
713
714   if ((h->def_dynamic
715        || h->ref_dynamic
716        || bfd_link_dll (info)
717        || elf_hash_table (info)->is_relocatable_executable)
718       && h->dynindx == -1)
719     {
720       if (! bfd_elf_link_record_dynamic_symbol (info, h))
721         return FALSE;
722
723       /* If this is a weak defined symbol, and we know a corresponding
724          real symbol from the same dynamic object, make sure the real
725          symbol is also made into a dynamic symbol.  */
726       if (h->u.weakdef != NULL
727           && h->u.weakdef->dynindx == -1)
728         {
729           if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
730             return FALSE;
731         }
732     }
733
734   return TRUE;
735 }
736
737 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
738    success, and 2 on a failure caused by attempting to record a symbol
739    in a discarded section, eg. a discarded link-once section symbol.  */
740
741 int
742 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
743                                           bfd *input_bfd,
744                                           long input_indx)
745 {
746   bfd_size_type amt;
747   struct elf_link_local_dynamic_entry *entry;
748   struct elf_link_hash_table *eht;
749   struct elf_strtab_hash *dynstr;
750   size_t dynstr_index;
751   char *name;
752   Elf_External_Sym_Shndx eshndx;
753   char esym[sizeof (Elf64_External_Sym)];
754
755   if (! is_elf_hash_table (info->hash))
756     return 0;
757
758   /* See if the entry exists already.  */
759   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
760     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
761       return 1;
762
763   amt = sizeof (*entry);
764   entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
765   if (entry == NULL)
766     return 0;
767
768   /* Go find the symbol, so that we can find it's name.  */
769   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
770                              1, input_indx, &entry->isym, esym, &eshndx))
771     {
772       bfd_release (input_bfd, entry);
773       return 0;
774     }
775
776   if (entry->isym.st_shndx != SHN_UNDEF
777       && entry->isym.st_shndx < SHN_LORESERVE)
778     {
779       asection *s;
780
781       s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
782       if (s == NULL || bfd_is_abs_section (s->output_section))
783         {
784           /* We can still bfd_release here as nothing has done another
785              bfd_alloc.  We can't do this later in this function.  */
786           bfd_release (input_bfd, entry);
787           return 2;
788         }
789     }
790
791   name = (bfd_elf_string_from_elf_section
792           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
793            entry->isym.st_name));
794
795   dynstr = elf_hash_table (info)->dynstr;
796   if (dynstr == NULL)
797     {
798       /* Create a strtab to hold the dynamic symbol names.  */
799       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
800       if (dynstr == NULL)
801         return 0;
802     }
803
804   dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
805   if (dynstr_index == (size_t) -1)
806     return 0;
807   entry->isym.st_name = dynstr_index;
808
809   eht = elf_hash_table (info);
810
811   entry->next = eht->dynlocal;
812   eht->dynlocal = entry;
813   entry->input_bfd = input_bfd;
814   entry->input_indx = input_indx;
815   eht->dynsymcount++;
816
817   /* Whatever binding the symbol had before, it's now local.  */
818   entry->isym.st_info
819     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
820
821   /* The dynindx will be set at the end of size_dynamic_sections.  */
822
823   return 1;
824 }
825
826 /* Return the dynindex of a local dynamic symbol.  */
827
828 long
829 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
830                                     bfd *input_bfd,
831                                     long input_indx)
832 {
833   struct elf_link_local_dynamic_entry *e;
834
835   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
836     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
837       return e->dynindx;
838   return -1;
839 }
840
841 /* This function is used to renumber the dynamic symbols, if some of
842    them are removed because they are marked as local.  This is called
843    via elf_link_hash_traverse.  */
844
845 static bfd_boolean
846 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
847                                       void *data)
848 {
849   size_t *count = (size_t *) data;
850
851   if (h->forced_local)
852     return TRUE;
853
854   if (h->dynindx != -1)
855     h->dynindx = ++(*count);
856
857   return TRUE;
858 }
859
860
861 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
862    STB_LOCAL binding.  */
863
864 static bfd_boolean
865 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
866                                             void *data)
867 {
868   size_t *count = (size_t *) data;
869
870   if (!h->forced_local)
871     return TRUE;
872
873   if (h->dynindx != -1)
874     h->dynindx = ++(*count);
875
876   return TRUE;
877 }
878
879 /* Return true if the dynamic symbol for a given section should be
880    omitted when creating a shared library.  */
881 bfd_boolean
882 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
883                                    struct bfd_link_info *info,
884                                    asection *p)
885 {
886   struct elf_link_hash_table *htab;
887   asection *ip;
888
889   switch (elf_section_data (p)->this_hdr.sh_type)
890     {
891     case SHT_PROGBITS:
892     case SHT_NOBITS:
893       /* If sh_type is yet undecided, assume it could be
894          SHT_PROGBITS/SHT_NOBITS.  */
895     case SHT_NULL:
896       htab = elf_hash_table (info);
897       if (p == htab->tls_sec)
898         return FALSE;
899
900       if (htab->text_index_section != NULL)
901         return p != htab->text_index_section && p != htab->data_index_section;
902
903       return (htab->dynobj != NULL
904               && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
905               && ip->output_section == p);
906
907       /* There shouldn't be section relative relocations
908          against any other section.  */
909     default:
910       return TRUE;
911     }
912 }
913
914 /* Assign dynsym indices.  In a shared library we generate a section
915    symbol for each output section, which come first.  Next come symbols
916    which have been forced to local binding.  Then all of the back-end
917    allocated local dynamic syms, followed by the rest of the global
918    symbols.  */
919
920 static unsigned long
921 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
922                                 struct bfd_link_info *info,
923                                 unsigned long *section_sym_count)
924 {
925   unsigned long dynsymcount = 0;
926
927   if (bfd_link_pic (info)
928       || elf_hash_table (info)->is_relocatable_executable)
929     {
930       const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
931       asection *p;
932       for (p = output_bfd->sections; p ; p = p->next)
933         if ((p->flags & SEC_EXCLUDE) == 0
934             && (p->flags & SEC_ALLOC) != 0
935             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
936           elf_section_data (p)->dynindx = ++dynsymcount;
937         else
938           elf_section_data (p)->dynindx = 0;
939     }
940   *section_sym_count = dynsymcount;
941
942   elf_link_hash_traverse (elf_hash_table (info),
943                           elf_link_renumber_local_hash_table_dynsyms,
944                           &dynsymcount);
945
946   if (elf_hash_table (info)->dynlocal)
947     {
948       struct elf_link_local_dynamic_entry *p;
949       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
950         p->dynindx = ++dynsymcount;
951     }
952   elf_hash_table (info)->local_dynsymcount = dynsymcount;
953
954   elf_link_hash_traverse (elf_hash_table (info),
955                           elf_link_renumber_hash_table_dynsyms,
956                           &dynsymcount);
957
958   /* There is an unused NULL entry at the head of the table which we
959      must account for in our count even if the table is empty since it
960      is intended for the mandatory DT_SYMTAB tag (.dynsym section) in
961      .dynamic section.  */
962   dynsymcount++;
963
964   elf_hash_table (info)->dynsymcount = dynsymcount;
965   return dynsymcount;
966 }
967
968 /* Merge st_other field.  */
969
970 static void
971 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
972                     const Elf_Internal_Sym *isym, asection *sec,
973                     bfd_boolean definition, bfd_boolean dynamic)
974 {
975   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
976
977   /* If st_other has a processor-specific meaning, specific
978      code might be needed here.  */
979   if (bed->elf_backend_merge_symbol_attribute)
980     (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
981                                                 dynamic);
982
983   if (!dynamic)
984     {
985       unsigned symvis = ELF_ST_VISIBILITY (isym->st_other);
986       unsigned hvis = ELF_ST_VISIBILITY (h->other);
987
988       /* Keep the most constraining visibility.  Leave the remainder
989          of the st_other field to elf_backend_merge_symbol_attribute.  */
990       if (symvis - 1 < hvis - 1)
991         h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
992     }
993   else if (definition
994            && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT
995            && (sec->flags & SEC_READONLY) == 0)
996     h->protected_def = 1;
997 }
998
999 /* This function is called when we want to merge a new symbol with an
1000    existing symbol.  It handles the various cases which arise when we
1001    find a definition in a dynamic object, or when there is already a
1002    definition in a dynamic object.  The new symbol is described by
1003    NAME, SYM, PSEC, and PVALUE.  We set SYM_HASH to the hash table
1004    entry.  We set POLDBFD to the old symbol's BFD.  We set POLD_WEAK
1005    if the old symbol was weak.  We set POLD_ALIGNMENT to the alignment
1006    of an old common symbol.  We set OVERRIDE if the old symbol is
1007    overriding a new definition.  We set TYPE_CHANGE_OK if it is OK for
1008    the type to change.  We set SIZE_CHANGE_OK if it is OK for the size
1009    to change.  By OK to change, we mean that we shouldn't warn if the
1010    type or size does change.  */
1011
1012 static bfd_boolean
1013 _bfd_elf_merge_symbol (bfd *abfd,
1014                        struct bfd_link_info *info,
1015                        const char *name,
1016                        Elf_Internal_Sym *sym,
1017                        asection **psec,
1018                        bfd_vma *pvalue,
1019                        struct elf_link_hash_entry **sym_hash,
1020                        bfd **poldbfd,
1021                        bfd_boolean *pold_weak,
1022                        unsigned int *pold_alignment,
1023                        bfd_boolean *skip,
1024                        bfd_boolean *override,
1025                        bfd_boolean *type_change_ok,
1026                        bfd_boolean *size_change_ok,
1027                        bfd_boolean *matched)
1028 {
1029   asection *sec, *oldsec;
1030   struct elf_link_hash_entry *h;
1031   struct elf_link_hash_entry *hi;
1032   struct elf_link_hash_entry *flip;
1033   int bind;
1034   bfd *oldbfd;
1035   bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
1036   bfd_boolean newweak, oldweak, newfunc, oldfunc;
1037   const struct elf_backend_data *bed;
1038   char *new_version;
1039
1040   *skip = FALSE;
1041   *override = FALSE;
1042
1043   sec = *psec;
1044   bind = ELF_ST_BIND (sym->st_info);
1045
1046   if (! bfd_is_und_section (sec))
1047     h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
1048   else
1049     h = ((struct elf_link_hash_entry *)
1050          bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
1051   if (h == NULL)
1052     return FALSE;
1053   *sym_hash = h;
1054
1055   bed = get_elf_backend_data (abfd);
1056
1057   /* NEW_VERSION is the symbol version of the new symbol.  */
1058   if (h->versioned != unversioned)
1059     {
1060       /* Symbol version is unknown or versioned.  */
1061       new_version = strrchr (name, ELF_VER_CHR);
1062       if (new_version)
1063         {
1064           if (h->versioned == unknown)
1065             {
1066               if (new_version > name && new_version[-1] != ELF_VER_CHR)
1067                 h->versioned = versioned_hidden;
1068               else
1069                 h->versioned = versioned;
1070             }
1071           new_version += 1;
1072           if (new_version[0] == '\0')
1073             new_version = NULL;
1074         }
1075       else
1076         h->versioned = unversioned;
1077     }
1078   else
1079     new_version = NULL;
1080
1081   /* For merging, we only care about real symbols.  But we need to make
1082      sure that indirect symbol dynamic flags are updated.  */
1083   hi = h;
1084   while (h->root.type == bfd_link_hash_indirect
1085          || h->root.type == bfd_link_hash_warning)
1086     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1087
1088   if (!*matched)
1089     {
1090       if (hi == h || h->root.type == bfd_link_hash_new)
1091         *matched = TRUE;
1092       else
1093         {
1094           /* OLD_HIDDEN is true if the existing symbol is only visible
1095              to the symbol with the same symbol version.  NEW_HIDDEN is
1096              true if the new symbol is only visible to the symbol with
1097              the same symbol version.  */
1098           bfd_boolean old_hidden = h->versioned == versioned_hidden;
1099           bfd_boolean new_hidden = hi->versioned == versioned_hidden;
1100           if (!old_hidden && !new_hidden)
1101             /* The new symbol matches the existing symbol if both
1102                aren't hidden.  */
1103             *matched = TRUE;
1104           else
1105             {
1106               /* OLD_VERSION is the symbol version of the existing
1107                  symbol. */
1108               char *old_version;
1109
1110               if (h->versioned >= versioned)
1111                 old_version = strrchr (h->root.root.string,
1112                                        ELF_VER_CHR) + 1;
1113               else
1114                  old_version = NULL;
1115
1116               /* The new symbol matches the existing symbol if they
1117                  have the same symbol version.  */
1118               *matched = (old_version == new_version
1119                           || (old_version != NULL
1120                               && new_version != NULL
1121                               && strcmp (old_version, new_version) == 0));
1122             }
1123         }
1124     }
1125
1126   /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1127      existing symbol.  */
1128
1129   oldbfd = NULL;
1130   oldsec = NULL;
1131   switch (h->root.type)
1132     {
1133     default:
1134       break;
1135
1136     case bfd_link_hash_undefined:
1137     case bfd_link_hash_undefweak:
1138       oldbfd = h->root.u.undef.abfd;
1139       break;
1140
1141     case bfd_link_hash_defined:
1142     case bfd_link_hash_defweak:
1143       oldbfd = h->root.u.def.section->owner;
1144       oldsec = h->root.u.def.section;
1145       break;
1146
1147     case bfd_link_hash_common:
1148       oldbfd = h->root.u.c.p->section->owner;
1149       oldsec = h->root.u.c.p->section;
1150       if (pold_alignment)
1151         *pold_alignment = h->root.u.c.p->alignment_power;
1152       break;
1153     }
1154   if (poldbfd && *poldbfd == NULL)
1155     *poldbfd = oldbfd;
1156
1157   /* Differentiate strong and weak symbols.  */
1158   newweak = bind == STB_WEAK;
1159   oldweak = (h->root.type == bfd_link_hash_defweak
1160              || h->root.type == bfd_link_hash_undefweak);
1161   if (pold_weak)
1162     *pold_weak = oldweak;
1163
1164   /* This code is for coping with dynamic objects, and is only useful
1165      if we are doing an ELF link.  */
1166   if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
1167     return TRUE;
1168
1169   /* We have to check it for every instance since the first few may be
1170      references and not all compilers emit symbol type for undefined
1171      symbols.  */
1172   bfd_elf_link_mark_dynamic_symbol (info, h, sym);
1173
1174   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1175      respectively, is from a dynamic object.  */
1176
1177   newdyn = (abfd->flags & DYNAMIC) != 0;
1178
1179   /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
1180      syms and defined syms in dynamic libraries respectively.
1181      ref_dynamic on the other hand can be set for a symbol defined in
1182      a dynamic library, and def_dynamic may not be set;  When the
1183      definition in a dynamic lib is overridden by a definition in the
1184      executable use of the symbol in the dynamic lib becomes a
1185      reference to the executable symbol.  */
1186   if (newdyn)
1187     {
1188       if (bfd_is_und_section (sec))
1189         {
1190           if (bind != STB_WEAK)
1191             {
1192               h->ref_dynamic_nonweak = 1;
1193               hi->ref_dynamic_nonweak = 1;
1194             }
1195         }
1196       else
1197         {
1198           /* Update the existing symbol only if they match. */
1199           if (*matched)
1200             h->dynamic_def = 1;
1201           hi->dynamic_def = 1;
1202         }
1203     }
1204
1205   /* If we just created the symbol, mark it as being an ELF symbol.
1206      Other than that, there is nothing to do--there is no merge issue
1207      with a newly defined symbol--so we just return.  */
1208
1209   if (h->root.type == bfd_link_hash_new)
1210     {
1211       h->non_elf = 0;
1212       return TRUE;
1213     }
1214
1215   /* In cases involving weak versioned symbols, we may wind up trying
1216      to merge a symbol with itself.  Catch that here, to avoid the
1217      confusion that results if we try to override a symbol with
1218      itself.  The additional tests catch cases like
1219      _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1220      dynamic object, which we do want to handle here.  */
1221   if (abfd == oldbfd
1222       && (newweak || oldweak)
1223       && ((abfd->flags & DYNAMIC) == 0
1224           || !h->def_regular))
1225     return TRUE;
1226
1227   olddyn = FALSE;
1228   if (oldbfd != NULL)
1229     olddyn = (oldbfd->flags & DYNAMIC) != 0;
1230   else if (oldsec != NULL)
1231     {
1232       /* This handles the special SHN_MIPS_{TEXT,DATA} section
1233          indices used by MIPS ELF.  */
1234       olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1235     }
1236
1237   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1238      respectively, appear to be a definition rather than reference.  */
1239
1240   newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1241
1242   olddef = (h->root.type != bfd_link_hash_undefined
1243             && h->root.type != bfd_link_hash_undefweak
1244             && h->root.type != bfd_link_hash_common);
1245
1246   /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1247      respectively, appear to be a function.  */
1248
1249   newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1250              && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1251
1252   oldfunc = (h->type != STT_NOTYPE
1253              && bed->is_function_type (h->type));
1254
1255   if (!(newfunc && oldfunc)
1256       && ELF_ST_TYPE (sym->st_info) != h->type
1257       && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1258       && h->type != STT_NOTYPE
1259       && (newdef || bfd_is_com_section (sec))
1260       && (olddef || h->root.type == bfd_link_hash_common))
1261     {
1262       /* If creating a default indirect symbol ("foo" or "foo@") from
1263          a dynamic versioned definition ("foo@@") skip doing so if
1264          there is an existing regular definition with a different
1265          type.  We don't want, for example, a "time" variable in the
1266          executable overriding a "time" function in a shared library.  */
1267       if (newdyn
1268           && !olddyn)
1269         {
1270           *skip = TRUE;
1271           return TRUE;
1272         }
1273
1274       /* When adding a symbol from a regular object file after we have
1275          created indirect symbols, undo the indirection and any
1276          dynamic state.  */
1277       if (hi != h
1278           && !newdyn
1279           && olddyn)
1280         {
1281           h = hi;
1282           (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1283           h->forced_local = 0;
1284           h->ref_dynamic = 0;
1285           h->def_dynamic = 0;
1286           h->dynamic_def = 0;
1287           if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1288             {
1289               h->root.type = bfd_link_hash_undefined;
1290               h->root.u.undef.abfd = abfd;
1291             }
1292           else
1293             {
1294               h->root.type = bfd_link_hash_new;
1295               h->root.u.undef.abfd = NULL;
1296             }
1297           return TRUE;
1298         }
1299     }
1300
1301   /* Check TLS symbols.  We don't check undefined symbols introduced
1302      by "ld -u" which have no type (and oldbfd NULL), and we don't
1303      check symbols from plugins because they also have no type.  */
1304   if (oldbfd != NULL
1305       && (oldbfd->flags & BFD_PLUGIN) == 0
1306       && (abfd->flags & BFD_PLUGIN) == 0
1307       && ELF_ST_TYPE (sym->st_info) != h->type
1308       && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1309     {
1310       bfd *ntbfd, *tbfd;
1311       bfd_boolean ntdef, tdef;
1312       asection *ntsec, *tsec;
1313
1314       if (h->type == STT_TLS)
1315         {
1316           ntbfd = abfd;
1317           ntsec = sec;
1318           ntdef = newdef;
1319           tbfd = oldbfd;
1320           tsec = oldsec;
1321           tdef = olddef;
1322         }
1323       else
1324         {
1325           ntbfd = oldbfd;
1326           ntsec = oldsec;
1327           ntdef = olddef;
1328           tbfd = abfd;
1329           tsec = sec;
1330           tdef = newdef;
1331         }
1332
1333       if (tdef && ntdef)
1334         _bfd_error_handler
1335           /* xgettext:c-format */
1336           (_("%s: TLS definition in %B section %A "
1337              "mismatches non-TLS definition in %B section %A"),
1338            h->root.root.string, tbfd, tsec, ntbfd, ntsec);
1339       else if (!tdef && !ntdef)
1340         _bfd_error_handler
1341           /* xgettext:c-format */
1342           (_("%s: TLS reference in %B "
1343              "mismatches non-TLS reference in %B"),
1344            h->root.root.string, tbfd, ntbfd);
1345       else if (tdef)
1346         _bfd_error_handler
1347           /* xgettext:c-format */
1348           (_("%s: TLS definition in %B section %A "
1349              "mismatches non-TLS reference in %B"),
1350            h->root.root.string, tbfd, tsec, ntbfd);
1351       else
1352         _bfd_error_handler
1353           /* xgettext:c-format */
1354           (_("%s: TLS reference in %B "
1355              "mismatches non-TLS definition in %B section %A"),
1356            h->root.root.string, tbfd, ntbfd, ntsec);
1357
1358       bfd_set_error (bfd_error_bad_value);
1359       return FALSE;
1360     }
1361
1362   /* If the old symbol has non-default visibility, we ignore the new
1363      definition from a dynamic object.  */
1364   if (newdyn
1365       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1366       && !bfd_is_und_section (sec))
1367     {
1368       *skip = TRUE;
1369       /* Make sure this symbol is dynamic.  */
1370       h->ref_dynamic = 1;
1371       hi->ref_dynamic = 1;
1372       /* A protected symbol has external availability. Make sure it is
1373          recorded as dynamic.
1374
1375          FIXME: Should we check type and size for protected symbol?  */
1376       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1377         return bfd_elf_link_record_dynamic_symbol (info, h);
1378       else
1379         return TRUE;
1380     }
1381   else if (!newdyn
1382            && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1383            && h->def_dynamic)
1384     {
1385       /* If the new symbol with non-default visibility comes from a
1386          relocatable file and the old definition comes from a dynamic
1387          object, we remove the old definition.  */
1388       if (hi->root.type == bfd_link_hash_indirect)
1389         {
1390           /* Handle the case where the old dynamic definition is
1391              default versioned.  We need to copy the symbol info from
1392              the symbol with default version to the normal one if it
1393              was referenced before.  */
1394           if (h->ref_regular)
1395             {
1396               hi->root.type = h->root.type;
1397               h->root.type = bfd_link_hash_indirect;
1398               (*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
1399
1400               h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1401               if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1402                 {
1403                   /* If the new symbol is hidden or internal, completely undo
1404                      any dynamic link state.  */
1405                   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1406                   h->forced_local = 0;
1407                   h->ref_dynamic = 0;
1408                 }
1409               else
1410                 h->ref_dynamic = 1;
1411
1412               h->def_dynamic = 0;
1413               /* FIXME: Should we check type and size for protected symbol?  */
1414               h->size = 0;
1415               h->type = 0;
1416
1417               h = hi;
1418             }
1419           else
1420             h = hi;
1421         }
1422
1423       /* If the old symbol was undefined before, then it will still be
1424          on the undefs list.  If the new symbol is undefined or
1425          common, we can't make it bfd_link_hash_new here, because new
1426          undefined or common symbols will be added to the undefs list
1427          by _bfd_generic_link_add_one_symbol.  Symbols may not be
1428          added twice to the undefs list.  Also, if the new symbol is
1429          undefweak then we don't want to lose the strong undef.  */
1430       if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1431         {
1432           h->root.type = bfd_link_hash_undefined;
1433           h->root.u.undef.abfd = abfd;
1434         }
1435       else
1436         {
1437           h->root.type = bfd_link_hash_new;
1438           h->root.u.undef.abfd = NULL;
1439         }
1440
1441       if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1442         {
1443           /* If the new symbol is hidden or internal, completely undo
1444              any dynamic link state.  */
1445           (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1446           h->forced_local = 0;
1447           h->ref_dynamic = 0;
1448         }
1449       else
1450         h->ref_dynamic = 1;
1451       h->def_dynamic = 0;
1452       /* FIXME: Should we check type and size for protected symbol?  */
1453       h->size = 0;
1454       h->type = 0;
1455       return TRUE;
1456     }
1457
1458   /* If a new weak symbol definition comes from a regular file and the
1459      old symbol comes from a dynamic library, we treat the new one as
1460      strong.  Similarly, an old weak symbol definition from a regular
1461      file is treated as strong when the new symbol comes from a dynamic
1462      library.  Further, an old weak symbol from a dynamic library is
1463      treated as strong if the new symbol is from a dynamic library.
1464      This reflects the way glibc's ld.so works.
1465
1466      Do this before setting *type_change_ok or *size_change_ok so that
1467      we warn properly when dynamic library symbols are overridden.  */
1468
1469   if (newdef && !newdyn && olddyn)
1470     newweak = FALSE;
1471   if (olddef && newdyn)
1472     oldweak = FALSE;
1473
1474   /* Allow changes between different types of function symbol.  */
1475   if (newfunc && oldfunc)
1476     *type_change_ok = TRUE;
1477
1478   /* It's OK to change the type if either the existing symbol or the
1479      new symbol is weak.  A type change is also OK if the old symbol
1480      is undefined and the new symbol is defined.  */
1481
1482   if (oldweak
1483       || newweak
1484       || (newdef
1485           && h->root.type == bfd_link_hash_undefined))
1486     *type_change_ok = TRUE;
1487
1488   /* It's OK to change the size if either the existing symbol or the
1489      new symbol is weak, or if the old symbol is undefined.  */
1490
1491   if (*type_change_ok
1492       || h->root.type == bfd_link_hash_undefined)
1493     *size_change_ok = TRUE;
1494
1495   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1496      symbol, respectively, appears to be a common symbol in a dynamic
1497      object.  If a symbol appears in an uninitialized section, and is
1498      not weak, and is not a function, then it may be a common symbol
1499      which was resolved when the dynamic object was created.  We want
1500      to treat such symbols specially, because they raise special
1501      considerations when setting the symbol size: if the symbol
1502      appears as a common symbol in a regular object, and the size in
1503      the regular object is larger, we must make sure that we use the
1504      larger size.  This problematic case can always be avoided in C,
1505      but it must be handled correctly when using Fortran shared
1506      libraries.
1507
1508      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1509      likewise for OLDDYNCOMMON and OLDDEF.
1510
1511      Note that this test is just a heuristic, and that it is quite
1512      possible to have an uninitialized symbol in a shared object which
1513      is really a definition, rather than a common symbol.  This could
1514      lead to some minor confusion when the symbol really is a common
1515      symbol in some regular object.  However, I think it will be
1516      harmless.  */
1517
1518   if (newdyn
1519       && newdef
1520       && !newweak
1521       && (sec->flags & SEC_ALLOC) != 0
1522       && (sec->flags & SEC_LOAD) == 0
1523       && sym->st_size > 0
1524       && !newfunc)
1525     newdyncommon = TRUE;
1526   else
1527     newdyncommon = FALSE;
1528
1529   if (olddyn
1530       && olddef
1531       && h->root.type == bfd_link_hash_defined
1532       && h->def_dynamic
1533       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1534       && (h->root.u.def.section->flags & SEC_LOAD) == 0
1535       && h->size > 0
1536       && !oldfunc)
1537     olddyncommon = TRUE;
1538   else
1539     olddyncommon = FALSE;
1540
1541   /* We now know everything about the old and new symbols.  We ask the
1542      backend to check if we can merge them.  */
1543   if (bed->merge_symbol != NULL)
1544     {
1545       if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
1546         return FALSE;
1547       sec = *psec;
1548     }
1549
1550   /* If both the old and the new symbols look like common symbols in a
1551      dynamic object, set the size of the symbol to the larger of the
1552      two.  */
1553
1554   if (olddyncommon
1555       && newdyncommon
1556       && sym->st_size != h->size)
1557     {
1558       /* Since we think we have two common symbols, issue a multiple
1559          common warning if desired.  Note that we only warn if the
1560          size is different.  If the size is the same, we simply let
1561          the old symbol override the new one as normally happens with
1562          symbols defined in dynamic objects.  */
1563
1564       (*info->callbacks->multiple_common) (info, &h->root, abfd,
1565                                            bfd_link_hash_common, sym->st_size);
1566       if (sym->st_size > h->size)
1567         h->size = sym->st_size;
1568
1569       *size_change_ok = TRUE;
1570     }
1571
1572   /* If we are looking at a dynamic object, and we have found a
1573      definition, we need to see if the symbol was already defined by
1574      some other object.  If so, we want to use the existing
1575      definition, and we do not want to report a multiple symbol
1576      definition error; we do this by clobbering *PSEC to be
1577      bfd_und_section_ptr.
1578
1579      We treat a common symbol as a definition if the symbol in the
1580      shared library is a function, since common symbols always
1581      represent variables; this can cause confusion in principle, but
1582      any such confusion would seem to indicate an erroneous program or
1583      shared library.  We also permit a common symbol in a regular
1584      object to override a weak symbol in a shared object.  */
1585
1586   if (newdyn
1587       && newdef
1588       && (olddef
1589           || (h->root.type == bfd_link_hash_common
1590               && (newweak || newfunc))))
1591     {
1592       *override = TRUE;
1593       newdef = FALSE;
1594       newdyncommon = FALSE;
1595
1596       *psec = sec = bfd_und_section_ptr;
1597       *size_change_ok = TRUE;
1598
1599       /* If we get here when the old symbol is a common symbol, then
1600          we are explicitly letting it override a weak symbol or
1601          function in a dynamic object, and we don't want to warn about
1602          a type change.  If the old symbol is a defined symbol, a type
1603          change warning may still be appropriate.  */
1604
1605       if (h->root.type == bfd_link_hash_common)
1606         *type_change_ok = TRUE;
1607     }
1608
1609   /* Handle the special case of an old common symbol merging with a
1610      new symbol which looks like a common symbol in a shared object.
1611      We change *PSEC and *PVALUE to make the new symbol look like a
1612      common symbol, and let _bfd_generic_link_add_one_symbol do the
1613      right thing.  */
1614
1615   if (newdyncommon
1616       && h->root.type == bfd_link_hash_common)
1617     {
1618       *override = TRUE;
1619       newdef = FALSE;
1620       newdyncommon = FALSE;
1621       *pvalue = sym->st_size;
1622       *psec = sec = bed->common_section (oldsec);
1623       *size_change_ok = TRUE;
1624     }
1625
1626   /* Skip weak definitions of symbols that are already defined.  */
1627   if (newdef && olddef && newweak)
1628     {
1629       /* Don't skip new non-IR weak syms.  */
1630       if (!(oldbfd != NULL
1631             && (oldbfd->flags & BFD_PLUGIN) != 0
1632             && (abfd->flags & BFD_PLUGIN) == 0))
1633         {
1634           newdef = FALSE;
1635           *skip = TRUE;
1636         }
1637
1638       /* Merge st_other.  If the symbol already has a dynamic index,
1639          but visibility says it should not be visible, turn it into a
1640          local symbol.  */
1641       elf_merge_st_other (abfd, h, sym, sec, newdef, newdyn);
1642       if (h->dynindx != -1)
1643         switch (ELF_ST_VISIBILITY (h->other))
1644           {
1645           case STV_INTERNAL:
1646           case STV_HIDDEN:
1647             (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1648             break;
1649           }
1650     }
1651
1652   /* If the old symbol is from a dynamic object, and the new symbol is
1653      a definition which is not from a dynamic object, then the new
1654      symbol overrides the old symbol.  Symbols from regular files
1655      always take precedence over symbols from dynamic objects, even if
1656      they are defined after the dynamic object in the link.
1657
1658      As above, we again permit a common symbol in a regular object to
1659      override a definition in a shared object if the shared object
1660      symbol is a function or is weak.  */
1661
1662   flip = NULL;
1663   if (!newdyn
1664       && (newdef
1665           || (bfd_is_com_section (sec)
1666               && (oldweak || oldfunc)))
1667       && olddyn
1668       && olddef
1669       && h->def_dynamic)
1670     {
1671       /* Change the hash table entry to undefined, and let
1672          _bfd_generic_link_add_one_symbol do the right thing with the
1673          new definition.  */
1674
1675       h->root.type = bfd_link_hash_undefined;
1676       h->root.u.undef.abfd = h->root.u.def.section->owner;
1677       *size_change_ok = TRUE;
1678
1679       olddef = FALSE;
1680       olddyncommon = FALSE;
1681
1682       /* We again permit a type change when a common symbol may be
1683          overriding a function.  */
1684
1685       if (bfd_is_com_section (sec))
1686         {
1687           if (oldfunc)
1688             {
1689               /* If a common symbol overrides a function, make sure
1690                  that it isn't defined dynamically nor has type
1691                  function.  */
1692               h->def_dynamic = 0;
1693               h->type = STT_NOTYPE;
1694             }
1695           *type_change_ok = TRUE;
1696         }
1697
1698       if (hi->root.type == bfd_link_hash_indirect)
1699         flip = hi;
1700       else
1701         /* This union may have been set to be non-NULL when this symbol
1702            was seen in a dynamic object.  We must force the union to be
1703            NULL, so that it is correct for a regular symbol.  */
1704         h->verinfo.vertree = NULL;
1705     }
1706
1707   /* Handle the special case of a new common symbol merging with an
1708      old symbol that looks like it might be a common symbol defined in
1709      a shared object.  Note that we have already handled the case in
1710      which a new common symbol should simply override the definition
1711      in the shared library.  */
1712
1713   if (! newdyn
1714       && bfd_is_com_section (sec)
1715       && olddyncommon)
1716     {
1717       /* It would be best if we could set the hash table entry to a
1718          common symbol, but we don't know what to use for the section
1719          or the alignment.  */
1720       (*info->callbacks->multiple_common) (info, &h->root, abfd,
1721                                            bfd_link_hash_common, sym->st_size);
1722
1723       /* If the presumed common symbol in the dynamic object is
1724          larger, pretend that the new symbol has its size.  */
1725
1726       if (h->size > *pvalue)
1727         *pvalue = h->size;
1728
1729       /* We need to remember the alignment required by the symbol
1730          in the dynamic object.  */
1731       BFD_ASSERT (pold_alignment);
1732       *pold_alignment = h->root.u.def.section->alignment_power;
1733
1734       olddef = FALSE;
1735       olddyncommon = FALSE;
1736
1737       h->root.type = bfd_link_hash_undefined;
1738       h->root.u.undef.abfd = h->root.u.def.section->owner;
1739
1740       *size_change_ok = TRUE;
1741       *type_change_ok = TRUE;
1742
1743       if (hi->root.type == bfd_link_hash_indirect)
1744         flip = hi;
1745       else
1746         h->verinfo.vertree = NULL;
1747     }
1748
1749   if (flip != NULL)
1750     {
1751       /* Handle the case where we had a versioned symbol in a dynamic
1752          library and now find a definition in a normal object.  In this
1753          case, we make the versioned symbol point to the normal one.  */
1754       flip->root.type = h->root.type;
1755       flip->root.u.undef.abfd = h->root.u.undef.abfd;
1756       h->root.type = bfd_link_hash_indirect;
1757       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1758       (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1759       if (h->def_dynamic)
1760         {
1761           h->def_dynamic = 0;
1762           flip->ref_dynamic = 1;
1763         }
1764     }
1765
1766   return TRUE;
1767 }
1768
1769 /* This function is called to create an indirect symbol from the
1770    default for the symbol with the default version if needed. The
1771    symbol is described by H, NAME, SYM, SEC, and VALUE.  We
1772    set DYNSYM if the new indirect symbol is dynamic.  */
1773
1774 static bfd_boolean
1775 _bfd_elf_add_default_symbol (bfd *abfd,
1776                              struct bfd_link_info *info,
1777                              struct elf_link_hash_entry *h,
1778                              const char *name,
1779                              Elf_Internal_Sym *sym,
1780                              asection *sec,
1781                              bfd_vma value,
1782                              bfd **poldbfd,
1783                              bfd_boolean *dynsym)
1784 {
1785   bfd_boolean type_change_ok;
1786   bfd_boolean size_change_ok;
1787   bfd_boolean skip;
1788   char *shortname;
1789   struct elf_link_hash_entry *hi;
1790   struct bfd_link_hash_entry *bh;
1791   const struct elf_backend_data *bed;
1792   bfd_boolean collect;
1793   bfd_boolean dynamic;
1794   bfd_boolean override;
1795   char *p;
1796   size_t len, shortlen;
1797   asection *tmp_sec;
1798   bfd_boolean matched;
1799
1800   if (h->versioned == unversioned || h->versioned == versioned_hidden)
1801     return TRUE;
1802
1803   /* If this symbol has a version, and it is the default version, we
1804      create an indirect symbol from the default name to the fully
1805      decorated name.  This will cause external references which do not
1806      specify a version to be bound to this version of the symbol.  */
1807   p = strchr (name, ELF_VER_CHR);
1808   if (h->versioned == unknown)
1809     {
1810       if (p == NULL)
1811         {
1812           h->versioned = unversioned;
1813           return TRUE;
1814         }
1815       else
1816         {
1817           if (p[1] != ELF_VER_CHR)
1818             {
1819               h->versioned = versioned_hidden;
1820               return TRUE;
1821             }
1822           else
1823             h->versioned = versioned;
1824         }
1825     }
1826   else
1827     {
1828       /* PR ld/19073: We may see an unversioned definition after the
1829          default version.  */
1830       if (p == NULL)
1831         return TRUE;
1832     }
1833
1834   bed = get_elf_backend_data (abfd);
1835   collect = bed->collect;
1836   dynamic = (abfd->flags & DYNAMIC) != 0;
1837
1838   shortlen = p - name;
1839   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1840   if (shortname == NULL)
1841     return FALSE;
1842   memcpy (shortname, name, shortlen);
1843   shortname[shortlen] = '\0';
1844
1845   /* We are going to create a new symbol.  Merge it with any existing
1846      symbol with this name.  For the purposes of the merge, act as
1847      though we were defining the symbol we just defined, although we
1848      actually going to define an indirect symbol.  */
1849   type_change_ok = FALSE;
1850   size_change_ok = FALSE;
1851   matched = TRUE;
1852   tmp_sec = sec;
1853   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1854                               &hi, poldbfd, NULL, NULL, &skip, &override,
1855                               &type_change_ok, &size_change_ok, &matched))
1856     return FALSE;
1857
1858   if (skip)
1859     goto nondefault;
1860
1861   if (hi->def_regular)
1862     {
1863       /* If the undecorated symbol will have a version added by a
1864          script different to H, then don't indirect to/from the
1865          undecorated symbol.  This isn't ideal because we may not yet
1866          have seen symbol versions, if given by a script on the
1867          command line rather than via --version-script.  */
1868       if (hi->verinfo.vertree == NULL && info->version_info != NULL)
1869         {
1870           bfd_boolean hide;
1871
1872           hi->verinfo.vertree
1873             = bfd_find_version_for_sym (info->version_info,
1874                                         hi->root.root.string, &hide);
1875           if (hi->verinfo.vertree != NULL && hide)
1876             {
1877               (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
1878               goto nondefault;
1879             }
1880         }
1881       if (hi->verinfo.vertree != NULL
1882           && strcmp (p + 1 + (p[1] == '@'), hi->verinfo.vertree->name) != 0)
1883         goto nondefault;
1884     }
1885
1886   if (! override)
1887     {
1888       /* Add the default symbol if not performing a relocatable link.  */
1889       if (! bfd_link_relocatable (info))
1890         {
1891           bh = &hi->root;
1892           if (! (_bfd_generic_link_add_one_symbol
1893                  (info, abfd, shortname, BSF_INDIRECT,
1894                   bfd_ind_section_ptr,
1895                   0, name, FALSE, collect, &bh)))
1896             return FALSE;
1897           hi = (struct elf_link_hash_entry *) bh;
1898         }
1899     }
1900   else
1901     {
1902       /* In this case the symbol named SHORTNAME is overriding the
1903          indirect symbol we want to add.  We were planning on making
1904          SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1905          is the name without a version.  NAME is the fully versioned
1906          name, and it is the default version.
1907
1908          Overriding means that we already saw a definition for the
1909          symbol SHORTNAME in a regular object, and it is overriding
1910          the symbol defined in the dynamic object.
1911
1912          When this happens, we actually want to change NAME, the
1913          symbol we just added, to refer to SHORTNAME.  This will cause
1914          references to NAME in the shared object to become references
1915          to SHORTNAME in the regular object.  This is what we expect
1916          when we override a function in a shared object: that the
1917          references in the shared object will be mapped to the
1918          definition in the regular object.  */
1919
1920       while (hi->root.type == bfd_link_hash_indirect
1921              || hi->root.type == bfd_link_hash_warning)
1922         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1923
1924       h->root.type = bfd_link_hash_indirect;
1925       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1926       if (h->def_dynamic)
1927         {
1928           h->def_dynamic = 0;
1929           hi->ref_dynamic = 1;
1930           if (hi->ref_regular
1931               || hi->def_regular)
1932             {
1933               if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1934                 return FALSE;
1935             }
1936         }
1937
1938       /* Now set HI to H, so that the following code will set the
1939          other fields correctly.  */
1940       hi = h;
1941     }
1942
1943   /* Check if HI is a warning symbol.  */
1944   if (hi->root.type == bfd_link_hash_warning)
1945     hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1946
1947   /* If there is a duplicate definition somewhere, then HI may not
1948      point to an indirect symbol.  We will have reported an error to
1949      the user in that case.  */
1950
1951   if (hi->root.type == bfd_link_hash_indirect)
1952     {
1953       struct elf_link_hash_entry *ht;
1954
1955       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1956       (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1957
1958       /* A reference to the SHORTNAME symbol from a dynamic library
1959          will be satisfied by the versioned symbol at runtime.  In
1960          effect, we have a reference to the versioned symbol.  */
1961       ht->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1962       hi->dynamic_def |= ht->dynamic_def;
1963
1964       /* See if the new flags lead us to realize that the symbol must
1965          be dynamic.  */
1966       if (! *dynsym)
1967         {
1968           if (! dynamic)
1969             {
1970               if (! bfd_link_executable (info)
1971                   || hi->def_dynamic
1972                   || hi->ref_dynamic)
1973                 *dynsym = TRUE;
1974             }
1975           else
1976             {
1977               if (hi->ref_regular)
1978                 *dynsym = TRUE;
1979             }
1980         }
1981     }
1982
1983   /* We also need to define an indirection from the nondefault version
1984      of the symbol.  */
1985
1986 nondefault:
1987   len = strlen (name);
1988   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1989   if (shortname == NULL)
1990     return FALSE;
1991   memcpy (shortname, name, shortlen);
1992   memcpy (shortname + shortlen, p + 1, len - shortlen);
1993
1994   /* Once again, merge with any existing symbol.  */
1995   type_change_ok = FALSE;
1996   size_change_ok = FALSE;
1997   tmp_sec = sec;
1998   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1999                               &hi, poldbfd, NULL, NULL, &skip, &override,
2000                               &type_change_ok, &size_change_ok, &matched))
2001     return FALSE;
2002
2003   if (skip)
2004     return TRUE;
2005
2006   if (override)
2007     {
2008       /* Here SHORTNAME is a versioned name, so we don't expect to see
2009          the type of override we do in the case above unless it is
2010          overridden by a versioned definition.  */
2011       if (hi->root.type != bfd_link_hash_defined
2012           && hi->root.type != bfd_link_hash_defweak)
2013         _bfd_error_handler
2014           /* xgettext:c-format */
2015           (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
2016            abfd, shortname);
2017     }
2018   else
2019     {
2020       bh = &hi->root;
2021       if (! (_bfd_generic_link_add_one_symbol
2022              (info, abfd, shortname, BSF_INDIRECT,
2023               bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
2024         return FALSE;
2025       hi = (struct elf_link_hash_entry *) bh;
2026
2027       /* If there is a duplicate definition somewhere, then HI may not
2028          point to an indirect symbol.  We will have reported an error
2029          to the user in that case.  */
2030
2031       if (hi->root.type == bfd_link_hash_indirect)
2032         {
2033           (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
2034           h->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
2035           hi->dynamic_def |= h->dynamic_def;
2036
2037           /* See if the new flags lead us to realize that the symbol
2038              must be dynamic.  */
2039           if (! *dynsym)
2040             {
2041               if (! dynamic)
2042                 {
2043                   if (! bfd_link_executable (info)
2044                       || hi->ref_dynamic)
2045                     *dynsym = TRUE;
2046                 }
2047               else
2048                 {
2049                   if (hi->ref_regular)
2050                     *dynsym = TRUE;
2051                 }
2052             }
2053         }
2054     }
2055
2056   return TRUE;
2057 }
2058 \f
2059 /* This routine is used to export all defined symbols into the dynamic
2060    symbol table.  It is called via elf_link_hash_traverse.  */
2061
2062 static bfd_boolean
2063 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
2064 {
2065   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2066
2067   /* Ignore indirect symbols.  These are added by the versioning code.  */
2068   if (h->root.type == bfd_link_hash_indirect)
2069     return TRUE;
2070
2071   /* Ignore this if we won't export it.  */
2072   if (!eif->info->export_dynamic && !h->dynamic)
2073     return TRUE;
2074
2075   if (h->dynindx == -1
2076       && (h->def_regular || h->ref_regular)
2077       && ! bfd_hide_sym_by_version (eif->info->version_info,
2078                                     h->root.root.string))
2079     {
2080       if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2081         {
2082           eif->failed = TRUE;
2083           return FALSE;
2084         }
2085     }
2086
2087   return TRUE;
2088 }
2089 \f
2090 /* Look through the symbols which are defined in other shared
2091    libraries and referenced here.  Update the list of version
2092    dependencies.  This will be put into the .gnu.version_r section.
2093    This function is called via elf_link_hash_traverse.  */
2094
2095 static bfd_boolean
2096 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
2097                                          void *data)
2098 {
2099   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
2100   Elf_Internal_Verneed *t;
2101   Elf_Internal_Vernaux *a;
2102   bfd_size_type amt;
2103
2104   /* We only care about symbols defined in shared objects with version
2105      information.  */
2106   if (!h->def_dynamic
2107       || h->def_regular
2108       || h->dynindx == -1
2109       || h->verinfo.verdef == NULL
2110       || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
2111           & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
2112     return TRUE;
2113
2114   /* See if we already know about this version.  */
2115   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
2116        t != NULL;
2117        t = t->vn_nextref)
2118     {
2119       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
2120         continue;
2121
2122       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
2123         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
2124           return TRUE;
2125
2126       break;
2127     }
2128
2129   /* This is a new version.  Add it to tree we are building.  */
2130
2131   if (t == NULL)
2132     {
2133       amt = sizeof *t;
2134       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
2135       if (t == NULL)
2136         {
2137           rinfo->failed = TRUE;
2138           return FALSE;
2139         }
2140
2141       t->vn_bfd = h->verinfo.verdef->vd_bfd;
2142       t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
2143       elf_tdata (rinfo->info->output_bfd)->verref = t;
2144     }
2145
2146   amt = sizeof *a;
2147   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
2148   if (a == NULL)
2149     {
2150       rinfo->failed = TRUE;
2151       return FALSE;
2152     }
2153
2154   /* Note that we are copying a string pointer here, and testing it
2155      above.  If bfd_elf_string_from_elf_section is ever changed to
2156      discard the string data when low in memory, this will have to be
2157      fixed.  */
2158   a->vna_nodename = h->verinfo.verdef->vd_nodename;
2159
2160   a->vna_flags = h->verinfo.verdef->vd_flags;
2161   a->vna_nextptr = t->vn_auxptr;
2162
2163   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
2164   ++rinfo->vers;
2165
2166   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
2167
2168   t->vn_auxptr = a;
2169
2170   return TRUE;
2171 }
2172
2173 /* Figure out appropriate versions for all the symbols.  We may not
2174    have the version number script until we have read all of the input
2175    files, so until that point we don't know which symbols should be
2176    local.  This function is called via elf_link_hash_traverse.  */
2177
2178 static bfd_boolean
2179 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
2180 {
2181   struct elf_info_failed *sinfo;
2182   struct bfd_link_info *info;
2183   const struct elf_backend_data *bed;
2184   struct elf_info_failed eif;
2185   char *p;
2186
2187   sinfo = (struct elf_info_failed *) data;
2188   info = sinfo->info;
2189
2190   /* Fix the symbol flags.  */
2191   eif.failed = FALSE;
2192   eif.info = info;
2193   if (! _bfd_elf_fix_symbol_flags (h, &eif))
2194     {
2195       if (eif.failed)
2196         sinfo->failed = TRUE;
2197       return FALSE;
2198     }
2199
2200   /* We only need version numbers for symbols defined in regular
2201      objects.  */
2202   if (!h->def_regular)
2203     return TRUE;
2204
2205   bed = get_elf_backend_data (info->output_bfd);
2206   p = strchr (h->root.root.string, ELF_VER_CHR);
2207   if (p != NULL && h->verinfo.vertree == NULL)
2208     {
2209       struct bfd_elf_version_tree *t;
2210
2211       ++p;
2212       if (*p == ELF_VER_CHR)
2213         ++p;
2214
2215       /* If there is no version string, we can just return out.  */
2216       if (*p == '\0')
2217         return TRUE;
2218
2219       /* Look for the version.  If we find it, it is no longer weak.  */
2220       for (t = sinfo->info->version_info; t != NULL; t = t->next)
2221         {
2222           if (strcmp (t->name, p) == 0)
2223             {
2224               size_t len;
2225               char *alc;
2226               struct bfd_elf_version_expr *d;
2227
2228               len = p - h->root.root.string;
2229               alc = (char *) bfd_malloc (len);
2230               if (alc == NULL)
2231                 {
2232                   sinfo->failed = TRUE;
2233                   return FALSE;
2234                 }
2235               memcpy (alc, h->root.root.string, len - 1);
2236               alc[len - 1] = '\0';
2237               if (alc[len - 2] == ELF_VER_CHR)
2238                 alc[len - 2] = '\0';
2239
2240               h->verinfo.vertree = t;
2241               t->used = TRUE;
2242               d = NULL;
2243
2244               if (t->globals.list != NULL)
2245                 d = (*t->match) (&t->globals, NULL, alc);
2246
2247               /* See if there is anything to force this symbol to
2248                  local scope.  */
2249               if (d == NULL && t->locals.list != NULL)
2250                 {
2251                   d = (*t->match) (&t->locals, NULL, alc);
2252                   if (d != NULL
2253                       && h->dynindx != -1
2254                       && ! info->export_dynamic)
2255                     (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2256                 }
2257
2258               free (alc);
2259               break;
2260             }
2261         }
2262
2263       /* If we are building an application, we need to create a
2264          version node for this version.  */
2265       if (t == NULL && bfd_link_executable (info))
2266         {
2267           struct bfd_elf_version_tree **pp;
2268           int version_index;
2269
2270           /* If we aren't going to export this symbol, we don't need
2271              to worry about it.  */
2272           if (h->dynindx == -1)
2273             return TRUE;
2274
2275           t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd,
2276                                                           sizeof *t);
2277           if (t == NULL)
2278             {
2279               sinfo->failed = TRUE;
2280               return FALSE;
2281             }
2282
2283           t->name = p;
2284           t->name_indx = (unsigned int) -1;
2285           t->used = TRUE;
2286
2287           version_index = 1;
2288           /* Don't count anonymous version tag.  */
2289           if (sinfo->info->version_info != NULL
2290               && sinfo->info->version_info->vernum == 0)
2291             version_index = 0;
2292           for (pp = &sinfo->info->version_info;
2293                *pp != NULL;
2294                pp = &(*pp)->next)
2295             ++version_index;
2296           t->vernum = version_index;
2297
2298           *pp = t;
2299
2300           h->verinfo.vertree = t;
2301         }
2302       else if (t == NULL)
2303         {
2304           /* We could not find the version for a symbol when
2305              generating a shared archive.  Return an error.  */
2306           _bfd_error_handler
2307             /* xgettext:c-format */
2308             (_("%B: version node not found for symbol %s"),
2309              info->output_bfd, h->root.root.string);
2310           bfd_set_error (bfd_error_bad_value);
2311           sinfo->failed = TRUE;
2312           return FALSE;
2313         }
2314     }
2315
2316   /* If we don't have a version for this symbol, see if we can find
2317      something.  */
2318   if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2319     {
2320       bfd_boolean hide;
2321
2322       h->verinfo.vertree
2323         = bfd_find_version_for_sym (sinfo->info->version_info,
2324                                     h->root.root.string, &hide);
2325       if (h->verinfo.vertree != NULL && hide)
2326         (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2327     }
2328
2329   return TRUE;
2330 }
2331 \f
2332 /* Read and swap the relocs from the section indicated by SHDR.  This
2333    may be either a REL or a RELA section.  The relocations are
2334    translated into RELA relocations and stored in INTERNAL_RELOCS,
2335    which should have already been allocated to contain enough space.
2336    The EXTERNAL_RELOCS are a buffer where the external form of the
2337    relocations should be stored.
2338
2339    Returns FALSE if something goes wrong.  */
2340
2341 static bfd_boolean
2342 elf_link_read_relocs_from_section (bfd *abfd,
2343                                    asection *sec,
2344                                    Elf_Internal_Shdr *shdr,
2345                                    void *external_relocs,
2346                                    Elf_Internal_Rela *internal_relocs)
2347 {
2348   const struct elf_backend_data *bed;
2349   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2350   const bfd_byte *erela;
2351   const bfd_byte *erelaend;
2352   Elf_Internal_Rela *irela;
2353   Elf_Internal_Shdr *symtab_hdr;
2354   size_t nsyms;
2355
2356   /* Position ourselves at the start of the section.  */
2357   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2358     return FALSE;
2359
2360   /* Read the relocations.  */
2361   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2362     return FALSE;
2363
2364   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2365   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2366
2367   bed = get_elf_backend_data (abfd);
2368
2369   /* Convert the external relocations to the internal format.  */
2370   if (shdr->sh_entsize == bed->s->sizeof_rel)
2371     swap_in = bed->s->swap_reloc_in;
2372   else if (shdr->sh_entsize == bed->s->sizeof_rela)
2373     swap_in = bed->s->swap_reloca_in;
2374   else
2375     {
2376       bfd_set_error (bfd_error_wrong_format);
2377       return FALSE;
2378     }
2379
2380   erela = (const bfd_byte *) external_relocs;
2381   erelaend = erela + shdr->sh_size;
2382   irela = internal_relocs;
2383   while (erela < erelaend)
2384     {
2385       bfd_vma r_symndx;
2386
2387       (*swap_in) (abfd, erela, irela);
2388       r_symndx = ELF32_R_SYM (irela->r_info);
2389       if (bed->s->arch_size == 64)
2390         r_symndx >>= 24;
2391       if (nsyms > 0)
2392         {
2393           if ((size_t) r_symndx >= nsyms)
2394             {
2395               _bfd_error_handler
2396                 /* xgettext:c-format */
2397                 (_("%B: bad reloc symbol index (%#Lx >= %#lx)"
2398                    " for offset %#Lx in section `%A'"),
2399                  abfd, r_symndx, (unsigned long) nsyms,
2400                  irela->r_offset, sec);
2401               bfd_set_error (bfd_error_bad_value);
2402               return FALSE;
2403             }
2404         }
2405       else if (r_symndx != STN_UNDEF)
2406         {
2407           _bfd_error_handler
2408             /* xgettext:c-format */
2409             (_("%B: non-zero symbol index (%#Lx)"
2410                " for offset %#Lx in section `%A'"
2411                " when the object file has no symbol table"),
2412              abfd, r_symndx,
2413              irela->r_offset, sec);
2414           bfd_set_error (bfd_error_bad_value);
2415           return FALSE;
2416         }
2417       irela += bed->s->int_rels_per_ext_rel;
2418       erela += shdr->sh_entsize;
2419     }
2420
2421   return TRUE;
2422 }
2423
2424 /* Read and swap the relocs for a section O.  They may have been
2425    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2426    not NULL, they are used as buffers to read into.  They are known to
2427    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2428    the return value is allocated using either malloc or bfd_alloc,
2429    according to the KEEP_MEMORY argument.  If O has two relocation
2430    sections (both REL and RELA relocations), then the REL_HDR
2431    relocations will appear first in INTERNAL_RELOCS, followed by the
2432    RELA_HDR relocations.  */
2433
2434 Elf_Internal_Rela *
2435 _bfd_elf_link_read_relocs (bfd *abfd,
2436                            asection *o,
2437                            void *external_relocs,
2438                            Elf_Internal_Rela *internal_relocs,
2439                            bfd_boolean keep_memory)
2440 {
2441   void *alloc1 = NULL;
2442   Elf_Internal_Rela *alloc2 = NULL;
2443   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2444   struct bfd_elf_section_data *esdo = elf_section_data (o);
2445   Elf_Internal_Rela *internal_rela_relocs;
2446
2447   if (esdo->relocs != NULL)
2448     return esdo->relocs;
2449
2450   if (o->reloc_count == 0)
2451     return NULL;
2452
2453   if (internal_relocs == NULL)
2454     {
2455       bfd_size_type size;
2456
2457       size = (bfd_size_type) o->reloc_count * sizeof (Elf_Internal_Rela);
2458       if (keep_memory)
2459         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2460       else
2461         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2462       if (internal_relocs == NULL)
2463         goto error_return;
2464     }
2465
2466   if (external_relocs == NULL)
2467     {
2468       bfd_size_type size = 0;
2469
2470       if (esdo->rel.hdr)
2471         size += esdo->rel.hdr->sh_size;
2472       if (esdo->rela.hdr)
2473         size += esdo->rela.hdr->sh_size;
2474
2475       alloc1 = bfd_malloc (size);
2476       if (alloc1 == NULL)
2477         goto error_return;
2478       external_relocs = alloc1;
2479     }
2480
2481   internal_rela_relocs = internal_relocs;
2482   if (esdo->rel.hdr)
2483     {
2484       if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2485                                               external_relocs,
2486                                               internal_relocs))
2487         goto error_return;
2488       external_relocs = (((bfd_byte *) external_relocs)
2489                          + esdo->rel.hdr->sh_size);
2490       internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2491                                * bed->s->int_rels_per_ext_rel);
2492     }
2493
2494   if (esdo->rela.hdr
2495       && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2496                                               external_relocs,
2497                                               internal_rela_relocs)))
2498     goto error_return;
2499
2500   /* Cache the results for next time, if we can.  */
2501   if (keep_memory)
2502     esdo->relocs = internal_relocs;
2503
2504   if (alloc1 != NULL)
2505     free (alloc1);
2506
2507   /* Don't free alloc2, since if it was allocated we are passing it
2508      back (under the name of internal_relocs).  */
2509
2510   return internal_relocs;
2511
2512  error_return:
2513   if (alloc1 != NULL)
2514     free (alloc1);
2515   if (alloc2 != NULL)
2516     {
2517       if (keep_memory)
2518         bfd_release (abfd, alloc2);
2519       else
2520         free (alloc2);
2521     }
2522   return NULL;
2523 }
2524
2525 /* Compute the size of, and allocate space for, REL_HDR which is the
2526    section header for a section containing relocations for O.  */
2527
2528 static bfd_boolean
2529 _bfd_elf_link_size_reloc_section (bfd *abfd,
2530                                   struct bfd_elf_section_reloc_data *reldata)
2531 {
2532   Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2533
2534   /* That allows us to calculate the size of the section.  */
2535   rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2536
2537   /* The contents field must last into write_object_contents, so we
2538      allocate it with bfd_alloc rather than malloc.  Also since we
2539      cannot be sure that the contents will actually be filled in,
2540      we zero the allocated space.  */
2541   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2542   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2543     return FALSE;
2544
2545   if (reldata->hashes == NULL && reldata->count)
2546     {
2547       struct elf_link_hash_entry **p;
2548
2549       p = ((struct elf_link_hash_entry **)
2550            bfd_zmalloc (reldata->count * sizeof (*p)));
2551       if (p == NULL)
2552         return FALSE;
2553
2554       reldata->hashes = p;
2555     }
2556
2557   return TRUE;
2558 }
2559
2560 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2561    originated from the section given by INPUT_REL_HDR) to the
2562    OUTPUT_BFD.  */
2563
2564 bfd_boolean
2565 _bfd_elf_link_output_relocs (bfd *output_bfd,
2566                              asection *input_section,
2567                              Elf_Internal_Shdr *input_rel_hdr,
2568                              Elf_Internal_Rela *internal_relocs,
2569                              struct elf_link_hash_entry **rel_hash
2570                                ATTRIBUTE_UNUSED)
2571 {
2572   Elf_Internal_Rela *irela;
2573   Elf_Internal_Rela *irelaend;
2574   bfd_byte *erel;
2575   struct bfd_elf_section_reloc_data *output_reldata;
2576   asection *output_section;
2577   const struct elf_backend_data *bed;
2578   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2579   struct bfd_elf_section_data *esdo;
2580
2581   output_section = input_section->output_section;
2582
2583   bed = get_elf_backend_data (output_bfd);
2584   esdo = elf_section_data (output_section);
2585   if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2586     {
2587       output_reldata = &esdo->rel;
2588       swap_out = bed->s->swap_reloc_out;
2589     }
2590   else if (esdo->rela.hdr
2591            && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2592     {
2593       output_reldata = &esdo->rela;
2594       swap_out = bed->s->swap_reloca_out;
2595     }
2596   else
2597     {
2598       _bfd_error_handler
2599         /* xgettext:c-format */
2600         (_("%B: relocation size mismatch in %B section %A"),
2601          output_bfd, input_section->owner, input_section);
2602       bfd_set_error (bfd_error_wrong_format);
2603       return FALSE;
2604     }
2605
2606   erel = output_reldata->hdr->contents;
2607   erel += output_reldata->count * input_rel_hdr->sh_entsize;
2608   irela = internal_relocs;
2609   irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2610                       * bed->s->int_rels_per_ext_rel);
2611   while (irela < irelaend)
2612     {
2613       (*swap_out) (output_bfd, irela, erel);
2614       irela += bed->s->int_rels_per_ext_rel;
2615       erel += input_rel_hdr->sh_entsize;
2616     }
2617
2618   /* Bump the counter, so that we know where to add the next set of
2619      relocations.  */
2620   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2621
2622   return TRUE;
2623 }
2624 \f
2625 /* Make weak undefined symbols in PIE dynamic.  */
2626
2627 bfd_boolean
2628 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2629                                  struct elf_link_hash_entry *h)
2630 {
2631   if (bfd_link_pie (info)
2632       && h->dynindx == -1
2633       && h->root.type == bfd_link_hash_undefweak)
2634     return bfd_elf_link_record_dynamic_symbol (info, h);
2635
2636   return TRUE;
2637 }
2638
2639 /* Fix up the flags for a symbol.  This handles various cases which
2640    can only be fixed after all the input files are seen.  This is
2641    currently called by both adjust_dynamic_symbol and
2642    assign_sym_version, which is unnecessary but perhaps more robust in
2643    the face of future changes.  */
2644
2645 static bfd_boolean
2646 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2647                            struct elf_info_failed *eif)
2648 {
2649   const struct elf_backend_data *bed;
2650
2651   /* If this symbol was mentioned in a non-ELF file, try to set
2652      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2653      permit a non-ELF file to correctly refer to a symbol defined in
2654      an ELF dynamic object.  */
2655   if (h->non_elf)
2656     {
2657       while (h->root.type == bfd_link_hash_indirect)
2658         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2659
2660       if (h->root.type != bfd_link_hash_defined
2661           && h->root.type != bfd_link_hash_defweak)
2662         {
2663           h->ref_regular = 1;
2664           h->ref_regular_nonweak = 1;
2665         }
2666       else
2667         {
2668           if (h->root.u.def.section->owner != NULL
2669               && (bfd_get_flavour (h->root.u.def.section->owner)
2670                   == bfd_target_elf_flavour))
2671             {
2672               h->ref_regular = 1;
2673               h->ref_regular_nonweak = 1;
2674             }
2675           else
2676             h->def_regular = 1;
2677         }
2678
2679       if (h->dynindx == -1
2680           && (h->def_dynamic
2681               || h->ref_dynamic))
2682         {
2683           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2684             {
2685               eif->failed = TRUE;
2686               return FALSE;
2687             }
2688         }
2689     }
2690   else
2691     {
2692       /* Unfortunately, NON_ELF is only correct if the symbol
2693          was first seen in a non-ELF file.  Fortunately, if the symbol
2694          was first seen in an ELF file, we're probably OK unless the
2695          symbol was defined in a non-ELF file.  Catch that case here.
2696          FIXME: We're still in trouble if the symbol was first seen in
2697          a dynamic object, and then later in a non-ELF regular object.  */
2698       if ((h->root.type == bfd_link_hash_defined
2699            || h->root.type == bfd_link_hash_defweak)
2700           && !h->def_regular
2701           && (h->root.u.def.section->owner != NULL
2702               ? (bfd_get_flavour (h->root.u.def.section->owner)
2703                  != bfd_target_elf_flavour)
2704               : (bfd_is_abs_section (h->root.u.def.section)
2705                  && !h->def_dynamic)))
2706         h->def_regular = 1;
2707     }
2708
2709   /* Backend specific symbol fixup.  */
2710   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2711   if (bed->elf_backend_fixup_symbol
2712       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2713     return FALSE;
2714
2715   /* If this is a final link, and the symbol was defined as a common
2716      symbol in a regular object file, and there was no definition in
2717      any dynamic object, then the linker will have allocated space for
2718      the symbol in a common section but the DEF_REGULAR
2719      flag will not have been set.  */
2720   if (h->root.type == bfd_link_hash_defined
2721       && !h->def_regular
2722       && h->ref_regular
2723       && !h->def_dynamic
2724       && (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0)
2725     h->def_regular = 1;
2726
2727   /* If a weak undefined symbol has non-default visibility, we also
2728      hide it from the dynamic linker.  */
2729   if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2730       && h->root.type == bfd_link_hash_undefweak)
2731     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2732
2733   /* A hidden versioned symbol in executable should be forced local if
2734      it is is locally defined, not referenced by shared library and not
2735      exported.  */
2736   else if (bfd_link_executable (eif->info)
2737            && h->versioned == versioned_hidden
2738            && !eif->info->export_dynamic
2739            && !h->dynamic
2740            && !h->ref_dynamic
2741            && h->def_regular)
2742     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2743
2744   /* If -Bsymbolic was used (which means to bind references to global
2745      symbols to the definition within the shared object), and this
2746      symbol was defined in a regular object, then it actually doesn't
2747      need a PLT entry.  Likewise, if the symbol has non-default
2748      visibility.  If the symbol has hidden or internal visibility, we
2749      will force it local.  */
2750   else if (h->needs_plt
2751            && bfd_link_pic (eif->info)
2752            && is_elf_hash_table (eif->info->hash)
2753            && (SYMBOLIC_BIND (eif->info, h)
2754                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2755            && h->def_regular)
2756     {
2757       bfd_boolean force_local;
2758
2759       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2760                      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2761       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2762     }
2763
2764   /* If this is a weak defined symbol in a dynamic object, and we know
2765      the real definition in the dynamic object, copy interesting flags
2766      over to the real definition.  */
2767   if (h->u.weakdef != NULL)
2768     {
2769       /* If the real definition is defined by a regular object file,
2770          don't do anything special.  See the longer description in
2771          _bfd_elf_adjust_dynamic_symbol, below.  */
2772       if (h->u.weakdef->def_regular)
2773         h->u.weakdef = NULL;
2774       else
2775         {
2776           struct elf_link_hash_entry *weakdef = h->u.weakdef;
2777
2778           while (h->root.type == bfd_link_hash_indirect)
2779             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2780
2781           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2782                       || h->root.type == bfd_link_hash_defweak);
2783           BFD_ASSERT (weakdef->def_dynamic);
2784           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2785                       || weakdef->root.type == bfd_link_hash_defweak);
2786           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2787         }
2788     }
2789
2790   return TRUE;
2791 }
2792
2793 /* Make the backend pick a good value for a dynamic symbol.  This is
2794    called via elf_link_hash_traverse, and also calls itself
2795    recursively.  */
2796
2797 static bfd_boolean
2798 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2799 {
2800   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2801   bfd *dynobj;
2802   const struct elf_backend_data *bed;
2803
2804   if (! is_elf_hash_table (eif->info->hash))
2805     return FALSE;
2806
2807   /* Ignore indirect symbols.  These are added by the versioning code.  */
2808   if (h->root.type == bfd_link_hash_indirect)
2809     return TRUE;
2810
2811   /* Fix the symbol flags.  */
2812   if (! _bfd_elf_fix_symbol_flags (h, eif))
2813     return FALSE;
2814
2815   if (h->root.type == bfd_link_hash_undefweak)
2816     {
2817       if (eif->info->dynamic_undefined_weak == 0)
2818         _bfd_elf_link_hash_hide_symbol (eif->info, h, TRUE);
2819       else if (eif->info->dynamic_undefined_weak > 0
2820                && h->ref_regular
2821                && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2822                && !bfd_hide_sym_by_version (eif->info->version_info,
2823                                             h->root.root.string))
2824         {
2825           if (!bfd_elf_link_record_dynamic_symbol (eif->info, h))
2826             {
2827               eif->failed = TRUE;
2828               return FALSE;
2829             }
2830         }
2831     }
2832
2833   /* If this symbol does not require a PLT entry, and it is not
2834      defined by a dynamic object, or is not referenced by a regular
2835      object, ignore it.  We do have to handle a weak defined symbol,
2836      even if no regular object refers to it, if we decided to add it
2837      to the dynamic symbol table.  FIXME: Do we normally need to worry
2838      about symbols which are defined by one dynamic object and
2839      referenced by another one?  */
2840   if (!h->needs_plt
2841       && h->type != STT_GNU_IFUNC
2842       && (h->def_regular
2843           || !h->def_dynamic
2844           || (!h->ref_regular
2845               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2846     {
2847       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2848       return TRUE;
2849     }
2850
2851   /* If we've already adjusted this symbol, don't do it again.  This
2852      can happen via a recursive call.  */
2853   if (h->dynamic_adjusted)
2854     return TRUE;
2855
2856   /* Don't look at this symbol again.  Note that we must set this
2857      after checking the above conditions, because we may look at a
2858      symbol once, decide not to do anything, and then get called
2859      recursively later after REF_REGULAR is set below.  */
2860   h->dynamic_adjusted = 1;
2861
2862   /* If this is a weak definition, and we know a real definition, and
2863      the real symbol is not itself defined by a regular object file,
2864      then get a good value for the real definition.  We handle the
2865      real symbol first, for the convenience of the backend routine.
2866
2867      Note that there is a confusing case here.  If the real definition
2868      is defined by a regular object file, we don't get the real symbol
2869      from the dynamic object, but we do get the weak symbol.  If the
2870      processor backend uses a COPY reloc, then if some routine in the
2871      dynamic object changes the real symbol, we will not see that
2872      change in the corresponding weak symbol.  This is the way other
2873      ELF linkers work as well, and seems to be a result of the shared
2874      library model.
2875
2876      I will clarify this issue.  Most SVR4 shared libraries define the
2877      variable _timezone and define timezone as a weak synonym.  The
2878      tzset call changes _timezone.  If you write
2879        extern int timezone;
2880        int _timezone = 5;
2881        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2882      you might expect that, since timezone is a synonym for _timezone,
2883      the same number will print both times.  However, if the processor
2884      backend uses a COPY reloc, then actually timezone will be copied
2885      into your process image, and, since you define _timezone
2886      yourself, _timezone will not.  Thus timezone and _timezone will
2887      wind up at different memory locations.  The tzset call will set
2888      _timezone, leaving timezone unchanged.  */
2889
2890   if (h->u.weakdef != NULL)
2891     {
2892       /* If we get to this point, there is an implicit reference to
2893          H->U.WEAKDEF by a regular object file via the weak symbol H.  */
2894       h->u.weakdef->ref_regular = 1;
2895
2896       /* Ensure that the backend adjust_dynamic_symbol function sees
2897          H->U.WEAKDEF before H by recursively calling ourselves.  */
2898       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2899         return FALSE;
2900     }
2901
2902   /* If a symbol has no type and no size and does not require a PLT
2903      entry, then we are probably about to do the wrong thing here: we
2904      are probably going to create a COPY reloc for an empty object.
2905      This case can arise when a shared object is built with assembly
2906      code, and the assembly code fails to set the symbol type.  */
2907   if (h->size == 0
2908       && h->type == STT_NOTYPE
2909       && !h->needs_plt)
2910     _bfd_error_handler
2911       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2912        h->root.root.string);
2913
2914   dynobj = elf_hash_table (eif->info)->dynobj;
2915   bed = get_elf_backend_data (dynobj);
2916
2917   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2918     {
2919       eif->failed = TRUE;
2920       return FALSE;
2921     }
2922
2923   return TRUE;
2924 }
2925
2926 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2927    DYNBSS.  */
2928
2929 bfd_boolean
2930 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
2931                               struct elf_link_hash_entry *h,
2932                               asection *dynbss)
2933 {
2934   unsigned int power_of_two;
2935   bfd_vma mask;
2936   asection *sec = h->root.u.def.section;
2937
2938   /* The section alignment of the definition is the maximum alignment
2939      requirement of symbols defined in the section.  Since we don't
2940      know the symbol alignment requirement, we start with the
2941      maximum alignment and check low bits of the symbol address
2942      for the minimum alignment.  */
2943   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2944   mask = ((bfd_vma) 1 << power_of_two) - 1;
2945   while ((h->root.u.def.value & mask) != 0)
2946     {
2947        mask >>= 1;
2948        --power_of_two;
2949     }
2950
2951   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2952                                                 dynbss))
2953     {
2954       /* Adjust the section alignment if needed.  */
2955       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2956                                        power_of_two))
2957         return FALSE;
2958     }
2959
2960   /* We make sure that the symbol will be aligned properly.  */
2961   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2962
2963   /* Define the symbol as being at this point in DYNBSS.  */
2964   h->root.u.def.section = dynbss;
2965   h->root.u.def.value = dynbss->size;
2966
2967   /* Increment the size of DYNBSS to make room for the symbol.  */
2968   dynbss->size += h->size;
2969
2970   /* No error if extern_protected_data is true.  */
2971   if (h->protected_def
2972       && (!info->extern_protected_data
2973           || (info->extern_protected_data < 0
2974               && !get_elf_backend_data (dynbss->owner)->extern_protected_data)))
2975     info->callbacks->einfo
2976       (_("%P: copy reloc against protected `%T' is dangerous\n"),
2977        h->root.root.string);
2978
2979   return TRUE;
2980 }
2981
2982 /* Adjust all external symbols pointing into SEC_MERGE sections
2983    to reflect the object merging within the sections.  */
2984
2985 static bfd_boolean
2986 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2987 {
2988   asection *sec;
2989
2990   if ((h->root.type == bfd_link_hash_defined
2991        || h->root.type == bfd_link_hash_defweak)
2992       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2993       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
2994     {
2995       bfd *output_bfd = (bfd *) data;
2996
2997       h->root.u.def.value =
2998         _bfd_merged_section_offset (output_bfd,
2999                                     &h->root.u.def.section,
3000                                     elf_section_data (sec)->sec_info,
3001                                     h->root.u.def.value);
3002     }
3003
3004   return TRUE;
3005 }
3006
3007 /* Returns false if the symbol referred to by H should be considered
3008    to resolve local to the current module, and true if it should be
3009    considered to bind dynamically.  */
3010
3011 bfd_boolean
3012 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
3013                            struct bfd_link_info *info,
3014                            bfd_boolean not_local_protected)
3015 {
3016   bfd_boolean binding_stays_local_p;
3017   const struct elf_backend_data *bed;
3018   struct elf_link_hash_table *hash_table;
3019
3020   if (h == NULL)
3021     return FALSE;
3022
3023   while (h->root.type == bfd_link_hash_indirect
3024          || h->root.type == bfd_link_hash_warning)
3025     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3026
3027   /* If it was forced local, then clearly it's not dynamic.  */
3028   if (h->dynindx == -1)
3029     return FALSE;
3030   if (h->forced_local)
3031     return FALSE;
3032
3033   /* Identify the cases where name binding rules say that a
3034      visible symbol resolves locally.  */
3035   binding_stays_local_p = (bfd_link_executable (info)
3036                            || SYMBOLIC_BIND (info, h));
3037
3038   switch (ELF_ST_VISIBILITY (h->other))
3039     {
3040     case STV_INTERNAL:
3041     case STV_HIDDEN:
3042       return FALSE;
3043
3044     case STV_PROTECTED:
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
3051       /* Proper resolution for function pointer equality may require
3052          that these symbols perhaps be resolved dynamically, even though
3053          we should be resolving them to the current module.  */
3054       if (!not_local_protected || !bed->is_function_type (h->type))
3055         binding_stays_local_p = TRUE;
3056       break;
3057
3058     default:
3059       break;
3060     }
3061
3062   /* If it isn't defined locally, then clearly it's dynamic.  */
3063   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
3064     return TRUE;
3065
3066   /* Otherwise, the symbol is dynamic if binding rules don't tell
3067      us that it remains local.  */
3068   return !binding_stays_local_p;
3069 }
3070
3071 /* Return true if the symbol referred to by H should be considered
3072    to resolve local to the current module, and false otherwise.  Differs
3073    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
3074    undefined symbols.  The two functions are virtually identical except
3075    for the place where dynindx == -1 is tested.  If that test is true,
3076    _bfd_elf_dynamic_symbol_p will say the symbol is local, while
3077    _bfd_elf_symbol_refs_local_p will say the symbol is local only for
3078    defined symbols.
3079    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
3080    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
3081    treatment of undefined weak symbols.  For those that do not make
3082    undefined weak symbols dynamic, both functions may return false.  */
3083
3084 bfd_boolean
3085 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
3086                               struct bfd_link_info *info,
3087                               bfd_boolean local_protected)
3088 {
3089   const struct elf_backend_data *bed;
3090   struct elf_link_hash_table *hash_table;
3091
3092   /* If it's a local sym, of course we resolve locally.  */
3093   if (h == NULL)
3094     return TRUE;
3095
3096   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
3097   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
3098       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
3099     return TRUE;
3100
3101   /* Forced local symbols resolve locally.  */
3102   if (h->forced_local)
3103     return TRUE;
3104
3105   /* Common symbols that become definitions don't get the DEF_REGULAR
3106      flag set, so test it first, and don't bail out.  */
3107   if (ELF_COMMON_DEF_P (h))
3108     /* Do nothing.  */;
3109   /* If we don't have a definition in a regular file, then we can't
3110      resolve locally.  The sym is either undefined or dynamic.  */
3111   else if (!h->def_regular)
3112     return FALSE;
3113
3114   /* Non-dynamic symbols resolve locally.  */
3115   if (h->dynindx == -1)
3116     return TRUE;
3117
3118   /* At this point, we know the symbol is defined and dynamic.  In an
3119      executable it must resolve locally, likewise when building symbolic
3120      shared libraries.  */
3121   if (bfd_link_executable (info) || SYMBOLIC_BIND (info, h))
3122     return TRUE;
3123
3124   /* Now deal with defined dynamic symbols in shared libraries.  Ones
3125      with default visibility might not resolve locally.  */
3126   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3127     return FALSE;
3128
3129   hash_table = elf_hash_table (info);
3130   if (!is_elf_hash_table (hash_table))
3131     return TRUE;
3132
3133   bed = get_elf_backend_data (hash_table->dynobj);
3134
3135   /* If extern_protected_data is false, STV_PROTECTED non-function
3136      symbols are local.  */
3137   if ((!info->extern_protected_data
3138        || (info->extern_protected_data < 0
3139            && !bed->extern_protected_data))
3140       && !bed->is_function_type (h->type))
3141     return TRUE;
3142
3143   /* Function pointer equality tests may require that STV_PROTECTED
3144      symbols be treated as dynamic symbols.  If the address of a
3145      function not defined in an executable is set to that function's
3146      plt entry in the executable, then the address of the function in
3147      a shared library must also be the plt entry in the executable.  */
3148   return local_protected;
3149 }
3150
3151 /* Caches some TLS segment info, and ensures that the TLS segment vma is
3152    aligned.  Returns the first TLS output section.  */
3153
3154 struct bfd_section *
3155 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
3156 {
3157   struct bfd_section *sec, *tls;
3158   unsigned int align = 0;
3159
3160   for (sec = obfd->sections; sec != NULL; sec = sec->next)
3161     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
3162       break;
3163   tls = sec;
3164
3165   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
3166     if (sec->alignment_power > align)
3167       align = sec->alignment_power;
3168
3169   elf_hash_table (info)->tls_sec = tls;
3170
3171   /* Ensure the alignment of the first section is the largest alignment,
3172      so that the tls segment starts aligned.  */
3173   if (tls != NULL)
3174     tls->alignment_power = align;
3175
3176   return tls;
3177 }
3178
3179 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
3180 static bfd_boolean
3181 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
3182                                   Elf_Internal_Sym *sym)
3183 {
3184   const struct elf_backend_data *bed;
3185
3186   /* Local symbols do not count, but target specific ones might.  */
3187   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
3188       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
3189     return FALSE;
3190
3191   bed = get_elf_backend_data (abfd);
3192   /* Function symbols do not count.  */
3193   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
3194     return FALSE;
3195
3196   /* If the section is undefined, then so is the symbol.  */
3197   if (sym->st_shndx == SHN_UNDEF)
3198     return FALSE;
3199
3200   /* If the symbol is defined in the common section, then
3201      it is a common definition and so does not count.  */
3202   if (bed->common_definition (sym))
3203     return FALSE;
3204
3205   /* If the symbol is in a target specific section then we
3206      must rely upon the backend to tell us what it is.  */
3207   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
3208     /* FIXME - this function is not coded yet:
3209
3210        return _bfd_is_global_symbol_definition (abfd, sym);
3211
3212        Instead for now assume that the definition is not global,
3213        Even if this is wrong, at least the linker will behave
3214        in the same way that it used to do.  */
3215     return FALSE;
3216
3217   return TRUE;
3218 }
3219
3220 /* Search the symbol table of the archive element of the archive ABFD
3221    whose archive map contains a mention of SYMDEF, and determine if
3222    the symbol is defined in this element.  */
3223 static bfd_boolean
3224 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
3225 {
3226   Elf_Internal_Shdr * hdr;
3227   size_t symcount;
3228   size_t extsymcount;
3229   size_t extsymoff;
3230   Elf_Internal_Sym *isymbuf;
3231   Elf_Internal_Sym *isym;
3232   Elf_Internal_Sym *isymend;
3233   bfd_boolean result;
3234
3235   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
3236   if (abfd == NULL)
3237     return FALSE;
3238
3239   if (! bfd_check_format (abfd, bfd_object))
3240     return FALSE;
3241
3242   /* Select the appropriate symbol table.  If we don't know if the
3243      object file is an IR object, give linker LTO plugin a chance to
3244      get the correct symbol table.  */
3245   if (abfd->plugin_format == bfd_plugin_yes
3246 #if BFD_SUPPORTS_PLUGINS
3247       || (abfd->plugin_format == bfd_plugin_unknown
3248           && bfd_link_plugin_object_p (abfd))
3249 #endif
3250       )
3251     {
3252       /* Use the IR symbol table if the object has been claimed by
3253          plugin.  */
3254       abfd = abfd->plugin_dummy_bfd;
3255       hdr = &elf_tdata (abfd)->symtab_hdr;
3256     }
3257   else if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
3258     hdr = &elf_tdata (abfd)->symtab_hdr;
3259   else
3260     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3261
3262   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3263
3264   /* The sh_info field of the symtab header tells us where the
3265      external symbols start.  We don't care about the local symbols.  */
3266   if (elf_bad_symtab (abfd))
3267     {
3268       extsymcount = symcount;
3269       extsymoff = 0;
3270     }
3271   else
3272     {
3273       extsymcount = symcount - hdr->sh_info;
3274       extsymoff = hdr->sh_info;
3275     }
3276
3277   if (extsymcount == 0)
3278     return FALSE;
3279
3280   /* Read in the symbol table.  */
3281   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3282                                   NULL, NULL, NULL);
3283   if (isymbuf == NULL)
3284     return FALSE;
3285
3286   /* Scan the symbol table looking for SYMDEF.  */
3287   result = FALSE;
3288   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
3289     {
3290       const char *name;
3291
3292       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3293                                               isym->st_name);
3294       if (name == NULL)
3295         break;
3296
3297       if (strcmp (name, symdef->name) == 0)
3298         {
3299           result = is_global_data_symbol_definition (abfd, isym);
3300           break;
3301         }
3302     }
3303
3304   free (isymbuf);
3305
3306   return result;
3307 }
3308 \f
3309 /* Add an entry to the .dynamic table.  */
3310
3311 bfd_boolean
3312 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3313                             bfd_vma tag,
3314                             bfd_vma val)
3315 {
3316   struct elf_link_hash_table *hash_table;
3317   const struct elf_backend_data *bed;
3318   asection *s;
3319   bfd_size_type newsize;
3320   bfd_byte *newcontents;
3321   Elf_Internal_Dyn dyn;
3322
3323   hash_table = elf_hash_table (info);
3324   if (! is_elf_hash_table (hash_table))
3325     return FALSE;
3326
3327   bed = get_elf_backend_data (hash_table->dynobj);
3328   s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3329   BFD_ASSERT (s != NULL);
3330
3331   newsize = s->size + bed->s->sizeof_dyn;
3332   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3333   if (newcontents == NULL)
3334     return FALSE;
3335
3336   dyn.d_tag = tag;
3337   dyn.d_un.d_val = val;
3338   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3339
3340   s->size = newsize;
3341   s->contents = newcontents;
3342
3343   return TRUE;
3344 }
3345
3346 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3347    otherwise just check whether one already exists.  Returns -1 on error,
3348    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3349
3350 static int
3351 elf_add_dt_needed_tag (bfd *abfd,
3352                        struct bfd_link_info *info,
3353                        const char *soname,
3354                        bfd_boolean do_it)
3355 {
3356   struct elf_link_hash_table *hash_table;
3357   size_t strindex;
3358
3359   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3360     return -1;
3361
3362   hash_table = elf_hash_table (info);
3363   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3364   if (strindex == (size_t) -1)
3365     return -1;
3366
3367   if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
3368     {
3369       asection *sdyn;
3370       const struct elf_backend_data *bed;
3371       bfd_byte *extdyn;
3372
3373       bed = get_elf_backend_data (hash_table->dynobj);
3374       sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3375       if (sdyn != NULL)
3376         for (extdyn = sdyn->contents;
3377              extdyn < sdyn->contents + sdyn->size;
3378              extdyn += bed->s->sizeof_dyn)
3379           {
3380             Elf_Internal_Dyn dyn;
3381
3382             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3383             if (dyn.d_tag == DT_NEEDED
3384                 && dyn.d_un.d_val == strindex)
3385               {
3386                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3387                 return 1;
3388               }
3389           }
3390     }
3391
3392   if (do_it)
3393     {
3394       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3395         return -1;
3396
3397       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3398         return -1;
3399     }
3400   else
3401     /* We were just checking for existence of the tag.  */
3402     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3403
3404   return 0;
3405 }
3406
3407 /* Return true if SONAME is on the needed list between NEEDED and STOP
3408    (or the end of list if STOP is NULL), and needed by a library that
3409    will be loaded.  */
3410
3411 static bfd_boolean
3412 on_needed_list (const char *soname,
3413                 struct bfd_link_needed_list *needed,
3414                 struct bfd_link_needed_list *stop)
3415 {
3416   struct bfd_link_needed_list *look;
3417   for (look = needed; look != stop; look = look->next)
3418     if (strcmp (soname, look->name) == 0
3419         && ((elf_dyn_lib_class (look->by) & DYN_AS_NEEDED) == 0
3420             /* If needed by a library that itself is not directly
3421                needed, recursively check whether that library is
3422                indirectly needed.  Since we add DT_NEEDED entries to
3423                the end of the list, library dependencies appear after
3424                the library.  Therefore search prior to the current
3425                LOOK, preventing possible infinite recursion.  */
3426             || on_needed_list (elf_dt_name (look->by), needed, look)))
3427       return TRUE;
3428
3429   return FALSE;
3430 }
3431
3432 /* Sort symbol by value, section, and size.  */
3433 static int
3434 elf_sort_symbol (const void *arg1, const void *arg2)
3435 {
3436   const struct elf_link_hash_entry *h1;
3437   const struct elf_link_hash_entry *h2;
3438   bfd_signed_vma vdiff;
3439
3440   h1 = *(const struct elf_link_hash_entry **) arg1;
3441   h2 = *(const struct elf_link_hash_entry **) arg2;
3442   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3443   if (vdiff != 0)
3444     return vdiff > 0 ? 1 : -1;
3445   else
3446     {
3447       int sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3448       if (sdiff != 0)
3449         return sdiff > 0 ? 1 : -1;
3450     }
3451   vdiff = h1->size - h2->size;
3452   return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
3453 }
3454
3455 /* This function is used to adjust offsets into .dynstr for
3456    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3457
3458 static bfd_boolean
3459 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3460 {
3461   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3462
3463   if (h->dynindx != -1)
3464     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3465   return TRUE;
3466 }
3467
3468 /* Assign string offsets in .dynstr, update all structures referencing
3469    them.  */
3470
3471 static bfd_boolean
3472 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3473 {
3474   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3475   struct elf_link_local_dynamic_entry *entry;
3476   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3477   bfd *dynobj = hash_table->dynobj;
3478   asection *sdyn;
3479   bfd_size_type size;
3480   const struct elf_backend_data *bed;
3481   bfd_byte *extdyn;
3482
3483   _bfd_elf_strtab_finalize (dynstr);
3484   size = _bfd_elf_strtab_size (dynstr);
3485
3486   bed = get_elf_backend_data (dynobj);
3487   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3488   BFD_ASSERT (sdyn != NULL);
3489
3490   /* Update all .dynamic entries referencing .dynstr strings.  */
3491   for (extdyn = sdyn->contents;
3492        extdyn < sdyn->contents + sdyn->size;
3493        extdyn += bed->s->sizeof_dyn)
3494     {
3495       Elf_Internal_Dyn dyn;
3496
3497       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3498       switch (dyn.d_tag)
3499         {
3500         case DT_STRSZ:
3501           dyn.d_un.d_val = size;
3502           break;
3503         case DT_NEEDED:
3504         case DT_SONAME:
3505         case DT_RPATH:
3506         case DT_RUNPATH:
3507         case DT_FILTER:
3508         case DT_AUXILIARY:
3509         case DT_AUDIT:
3510         case DT_DEPAUDIT:
3511           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3512           break;
3513         default:
3514           continue;
3515         }
3516       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3517     }
3518
3519   /* Now update local dynamic symbols.  */
3520   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3521     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3522                                                   entry->isym.st_name);
3523
3524   /* And the rest of dynamic symbols.  */
3525   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3526
3527   /* Adjust version definitions.  */
3528   if (elf_tdata (output_bfd)->cverdefs)
3529     {
3530       asection *s;
3531       bfd_byte *p;
3532       size_t i;
3533       Elf_Internal_Verdef def;
3534       Elf_Internal_Verdaux defaux;
3535
3536       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
3537       p = s->contents;
3538       do
3539         {
3540           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3541                                    &def);
3542           p += sizeof (Elf_External_Verdef);
3543           if (def.vd_aux != sizeof (Elf_External_Verdef))
3544             continue;
3545           for (i = 0; i < def.vd_cnt; ++i)
3546             {
3547               _bfd_elf_swap_verdaux_in (output_bfd,
3548                                         (Elf_External_Verdaux *) p, &defaux);
3549               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3550                                                         defaux.vda_name);
3551               _bfd_elf_swap_verdaux_out (output_bfd,
3552                                          &defaux, (Elf_External_Verdaux *) p);
3553               p += sizeof (Elf_External_Verdaux);
3554             }
3555         }
3556       while (def.vd_next);
3557     }
3558
3559   /* Adjust version references.  */
3560   if (elf_tdata (output_bfd)->verref)
3561     {
3562       asection *s;
3563       bfd_byte *p;
3564       size_t i;
3565       Elf_Internal_Verneed need;
3566       Elf_Internal_Vernaux needaux;
3567
3568       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
3569       p = s->contents;
3570       do
3571         {
3572           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3573                                     &need);
3574           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3575           _bfd_elf_swap_verneed_out (output_bfd, &need,
3576                                      (Elf_External_Verneed *) p);
3577           p += sizeof (Elf_External_Verneed);
3578           for (i = 0; i < need.vn_cnt; ++i)
3579             {
3580               _bfd_elf_swap_vernaux_in (output_bfd,
3581                                         (Elf_External_Vernaux *) p, &needaux);
3582               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3583                                                          needaux.vna_name);
3584               _bfd_elf_swap_vernaux_out (output_bfd,
3585                                          &needaux,
3586                                          (Elf_External_Vernaux *) p);
3587               p += sizeof (Elf_External_Vernaux);
3588             }
3589         }
3590       while (need.vn_next);
3591     }
3592
3593   return TRUE;
3594 }
3595 \f
3596 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3597    The default is to only match when the INPUT and OUTPUT are exactly
3598    the same target.  */
3599
3600 bfd_boolean
3601 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3602                                     const bfd_target *output)
3603 {
3604   return input == output;
3605 }
3606
3607 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3608    This version is used when different targets for the same architecture
3609    are virtually identical.  */
3610
3611 bfd_boolean
3612 _bfd_elf_relocs_compatible (const bfd_target *input,
3613                             const bfd_target *output)
3614 {
3615   const struct elf_backend_data *obed, *ibed;
3616
3617   if (input == output)
3618     return TRUE;
3619
3620   ibed = xvec_get_elf_backend_data (input);
3621   obed = xvec_get_elf_backend_data (output);
3622
3623   if (ibed->arch != obed->arch)
3624     return FALSE;
3625
3626   /* If both backends are using this function, deem them compatible.  */
3627   return ibed->relocs_compatible == obed->relocs_compatible;
3628 }
3629
3630 /* Make a special call to the linker "notice" function to tell it that
3631    we are about to handle an as-needed lib, or have finished
3632    processing the lib.  */
3633
3634 bfd_boolean
3635 _bfd_elf_notice_as_needed (bfd *ibfd,
3636                            struct bfd_link_info *info,
3637                            enum notice_asneeded_action act)
3638 {
3639   return (*info->callbacks->notice) (info, NULL, NULL, ibfd, NULL, act, 0);
3640 }
3641
3642 /* Check relocations an ELF object file.  */
3643
3644 bfd_boolean
3645 _bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
3646 {
3647   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3648   struct elf_link_hash_table *htab = elf_hash_table (info);
3649
3650   /* If this object is the same format as the output object, and it is
3651      not a shared library, then let the backend look through the
3652      relocs.
3653
3654      This is required to build global offset table entries and to
3655      arrange for dynamic relocs.  It is not required for the
3656      particular common case of linking non PIC code, even when linking
3657      against shared libraries, but unfortunately there is no way of
3658      knowing whether an object file has been compiled PIC or not.
3659      Looking through the relocs is not particularly time consuming.
3660      The problem is that we must either (1) keep the relocs in memory,
3661      which causes the linker to require additional runtime memory or
3662      (2) read the relocs twice from the input file, which wastes time.
3663      This would be a good case for using mmap.
3664
3665      I have no idea how to handle linking PIC code into a file of a
3666      different format.  It probably can't be done.  */
3667   if ((abfd->flags & DYNAMIC) == 0
3668       && is_elf_hash_table (htab)
3669       && bed->check_relocs != NULL
3670       && elf_object_id (abfd) == elf_hash_table_id (htab)
3671       && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
3672     {
3673       asection *o;
3674
3675       for (o = abfd->sections; o != NULL; o = o->next)
3676         {
3677           Elf_Internal_Rela *internal_relocs;
3678           bfd_boolean ok;
3679
3680           /* Don't check relocations in excluded sections.  */
3681           if ((o->flags & SEC_RELOC) == 0
3682               || (o->flags & SEC_EXCLUDE) != 0
3683               || o->reloc_count == 0
3684               || ((info->strip == strip_all || info->strip == strip_debugger)
3685                   && (o->flags & SEC_DEBUGGING) != 0)
3686               || bfd_is_abs_section (o->output_section))
3687             continue;
3688
3689           internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
3690                                                        info->keep_memory);
3691           if (internal_relocs == NULL)
3692             return FALSE;
3693
3694           ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
3695
3696           if (elf_section_data (o)->relocs != internal_relocs)
3697             free (internal_relocs);
3698
3699           if (! ok)
3700             return FALSE;
3701         }
3702     }
3703
3704   return TRUE;
3705 }
3706
3707 /* Add symbols from an ELF object file to the linker hash table.  */
3708
3709 static bfd_boolean
3710 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3711 {
3712   Elf_Internal_Ehdr *ehdr;
3713   Elf_Internal_Shdr *hdr;
3714   size_t symcount;
3715   size_t extsymcount;
3716   size_t extsymoff;
3717   struct elf_link_hash_entry **sym_hash;
3718   bfd_boolean dynamic;
3719   Elf_External_Versym *extversym = NULL;
3720   Elf_External_Versym *ever;
3721   struct elf_link_hash_entry *weaks;
3722   struct elf_link_hash_entry **nondeflt_vers = NULL;
3723   size_t nondeflt_vers_cnt = 0;
3724   Elf_Internal_Sym *isymbuf = NULL;
3725   Elf_Internal_Sym *isym;
3726   Elf_Internal_Sym *isymend;
3727   const struct elf_backend_data *bed;
3728   bfd_boolean add_needed;
3729   struct elf_link_hash_table *htab;
3730   bfd_size_type amt;
3731   void *alloc_mark = NULL;
3732   struct bfd_hash_entry **old_table = NULL;
3733   unsigned int old_size = 0;
3734   unsigned int old_count = 0;
3735   void *old_tab = NULL;
3736   void *old_ent;
3737   struct bfd_link_hash_entry *old_undefs = NULL;
3738   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3739   void *old_strtab = NULL;
3740   size_t tabsize = 0;
3741   asection *s;
3742   bfd_boolean just_syms;
3743
3744   htab = elf_hash_table (info);
3745   bed = get_elf_backend_data (abfd);
3746
3747   if ((abfd->flags & DYNAMIC) == 0)
3748     dynamic = FALSE;
3749   else
3750     {
3751       dynamic = TRUE;
3752
3753       /* You can't use -r against a dynamic object.  Also, there's no
3754          hope of using a dynamic object which does not exactly match
3755          the format of the output file.  */
3756       if (bfd_link_relocatable (info)
3757           || !is_elf_hash_table (htab)
3758           || info->output_bfd->xvec != abfd->xvec)
3759         {
3760           if (bfd_link_relocatable (info))
3761             bfd_set_error (bfd_error_invalid_operation);
3762           else
3763             bfd_set_error (bfd_error_wrong_format);
3764           goto error_return;
3765         }
3766     }
3767
3768   ehdr = elf_elfheader (abfd);
3769   if (info->warn_alternate_em
3770       && bed->elf_machine_code != ehdr->e_machine
3771       && ((bed->elf_machine_alt1 != 0
3772            && ehdr->e_machine == bed->elf_machine_alt1)
3773           || (bed->elf_machine_alt2 != 0
3774               && ehdr->e_machine == bed->elf_machine_alt2)))
3775     info->callbacks->einfo
3776       /* xgettext:c-format */
3777       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3778        ehdr->e_machine, abfd, bed->elf_machine_code);
3779
3780   /* As a GNU extension, any input sections which are named
3781      .gnu.warning.SYMBOL are treated as warning symbols for the given
3782      symbol.  This differs from .gnu.warning sections, which generate
3783      warnings when they are included in an output file.  */
3784   /* PR 12761: Also generate this warning when building shared libraries.  */
3785   for (s = abfd->sections; s != NULL; s = s->next)
3786     {
3787       const char *name;
3788
3789       name = bfd_get_section_name (abfd, s);
3790       if (CONST_STRNEQ (name, ".gnu.warning."))
3791         {
3792           char *msg;
3793           bfd_size_type sz;
3794
3795           name += sizeof ".gnu.warning." - 1;
3796
3797           /* If this is a shared object, then look up the symbol
3798              in the hash table.  If it is there, and it is already
3799              been defined, then we will not be using the entry
3800              from this shared object, so we don't need to warn.
3801              FIXME: If we see the definition in a regular object
3802              later on, we will warn, but we shouldn't.  The only
3803              fix is to keep track of what warnings we are supposed
3804              to emit, and then handle them all at the end of the
3805              link.  */
3806           if (dynamic)
3807             {
3808               struct elf_link_hash_entry *h;
3809
3810               h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3811
3812               /* FIXME: What about bfd_link_hash_common?  */
3813               if (h != NULL
3814                   && (h->root.type == bfd_link_hash_defined
3815                       || h->root.type == bfd_link_hash_defweak))
3816                 continue;
3817             }
3818
3819           sz = s->size;
3820           msg = (char *) bfd_alloc (abfd, sz + 1);
3821           if (msg == NULL)
3822             goto error_return;
3823
3824           if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3825             goto error_return;
3826
3827           msg[sz] = '\0';
3828
3829           if (! (_bfd_generic_link_add_one_symbol
3830                  (info, abfd, name, BSF_WARNING, s, 0, msg,
3831                   FALSE, bed->collect, NULL)))
3832             goto error_return;
3833
3834           if (bfd_link_executable (info))
3835             {
3836               /* Clobber the section size so that the warning does
3837                  not get copied into the output file.  */
3838               s->size = 0;
3839
3840               /* Also set SEC_EXCLUDE, so that symbols defined in
3841                  the warning section don't get copied to the output.  */
3842               s->flags |= SEC_EXCLUDE;
3843             }
3844         }
3845     }
3846
3847   just_syms = ((s = abfd->sections) != NULL
3848                && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS);
3849
3850   add_needed = TRUE;
3851   if (! dynamic)
3852     {
3853       /* If we are creating a shared library, create all the dynamic
3854          sections immediately.  We need to attach them to something,
3855          so we attach them to this BFD, provided it is the right
3856          format and is not from ld --just-symbols.  Always create the
3857          dynamic sections for -E/--dynamic-list.  FIXME: If there
3858          are no input BFD's of the same format as the output, we can't
3859          make a shared library.  */
3860       if (!just_syms
3861           && (bfd_link_pic (info)
3862               || (!bfd_link_relocatable (info)
3863                   && info->nointerp
3864                   && (info->export_dynamic || info->dynamic)))
3865           && is_elf_hash_table (htab)
3866           && info->output_bfd->xvec == abfd->xvec
3867           && !htab->dynamic_sections_created)
3868         {
3869           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3870             goto error_return;
3871         }
3872     }
3873   else if (!is_elf_hash_table (htab))
3874     goto error_return;
3875   else
3876     {
3877       const char *soname = NULL;
3878       char *audit = NULL;
3879       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3880       const Elf_Internal_Phdr *phdr;
3881       int ret;
3882
3883       /* ld --just-symbols and dynamic objects don't mix very well.
3884          ld shouldn't allow it.  */
3885       if (just_syms)
3886         abort ();
3887
3888       /* If this dynamic lib was specified on the command line with
3889          --as-needed in effect, then we don't want to add a DT_NEEDED
3890          tag unless the lib is actually used.  Similary for libs brought
3891          in by another lib's DT_NEEDED.  When --no-add-needed is used
3892          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3893          any dynamic library in DT_NEEDED tags in the dynamic lib at
3894          all.  */
3895       add_needed = (elf_dyn_lib_class (abfd)
3896                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3897                        | DYN_NO_NEEDED)) == 0;
3898
3899       s = bfd_get_section_by_name (abfd, ".dynamic");
3900       if (s != NULL)
3901         {
3902           bfd_byte *dynbuf;
3903           bfd_byte *extdyn;
3904           unsigned int elfsec;
3905           unsigned long shlink;
3906
3907           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3908             {
3909 error_free_dyn:
3910               free (dynbuf);
3911               goto error_return;
3912             }
3913
3914           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3915           if (elfsec == SHN_BAD)
3916             goto error_free_dyn;
3917           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3918
3919           for (extdyn = dynbuf;
3920                extdyn < dynbuf + s->size;
3921                extdyn += bed->s->sizeof_dyn)
3922             {
3923               Elf_Internal_Dyn dyn;
3924
3925               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3926               if (dyn.d_tag == DT_SONAME)
3927                 {
3928                   unsigned int tagv = dyn.d_un.d_val;
3929                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3930                   if (soname == NULL)
3931                     goto error_free_dyn;
3932                 }
3933               if (dyn.d_tag == DT_NEEDED)
3934                 {
3935                   struct bfd_link_needed_list *n, **pn;
3936                   char *fnm, *anm;
3937                   unsigned int tagv = dyn.d_un.d_val;
3938
3939                   amt = sizeof (struct bfd_link_needed_list);
3940                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3941                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3942                   if (n == NULL || fnm == NULL)
3943                     goto error_free_dyn;
3944                   amt = strlen (fnm) + 1;
3945                   anm = (char *) bfd_alloc (abfd, amt);
3946                   if (anm == NULL)
3947                     goto error_free_dyn;
3948                   memcpy (anm, fnm, amt);
3949                   n->name = anm;
3950                   n->by = abfd;
3951                   n->next = NULL;
3952                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3953                     ;
3954                   *pn = n;
3955                 }
3956               if (dyn.d_tag == DT_RUNPATH)
3957                 {
3958                   struct bfd_link_needed_list *n, **pn;
3959                   char *fnm, *anm;
3960                   unsigned int tagv = dyn.d_un.d_val;
3961
3962                   amt = sizeof (struct bfd_link_needed_list);
3963                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3964                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3965                   if (n == NULL || fnm == NULL)
3966                     goto error_free_dyn;
3967                   amt = strlen (fnm) + 1;
3968                   anm = (char *) bfd_alloc (abfd, amt);
3969                   if (anm == NULL)
3970                     goto error_free_dyn;
3971                   memcpy (anm, fnm, amt);
3972                   n->name = anm;
3973                   n->by = abfd;
3974                   n->next = NULL;
3975                   for (pn = & runpath;
3976                        *pn != NULL;
3977                        pn = &(*pn)->next)
3978                     ;
3979                   *pn = n;
3980                 }
3981               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3982               if (!runpath && dyn.d_tag == DT_RPATH)
3983                 {
3984                   struct bfd_link_needed_list *n, **pn;
3985                   char *fnm, *anm;
3986                   unsigned int tagv = dyn.d_un.d_val;
3987
3988                   amt = sizeof (struct bfd_link_needed_list);
3989                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3990                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3991                   if (n == NULL || fnm == NULL)
3992                     goto error_free_dyn;
3993                   amt = strlen (fnm) + 1;
3994                   anm = (char *) bfd_alloc (abfd, amt);
3995                   if (anm == NULL)
3996                     goto error_free_dyn;
3997                   memcpy (anm, fnm, amt);
3998                   n->name = anm;
3999                   n->by = abfd;
4000                   n->next = NULL;
4001                   for (pn = & rpath;
4002                        *pn != NULL;
4003                        pn = &(*pn)->next)
4004                     ;
4005                   *pn = n;
4006                 }
4007               if (dyn.d_tag == DT_AUDIT)
4008                 {
4009                   unsigned int tagv = dyn.d_un.d_val;
4010                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
4011                 }
4012             }
4013
4014           free (dynbuf);
4015         }
4016
4017       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
4018          frees all more recently bfd_alloc'd blocks as well.  */
4019       if (runpath)
4020         rpath = runpath;
4021
4022       if (rpath)
4023         {
4024           struct bfd_link_needed_list **pn;
4025           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
4026             ;
4027           *pn = rpath;
4028         }
4029
4030       /* If we have a PT_GNU_RELRO program header, mark as read-only
4031          all sections contained fully therein.  This makes relro
4032          shared library sections appear as they will at run-time.  */
4033       phdr = elf_tdata (abfd)->phdr + elf_elfheader (abfd)->e_phnum;
4034       while (--phdr >= elf_tdata (abfd)->phdr)
4035         if (phdr->p_type == PT_GNU_RELRO)
4036           {
4037             for (s = abfd->sections; s != NULL; s = s->next)
4038               if ((s->flags & SEC_ALLOC) != 0
4039                   && s->vma >= phdr->p_vaddr
4040                   && s->vma + s->size <= phdr->p_vaddr + phdr->p_memsz)
4041                 s->flags |= SEC_READONLY;
4042             break;
4043           }
4044
4045       /* We do not want to include any of the sections in a dynamic
4046          object in the output file.  We hack by simply clobbering the
4047          list of sections in the BFD.  This could be handled more
4048          cleanly by, say, a new section flag; the existing
4049          SEC_NEVER_LOAD flag is not the one we want, because that one
4050          still implies that the section takes up space in the output
4051          file.  */
4052       bfd_section_list_clear (abfd);
4053
4054       /* Find the name to use in a DT_NEEDED entry that refers to this
4055          object.  If the object has a DT_SONAME entry, we use it.
4056          Otherwise, if the generic linker stuck something in
4057          elf_dt_name, we use that.  Otherwise, we just use the file
4058          name.  */
4059       if (soname == NULL || *soname == '\0')
4060         {
4061           soname = elf_dt_name (abfd);
4062           if (soname == NULL || *soname == '\0')
4063             soname = bfd_get_filename (abfd);
4064         }
4065
4066       /* Save the SONAME because sometimes the linker emulation code
4067          will need to know it.  */
4068       elf_dt_name (abfd) = soname;
4069
4070       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4071       if (ret < 0)
4072         goto error_return;
4073
4074       /* If we have already included this dynamic object in the
4075          link, just ignore it.  There is no reason to include a
4076          particular dynamic object more than once.  */
4077       if (ret > 0)
4078         return TRUE;
4079
4080       /* Save the DT_AUDIT entry for the linker emulation code. */
4081       elf_dt_audit (abfd) = audit;
4082     }
4083
4084   /* If this is a dynamic object, we always link against the .dynsym
4085      symbol table, not the .symtab symbol table.  The dynamic linker
4086      will only see the .dynsym symbol table, so there is no reason to
4087      look at .symtab for a dynamic object.  */
4088
4089   if (! dynamic || elf_dynsymtab (abfd) == 0)
4090     hdr = &elf_tdata (abfd)->symtab_hdr;
4091   else
4092     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4093
4094   symcount = hdr->sh_size / bed->s->sizeof_sym;
4095
4096   /* The sh_info field of the symtab header tells us where the
4097      external symbols start.  We don't care about the local symbols at
4098      this point.  */
4099   if (elf_bad_symtab (abfd))
4100     {
4101       extsymcount = symcount;
4102       extsymoff = 0;
4103     }
4104   else
4105     {
4106       extsymcount = symcount - hdr->sh_info;
4107       extsymoff = hdr->sh_info;
4108     }
4109
4110   sym_hash = elf_sym_hashes (abfd);
4111   if (extsymcount != 0)
4112     {
4113       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
4114                                       NULL, NULL, NULL);
4115       if (isymbuf == NULL)
4116         goto error_return;
4117
4118       if (sym_hash == NULL)
4119         {
4120           /* We store a pointer to the hash table entry for each
4121              external symbol.  */
4122           amt = extsymcount;
4123           amt *= sizeof (struct elf_link_hash_entry *);
4124           sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
4125           if (sym_hash == NULL)
4126             goto error_free_sym;
4127           elf_sym_hashes (abfd) = sym_hash;
4128         }
4129     }
4130
4131   if (dynamic)
4132     {
4133       /* Read in any version definitions.  */
4134       if (!_bfd_elf_slurp_version_tables (abfd,
4135                                           info->default_imported_symver))
4136         goto error_free_sym;
4137
4138       /* Read in the symbol versions, but don't bother to convert them
4139          to internal format.  */
4140       if (elf_dynversym (abfd) != 0)
4141         {
4142           Elf_Internal_Shdr *versymhdr;
4143
4144           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
4145           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
4146           if (extversym == NULL)
4147             goto error_free_sym;
4148           amt = versymhdr->sh_size;
4149           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
4150               || bfd_bread (extversym, amt, abfd) != amt)
4151             goto error_free_vers;
4152         }
4153     }
4154
4155   /* If we are loading an as-needed shared lib, save the symbol table
4156      state before we start adding symbols.  If the lib turns out
4157      to be unneeded, restore the state.  */
4158   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4159     {
4160       unsigned int i;
4161       size_t entsize;
4162
4163       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
4164         {
4165           struct bfd_hash_entry *p;
4166           struct elf_link_hash_entry *h;
4167
4168           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4169             {
4170               h = (struct elf_link_hash_entry *) p;
4171               entsize += htab->root.table.entsize;
4172               if (h->root.type == bfd_link_hash_warning)
4173                 entsize += htab->root.table.entsize;
4174             }
4175         }
4176
4177       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
4178       old_tab = bfd_malloc (tabsize + entsize);
4179       if (old_tab == NULL)
4180         goto error_free_vers;
4181
4182       /* Remember the current objalloc pointer, so that all mem for
4183          symbols added can later be reclaimed.  */
4184       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
4185       if (alloc_mark == NULL)
4186         goto error_free_vers;
4187
4188       /* Make a special call to the linker "notice" function to
4189          tell it that we are about to handle an as-needed lib.  */
4190       if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed))
4191         goto error_free_vers;
4192
4193       /* Clone the symbol table.  Remember some pointers into the
4194          symbol table, and dynamic symbol count.  */
4195       old_ent = (char *) old_tab + tabsize;
4196       memcpy (old_tab, htab->root.table.table, tabsize);
4197       old_undefs = htab->root.undefs;
4198       old_undefs_tail = htab->root.undefs_tail;
4199       old_table = htab->root.table.table;
4200       old_size = htab->root.table.size;
4201       old_count = htab->root.table.count;
4202       old_strtab = _bfd_elf_strtab_save (htab->dynstr);
4203       if (old_strtab == NULL)
4204         goto error_free_vers;
4205
4206       for (i = 0; i < htab->root.table.size; i++)
4207         {
4208           struct bfd_hash_entry *p;
4209           struct elf_link_hash_entry *h;
4210
4211           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4212             {
4213               memcpy (old_ent, p, htab->root.table.entsize);
4214               old_ent = (char *) old_ent + htab->root.table.entsize;
4215               h = (struct elf_link_hash_entry *) p;
4216               if (h->root.type == bfd_link_hash_warning)
4217                 {
4218                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
4219                   old_ent = (char *) old_ent + htab->root.table.entsize;
4220                 }
4221             }
4222         }
4223     }
4224
4225   weaks = NULL;
4226   ever = extversym != NULL ? extversym + extsymoff : NULL;
4227   for (isym = isymbuf, isymend = isymbuf + extsymcount;
4228        isym < isymend;
4229        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
4230     {
4231       int bind;
4232       bfd_vma value;
4233       asection *sec, *new_sec;
4234       flagword flags;
4235       const char *name;
4236       struct elf_link_hash_entry *h;
4237       struct elf_link_hash_entry *hi;
4238       bfd_boolean definition;
4239       bfd_boolean size_change_ok;
4240       bfd_boolean type_change_ok;
4241       bfd_boolean new_weakdef;
4242       bfd_boolean new_weak;
4243       bfd_boolean old_weak;
4244       bfd_boolean override;
4245       bfd_boolean common;
4246       bfd_boolean discarded;
4247       unsigned int old_alignment;
4248       bfd *old_bfd;
4249       bfd_boolean matched;
4250
4251       override = FALSE;
4252
4253       /* Treat common symbol as undefined for --no-define-common.  */
4254       if (isym->st_shndx == SHN_COMMON
4255           && info->inhibit_common_definition)
4256         isym->st_shndx = SHN_UNDEF;
4257
4258       flags = BSF_NO_FLAGS;
4259       sec = NULL;
4260       value = isym->st_value;
4261       common = bed->common_definition (isym);
4262       discarded = FALSE;
4263
4264       bind = ELF_ST_BIND (isym->st_info);
4265       switch (bind)
4266         {
4267         case STB_LOCAL:
4268           /* This should be impossible, since ELF requires that all
4269              global symbols follow all local symbols, and that sh_info
4270              point to the first global symbol.  Unfortunately, Irix 5
4271              screws this up.  */
4272           continue;
4273
4274         case STB_GLOBAL:
4275           if (isym->st_shndx != SHN_UNDEF && !common)
4276             flags = BSF_GLOBAL;
4277           break;
4278
4279         case STB_WEAK:
4280           flags = BSF_WEAK;
4281           break;
4282
4283         case STB_GNU_UNIQUE:
4284           flags = BSF_GNU_UNIQUE;
4285           break;
4286
4287         default:
4288           /* Leave it up to the processor backend.  */
4289           break;
4290         }
4291
4292       if (isym->st_shndx == SHN_UNDEF)
4293         sec = bfd_und_section_ptr;
4294       else if (isym->st_shndx == SHN_ABS)
4295         sec = bfd_abs_section_ptr;
4296       else if (isym->st_shndx == SHN_COMMON)
4297         {
4298           sec = bfd_com_section_ptr;
4299           /* What ELF calls the size we call the value.  What ELF
4300              calls the value we call the alignment.  */
4301           value = isym->st_size;
4302         }
4303       else
4304         {
4305           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4306           if (sec == NULL)
4307             sec = bfd_abs_section_ptr;
4308           else if (discarded_section (sec))
4309             {
4310               /* Symbols from discarded section are undefined.  We keep
4311                  its visibility.  */
4312               sec = bfd_und_section_ptr;
4313               discarded = TRUE;
4314               isym->st_shndx = SHN_UNDEF;
4315             }
4316           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
4317             value -= sec->vma;
4318         }
4319
4320       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4321                                               isym->st_name);
4322       if (name == NULL)
4323         goto error_free_vers;
4324
4325       if (isym->st_shndx == SHN_COMMON
4326           && (abfd->flags & BFD_PLUGIN) != 0)
4327         {
4328           asection *xc = bfd_get_section_by_name (abfd, "COMMON");
4329
4330           if (xc == NULL)
4331             {
4332               flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
4333                                  | SEC_EXCLUDE);
4334               xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
4335               if (xc == NULL)
4336                 goto error_free_vers;
4337             }
4338           sec = xc;
4339         }
4340       else if (isym->st_shndx == SHN_COMMON
4341                && ELF_ST_TYPE (isym->st_info) == STT_TLS
4342                && !bfd_link_relocatable (info))
4343         {
4344           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
4345
4346           if (tcomm == NULL)
4347             {
4348               flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
4349                                  | SEC_LINKER_CREATED);
4350               tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
4351               if (tcomm == NULL)
4352                 goto error_free_vers;
4353             }
4354           sec = tcomm;
4355         }
4356       else if (bed->elf_add_symbol_hook)
4357         {
4358           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
4359                                              &sec, &value))
4360             goto error_free_vers;
4361
4362           /* The hook function sets the name to NULL if this symbol
4363              should be skipped for some reason.  */
4364           if (name == NULL)
4365             continue;
4366         }
4367
4368       /* Sanity check that all possibilities were handled.  */
4369       if (sec == NULL)
4370         {
4371           bfd_set_error (bfd_error_bad_value);
4372           goto error_free_vers;
4373         }
4374
4375       /* Silently discard TLS symbols from --just-syms.  There's
4376          no way to combine a static TLS block with a new TLS block
4377          for this executable.  */
4378       if (ELF_ST_TYPE (isym->st_info) == STT_TLS
4379           && sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4380         continue;
4381
4382       if (bfd_is_und_section (sec)
4383           || bfd_is_com_section (sec))
4384         definition = FALSE;
4385       else
4386         definition = TRUE;
4387
4388       size_change_ok = FALSE;
4389       type_change_ok = bed->type_change_ok;
4390       old_weak = FALSE;
4391       matched = FALSE;
4392       old_alignment = 0;
4393       old_bfd = NULL;
4394       new_sec = sec;
4395
4396       if (is_elf_hash_table (htab))
4397         {
4398           Elf_Internal_Versym iver;
4399           unsigned int vernum = 0;
4400           bfd_boolean skip;
4401
4402           if (ever == NULL)
4403             {
4404               if (info->default_imported_symver)
4405                 /* Use the default symbol version created earlier.  */
4406                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
4407               else
4408                 iver.vs_vers = 0;
4409             }
4410           else
4411             _bfd_elf_swap_versym_in (abfd, ever, &iver);
4412
4413           vernum = iver.vs_vers & VERSYM_VERSION;
4414
4415           /* If this is a hidden symbol, or if it is not version
4416              1, we append the version name to the symbol name.
4417              However, we do not modify a non-hidden absolute symbol
4418              if it is not a function, because it might be the version
4419              symbol itself.  FIXME: What if it isn't?  */
4420           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4421               || (vernum > 1
4422                   && (!bfd_is_abs_section (sec)
4423                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4424             {
4425               const char *verstr;
4426               size_t namelen, verlen, newlen;
4427               char *newname, *p;
4428
4429               if (isym->st_shndx != SHN_UNDEF)
4430                 {
4431                   if (vernum > elf_tdata (abfd)->cverdefs)
4432                     verstr = NULL;
4433                   else if (vernum > 1)
4434                     verstr =
4435                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4436                   else
4437                     verstr = "";
4438
4439                   if (verstr == NULL)
4440                     {
4441                       _bfd_error_handler
4442                         /* xgettext:c-format */
4443                         (_("%B: %s: invalid version %u (max %d)"),
4444                          abfd, name, vernum,
4445                          elf_tdata (abfd)->cverdefs);
4446                       bfd_set_error (bfd_error_bad_value);
4447                       goto error_free_vers;
4448                     }
4449                 }
4450               else
4451                 {
4452                   /* We cannot simply test for the number of
4453                      entries in the VERNEED section since the
4454                      numbers for the needed versions do not start
4455                      at 0.  */
4456                   Elf_Internal_Verneed *t;
4457
4458                   verstr = NULL;
4459                   for (t = elf_tdata (abfd)->verref;
4460                        t != NULL;
4461                        t = t->vn_nextref)
4462                     {
4463                       Elf_Internal_Vernaux *a;
4464
4465                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4466                         {
4467                           if (a->vna_other == vernum)
4468                             {
4469                               verstr = a->vna_nodename;
4470                               break;
4471                             }
4472                         }
4473                       if (a != NULL)
4474                         break;
4475                     }
4476                   if (verstr == NULL)
4477                     {
4478                       _bfd_error_handler
4479                         /* xgettext:c-format */
4480                         (_("%B: %s: invalid needed version %d"),
4481                          abfd, name, vernum);
4482                       bfd_set_error (bfd_error_bad_value);
4483                       goto error_free_vers;
4484                     }
4485                 }
4486
4487               namelen = strlen (name);
4488               verlen = strlen (verstr);
4489               newlen = namelen + verlen + 2;
4490               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4491                   && isym->st_shndx != SHN_UNDEF)
4492                 ++newlen;
4493
4494               newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4495               if (newname == NULL)
4496                 goto error_free_vers;
4497               memcpy (newname, name, namelen);
4498               p = newname + namelen;
4499               *p++ = ELF_VER_CHR;
4500               /* If this is a defined non-hidden version symbol,
4501                  we add another @ to the name.  This indicates the
4502                  default version of the symbol.  */
4503               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4504                   && isym->st_shndx != SHN_UNDEF)
4505                 *p++ = ELF_VER_CHR;
4506               memcpy (p, verstr, verlen + 1);
4507
4508               name = newname;
4509             }
4510
4511           /* If this symbol has default visibility and the user has
4512              requested we not re-export it, then mark it as hidden.  */
4513           if (!bfd_is_und_section (sec)
4514               && !dynamic
4515               && abfd->no_export
4516               && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
4517             isym->st_other = (STV_HIDDEN
4518                               | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
4519
4520           if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
4521                                       sym_hash, &old_bfd, &old_weak,
4522                                       &old_alignment, &skip, &override,
4523                                       &type_change_ok, &size_change_ok,
4524                                       &matched))
4525             goto error_free_vers;
4526
4527           if (skip)
4528             continue;
4529
4530           /* Override a definition only if the new symbol matches the
4531              existing one.  */
4532           if (override && matched)
4533             definition = FALSE;
4534
4535           h = *sym_hash;
4536           while (h->root.type == bfd_link_hash_indirect
4537                  || h->root.type == bfd_link_hash_warning)
4538             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4539
4540           if (elf_tdata (abfd)->verdef != NULL
4541               && vernum > 1
4542               && definition)
4543             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4544         }
4545
4546       if (! (_bfd_generic_link_add_one_symbol
4547              (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4548               (struct bfd_link_hash_entry **) sym_hash)))
4549         goto error_free_vers;
4550
4551       if ((flags & BSF_GNU_UNIQUE)
4552           && (abfd->flags & DYNAMIC) == 0
4553           && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4554         elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_unique;
4555
4556       h = *sym_hash;
4557       /* We need to make sure that indirect symbol dynamic flags are
4558          updated.  */
4559       hi = h;
4560       while (h->root.type == bfd_link_hash_indirect
4561              || h->root.type == bfd_link_hash_warning)
4562         h = (struct elf_link_hash_entry *) h->root.u.i.link;
4563
4564       /* Setting the index to -3 tells elf_link_output_extsym that
4565          this symbol is defined in a discarded section.  */
4566       if (discarded)
4567         h->indx = -3;
4568
4569       *sym_hash = h;
4570
4571       new_weak = (flags & BSF_WEAK) != 0;
4572       new_weakdef = FALSE;
4573       if (dynamic
4574           && definition
4575           && new_weak
4576           && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4577           && is_elf_hash_table (htab)
4578           && h->u.weakdef == NULL)
4579         {
4580           /* Keep a list of all weak defined non function symbols from
4581              a dynamic object, using the weakdef field.  Later in this
4582              function we will set the weakdef field to the correct
4583              value.  We only put non-function symbols from dynamic
4584              objects on this list, because that happens to be the only
4585              time we need to know the normal symbol corresponding to a
4586              weak symbol, and the information is time consuming to
4587              figure out.  If the weakdef field is not already NULL,
4588              then this symbol was already defined by some previous
4589              dynamic object, and we will be using that previous
4590              definition anyhow.  */
4591
4592           h->u.weakdef = weaks;
4593           weaks = h;
4594           new_weakdef = TRUE;
4595         }
4596
4597       /* Set the alignment of a common symbol.  */
4598       if ((common || bfd_is_com_section (sec))
4599           && h->root.type == bfd_link_hash_common)
4600         {
4601           unsigned int align;
4602
4603           if (common)
4604             align = bfd_log2 (isym->st_value);
4605           else
4606             {
4607               /* The new symbol is a common symbol in a shared object.
4608                  We need to get the alignment from the section.  */
4609               align = new_sec->alignment_power;
4610             }
4611           if (align > old_alignment)
4612             h->root.u.c.p->alignment_power = align;
4613           else
4614             h->root.u.c.p->alignment_power = old_alignment;
4615         }
4616
4617       if (is_elf_hash_table (htab))
4618         {
4619           /* Set a flag in the hash table entry indicating the type of
4620              reference or definition we just found.  A dynamic symbol
4621              is one which is referenced or defined by both a regular
4622              object and a shared object.  */
4623           bfd_boolean dynsym = FALSE;
4624
4625           /* Plugin symbols aren't normal.  Don't set def_regular or
4626              ref_regular for them, or make them dynamic.  */
4627           if ((abfd->flags & BFD_PLUGIN) != 0)
4628             ;
4629           else if (! dynamic)
4630             {
4631               if (! definition)
4632                 {
4633                   h->ref_regular = 1;
4634                   if (bind != STB_WEAK)
4635                     h->ref_regular_nonweak = 1;
4636                 }
4637               else
4638                 {
4639                   h->def_regular = 1;
4640                   if (h->def_dynamic)
4641                     {
4642                       h->def_dynamic = 0;
4643                       h->ref_dynamic = 1;
4644                     }
4645                 }
4646
4647               /* If the indirect symbol has been forced local, don't
4648                  make the real symbol dynamic.  */
4649               if ((h == hi || !hi->forced_local)
4650                   && (bfd_link_dll (info)
4651                       || h->def_dynamic
4652                       || h->ref_dynamic))
4653                 dynsym = TRUE;
4654             }
4655           else
4656             {
4657               if (! definition)
4658                 {
4659                   h->ref_dynamic = 1;
4660                   hi->ref_dynamic = 1;
4661                 }
4662               else
4663                 {
4664                   h->def_dynamic = 1;
4665                   hi->def_dynamic = 1;
4666                 }
4667
4668               /* If the indirect symbol has been forced local, don't
4669                  make the real symbol dynamic.  */
4670               if ((h == hi || !hi->forced_local)
4671                   && (h->def_regular
4672                       || h->ref_regular
4673                       || (h->u.weakdef != NULL
4674                           && ! new_weakdef
4675                           && h->u.weakdef->dynindx != -1)))
4676                 dynsym = TRUE;
4677             }
4678
4679           /* Check to see if we need to add an indirect symbol for
4680              the default name.  */
4681           if (definition
4682               || (!override && h->root.type == bfd_link_hash_common))
4683             if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4684                                               sec, value, &old_bfd, &dynsym))
4685               goto error_free_vers;
4686
4687           /* Check the alignment when a common symbol is involved. This
4688              can change when a common symbol is overridden by a normal
4689              definition or a common symbol is ignored due to the old
4690              normal definition. We need to make sure the maximum
4691              alignment is maintained.  */
4692           if ((old_alignment || common)
4693               && h->root.type != bfd_link_hash_common)
4694             {
4695               unsigned int common_align;
4696               unsigned int normal_align;
4697               unsigned int symbol_align;
4698               bfd *normal_bfd;
4699               bfd *common_bfd;
4700
4701               BFD_ASSERT (h->root.type == bfd_link_hash_defined
4702                           || h->root.type == bfd_link_hash_defweak);
4703
4704               symbol_align = ffs (h->root.u.def.value) - 1;
4705               if (h->root.u.def.section->owner != NULL
4706                   && (h->root.u.def.section->owner->flags
4707                        & (DYNAMIC | BFD_PLUGIN)) == 0)
4708                 {
4709                   normal_align = h->root.u.def.section->alignment_power;
4710                   if (normal_align > symbol_align)
4711                     normal_align = symbol_align;
4712                 }
4713               else
4714                 normal_align = symbol_align;
4715
4716               if (old_alignment)
4717                 {
4718                   common_align = old_alignment;
4719                   common_bfd = old_bfd;
4720                   normal_bfd = abfd;
4721                 }
4722               else
4723                 {
4724                   common_align = bfd_log2 (isym->st_value);
4725                   common_bfd = abfd;
4726                   normal_bfd = old_bfd;
4727                 }
4728
4729               if (normal_align < common_align)
4730                 {
4731                   /* PR binutils/2735 */
4732                   if (normal_bfd == NULL)
4733                     _bfd_error_handler
4734                       /* xgettext:c-format */
4735                       (_("Warning: alignment %u of common symbol `%s' in %B is"
4736                          " greater than the alignment (%u) of its section %A"),
4737                        1 << common_align, name, common_bfd,
4738                        1 << normal_align, h->root.u.def.section);
4739                   else
4740                     _bfd_error_handler
4741                       /* xgettext:c-format */
4742                       (_("Warning: alignment %u of symbol `%s' in %B"
4743                          " is smaller than %u in %B"),
4744                        1 << normal_align, name, normal_bfd,
4745                        1 << common_align, common_bfd);
4746                 }
4747             }
4748
4749           /* Remember the symbol size if it isn't undefined.  */
4750           if (isym->st_size != 0
4751               && isym->st_shndx != SHN_UNDEF
4752               && (definition || h->size == 0))
4753             {
4754               if (h->size != 0
4755                   && h->size != isym->st_size
4756                   && ! size_change_ok)
4757                 _bfd_error_handler
4758                   /* xgettext:c-format */
4759                   (_("Warning: size of symbol `%s' changed"
4760                      " from %Lu in %B to %Lu in %B"),
4761                    name, h->size, old_bfd, isym->st_size, abfd);
4762
4763               h->size = isym->st_size;
4764             }
4765
4766           /* If this is a common symbol, then we always want H->SIZE
4767              to be the size of the common symbol.  The code just above
4768              won't fix the size if a common symbol becomes larger.  We
4769              don't warn about a size change here, because that is
4770              covered by --warn-common.  Allow changes between different
4771              function types.  */
4772           if (h->root.type == bfd_link_hash_common)
4773             h->size = h->root.u.c.size;
4774
4775           if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4776               && ((definition && !new_weak)
4777                   || (old_weak && h->root.type == bfd_link_hash_common)
4778                   || h->type == STT_NOTYPE))
4779             {
4780               unsigned int type = ELF_ST_TYPE (isym->st_info);
4781
4782               /* Turn an IFUNC symbol from a DSO into a normal FUNC
4783                  symbol.  */
4784               if (type == STT_GNU_IFUNC
4785                   && (abfd->flags & DYNAMIC) != 0)
4786                 type = STT_FUNC;
4787
4788               if (h->type != type)
4789                 {
4790                   if (h->type != STT_NOTYPE && ! type_change_ok)
4791                     /* xgettext:c-format */
4792                     _bfd_error_handler
4793                       (_("Warning: type of symbol `%s' changed"
4794                          " from %d to %d in %B"),
4795                        name, h->type, type, abfd);
4796
4797                   h->type = type;
4798                 }
4799             }
4800
4801           /* Merge st_other field.  */
4802           elf_merge_st_other (abfd, h, isym, sec, definition, dynamic);
4803
4804           /* We don't want to make debug symbol dynamic.  */
4805           if (definition
4806               && (sec->flags & SEC_DEBUGGING)
4807               && !bfd_link_relocatable (info))
4808             dynsym = FALSE;
4809
4810           /* Nor should we make plugin symbols dynamic.  */
4811           if ((abfd->flags & BFD_PLUGIN) != 0)
4812             dynsym = FALSE;
4813
4814           if (definition)
4815             {
4816               h->target_internal = isym->st_target_internal;
4817               h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4818             }
4819
4820           if (definition && !dynamic)
4821             {
4822               char *p = strchr (name, ELF_VER_CHR);
4823               if (p != NULL && p[1] != ELF_VER_CHR)
4824                 {
4825                   /* Queue non-default versions so that .symver x, x@FOO
4826                      aliases can be checked.  */
4827                   if (!nondeflt_vers)
4828                     {
4829                       amt = ((isymend - isym + 1)
4830                              * sizeof (struct elf_link_hash_entry *));
4831                       nondeflt_vers
4832                         = (struct elf_link_hash_entry **) bfd_malloc (amt);
4833                       if (!nondeflt_vers)
4834                         goto error_free_vers;
4835                     }
4836                   nondeflt_vers[nondeflt_vers_cnt++] = h;
4837                 }
4838             }
4839
4840           if (dynsym && h->dynindx == -1)
4841             {
4842               if (! bfd_elf_link_record_dynamic_symbol (info, h))
4843                 goto error_free_vers;
4844               if (h->u.weakdef != NULL
4845                   && ! new_weakdef
4846                   && h->u.weakdef->dynindx == -1)
4847                 {
4848                   if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4849                     goto error_free_vers;
4850                 }
4851             }
4852           else if (h->dynindx != -1)
4853             /* If the symbol already has a dynamic index, but
4854                visibility says it should not be visible, turn it into
4855                a local symbol.  */
4856             switch (ELF_ST_VISIBILITY (h->other))
4857               {
4858               case STV_INTERNAL:
4859               case STV_HIDDEN:
4860                 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4861                 dynsym = FALSE;
4862                 break;
4863               }
4864
4865           /* Don't add DT_NEEDED for references from the dummy bfd nor
4866              for unmatched symbol.  */
4867           if (!add_needed
4868               && matched
4869               && definition
4870               && ((dynsym
4871                    && h->ref_regular_nonweak
4872                    && (old_bfd == NULL
4873                        || (old_bfd->flags & BFD_PLUGIN) == 0))
4874                   || (h->ref_dynamic_nonweak
4875                       && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4876                       && !on_needed_list (elf_dt_name (abfd),
4877                                           htab->needed, NULL))))
4878             {
4879               int ret;
4880               const char *soname = elf_dt_name (abfd);
4881
4882               info->callbacks->minfo ("%!", soname, old_bfd,
4883                                       h->root.root.string);
4884
4885               /* A symbol from a library loaded via DT_NEEDED of some
4886                  other library is referenced by a regular object.
4887                  Add a DT_NEEDED entry for it.  Issue an error if
4888                  --no-add-needed is used and the reference was not
4889                  a weak one.  */
4890               if (old_bfd != NULL
4891                   && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4892                 {
4893                   _bfd_error_handler
4894                     /* xgettext:c-format */
4895                     (_("%B: undefined reference to symbol '%s'"),
4896                      old_bfd, name);
4897                   bfd_set_error (bfd_error_missing_dso);
4898                   goto error_free_vers;
4899                 }
4900
4901               elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4902                 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4903
4904               add_needed = TRUE;
4905               ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4906               if (ret < 0)
4907                 goto error_free_vers;
4908
4909               BFD_ASSERT (ret == 0);
4910             }
4911         }
4912     }
4913
4914   if (extversym != NULL)
4915     {
4916       free (extversym);
4917       extversym = NULL;
4918     }
4919
4920   if (isymbuf != NULL)
4921     {
4922       free (isymbuf);
4923       isymbuf = NULL;
4924     }
4925
4926   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4927     {
4928       unsigned int i;
4929
4930       /* Restore the symbol table.  */
4931       old_ent = (char *) old_tab + tabsize;
4932       memset (elf_sym_hashes (abfd), 0,
4933               extsymcount * sizeof (struct elf_link_hash_entry *));
4934       htab->root.table.table = old_table;
4935       htab->root.table.size = old_size;
4936       htab->root.table.count = old_count;
4937       memcpy (htab->root.table.table, old_tab, tabsize);
4938       htab->root.undefs = old_undefs;
4939       htab->root.undefs_tail = old_undefs_tail;
4940       _bfd_elf_strtab_restore (htab->dynstr, old_strtab);
4941       free (old_strtab);
4942       old_strtab = NULL;
4943       for (i = 0; i < htab->root.table.size; i++)
4944         {
4945           struct bfd_hash_entry *p;
4946           struct elf_link_hash_entry *h;
4947           bfd_size_type size;
4948           unsigned int alignment_power;
4949           unsigned int non_ir_ref_dynamic;
4950
4951           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4952             {
4953               h = (struct elf_link_hash_entry *) p;
4954               if (h->root.type == bfd_link_hash_warning)
4955                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4956
4957               /* Preserve the maximum alignment and size for common
4958                  symbols even if this dynamic lib isn't on DT_NEEDED
4959                  since it can still be loaded at run time by another
4960                  dynamic lib.  */
4961               if (h->root.type == bfd_link_hash_common)
4962                 {
4963                   size = h->root.u.c.size;
4964                   alignment_power = h->root.u.c.p->alignment_power;
4965                 }
4966               else
4967                 {
4968                   size = 0;
4969                   alignment_power = 0;
4970                 }
4971               /* Preserve non_ir_ref_dynamic so that this symbol
4972                  will be exported when the dynamic lib becomes needed
4973                  in the second pass.  */
4974               non_ir_ref_dynamic = h->root.non_ir_ref_dynamic;
4975               memcpy (p, old_ent, htab->root.table.entsize);
4976               old_ent = (char *) old_ent + htab->root.table.entsize;
4977               h = (struct elf_link_hash_entry *) p;
4978               if (h->root.type == bfd_link_hash_warning)
4979                 {
4980                   memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4981                   old_ent = (char *) old_ent + htab->root.table.entsize;
4982                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
4983                 }
4984               if (h->root.type == bfd_link_hash_common)
4985                 {
4986                   if (size > h->root.u.c.size)
4987                     h->root.u.c.size = size;
4988                   if (alignment_power > h->root.u.c.p->alignment_power)
4989                     h->root.u.c.p->alignment_power = alignment_power;
4990                 }
4991               h->root.non_ir_ref_dynamic = non_ir_ref_dynamic;
4992             }
4993         }
4994
4995       /* Make a special call to the linker "notice" function to
4996          tell it that symbols added for crefs may need to be removed.  */
4997       if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed))
4998         goto error_free_vers;
4999
5000       free (old_tab);
5001       objalloc_free_block ((struct objalloc *) htab->root.table.memory,
5002                            alloc_mark);
5003       if (nondeflt_vers != NULL)
5004         free (nondeflt_vers);
5005       return TRUE;
5006     }
5007
5008   if (old_tab != NULL)
5009     {
5010       if (!(*bed->notice_as_needed) (abfd, info, notice_needed))
5011         goto error_free_vers;
5012       free (old_tab);
5013       old_tab = NULL;
5014     }
5015
5016   /* Now that all the symbols from this input file are created, if
5017      not performing a relocatable link, handle .symver foo, foo@BAR
5018      such that any relocs against foo become foo@BAR.  */
5019   if (!bfd_link_relocatable (info) && nondeflt_vers != NULL)
5020     {
5021       size_t cnt, symidx;
5022
5023       for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
5024         {
5025           struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
5026           char *shortname, *p;
5027
5028           p = strchr (h->root.root.string, ELF_VER_CHR);
5029           if (p == NULL
5030               || (h->root.type != bfd_link_hash_defined
5031                   && h->root.type != bfd_link_hash_defweak))
5032             continue;
5033
5034           amt = p - h->root.root.string;
5035           shortname = (char *) bfd_malloc (amt + 1);
5036           if (!shortname)
5037             goto error_free_vers;
5038           memcpy (shortname, h->root.root.string, amt);
5039           shortname[amt] = '\0';
5040
5041           hi = (struct elf_link_hash_entry *)
5042                bfd_link_hash_lookup (&htab->root, shortname,
5043                                      FALSE, FALSE, FALSE);
5044           if (hi != NULL
5045               && hi->root.type == h->root.type
5046               && hi->root.u.def.value == h->root.u.def.value
5047               && hi->root.u.def.section == h->root.u.def.section)
5048             {
5049               (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
5050               hi->root.type = bfd_link_hash_indirect;
5051               hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
5052               (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
5053               sym_hash = elf_sym_hashes (abfd);
5054               if (sym_hash)
5055                 for (symidx = 0; symidx < extsymcount; ++symidx)
5056                   if (sym_hash[symidx] == hi)
5057                     {
5058                       sym_hash[symidx] = h;
5059                       break;
5060                     }
5061             }
5062           free (shortname);
5063         }
5064       free (nondeflt_vers);
5065       nondeflt_vers = NULL;
5066     }
5067
5068   /* Now set the weakdefs field correctly for all the weak defined
5069      symbols we found.  The only way to do this is to search all the
5070      symbols.  Since we only need the information for non functions in
5071      dynamic objects, that's the only time we actually put anything on
5072      the list WEAKS.  We need this information so that if a regular
5073      object refers to a symbol defined weakly in a dynamic object, the
5074      real symbol in the dynamic object is also put in the dynamic
5075      symbols; we also must arrange for both symbols to point to the
5076      same memory location.  We could handle the general case of symbol
5077      aliasing, but a general symbol alias can only be generated in
5078      assembler code, handling it correctly would be very time
5079      consuming, and other ELF linkers don't handle general aliasing
5080      either.  */
5081   if (weaks != NULL)
5082     {
5083       struct elf_link_hash_entry **hpp;
5084       struct elf_link_hash_entry **hppend;
5085       struct elf_link_hash_entry **sorted_sym_hash;
5086       struct elf_link_hash_entry *h;
5087       size_t sym_count;
5088
5089       /* Since we have to search the whole symbol list for each weak
5090          defined symbol, search time for N weak defined symbols will be
5091          O(N^2). Binary search will cut it down to O(NlogN).  */
5092       amt = extsymcount;
5093       amt *= sizeof (struct elf_link_hash_entry *);
5094       sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
5095       if (sorted_sym_hash == NULL)
5096         goto error_return;
5097       sym_hash = sorted_sym_hash;
5098       hpp = elf_sym_hashes (abfd);
5099       hppend = hpp + extsymcount;
5100       sym_count = 0;
5101       for (; hpp < hppend; hpp++)
5102         {
5103           h = *hpp;
5104           if (h != NULL
5105               && h->root.type == bfd_link_hash_defined
5106               && !bed->is_function_type (h->type))
5107             {
5108               *sym_hash = h;
5109               sym_hash++;
5110               sym_count++;
5111             }
5112         }
5113
5114       qsort (sorted_sym_hash, sym_count,
5115              sizeof (struct elf_link_hash_entry *),
5116              elf_sort_symbol);
5117
5118       while (weaks != NULL)
5119         {
5120           struct elf_link_hash_entry *hlook;
5121           asection *slook;
5122           bfd_vma vlook;
5123           size_t i, j, idx = 0;
5124
5125           hlook = weaks;
5126           weaks = hlook->u.weakdef;
5127           hlook->u.weakdef = NULL;
5128
5129           BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
5130                       || hlook->root.type == bfd_link_hash_defweak
5131                       || hlook->root.type == bfd_link_hash_common
5132                       || hlook->root.type == bfd_link_hash_indirect);
5133           slook = hlook->root.u.def.section;
5134           vlook = hlook->root.u.def.value;
5135
5136           i = 0;
5137           j = sym_count;
5138           while (i != j)
5139             {
5140               bfd_signed_vma vdiff;
5141               idx = (i + j) / 2;
5142               h = sorted_sym_hash[idx];
5143               vdiff = vlook - h->root.u.def.value;
5144               if (vdiff < 0)
5145                 j = idx;
5146               else if (vdiff > 0)
5147                 i = idx + 1;
5148               else
5149                 {
5150                   int sdiff = slook->id - h->root.u.def.section->id;
5151                   if (sdiff < 0)
5152                     j = idx;
5153                   else if (sdiff > 0)
5154                     i = idx + 1;
5155                   else
5156                     break;
5157                 }
5158             }
5159
5160           /* We didn't find a value/section match.  */
5161           if (i == j)
5162             continue;
5163
5164           /* With multiple aliases, or when the weak symbol is already
5165              strongly defined, we have multiple matching symbols and
5166              the binary search above may land on any of them.  Step
5167              one past the matching symbol(s).  */
5168           while (++idx != j)
5169             {
5170               h = sorted_sym_hash[idx];
5171               if (h->root.u.def.section != slook
5172                   || h->root.u.def.value != vlook)
5173                 break;
5174             }
5175
5176           /* Now look back over the aliases.  Since we sorted by size
5177              as well as value and section, we'll choose the one with
5178              the largest size.  */
5179           while (idx-- != i)
5180             {
5181               h = sorted_sym_hash[idx];
5182
5183               /* Stop if value or section doesn't match.  */
5184               if (h->root.u.def.section != slook
5185                   || h->root.u.def.value != vlook)
5186                 break;
5187               else if (h != hlook)
5188                 {
5189                   hlook->u.weakdef = h;
5190
5191                   /* If the weak definition is in the list of dynamic
5192                      symbols, make sure the real definition is put
5193                      there as well.  */
5194                   if (hlook->dynindx != -1 && h->dynindx == -1)
5195                     {
5196                       if (! bfd_elf_link_record_dynamic_symbol (info, h))
5197                         {
5198                         err_free_sym_hash:
5199                           free (sorted_sym_hash);
5200                           goto error_return;
5201                         }
5202                     }
5203
5204                   /* If the real definition is in the list of dynamic
5205                      symbols, make sure the weak definition is put
5206                      there as well.  If we don't do this, then the
5207                      dynamic loader might not merge the entries for the
5208                      real definition and the weak definition.  */
5209                   if (h->dynindx != -1 && hlook->dynindx == -1)
5210                     {
5211                       if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
5212                         goto err_free_sym_hash;
5213                     }
5214                   break;
5215                 }
5216             }
5217         }
5218
5219       free (sorted_sym_hash);
5220     }
5221
5222   if (bed->check_directives
5223       && !(*bed->check_directives) (abfd, info))
5224     return FALSE;
5225
5226   if (!info->check_relocs_after_open_input
5227       && !_bfd_elf_link_check_relocs (abfd, info))
5228     return FALSE;
5229
5230   /* If this is a non-traditional link, try to optimize the handling
5231      of the .stab/.stabstr sections.  */
5232   if (! dynamic
5233       && ! info->traditional_format
5234       && is_elf_hash_table (htab)
5235       && (info->strip != strip_all && info->strip != strip_debugger))
5236     {
5237       asection *stabstr;
5238
5239       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
5240       if (stabstr != NULL)
5241         {
5242           bfd_size_type string_offset = 0;
5243           asection *stab;
5244
5245           for (stab = abfd->sections; stab; stab = stab->next)
5246             if (CONST_STRNEQ (stab->name, ".stab")
5247                 && (!stab->name[5] ||
5248                     (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
5249                 && (stab->flags & SEC_MERGE) == 0
5250                 && !bfd_is_abs_section (stab->output_section))
5251               {
5252                 struct bfd_elf_section_data *secdata;
5253
5254                 secdata = elf_section_data (stab);
5255                 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
5256                                                stabstr, &secdata->sec_info,
5257                                                &string_offset))
5258                   goto error_return;
5259                 if (secdata->sec_info)
5260                   stab->sec_info_type = SEC_INFO_TYPE_STABS;
5261             }
5262         }
5263     }
5264
5265   if (is_elf_hash_table (htab) && add_needed)
5266     {
5267       /* Add this bfd to the loaded list.  */
5268       struct elf_link_loaded_list *n;
5269
5270       n = (struct elf_link_loaded_list *) bfd_alloc (abfd, sizeof (*n));
5271       if (n == NULL)
5272         goto error_return;
5273       n->abfd = abfd;
5274       n->next = htab->loaded;
5275       htab->loaded = n;
5276     }
5277
5278   return TRUE;
5279
5280  error_free_vers:
5281   if (old_tab != NULL)
5282     free (old_tab);
5283   if (old_strtab != NULL)
5284     free (old_strtab);
5285   if (nondeflt_vers != NULL)
5286     free (nondeflt_vers);
5287   if (extversym != NULL)
5288     free (extversym);
5289  error_free_sym:
5290   if (isymbuf != NULL)
5291     free (isymbuf);
5292  error_return:
5293   return FALSE;
5294 }
5295
5296 /* Return the linker hash table entry of a symbol that might be
5297    satisfied by an archive symbol.  Return -1 on error.  */
5298
5299 struct elf_link_hash_entry *
5300 _bfd_elf_archive_symbol_lookup (bfd *abfd,
5301                                 struct bfd_link_info *info,
5302                                 const char *name)
5303 {
5304   struct elf_link_hash_entry *h;
5305   char *p, *copy;
5306   size_t len, first;
5307
5308   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
5309   if (h != NULL)
5310     return h;
5311
5312   /* If this is a default version (the name contains @@), look up the
5313      symbol again with only one `@' as well as without the version.
5314      The effect is that references to the symbol with and without the
5315      version will be matched by the default symbol in the archive.  */
5316
5317   p = strchr (name, ELF_VER_CHR);
5318   if (p == NULL || p[1] != ELF_VER_CHR)
5319     return h;
5320
5321   /* First check with only one `@'.  */
5322   len = strlen (name);
5323   copy = (char *) bfd_alloc (abfd, len);
5324   if (copy == NULL)
5325     return (struct elf_link_hash_entry *) 0 - 1;
5326
5327   first = p - name + 1;
5328   memcpy (copy, name, first);
5329   memcpy (copy + first, name + first + 1, len - first);
5330
5331   h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
5332   if (h == NULL)
5333     {
5334       /* We also need to check references to the symbol without the
5335          version.  */
5336       copy[first - 1] = '\0';
5337       h = elf_link_hash_lookup (elf_hash_table (info), copy,
5338                                 FALSE, FALSE, TRUE);
5339     }
5340
5341   bfd_release (abfd, copy);
5342   return h;
5343 }
5344
5345 /* Add symbols from an ELF archive file to the linker hash table.  We
5346    don't use _bfd_generic_link_add_archive_symbols because we need to
5347    handle versioned symbols.
5348
5349    Fortunately, ELF archive handling is simpler than that done by
5350    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
5351    oddities.  In ELF, if we find a symbol in the archive map, and the
5352    symbol is currently undefined, we know that we must pull in that
5353    object file.
5354
5355    Unfortunately, we do have to make multiple passes over the symbol
5356    table until nothing further is resolved.  */
5357
5358 static bfd_boolean
5359 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
5360 {
5361   symindex c;
5362   unsigned char *included = NULL;
5363   carsym *symdefs;
5364   bfd_boolean loop;
5365   bfd_size_type amt;
5366   const struct elf_backend_data *bed;
5367   struct elf_link_hash_entry * (*archive_symbol_lookup)
5368     (bfd *, struct bfd_link_info *, const char *);
5369
5370   if (! bfd_has_map (abfd))
5371     {
5372       /* An empty archive is a special case.  */
5373       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
5374         return TRUE;
5375       bfd_set_error (bfd_error_no_armap);
5376       return FALSE;
5377     }
5378
5379   /* Keep track of all symbols we know to be already defined, and all
5380      files we know to be already included.  This is to speed up the
5381      second and subsequent passes.  */
5382   c = bfd_ardata (abfd)->symdef_count;
5383   if (c == 0)
5384     return TRUE;
5385   amt = c;
5386   amt *= sizeof (*included);
5387   included = (unsigned char *) bfd_zmalloc (amt);
5388   if (included == NULL)
5389     return FALSE;
5390
5391   symdefs = bfd_ardata (abfd)->symdefs;
5392   bed = get_elf_backend_data (abfd);
5393   archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
5394
5395   do
5396     {
5397       file_ptr last;
5398       symindex i;
5399       carsym *symdef;
5400       carsym *symdefend;
5401
5402       loop = FALSE;
5403       last = -1;
5404
5405       symdef = symdefs;
5406       symdefend = symdef + c;
5407       for (i = 0; symdef < symdefend; symdef++, i++)
5408         {
5409           struct elf_link_hash_entry *h;
5410           bfd *element;
5411           struct bfd_link_hash_entry *undefs_tail;
5412           symindex mark;
5413
5414           if (included[i])
5415             continue;
5416           if (symdef->file_offset == last)
5417             {
5418               included[i] = TRUE;
5419               continue;
5420             }
5421
5422           h = archive_symbol_lookup (abfd, info, symdef->name);
5423           if (h == (struct elf_link_hash_entry *) 0 - 1)
5424             goto error_return;
5425
5426           if (h == NULL)
5427             continue;
5428
5429           if (h->root.type == bfd_link_hash_common)
5430             {
5431               /* We currently have a common symbol.  The archive map contains
5432                  a reference to this symbol, so we may want to include it.  We
5433                  only want to include it however, if this archive element
5434                  contains a definition of the symbol, not just another common
5435                  declaration of it.
5436
5437                  Unfortunately some archivers (including GNU ar) will put
5438                  declarations of common symbols into their archive maps, as
5439                  well as real definitions, so we cannot just go by the archive
5440                  map alone.  Instead we must read in the element's symbol
5441                  table and check that to see what kind of symbol definition
5442                  this is.  */
5443               if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5444                 continue;
5445             }
5446           else if (h->root.type != bfd_link_hash_undefined)
5447             {
5448               if (h->root.type != bfd_link_hash_undefweak)
5449                 /* Symbol must be defined.  Don't check it again.  */
5450                 included[i] = TRUE;
5451               continue;
5452             }
5453
5454           /* We need to include this archive member.  */
5455           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5456           if (element == NULL)
5457             goto error_return;
5458
5459           if (! bfd_check_format (element, bfd_object))
5460             goto error_return;
5461
5462           undefs_tail = info->hash->undefs_tail;
5463
5464           if (!(*info->callbacks
5465                 ->add_archive_element) (info, element, symdef->name, &element))
5466             continue;
5467           if (!bfd_link_add_symbols (element, info))
5468             goto error_return;
5469
5470           /* If there are any new undefined symbols, we need to make
5471              another pass through the archive in order to see whether
5472              they can be defined.  FIXME: This isn't perfect, because
5473              common symbols wind up on undefs_tail and because an
5474              undefined symbol which is defined later on in this pass
5475              does not require another pass.  This isn't a bug, but it
5476              does make the code less efficient than it could be.  */
5477           if (undefs_tail != info->hash->undefs_tail)
5478             loop = TRUE;
5479
5480           /* Look backward to mark all symbols from this object file
5481              which we have already seen in this pass.  */
5482           mark = i;
5483           do
5484             {
5485               included[mark] = TRUE;
5486               if (mark == 0)
5487                 break;
5488               --mark;
5489             }
5490           while (symdefs[mark].file_offset == symdef->file_offset);
5491
5492           /* We mark subsequent symbols from this object file as we go
5493              on through the loop.  */
5494           last = symdef->file_offset;
5495         }
5496     }
5497   while (loop);
5498
5499   free (included);
5500
5501   return TRUE;
5502
5503  error_return:
5504   if (included != NULL)
5505     free (included);
5506   return FALSE;
5507 }
5508
5509 /* Given an ELF BFD, add symbols to the global hash table as
5510    appropriate.  */
5511
5512 bfd_boolean
5513 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5514 {
5515   switch (bfd_get_format (abfd))
5516     {
5517     case bfd_object:
5518       return elf_link_add_object_symbols (abfd, info);
5519     case bfd_archive:
5520       return elf_link_add_archive_symbols (abfd, info);
5521     default:
5522       bfd_set_error (bfd_error_wrong_format);
5523       return FALSE;
5524     }
5525 }
5526 \f
5527 struct hash_codes_info
5528 {
5529   unsigned long *hashcodes;
5530   bfd_boolean error;
5531 };
5532
5533 /* This function will be called though elf_link_hash_traverse to store
5534    all hash value of the exported symbols in an array.  */
5535
5536 static bfd_boolean
5537 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5538 {
5539   struct hash_codes_info *inf = (struct hash_codes_info *) data;
5540   const char *name;
5541   unsigned long ha;
5542   char *alc = NULL;
5543
5544   /* Ignore indirect symbols.  These are added by the versioning code.  */
5545   if (h->dynindx == -1)
5546     return TRUE;
5547
5548   name = h->root.root.string;
5549   if (h->versioned >= versioned)
5550     {
5551       char *p = strchr (name, ELF_VER_CHR);
5552       if (p != NULL)
5553         {
5554           alc = (char *) bfd_malloc (p - name + 1);
5555           if (alc == NULL)
5556             {
5557               inf->error = TRUE;
5558               return FALSE;
5559             }
5560           memcpy (alc, name, p - name);
5561           alc[p - name] = '\0';
5562           name = alc;
5563         }
5564     }
5565
5566   /* Compute the hash value.  */
5567   ha = bfd_elf_hash (name);
5568
5569   /* Store the found hash value in the array given as the argument.  */
5570   *(inf->hashcodes)++ = ha;
5571
5572   /* And store it in the struct so that we can put it in the hash table
5573      later.  */
5574   h->u.elf_hash_value = ha;
5575
5576   if (alc != NULL)
5577     free (alc);
5578
5579   return TRUE;
5580 }
5581
5582 struct collect_gnu_hash_codes
5583 {
5584   bfd *output_bfd;
5585   const struct elf_backend_data *bed;
5586   unsigned long int nsyms;
5587   unsigned long int maskbits;
5588   unsigned long int *hashcodes;
5589   unsigned long int *hashval;
5590   unsigned long int *indx;
5591   unsigned long int *counts;
5592   bfd_vma *bitmask;
5593   bfd_byte *contents;
5594   long int min_dynindx;
5595   unsigned long int bucketcount;
5596   unsigned long int symindx;
5597   long int local_indx;
5598   long int shift1, shift2;
5599   unsigned long int mask;
5600   bfd_boolean error;
5601 };
5602
5603 /* This function will be called though elf_link_hash_traverse to store
5604    all hash value of the exported symbols in an array.  */
5605
5606 static bfd_boolean
5607 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5608 {
5609   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5610   const char *name;
5611   unsigned long ha;
5612   char *alc = NULL;
5613
5614   /* Ignore indirect symbols.  These are added by the versioning code.  */
5615   if (h->dynindx == -1)
5616     return TRUE;
5617
5618   /* Ignore also local symbols and undefined symbols.  */
5619   if (! (*s->bed->elf_hash_symbol) (h))
5620     return TRUE;
5621
5622   name = h->root.root.string;
5623   if (h->versioned >= versioned)
5624     {
5625       char *p = strchr (name, ELF_VER_CHR);
5626       if (p != NULL)
5627         {
5628           alc = (char *) bfd_malloc (p - name + 1);
5629           if (alc == NULL)
5630             {
5631               s->error = TRUE;
5632               return FALSE;
5633             }
5634           memcpy (alc, name, p - name);
5635           alc[p - name] = '\0';
5636           name = alc;
5637         }
5638     }
5639
5640   /* Compute the hash value.  */
5641   ha = bfd_elf_gnu_hash (name);
5642
5643   /* Store the found hash value in the array for compute_bucket_count,
5644      and also for .dynsym reordering purposes.  */
5645   s->hashcodes[s->nsyms] = ha;
5646   s->hashval[h->dynindx] = ha;
5647   ++s->nsyms;
5648   if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5649     s->min_dynindx = h->dynindx;
5650
5651   if (alc != NULL)
5652     free (alc);
5653
5654   return TRUE;
5655 }
5656
5657 /* This function will be called though elf_link_hash_traverse to do
5658    final dynaminc symbol renumbering.  */
5659
5660 static bfd_boolean
5661 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5662 {
5663   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5664   unsigned long int bucket;
5665   unsigned long int val;
5666
5667   /* Ignore indirect symbols.  */
5668   if (h->dynindx == -1)
5669     return TRUE;
5670
5671   /* Ignore also local symbols and undefined symbols.  */
5672   if (! (*s->bed->elf_hash_symbol) (h))
5673     {
5674       if (h->dynindx >= s->min_dynindx)
5675         h->dynindx = s->local_indx++;
5676       return TRUE;
5677     }
5678
5679   bucket = s->hashval[h->dynindx] % s->bucketcount;
5680   val = (s->hashval[h->dynindx] >> s->shift1)
5681         & ((s->maskbits >> s->shift1) - 1);
5682   s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5683   s->bitmask[val]
5684     |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5685   val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5686   if (s->counts[bucket] == 1)
5687     /* Last element terminates the chain.  */
5688     val |= 1;
5689   bfd_put_32 (s->output_bfd, val,
5690               s->contents + (s->indx[bucket] - s->symindx) * 4);
5691   --s->counts[bucket];
5692   h->dynindx = s->indx[bucket]++;
5693   return TRUE;
5694 }
5695
5696 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5697
5698 bfd_boolean
5699 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5700 {
5701   return !(h->forced_local
5702            || h->root.type == bfd_link_hash_undefined
5703            || h->root.type == bfd_link_hash_undefweak
5704            || ((h->root.type == bfd_link_hash_defined
5705                 || h->root.type == bfd_link_hash_defweak)
5706                && h->root.u.def.section->output_section == NULL));
5707 }
5708
5709 /* Array used to determine the number of hash table buckets to use
5710    based on the number of symbols there are.  If there are fewer than
5711    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5712    fewer than 37 we use 17 buckets, and so forth.  We never use more
5713    than 32771 buckets.  */
5714
5715 static const size_t elf_buckets[] =
5716 {
5717   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5718   16411, 32771, 0
5719 };
5720
5721 /* Compute bucket count for hashing table.  We do not use a static set
5722    of possible tables sizes anymore.  Instead we determine for all
5723    possible reasonable sizes of the table the outcome (i.e., the
5724    number of collisions etc) and choose the best solution.  The
5725    weighting functions are not too simple to allow the table to grow
5726    without bounds.  Instead one of the weighting factors is the size.
5727    Therefore the result is always a good payoff between few collisions
5728    (= short chain lengths) and table size.  */
5729 static size_t
5730 compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5731                       unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5732                       unsigned long int nsyms,
5733                       int gnu_hash)
5734 {
5735   size_t best_size = 0;
5736   unsigned long int i;
5737
5738   /* We have a problem here.  The following code to optimize the table
5739      size requires an integer type with more the 32 bits.  If
5740      BFD_HOST_U_64_BIT is set we know about such a type.  */
5741 #ifdef BFD_HOST_U_64_BIT
5742   if (info->optimize)
5743     {
5744       size_t minsize;
5745       size_t maxsize;
5746       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5747       bfd *dynobj = elf_hash_table (info)->dynobj;
5748       size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5749       const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5750       unsigned long int *counts;
5751       bfd_size_type amt;
5752       unsigned int no_improvement_count = 0;
5753
5754       /* Possible optimization parameters: if we have NSYMS symbols we say
5755          that the hashing table must at least have NSYMS/4 and at most
5756          2*NSYMS buckets.  */
5757       minsize = nsyms / 4;
5758       if (minsize == 0)
5759         minsize = 1;
5760       best_size = maxsize = nsyms * 2;
5761       if (gnu_hash)
5762         {
5763           if (minsize < 2)
5764             minsize = 2;
5765           if ((best_size & 31) == 0)
5766             ++best_size;
5767         }
5768
5769       /* Create array where we count the collisions in.  We must use bfd_malloc
5770          since the size could be large.  */
5771       amt = maxsize;
5772       amt *= sizeof (unsigned long int);
5773       counts = (unsigned long int *) bfd_malloc (amt);
5774       if (counts == NULL)
5775         return 0;
5776
5777       /* Compute the "optimal" size for the hash table.  The criteria is a
5778          minimal chain length.  The minor criteria is (of course) the size
5779          of the table.  */
5780       for (i = minsize; i < maxsize; ++i)
5781         {
5782           /* Walk through the array of hashcodes and count the collisions.  */
5783           BFD_HOST_U_64_BIT max;
5784           unsigned long int j;
5785           unsigned long int fact;
5786
5787           if (gnu_hash && (i & 31) == 0)
5788             continue;
5789
5790           memset (counts, '\0', i * sizeof (unsigned long int));
5791
5792           /* Determine how often each hash bucket is used.  */
5793           for (j = 0; j < nsyms; ++j)
5794             ++counts[hashcodes[j] % i];
5795
5796           /* For the weight function we need some information about the
5797              pagesize on the target.  This is information need not be 100%
5798              accurate.  Since this information is not available (so far) we
5799              define it here to a reasonable default value.  If it is crucial
5800              to have a better value some day simply define this value.  */
5801 # ifndef BFD_TARGET_PAGESIZE
5802 #  define BFD_TARGET_PAGESIZE   (4096)
5803 # endif
5804
5805           /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5806              and the chains.  */
5807           max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5808
5809 # if 1
5810           /* Variant 1: optimize for short chains.  We add the squares
5811              of all the chain lengths (which favors many small chain
5812              over a few long chains).  */
5813           for (j = 0; j < i; ++j)
5814             max += counts[j] * counts[j];
5815
5816           /* This adds penalties for the overall size of the table.  */
5817           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5818           max *= fact * fact;
5819 # else
5820           /* Variant 2: Optimize a lot more for small table.  Here we
5821              also add squares of the size but we also add penalties for
5822              empty slots (the +1 term).  */
5823           for (j = 0; j < i; ++j)
5824             max += (1 + counts[j]) * (1 + counts[j]);
5825
5826           /* The overall size of the table is considered, but not as
5827              strong as in variant 1, where it is squared.  */
5828           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5829           max *= fact;
5830 # endif
5831
5832           /* Compare with current best results.  */
5833           if (max < best_chlen)
5834             {
5835               best_chlen = max;
5836               best_size = i;
5837               no_improvement_count = 0;
5838             }
5839           /* PR 11843: Avoid futile long searches for the best bucket size
5840              when there are a large number of symbols.  */
5841           else if (++no_improvement_count == 100)
5842             break;
5843         }
5844
5845       free (counts);
5846     }
5847   else
5848 #endif /* defined (BFD_HOST_U_64_BIT) */
5849     {
5850       /* This is the fallback solution if no 64bit type is available or if we
5851          are not supposed to spend much time on optimizations.  We select the
5852          bucket count using a fixed set of numbers.  */
5853       for (i = 0; elf_buckets[i] != 0; i++)
5854         {
5855           best_size = elf_buckets[i];
5856           if (nsyms < elf_buckets[i + 1])
5857             break;
5858         }
5859       if (gnu_hash && best_size < 2)
5860         best_size = 2;
5861     }
5862
5863   return best_size;
5864 }
5865
5866 /* Size any SHT_GROUP section for ld -r.  */
5867
5868 bfd_boolean
5869 _bfd_elf_size_group_sections (struct bfd_link_info *info)
5870 {
5871   bfd *ibfd;
5872   asection *s;
5873
5874   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5875     if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5876         && (s = ibfd->sections) != NULL
5877         && s->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
5878         && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5879       return FALSE;
5880   return TRUE;
5881 }
5882
5883 /* Set a default stack segment size.  The value in INFO wins.  If it
5884    is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5885    undefined it is initialized.  */
5886
5887 bfd_boolean
5888 bfd_elf_stack_segment_size (bfd *output_bfd,
5889                             struct bfd_link_info *info,
5890                             const char *legacy_symbol,
5891                             bfd_vma default_size)
5892 {
5893   struct elf_link_hash_entry *h = NULL;
5894
5895   /* Look for legacy symbol.  */
5896   if (legacy_symbol)
5897     h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
5898                               FALSE, FALSE, FALSE);
5899   if (h && (h->root.type == bfd_link_hash_defined
5900             || h->root.type == bfd_link_hash_defweak)
5901       && h->def_regular
5902       && (h->type == STT_NOTYPE || h->type == STT_OBJECT))
5903     {
5904       /* The symbol has no type if specified on the command line.  */
5905       h->type = STT_OBJECT;
5906       if (info->stacksize)
5907         /* xgettext:c-format */
5908         _bfd_error_handler (_("%B: stack size specified and %s set"),
5909                             output_bfd, legacy_symbol);
5910       else if (h->root.u.def.section != bfd_abs_section_ptr)
5911         /* xgettext:c-format */
5912         _bfd_error_handler (_("%B: %s not absolute"),
5913                             output_bfd, legacy_symbol);
5914       else
5915         info->stacksize = h->root.u.def.value;
5916     }
5917
5918   if (!info->stacksize)
5919     /* If the user didn't set a size, or explicitly inhibit the
5920        size, set it now.  */
5921     info->stacksize = default_size;
5922
5923   /* Provide the legacy symbol, if it is referenced.  */
5924   if (h && (h->root.type == bfd_link_hash_undefined
5925             || h->root.type == bfd_link_hash_undefweak))
5926     {
5927       struct bfd_link_hash_entry *bh = NULL;
5928
5929       if (!(_bfd_generic_link_add_one_symbol
5930             (info, output_bfd, legacy_symbol,
5931              BSF_GLOBAL, bfd_abs_section_ptr,
5932              info->stacksize >= 0 ? info->stacksize : 0,
5933              NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
5934         return FALSE;
5935
5936       h = (struct elf_link_hash_entry *) bh;
5937       h->def_regular = 1;
5938       h->type = STT_OBJECT;
5939     }
5940
5941   return TRUE;
5942 }
5943
5944 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
5945
5946 struct elf_gc_sweep_symbol_info
5947 {
5948   struct bfd_link_info *info;
5949   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
5950                        bfd_boolean);
5951 };
5952
5953 static bfd_boolean
5954 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
5955 {
5956   if (!h->mark
5957       && (((h->root.type == bfd_link_hash_defined
5958             || h->root.type == bfd_link_hash_defweak)
5959            && !((h->def_regular || ELF_COMMON_DEF_P (h))
5960                 && h->root.u.def.section->gc_mark))
5961           || h->root.type == bfd_link_hash_undefined
5962           || h->root.type == bfd_link_hash_undefweak))
5963     {
5964       struct elf_gc_sweep_symbol_info *inf;
5965
5966       inf = (struct elf_gc_sweep_symbol_info *) data;
5967       (*inf->hide_symbol) (inf->info, h, TRUE);
5968       h->def_regular = 0;
5969       h->ref_regular = 0;
5970       h->ref_regular_nonweak = 0;
5971     }
5972
5973   return TRUE;
5974 }
5975
5976 /* Set up the sizes and contents of the ELF dynamic sections.  This is
5977    called by the ELF linker emulation before_allocation routine.  We
5978    must set the sizes of the sections before the linker sets the
5979    addresses of the various sections.  */
5980
5981 bfd_boolean
5982 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5983                                const char *soname,
5984                                const char *rpath,
5985                                const char *filter_shlib,
5986                                const char *audit,
5987                                const char *depaudit,
5988                                const char * const *auxiliary_filters,
5989                                struct bfd_link_info *info,
5990                                asection **sinterpptr)
5991 {
5992   bfd *dynobj;
5993   const struct elf_backend_data *bed;
5994
5995   *sinterpptr = NULL;
5996
5997   if (!is_elf_hash_table (info->hash))
5998     return TRUE;
5999
6000   dynobj = elf_hash_table (info)->dynobj;
6001
6002   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
6003     {
6004       struct bfd_elf_version_tree *verdefs;
6005       struct elf_info_failed asvinfo;
6006       struct bfd_elf_version_tree *t;
6007       struct bfd_elf_version_expr *d;
6008       struct elf_info_failed eif;
6009       bfd_boolean all_defined;
6010       asection *s;
6011       size_t soname_indx;
6012
6013       eif.info = info;
6014       eif.failed = FALSE;
6015
6016       /* If we are supposed to export all symbols into the dynamic symbol
6017          table (this is not the normal case), then do so.  */
6018       if (info->export_dynamic
6019           || (bfd_link_executable (info) && info->dynamic))
6020         {
6021           elf_link_hash_traverse (elf_hash_table (info),
6022                                   _bfd_elf_export_symbol,
6023                                   &eif);
6024           if (eif.failed)
6025             return FALSE;
6026         }
6027
6028       if (soname != NULL)
6029         {
6030           soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6031                                              soname, TRUE);
6032           if (soname_indx == (size_t) -1
6033               || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
6034             return FALSE;
6035         }
6036       else
6037         soname_indx = (size_t) -1;
6038
6039       /* Make all global versions with definition.  */
6040       for (t = info->version_info; t != NULL; t = t->next)
6041         for (d = t->globals.list; d != NULL; d = d->next)
6042           if (!d->symver && d->literal)
6043             {
6044               const char *verstr, *name;
6045               size_t namelen, verlen, newlen;
6046               char *newname, *p, leading_char;
6047               struct elf_link_hash_entry *newh;
6048
6049               leading_char = bfd_get_symbol_leading_char (output_bfd);
6050               name = d->pattern;
6051               namelen = strlen (name) + (leading_char != '\0');
6052               verstr = t->name;
6053               verlen = strlen (verstr);
6054               newlen = namelen + verlen + 3;
6055
6056               newname = (char *) bfd_malloc (newlen);
6057               if (newname == NULL)
6058                 return FALSE;
6059               newname[0] = leading_char;
6060               memcpy (newname + (leading_char != '\0'), name, namelen);
6061
6062               /* Check the hidden versioned definition.  */
6063               p = newname + namelen;
6064               *p++ = ELF_VER_CHR;
6065               memcpy (p, verstr, verlen + 1);
6066               newh = elf_link_hash_lookup (elf_hash_table (info),
6067                                            newname, FALSE, FALSE,
6068                                            FALSE);
6069               if (newh == NULL
6070                   || (newh->root.type != bfd_link_hash_defined
6071                       && newh->root.type != bfd_link_hash_defweak))
6072                 {
6073                   /* Check the default versioned definition.  */
6074                   *p++ = ELF_VER_CHR;
6075                   memcpy (p, verstr, verlen + 1);
6076                   newh = elf_link_hash_lookup (elf_hash_table (info),
6077                                                newname, FALSE, FALSE,
6078                                                FALSE);
6079                 }
6080               free (newname);
6081
6082               /* Mark this version if there is a definition and it is
6083                  not defined in a shared object.  */
6084               if (newh != NULL
6085                   && !newh->def_dynamic
6086                   && (newh->root.type == bfd_link_hash_defined
6087                       || newh->root.type == bfd_link_hash_defweak))
6088                 d->symver = 1;
6089             }
6090
6091       /* Attach all the symbols to their version information.  */
6092       asvinfo.info = info;
6093       asvinfo.failed = FALSE;
6094
6095       elf_link_hash_traverse (elf_hash_table (info),
6096                               _bfd_elf_link_assign_sym_version,
6097                               &asvinfo);
6098       if (asvinfo.failed)
6099         return FALSE;
6100
6101       if (!info->allow_undefined_version)
6102         {
6103           /* Check if all global versions have a definition.  */
6104           all_defined = TRUE;
6105           for (t = info->version_info; t != NULL; t = t->next)
6106             for (d = t->globals.list; d != NULL; d = d->next)
6107               if (d->literal && !d->symver && !d->script)
6108                 {
6109                   _bfd_error_handler
6110                     (_("%s: undefined version: %s"),
6111                      d->pattern, t->name);
6112                   all_defined = FALSE;
6113                 }
6114
6115           if (!all_defined)
6116             {
6117               bfd_set_error (bfd_error_bad_value);
6118               return FALSE;
6119             }
6120         }
6121
6122       /* Set up the version definition section.  */
6123       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
6124       BFD_ASSERT (s != NULL);
6125
6126       /* We may have created additional version definitions if we are
6127          just linking a regular application.  */
6128       verdefs = info->version_info;
6129
6130       /* Skip anonymous version tag.  */
6131       if (verdefs != NULL && verdefs->vernum == 0)
6132         verdefs = verdefs->next;
6133
6134       if (verdefs == NULL && !info->create_default_symver)
6135         s->flags |= SEC_EXCLUDE;
6136       else
6137         {
6138           unsigned int cdefs;
6139           bfd_size_type size;
6140           bfd_byte *p;
6141           Elf_Internal_Verdef def;
6142           Elf_Internal_Verdaux defaux;
6143           struct bfd_link_hash_entry *bh;
6144           struct elf_link_hash_entry *h;
6145           const char *name;
6146
6147           cdefs = 0;
6148           size = 0;
6149
6150           /* Make space for the base version.  */
6151           size += sizeof (Elf_External_Verdef);
6152           size += sizeof (Elf_External_Verdaux);
6153           ++cdefs;
6154
6155           /* Make space for the default version.  */
6156           if (info->create_default_symver)
6157             {
6158               size += sizeof (Elf_External_Verdef);
6159               ++cdefs;
6160             }
6161
6162           for (t = verdefs; t != NULL; t = t->next)
6163             {
6164               struct bfd_elf_version_deps *n;
6165
6166               /* Don't emit base version twice.  */
6167               if (t->vernum == 0)
6168                 continue;
6169
6170               size += sizeof (Elf_External_Verdef);
6171               size += sizeof (Elf_External_Verdaux);
6172               ++cdefs;
6173
6174               for (n = t->deps; n != NULL; n = n->next)
6175                 size += sizeof (Elf_External_Verdaux);
6176             }
6177
6178           s->size = size;
6179           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6180           if (s->contents == NULL && s->size != 0)
6181             return FALSE;
6182
6183           /* Fill in the version definition section.  */
6184
6185           p = s->contents;
6186
6187           def.vd_version = VER_DEF_CURRENT;
6188           def.vd_flags = VER_FLG_BASE;
6189           def.vd_ndx = 1;
6190           def.vd_cnt = 1;
6191           if (info->create_default_symver)
6192             {
6193               def.vd_aux = 2 * sizeof (Elf_External_Verdef);
6194               def.vd_next = sizeof (Elf_External_Verdef);
6195             }
6196           else
6197             {
6198               def.vd_aux = sizeof (Elf_External_Verdef);
6199               def.vd_next = (sizeof (Elf_External_Verdef)
6200                              + sizeof (Elf_External_Verdaux));
6201             }
6202
6203           if (soname_indx != (size_t) -1)
6204             {
6205               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6206                                       soname_indx);
6207               def.vd_hash = bfd_elf_hash (soname);
6208               defaux.vda_name = soname_indx;
6209               name = soname;
6210             }
6211           else
6212             {
6213               size_t indx;
6214
6215               name = lbasename (output_bfd->filename);
6216               def.vd_hash = bfd_elf_hash (name);
6217               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6218                                           name, FALSE);
6219               if (indx == (size_t) -1)
6220                 return FALSE;
6221               defaux.vda_name = indx;
6222             }
6223           defaux.vda_next = 0;
6224
6225           _bfd_elf_swap_verdef_out (output_bfd, &def,
6226                                     (Elf_External_Verdef *) p);
6227           p += sizeof (Elf_External_Verdef);
6228           if (info->create_default_symver)
6229             {
6230               /* Add a symbol representing this version.  */
6231               bh = NULL;
6232               if (! (_bfd_generic_link_add_one_symbol
6233                      (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6234                       0, NULL, FALSE,
6235                       get_elf_backend_data (dynobj)->collect, &bh)))
6236                 return FALSE;
6237               h = (struct elf_link_hash_entry *) bh;
6238               h->non_elf = 0;
6239               h->def_regular = 1;
6240               h->type = STT_OBJECT;
6241               h->verinfo.vertree = NULL;
6242
6243               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6244                 return FALSE;
6245
6246               /* Create a duplicate of the base version with the same
6247                  aux block, but different flags.  */
6248               def.vd_flags = 0;
6249               def.vd_ndx = 2;
6250               def.vd_aux = sizeof (Elf_External_Verdef);
6251               if (verdefs)
6252                 def.vd_next = (sizeof (Elf_External_Verdef)
6253                                + sizeof (Elf_External_Verdaux));
6254               else
6255                 def.vd_next = 0;
6256               _bfd_elf_swap_verdef_out (output_bfd, &def,
6257                                         (Elf_External_Verdef *) p);
6258               p += sizeof (Elf_External_Verdef);
6259             }
6260           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6261                                      (Elf_External_Verdaux *) p);
6262           p += sizeof (Elf_External_Verdaux);
6263
6264           for (t = verdefs; t != NULL; t = t->next)
6265             {
6266               unsigned int cdeps;
6267               struct bfd_elf_version_deps *n;
6268
6269               /* Don't emit the base version twice.  */
6270               if (t->vernum == 0)
6271                 continue;
6272
6273               cdeps = 0;
6274               for (n = t->deps; n != NULL; n = n->next)
6275                 ++cdeps;
6276
6277               /* Add a symbol representing this version.  */
6278               bh = NULL;
6279               if (! (_bfd_generic_link_add_one_symbol
6280                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6281                       0, NULL, FALSE,
6282                       get_elf_backend_data (dynobj)->collect, &bh)))
6283                 return FALSE;
6284               h = (struct elf_link_hash_entry *) bh;
6285               h->non_elf = 0;
6286               h->def_regular = 1;
6287               h->type = STT_OBJECT;
6288               h->verinfo.vertree = t;
6289
6290               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6291                 return FALSE;
6292
6293               def.vd_version = VER_DEF_CURRENT;
6294               def.vd_flags = 0;
6295               if (t->globals.list == NULL
6296                   && t->locals.list == NULL
6297                   && ! t->used)
6298                 def.vd_flags |= VER_FLG_WEAK;
6299               def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6300               def.vd_cnt = cdeps + 1;
6301               def.vd_hash = bfd_elf_hash (t->name);
6302               def.vd_aux = sizeof (Elf_External_Verdef);
6303               def.vd_next = 0;
6304
6305               /* If a basever node is next, it *must* be the last node in
6306                  the chain, otherwise Verdef construction breaks.  */
6307               if (t->next != NULL && t->next->vernum == 0)
6308                 BFD_ASSERT (t->next->next == NULL);
6309
6310               if (t->next != NULL && t->next->vernum != 0)
6311                 def.vd_next = (sizeof (Elf_External_Verdef)
6312                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6313
6314               _bfd_elf_swap_verdef_out (output_bfd, &def,
6315                                         (Elf_External_Verdef *) p);
6316               p += sizeof (Elf_External_Verdef);
6317
6318               defaux.vda_name = h->dynstr_index;
6319               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6320                                       h->dynstr_index);
6321               defaux.vda_next = 0;
6322               if (t->deps != NULL)
6323                 defaux.vda_next = sizeof (Elf_External_Verdaux);
6324               t->name_indx = defaux.vda_name;
6325
6326               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6327                                          (Elf_External_Verdaux *) p);
6328               p += sizeof (Elf_External_Verdaux);
6329
6330               for (n = t->deps; n != NULL; n = n->next)
6331                 {
6332                   if (n->version_needed == NULL)
6333                     {
6334                       /* This can happen if there was an error in the
6335                          version script.  */
6336                       defaux.vda_name = 0;
6337                     }
6338                   else
6339                     {
6340                       defaux.vda_name = n->version_needed->name_indx;
6341                       _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6342                                               defaux.vda_name);
6343                     }
6344                   if (n->next == NULL)
6345                     defaux.vda_next = 0;
6346                   else
6347                     defaux.vda_next = sizeof (Elf_External_Verdaux);
6348
6349                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6350                                              (Elf_External_Verdaux *) p);
6351                   p += sizeof (Elf_External_Verdaux);
6352                 }
6353             }
6354
6355           elf_tdata (output_bfd)->cverdefs = cdefs;
6356         }
6357
6358       /* Work out the size of the version reference section.  */
6359
6360       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
6361       BFD_ASSERT (s != NULL);
6362       {
6363         struct elf_find_verdep_info sinfo;
6364
6365         sinfo.info = info;
6366         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6367         if (sinfo.vers == 0)
6368           sinfo.vers = 1;
6369         sinfo.failed = FALSE;
6370
6371         elf_link_hash_traverse (elf_hash_table (info),
6372                                 _bfd_elf_link_find_version_dependencies,
6373                                 &sinfo);
6374         if (sinfo.failed)
6375           return FALSE;
6376
6377         if (elf_tdata (output_bfd)->verref == NULL)
6378           s->flags |= SEC_EXCLUDE;
6379         else
6380           {
6381             Elf_Internal_Verneed *vn;
6382             unsigned int size;
6383             unsigned int crefs;
6384             bfd_byte *p;
6385
6386             /* Build the version dependency section.  */
6387             size = 0;
6388             crefs = 0;
6389             for (vn = elf_tdata (output_bfd)->verref;
6390                  vn != NULL;
6391                  vn = vn->vn_nextref)
6392               {
6393                 Elf_Internal_Vernaux *a;
6394
6395                 size += sizeof (Elf_External_Verneed);
6396                 ++crefs;
6397                 for (a = vn->vn_auxptr; a != NULL; a = a->vna_nextptr)
6398                   size += sizeof (Elf_External_Vernaux);
6399               }
6400
6401             s->size = size;
6402             s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6403             if (s->contents == NULL)
6404               return FALSE;
6405
6406             p = s->contents;
6407             for (vn = elf_tdata (output_bfd)->verref;
6408                  vn != NULL;
6409                  vn = vn->vn_nextref)
6410               {
6411                 unsigned int caux;
6412                 Elf_Internal_Vernaux *a;
6413                 size_t indx;
6414
6415                 caux = 0;
6416                 for (a = vn->vn_auxptr; a != NULL; a = a->vna_nextptr)
6417                   ++caux;
6418
6419                 vn->vn_version = VER_NEED_CURRENT;
6420                 vn->vn_cnt = caux;
6421                 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6422                                             elf_dt_name (vn->vn_bfd) != NULL
6423                                             ? elf_dt_name (vn->vn_bfd)
6424                                             : lbasename (vn->vn_bfd->filename),
6425                                             FALSE);
6426                 if (indx == (size_t) -1)
6427                   return FALSE;
6428                 vn->vn_file = indx;
6429                 vn->vn_aux = sizeof (Elf_External_Verneed);
6430                 if (vn->vn_nextref == NULL)
6431                   vn->vn_next = 0;
6432                 else
6433                   vn->vn_next = (sizeof (Elf_External_Verneed)
6434                                 + caux * sizeof (Elf_External_Vernaux));
6435
6436                 _bfd_elf_swap_verneed_out (output_bfd, vn,
6437                                            (Elf_External_Verneed *) p);
6438                 p += sizeof (Elf_External_Verneed);
6439
6440                 for (a = vn->vn_auxptr; a != NULL; a = a->vna_nextptr)
6441                   {
6442                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
6443                     indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6444                                                 a->vna_nodename, FALSE);
6445                     if (indx == (size_t) -1)
6446                       return FALSE;
6447                     a->vna_name = indx;
6448                     if (a->vna_nextptr == NULL)
6449                       a->vna_next = 0;
6450                     else
6451                       a->vna_next = sizeof (Elf_External_Vernaux);
6452
6453                     _bfd_elf_swap_vernaux_out (output_bfd, a,
6454                                                (Elf_External_Vernaux *) p);
6455                     p += sizeof (Elf_External_Vernaux);
6456                   }
6457               }
6458
6459             elf_tdata (output_bfd)->cverrefs = crefs;
6460           }
6461       }
6462     }
6463
6464   bed = get_elf_backend_data (output_bfd);
6465
6466   if (info->gc_sections && bed->can_gc_sections)
6467     {
6468       struct elf_gc_sweep_symbol_info sweep_info;
6469       unsigned long section_sym_count;
6470
6471       /* Remove the symbols that were in the swept sections from the
6472          dynamic symbol table.  GCFIXME: Anyone know how to get them
6473          out of the static symbol table as well?  */
6474       sweep_info.info = info;
6475       sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
6476       elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
6477                               &sweep_info);
6478
6479       /* We need to reassign dynsym indices now that symbols may have
6480          been removed.  See the call in `bfd_elf_size_dynsym_hash_dynstr'
6481          for the details of the conditions used here.  */
6482       if (elf_hash_table (info)->dynamic_sections_created
6483           || bed->always_renumber_dynsyms)
6484         _bfd_elf_link_renumber_dynsyms (output_bfd, info, &section_sym_count);
6485     }
6486
6487   /* Any syms created from now on start with -1 in
6488      got.refcount/offset and plt.refcount/offset.  */
6489   elf_hash_table (info)->init_got_refcount
6490     = elf_hash_table (info)->init_got_offset;
6491   elf_hash_table (info)->init_plt_refcount
6492     = elf_hash_table (info)->init_plt_offset;
6493
6494   if (bfd_link_relocatable (info)
6495       && !_bfd_elf_size_group_sections (info))
6496     return FALSE;
6497
6498   /* The backend may have to create some sections regardless of whether
6499      we're dynamic or not.  */
6500   if (bed->elf_backend_always_size_sections
6501       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
6502     return FALSE;
6503
6504   /* Determine any GNU_STACK segment requirements, after the backend
6505      has had a chance to set a default segment size.  */
6506   if (info->execstack)
6507     elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
6508   else if (info->noexecstack)
6509     elf_stack_flags (output_bfd) = PF_R | PF_W;
6510   else
6511     {
6512       bfd *inputobj;
6513       asection *notesec = NULL;
6514       int exec = 0;
6515
6516       for (inputobj = info->input_bfds;
6517            inputobj;
6518            inputobj = inputobj->link.next)
6519         {
6520           asection *s;
6521
6522           if (inputobj->flags
6523               & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
6524             continue;
6525           s = inputobj->sections;
6526           if (s == NULL || s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
6527             continue;
6528
6529           s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
6530           if (s)
6531             {
6532               if (s->flags & SEC_CODE)
6533                 exec = PF_X;
6534               notesec = s;
6535             }
6536           else if (bed->default_execstack)
6537             exec = PF_X;
6538         }
6539       if (notesec || info->stacksize > 0)
6540         elf_stack_flags (output_bfd) = PF_R | PF_W | exec;
6541       if (notesec && exec && bfd_link_relocatable (info)
6542           && notesec->output_section != bfd_abs_section_ptr)
6543         notesec->output_section->flags |= SEC_CODE;
6544     }
6545
6546   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
6547     {
6548       struct elf_info_failed eif;
6549       struct elf_link_hash_entry *h;
6550       asection *dynstr;
6551       asection *s;
6552
6553       *sinterpptr = bfd_get_linker_section (dynobj, ".interp");
6554       BFD_ASSERT (*sinterpptr != NULL || !bfd_link_executable (info) || info->nointerp);
6555
6556       if (info->symbolic)
6557         {
6558           if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
6559             return FALSE;
6560           info->flags |= DF_SYMBOLIC;
6561         }
6562
6563       if (rpath != NULL)
6564         {
6565           size_t indx;
6566           bfd_vma tag;
6567
6568           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
6569                                       TRUE);
6570           if (indx == (size_t) -1)
6571             return FALSE;
6572
6573           tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
6574           if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
6575             return FALSE;
6576         }
6577
6578       if (filter_shlib != NULL)
6579         {
6580           size_t indx;
6581
6582           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6583                                       filter_shlib, TRUE);
6584           if (indx == (size_t) -1
6585               || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
6586             return FALSE;
6587         }
6588
6589       if (auxiliary_filters != NULL)
6590         {
6591           const char * const *p;
6592
6593           for (p = auxiliary_filters; *p != NULL; p++)
6594             {
6595               size_t indx;
6596
6597               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6598                                           *p, TRUE);
6599               if (indx == (size_t) -1
6600                   || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
6601                 return FALSE;
6602             }
6603         }
6604
6605       if (audit != NULL)
6606         {
6607           size_t indx;
6608
6609           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
6610                                       TRUE);
6611           if (indx == (size_t) -1
6612               || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
6613             return FALSE;
6614         }
6615
6616       if (depaudit != NULL)
6617         {
6618           size_t indx;
6619
6620           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
6621                                       TRUE);
6622           if (indx == (size_t) -1
6623               || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
6624             return FALSE;
6625         }
6626
6627       eif.info = info;
6628       eif.failed = FALSE;
6629
6630       /* Find all symbols which were defined in a dynamic object and make
6631          the backend pick a reasonable value for them.  */
6632       elf_link_hash_traverse (elf_hash_table (info),
6633                               _bfd_elf_adjust_dynamic_symbol,
6634                               &eif);
6635       if (eif.failed)
6636         return FALSE;
6637
6638       /* Add some entries to the .dynamic section.  We fill in some of the
6639          values later, in bfd_elf_final_link, but we must add the entries
6640          now so that we know the final size of the .dynamic section.  */
6641
6642       /* If there are initialization and/or finalization functions to
6643          call then add the corresponding DT_INIT/DT_FINI entries.  */
6644       h = (info->init_function
6645            ? elf_link_hash_lookup (elf_hash_table (info),
6646                                    info->init_function, FALSE,
6647                                    FALSE, FALSE)
6648            : NULL);
6649       if (h != NULL
6650           && (h->ref_regular
6651               || h->def_regular))
6652         {
6653           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
6654             return FALSE;
6655         }
6656       h = (info->fini_function
6657            ? elf_link_hash_lookup (elf_hash_table (info),
6658                                    info->fini_function, FALSE,
6659                                    FALSE, FALSE)
6660            : NULL);
6661       if (h != NULL
6662           && (h->ref_regular
6663               || h->def_regular))
6664         {
6665           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
6666             return FALSE;
6667         }
6668
6669       s = bfd_get_section_by_name (output_bfd, ".preinit_array");
6670       if (s != NULL && s->linker_has_input)
6671         {
6672           /* DT_PREINIT_ARRAY is not allowed in shared library.  */
6673           if (! bfd_link_executable (info))
6674             {
6675               bfd *sub;
6676               asection *o;
6677
6678               for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
6679                 if (bfd_get_flavour (sub) == bfd_target_elf_flavour
6680                     && (o = sub->sections) != NULL
6681                     && o->sec_info_type != SEC_INFO_TYPE_JUST_SYMS)
6682                   for (o = sub->sections; o != NULL; o = o->next)
6683                     if (elf_section_data (o)->this_hdr.sh_type
6684                         == SHT_PREINIT_ARRAY)
6685                       {
6686                         _bfd_error_handler
6687                           (_("%B: .preinit_array section is not allowed in DSO"),
6688                            sub);
6689                         break;
6690                       }
6691
6692               bfd_set_error (bfd_error_nonrepresentable_section);
6693               return FALSE;
6694             }
6695
6696           if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
6697               || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
6698             return FALSE;
6699         }
6700       s = bfd_get_section_by_name (output_bfd, ".init_array");
6701       if (s != NULL && s->linker_has_input)
6702         {
6703           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
6704               || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
6705             return FALSE;
6706         }
6707       s = bfd_get_section_by_name (output_bfd, ".fini_array");
6708       if (s != NULL && s->linker_has_input)
6709         {
6710           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
6711               || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
6712             return FALSE;
6713         }
6714
6715       dynstr = bfd_get_linker_section (dynobj, ".dynstr");
6716       /* If .dynstr is excluded from the link, we don't want any of
6717          these tags.  Strictly, we should be checking each section
6718          individually;  This quick check covers for the case where
6719          someone does a /DISCARD/ : { *(*) }.  */
6720       if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
6721         {
6722           bfd_size_type strsize;
6723
6724           strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6725           if ((info->emit_hash
6726                && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
6727               || (info->emit_gnu_hash
6728                   && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
6729               || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
6730               || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
6731               || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
6732               || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
6733                                               bed->s->sizeof_sym))
6734             return FALSE;
6735         }
6736     }
6737
6738   if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
6739     return FALSE;
6740
6741   /* The backend must work out the sizes of all the other dynamic
6742      sections.  */
6743   if (dynobj != NULL
6744       && bed->elf_backend_size_dynamic_sections != NULL
6745       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
6746     return FALSE;
6747
6748   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
6749     {
6750       unsigned long section_sym_count;
6751
6752       if (elf_tdata (output_bfd)->cverdefs)
6753         {
6754           unsigned int crefs = elf_tdata (output_bfd)->cverdefs;
6755
6756           if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6757               || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, crefs))
6758             return FALSE;
6759         }
6760
6761       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6762         {
6763           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6764             return FALSE;
6765         }
6766       else if (info->flags & DF_BIND_NOW)
6767         {
6768           if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6769             return FALSE;
6770         }
6771
6772       if (info->flags_1)
6773         {
6774           if (bfd_link_executable (info))
6775             info->flags_1 &= ~ (DF_1_INITFIRST
6776                                 | DF_1_NODELETE
6777                                 | DF_1_NOOPEN);
6778           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6779             return FALSE;
6780         }
6781
6782       if (elf_tdata (output_bfd)->cverrefs)
6783         {
6784           unsigned int crefs = elf_tdata (output_bfd)->cverrefs;
6785
6786           if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6787               || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6788             return FALSE;
6789         }
6790
6791       if ((elf_tdata (output_bfd)->cverrefs == 0
6792            && elf_tdata (output_bfd)->cverdefs == 0)
6793           || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6794                                              &section_sym_count) == 0)
6795         {
6796           asection *s;
6797
6798           s = bfd_get_linker_section (dynobj, ".gnu.version");
6799           s->flags |= SEC_EXCLUDE;
6800         }
6801     }
6802   return TRUE;
6803 }
6804
6805 /* Find the first non-excluded output section.  We'll use its
6806    section symbol for some emitted relocs.  */
6807 void
6808 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6809 {
6810   asection *s;
6811
6812   for (s = output_bfd->sections; s != NULL; s = s->next)
6813     if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6814         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6815       {
6816         elf_hash_table (info)->text_index_section = s;
6817         break;
6818       }
6819 }
6820
6821 /* Find two non-excluded output sections, one for code, one for data.
6822    We'll use their section symbols for some emitted relocs.  */
6823 void
6824 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6825 {
6826   asection *s;
6827
6828   /* Data first, since setting text_index_section changes
6829      _bfd_elf_link_omit_section_dynsym.  */
6830   for (s = output_bfd->sections; s != NULL; s = s->next)
6831     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6832         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6833       {
6834         elf_hash_table (info)->data_index_section = s;
6835         break;
6836       }
6837
6838   for (s = output_bfd->sections; s != NULL; s = s->next)
6839     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6840          == (SEC_ALLOC | SEC_READONLY))
6841         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6842       {
6843         elf_hash_table (info)->text_index_section = s;
6844         break;
6845       }
6846
6847   if (elf_hash_table (info)->text_index_section == NULL)
6848     elf_hash_table (info)->text_index_section
6849       = elf_hash_table (info)->data_index_section;
6850 }
6851
6852 bfd_boolean
6853 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6854 {
6855   const struct elf_backend_data *bed;
6856   unsigned long section_sym_count;
6857   bfd_size_type dynsymcount;
6858
6859   if (!is_elf_hash_table (info->hash))
6860     return TRUE;
6861
6862   bed = get_elf_backend_data (output_bfd);
6863   (*bed->elf_backend_init_index_section) (output_bfd, info);
6864
6865   /* Assign dynsym indices.  In a shared library we generate a section
6866      symbol for each output section, which come first.  Next come all
6867      of the back-end allocated local dynamic syms, followed by the rest
6868      of the global symbols.
6869
6870      This is usually not needed for static binaries, however backends
6871      can request to always do it, e.g. the MIPS backend uses dynamic
6872      symbol counts to lay out GOT, which will be produced in the
6873      presence of GOT relocations even in static binaries (holding fixed
6874      data in that case, to satisfy those relocations).  */
6875
6876   if (elf_hash_table (info)->dynamic_sections_created
6877       || bed->always_renumber_dynsyms)
6878     dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6879                                                   &section_sym_count);
6880
6881   if (elf_hash_table (info)->dynamic_sections_created)
6882     {
6883       bfd *dynobj;
6884       asection *s;
6885       unsigned int dtagcount;
6886
6887       dynobj = elf_hash_table (info)->dynobj;
6888
6889       /* Work out the size of the symbol version section.  */
6890       s = bfd_get_linker_section (dynobj, ".gnu.version");
6891       BFD_ASSERT (s != NULL);
6892       if ((s->flags & SEC_EXCLUDE) == 0)
6893         {
6894           s->size = dynsymcount * sizeof (Elf_External_Versym);
6895           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6896           if (s->contents == NULL)
6897             return FALSE;
6898
6899           if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6900             return FALSE;
6901         }
6902
6903       /* Set the size of the .dynsym and .hash sections.  We counted
6904          the number of dynamic symbols in elf_link_add_object_symbols.
6905          We will build the contents of .dynsym and .hash when we build
6906          the final symbol table, because until then we do not know the
6907          correct value to give the symbols.  We built the .dynstr
6908          section as we went along in elf_link_add_object_symbols.  */
6909       s = elf_hash_table (info)->dynsym;
6910       BFD_ASSERT (s != NULL);
6911       s->size = dynsymcount * bed->s->sizeof_sym;
6912
6913       s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6914       if (s->contents == NULL)
6915         return FALSE;
6916
6917       /* The first entry in .dynsym is a dummy symbol.  Clear all the
6918          section syms, in case we don't output them all.  */
6919       ++section_sym_count;
6920       memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6921
6922       elf_hash_table (info)->bucketcount = 0;
6923
6924       /* Compute the size of the hashing table.  As a side effect this
6925          computes the hash values for all the names we export.  */
6926       if (info->emit_hash)
6927         {
6928           unsigned long int *hashcodes;
6929           struct hash_codes_info hashinf;
6930           bfd_size_type amt;
6931           unsigned long int nsyms;
6932           size_t bucketcount;
6933           size_t hash_entry_size;
6934
6935           /* Compute the hash values for all exported symbols.  At the same
6936              time store the values in an array so that we could use them for
6937              optimizations.  */
6938           amt = dynsymcount * sizeof (unsigned long int);
6939           hashcodes = (unsigned long int *) bfd_malloc (amt);
6940           if (hashcodes == NULL)
6941             return FALSE;
6942           hashinf.hashcodes = hashcodes;
6943           hashinf.error = FALSE;
6944
6945           /* Put all hash values in HASHCODES.  */
6946           elf_link_hash_traverse (elf_hash_table (info),
6947                                   elf_collect_hash_codes, &hashinf);
6948           if (hashinf.error)
6949             {
6950               free (hashcodes);
6951               return FALSE;
6952             }
6953
6954           nsyms = hashinf.hashcodes - hashcodes;
6955           bucketcount
6956             = compute_bucket_count (info, hashcodes, nsyms, 0);
6957           free (hashcodes);
6958
6959           if (bucketcount == 0 && nsyms > 0)
6960             return FALSE;
6961
6962           elf_hash_table (info)->bucketcount = bucketcount;
6963
6964           s = bfd_get_linker_section (dynobj, ".hash");
6965           BFD_ASSERT (s != NULL);
6966           hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6967           s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6968           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6969           if (s->contents == NULL)
6970             return FALSE;
6971
6972           bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6973           bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6974                    s->contents + hash_entry_size);
6975         }
6976
6977       if (info->emit_gnu_hash)
6978         {
6979           size_t i, cnt;
6980           unsigned char *contents;
6981           struct collect_gnu_hash_codes cinfo;
6982           bfd_size_type amt;
6983           size_t bucketcount;
6984
6985           memset (&cinfo, 0, sizeof (cinfo));
6986
6987           /* Compute the hash values for all exported symbols.  At the same
6988              time store the values in an array so that we could use them for
6989              optimizations.  */
6990           amt = dynsymcount * 2 * sizeof (unsigned long int);
6991           cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6992           if (cinfo.hashcodes == NULL)
6993             return FALSE;
6994
6995           cinfo.hashval = cinfo.hashcodes + dynsymcount;
6996           cinfo.min_dynindx = -1;
6997           cinfo.output_bfd = output_bfd;
6998           cinfo.bed = bed;
6999
7000           /* Put all hash values in HASHCODES.  */
7001           elf_link_hash_traverse (elf_hash_table (info),
7002                                   elf_collect_gnu_hash_codes, &cinfo);
7003           if (cinfo.error)
7004             {
7005               free (cinfo.hashcodes);
7006               return FALSE;
7007             }
7008
7009           bucketcount
7010             = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
7011
7012           if (bucketcount == 0)
7013             {
7014               free (cinfo.hashcodes);
7015               return FALSE;
7016             }
7017
7018           s = bfd_get_linker_section (dynobj, ".gnu.hash");
7019           BFD_ASSERT (s != NULL);
7020
7021           if (cinfo.nsyms == 0)
7022             {
7023               /* Empty .gnu.hash section is special.  */
7024               BFD_ASSERT (cinfo.min_dynindx == -1);
7025               free (cinfo.hashcodes);
7026               s->size = 5 * 4 + bed->s->arch_size / 8;
7027               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
7028               if (contents == NULL)
7029                 return FALSE;
7030               s->contents = contents;
7031               /* 1 empty bucket.  */
7032               bfd_put_32 (output_bfd, 1, contents);
7033               /* SYMIDX above the special symbol 0.  */
7034               bfd_put_32 (output_bfd, 1, contents + 4);
7035               /* Just one word for bitmask.  */
7036               bfd_put_32 (output_bfd, 1, contents + 8);
7037               /* Only hash fn bloom filter.  */
7038               bfd_put_32 (output_bfd, 0, contents + 12);
7039               /* No hashes are valid - empty bitmask.  */
7040               bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
7041               /* No hashes in the only bucket.  */
7042               bfd_put_32 (output_bfd, 0,
7043                           contents + 16 + bed->s->arch_size / 8);
7044             }
7045           else
7046             {
7047               unsigned long int maskwords, maskbitslog2, x;
7048               BFD_ASSERT (cinfo.min_dynindx != -1);
7049
7050               x = cinfo.nsyms;
7051               maskbitslog2 = 1;
7052               while ((x >>= 1) != 0)
7053                 ++maskbitslog2;
7054               if (maskbitslog2 < 3)
7055                 maskbitslog2 = 5;
7056               else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
7057                 maskbitslog2 = maskbitslog2 + 3;
7058               else
7059                 maskbitslog2 = maskbitslog2 + 2;
7060               if (bed->s->arch_size == 64)
7061                 {
7062                   if (maskbitslog2 == 5)
7063                     maskbitslog2 = 6;
7064                   cinfo.shift1 = 6;
7065                 }
7066               else
7067                 cinfo.shift1 = 5;
7068               cinfo.mask = (1 << cinfo.shift1) - 1;
7069               cinfo.shift2 = maskbitslog2;
7070               cinfo.maskbits = 1 << maskbitslog2;
7071               maskwords = 1 << (maskbitslog2 - cinfo.shift1);
7072               amt = bucketcount * sizeof (unsigned long int) * 2;
7073               amt += maskwords * sizeof (bfd_vma);
7074               cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
7075               if (cinfo.bitmask == NULL)
7076                 {
7077                   free (cinfo.hashcodes);
7078                   return FALSE;
7079                 }
7080
7081               cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
7082               cinfo.indx = cinfo.counts + bucketcount;
7083               cinfo.symindx = dynsymcount - cinfo.nsyms;
7084               memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
7085
7086               /* Determine how often each hash bucket is used.  */
7087               memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
7088               for (i = 0; i < cinfo.nsyms; ++i)
7089                 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
7090
7091               for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
7092                 if (cinfo.counts[i] != 0)
7093                   {
7094                     cinfo.indx[i] = cnt;
7095                     cnt += cinfo.counts[i];
7096                   }
7097               BFD_ASSERT (cnt == dynsymcount);
7098               cinfo.bucketcount = bucketcount;
7099               cinfo.local_indx = cinfo.min_dynindx;
7100
7101               s->size = (4 + bucketcount + cinfo.nsyms) * 4;
7102               s->size += cinfo.maskbits / 8;
7103               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
7104               if (contents == NULL)
7105                 {
7106                   free (cinfo.bitmask);
7107                   free (cinfo.hashcodes);
7108                   return FALSE;
7109                 }
7110
7111               s->contents = contents;
7112               bfd_put_32 (output_bfd, bucketcount, contents);
7113               bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
7114               bfd_put_32 (output_bfd, maskwords, contents + 8);
7115               bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
7116               contents += 16 + cinfo.maskbits / 8;
7117
7118               for (i = 0; i < bucketcount; ++i)
7119                 {
7120                   if (cinfo.counts[i] == 0)
7121                     bfd_put_32 (output_bfd, 0, contents);
7122                   else
7123                     bfd_put_32 (output_bfd, cinfo.indx[i], contents);
7124                   contents += 4;
7125                 }
7126
7127               cinfo.contents = contents;
7128
7129               /* Renumber dynamic symbols, populate .gnu.hash section.  */
7130               elf_link_hash_traverse (elf_hash_table (info),
7131                                       elf_renumber_gnu_hash_syms, &cinfo);
7132
7133               contents = s->contents + 16;
7134               for (i = 0; i < maskwords; ++i)
7135                 {
7136                   bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
7137                            contents);
7138                   contents += bed->s->arch_size / 8;
7139                 }
7140
7141               free (cinfo.bitmask);
7142               free (cinfo.hashcodes);
7143             }
7144         }
7145
7146       s = bfd_get_linker_section (dynobj, ".dynstr");
7147       BFD_ASSERT (s != NULL);
7148
7149       elf_finalize_dynstr (output_bfd, info);
7150
7151       s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
7152
7153       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
7154         if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
7155           return FALSE;
7156     }
7157
7158   return TRUE;
7159 }
7160 \f
7161 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
7162
7163 static void
7164 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
7165                             asection *sec)
7166 {
7167   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
7168   sec->sec_info_type = SEC_INFO_TYPE_NONE;
7169 }
7170
7171 /* Finish SHF_MERGE section merging.  */
7172
7173 bfd_boolean
7174 _bfd_elf_merge_sections (bfd *obfd, struct bfd_link_info *info)
7175 {
7176   bfd *ibfd;
7177   asection *sec;
7178
7179   if (!is_elf_hash_table (info->hash))
7180     return FALSE;
7181
7182   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7183     if ((ibfd->flags & DYNAMIC) == 0
7184         && bfd_get_flavour (ibfd) == bfd_target_elf_flavour
7185         && (elf_elfheader (ibfd)->e_ident[EI_CLASS]
7186             == get_elf_backend_data (obfd)->s->elfclass))
7187       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7188         if ((sec->flags & SEC_MERGE) != 0
7189             && !bfd_is_abs_section (sec->output_section))
7190           {
7191             struct bfd_elf_section_data *secdata;
7192
7193             secdata = elf_section_data (sec);
7194             if (! _bfd_add_merge_section (obfd,
7195                                           &elf_hash_table (info)->merge_info,
7196                                           sec, &secdata->sec_info))
7197               return FALSE;
7198             else if (secdata->sec_info)
7199               sec->sec_info_type = SEC_INFO_TYPE_MERGE;
7200           }
7201
7202   if (elf_hash_table (info)->merge_info != NULL)
7203     _bfd_merge_sections (obfd, info, elf_hash_table (info)->merge_info,
7204                          merge_sections_remove_hook);
7205   return TRUE;
7206 }
7207
7208 /* Create an entry in an ELF linker hash table.  */
7209
7210 struct bfd_hash_entry *
7211 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
7212                             struct bfd_hash_table *table,
7213                             const char *string)
7214 {
7215   /* Allocate the structure if it has not already been allocated by a
7216      subclass.  */
7217   if (entry == NULL)
7218     {
7219       entry = (struct bfd_hash_entry *)
7220         bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
7221       if (entry == NULL)
7222         return entry;
7223     }
7224
7225   /* Call the allocation method of the superclass.  */
7226   entry = _bfd_link_hash_newfunc (entry, table, string);
7227   if (entry != NULL)
7228     {
7229       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
7230       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
7231
7232       /* Set local fields.  */
7233       ret->indx = -1;
7234       ret->dynindx = -1;
7235       ret->got = htab->init_got_refcount;
7236       ret->plt = htab->init_plt_refcount;
7237       memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
7238                               - offsetof (struct elf_link_hash_entry, size)));
7239       /* Assume that we have been called by a non-ELF symbol reader.
7240          This flag is then reset by the code which reads an ELF input
7241          file.  This ensures that a symbol created by a non-ELF symbol
7242          reader will have the flag set correctly.  */
7243       ret->non_elf = 1;
7244     }
7245
7246   return entry;
7247 }
7248
7249 /* Copy data from an indirect symbol to its direct symbol, hiding the
7250    old indirect symbol.  Also used for copying flags to a weakdef.  */
7251
7252 void
7253 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
7254                                   struct elf_link_hash_entry *dir,
7255                                   struct elf_link_hash_entry *ind)
7256 {
7257   struct elf_link_hash_table *htab;
7258
7259   /* Copy down any references that we may have already seen to the
7260      symbol which just became indirect.  */
7261
7262   if (dir->versioned != versioned_hidden)
7263     dir->ref_dynamic |= ind->ref_dynamic;
7264   dir->ref_regular |= ind->ref_regular;
7265   dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
7266   dir->non_got_ref |= ind->non_got_ref;
7267   dir->needs_plt |= ind->needs_plt;
7268   dir->pointer_equality_needed |= ind->pointer_equality_needed;
7269
7270   if (ind->root.type != bfd_link_hash_indirect)
7271     return;
7272
7273   /* Copy over the global and procedure linkage table refcount entries.
7274      These may have been already set up by a check_relocs routine.  */
7275   htab = elf_hash_table (info);
7276   if (ind->got.refcount > htab->init_got_refcount.refcount)
7277     {
7278       if (dir->got.refcount < 0)
7279         dir->got.refcount = 0;
7280       dir->got.refcount += ind->got.refcount;
7281       ind->got.refcount = htab->init_got_refcount.refcount;
7282     }
7283
7284   if (ind->plt.refcount > htab->init_plt_refcount.refcount)
7285     {
7286       if (dir->plt.refcount < 0)
7287         dir->plt.refcount = 0;
7288       dir->plt.refcount += ind->plt.refcount;
7289       ind->plt.refcount = htab->init_plt_refcount.refcount;
7290     }
7291
7292   if (ind->dynindx != -1)
7293     {
7294       if (dir->dynindx != -1)
7295         _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
7296       dir->dynindx = ind->dynindx;
7297       dir->dynstr_index = ind->dynstr_index;
7298       ind->dynindx = -1;
7299       ind->dynstr_index = 0;
7300     }
7301 }
7302
7303 void
7304 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
7305                                 struct elf_link_hash_entry *h,
7306                                 bfd_boolean force_local)
7307 {
7308   /* STT_GNU_IFUNC symbol must go through PLT.  */
7309   if (h->type != STT_GNU_IFUNC)
7310     {
7311       h->plt = elf_hash_table (info)->init_plt_offset;
7312       h->needs_plt = 0;
7313     }
7314   if (force_local)
7315     {
7316       h->forced_local = 1;
7317       if (h->dynindx != -1)
7318         {
7319           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7320                                   h->dynstr_index);
7321           h->dynindx = -1;
7322           h->dynstr_index = 0;
7323         }
7324     }
7325 }
7326
7327 /* Initialize an ELF linker hash table.  *TABLE has been zeroed by our
7328    caller.  */
7329
7330 bfd_boolean
7331 _bfd_elf_link_hash_table_init
7332   (struct elf_link_hash_table *table,
7333    bfd *abfd,
7334    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
7335                                       struct bfd_hash_table *,
7336                                       const char *),
7337    unsigned int entsize,
7338    enum elf_target_id target_id)
7339 {
7340   bfd_boolean ret;
7341   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
7342
7343   table->init_got_refcount.refcount = can_refcount - 1;
7344   table->init_plt_refcount.refcount = can_refcount - 1;
7345   table->init_got_offset.offset = -(bfd_vma) 1;
7346   table->init_plt_offset.offset = -(bfd_vma) 1;
7347   /* The first dynamic symbol is a dummy.  */
7348   table->dynsymcount = 1;
7349
7350   ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
7351
7352   table->root.type = bfd_link_elf_hash_table;
7353   table->hash_table_id = target_id;
7354
7355   return ret;
7356 }
7357
7358 /* Create an ELF linker hash table.  */
7359
7360 struct bfd_link_hash_table *
7361 _bfd_elf_link_hash_table_create (bfd *abfd)
7362 {
7363   struct elf_link_hash_table *ret;
7364   bfd_size_type amt = sizeof (struct elf_link_hash_table);
7365
7366   ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
7367   if (ret == NULL)
7368     return NULL;
7369
7370   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
7371                                        sizeof (struct elf_link_hash_entry),
7372                                        GENERIC_ELF_DATA))
7373     {
7374       free (ret);
7375       return NULL;
7376     }
7377   ret->root.hash_table_free = _bfd_elf_link_hash_table_free;
7378
7379   return &ret->root;
7380 }
7381
7382 /* Destroy an ELF linker hash table.  */
7383
7384 void
7385 _bfd_elf_link_hash_table_free (bfd *obfd)
7386 {
7387   struct elf_link_hash_table *htab;
7388
7389   htab = (struct elf_link_hash_table *) obfd->link.hash;
7390   if (htab->dynstr != NULL)
7391     _bfd_elf_strtab_free (htab->dynstr);
7392   _bfd_merge_sections_free (htab->merge_info);
7393   _bfd_generic_link_hash_table_free (obfd);
7394 }
7395
7396 /* This is a hook for the ELF emulation code in the generic linker to
7397    tell the backend linker what file name to use for the DT_NEEDED
7398    entry for a dynamic object.  */
7399
7400 void
7401 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
7402 {
7403   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7404       && bfd_get_format (abfd) == bfd_object)
7405     elf_dt_name (abfd) = name;
7406 }
7407
7408 int
7409 bfd_elf_get_dyn_lib_class (bfd *abfd)
7410 {
7411   int lib_class;
7412   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7413       && bfd_get_format (abfd) == bfd_object)
7414     lib_class = elf_dyn_lib_class (abfd);
7415   else
7416     lib_class = 0;
7417   return lib_class;
7418 }
7419
7420 void
7421 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
7422 {
7423   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7424       && bfd_get_format (abfd) == bfd_object)
7425     elf_dyn_lib_class (abfd) = lib_class;
7426 }
7427
7428 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
7429    the linker ELF emulation code.  */
7430
7431 struct bfd_link_needed_list *
7432 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
7433                          struct bfd_link_info *info)
7434 {
7435   if (! is_elf_hash_table (info->hash))
7436     return NULL;
7437   return elf_hash_table (info)->needed;
7438 }
7439
7440 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
7441    hook for the linker ELF emulation code.  */
7442
7443 struct bfd_link_needed_list *
7444 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
7445                           struct bfd_link_info *info)
7446 {
7447   if (! is_elf_hash_table (info->hash))
7448     return NULL;
7449   return elf_hash_table (info)->runpath;
7450 }
7451
7452 /* Get the name actually used for a dynamic object for a link.  This
7453    is the SONAME entry if there is one.  Otherwise, it is the string
7454    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
7455
7456 const char *
7457 bfd_elf_get_dt_soname (bfd *abfd)
7458 {
7459   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7460       && bfd_get_format (abfd) == bfd_object)
7461     return elf_dt_name (abfd);
7462   return NULL;
7463 }
7464
7465 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
7466    the ELF linker emulation code.  */
7467
7468 bfd_boolean
7469 bfd_elf_get_bfd_needed_list (bfd *abfd,
7470                              struct bfd_link_needed_list **pneeded)
7471 {
7472   asection *s;
7473   bfd_byte *dynbuf = NULL;
7474   unsigned int elfsec;
7475   unsigned long shlink;
7476   bfd_byte *extdyn, *extdynend;
7477   size_t extdynsize;
7478   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
7479
7480   *pneeded = NULL;
7481
7482   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
7483       || bfd_get_format (abfd) != bfd_object)
7484     return TRUE;
7485
7486   s = bfd_get_section_by_name (abfd, ".dynamic");
7487   if (s == NULL || s->size == 0)
7488     return TRUE;
7489
7490   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
7491     goto error_return;
7492
7493   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
7494   if (elfsec == SHN_BAD)
7495     goto error_return;
7496
7497   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
7498
7499   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
7500   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
7501
7502   extdyn = dynbuf;
7503   extdynend = extdyn + s->size;
7504   for (; extdyn < extdynend; extdyn += extdynsize)
7505     {
7506       Elf_Internal_Dyn dyn;
7507
7508       (*swap_dyn_in) (abfd, extdyn, &dyn);
7509
7510       if (dyn.d_tag == DT_NULL)
7511         break;
7512
7513       if (dyn.d_tag == DT_NEEDED)
7514         {
7515           const char *string;
7516           struct bfd_link_needed_list *l;
7517           unsigned int tagv = dyn.d_un.d_val;
7518           bfd_size_type amt;
7519
7520           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
7521           if (string == NULL)
7522             goto error_return;
7523
7524           amt = sizeof *l;
7525           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7526           if (l == NULL)
7527             goto error_return;
7528
7529           l->by = abfd;
7530           l->name = string;
7531           l->next = *pneeded;
7532           *pneeded = l;
7533         }
7534     }
7535
7536   free (dynbuf);
7537
7538   return TRUE;
7539
7540  error_return:
7541   if (dynbuf != NULL)
7542     free (dynbuf);
7543   return FALSE;
7544 }
7545
7546 struct elf_symbuf_symbol
7547 {
7548   unsigned long st_name;        /* Symbol name, index in string tbl */
7549   unsigned char st_info;        /* Type and binding attributes */
7550   unsigned char st_other;       /* Visibilty, and target specific */
7551 };
7552
7553 struct elf_symbuf_head
7554 {
7555   struct elf_symbuf_symbol *ssym;
7556   size_t count;
7557   unsigned int st_shndx;
7558 };
7559
7560 struct elf_symbol
7561 {
7562   union
7563     {
7564       Elf_Internal_Sym *isym;
7565       struct elf_symbuf_symbol *ssym;
7566     } u;
7567   const char *name;
7568 };
7569
7570 /* Sort references to symbols by ascending section number.  */
7571
7572 static int
7573 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7574 {
7575   const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7576   const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7577
7578   return s1->st_shndx - s2->st_shndx;
7579 }
7580
7581 static int
7582 elf_sym_name_compare (const void *arg1, const void *arg2)
7583 {
7584   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7585   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7586   return strcmp (s1->name, s2->name);
7587 }
7588
7589 static struct elf_symbuf_head *
7590 elf_create_symbuf (size_t symcount, Elf_Internal_Sym *isymbuf)
7591 {
7592   Elf_Internal_Sym **ind, **indbufend, **indbuf;
7593   struct elf_symbuf_symbol *ssym;
7594   struct elf_symbuf_head *ssymbuf, *ssymhead;
7595   size_t i, shndx_count, total_size;
7596
7597   indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7598   if (indbuf == NULL)
7599     return NULL;
7600
7601   for (ind = indbuf, i = 0; i < symcount; i++)
7602     if (isymbuf[i].st_shndx != SHN_UNDEF)
7603       *ind++ = &isymbuf[i];
7604   indbufend = ind;
7605
7606   qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7607          elf_sort_elf_symbol);
7608
7609   shndx_count = 0;
7610   if (indbufend > indbuf)
7611     for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7612       if (ind[0]->st_shndx != ind[1]->st_shndx)
7613         shndx_count++;
7614
7615   total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7616                 + (indbufend - indbuf) * sizeof (*ssym));
7617   ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7618   if (ssymbuf == NULL)
7619     {
7620       free (indbuf);
7621       return NULL;
7622     }
7623
7624   ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7625   ssymbuf->ssym = NULL;
7626   ssymbuf->count = shndx_count;
7627   ssymbuf->st_shndx = 0;
7628   for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7629     {
7630       if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7631         {
7632           ssymhead++;
7633           ssymhead->ssym = ssym;
7634           ssymhead->count = 0;
7635           ssymhead->st_shndx = (*ind)->st_shndx;
7636         }
7637       ssym->st_name = (*ind)->st_name;
7638       ssym->st_info = (*ind)->st_info;
7639       ssym->st_other = (*ind)->st_other;
7640       ssymhead->count++;
7641     }
7642   BFD_ASSERT ((size_t) (ssymhead - ssymbuf) == shndx_count
7643               && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7644                   == total_size));
7645
7646   free (indbuf);
7647   return ssymbuf;
7648 }
7649
7650 /* Check if 2 sections define the same set of local and global
7651    symbols.  */
7652
7653 static bfd_boolean
7654 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7655                                    struct bfd_link_info *info)
7656 {
7657   bfd *bfd1, *bfd2;
7658   const struct elf_backend_data *bed1, *bed2;
7659   Elf_Internal_Shdr *hdr1, *hdr2;
7660   size_t symcount1, symcount2;
7661   Elf_Internal_Sym *isymbuf1, *isymbuf2;
7662   struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7663   Elf_Internal_Sym *isym, *isymend;
7664   struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7665   size_t count1, count2, i;
7666   unsigned int shndx1, shndx2;
7667   bfd_boolean result;
7668
7669   bfd1 = sec1->owner;
7670   bfd2 = sec2->owner;
7671
7672   /* Both sections have to be in ELF.  */
7673   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7674       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7675     return FALSE;
7676
7677   if (elf_section_type (sec1) != elf_section_type (sec2))
7678     return FALSE;
7679
7680   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7681   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7682   if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7683     return FALSE;
7684
7685   bed1 = get_elf_backend_data (bfd1);
7686   bed2 = get_elf_backend_data (bfd2);
7687   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7688   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7689   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7690   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7691
7692   if (symcount1 == 0 || symcount2 == 0)
7693     return FALSE;
7694
7695   result = FALSE;
7696   isymbuf1 = NULL;
7697   isymbuf2 = NULL;
7698   ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7699   ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7700
7701   if (ssymbuf1 == NULL)
7702     {
7703       isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7704                                        NULL, NULL, NULL);
7705       if (isymbuf1 == NULL)
7706         goto done;
7707
7708       if (!info->reduce_memory_overheads)
7709         elf_tdata (bfd1)->symbuf = ssymbuf1
7710           = elf_create_symbuf (symcount1, isymbuf1);
7711     }
7712
7713   if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7714     {
7715       isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7716                                        NULL, NULL, NULL);
7717       if (isymbuf2 == NULL)
7718         goto done;
7719
7720       if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7721         elf_tdata (bfd2)->symbuf = ssymbuf2
7722           = elf_create_symbuf (symcount2, isymbuf2);
7723     }
7724
7725   if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7726     {
7727       /* Optimized faster version.  */
7728       size_t lo, hi, mid;
7729       struct elf_symbol *symp;
7730       struct elf_symbuf_symbol *ssym, *ssymend;
7731
7732       lo = 0;
7733       hi = ssymbuf1->count;
7734       ssymbuf1++;
7735       count1 = 0;
7736       while (lo < hi)
7737         {
7738           mid = (lo + hi) / 2;
7739           if (shndx1 < ssymbuf1[mid].st_shndx)
7740             hi = mid;
7741           else if (shndx1 > ssymbuf1[mid].st_shndx)
7742             lo = mid + 1;
7743           else
7744             {
7745               count1 = ssymbuf1[mid].count;
7746               ssymbuf1 += mid;
7747               break;
7748             }
7749         }
7750
7751       lo = 0;
7752       hi = ssymbuf2->count;
7753       ssymbuf2++;
7754       count2 = 0;
7755       while (lo < hi)
7756         {
7757           mid = (lo + hi) / 2;
7758           if (shndx2 < ssymbuf2[mid].st_shndx)
7759             hi = mid;
7760           else if (shndx2 > ssymbuf2[mid].st_shndx)
7761             lo = mid + 1;
7762           else
7763             {
7764               count2 = ssymbuf2[mid].count;
7765               ssymbuf2 += mid;
7766               break;
7767             }
7768         }
7769
7770       if (count1 == 0 || count2 == 0 || count1 != count2)
7771         goto done;
7772
7773       symtable1
7774         = (struct elf_symbol *) bfd_malloc (count1 * sizeof (*symtable1));
7775       symtable2
7776         = (struct elf_symbol *) bfd_malloc (count2 * sizeof (*symtable2));
7777       if (symtable1 == NULL || symtable2 == NULL)
7778         goto done;
7779
7780       symp = symtable1;
7781       for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7782            ssym < ssymend; ssym++, symp++)
7783         {
7784           symp->u.ssym = ssym;
7785           symp->name = bfd_elf_string_from_elf_section (bfd1,
7786                                                         hdr1->sh_link,
7787                                                         ssym->st_name);
7788         }
7789
7790       symp = symtable2;
7791       for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7792            ssym < ssymend; ssym++, symp++)
7793         {
7794           symp->u.ssym = ssym;
7795           symp->name = bfd_elf_string_from_elf_section (bfd2,
7796                                                         hdr2->sh_link,
7797                                                         ssym->st_name);
7798         }
7799
7800       /* Sort symbol by name.  */
7801       qsort (symtable1, count1, sizeof (struct elf_symbol),
7802              elf_sym_name_compare);
7803       qsort (symtable2, count1, sizeof (struct elf_symbol),
7804              elf_sym_name_compare);
7805
7806       for (i = 0; i < count1; i++)
7807         /* Two symbols must have the same binding, type and name.  */
7808         if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7809             || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7810             || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7811           goto done;
7812
7813       result = TRUE;
7814       goto done;
7815     }
7816
7817   symtable1 = (struct elf_symbol *)
7818       bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7819   symtable2 = (struct elf_symbol *)
7820       bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7821   if (symtable1 == NULL || symtable2 == NULL)
7822     goto done;
7823
7824   /* Count definitions in the section.  */
7825   count1 = 0;
7826   for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7827     if (isym->st_shndx == shndx1)
7828       symtable1[count1++].u.isym = isym;
7829
7830   count2 = 0;
7831   for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7832     if (isym->st_shndx == shndx2)
7833       symtable2[count2++].u.isym = isym;
7834
7835   if (count1 == 0 || count2 == 0 || count1 != count2)
7836     goto done;
7837
7838   for (i = 0; i < count1; i++)
7839     symtable1[i].name
7840       = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7841                                          symtable1[i].u.isym->st_name);
7842
7843   for (i = 0; i < count2; i++)
7844     symtable2[i].name
7845       = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7846                                          symtable2[i].u.isym->st_name);
7847
7848   /* Sort symbol by name.  */
7849   qsort (symtable1, count1, sizeof (struct elf_symbol),
7850          elf_sym_name_compare);
7851   qsort (symtable2, count1, sizeof (struct elf_symbol),
7852          elf_sym_name_compare);
7853
7854   for (i = 0; i < count1; i++)
7855     /* Two symbols must have the same binding, type and name.  */
7856     if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7857         || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7858         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7859       goto done;
7860
7861   result = TRUE;
7862
7863 done:
7864   if (symtable1)
7865     free (symtable1);
7866   if (symtable2)
7867     free (symtable2);
7868   if (isymbuf1)
7869     free (isymbuf1);
7870   if (isymbuf2)
7871     free (isymbuf2);
7872
7873   return result;
7874 }
7875
7876 /* Return TRUE if 2 section types are compatible.  */
7877
7878 bfd_boolean
7879 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7880                                  bfd *bbfd, const asection *bsec)
7881 {
7882   if (asec == NULL
7883       || bsec == NULL
7884       || abfd->xvec->flavour != bfd_target_elf_flavour
7885       || bbfd->xvec->flavour != bfd_target_elf_flavour)
7886     return TRUE;
7887
7888   return elf_section_type (asec) == elf_section_type (bsec);
7889 }
7890 \f
7891 /* Final phase of ELF linker.  */
7892
7893 /* A structure we use to avoid passing large numbers of arguments.  */
7894
7895 struct elf_final_link_info
7896 {
7897   /* General link information.  */
7898   struct bfd_link_info *info;
7899   /* Output BFD.  */
7900   bfd *output_bfd;
7901   /* Symbol string table.  */
7902   struct elf_strtab_hash *symstrtab;
7903   /* .hash section.  */
7904   asection *hash_sec;
7905   /* symbol version section (.gnu.version).  */
7906   asection *symver_sec;
7907   /* Buffer large enough to hold contents of any section.  */
7908   bfd_byte *contents;
7909   /* Buffer large enough to hold external relocs of any section.  */
7910   void *external_relocs;
7911   /* Buffer large enough to hold internal relocs of any section.  */
7912   Elf_Internal_Rela *internal_relocs;
7913   /* Buffer large enough to hold external local symbols of any input
7914      BFD.  */
7915   bfd_byte *external_syms;
7916   /* And a buffer for symbol section indices.  */
7917   Elf_External_Sym_Shndx *locsym_shndx;
7918   /* Buffer large enough to hold internal local symbols of any input
7919      BFD.  */
7920   Elf_Internal_Sym *internal_syms;
7921   /* Array large enough to hold a symbol index for each local symbol
7922      of any input BFD.  */
7923   long *indices;
7924   /* Array large enough to hold a section pointer for each local
7925      symbol of any input BFD.  */
7926   asection **sections;
7927   /* Buffer for SHT_SYMTAB_SHNDX section.  */
7928   Elf_External_Sym_Shndx *symshndxbuf;
7929   /* Number of STT_FILE syms seen.  */
7930   size_t filesym_count;
7931 };
7932
7933 /* This struct is used to pass information to elf_link_output_extsym.  */
7934
7935 struct elf_outext_info
7936 {
7937   bfd_boolean failed;
7938   bfd_boolean localsyms;
7939   bfd_boolean file_sym_done;
7940   struct elf_final_link_info *flinfo;
7941 };
7942
7943
7944 /* Support for evaluating a complex relocation.
7945
7946    Complex relocations are generalized, self-describing relocations.  The
7947    implementation of them consists of two parts: complex symbols, and the
7948    relocations themselves.
7949
7950    The relocations are use a reserved elf-wide relocation type code (R_RELC
7951    external / BFD_RELOC_RELC internal) and an encoding of relocation field
7952    information (start bit, end bit, word width, etc) into the addend.  This
7953    information is extracted from CGEN-generated operand tables within gas.
7954
7955    Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7956    internal) representing prefix-notation expressions, including but not
7957    limited to those sorts of expressions normally encoded as addends in the
7958    addend field.  The symbol mangling format is:
7959
7960    <node> := <literal>
7961           |  <unary-operator> ':' <node>
7962           |  <binary-operator> ':' <node> ':' <node>
7963           ;
7964
7965    <literal> := 's' <digits=N> ':' <N character symbol name>
7966              |  'S' <digits=N> ':' <N character section name>
7967              |  '#' <hexdigits>
7968              ;
7969
7970    <binary-operator> := as in C
7971    <unary-operator> := as in C, plus "0-" for unambiguous negation.  */
7972
7973 static void
7974 set_symbol_value (bfd *bfd_with_globals,
7975                   Elf_Internal_Sym *isymbuf,
7976                   size_t locsymcount,
7977                   size_t symidx,
7978                   bfd_vma val)
7979 {
7980   struct elf_link_hash_entry **sym_hashes;
7981   struct elf_link_hash_entry *h;
7982   size_t extsymoff = locsymcount;
7983
7984   if (symidx < locsymcount)
7985     {
7986       Elf_Internal_Sym *sym;
7987
7988       sym = isymbuf + symidx;
7989       if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7990         {
7991           /* It is a local symbol: move it to the
7992              "absolute" section and give it a value.  */
7993           sym->st_shndx = SHN_ABS;
7994           sym->st_value = val;
7995           return;
7996         }
7997       BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7998       extsymoff = 0;
7999     }
8000
8001   /* It is a global symbol: set its link type
8002      to "defined" and give it a value.  */
8003
8004   sym_hashes = elf_sym_hashes (bfd_with_globals);
8005   h = sym_hashes [symidx - extsymoff];
8006   while (h->root.type == bfd_link_hash_indirect
8007          || h->root.type == bfd_link_hash_warning)
8008     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8009   h->root.type = bfd_link_hash_defined;
8010   h->root.u.def.value = val;
8011   h->root.u.def.section = bfd_abs_section_ptr;
8012 }
8013
8014 static bfd_boolean
8015 resolve_symbol (const char *name,
8016                 bfd *input_bfd,
8017                 struct elf_final_link_info *flinfo,
8018                 bfd_vma *result,
8019                 Elf_Internal_Sym *isymbuf,
8020                 size_t locsymcount)
8021 {
8022   Elf_Internal_Sym *sym;
8023   struct bfd_link_hash_entry *global_entry;
8024   const char *candidate = NULL;
8025   Elf_Internal_Shdr *symtab_hdr;
8026   size_t i;
8027
8028   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
8029
8030   for (i = 0; i < locsymcount; ++ i)
8031     {
8032       sym = isymbuf + i;
8033
8034       if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
8035         continue;
8036
8037       candidate = bfd_elf_string_from_elf_section (input_bfd,
8038                                                    symtab_hdr->sh_link,
8039                                                    sym->st_name);
8040 #ifdef DEBUG
8041       printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
8042               name, candidate, (unsigned long) sym->st_value);
8043 #endif
8044       if (candidate && strcmp (candidate, name) == 0)
8045         {
8046           asection *sec = flinfo->sections [i];
8047
8048           *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
8049           *result += sec->output_offset + sec->output_section->vma;
8050 #ifdef DEBUG
8051           printf ("Found symbol with value %8.8lx\n",
8052                   (unsigned long) *result);
8053 #endif
8054           return TRUE;
8055         }
8056     }
8057
8058   /* Hmm, haven't found it yet. perhaps it is a global.  */
8059   global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
8060                                        FALSE, FALSE, TRUE);
8061   if (!global_entry)
8062     return FALSE;
8063
8064   if (global_entry->type == bfd_link_hash_defined
8065       || global_entry->type == bfd_link_hash_defweak)
8066     {
8067       *result = (global_entry->u.def.value
8068                  + global_entry->u.def.section->output_section->vma
8069                  + global_entry->u.def.section->output_offset);
8070 #ifdef DEBUG
8071       printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
8072               global_entry->root.string, (unsigned long) *result);
8073 #endif
8074       return TRUE;
8075     }
8076
8077   return FALSE;
8078 }
8079
8080 /* Looks up NAME in SECTIONS.  If found sets RESULT to NAME's address (in
8081    bytes) and returns TRUE, otherwise returns FALSE.  Accepts pseudo-section
8082    names like "foo.end" which is the end address of section "foo".  */
8083    
8084 static bfd_boolean
8085 resolve_section (const char *name,
8086                  asection *sections,
8087                  bfd_vma *result,
8088                  bfd * abfd)
8089 {
8090   asection *curr;
8091   unsigned int len;
8092
8093   for (curr = sections; curr; curr = curr->next)
8094     if (strcmp (curr->name, name) == 0)
8095       {
8096         *result = curr->vma;
8097         return TRUE;
8098       }
8099
8100   /* Hmm. still haven't found it. try pseudo-section names.  */
8101   /* FIXME: This could be coded more efficiently...  */
8102   for (curr = sections; curr; curr = curr->next)
8103     {
8104       len = strlen (curr->name);
8105       if (len > strlen (name))
8106         continue;
8107
8108       if (strncmp (curr->name, name, len) == 0)
8109         {
8110           if (strncmp (".end", name + len, 4) == 0)
8111             {
8112               *result = curr->vma + curr->size / bfd_octets_per_byte (abfd);
8113               return TRUE;
8114             }
8115
8116           /* Insert more pseudo-section names here, if you like.  */
8117         }
8118     }
8119
8120   return FALSE;
8121 }
8122
8123 static void
8124 undefined_reference (const char *reftype, const char *name)
8125 {
8126   /* xgettext:c-format */
8127   _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
8128                       reftype, name);
8129 }
8130
8131 static bfd_boolean
8132 eval_symbol (bfd_vma *result,
8133              const char **symp,
8134              bfd *input_bfd,
8135              struct elf_final_link_info *flinfo,
8136              bfd_vma dot,
8137              Elf_Internal_Sym *isymbuf,
8138              size_t locsymcount,
8139              int signed_p)
8140 {
8141   size_t len;
8142   size_t symlen;
8143   bfd_vma a;
8144   bfd_vma b;
8145   char symbuf[4096];
8146   const char *sym = *symp;
8147   const char *symend;
8148   bfd_boolean symbol_is_section = FALSE;
8149
8150   len = strlen (sym);
8151   symend = sym + len;
8152
8153   if (len < 1 || len > sizeof (symbuf))
8154     {
8155       bfd_set_error (bfd_error_invalid_operation);
8156       return FALSE;
8157     }
8158
8159   switch (* sym)
8160     {
8161     case '.':
8162       *result = dot;
8163       *symp = sym + 1;
8164       return TRUE;
8165
8166     case '#':
8167       ++sym;
8168       *result = strtoul (sym, (char **) symp, 16);
8169       return TRUE;
8170
8171     case 'S':
8172       symbol_is_section = TRUE;
8173       /* Fall through.  */
8174     case 's':
8175       ++sym;
8176       symlen = strtol (sym, (char **) symp, 10);
8177       sym = *symp + 1; /* Skip the trailing ':'.  */
8178
8179       if (symend < sym || symlen + 1 > sizeof (symbuf))
8180         {
8181           bfd_set_error (bfd_error_invalid_operation);
8182           return FALSE;
8183         }
8184
8185       memcpy (symbuf, sym, symlen);
8186       symbuf[symlen] = '\0';
8187       *symp = sym + symlen;
8188
8189       /* Is it always possible, with complex symbols, that gas "mis-guessed"
8190          the symbol as a section, or vice-versa. so we're pretty liberal in our
8191          interpretation here; section means "try section first", not "must be a
8192          section", and likewise with symbol.  */
8193
8194       if (symbol_is_section)
8195         {
8196           if (!resolve_section (symbuf, flinfo->output_bfd->sections, result, input_bfd)
8197               && !resolve_symbol (symbuf, input_bfd, flinfo, result,
8198                                   isymbuf, locsymcount))
8199             {
8200               undefined_reference ("section", symbuf);
8201               return FALSE;
8202             }
8203         }
8204       else
8205         {
8206           if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
8207                                isymbuf, locsymcount)
8208               && !resolve_section (symbuf, flinfo->output_bfd->sections,
8209                                    result, input_bfd))
8210             {
8211               undefined_reference ("symbol", symbuf);
8212               return FALSE;
8213             }
8214         }
8215
8216       return TRUE;
8217
8218       /* All that remains are operators.  */
8219
8220 #define UNARY_OP(op)                                            \
8221   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
8222     {                                                           \
8223       sym += strlen (#op);                                      \
8224       if (*sym == ':')                                          \
8225         ++sym;                                                  \
8226       *symp = sym;                                              \
8227       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
8228                         isymbuf, locsymcount, signed_p))        \
8229         return FALSE;                                           \
8230       if (signed_p)                                             \
8231         *result = op ((bfd_signed_vma) a);                      \
8232       else                                                      \
8233         *result = op a;                                         \
8234       return TRUE;                                              \
8235     }
8236
8237 #define BINARY_OP(op)                                           \
8238   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
8239     {                                                           \
8240       sym += strlen (#op);                                      \
8241       if (*sym == ':')                                          \
8242         ++sym;                                                  \
8243       *symp = sym;                                              \
8244       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
8245                         isymbuf, locsymcount, signed_p))        \
8246         return FALSE;                                           \
8247       ++*symp;                                                  \
8248       if (!eval_symbol (&b, symp, input_bfd, flinfo, dot,       \
8249                         isymbuf, locsymcount, signed_p))        \
8250         return FALSE;                                           \
8251       if (signed_p)                                             \
8252         *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
8253       else                                                      \
8254         *result = a op b;                                       \
8255       return TRUE;                                              \
8256     }
8257
8258     default:
8259       UNARY_OP  (0-);
8260       BINARY_OP (<<);
8261       BINARY_OP (>>);
8262       BINARY_OP (==);
8263       BINARY_OP (!=);
8264       BINARY_OP (<=);
8265       BINARY_OP (>=);
8266       BINARY_OP (&&);
8267       BINARY_OP (||);
8268       UNARY_OP  (~);
8269       UNARY_OP  (!);
8270       BINARY_OP (*);
8271       BINARY_OP (/);
8272       BINARY_OP (%);
8273       BINARY_OP (^);
8274       BINARY_OP (|);
8275       BINARY_OP (&);
8276       BINARY_OP (+);
8277       BINARY_OP (-);
8278       BINARY_OP (<);
8279       BINARY_OP (>);
8280 #undef UNARY_OP
8281 #undef BINARY_OP
8282       _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
8283       bfd_set_error (bfd_error_invalid_operation);
8284       return FALSE;
8285     }
8286 }
8287
8288 static void
8289 put_value (bfd_vma size,
8290            unsigned long chunksz,
8291            bfd *input_bfd,
8292            bfd_vma x,
8293            bfd_byte *location)
8294 {
8295   location += (size - chunksz);
8296
8297   for (; size; size -= chunksz, location -= chunksz)
8298     {
8299       switch (chunksz)
8300         {
8301         case 1:
8302           bfd_put_8 (input_bfd, x, location);
8303           x >>= 8;
8304           break;
8305         case 2:
8306           bfd_put_16 (input_bfd, x, location);
8307           x >>= 16;
8308           break;
8309         case 4:
8310           bfd_put_32 (input_bfd, x, location);
8311           /* Computed this way because x >>= 32 is undefined if x is a 32-bit value.  */
8312           x >>= 16;
8313           x >>= 16;
8314           break;
8315 #ifdef BFD64
8316         case 8:
8317           bfd_put_64 (input_bfd, x, location);
8318           /* Computed this way because x >>= 64 is undefined if x is a 64-bit value.  */
8319           x >>= 32;
8320           x >>= 32;
8321           break;
8322 #endif
8323         default:
8324           abort ();
8325           break;
8326         }
8327     }
8328 }
8329
8330 static bfd_vma
8331 get_value (bfd_vma size,
8332            unsigned long chunksz,
8333            bfd *input_bfd,
8334            bfd_byte *location)
8335 {
8336   int shift;
8337   bfd_vma x = 0;
8338
8339   /* Sanity checks.  */
8340   BFD_ASSERT (chunksz <= sizeof (x)
8341               && size >= chunksz
8342               && chunksz != 0
8343               && (size % chunksz) == 0
8344               && input_bfd != NULL
8345               && location != NULL);
8346
8347   if (chunksz == sizeof (x))
8348     {
8349       BFD_ASSERT (size == chunksz);
8350
8351       /* Make sure that we do not perform an undefined shift operation.
8352          We know that size == chunksz so there will only be one iteration
8353          of the loop below.  */
8354       shift = 0;
8355     }
8356   else
8357     shift = 8 * chunksz;
8358
8359   for (; size; size -= chunksz, location += chunksz)
8360     {
8361       switch (chunksz)
8362         {
8363         case 1:
8364           x = (x << shift) | bfd_get_8 (input_bfd, location);
8365           break;
8366         case 2:
8367           x = (x << shift) | bfd_get_16 (input_bfd, location);
8368           break;
8369         case 4:
8370           x = (x << shift) | bfd_get_32 (input_bfd, location);
8371           break;
8372 #ifdef BFD64
8373         case 8:
8374           x = (x << shift) | bfd_get_64 (input_bfd, location);
8375           break;
8376 #endif
8377         default:
8378           abort ();
8379         }
8380     }
8381   return x;
8382 }
8383
8384 static void
8385 decode_complex_addend (unsigned long *start,   /* in bits */
8386                        unsigned long *oplen,   /* in bits */
8387                        unsigned long *len,     /* in bits */
8388                        unsigned long *wordsz,  /* in bytes */
8389                        unsigned long *chunksz, /* in bytes */
8390                        unsigned long *lsb0_p,
8391                        unsigned long *signed_p,
8392                        unsigned long *trunc_p,
8393                        unsigned long encoded)
8394 {
8395   * start     =  encoded        & 0x3F;
8396   * len       = (encoded >>  6) & 0x3F;
8397   * oplen     = (encoded >> 12) & 0x3F;
8398   * wordsz    = (encoded >> 18) & 0xF;
8399   * chunksz   = (encoded >> 22) & 0xF;
8400   * lsb0_p    = (encoded >> 27) & 1;
8401   * signed_p  = (encoded >> 28) & 1;
8402   * trunc_p   = (encoded >> 29) & 1;
8403 }
8404
8405 bfd_reloc_status_type
8406 bfd_elf_perform_complex_relocation (bfd *input_bfd,
8407                                     asection *input_section ATTRIBUTE_UNUSED,
8408                                     bfd_byte *contents,
8409                                     Elf_Internal_Rela *rel,
8410                                     bfd_vma relocation)
8411 {
8412   bfd_vma shift, x, mask;
8413   unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
8414   bfd_reloc_status_type r;
8415
8416   /*  Perform this reloc, since it is complex.
8417       (this is not to say that it necessarily refers to a complex
8418       symbol; merely that it is a self-describing CGEN based reloc.
8419       i.e. the addend has the complete reloc information (bit start, end,
8420       word size, etc) encoded within it.).  */
8421
8422   decode_complex_addend (&start, &oplen, &len, &wordsz,
8423                          &chunksz, &lsb0_p, &signed_p,
8424                          &trunc_p, rel->r_addend);
8425
8426   mask = (((1L << (len - 1)) - 1) << 1) | 1;
8427
8428   if (lsb0_p)
8429     shift = (start + 1) - len;
8430   else
8431     shift = (8 * wordsz) - (start + len);
8432
8433   x = get_value (wordsz, chunksz, input_bfd,
8434                  contents + rel->r_offset * bfd_octets_per_byte (input_bfd));
8435
8436 #ifdef DEBUG
8437   printf ("Doing complex reloc: "
8438           "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
8439           "chunksz %ld, start %ld, len %ld, oplen %ld\n"
8440           "    dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
8441           lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
8442           oplen, (unsigned long) x, (unsigned long) mask,
8443           (unsigned long) relocation);
8444 #endif
8445
8446   r = bfd_reloc_ok;
8447   if (! trunc_p)
8448     /* Now do an overflow check.  */
8449     r = bfd_check_overflow ((signed_p
8450                              ? complain_overflow_signed
8451                              : complain_overflow_unsigned),
8452                             len, 0, (8 * wordsz),
8453                             relocation);
8454
8455   /* Do the deed.  */
8456   x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
8457
8458 #ifdef DEBUG
8459   printf ("           relocation: %8.8lx\n"
8460           "         shifted mask: %8.8lx\n"
8461           " shifted/masked reloc: %8.8lx\n"
8462           "               result: %8.8lx\n",
8463           (unsigned long) relocation, (unsigned long) (mask << shift),
8464           (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
8465 #endif
8466   put_value (wordsz, chunksz, input_bfd, x,
8467              contents + rel->r_offset * bfd_octets_per_byte (input_bfd));
8468   return r;
8469 }
8470
8471 /* Functions to read r_offset from external (target order) reloc
8472    entry.  Faster than bfd_getl32 et al, because we let the compiler
8473    know the value is aligned.  */
8474
8475 static bfd_vma
8476 ext32l_r_offset (const void *p)
8477 {
8478   union aligned32
8479   {
8480     uint32_t v;
8481     unsigned char c[4];
8482   };
8483   const union aligned32 *a
8484     = (const union aligned32 *) &((const Elf32_External_Rel *) p)->r_offset;
8485
8486   uint32_t aval = (  (uint32_t) a->c[0]
8487                    | (uint32_t) a->c[1] << 8
8488                    | (uint32_t) a->c[2] << 16
8489                    | (uint32_t) a->c[3] << 24);
8490   return aval;
8491 }
8492
8493 static bfd_vma
8494 ext32b_r_offset (const void *p)
8495 {
8496   union aligned32
8497   {
8498     uint32_t v;
8499     unsigned char c[4];
8500   };
8501   const union aligned32 *a
8502     = (const union aligned32 *) &((const Elf32_External_Rel *) p)->r_offset;
8503
8504   uint32_t aval = (  (uint32_t) a->c[0] << 24
8505                    | (uint32_t) a->c[1] << 16
8506                    | (uint32_t) a->c[2] << 8
8507                    | (uint32_t) a->c[3]);
8508   return aval;
8509 }
8510
8511 #ifdef BFD_HOST_64_BIT
8512 static bfd_vma
8513 ext64l_r_offset (const void *p)
8514 {
8515   union aligned64
8516   {
8517     uint64_t v;
8518     unsigned char c[8];
8519   };
8520   const union aligned64 *a
8521     = (const union aligned64 *) &((const Elf64_External_Rel *) p)->r_offset;
8522
8523   uint64_t aval = (  (uint64_t) a->c[0]
8524                    | (uint64_t) a->c[1] << 8
8525                    | (uint64_t) a->c[2] << 16
8526                    | (uint64_t) a->c[3] << 24
8527                    | (uint64_t) a->c[4] << 32
8528                    | (uint64_t) a->c[5] << 40
8529                    | (uint64_t) a->c[6] << 48
8530                    | (uint64_t) a->c[7] << 56);
8531   return aval;
8532 }
8533
8534 static bfd_vma
8535 ext64b_r_offset (const void *p)
8536 {
8537   union aligned64
8538   {
8539     uint64_t v;
8540     unsigned char c[8];
8541   };
8542   const union aligned64 *a
8543     = (const union aligned64 *) &((const Elf64_External_Rel *) p)->r_offset;
8544
8545   uint64_t aval = (  (uint64_t) a->c[0] << 56
8546                    | (uint64_t) a->c[1] << 48
8547                    | (uint64_t) a->c[2] << 40
8548                    | (uint64_t) a->c[3] << 32
8549                    | (uint64_t) a->c[4] << 24
8550                    | (uint64_t) a->c[5] << 16
8551                    | (uint64_t) a->c[6] << 8
8552                    | (uint64_t) a->c[7]);
8553   return aval;
8554 }
8555 #endif
8556
8557 /* When performing a relocatable link, the input relocations are
8558    preserved.  But, if they reference global symbols, the indices
8559    referenced must be updated.  Update all the relocations found in
8560    RELDATA.  */
8561
8562 static bfd_boolean
8563 elf_link_adjust_relocs (bfd *abfd,
8564                         asection *sec,
8565                         struct bfd_elf_section_reloc_data *reldata,
8566                         bfd_boolean sort,
8567                         struct bfd_link_info *info)
8568 {
8569   unsigned int i;
8570   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8571   bfd_byte *erela;
8572   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8573   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8574   bfd_vma r_type_mask;
8575   int r_sym_shift;
8576   unsigned int count = reldata->count;
8577   struct elf_link_hash_entry **rel_hash = reldata->hashes;
8578
8579   if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
8580     {
8581       swap_in = bed->s->swap_reloc_in;
8582       swap_out = bed->s->swap_reloc_out;
8583     }
8584   else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
8585     {
8586       swap_in = bed->s->swap_reloca_in;
8587       swap_out = bed->s->swap_reloca_out;
8588     }
8589   else
8590     abort ();
8591
8592   if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
8593     abort ();
8594
8595   if (bed->s->arch_size == 32)
8596     {
8597       r_type_mask = 0xff;
8598       r_sym_shift = 8;
8599     }
8600   else
8601     {
8602       r_type_mask = 0xffffffff;
8603       r_sym_shift = 32;
8604     }
8605
8606   erela = reldata->hdr->contents;
8607   for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
8608     {
8609       Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
8610       unsigned int j;
8611
8612       if (*rel_hash == NULL)
8613         continue;
8614
8615       if ((*rel_hash)->indx == -2
8616           && info->gc_sections
8617           && ! info->gc_keep_exported)
8618         {
8619           /* PR 21524: Let the user know if a symbol was removed by garbage collection.  */
8620           _bfd_error_handler (_("%B:%A: error: relocation references symbol %s which was removed by garbage collection."),
8621                               abfd, sec,
8622                               (*rel_hash)->root.root.string);
8623           _bfd_error_handler (_("%B:%A: error: try relinking with --gc-keep-exported enabled."),
8624                               abfd, sec);
8625           bfd_set_error (bfd_error_invalid_operation);
8626           return FALSE;
8627         }
8628       BFD_ASSERT ((*rel_hash)->indx >= 0);
8629
8630       (*swap_in) (abfd, erela, irela);
8631       for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
8632         irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
8633                            | (irela[j].r_info & r_type_mask));
8634       (*swap_out) (abfd, irela, erela);
8635     }
8636
8637   if (bed->elf_backend_update_relocs)
8638     (*bed->elf_backend_update_relocs) (sec, reldata);
8639
8640   if (sort && count != 0)
8641     {
8642       bfd_vma (*ext_r_off) (const void *);
8643       bfd_vma r_off;
8644       size_t elt_size;
8645       bfd_byte *base, *end, *p, *loc;
8646       bfd_byte *buf = NULL;
8647
8648       if (bed->s->arch_size == 32)
8649         {
8650           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8651             ext_r_off = ext32l_r_offset;
8652           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8653             ext_r_off = ext32b_r_offset;
8654           else
8655             abort ();
8656         }
8657       else
8658         {
8659 #ifdef BFD_HOST_64_BIT
8660           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8661             ext_r_off = ext64l_r_offset;
8662           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8663             ext_r_off = ext64b_r_offset;
8664           else
8665 #endif
8666             abort ();
8667         }
8668
8669       /*  Must use a stable sort here.  A modified insertion sort,
8670           since the relocs are mostly sorted already.  */
8671       elt_size = reldata->hdr->sh_entsize;
8672       base = reldata->hdr->contents;
8673       end = base + count * elt_size;
8674       if (elt_size > sizeof (Elf64_External_Rela))
8675         abort ();
8676
8677       /* Ensure the first element is lowest.  This acts as a sentinel,
8678          speeding the main loop below.  */
8679       r_off = (*ext_r_off) (base);
8680       for (p = loc = base; (p += elt_size) < end; )
8681         {
8682           bfd_vma r_off2 = (*ext_r_off) (p);
8683           if (r_off > r_off2)
8684             {
8685               r_off = r_off2;
8686               loc = p;
8687             }
8688         }
8689       if (loc != base)
8690         {
8691           /* Don't just swap *base and *loc as that changes the order
8692              of the original base[0] and base[1] if they happen to
8693              have the same r_offset.  */
8694           bfd_byte onebuf[sizeof (Elf64_External_Rela)];
8695           memcpy (onebuf, loc, elt_size);
8696           memmove (base + elt_size, base, loc - base);
8697           memcpy (base, onebuf, elt_size);
8698         }
8699
8700       for (p = base + elt_size; (p += elt_size) < end; )
8701         {
8702           /* base to p is sorted, *p is next to insert.  */
8703           r_off = (*ext_r_off) (p);
8704           /* Search the sorted region for location to insert.  */
8705           loc = p - elt_size;
8706           while (r_off < (*ext_r_off) (loc))
8707             loc -= elt_size;
8708           loc += elt_size;
8709           if (loc != p)
8710             {
8711               /* Chances are there is a run of relocs to insert here,
8712                  from one of more input files.  Files are not always
8713                  linked in order due to the way elf_link_input_bfd is
8714                  called.  See pr17666.  */
8715               size_t sortlen = p - loc;
8716               bfd_vma r_off2 = (*ext_r_off) (loc);
8717               size_t runlen = elt_size;
8718               size_t buf_size = 96 * 1024;
8719               while (p + runlen < end
8720                      && (sortlen <= buf_size
8721                          || runlen + elt_size <= buf_size)
8722                      && r_off2 > (*ext_r_off) (p + runlen))
8723                 runlen += elt_size;
8724               if (buf == NULL)
8725                 {
8726                   buf = bfd_malloc (buf_size);
8727                   if (buf == NULL)
8728                     return FALSE;
8729                 }
8730               if (runlen < sortlen)
8731                 {
8732                   memcpy (buf, p, runlen);
8733                   memmove (loc + runlen, loc, sortlen);
8734                   memcpy (loc, buf, runlen);
8735                 }
8736               else
8737                 {
8738                   memcpy (buf, loc, sortlen);
8739                   memmove (loc, p, runlen);
8740                   memcpy (loc + runlen, buf, sortlen);
8741                 }
8742               p += runlen - elt_size;
8743             }
8744         }
8745       /* Hashes are no longer valid.  */
8746       free (reldata->hashes);
8747       reldata->hashes = NULL;
8748       free (buf);
8749     }
8750   return TRUE;
8751 }
8752
8753 struct elf_link_sort_rela
8754 {
8755   union {
8756     bfd_vma offset;
8757     bfd_vma sym_mask;
8758   } u;
8759   enum elf_reloc_type_class type;
8760   /* We use this as an array of size int_rels_per_ext_rel.  */
8761   Elf_Internal_Rela rela[1];
8762 };
8763
8764 static int
8765 elf_link_sort_cmp1 (const void *A, const void *B)
8766 {
8767   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8768   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8769   int relativea, relativeb;
8770
8771   relativea = a->type == reloc_class_relative;
8772   relativeb = b->type == reloc_class_relative;
8773
8774   if (relativea < relativeb)
8775     return 1;
8776   if (relativea > relativeb)
8777     return -1;
8778   if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8779     return -1;
8780   if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8781     return 1;
8782   if (a->rela->r_offset < b->rela->r_offset)
8783     return -1;
8784   if (a->rela->r_offset > b->rela->r_offset)
8785     return 1;
8786   return 0;
8787 }
8788
8789 static int
8790 elf_link_sort_cmp2 (const void *A, const void *B)
8791 {
8792   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8793   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8794
8795   if (a->type < b->type)
8796     return -1;
8797   if (a->type > b->type)
8798     return 1;
8799   if (a->u.offset < b->u.offset)
8800     return -1;
8801   if (a->u.offset > b->u.offset)
8802     return 1;
8803   if (a->rela->r_offset < b->rela->r_offset)
8804     return -1;
8805   if (a->rela->r_offset > b->rela->r_offset)
8806     return 1;
8807   return 0;
8808 }
8809
8810 static size_t
8811 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8812 {
8813   asection *dynamic_relocs;
8814   asection *rela_dyn;
8815   asection *rel_dyn;
8816   bfd_size_type count, size;
8817   size_t i, ret, sort_elt, ext_size;
8818   bfd_byte *sort, *s_non_relative, *p;
8819   struct elf_link_sort_rela *sq;
8820   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8821   int i2e = bed->s->int_rels_per_ext_rel;
8822   unsigned int opb = bfd_octets_per_byte (abfd);
8823   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8824   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8825   struct bfd_link_order *lo;
8826   bfd_vma r_sym_mask;
8827   bfd_boolean use_rela;
8828
8829   /* Find a dynamic reloc section.  */
8830   rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8831   rel_dyn  = bfd_get_section_by_name (abfd, ".rel.dyn");
8832   if (rela_dyn != NULL && rela_dyn->size > 0
8833       && rel_dyn != NULL && rel_dyn->size > 0)
8834     {
8835       bfd_boolean use_rela_initialised = FALSE;
8836
8837       /* This is just here to stop gcc from complaining.
8838          Its initialization checking code is not perfect.  */
8839       use_rela = TRUE;
8840
8841       /* Both sections are present.  Examine the sizes
8842          of the indirect sections to help us choose.  */
8843       for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8844         if (lo->type == bfd_indirect_link_order)
8845           {
8846             asection *o = lo->u.indirect.section;
8847
8848             if ((o->size % bed->s->sizeof_rela) == 0)
8849               {
8850                 if ((o->size % bed->s->sizeof_rel) == 0)
8851                   /* Section size is divisible by both rel and rela sizes.
8852                      It is of no help to us.  */
8853                   ;
8854                 else
8855                   {
8856                     /* Section size is only divisible by rela.  */
8857                     if (use_rela_initialised && !use_rela)
8858                       {
8859                         _bfd_error_handler (_("%B: Unable to sort relocs - "
8860                                               "they are in more than one size"),
8861                                             abfd);
8862                         bfd_set_error (bfd_error_invalid_operation);
8863                         return 0;
8864                       }
8865                     else
8866                       {
8867                         use_rela = TRUE;
8868                         use_rela_initialised = TRUE;
8869                       }
8870                   }
8871               }
8872             else if ((o->size % bed->s->sizeof_rel) == 0)
8873               {
8874                 /* Section size is only divisible by rel.  */
8875                 if (use_rela_initialised && use_rela)
8876                   {
8877                     _bfd_error_handler (_("%B: Unable to sort relocs - "
8878                                           "they are in more than one size"),
8879                                         abfd);
8880                     bfd_set_error (bfd_error_invalid_operation);
8881                     return 0;
8882                   }
8883                 else
8884                   {
8885                     use_rela = FALSE;
8886                     use_rela_initialised = TRUE;
8887                   }
8888               }
8889             else
8890               {
8891                 /* The section size is not divisible by either -
8892                    something is wrong.  */
8893                 _bfd_error_handler (_("%B: Unable to sort relocs - "
8894                                       "they are of an unknown size"), abfd);
8895                 bfd_set_error (bfd_error_invalid_operation);
8896                 return 0;
8897               }
8898           }
8899
8900       for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8901         if (lo->type == bfd_indirect_link_order)
8902           {
8903             asection *o = lo->u.indirect.section;
8904
8905             if ((o->size % bed->s->sizeof_rela) == 0)
8906               {
8907                 if ((o->size % bed->s->sizeof_rel) == 0)
8908                   /* Section size is divisible by both rel and rela sizes.
8909                      It is of no help to us.  */
8910                   ;
8911                 else
8912                   {
8913                     /* Section size is only divisible by rela.  */
8914                     if (use_rela_initialised && !use_rela)
8915                       {
8916                         _bfd_error_handler (_("%B: Unable to sort relocs - "
8917                                               "they are in more than one size"),
8918                                             abfd);
8919                         bfd_set_error (bfd_error_invalid_operation);
8920                         return 0;
8921                       }
8922                     else
8923                       {
8924                         use_rela = TRUE;
8925                         use_rela_initialised = TRUE;
8926                       }
8927                   }
8928               }
8929             else if ((o->size % bed->s->sizeof_rel) == 0)
8930               {
8931                 /* Section size is only divisible by rel.  */
8932                 if (use_rela_initialised && use_rela)
8933                   {
8934                     _bfd_error_handler (_("%B: Unable to sort relocs - "
8935                                           "they are in more than one size"),
8936                                         abfd);
8937                     bfd_set_error (bfd_error_invalid_operation);
8938                     return 0;
8939                   }
8940                 else
8941                   {
8942                     use_rela = FALSE;
8943                     use_rela_initialised = TRUE;
8944                   }
8945               }
8946             else
8947               {
8948                 /* The section size is not divisible by either -
8949                    something is wrong.  */
8950                 _bfd_error_handler (_("%B: Unable to sort relocs - "
8951                                       "they are of an unknown size"), abfd);
8952                 bfd_set_error (bfd_error_invalid_operation);
8953                 return 0;
8954               }
8955           }
8956
8957       if (! use_rela_initialised)
8958         /* Make a guess.  */
8959         use_rela = TRUE;
8960     }
8961   else if (rela_dyn != NULL && rela_dyn->size > 0)
8962     use_rela = TRUE;
8963   else if (rel_dyn != NULL && rel_dyn->size > 0)
8964     use_rela = FALSE;
8965   else
8966     return 0;
8967
8968   if (use_rela)
8969     {
8970       dynamic_relocs = rela_dyn;
8971       ext_size = bed->s->sizeof_rela;
8972       swap_in = bed->s->swap_reloca_in;
8973       swap_out = bed->s->swap_reloca_out;
8974     }
8975   else
8976     {
8977       dynamic_relocs = rel_dyn;
8978       ext_size = bed->s->sizeof_rel;
8979       swap_in = bed->s->swap_reloc_in;
8980       swap_out = bed->s->swap_reloc_out;
8981     }
8982
8983   size = 0;
8984   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8985     if (lo->type == bfd_indirect_link_order)
8986       size += lo->u.indirect.section->size;
8987
8988   if (size != dynamic_relocs->size)
8989     return 0;
8990
8991   sort_elt = (sizeof (struct elf_link_sort_rela)
8992               + (i2e - 1) * sizeof (Elf_Internal_Rela));
8993
8994   count = dynamic_relocs->size / ext_size;
8995   if (count == 0)
8996     return 0;
8997   sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8998
8999   if (sort == NULL)
9000     {
9001       (*info->callbacks->warning)
9002         (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
9003       return 0;
9004     }
9005
9006   if (bed->s->arch_size == 32)
9007     r_sym_mask = ~(bfd_vma) 0xff;
9008   else
9009     r_sym_mask = ~(bfd_vma) 0xffffffff;
9010
9011   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
9012     if (lo->type == bfd_indirect_link_order)
9013       {
9014         bfd_byte *erel, *erelend;
9015         asection *o = lo->u.indirect.section;
9016
9017         if (o->contents == NULL && o->size != 0)
9018           {
9019             /* This is a reloc section that is being handled as a normal
9020                section.  See bfd_section_from_shdr.  We can't combine
9021                relocs in this case.  */
9022             free (sort);
9023             return 0;
9024           }
9025         erel = o->contents;
9026         erelend = o->contents + o->size;
9027         p = sort + o->output_offset * opb / ext_size * sort_elt;
9028
9029         while (erel < erelend)
9030           {
9031             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
9032
9033             (*swap_in) (abfd, erel, s->rela);
9034             s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
9035             s->u.sym_mask = r_sym_mask;
9036             p += sort_elt;
9037             erel += ext_size;
9038           }
9039       }
9040
9041   qsort (sort, count, sort_elt, elf_link_sort_cmp1);
9042
9043   for (i = 0, p = sort; i < count; i++, p += sort_elt)
9044     {
9045       struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
9046       if (s->type != reloc_class_relative)
9047         break;
9048     }
9049   ret = i;
9050   s_non_relative = p;
9051
9052   sq = (struct elf_link_sort_rela *) s_non_relative;
9053   for (; i < count; i++, p += sort_elt)
9054     {
9055       struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
9056       if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
9057         sq = sp;
9058       sp->u.offset = sq->rela->r_offset;
9059     }
9060
9061   qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
9062
9063   struct elf_link_hash_table *htab = elf_hash_table (info);
9064   if (htab->srelplt && htab->srelplt->output_section == dynamic_relocs)
9065     {
9066       /* We have plt relocs in .rela.dyn.  */
9067       sq = (struct elf_link_sort_rela *) sort;
9068       for (i = 0; i < count; i++)
9069         if (sq[count - i - 1].type != reloc_class_plt)
9070           break;
9071       if (i != 0 && htab->srelplt->size == i * ext_size)
9072         {
9073           struct bfd_link_order **plo;
9074           /* Put srelplt link_order last.  This is so the output_offset
9075              set in the next loop is correct for DT_JMPREL.  */
9076           for (plo = &dynamic_relocs->map_head.link_order; *plo != NULL; )
9077             if ((*plo)->type == bfd_indirect_link_order
9078                 && (*plo)->u.indirect.section == htab->srelplt)
9079               {
9080                 lo = *plo;
9081                 *plo = lo->next;
9082               }
9083             else
9084               plo = &(*plo)->next;
9085           *plo = lo;
9086           lo->next = NULL;
9087           dynamic_relocs->map_tail.link_order = lo;
9088         }
9089     }
9090
9091   p = sort;
9092   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
9093     if (lo->type == bfd_indirect_link_order)
9094       {
9095         bfd_byte *erel, *erelend;
9096         asection *o = lo->u.indirect.section;
9097
9098         erel = o->contents;
9099         erelend = o->contents + o->size;
9100         o->output_offset = (p - sort) / sort_elt * ext_size / opb;
9101         while (erel < erelend)
9102           {
9103             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
9104             (*swap_out) (abfd, s->rela, erel);
9105             p += sort_elt;
9106             erel += ext_size;
9107           }
9108       }
9109
9110   free (sort);
9111   *psec = dynamic_relocs;
9112   return ret;
9113 }
9114
9115 /* Add a symbol to the output symbol string table.  */
9116
9117 static int
9118 elf_link_output_symstrtab (struct elf_final_link_info *flinfo,
9119                            const char *name,
9120                            Elf_Internal_Sym *elfsym,
9121                            asection *input_sec,
9122                            struct elf_link_hash_entry *h)
9123 {
9124   int (*output_symbol_hook)
9125     (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
9126      struct elf_link_hash_entry *);
9127   struct elf_link_hash_table *hash_table;
9128   const struct elf_backend_data *bed;
9129   bfd_size_type strtabsize;
9130
9131   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
9132
9133   bed = get_elf_backend_data (flinfo->output_bfd);
9134   output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
9135   if (output_symbol_hook != NULL)
9136     {
9137       int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
9138       if (ret != 1)
9139         return ret;
9140     }
9141
9142   if (name == NULL
9143       || *name == '\0'
9144       || (input_sec->flags & SEC_EXCLUDE))
9145     elfsym->st_name = (unsigned long) -1;
9146   else
9147     {
9148       /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
9149          to get the final offset for st_name.  */
9150       elfsym->st_name
9151         = (unsigned long) _bfd_elf_strtab_add (flinfo->symstrtab,
9152                                                name, FALSE);
9153       if (elfsym->st_name == (unsigned long) -1)
9154         return 0;
9155     }
9156
9157   hash_table = elf_hash_table (flinfo->info);
9158   strtabsize = hash_table->strtabsize;
9159   if (strtabsize <= hash_table->strtabcount)
9160     {
9161       strtabsize += strtabsize;
9162       hash_table->strtabsize = strtabsize;
9163       strtabsize *= sizeof (*hash_table->strtab);
9164       hash_table->strtab
9165         = (struct elf_sym_strtab *) bfd_realloc (hash_table->strtab,
9166                                                  strtabsize);
9167       if (hash_table->strtab == NULL)
9168         return 0;
9169     }
9170   hash_table->strtab[hash_table->strtabcount].sym = *elfsym;
9171   hash_table->strtab[hash_table->strtabcount].dest_index
9172     = hash_table->strtabcount;
9173   hash_table->strtab[hash_table->strtabcount].destshndx_index
9174     = flinfo->symshndxbuf ? bfd_get_symcount (flinfo->output_bfd) : 0;
9175
9176   bfd_get_symcount (flinfo->output_bfd) += 1;
9177   hash_table->strtabcount += 1;
9178
9179   return 1;
9180 }
9181
9182 /* Swap symbols out to the symbol table and flush the output symbols to
9183    the file.  */
9184
9185 static bfd_boolean
9186 elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
9187 {
9188   struct elf_link_hash_table *hash_table = elf_hash_table (flinfo->info);
9189   bfd_size_type amt;
9190   size_t i;
9191   const struct elf_backend_data *bed;
9192   bfd_byte *symbuf;
9193   Elf_Internal_Shdr *hdr;
9194   file_ptr pos;
9195   bfd_boolean ret;
9196
9197   if (!hash_table->strtabcount)
9198     return TRUE;
9199
9200   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
9201
9202   bed = get_elf_backend_data (flinfo->output_bfd);
9203
9204   amt = bed->s->sizeof_sym * hash_table->strtabcount;
9205   symbuf = (bfd_byte *) bfd_malloc (amt);
9206   if (symbuf == NULL)
9207     return FALSE;
9208
9209   if (flinfo->symshndxbuf)
9210     {
9211       amt = sizeof (Elf_External_Sym_Shndx);
9212       amt *= bfd_get_symcount (flinfo->output_bfd);
9213       flinfo->symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
9214       if (flinfo->symshndxbuf == NULL)
9215         {
9216           free (symbuf);
9217           return FALSE;
9218         }
9219     }
9220
9221   for (i = 0; i < hash_table->strtabcount; i++)
9222     {
9223       struct elf_sym_strtab *elfsym = &hash_table->strtab[i];
9224       if (elfsym->sym.st_name == (unsigned long) -1)
9225         elfsym->sym.st_name = 0;
9226       else
9227         elfsym->sym.st_name
9228           = (unsigned long) _bfd_elf_strtab_offset (flinfo->symstrtab,
9229                                                     elfsym->sym.st_name);
9230       bed->s->swap_symbol_out (flinfo->output_bfd, &elfsym->sym,
9231                                ((bfd_byte *) symbuf
9232                                 + (elfsym->dest_index
9233                                    * bed->s->sizeof_sym)),
9234                                (flinfo->symshndxbuf
9235                                 + elfsym->destshndx_index));
9236     }
9237
9238   hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
9239   pos = hdr->sh_offset + hdr->sh_size;
9240   amt = hash_table->strtabcount * bed->s->sizeof_sym;
9241   if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) == 0
9242       && bfd_bwrite (symbuf, amt, flinfo->output_bfd) == amt)
9243     {
9244       hdr->sh_size += amt;
9245       ret = TRUE;
9246     }
9247   else
9248     ret = FALSE;
9249
9250   free (symbuf);
9251
9252   free (hash_table->strtab);
9253   hash_table->strtab = NULL;
9254
9255   return ret;
9256 }
9257
9258 /* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
9259
9260 static bfd_boolean
9261 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
9262 {
9263   if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
9264       && sym->st_shndx < SHN_LORESERVE)
9265     {
9266       /* The gABI doesn't support dynamic symbols in output sections
9267          beyond 64k.  */
9268       _bfd_error_handler
9269         /* xgettext:c-format */
9270         (_("%B: Too many sections: %d (>= %d)"),
9271          abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
9272       bfd_set_error (bfd_error_nonrepresentable_section);
9273       return FALSE;
9274     }
9275   return TRUE;
9276 }
9277
9278 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
9279    allowing an unsatisfied unversioned symbol in the DSO to match a
9280    versioned symbol that would normally require an explicit version.
9281    We also handle the case that a DSO references a hidden symbol
9282    which may be satisfied by a versioned symbol in another DSO.  */
9283
9284 static bfd_boolean
9285 elf_link_check_versioned_symbol (struct bfd_link_info *info,
9286                                  const struct elf_backend_data *bed,
9287                                  struct elf_link_hash_entry *h)
9288 {
9289   bfd *abfd;
9290   struct elf_link_loaded_list *loaded;
9291
9292   if (!is_elf_hash_table (info->hash))
9293     return FALSE;
9294
9295   /* Check indirect symbol.  */
9296   while (h->root.type == bfd_link_hash_indirect)
9297     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9298
9299   switch (h->root.type)
9300     {
9301     default:
9302       abfd = NULL;
9303       break;
9304
9305     case bfd_link_hash_undefined:
9306     case bfd_link_hash_undefweak:
9307       abfd = h->root.u.undef.abfd;
9308       if (abfd == NULL
9309           || (abfd->flags & DYNAMIC) == 0
9310           || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
9311         return FALSE;
9312       break;
9313
9314     case bfd_link_hash_defined:
9315     case bfd_link_hash_defweak:
9316       abfd = h->root.u.def.section->owner;
9317       break;
9318
9319     case bfd_link_hash_common:
9320       abfd = h->root.u.c.p->section->owner;
9321       break;
9322     }
9323   BFD_ASSERT (abfd != NULL);
9324
9325   for (loaded = elf_hash_table (info)->loaded;
9326        loaded != NULL;
9327        loaded = loaded->next)
9328     {
9329       bfd *input;
9330       Elf_Internal_Shdr *hdr;
9331       size_t symcount;
9332       size_t extsymcount;
9333       size_t extsymoff;
9334       Elf_Internal_Shdr *versymhdr;
9335       Elf_Internal_Sym *isym;
9336       Elf_Internal_Sym *isymend;
9337       Elf_Internal_Sym *isymbuf;
9338       Elf_External_Versym *ever;
9339       Elf_External_Versym *extversym;
9340
9341       input = loaded->abfd;
9342
9343       /* We check each DSO for a possible hidden versioned definition.  */
9344       if (input == abfd
9345           || (input->flags & DYNAMIC) == 0
9346           || elf_dynversym (input) == 0)
9347         continue;
9348
9349       hdr = &elf_tdata (input)->dynsymtab_hdr;
9350
9351       symcount = hdr->sh_size / bed->s->sizeof_sym;
9352       if (elf_bad_symtab (input))
9353         {
9354           extsymcount = symcount;
9355           extsymoff = 0;
9356         }
9357       else
9358         {
9359           extsymcount = symcount - hdr->sh_info;
9360           extsymoff = hdr->sh_info;
9361         }
9362
9363       if (extsymcount == 0)
9364         continue;
9365
9366       isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
9367                                       NULL, NULL, NULL);
9368       if (isymbuf == NULL)
9369         return FALSE;
9370
9371       /* Read in any version definitions.  */
9372       versymhdr = &elf_tdata (input)->dynversym_hdr;
9373       extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
9374       if (extversym == NULL)
9375         goto error_ret;
9376
9377       if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
9378           || (bfd_bread (extversym, versymhdr->sh_size, input)
9379               != versymhdr->sh_size))
9380         {
9381           free (extversym);
9382         error_ret:
9383           free (isymbuf);
9384           return FALSE;
9385         }
9386
9387       ever = extversym + extsymoff;
9388       isymend = isymbuf + extsymcount;
9389       for (isym = isymbuf; isym < isymend; isym++, ever++)
9390         {
9391           const char *name;
9392           Elf_Internal_Versym iver;
9393           unsigned short version_index;
9394
9395           if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
9396               || isym->st_shndx == SHN_UNDEF)
9397             continue;
9398
9399           name = bfd_elf_string_from_elf_section (input,
9400                                                   hdr->sh_link,
9401                                                   isym->st_name);
9402           if (strcmp (name, h->root.root.string) != 0)
9403             continue;
9404
9405           _bfd_elf_swap_versym_in (input, ever, &iver);
9406
9407           if ((iver.vs_vers & VERSYM_HIDDEN) == 0
9408               && !(h->def_regular
9409                    && h->forced_local))
9410             {
9411               /* If we have a non-hidden versioned sym, then it should
9412                  have provided a definition for the undefined sym unless
9413                  it is defined in a non-shared object and forced local.
9414                */
9415               abort ();
9416             }
9417
9418           version_index = iver.vs_vers & VERSYM_VERSION;
9419           if (version_index == 1 || version_index == 2)
9420             {
9421               /* This is the base or first version.  We can use it.  */
9422               free (extversym);
9423               free (isymbuf);
9424               return TRUE;
9425             }
9426         }
9427
9428       free (extversym);
9429       free (isymbuf);
9430     }
9431
9432   return FALSE;
9433 }
9434
9435 /* Convert ELF common symbol TYPE.  */
9436
9437 static int
9438 elf_link_convert_common_type (struct bfd_link_info *info, int type)
9439 {
9440   /* Commom symbol can only appear in relocatable link.  */
9441   if (!bfd_link_relocatable (info))
9442     abort ();
9443   switch (info->elf_stt_common)
9444     {
9445     case unchanged:
9446       break;
9447     case elf_stt_common:
9448       type = STT_COMMON;
9449       break;
9450     case no_elf_stt_common:
9451       type = STT_OBJECT;
9452       break;
9453     }
9454   return type;
9455 }
9456
9457 /* Add an external symbol to the symbol table.  This is called from
9458    the hash table traversal routine.  When generating a shared object,
9459    we go through the symbol table twice.  The first time we output
9460    anything that might have been forced to local scope in a version
9461    script.  The second time we output the symbols that are still
9462    global symbols.  */
9463
9464 static bfd_boolean
9465 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
9466 {
9467   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
9468   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
9469   struct elf_final_link_info *flinfo = eoinfo->flinfo;
9470   bfd_boolean strip;
9471   Elf_Internal_Sym sym;
9472   asection *input_sec;
9473   const struct elf_backend_data *bed;
9474   long indx;
9475   int ret;
9476   unsigned int type;
9477
9478   if (h->root.type == bfd_link_hash_warning)
9479     {
9480       h = (struct elf_link_hash_entry *) h->root.u.i.link;
9481       if (h->root.type == bfd_link_hash_new)
9482         return TRUE;
9483     }
9484
9485   /* Decide whether to output this symbol in this pass.  */
9486   if (eoinfo->localsyms)
9487     {
9488       if (!h->forced_local)
9489         return TRUE;
9490     }
9491   else
9492     {
9493       if (h->forced_local)
9494         return TRUE;
9495     }
9496
9497   bed = get_elf_backend_data (flinfo->output_bfd);
9498
9499   if (h->root.type == bfd_link_hash_undefined)
9500     {
9501       /* If we have an undefined symbol reference here then it must have
9502          come from a shared library that is being linked in.  (Undefined
9503          references in regular files have already been handled unless
9504          they are in unreferenced sections which are removed by garbage
9505          collection).  */
9506       bfd_boolean ignore_undef = FALSE;
9507
9508       /* Some symbols may be special in that the fact that they're
9509          undefined can be safely ignored - let backend determine that.  */
9510       if (bed->elf_backend_ignore_undef_symbol)
9511         ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
9512
9513       /* If we are reporting errors for this situation then do so now.  */
9514       if (!ignore_undef
9515           && h->ref_dynamic
9516           && (!h->ref_regular || flinfo->info->gc_sections)
9517           && !elf_link_check_versioned_symbol (flinfo->info, bed, h)
9518           && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
9519         (*flinfo->info->callbacks->undefined_symbol)
9520           (flinfo->info, h->root.root.string,
9521            h->ref_regular ? NULL : h->root.u.undef.abfd,
9522            NULL, 0,
9523            flinfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR);
9524
9525       /* Strip a global symbol defined in a discarded section.  */
9526       if (h->indx == -3)
9527         return TRUE;
9528     }
9529
9530   /* We should also warn if a forced local symbol is referenced from
9531      shared libraries.  */
9532   if (bfd_link_executable (flinfo->info)
9533       && h->forced_local
9534       && h->ref_dynamic
9535       && h->def_regular
9536       && !h->dynamic_def
9537       && h->ref_dynamic_nonweak
9538       && !elf_link_check_versioned_symbol (flinfo->info, bed, h))
9539     {
9540       bfd *def_bfd;
9541       const char *msg;
9542       struct elf_link_hash_entry *hi = h;
9543
9544       /* Check indirect symbol.  */
9545       while (hi->root.type == bfd_link_hash_indirect)
9546         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
9547
9548       if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
9549         /* xgettext:c-format */
9550         msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
9551       else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
9552         /* xgettext:c-format */
9553         msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
9554       else
9555         /* xgettext:c-format */
9556         msg = _("%B: local symbol `%s' in %B is referenced by DSO");
9557       def_bfd = flinfo->output_bfd;
9558       if (hi->root.u.def.section != bfd_abs_section_ptr)
9559         def_bfd = hi->root.u.def.section->owner;
9560       _bfd_error_handler (msg, flinfo->output_bfd,
9561                           h->root.root.string, def_bfd);
9562       bfd_set_error (bfd_error_bad_value);
9563       eoinfo->failed = TRUE;
9564       return FALSE;
9565     }
9566
9567   /* We don't want to output symbols that have never been mentioned by
9568      a regular file, or that we have been told to strip.  However, if
9569      h->indx is set to -2, the symbol is used by a reloc and we must
9570      output it.  */
9571   strip = FALSE;
9572   if (h->indx == -2)
9573     ;
9574   else if ((h->def_dynamic
9575             || h->ref_dynamic
9576             || h->root.type == bfd_link_hash_new)
9577            && !h->def_regular
9578            && !h->ref_regular)
9579     strip = TRUE;
9580   else if (flinfo->info->strip == strip_all)
9581     strip = TRUE;
9582   else if (flinfo->info->strip == strip_some
9583            && bfd_hash_lookup (flinfo->info->keep_hash,
9584                                h->root.root.string, FALSE, FALSE) == NULL)
9585     strip = TRUE;
9586   else if ((h->root.type == bfd_link_hash_defined
9587             || h->root.type == bfd_link_hash_defweak)
9588            && ((flinfo->info->strip_discarded
9589                 && discarded_section (h->root.u.def.section))
9590                || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0
9591                    && h->root.u.def.section->owner != NULL
9592                    && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
9593     strip = TRUE;
9594   else if ((h->root.type == bfd_link_hash_undefined
9595             || h->root.type == bfd_link_hash_undefweak)
9596            && h->root.u.undef.abfd != NULL
9597            && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
9598     strip = TRUE;
9599
9600   type = h->type;
9601
9602   /* If we're stripping it, and it's not a dynamic symbol, there's
9603      nothing else to do.   However, if it is a forced local symbol or
9604      an ifunc symbol we need to give the backend finish_dynamic_symbol
9605      function a chance to make it dynamic.  */
9606   if (strip
9607       && h->dynindx == -1
9608       && type != STT_GNU_IFUNC
9609       && !h->forced_local)
9610     return TRUE;
9611
9612   sym.st_value = 0;
9613   sym.st_size = h->size;
9614   sym.st_other = h->other;
9615   switch (h->root.type)
9616     {
9617     default:
9618     case bfd_link_hash_new:
9619     case bfd_link_hash_warning:
9620       abort ();
9621       return FALSE;
9622
9623     case bfd_link_hash_undefined:
9624     case bfd_link_hash_undefweak:
9625       input_sec = bfd_und_section_ptr;
9626       sym.st_shndx = SHN_UNDEF;
9627       break;
9628
9629     case bfd_link_hash_defined:
9630     case bfd_link_hash_defweak:
9631       {
9632         input_sec = h->root.u.def.section;
9633         if (input_sec->output_section != NULL)
9634           {
9635             sym.st_shndx =
9636               _bfd_elf_section_from_bfd_section (flinfo->output_bfd,
9637                                                  input_sec->output_section);
9638             if (sym.st_shndx == SHN_BAD)
9639               {
9640                 _bfd_error_handler
9641                   /* xgettext:c-format */
9642                   (_("%B: could not find output section %A for input section %A"),
9643                    flinfo->output_bfd, input_sec->output_section, input_sec);
9644                 bfd_set_error (bfd_error_nonrepresentable_section);
9645                 eoinfo->failed = TRUE;
9646                 return FALSE;
9647               }
9648
9649             /* ELF symbols in relocatable files are section relative,
9650                but in nonrelocatable files they are virtual
9651                addresses.  */
9652             sym.st_value = h->root.u.def.value + input_sec->output_offset;
9653             if (!bfd_link_relocatable (flinfo->info))
9654               {
9655                 sym.st_value += input_sec->output_section->vma;
9656                 if (h->type == STT_TLS)
9657                   {
9658                     asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
9659                     if (tls_sec != NULL)
9660                       sym.st_value -= tls_sec->vma;
9661                   }
9662               }
9663           }
9664         else
9665           {
9666             BFD_ASSERT (input_sec->owner == NULL
9667                         || (input_sec->owner->flags & DYNAMIC) != 0);
9668             sym.st_shndx = SHN_UNDEF;
9669             input_sec = bfd_und_section_ptr;
9670           }
9671       }
9672       break;
9673
9674     case bfd_link_hash_common:
9675       input_sec = h->root.u.c.p->section;
9676       sym.st_shndx = bed->common_section_index (input_sec);
9677       sym.st_value = 1 << h->root.u.c.p->alignment_power;
9678       break;
9679
9680     case bfd_link_hash_indirect:
9681       /* These symbols are created by symbol versioning.  They point
9682          to the decorated version of the name.  For example, if the
9683          symbol foo@@GNU_1.2 is the default, which should be used when
9684          foo is used with no version, then we add an indirect symbol
9685          foo which points to foo@@GNU_1.2.  We ignore these symbols,
9686          since the indirected symbol is already in the hash table.  */
9687       return TRUE;
9688     }
9689
9690   if (type == STT_COMMON || type == STT_OBJECT)
9691     switch (h->root.type)
9692       {
9693       case bfd_link_hash_common:
9694         type = elf_link_convert_common_type (flinfo->info, type);
9695         break;
9696       case bfd_link_hash_defined:
9697       case bfd_link_hash_defweak:
9698         if (bed->common_definition (&sym))
9699           type = elf_link_convert_common_type (flinfo->info, type);
9700         else
9701           type = STT_OBJECT;
9702         break;
9703       case bfd_link_hash_undefined:
9704       case bfd_link_hash_undefweak:
9705         break;
9706       default:
9707         abort ();
9708       }
9709
9710   if (h->forced_local)
9711     {
9712       sym.st_info = ELF_ST_INFO (STB_LOCAL, type);
9713       /* Turn off visibility on local symbol.  */
9714       sym.st_other &= ~ELF_ST_VISIBILITY (-1);
9715     }
9716   /* Set STB_GNU_UNIQUE only if symbol is defined in regular object.  */
9717   else if (h->unique_global && h->def_regular)
9718     sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, type);
9719   else if (h->root.type == bfd_link_hash_undefweak
9720            || h->root.type == bfd_link_hash_defweak)
9721     sym.st_info = ELF_ST_INFO (STB_WEAK, type);
9722   else
9723     sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
9724   sym.st_target_internal = h->target_internal;
9725
9726   /* Give the processor backend a chance to tweak the symbol value,
9727      and also to finish up anything that needs to be done for this
9728      symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
9729      forced local syms when non-shared is due to a historical quirk.
9730      STT_GNU_IFUNC symbol must go through PLT.  */
9731   if ((h->type == STT_GNU_IFUNC
9732        && h->def_regular
9733        && !bfd_link_relocatable (flinfo->info))
9734       || ((h->dynindx != -1
9735            || h->forced_local)
9736           && ((bfd_link_pic (flinfo->info)
9737                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9738                    || h->root.type != bfd_link_hash_undefweak))
9739               || !h->forced_local)
9740           && elf_hash_table (flinfo->info)->dynamic_sections_created))
9741     {
9742       if (! ((*bed->elf_backend_finish_dynamic_symbol)
9743              (flinfo->output_bfd, flinfo->info, h, &sym)))
9744         {
9745           eoinfo->failed = TRUE;
9746           return FALSE;
9747         }
9748     }
9749
9750   /* If we are marking the symbol as undefined, and there are no
9751      non-weak references to this symbol from a regular object, then
9752      mark the symbol as weak undefined; if there are non-weak
9753      references, mark the symbol as strong.  We can't do this earlier,
9754      because it might not be marked as undefined until the
9755      finish_dynamic_symbol routine gets through with it.  */
9756   if (sym.st_shndx == SHN_UNDEF
9757       && h->ref_regular
9758       && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
9759           || ELF_ST_BIND (sym.st_info) == STB_WEAK))
9760     {
9761       int bindtype;
9762       type = ELF_ST_TYPE (sym.st_info);
9763
9764       /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9765       if (type == STT_GNU_IFUNC)
9766         type = STT_FUNC;
9767
9768       if (h->ref_regular_nonweak)
9769         bindtype = STB_GLOBAL;
9770       else
9771         bindtype = STB_WEAK;
9772       sym.st_info = ELF_ST_INFO (bindtype, type);
9773     }
9774
9775   /* If this is a symbol defined in a dynamic library, don't use the
9776      symbol size from the dynamic library.  Relinking an executable
9777      against a new library may introduce gratuitous changes in the
9778      executable's symbols if we keep the size.  */
9779   if (sym.st_shndx == SHN_UNDEF
9780       && !h->def_regular
9781       && h->def_dynamic)
9782     sym.st_size = 0;
9783
9784   /* If a non-weak symbol with non-default visibility is not defined
9785      locally, it is a fatal error.  */
9786   if (!bfd_link_relocatable (flinfo->info)
9787       && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
9788       && ELF_ST_BIND (sym.st_info) != STB_WEAK
9789       && h->root.type == bfd_link_hash_undefined
9790       && !h->def_regular)
9791     {
9792       const char *msg;
9793
9794       if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
9795         /* xgettext:c-format */
9796         msg = _("%B: protected symbol `%s' isn't defined");
9797       else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
9798         /* xgettext:c-format */
9799         msg = _("%B: internal symbol `%s' isn't defined");
9800       else
9801         /* xgettext:c-format */
9802         msg = _("%B: hidden symbol `%s' isn't defined");
9803       _bfd_error_handler (msg, flinfo->output_bfd, h->root.root.string);
9804       bfd_set_error (bfd_error_bad_value);
9805       eoinfo->failed = TRUE;
9806       return FALSE;
9807     }
9808
9809   /* If this symbol should be put in the .dynsym section, then put it
9810      there now.  We already know the symbol index.  We also fill in
9811      the entry in the .hash section.  */
9812   if (elf_hash_table (flinfo->info)->dynsym != NULL
9813       && h->dynindx != -1
9814       && elf_hash_table (flinfo->info)->dynamic_sections_created)
9815     {
9816       bfd_byte *esym;
9817
9818       /* Since there is no version information in the dynamic string,
9819          if there is no version info in symbol version section, we will
9820          have a run-time problem if not linking executable, referenced
9821          by shared library, or not bound locally.  */
9822       if (h->verinfo.verdef == NULL
9823           && (!bfd_link_executable (flinfo->info)
9824               || h->ref_dynamic
9825               || !h->def_regular))
9826         {
9827           char *p = strrchr (h->root.root.string, ELF_VER_CHR);
9828
9829           if (p && p [1] != '\0')
9830             {
9831               _bfd_error_handler
9832                 /* xgettext:c-format */
9833                 (_("%B: No symbol version section for versioned symbol `%s'"),
9834                  flinfo->output_bfd, h->root.root.string);
9835               eoinfo->failed = TRUE;
9836               return FALSE;
9837             }
9838         }
9839
9840       sym.st_name = h->dynstr_index;
9841       esym = (elf_hash_table (flinfo->info)->dynsym->contents
9842               + h->dynindx * bed->s->sizeof_sym);
9843       if (!check_dynsym (flinfo->output_bfd, &sym))
9844         {
9845           eoinfo->failed = TRUE;
9846           return FALSE;
9847         }
9848       bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
9849
9850       if (flinfo->hash_sec != NULL)
9851         {
9852           size_t hash_entry_size;
9853           bfd_byte *bucketpos;
9854           bfd_vma chain;
9855           size_t bucketcount;
9856           size_t bucket;
9857
9858           bucketcount = elf_hash_table (flinfo->info)->bucketcount;
9859           bucket = h->u.elf_hash_value % bucketcount;
9860
9861           hash_entry_size
9862             = elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
9863           bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
9864                        + (bucket + 2) * hash_entry_size);
9865           chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
9866           bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
9867                    bucketpos);
9868           bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
9869                    ((bfd_byte *) flinfo->hash_sec->contents
9870                     + (bucketcount + 2 + h->dynindx) * hash_entry_size));
9871         }
9872
9873       if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
9874         {
9875           Elf_Internal_Versym iversym;
9876           Elf_External_Versym *eversym;
9877
9878           if (!h->def_regular)
9879             {
9880               if (h->verinfo.verdef == NULL
9881                   || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
9882                       & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
9883                 iversym.vs_vers = 0;
9884               else
9885                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
9886             }
9887           else
9888             {
9889               if (h->verinfo.vertree == NULL)
9890                 iversym.vs_vers = 1;
9891               else
9892                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
9893               if (flinfo->info->create_default_symver)
9894                 iversym.vs_vers++;
9895             }
9896
9897           /* Turn on VERSYM_HIDDEN only if the hidden versioned symbol is
9898              defined locally.  */
9899           if (h->versioned == versioned_hidden && h->def_regular)
9900             iversym.vs_vers |= VERSYM_HIDDEN;
9901
9902           eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
9903           eversym += h->dynindx;
9904           _bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
9905         }
9906     }
9907
9908   /* If the symbol is undefined, and we didn't output it to .dynsym,
9909      strip it from .symtab too.  Obviously we can't do this for
9910      relocatable output or when needed for --emit-relocs.  */
9911   else if (input_sec == bfd_und_section_ptr
9912            && h->indx != -2
9913            && !bfd_link_relocatable (flinfo->info))
9914     return TRUE;
9915   /* Also strip others that we couldn't earlier due to dynamic symbol
9916      processing.  */
9917   if (strip)
9918     return TRUE;
9919   if ((input_sec->flags & SEC_EXCLUDE) != 0)
9920     return TRUE;
9921
9922   /* Output a FILE symbol so that following locals are not associated
9923      with the wrong input file.  We need one for forced local symbols
9924      if we've seen more than one FILE symbol or when we have exactly
9925      one FILE symbol but global symbols are present in a file other
9926      than the one with the FILE symbol.  We also need one if linker
9927      defined symbols are present.  In practice these conditions are
9928      always met, so just emit the FILE symbol unconditionally.  */
9929   if (eoinfo->localsyms
9930       && !eoinfo->file_sym_done
9931       && eoinfo->flinfo->filesym_count != 0)
9932     {
9933       Elf_Internal_Sym fsym;
9934
9935       memset (&fsym, 0, sizeof (fsym));
9936       fsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9937       fsym.st_shndx = SHN_ABS;
9938       if (!elf_link_output_symstrtab (eoinfo->flinfo, NULL, &fsym,
9939                                       bfd_und_section_ptr, NULL))
9940         return FALSE;
9941
9942       eoinfo->file_sym_done = TRUE;
9943     }
9944
9945   indx = bfd_get_symcount (flinfo->output_bfd);
9946   ret = elf_link_output_symstrtab (flinfo, h->root.root.string, &sym,
9947                                    input_sec, h);
9948   if (ret == 0)
9949     {
9950       eoinfo->failed = TRUE;
9951       return FALSE;
9952     }
9953   else if (ret == 1)
9954     h->indx = indx;
9955   else if (h->indx == -2)
9956     abort();
9957
9958   return TRUE;
9959 }
9960
9961 /* Return TRUE if special handling is done for relocs in SEC against
9962    symbols defined in discarded sections.  */
9963
9964 static bfd_boolean
9965 elf_section_ignore_discarded_relocs (asection *sec)
9966 {
9967   const struct elf_backend_data *bed;
9968
9969   switch (sec->sec_info_type)
9970     {
9971     case SEC_INFO_TYPE_STABS:
9972     case SEC_INFO_TYPE_EH_FRAME:
9973     case SEC_INFO_TYPE_EH_FRAME_ENTRY:
9974       return TRUE;
9975     default:
9976       break;
9977     }
9978
9979   bed = get_elf_backend_data (sec->owner);
9980   if (bed->elf_backend_ignore_discarded_relocs != NULL
9981       && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9982     return TRUE;
9983
9984   return FALSE;
9985 }
9986
9987 /* Return a mask saying how ld should treat relocations in SEC against
9988    symbols defined in discarded sections.  If this function returns
9989    COMPLAIN set, ld will issue a warning message.  If this function
9990    returns PRETEND set, and the discarded section was link-once and the
9991    same size as the kept link-once section, ld will pretend that the
9992    symbol was actually defined in the kept section.  Otherwise ld will
9993    zero the reloc (at least that is the intent, but some cooperation by
9994    the target dependent code is needed, particularly for REL targets).  */
9995
9996 unsigned int
9997 _bfd_elf_default_action_discarded (asection *sec)
9998 {
9999   if (sec->flags & SEC_DEBUGGING)
10000     return PRETEND;
10001
10002   if (strcmp (".eh_frame", sec->name) == 0)
10003     return 0;
10004
10005   if (strcmp (".gcc_except_table", sec->name) == 0)
10006     return 0;
10007
10008   return COMPLAIN | PRETEND;
10009 }
10010
10011 /* Find a match between a section and a member of a section group.  */
10012
10013 static asection *
10014 match_group_member (asection *sec, asection *group,
10015                     struct bfd_link_info *info)
10016 {
10017   asection *first = elf_next_in_group (group);
10018   asection *s = first;
10019
10020   while (s != NULL)
10021     {
10022       if (bfd_elf_match_symbols_in_sections (s, sec, info))
10023         return s;
10024
10025       s = elf_next_in_group (s);
10026       if (s == first)
10027         break;
10028     }
10029
10030   return NULL;
10031 }
10032
10033 /* Check if the kept section of a discarded section SEC can be used
10034    to replace it.  Return the replacement if it is OK.  Otherwise return
10035    NULL.  */
10036
10037 asection *
10038 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
10039 {
10040   asection *kept;
10041
10042   kept = sec->kept_section;
10043   if (kept != NULL)
10044     {
10045       if ((kept->flags & SEC_GROUP) != 0)
10046         kept = match_group_member (sec, kept, info);
10047       if (kept != NULL
10048           && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
10049               != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
10050         kept = NULL;
10051       sec->kept_section = kept;
10052     }
10053   return kept;
10054 }
10055
10056 /* Link an input file into the linker output file.  This function
10057    handles all the sections and relocations of the input file at once.
10058    This is so that we only have to read the local symbols once, and
10059    don't have to keep them in memory.  */
10060
10061 static bfd_boolean
10062 elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
10063 {
10064   int (*relocate_section)
10065     (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
10066      Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
10067   bfd *output_bfd;
10068   Elf_Internal_Shdr *symtab_hdr;
10069   size_t locsymcount;
10070   size_t extsymoff;
10071   Elf_Internal_Sym *isymbuf;
10072   Elf_Internal_Sym *isym;
10073   Elf_Internal_Sym *isymend;
10074   long *pindex;
10075   asection **ppsection;
10076   asection *o;
10077   const struct elf_backend_data *bed;
10078   struct elf_link_hash_entry **sym_hashes;
10079   bfd_size_type address_size;
10080   bfd_vma r_type_mask;
10081   int r_sym_shift;
10082   bfd_boolean have_file_sym = FALSE;
10083
10084   output_bfd = flinfo->output_bfd;
10085   bed = get_elf_backend_data (output_bfd);
10086   relocate_section = bed->elf_backend_relocate_section;
10087
10088   /* If this is a dynamic object, we don't want to do anything here:
10089      we don't want the local symbols, and we don't want the section
10090      contents.  */
10091   if ((input_bfd->flags & DYNAMIC) != 0)
10092     return TRUE;
10093
10094   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
10095   if (elf_bad_symtab (input_bfd))
10096     {
10097       locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
10098       extsymoff = 0;
10099     }
10100   else
10101     {
10102       locsymcount = symtab_hdr->sh_info;
10103       extsymoff = symtab_hdr->sh_info;
10104     }
10105
10106   /* Read the local symbols.  */
10107   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
10108   if (isymbuf == NULL && locsymcount != 0)
10109     {
10110       isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
10111                                       flinfo->internal_syms,
10112                                       flinfo->external_syms,
10113                                       flinfo->locsym_shndx);
10114       if (isymbuf == NULL)
10115         return FALSE;
10116     }
10117
10118   /* Find local symbol sections and adjust values of symbols in
10119      SEC_MERGE sections.  Write out those local symbols we know are
10120      going into the output file.  */
10121   isymend = isymbuf + locsymcount;
10122   for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
10123        isym < isymend;
10124        isym++, pindex++, ppsection++)
10125     {
10126       asection *isec;
10127       const char *name;
10128       Elf_Internal_Sym osym;
10129       long indx;
10130       int ret;
10131
10132       *pindex = -1;
10133
10134       if (elf_bad_symtab (input_bfd))
10135         {
10136           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
10137             {
10138               *ppsection = NULL;
10139               continue;
10140             }
10141         }
10142
10143       if (isym->st_shndx == SHN_UNDEF)
10144         isec = bfd_und_section_ptr;
10145       else if (isym->st_shndx == SHN_ABS)
10146         isec = bfd_abs_section_ptr;
10147       else if (isym->st_shndx == SHN_COMMON)
10148         isec = bfd_com_section_ptr;
10149       else
10150         {
10151           isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
10152           if (isec == NULL)
10153             {
10154               /* Don't attempt to output symbols with st_shnx in the
10155                  reserved range other than SHN_ABS and SHN_COMMON.  */
10156               *ppsection = NULL;
10157               continue;
10158             }
10159           else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
10160                    && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
10161             isym->st_value =
10162               _bfd_merged_section_offset (output_bfd, &isec,
10163                                           elf_section_data (isec)->sec_info,
10164                                           isym->st_value);
10165         }
10166
10167       *ppsection = isec;
10168
10169       /* Don't output the first, undefined, symbol.  In fact, don't
10170          output any undefined local symbol.  */
10171       if (isec == bfd_und_section_ptr)
10172         continue;
10173
10174       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
10175         {
10176           /* We never output section symbols.  Instead, we use the
10177              section symbol of the corresponding section in the output
10178              file.  */
10179           continue;
10180         }
10181
10182       /* If we are stripping all symbols, we don't want to output this
10183          one.  */
10184       if (flinfo->info->strip == strip_all)
10185         continue;
10186
10187       /* If we are discarding all local symbols, we don't want to
10188          output this one.  If we are generating a relocatable output
10189          file, then some of the local symbols may be required by
10190          relocs; we output them below as we discover that they are
10191          needed.  */
10192       if (flinfo->info->discard == discard_all)
10193         continue;
10194
10195       /* If this symbol is defined in a section which we are
10196          discarding, we don't need to keep it.  */
10197       if (isym->st_shndx != SHN_UNDEF
10198           && isym->st_shndx < SHN_LORESERVE
10199           && bfd_section_removed_from_list (output_bfd,
10200                                             isec->output_section))
10201         continue;
10202
10203       /* Get the name of the symbol.  */
10204       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
10205                                               isym->st_name);
10206       if (name == NULL)
10207         return FALSE;
10208
10209       /* See if we are discarding symbols with this name.  */
10210       if ((flinfo->info->strip == strip_some
10211            && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
10212                == NULL))
10213           || (((flinfo->info->discard == discard_sec_merge
10214                 && (isec->flags & SEC_MERGE)
10215                 && !bfd_link_relocatable (flinfo->info))
10216                || flinfo->info->discard == discard_l)
10217               && bfd_is_local_label_name (input_bfd, name)))
10218         continue;
10219
10220       if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
10221         {
10222           if (input_bfd->lto_output)
10223             /* -flto puts a temp file name here.  This means builds
10224                are not reproducible.  Discard the symbol.  */
10225             continue;
10226           have_file_sym = TRUE;
10227           flinfo->filesym_count += 1;
10228         }
10229       if (!have_file_sym)
10230         {
10231           /* In the absence of debug info, bfd_find_nearest_line uses
10232              FILE symbols to determine the source file for local
10233              function symbols.  Provide a FILE symbol here if input
10234              files lack such, so that their symbols won't be
10235              associated with a previous input file.  It's not the
10236              source file, but the best we can do.  */
10237           have_file_sym = TRUE;
10238           flinfo->filesym_count += 1;
10239           memset (&osym, 0, sizeof (osym));
10240           osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
10241           osym.st_shndx = SHN_ABS;
10242           if (!elf_link_output_symstrtab (flinfo,
10243                                           (input_bfd->lto_output ? NULL
10244                                            : input_bfd->filename),
10245                                           &osym, bfd_abs_section_ptr,
10246                                           NULL))
10247             return FALSE;
10248         }
10249
10250       osym = *isym;
10251
10252       /* Adjust the section index for the output file.  */
10253       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
10254                                                          isec->output_section);
10255       if (osym.st_shndx == SHN_BAD)
10256         return FALSE;
10257
10258       /* ELF symbols in relocatable files are section relative, but
10259          in executable files they are virtual addresses.  Note that
10260          this code assumes that all ELF sections have an associated
10261          BFD section with a reasonable value for output_offset; below
10262          we assume that they also have a reasonable value for
10263          output_section.  Any special sections must be set up to meet
10264          these requirements.  */
10265       osym.st_value += isec->output_offset;
10266       if (!bfd_link_relocatable (flinfo->info))
10267         {
10268           osym.st_value += isec->output_section->vma;
10269           if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
10270             {
10271               /* STT_TLS symbols are relative to PT_TLS segment base.  */
10272               BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
10273               osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
10274             }
10275         }
10276
10277       indx = bfd_get_symcount (output_bfd);
10278       ret = elf_link_output_symstrtab (flinfo, name, &osym, isec, NULL);
10279       if (ret == 0)
10280         return FALSE;
10281       else if (ret == 1)
10282         *pindex = indx;
10283     }
10284
10285   if (bed->s->arch_size == 32)
10286     {
10287       r_type_mask = 0xff;
10288       r_sym_shift = 8;
10289       address_size = 4;
10290     }
10291   else
10292     {
10293       r_type_mask = 0xffffffff;
10294       r_sym_shift = 32;
10295       address_size = 8;
10296     }
10297
10298   /* Relocate the contents of each section.  */
10299   sym_hashes = elf_sym_hashes (input_bfd);
10300   for (o = input_bfd->sections; o != NULL; o = o->next)
10301     {
10302       bfd_byte *contents;
10303
10304       if (! o->linker_mark)
10305         {
10306           /* This section was omitted from the link.  */
10307           continue;
10308         }
10309
10310       if (!flinfo->info->resolve_section_groups
10311           && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
10312         {
10313           /* Deal with the group signature symbol.  */
10314           struct bfd_elf_section_data *sec_data = elf_section_data (o);
10315           unsigned long symndx = sec_data->this_hdr.sh_info;
10316           asection *osec = o->output_section;
10317
10318           BFD_ASSERT (bfd_link_relocatable (flinfo->info));
10319           if (symndx >= locsymcount
10320               || (elf_bad_symtab (input_bfd)
10321                   && flinfo->sections[symndx] == NULL))
10322             {
10323               struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
10324               while (h->root.type == bfd_link_hash_indirect
10325                      || h->root.type == bfd_link_hash_warning)
10326                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10327               /* Arrange for symbol to be output.  */
10328               h->indx = -2;
10329               elf_section_data (osec)->this_hdr.sh_info = -2;
10330             }
10331           else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
10332             {
10333               /* We'll use the output section target_index.  */
10334               asection *sec = flinfo->sections[symndx]->output_section;
10335               elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
10336             }
10337           else
10338             {
10339               if (flinfo->indices[symndx] == -1)
10340                 {
10341                   /* Otherwise output the local symbol now.  */
10342                   Elf_Internal_Sym sym = isymbuf[symndx];
10343                   asection *sec = flinfo->sections[symndx]->output_section;
10344                   const char *name;
10345                   long indx;
10346                   int ret;
10347
10348                   name = bfd_elf_string_from_elf_section (input_bfd,
10349                                                           symtab_hdr->sh_link,
10350                                                           sym.st_name);
10351                   if (name == NULL)
10352                     return FALSE;
10353
10354                   sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
10355                                                                     sec);
10356                   if (sym.st_shndx == SHN_BAD)
10357                     return FALSE;
10358
10359                   sym.st_value += o->output_offset;
10360
10361                   indx = bfd_get_symcount (output_bfd);
10362                   ret = elf_link_output_symstrtab (flinfo, name, &sym, o,
10363                                                    NULL);
10364                   if (ret == 0)
10365                     return FALSE;
10366                   else if (ret == 1)
10367                     flinfo->indices[symndx] = indx;
10368                   else
10369                     abort ();
10370                 }
10371               elf_section_data (osec)->this_hdr.sh_info
10372                 = flinfo->indices[symndx];
10373             }
10374         }
10375
10376       if ((o->flags & SEC_HAS_CONTENTS) == 0
10377           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
10378         continue;
10379
10380       if ((o->flags & SEC_LINKER_CREATED) != 0)
10381         {
10382           /* Section was created by _bfd_elf_link_create_dynamic_sections
10383              or somesuch.  */
10384           continue;
10385         }
10386
10387       /* Get the contents of the section.  They have been cached by a
10388          relaxation routine.  Note that o is a section in an input
10389          file, so the contents field will not have been set by any of
10390          the routines which work on output files.  */
10391       if (elf_section_data (o)->this_hdr.contents != NULL)
10392         {
10393           contents = elf_section_data (o)->this_hdr.contents;
10394           if (bed->caches_rawsize
10395               && o->rawsize != 0
10396               && o->rawsize < o->size)
10397             {
10398               memcpy (flinfo->contents, contents, o->rawsize);
10399               contents = flinfo->contents;
10400             }
10401         }
10402       else
10403         {
10404           contents = flinfo->contents;
10405           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
10406             return FALSE;
10407         }
10408
10409       if ((o->flags & SEC_RELOC) != 0)
10410         {
10411           Elf_Internal_Rela *internal_relocs;
10412           Elf_Internal_Rela *rel, *relend;
10413           int action_discarded;
10414           int ret;
10415
10416           /* Get the swapped relocs.  */
10417           internal_relocs
10418             = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
10419                                          flinfo->internal_relocs, FALSE);
10420           if (internal_relocs == NULL
10421               && o->reloc_count > 0)
10422             return FALSE;
10423
10424           /* We need to reverse-copy input .ctors/.dtors sections if
10425              they are placed in .init_array/.finit_array for output.  */
10426           if (o->size > address_size
10427               && ((strncmp (o->name, ".ctors", 6) == 0
10428                    && strcmp (o->output_section->name,
10429                               ".init_array") == 0)
10430                   || (strncmp (o->name, ".dtors", 6) == 0
10431                       && strcmp (o->output_section->name,
10432                                  ".fini_array") == 0))
10433               && (o->name[6] == 0 || o->name[6] == '.'))
10434             {
10435               if (o->size * bed->s->int_rels_per_ext_rel
10436                   != o->reloc_count * address_size)
10437                 {
10438                   _bfd_error_handler
10439                     /* xgettext:c-format */
10440                     (_("error: %B: size of section %A is not "
10441                        "multiple of address size"),
10442                      input_bfd, o);
10443                   bfd_set_error (bfd_error_on_input);
10444                   return FALSE;
10445                 }
10446               o->flags |= SEC_ELF_REVERSE_COPY;
10447             }
10448
10449           action_discarded = -1;
10450           if (!elf_section_ignore_discarded_relocs (o))
10451             action_discarded = (*bed->action_discarded) (o);
10452
10453           /* Run through the relocs evaluating complex reloc symbols and
10454              looking for relocs against symbols from discarded sections
10455              or section symbols from removed link-once sections.
10456              Complain about relocs against discarded sections.  Zero
10457              relocs against removed link-once sections.  */
10458
10459           rel = internal_relocs;
10460           relend = rel + o->reloc_count;
10461           for ( ; rel < relend; rel++)
10462             {
10463               unsigned long r_symndx = rel->r_info >> r_sym_shift;
10464               unsigned int s_type;
10465               asection **ps, *sec;
10466               struct elf_link_hash_entry *h = NULL;
10467               const char *sym_name;
10468
10469               if (r_symndx == STN_UNDEF)
10470                 continue;
10471
10472               if (r_symndx >= locsymcount
10473                   || (elf_bad_symtab (input_bfd)
10474                       && flinfo->sections[r_symndx] == NULL))
10475                 {
10476                   h = sym_hashes[r_symndx - extsymoff];
10477
10478                   /* Badly formatted input files can contain relocs that
10479                      reference non-existant symbols.  Check here so that
10480                      we do not seg fault.  */
10481                   if (h == NULL)
10482                     {
10483                       _bfd_error_handler
10484                         /* xgettext:c-format */
10485                         (_("error: %B contains a reloc (%#Lx) for section %A "
10486                            "that references a non-existent global symbol"),
10487                          input_bfd, rel->r_info, o);
10488                       bfd_set_error (bfd_error_bad_value);
10489                       return FALSE;
10490                     }
10491
10492                   while (h->root.type == bfd_link_hash_indirect
10493                          || h->root.type == bfd_link_hash_warning)
10494                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10495
10496                   s_type = h->type;
10497
10498                   /* If a plugin symbol is referenced from a non-IR file,
10499                      mark the symbol as undefined.  Note that the
10500                      linker may attach linker created dynamic sections
10501                      to the plugin bfd.  Symbols defined in linker
10502                      created sections are not plugin symbols.  */
10503                   if ((h->root.non_ir_ref_regular
10504                        || h->root.non_ir_ref_dynamic)
10505                       && (h->root.type == bfd_link_hash_defined
10506                           || h->root.type == bfd_link_hash_defweak)
10507                       && (h->root.u.def.section->flags
10508                           & SEC_LINKER_CREATED) == 0
10509                       && h->root.u.def.section->owner != NULL
10510                       && (h->root.u.def.section->owner->flags
10511                           & BFD_PLUGIN) != 0)
10512                     {
10513                       h->root.type = bfd_link_hash_undefined;
10514                       h->root.u.undef.abfd = h->root.u.def.section->owner;
10515                     }
10516
10517                   ps = NULL;
10518                   if (h->root.type == bfd_link_hash_defined
10519                       || h->root.type == bfd_link_hash_defweak)
10520                     ps = &h->root.u.def.section;
10521
10522                   sym_name = h->root.root.string;
10523                 }
10524               else
10525                 {
10526                   Elf_Internal_Sym *sym = isymbuf + r_symndx;
10527
10528                   s_type = ELF_ST_TYPE (sym->st_info);
10529                   ps = &flinfo->sections[r_symndx];
10530                   sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
10531                                                sym, *ps);
10532                 }
10533
10534               if ((s_type == STT_RELC || s_type == STT_SRELC)
10535                   && !bfd_link_relocatable (flinfo->info))
10536                 {
10537                   bfd_vma val;
10538                   bfd_vma dot = (rel->r_offset
10539                                  + o->output_offset + o->output_section->vma);
10540 #ifdef DEBUG
10541                   printf ("Encountered a complex symbol!");
10542                   printf (" (input_bfd %s, section %s, reloc %ld\n",
10543                           input_bfd->filename, o->name,
10544                           (long) (rel - internal_relocs));
10545                   printf (" symbol: idx  %8.8lx, name %s\n",
10546                           r_symndx, sym_name);
10547                   printf (" reloc : info %8.8lx, addr %8.8lx\n",
10548                           (unsigned long) rel->r_info,
10549                           (unsigned long) rel->r_offset);
10550 #endif
10551                   if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
10552                                     isymbuf, locsymcount, s_type == STT_SRELC))
10553                     return FALSE;
10554
10555                   /* Symbol evaluated OK.  Update to absolute value.  */
10556                   set_symbol_value (input_bfd, isymbuf, locsymcount,
10557                                     r_symndx, val);
10558                   continue;
10559                 }
10560
10561               if (action_discarded != -1 && ps != NULL)
10562                 {
10563                   /* Complain if the definition comes from a
10564                      discarded section.  */
10565                   if ((sec = *ps) != NULL && discarded_section (sec))
10566                     {
10567                       BFD_ASSERT (r_symndx != STN_UNDEF);
10568                       if (action_discarded & COMPLAIN)
10569                         (*flinfo->info->callbacks->einfo)
10570                           /* xgettext:c-format */
10571                           (_("%X`%s' referenced in section `%A' of %B: "
10572                              "defined in discarded section `%A' of %B\n"),
10573                            sym_name, o, input_bfd, sec, sec->owner);
10574
10575                       /* Try to do the best we can to support buggy old
10576                          versions of gcc.  Pretend that the symbol is
10577                          really defined in the kept linkonce section.
10578                          FIXME: This is quite broken.  Modifying the
10579                          symbol here means we will be changing all later
10580                          uses of the symbol, not just in this section.  */
10581                       if (action_discarded & PRETEND)
10582                         {
10583                           asection *kept;
10584
10585                           kept = _bfd_elf_check_kept_section (sec,
10586                                                               flinfo->info);
10587                           if (kept != NULL)
10588                             {
10589                               *ps = kept;
10590                               continue;
10591                             }
10592                         }
10593                     }
10594                 }
10595             }
10596
10597           /* Relocate the section by invoking a back end routine.
10598
10599              The back end routine is responsible for adjusting the
10600              section contents as necessary, and (if using Rela relocs
10601              and generating a relocatable output file) adjusting the
10602              reloc addend as necessary.
10603
10604              The back end routine does not have to worry about setting
10605              the reloc address or the reloc symbol index.
10606
10607              The back end routine is given a pointer to the swapped in
10608              internal symbols, and can access the hash table entries
10609              for the external symbols via elf_sym_hashes (input_bfd).
10610
10611              When generating relocatable output, the back end routine
10612              must handle STB_LOCAL/STT_SECTION symbols specially.  The
10613              output symbol is going to be a section symbol
10614              corresponding to the output section, which will require
10615              the addend to be adjusted.  */
10616
10617           ret = (*relocate_section) (output_bfd, flinfo->info,
10618                                      input_bfd, o, contents,
10619                                      internal_relocs,
10620                                      isymbuf,
10621                                      flinfo->sections);
10622           if (!ret)
10623             return FALSE;
10624
10625           if (ret == 2
10626               || bfd_link_relocatable (flinfo->info)
10627               || flinfo->info->emitrelocations)
10628             {
10629               Elf_Internal_Rela *irela;
10630               Elf_Internal_Rela *irelaend, *irelamid;
10631               bfd_vma last_offset;
10632               struct elf_link_hash_entry **rel_hash;
10633               struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
10634               Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
10635               unsigned int next_erel;
10636               bfd_boolean rela_normal;
10637               struct bfd_elf_section_data *esdi, *esdo;
10638
10639               esdi = elf_section_data (o);
10640               esdo = elf_section_data (o->output_section);
10641               rela_normal = FALSE;
10642
10643               /* Adjust the reloc addresses and symbol indices.  */
10644
10645               irela = internal_relocs;
10646               irelaend = irela + o->reloc_count;
10647               rel_hash = esdo->rel.hashes + esdo->rel.count;
10648               /* We start processing the REL relocs, if any.  When we reach
10649                  IRELAMID in the loop, we switch to the RELA relocs.  */
10650               irelamid = irela;
10651               if (esdi->rel.hdr != NULL)
10652                 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
10653                              * bed->s->int_rels_per_ext_rel);
10654               rel_hash_list = rel_hash;
10655               rela_hash_list = NULL;
10656               last_offset = o->output_offset;
10657               if (!bfd_link_relocatable (flinfo->info))
10658                 last_offset += o->output_section->vma;
10659               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
10660                 {
10661                   unsigned long r_symndx;
10662                   asection *sec;
10663                   Elf_Internal_Sym sym;
10664
10665                   if (next_erel == bed->s->int_rels_per_ext_rel)
10666                     {
10667                       rel_hash++;
10668                       next_erel = 0;
10669                     }
10670
10671                   if (irela == irelamid)
10672                     {
10673                       rel_hash = esdo->rela.hashes + esdo->rela.count;
10674                       rela_hash_list = rel_hash;
10675                       rela_normal = bed->rela_normal;
10676                     }
10677
10678                   irela->r_offset = _bfd_elf_section_offset (output_bfd,
10679                                                              flinfo->info, o,
10680                                                              irela->r_offset);
10681                   if (irela->r_offset >= (bfd_vma) -2)
10682                     {
10683                       /* This is a reloc for a deleted entry or somesuch.
10684                          Turn it into an R_*_NONE reloc, at the same
10685                          offset as the last reloc.  elf_eh_frame.c and
10686                          bfd_elf_discard_info rely on reloc offsets
10687                          being ordered.  */
10688                       irela->r_offset = last_offset;
10689                       irela->r_info = 0;
10690                       irela->r_addend = 0;
10691                       continue;
10692                     }
10693
10694                   irela->r_offset += o->output_offset;
10695
10696                   /* Relocs in an executable have to be virtual addresses.  */
10697                   if (!bfd_link_relocatable (flinfo->info))
10698                     irela->r_offset += o->output_section->vma;
10699
10700                   last_offset = irela->r_offset;
10701
10702                   r_symndx = irela->r_info >> r_sym_shift;
10703                   if (r_symndx == STN_UNDEF)
10704                     continue;
10705
10706                   if (r_symndx >= locsymcount
10707                       || (elf_bad_symtab (input_bfd)
10708                           && flinfo->sections[r_symndx] == NULL))
10709                     {
10710                       struct elf_link_hash_entry *rh;
10711                       unsigned long indx;
10712
10713                       /* This is a reloc against a global symbol.  We
10714                          have not yet output all the local symbols, so
10715                          we do not know the symbol index of any global
10716                          symbol.  We set the rel_hash entry for this
10717                          reloc to point to the global hash table entry
10718                          for this symbol.  The symbol index is then
10719                          set at the end of bfd_elf_final_link.  */
10720                       indx = r_symndx - extsymoff;
10721                       rh = elf_sym_hashes (input_bfd)[indx];
10722                       while (rh->root.type == bfd_link_hash_indirect
10723                              || rh->root.type == bfd_link_hash_warning)
10724                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
10725
10726                       /* Setting the index to -2 tells
10727                          elf_link_output_extsym that this symbol is
10728                          used by a reloc.  */
10729                       BFD_ASSERT (rh->indx < 0);
10730                       rh->indx = -2;
10731                       *rel_hash = rh;
10732
10733                       continue;
10734                     }
10735
10736                   /* This is a reloc against a local symbol.  */
10737
10738                   *rel_hash = NULL;
10739                   sym = isymbuf[r_symndx];
10740                   sec = flinfo->sections[r_symndx];
10741                   if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
10742                     {
10743                       /* I suppose the backend ought to fill in the
10744                          section of any STT_SECTION symbol against a
10745                          processor specific section.  */
10746                       r_symndx = STN_UNDEF;
10747                       if (bfd_is_abs_section (sec))
10748                         ;
10749                       else if (sec == NULL || sec->owner == NULL)
10750                         {
10751                           bfd_set_error (bfd_error_bad_value);
10752                           return FALSE;
10753                         }
10754                       else
10755                         {
10756                           asection *osec = sec->output_section;
10757
10758                           /* If we have discarded a section, the output
10759                              section will be the absolute section.  In
10760                              case of discarded SEC_MERGE sections, use
10761                              the kept section.  relocate_section should
10762                              have already handled discarded linkonce
10763                              sections.  */
10764                           if (bfd_is_abs_section (osec)
10765                               && sec->kept_section != NULL
10766                               && sec->kept_section->output_section != NULL)
10767                             {
10768                               osec = sec->kept_section->output_section;
10769                               irela->r_addend -= osec->vma;
10770                             }
10771
10772                           if (!bfd_is_abs_section (osec))
10773                             {
10774                               r_symndx = osec->target_index;
10775                               if (r_symndx == STN_UNDEF)
10776                                 {
10777                                   irela->r_addend += osec->vma;
10778                                   osec = _bfd_nearby_section (output_bfd, osec,
10779                                                               osec->vma);
10780                                   irela->r_addend -= osec->vma;
10781                                   r_symndx = osec->target_index;
10782                                 }
10783                             }
10784                         }
10785
10786                       /* Adjust the addend according to where the
10787                          section winds up in the output section.  */
10788                       if (rela_normal)
10789                         irela->r_addend += sec->output_offset;
10790                     }
10791                   else
10792                     {
10793                       if (flinfo->indices[r_symndx] == -1)
10794                         {
10795                           unsigned long shlink;
10796                           const char *name;
10797                           asection *osec;
10798                           long indx;
10799
10800                           if (flinfo->info->strip == strip_all)
10801                             {
10802                               /* You can't do ld -r -s.  */
10803                               bfd_set_error (bfd_error_invalid_operation);
10804                               return FALSE;
10805                             }
10806
10807                           /* This symbol was skipped earlier, but
10808                              since it is needed by a reloc, we
10809                              must output it now.  */
10810                           shlink = symtab_hdr->sh_link;
10811                           name = (bfd_elf_string_from_elf_section
10812                                   (input_bfd, shlink, sym.st_name));
10813                           if (name == NULL)
10814                             return FALSE;
10815
10816                           osec = sec->output_section;
10817                           sym.st_shndx =
10818                             _bfd_elf_section_from_bfd_section (output_bfd,
10819                                                                osec);
10820                           if (sym.st_shndx == SHN_BAD)
10821                             return FALSE;
10822
10823                           sym.st_value += sec->output_offset;
10824                           if (!bfd_link_relocatable (flinfo->info))
10825                             {
10826                               sym.st_value += osec->vma;
10827                               if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
10828                                 {
10829                                   /* STT_TLS symbols are relative to PT_TLS
10830                                      segment base.  */
10831                                   BFD_ASSERT (elf_hash_table (flinfo->info)
10832                                               ->tls_sec != NULL);
10833                                   sym.st_value -= (elf_hash_table (flinfo->info)
10834                                                    ->tls_sec->vma);
10835                                 }
10836                             }
10837
10838                           indx = bfd_get_symcount (output_bfd);
10839                           ret = elf_link_output_symstrtab (flinfo, name,
10840                                                            &sym, sec,
10841                                                            NULL);
10842                           if (ret == 0)
10843                             return FALSE;
10844                           else if (ret == 1)
10845                             flinfo->indices[r_symndx] = indx;
10846                           else
10847                             abort ();
10848                         }
10849
10850                       r_symndx = flinfo->indices[r_symndx];
10851                     }
10852
10853                   irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
10854                                    | (irela->r_info & r_type_mask));
10855                 }
10856
10857               /* Swap out the relocs.  */
10858               input_rel_hdr = esdi->rel.hdr;
10859               if (input_rel_hdr && input_rel_hdr->sh_size != 0)
10860                 {
10861                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10862                                                      input_rel_hdr,
10863                                                      internal_relocs,
10864                                                      rel_hash_list))
10865                     return FALSE;
10866                   internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
10867                                       * bed->s->int_rels_per_ext_rel);
10868                   rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
10869                 }
10870
10871               input_rela_hdr = esdi->rela.hdr;
10872               if (input_rela_hdr && input_rela_hdr->sh_size != 0)
10873                 {
10874                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10875                                                      input_rela_hdr,
10876                                                      internal_relocs,
10877                                                      rela_hash_list))
10878                     return FALSE;
10879                 }
10880             }
10881         }
10882
10883       /* Write out the modified section contents.  */
10884       if (bed->elf_backend_write_section
10885           && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
10886                                                 contents))
10887         {
10888           /* Section written out.  */
10889         }
10890       else switch (o->sec_info_type)
10891         {
10892         case SEC_INFO_TYPE_STABS:
10893           if (! (_bfd_write_section_stabs
10894                  (output_bfd,
10895                   &elf_hash_table (flinfo->info)->stab_info,
10896                   o, &elf_section_data (o)->sec_info, contents)))
10897             return FALSE;
10898           break;
10899         case SEC_INFO_TYPE_MERGE:
10900           if (! _bfd_write_merged_section (output_bfd, o,
10901                                            elf_section_data (o)->sec_info))
10902             return FALSE;
10903           break;
10904         case SEC_INFO_TYPE_EH_FRAME:
10905           {
10906             if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10907                                                    o, contents))
10908               return FALSE;
10909           }
10910           break;
10911         case SEC_INFO_TYPE_EH_FRAME_ENTRY:
10912           {
10913             if (! _bfd_elf_write_section_eh_frame_entry (output_bfd,
10914                                                          flinfo->info,
10915                                                          o, contents))
10916               return FALSE;
10917           }
10918           break;
10919         default:
10920           {
10921             if (! (o->flags & SEC_EXCLUDE))
10922               {
10923                 file_ptr offset = (file_ptr) o->output_offset;
10924                 bfd_size_type todo = o->size;
10925
10926                 offset *= bfd_octets_per_byte (output_bfd);
10927
10928                 if ((o->flags & SEC_ELF_REVERSE_COPY))
10929                   {
10930                     /* Reverse-copy input section to output.  */
10931                     do
10932                       {
10933                         todo -= address_size;
10934                         if (! bfd_set_section_contents (output_bfd,
10935                                                         o->output_section,
10936                                                         contents + todo,
10937                                                         offset,
10938                                                         address_size))
10939                           return FALSE;
10940                         if (todo == 0)
10941                           break;
10942                         offset += address_size;
10943                       }
10944                     while (1);
10945                   }
10946                 else if (! bfd_set_section_contents (output_bfd,
10947                                                      o->output_section,
10948                                                      contents,
10949                                                      offset, todo))
10950                   return FALSE;
10951               }
10952           }
10953           break;
10954         }
10955     }
10956
10957   return TRUE;
10958 }
10959
10960 /* Generate a reloc when linking an ELF file.  This is a reloc
10961    requested by the linker, and does not come from any input file.  This
10962    is used to build constructor and destructor tables when linking
10963    with -Ur.  */
10964
10965 static bfd_boolean
10966 elf_reloc_link_order (bfd *output_bfd,
10967                       struct bfd_link_info *info,
10968                       asection *output_section,
10969                       struct bfd_link_order *link_order)
10970 {
10971   reloc_howto_type *howto;
10972   long indx;
10973   bfd_vma offset;
10974   bfd_vma addend;
10975   struct bfd_elf_section_reloc_data *reldata;
10976   struct elf_link_hash_entry **rel_hash_ptr;
10977   Elf_Internal_Shdr *rel_hdr;
10978   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10979   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10980   bfd_byte *erel;
10981   unsigned int i;
10982   struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10983
10984   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10985   if (howto == NULL)
10986     {
10987       bfd_set_error (bfd_error_bad_value);
10988       return FALSE;
10989     }
10990
10991   addend = link_order->u.reloc.p->addend;
10992
10993   if (esdo->rel.hdr)
10994     reldata = &esdo->rel;
10995   else if (esdo->rela.hdr)
10996     reldata = &esdo->rela;
10997   else
10998     {
10999       reldata = NULL;
11000       BFD_ASSERT (0);
11001     }
11002
11003   /* Figure out the symbol index.  */
11004   rel_hash_ptr = reldata->hashes + reldata->count;
11005   if (link_order->type == bfd_section_reloc_link_order)
11006     {
11007       indx = link_order->u.reloc.p->u.section->target_index;
11008       BFD_ASSERT (indx != 0);
11009       *rel_hash_ptr = NULL;
11010     }
11011   else
11012     {
11013       struct elf_link_hash_entry *h;
11014
11015       /* Treat a reloc against a defined symbol as though it were
11016          actually against the section.  */
11017       h = ((struct elf_link_hash_entry *)
11018            bfd_wrapped_link_hash_lookup (output_bfd, info,
11019                                          link_order->u.reloc.p->u.name,
11020                                          FALSE, FALSE, TRUE));
11021       if (h != NULL
11022           && (h->root.type == bfd_link_hash_defined
11023               || h->root.type == bfd_link_hash_defweak))
11024         {
11025           asection *section;
11026
11027           section = h->root.u.def.section;
11028           indx = section->output_section->target_index;
11029           *rel_hash_ptr = NULL;
11030           /* It seems that we ought to add the symbol value to the
11031              addend here, but in practice it has already been added
11032              because it was passed to constructor_callback.  */
11033           addend += section->output_section->vma + section->output_offset;
11034         }
11035       else if (h != NULL)
11036         {
11037           /* Setting the index to -2 tells elf_link_output_extsym that
11038              this symbol is used by a reloc.  */
11039           h->indx = -2;
11040           *rel_hash_ptr = h;
11041           indx = 0;
11042         }
11043       else
11044         {
11045           (*info->callbacks->unattached_reloc)
11046             (info, link_order->u.reloc.p->u.name, NULL, NULL, 0);
11047           indx = 0;
11048         }
11049     }
11050
11051   /* If this is an inplace reloc, we must write the addend into the
11052      object file.  */
11053   if (howto->partial_inplace && addend != 0)
11054     {
11055       bfd_size_type size;
11056       bfd_reloc_status_type rstat;
11057       bfd_byte *buf;
11058       bfd_boolean ok;
11059       const char *sym_name;
11060
11061       size = (bfd_size_type) bfd_get_reloc_size (howto);
11062       buf = (bfd_byte *) bfd_zmalloc (size);
11063       if (buf == NULL && size != 0)
11064         return FALSE;
11065       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
11066       switch (rstat)
11067         {
11068         case bfd_reloc_ok:
11069           break;
11070
11071         default:
11072         case bfd_reloc_outofrange:
11073           abort ();
11074
11075         case bfd_reloc_overflow:
11076           if (link_order->type == bfd_section_reloc_link_order)
11077             sym_name = bfd_section_name (output_bfd,
11078                                          link_order->u.reloc.p->u.section);
11079           else
11080             sym_name = link_order->u.reloc.p->u.name;
11081           (*info->callbacks->reloc_overflow) (info, NULL, sym_name,
11082                                               howto->name, addend, NULL, NULL,
11083                                               (bfd_vma) 0);
11084           break;
11085         }
11086
11087       ok = bfd_set_section_contents (output_bfd, output_section, buf,
11088                                      link_order->offset
11089                                      * bfd_octets_per_byte (output_bfd),
11090                                      size);
11091       free (buf);
11092       if (! ok)
11093         return FALSE;
11094     }
11095
11096   /* The address of a reloc is relative to the section in a
11097      relocatable file, and is a virtual address in an executable
11098      file.  */
11099   offset = link_order->offset;
11100   if (! bfd_link_relocatable (info))
11101     offset += output_section->vma;
11102
11103   for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
11104     {
11105       irel[i].r_offset = offset;
11106       irel[i].r_info = 0;
11107       irel[i].r_addend = 0;
11108     }
11109   if (bed->s->arch_size == 32)
11110     irel[0].r_info = ELF32_R_INFO (indx, howto->type);
11111   else
11112     irel[0].r_info = ELF64_R_INFO (indx, howto->type);
11113
11114   rel_hdr = reldata->hdr;
11115   erel = rel_hdr->contents;
11116   if (rel_hdr->sh_type == SHT_REL)
11117     {
11118       erel += reldata->count * bed->s->sizeof_rel;
11119       (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
11120     }
11121   else
11122     {
11123       irel[0].r_addend = addend;
11124       erel += reldata->count * bed->s->sizeof_rela;
11125       (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
11126     }
11127
11128   ++reldata->count;
11129
11130   return TRUE;
11131 }
11132
11133
11134 /* Get the output vma of the section pointed to by the sh_link field.  */
11135
11136 static bfd_vma
11137 elf_get_linked_section_vma (struct bfd_link_order *p)
11138 {
11139   Elf_Internal_Shdr **elf_shdrp;
11140   asection *s;
11141   int elfsec;
11142
11143   s = p->u.indirect.section;
11144   elf_shdrp = elf_elfsections (s->owner);
11145   elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
11146   elfsec = elf_shdrp[elfsec]->sh_link;
11147   /* PR 290:
11148      The Intel C compiler generates SHT_IA_64_UNWIND with
11149      SHF_LINK_ORDER.  But it doesn't set the sh_link or
11150      sh_info fields.  Hence we could get the situation
11151      where elfsec is 0.  */
11152   if (elfsec == 0)
11153     {
11154       const struct elf_backend_data *bed
11155         = get_elf_backend_data (s->owner);
11156       if (bed->link_order_error_handler)
11157         bed->link_order_error_handler
11158           /* xgettext:c-format */
11159           (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
11160       return 0;
11161     }
11162   else
11163     {
11164       s = elf_shdrp[elfsec]->bfd_section;
11165       return s->output_section->vma + s->output_offset;
11166     }
11167 }
11168
11169
11170 /* Compare two sections based on the locations of the sections they are
11171    linked to.  Used by elf_fixup_link_order.  */
11172
11173 static int
11174 compare_link_order (const void * a, const void * b)
11175 {
11176   bfd_vma apos;
11177   bfd_vma bpos;
11178
11179   apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
11180   bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
11181   if (apos < bpos)
11182     return -1;
11183   return apos > bpos;
11184 }
11185
11186
11187 /* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
11188    order as their linked sections.  Returns false if this could not be done
11189    because an output section includes both ordered and unordered
11190    sections.  Ideally we'd do this in the linker proper.  */
11191
11192 static bfd_boolean
11193 elf_fixup_link_order (bfd *abfd, asection *o)
11194 {
11195   int seen_linkorder;
11196   int seen_other;
11197   int n;
11198   struct bfd_link_order *p;
11199   bfd *sub;
11200   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11201   unsigned elfsec;
11202   struct bfd_link_order **sections;
11203   asection *s, *other_sec, *linkorder_sec;
11204   bfd_vma offset;
11205
11206   other_sec = NULL;
11207   linkorder_sec = NULL;
11208   seen_other = 0;
11209   seen_linkorder = 0;
11210   for (p = o->map_head.link_order; p != NULL; p = p->next)
11211     {
11212       if (p->type == bfd_indirect_link_order)
11213         {
11214           s = p->u.indirect.section;
11215           sub = s->owner;
11216           if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11217               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
11218               && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
11219               && elfsec < elf_numsections (sub)
11220               && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
11221               && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
11222             {
11223               seen_linkorder++;
11224               linkorder_sec = s;
11225             }
11226           else
11227             {
11228               seen_other++;
11229               other_sec = s;
11230             }
11231         }
11232       else
11233         seen_other++;
11234
11235       if (seen_other && seen_linkorder)
11236         {
11237           if (other_sec && linkorder_sec)
11238             _bfd_error_handler
11239               /* xgettext:c-format */
11240               (_("%A has both ordered [`%A' in %B] "
11241                  "and unordered [`%A' in %B] sections"),
11242                o, linkorder_sec, linkorder_sec->owner,
11243                other_sec, other_sec->owner);
11244           else
11245             _bfd_error_handler
11246               (_("%A has both ordered and unordered sections"), o);
11247           bfd_set_error (bfd_error_bad_value);
11248           return FALSE;
11249         }
11250     }
11251
11252   if (!seen_linkorder)
11253     return TRUE;
11254
11255   sections = (struct bfd_link_order **)
11256     bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
11257   if (sections == NULL)
11258     return FALSE;
11259   seen_linkorder = 0;
11260
11261   for (p = o->map_head.link_order; p != NULL; p = p->next)
11262     {
11263       sections[seen_linkorder++] = p;
11264     }
11265   /* Sort the input sections in the order of their linked section.  */
11266   qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
11267          compare_link_order);
11268
11269   /* Change the offsets of the sections.  */
11270   offset = 0;
11271   for (n = 0; n < seen_linkorder; n++)
11272     {
11273       s = sections[n]->u.indirect.section;
11274       offset &= ~(bfd_vma) 0 << s->alignment_power;
11275       s->output_offset = offset / bfd_octets_per_byte (abfd);
11276       sections[n]->offset = offset;
11277       offset += sections[n]->size;
11278     }
11279
11280   free (sections);
11281   return TRUE;
11282 }
11283
11284 /* Generate an import library in INFO->implib_bfd from symbols in ABFD.
11285    Returns TRUE upon success, FALSE otherwise.  */
11286
11287 static bfd_boolean
11288 elf_output_implib (bfd *abfd, struct bfd_link_info *info)
11289 {
11290   bfd_boolean ret = FALSE;
11291   bfd *implib_bfd;
11292   const struct elf_backend_data *bed;
11293   flagword flags;
11294   enum bfd_architecture arch;
11295   unsigned int mach;
11296   asymbol **sympp = NULL;
11297   long symsize;
11298   long symcount;
11299   long src_count;
11300   elf_symbol_type *osymbuf;
11301
11302   implib_bfd = info->out_implib_bfd;
11303   bed = get_elf_backend_data (abfd);
11304
11305   if (!bfd_set_format (implib_bfd, bfd_object))
11306     return FALSE;
11307
11308   /* Use flag from executable but make it a relocatable object.  */
11309   flags = bfd_get_file_flags (abfd);
11310   flags &= ~HAS_RELOC;
11311   if (!bfd_set_start_address (implib_bfd, 0)
11312       || !bfd_set_file_flags (implib_bfd, flags & ~EXEC_P))
11313     return FALSE;
11314
11315   /* Copy architecture of output file to import library file.  */
11316   arch = bfd_get_arch (abfd);
11317   mach = bfd_get_mach (abfd);
11318   if (!bfd_set_arch_mach (implib_bfd, arch, mach)
11319       && (abfd->target_defaulted
11320           || bfd_get_arch (abfd) != bfd_get_arch (implib_bfd)))
11321     return FALSE;
11322
11323   /* Get symbol table size.  */
11324   symsize = bfd_get_symtab_upper_bound (abfd);
11325   if (symsize < 0)
11326     return FALSE;
11327
11328   /* Read in the symbol table.  */
11329   sympp = (asymbol **) xmalloc (symsize);
11330   symcount = bfd_canonicalize_symtab (abfd, sympp);
11331   if (symcount < 0)
11332     goto free_sym_buf;
11333
11334   /* Allow the BFD backend to copy any private header data it
11335      understands from the output BFD to the import library BFD.  */
11336   if (! bfd_copy_private_header_data (abfd, implib_bfd))
11337     goto free_sym_buf;
11338
11339   /* Filter symbols to appear in the import library.  */
11340   if (bed->elf_backend_filter_implib_symbols)
11341     symcount = bed->elf_backend_filter_implib_symbols (abfd, info, sympp,
11342                                                        symcount);
11343   else
11344     symcount = _bfd_elf_filter_global_symbols (abfd, info, sympp, symcount);
11345   if (symcount == 0)
11346     {
11347       bfd_set_error (bfd_error_no_symbols);
11348       _bfd_error_handler (_("%B: no symbol found for import library"),
11349                           implib_bfd);
11350       goto free_sym_buf;
11351     }
11352
11353
11354   /* Make symbols absolute.  */
11355   osymbuf = (elf_symbol_type *) bfd_alloc2 (implib_bfd, symcount,
11356                                             sizeof (*osymbuf));
11357   for (src_count = 0; src_count < symcount; src_count++)
11358     {
11359       memcpy (&osymbuf[src_count], (elf_symbol_type *) sympp[src_count],
11360               sizeof (*osymbuf));
11361       osymbuf[src_count].symbol.section = bfd_abs_section_ptr;
11362       osymbuf[src_count].internal_elf_sym.st_shndx = SHN_ABS;
11363       osymbuf[src_count].symbol.value += sympp[src_count]->section->vma;
11364       osymbuf[src_count].internal_elf_sym.st_value =
11365         osymbuf[src_count].symbol.value;
11366       sympp[src_count] = &osymbuf[src_count].symbol;
11367     }
11368
11369   bfd_set_symtab (implib_bfd, sympp, symcount);
11370
11371   /* Allow the BFD backend to copy any private data it understands
11372      from the output BFD to the import library BFD.  This is done last
11373      to permit the routine to look at the filtered symbol table.  */
11374   if (! bfd_copy_private_bfd_data (abfd, implib_bfd))
11375     goto free_sym_buf;
11376
11377   if (!bfd_close (implib_bfd))
11378     goto free_sym_buf;
11379
11380   ret = TRUE;
11381
11382 free_sym_buf:
11383   free (sympp);
11384   return ret;
11385 }
11386
11387 static void
11388 elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
11389 {
11390   asection *o;
11391
11392   if (flinfo->symstrtab != NULL)
11393     _bfd_elf_strtab_free (flinfo->symstrtab);
11394   if (flinfo->contents != NULL)
11395     free (flinfo->contents);
11396   if (flinfo->external_relocs != NULL)
11397     free (flinfo->external_relocs);
11398   if (flinfo->internal_relocs != NULL)
11399     free (flinfo->internal_relocs);
11400   if (flinfo->external_syms != NULL)
11401     free (flinfo->external_syms);
11402   if (flinfo->locsym_shndx != NULL)
11403     free (flinfo->locsym_shndx);
11404   if (flinfo->internal_syms != NULL)
11405     free (flinfo->internal_syms);
11406   if (flinfo->indices != NULL)
11407     free (flinfo->indices);
11408   if (flinfo->sections != NULL)
11409     free (flinfo->sections);
11410   if (flinfo->symshndxbuf != NULL)
11411     free (flinfo->symshndxbuf);
11412   for (o = obfd->sections; o != NULL; o = o->next)
11413     {
11414       struct bfd_elf_section_data *esdo = elf_section_data (o);
11415       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
11416         free (esdo->rel.hashes);
11417       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
11418         free (esdo->rela.hashes);
11419     }
11420 }
11421
11422 /* Do the final step of an ELF link.  */
11423
11424 bfd_boolean
11425 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
11426 {
11427   bfd_boolean dynamic;
11428   bfd_boolean emit_relocs;
11429   bfd *dynobj;
11430   struct elf_final_link_info flinfo;
11431   asection *o;
11432   struct bfd_link_order *p;
11433   bfd *sub;
11434   bfd_size_type max_contents_size;
11435   bfd_size_type max_external_reloc_size;
11436   bfd_size_type max_internal_reloc_count;
11437   bfd_size_type max_sym_count;
11438   bfd_size_type max_sym_shndx_count;
11439   Elf_Internal_Sym elfsym;
11440   unsigned int i;
11441   Elf_Internal_Shdr *symtab_hdr;
11442   Elf_Internal_Shdr *symtab_shndx_hdr;
11443   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11444   struct elf_outext_info eoinfo;
11445   bfd_boolean merged;
11446   size_t relativecount = 0;
11447   asection *reldyn = 0;
11448   bfd_size_type amt;
11449   asection *attr_section = NULL;
11450   bfd_vma attr_size = 0;
11451   const char *std_attrs_section;
11452   struct elf_link_hash_table *htab = elf_hash_table (info);
11453
11454   if (!is_elf_hash_table (htab))
11455     return FALSE;
11456
11457   if (bfd_link_pic (info))
11458     abfd->flags |= DYNAMIC;
11459
11460   dynamic = htab->dynamic_sections_created;
11461   dynobj = htab->dynobj;
11462
11463   emit_relocs = (bfd_link_relocatable (info)
11464                  || info->emitrelocations);
11465
11466   flinfo.info = info;
11467   flinfo.output_bfd = abfd;
11468   flinfo.symstrtab = _bfd_elf_strtab_init ();
11469   if (flinfo.symstrtab == NULL)
11470     return FALSE;
11471
11472   if (! dynamic)
11473     {
11474       flinfo.hash_sec = NULL;
11475       flinfo.symver_sec = NULL;
11476     }
11477   else
11478     {
11479       flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
11480       /* Note that dynsym_sec can be NULL (on VMS).  */
11481       flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
11482       /* Note that it is OK if symver_sec is NULL.  */
11483     }
11484
11485   flinfo.contents = NULL;
11486   flinfo.external_relocs = NULL;
11487   flinfo.internal_relocs = NULL;
11488   flinfo.external_syms = NULL;
11489   flinfo.locsym_shndx = NULL;
11490   flinfo.internal_syms = NULL;
11491   flinfo.indices = NULL;
11492   flinfo.sections = NULL;
11493   flinfo.symshndxbuf = NULL;
11494   flinfo.filesym_count = 0;
11495
11496   /* The object attributes have been merged.  Remove the input
11497      sections from the link, and set the contents of the output
11498      secton.  */
11499   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
11500   for (o = abfd->sections; o != NULL; o = o->next)
11501     {
11502       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
11503           || strcmp (o->name, ".gnu.attributes") == 0)
11504         {
11505           for (p = o->map_head.link_order; p != NULL; p = p->next)
11506             {
11507               asection *input_section;
11508
11509               if (p->type != bfd_indirect_link_order)
11510                 continue;
11511               input_section = p->u.indirect.section;
11512               /* Hack: reset the SEC_HAS_CONTENTS flag so that
11513                  elf_link_input_bfd ignores this section.  */
11514               input_section->flags &= ~SEC_HAS_CONTENTS;
11515             }
11516
11517           attr_size = bfd_elf_obj_attr_size (abfd);
11518           if (attr_size)
11519             {
11520               bfd_set_section_size (abfd, o, attr_size);
11521               attr_section = o;
11522               /* Skip this section later on.  */
11523               o->map_head.link_order = NULL;
11524             }
11525           else
11526             o->flags |= SEC_EXCLUDE;
11527         }
11528     }
11529
11530   /* Count up the number of relocations we will output for each output
11531      section, so that we know the sizes of the reloc sections.  We
11532      also figure out some maximum sizes.  */
11533   max_contents_size = 0;
11534   max_external_reloc_size = 0;
11535   max_internal_reloc_count = 0;
11536   max_sym_count = 0;
11537   max_sym_shndx_count = 0;
11538   merged = FALSE;
11539   for (o = abfd->sections; o != NULL; o = o->next)
11540     {
11541       struct bfd_elf_section_data *esdo = elf_section_data (o);
11542       o->reloc_count = 0;
11543
11544       for (p = o->map_head.link_order; p != NULL; p = p->next)
11545         {
11546           unsigned int reloc_count = 0;
11547           unsigned int additional_reloc_count = 0;
11548           struct bfd_elf_section_data *esdi = NULL;
11549
11550           if (p->type == bfd_section_reloc_link_order
11551               || p->type == bfd_symbol_reloc_link_order)
11552             reloc_count = 1;
11553           else if (p->type == bfd_indirect_link_order)
11554             {
11555               asection *sec;
11556
11557               sec = p->u.indirect.section;
11558
11559               /* Mark all sections which are to be included in the
11560                  link.  This will normally be every section.  We need
11561                  to do this so that we can identify any sections which
11562                  the linker has decided to not include.  */
11563               sec->linker_mark = TRUE;
11564
11565               if (sec->flags & SEC_MERGE)
11566                 merged = TRUE;
11567
11568               if (sec->rawsize > max_contents_size)
11569                 max_contents_size = sec->rawsize;
11570               if (sec->size > max_contents_size)
11571                 max_contents_size = sec->size;
11572
11573               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
11574                   && (sec->owner->flags & DYNAMIC) == 0)
11575                 {
11576                   size_t sym_count;
11577
11578                   /* We are interested in just local symbols, not all
11579                      symbols.  */
11580                   if (elf_bad_symtab (sec->owner))
11581                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
11582                                  / bed->s->sizeof_sym);
11583                   else
11584                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
11585
11586                   if (sym_count > max_sym_count)
11587                     max_sym_count = sym_count;
11588
11589                   if (sym_count > max_sym_shndx_count
11590                       && elf_symtab_shndx_list (sec->owner) != NULL)
11591                     max_sym_shndx_count = sym_count;
11592
11593                   if (esdo->this_hdr.sh_type == SHT_REL
11594                       || esdo->this_hdr.sh_type == SHT_RELA)
11595                     /* Some backends use reloc_count in relocation sections
11596                        to count particular types of relocs.  Of course,
11597                        reloc sections themselves can't have relocations.  */
11598                     ;
11599                   else if (emit_relocs)
11600                     {
11601                       reloc_count = sec->reloc_count;
11602                       if (bed->elf_backend_count_additional_relocs)
11603                         {
11604                           int c;
11605                           c = (*bed->elf_backend_count_additional_relocs) (sec);
11606                           additional_reloc_count += c;
11607                         }
11608                     }
11609                   else if (bed->elf_backend_count_relocs)
11610                     reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
11611
11612                   esdi = elf_section_data (sec);
11613
11614                   if ((sec->flags & SEC_RELOC) != 0)
11615                     {
11616                       size_t ext_size = 0;
11617
11618                       if (esdi->rel.hdr != NULL)
11619                         ext_size = esdi->rel.hdr->sh_size;
11620                       if (esdi->rela.hdr != NULL)
11621                         ext_size += esdi->rela.hdr->sh_size;
11622
11623                       if (ext_size > max_external_reloc_size)
11624                         max_external_reloc_size = ext_size;
11625                       if (sec->reloc_count > max_internal_reloc_count)
11626                         max_internal_reloc_count = sec->reloc_count;
11627                     }
11628                 }
11629             }
11630
11631           if (reloc_count == 0)
11632             continue;
11633
11634           reloc_count += additional_reloc_count;
11635           o->reloc_count += reloc_count;
11636
11637           if (p->type == bfd_indirect_link_order && emit_relocs)
11638             {
11639               if (esdi->rel.hdr)
11640                 {
11641                   esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
11642                   esdo->rel.count += additional_reloc_count;
11643                 }
11644               if (esdi->rela.hdr)
11645                 {
11646                   esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
11647                   esdo->rela.count += additional_reloc_count;
11648                 }
11649             }
11650           else
11651             {
11652               if (o->use_rela_p)
11653                 esdo->rela.count += reloc_count;
11654               else
11655                 esdo->rel.count += reloc_count;
11656             }
11657         }
11658
11659       if (o->reloc_count > 0)
11660         o->flags |= SEC_RELOC;
11661       else
11662         {
11663           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
11664              set it (this is probably a bug) and if it is set
11665              assign_section_numbers will create a reloc section.  */
11666           o->flags &=~ SEC_RELOC;
11667         }
11668
11669       /* If the SEC_ALLOC flag is not set, force the section VMA to
11670          zero.  This is done in elf_fake_sections as well, but forcing
11671          the VMA to 0 here will ensure that relocs against these
11672          sections are handled correctly.  */
11673       if ((o->flags & SEC_ALLOC) == 0
11674           && ! o->user_set_vma)
11675         o->vma = 0;
11676     }
11677
11678   if (! bfd_link_relocatable (info) && merged)
11679     elf_link_hash_traverse (htab, _bfd_elf_link_sec_merge_syms, abfd);
11680
11681   /* Figure out the file positions for everything but the symbol table
11682      and the relocs.  We set symcount to force assign_section_numbers
11683      to create a symbol table.  */
11684   bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
11685   BFD_ASSERT (! abfd->output_has_begun);
11686   if (! _bfd_elf_compute_section_file_positions (abfd, info))
11687     goto error_return;
11688
11689   /* Set sizes, and assign file positions for reloc sections.  */
11690   for (o = abfd->sections; o != NULL; o = o->next)
11691     {
11692       struct bfd_elf_section_data *esdo = elf_section_data (o);
11693       if ((o->flags & SEC_RELOC) != 0)
11694         {
11695           if (esdo->rel.hdr
11696               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
11697             goto error_return;
11698
11699           if (esdo->rela.hdr
11700               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
11701             goto error_return;
11702         }
11703
11704       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
11705          to count upwards while actually outputting the relocations.  */
11706       esdo->rel.count = 0;
11707       esdo->rela.count = 0;
11708
11709       if (esdo->this_hdr.sh_offset == (file_ptr) -1)
11710         {
11711           /* Cache the section contents so that they can be compressed
11712              later.  Use bfd_malloc since it will be freed by
11713              bfd_compress_section_contents.  */
11714           unsigned char *contents = esdo->this_hdr.contents;
11715           if ((o->flags & SEC_ELF_COMPRESS) == 0 || contents != NULL)
11716             abort ();
11717           contents
11718             = (unsigned char *) bfd_malloc (esdo->this_hdr.sh_size);
11719           if (contents == NULL)
11720             goto error_return;
11721           esdo->this_hdr.contents = contents;
11722         }
11723     }
11724
11725   /* We have now assigned file positions for all the sections except
11726      .symtab, .strtab, and non-loaded reloc sections.  We start the
11727      .symtab section at the current file position, and write directly
11728      to it.  We build the .strtab section in memory.  */
11729   bfd_get_symcount (abfd) = 0;
11730   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11731   /* sh_name is set in prep_headers.  */
11732   symtab_hdr->sh_type = SHT_SYMTAB;
11733   /* sh_flags, sh_addr and sh_size all start off zero.  */
11734   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
11735   /* sh_link is set in assign_section_numbers.  */
11736   /* sh_info is set below.  */
11737   /* sh_offset is set just below.  */
11738   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
11739
11740   if (max_sym_count < 20)
11741     max_sym_count = 20;
11742   htab->strtabsize = max_sym_count;
11743   amt = max_sym_count * sizeof (struct elf_sym_strtab);
11744   htab->strtab = (struct elf_sym_strtab *) bfd_malloc (amt);
11745   if (htab->strtab == NULL)
11746     goto error_return;
11747   /* The real buffer will be allocated in elf_link_swap_symbols_out.  */
11748   flinfo.symshndxbuf
11749     = (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF)
11750        ? (Elf_External_Sym_Shndx *) -1 : NULL);
11751
11752   if (info->strip != strip_all || emit_relocs)
11753     {
11754       file_ptr off = elf_next_file_pos (abfd);
11755
11756       _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
11757
11758       /* Note that at this point elf_next_file_pos (abfd) is
11759          incorrect.  We do not yet know the size of the .symtab section.
11760          We correct next_file_pos below, after we do know the size.  */
11761
11762       /* Start writing out the symbol table.  The first symbol is always a
11763          dummy symbol.  */
11764       elfsym.st_value = 0;
11765       elfsym.st_size = 0;
11766       elfsym.st_info = 0;
11767       elfsym.st_other = 0;
11768       elfsym.st_shndx = SHN_UNDEF;
11769       elfsym.st_target_internal = 0;
11770       if (elf_link_output_symstrtab (&flinfo, NULL, &elfsym,
11771                                      bfd_und_section_ptr, NULL) != 1)
11772         goto error_return;
11773
11774       /* Output a symbol for each section.  We output these even if we are
11775          discarding local symbols, since they are used for relocs.  These
11776          symbols have no names.  We store the index of each one in the
11777          index field of the section, so that we can find it again when
11778          outputting relocs.  */
11779
11780       elfsym.st_size = 0;
11781       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11782       elfsym.st_other = 0;
11783       elfsym.st_value = 0;
11784       elfsym.st_target_internal = 0;
11785       for (i = 1; i < elf_numsections (abfd); i++)
11786         {
11787           o = bfd_section_from_elf_index (abfd, i);
11788           if (o != NULL)
11789             {
11790               o->target_index = bfd_get_symcount (abfd);
11791               elfsym.st_shndx = i;
11792               if (!bfd_link_relocatable (info))
11793                 elfsym.st_value = o->vma;
11794               if (elf_link_output_symstrtab (&flinfo, NULL, &elfsym, o,
11795                                              NULL) != 1)
11796                 goto error_return;
11797             }
11798         }
11799     }
11800
11801   /* Allocate some memory to hold information read in from the input
11802      files.  */
11803   if (max_contents_size != 0)
11804     {
11805       flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
11806       if (flinfo.contents == NULL)
11807         goto error_return;
11808     }
11809
11810   if (max_external_reloc_size != 0)
11811     {
11812       flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
11813       if (flinfo.external_relocs == NULL)
11814         goto error_return;
11815     }
11816
11817   if (max_internal_reloc_count != 0)
11818     {
11819       amt = max_internal_reloc_count * sizeof (Elf_Internal_Rela);
11820       flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
11821       if (flinfo.internal_relocs == NULL)
11822         goto error_return;
11823     }
11824
11825   if (max_sym_count != 0)
11826     {
11827       amt = max_sym_count * bed->s->sizeof_sym;
11828       flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
11829       if (flinfo.external_syms == NULL)
11830         goto error_return;
11831
11832       amt = max_sym_count * sizeof (Elf_Internal_Sym);
11833       flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
11834       if (flinfo.internal_syms == NULL)
11835         goto error_return;
11836
11837       amt = max_sym_count * sizeof (long);
11838       flinfo.indices = (long int *) bfd_malloc (amt);
11839       if (flinfo.indices == NULL)
11840         goto error_return;
11841
11842       amt = max_sym_count * sizeof (asection *);
11843       flinfo.sections = (asection **) bfd_malloc (amt);
11844       if (flinfo.sections == NULL)
11845         goto error_return;
11846     }
11847
11848   if (max_sym_shndx_count != 0)
11849     {
11850       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
11851       flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
11852       if (flinfo.locsym_shndx == NULL)
11853         goto error_return;
11854     }
11855
11856   if (htab->tls_sec)
11857     {
11858       bfd_vma base, end = 0;
11859       asection *sec;
11860
11861       for (sec = htab->tls_sec;
11862            sec && (sec->flags & SEC_THREAD_LOCAL);
11863            sec = sec->next)
11864         {
11865           bfd_size_type size = sec->size;
11866
11867           if (size == 0
11868               && (sec->flags & SEC_HAS_CONTENTS) == 0)
11869             {
11870               struct bfd_link_order *ord = sec->map_tail.link_order;
11871
11872               if (ord != NULL)
11873                 size = ord->offset + ord->size;
11874             }
11875           end = sec->vma + size;
11876         }
11877       base = htab->tls_sec->vma;
11878       /* Only align end of TLS section if static TLS doesn't have special
11879          alignment requirements.  */
11880       if (bed->static_tls_alignment == 1)
11881         end = align_power (end, htab->tls_sec->alignment_power);
11882       htab->tls_size = end - base;
11883     }
11884
11885   /* Reorder SHF_LINK_ORDER sections.  */
11886   for (o = abfd->sections; o != NULL; o = o->next)
11887     {
11888       if (!elf_fixup_link_order (abfd, o))
11889         return FALSE;
11890     }
11891
11892   if (!_bfd_elf_fixup_eh_frame_hdr (info))
11893     return FALSE;
11894
11895   /* Since ELF permits relocations to be against local symbols, we
11896      must have the local symbols available when we do the relocations.
11897      Since we would rather only read the local symbols once, and we
11898      would rather not keep them in memory, we handle all the
11899      relocations for a single input file at the same time.
11900
11901      Unfortunately, there is no way to know the total number of local
11902      symbols until we have seen all of them, and the local symbol
11903      indices precede the global symbol indices.  This means that when
11904      we are generating relocatable output, and we see a reloc against
11905      a global symbol, we can not know the symbol index until we have
11906      finished examining all the local symbols to see which ones we are
11907      going to output.  To deal with this, we keep the relocations in
11908      memory, and don't output them until the end of the link.  This is
11909      an unfortunate waste of memory, but I don't see a good way around
11910      it.  Fortunately, it only happens when performing a relocatable
11911      link, which is not the common case.  FIXME: If keep_memory is set
11912      we could write the relocs out and then read them again; I don't
11913      know how bad the memory loss will be.  */
11914
11915   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11916     sub->output_has_begun = FALSE;
11917   for (o = abfd->sections; o != NULL; o = o->next)
11918     {
11919       for (p = o->map_head.link_order; p != NULL; p = p->next)
11920         {
11921           if (p->type == bfd_indirect_link_order
11922               && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
11923                   == bfd_target_elf_flavour)
11924               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
11925             {
11926               if (! sub->output_has_begun)
11927                 {
11928                   if (! elf_link_input_bfd (&flinfo, sub))
11929                     goto error_return;
11930                   sub->output_has_begun = TRUE;
11931                 }
11932             }
11933           else if (p->type == bfd_section_reloc_link_order
11934                    || p->type == bfd_symbol_reloc_link_order)
11935             {
11936               if (! elf_reloc_link_order (abfd, info, o, p))
11937                 goto error_return;
11938             }
11939           else
11940             {
11941               if (! _bfd_default_link_order (abfd, info, o, p))
11942                 {
11943                   if (p->type == bfd_indirect_link_order
11944                       && (bfd_get_flavour (sub)
11945                           == bfd_target_elf_flavour)
11946                       && (elf_elfheader (sub)->e_ident[EI_CLASS]
11947                           != bed->s->elfclass))
11948                     {
11949                       const char *iclass, *oclass;
11950
11951                       switch (bed->s->elfclass)
11952                         {
11953                         case ELFCLASS64: oclass = "ELFCLASS64"; break;
11954                         case ELFCLASS32: oclass = "ELFCLASS32"; break;
11955                         case ELFCLASSNONE: oclass = "ELFCLASSNONE"; break;
11956                         default: abort ();
11957                         }
11958
11959                       switch (elf_elfheader (sub)->e_ident[EI_CLASS])
11960                         {
11961                         case ELFCLASS64: iclass = "ELFCLASS64"; break;
11962                         case ELFCLASS32: iclass = "ELFCLASS32"; break;
11963                         case ELFCLASSNONE: iclass = "ELFCLASSNONE"; break;
11964                         default: abort ();
11965                         }
11966
11967                       bfd_set_error (bfd_error_wrong_format);
11968                       _bfd_error_handler
11969                         /* xgettext:c-format */
11970                         (_("%B: file class %s incompatible with %s"),
11971                          sub, iclass, oclass);
11972                     }
11973
11974                   goto error_return;
11975                 }
11976             }
11977         }
11978     }
11979
11980   /* Free symbol buffer if needed.  */
11981   if (!info->reduce_memory_overheads)
11982     {
11983       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11984         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11985             && elf_tdata (sub)->symbuf)
11986           {
11987             free (elf_tdata (sub)->symbuf);
11988             elf_tdata (sub)->symbuf = NULL;
11989           }
11990     }
11991
11992   /* Output any global symbols that got converted to local in a
11993      version script or due to symbol visibility.  We do this in a
11994      separate step since ELF requires all local symbols to appear
11995      prior to any global symbols.  FIXME: We should only do this if
11996      some global symbols were, in fact, converted to become local.
11997      FIXME: Will this work correctly with the Irix 5 linker?  */
11998   eoinfo.failed = FALSE;
11999   eoinfo.flinfo = &flinfo;
12000   eoinfo.localsyms = TRUE;
12001   eoinfo.file_sym_done = FALSE;
12002   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
12003   if (eoinfo.failed)
12004     return FALSE;
12005
12006   /* If backend needs to output some local symbols not present in the hash
12007      table, do it now.  */
12008   if (bed->elf_backend_output_arch_local_syms
12009       && (info->strip != strip_all || emit_relocs))
12010     {
12011       typedef int (*out_sym_func)
12012         (void *, const char *, Elf_Internal_Sym *, asection *,
12013          struct elf_link_hash_entry *);
12014
12015       if (! ((*bed->elf_backend_output_arch_local_syms)
12016              (abfd, info, &flinfo,
12017               (out_sym_func) elf_link_output_symstrtab)))
12018         return FALSE;
12019     }
12020
12021   /* That wrote out all the local symbols.  Finish up the symbol table
12022      with the global symbols. Even if we want to strip everything we
12023      can, we still need to deal with those global symbols that got
12024      converted to local in a version script.  */
12025
12026   /* The sh_info field records the index of the first non local symbol.  */
12027   symtab_hdr->sh_info = bfd_get_symcount (abfd);
12028
12029   if (dynamic
12030       && htab->dynsym != NULL
12031       && htab->dynsym->output_section != bfd_abs_section_ptr)
12032     {
12033       Elf_Internal_Sym sym;
12034       bfd_byte *dynsym = htab->dynsym->contents;
12035
12036       o = htab->dynsym->output_section;
12037       elf_section_data (o)->this_hdr.sh_info = htab->local_dynsymcount + 1;
12038
12039       /* Write out the section symbols for the output sections.  */
12040       if (bfd_link_pic (info)
12041           || htab->is_relocatable_executable)
12042         {
12043           asection *s;
12044
12045           sym.st_size = 0;
12046           sym.st_name = 0;
12047           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
12048           sym.st_other = 0;
12049           sym.st_target_internal = 0;
12050
12051           for (s = abfd->sections; s != NULL; s = s->next)
12052             {
12053               int indx;
12054               bfd_byte *dest;
12055               long dynindx;
12056
12057               dynindx = elf_section_data (s)->dynindx;
12058               if (dynindx <= 0)
12059                 continue;
12060               indx = elf_section_data (s)->this_idx;
12061               BFD_ASSERT (indx > 0);
12062               sym.st_shndx = indx;
12063               if (! check_dynsym (abfd, &sym))
12064                 return FALSE;
12065               sym.st_value = s->vma;
12066               dest = dynsym + dynindx * bed->s->sizeof_sym;
12067               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
12068             }
12069         }
12070
12071       /* Write out the local dynsyms.  */
12072       if (htab->dynlocal)
12073         {
12074           struct elf_link_local_dynamic_entry *e;
12075           for (e = htab->dynlocal; e ; e = e->next)
12076             {
12077               asection *s;
12078               bfd_byte *dest;
12079
12080               /* Copy the internal symbol and turn off visibility.
12081                  Note that we saved a word of storage and overwrote
12082                  the original st_name with the dynstr_index.  */
12083               sym = e->isym;
12084               sym.st_other &= ~ELF_ST_VISIBILITY (-1);
12085
12086               s = bfd_section_from_elf_index (e->input_bfd,
12087                                               e->isym.st_shndx);
12088               if (s != NULL)
12089                 {
12090                   sym.st_shndx =
12091                     elf_section_data (s->output_section)->this_idx;
12092                   if (! check_dynsym (abfd, &sym))
12093                     return FALSE;
12094                   sym.st_value = (s->output_section->vma
12095                                   + s->output_offset
12096                                   + e->isym.st_value);
12097                 }
12098
12099               dest = dynsym + e->dynindx * bed->s->sizeof_sym;
12100               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
12101             }
12102         }
12103     }
12104
12105   /* We get the global symbols from the hash table.  */
12106   eoinfo.failed = FALSE;
12107   eoinfo.localsyms = FALSE;
12108   eoinfo.flinfo = &flinfo;
12109   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
12110   if (eoinfo.failed)
12111     return FALSE;
12112
12113   /* If backend needs to output some symbols not present in the hash
12114      table, do it now.  */
12115   if (bed->elf_backend_output_arch_syms
12116       && (info->strip != strip_all || emit_relocs))
12117     {
12118       typedef int (*out_sym_func)
12119         (void *, const char *, Elf_Internal_Sym *, asection *,
12120          struct elf_link_hash_entry *);
12121
12122       if (! ((*bed->elf_backend_output_arch_syms)
12123              (abfd, info, &flinfo,
12124               (out_sym_func) elf_link_output_symstrtab)))
12125         return FALSE;
12126     }
12127
12128   /* Finalize the .strtab section.  */
12129   _bfd_elf_strtab_finalize (flinfo.symstrtab);
12130
12131   /* Swap out the .strtab section. */
12132   if (!elf_link_swap_symbols_out (&flinfo))
12133     return FALSE;
12134
12135   /* Now we know the size of the symtab section.  */
12136   if (bfd_get_symcount (abfd) > 0)
12137     {
12138       /* Finish up and write out the symbol string table (.strtab)
12139          section.  */
12140       Elf_Internal_Shdr *symstrtab_hdr = NULL;
12141       file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
12142
12143       if (elf_symtab_shndx_list (abfd))
12144         {
12145           symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
12146
12147           if (symtab_shndx_hdr != NULL && symtab_shndx_hdr->sh_name != 0)
12148             {
12149               symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
12150               symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
12151               symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
12152               amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
12153               symtab_shndx_hdr->sh_size = amt;
12154
12155               off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
12156                                                                off, TRUE);
12157
12158               if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
12159                   || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
12160                 return FALSE;
12161             }
12162         }
12163
12164       symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
12165       /* sh_name was set in prep_headers.  */
12166       symstrtab_hdr->sh_type = SHT_STRTAB;
12167       symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
12168       symstrtab_hdr->sh_addr = 0;
12169       symstrtab_hdr->sh_size = _bfd_elf_strtab_size (flinfo.symstrtab);
12170       symstrtab_hdr->sh_entsize = 0;
12171       symstrtab_hdr->sh_link = 0;
12172       symstrtab_hdr->sh_info = 0;
12173       /* sh_offset is set just below.  */
12174       symstrtab_hdr->sh_addralign = 1;
12175
12176       off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
12177                                                        off, TRUE);
12178       elf_next_file_pos (abfd) = off;
12179
12180       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
12181           || ! _bfd_elf_strtab_emit (abfd, flinfo.symstrtab))
12182         return FALSE;
12183     }
12184
12185   if (info->out_implib_bfd && !elf_output_implib (abfd, info))
12186     {
12187       _bfd_error_handler (_("%B: failed to generate import library"),
12188                           info->out_implib_bfd);
12189       return FALSE;
12190     }
12191
12192   /* Adjust the relocs to have the correct symbol indices.  */
12193   for (o = abfd->sections; o != NULL; o = o->next)
12194     {
12195       struct bfd_elf_section_data *esdo = elf_section_data (o);
12196       bfd_boolean sort;
12197
12198       if ((o->flags & SEC_RELOC) == 0)
12199         continue;
12200
12201       sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
12202       if (esdo->rel.hdr != NULL
12203           && !elf_link_adjust_relocs (abfd, o, &esdo->rel, sort, info))
12204         return FALSE;
12205       if (esdo->rela.hdr != NULL
12206           && !elf_link_adjust_relocs (abfd, o, &esdo->rela, sort, info))
12207         return FALSE;
12208
12209       /* Set the reloc_count field to 0 to prevent write_relocs from
12210          trying to swap the relocs out itself.  */
12211       o->reloc_count = 0;
12212     }
12213
12214   if (dynamic && info->combreloc && dynobj != NULL)
12215     relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
12216
12217   /* If we are linking against a dynamic object, or generating a
12218      shared library, finish up the dynamic linking information.  */
12219   if (dynamic)
12220     {
12221       bfd_byte *dyncon, *dynconend;
12222
12223       /* Fix up .dynamic entries.  */
12224       o = bfd_get_linker_section (dynobj, ".dynamic");
12225       BFD_ASSERT (o != NULL);
12226
12227       dyncon = o->contents;
12228       dynconend = o->contents + o->size;
12229       for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
12230         {
12231           Elf_Internal_Dyn dyn;
12232           const char *name;
12233           unsigned int type;
12234           bfd_size_type sh_size;
12235           bfd_vma sh_addr;
12236
12237           bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
12238
12239           switch (dyn.d_tag)
12240             {
12241             default:
12242               continue;
12243             case DT_NULL:
12244               if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
12245                 {
12246                   switch (elf_section_data (reldyn)->this_hdr.sh_type)
12247                     {
12248                     case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
12249                     case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
12250                     default: continue;
12251                     }
12252                   dyn.d_un.d_val = relativecount;
12253                   relativecount = 0;
12254                   break;
12255                 }
12256               continue;
12257
12258             case DT_INIT:
12259               name = info->init_function;
12260               goto get_sym;
12261             case DT_FINI:
12262               name = info->fini_function;
12263             get_sym:
12264               {
12265                 struct elf_link_hash_entry *h;
12266
12267                 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
12268                 if (h != NULL
12269                     && (h->root.type == bfd_link_hash_defined
12270                         || h->root.type == bfd_link_hash_defweak))
12271                   {
12272                     dyn.d_un.d_ptr = h->root.u.def.value;
12273                     o = h->root.u.def.section;
12274                     if (o->output_section != NULL)
12275                       dyn.d_un.d_ptr += (o->output_section->vma
12276                                          + o->output_offset);
12277                     else
12278                       {
12279                         /* The symbol is imported from another shared
12280                            library and does not apply to this one.  */
12281                         dyn.d_un.d_ptr = 0;
12282                       }
12283                     break;
12284                   }
12285               }
12286               continue;
12287
12288             case DT_PREINIT_ARRAYSZ:
12289               name = ".preinit_array";
12290               goto get_out_size;
12291             case DT_INIT_ARRAYSZ:
12292               name = ".init_array";
12293               goto get_out_size;
12294             case DT_FINI_ARRAYSZ:
12295               name = ".fini_array";
12296             get_out_size:
12297               o = bfd_get_section_by_name (abfd, name);
12298               if (o == NULL)
12299                 {
12300                   _bfd_error_handler
12301                     (_("could not find section %s"), name);
12302                   goto error_return;
12303                 }
12304               if (o->size == 0)
12305                 _bfd_error_handler
12306                   (_("warning: %s section has zero size"), name);
12307               dyn.d_un.d_val = o->size;
12308               break;
12309
12310             case DT_PREINIT_ARRAY:
12311               name = ".preinit_array";
12312               goto get_out_vma;
12313             case DT_INIT_ARRAY:
12314               name = ".init_array";
12315               goto get_out_vma;
12316             case DT_FINI_ARRAY:
12317               name = ".fini_array";
12318             get_out_vma:
12319               o = bfd_get_section_by_name (abfd, name);
12320               goto do_vma;
12321
12322             case DT_HASH:
12323               name = ".hash";
12324               goto get_vma;
12325             case DT_GNU_HASH:
12326               name = ".gnu.hash";
12327               goto get_vma;
12328             case DT_STRTAB:
12329               name = ".dynstr";
12330               goto get_vma;
12331             case DT_SYMTAB:
12332               name = ".dynsym";
12333               goto get_vma;
12334             case DT_VERDEF:
12335               name = ".gnu.version_d";
12336               goto get_vma;
12337             case DT_VERNEED:
12338               name = ".gnu.version_r";
12339               goto get_vma;
12340             case DT_VERSYM:
12341               name = ".gnu.version";
12342             get_vma:
12343               o = bfd_get_linker_section (dynobj, name);
12344             do_vma:
12345               if (o == NULL || bfd_is_abs_section (o->output_section))
12346                 {
12347                   _bfd_error_handler
12348                     (_("could not find section %s"), name);
12349                   goto error_return;
12350                 }
12351               if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
12352                 {
12353                   _bfd_error_handler
12354                     (_("warning: section '%s' is being made into a note"), name);
12355                   bfd_set_error (bfd_error_nonrepresentable_section);
12356                   goto error_return;
12357                 }
12358               dyn.d_un.d_ptr = o->output_section->vma + o->output_offset;
12359               break;
12360
12361             case DT_REL:
12362             case DT_RELA:
12363             case DT_RELSZ:
12364             case DT_RELASZ:
12365               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
12366                 type = SHT_REL;
12367               else
12368                 type = SHT_RELA;
12369               sh_size = 0;
12370               sh_addr = 0;
12371               for (i = 1; i < elf_numsections (abfd); i++)
12372                 {
12373                   Elf_Internal_Shdr *hdr;
12374
12375                   hdr = elf_elfsections (abfd)[i];
12376                   if (hdr->sh_type == type
12377                       && (hdr->sh_flags & SHF_ALLOC) != 0)
12378                     {
12379                       sh_size += hdr->sh_size;
12380                       if (sh_addr == 0
12381                           || sh_addr > hdr->sh_addr)
12382                         sh_addr = hdr->sh_addr;
12383                     }
12384                 }
12385
12386               if (bed->dtrel_excludes_plt && htab->srelplt != NULL)
12387                 {
12388                   /* Don't count procedure linkage table relocs in the
12389                      overall reloc count.  */
12390                   sh_size -= htab->srelplt->size;
12391                   if (sh_size == 0)
12392                     /* If the size is zero, make the address zero too.
12393                        This is to avoid a glibc bug.  If the backend
12394                        emits DT_RELA/DT_RELASZ even when DT_RELASZ is
12395                        zero, then we'll put DT_RELA at the end of
12396                        DT_JMPREL.  glibc will interpret the end of
12397                        DT_RELA matching the end of DT_JMPREL as the
12398                        case where DT_RELA includes DT_JMPREL, and for
12399                        LD_BIND_NOW will decide that processing DT_RELA
12400                        will process the PLT relocs too.  Net result:
12401                        No PLT relocs applied.  */
12402                     sh_addr = 0;
12403
12404                   /* If .rela.plt is the first .rela section, exclude
12405                      it from DT_RELA.  */
12406                   else if (sh_addr == (htab->srelplt->output_section->vma
12407                                        + htab->srelplt->output_offset))
12408                     sh_addr += htab->srelplt->size;
12409                 }
12410
12411               if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
12412                 dyn.d_un.d_val = sh_size;
12413               else
12414                 dyn.d_un.d_ptr = sh_addr;
12415               break;
12416             }
12417           bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
12418         }
12419     }
12420
12421   /* If we have created any dynamic sections, then output them.  */
12422   if (dynobj != NULL)
12423     {
12424       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
12425         goto error_return;
12426
12427       /* Check for DT_TEXTREL (late, in case the backend removes it).  */
12428       if (((info->warn_shared_textrel && bfd_link_pic (info))
12429            || info->error_textrel)
12430           && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
12431         {
12432           bfd_byte *dyncon, *dynconend;
12433
12434           dyncon = o->contents;
12435           dynconend = o->contents + o->size;
12436           for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
12437             {
12438               Elf_Internal_Dyn dyn;
12439
12440               bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
12441
12442               if (dyn.d_tag == DT_TEXTREL)
12443                 {
12444                   if (info->error_textrel)
12445                     info->callbacks->einfo
12446                       (_("%P%X: read-only segment has dynamic relocations.\n"));
12447                   else
12448                     info->callbacks->einfo
12449                       (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
12450                   break;
12451                 }
12452             }
12453         }
12454
12455       for (o = dynobj->sections; o != NULL; o = o->next)
12456         {
12457           if ((o->flags & SEC_HAS_CONTENTS) == 0
12458               || o->size == 0
12459               || o->output_section == bfd_abs_section_ptr)
12460             continue;
12461           if ((o->flags & SEC_LINKER_CREATED) == 0)
12462             {
12463               /* At this point, we are only interested in sections
12464                  created by _bfd_elf_link_create_dynamic_sections.  */
12465               continue;
12466             }
12467           if (htab->stab_info.stabstr == o)
12468             continue;
12469           if (htab->eh_info.hdr_sec == o)
12470             continue;
12471           if (strcmp (o->name, ".dynstr") != 0)
12472             {
12473               if (! bfd_set_section_contents (abfd, o->output_section,
12474                                               o->contents,
12475                                               (file_ptr) o->output_offset
12476                                               * bfd_octets_per_byte (abfd),
12477                                               o->size))
12478                 goto error_return;
12479             }
12480           else
12481             {
12482               /* The contents of the .dynstr section are actually in a
12483                  stringtab.  */
12484               file_ptr off;
12485
12486               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
12487               if (bfd_seek (abfd, off, SEEK_SET) != 0
12488                   || !_bfd_elf_strtab_emit (abfd, htab->dynstr))
12489                 goto error_return;
12490             }
12491         }
12492     }
12493
12494   if (!info->resolve_section_groups)
12495     {
12496       bfd_boolean failed = FALSE;
12497
12498       BFD_ASSERT (bfd_link_relocatable (info));
12499       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
12500       if (failed)
12501         goto error_return;
12502     }
12503
12504   /* If we have optimized stabs strings, output them.  */
12505   if (htab->stab_info.stabstr != NULL)
12506     {
12507       if (!_bfd_write_stab_strings (abfd, &htab->stab_info))
12508         goto error_return;
12509     }
12510
12511   if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
12512     goto error_return;
12513
12514   elf_final_link_free (abfd, &flinfo);
12515
12516   elf_linker (abfd) = TRUE;
12517
12518   if (attr_section)
12519     {
12520       bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
12521       if (contents == NULL)
12522         return FALSE;   /* Bail out and fail.  */
12523       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
12524       bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
12525       free (contents);
12526     }
12527
12528   return TRUE;
12529
12530  error_return:
12531   elf_final_link_free (abfd, &flinfo);
12532   return FALSE;
12533 }
12534 \f
12535 /* Initialize COOKIE for input bfd ABFD.  */
12536
12537 static bfd_boolean
12538 init_reloc_cookie (struct elf_reloc_cookie *cookie,
12539                    struct bfd_link_info *info, bfd *abfd)
12540 {
12541   Elf_Internal_Shdr *symtab_hdr;
12542   const struct elf_backend_data *bed;
12543
12544   bed = get_elf_backend_data (abfd);
12545   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12546
12547   cookie->abfd = abfd;
12548   cookie->sym_hashes = elf_sym_hashes (abfd);
12549   cookie->bad_symtab = elf_bad_symtab (abfd);
12550   if (cookie->bad_symtab)
12551     {
12552       cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12553       cookie->extsymoff = 0;
12554     }
12555   else
12556     {
12557       cookie->locsymcount = symtab_hdr->sh_info;
12558       cookie->extsymoff = symtab_hdr->sh_info;
12559     }
12560
12561   if (bed->s->arch_size == 32)
12562     cookie->r_sym_shift = 8;
12563   else
12564     cookie->r_sym_shift = 32;
12565
12566   cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
12567   if (cookie->locsyms == NULL && cookie->locsymcount != 0)
12568     {
12569       cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
12570                                               cookie->locsymcount, 0,
12571                                               NULL, NULL, NULL);
12572       if (cookie->locsyms == NULL)
12573         {
12574           info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
12575           return FALSE;
12576         }
12577       if (info->keep_memory)
12578         symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
12579     }
12580   return TRUE;
12581 }
12582
12583 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
12584
12585 static void
12586 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
12587 {
12588   Elf_Internal_Shdr *symtab_hdr;
12589
12590   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12591   if (cookie->locsyms != NULL
12592       && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
12593     free (cookie->locsyms);
12594 }
12595
12596 /* Initialize the relocation information in COOKIE for input section SEC
12597    of input bfd ABFD.  */
12598
12599 static bfd_boolean
12600 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
12601                         struct bfd_link_info *info, bfd *abfd,
12602                         asection *sec)
12603 {
12604   if (sec->reloc_count == 0)
12605     {
12606       cookie->rels = NULL;
12607       cookie->relend = NULL;
12608     }
12609   else
12610     {
12611       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12612                                                 info->keep_memory);
12613       if (cookie->rels == NULL)
12614         return FALSE;
12615       cookie->rel = cookie->rels;
12616       cookie->relend = cookie->rels + sec->reloc_count;
12617     }
12618   cookie->rel = cookie->rels;
12619   return TRUE;
12620 }
12621
12622 /* Free the memory allocated by init_reloc_cookie_rels,
12623    if appropriate.  */
12624
12625 static void
12626 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
12627                         asection *sec)
12628 {
12629   if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
12630     free (cookie->rels);
12631 }
12632
12633 /* Initialize the whole of COOKIE for input section SEC.  */
12634
12635 static bfd_boolean
12636 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
12637                                struct bfd_link_info *info,
12638                                asection *sec)
12639 {
12640   if (!init_reloc_cookie (cookie, info, sec->owner))
12641     goto error1;
12642   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
12643     goto error2;
12644   return TRUE;
12645
12646  error2:
12647   fini_reloc_cookie (cookie, sec->owner);
12648  error1:
12649   return FALSE;
12650 }
12651
12652 /* Free the memory allocated by init_reloc_cookie_for_section,
12653    if appropriate.  */
12654
12655 static void
12656 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
12657                                asection *sec)
12658 {
12659   fini_reloc_cookie_rels (cookie, sec);
12660   fini_reloc_cookie (cookie, sec->owner);
12661 }
12662 \f
12663 /* Garbage collect unused sections.  */
12664
12665 /* Default gc_mark_hook.  */
12666
12667 asection *
12668 _bfd_elf_gc_mark_hook (asection *sec,
12669                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
12670                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
12671                        struct elf_link_hash_entry *h,
12672                        Elf_Internal_Sym *sym)
12673 {
12674   if (h != NULL)
12675     {
12676       switch (h->root.type)
12677         {
12678         case bfd_link_hash_defined:
12679         case bfd_link_hash_defweak:
12680           return h->root.u.def.section;
12681
12682         case bfd_link_hash_common:
12683           return h->root.u.c.p->section;
12684
12685         default:
12686           break;
12687         }
12688     }
12689   else
12690     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
12691
12692   return NULL;
12693 }
12694
12695 /* Return the global debug definition section.  */
12696
12697 static asection *
12698 elf_gc_mark_debug_section (asection *sec ATTRIBUTE_UNUSED,
12699                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
12700                            Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
12701                            struct elf_link_hash_entry *h,
12702                            Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
12703 {
12704   if (h != NULL
12705       && (h->root.type == bfd_link_hash_defined
12706           || h->root.type == bfd_link_hash_defweak)
12707       && (h->root.u.def.section->flags & SEC_DEBUGGING) != 0)
12708     return h->root.u.def.section;
12709
12710   return NULL;
12711 }
12712
12713 /* COOKIE->rel describes a relocation against section SEC, which is
12714    a section we've decided to keep.  Return the section that contains
12715    the relocation symbol, or NULL if no section contains it.  */
12716
12717 asection *
12718 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
12719                        elf_gc_mark_hook_fn gc_mark_hook,
12720                        struct elf_reloc_cookie *cookie,
12721                        bfd_boolean *start_stop)
12722 {
12723   unsigned long r_symndx;
12724   struct elf_link_hash_entry *h;
12725
12726   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
12727   if (r_symndx == STN_UNDEF)
12728     return NULL;
12729
12730   if (r_symndx >= cookie->locsymcount
12731       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12732     {
12733       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
12734       if (h == NULL)
12735         {
12736           info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
12737                                   sec->owner);
12738           return NULL;
12739         }
12740       while (h->root.type == bfd_link_hash_indirect
12741              || h->root.type == bfd_link_hash_warning)
12742         h = (struct elf_link_hash_entry *) h->root.u.i.link;
12743       h->mark = 1;
12744       /* If this symbol is weak and there is a non-weak definition, we
12745          keep the non-weak definition because many backends put
12746          dynamic reloc info on the non-weak definition for code
12747          handling copy relocs.  */
12748       if (h->u.weakdef != NULL)
12749         h->u.weakdef->mark = 1;
12750
12751       if (start_stop != NULL)
12752         {
12753           /* To work around a glibc bug, mark XXX input sections
12754              when there is a reference to __start_XXX or __stop_XXX
12755              symbols.  */
12756           if (h->start_stop)
12757             {
12758               asection *s = h->u2.start_stop_section;
12759               *start_stop = !s->gc_mark;
12760               return s;
12761             }
12762         }
12763
12764       return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
12765     }
12766
12767   return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
12768                           &cookie->locsyms[r_symndx]);
12769 }
12770
12771 /* COOKIE->rel describes a relocation against section SEC, which is
12772    a section we've decided to keep.  Mark the section that contains
12773    the relocation symbol.  */
12774
12775 bfd_boolean
12776 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
12777                         asection *sec,
12778                         elf_gc_mark_hook_fn gc_mark_hook,
12779                         struct elf_reloc_cookie *cookie)
12780 {
12781   asection *rsec;
12782   bfd_boolean start_stop = FALSE;
12783
12784   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie, &start_stop);
12785   while (rsec != NULL)
12786     {
12787       if (!rsec->gc_mark)
12788         {
12789           if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
12790               || (rsec->owner->flags & DYNAMIC) != 0)
12791             rsec->gc_mark = 1;
12792           else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
12793             return FALSE;
12794         }
12795       if (!start_stop)
12796         break;
12797       rsec = bfd_get_next_section_by_name (rsec->owner, rsec);
12798     }
12799   return TRUE;
12800 }
12801
12802 /* The mark phase of garbage collection.  For a given section, mark
12803    it and any sections in this section's group, and all the sections
12804    which define symbols to which it refers.  */
12805
12806 bfd_boolean
12807 _bfd_elf_gc_mark (struct bfd_link_info *info,
12808                   asection *sec,
12809                   elf_gc_mark_hook_fn gc_mark_hook)
12810 {
12811   bfd_boolean ret;
12812   asection *group_sec, *eh_frame;
12813
12814   sec->gc_mark = 1;
12815
12816   /* Mark all the sections in the group.  */
12817   group_sec = elf_section_data (sec)->next_in_group;
12818   if (group_sec && !group_sec->gc_mark)
12819     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
12820       return FALSE;
12821
12822   /* Look through the section relocs.  */
12823   ret = TRUE;
12824   eh_frame = elf_eh_frame_section (sec->owner);
12825   if ((sec->flags & SEC_RELOC) != 0
12826       && sec->reloc_count > 0
12827       && sec != eh_frame)
12828     {
12829       struct elf_reloc_cookie cookie;
12830
12831       if (!init_reloc_cookie_for_section (&cookie, info, sec))
12832         ret = FALSE;
12833       else
12834         {
12835           for (; cookie.rel < cookie.relend; cookie.rel++)
12836             if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
12837               {
12838                 ret = FALSE;
12839                 break;
12840               }
12841           fini_reloc_cookie_for_section (&cookie, sec);
12842         }
12843     }
12844
12845   if (ret && eh_frame && elf_fde_list (sec))
12846     {
12847       struct elf_reloc_cookie cookie;
12848
12849       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
12850         ret = FALSE;
12851       else
12852         {
12853           if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
12854                                       gc_mark_hook, &cookie))
12855             ret = FALSE;
12856           fini_reloc_cookie_for_section (&cookie, eh_frame);
12857         }
12858     }
12859
12860   eh_frame = elf_section_eh_frame_entry (sec);
12861   if (ret && eh_frame && !eh_frame->gc_mark)
12862     if (!_bfd_elf_gc_mark (info, eh_frame, gc_mark_hook))
12863       ret = FALSE;
12864
12865   return ret;
12866 }
12867
12868 /* Scan and mark sections in a special or debug section group.  */
12869
12870 static void
12871 _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
12872 {
12873   /* Point to first section of section group.  */
12874   asection *ssec;
12875   /* Used to iterate the section group.  */
12876   asection *msec;
12877
12878   bfd_boolean is_special_grp = TRUE;
12879   bfd_boolean is_debug_grp = TRUE;
12880
12881   /* First scan to see if group contains any section other than debug
12882      and special section.  */
12883   ssec = msec = elf_next_in_group (grp);
12884   do
12885     {
12886       if ((msec->flags & SEC_DEBUGGING) == 0)
12887         is_debug_grp = FALSE;
12888
12889       if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
12890         is_special_grp = FALSE;
12891
12892       msec = elf_next_in_group (msec);
12893     }
12894   while (msec != ssec);
12895
12896   /* If this is a pure debug section group or pure special section group,
12897      keep all sections in this group.  */
12898   if (is_debug_grp || is_special_grp)
12899     {
12900       do
12901         {
12902           msec->gc_mark = 1;
12903           msec = elf_next_in_group (msec);
12904         }
12905       while (msec != ssec);
12906     }
12907 }
12908
12909 /* Keep debug and special sections.  */
12910
12911 bfd_boolean
12912 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12913                                  elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
12914 {
12915   bfd *ibfd;
12916
12917   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12918     {
12919       asection *isec;
12920       bfd_boolean some_kept;
12921       bfd_boolean debug_frag_seen;
12922       bfd_boolean has_kept_debug_info;
12923
12924       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12925         continue;
12926       isec = ibfd->sections;
12927       if (isec == NULL || isec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
12928         continue;
12929
12930       /* Ensure all linker created sections are kept,
12931          see if any other section is already marked,
12932          and note if we have any fragmented debug sections.  */
12933       debug_frag_seen = some_kept = has_kept_debug_info = FALSE;
12934       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12935         {
12936           if ((isec->flags & SEC_LINKER_CREATED) != 0)
12937             isec->gc_mark = 1;
12938           else if (isec->gc_mark
12939                    && (isec->flags & SEC_ALLOC) != 0
12940                    && elf_section_type (isec) != SHT_NOTE)
12941             some_kept = TRUE;
12942
12943           if (!debug_frag_seen
12944               && (isec->flags & SEC_DEBUGGING)
12945               && CONST_STRNEQ (isec->name, ".debug_line."))
12946             debug_frag_seen = TRUE;
12947         }
12948
12949       /* If no non-note alloc section in this file will be kept, then
12950          we can toss out the debug and special sections.  */
12951       if (!some_kept)
12952         continue;
12953
12954       /* Keep debug and special sections like .comment when they are
12955          not part of a group.  Also keep section groups that contain
12956          just debug sections or special sections.  */
12957       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12958         {
12959           if ((isec->flags & SEC_GROUP) != 0)
12960             _bfd_elf_gc_mark_debug_special_section_group (isec);
12961           else if (((isec->flags & SEC_DEBUGGING) != 0
12962                     || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
12963                    && elf_next_in_group (isec) == NULL)
12964             isec->gc_mark = 1;
12965           if (isec->gc_mark && (isec->flags & SEC_DEBUGGING) != 0)
12966             has_kept_debug_info = TRUE;
12967         }
12968
12969       /* Look for CODE sections which are going to be discarded,
12970          and find and discard any fragmented debug sections which
12971          are associated with that code section.  */
12972       if (debug_frag_seen)
12973         for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12974           if ((isec->flags & SEC_CODE) != 0
12975               && isec->gc_mark == 0)
12976             {
12977               unsigned int ilen;
12978               asection *dsec;
12979
12980               ilen = strlen (isec->name);
12981
12982               /* Association is determined by the name of the debug
12983                  section containing the name of the code section as
12984                  a suffix.  For example .debug_line.text.foo is a
12985                  debug section associated with .text.foo.  */
12986               for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
12987                 {
12988                   unsigned int dlen;
12989
12990                   if (dsec->gc_mark == 0
12991                       || (dsec->flags & SEC_DEBUGGING) == 0)
12992                     continue;
12993
12994                   dlen = strlen (dsec->name);
12995
12996                   if (dlen > ilen
12997                       && strncmp (dsec->name + (dlen - ilen),
12998                                   isec->name, ilen) == 0)
12999                     dsec->gc_mark = 0;
13000                 }
13001           }
13002
13003       /* Mark debug sections referenced by kept debug sections.  */
13004       if (has_kept_debug_info)
13005         for (isec = ibfd->sections; isec != NULL; isec = isec->next)
13006           if (isec->gc_mark
13007               && (isec->flags & SEC_DEBUGGING) != 0)
13008             if (!_bfd_elf_gc_mark (info, isec,
13009                                    elf_gc_mark_debug_section))
13010               return FALSE;
13011     }
13012   return TRUE;
13013 }
13014
13015 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
13016
13017 typedef bfd_boolean (*gc_sweep_hook_fn)
13018   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
13019
13020 static bfd_boolean
13021 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
13022 {
13023   bfd *sub;
13024   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13025   gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
13026
13027   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
13028     {
13029       asection *o;
13030
13031       if (bfd_get_flavour (sub) != bfd_target_elf_flavour
13032           || !(*bed->relocs_compatible) (sub->xvec, abfd->xvec))
13033         continue;
13034       o = sub->sections;
13035       if (o == NULL || o->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
13036         continue;
13037
13038       for (o = sub->sections; o != NULL; o = o->next)
13039         {
13040           /* When any section in a section group is kept, we keep all
13041              sections in the section group.  If the first member of
13042              the section group is excluded, we will also exclude the
13043              group section.  */
13044           if (o->flags & SEC_GROUP)
13045             {
13046               asection *first = elf_next_in_group (o);
13047               o->gc_mark = first->gc_mark;
13048             }
13049
13050           if (o->gc_mark)
13051             continue;
13052
13053           /* Skip sweeping sections already excluded.  */
13054           if (o->flags & SEC_EXCLUDE)
13055             continue;
13056
13057           /* Since this is early in the link process, it is simple
13058              to remove a section from the output.  */
13059           o->flags |= SEC_EXCLUDE;
13060
13061           if (info->print_gc_sections && o->size != 0)
13062             /* xgettext:c-format */
13063             _bfd_error_handler (_("Removing unused section '%A' in file '%B'"),
13064                                 o, sub);
13065
13066           /* But we also have to update some of the relocation
13067              info we collected before.  */
13068           if (gc_sweep_hook
13069               && (o->flags & SEC_RELOC) != 0
13070               && o->reloc_count != 0
13071               && !((info->strip == strip_all || info->strip == strip_debugger)
13072                    && (o->flags & SEC_DEBUGGING) != 0)
13073               && !bfd_is_abs_section (o->output_section))
13074             {
13075               Elf_Internal_Rela *internal_relocs;
13076               bfd_boolean r;
13077
13078               internal_relocs
13079                 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
13080                                              info->keep_memory);
13081               if (internal_relocs == NULL)
13082                 return FALSE;
13083
13084               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
13085
13086               if (elf_section_data (o)->relocs != internal_relocs)
13087                 free (internal_relocs);
13088
13089               if (!r)
13090                 return FALSE;
13091             }
13092         }
13093     }
13094
13095   return TRUE;
13096 }
13097
13098 /* Propagate collected vtable information.  This is called through
13099    elf_link_hash_traverse.  */
13100
13101 static bfd_boolean
13102 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
13103 {
13104   /* Those that are not vtables.  */
13105   if (h->start_stop
13106       || h->u2.vtable == NULL
13107       || h->u2.vtable->parent == NULL)
13108     return TRUE;
13109
13110   /* Those vtables that do not have parents, we cannot merge.  */
13111   if (h->u2.vtable->parent == (struct elf_link_hash_entry *) -1)
13112     return TRUE;
13113
13114   /* If we've already been done, exit.  */
13115   if (h->u2.vtable->used && h->u2.vtable->used[-1])
13116     return TRUE;
13117
13118   /* Make sure the parent's table is up to date.  */
13119   elf_gc_propagate_vtable_entries_used (h->u2.vtable->parent, okp);
13120
13121   if (h->u2.vtable->used == NULL)
13122     {
13123       /* None of this table's entries were referenced.  Re-use the
13124          parent's table.  */
13125       h->u2.vtable->used = h->u2.vtable->parent->u2.vtable->used;
13126       h->u2.vtable->size = h->u2.vtable->parent->u2.vtable->size;
13127     }
13128   else
13129     {
13130       size_t n;
13131       bfd_boolean *cu, *pu;
13132
13133       /* Or the parent's entries into ours.  */
13134       cu = h->u2.vtable->used;
13135       cu[-1] = TRUE;
13136       pu = h->u2.vtable->parent->u2.vtable->used;
13137       if (pu != NULL)
13138         {
13139           const struct elf_backend_data *bed;
13140           unsigned int log_file_align;
13141
13142           bed = get_elf_backend_data (h->root.u.def.section->owner);
13143           log_file_align = bed->s->log_file_align;
13144           n = h->u2.vtable->parent->u2.vtable->size >> log_file_align;
13145           while (n--)
13146             {
13147               if (*pu)
13148                 *cu = TRUE;
13149               pu++;
13150               cu++;
13151             }
13152         }
13153     }
13154
13155   return TRUE;
13156 }
13157
13158 static bfd_boolean
13159 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
13160 {
13161   asection *sec;
13162   bfd_vma hstart, hend;
13163   Elf_Internal_Rela *relstart, *relend, *rel;
13164   const struct elf_backend_data *bed;
13165   unsigned int log_file_align;
13166
13167   /* Take care of both those symbols that do not describe vtables as
13168      well as those that are not loaded.  */
13169   if (h->start_stop
13170       || h->u2.vtable == NULL
13171       || h->u2.vtable->parent == NULL)
13172     return TRUE;
13173
13174   BFD_ASSERT (h->root.type == bfd_link_hash_defined
13175               || h->root.type == bfd_link_hash_defweak);
13176
13177   sec = h->root.u.def.section;
13178   hstart = h->root.u.def.value;
13179   hend = hstart + h->size;
13180
13181   relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
13182   if (!relstart)
13183     return *(bfd_boolean *) okp = FALSE;
13184   bed = get_elf_backend_data (sec->owner);
13185   log_file_align = bed->s->log_file_align;
13186
13187   relend = relstart + sec->reloc_count;
13188
13189   for (rel = relstart; rel < relend; ++rel)
13190     if (rel->r_offset >= hstart && rel->r_offset < hend)
13191       {
13192         /* If the entry is in use, do nothing.  */
13193         if (h->u2.vtable->used
13194             && (rel->r_offset - hstart) < h->u2.vtable->size)
13195           {
13196             bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
13197             if (h->u2.vtable->used[entry])
13198               continue;
13199           }
13200         /* Otherwise, kill it.  */
13201         rel->r_offset = rel->r_info = rel->r_addend = 0;
13202       }
13203
13204   return TRUE;
13205 }
13206
13207 /* Mark sections containing dynamically referenced symbols.  When
13208    building shared libraries, we must assume that any visible symbol is
13209    referenced.  */
13210
13211 bfd_boolean
13212 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
13213 {
13214   struct bfd_link_info *info = (struct bfd_link_info *) inf;
13215   struct bfd_elf_dynamic_list *d = info->dynamic_list;
13216
13217   if ((h->root.type == bfd_link_hash_defined
13218        || h->root.type == bfd_link_hash_defweak)
13219       && (h->ref_dynamic
13220           || ((h->def_regular || ELF_COMMON_DEF_P (h))
13221               && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
13222               && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
13223               && (!bfd_link_executable (info)
13224                   || info->gc_keep_exported
13225                   || info->export_dynamic
13226                   || (h->dynamic
13227                       && d != NULL
13228                       && (*d->match) (&d->head, NULL, h->root.root.string)))
13229               && (h->versioned >= versioned
13230                   || !bfd_hide_sym_by_version (info->version_info,
13231                                                h->root.root.string)))))
13232     h->root.u.def.section->flags |= SEC_KEEP;
13233
13234   return TRUE;
13235 }
13236
13237 /* Keep all sections containing symbols undefined on the command-line,
13238    and the section containing the entry symbol.  */
13239
13240 void
13241 _bfd_elf_gc_keep (struct bfd_link_info *info)
13242 {
13243   struct bfd_sym_chain *sym;
13244
13245   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
13246     {
13247       struct elf_link_hash_entry *h;
13248
13249       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
13250                                 FALSE, FALSE, FALSE);
13251
13252       if (h != NULL
13253           && (h->root.type == bfd_link_hash_defined
13254               || h->root.type == bfd_link_hash_defweak)
13255           && !bfd_is_abs_section (h->root.u.def.section)
13256           && !bfd_is_und_section (h->root.u.def.section))
13257         h->root.u.def.section->flags |= SEC_KEEP;
13258     }
13259 }
13260
13261 bfd_boolean
13262 bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED,
13263                                 struct bfd_link_info *info)
13264 {
13265   bfd *ibfd = info->input_bfds;
13266
13267   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13268     {
13269       asection *sec;
13270       struct elf_reloc_cookie cookie;
13271
13272       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
13273         continue;
13274       sec = ibfd->sections;
13275       if (sec == NULL || sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
13276         continue;
13277
13278       if (!init_reloc_cookie (&cookie, info, ibfd))
13279         return FALSE;
13280
13281       for (sec = ibfd->sections; sec; sec = sec->next)
13282         {
13283           if (CONST_STRNEQ (bfd_section_name (ibfd, sec), ".eh_frame_entry")
13284               && init_reloc_cookie_rels (&cookie, info, ibfd, sec))
13285             {
13286               _bfd_elf_parse_eh_frame_entry (info, sec, &cookie);
13287               fini_reloc_cookie_rels (&cookie, sec);
13288             }
13289         }
13290     }
13291   return TRUE;
13292 }
13293
13294 /* Do mark and sweep of unused sections.  */
13295
13296 bfd_boolean
13297 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
13298 {
13299   bfd_boolean ok = TRUE;
13300   bfd *sub;
13301   elf_gc_mark_hook_fn gc_mark_hook;
13302   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13303   struct elf_link_hash_table *htab;
13304
13305   if (!bed->can_gc_sections
13306       || !is_elf_hash_table (info->hash))
13307     {
13308       _bfd_error_handler(_("Warning: gc-sections option ignored"));
13309       return TRUE;
13310     }
13311
13312   bed->gc_keep (info);
13313   htab = elf_hash_table (info);
13314
13315   /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
13316      at the .eh_frame section if we can mark the FDEs individually.  */
13317   for (sub = info->input_bfds;
13318        info->eh_frame_hdr_type != COMPACT_EH_HDR && sub != NULL;
13319        sub = sub->link.next)
13320     {
13321       asection *sec;
13322       struct elf_reloc_cookie cookie;
13323
13324       sec = sub->sections;
13325       if (sec == NULL || sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
13326         continue;
13327       sec = bfd_get_section_by_name (sub, ".eh_frame");
13328       while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
13329         {
13330           _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
13331           if (elf_section_data (sec)->sec_info
13332               && (sec->flags & SEC_LINKER_CREATED) == 0)
13333             elf_eh_frame_section (sub) = sec;
13334           fini_reloc_cookie_for_section (&cookie, sec);
13335           sec = bfd_get_next_section_by_name (NULL, sec);
13336         }
13337     }
13338
13339   /* Apply transitive closure to the vtable entry usage info.  */
13340   elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
13341   if (!ok)
13342     return FALSE;
13343
13344   /* Kill the vtable relocations that were not used.  */
13345   elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
13346   if (!ok)
13347     return FALSE;
13348
13349   /* Mark dynamically referenced symbols.  */
13350   if (htab->dynamic_sections_created || info->gc_keep_exported)
13351     elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info);
13352
13353   /* Grovel through relocs to find out who stays ...  */
13354   gc_mark_hook = bed->gc_mark_hook;
13355   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
13356     {
13357       asection *o;
13358
13359       if (bfd_get_flavour (sub) != bfd_target_elf_flavour
13360           || !(*bed->relocs_compatible) (sub->xvec, abfd->xvec))
13361         continue;
13362
13363       o = sub->sections;
13364       if (o == NULL || o->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
13365         continue;
13366
13367       /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
13368          Also treat note sections as a root, if the section is not part
13369          of a group.  */
13370       for (o = sub->sections; o != NULL; o = o->next)
13371         if (!o->gc_mark
13372             && (o->flags & SEC_EXCLUDE) == 0
13373             && ((o->flags & SEC_KEEP) != 0
13374                 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
13375                     && elf_next_in_group (o) == NULL )))
13376           {
13377             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
13378               return FALSE;
13379           }
13380     }
13381
13382   /* Allow the backend to mark additional target specific sections.  */
13383   bed->gc_mark_extra_sections (info, gc_mark_hook);
13384
13385   /* ... and mark SEC_EXCLUDE for those that go.  */
13386   return elf_gc_sweep (abfd, info);
13387 }
13388 \f
13389 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
13390
13391 bfd_boolean
13392 bfd_elf_gc_record_vtinherit (bfd *abfd,
13393                              asection *sec,
13394                              struct elf_link_hash_entry *h,
13395                              bfd_vma offset)
13396 {
13397   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
13398   struct elf_link_hash_entry **search, *child;
13399   size_t extsymcount;
13400   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13401
13402   /* The sh_info field of the symtab header tells us where the
13403      external symbols start.  We don't care about the local symbols at
13404      this point.  */
13405   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
13406   if (!elf_bad_symtab (abfd))
13407     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
13408
13409   sym_hashes = elf_sym_hashes (abfd);
13410   sym_hashes_end = sym_hashes + extsymcount;
13411
13412   /* Hunt down the child symbol, which is in this section at the same
13413      offset as the relocation.  */
13414   for (search = sym_hashes; search != sym_hashes_end; ++search)
13415     {
13416       if ((child = *search) != NULL
13417           && (child->root.type == bfd_link_hash_defined
13418               || child->root.type == bfd_link_hash_defweak)
13419           && child->root.u.def.section == sec
13420           && child->root.u.def.value == offset)
13421         goto win;
13422     }
13423
13424   /* xgettext:c-format */
13425   _bfd_error_handler (_("%B: %A+%#Lx: No symbol found for INHERIT"),
13426                       abfd, sec, offset);
13427   bfd_set_error (bfd_error_invalid_operation);
13428   return FALSE;
13429
13430  win:
13431   if (!child->u2.vtable)
13432     {
13433       child->u2.vtable = ((struct elf_link_virtual_table_entry *)
13434                           bfd_zalloc (abfd, sizeof (*child->u2.vtable)));
13435       if (!child->u2.vtable)
13436         return FALSE;
13437     }
13438   if (!h)
13439     {
13440       /* This *should* only be the absolute section.  It could potentially
13441          be that someone has defined a non-global vtable though, which
13442          would be bad.  It isn't worth paging in the local symbols to be
13443          sure though; that case should simply be handled by the assembler.  */
13444
13445       child->u2.vtable->parent = (struct elf_link_hash_entry *) -1;
13446     }
13447   else
13448     child->u2.vtable->parent = h;
13449
13450   return TRUE;
13451 }
13452
13453 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
13454
13455 bfd_boolean
13456 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
13457                            asection *sec ATTRIBUTE_UNUSED,
13458                            struct elf_link_hash_entry *h,
13459                            bfd_vma addend)
13460 {
13461   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13462   unsigned int log_file_align = bed->s->log_file_align;
13463
13464   if (!h->u2.vtable)
13465     {
13466       h->u2.vtable = ((struct elf_link_virtual_table_entry *)
13467                       bfd_zalloc (abfd, sizeof (*h->u2.vtable)));
13468       if (!h->u2.vtable)
13469         return FALSE;
13470     }
13471
13472   if (addend >= h->u2.vtable->size)
13473     {
13474       size_t size, bytes, file_align;
13475       bfd_boolean *ptr = h->u2.vtable->used;
13476
13477       /* While the symbol is undefined, we have to be prepared to handle
13478          a zero size.  */
13479       file_align = 1 << log_file_align;
13480       if (h->root.type == bfd_link_hash_undefined)
13481         size = addend + file_align;
13482       else
13483         {
13484           size = h->size;
13485           if (addend >= size)
13486             {
13487               /* Oops!  We've got a reference past the defined end of
13488                  the table.  This is probably a bug -- shall we warn?  */
13489               size = addend + file_align;
13490             }
13491         }
13492       size = (size + file_align - 1) & -file_align;
13493
13494       /* Allocate one extra entry for use as a "done" flag for the
13495          consolidation pass.  */
13496       bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
13497
13498       if (ptr)
13499         {
13500           ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
13501
13502           if (ptr != NULL)
13503             {
13504               size_t oldbytes;
13505
13506               oldbytes = (((h->u2.vtable->size >> log_file_align) + 1)
13507                           * sizeof (bfd_boolean));
13508               memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
13509             }
13510         }
13511       else
13512         ptr = (bfd_boolean *) bfd_zmalloc (bytes);
13513
13514       if (ptr == NULL)
13515         return FALSE;
13516
13517       /* And arrange for that done flag to be at index -1.  */
13518       h->u2.vtable->used = ptr + 1;
13519       h->u2.vtable->size = size;
13520     }
13521
13522   h->u2.vtable->used[addend >> log_file_align] = TRUE;
13523
13524   return TRUE;
13525 }
13526
13527 /* Map an ELF section header flag to its corresponding string.  */
13528 typedef struct
13529 {
13530   char *flag_name;
13531   flagword flag_value;
13532 } elf_flags_to_name_table;
13533
13534 static elf_flags_to_name_table elf_flags_to_names [] =
13535 {
13536   { "SHF_WRITE", SHF_WRITE },
13537   { "SHF_ALLOC", SHF_ALLOC },
13538   { "SHF_EXECINSTR", SHF_EXECINSTR },
13539   { "SHF_MERGE", SHF_MERGE },
13540   { "SHF_STRINGS", SHF_STRINGS },
13541   { "SHF_INFO_LINK", SHF_INFO_LINK},
13542   { "SHF_LINK_ORDER", SHF_LINK_ORDER},
13543   { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
13544   { "SHF_GROUP", SHF_GROUP },
13545   { "SHF_TLS", SHF_TLS },
13546   { "SHF_MASKOS", SHF_MASKOS },
13547   { "SHF_EXCLUDE", SHF_EXCLUDE },
13548 };
13549
13550 /* Returns TRUE if the section is to be included, otherwise FALSE.  */
13551 bfd_boolean
13552 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
13553                               struct flag_info *flaginfo,
13554                               asection *section)
13555 {
13556   const bfd_vma sh_flags = elf_section_flags (section);
13557
13558   if (!flaginfo->flags_initialized)
13559     {
13560       bfd *obfd = info->output_bfd;
13561       const struct elf_backend_data *bed = get_elf_backend_data (obfd);
13562       struct flag_info_list *tf = flaginfo->flag_list;
13563       int with_hex = 0;
13564       int without_hex = 0;
13565
13566       for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
13567         {
13568           unsigned i;
13569           flagword (*lookup) (char *);
13570
13571           lookup = bed->elf_backend_lookup_section_flags_hook;
13572           if (lookup != NULL)
13573             {
13574               flagword hexval = (*lookup) ((char *) tf->name);
13575
13576               if (hexval != 0)
13577                 {
13578                   if (tf->with == with_flags)
13579                     with_hex |= hexval;
13580                   else if (tf->with == without_flags)
13581                     without_hex |= hexval;
13582                   tf->valid = TRUE;
13583                   continue;
13584                 }
13585             }
13586           for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
13587             {
13588               if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
13589                 {
13590                   if (tf->with == with_flags)
13591                     with_hex |= elf_flags_to_names[i].flag_value;
13592                   else if (tf->with == without_flags)
13593                     without_hex |= elf_flags_to_names[i].flag_value;
13594                   tf->valid = TRUE;
13595                   break;
13596                 }
13597             }
13598           if (!tf->valid)
13599             {
13600               info->callbacks->einfo
13601                 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
13602               return FALSE;
13603             }
13604         }
13605       flaginfo->flags_initialized = TRUE;
13606       flaginfo->only_with_flags |= with_hex;
13607       flaginfo->not_with_flags |= without_hex;
13608     }
13609
13610   if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
13611     return FALSE;
13612
13613   if ((flaginfo->not_with_flags & sh_flags) != 0)
13614     return FALSE;
13615
13616   return TRUE;
13617 }
13618
13619 struct alloc_got_off_arg {
13620   bfd_vma gotoff;
13621   struct bfd_link_info *info;
13622 };
13623
13624 /* We need a special top-level link routine to convert got reference counts
13625    to real got offsets.  */
13626
13627 static bfd_boolean
13628 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
13629 {
13630   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
13631   bfd *obfd = gofarg->info->output_bfd;
13632   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
13633
13634   if (h->got.refcount > 0)
13635     {
13636       h->got.offset = gofarg->gotoff;
13637       gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
13638     }
13639   else
13640     h->got.offset = (bfd_vma) -1;
13641
13642   return TRUE;
13643 }
13644
13645 /* And an accompanying bit to work out final got entry offsets once
13646    we're done.  Should be called from final_link.  */
13647
13648 bfd_boolean
13649 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
13650                                         struct bfd_link_info *info)
13651 {
13652   bfd *i;
13653   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13654   bfd_vma gotoff;
13655   struct alloc_got_off_arg gofarg;
13656
13657   BFD_ASSERT (abfd == info->output_bfd);
13658
13659   if (! is_elf_hash_table (info->hash))
13660     return FALSE;
13661
13662   /* The GOT offset is relative to the .got section, but the GOT header is
13663      put into the .got.plt section, if the backend uses it.  */
13664   if (bed->want_got_plt)
13665     gotoff = 0;
13666   else
13667     gotoff = bed->got_header_size;
13668
13669   /* Do the local .got entries first.  */
13670   for (i = info->input_bfds; i; i = i->link.next)
13671     {
13672       bfd_signed_vma *local_got;
13673       size_t j, locsymcount;
13674       Elf_Internal_Shdr *symtab_hdr;
13675
13676       if (bfd_get_flavour (i) != bfd_target_elf_flavour)
13677         continue;
13678
13679       local_got = elf_local_got_refcounts (i);
13680       if (!local_got)
13681         continue;
13682
13683       symtab_hdr = &elf_tdata (i)->symtab_hdr;
13684       if (elf_bad_symtab (i))
13685         locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
13686       else
13687         locsymcount = symtab_hdr->sh_info;
13688
13689       for (j = 0; j < locsymcount; ++j)
13690         {
13691           if (local_got[j] > 0)
13692             {
13693               local_got[j] = gotoff;
13694               gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
13695             }
13696           else
13697             local_got[j] = (bfd_vma) -1;
13698         }
13699     }
13700
13701   /* Then the global .got entries.  .plt refcounts are handled by
13702      adjust_dynamic_symbol  */
13703   gofarg.gotoff = gotoff;
13704   gofarg.info = info;
13705   elf_link_hash_traverse (elf_hash_table (info),
13706                           elf_gc_allocate_got_offsets,
13707                           &gofarg);
13708   return TRUE;
13709 }
13710
13711 /* Many folk need no more in the way of final link than this, once
13712    got entry reference counting is enabled.  */
13713
13714 bfd_boolean
13715 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
13716 {
13717   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
13718     return FALSE;
13719
13720   /* Invoke the regular ELF backend linker to do all the work.  */
13721   return bfd_elf_final_link (abfd, info);
13722 }
13723
13724 bfd_boolean
13725 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
13726 {
13727   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
13728
13729   if (rcookie->bad_symtab)
13730     rcookie->rel = rcookie->rels;
13731
13732   for (; rcookie->rel < rcookie->relend; rcookie->rel++)
13733     {
13734       unsigned long r_symndx;
13735
13736       if (! rcookie->bad_symtab)
13737         if (rcookie->rel->r_offset > offset)
13738           return FALSE;
13739       if (rcookie->rel->r_offset != offset)
13740         continue;
13741
13742       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
13743       if (r_symndx == STN_UNDEF)
13744         return TRUE;
13745
13746       if (r_symndx >= rcookie->locsymcount
13747           || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
13748         {
13749           struct elf_link_hash_entry *h;
13750
13751           h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
13752
13753           while (h->root.type == bfd_link_hash_indirect
13754                  || h->root.type == bfd_link_hash_warning)
13755             h = (struct elf_link_hash_entry *) h->root.u.i.link;
13756
13757           if ((h->root.type == bfd_link_hash_defined
13758                || h->root.type == bfd_link_hash_defweak)
13759               && (h->root.u.def.section->owner != rcookie->abfd
13760                   || h->root.u.def.section->kept_section != NULL
13761                   || discarded_section (h->root.u.def.section)))
13762             return TRUE;
13763         }
13764       else
13765         {
13766           /* It's not a relocation against a global symbol,
13767              but it could be a relocation against a local
13768              symbol for a discarded section.  */
13769           asection *isec;
13770           Elf_Internal_Sym *isym;
13771
13772           /* Need to: get the symbol; get the section.  */
13773           isym = &rcookie->locsyms[r_symndx];
13774           isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
13775           if (isec != NULL
13776               && (isec->kept_section != NULL
13777                   || discarded_section (isec)))
13778             return TRUE;
13779         }
13780       return FALSE;
13781     }
13782   return FALSE;
13783 }
13784
13785 /* Discard unneeded references to discarded sections.
13786    Returns -1 on error, 1 if any section's size was changed, 0 if
13787    nothing changed.  This function assumes that the relocations are in
13788    sorted order, which is true for all known assemblers.  */
13789
13790 int
13791 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
13792 {
13793   struct elf_reloc_cookie cookie;
13794   asection *o;
13795   bfd *abfd;
13796   int changed = 0;
13797
13798   if (info->traditional_format
13799       || !is_elf_hash_table (info->hash))
13800     return 0;
13801
13802   o = bfd_get_section_by_name (output_bfd, ".stab");
13803   if (o != NULL)
13804     {
13805       asection *i;
13806
13807       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13808         {
13809           if (i->size == 0
13810               || i->reloc_count == 0
13811               || i->sec_info_type != SEC_INFO_TYPE_STABS)
13812             continue;
13813
13814           abfd = i->owner;
13815           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
13816             continue;
13817
13818           if (!init_reloc_cookie_for_section (&cookie, info, i))
13819             return -1;
13820
13821           if (_bfd_discard_section_stabs (abfd, i,
13822                                           elf_section_data (i)->sec_info,
13823                                           bfd_elf_reloc_symbol_deleted_p,
13824                                           &cookie))
13825             changed = 1;
13826
13827           fini_reloc_cookie_for_section (&cookie, i);
13828         }
13829     }
13830
13831   o = NULL;
13832   if (info->eh_frame_hdr_type != COMPACT_EH_HDR)
13833     o = bfd_get_section_by_name (output_bfd, ".eh_frame");
13834   if (o != NULL)
13835     {
13836       asection *i;
13837       int eh_changed = 0;
13838
13839       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13840         {
13841           if (i->size == 0)
13842             continue;
13843
13844           abfd = i->owner;
13845           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
13846             continue;
13847
13848           if (!init_reloc_cookie_for_section (&cookie, info, i))
13849             return -1;
13850
13851           _bfd_elf_parse_eh_frame (abfd, info, i, &cookie);
13852           if (_bfd_elf_discard_section_eh_frame (abfd, info, i,
13853                                                  bfd_elf_reloc_symbol_deleted_p,
13854                                                  &cookie))
13855             {
13856               eh_changed = 1;
13857               if (i->size != i->rawsize)
13858                 changed = 1;
13859             }
13860
13861           fini_reloc_cookie_for_section (&cookie, i);
13862         }
13863       if (eh_changed)
13864         elf_link_hash_traverse (elf_hash_table (info),
13865                                 _bfd_elf_adjust_eh_frame_global_symbol, NULL);
13866     }
13867
13868   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
13869     {
13870       const struct elf_backend_data *bed;
13871       asection *s;
13872
13873       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
13874         continue;
13875       s = abfd->sections;
13876       if (s == NULL || s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
13877         continue;
13878
13879       bed = get_elf_backend_data (abfd);
13880
13881       if (bed->elf_backend_discard_info != NULL)
13882         {
13883           if (!init_reloc_cookie (&cookie, info, abfd))
13884             return -1;
13885
13886           if ((*bed->elf_backend_discard_info) (abfd, &cookie, info))
13887             changed = 1;
13888
13889           fini_reloc_cookie (&cookie, abfd);
13890         }
13891     }
13892
13893   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
13894     _bfd_elf_end_eh_frame_parsing (info);
13895
13896   if (info->eh_frame_hdr_type
13897       && !bfd_link_relocatable (info)
13898       && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
13899     changed = 1;
13900
13901   return changed;
13902 }
13903
13904 bfd_boolean
13905 _bfd_elf_section_already_linked (bfd *abfd,
13906                                  asection *sec,
13907                                  struct bfd_link_info *info)
13908 {
13909   flagword flags;
13910   const char *name, *key;
13911   struct bfd_section_already_linked *l;
13912   struct bfd_section_already_linked_hash_entry *already_linked_list;
13913
13914   if (sec->output_section == bfd_abs_section_ptr)
13915     return FALSE;
13916
13917   flags = sec->flags;
13918
13919   /* Return if it isn't a linkonce section.  A comdat group section
13920      also has SEC_LINK_ONCE set.  */
13921   if ((flags & SEC_LINK_ONCE) == 0)
13922     return FALSE;
13923
13924   /* Don't put group member sections on our list of already linked
13925      sections.  They are handled as a group via their group section.  */
13926   if (elf_sec_group (sec) != NULL)
13927     return FALSE;
13928
13929   /* For a SHT_GROUP section, use the group signature as the key.  */
13930   name = sec->name;
13931   if ((flags & SEC_GROUP) != 0
13932       && elf_next_in_group (sec) != NULL
13933       && elf_group_name (elf_next_in_group (sec)) != NULL)
13934     key = elf_group_name (elf_next_in_group (sec));
13935   else
13936     {
13937       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
13938       if (CONST_STRNEQ (name, ".gnu.linkonce.")
13939           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
13940         key++;
13941       else
13942         /* Must be a user linkonce section that doesn't follow gcc's
13943            naming convention.  In this case we won't be matching
13944            single member groups.  */
13945         key = name;
13946     }
13947
13948   already_linked_list = bfd_section_already_linked_table_lookup (key);
13949
13950   for (l = already_linked_list->entry; l != NULL; l = l->next)
13951     {
13952       /* We may have 2 different types of sections on the list: group
13953          sections with a signature of <key> (<key> is some string),
13954          and linkonce sections named .gnu.linkonce.<type>.<key>.
13955          Match like sections.  LTO plugin sections are an exception.
13956          They are always named .gnu.linkonce.t.<key> and match either
13957          type of section.  */
13958       if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
13959            && ((flags & SEC_GROUP) != 0
13960                || strcmp (name, l->sec->name) == 0))
13961           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
13962         {
13963           /* The section has already been linked.  See if we should
13964              issue a warning.  */
13965           if (!_bfd_handle_already_linked (sec, l, info))
13966             return FALSE;
13967
13968           if (flags & SEC_GROUP)
13969             {
13970               asection *first = elf_next_in_group (sec);
13971               asection *s = first;
13972
13973               while (s != NULL)
13974                 {
13975                   s->output_section = bfd_abs_section_ptr;
13976                   /* Record which group discards it.  */
13977                   s->kept_section = l->sec;
13978                   s = elf_next_in_group (s);
13979                   /* These lists are circular.  */
13980                   if (s == first)
13981                     break;
13982                 }
13983             }
13984
13985           return TRUE;
13986         }
13987     }
13988
13989   /* A single member comdat group section may be discarded by a
13990      linkonce section and vice versa.  */
13991   if ((flags & SEC_GROUP) != 0)
13992     {
13993       asection *first = elf_next_in_group (sec);
13994
13995       if (first != NULL && elf_next_in_group (first) == first)
13996         /* Check this single member group against linkonce sections.  */
13997         for (l = already_linked_list->entry; l != NULL; l = l->next)
13998           if ((l->sec->flags & SEC_GROUP) == 0
13999               && bfd_elf_match_symbols_in_sections (l->sec, first, info))
14000             {
14001               first->output_section = bfd_abs_section_ptr;
14002               first->kept_section = l->sec;
14003               sec->output_section = bfd_abs_section_ptr;
14004               break;
14005             }
14006     }
14007   else
14008     /* Check this linkonce section against single member groups.  */
14009     for (l = already_linked_list->entry; l != NULL; l = l->next)
14010       if (l->sec->flags & SEC_GROUP)
14011         {
14012           asection *first = elf_next_in_group (l->sec);
14013
14014           if (first != NULL
14015               && elf_next_in_group (first) == first
14016               && bfd_elf_match_symbols_in_sections (first, sec, info))
14017             {
14018               sec->output_section = bfd_abs_section_ptr;
14019               sec->kept_section = first;
14020               break;
14021             }
14022         }
14023
14024   /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
14025      referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
14026      specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
14027      prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
14028      matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
14029      but its `.gnu.linkonce.t.F' is discarded means we chose one-only
14030      `.gnu.linkonce.t.F' section from a different bfd not requiring any
14031      `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
14032      The reverse order cannot happen as there is never a bfd with only the
14033      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
14034      matter as here were are looking only for cross-bfd sections.  */
14035
14036   if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
14037     for (l = already_linked_list->entry; l != NULL; l = l->next)
14038       if ((l->sec->flags & SEC_GROUP) == 0
14039           && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
14040         {
14041           if (abfd != l->sec->owner)
14042             sec->output_section = bfd_abs_section_ptr;
14043           break;
14044         }
14045
14046   /* This is the first section with this name.  Record it.  */
14047   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
14048     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
14049   return sec->output_section == bfd_abs_section_ptr;
14050 }
14051
14052 bfd_boolean
14053 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
14054 {
14055   return sym->st_shndx == SHN_COMMON;
14056 }
14057
14058 unsigned int
14059 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
14060 {
14061   return SHN_COMMON;
14062 }
14063
14064 asection *
14065 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
14066 {
14067   return bfd_com_section_ptr;
14068 }
14069
14070 bfd_vma
14071 _bfd_elf_default_got_elt_size (bfd *abfd,
14072                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
14073                                struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
14074                                bfd *ibfd ATTRIBUTE_UNUSED,
14075                                unsigned long symndx ATTRIBUTE_UNUSED)
14076 {
14077   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14078   return bed->s->arch_size / 8;
14079 }
14080
14081 /* Routines to support the creation of dynamic relocs.  */
14082
14083 /* Returns the name of the dynamic reloc section associated with SEC.  */
14084
14085 static const char *
14086 get_dynamic_reloc_section_name (bfd *       abfd,
14087                                 asection *  sec,
14088                                 bfd_boolean is_rela)
14089 {
14090   char *name;
14091   const char *old_name = bfd_get_section_name (NULL, sec);
14092   const char *prefix = is_rela ? ".rela" : ".rel";
14093
14094   if (old_name == NULL)
14095     return NULL;
14096
14097   name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
14098   sprintf (name, "%s%s", prefix, old_name);
14099
14100   return name;
14101 }
14102
14103 /* Returns the dynamic reloc section associated with SEC.
14104    If necessary compute the name of the dynamic reloc section based
14105    on SEC's name (looked up in ABFD's string table) and the setting
14106    of IS_RELA.  */
14107
14108 asection *
14109 _bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
14110                                     asection *  sec,
14111                                     bfd_boolean is_rela)
14112 {
14113   asection * reloc_sec = elf_section_data (sec)->sreloc;
14114
14115   if (reloc_sec == NULL)
14116     {
14117       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
14118
14119       if (name != NULL)
14120         {
14121           reloc_sec = bfd_get_linker_section (abfd, name);
14122
14123           if (reloc_sec != NULL)
14124             elf_section_data (sec)->sreloc = reloc_sec;
14125         }
14126     }
14127
14128   return reloc_sec;
14129 }
14130
14131 /* Returns the dynamic reloc section associated with SEC.  If the
14132    section does not exist it is created and attached to the DYNOBJ
14133    bfd and stored in the SRELOC field of SEC's elf_section_data
14134    structure.
14135
14136    ALIGNMENT is the alignment for the newly created section and
14137    IS_RELA defines whether the name should be .rela.<SEC's name>
14138    or .rel.<SEC's name>.  The section name is looked up in the
14139    string table associated with ABFD.  */
14140
14141 asection *
14142 _bfd_elf_make_dynamic_reloc_section (asection *sec,
14143                                      bfd *dynobj,
14144                                      unsigned int alignment,
14145                                      bfd *abfd,
14146                                      bfd_boolean is_rela)
14147 {
14148   asection * reloc_sec = elf_section_data (sec)->sreloc;
14149
14150   if (reloc_sec == NULL)
14151     {
14152       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
14153
14154       if (name == NULL)
14155         return NULL;
14156
14157       reloc_sec = bfd_get_linker_section (dynobj, name);
14158
14159       if (reloc_sec == NULL)
14160         {
14161           flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
14162                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
14163           if ((sec->flags & SEC_ALLOC) != 0)
14164             flags |= SEC_ALLOC | SEC_LOAD;
14165
14166           reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
14167           if (reloc_sec != NULL)
14168             {
14169               /* _bfd_elf_get_sec_type_attr chooses a section type by
14170                  name.  Override as it may be wrong, eg. for a user
14171                  section named "auto" we'll get ".relauto" which is
14172                  seen to be a .rela section.  */
14173               elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
14174               if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
14175                 reloc_sec = NULL;
14176             }
14177         }
14178
14179       elf_section_data (sec)->sreloc = reloc_sec;
14180     }
14181
14182   return reloc_sec;
14183 }
14184
14185 /* Copy the ELF symbol type and other attributes for a linker script
14186    assignment from HSRC to HDEST.  Generally this should be treated as
14187    if we found a strong non-dynamic definition for HDEST (except that
14188    ld ignores multiple definition errors).  */
14189 void
14190 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
14191                                      struct bfd_link_hash_entry *hdest,
14192                                      struct bfd_link_hash_entry *hsrc)
14193 {
14194   struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest;
14195   struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc;
14196   Elf_Internal_Sym isym;
14197
14198   ehdest->type = ehsrc->type;
14199   ehdest->target_internal = ehsrc->target_internal;
14200
14201   isym.st_other = ehsrc->other;
14202   elf_merge_st_other (abfd, ehdest, &isym, NULL, TRUE, FALSE);
14203 }
14204
14205 /* Append a RELA relocation REL to section S in BFD.  */
14206
14207 void
14208 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
14209 {
14210   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14211   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
14212   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
14213   bed->s->swap_reloca_out (abfd, rel, loc);
14214 }
14215
14216 /* Append a REL relocation REL to section S in BFD.  */
14217
14218 void
14219 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
14220 {
14221   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14222   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
14223   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
14224   bed->s->swap_reloc_out (abfd, rel, loc);
14225 }
14226
14227 /* Define __start, __stop, .startof. or .sizeof. symbol.  */
14228
14229 struct bfd_link_hash_entry *
14230 bfd_elf_define_start_stop (struct bfd_link_info *info,
14231                            const char *symbol, asection *sec)
14232 {
14233   struct bfd_link_hash_entry *h;
14234
14235   h = bfd_generic_define_start_stop (info, symbol, sec);
14236   if (h != NULL)
14237     {
14238       struct elf_link_hash_entry *eh = (struct elf_link_hash_entry *) h;
14239       eh->start_stop = 1;
14240       eh->u2.start_stop_section = sec;
14241       _bfd_elf_link_hash_hide_symbol (info, eh, TRUE);
14242       if (ELF_ST_VISIBILITY (eh->other) != STV_INTERNAL)
14243         eh->other = ((eh->other & ~ELF_ST_VISIBILITY (-1))
14244                      | STV_HIDDEN);
14245     }
14246   return h;
14247 }