Fix copying Solaris binaries with objcopy.
[external/binutils.git] / bfd / elflink.c
1 /* ELF linking support for BFD.
2    Copyright (C) 1995-2016 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfd_stdint.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #define ARCH_SIZE 0
27 #include "elf-bfd.h"
28 #include "safe-ctype.h"
29 #include "libiberty.h"
30 #include "objalloc.h"
31
32 /* This struct is used to pass information to routines called via
33    elf_link_hash_traverse which must return failure.  */
34
35 struct elf_info_failed
36 {
37   struct bfd_link_info *info;
38   bfd_boolean failed;
39 };
40
41 /* This structure is used to pass information to
42    _bfd_elf_link_find_version_dependencies.  */
43
44 struct elf_find_verdep_info
45 {
46   /* General link information.  */
47   struct bfd_link_info *info;
48   /* The number of dependencies.  */
49   unsigned int vers;
50   /* Whether we had a failure.  */
51   bfd_boolean failed;
52 };
53
54 static bfd_boolean _bfd_elf_fix_symbol_flags
55   (struct elf_link_hash_entry *, struct elf_info_failed *);
56
57 asection *
58 _bfd_elf_section_for_symbol (struct elf_reloc_cookie *cookie,
59                              unsigned long r_symndx,
60                              bfd_boolean discard)
61 {
62   if (r_symndx >= cookie->locsymcount
63       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
64     {
65       struct elf_link_hash_entry *h;
66
67       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
68
69       while (h->root.type == bfd_link_hash_indirect
70              || h->root.type == bfd_link_hash_warning)
71         h = (struct elf_link_hash_entry *) h->root.u.i.link;
72
73       if ((h->root.type == bfd_link_hash_defined
74            || h->root.type == bfd_link_hash_defweak)
75            && discarded_section (h->root.u.def.section))
76         return h->root.u.def.section;
77       else
78         return NULL;
79     }
80   else
81     {
82       /* It's not a relocation against a global symbol,
83          but it could be a relocation against a local
84          symbol for a discarded section.  */
85       asection *isec;
86       Elf_Internal_Sym *isym;
87
88       /* Need to: get the symbol; get the section.  */
89       isym = &cookie->locsyms[r_symndx];
90       isec = bfd_section_from_elf_index (cookie->abfd, isym->st_shndx);
91       if (isec != NULL
92           && discard ? discarded_section (isec) : 1)
93         return isec;
94      }
95   return NULL;
96 }
97
98 /* Define a symbol in a dynamic linkage section.  */
99
100 struct elf_link_hash_entry *
101 _bfd_elf_define_linkage_sym (bfd *abfd,
102                              struct bfd_link_info *info,
103                              asection *sec,
104                              const char *name)
105 {
106   struct elf_link_hash_entry *h;
107   struct bfd_link_hash_entry *bh;
108   const struct elf_backend_data *bed;
109
110   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
111   if (h != NULL)
112     {
113       /* Zap symbol defined in an as-needed lib that wasn't linked.
114          This is a symptom of a larger problem:  Absolute symbols
115          defined in shared libraries can't be overridden, because we
116          lose the link to the bfd which is via the symbol section.  */
117       h->root.type = bfd_link_hash_new;
118     }
119
120   bh = &h->root;
121   bed = get_elf_backend_data (abfd);
122   if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
123                                          sec, 0, NULL, FALSE, bed->collect,
124                                          &bh))
125     return NULL;
126   h = (struct elf_link_hash_entry *) bh;
127   h->def_regular = 1;
128   h->non_elf = 0;
129   h->root.linker_def = 1;
130   h->type = STT_OBJECT;
131   if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
132     h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
133
134   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
135   return h;
136 }
137
138 bfd_boolean
139 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
140 {
141   flagword flags;
142   asection *s;
143   struct elf_link_hash_entry *h;
144   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
145   struct elf_link_hash_table *htab = elf_hash_table (info);
146
147   /* This function may be called more than once.  */
148   s = bfd_get_linker_section (abfd, ".got");
149   if (s != NULL)
150     return TRUE;
151
152   flags = bed->dynamic_sec_flags;
153
154   s = bfd_make_section_anyway_with_flags (abfd,
155                                           (bed->rela_plts_and_copies_p
156                                            ? ".rela.got" : ".rel.got"),
157                                           (bed->dynamic_sec_flags
158                                            | SEC_READONLY));
159   if (s == NULL
160       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
161     return FALSE;
162   htab->srelgot = s;
163
164   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
165   if (s == NULL
166       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
167     return FALSE;
168   htab->sgot = s;
169
170   if (bed->want_got_plt)
171     {
172       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
173       if (s == NULL
174           || !bfd_set_section_alignment (abfd, s,
175                                          bed->s->log_file_align))
176         return FALSE;
177       htab->sgotplt = s;
178     }
179
180   /* The first bit of the global offset table is the header.  */
181   s->size += bed->got_header_size;
182
183   if (bed->want_got_sym)
184     {
185       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
186          (or .got.plt) section.  We don't do this in the linker script
187          because we don't want to define the symbol if we are not creating
188          a global offset table.  */
189       h = _bfd_elf_define_linkage_sym (abfd, info, s,
190                                        "_GLOBAL_OFFSET_TABLE_");
191       elf_hash_table (info)->hgot = h;
192       if (h == NULL)
193         return FALSE;
194     }
195
196   return TRUE;
197 }
198 \f
199 /* Create a strtab to hold the dynamic symbol names.  */
200 static bfd_boolean
201 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
202 {
203   struct elf_link_hash_table *hash_table;
204
205   hash_table = elf_hash_table (info);
206   if (hash_table->dynobj == NULL)
207     hash_table->dynobj = abfd;
208
209   if (hash_table->dynstr == NULL)
210     {
211       hash_table->dynstr = _bfd_elf_strtab_init ();
212       if (hash_table->dynstr == NULL)
213         return FALSE;
214     }
215   return TRUE;
216 }
217
218 /* Create some sections which will be filled in with dynamic linking
219    information.  ABFD is an input file which requires dynamic sections
220    to be created.  The dynamic sections take up virtual memory space
221    when the final executable is run, so we need to create them before
222    addresses are assigned to the output sections.  We work out the
223    actual contents and size of these sections later.  */
224
225 bfd_boolean
226 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
227 {
228   flagword flags;
229   asection *s;
230   const struct elf_backend_data *bed;
231   struct elf_link_hash_entry *h;
232
233   if (! is_elf_hash_table (info->hash))
234     return FALSE;
235
236   if (elf_hash_table (info)->dynamic_sections_created)
237     return TRUE;
238
239   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
240     return FALSE;
241
242   abfd = elf_hash_table (info)->dynobj;
243   bed = get_elf_backend_data (abfd);
244
245   flags = bed->dynamic_sec_flags;
246
247   /* A dynamically linked executable has a .interp section, but a
248      shared library does not.  */
249   if (bfd_link_executable (info) && !info->nointerp)
250     {
251       s = bfd_make_section_anyway_with_flags (abfd, ".interp",
252                                               flags | SEC_READONLY);
253       if (s == NULL)
254         return FALSE;
255     }
256
257   /* Create sections to hold version informations.  These are removed
258      if they are not needed.  */
259   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
260                                           flags | SEC_READONLY);
261   if (s == NULL
262       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
263     return FALSE;
264
265   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
266                                           flags | SEC_READONLY);
267   if (s == NULL
268       || ! bfd_set_section_alignment (abfd, s, 1))
269     return FALSE;
270
271   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
272                                           flags | SEC_READONLY);
273   if (s == NULL
274       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
275     return FALSE;
276
277   s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
278                                           flags | SEC_READONLY);
279   if (s == NULL
280       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
281     return FALSE;
282   elf_hash_table (info)->dynsym = s;
283
284   s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
285                                           flags | SEC_READONLY);
286   if (s == NULL)
287     return FALSE;
288
289   s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
290   if (s == NULL
291       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
292     return FALSE;
293
294   /* The special symbol _DYNAMIC is always set to the start of the
295      .dynamic section.  We could set _DYNAMIC in a linker script, but we
296      only want to define it if we are, in fact, creating a .dynamic
297      section.  We don't want to define it if there is no .dynamic
298      section, since on some ELF platforms the start up code examines it
299      to decide how to initialize the process.  */
300   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
301   elf_hash_table (info)->hdynamic = h;
302   if (h == NULL)
303     return FALSE;
304
305   if (info->emit_hash)
306     {
307       s = bfd_make_section_anyway_with_flags (abfd, ".hash",
308                                               flags | SEC_READONLY);
309       if (s == NULL
310           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
311         return FALSE;
312       elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
313     }
314
315   if (info->emit_gnu_hash)
316     {
317       s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
318                                               flags | SEC_READONLY);
319       if (s == NULL
320           || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
321         return FALSE;
322       /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
323          4 32-bit words followed by variable count of 64-bit words, then
324          variable count of 32-bit words.  */
325       if (bed->s->arch_size == 64)
326         elf_section_data (s)->this_hdr.sh_entsize = 0;
327       else
328         elf_section_data (s)->this_hdr.sh_entsize = 4;
329     }
330
331   /* Let the backend create the rest of the sections.  This lets the
332      backend set the right flags.  The backend will normally create
333      the .got and .plt sections.  */
334   if (bed->elf_backend_create_dynamic_sections == NULL
335       || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
336     return FALSE;
337
338   elf_hash_table (info)->dynamic_sections_created = TRUE;
339
340   return TRUE;
341 }
342
343 /* Create dynamic sections when linking against a dynamic object.  */
344
345 bfd_boolean
346 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
347 {
348   flagword flags, pltflags;
349   struct elf_link_hash_entry *h;
350   asection *s;
351   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
352   struct elf_link_hash_table *htab = elf_hash_table (info);
353
354   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
355      .rel[a].bss sections.  */
356   flags = bed->dynamic_sec_flags;
357
358   pltflags = flags;
359   if (bed->plt_not_loaded)
360     /* We do not clear SEC_ALLOC here because we still want the OS to
361        allocate space for the section; it's just that there's nothing
362        to read in from the object file.  */
363     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
364   else
365     pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
366   if (bed->plt_readonly)
367     pltflags |= SEC_READONLY;
368
369   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
370   if (s == NULL
371       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
372     return FALSE;
373   htab->splt = s;
374
375   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
376      .plt section.  */
377   if (bed->want_plt_sym)
378     {
379       h = _bfd_elf_define_linkage_sym (abfd, info, s,
380                                        "_PROCEDURE_LINKAGE_TABLE_");
381       elf_hash_table (info)->hplt = h;
382       if (h == NULL)
383         return FALSE;
384     }
385
386   s = bfd_make_section_anyway_with_flags (abfd,
387                                           (bed->rela_plts_and_copies_p
388                                            ? ".rela.plt" : ".rel.plt"),
389                                           flags | SEC_READONLY);
390   if (s == NULL
391       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
392     return FALSE;
393   htab->srelplt = s;
394
395   if (! _bfd_elf_create_got_section (abfd, info))
396     return FALSE;
397
398   if (bed->want_dynbss)
399     {
400       /* The .dynbss section is a place to put symbols which are defined
401          by dynamic objects, are referenced by regular objects, and are
402          not functions.  We must allocate space for them in the process
403          image and use a R_*_COPY reloc to tell the dynamic linker to
404          initialize them at run time.  The linker script puts the .dynbss
405          section into the .bss section of the final image.  */
406       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
407                                               (SEC_ALLOC | SEC_LINKER_CREATED));
408       if (s == NULL)
409         return FALSE;
410
411       /* The .rel[a].bss section holds copy relocs.  This section is not
412          normally needed.  We need to create it here, though, so that the
413          linker will map it to an output section.  We can't just create it
414          only if we need it, because we will not know whether we need it
415          until we have seen all the input files, and the first time the
416          main linker code calls BFD after examining all the input files
417          (size_dynamic_sections) the input sections have already been
418          mapped to the output sections.  If the section turns out not to
419          be needed, we can discard it later.  We will never need this
420          section when generating a shared object, since they do not use
421          copy relocs.  */
422       if (! bfd_link_pic (info))
423         {
424           s = bfd_make_section_anyway_with_flags (abfd,
425                                                   (bed->rela_plts_and_copies_p
426                                                    ? ".rela.bss" : ".rel.bss"),
427                                                   flags | SEC_READONLY);
428           if (s == NULL
429               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
430             return FALSE;
431         }
432     }
433
434   return TRUE;
435 }
436 \f
437 /* Record a new dynamic symbol.  We record the dynamic symbols as we
438    read the input files, since we need to have a list of all of them
439    before we can determine the final sizes of the output sections.
440    Note that we may actually call this function even though we are not
441    going to output any dynamic symbols; in some cases we know that a
442    symbol should be in the dynamic symbol table, but only if there is
443    one.  */
444
445 bfd_boolean
446 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
447                                     struct elf_link_hash_entry *h)
448 {
449   if (h->dynindx == -1)
450     {
451       struct elf_strtab_hash *dynstr;
452       char *p;
453       const char *name;
454       bfd_size_type indx;
455
456       /* XXX: The ABI draft says the linker must turn hidden and
457          internal symbols into STB_LOCAL symbols when producing the
458          DSO. However, if ld.so honors st_other in the dynamic table,
459          this would not be necessary.  */
460       switch (ELF_ST_VISIBILITY (h->other))
461         {
462         case STV_INTERNAL:
463         case STV_HIDDEN:
464           if (h->root.type != bfd_link_hash_undefined
465               && h->root.type != bfd_link_hash_undefweak)
466             {
467               h->forced_local = 1;
468               if (!elf_hash_table (info)->is_relocatable_executable)
469                 return TRUE;
470             }
471
472         default:
473           break;
474         }
475
476       h->dynindx = elf_hash_table (info)->dynsymcount;
477       ++elf_hash_table (info)->dynsymcount;
478
479       dynstr = elf_hash_table (info)->dynstr;
480       if (dynstr == NULL)
481         {
482           /* Create a strtab to hold the dynamic symbol names.  */
483           elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
484           if (dynstr == NULL)
485             return FALSE;
486         }
487
488       /* We don't put any version information in the dynamic string
489          table.  */
490       name = h->root.root.string;
491       p = strchr (name, ELF_VER_CHR);
492       if (p != NULL)
493         /* We know that the p points into writable memory.  In fact,
494            there are only a few symbols that have read-only names, being
495            those like _GLOBAL_OFFSET_TABLE_ that are created specially
496            by the backends.  Most symbols will have names pointing into
497            an ELF string table read from a file, or to objalloc memory.  */
498         *p = 0;
499
500       indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
501
502       if (p != NULL)
503         *p = ELF_VER_CHR;
504
505       if (indx == (bfd_size_type) -1)
506         return FALSE;
507       h->dynstr_index = indx;
508     }
509
510   return TRUE;
511 }
512 \f
513 /* Mark a symbol dynamic.  */
514
515 static void
516 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
517                                   struct elf_link_hash_entry *h,
518                                   Elf_Internal_Sym *sym)
519 {
520   struct bfd_elf_dynamic_list *d = info->dynamic_list;
521
522   /* It may be called more than once on the same H.  */
523   if(h->dynamic || bfd_link_relocatable (info))
524     return;
525
526   if ((info->dynamic_data
527        && (h->type == STT_OBJECT
528            || h->type == STT_COMMON
529            || (sym != NULL
530                && (ELF_ST_TYPE (sym->st_info) == STT_OBJECT
531                    || ELF_ST_TYPE (sym->st_info) == STT_COMMON))))
532       || (d != NULL
533           && h->root.type == bfd_link_hash_new
534           && (*d->match) (&d->head, NULL, h->root.root.string)))
535     h->dynamic = 1;
536 }
537
538 /* Record an assignment to a symbol made by a linker script.  We need
539    this in case some dynamic object refers to this symbol.  */
540
541 bfd_boolean
542 bfd_elf_record_link_assignment (bfd *output_bfd,
543                                 struct bfd_link_info *info,
544                                 const char *name,
545                                 bfd_boolean provide,
546                                 bfd_boolean hidden)
547 {
548   struct elf_link_hash_entry *h, *hv;
549   struct elf_link_hash_table *htab;
550   const struct elf_backend_data *bed;
551
552   if (!is_elf_hash_table (info->hash))
553     return TRUE;
554
555   htab = elf_hash_table (info);
556   h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
557   if (h == NULL)
558     return provide;
559
560   if (h->versioned == unknown)
561     {
562       /* Set versioned if symbol version is unknown.  */
563       char *version = strrchr (name, ELF_VER_CHR);
564       if (version)
565         {
566           if (version > name && version[-1] != ELF_VER_CHR)
567             h->versioned = versioned_hidden;
568           else
569             h->versioned = versioned;
570         }
571     }
572
573   switch (h->root.type)
574     {
575     case bfd_link_hash_defined:
576     case bfd_link_hash_defweak:
577     case bfd_link_hash_common:
578       break;
579     case bfd_link_hash_undefweak:
580     case bfd_link_hash_undefined:
581       /* Since we're defining the symbol, don't let it seem to have not
582          been defined.  record_dynamic_symbol and size_dynamic_sections
583          may depend on this.  */
584       h->root.type = bfd_link_hash_new;
585       if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
586         bfd_link_repair_undef_list (&htab->root);
587       break;
588     case bfd_link_hash_new:
589       bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
590       h->non_elf = 0;
591       break;
592     case bfd_link_hash_indirect:
593       /* We had a versioned symbol in a dynamic library.  We make the
594          the versioned symbol point to this one.  */
595       bed = get_elf_backend_data (output_bfd);
596       hv = h;
597       while (hv->root.type == bfd_link_hash_indirect
598              || hv->root.type == bfd_link_hash_warning)
599         hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
600       /* We don't need to update h->root.u since linker will set them
601          later.  */
602       h->root.type = bfd_link_hash_undefined;
603       hv->root.type = bfd_link_hash_indirect;
604       hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
605       (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
606       break;
607     case bfd_link_hash_warning:
608       abort ();
609       break;
610     }
611
612   /* If this symbol is being provided by the linker script, and it is
613      currently defined by a dynamic object, but not by a regular
614      object, then mark it as undefined so that the generic linker will
615      force the correct value.  */
616   if (provide
617       && h->def_dynamic
618       && !h->def_regular)
619     h->root.type = bfd_link_hash_undefined;
620
621   /* If this symbol is not being provided by the linker script, and it is
622      currently defined by a dynamic object, but not by a regular object,
623      then clear out any version information because the symbol will not be
624      associated with the dynamic object any more.  */
625   if (!provide
626       && h->def_dynamic
627       && !h->def_regular)
628     h->verinfo.verdef = NULL;
629
630   h->def_regular = 1;
631
632   if (hidden)
633     {
634       bed = get_elf_backend_data (output_bfd);
635       if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
636         h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
637       (*bed->elf_backend_hide_symbol) (info, h, TRUE);
638     }
639
640   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
641      and executables.  */
642   if (!bfd_link_relocatable (info)
643       && h->dynindx != -1
644       && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
645           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
646     h->forced_local = 1;
647
648   if ((h->def_dynamic
649        || h->ref_dynamic
650        || bfd_link_dll (info)
651        || elf_hash_table (info)->is_relocatable_executable)
652       && h->dynindx == -1)
653     {
654       if (! bfd_elf_link_record_dynamic_symbol (info, h))
655         return FALSE;
656
657       /* If this is a weak defined symbol, and we know a corresponding
658          real symbol from the same dynamic object, make sure the real
659          symbol is also made into a dynamic symbol.  */
660       if (h->u.weakdef != NULL
661           && h->u.weakdef->dynindx == -1)
662         {
663           if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
664             return FALSE;
665         }
666     }
667
668   return TRUE;
669 }
670
671 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
672    success, and 2 on a failure caused by attempting to record a symbol
673    in a discarded section, eg. a discarded link-once section symbol.  */
674
675 int
676 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
677                                           bfd *input_bfd,
678                                           long input_indx)
679 {
680   bfd_size_type amt;
681   struct elf_link_local_dynamic_entry *entry;
682   struct elf_link_hash_table *eht;
683   struct elf_strtab_hash *dynstr;
684   unsigned long dynstr_index;
685   char *name;
686   Elf_External_Sym_Shndx eshndx;
687   char esym[sizeof (Elf64_External_Sym)];
688
689   if (! is_elf_hash_table (info->hash))
690     return 0;
691
692   /* See if the entry exists already.  */
693   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
694     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
695       return 1;
696
697   amt = sizeof (*entry);
698   entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
699   if (entry == NULL)
700     return 0;
701
702   /* Go find the symbol, so that we can find it's name.  */
703   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
704                              1, input_indx, &entry->isym, esym, &eshndx))
705     {
706       bfd_release (input_bfd, entry);
707       return 0;
708     }
709
710   if (entry->isym.st_shndx != SHN_UNDEF
711       && entry->isym.st_shndx < SHN_LORESERVE)
712     {
713       asection *s;
714
715       s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
716       if (s == NULL || bfd_is_abs_section (s->output_section))
717         {
718           /* We can still bfd_release here as nothing has done another
719              bfd_alloc.  We can't do this later in this function.  */
720           bfd_release (input_bfd, entry);
721           return 2;
722         }
723     }
724
725   name = (bfd_elf_string_from_elf_section
726           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
727            entry->isym.st_name));
728
729   dynstr = elf_hash_table (info)->dynstr;
730   if (dynstr == NULL)
731     {
732       /* Create a strtab to hold the dynamic symbol names.  */
733       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
734       if (dynstr == NULL)
735         return 0;
736     }
737
738   dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
739   if (dynstr_index == (unsigned long) -1)
740     return 0;
741   entry->isym.st_name = dynstr_index;
742
743   eht = elf_hash_table (info);
744
745   entry->next = eht->dynlocal;
746   eht->dynlocal = entry;
747   entry->input_bfd = input_bfd;
748   entry->input_indx = input_indx;
749   eht->dynsymcount++;
750
751   /* Whatever binding the symbol had before, it's now local.  */
752   entry->isym.st_info
753     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
754
755   /* The dynindx will be set at the end of size_dynamic_sections.  */
756
757   return 1;
758 }
759
760 /* Return the dynindex of a local dynamic symbol.  */
761
762 long
763 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
764                                     bfd *input_bfd,
765                                     long input_indx)
766 {
767   struct elf_link_local_dynamic_entry *e;
768
769   for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
770     if (e->input_bfd == input_bfd && e->input_indx == input_indx)
771       return e->dynindx;
772   return -1;
773 }
774
775 /* This function is used to renumber the dynamic symbols, if some of
776    them are removed because they are marked as local.  This is called
777    via elf_link_hash_traverse.  */
778
779 static bfd_boolean
780 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
781                                       void *data)
782 {
783   size_t *count = (size_t *) data;
784
785   if (h->forced_local)
786     return TRUE;
787
788   if (h->dynindx != -1)
789     h->dynindx = ++(*count);
790
791   return TRUE;
792 }
793
794
795 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
796    STB_LOCAL binding.  */
797
798 static bfd_boolean
799 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
800                                             void *data)
801 {
802   size_t *count = (size_t *) data;
803
804   if (!h->forced_local)
805     return TRUE;
806
807   if (h->dynindx != -1)
808     h->dynindx = ++(*count);
809
810   return TRUE;
811 }
812
813 /* Return true if the dynamic symbol for a given section should be
814    omitted when creating a shared library.  */
815 bfd_boolean
816 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
817                                    struct bfd_link_info *info,
818                                    asection *p)
819 {
820   struct elf_link_hash_table *htab;
821   asection *ip;
822
823   switch (elf_section_data (p)->this_hdr.sh_type)
824     {
825     case SHT_PROGBITS:
826     case SHT_NOBITS:
827       /* If sh_type is yet undecided, assume it could be
828          SHT_PROGBITS/SHT_NOBITS.  */
829     case SHT_NULL:
830       htab = elf_hash_table (info);
831       if (p == htab->tls_sec)
832         return FALSE;
833
834       if (htab->text_index_section != NULL)
835         return p != htab->text_index_section && p != htab->data_index_section;
836
837       return (htab->dynobj != NULL
838               && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
839               && ip->output_section == p);
840
841       /* There shouldn't be section relative relocations
842          against any other section.  */
843     default:
844       return TRUE;
845     }
846 }
847
848 /* Assign dynsym indices.  In a shared library we generate a section
849    symbol for each output section, which come first.  Next come symbols
850    which have been forced to local binding.  Then all of the back-end
851    allocated local dynamic syms, followed by the rest of the global
852    symbols.  */
853
854 static unsigned long
855 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
856                                 struct bfd_link_info *info,
857                                 unsigned long *section_sym_count)
858 {
859   unsigned long dynsymcount = 0;
860
861   if (bfd_link_pic (info)
862       || elf_hash_table (info)->is_relocatable_executable)
863     {
864       const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
865       asection *p;
866       for (p = output_bfd->sections; p ; p = p->next)
867         if ((p->flags & SEC_EXCLUDE) == 0
868             && (p->flags & SEC_ALLOC) != 0
869             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
870           elf_section_data (p)->dynindx = ++dynsymcount;
871         else
872           elf_section_data (p)->dynindx = 0;
873     }
874   *section_sym_count = dynsymcount;
875
876   elf_link_hash_traverse (elf_hash_table (info),
877                           elf_link_renumber_local_hash_table_dynsyms,
878                           &dynsymcount);
879
880   if (elf_hash_table (info)->dynlocal)
881     {
882       struct elf_link_local_dynamic_entry *p;
883       for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
884         p->dynindx = ++dynsymcount;
885     }
886
887   elf_link_hash_traverse (elf_hash_table (info),
888                           elf_link_renumber_hash_table_dynsyms,
889                           &dynsymcount);
890
891   /* There is an unused NULL entry at the head of the table which
892      we must account for in our count.  We always create the dynsym
893      section, even if it is empty, with dynamic sections.  */
894   if (elf_hash_table (info)->dynamic_sections_created)
895     ++dynsymcount;
896
897   elf_hash_table (info)->dynsymcount = dynsymcount;
898   return dynsymcount;
899 }
900
901 /* Merge st_other field.  */
902
903 static void
904 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
905                     const Elf_Internal_Sym *isym, asection *sec,
906                     bfd_boolean definition, bfd_boolean dynamic)
907 {
908   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
909
910   /* If st_other has a processor-specific meaning, specific
911      code might be needed here.  */
912   if (bed->elf_backend_merge_symbol_attribute)
913     (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
914                                                 dynamic);
915
916   if (!dynamic)
917     {
918       unsigned symvis = ELF_ST_VISIBILITY (isym->st_other);
919       unsigned hvis = ELF_ST_VISIBILITY (h->other);
920
921       /* Keep the most constraining visibility.  Leave the remainder
922          of the st_other field to elf_backend_merge_symbol_attribute.  */
923       if (symvis - 1 < hvis - 1)
924         h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
925     }
926   else if (definition
927            && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT
928            && (sec->flags & SEC_READONLY) == 0)
929     h->protected_def = 1;
930 }
931
932 /* This function is called when we want to merge a new symbol with an
933    existing symbol.  It handles the various cases which arise when we
934    find a definition in a dynamic object, or when there is already a
935    definition in a dynamic object.  The new symbol is described by
936    NAME, SYM, PSEC, and PVALUE.  We set SYM_HASH to the hash table
937    entry.  We set POLDBFD to the old symbol's BFD.  We set POLD_WEAK
938    if the old symbol was weak.  We set POLD_ALIGNMENT to the alignment
939    of an old common symbol.  We set OVERRIDE if the old symbol is
940    overriding a new definition.  We set TYPE_CHANGE_OK if it is OK for
941    the type to change.  We set SIZE_CHANGE_OK if it is OK for the size
942    to change.  By OK to change, we mean that we shouldn't warn if the
943    type or size does change.  */
944
945 static bfd_boolean
946 _bfd_elf_merge_symbol (bfd *abfd,
947                        struct bfd_link_info *info,
948                        const char *name,
949                        Elf_Internal_Sym *sym,
950                        asection **psec,
951                        bfd_vma *pvalue,
952                        struct elf_link_hash_entry **sym_hash,
953                        bfd **poldbfd,
954                        bfd_boolean *pold_weak,
955                        unsigned int *pold_alignment,
956                        bfd_boolean *skip,
957                        bfd_boolean *override,
958                        bfd_boolean *type_change_ok,
959                        bfd_boolean *size_change_ok,
960                        bfd_boolean *matched)
961 {
962   asection *sec, *oldsec;
963   struct elf_link_hash_entry *h;
964   struct elf_link_hash_entry *hi;
965   struct elf_link_hash_entry *flip;
966   int bind;
967   bfd *oldbfd;
968   bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
969   bfd_boolean newweak, oldweak, newfunc, oldfunc;
970   const struct elf_backend_data *bed;
971   char *new_version;
972
973   *skip = FALSE;
974   *override = FALSE;
975
976   sec = *psec;
977   bind = ELF_ST_BIND (sym->st_info);
978
979   if (! bfd_is_und_section (sec))
980     h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
981   else
982     h = ((struct elf_link_hash_entry *)
983          bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
984   if (h == NULL)
985     return FALSE;
986   *sym_hash = h;
987
988   bed = get_elf_backend_data (abfd);
989
990   /* NEW_VERSION is the symbol version of the new symbol.  */
991   if (h->versioned != unversioned)
992     {
993       /* Symbol version is unknown or versioned.  */
994       new_version = strrchr (name, ELF_VER_CHR);
995       if (new_version)
996         {
997           if (h->versioned == unknown)
998             {
999               if (new_version > name && new_version[-1] != ELF_VER_CHR)
1000                 h->versioned = versioned_hidden;
1001               else
1002                 h->versioned = versioned;
1003             }
1004           new_version += 1;
1005           if (new_version[0] == '\0')
1006             new_version = NULL;
1007         }
1008       else
1009         h->versioned = unversioned;
1010     }
1011   else
1012     new_version = NULL;
1013
1014   /* For merging, we only care about real symbols.  But we need to make
1015      sure that indirect symbol dynamic flags are updated.  */
1016   hi = h;
1017   while (h->root.type == bfd_link_hash_indirect
1018          || h->root.type == bfd_link_hash_warning)
1019     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1020
1021   if (!*matched)
1022     {
1023       if (hi == h || h->root.type == bfd_link_hash_new)
1024         *matched = TRUE;
1025       else
1026         {
1027           /* OLD_HIDDEN is true if the existing symbol is only visible
1028              to the symbol with the same symbol version.  NEW_HIDDEN is
1029              true if the new symbol is only visible to the symbol with
1030              the same symbol version.  */
1031           bfd_boolean old_hidden = h->versioned == versioned_hidden;
1032           bfd_boolean new_hidden = hi->versioned == versioned_hidden;
1033           if (!old_hidden && !new_hidden)
1034             /* The new symbol matches the existing symbol if both
1035                aren't hidden.  */
1036             *matched = TRUE;
1037           else
1038             {
1039               /* OLD_VERSION is the symbol version of the existing
1040                  symbol. */
1041               char *old_version;
1042
1043               if (h->versioned >= versioned)
1044                 old_version = strrchr (h->root.root.string,
1045                                        ELF_VER_CHR) + 1;
1046               else
1047                  old_version = NULL;
1048
1049               /* The new symbol matches the existing symbol if they
1050                  have the same symbol version.  */
1051               *matched = (old_version == new_version
1052                           || (old_version != NULL
1053                               && new_version != NULL
1054                               && strcmp (old_version, new_version) == 0));
1055             }
1056         }
1057     }
1058
1059   /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
1060      existing symbol.  */
1061
1062   oldbfd = NULL;
1063   oldsec = NULL;
1064   switch (h->root.type)
1065     {
1066     default:
1067       break;
1068
1069     case bfd_link_hash_undefined:
1070     case bfd_link_hash_undefweak:
1071       oldbfd = h->root.u.undef.abfd;
1072       break;
1073
1074     case bfd_link_hash_defined:
1075     case bfd_link_hash_defweak:
1076       oldbfd = h->root.u.def.section->owner;
1077       oldsec = h->root.u.def.section;
1078       break;
1079
1080     case bfd_link_hash_common:
1081       oldbfd = h->root.u.c.p->section->owner;
1082       oldsec = h->root.u.c.p->section;
1083       if (pold_alignment)
1084         *pold_alignment = h->root.u.c.p->alignment_power;
1085       break;
1086     }
1087   if (poldbfd && *poldbfd == NULL)
1088     *poldbfd = oldbfd;
1089
1090   /* Differentiate strong and weak symbols.  */
1091   newweak = bind == STB_WEAK;
1092   oldweak = (h->root.type == bfd_link_hash_defweak
1093              || h->root.type == bfd_link_hash_undefweak);
1094   if (pold_weak)
1095     *pold_weak = oldweak;
1096
1097   /* This code is for coping with dynamic objects, and is only useful
1098      if we are doing an ELF link.  */
1099   if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
1100     return TRUE;
1101
1102   /* We have to check it for every instance since the first few may be
1103      references and not all compilers emit symbol type for undefined
1104      symbols.  */
1105   bfd_elf_link_mark_dynamic_symbol (info, h, sym);
1106
1107   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1108      respectively, is from a dynamic object.  */
1109
1110   newdyn = (abfd->flags & DYNAMIC) != 0;
1111
1112   /* ref_dynamic_nonweak and dynamic_def flags track actual undefined
1113      syms and defined syms in dynamic libraries respectively.
1114      ref_dynamic on the other hand can be set for a symbol defined in
1115      a dynamic library, and def_dynamic may not be set;  When the
1116      definition in a dynamic lib is overridden by a definition in the
1117      executable use of the symbol in the dynamic lib becomes a
1118      reference to the executable symbol.  */
1119   if (newdyn)
1120     {
1121       if (bfd_is_und_section (sec))
1122         {
1123           if (bind != STB_WEAK)
1124             {
1125               h->ref_dynamic_nonweak = 1;
1126               hi->ref_dynamic_nonweak = 1;
1127             }
1128         }
1129       else
1130         {
1131           /* Update the existing symbol only if they match. */
1132           if (*matched)
1133             h->dynamic_def = 1;
1134           hi->dynamic_def = 1;
1135         }
1136     }
1137
1138   /* If we just created the symbol, mark it as being an ELF symbol.
1139      Other than that, there is nothing to do--there is no merge issue
1140      with a newly defined symbol--so we just return.  */
1141
1142   if (h->root.type == bfd_link_hash_new)
1143     {
1144       h->non_elf = 0;
1145       return TRUE;
1146     }
1147
1148   /* In cases involving weak versioned symbols, we may wind up trying
1149      to merge a symbol with itself.  Catch that here, to avoid the
1150      confusion that results if we try to override a symbol with
1151      itself.  The additional tests catch cases like
1152      _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1153      dynamic object, which we do want to handle here.  */
1154   if (abfd == oldbfd
1155       && (newweak || oldweak)
1156       && ((abfd->flags & DYNAMIC) == 0
1157           || !h->def_regular))
1158     return TRUE;
1159
1160   olddyn = FALSE;
1161   if (oldbfd != NULL)
1162     olddyn = (oldbfd->flags & DYNAMIC) != 0;
1163   else if (oldsec != NULL)
1164     {
1165       /* This handles the special SHN_MIPS_{TEXT,DATA} section
1166          indices used by MIPS ELF.  */
1167       olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1168     }
1169
1170   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1171      respectively, appear to be a definition rather than reference.  */
1172
1173   newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1174
1175   olddef = (h->root.type != bfd_link_hash_undefined
1176             && h->root.type != bfd_link_hash_undefweak
1177             && h->root.type != bfd_link_hash_common);
1178
1179   /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1180      respectively, appear to be a function.  */
1181
1182   newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1183              && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1184
1185   oldfunc = (h->type != STT_NOTYPE
1186              && bed->is_function_type (h->type));
1187
1188   /* When we try to create a default indirect symbol from the dynamic
1189      definition with the default version, we skip it if its type and
1190      the type of existing regular definition mismatch.  */
1191   if (pold_alignment == NULL
1192       && newdyn
1193       && newdef
1194       && !olddyn
1195       && (((olddef || h->root.type == bfd_link_hash_common)
1196            && ELF_ST_TYPE (sym->st_info) != h->type
1197            && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1198            && h->type != STT_NOTYPE
1199            && !(newfunc && oldfunc))
1200           || (olddef
1201               && ((h->type == STT_GNU_IFUNC)
1202                   != (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))))
1203     {
1204       *skip = TRUE;
1205       return TRUE;
1206     }
1207
1208   /* Check TLS symbols.  We don't check undefined symbols introduced
1209      by "ld -u" which have no type (and oldbfd NULL), and we don't
1210      check symbols from plugins because they also have no type.  */
1211   if (oldbfd != NULL
1212       && (oldbfd->flags & BFD_PLUGIN) == 0
1213       && (abfd->flags & BFD_PLUGIN) == 0
1214       && ELF_ST_TYPE (sym->st_info) != h->type
1215       && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1216     {
1217       bfd *ntbfd, *tbfd;
1218       bfd_boolean ntdef, tdef;
1219       asection *ntsec, *tsec;
1220
1221       if (h->type == STT_TLS)
1222         {
1223           ntbfd = abfd;
1224           ntsec = sec;
1225           ntdef = newdef;
1226           tbfd = oldbfd;
1227           tsec = oldsec;
1228           tdef = olddef;
1229         }
1230       else
1231         {
1232           ntbfd = oldbfd;
1233           ntsec = oldsec;
1234           ntdef = olddef;
1235           tbfd = abfd;
1236           tsec = sec;
1237           tdef = newdef;
1238         }
1239
1240       if (tdef && ntdef)
1241         (*_bfd_error_handler)
1242           (_("%s: TLS definition in %B section %A "
1243              "mismatches non-TLS definition in %B section %A"),
1244            tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1245       else if (!tdef && !ntdef)
1246         (*_bfd_error_handler)
1247           (_("%s: TLS reference in %B "
1248              "mismatches non-TLS reference in %B"),
1249            tbfd, ntbfd, h->root.root.string);
1250       else if (tdef)
1251         (*_bfd_error_handler)
1252           (_("%s: TLS definition in %B section %A "
1253              "mismatches non-TLS reference in %B"),
1254            tbfd, tsec, ntbfd, h->root.root.string);
1255       else
1256         (*_bfd_error_handler)
1257           (_("%s: TLS reference in %B "
1258              "mismatches non-TLS definition in %B section %A"),
1259            tbfd, ntbfd, ntsec, h->root.root.string);
1260
1261       bfd_set_error (bfd_error_bad_value);
1262       return FALSE;
1263     }
1264
1265   /* If the old symbol has non-default visibility, we ignore the new
1266      definition from a dynamic object.  */
1267   if (newdyn
1268       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1269       && !bfd_is_und_section (sec))
1270     {
1271       *skip = TRUE;
1272       /* Make sure this symbol is dynamic.  */
1273       h->ref_dynamic = 1;
1274       hi->ref_dynamic = 1;
1275       /* A protected symbol has external availability. Make sure it is
1276          recorded as dynamic.
1277
1278          FIXME: Should we check type and size for protected symbol?  */
1279       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1280         return bfd_elf_link_record_dynamic_symbol (info, h);
1281       else
1282         return TRUE;
1283     }
1284   else if (!newdyn
1285            && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1286            && h->def_dynamic)
1287     {
1288       /* If the new symbol with non-default visibility comes from a
1289          relocatable file and the old definition comes from a dynamic
1290          object, we remove the old definition.  */
1291       if (hi->root.type == bfd_link_hash_indirect)
1292         {
1293           /* Handle the case where the old dynamic definition is
1294              default versioned.  We need to copy the symbol info from
1295              the symbol with default version to the normal one if it
1296              was referenced before.  */
1297           if (h->ref_regular)
1298             {
1299               hi->root.type = h->root.type;
1300               h->root.type = bfd_link_hash_indirect;
1301               (*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
1302
1303               h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1304               if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1305                 {
1306                   /* If the new symbol is hidden or internal, completely undo
1307                      any dynamic link state.  */
1308                   (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1309                   h->forced_local = 0;
1310                   h->ref_dynamic = 0;
1311                 }
1312               else
1313                 h->ref_dynamic = 1;
1314
1315               h->def_dynamic = 0;
1316               /* FIXME: Should we check type and size for protected symbol?  */
1317               h->size = 0;
1318               h->type = 0;
1319
1320               h = hi;
1321             }
1322           else
1323             h = hi;
1324         }
1325
1326       /* If the old symbol was undefined before, then it will still be
1327          on the undefs list.  If the new symbol is undefined or
1328          common, we can't make it bfd_link_hash_new here, because new
1329          undefined or common symbols will be added to the undefs list
1330          by _bfd_generic_link_add_one_symbol.  Symbols may not be
1331          added twice to the undefs list.  Also, if the new symbol is
1332          undefweak then we don't want to lose the strong undef.  */
1333       if (h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1334         {
1335           h->root.type = bfd_link_hash_undefined;
1336           h->root.u.undef.abfd = abfd;
1337         }
1338       else
1339         {
1340           h->root.type = bfd_link_hash_new;
1341           h->root.u.undef.abfd = NULL;
1342         }
1343
1344       if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
1345         {
1346           /* If the new symbol is hidden or internal, completely undo
1347              any dynamic link state.  */
1348           (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1349           h->forced_local = 0;
1350           h->ref_dynamic = 0;
1351         }
1352       else
1353         h->ref_dynamic = 1;
1354       h->def_dynamic = 0;
1355       /* FIXME: Should we check type and size for protected symbol?  */
1356       h->size = 0;
1357       h->type = 0;
1358       return TRUE;
1359     }
1360
1361   /* If a new weak symbol definition comes from a regular file and the
1362      old symbol comes from a dynamic library, we treat the new one as
1363      strong.  Similarly, an old weak symbol definition from a regular
1364      file is treated as strong when the new symbol comes from a dynamic
1365      library.  Further, an old weak symbol from a dynamic library is
1366      treated as strong if the new symbol is from a dynamic library.
1367      This reflects the way glibc's ld.so works.
1368
1369      Do this before setting *type_change_ok or *size_change_ok so that
1370      we warn properly when dynamic library symbols are overridden.  */
1371
1372   if (newdef && !newdyn && olddyn)
1373     newweak = FALSE;
1374   if (olddef && newdyn)
1375     oldweak = FALSE;
1376
1377   /* Allow changes between different types of function symbol.  */
1378   if (newfunc && oldfunc)
1379     *type_change_ok = TRUE;
1380
1381   /* It's OK to change the type if either the existing symbol or the
1382      new symbol is weak.  A type change is also OK if the old symbol
1383      is undefined and the new symbol is defined.  */
1384
1385   if (oldweak
1386       || newweak
1387       || (newdef
1388           && h->root.type == bfd_link_hash_undefined))
1389     *type_change_ok = TRUE;
1390
1391   /* It's OK to change the size if either the existing symbol or the
1392      new symbol is weak, or if the old symbol is undefined.  */
1393
1394   if (*type_change_ok
1395       || h->root.type == bfd_link_hash_undefined)
1396     *size_change_ok = TRUE;
1397
1398   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1399      symbol, respectively, appears to be a common symbol in a dynamic
1400      object.  If a symbol appears in an uninitialized section, and is
1401      not weak, and is not a function, then it may be a common symbol
1402      which was resolved when the dynamic object was created.  We want
1403      to treat such symbols specially, because they raise special
1404      considerations when setting the symbol size: if the symbol
1405      appears as a common symbol in a regular object, and the size in
1406      the regular object is larger, we must make sure that we use the
1407      larger size.  This problematic case can always be avoided in C,
1408      but it must be handled correctly when using Fortran shared
1409      libraries.
1410
1411      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1412      likewise for OLDDYNCOMMON and OLDDEF.
1413
1414      Note that this test is just a heuristic, and that it is quite
1415      possible to have an uninitialized symbol in a shared object which
1416      is really a definition, rather than a common symbol.  This could
1417      lead to some minor confusion when the symbol really is a common
1418      symbol in some regular object.  However, I think it will be
1419      harmless.  */
1420
1421   if (newdyn
1422       && newdef
1423       && !newweak
1424       && (sec->flags & SEC_ALLOC) != 0
1425       && (sec->flags & SEC_LOAD) == 0
1426       && sym->st_size > 0
1427       && !newfunc)
1428     newdyncommon = TRUE;
1429   else
1430     newdyncommon = FALSE;
1431
1432   if (olddyn
1433       && olddef
1434       && h->root.type == bfd_link_hash_defined
1435       && h->def_dynamic
1436       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1437       && (h->root.u.def.section->flags & SEC_LOAD) == 0
1438       && h->size > 0
1439       && !oldfunc)
1440     olddyncommon = TRUE;
1441   else
1442     olddyncommon = FALSE;
1443
1444   /* We now know everything about the old and new symbols.  We ask the
1445      backend to check if we can merge them.  */
1446   if (bed->merge_symbol != NULL)
1447     {
1448       if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
1449         return FALSE;
1450       sec = *psec;
1451     }
1452
1453   /* If both the old and the new symbols look like common symbols in a
1454      dynamic object, set the size of the symbol to the larger of the
1455      two.  */
1456
1457   if (olddyncommon
1458       && newdyncommon
1459       && sym->st_size != h->size)
1460     {
1461       /* Since we think we have two common symbols, issue a multiple
1462          common warning if desired.  Note that we only warn if the
1463          size is different.  If the size is the same, we simply let
1464          the old symbol override the new one as normally happens with
1465          symbols defined in dynamic objects.  */
1466
1467       if (! ((*info->callbacks->multiple_common)
1468              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1469         return FALSE;
1470
1471       if (sym->st_size > h->size)
1472         h->size = sym->st_size;
1473
1474       *size_change_ok = TRUE;
1475     }
1476
1477   /* If we are looking at a dynamic object, and we have found a
1478      definition, we need to see if the symbol was already defined by
1479      some other object.  If so, we want to use the existing
1480      definition, and we do not want to report a multiple symbol
1481      definition error; we do this by clobbering *PSEC to be
1482      bfd_und_section_ptr.
1483
1484      We treat a common symbol as a definition if the symbol in the
1485      shared library is a function, since common symbols always
1486      represent variables; this can cause confusion in principle, but
1487      any such confusion would seem to indicate an erroneous program or
1488      shared library.  We also permit a common symbol in a regular
1489      object to override a weak symbol in a shared object.  A common
1490      symbol in executable also overrides a symbol in a shared object.  */
1491
1492   if (newdyn
1493       && newdef
1494       && (olddef
1495           || (h->root.type == bfd_link_hash_common
1496               && (newweak
1497                   || newfunc
1498                   || (!olddyn && bfd_link_executable (info))))))
1499     {
1500       *override = TRUE;
1501       newdef = FALSE;
1502       newdyncommon = FALSE;
1503
1504       *psec = sec = bfd_und_section_ptr;
1505       *size_change_ok = TRUE;
1506
1507       /* If we get here when the old symbol is a common symbol, then
1508          we are explicitly letting it override a weak symbol or
1509          function in a dynamic object, and we don't want to warn about
1510          a type change.  If the old symbol is a defined symbol, a type
1511          change warning may still be appropriate.  */
1512
1513       if (h->root.type == bfd_link_hash_common)
1514         *type_change_ok = TRUE;
1515     }
1516
1517   /* Handle the special case of an old common symbol merging with a
1518      new symbol which looks like a common symbol in a shared object.
1519      We change *PSEC and *PVALUE to make the new symbol look like a
1520      common symbol, and let _bfd_generic_link_add_one_symbol do the
1521      right thing.  */
1522
1523   if (newdyncommon
1524       && h->root.type == bfd_link_hash_common)
1525     {
1526       *override = TRUE;
1527       newdef = FALSE;
1528       newdyncommon = FALSE;
1529       *pvalue = sym->st_size;
1530       *psec = sec = bed->common_section (oldsec);
1531       *size_change_ok = TRUE;
1532     }
1533
1534   /* Skip weak definitions of symbols that are already defined.  */
1535   if (newdef && olddef && newweak)
1536     {
1537       /* Don't skip new non-IR weak syms.  */
1538       if (!(oldbfd != NULL
1539             && (oldbfd->flags & BFD_PLUGIN) != 0
1540             && (abfd->flags & BFD_PLUGIN) == 0))
1541         {
1542           newdef = FALSE;
1543           *skip = TRUE;
1544         }
1545
1546       /* Merge st_other.  If the symbol already has a dynamic index,
1547          but visibility says it should not be visible, turn it into a
1548          local symbol.  */
1549       elf_merge_st_other (abfd, h, sym, sec, newdef, newdyn);
1550       if (h->dynindx != -1)
1551         switch (ELF_ST_VISIBILITY (h->other))
1552           {
1553           case STV_INTERNAL:
1554           case STV_HIDDEN:
1555             (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1556             break;
1557           }
1558     }
1559
1560   /* If the old symbol is from a dynamic object, and the new symbol is
1561      a definition which is not from a dynamic object, then the new
1562      symbol overrides the old symbol.  Symbols from regular files
1563      always take precedence over symbols from dynamic objects, even if
1564      they are defined after the dynamic object in the link.
1565
1566      As above, we again permit a common symbol in a regular object to
1567      override a definition in a shared object if the shared object
1568      symbol is a function or is weak.  */
1569
1570   flip = NULL;
1571   if (!newdyn
1572       && (newdef
1573           || (bfd_is_com_section (sec)
1574               && (oldweak || oldfunc)))
1575       && olddyn
1576       && olddef
1577       && h->def_dynamic)
1578     {
1579       /* Change the hash table entry to undefined, and let
1580          _bfd_generic_link_add_one_symbol do the right thing with the
1581          new definition.  */
1582
1583       h->root.type = bfd_link_hash_undefined;
1584       h->root.u.undef.abfd = h->root.u.def.section->owner;
1585       *size_change_ok = TRUE;
1586
1587       olddef = FALSE;
1588       olddyncommon = FALSE;
1589
1590       /* We again permit a type change when a common symbol may be
1591          overriding a function.  */
1592
1593       if (bfd_is_com_section (sec))
1594         {
1595           if (oldfunc)
1596             {
1597               /* If a common symbol overrides a function, make sure
1598                  that it isn't defined dynamically nor has type
1599                  function.  */
1600               h->def_dynamic = 0;
1601               h->type = STT_NOTYPE;
1602             }
1603           *type_change_ok = TRUE;
1604         }
1605
1606       if (hi->root.type == bfd_link_hash_indirect)
1607         flip = hi;
1608       else
1609         /* This union may have been set to be non-NULL when this symbol
1610            was seen in a dynamic object.  We must force the union to be
1611            NULL, so that it is correct for a regular symbol.  */
1612         h->verinfo.vertree = NULL;
1613     }
1614
1615   /* Handle the special case of a new common symbol merging with an
1616      old symbol that looks like it might be a common symbol defined in
1617      a shared object.  Note that we have already handled the case in
1618      which a new common symbol should simply override the definition
1619      in the shared library.  */
1620
1621   if (! newdyn
1622       && bfd_is_com_section (sec)
1623       && olddyncommon)
1624     {
1625       /* It would be best if we could set the hash table entry to a
1626          common symbol, but we don't know what to use for the section
1627          or the alignment.  */
1628       if (! ((*info->callbacks->multiple_common)
1629              (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1630         return FALSE;
1631
1632       /* If the presumed common symbol in the dynamic object is
1633          larger, pretend that the new symbol has its size.  */
1634
1635       if (h->size > *pvalue)
1636         *pvalue = h->size;
1637
1638       /* We need to remember the alignment required by the symbol
1639          in the dynamic object.  */
1640       BFD_ASSERT (pold_alignment);
1641       *pold_alignment = h->root.u.def.section->alignment_power;
1642
1643       olddef = FALSE;
1644       olddyncommon = FALSE;
1645
1646       h->root.type = bfd_link_hash_undefined;
1647       h->root.u.undef.abfd = h->root.u.def.section->owner;
1648
1649       *size_change_ok = TRUE;
1650       *type_change_ok = TRUE;
1651
1652       if (hi->root.type == bfd_link_hash_indirect)
1653         flip = hi;
1654       else
1655         h->verinfo.vertree = NULL;
1656     }
1657
1658   if (flip != NULL)
1659     {
1660       /* Handle the case where we had a versioned symbol in a dynamic
1661          library and now find a definition in a normal object.  In this
1662          case, we make the versioned symbol point to the normal one.  */
1663       flip->root.type = h->root.type;
1664       flip->root.u.undef.abfd = h->root.u.undef.abfd;
1665       h->root.type = bfd_link_hash_indirect;
1666       h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1667       (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1668       if (h->def_dynamic)
1669         {
1670           h->def_dynamic = 0;
1671           flip->ref_dynamic = 1;
1672         }
1673     }
1674
1675   return TRUE;
1676 }
1677
1678 /* This function is called to create an indirect symbol from the
1679    default for the symbol with the default version if needed. The
1680    symbol is described by H, NAME, SYM, SEC, and VALUE.  We
1681    set DYNSYM if the new indirect symbol is dynamic.  */
1682
1683 static bfd_boolean
1684 _bfd_elf_add_default_symbol (bfd *abfd,
1685                              struct bfd_link_info *info,
1686                              struct elf_link_hash_entry *h,
1687                              const char *name,
1688                              Elf_Internal_Sym *sym,
1689                              asection *sec,
1690                              bfd_vma value,
1691                              bfd **poldbfd,
1692                              bfd_boolean *dynsym)
1693 {
1694   bfd_boolean type_change_ok;
1695   bfd_boolean size_change_ok;
1696   bfd_boolean skip;
1697   char *shortname;
1698   struct elf_link_hash_entry *hi;
1699   struct bfd_link_hash_entry *bh;
1700   const struct elf_backend_data *bed;
1701   bfd_boolean collect;
1702   bfd_boolean dynamic;
1703   bfd_boolean override;
1704   char *p;
1705   size_t len, shortlen;
1706   asection *tmp_sec;
1707   bfd_boolean matched;
1708
1709   if (h->versioned == unversioned || h->versioned == versioned_hidden)
1710     return TRUE;
1711
1712   /* If this symbol has a version, and it is the default version, we
1713      create an indirect symbol from the default name to the fully
1714      decorated name.  This will cause external references which do not
1715      specify a version to be bound to this version of the symbol.  */
1716   p = strchr (name, ELF_VER_CHR);
1717   if (h->versioned == unknown)
1718     {
1719       if (p == NULL)
1720         {
1721           h->versioned = unversioned;
1722           return TRUE;
1723         }
1724       else
1725         {
1726           if (p[1] != ELF_VER_CHR)
1727             {
1728               h->versioned = versioned_hidden;
1729               return TRUE;
1730             }
1731           else
1732             h->versioned = versioned;
1733         }
1734     }
1735   else
1736     {
1737       /* PR ld/19073: We may see an unversioned definition after the
1738          default version.  */
1739       if (p == NULL)
1740         return TRUE;
1741     }
1742
1743   bed = get_elf_backend_data (abfd);
1744   collect = bed->collect;
1745   dynamic = (abfd->flags & DYNAMIC) != 0;
1746
1747   shortlen = p - name;
1748   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1749   if (shortname == NULL)
1750     return FALSE;
1751   memcpy (shortname, name, shortlen);
1752   shortname[shortlen] = '\0';
1753
1754   /* We are going to create a new symbol.  Merge it with any existing
1755      symbol with this name.  For the purposes of the merge, act as
1756      though we were defining the symbol we just defined, although we
1757      actually going to define an indirect symbol.  */
1758   type_change_ok = FALSE;
1759   size_change_ok = FALSE;
1760   matched = TRUE;
1761   tmp_sec = sec;
1762   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1763                               &hi, poldbfd, NULL, NULL, &skip, &override,
1764                               &type_change_ok, &size_change_ok, &matched))
1765     return FALSE;
1766
1767   if (skip)
1768     goto nondefault;
1769
1770   if (! override)
1771     {
1772       /* Add the default symbol if not performing a relocatable link.  */
1773       if (! bfd_link_relocatable (info))
1774         {
1775           bh = &hi->root;
1776           if (! (_bfd_generic_link_add_one_symbol
1777                  (info, abfd, shortname, BSF_INDIRECT,
1778                   bfd_ind_section_ptr,
1779                   0, name, FALSE, collect, &bh)))
1780             return FALSE;
1781           hi = (struct elf_link_hash_entry *) bh;
1782         }
1783     }
1784   else
1785     {
1786       /* In this case the symbol named SHORTNAME is overriding the
1787          indirect symbol we want to add.  We were planning on making
1788          SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1789          is the name without a version.  NAME is the fully versioned
1790          name, and it is the default version.
1791
1792          Overriding means that we already saw a definition for the
1793          symbol SHORTNAME in a regular object, and it is overriding
1794          the symbol defined in the dynamic object.
1795
1796          When this happens, we actually want to change NAME, the
1797          symbol we just added, to refer to SHORTNAME.  This will cause
1798          references to NAME in the shared object to become references
1799          to SHORTNAME in the regular object.  This is what we expect
1800          when we override a function in a shared object: that the
1801          references in the shared object will be mapped to the
1802          definition in the regular object.  */
1803
1804       while (hi->root.type == bfd_link_hash_indirect
1805              || hi->root.type == bfd_link_hash_warning)
1806         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1807
1808       h->root.type = bfd_link_hash_indirect;
1809       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1810       if (h->def_dynamic)
1811         {
1812           h->def_dynamic = 0;
1813           hi->ref_dynamic = 1;
1814           if (hi->ref_regular
1815               || hi->def_regular)
1816             {
1817               if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1818                 return FALSE;
1819             }
1820         }
1821
1822       /* Now set HI to H, so that the following code will set the
1823          other fields correctly.  */
1824       hi = h;
1825     }
1826
1827   /* Check if HI is a warning symbol.  */
1828   if (hi->root.type == bfd_link_hash_warning)
1829     hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1830
1831   /* If there is a duplicate definition somewhere, then HI may not
1832      point to an indirect symbol.  We will have reported an error to
1833      the user in that case.  */
1834
1835   if (hi->root.type == bfd_link_hash_indirect)
1836     {
1837       struct elf_link_hash_entry *ht;
1838
1839       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1840       (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1841
1842       /* A reference to the SHORTNAME symbol from a dynamic library
1843          will be satisfied by the versioned symbol at runtime.  In
1844          effect, we have a reference to the versioned symbol.  */
1845       ht->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1846       hi->dynamic_def |= ht->dynamic_def;
1847
1848       /* See if the new flags lead us to realize that the symbol must
1849          be dynamic.  */
1850       if (! *dynsym)
1851         {
1852           if (! dynamic)
1853             {
1854               if (! bfd_link_executable (info)
1855                   || hi->def_dynamic
1856                   || hi->ref_dynamic)
1857                 *dynsym = TRUE;
1858             }
1859           else
1860             {
1861               if (hi->ref_regular)
1862                 *dynsym = TRUE;
1863             }
1864         }
1865     }
1866
1867   /* We also need to define an indirection from the nondefault version
1868      of the symbol.  */
1869
1870 nondefault:
1871   len = strlen (name);
1872   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1873   if (shortname == NULL)
1874     return FALSE;
1875   memcpy (shortname, name, shortlen);
1876   memcpy (shortname + shortlen, p + 1, len - shortlen);
1877
1878   /* Once again, merge with any existing symbol.  */
1879   type_change_ok = FALSE;
1880   size_change_ok = FALSE;
1881   tmp_sec = sec;
1882   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
1883                               &hi, poldbfd, NULL, NULL, &skip, &override,
1884                               &type_change_ok, &size_change_ok, &matched))
1885     return FALSE;
1886
1887   if (skip)
1888     return TRUE;
1889
1890   if (override)
1891     {
1892       /* Here SHORTNAME is a versioned name, so we don't expect to see
1893          the type of override we do in the case above unless it is
1894          overridden by a versioned definition.  */
1895       if (hi->root.type != bfd_link_hash_defined
1896           && hi->root.type != bfd_link_hash_defweak)
1897         (*_bfd_error_handler)
1898           (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1899            abfd, shortname);
1900     }
1901   else
1902     {
1903       bh = &hi->root;
1904       if (! (_bfd_generic_link_add_one_symbol
1905              (info, abfd, shortname, BSF_INDIRECT,
1906               bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1907         return FALSE;
1908       hi = (struct elf_link_hash_entry *) bh;
1909
1910       /* If there is a duplicate definition somewhere, then HI may not
1911          point to an indirect symbol.  We will have reported an error
1912          to the user in that case.  */
1913
1914       if (hi->root.type == bfd_link_hash_indirect)
1915         {
1916           (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1917           h->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak;
1918           hi->dynamic_def |= h->dynamic_def;
1919
1920           /* See if the new flags lead us to realize that the symbol
1921              must be dynamic.  */
1922           if (! *dynsym)
1923             {
1924               if (! dynamic)
1925                 {
1926                   if (! bfd_link_executable (info)
1927                       || hi->ref_dynamic)
1928                     *dynsym = TRUE;
1929                 }
1930               else
1931                 {
1932                   if (hi->ref_regular)
1933                     *dynsym = TRUE;
1934                 }
1935             }
1936         }
1937     }
1938
1939   return TRUE;
1940 }
1941 \f
1942 /* This routine is used to export all defined symbols into the dynamic
1943    symbol table.  It is called via elf_link_hash_traverse.  */
1944
1945 static bfd_boolean
1946 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1947 {
1948   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1949
1950   /* Ignore indirect symbols.  These are added by the versioning code.  */
1951   if (h->root.type == bfd_link_hash_indirect)
1952     return TRUE;
1953
1954   /* Ignore this if we won't export it.  */
1955   if (!eif->info->export_dynamic && !h->dynamic)
1956     return TRUE;
1957
1958   if (h->dynindx == -1
1959       && (h->def_regular || h->ref_regular)
1960       && ! bfd_hide_sym_by_version (eif->info->version_info,
1961                                     h->root.root.string))
1962     {
1963       if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1964         {
1965           eif->failed = TRUE;
1966           return FALSE;
1967         }
1968     }
1969
1970   return TRUE;
1971 }
1972 \f
1973 /* Look through the symbols which are defined in other shared
1974    libraries and referenced here.  Update the list of version
1975    dependencies.  This will be put into the .gnu.version_r section.
1976    This function is called via elf_link_hash_traverse.  */
1977
1978 static bfd_boolean
1979 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1980                                          void *data)
1981 {
1982   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1983   Elf_Internal_Verneed *t;
1984   Elf_Internal_Vernaux *a;
1985   bfd_size_type amt;
1986
1987   /* We only care about symbols defined in shared objects with version
1988      information.  */
1989   if (!h->def_dynamic
1990       || h->def_regular
1991       || h->dynindx == -1
1992       || h->verinfo.verdef == NULL
1993       || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
1994           & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
1995     return TRUE;
1996
1997   /* See if we already know about this version.  */
1998   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1999        t != NULL;
2000        t = t->vn_nextref)
2001     {
2002       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
2003         continue;
2004
2005       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
2006         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
2007           return TRUE;
2008
2009       break;
2010     }
2011
2012   /* This is a new version.  Add it to tree we are building.  */
2013
2014   if (t == NULL)
2015     {
2016       amt = sizeof *t;
2017       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
2018       if (t == NULL)
2019         {
2020           rinfo->failed = TRUE;
2021           return FALSE;
2022         }
2023
2024       t->vn_bfd = h->verinfo.verdef->vd_bfd;
2025       t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
2026       elf_tdata (rinfo->info->output_bfd)->verref = t;
2027     }
2028
2029   amt = sizeof *a;
2030   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
2031   if (a == NULL)
2032     {
2033       rinfo->failed = TRUE;
2034       return FALSE;
2035     }
2036
2037   /* Note that we are copying a string pointer here, and testing it
2038      above.  If bfd_elf_string_from_elf_section is ever changed to
2039      discard the string data when low in memory, this will have to be
2040      fixed.  */
2041   a->vna_nodename = h->verinfo.verdef->vd_nodename;
2042
2043   a->vna_flags = h->verinfo.verdef->vd_flags;
2044   a->vna_nextptr = t->vn_auxptr;
2045
2046   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
2047   ++rinfo->vers;
2048
2049   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
2050
2051   t->vn_auxptr = a;
2052
2053   return TRUE;
2054 }
2055
2056 /* Figure out appropriate versions for all the symbols.  We may not
2057    have the version number script until we have read all of the input
2058    files, so until that point we don't know which symbols should be
2059    local.  This function is called via elf_link_hash_traverse.  */
2060
2061 static bfd_boolean
2062 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
2063 {
2064   struct elf_info_failed *sinfo;
2065   struct bfd_link_info *info;
2066   const struct elf_backend_data *bed;
2067   struct elf_info_failed eif;
2068   char *p;
2069   bfd_size_type amt;
2070
2071   sinfo = (struct elf_info_failed *) data;
2072   info = sinfo->info;
2073
2074   /* Fix the symbol flags.  */
2075   eif.failed = FALSE;
2076   eif.info = info;
2077   if (! _bfd_elf_fix_symbol_flags (h, &eif))
2078     {
2079       if (eif.failed)
2080         sinfo->failed = TRUE;
2081       return FALSE;
2082     }
2083
2084   /* We only need version numbers for symbols defined in regular
2085      objects.  */
2086   if (!h->def_regular)
2087     return TRUE;
2088
2089   bed = get_elf_backend_data (info->output_bfd);
2090   p = strchr (h->root.root.string, ELF_VER_CHR);
2091   if (p != NULL && h->verinfo.vertree == NULL)
2092     {
2093       struct bfd_elf_version_tree *t;
2094
2095       ++p;
2096       if (*p == ELF_VER_CHR)
2097         ++p;
2098
2099       /* If there is no version string, we can just return out.  */
2100       if (*p == '\0')
2101         return TRUE;
2102
2103       /* Look for the version.  If we find it, it is no longer weak.  */
2104       for (t = sinfo->info->version_info; t != NULL; t = t->next)
2105         {
2106           if (strcmp (t->name, p) == 0)
2107             {
2108               size_t len;
2109               char *alc;
2110               struct bfd_elf_version_expr *d;
2111
2112               len = p - h->root.root.string;
2113               alc = (char *) bfd_malloc (len);
2114               if (alc == NULL)
2115                 {
2116                   sinfo->failed = TRUE;
2117                   return FALSE;
2118                 }
2119               memcpy (alc, h->root.root.string, len - 1);
2120               alc[len - 1] = '\0';
2121               if (alc[len - 2] == ELF_VER_CHR)
2122                 alc[len - 2] = '\0';
2123
2124               h->verinfo.vertree = t;
2125               t->used = TRUE;
2126               d = NULL;
2127
2128               if (t->globals.list != NULL)
2129                 d = (*t->match) (&t->globals, NULL, alc);
2130
2131               /* See if there is anything to force this symbol to
2132                  local scope.  */
2133               if (d == NULL && t->locals.list != NULL)
2134                 {
2135                   d = (*t->match) (&t->locals, NULL, alc);
2136                   if (d != NULL
2137                       && h->dynindx != -1
2138                       && ! info->export_dynamic)
2139                     (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2140                 }
2141
2142               free (alc);
2143               break;
2144             }
2145         }
2146
2147       /* If we are building an application, we need to create a
2148          version node for this version.  */
2149       if (t == NULL && bfd_link_executable (info))
2150         {
2151           struct bfd_elf_version_tree **pp;
2152           int version_index;
2153
2154           /* If we aren't going to export this symbol, we don't need
2155              to worry about it.  */
2156           if (h->dynindx == -1)
2157             return TRUE;
2158
2159           amt = sizeof *t;
2160           t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2161           if (t == NULL)
2162             {
2163               sinfo->failed = TRUE;
2164               return FALSE;
2165             }
2166
2167           t->name = p;
2168           t->name_indx = (unsigned int) -1;
2169           t->used = TRUE;
2170
2171           version_index = 1;
2172           /* Don't count anonymous version tag.  */
2173           if (sinfo->info->version_info != NULL
2174               && sinfo->info->version_info->vernum == 0)
2175             version_index = 0;
2176           for (pp = &sinfo->info->version_info;
2177                *pp != NULL;
2178                pp = &(*pp)->next)
2179             ++version_index;
2180           t->vernum = version_index;
2181
2182           *pp = t;
2183
2184           h->verinfo.vertree = t;
2185         }
2186       else if (t == NULL)
2187         {
2188           /* We could not find the version for a symbol when
2189              generating a shared archive.  Return an error.  */
2190           (*_bfd_error_handler)
2191             (_("%B: version node not found for symbol %s"),
2192              info->output_bfd, h->root.root.string);
2193           bfd_set_error (bfd_error_bad_value);
2194           sinfo->failed = TRUE;
2195           return FALSE;
2196         }
2197     }
2198
2199   /* If we don't have a version for this symbol, see if we can find
2200      something.  */
2201   if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2202     {
2203       bfd_boolean hide;
2204
2205       h->verinfo.vertree
2206         = bfd_find_version_for_sym (sinfo->info->version_info,
2207                                     h->root.root.string, &hide);
2208       if (h->verinfo.vertree != NULL && hide)
2209         (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2210     }
2211
2212   return TRUE;
2213 }
2214 \f
2215 /* Read and swap the relocs from the section indicated by SHDR.  This
2216    may be either a REL or a RELA section.  The relocations are
2217    translated into RELA relocations and stored in INTERNAL_RELOCS,
2218    which should have already been allocated to contain enough space.
2219    The EXTERNAL_RELOCS are a buffer where the external form of the
2220    relocations should be stored.
2221
2222    Returns FALSE if something goes wrong.  */
2223
2224 static bfd_boolean
2225 elf_link_read_relocs_from_section (bfd *abfd,
2226                                    asection *sec,
2227                                    Elf_Internal_Shdr *shdr,
2228                                    void *external_relocs,
2229                                    Elf_Internal_Rela *internal_relocs)
2230 {
2231   const struct elf_backend_data *bed;
2232   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2233   const bfd_byte *erela;
2234   const bfd_byte *erelaend;
2235   Elf_Internal_Rela *irela;
2236   Elf_Internal_Shdr *symtab_hdr;
2237   size_t nsyms;
2238
2239   /* Position ourselves at the start of the section.  */
2240   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2241     return FALSE;
2242
2243   /* Read the relocations.  */
2244   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2245     return FALSE;
2246
2247   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2248   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2249
2250   bed = get_elf_backend_data (abfd);
2251
2252   /* Convert the external relocations to the internal format.  */
2253   if (shdr->sh_entsize == bed->s->sizeof_rel)
2254     swap_in = bed->s->swap_reloc_in;
2255   else if (shdr->sh_entsize == bed->s->sizeof_rela)
2256     swap_in = bed->s->swap_reloca_in;
2257   else
2258     {
2259       bfd_set_error (bfd_error_wrong_format);
2260       return FALSE;
2261     }
2262
2263   erela = (const bfd_byte *) external_relocs;
2264   erelaend = erela + shdr->sh_size;
2265   irela = internal_relocs;
2266   while (erela < erelaend)
2267     {
2268       bfd_vma r_symndx;
2269
2270       (*swap_in) (abfd, erela, irela);
2271       r_symndx = ELF32_R_SYM (irela->r_info);
2272       if (bed->s->arch_size == 64)
2273         r_symndx >>= 24;
2274       if (nsyms > 0)
2275         {
2276           if ((size_t) r_symndx >= nsyms)
2277             {
2278               (*_bfd_error_handler)
2279                 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2280                    " for offset 0x%lx in section `%A'"),
2281                  abfd, sec,
2282                  (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2283               bfd_set_error (bfd_error_bad_value);
2284               return FALSE;
2285             }
2286         }
2287       else if (r_symndx != STN_UNDEF)
2288         {
2289           (*_bfd_error_handler)
2290             (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2291                " when the object file has no symbol table"),
2292              abfd, sec,
2293              (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2294           bfd_set_error (bfd_error_bad_value);
2295           return FALSE;
2296         }
2297       irela += bed->s->int_rels_per_ext_rel;
2298       erela += shdr->sh_entsize;
2299     }
2300
2301   return TRUE;
2302 }
2303
2304 /* Read and swap the relocs for a section O.  They may have been
2305    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2306    not NULL, they are used as buffers to read into.  They are known to
2307    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2308    the return value is allocated using either malloc or bfd_alloc,
2309    according to the KEEP_MEMORY argument.  If O has two relocation
2310    sections (both REL and RELA relocations), then the REL_HDR
2311    relocations will appear first in INTERNAL_RELOCS, followed by the
2312    RELA_HDR relocations.  */
2313
2314 Elf_Internal_Rela *
2315 _bfd_elf_link_read_relocs (bfd *abfd,
2316                            asection *o,
2317                            void *external_relocs,
2318                            Elf_Internal_Rela *internal_relocs,
2319                            bfd_boolean keep_memory)
2320 {
2321   void *alloc1 = NULL;
2322   Elf_Internal_Rela *alloc2 = NULL;
2323   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2324   struct bfd_elf_section_data *esdo = elf_section_data (o);
2325   Elf_Internal_Rela *internal_rela_relocs;
2326
2327   if (esdo->relocs != NULL)
2328     return esdo->relocs;
2329
2330   if (o->reloc_count == 0)
2331     return NULL;
2332
2333   if (internal_relocs == NULL)
2334     {
2335       bfd_size_type size;
2336
2337       size = o->reloc_count;
2338       size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2339       if (keep_memory)
2340         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2341       else
2342         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2343       if (internal_relocs == NULL)
2344         goto error_return;
2345     }
2346
2347   if (external_relocs == NULL)
2348     {
2349       bfd_size_type size = 0;
2350
2351       if (esdo->rel.hdr)
2352         size += esdo->rel.hdr->sh_size;
2353       if (esdo->rela.hdr)
2354         size += esdo->rela.hdr->sh_size;
2355
2356       alloc1 = bfd_malloc (size);
2357       if (alloc1 == NULL)
2358         goto error_return;
2359       external_relocs = alloc1;
2360     }
2361
2362   internal_rela_relocs = internal_relocs;
2363   if (esdo->rel.hdr)
2364     {
2365       if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2366                                               external_relocs,
2367                                               internal_relocs))
2368         goto error_return;
2369       external_relocs = (((bfd_byte *) external_relocs)
2370                          + esdo->rel.hdr->sh_size);
2371       internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2372                                * bed->s->int_rels_per_ext_rel);
2373     }
2374
2375   if (esdo->rela.hdr
2376       && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2377                                               external_relocs,
2378                                               internal_rela_relocs)))
2379     goto error_return;
2380
2381   /* Cache the results for next time, if we can.  */
2382   if (keep_memory)
2383     esdo->relocs = internal_relocs;
2384
2385   if (alloc1 != NULL)
2386     free (alloc1);
2387
2388   /* Don't free alloc2, since if it was allocated we are passing it
2389      back (under the name of internal_relocs).  */
2390
2391   return internal_relocs;
2392
2393  error_return:
2394   if (alloc1 != NULL)
2395     free (alloc1);
2396   if (alloc2 != NULL)
2397     {
2398       if (keep_memory)
2399         bfd_release (abfd, alloc2);
2400       else
2401         free (alloc2);
2402     }
2403   return NULL;
2404 }
2405
2406 /* Compute the size of, and allocate space for, REL_HDR which is the
2407    section header for a section containing relocations for O.  */
2408
2409 static bfd_boolean
2410 _bfd_elf_link_size_reloc_section (bfd *abfd,
2411                                   struct bfd_elf_section_reloc_data *reldata)
2412 {
2413   Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2414
2415   /* That allows us to calculate the size of the section.  */
2416   rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2417
2418   /* The contents field must last into write_object_contents, so we
2419      allocate it with bfd_alloc rather than malloc.  Also since we
2420      cannot be sure that the contents will actually be filled in,
2421      we zero the allocated space.  */
2422   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2423   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2424     return FALSE;
2425
2426   if (reldata->hashes == NULL && reldata->count)
2427     {
2428       struct elf_link_hash_entry **p;
2429
2430       p = ((struct elf_link_hash_entry **)
2431            bfd_zmalloc (reldata->count * sizeof (*p)));
2432       if (p == NULL)
2433         return FALSE;
2434
2435       reldata->hashes = p;
2436     }
2437
2438   return TRUE;
2439 }
2440
2441 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
2442    originated from the section given by INPUT_REL_HDR) to the
2443    OUTPUT_BFD.  */
2444
2445 bfd_boolean
2446 _bfd_elf_link_output_relocs (bfd *output_bfd,
2447                              asection *input_section,
2448                              Elf_Internal_Shdr *input_rel_hdr,
2449                              Elf_Internal_Rela *internal_relocs,
2450                              struct elf_link_hash_entry **rel_hash
2451                                ATTRIBUTE_UNUSED)
2452 {
2453   Elf_Internal_Rela *irela;
2454   Elf_Internal_Rela *irelaend;
2455   bfd_byte *erel;
2456   struct bfd_elf_section_reloc_data *output_reldata;
2457   asection *output_section;
2458   const struct elf_backend_data *bed;
2459   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2460   struct bfd_elf_section_data *esdo;
2461
2462   output_section = input_section->output_section;
2463
2464   bed = get_elf_backend_data (output_bfd);
2465   esdo = elf_section_data (output_section);
2466   if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2467     {
2468       output_reldata = &esdo->rel;
2469       swap_out = bed->s->swap_reloc_out;
2470     }
2471   else if (esdo->rela.hdr
2472            && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2473     {
2474       output_reldata = &esdo->rela;
2475       swap_out = bed->s->swap_reloca_out;
2476     }
2477   else
2478     {
2479       (*_bfd_error_handler)
2480         (_("%B: relocation size mismatch in %B section %A"),
2481          output_bfd, input_section->owner, input_section);
2482       bfd_set_error (bfd_error_wrong_format);
2483       return FALSE;
2484     }
2485
2486   erel = output_reldata->hdr->contents;
2487   erel += output_reldata->count * input_rel_hdr->sh_entsize;
2488   irela = internal_relocs;
2489   irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2490                       * bed->s->int_rels_per_ext_rel);
2491   while (irela < irelaend)
2492     {
2493       (*swap_out) (output_bfd, irela, erel);
2494       irela += bed->s->int_rels_per_ext_rel;
2495       erel += input_rel_hdr->sh_entsize;
2496     }
2497
2498   /* Bump the counter, so that we know where to add the next set of
2499      relocations.  */
2500   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2501
2502   return TRUE;
2503 }
2504 \f
2505 /* Make weak undefined symbols in PIE dynamic.  */
2506
2507 bfd_boolean
2508 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2509                                  struct elf_link_hash_entry *h)
2510 {
2511   if (bfd_link_pie (info)
2512       && h->dynindx == -1
2513       && h->root.type == bfd_link_hash_undefweak)
2514     return bfd_elf_link_record_dynamic_symbol (info, h);
2515
2516   return TRUE;
2517 }
2518
2519 /* Fix up the flags for a symbol.  This handles various cases which
2520    can only be fixed after all the input files are seen.  This is
2521    currently called by both adjust_dynamic_symbol and
2522    assign_sym_version, which is unnecessary but perhaps more robust in
2523    the face of future changes.  */
2524
2525 static bfd_boolean
2526 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2527                            struct elf_info_failed *eif)
2528 {
2529   const struct elf_backend_data *bed;
2530
2531   /* If this symbol was mentioned in a non-ELF file, try to set
2532      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2533      permit a non-ELF file to correctly refer to a symbol defined in
2534      an ELF dynamic object.  */
2535   if (h->non_elf)
2536     {
2537       while (h->root.type == bfd_link_hash_indirect)
2538         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2539
2540       if (h->root.type != bfd_link_hash_defined
2541           && h->root.type != bfd_link_hash_defweak)
2542         {
2543           h->ref_regular = 1;
2544           h->ref_regular_nonweak = 1;
2545         }
2546       else
2547         {
2548           if (h->root.u.def.section->owner != NULL
2549               && (bfd_get_flavour (h->root.u.def.section->owner)
2550                   == bfd_target_elf_flavour))
2551             {
2552               h->ref_regular = 1;
2553               h->ref_regular_nonweak = 1;
2554             }
2555           else
2556             h->def_regular = 1;
2557         }
2558
2559       if (h->dynindx == -1
2560           && (h->def_dynamic
2561               || h->ref_dynamic))
2562         {
2563           if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2564             {
2565               eif->failed = TRUE;
2566               return FALSE;
2567             }
2568         }
2569     }
2570   else
2571     {
2572       /* Unfortunately, NON_ELF is only correct if the symbol
2573          was first seen in a non-ELF file.  Fortunately, if the symbol
2574          was first seen in an ELF file, we're probably OK unless the
2575          symbol was defined in a non-ELF file.  Catch that case here.
2576          FIXME: We're still in trouble if the symbol was first seen in
2577          a dynamic object, and then later in a non-ELF regular object.  */
2578       if ((h->root.type == bfd_link_hash_defined
2579            || h->root.type == bfd_link_hash_defweak)
2580           && !h->def_regular
2581           && (h->root.u.def.section->owner != NULL
2582               ? (bfd_get_flavour (h->root.u.def.section->owner)
2583                  != bfd_target_elf_flavour)
2584               : (bfd_is_abs_section (h->root.u.def.section)
2585                  && !h->def_dynamic)))
2586         h->def_regular = 1;
2587     }
2588
2589   /* Backend specific symbol fixup.  */
2590   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2591   if (bed->elf_backend_fixup_symbol
2592       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2593     return FALSE;
2594
2595   /* If this is a final link, and the symbol was defined as a common
2596      symbol in a regular object file, and there was no definition in
2597      any dynamic object, then the linker will have allocated space for
2598      the symbol in a common section but the DEF_REGULAR
2599      flag will not have been set.  */
2600   if (h->root.type == bfd_link_hash_defined
2601       && !h->def_regular
2602       && h->ref_regular
2603       && !h->def_dynamic
2604       && (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0)
2605     h->def_regular = 1;
2606
2607   /* If -Bsymbolic was used (which means to bind references to global
2608      symbols to the definition within the shared object), and this
2609      symbol was defined in a regular object, then it actually doesn't
2610      need a PLT entry.  Likewise, if the symbol has non-default
2611      visibility.  If the symbol has hidden or internal visibility, we
2612      will force it local.  */
2613   if (h->needs_plt
2614       && bfd_link_pic (eif->info)
2615       && is_elf_hash_table (eif->info->hash)
2616       && (SYMBOLIC_BIND (eif->info, h)
2617           || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2618       && h->def_regular)
2619     {
2620       bfd_boolean force_local;
2621
2622       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2623                      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2624       (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2625     }
2626
2627   /* If a weak undefined symbol has non-default visibility, we also
2628      hide it from the dynamic linker.  */
2629   if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2630       && h->root.type == bfd_link_hash_undefweak)
2631     (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2632
2633   /* If this is a weak defined symbol in a dynamic object, and we know
2634      the real definition in the dynamic object, copy interesting flags
2635      over to the real definition.  */
2636   if (h->u.weakdef != NULL)
2637     {
2638       /* If the real definition is defined by a regular object file,
2639          don't do anything special.  See the longer description in
2640          _bfd_elf_adjust_dynamic_symbol, below.  */
2641       if (h->u.weakdef->def_regular)
2642         h->u.weakdef = NULL;
2643       else
2644         {
2645           struct elf_link_hash_entry *weakdef = h->u.weakdef;
2646
2647           while (h->root.type == bfd_link_hash_indirect)
2648             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2649
2650           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2651                       || h->root.type == bfd_link_hash_defweak);
2652           BFD_ASSERT (weakdef->def_dynamic);
2653           BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2654                       || weakdef->root.type == bfd_link_hash_defweak);
2655           (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2656         }
2657     }
2658
2659   return TRUE;
2660 }
2661
2662 /* Make the backend pick a good value for a dynamic symbol.  This is
2663    called via elf_link_hash_traverse, and also calls itself
2664    recursively.  */
2665
2666 static bfd_boolean
2667 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2668 {
2669   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2670   bfd *dynobj;
2671   const struct elf_backend_data *bed;
2672
2673   if (! is_elf_hash_table (eif->info->hash))
2674     return FALSE;
2675
2676   /* Ignore indirect symbols.  These are added by the versioning code.  */
2677   if (h->root.type == bfd_link_hash_indirect)
2678     return TRUE;
2679
2680   /* Fix the symbol flags.  */
2681   if (! _bfd_elf_fix_symbol_flags (h, eif))
2682     return FALSE;
2683
2684   /* If this symbol does not require a PLT entry, and it is not
2685      defined by a dynamic object, or is not referenced by a regular
2686      object, ignore it.  We do have to handle a weak defined symbol,
2687      even if no regular object refers to it, if we decided to add it
2688      to the dynamic symbol table.  FIXME: Do we normally need to worry
2689      about symbols which are defined by one dynamic object and
2690      referenced by another one?  */
2691   if (!h->needs_plt
2692       && h->type != STT_GNU_IFUNC
2693       && (h->def_regular
2694           || !h->def_dynamic
2695           || (!h->ref_regular
2696               && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2697     {
2698       h->plt = elf_hash_table (eif->info)->init_plt_offset;
2699       return TRUE;
2700     }
2701
2702   /* If we've already adjusted this symbol, don't do it again.  This
2703      can happen via a recursive call.  */
2704   if (h->dynamic_adjusted)
2705     return TRUE;
2706
2707   /* Don't look at this symbol again.  Note that we must set this
2708      after checking the above conditions, because we may look at a
2709      symbol once, decide not to do anything, and then get called
2710      recursively later after REF_REGULAR is set below.  */
2711   h->dynamic_adjusted = 1;
2712
2713   /* If this is a weak definition, and we know a real definition, and
2714      the real symbol is not itself defined by a regular object file,
2715      then get a good value for the real definition.  We handle the
2716      real symbol first, for the convenience of the backend routine.
2717
2718      Note that there is a confusing case here.  If the real definition
2719      is defined by a regular object file, we don't get the real symbol
2720      from the dynamic object, but we do get the weak symbol.  If the
2721      processor backend uses a COPY reloc, then if some routine in the
2722      dynamic object changes the real symbol, we will not see that
2723      change in the corresponding weak symbol.  This is the way other
2724      ELF linkers work as well, and seems to be a result of the shared
2725      library model.
2726
2727      I will clarify this issue.  Most SVR4 shared libraries define the
2728      variable _timezone and define timezone as a weak synonym.  The
2729      tzset call changes _timezone.  If you write
2730        extern int timezone;
2731        int _timezone = 5;
2732        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2733      you might expect that, since timezone is a synonym for _timezone,
2734      the same number will print both times.  However, if the processor
2735      backend uses a COPY reloc, then actually timezone will be copied
2736      into your process image, and, since you define _timezone
2737      yourself, _timezone will not.  Thus timezone and _timezone will
2738      wind up at different memory locations.  The tzset call will set
2739      _timezone, leaving timezone unchanged.  */
2740
2741   if (h->u.weakdef != NULL)
2742     {
2743       /* If we get to this point, there is an implicit reference to
2744          H->U.WEAKDEF by a regular object file via the weak symbol H.  */
2745       h->u.weakdef->ref_regular = 1;
2746
2747       /* Ensure that the backend adjust_dynamic_symbol function sees
2748          H->U.WEAKDEF before H by recursively calling ourselves.  */
2749       if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2750         return FALSE;
2751     }
2752
2753   /* If a symbol has no type and no size and does not require a PLT
2754      entry, then we are probably about to do the wrong thing here: we
2755      are probably going to create a COPY reloc for an empty object.
2756      This case can arise when a shared object is built with assembly
2757      code, and the assembly code fails to set the symbol type.  */
2758   if (h->size == 0
2759       && h->type == STT_NOTYPE
2760       && !h->needs_plt)
2761     (*_bfd_error_handler)
2762       (_("warning: type and size of dynamic symbol `%s' are not defined"),
2763        h->root.root.string);
2764
2765   dynobj = elf_hash_table (eif->info)->dynobj;
2766   bed = get_elf_backend_data (dynobj);
2767
2768   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2769     {
2770       eif->failed = TRUE;
2771       return FALSE;
2772     }
2773
2774   return TRUE;
2775 }
2776
2777 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2778    DYNBSS.  */
2779
2780 bfd_boolean
2781 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
2782                               struct elf_link_hash_entry *h,
2783                               asection *dynbss)
2784 {
2785   unsigned int power_of_two;
2786   bfd_vma mask;
2787   asection *sec = h->root.u.def.section;
2788
2789   /* The section aligment of definition is the maximum alignment
2790      requirement of symbols defined in the section.  Since we don't
2791      know the symbol alignment requirement, we start with the
2792      maximum alignment and check low bits of the symbol address
2793      for the minimum alignment.  */
2794   power_of_two = bfd_get_section_alignment (sec->owner, sec);
2795   mask = ((bfd_vma) 1 << power_of_two) - 1;
2796   while ((h->root.u.def.value & mask) != 0)
2797     {
2798        mask >>= 1;
2799        --power_of_two;
2800     }
2801
2802   if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2803                                                 dynbss))
2804     {
2805       /* Adjust the section alignment if needed.  */
2806       if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2807                                        power_of_two))
2808         return FALSE;
2809     }
2810
2811   /* We make sure that the symbol will be aligned properly.  */
2812   dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2813
2814   /* Define the symbol as being at this point in DYNBSS.  */
2815   h->root.u.def.section = dynbss;
2816   h->root.u.def.value = dynbss->size;
2817
2818   /* Increment the size of DYNBSS to make room for the symbol.  */
2819   dynbss->size += h->size;
2820
2821   /* No error if extern_protected_data is true.  */
2822   if (h->protected_def
2823       && (!info->extern_protected_data
2824           || (info->extern_protected_data < 0
2825               && !get_elf_backend_data (dynbss->owner)->extern_protected_data)))
2826     info->callbacks->einfo
2827       (_("%P: copy reloc against protected `%T' is dangerous\n"),
2828        h->root.root.string);
2829
2830   return TRUE;
2831 }
2832
2833 /* Adjust all external symbols pointing into SEC_MERGE sections
2834    to reflect the object merging within the sections.  */
2835
2836 static bfd_boolean
2837 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2838 {
2839   asection *sec;
2840
2841   if ((h->root.type == bfd_link_hash_defined
2842        || h->root.type == bfd_link_hash_defweak)
2843       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2844       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
2845     {
2846       bfd *output_bfd = (bfd *) data;
2847
2848       h->root.u.def.value =
2849         _bfd_merged_section_offset (output_bfd,
2850                                     &h->root.u.def.section,
2851                                     elf_section_data (sec)->sec_info,
2852                                     h->root.u.def.value);
2853     }
2854
2855   return TRUE;
2856 }
2857
2858 /* Returns false if the symbol referred to by H should be considered
2859    to resolve local to the current module, and true if it should be
2860    considered to bind dynamically.  */
2861
2862 bfd_boolean
2863 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2864                            struct bfd_link_info *info,
2865                            bfd_boolean not_local_protected)
2866 {
2867   bfd_boolean binding_stays_local_p;
2868   const struct elf_backend_data *bed;
2869   struct elf_link_hash_table *hash_table;
2870
2871   if (h == NULL)
2872     return FALSE;
2873
2874   while (h->root.type == bfd_link_hash_indirect
2875          || h->root.type == bfd_link_hash_warning)
2876     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2877
2878   /* If it was forced local, then clearly it's not dynamic.  */
2879   if (h->dynindx == -1)
2880     return FALSE;
2881   if (h->forced_local)
2882     return FALSE;
2883
2884   /* Identify the cases where name binding rules say that a
2885      visible symbol resolves locally.  */
2886   binding_stays_local_p = (bfd_link_executable (info)
2887                            || SYMBOLIC_BIND (info, h));
2888
2889   switch (ELF_ST_VISIBILITY (h->other))
2890     {
2891     case STV_INTERNAL:
2892     case STV_HIDDEN:
2893       return FALSE;
2894
2895     case STV_PROTECTED:
2896       hash_table = elf_hash_table (info);
2897       if (!is_elf_hash_table (hash_table))
2898         return FALSE;
2899
2900       bed = get_elf_backend_data (hash_table->dynobj);
2901
2902       /* Proper resolution for function pointer equality may require
2903          that these symbols perhaps be resolved dynamically, even though
2904          we should be resolving them to the current module.  */
2905       if (!not_local_protected || !bed->is_function_type (h->type))
2906         binding_stays_local_p = TRUE;
2907       break;
2908
2909     default:
2910       break;
2911     }
2912
2913   /* If it isn't defined locally, then clearly it's dynamic.  */
2914   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2915     return TRUE;
2916
2917   /* Otherwise, the symbol is dynamic if binding rules don't tell
2918      us that it remains local.  */
2919   return !binding_stays_local_p;
2920 }
2921
2922 /* Return true if the symbol referred to by H should be considered
2923    to resolve local to the current module, and false otherwise.  Differs
2924    from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2925    undefined symbols.  The two functions are virtually identical except
2926    for the place where forced_local and dynindx == -1 are tested.  If
2927    either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2928    the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2929    the symbol is local only for defined symbols.
2930    It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2931    !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2932    treatment of undefined weak symbols.  For those that do not make
2933    undefined weak symbols dynamic, both functions may return false.  */
2934
2935 bfd_boolean
2936 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2937                               struct bfd_link_info *info,
2938                               bfd_boolean local_protected)
2939 {
2940   const struct elf_backend_data *bed;
2941   struct elf_link_hash_table *hash_table;
2942
2943   /* If it's a local sym, of course we resolve locally.  */
2944   if (h == NULL)
2945     return TRUE;
2946
2947   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2948   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2949       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2950     return TRUE;
2951
2952   /* Common symbols that become definitions don't get the DEF_REGULAR
2953      flag set, so test it first, and don't bail out.  */
2954   if (ELF_COMMON_DEF_P (h))
2955     /* Do nothing.  */;
2956   /* If we don't have a definition in a regular file, then we can't
2957      resolve locally.  The sym is either undefined or dynamic.  */
2958   else if (!h->def_regular)
2959     return FALSE;
2960
2961   /* Forced local symbols resolve locally.  */
2962   if (h->forced_local)
2963     return TRUE;
2964
2965   /* As do non-dynamic symbols.  */
2966   if (h->dynindx == -1)
2967     return TRUE;
2968
2969   /* At this point, we know the symbol is defined and dynamic.  In an
2970      executable it must resolve locally, likewise when building symbolic
2971      shared libraries.  */
2972   if (bfd_link_executable (info) || SYMBOLIC_BIND (info, h))
2973     return TRUE;
2974
2975   /* Now deal with defined dynamic symbols in shared libraries.  Ones
2976      with default visibility might not resolve locally.  */
2977   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2978     return FALSE;
2979
2980   hash_table = elf_hash_table (info);
2981   if (!is_elf_hash_table (hash_table))
2982     return TRUE;
2983
2984   bed = get_elf_backend_data (hash_table->dynobj);
2985
2986   /* If extern_protected_data is false, STV_PROTECTED non-function
2987      symbols are local.  */
2988   if ((!info->extern_protected_data
2989        || (info->extern_protected_data < 0
2990            && !bed->extern_protected_data))
2991       && !bed->is_function_type (h->type))
2992     return TRUE;
2993
2994   /* Function pointer equality tests may require that STV_PROTECTED
2995      symbols be treated as dynamic symbols.  If the address of a
2996      function not defined in an executable is set to that function's
2997      plt entry in the executable, then the address of the function in
2998      a shared library must also be the plt entry in the executable.  */
2999   return local_protected;
3000 }
3001
3002 /* Caches some TLS segment info, and ensures that the TLS segment vma is
3003    aligned.  Returns the first TLS output section.  */
3004
3005 struct bfd_section *
3006 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
3007 {
3008   struct bfd_section *sec, *tls;
3009   unsigned int align = 0;
3010
3011   for (sec = obfd->sections; sec != NULL; sec = sec->next)
3012     if ((sec->flags & SEC_THREAD_LOCAL) != 0)
3013       break;
3014   tls = sec;
3015
3016   for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
3017     if (sec->alignment_power > align)
3018       align = sec->alignment_power;
3019
3020   elf_hash_table (info)->tls_sec = tls;
3021
3022   /* Ensure the alignment of the first section is the largest alignment,
3023      so that the tls segment starts aligned.  */
3024   if (tls != NULL)
3025     tls->alignment_power = align;
3026
3027   return tls;
3028 }
3029
3030 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
3031 static bfd_boolean
3032 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
3033                                   Elf_Internal_Sym *sym)
3034 {
3035   const struct elf_backend_data *bed;
3036
3037   /* Local symbols do not count, but target specific ones might.  */
3038   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
3039       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
3040     return FALSE;
3041
3042   bed = get_elf_backend_data (abfd);
3043   /* Function symbols do not count.  */
3044   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
3045     return FALSE;
3046
3047   /* If the section is undefined, then so is the symbol.  */
3048   if (sym->st_shndx == SHN_UNDEF)
3049     return FALSE;
3050
3051   /* If the symbol is defined in the common section, then
3052      it is a common definition and so does not count.  */
3053   if (bed->common_definition (sym))
3054     return FALSE;
3055
3056   /* If the symbol is in a target specific section then we
3057      must rely upon the backend to tell us what it is.  */
3058   if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
3059     /* FIXME - this function is not coded yet:
3060
3061        return _bfd_is_global_symbol_definition (abfd, sym);
3062
3063        Instead for now assume that the definition is not global,
3064        Even if this is wrong, at least the linker will behave
3065        in the same way that it used to do.  */
3066     return FALSE;
3067
3068   return TRUE;
3069 }
3070
3071 /* Search the symbol table of the archive element of the archive ABFD
3072    whose archive map contains a mention of SYMDEF, and determine if
3073    the symbol is defined in this element.  */
3074 static bfd_boolean
3075 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
3076 {
3077   Elf_Internal_Shdr * hdr;
3078   bfd_size_type symcount;
3079   bfd_size_type extsymcount;
3080   bfd_size_type extsymoff;
3081   Elf_Internal_Sym *isymbuf;
3082   Elf_Internal_Sym *isym;
3083   Elf_Internal_Sym *isymend;
3084   bfd_boolean result;
3085
3086   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
3087   if (abfd == NULL)
3088     return FALSE;
3089
3090   /* Return FALSE if the object has been claimed by plugin.  */
3091   if (abfd->plugin_format == bfd_plugin_yes)
3092     return FALSE;
3093
3094   if (! bfd_check_format (abfd, bfd_object))
3095     return FALSE;
3096
3097   /* Select the appropriate symbol table.  */
3098   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
3099     hdr = &elf_tdata (abfd)->symtab_hdr;
3100   else
3101     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3102
3103   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3104
3105   /* The sh_info field of the symtab header tells us where the
3106      external symbols start.  We don't care about the local symbols.  */
3107   if (elf_bad_symtab (abfd))
3108     {
3109       extsymcount = symcount;
3110       extsymoff = 0;
3111     }
3112   else
3113     {
3114       extsymcount = symcount - hdr->sh_info;
3115       extsymoff = hdr->sh_info;
3116     }
3117
3118   if (extsymcount == 0)
3119     return FALSE;
3120
3121   /* Read in the symbol table.  */
3122   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3123                                   NULL, NULL, NULL);
3124   if (isymbuf == NULL)
3125     return FALSE;
3126
3127   /* Scan the symbol table looking for SYMDEF.  */
3128   result = FALSE;
3129   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
3130     {
3131       const char *name;
3132
3133       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3134                                               isym->st_name);
3135       if (name == NULL)
3136         break;
3137
3138       if (strcmp (name, symdef->name) == 0)
3139         {
3140           result = is_global_data_symbol_definition (abfd, isym);
3141           break;
3142         }
3143     }
3144
3145   free (isymbuf);
3146
3147   return result;
3148 }
3149 \f
3150 /* Add an entry to the .dynamic table.  */
3151
3152 bfd_boolean
3153 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3154                             bfd_vma tag,
3155                             bfd_vma val)
3156 {
3157   struct elf_link_hash_table *hash_table;
3158   const struct elf_backend_data *bed;
3159   asection *s;
3160   bfd_size_type newsize;
3161   bfd_byte *newcontents;
3162   Elf_Internal_Dyn dyn;
3163
3164   hash_table = elf_hash_table (info);
3165   if (! is_elf_hash_table (hash_table))
3166     return FALSE;
3167
3168   bed = get_elf_backend_data (hash_table->dynobj);
3169   s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3170   BFD_ASSERT (s != NULL);
3171
3172   newsize = s->size + bed->s->sizeof_dyn;
3173   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3174   if (newcontents == NULL)
3175     return FALSE;
3176
3177   dyn.d_tag = tag;
3178   dyn.d_un.d_val = val;
3179   bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3180
3181   s->size = newsize;
3182   s->contents = newcontents;
3183
3184   return TRUE;
3185 }
3186
3187 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3188    otherwise just check whether one already exists.  Returns -1 on error,
3189    1 if a DT_NEEDED tag already exists, and 0 on success.  */
3190
3191 static int
3192 elf_add_dt_needed_tag (bfd *abfd,
3193                        struct bfd_link_info *info,
3194                        const char *soname,
3195                        bfd_boolean do_it)
3196 {
3197   struct elf_link_hash_table *hash_table;
3198   bfd_size_type strindex;
3199
3200   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3201     return -1;
3202
3203   hash_table = elf_hash_table (info);
3204   strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3205   if (strindex == (bfd_size_type) -1)
3206     return -1;
3207
3208   if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
3209     {
3210       asection *sdyn;
3211       const struct elf_backend_data *bed;
3212       bfd_byte *extdyn;
3213
3214       bed = get_elf_backend_data (hash_table->dynobj);
3215       sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
3216       if (sdyn != NULL)
3217         for (extdyn = sdyn->contents;
3218              extdyn < sdyn->contents + sdyn->size;
3219              extdyn += bed->s->sizeof_dyn)
3220           {
3221             Elf_Internal_Dyn dyn;
3222
3223             bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3224             if (dyn.d_tag == DT_NEEDED
3225                 && dyn.d_un.d_val == strindex)
3226               {
3227                 _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3228                 return 1;
3229               }
3230           }
3231     }
3232
3233   if (do_it)
3234     {
3235       if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3236         return -1;
3237
3238       if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3239         return -1;
3240     }
3241   else
3242     /* We were just checking for existence of the tag.  */
3243     _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3244
3245   return 0;
3246 }
3247
3248 /* Return true if SONAME is on the needed list between NEEDED and STOP
3249    (or the end of list if STOP is NULL), and needed by a library that
3250    will be loaded.  */
3251
3252 static bfd_boolean
3253 on_needed_list (const char *soname,
3254                 struct bfd_link_needed_list *needed,
3255                 struct bfd_link_needed_list *stop)
3256 {
3257   struct bfd_link_needed_list *look;
3258   for (look = needed; look != stop; look = look->next)
3259     if (strcmp (soname, look->name) == 0
3260         && ((elf_dyn_lib_class (look->by) & DYN_AS_NEEDED) == 0
3261             /* If needed by a library that itself is not directly
3262                needed, recursively check whether that library is
3263                indirectly needed.  Since we add DT_NEEDED entries to
3264                the end of the list, library dependencies appear after
3265                the library.  Therefore search prior to the current
3266                LOOK, preventing possible infinite recursion.  */
3267             || on_needed_list (elf_dt_name (look->by), needed, look)))
3268       return TRUE;
3269
3270   return FALSE;
3271 }
3272
3273 /* Sort symbol by value, section, and size.  */
3274 static int
3275 elf_sort_symbol (const void *arg1, const void *arg2)
3276 {
3277   const struct elf_link_hash_entry *h1;
3278   const struct elf_link_hash_entry *h2;
3279   bfd_signed_vma vdiff;
3280
3281   h1 = *(const struct elf_link_hash_entry **) arg1;
3282   h2 = *(const struct elf_link_hash_entry **) arg2;
3283   vdiff = h1->root.u.def.value - h2->root.u.def.value;
3284   if (vdiff != 0)
3285     return vdiff > 0 ? 1 : -1;
3286   else
3287     {
3288       int sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3289       if (sdiff != 0)
3290         return sdiff > 0 ? 1 : -1;
3291     }
3292   vdiff = h1->size - h2->size;
3293   return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
3294 }
3295
3296 /* This function is used to adjust offsets into .dynstr for
3297    dynamic symbols.  This is called via elf_link_hash_traverse.  */
3298
3299 static bfd_boolean
3300 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3301 {
3302   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3303
3304   if (h->dynindx != -1)
3305     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3306   return TRUE;
3307 }
3308
3309 /* Assign string offsets in .dynstr, update all structures referencing
3310    them.  */
3311
3312 static bfd_boolean
3313 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3314 {
3315   struct elf_link_hash_table *hash_table = elf_hash_table (info);
3316   struct elf_link_local_dynamic_entry *entry;
3317   struct elf_strtab_hash *dynstr = hash_table->dynstr;
3318   bfd *dynobj = hash_table->dynobj;
3319   asection *sdyn;
3320   bfd_size_type size;
3321   const struct elf_backend_data *bed;
3322   bfd_byte *extdyn;
3323
3324   _bfd_elf_strtab_finalize (dynstr);
3325   size = _bfd_elf_strtab_size (dynstr);
3326
3327   bed = get_elf_backend_data (dynobj);
3328   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3329   BFD_ASSERT (sdyn != NULL);
3330
3331   /* Update all .dynamic entries referencing .dynstr strings.  */
3332   for (extdyn = sdyn->contents;
3333        extdyn < sdyn->contents + sdyn->size;
3334        extdyn += bed->s->sizeof_dyn)
3335     {
3336       Elf_Internal_Dyn dyn;
3337
3338       bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3339       switch (dyn.d_tag)
3340         {
3341         case DT_STRSZ:
3342           dyn.d_un.d_val = size;
3343           break;
3344         case DT_NEEDED:
3345         case DT_SONAME:
3346         case DT_RPATH:
3347         case DT_RUNPATH:
3348         case DT_FILTER:
3349         case DT_AUXILIARY:
3350         case DT_AUDIT:
3351         case DT_DEPAUDIT:
3352           dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3353           break;
3354         default:
3355           continue;
3356         }
3357       bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3358     }
3359
3360   /* Now update local dynamic symbols.  */
3361   for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3362     entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3363                                                   entry->isym.st_name);
3364
3365   /* And the rest of dynamic symbols.  */
3366   elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3367
3368   /* Adjust version definitions.  */
3369   if (elf_tdata (output_bfd)->cverdefs)
3370     {
3371       asection *s;
3372       bfd_byte *p;
3373       bfd_size_type i;
3374       Elf_Internal_Verdef def;
3375       Elf_Internal_Verdaux defaux;
3376
3377       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
3378       p = s->contents;
3379       do
3380         {
3381           _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3382                                    &def);
3383           p += sizeof (Elf_External_Verdef);
3384           if (def.vd_aux != sizeof (Elf_External_Verdef))
3385             continue;
3386           for (i = 0; i < def.vd_cnt; ++i)
3387             {
3388               _bfd_elf_swap_verdaux_in (output_bfd,
3389                                         (Elf_External_Verdaux *) p, &defaux);
3390               defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3391                                                         defaux.vda_name);
3392               _bfd_elf_swap_verdaux_out (output_bfd,
3393                                          &defaux, (Elf_External_Verdaux *) p);
3394               p += sizeof (Elf_External_Verdaux);
3395             }
3396         }
3397       while (def.vd_next);
3398     }
3399
3400   /* Adjust version references.  */
3401   if (elf_tdata (output_bfd)->verref)
3402     {
3403       asection *s;
3404       bfd_byte *p;
3405       bfd_size_type i;
3406       Elf_Internal_Verneed need;
3407       Elf_Internal_Vernaux needaux;
3408
3409       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
3410       p = s->contents;
3411       do
3412         {
3413           _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3414                                     &need);
3415           need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3416           _bfd_elf_swap_verneed_out (output_bfd, &need,
3417                                      (Elf_External_Verneed *) p);
3418           p += sizeof (Elf_External_Verneed);
3419           for (i = 0; i < need.vn_cnt; ++i)
3420             {
3421               _bfd_elf_swap_vernaux_in (output_bfd,
3422                                         (Elf_External_Vernaux *) p, &needaux);
3423               needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3424                                                          needaux.vna_name);
3425               _bfd_elf_swap_vernaux_out (output_bfd,
3426                                          &needaux,
3427                                          (Elf_External_Vernaux *) p);
3428               p += sizeof (Elf_External_Vernaux);
3429             }
3430         }
3431       while (need.vn_next);
3432     }
3433
3434   return TRUE;
3435 }
3436 \f
3437 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3438    The default is to only match when the INPUT and OUTPUT are exactly
3439    the same target.  */
3440
3441 bfd_boolean
3442 _bfd_elf_default_relocs_compatible (const bfd_target *input,
3443                                     const bfd_target *output)
3444 {
3445   return input == output;
3446 }
3447
3448 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3449    This version is used when different targets for the same architecture
3450    are virtually identical.  */
3451
3452 bfd_boolean
3453 _bfd_elf_relocs_compatible (const bfd_target *input,
3454                             const bfd_target *output)
3455 {
3456   const struct elf_backend_data *obed, *ibed;
3457
3458   if (input == output)
3459     return TRUE;
3460
3461   ibed = xvec_get_elf_backend_data (input);
3462   obed = xvec_get_elf_backend_data (output);
3463
3464   if (ibed->arch != obed->arch)
3465     return FALSE;
3466
3467   /* If both backends are using this function, deem them compatible.  */
3468   return ibed->relocs_compatible == obed->relocs_compatible;
3469 }
3470
3471 /* Make a special call to the linker "notice" function to tell it that
3472    we are about to handle an as-needed lib, or have finished
3473    processing the lib.  */
3474
3475 bfd_boolean
3476 _bfd_elf_notice_as_needed (bfd *ibfd,
3477                            struct bfd_link_info *info,
3478                            enum notice_asneeded_action act)
3479 {
3480   return (*info->callbacks->notice) (info, NULL, NULL, ibfd, NULL, act, 0);
3481 }
3482
3483 /* Add symbols from an ELF object file to the linker hash table.  */
3484
3485 static bfd_boolean
3486 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3487 {
3488   Elf_Internal_Ehdr *ehdr;
3489   Elf_Internal_Shdr *hdr;
3490   bfd_size_type symcount;
3491   bfd_size_type extsymcount;
3492   bfd_size_type extsymoff;
3493   struct elf_link_hash_entry **sym_hash;
3494   bfd_boolean dynamic;
3495   Elf_External_Versym *extversym = NULL;
3496   Elf_External_Versym *ever;
3497   struct elf_link_hash_entry *weaks;
3498   struct elf_link_hash_entry **nondeflt_vers = NULL;
3499   bfd_size_type nondeflt_vers_cnt = 0;
3500   Elf_Internal_Sym *isymbuf = NULL;
3501   Elf_Internal_Sym *isym;
3502   Elf_Internal_Sym *isymend;
3503   const struct elf_backend_data *bed;
3504   bfd_boolean add_needed;
3505   struct elf_link_hash_table *htab;
3506   bfd_size_type amt;
3507   void *alloc_mark = NULL;
3508   struct bfd_hash_entry **old_table = NULL;
3509   unsigned int old_size = 0;
3510   unsigned int old_count = 0;
3511   void *old_tab = NULL;
3512   void *old_ent;
3513   struct bfd_link_hash_entry *old_undefs = NULL;
3514   struct bfd_link_hash_entry *old_undefs_tail = NULL;
3515   long old_dynsymcount = 0;
3516   bfd_size_type old_dynstr_size = 0;
3517   size_t tabsize = 0;
3518   asection *s;
3519   bfd_boolean just_syms;
3520
3521   htab = elf_hash_table (info);
3522   bed = get_elf_backend_data (abfd);
3523
3524   if ((abfd->flags & DYNAMIC) == 0)
3525     dynamic = FALSE;
3526   else
3527     {
3528       dynamic = TRUE;
3529
3530       /* You can't use -r against a dynamic object.  Also, there's no
3531          hope of using a dynamic object which does not exactly match
3532          the format of the output file.  */
3533       if (bfd_link_relocatable (info)
3534           || !is_elf_hash_table (htab)
3535           || info->output_bfd->xvec != abfd->xvec)
3536         {
3537           if (bfd_link_relocatable (info))
3538             bfd_set_error (bfd_error_invalid_operation);
3539           else
3540             bfd_set_error (bfd_error_wrong_format);
3541           goto error_return;
3542         }
3543     }
3544
3545   ehdr = elf_elfheader (abfd);
3546   if (info->warn_alternate_em
3547       && bed->elf_machine_code != ehdr->e_machine
3548       && ((bed->elf_machine_alt1 != 0
3549            && ehdr->e_machine == bed->elf_machine_alt1)
3550           || (bed->elf_machine_alt2 != 0
3551               && ehdr->e_machine == bed->elf_machine_alt2)))
3552     info->callbacks->einfo
3553       (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3554        ehdr->e_machine, abfd, bed->elf_machine_code);
3555
3556   /* As a GNU extension, any input sections which are named
3557      .gnu.warning.SYMBOL are treated as warning symbols for the given
3558      symbol.  This differs from .gnu.warning sections, which generate
3559      warnings when they are included in an output file.  */
3560   /* PR 12761: Also generate this warning when building shared libraries.  */
3561   for (s = abfd->sections; s != NULL; s = s->next)
3562     {
3563       const char *name;
3564
3565       name = bfd_get_section_name (abfd, s);
3566       if (CONST_STRNEQ (name, ".gnu.warning."))
3567         {
3568           char *msg;
3569           bfd_size_type sz;
3570
3571           name += sizeof ".gnu.warning." - 1;
3572
3573           /* If this is a shared object, then look up the symbol
3574              in the hash table.  If it is there, and it is already
3575              been defined, then we will not be using the entry
3576              from this shared object, so we don't need to warn.
3577              FIXME: If we see the definition in a regular object
3578              later on, we will warn, but we shouldn't.  The only
3579              fix is to keep track of what warnings we are supposed
3580              to emit, and then handle them all at the end of the
3581              link.  */
3582           if (dynamic)
3583             {
3584               struct elf_link_hash_entry *h;
3585
3586               h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3587
3588               /* FIXME: What about bfd_link_hash_common?  */
3589               if (h != NULL
3590                   && (h->root.type == bfd_link_hash_defined
3591                       || h->root.type == bfd_link_hash_defweak))
3592                 continue;
3593             }
3594
3595           sz = s->size;
3596           msg = (char *) bfd_alloc (abfd, sz + 1);
3597           if (msg == NULL)
3598             goto error_return;
3599
3600           if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3601             goto error_return;
3602
3603           msg[sz] = '\0';
3604
3605           if (! (_bfd_generic_link_add_one_symbol
3606                  (info, abfd, name, BSF_WARNING, s, 0, msg,
3607                   FALSE, bed->collect, NULL)))
3608             goto error_return;
3609
3610           if (bfd_link_executable (info))
3611             {
3612               /* Clobber the section size so that the warning does
3613                  not get copied into the output file.  */
3614               s->size = 0;
3615
3616               /* Also set SEC_EXCLUDE, so that symbols defined in
3617                  the warning section don't get copied to the output.  */
3618               s->flags |= SEC_EXCLUDE;
3619             }
3620         }
3621     }
3622
3623   just_syms = ((s = abfd->sections) != NULL
3624                && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS);
3625
3626   add_needed = TRUE;
3627   if (! dynamic)
3628     {
3629       /* If we are creating a shared library, create all the dynamic
3630          sections immediately.  We need to attach them to something,
3631          so we attach them to this BFD, provided it is the right
3632          format and is not from ld --just-symbols.  Always create the
3633          dynamic sections for -E/--dynamic-list.  FIXME: If there
3634          are no input BFD's of the same format as the output, we can't
3635          make a shared library.  */
3636       if (!just_syms
3637           && (bfd_link_pic (info)
3638               || (!bfd_link_relocatable (info)
3639                   && (info->export_dynamic || info->dynamic)))
3640           && is_elf_hash_table (htab)
3641           && info->output_bfd->xvec == abfd->xvec
3642           && !htab->dynamic_sections_created)
3643         {
3644           if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3645             goto error_return;
3646         }
3647     }
3648   else if (!is_elf_hash_table (htab))
3649     goto error_return;
3650   else
3651     {
3652       const char *soname = NULL;
3653       char *audit = NULL;
3654       struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3655       int ret;
3656
3657       /* ld --just-symbols and dynamic objects don't mix very well.
3658          ld shouldn't allow it.  */
3659       if (just_syms)
3660         abort ();
3661
3662       /* If this dynamic lib was specified on the command line with
3663          --as-needed in effect, then we don't want to add a DT_NEEDED
3664          tag unless the lib is actually used.  Similary for libs brought
3665          in by another lib's DT_NEEDED.  When --no-add-needed is used
3666          on a dynamic lib, we don't want to add a DT_NEEDED entry for
3667          any dynamic library in DT_NEEDED tags in the dynamic lib at
3668          all.  */
3669       add_needed = (elf_dyn_lib_class (abfd)
3670                     & (DYN_AS_NEEDED | DYN_DT_NEEDED
3671                        | DYN_NO_NEEDED)) == 0;
3672
3673       s = bfd_get_section_by_name (abfd, ".dynamic");
3674       if (s != NULL)
3675         {
3676           bfd_byte *dynbuf;
3677           bfd_byte *extdyn;
3678           unsigned int elfsec;
3679           unsigned long shlink;
3680
3681           if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3682             {
3683 error_free_dyn:
3684               free (dynbuf);
3685               goto error_return;
3686             }
3687
3688           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3689           if (elfsec == SHN_BAD)
3690             goto error_free_dyn;
3691           shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3692
3693           for (extdyn = dynbuf;
3694                extdyn < dynbuf + s->size;
3695                extdyn += bed->s->sizeof_dyn)
3696             {
3697               Elf_Internal_Dyn dyn;
3698
3699               bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3700               if (dyn.d_tag == DT_SONAME)
3701                 {
3702                   unsigned int tagv = dyn.d_un.d_val;
3703                   soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3704                   if (soname == NULL)
3705                     goto error_free_dyn;
3706                 }
3707               if (dyn.d_tag == DT_NEEDED)
3708                 {
3709                   struct bfd_link_needed_list *n, **pn;
3710                   char *fnm, *anm;
3711                   unsigned int tagv = dyn.d_un.d_val;
3712
3713                   amt = sizeof (struct bfd_link_needed_list);
3714                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3715                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3716                   if (n == NULL || fnm == NULL)
3717                     goto error_free_dyn;
3718                   amt = strlen (fnm) + 1;
3719                   anm = (char *) bfd_alloc (abfd, amt);
3720                   if (anm == NULL)
3721                     goto error_free_dyn;
3722                   memcpy (anm, fnm, amt);
3723                   n->name = anm;
3724                   n->by = abfd;
3725                   n->next = NULL;
3726                   for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3727                     ;
3728                   *pn = n;
3729                 }
3730               if (dyn.d_tag == DT_RUNPATH)
3731                 {
3732                   struct bfd_link_needed_list *n, **pn;
3733                   char *fnm, *anm;
3734                   unsigned int tagv = dyn.d_un.d_val;
3735
3736                   amt = sizeof (struct bfd_link_needed_list);
3737                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3738                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3739                   if (n == NULL || fnm == NULL)
3740                     goto error_free_dyn;
3741                   amt = strlen (fnm) + 1;
3742                   anm = (char *) bfd_alloc (abfd, amt);
3743                   if (anm == NULL)
3744                     goto error_free_dyn;
3745                   memcpy (anm, fnm, amt);
3746                   n->name = anm;
3747                   n->by = abfd;
3748                   n->next = NULL;
3749                   for (pn = & runpath;
3750                        *pn != NULL;
3751                        pn = &(*pn)->next)
3752                     ;
3753                   *pn = n;
3754                 }
3755               /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3756               if (!runpath && dyn.d_tag == DT_RPATH)
3757                 {
3758                   struct bfd_link_needed_list *n, **pn;
3759                   char *fnm, *anm;
3760                   unsigned int tagv = dyn.d_un.d_val;
3761
3762                   amt = sizeof (struct bfd_link_needed_list);
3763                   n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3764                   fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3765                   if (n == NULL || fnm == NULL)
3766                     goto error_free_dyn;
3767                   amt = strlen (fnm) + 1;
3768                   anm = (char *) bfd_alloc (abfd, amt);
3769                   if (anm == NULL)
3770                     goto error_free_dyn;
3771                   memcpy (anm, fnm, amt);
3772                   n->name = anm;
3773                   n->by = abfd;
3774                   n->next = NULL;
3775                   for (pn = & rpath;
3776                        *pn != NULL;
3777                        pn = &(*pn)->next)
3778                     ;
3779                   *pn = n;
3780                 }
3781               if (dyn.d_tag == DT_AUDIT)
3782                 {
3783                   unsigned int tagv = dyn.d_un.d_val;
3784                   audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3785                 }
3786             }
3787
3788           free (dynbuf);
3789         }
3790
3791       /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3792          frees all more recently bfd_alloc'd blocks as well.  */
3793       if (runpath)
3794         rpath = runpath;
3795
3796       if (rpath)
3797         {
3798           struct bfd_link_needed_list **pn;
3799           for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3800             ;
3801           *pn = rpath;
3802         }
3803
3804       /* We do not want to include any of the sections in a dynamic
3805          object in the output file.  We hack by simply clobbering the
3806          list of sections in the BFD.  This could be handled more
3807          cleanly by, say, a new section flag; the existing
3808          SEC_NEVER_LOAD flag is not the one we want, because that one
3809          still implies that the section takes up space in the output
3810          file.  */
3811       bfd_section_list_clear (abfd);
3812
3813       /* Find the name to use in a DT_NEEDED entry that refers to this
3814          object.  If the object has a DT_SONAME entry, we use it.
3815          Otherwise, if the generic linker stuck something in
3816          elf_dt_name, we use that.  Otherwise, we just use the file
3817          name.  */
3818       if (soname == NULL || *soname == '\0')
3819         {
3820           soname = elf_dt_name (abfd);
3821           if (soname == NULL || *soname == '\0')
3822             soname = bfd_get_filename (abfd);
3823         }
3824
3825       /* Save the SONAME because sometimes the linker emulation code
3826          will need to know it.  */
3827       elf_dt_name (abfd) = soname;
3828
3829       ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3830       if (ret < 0)
3831         goto error_return;
3832
3833       /* If we have already included this dynamic object in the
3834          link, just ignore it.  There is no reason to include a
3835          particular dynamic object more than once.  */
3836       if (ret > 0)
3837         return TRUE;
3838
3839       /* Save the DT_AUDIT entry for the linker emulation code. */
3840       elf_dt_audit (abfd) = audit;
3841     }
3842
3843   /* If this is a dynamic object, we always link against the .dynsym
3844      symbol table, not the .symtab symbol table.  The dynamic linker
3845      will only see the .dynsym symbol table, so there is no reason to
3846      look at .symtab for a dynamic object.  */
3847
3848   if (! dynamic || elf_dynsymtab (abfd) == 0)
3849     hdr = &elf_tdata (abfd)->symtab_hdr;
3850   else
3851     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3852
3853   symcount = hdr->sh_size / bed->s->sizeof_sym;
3854
3855   /* The sh_info field of the symtab header tells us where the
3856      external symbols start.  We don't care about the local symbols at
3857      this point.  */
3858   if (elf_bad_symtab (abfd))
3859     {
3860       extsymcount = symcount;
3861       extsymoff = 0;
3862     }
3863   else
3864     {
3865       extsymcount = symcount - hdr->sh_info;
3866       extsymoff = hdr->sh_info;
3867     }
3868
3869   sym_hash = elf_sym_hashes (abfd);
3870   if (extsymcount != 0)
3871     {
3872       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3873                                       NULL, NULL, NULL);
3874       if (isymbuf == NULL)
3875         goto error_return;
3876
3877       if (sym_hash == NULL)
3878         {
3879           /* We store a pointer to the hash table entry for each
3880              external symbol.  */
3881           amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3882           sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
3883           if (sym_hash == NULL)
3884             goto error_free_sym;
3885           elf_sym_hashes (abfd) = sym_hash;
3886         }
3887     }
3888
3889   if (dynamic)
3890     {
3891       /* Read in any version definitions.  */
3892       if (!_bfd_elf_slurp_version_tables (abfd,
3893                                           info->default_imported_symver))
3894         goto error_free_sym;
3895
3896       /* Read in the symbol versions, but don't bother to convert them
3897          to internal format.  */
3898       if (elf_dynversym (abfd) != 0)
3899         {
3900           Elf_Internal_Shdr *versymhdr;
3901
3902           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3903           extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3904           if (extversym == NULL)
3905             goto error_free_sym;
3906           amt = versymhdr->sh_size;
3907           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3908               || bfd_bread (extversym, amt, abfd) != amt)
3909             goto error_free_vers;
3910         }
3911     }
3912
3913   /* If we are loading an as-needed shared lib, save the symbol table
3914      state before we start adding symbols.  If the lib turns out
3915      to be unneeded, restore the state.  */
3916   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3917     {
3918       unsigned int i;
3919       size_t entsize;
3920
3921       for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3922         {
3923           struct bfd_hash_entry *p;
3924           struct elf_link_hash_entry *h;
3925
3926           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3927             {
3928               h = (struct elf_link_hash_entry *) p;
3929               entsize += htab->root.table.entsize;
3930               if (h->root.type == bfd_link_hash_warning)
3931                 entsize += htab->root.table.entsize;
3932             }
3933         }
3934
3935       tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3936       old_tab = bfd_malloc (tabsize + entsize);
3937       if (old_tab == NULL)
3938         goto error_free_vers;
3939
3940       /* Remember the current objalloc pointer, so that all mem for
3941          symbols added can later be reclaimed.  */
3942       alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3943       if (alloc_mark == NULL)
3944         goto error_free_vers;
3945
3946       /* Make a special call to the linker "notice" function to
3947          tell it that we are about to handle an as-needed lib.  */
3948       if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed))
3949         goto error_free_vers;
3950
3951       /* Clone the symbol table.  Remember some pointers into the
3952          symbol table, and dynamic symbol count.  */
3953       old_ent = (char *) old_tab + tabsize;
3954       memcpy (old_tab, htab->root.table.table, tabsize);
3955       old_undefs = htab->root.undefs;
3956       old_undefs_tail = htab->root.undefs_tail;
3957       old_table = htab->root.table.table;
3958       old_size = htab->root.table.size;
3959       old_count = htab->root.table.count;
3960       old_dynsymcount = htab->dynsymcount;
3961       old_dynstr_size = _bfd_elf_strtab_size (htab->dynstr);
3962
3963       for (i = 0; i < htab->root.table.size; i++)
3964         {
3965           struct bfd_hash_entry *p;
3966           struct elf_link_hash_entry *h;
3967
3968           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3969             {
3970               memcpy (old_ent, p, htab->root.table.entsize);
3971               old_ent = (char *) old_ent + htab->root.table.entsize;
3972               h = (struct elf_link_hash_entry *) p;
3973               if (h->root.type == bfd_link_hash_warning)
3974                 {
3975                   memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3976                   old_ent = (char *) old_ent + htab->root.table.entsize;
3977                 }
3978             }
3979         }
3980     }
3981
3982   weaks = NULL;
3983   ever = extversym != NULL ? extversym + extsymoff : NULL;
3984   for (isym = isymbuf, isymend = isymbuf + extsymcount;
3985        isym < isymend;
3986        isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3987     {
3988       int bind;
3989       bfd_vma value;
3990       asection *sec, *new_sec;
3991       flagword flags;
3992       const char *name;
3993       struct elf_link_hash_entry *h;
3994       struct elf_link_hash_entry *hi;
3995       bfd_boolean definition;
3996       bfd_boolean size_change_ok;
3997       bfd_boolean type_change_ok;
3998       bfd_boolean new_weakdef;
3999       bfd_boolean new_weak;
4000       bfd_boolean old_weak;
4001       bfd_boolean override;
4002       bfd_boolean common;
4003       unsigned int old_alignment;
4004       bfd *old_bfd;
4005       bfd_boolean matched;
4006
4007       override = FALSE;
4008
4009       flags = BSF_NO_FLAGS;
4010       sec = NULL;
4011       value = isym->st_value;
4012       common = bed->common_definition (isym);
4013
4014       bind = ELF_ST_BIND (isym->st_info);
4015       switch (bind)
4016         {
4017         case STB_LOCAL:
4018           /* This should be impossible, since ELF requires that all
4019              global symbols follow all local symbols, and that sh_info
4020              point to the first global symbol.  Unfortunately, Irix 5
4021              screws this up.  */
4022           continue;
4023
4024         case STB_GLOBAL:
4025           if (isym->st_shndx != SHN_UNDEF && !common)
4026             flags = BSF_GLOBAL;
4027           break;
4028
4029         case STB_WEAK:
4030           flags = BSF_WEAK;
4031           break;
4032
4033         case STB_GNU_UNIQUE:
4034           flags = BSF_GNU_UNIQUE;
4035           break;
4036
4037         default:
4038           /* Leave it up to the processor backend.  */
4039           break;
4040         }
4041
4042       if (isym->st_shndx == SHN_UNDEF)
4043         sec = bfd_und_section_ptr;
4044       else if (isym->st_shndx == SHN_ABS)
4045         sec = bfd_abs_section_ptr;
4046       else if (isym->st_shndx == SHN_COMMON)
4047         {
4048           sec = bfd_com_section_ptr;
4049           /* What ELF calls the size we call the value.  What ELF
4050              calls the value we call the alignment.  */
4051           value = isym->st_size;
4052         }
4053       else
4054         {
4055           sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4056           if (sec == NULL)
4057             sec = bfd_abs_section_ptr;
4058           else if (discarded_section (sec))
4059             {
4060               /* Symbols from discarded section are undefined.  We keep
4061                  its visibility.  */
4062               sec = bfd_und_section_ptr;
4063               isym->st_shndx = SHN_UNDEF;
4064             }
4065           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
4066             value -= sec->vma;
4067         }
4068
4069       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4070                                               isym->st_name);
4071       if (name == NULL)
4072         goto error_free_vers;
4073
4074       if (isym->st_shndx == SHN_COMMON
4075           && (abfd->flags & BFD_PLUGIN) != 0)
4076         {
4077           asection *xc = bfd_get_section_by_name (abfd, "COMMON");
4078
4079           if (xc == NULL)
4080             {
4081               flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
4082                                  | SEC_EXCLUDE);
4083               xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
4084               if (xc == NULL)
4085                 goto error_free_vers;
4086             }
4087           sec = xc;
4088         }
4089       else if (isym->st_shndx == SHN_COMMON
4090                && ELF_ST_TYPE (isym->st_info) == STT_TLS
4091                && !bfd_link_relocatable (info))
4092         {
4093           asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
4094
4095           if (tcomm == NULL)
4096             {
4097               flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
4098                                  | SEC_LINKER_CREATED);
4099               tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
4100               if (tcomm == NULL)
4101                 goto error_free_vers;
4102             }
4103           sec = tcomm;
4104         }
4105       else if (bed->elf_add_symbol_hook)
4106         {
4107           if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
4108                                              &sec, &value))
4109             goto error_free_vers;
4110
4111           /* The hook function sets the name to NULL if this symbol
4112              should be skipped for some reason.  */
4113           if (name == NULL)
4114             continue;
4115         }
4116
4117       /* Sanity check that all possibilities were handled.  */
4118       if (sec == NULL)
4119         {
4120           bfd_set_error (bfd_error_bad_value);
4121           goto error_free_vers;
4122         }
4123
4124       /* Silently discard TLS symbols from --just-syms.  There's
4125          no way to combine a static TLS block with a new TLS block
4126          for this executable.  */
4127       if (ELF_ST_TYPE (isym->st_info) == STT_TLS
4128           && sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4129         continue;
4130
4131       if (bfd_is_und_section (sec)
4132           || bfd_is_com_section (sec))
4133         definition = FALSE;
4134       else
4135         definition = TRUE;
4136
4137       size_change_ok = FALSE;
4138       type_change_ok = bed->type_change_ok;
4139       old_weak = FALSE;
4140       matched = FALSE;
4141       old_alignment = 0;
4142       old_bfd = NULL;
4143       new_sec = sec;
4144
4145       if (is_elf_hash_table (htab))
4146         {
4147           Elf_Internal_Versym iver;
4148           unsigned int vernum = 0;
4149           bfd_boolean skip;
4150
4151           if (ever == NULL)
4152             {
4153               if (info->default_imported_symver)
4154                 /* Use the default symbol version created earlier.  */
4155                 iver.vs_vers = elf_tdata (abfd)->cverdefs;
4156               else
4157                 iver.vs_vers = 0;
4158             }
4159           else
4160             _bfd_elf_swap_versym_in (abfd, ever, &iver);
4161
4162           vernum = iver.vs_vers & VERSYM_VERSION;
4163
4164           /* If this is a hidden symbol, or if it is not version
4165              1, we append the version name to the symbol name.
4166              However, we do not modify a non-hidden absolute symbol
4167              if it is not a function, because it might be the version
4168              symbol itself.  FIXME: What if it isn't?  */
4169           if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4170               || (vernum > 1
4171                   && (!bfd_is_abs_section (sec)
4172                       || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4173             {
4174               const char *verstr;
4175               size_t namelen, verlen, newlen;
4176               char *newname, *p;
4177
4178               if (isym->st_shndx != SHN_UNDEF)
4179                 {
4180                   if (vernum > elf_tdata (abfd)->cverdefs)
4181                     verstr = NULL;
4182                   else if (vernum > 1)
4183                     verstr =
4184                       elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4185                   else
4186                     verstr = "";
4187
4188                   if (verstr == NULL)
4189                     {
4190                       (*_bfd_error_handler)
4191                         (_("%B: %s: invalid version %u (max %d)"),
4192                          abfd, name, vernum,
4193                          elf_tdata (abfd)->cverdefs);
4194                       bfd_set_error (bfd_error_bad_value);
4195                       goto error_free_vers;
4196                     }
4197                 }
4198               else
4199                 {
4200                   /* We cannot simply test for the number of
4201                      entries in the VERNEED section since the
4202                      numbers for the needed versions do not start
4203                      at 0.  */
4204                   Elf_Internal_Verneed *t;
4205
4206                   verstr = NULL;
4207                   for (t = elf_tdata (abfd)->verref;
4208                        t != NULL;
4209                        t = t->vn_nextref)
4210                     {
4211                       Elf_Internal_Vernaux *a;
4212
4213                       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4214                         {
4215                           if (a->vna_other == vernum)
4216                             {
4217                               verstr = a->vna_nodename;
4218                               break;
4219                             }
4220                         }
4221                       if (a != NULL)
4222                         break;
4223                     }
4224                   if (verstr == NULL)
4225                     {
4226                       (*_bfd_error_handler)
4227                         (_("%B: %s: invalid needed version %d"),
4228                          abfd, name, vernum);
4229                       bfd_set_error (bfd_error_bad_value);
4230                       goto error_free_vers;
4231                     }
4232                 }
4233
4234               namelen = strlen (name);
4235               verlen = strlen (verstr);
4236               newlen = namelen + verlen + 2;
4237               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4238                   && isym->st_shndx != SHN_UNDEF)
4239                 ++newlen;
4240
4241               newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4242               if (newname == NULL)
4243                 goto error_free_vers;
4244               memcpy (newname, name, namelen);
4245               p = newname + namelen;
4246               *p++ = ELF_VER_CHR;
4247               /* If this is a defined non-hidden version symbol,
4248                  we add another @ to the name.  This indicates the
4249                  default version of the symbol.  */
4250               if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4251                   && isym->st_shndx != SHN_UNDEF)
4252                 *p++ = ELF_VER_CHR;
4253               memcpy (p, verstr, verlen + 1);
4254
4255               name = newname;
4256             }
4257
4258           /* If this symbol has default visibility and the user has
4259              requested we not re-export it, then mark it as hidden.  */
4260           if (!bfd_is_und_section (sec)
4261               && !dynamic
4262               && abfd->no_export
4263               && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
4264             isym->st_other = (STV_HIDDEN
4265                               | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
4266
4267           if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
4268                                       sym_hash, &old_bfd, &old_weak,
4269                                       &old_alignment, &skip, &override,
4270                                       &type_change_ok, &size_change_ok,
4271                                       &matched))
4272             goto error_free_vers;
4273
4274           if (skip)
4275             continue;
4276
4277           /* Override a definition only if the new symbol matches the
4278              existing one.  */
4279           if (override && matched)
4280             definition = FALSE;
4281
4282           h = *sym_hash;
4283           while (h->root.type == bfd_link_hash_indirect
4284                  || h->root.type == bfd_link_hash_warning)
4285             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4286
4287           if (elf_tdata (abfd)->verdef != NULL
4288               && vernum > 1
4289               && definition)
4290             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4291         }
4292
4293       if (! (_bfd_generic_link_add_one_symbol
4294              (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4295               (struct bfd_link_hash_entry **) sym_hash)))
4296         goto error_free_vers;
4297
4298       h = *sym_hash;
4299       /* We need to make sure that indirect symbol dynamic flags are
4300          updated.  */
4301       hi = h;
4302       while (h->root.type == bfd_link_hash_indirect
4303              || h->root.type == bfd_link_hash_warning)
4304         h = (struct elf_link_hash_entry *) h->root.u.i.link;
4305
4306       *sym_hash = h;
4307
4308       new_weak = (flags & BSF_WEAK) != 0;
4309       new_weakdef = FALSE;
4310       if (dynamic
4311           && definition
4312           && new_weak
4313           && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4314           && is_elf_hash_table (htab)
4315           && h->u.weakdef == NULL)
4316         {
4317           /* Keep a list of all weak defined non function symbols from
4318              a dynamic object, using the weakdef field.  Later in this
4319              function we will set the weakdef field to the correct
4320              value.  We only put non-function symbols from dynamic
4321              objects on this list, because that happens to be the only
4322              time we need to know the normal symbol corresponding to a
4323              weak symbol, and the information is time consuming to
4324              figure out.  If the weakdef field is not already NULL,
4325              then this symbol was already defined by some previous
4326              dynamic object, and we will be using that previous
4327              definition anyhow.  */
4328
4329           h->u.weakdef = weaks;
4330           weaks = h;
4331           new_weakdef = TRUE;
4332         }
4333
4334       /* Set the alignment of a common symbol.  */
4335       if ((common || bfd_is_com_section (sec))
4336           && h->root.type == bfd_link_hash_common)
4337         {
4338           unsigned int align;
4339
4340           if (common)
4341             align = bfd_log2 (isym->st_value);
4342           else
4343             {
4344               /* The new symbol is a common symbol in a shared object.
4345                  We need to get the alignment from the section.  */
4346               align = new_sec->alignment_power;
4347             }
4348           if (align > old_alignment)
4349             h->root.u.c.p->alignment_power = align;
4350           else
4351             h->root.u.c.p->alignment_power = old_alignment;
4352         }
4353
4354       if (is_elf_hash_table (htab))
4355         {
4356           /* Set a flag in the hash table entry indicating the type of
4357              reference or definition we just found.  A dynamic symbol
4358              is one which is referenced or defined by both a regular
4359              object and a shared object.  */
4360           bfd_boolean dynsym = FALSE;
4361
4362           /* Plugin symbols aren't normal.  Don't set def_regular or
4363              ref_regular for them, or make them dynamic.  */
4364           if ((abfd->flags & BFD_PLUGIN) != 0)
4365             ;
4366           else if (! dynamic)
4367             {
4368               if (! definition)
4369                 {
4370                   h->ref_regular = 1;
4371                   if (bind != STB_WEAK)
4372                     h->ref_regular_nonweak = 1;
4373                 }
4374               else
4375                 {
4376                   h->def_regular = 1;
4377                   if (h->def_dynamic)
4378                     {
4379                       h->def_dynamic = 0;
4380                       h->ref_dynamic = 1;
4381                     }
4382                 }
4383
4384               /* If the indirect symbol has been forced local, don't
4385                  make the real symbol dynamic.  */
4386               if ((h == hi || !hi->forced_local)
4387                   && (bfd_link_dll (info)
4388                       || h->def_dynamic
4389                       || h->ref_dynamic))
4390                 dynsym = TRUE;
4391             }
4392           else
4393             {
4394               if (! definition)
4395                 {
4396                   h->ref_dynamic = 1;
4397                   hi->ref_dynamic = 1;
4398                 }
4399               else
4400                 {
4401                   h->def_dynamic = 1;
4402                   hi->def_dynamic = 1;
4403                 }
4404
4405               /* If the indirect symbol has been forced local, don't
4406                  make the real symbol dynamic.  */
4407               if ((h == hi || !hi->forced_local)
4408                   && (h->def_regular
4409                       || h->ref_regular
4410                       || (h->u.weakdef != NULL
4411                           && ! new_weakdef
4412                           && h->u.weakdef->dynindx != -1)))
4413                 dynsym = TRUE;
4414             }
4415
4416           /* Check to see if we need to add an indirect symbol for
4417              the default name.  */
4418           if (definition
4419               || (!override && h->root.type == bfd_link_hash_common))
4420             if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4421                                               sec, value, &old_bfd, &dynsym))
4422               goto error_free_vers;
4423
4424           /* Check the alignment when a common symbol is involved. This
4425              can change when a common symbol is overridden by a normal
4426              definition or a common symbol is ignored due to the old
4427              normal definition. We need to make sure the maximum
4428              alignment is maintained.  */
4429           if ((old_alignment || common)
4430               && h->root.type != bfd_link_hash_common)
4431             {
4432               unsigned int common_align;
4433               unsigned int normal_align;
4434               unsigned int symbol_align;
4435               bfd *normal_bfd;
4436               bfd *common_bfd;
4437
4438               BFD_ASSERT (h->root.type == bfd_link_hash_defined
4439                           || h->root.type == bfd_link_hash_defweak);
4440
4441               symbol_align = ffs (h->root.u.def.value) - 1;
4442               if (h->root.u.def.section->owner != NULL
4443                   && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4444                 {
4445                   normal_align = h->root.u.def.section->alignment_power;
4446                   if (normal_align > symbol_align)
4447                     normal_align = symbol_align;
4448                 }
4449               else
4450                 normal_align = symbol_align;
4451
4452               if (old_alignment)
4453                 {
4454                   common_align = old_alignment;
4455                   common_bfd = old_bfd;
4456                   normal_bfd = abfd;
4457                 }
4458               else
4459                 {
4460                   common_align = bfd_log2 (isym->st_value);
4461                   common_bfd = abfd;
4462                   normal_bfd = old_bfd;
4463                 }
4464
4465               if (normal_align < common_align)
4466                 {
4467                   /* PR binutils/2735 */
4468                   if (normal_bfd == NULL)
4469                     (*_bfd_error_handler)
4470                       (_("Warning: alignment %u of common symbol `%s' in %B is"
4471                          " greater than the alignment (%u) of its section %A"),
4472                        common_bfd, h->root.u.def.section,
4473                        1 << common_align, name, 1 << normal_align);
4474                   else
4475                     (*_bfd_error_handler)
4476                       (_("Warning: alignment %u of symbol `%s' in %B"
4477                          " is smaller than %u in %B"),
4478                        normal_bfd, common_bfd,
4479                        1 << normal_align, name, 1 << common_align);
4480                 }
4481             }
4482
4483           /* Remember the symbol size if it isn't undefined.  */
4484           if (isym->st_size != 0
4485               && isym->st_shndx != SHN_UNDEF
4486               && (definition || h->size == 0))
4487             {
4488               if (h->size != 0
4489                   && h->size != isym->st_size
4490                   && ! size_change_ok)
4491                 (*_bfd_error_handler)
4492                   (_("Warning: size of symbol `%s' changed"
4493                      " from %lu in %B to %lu in %B"),
4494                    old_bfd, abfd,
4495                    name, (unsigned long) h->size,
4496                    (unsigned long) isym->st_size);
4497
4498               h->size = isym->st_size;
4499             }
4500
4501           /* If this is a common symbol, then we always want H->SIZE
4502              to be the size of the common symbol.  The code just above
4503              won't fix the size if a common symbol becomes larger.  We
4504              don't warn about a size change here, because that is
4505              covered by --warn-common.  Allow changes between different
4506              function types.  */
4507           if (h->root.type == bfd_link_hash_common)
4508             h->size = h->root.u.c.size;
4509
4510           if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4511               && ((definition && !new_weak)
4512                   || (old_weak && h->root.type == bfd_link_hash_common)
4513                   || h->type == STT_NOTYPE))
4514             {
4515               unsigned int type = ELF_ST_TYPE (isym->st_info);
4516
4517               /* Turn an IFUNC symbol from a DSO into a normal FUNC
4518                  symbol.  */
4519               if (type == STT_GNU_IFUNC
4520                   && (abfd->flags & DYNAMIC) != 0)
4521                 type = STT_FUNC;
4522
4523               if (h->type != type)
4524                 {
4525                   if (h->type != STT_NOTYPE && ! type_change_ok)
4526                     (*_bfd_error_handler)
4527                       (_("Warning: type of symbol `%s' changed"
4528                          " from %d to %d in %B"),
4529                        abfd, name, h->type, type);
4530
4531                   h->type = type;
4532                 }
4533             }
4534
4535           /* Merge st_other field.  */
4536           elf_merge_st_other (abfd, h, isym, sec, definition, dynamic);
4537
4538           /* We don't want to make debug symbol dynamic.  */
4539           if (definition
4540               && (sec->flags & SEC_DEBUGGING)
4541               && !bfd_link_relocatable (info))
4542             dynsym = FALSE;
4543
4544           /* Nor should we make plugin symbols dynamic.  */
4545           if ((abfd->flags & BFD_PLUGIN) != 0)
4546             dynsym = FALSE;
4547
4548           if (definition)
4549             {
4550               h->target_internal = isym->st_target_internal;
4551               h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4552             }
4553
4554           if (definition && !dynamic)
4555             {
4556               char *p = strchr (name, ELF_VER_CHR);
4557               if (p != NULL && p[1] != ELF_VER_CHR)
4558                 {
4559                   /* Queue non-default versions so that .symver x, x@FOO
4560                      aliases can be checked.  */
4561                   if (!nondeflt_vers)
4562                     {
4563                       amt = ((isymend - isym + 1)
4564                              * sizeof (struct elf_link_hash_entry *));
4565                       nondeflt_vers
4566                         = (struct elf_link_hash_entry **) bfd_malloc (amt);
4567                       if (!nondeflt_vers)
4568                         goto error_free_vers;
4569                     }
4570                   nondeflt_vers[nondeflt_vers_cnt++] = h;
4571                 }
4572             }
4573
4574           if (dynsym && h->dynindx == -1)
4575             {
4576               if (! bfd_elf_link_record_dynamic_symbol (info, h))
4577                 goto error_free_vers;
4578               if (h->u.weakdef != NULL
4579                   && ! new_weakdef
4580                   && h->u.weakdef->dynindx == -1)
4581                 {
4582                   if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4583                     goto error_free_vers;
4584                 }
4585             }
4586           else if (h->dynindx != -1)
4587             /* If the symbol already has a dynamic index, but
4588                visibility says it should not be visible, turn it into
4589                a local symbol.  */
4590             switch (ELF_ST_VISIBILITY (h->other))
4591               {
4592               case STV_INTERNAL:
4593               case STV_HIDDEN:
4594                 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4595                 dynsym = FALSE;
4596                 break;
4597               }
4598
4599           /* Don't add DT_NEEDED for references from the dummy bfd nor
4600              for unmatched symbol.  */
4601           if (!add_needed
4602               && matched
4603               && definition
4604               && ((dynsym
4605                    && h->ref_regular_nonweak
4606                    && (old_bfd == NULL
4607                        || (old_bfd->flags & BFD_PLUGIN) == 0))
4608                   || (h->ref_dynamic_nonweak
4609                       && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4610                       && !on_needed_list (elf_dt_name (abfd),
4611                                           htab->needed, NULL))))
4612             {
4613               int ret;
4614               const char *soname = elf_dt_name (abfd);
4615
4616               info->callbacks->minfo ("%!", soname, old_bfd,
4617                                       h->root.root.string);
4618
4619               /* A symbol from a library loaded via DT_NEEDED of some
4620                  other library is referenced by a regular object.
4621                  Add a DT_NEEDED entry for it.  Issue an error if
4622                  --no-add-needed is used and the reference was not
4623                  a weak one.  */
4624               if (old_bfd != NULL
4625                   && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4626                 {
4627                   (*_bfd_error_handler)
4628                     (_("%B: undefined reference to symbol '%s'"),
4629                      old_bfd, name);
4630                   bfd_set_error (bfd_error_missing_dso);
4631                   goto error_free_vers;
4632                 }
4633
4634               elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4635                 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4636
4637               add_needed = TRUE;
4638               ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4639               if (ret < 0)
4640                 goto error_free_vers;
4641
4642               BFD_ASSERT (ret == 0);
4643             }
4644         }
4645     }
4646
4647   if (extversym != NULL)
4648     {
4649       free (extversym);
4650       extversym = NULL;
4651     }
4652
4653   if (isymbuf != NULL)
4654     {
4655       free (isymbuf);
4656       isymbuf = NULL;
4657     }
4658
4659   if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4660     {
4661       unsigned int i;
4662
4663       /* Restore the symbol table.  */
4664       old_ent = (char *) old_tab + tabsize;
4665       memset (elf_sym_hashes (abfd), 0,
4666               extsymcount * sizeof (struct elf_link_hash_entry *));
4667       htab->root.table.table = old_table;
4668       htab->root.table.size = old_size;
4669       htab->root.table.count = old_count;
4670       memcpy (htab->root.table.table, old_tab, tabsize);
4671       htab->root.undefs = old_undefs;
4672       htab->root.undefs_tail = old_undefs_tail;
4673       _bfd_elf_strtab_restore_size (htab->dynstr, old_dynstr_size);
4674       for (i = 0; i < htab->root.table.size; i++)
4675         {
4676           struct bfd_hash_entry *p;
4677           struct elf_link_hash_entry *h;
4678           bfd_size_type size;
4679           unsigned int alignment_power;
4680
4681           for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4682             {
4683               h = (struct elf_link_hash_entry *) p;
4684               if (h->root.type == bfd_link_hash_warning)
4685                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4686               if (h->dynindx >= old_dynsymcount
4687                   && h->dynstr_index < old_dynstr_size)
4688                 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4689
4690               /* Preserve the maximum alignment and size for common
4691                  symbols even if this dynamic lib isn't on DT_NEEDED
4692                  since it can still be loaded at run time by another
4693                  dynamic lib.  */
4694               if (h->root.type == bfd_link_hash_common)
4695                 {
4696                   size = h->root.u.c.size;
4697                   alignment_power = h->root.u.c.p->alignment_power;
4698                 }
4699               else
4700                 {
4701                   size = 0;
4702                   alignment_power = 0;
4703                 }
4704               memcpy (p, old_ent, htab->root.table.entsize);
4705               old_ent = (char *) old_ent + htab->root.table.entsize;
4706               h = (struct elf_link_hash_entry *) p;
4707               if (h->root.type == bfd_link_hash_warning)
4708                 {
4709                   memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4710                   old_ent = (char *) old_ent + htab->root.table.entsize;
4711                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
4712                 }
4713               if (h->root.type == bfd_link_hash_common)
4714                 {
4715                   if (size > h->root.u.c.size)
4716                     h->root.u.c.size = size;
4717                   if (alignment_power > h->root.u.c.p->alignment_power)
4718                     h->root.u.c.p->alignment_power = alignment_power;
4719                 }
4720             }
4721         }
4722
4723       /* Make a special call to the linker "notice" function to
4724          tell it that symbols added for crefs may need to be removed.  */
4725       if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed))
4726         goto error_free_vers;
4727
4728       free (old_tab);
4729       objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4730                            alloc_mark);
4731       if (nondeflt_vers != NULL)
4732         free (nondeflt_vers);
4733       return TRUE;
4734     }
4735
4736   if (old_tab != NULL)
4737     {
4738       if (!(*bed->notice_as_needed) (abfd, info, notice_needed))
4739         goto error_free_vers;
4740       free (old_tab);
4741       old_tab = NULL;
4742     }
4743
4744   /* Now that all the symbols from this input file are created, if
4745      not performing a relocatable link, handle .symver foo, foo@BAR
4746      such that any relocs against foo become foo@BAR.  */
4747   if (!bfd_link_relocatable (info) && nondeflt_vers != NULL)
4748     {
4749       bfd_size_type cnt, symidx;
4750
4751       for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4752         {
4753           struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4754           char *shortname, *p;
4755
4756           p = strchr (h->root.root.string, ELF_VER_CHR);
4757           if (p == NULL
4758               || (h->root.type != bfd_link_hash_defined
4759                   && h->root.type != bfd_link_hash_defweak))
4760             continue;
4761
4762           amt = p - h->root.root.string;
4763           shortname = (char *) bfd_malloc (amt + 1);
4764           if (!shortname)
4765             goto error_free_vers;
4766           memcpy (shortname, h->root.root.string, amt);
4767           shortname[amt] = '\0';
4768
4769           hi = (struct elf_link_hash_entry *)
4770                bfd_link_hash_lookup (&htab->root, shortname,
4771                                      FALSE, FALSE, FALSE);
4772           if (hi != NULL
4773               && hi->root.type == h->root.type
4774               && hi->root.u.def.value == h->root.u.def.value
4775               && hi->root.u.def.section == h->root.u.def.section)
4776             {
4777               (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4778               hi->root.type = bfd_link_hash_indirect;
4779               hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4780               (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4781               sym_hash = elf_sym_hashes (abfd);
4782               if (sym_hash)
4783                 for (symidx = 0; symidx < extsymcount; ++symidx)
4784                   if (sym_hash[symidx] == hi)
4785                     {
4786                       sym_hash[symidx] = h;
4787                       break;
4788                     }
4789             }
4790           free (shortname);
4791         }
4792       free (nondeflt_vers);
4793       nondeflt_vers = NULL;
4794     }
4795
4796   /* Now set the weakdefs field correctly for all the weak defined
4797      symbols we found.  The only way to do this is to search all the
4798      symbols.  Since we only need the information for non functions in
4799      dynamic objects, that's the only time we actually put anything on
4800      the list WEAKS.  We need this information so that if a regular
4801      object refers to a symbol defined weakly in a dynamic object, the
4802      real symbol in the dynamic object is also put in the dynamic
4803      symbols; we also must arrange for both symbols to point to the
4804      same memory location.  We could handle the general case of symbol
4805      aliasing, but a general symbol alias can only be generated in
4806      assembler code, handling it correctly would be very time
4807      consuming, and other ELF linkers don't handle general aliasing
4808      either.  */
4809   if (weaks != NULL)
4810     {
4811       struct elf_link_hash_entry **hpp;
4812       struct elf_link_hash_entry **hppend;
4813       struct elf_link_hash_entry **sorted_sym_hash;
4814       struct elf_link_hash_entry *h;
4815       size_t sym_count;
4816
4817       /* Since we have to search the whole symbol list for each weak
4818          defined symbol, search time for N weak defined symbols will be
4819          O(N^2). Binary search will cut it down to O(NlogN).  */
4820       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4821       sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4822       if (sorted_sym_hash == NULL)
4823         goto error_return;
4824       sym_hash = sorted_sym_hash;
4825       hpp = elf_sym_hashes (abfd);
4826       hppend = hpp + extsymcount;
4827       sym_count = 0;
4828       for (; hpp < hppend; hpp++)
4829         {
4830           h = *hpp;
4831           if (h != NULL
4832               && h->root.type == bfd_link_hash_defined
4833               && !bed->is_function_type (h->type))
4834             {
4835               *sym_hash = h;
4836               sym_hash++;
4837               sym_count++;
4838             }
4839         }
4840
4841       qsort (sorted_sym_hash, sym_count,
4842              sizeof (struct elf_link_hash_entry *),
4843              elf_sort_symbol);
4844
4845       while (weaks != NULL)
4846         {
4847           struct elf_link_hash_entry *hlook;
4848           asection *slook;
4849           bfd_vma vlook;
4850           size_t i, j, idx = 0;
4851
4852           hlook = weaks;
4853           weaks = hlook->u.weakdef;
4854           hlook->u.weakdef = NULL;
4855
4856           BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4857                       || hlook->root.type == bfd_link_hash_defweak
4858                       || hlook->root.type == bfd_link_hash_common
4859                       || hlook->root.type == bfd_link_hash_indirect);
4860           slook = hlook->root.u.def.section;
4861           vlook = hlook->root.u.def.value;
4862
4863           i = 0;
4864           j = sym_count;
4865           while (i != j)
4866             {
4867               bfd_signed_vma vdiff;
4868               idx = (i + j) / 2;
4869               h = sorted_sym_hash[idx];
4870               vdiff = vlook - h->root.u.def.value;
4871               if (vdiff < 0)
4872                 j = idx;
4873               else if (vdiff > 0)
4874                 i = idx + 1;
4875               else
4876                 {
4877                   int sdiff = slook->id - h->root.u.def.section->id;
4878                   if (sdiff < 0)
4879                     j = idx;
4880                   else if (sdiff > 0)
4881                     i = idx + 1;
4882                   else
4883                     break;
4884                 }
4885             }
4886
4887           /* We didn't find a value/section match.  */
4888           if (i == j)
4889             continue;
4890
4891           /* With multiple aliases, or when the weak symbol is already
4892              strongly defined, we have multiple matching symbols and
4893              the binary search above may land on any of them.  Step
4894              one past the matching symbol(s).  */
4895           while (++idx != j)
4896             {
4897               h = sorted_sym_hash[idx];
4898               if (h->root.u.def.section != slook
4899                   || h->root.u.def.value != vlook)
4900                 break;
4901             }
4902
4903           /* Now look back over the aliases.  Since we sorted by size
4904              as well as value and section, we'll choose the one with
4905              the largest size.  */
4906           while (idx-- != i)
4907             {
4908               h = sorted_sym_hash[idx];
4909
4910               /* Stop if value or section doesn't match.  */
4911               if (h->root.u.def.section != slook
4912                   || h->root.u.def.value != vlook)
4913                 break;
4914               else if (h != hlook)
4915                 {
4916                   hlook->u.weakdef = h;
4917
4918                   /* If the weak definition is in the list of dynamic
4919                      symbols, make sure the real definition is put
4920                      there as well.  */
4921                   if (hlook->dynindx != -1 && h->dynindx == -1)
4922                     {
4923                       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4924                         {
4925                         err_free_sym_hash:
4926                           free (sorted_sym_hash);
4927                           goto error_return;
4928                         }
4929                     }
4930
4931                   /* If the real definition is in the list of dynamic
4932                      symbols, make sure the weak definition is put
4933                      there as well.  If we don't do this, then the
4934                      dynamic loader might not merge the entries for the
4935                      real definition and the weak definition.  */
4936                   if (h->dynindx != -1 && hlook->dynindx == -1)
4937                     {
4938                       if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4939                         goto err_free_sym_hash;
4940                     }
4941                   break;
4942                 }
4943             }
4944         }
4945
4946       free (sorted_sym_hash);
4947     }
4948
4949   if (bed->check_directives
4950       && !(*bed->check_directives) (abfd, info))
4951     return FALSE;
4952
4953   /* If this object is the same format as the output object, and it is
4954      not a shared library, then let the backend look through the
4955      relocs.
4956
4957      This is required to build global offset table entries and to
4958      arrange for dynamic relocs.  It is not required for the
4959      particular common case of linking non PIC code, even when linking
4960      against shared libraries, but unfortunately there is no way of
4961      knowing whether an object file has been compiled PIC or not.
4962      Looking through the relocs is not particularly time consuming.
4963      The problem is that we must either (1) keep the relocs in memory,
4964      which causes the linker to require additional runtime memory or
4965      (2) read the relocs twice from the input file, which wastes time.
4966      This would be a good case for using mmap.
4967
4968      I have no idea how to handle linking PIC code into a file of a
4969      different format.  It probably can't be done.  */
4970   if (! dynamic
4971       && is_elf_hash_table (htab)
4972       && bed->check_relocs != NULL
4973       && elf_object_id (abfd) == elf_hash_table_id (htab)
4974       && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4975     {
4976       asection *o;
4977
4978       for (o = abfd->sections; o != NULL; o = o->next)
4979         {
4980           Elf_Internal_Rela *internal_relocs;
4981           bfd_boolean ok;
4982
4983           if ((o->flags & SEC_RELOC) == 0
4984               || o->reloc_count == 0
4985               || ((info->strip == strip_all || info->strip == strip_debugger)
4986                   && (o->flags & SEC_DEBUGGING) != 0)
4987               || bfd_is_abs_section (o->output_section))
4988             continue;
4989
4990           internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4991                                                        info->keep_memory);
4992           if (internal_relocs == NULL)
4993             goto error_return;
4994
4995           ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4996
4997           if (elf_section_data (o)->relocs != internal_relocs)
4998             free (internal_relocs);
4999
5000           if (! ok)
5001             goto error_return;
5002         }
5003     }
5004
5005   /* If this is a non-traditional link, try to optimize the handling
5006      of the .stab/.stabstr sections.  */
5007   if (! dynamic
5008       && ! info->traditional_format
5009       && is_elf_hash_table (htab)
5010       && (info->strip != strip_all && info->strip != strip_debugger))
5011     {
5012       asection *stabstr;
5013
5014       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
5015       if (stabstr != NULL)
5016         {
5017           bfd_size_type string_offset = 0;
5018           asection *stab;
5019
5020           for (stab = abfd->sections; stab; stab = stab->next)
5021             if (CONST_STRNEQ (stab->name, ".stab")
5022                 && (!stab->name[5] ||
5023                     (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
5024                 && (stab->flags & SEC_MERGE) == 0
5025                 && !bfd_is_abs_section (stab->output_section))
5026               {
5027                 struct bfd_elf_section_data *secdata;
5028
5029                 secdata = elf_section_data (stab);
5030                 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
5031                                                stabstr, &secdata->sec_info,
5032                                                &string_offset))
5033                   goto error_return;
5034                 if (secdata->sec_info)
5035                   stab->sec_info_type = SEC_INFO_TYPE_STABS;
5036             }
5037         }
5038     }
5039
5040   if (is_elf_hash_table (htab) && add_needed)
5041     {
5042       /* Add this bfd to the loaded list.  */
5043       struct elf_link_loaded_list *n;
5044
5045       n = (struct elf_link_loaded_list *) bfd_alloc (abfd, sizeof (*n));
5046       if (n == NULL)
5047         goto error_return;
5048       n->abfd = abfd;
5049       n->next = htab->loaded;
5050       htab->loaded = n;
5051     }
5052
5053   return TRUE;
5054
5055  error_free_vers:
5056   if (old_tab != NULL)
5057     free (old_tab);
5058   if (nondeflt_vers != NULL)
5059     free (nondeflt_vers);
5060   if (extversym != NULL)
5061     free (extversym);
5062  error_free_sym:
5063   if (isymbuf != NULL)
5064     free (isymbuf);
5065  error_return:
5066   return FALSE;
5067 }
5068
5069 /* Return the linker hash table entry of a symbol that might be
5070    satisfied by an archive symbol.  Return -1 on error.  */
5071
5072 struct elf_link_hash_entry *
5073 _bfd_elf_archive_symbol_lookup (bfd *abfd,
5074                                 struct bfd_link_info *info,
5075                                 const char *name)
5076 {
5077   struct elf_link_hash_entry *h;
5078   char *p, *copy;
5079   size_t len, first;
5080
5081   h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
5082   if (h != NULL)
5083     return h;
5084
5085   /* If this is a default version (the name contains @@), look up the
5086      symbol again with only one `@' as well as without the version.
5087      The effect is that references to the symbol with and without the
5088      version will be matched by the default symbol in the archive.  */
5089
5090   p = strchr (name, ELF_VER_CHR);
5091   if (p == NULL || p[1] != ELF_VER_CHR)
5092     return h;
5093
5094   /* First check with only one `@'.  */
5095   len = strlen (name);
5096   copy = (char *) bfd_alloc (abfd, len);
5097   if (copy == NULL)
5098     return (struct elf_link_hash_entry *) 0 - 1;
5099
5100   first = p - name + 1;
5101   memcpy (copy, name, first);
5102   memcpy (copy + first, name + first + 1, len - first);
5103
5104   h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
5105   if (h == NULL)
5106     {
5107       /* We also need to check references to the symbol without the
5108          version.  */
5109       copy[first - 1] = '\0';
5110       h = elf_link_hash_lookup (elf_hash_table (info), copy,
5111                                 FALSE, FALSE, TRUE);
5112     }
5113
5114   bfd_release (abfd, copy);
5115   return h;
5116 }
5117
5118 /* Add symbols from an ELF archive file to the linker hash table.  We
5119    don't use _bfd_generic_link_add_archive_symbols because we need to
5120    handle versioned symbols.
5121
5122    Fortunately, ELF archive handling is simpler than that done by
5123    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
5124    oddities.  In ELF, if we find a symbol in the archive map, and the
5125    symbol is currently undefined, we know that we must pull in that
5126    object file.
5127
5128    Unfortunately, we do have to make multiple passes over the symbol
5129    table until nothing further is resolved.  */
5130
5131 static bfd_boolean
5132 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
5133 {
5134   symindex c;
5135   unsigned char *included = NULL;
5136   carsym *symdefs;
5137   bfd_boolean loop;
5138   bfd_size_type amt;
5139   const struct elf_backend_data *bed;
5140   struct elf_link_hash_entry * (*archive_symbol_lookup)
5141     (bfd *, struct bfd_link_info *, const char *);
5142
5143   if (! bfd_has_map (abfd))
5144     {
5145       /* An empty archive is a special case.  */
5146       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
5147         return TRUE;
5148       bfd_set_error (bfd_error_no_armap);
5149       return FALSE;
5150     }
5151
5152   /* Keep track of all symbols we know to be already defined, and all
5153      files we know to be already included.  This is to speed up the
5154      second and subsequent passes.  */
5155   c = bfd_ardata (abfd)->symdef_count;
5156   if (c == 0)
5157     return TRUE;
5158   amt = c;
5159   amt *= sizeof (*included);
5160   included = (unsigned char *) bfd_zmalloc (amt);
5161   if (included == NULL)
5162     return FALSE;
5163
5164   symdefs = bfd_ardata (abfd)->symdefs;
5165   bed = get_elf_backend_data (abfd);
5166   archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
5167
5168   do
5169     {
5170       file_ptr last;
5171       symindex i;
5172       carsym *symdef;
5173       carsym *symdefend;
5174
5175       loop = FALSE;
5176       last = -1;
5177
5178       symdef = symdefs;
5179       symdefend = symdef + c;
5180       for (i = 0; symdef < symdefend; symdef++, i++)
5181         {
5182           struct elf_link_hash_entry *h;
5183           bfd *element;
5184           struct bfd_link_hash_entry *undefs_tail;
5185           symindex mark;
5186
5187           if (included[i])
5188             continue;
5189           if (symdef->file_offset == last)
5190             {
5191               included[i] = TRUE;
5192               continue;
5193             }
5194
5195           h = archive_symbol_lookup (abfd, info, symdef->name);
5196           if (h == (struct elf_link_hash_entry *) 0 - 1)
5197             goto error_return;
5198
5199           if (h == NULL)
5200             continue;
5201
5202           if (h->root.type == bfd_link_hash_common)
5203             {
5204               /* We currently have a common symbol.  The archive map contains
5205                  a reference to this symbol, so we may want to include it.  We
5206                  only want to include it however, if this archive element
5207                  contains a definition of the symbol, not just another common
5208                  declaration of it.
5209
5210                  Unfortunately some archivers (including GNU ar) will put
5211                  declarations of common symbols into their archive maps, as
5212                  well as real definitions, so we cannot just go by the archive
5213                  map alone.  Instead we must read in the element's symbol
5214                  table and check that to see what kind of symbol definition
5215                  this is.  */
5216               if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5217                 continue;
5218             }
5219           else if (h->root.type != bfd_link_hash_undefined)
5220             {
5221               if (h->root.type != bfd_link_hash_undefweak)
5222                 /* Symbol must be defined.  Don't check it again.  */
5223                 included[i] = TRUE;
5224               continue;
5225             }
5226
5227           /* We need to include this archive member.  */
5228           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5229           if (element == NULL)
5230             goto error_return;
5231
5232           if (! bfd_check_format (element, bfd_object))
5233             goto error_return;
5234
5235           undefs_tail = info->hash->undefs_tail;
5236
5237           if (!(*info->callbacks
5238                 ->add_archive_element) (info, element, symdef->name, &element))
5239             goto error_return;
5240           if (!bfd_link_add_symbols (element, info))
5241             goto error_return;
5242
5243           /* If there are any new undefined symbols, we need to make
5244              another pass through the archive in order to see whether
5245              they can be defined.  FIXME: This isn't perfect, because
5246              common symbols wind up on undefs_tail and because an
5247              undefined symbol which is defined later on in this pass
5248              does not require another pass.  This isn't a bug, but it
5249              does make the code less efficient than it could be.  */
5250           if (undefs_tail != info->hash->undefs_tail)
5251             loop = TRUE;
5252
5253           /* Look backward to mark all symbols from this object file
5254              which we have already seen in this pass.  */
5255           mark = i;
5256           do
5257             {
5258               included[mark] = TRUE;
5259               if (mark == 0)
5260                 break;
5261               --mark;
5262             }
5263           while (symdefs[mark].file_offset == symdef->file_offset);
5264
5265           /* We mark subsequent symbols from this object file as we go
5266              on through the loop.  */
5267           last = symdef->file_offset;
5268         }
5269     }
5270   while (loop);
5271
5272   free (included);
5273
5274   return TRUE;
5275
5276  error_return:
5277   if (included != NULL)
5278     free (included);
5279   return FALSE;
5280 }
5281
5282 /* Given an ELF BFD, add symbols to the global hash table as
5283    appropriate.  */
5284
5285 bfd_boolean
5286 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5287 {
5288   switch (bfd_get_format (abfd))
5289     {
5290     case bfd_object:
5291       return elf_link_add_object_symbols (abfd, info);
5292     case bfd_archive:
5293       return elf_link_add_archive_symbols (abfd, info);
5294     default:
5295       bfd_set_error (bfd_error_wrong_format);
5296       return FALSE;
5297     }
5298 }
5299 \f
5300 struct hash_codes_info
5301 {
5302   unsigned long *hashcodes;
5303   bfd_boolean error;
5304 };
5305
5306 /* This function will be called though elf_link_hash_traverse to store
5307    all hash value of the exported symbols in an array.  */
5308
5309 static bfd_boolean
5310 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5311 {
5312   struct hash_codes_info *inf = (struct hash_codes_info *) data;
5313   const char *name;
5314   unsigned long ha;
5315   char *alc = NULL;
5316
5317   /* Ignore indirect symbols.  These are added by the versioning code.  */
5318   if (h->dynindx == -1)
5319     return TRUE;
5320
5321   name = h->root.root.string;
5322   if (h->versioned >= versioned)
5323     {
5324       char *p = strchr (name, ELF_VER_CHR);
5325       if (p != NULL)
5326         {
5327           alc = (char *) bfd_malloc (p - name + 1);
5328           if (alc == NULL)
5329             {
5330               inf->error = TRUE;
5331               return FALSE;
5332             }
5333           memcpy (alc, name, p - name);
5334           alc[p - name] = '\0';
5335           name = alc;
5336         }
5337     }
5338
5339   /* Compute the hash value.  */
5340   ha = bfd_elf_hash (name);
5341
5342   /* Store the found hash value in the array given as the argument.  */
5343   *(inf->hashcodes)++ = ha;
5344
5345   /* And store it in the struct so that we can put it in the hash table
5346      later.  */
5347   h->u.elf_hash_value = ha;
5348
5349   if (alc != NULL)
5350     free (alc);
5351
5352   return TRUE;
5353 }
5354
5355 struct collect_gnu_hash_codes
5356 {
5357   bfd *output_bfd;
5358   const struct elf_backend_data *bed;
5359   unsigned long int nsyms;
5360   unsigned long int maskbits;
5361   unsigned long int *hashcodes;
5362   unsigned long int *hashval;
5363   unsigned long int *indx;
5364   unsigned long int *counts;
5365   bfd_vma *bitmask;
5366   bfd_byte *contents;
5367   long int min_dynindx;
5368   unsigned long int bucketcount;
5369   unsigned long int symindx;
5370   long int local_indx;
5371   long int shift1, shift2;
5372   unsigned long int mask;
5373   bfd_boolean error;
5374 };
5375
5376 /* This function will be called though elf_link_hash_traverse to store
5377    all hash value of the exported symbols in an array.  */
5378
5379 static bfd_boolean
5380 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5381 {
5382   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5383   const char *name;
5384   unsigned long ha;
5385   char *alc = NULL;
5386
5387   /* Ignore indirect symbols.  These are added by the versioning code.  */
5388   if (h->dynindx == -1)
5389     return TRUE;
5390
5391   /* Ignore also local symbols and undefined symbols.  */
5392   if (! (*s->bed->elf_hash_symbol) (h))
5393     return TRUE;
5394
5395   name = h->root.root.string;
5396   if (h->versioned >= versioned)
5397     {
5398       char *p = strchr (name, ELF_VER_CHR);
5399       if (p != NULL)
5400         {
5401           alc = (char *) bfd_malloc (p - name + 1);
5402           if (alc == NULL)
5403             {
5404               s->error = TRUE;
5405               return FALSE;
5406             }
5407           memcpy (alc, name, p - name);
5408           alc[p - name] = '\0';
5409           name = alc;
5410         }
5411     }
5412
5413   /* Compute the hash value.  */
5414   ha = bfd_elf_gnu_hash (name);
5415
5416   /* Store the found hash value in the array for compute_bucket_count,
5417      and also for .dynsym reordering purposes.  */
5418   s->hashcodes[s->nsyms] = ha;
5419   s->hashval[h->dynindx] = ha;
5420   ++s->nsyms;
5421   if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5422     s->min_dynindx = h->dynindx;
5423
5424   if (alc != NULL)
5425     free (alc);
5426
5427   return TRUE;
5428 }
5429
5430 /* This function will be called though elf_link_hash_traverse to do
5431    final dynaminc symbol renumbering.  */
5432
5433 static bfd_boolean
5434 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5435 {
5436   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5437   unsigned long int bucket;
5438   unsigned long int val;
5439
5440   /* Ignore indirect symbols.  */
5441   if (h->dynindx == -1)
5442     return TRUE;
5443
5444   /* Ignore also local symbols and undefined symbols.  */
5445   if (! (*s->bed->elf_hash_symbol) (h))
5446     {
5447       if (h->dynindx >= s->min_dynindx)
5448         h->dynindx = s->local_indx++;
5449       return TRUE;
5450     }
5451
5452   bucket = s->hashval[h->dynindx] % s->bucketcount;
5453   val = (s->hashval[h->dynindx] >> s->shift1)
5454         & ((s->maskbits >> s->shift1) - 1);
5455   s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5456   s->bitmask[val]
5457     |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5458   val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5459   if (s->counts[bucket] == 1)
5460     /* Last element terminates the chain.  */
5461     val |= 1;
5462   bfd_put_32 (s->output_bfd, val,
5463               s->contents + (s->indx[bucket] - s->symindx) * 4);
5464   --s->counts[bucket];
5465   h->dynindx = s->indx[bucket]++;
5466   return TRUE;
5467 }
5468
5469 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5470
5471 bfd_boolean
5472 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5473 {
5474   return !(h->forced_local
5475            || h->root.type == bfd_link_hash_undefined
5476            || h->root.type == bfd_link_hash_undefweak
5477            || ((h->root.type == bfd_link_hash_defined
5478                 || h->root.type == bfd_link_hash_defweak)
5479                && h->root.u.def.section->output_section == NULL));
5480 }
5481
5482 /* Array used to determine the number of hash table buckets to use
5483    based on the number of symbols there are.  If there are fewer than
5484    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5485    fewer than 37 we use 17 buckets, and so forth.  We never use more
5486    than 32771 buckets.  */
5487
5488 static const size_t elf_buckets[] =
5489 {
5490   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5491   16411, 32771, 0
5492 };
5493
5494 /* Compute bucket count for hashing table.  We do not use a static set
5495    of possible tables sizes anymore.  Instead we determine for all
5496    possible reasonable sizes of the table the outcome (i.e., the
5497    number of collisions etc) and choose the best solution.  The
5498    weighting functions are not too simple to allow the table to grow
5499    without bounds.  Instead one of the weighting factors is the size.
5500    Therefore the result is always a good payoff between few collisions
5501    (= short chain lengths) and table size.  */
5502 static size_t
5503 compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5504                       unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5505                       unsigned long int nsyms,
5506                       int gnu_hash)
5507 {
5508   size_t best_size = 0;
5509   unsigned long int i;
5510
5511   /* We have a problem here.  The following code to optimize the table
5512      size requires an integer type with more the 32 bits.  If
5513      BFD_HOST_U_64_BIT is set we know about such a type.  */
5514 #ifdef BFD_HOST_U_64_BIT
5515   if (info->optimize)
5516     {
5517       size_t minsize;
5518       size_t maxsize;
5519       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5520       bfd *dynobj = elf_hash_table (info)->dynobj;
5521       size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5522       const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5523       unsigned long int *counts;
5524       bfd_size_type amt;
5525       unsigned int no_improvement_count = 0;
5526
5527       /* Possible optimization parameters: if we have NSYMS symbols we say
5528          that the hashing table must at least have NSYMS/4 and at most
5529          2*NSYMS buckets.  */
5530       minsize = nsyms / 4;
5531       if (minsize == 0)
5532         minsize = 1;
5533       best_size = maxsize = nsyms * 2;
5534       if (gnu_hash)
5535         {
5536           if (minsize < 2)
5537             minsize = 2;
5538           if ((best_size & 31) == 0)
5539             ++best_size;
5540         }
5541
5542       /* Create array where we count the collisions in.  We must use bfd_malloc
5543          since the size could be large.  */
5544       amt = maxsize;
5545       amt *= sizeof (unsigned long int);
5546       counts = (unsigned long int *) bfd_malloc (amt);
5547       if (counts == NULL)
5548         return 0;
5549
5550       /* Compute the "optimal" size for the hash table.  The criteria is a
5551          minimal chain length.  The minor criteria is (of course) the size
5552          of the table.  */
5553       for (i = minsize; i < maxsize; ++i)
5554         {
5555           /* Walk through the array of hashcodes and count the collisions.  */
5556           BFD_HOST_U_64_BIT max;
5557           unsigned long int j;
5558           unsigned long int fact;
5559
5560           if (gnu_hash && (i & 31) == 0)
5561             continue;
5562
5563           memset (counts, '\0', i * sizeof (unsigned long int));
5564
5565           /* Determine how often each hash bucket is used.  */
5566           for (j = 0; j < nsyms; ++j)
5567             ++counts[hashcodes[j] % i];
5568
5569           /* For the weight function we need some information about the
5570              pagesize on the target.  This is information need not be 100%
5571              accurate.  Since this information is not available (so far) we
5572              define it here to a reasonable default value.  If it is crucial
5573              to have a better value some day simply define this value.  */
5574 # ifndef BFD_TARGET_PAGESIZE
5575 #  define BFD_TARGET_PAGESIZE   (4096)
5576 # endif
5577
5578           /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5579              and the chains.  */
5580           max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5581
5582 # if 1
5583           /* Variant 1: optimize for short chains.  We add the squares
5584              of all the chain lengths (which favors many small chain
5585              over a few long chains).  */
5586           for (j = 0; j < i; ++j)
5587             max += counts[j] * counts[j];
5588
5589           /* This adds penalties for the overall size of the table.  */
5590           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5591           max *= fact * fact;
5592 # else
5593           /* Variant 2: Optimize a lot more for small table.  Here we
5594              also add squares of the size but we also add penalties for
5595              empty slots (the +1 term).  */
5596           for (j = 0; j < i; ++j)
5597             max += (1 + counts[j]) * (1 + counts[j]);
5598
5599           /* The overall size of the table is considered, but not as
5600              strong as in variant 1, where it is squared.  */
5601           fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5602           max *= fact;
5603 # endif
5604
5605           /* Compare with current best results.  */
5606           if (max < best_chlen)
5607             {
5608               best_chlen = max;
5609               best_size = i;
5610               no_improvement_count = 0;
5611             }
5612           /* PR 11843: Avoid futile long searches for the best bucket size
5613              when there are a large number of symbols.  */
5614           else if (++no_improvement_count == 100)
5615             break;
5616         }
5617
5618       free (counts);
5619     }
5620   else
5621 #endif /* defined (BFD_HOST_U_64_BIT) */
5622     {
5623       /* This is the fallback solution if no 64bit type is available or if we
5624          are not supposed to spend much time on optimizations.  We select the
5625          bucket count using a fixed set of numbers.  */
5626       for (i = 0; elf_buckets[i] != 0; i++)
5627         {
5628           best_size = elf_buckets[i];
5629           if (nsyms < elf_buckets[i + 1])
5630             break;
5631         }
5632       if (gnu_hash && best_size < 2)
5633         best_size = 2;
5634     }
5635
5636   return best_size;
5637 }
5638
5639 /* Size any SHT_GROUP section for ld -r.  */
5640
5641 bfd_boolean
5642 _bfd_elf_size_group_sections (struct bfd_link_info *info)
5643 {
5644   bfd *ibfd;
5645
5646   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5647     if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5648         && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5649       return FALSE;
5650   return TRUE;
5651 }
5652
5653 /* Set a default stack segment size.  The value in INFO wins.  If it
5654    is unset, LEGACY_SYMBOL's value is used, and if that symbol is
5655    undefined it is initialized.  */
5656
5657 bfd_boolean
5658 bfd_elf_stack_segment_size (bfd *output_bfd,
5659                             struct bfd_link_info *info,
5660                             const char *legacy_symbol,
5661                             bfd_vma default_size)
5662 {
5663   struct elf_link_hash_entry *h = NULL;
5664
5665   /* Look for legacy symbol.  */
5666   if (legacy_symbol)
5667     h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
5668                               FALSE, FALSE, FALSE);
5669   if (h && (h->root.type == bfd_link_hash_defined
5670             || h->root.type == bfd_link_hash_defweak)
5671       && h->def_regular
5672       && (h->type == STT_NOTYPE || h->type == STT_OBJECT))
5673     {
5674       /* The symbol has no type if specified on the command line.  */
5675       h->type = STT_OBJECT;
5676       if (info->stacksize)
5677         (*_bfd_error_handler) (_("%B: stack size specified and %s set"),
5678                                output_bfd, legacy_symbol);
5679       else if (h->root.u.def.section != bfd_abs_section_ptr)
5680         (*_bfd_error_handler) (_("%B: %s not absolute"),
5681                                output_bfd, legacy_symbol);
5682       else
5683         info->stacksize = h->root.u.def.value;
5684     }
5685
5686   if (!info->stacksize)
5687     /* If the user didn't set a size, or explicitly inhibit the
5688        size, set it now.  */
5689     info->stacksize = default_size;
5690
5691   /* Provide the legacy symbol, if it is referenced.  */
5692   if (h && (h->root.type == bfd_link_hash_undefined
5693             || h->root.type == bfd_link_hash_undefweak))
5694     {
5695       struct bfd_link_hash_entry *bh = NULL;
5696
5697       if (!(_bfd_generic_link_add_one_symbol
5698             (info, output_bfd, legacy_symbol,
5699              BSF_GLOBAL, bfd_abs_section_ptr,
5700              info->stacksize >= 0 ? info->stacksize : 0,
5701              NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
5702         return FALSE;
5703
5704       h = (struct elf_link_hash_entry *) bh;
5705       h->def_regular = 1;
5706       h->type = STT_OBJECT;
5707     }
5708
5709   return TRUE;
5710 }
5711
5712 /* Set up the sizes and contents of the ELF dynamic sections.  This is
5713    called by the ELF linker emulation before_allocation routine.  We
5714    must set the sizes of the sections before the linker sets the
5715    addresses of the various sections.  */
5716
5717 bfd_boolean
5718 bfd_elf_size_dynamic_sections (bfd *output_bfd,
5719                                const char *soname,
5720                                const char *rpath,
5721                                const char *filter_shlib,
5722                                const char *audit,
5723                                const char *depaudit,
5724                                const char * const *auxiliary_filters,
5725                                struct bfd_link_info *info,
5726                                asection **sinterpptr)
5727 {
5728   bfd_size_type soname_indx;
5729   bfd *dynobj;
5730   const struct elf_backend_data *bed;
5731   struct elf_info_failed asvinfo;
5732
5733   *sinterpptr = NULL;
5734
5735   soname_indx = (bfd_size_type) -1;
5736
5737   if (!is_elf_hash_table (info->hash))
5738     return TRUE;
5739
5740   bed = get_elf_backend_data (output_bfd);
5741
5742   /* Any syms created from now on start with -1 in
5743      got.refcount/offset and plt.refcount/offset.  */
5744   elf_hash_table (info)->init_got_refcount
5745     = elf_hash_table (info)->init_got_offset;
5746   elf_hash_table (info)->init_plt_refcount
5747     = elf_hash_table (info)->init_plt_offset;
5748
5749   if (bfd_link_relocatable (info)
5750       && !_bfd_elf_size_group_sections (info))
5751     return FALSE;
5752
5753   /* The backend may have to create some sections regardless of whether
5754      we're dynamic or not.  */
5755   if (bed->elf_backend_always_size_sections
5756       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5757     return FALSE;
5758
5759   /* Determine any GNU_STACK segment requirements, after the backend
5760      has had a chance to set a default segment size.  */
5761   if (info->execstack)
5762     elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X;
5763   else if (info->noexecstack)
5764     elf_stack_flags (output_bfd) = PF_R | PF_W;
5765   else
5766     {
5767       bfd *inputobj;
5768       asection *notesec = NULL;
5769       int exec = 0;
5770
5771       for (inputobj = info->input_bfds;
5772            inputobj;
5773            inputobj = inputobj->link.next)
5774         {
5775           asection *s;
5776
5777           if (inputobj->flags
5778               & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5779             continue;
5780           s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5781           if (s)
5782             {
5783               if (s->flags & SEC_CODE)
5784                 exec = PF_X;
5785               notesec = s;
5786             }
5787           else if (bed->default_execstack)
5788             exec = PF_X;
5789         }
5790       if (notesec || info->stacksize > 0)
5791         elf_stack_flags (output_bfd) = PF_R | PF_W | exec;
5792       if (notesec && exec && bfd_link_relocatable (info)
5793           && notesec->output_section != bfd_abs_section_ptr)
5794         notesec->output_section->flags |= SEC_CODE;
5795     }
5796
5797   dynobj = elf_hash_table (info)->dynobj;
5798
5799   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
5800     {
5801       struct elf_info_failed eif;
5802       struct elf_link_hash_entry *h;
5803       asection *dynstr;
5804       struct bfd_elf_version_tree *t;
5805       struct bfd_elf_version_expr *d;
5806       asection *s;
5807       bfd_boolean all_defined;
5808
5809       *sinterpptr = bfd_get_linker_section (dynobj, ".interp");
5810       BFD_ASSERT (*sinterpptr != NULL || !bfd_link_executable (info) || info->nointerp);
5811
5812       if (soname != NULL)
5813         {
5814           soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5815                                              soname, TRUE);
5816           if (soname_indx == (bfd_size_type) -1
5817               || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5818             return FALSE;
5819         }
5820
5821       if (info->symbolic)
5822         {
5823           if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5824             return FALSE;
5825           info->flags |= DF_SYMBOLIC;
5826         }
5827
5828       if (rpath != NULL)
5829         {
5830           bfd_size_type indx;
5831           bfd_vma tag;
5832
5833           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5834                                       TRUE);
5835           if (indx == (bfd_size_type) -1)
5836             return FALSE;
5837
5838           tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
5839           if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
5840             return FALSE;
5841         }
5842
5843       if (filter_shlib != NULL)
5844         {
5845           bfd_size_type indx;
5846
5847           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5848                                       filter_shlib, TRUE);
5849           if (indx == (bfd_size_type) -1
5850               || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5851             return FALSE;
5852         }
5853
5854       if (auxiliary_filters != NULL)
5855         {
5856           const char * const *p;
5857
5858           for (p = auxiliary_filters; *p != NULL; p++)
5859             {
5860               bfd_size_type indx;
5861
5862               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5863                                           *p, TRUE);
5864               if (indx == (bfd_size_type) -1
5865                   || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5866                 return FALSE;
5867             }
5868         }
5869
5870       if (audit != NULL)
5871         {
5872           bfd_size_type indx;
5873
5874           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5875                                       TRUE);
5876           if (indx == (bfd_size_type) -1
5877               || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5878             return FALSE;
5879         }
5880
5881       if (depaudit != NULL)
5882         {
5883           bfd_size_type indx;
5884
5885           indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5886                                       TRUE);
5887           if (indx == (bfd_size_type) -1
5888               || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5889             return FALSE;
5890         }
5891
5892       eif.info = info;
5893       eif.failed = FALSE;
5894
5895       /* If we are supposed to export all symbols into the dynamic symbol
5896          table (this is not the normal case), then do so.  */
5897       if (info->export_dynamic
5898           || (bfd_link_executable (info) && info->dynamic))
5899         {
5900           elf_link_hash_traverse (elf_hash_table (info),
5901                                   _bfd_elf_export_symbol,
5902                                   &eif);
5903           if (eif.failed)
5904             return FALSE;
5905         }
5906
5907       /* Make all global versions with definition.  */
5908       for (t = info->version_info; t != NULL; t = t->next)
5909         for (d = t->globals.list; d != NULL; d = d->next)
5910           if (!d->symver && d->literal)
5911             {
5912               const char *verstr, *name;
5913               size_t namelen, verlen, newlen;
5914               char *newname, *p, leading_char;
5915               struct elf_link_hash_entry *newh;
5916
5917               leading_char = bfd_get_symbol_leading_char (output_bfd);
5918               name = d->pattern;
5919               namelen = strlen (name) + (leading_char != '\0');
5920               verstr = t->name;
5921               verlen = strlen (verstr);
5922               newlen = namelen + verlen + 3;
5923
5924               newname = (char *) bfd_malloc (newlen);
5925               if (newname == NULL)
5926                 return FALSE;
5927               newname[0] = leading_char;
5928               memcpy (newname + (leading_char != '\0'), name, namelen);
5929
5930               /* Check the hidden versioned definition.  */
5931               p = newname + namelen;
5932               *p++ = ELF_VER_CHR;
5933               memcpy (p, verstr, verlen + 1);
5934               newh = elf_link_hash_lookup (elf_hash_table (info),
5935                                            newname, FALSE, FALSE,
5936                                            FALSE);
5937               if (newh == NULL
5938                   || (newh->root.type != bfd_link_hash_defined
5939                       && newh->root.type != bfd_link_hash_defweak))
5940                 {
5941                   /* Check the default versioned definition.  */
5942                   *p++ = ELF_VER_CHR;
5943                   memcpy (p, verstr, verlen + 1);
5944                   newh = elf_link_hash_lookup (elf_hash_table (info),
5945                                                newname, FALSE, FALSE,
5946                                                FALSE);
5947                 }
5948               free (newname);
5949
5950               /* Mark this version if there is a definition and it is
5951                  not defined in a shared object.  */
5952               if (newh != NULL
5953                   && !newh->def_dynamic
5954                   && (newh->root.type == bfd_link_hash_defined
5955                       || newh->root.type == bfd_link_hash_defweak))
5956                 d->symver = 1;
5957             }
5958
5959       /* Attach all the symbols to their version information.  */
5960       asvinfo.info = info;
5961       asvinfo.failed = FALSE;
5962
5963       elf_link_hash_traverse (elf_hash_table (info),
5964                               _bfd_elf_link_assign_sym_version,
5965                               &asvinfo);
5966       if (asvinfo.failed)
5967         return FALSE;
5968
5969       if (!info->allow_undefined_version)
5970         {
5971           /* Check if all global versions have a definition.  */
5972           all_defined = TRUE;
5973           for (t = info->version_info; t != NULL; t = t->next)
5974             for (d = t->globals.list; d != NULL; d = d->next)
5975               if (d->literal && !d->symver && !d->script)
5976                 {
5977                   (*_bfd_error_handler)
5978                     (_("%s: undefined version: %s"),
5979                      d->pattern, t->name);
5980                   all_defined = FALSE;
5981                 }
5982
5983           if (!all_defined)
5984             {
5985               bfd_set_error (bfd_error_bad_value);
5986               return FALSE;
5987             }
5988         }
5989
5990       /* Find all symbols which were defined in a dynamic object and make
5991          the backend pick a reasonable value for them.  */
5992       elf_link_hash_traverse (elf_hash_table (info),
5993                               _bfd_elf_adjust_dynamic_symbol,
5994                               &eif);
5995       if (eif.failed)
5996         return FALSE;
5997
5998       /* Add some entries to the .dynamic section.  We fill in some of the
5999          values later, in bfd_elf_final_link, but we must add the entries
6000          now so that we know the final size of the .dynamic section.  */
6001
6002       /* If there are initialization and/or finalization functions to
6003          call then add the corresponding DT_INIT/DT_FINI entries.  */
6004       h = (info->init_function
6005            ? elf_link_hash_lookup (elf_hash_table (info),
6006                                    info->init_function, FALSE,
6007                                    FALSE, FALSE)
6008            : NULL);
6009       if (h != NULL
6010           && (h->ref_regular
6011               || h->def_regular))
6012         {
6013           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
6014             return FALSE;
6015         }
6016       h = (info->fini_function
6017            ? elf_link_hash_lookup (elf_hash_table (info),
6018                                    info->fini_function, FALSE,
6019                                    FALSE, FALSE)
6020            : NULL);
6021       if (h != NULL
6022           && (h->ref_regular
6023               || h->def_regular))
6024         {
6025           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
6026             return FALSE;
6027         }
6028
6029       s = bfd_get_section_by_name (output_bfd, ".preinit_array");
6030       if (s != NULL && s->linker_has_input)
6031         {
6032           /* DT_PREINIT_ARRAY is not allowed in shared library.  */
6033           if (! bfd_link_executable (info))
6034             {
6035               bfd *sub;
6036               asection *o;
6037
6038               for (sub = info->input_bfds; sub != NULL;
6039                    sub = sub->link.next)
6040                 if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
6041                   for (o = sub->sections; o != NULL; o = o->next)
6042                     if (elf_section_data (o)->this_hdr.sh_type
6043                         == SHT_PREINIT_ARRAY)
6044                       {
6045                         (*_bfd_error_handler)
6046                           (_("%B: .preinit_array section is not allowed in DSO"),
6047                            sub);
6048                         break;
6049                       }
6050
6051               bfd_set_error (bfd_error_nonrepresentable_section);
6052               return FALSE;
6053             }
6054
6055           if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
6056               || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
6057             return FALSE;
6058         }
6059       s = bfd_get_section_by_name (output_bfd, ".init_array");
6060       if (s != NULL && s->linker_has_input)
6061         {
6062           if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
6063               || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
6064             return FALSE;
6065         }
6066       s = bfd_get_section_by_name (output_bfd, ".fini_array");
6067       if (s != NULL && s->linker_has_input)
6068         {
6069           if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
6070               || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
6071             return FALSE;
6072         }
6073
6074       dynstr = bfd_get_linker_section (dynobj, ".dynstr");
6075       /* If .dynstr is excluded from the link, we don't want any of
6076          these tags.  Strictly, we should be checking each section
6077          individually;  This quick check covers for the case where
6078          someone does a /DISCARD/ : { *(*) }.  */
6079       if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
6080         {
6081           bfd_size_type strsize;
6082
6083           strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6084           if ((info->emit_hash
6085                && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
6086               || (info->emit_gnu_hash
6087                   && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
6088               || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
6089               || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
6090               || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
6091               || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
6092                                               bed->s->sizeof_sym))
6093             return FALSE;
6094         }
6095     }
6096
6097   if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
6098     return FALSE;
6099
6100   /* The backend must work out the sizes of all the other dynamic
6101      sections.  */
6102   if (dynobj != NULL
6103       && bed->elf_backend_size_dynamic_sections != NULL
6104       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
6105     return FALSE;
6106
6107   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
6108     {
6109       unsigned long section_sym_count;
6110       struct bfd_elf_version_tree *verdefs;
6111       asection *s;
6112
6113       /* Set up the version definition section.  */
6114       s = bfd_get_linker_section (dynobj, ".gnu.version_d");
6115       BFD_ASSERT (s != NULL);
6116
6117       /* We may have created additional version definitions if we are
6118          just linking a regular application.  */
6119       verdefs = info->version_info;
6120
6121       /* Skip anonymous version tag.  */
6122       if (verdefs != NULL && verdefs->vernum == 0)
6123         verdefs = verdefs->next;
6124
6125       if (verdefs == NULL && !info->create_default_symver)
6126         s->flags |= SEC_EXCLUDE;
6127       else
6128         {
6129           unsigned int cdefs;
6130           bfd_size_type size;
6131           struct bfd_elf_version_tree *t;
6132           bfd_byte *p;
6133           Elf_Internal_Verdef def;
6134           Elf_Internal_Verdaux defaux;
6135           struct bfd_link_hash_entry *bh;
6136           struct elf_link_hash_entry *h;
6137           const char *name;
6138
6139           cdefs = 0;
6140           size = 0;
6141
6142           /* Make space for the base version.  */
6143           size += sizeof (Elf_External_Verdef);
6144           size += sizeof (Elf_External_Verdaux);
6145           ++cdefs;
6146
6147           /* Make space for the default version.  */
6148           if (info->create_default_symver)
6149             {
6150               size += sizeof (Elf_External_Verdef);
6151               ++cdefs;
6152             }
6153
6154           for (t = verdefs; t != NULL; t = t->next)
6155             {
6156               struct bfd_elf_version_deps *n;
6157
6158               /* Don't emit base version twice.  */
6159               if (t->vernum == 0)
6160                 continue;
6161
6162               size += sizeof (Elf_External_Verdef);
6163               size += sizeof (Elf_External_Verdaux);
6164               ++cdefs;
6165
6166               for (n = t->deps; n != NULL; n = n->next)
6167                 size += sizeof (Elf_External_Verdaux);
6168             }
6169
6170           s->size = size;
6171           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6172           if (s->contents == NULL && s->size != 0)
6173             return FALSE;
6174
6175           /* Fill in the version definition section.  */
6176
6177           p = s->contents;
6178
6179           def.vd_version = VER_DEF_CURRENT;
6180           def.vd_flags = VER_FLG_BASE;
6181           def.vd_ndx = 1;
6182           def.vd_cnt = 1;
6183           if (info->create_default_symver)
6184             {
6185               def.vd_aux = 2 * sizeof (Elf_External_Verdef);
6186               def.vd_next = sizeof (Elf_External_Verdef);
6187             }
6188           else
6189             {
6190               def.vd_aux = sizeof (Elf_External_Verdef);
6191               def.vd_next = (sizeof (Elf_External_Verdef)
6192                              + sizeof (Elf_External_Verdaux));
6193             }
6194
6195           if (soname_indx != (bfd_size_type) -1)
6196             {
6197               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6198                                       soname_indx);
6199               def.vd_hash = bfd_elf_hash (soname);
6200               defaux.vda_name = soname_indx;
6201               name = soname;
6202             }
6203           else
6204             {
6205               bfd_size_type indx;
6206
6207               name = lbasename (output_bfd->filename);
6208               def.vd_hash = bfd_elf_hash (name);
6209               indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6210                                           name, FALSE);
6211               if (indx == (bfd_size_type) -1)
6212                 return FALSE;
6213               defaux.vda_name = indx;
6214             }
6215           defaux.vda_next = 0;
6216
6217           _bfd_elf_swap_verdef_out (output_bfd, &def,
6218                                     (Elf_External_Verdef *) p);
6219           p += sizeof (Elf_External_Verdef);
6220           if (info->create_default_symver)
6221             {
6222               /* Add a symbol representing this version.  */
6223               bh = NULL;
6224               if (! (_bfd_generic_link_add_one_symbol
6225                      (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6226                       0, NULL, FALSE,
6227                       get_elf_backend_data (dynobj)->collect, &bh)))
6228                 return FALSE;
6229               h = (struct elf_link_hash_entry *) bh;
6230               h->non_elf = 0;
6231               h->def_regular = 1;
6232               h->type = STT_OBJECT;
6233               h->verinfo.vertree = NULL;
6234
6235               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6236                 return FALSE;
6237
6238               /* Create a duplicate of the base version with the same
6239                  aux block, but different flags.  */
6240               def.vd_flags = 0;
6241               def.vd_ndx = 2;
6242               def.vd_aux = sizeof (Elf_External_Verdef);
6243               if (verdefs)
6244                 def.vd_next = (sizeof (Elf_External_Verdef)
6245                                + sizeof (Elf_External_Verdaux));
6246               else
6247                 def.vd_next = 0;
6248               _bfd_elf_swap_verdef_out (output_bfd, &def,
6249                                         (Elf_External_Verdef *) p);
6250               p += sizeof (Elf_External_Verdef);
6251             }
6252           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6253                                      (Elf_External_Verdaux *) p);
6254           p += sizeof (Elf_External_Verdaux);
6255
6256           for (t = verdefs; t != NULL; t = t->next)
6257             {
6258               unsigned int cdeps;
6259               struct bfd_elf_version_deps *n;
6260
6261               /* Don't emit the base version twice.  */
6262               if (t->vernum == 0)
6263                 continue;
6264
6265               cdeps = 0;
6266               for (n = t->deps; n != NULL; n = n->next)
6267                 ++cdeps;
6268
6269               /* Add a symbol representing this version.  */
6270               bh = NULL;
6271               if (! (_bfd_generic_link_add_one_symbol
6272                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6273                       0, NULL, FALSE,
6274                       get_elf_backend_data (dynobj)->collect, &bh)))
6275                 return FALSE;
6276               h = (struct elf_link_hash_entry *) bh;
6277               h->non_elf = 0;
6278               h->def_regular = 1;
6279               h->type = STT_OBJECT;
6280               h->verinfo.vertree = t;
6281
6282               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6283                 return FALSE;
6284
6285               def.vd_version = VER_DEF_CURRENT;
6286               def.vd_flags = 0;
6287               if (t->globals.list == NULL
6288                   && t->locals.list == NULL
6289                   && ! t->used)
6290                 def.vd_flags |= VER_FLG_WEAK;
6291               def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6292               def.vd_cnt = cdeps + 1;
6293               def.vd_hash = bfd_elf_hash (t->name);
6294               def.vd_aux = sizeof (Elf_External_Verdef);
6295               def.vd_next = 0;
6296
6297               /* If a basever node is next, it *must* be the last node in
6298                  the chain, otherwise Verdef construction breaks.  */
6299               if (t->next != NULL && t->next->vernum == 0)
6300                 BFD_ASSERT (t->next->next == NULL);
6301
6302               if (t->next != NULL && t->next->vernum != 0)
6303                 def.vd_next = (sizeof (Elf_External_Verdef)
6304                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6305
6306               _bfd_elf_swap_verdef_out (output_bfd, &def,
6307                                         (Elf_External_Verdef *) p);
6308               p += sizeof (Elf_External_Verdef);
6309
6310               defaux.vda_name = h->dynstr_index;
6311               _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6312                                       h->dynstr_index);
6313               defaux.vda_next = 0;
6314               if (t->deps != NULL)
6315                 defaux.vda_next = sizeof (Elf_External_Verdaux);
6316               t->name_indx = defaux.vda_name;
6317
6318               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6319                                          (Elf_External_Verdaux *) p);
6320               p += sizeof (Elf_External_Verdaux);
6321
6322               for (n = t->deps; n != NULL; n = n->next)
6323                 {
6324                   if (n->version_needed == NULL)
6325                     {
6326                       /* This can happen if there was an error in the
6327                          version script.  */
6328                       defaux.vda_name = 0;
6329                     }
6330                   else
6331                     {
6332                       defaux.vda_name = n->version_needed->name_indx;
6333                       _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6334                                               defaux.vda_name);
6335                     }
6336                   if (n->next == NULL)
6337                     defaux.vda_next = 0;
6338                   else
6339                     defaux.vda_next = sizeof (Elf_External_Verdaux);
6340
6341                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6342                                              (Elf_External_Verdaux *) p);
6343                   p += sizeof (Elf_External_Verdaux);
6344                 }
6345             }
6346
6347           if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6348               || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6349             return FALSE;
6350
6351           elf_tdata (output_bfd)->cverdefs = cdefs;
6352         }
6353
6354       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6355         {
6356           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6357             return FALSE;
6358         }
6359       else if (info->flags & DF_BIND_NOW)
6360         {
6361           if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6362             return FALSE;
6363         }
6364
6365       if (info->flags_1)
6366         {
6367           if (bfd_link_executable (info))
6368             info->flags_1 &= ~ (DF_1_INITFIRST
6369                                 | DF_1_NODELETE
6370                                 | DF_1_NOOPEN);
6371           if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6372             return FALSE;
6373         }
6374
6375       /* Work out the size of the version reference section.  */
6376
6377       s = bfd_get_linker_section (dynobj, ".gnu.version_r");
6378       BFD_ASSERT (s != NULL);
6379       {
6380         struct elf_find_verdep_info sinfo;
6381
6382         sinfo.info = info;
6383         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6384         if (sinfo.vers == 0)
6385           sinfo.vers = 1;
6386         sinfo.failed = FALSE;
6387
6388         elf_link_hash_traverse (elf_hash_table (info),
6389                                 _bfd_elf_link_find_version_dependencies,
6390                                 &sinfo);
6391         if (sinfo.failed)
6392           return FALSE;
6393
6394         if (elf_tdata (output_bfd)->verref == NULL)
6395           s->flags |= SEC_EXCLUDE;
6396         else
6397           {
6398             Elf_Internal_Verneed *t;
6399             unsigned int size;
6400             unsigned int crefs;
6401             bfd_byte *p;
6402
6403             /* Build the version dependency section.  */
6404             size = 0;
6405             crefs = 0;
6406             for (t = elf_tdata (output_bfd)->verref;
6407                  t != NULL;
6408                  t = t->vn_nextref)
6409               {
6410                 Elf_Internal_Vernaux *a;
6411
6412                 size += sizeof (Elf_External_Verneed);
6413                 ++crefs;
6414                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6415                   size += sizeof (Elf_External_Vernaux);
6416               }
6417
6418             s->size = size;
6419             s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6420             if (s->contents == NULL)
6421               return FALSE;
6422
6423             p = s->contents;
6424             for (t = elf_tdata (output_bfd)->verref;
6425                  t != NULL;
6426                  t = t->vn_nextref)
6427               {
6428                 unsigned int caux;
6429                 Elf_Internal_Vernaux *a;
6430                 bfd_size_type indx;
6431
6432                 caux = 0;
6433                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6434                   ++caux;
6435
6436                 t->vn_version = VER_NEED_CURRENT;
6437                 t->vn_cnt = caux;
6438                 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6439                                             elf_dt_name (t->vn_bfd) != NULL
6440                                             ? elf_dt_name (t->vn_bfd)
6441                                             : lbasename (t->vn_bfd->filename),
6442                                             FALSE);
6443                 if (indx == (bfd_size_type) -1)
6444                   return FALSE;
6445                 t->vn_file = indx;
6446                 t->vn_aux = sizeof (Elf_External_Verneed);
6447                 if (t->vn_nextref == NULL)
6448                   t->vn_next = 0;
6449                 else
6450                   t->vn_next = (sizeof (Elf_External_Verneed)
6451                                 + caux * sizeof (Elf_External_Vernaux));
6452
6453                 _bfd_elf_swap_verneed_out (output_bfd, t,
6454                                            (Elf_External_Verneed *) p);
6455                 p += sizeof (Elf_External_Verneed);
6456
6457                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6458                   {
6459                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
6460                     indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6461                                                 a->vna_nodename, FALSE);
6462                     if (indx == (bfd_size_type) -1)
6463                       return FALSE;
6464                     a->vna_name = indx;
6465                     if (a->vna_nextptr == NULL)
6466                       a->vna_next = 0;
6467                     else
6468                       a->vna_next = sizeof (Elf_External_Vernaux);
6469
6470                     _bfd_elf_swap_vernaux_out (output_bfd, a,
6471                                                (Elf_External_Vernaux *) p);
6472                     p += sizeof (Elf_External_Vernaux);
6473                   }
6474               }
6475
6476             if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6477                 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6478               return FALSE;
6479
6480             elf_tdata (output_bfd)->cverrefs = crefs;
6481           }
6482       }
6483
6484       if ((elf_tdata (output_bfd)->cverrefs == 0
6485            && elf_tdata (output_bfd)->cverdefs == 0)
6486           || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6487                                              &section_sym_count) == 0)
6488         {
6489           s = bfd_get_linker_section (dynobj, ".gnu.version");
6490           s->flags |= SEC_EXCLUDE;
6491         }
6492     }
6493   return TRUE;
6494 }
6495
6496 /* Find the first non-excluded output section.  We'll use its
6497    section symbol for some emitted relocs.  */
6498 void
6499 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6500 {
6501   asection *s;
6502
6503   for (s = output_bfd->sections; s != NULL; s = s->next)
6504     if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6505         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6506       {
6507         elf_hash_table (info)->text_index_section = s;
6508         break;
6509       }
6510 }
6511
6512 /* Find two non-excluded output sections, one for code, one for data.
6513    We'll use their section symbols for some emitted relocs.  */
6514 void
6515 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6516 {
6517   asection *s;
6518
6519   /* Data first, since setting text_index_section changes
6520      _bfd_elf_link_omit_section_dynsym.  */
6521   for (s = output_bfd->sections; s != NULL; s = s->next)
6522     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6523         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6524       {
6525         elf_hash_table (info)->data_index_section = s;
6526         break;
6527       }
6528
6529   for (s = output_bfd->sections; s != NULL; s = s->next)
6530     if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6531          == (SEC_ALLOC | SEC_READONLY))
6532         && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6533       {
6534         elf_hash_table (info)->text_index_section = s;
6535         break;
6536       }
6537
6538   if (elf_hash_table (info)->text_index_section == NULL)
6539     elf_hash_table (info)->text_index_section
6540       = elf_hash_table (info)->data_index_section;
6541 }
6542
6543 bfd_boolean
6544 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6545 {
6546   const struct elf_backend_data *bed;
6547
6548   if (!is_elf_hash_table (info->hash))
6549     return TRUE;
6550
6551   bed = get_elf_backend_data (output_bfd);
6552   (*bed->elf_backend_init_index_section) (output_bfd, info);
6553
6554   if (elf_hash_table (info)->dynamic_sections_created)
6555     {
6556       bfd *dynobj;
6557       asection *s;
6558       bfd_size_type dynsymcount;
6559       unsigned long section_sym_count;
6560       unsigned int dtagcount;
6561
6562       dynobj = elf_hash_table (info)->dynobj;
6563
6564       /* Assign dynsym indicies.  In a shared library we generate a
6565          section symbol for each output section, which come first.
6566          Next come all of the back-end allocated local dynamic syms,
6567          followed by the rest of the global symbols.  */
6568
6569       dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6570                                                     &section_sym_count);
6571
6572       /* Work out the size of the symbol version section.  */
6573       s = bfd_get_linker_section (dynobj, ".gnu.version");
6574       BFD_ASSERT (s != NULL);
6575       if (dynsymcount != 0
6576           && (s->flags & SEC_EXCLUDE) == 0)
6577         {
6578           s->size = dynsymcount * sizeof (Elf_External_Versym);
6579           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6580           if (s->contents == NULL)
6581             return FALSE;
6582
6583           if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6584             return FALSE;
6585         }
6586
6587       /* Set the size of the .dynsym and .hash sections.  We counted
6588          the number of dynamic symbols in elf_link_add_object_symbols.
6589          We will build the contents of .dynsym and .hash when we build
6590          the final symbol table, because until then we do not know the
6591          correct value to give the symbols.  We built the .dynstr
6592          section as we went along in elf_link_add_object_symbols.  */
6593       s = elf_hash_table (info)->dynsym;
6594       BFD_ASSERT (s != NULL);
6595       s->size = dynsymcount * bed->s->sizeof_sym;
6596
6597       if (dynsymcount != 0)
6598         {
6599           s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6600           if (s->contents == NULL)
6601             return FALSE;
6602
6603           /* The first entry in .dynsym is a dummy symbol.
6604              Clear all the section syms, in case we don't output them all.  */
6605           ++section_sym_count;
6606           memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6607         }
6608
6609       elf_hash_table (info)->bucketcount = 0;
6610
6611       /* Compute the size of the hashing table.  As a side effect this
6612          computes the hash values for all the names we export.  */
6613       if (info->emit_hash)
6614         {
6615           unsigned long int *hashcodes;
6616           struct hash_codes_info hashinf;
6617           bfd_size_type amt;
6618           unsigned long int nsyms;
6619           size_t bucketcount;
6620           size_t hash_entry_size;
6621
6622           /* Compute the hash values for all exported symbols.  At the same
6623              time store the values in an array so that we could use them for
6624              optimizations.  */
6625           amt = dynsymcount * sizeof (unsigned long int);
6626           hashcodes = (unsigned long int *) bfd_malloc (amt);
6627           if (hashcodes == NULL)
6628             return FALSE;
6629           hashinf.hashcodes = hashcodes;
6630           hashinf.error = FALSE;
6631
6632           /* Put all hash values in HASHCODES.  */
6633           elf_link_hash_traverse (elf_hash_table (info),
6634                                   elf_collect_hash_codes, &hashinf);
6635           if (hashinf.error)
6636             {
6637               free (hashcodes);
6638               return FALSE;
6639             }
6640
6641           nsyms = hashinf.hashcodes - hashcodes;
6642           bucketcount
6643             = compute_bucket_count (info, hashcodes, nsyms, 0);
6644           free (hashcodes);
6645
6646           if (bucketcount == 0)
6647             return FALSE;
6648
6649           elf_hash_table (info)->bucketcount = bucketcount;
6650
6651           s = bfd_get_linker_section (dynobj, ".hash");
6652           BFD_ASSERT (s != NULL);
6653           hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6654           s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6655           s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6656           if (s->contents == NULL)
6657             return FALSE;
6658
6659           bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6660           bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6661                    s->contents + hash_entry_size);
6662         }
6663
6664       if (info->emit_gnu_hash)
6665         {
6666           size_t i, cnt;
6667           unsigned char *contents;
6668           struct collect_gnu_hash_codes cinfo;
6669           bfd_size_type amt;
6670           size_t bucketcount;
6671
6672           memset (&cinfo, 0, sizeof (cinfo));
6673
6674           /* Compute the hash values for all exported symbols.  At the same
6675              time store the values in an array so that we could use them for
6676              optimizations.  */
6677           amt = dynsymcount * 2 * sizeof (unsigned long int);
6678           cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6679           if (cinfo.hashcodes == NULL)
6680             return FALSE;
6681
6682           cinfo.hashval = cinfo.hashcodes + dynsymcount;
6683           cinfo.min_dynindx = -1;
6684           cinfo.output_bfd = output_bfd;
6685           cinfo.bed = bed;
6686
6687           /* Put all hash values in HASHCODES.  */
6688           elf_link_hash_traverse (elf_hash_table (info),
6689                                   elf_collect_gnu_hash_codes, &cinfo);
6690           if (cinfo.error)
6691             {
6692               free (cinfo.hashcodes);
6693               return FALSE;
6694             }
6695
6696           bucketcount
6697             = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6698
6699           if (bucketcount == 0)
6700             {
6701               free (cinfo.hashcodes);
6702               return FALSE;
6703             }
6704
6705           s = bfd_get_linker_section (dynobj, ".gnu.hash");
6706           BFD_ASSERT (s != NULL);
6707
6708           if (cinfo.nsyms == 0)
6709             {
6710               /* Empty .gnu.hash section is special.  */
6711               BFD_ASSERT (cinfo.min_dynindx == -1);
6712               free (cinfo.hashcodes);
6713               s->size = 5 * 4 + bed->s->arch_size / 8;
6714               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6715               if (contents == NULL)
6716                 return FALSE;
6717               s->contents = contents;
6718               /* 1 empty bucket.  */
6719               bfd_put_32 (output_bfd, 1, contents);
6720               /* SYMIDX above the special symbol 0.  */
6721               bfd_put_32 (output_bfd, 1, contents + 4);
6722               /* Just one word for bitmask.  */
6723               bfd_put_32 (output_bfd, 1, contents + 8);
6724               /* Only hash fn bloom filter.  */
6725               bfd_put_32 (output_bfd, 0, contents + 12);
6726               /* No hashes are valid - empty bitmask.  */
6727               bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6728               /* No hashes in the only bucket.  */
6729               bfd_put_32 (output_bfd, 0,
6730                           contents + 16 + bed->s->arch_size / 8);
6731             }
6732           else
6733             {
6734               unsigned long int maskwords, maskbitslog2, x;
6735               BFD_ASSERT (cinfo.min_dynindx != -1);
6736
6737               x = cinfo.nsyms;
6738               maskbitslog2 = 1;
6739               while ((x >>= 1) != 0)
6740                 ++maskbitslog2;
6741               if (maskbitslog2 < 3)
6742                 maskbitslog2 = 5;
6743               else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6744                 maskbitslog2 = maskbitslog2 + 3;
6745               else
6746                 maskbitslog2 = maskbitslog2 + 2;
6747               if (bed->s->arch_size == 64)
6748                 {
6749                   if (maskbitslog2 == 5)
6750                     maskbitslog2 = 6;
6751                   cinfo.shift1 = 6;
6752                 }
6753               else
6754                 cinfo.shift1 = 5;
6755               cinfo.mask = (1 << cinfo.shift1) - 1;
6756               cinfo.shift2 = maskbitslog2;
6757               cinfo.maskbits = 1 << maskbitslog2;
6758               maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6759               amt = bucketcount * sizeof (unsigned long int) * 2;
6760               amt += maskwords * sizeof (bfd_vma);
6761               cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6762               if (cinfo.bitmask == NULL)
6763                 {
6764                   free (cinfo.hashcodes);
6765                   return FALSE;
6766                 }
6767
6768               cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6769               cinfo.indx = cinfo.counts + bucketcount;
6770               cinfo.symindx = dynsymcount - cinfo.nsyms;
6771               memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6772
6773               /* Determine how often each hash bucket is used.  */
6774               memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6775               for (i = 0; i < cinfo.nsyms; ++i)
6776                 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6777
6778               for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6779                 if (cinfo.counts[i] != 0)
6780                   {
6781                     cinfo.indx[i] = cnt;
6782                     cnt += cinfo.counts[i];
6783                   }
6784               BFD_ASSERT (cnt == dynsymcount);
6785               cinfo.bucketcount = bucketcount;
6786               cinfo.local_indx = cinfo.min_dynindx;
6787
6788               s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6789               s->size += cinfo.maskbits / 8;
6790               contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6791               if (contents == NULL)
6792                 {
6793                   free (cinfo.bitmask);
6794                   free (cinfo.hashcodes);
6795                   return FALSE;
6796                 }
6797
6798               s->contents = contents;
6799               bfd_put_32 (output_bfd, bucketcount, contents);
6800               bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6801               bfd_put_32 (output_bfd, maskwords, contents + 8);
6802               bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6803               contents += 16 + cinfo.maskbits / 8;
6804
6805               for (i = 0; i < bucketcount; ++i)
6806                 {
6807                   if (cinfo.counts[i] == 0)
6808                     bfd_put_32 (output_bfd, 0, contents);
6809                   else
6810                     bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6811                   contents += 4;
6812                 }
6813
6814               cinfo.contents = contents;
6815
6816               /* Renumber dynamic symbols, populate .gnu.hash section.  */
6817               elf_link_hash_traverse (elf_hash_table (info),
6818                                       elf_renumber_gnu_hash_syms, &cinfo);
6819
6820               contents = s->contents + 16;
6821               for (i = 0; i < maskwords; ++i)
6822                 {
6823                   bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6824                            contents);
6825                   contents += bed->s->arch_size / 8;
6826                 }
6827
6828               free (cinfo.bitmask);
6829               free (cinfo.hashcodes);
6830             }
6831         }
6832
6833       s = bfd_get_linker_section (dynobj, ".dynstr");
6834       BFD_ASSERT (s != NULL);
6835
6836       elf_finalize_dynstr (output_bfd, info);
6837
6838       s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6839
6840       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6841         if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6842           return FALSE;
6843     }
6844
6845   return TRUE;
6846 }
6847 \f
6848 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
6849
6850 static void
6851 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6852                             asection *sec)
6853 {
6854   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
6855   sec->sec_info_type = SEC_INFO_TYPE_NONE;
6856 }
6857
6858 /* Finish SHF_MERGE section merging.  */
6859
6860 bfd_boolean
6861 _bfd_elf_merge_sections (bfd *obfd, struct bfd_link_info *info)
6862 {
6863   bfd *ibfd;
6864   asection *sec;
6865
6866   if (!is_elf_hash_table (info->hash))
6867     return FALSE;
6868
6869   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
6870     if ((ibfd->flags & DYNAMIC) == 0
6871         && bfd_get_flavour (ibfd) == bfd_target_elf_flavour
6872         && (elf_elfheader (ibfd)->e_ident[EI_CLASS]
6873             == get_elf_backend_data (obfd)->s->elfclass))
6874       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6875         if ((sec->flags & SEC_MERGE) != 0
6876             && !bfd_is_abs_section (sec->output_section))
6877           {
6878             struct bfd_elf_section_data *secdata;
6879
6880             secdata = elf_section_data (sec);
6881             if (! _bfd_add_merge_section (obfd,
6882                                           &elf_hash_table (info)->merge_info,
6883                                           sec, &secdata->sec_info))
6884               return FALSE;
6885             else if (secdata->sec_info)
6886               sec->sec_info_type = SEC_INFO_TYPE_MERGE;
6887           }
6888
6889   if (elf_hash_table (info)->merge_info != NULL)
6890     _bfd_merge_sections (obfd, info, elf_hash_table (info)->merge_info,
6891                          merge_sections_remove_hook);
6892   return TRUE;
6893 }
6894
6895 /* Create an entry in an ELF linker hash table.  */
6896
6897 struct bfd_hash_entry *
6898 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6899                             struct bfd_hash_table *table,
6900                             const char *string)
6901 {
6902   /* Allocate the structure if it has not already been allocated by a
6903      subclass.  */
6904   if (entry == NULL)
6905     {
6906       entry = (struct bfd_hash_entry *)
6907         bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6908       if (entry == NULL)
6909         return entry;
6910     }
6911
6912   /* Call the allocation method of the superclass.  */
6913   entry = _bfd_link_hash_newfunc (entry, table, string);
6914   if (entry != NULL)
6915     {
6916       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6917       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6918
6919       /* Set local fields.  */
6920       ret->indx = -1;
6921       ret->dynindx = -1;
6922       ret->got = htab->init_got_refcount;
6923       ret->plt = htab->init_plt_refcount;
6924       memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6925                               - offsetof (struct elf_link_hash_entry, size)));
6926       /* Assume that we have been called by a non-ELF symbol reader.
6927          This flag is then reset by the code which reads an ELF input
6928          file.  This ensures that a symbol created by a non-ELF symbol
6929          reader will have the flag set correctly.  */
6930       ret->non_elf = 1;
6931     }
6932
6933   return entry;
6934 }
6935
6936 /* Copy data from an indirect symbol to its direct symbol, hiding the
6937    old indirect symbol.  Also used for copying flags to a weakdef.  */
6938
6939 void
6940 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6941                                   struct elf_link_hash_entry *dir,
6942                                   struct elf_link_hash_entry *ind)
6943 {
6944   struct elf_link_hash_table *htab;
6945
6946   /* Copy down any references that we may have already seen to the
6947      symbol which just became indirect if DIR isn't a hidden versioned
6948      symbol.  */
6949
6950   if (dir->versioned != versioned_hidden)
6951     {
6952       dir->ref_dynamic |= ind->ref_dynamic;
6953       dir->ref_regular |= ind->ref_regular;
6954       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6955       dir->non_got_ref |= ind->non_got_ref;
6956       dir->needs_plt |= ind->needs_plt;
6957       dir->pointer_equality_needed |= ind->pointer_equality_needed;
6958     }
6959
6960   if (ind->root.type != bfd_link_hash_indirect)
6961     return;
6962
6963   /* Copy over the global and procedure linkage table refcount entries.
6964      These may have been already set up by a check_relocs routine.  */
6965   htab = elf_hash_table (info);
6966   if (ind->got.refcount > htab->init_got_refcount.refcount)
6967     {
6968       if (dir->got.refcount < 0)
6969         dir->got.refcount = 0;
6970       dir->got.refcount += ind->got.refcount;
6971       ind->got.refcount = htab->init_got_refcount.refcount;
6972     }
6973
6974   if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6975     {
6976       if (dir->plt.refcount < 0)
6977         dir->plt.refcount = 0;
6978       dir->plt.refcount += ind->plt.refcount;
6979       ind->plt.refcount = htab->init_plt_refcount.refcount;
6980     }
6981
6982   if (ind->dynindx != -1)
6983     {
6984       if (dir->dynindx != -1)
6985         _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6986       dir->dynindx = ind->dynindx;
6987       dir->dynstr_index = ind->dynstr_index;
6988       ind->dynindx = -1;
6989       ind->dynstr_index = 0;
6990     }
6991 }
6992
6993 void
6994 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6995                                 struct elf_link_hash_entry *h,
6996                                 bfd_boolean force_local)
6997 {
6998   /* STT_GNU_IFUNC symbol must go through PLT.  */
6999   if (h->type != STT_GNU_IFUNC)
7000     {
7001       h->plt = elf_hash_table (info)->init_plt_offset;
7002       h->needs_plt = 0;
7003     }
7004   if (force_local)
7005     {
7006       h->forced_local = 1;
7007       if (h->dynindx != -1)
7008         {
7009           h->dynindx = -1;
7010           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7011                                   h->dynstr_index);
7012         }
7013     }
7014 }
7015
7016 /* Initialize an ELF linker hash table.  *TABLE has been zeroed by our
7017    caller.  */
7018
7019 bfd_boolean
7020 _bfd_elf_link_hash_table_init
7021   (struct elf_link_hash_table *table,
7022    bfd *abfd,
7023    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
7024                                       struct bfd_hash_table *,
7025                                       const char *),
7026    unsigned int entsize,
7027    enum elf_target_id target_id)
7028 {
7029   bfd_boolean ret;
7030   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
7031
7032   table->init_got_refcount.refcount = can_refcount - 1;
7033   table->init_plt_refcount.refcount = can_refcount - 1;
7034   table->init_got_offset.offset = -(bfd_vma) 1;
7035   table->init_plt_offset.offset = -(bfd_vma) 1;
7036   /* The first dynamic symbol is a dummy.  */
7037   table->dynsymcount = 1;
7038
7039   ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
7040
7041   table->root.type = bfd_link_elf_hash_table;
7042   table->hash_table_id = target_id;
7043
7044   return ret;
7045 }
7046
7047 /* Create an ELF linker hash table.  */
7048
7049 struct bfd_link_hash_table *
7050 _bfd_elf_link_hash_table_create (bfd *abfd)
7051 {
7052   struct elf_link_hash_table *ret;
7053   bfd_size_type amt = sizeof (struct elf_link_hash_table);
7054
7055   ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
7056   if (ret == NULL)
7057     return NULL;
7058
7059   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
7060                                        sizeof (struct elf_link_hash_entry),
7061                                        GENERIC_ELF_DATA))
7062     {
7063       free (ret);
7064       return NULL;
7065     }
7066   ret->root.hash_table_free = _bfd_elf_link_hash_table_free;
7067
7068   return &ret->root;
7069 }
7070
7071 /* Destroy an ELF linker hash table.  */
7072
7073 void
7074 _bfd_elf_link_hash_table_free (bfd *obfd)
7075 {
7076   struct elf_link_hash_table *htab;
7077
7078   htab = (struct elf_link_hash_table *) obfd->link.hash;
7079   if (htab->dynstr != NULL)
7080     _bfd_elf_strtab_free (htab->dynstr);
7081   _bfd_merge_sections_free (htab->merge_info);
7082   _bfd_generic_link_hash_table_free (obfd);
7083 }
7084
7085 /* This is a hook for the ELF emulation code in the generic linker to
7086    tell the backend linker what file name to use for the DT_NEEDED
7087    entry for a dynamic object.  */
7088
7089 void
7090 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
7091 {
7092   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7093       && bfd_get_format (abfd) == bfd_object)
7094     elf_dt_name (abfd) = name;
7095 }
7096
7097 int
7098 bfd_elf_get_dyn_lib_class (bfd *abfd)
7099 {
7100   int lib_class;
7101   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7102       && bfd_get_format (abfd) == bfd_object)
7103     lib_class = elf_dyn_lib_class (abfd);
7104   else
7105     lib_class = 0;
7106   return lib_class;
7107 }
7108
7109 void
7110 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
7111 {
7112   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7113       && bfd_get_format (abfd) == bfd_object)
7114     elf_dyn_lib_class (abfd) = lib_class;
7115 }
7116
7117 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
7118    the linker ELF emulation code.  */
7119
7120 struct bfd_link_needed_list *
7121 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
7122                          struct bfd_link_info *info)
7123 {
7124   if (! is_elf_hash_table (info->hash))
7125     return NULL;
7126   return elf_hash_table (info)->needed;
7127 }
7128
7129 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
7130    hook for the linker ELF emulation code.  */
7131
7132 struct bfd_link_needed_list *
7133 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
7134                           struct bfd_link_info *info)
7135 {
7136   if (! is_elf_hash_table (info->hash))
7137     return NULL;
7138   return elf_hash_table (info)->runpath;
7139 }
7140
7141 /* Get the name actually used for a dynamic object for a link.  This
7142    is the SONAME entry if there is one.  Otherwise, it is the string
7143    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
7144
7145 const char *
7146 bfd_elf_get_dt_soname (bfd *abfd)
7147 {
7148   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7149       && bfd_get_format (abfd) == bfd_object)
7150     return elf_dt_name (abfd);
7151   return NULL;
7152 }
7153
7154 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
7155    the ELF linker emulation code.  */
7156
7157 bfd_boolean
7158 bfd_elf_get_bfd_needed_list (bfd *abfd,
7159                              struct bfd_link_needed_list **pneeded)
7160 {
7161   asection *s;
7162   bfd_byte *dynbuf = NULL;
7163   unsigned int elfsec;
7164   unsigned long shlink;
7165   bfd_byte *extdyn, *extdynend;
7166   size_t extdynsize;
7167   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
7168
7169   *pneeded = NULL;
7170
7171   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
7172       || bfd_get_format (abfd) != bfd_object)
7173     return TRUE;
7174
7175   s = bfd_get_section_by_name (abfd, ".dynamic");
7176   if (s == NULL || s->size == 0)
7177     return TRUE;
7178
7179   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
7180     goto error_return;
7181
7182   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
7183   if (elfsec == SHN_BAD)
7184     goto error_return;
7185
7186   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
7187
7188   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
7189   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
7190
7191   extdyn = dynbuf;
7192   extdynend = extdyn + s->size;
7193   for (; extdyn < extdynend; extdyn += extdynsize)
7194     {
7195       Elf_Internal_Dyn dyn;
7196
7197       (*swap_dyn_in) (abfd, extdyn, &dyn);
7198
7199       if (dyn.d_tag == DT_NULL)
7200         break;
7201
7202       if (dyn.d_tag == DT_NEEDED)
7203         {
7204           const char *string;
7205           struct bfd_link_needed_list *l;
7206           unsigned int tagv = dyn.d_un.d_val;
7207           bfd_size_type amt;
7208
7209           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
7210           if (string == NULL)
7211             goto error_return;
7212
7213           amt = sizeof *l;
7214           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7215           if (l == NULL)
7216             goto error_return;
7217
7218           l->by = abfd;
7219           l->name = string;
7220           l->next = *pneeded;
7221           *pneeded = l;
7222         }
7223     }
7224
7225   free (dynbuf);
7226
7227   return TRUE;
7228
7229  error_return:
7230   if (dynbuf != NULL)
7231     free (dynbuf);
7232   return FALSE;
7233 }
7234
7235 struct elf_symbuf_symbol
7236 {
7237   unsigned long st_name;        /* Symbol name, index in string tbl */
7238   unsigned char st_info;        /* Type and binding attributes */
7239   unsigned char st_other;       /* Visibilty, and target specific */
7240 };
7241
7242 struct elf_symbuf_head
7243 {
7244   struct elf_symbuf_symbol *ssym;
7245   bfd_size_type count;
7246   unsigned int st_shndx;
7247 };
7248
7249 struct elf_symbol
7250 {
7251   union
7252     {
7253       Elf_Internal_Sym *isym;
7254       struct elf_symbuf_symbol *ssym;
7255     } u;
7256   const char *name;
7257 };
7258
7259 /* Sort references to symbols by ascending section number.  */
7260
7261 static int
7262 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7263 {
7264   const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7265   const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7266
7267   return s1->st_shndx - s2->st_shndx;
7268 }
7269
7270 static int
7271 elf_sym_name_compare (const void *arg1, const void *arg2)
7272 {
7273   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7274   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7275   return strcmp (s1->name, s2->name);
7276 }
7277
7278 static struct elf_symbuf_head *
7279 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7280 {
7281   Elf_Internal_Sym **ind, **indbufend, **indbuf;
7282   struct elf_symbuf_symbol *ssym;
7283   struct elf_symbuf_head *ssymbuf, *ssymhead;
7284   bfd_size_type i, shndx_count, total_size;
7285
7286   indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7287   if (indbuf == NULL)
7288     return NULL;
7289
7290   for (ind = indbuf, i = 0; i < symcount; i++)
7291     if (isymbuf[i].st_shndx != SHN_UNDEF)
7292       *ind++ = &isymbuf[i];
7293   indbufend = ind;
7294
7295   qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7296          elf_sort_elf_symbol);
7297
7298   shndx_count = 0;
7299   if (indbufend > indbuf)
7300     for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7301       if (ind[0]->st_shndx != ind[1]->st_shndx)
7302         shndx_count++;
7303
7304   total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7305                 + (indbufend - indbuf) * sizeof (*ssym));
7306   ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7307   if (ssymbuf == NULL)
7308     {
7309       free (indbuf);
7310       return NULL;
7311     }
7312
7313   ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7314   ssymbuf->ssym = NULL;
7315   ssymbuf->count = shndx_count;
7316   ssymbuf->st_shndx = 0;
7317   for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7318     {
7319       if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7320         {
7321           ssymhead++;
7322           ssymhead->ssym = ssym;
7323           ssymhead->count = 0;
7324           ssymhead->st_shndx = (*ind)->st_shndx;
7325         }
7326       ssym->st_name = (*ind)->st_name;
7327       ssym->st_info = (*ind)->st_info;
7328       ssym->st_other = (*ind)->st_other;
7329       ssymhead->count++;
7330     }
7331   BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7332               && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7333                   == total_size));
7334
7335   free (indbuf);
7336   return ssymbuf;
7337 }
7338
7339 /* Check if 2 sections define the same set of local and global
7340    symbols.  */
7341
7342 static bfd_boolean
7343 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7344                                    struct bfd_link_info *info)
7345 {
7346   bfd *bfd1, *bfd2;
7347   const struct elf_backend_data *bed1, *bed2;
7348   Elf_Internal_Shdr *hdr1, *hdr2;
7349   bfd_size_type symcount1, symcount2;
7350   Elf_Internal_Sym *isymbuf1, *isymbuf2;
7351   struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7352   Elf_Internal_Sym *isym, *isymend;
7353   struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7354   bfd_size_type count1, count2, i;
7355   unsigned int shndx1, shndx2;
7356   bfd_boolean result;
7357
7358   bfd1 = sec1->owner;
7359   bfd2 = sec2->owner;
7360
7361   /* Both sections have to be in ELF.  */
7362   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7363       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7364     return FALSE;
7365
7366   if (elf_section_type (sec1) != elf_section_type (sec2))
7367     return FALSE;
7368
7369   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7370   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7371   if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7372     return FALSE;
7373
7374   bed1 = get_elf_backend_data (bfd1);
7375   bed2 = get_elf_backend_data (bfd2);
7376   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7377   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7378   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7379   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7380
7381   if (symcount1 == 0 || symcount2 == 0)
7382     return FALSE;
7383
7384   result = FALSE;
7385   isymbuf1 = NULL;
7386   isymbuf2 = NULL;
7387   ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7388   ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7389
7390   if (ssymbuf1 == NULL)
7391     {
7392       isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7393                                        NULL, NULL, NULL);
7394       if (isymbuf1 == NULL)
7395         goto done;
7396
7397       if (!info->reduce_memory_overheads)
7398         elf_tdata (bfd1)->symbuf = ssymbuf1
7399           = elf_create_symbuf (symcount1, isymbuf1);
7400     }
7401
7402   if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7403     {
7404       isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7405                                        NULL, NULL, NULL);
7406       if (isymbuf2 == NULL)
7407         goto done;
7408
7409       if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7410         elf_tdata (bfd2)->symbuf = ssymbuf2
7411           = elf_create_symbuf (symcount2, isymbuf2);
7412     }
7413
7414   if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7415     {
7416       /* Optimized faster version.  */
7417       bfd_size_type lo, hi, mid;
7418       struct elf_symbol *symp;
7419       struct elf_symbuf_symbol *ssym, *ssymend;
7420
7421       lo = 0;
7422       hi = ssymbuf1->count;
7423       ssymbuf1++;
7424       count1 = 0;
7425       while (lo < hi)
7426         {
7427           mid = (lo + hi) / 2;
7428           if (shndx1 < ssymbuf1[mid].st_shndx)
7429             hi = mid;
7430           else if (shndx1 > ssymbuf1[mid].st_shndx)
7431             lo = mid + 1;
7432           else
7433             {
7434               count1 = ssymbuf1[mid].count;
7435               ssymbuf1 += mid;
7436               break;
7437             }
7438         }
7439
7440       lo = 0;
7441       hi = ssymbuf2->count;
7442       ssymbuf2++;
7443       count2 = 0;
7444       while (lo < hi)
7445         {
7446           mid = (lo + hi) / 2;
7447           if (shndx2 < ssymbuf2[mid].st_shndx)
7448             hi = mid;
7449           else if (shndx2 > ssymbuf2[mid].st_shndx)
7450             lo = mid + 1;
7451           else
7452             {
7453               count2 = ssymbuf2[mid].count;
7454               ssymbuf2 += mid;
7455               break;
7456             }
7457         }
7458
7459       if (count1 == 0 || count2 == 0 || count1 != count2)
7460         goto done;
7461
7462       symtable1
7463         = (struct elf_symbol *) bfd_malloc (count1 * sizeof (*symtable1));
7464       symtable2
7465         = (struct elf_symbol *) bfd_malloc (count2 * sizeof (*symtable2));
7466       if (symtable1 == NULL || symtable2 == NULL)
7467         goto done;
7468
7469       symp = symtable1;
7470       for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7471            ssym < ssymend; ssym++, symp++)
7472         {
7473           symp->u.ssym = ssym;
7474           symp->name = bfd_elf_string_from_elf_section (bfd1,
7475                                                         hdr1->sh_link,
7476                                                         ssym->st_name);
7477         }
7478
7479       symp = symtable2;
7480       for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7481            ssym < ssymend; ssym++, symp++)
7482         {
7483           symp->u.ssym = ssym;
7484           symp->name = bfd_elf_string_from_elf_section (bfd2,
7485                                                         hdr2->sh_link,
7486                                                         ssym->st_name);
7487         }
7488
7489       /* Sort symbol by name.  */
7490       qsort (symtable1, count1, sizeof (struct elf_symbol),
7491              elf_sym_name_compare);
7492       qsort (symtable2, count1, sizeof (struct elf_symbol),
7493              elf_sym_name_compare);
7494
7495       for (i = 0; i < count1; i++)
7496         /* Two symbols must have the same binding, type and name.  */
7497         if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7498             || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7499             || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7500           goto done;
7501
7502       result = TRUE;
7503       goto done;
7504     }
7505
7506   symtable1 = (struct elf_symbol *)
7507       bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7508   symtable2 = (struct elf_symbol *)
7509       bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7510   if (symtable1 == NULL || symtable2 == NULL)
7511     goto done;
7512
7513   /* Count definitions in the section.  */
7514   count1 = 0;
7515   for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7516     if (isym->st_shndx == shndx1)
7517       symtable1[count1++].u.isym = isym;
7518
7519   count2 = 0;
7520   for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7521     if (isym->st_shndx == shndx2)
7522       symtable2[count2++].u.isym = isym;
7523
7524   if (count1 == 0 || count2 == 0 || count1 != count2)
7525     goto done;
7526
7527   for (i = 0; i < count1; i++)
7528     symtable1[i].name
7529       = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7530                                          symtable1[i].u.isym->st_name);
7531
7532   for (i = 0; i < count2; i++)
7533     symtable2[i].name
7534       = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7535                                          symtable2[i].u.isym->st_name);
7536
7537   /* Sort symbol by name.  */
7538   qsort (symtable1, count1, sizeof (struct elf_symbol),
7539          elf_sym_name_compare);
7540   qsort (symtable2, count1, sizeof (struct elf_symbol),
7541          elf_sym_name_compare);
7542
7543   for (i = 0; i < count1; i++)
7544     /* Two symbols must have the same binding, type and name.  */
7545     if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7546         || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7547         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7548       goto done;
7549
7550   result = TRUE;
7551
7552 done:
7553   if (symtable1)
7554     free (symtable1);
7555   if (symtable2)
7556     free (symtable2);
7557   if (isymbuf1)
7558     free (isymbuf1);
7559   if (isymbuf2)
7560     free (isymbuf2);
7561
7562   return result;
7563 }
7564
7565 /* Return TRUE if 2 section types are compatible.  */
7566
7567 bfd_boolean
7568 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7569                                  bfd *bbfd, const asection *bsec)
7570 {
7571   if (asec == NULL
7572       || bsec == NULL
7573       || abfd->xvec->flavour != bfd_target_elf_flavour
7574       || bbfd->xvec->flavour != bfd_target_elf_flavour)
7575     return TRUE;
7576
7577   return elf_section_type (asec) == elf_section_type (bsec);
7578 }
7579 \f
7580 /* Final phase of ELF linker.  */
7581
7582 /* A structure we use to avoid passing large numbers of arguments.  */
7583
7584 struct elf_final_link_info
7585 {
7586   /* General link information.  */
7587   struct bfd_link_info *info;
7588   /* Output BFD.  */
7589   bfd *output_bfd;
7590   /* Symbol string table.  */
7591   struct elf_strtab_hash *symstrtab;
7592   /* .hash section.  */
7593   asection *hash_sec;
7594   /* symbol version section (.gnu.version).  */
7595   asection *symver_sec;
7596   /* Buffer large enough to hold contents of any section.  */
7597   bfd_byte *contents;
7598   /* Buffer large enough to hold external relocs of any section.  */
7599   void *external_relocs;
7600   /* Buffer large enough to hold internal relocs of any section.  */
7601   Elf_Internal_Rela *internal_relocs;
7602   /* Buffer large enough to hold external local symbols of any input
7603      BFD.  */
7604   bfd_byte *external_syms;
7605   /* And a buffer for symbol section indices.  */
7606   Elf_External_Sym_Shndx *locsym_shndx;
7607   /* Buffer large enough to hold internal local symbols of any input
7608      BFD.  */
7609   Elf_Internal_Sym *internal_syms;
7610   /* Array large enough to hold a symbol index for each local symbol
7611      of any input BFD.  */
7612   long *indices;
7613   /* Array large enough to hold a section pointer for each local
7614      symbol of any input BFD.  */
7615   asection **sections;
7616   /* Buffer for SHT_SYMTAB_SHNDX section.  */
7617   Elf_External_Sym_Shndx *symshndxbuf;
7618   /* Number of STT_FILE syms seen.  */
7619   size_t filesym_count;
7620 };
7621
7622 /* This struct is used to pass information to elf_link_output_extsym.  */
7623
7624 struct elf_outext_info
7625 {
7626   bfd_boolean failed;
7627   bfd_boolean localsyms;
7628   bfd_boolean file_sym_done;
7629   struct elf_final_link_info *flinfo;
7630 };
7631
7632
7633 /* Support for evaluating a complex relocation.
7634
7635    Complex relocations are generalized, self-describing relocations.  The
7636    implementation of them consists of two parts: complex symbols, and the
7637    relocations themselves.
7638
7639    The relocations are use a reserved elf-wide relocation type code (R_RELC
7640    external / BFD_RELOC_RELC internal) and an encoding of relocation field
7641    information (start bit, end bit, word width, etc) into the addend.  This
7642    information is extracted from CGEN-generated operand tables within gas.
7643
7644    Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7645    internal) representing prefix-notation expressions, including but not
7646    limited to those sorts of expressions normally encoded as addends in the
7647    addend field.  The symbol mangling format is:
7648
7649    <node> := <literal>
7650           |  <unary-operator> ':' <node>
7651           |  <binary-operator> ':' <node> ':' <node>
7652           ;
7653
7654    <literal> := 's' <digits=N> ':' <N character symbol name>
7655              |  'S' <digits=N> ':' <N character section name>
7656              |  '#' <hexdigits>
7657              ;
7658
7659    <binary-operator> := as in C
7660    <unary-operator> := as in C, plus "0-" for unambiguous negation.  */
7661
7662 static void
7663 set_symbol_value (bfd *bfd_with_globals,
7664                   Elf_Internal_Sym *isymbuf,
7665                   size_t locsymcount,
7666                   size_t symidx,
7667                   bfd_vma val)
7668 {
7669   struct elf_link_hash_entry **sym_hashes;
7670   struct elf_link_hash_entry *h;
7671   size_t extsymoff = locsymcount;
7672
7673   if (symidx < locsymcount)
7674     {
7675       Elf_Internal_Sym *sym;
7676
7677       sym = isymbuf + symidx;
7678       if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7679         {
7680           /* It is a local symbol: move it to the
7681              "absolute" section and give it a value.  */
7682           sym->st_shndx = SHN_ABS;
7683           sym->st_value = val;
7684           return;
7685         }
7686       BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7687       extsymoff = 0;
7688     }
7689
7690   /* It is a global symbol: set its link type
7691      to "defined" and give it a value.  */
7692
7693   sym_hashes = elf_sym_hashes (bfd_with_globals);
7694   h = sym_hashes [symidx - extsymoff];
7695   while (h->root.type == bfd_link_hash_indirect
7696          || h->root.type == bfd_link_hash_warning)
7697     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7698   h->root.type = bfd_link_hash_defined;
7699   h->root.u.def.value = val;
7700   h->root.u.def.section = bfd_abs_section_ptr;
7701 }
7702
7703 static bfd_boolean
7704 resolve_symbol (const char *name,
7705                 bfd *input_bfd,
7706                 struct elf_final_link_info *flinfo,
7707                 bfd_vma *result,
7708                 Elf_Internal_Sym *isymbuf,
7709                 size_t locsymcount)
7710 {
7711   Elf_Internal_Sym *sym;
7712   struct bfd_link_hash_entry *global_entry;
7713   const char *candidate = NULL;
7714   Elf_Internal_Shdr *symtab_hdr;
7715   size_t i;
7716
7717   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7718
7719   for (i = 0; i < locsymcount; ++ i)
7720     {
7721       sym = isymbuf + i;
7722
7723       if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7724         continue;
7725
7726       candidate = bfd_elf_string_from_elf_section (input_bfd,
7727                                                    symtab_hdr->sh_link,
7728                                                    sym->st_name);
7729 #ifdef DEBUG
7730       printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7731               name, candidate, (unsigned long) sym->st_value);
7732 #endif
7733       if (candidate && strcmp (candidate, name) == 0)
7734         {
7735           asection *sec = flinfo->sections [i];
7736
7737           *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7738           *result += sec->output_offset + sec->output_section->vma;
7739 #ifdef DEBUG
7740           printf ("Found symbol with value %8.8lx\n",
7741                   (unsigned long) *result);
7742 #endif
7743           return TRUE;
7744         }
7745     }
7746
7747   /* Hmm, haven't found it yet. perhaps it is a global.  */
7748   global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
7749                                        FALSE, FALSE, TRUE);
7750   if (!global_entry)
7751     return FALSE;
7752
7753   if (global_entry->type == bfd_link_hash_defined
7754       || global_entry->type == bfd_link_hash_defweak)
7755     {
7756       *result = (global_entry->u.def.value
7757                  + global_entry->u.def.section->output_section->vma
7758                  + global_entry->u.def.section->output_offset);
7759 #ifdef DEBUG
7760       printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7761               global_entry->root.string, (unsigned long) *result);
7762 #endif
7763       return TRUE;
7764     }
7765
7766   return FALSE;
7767 }
7768
7769 /* Looks up NAME in SECTIONS.  If found sets RESULT to NAME's address (in
7770    bytes) and returns TRUE, otherwise returns FALSE.  Accepts pseudo-section
7771    names like "foo.end" which is the end address of section "foo".  */
7772    
7773 static bfd_boolean
7774 resolve_section (const char *name,
7775                  asection *sections,
7776                  bfd_vma *result,
7777                  bfd * abfd)
7778 {
7779   asection *curr;
7780   unsigned int len;
7781
7782   for (curr = sections; curr; curr = curr->next)
7783     if (strcmp (curr->name, name) == 0)
7784       {
7785         *result = curr->vma;
7786         return TRUE;
7787       }
7788
7789   /* Hmm. still haven't found it. try pseudo-section names.  */
7790   /* FIXME: This could be coded more efficiently...  */
7791   for (curr = sections; curr; curr = curr->next)
7792     {
7793       len = strlen (curr->name);
7794       if (len > strlen (name))
7795         continue;
7796
7797       if (strncmp (curr->name, name, len) == 0)
7798         {
7799           if (strncmp (".end", name + len, 4) == 0)
7800             {
7801               *result = curr->vma + curr->size / bfd_octets_per_byte (abfd);
7802               return TRUE;
7803             }
7804
7805           /* Insert more pseudo-section names here, if you like.  */
7806         }
7807     }
7808
7809   return FALSE;
7810 }
7811
7812 static void
7813 undefined_reference (const char *reftype, const char *name)
7814 {
7815   _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7816                       reftype, name);
7817 }
7818
7819 static bfd_boolean
7820 eval_symbol (bfd_vma *result,
7821              const char **symp,
7822              bfd *input_bfd,
7823              struct elf_final_link_info *flinfo,
7824              bfd_vma dot,
7825              Elf_Internal_Sym *isymbuf,
7826              size_t locsymcount,
7827              int signed_p)
7828 {
7829   size_t len;
7830   size_t symlen;
7831   bfd_vma a;
7832   bfd_vma b;
7833   char symbuf[4096];
7834   const char *sym = *symp;
7835   const char *symend;
7836   bfd_boolean symbol_is_section = FALSE;
7837
7838   len = strlen (sym);
7839   symend = sym + len;
7840
7841   if (len < 1 || len > sizeof (symbuf))
7842     {
7843       bfd_set_error (bfd_error_invalid_operation);
7844       return FALSE;
7845     }
7846
7847   switch (* sym)
7848     {
7849     case '.':
7850       *result = dot;
7851       *symp = sym + 1;
7852       return TRUE;
7853
7854     case '#':
7855       ++sym;
7856       *result = strtoul (sym, (char **) symp, 16);
7857       return TRUE;
7858
7859     case 'S':
7860       symbol_is_section = TRUE;
7861     case 's':
7862       ++sym;
7863       symlen = strtol (sym, (char **) symp, 10);
7864       sym = *symp + 1; /* Skip the trailing ':'.  */
7865
7866       if (symend < sym || symlen + 1 > sizeof (symbuf))
7867         {
7868           bfd_set_error (bfd_error_invalid_operation);
7869           return FALSE;
7870         }
7871
7872       memcpy (symbuf, sym, symlen);
7873       symbuf[symlen] = '\0';
7874       *symp = sym + symlen;
7875
7876       /* Is it always possible, with complex symbols, that gas "mis-guessed"
7877          the symbol as a section, or vice-versa. so we're pretty liberal in our
7878          interpretation here; section means "try section first", not "must be a
7879          section", and likewise with symbol.  */
7880
7881       if (symbol_is_section)
7882         {
7883           if (!resolve_section (symbuf, flinfo->output_bfd->sections, result, input_bfd)
7884               && !resolve_symbol (symbuf, input_bfd, flinfo, result,
7885                                   isymbuf, locsymcount))
7886             {
7887               undefined_reference ("section", symbuf);
7888               return FALSE;
7889             }
7890         }
7891       else
7892         {
7893           if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
7894                                isymbuf, locsymcount)
7895               && !resolve_section (symbuf, flinfo->output_bfd->sections,
7896                                    result, input_bfd))
7897             {
7898               undefined_reference ("symbol", symbuf);
7899               return FALSE;
7900             }
7901         }
7902
7903       return TRUE;
7904
7905       /* All that remains are operators.  */
7906
7907 #define UNARY_OP(op)                                            \
7908   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7909     {                                                           \
7910       sym += strlen (#op);                                      \
7911       if (*sym == ':')                                          \
7912         ++sym;                                                  \
7913       *symp = sym;                                              \
7914       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
7915                         isymbuf, locsymcount, signed_p))        \
7916         return FALSE;                                           \
7917       if (signed_p)                                             \
7918         *result = op ((bfd_signed_vma) a);                      \
7919       else                                                      \
7920         *result = op a;                                         \
7921       return TRUE;                                              \
7922     }
7923
7924 #define BINARY_OP(op)                                           \
7925   if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7926     {                                                           \
7927       sym += strlen (#op);                                      \
7928       if (*sym == ':')                                          \
7929         ++sym;                                                  \
7930       *symp = sym;                                              \
7931       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,       \
7932                         isymbuf, locsymcount, signed_p))        \
7933         return FALSE;                                           \
7934       ++*symp;                                                  \
7935       if (!eval_symbol (&b, symp, input_bfd, flinfo, dot,       \
7936                         isymbuf, locsymcount, signed_p))        \
7937         return FALSE;                                           \
7938       if (signed_p)                                             \
7939         *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7940       else                                                      \
7941         *result = a op b;                                       \
7942       return TRUE;                                              \
7943     }
7944
7945     default:
7946       UNARY_OP  (0-);
7947       BINARY_OP (<<);
7948       BINARY_OP (>>);
7949       BINARY_OP (==);
7950       BINARY_OP (!=);
7951       BINARY_OP (<=);
7952       BINARY_OP (>=);
7953       BINARY_OP (&&);
7954       BINARY_OP (||);
7955       UNARY_OP  (~);
7956       UNARY_OP  (!);
7957       BINARY_OP (*);
7958       BINARY_OP (/);
7959       BINARY_OP (%);
7960       BINARY_OP (^);
7961       BINARY_OP (|);
7962       BINARY_OP (&);
7963       BINARY_OP (+);
7964       BINARY_OP (-);
7965       BINARY_OP (<);
7966       BINARY_OP (>);
7967 #undef UNARY_OP
7968 #undef BINARY_OP
7969       _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7970       bfd_set_error (bfd_error_invalid_operation);
7971       return FALSE;
7972     }
7973 }
7974
7975 static void
7976 put_value (bfd_vma size,
7977            unsigned long chunksz,
7978            bfd *input_bfd,
7979            bfd_vma x,
7980            bfd_byte *location)
7981 {
7982   location += (size - chunksz);
7983
7984   for (; size; size -= chunksz, location -= chunksz)
7985     {
7986       switch (chunksz)
7987         {
7988         case 1:
7989           bfd_put_8 (input_bfd, x, location);
7990           x >>= 8;
7991           break;
7992         case 2:
7993           bfd_put_16 (input_bfd, x, location);
7994           x >>= 16;
7995           break;
7996         case 4:
7997           bfd_put_32 (input_bfd, x, location);
7998           /* Computed this way because x >>= 32 is undefined if x is a 32-bit value.  */
7999           x >>= 16;
8000           x >>= 16;
8001           break;
8002 #ifdef BFD64
8003         case 8:
8004           bfd_put_64 (input_bfd, x, location);
8005           /* Computed this way because x >>= 64 is undefined if x is a 64-bit value.  */
8006           x >>= 32;
8007           x >>= 32;
8008           break;
8009 #endif
8010         default:
8011           abort ();
8012           break;
8013         }
8014     }
8015 }
8016
8017 static bfd_vma
8018 get_value (bfd_vma size,
8019            unsigned long chunksz,
8020            bfd *input_bfd,
8021            bfd_byte *location)
8022 {
8023   int shift;
8024   bfd_vma x = 0;
8025
8026   /* Sanity checks.  */
8027   BFD_ASSERT (chunksz <= sizeof (x)
8028               && size >= chunksz
8029               && chunksz != 0
8030               && (size % chunksz) == 0
8031               && input_bfd != NULL
8032               && location != NULL);
8033
8034   if (chunksz == sizeof (x))
8035     {
8036       BFD_ASSERT (size == chunksz);
8037
8038       /* Make sure that we do not perform an undefined shift operation.
8039          We know that size == chunksz so there will only be one iteration
8040          of the loop below.  */
8041       shift = 0;
8042     }
8043   else
8044     shift = 8 * chunksz;
8045
8046   for (; size; size -= chunksz, location += chunksz)
8047     {
8048       switch (chunksz)
8049         {
8050         case 1:
8051           x = (x << shift) | bfd_get_8 (input_bfd, location);
8052           break;
8053         case 2:
8054           x = (x << shift) | bfd_get_16 (input_bfd, location);
8055           break;
8056         case 4:
8057           x = (x << shift) | bfd_get_32 (input_bfd, location);
8058           break;
8059 #ifdef BFD64
8060         case 8:
8061           x = (x << shift) | bfd_get_64 (input_bfd, location);
8062           break;
8063 #endif
8064         default:
8065           abort ();
8066         }
8067     }
8068   return x;
8069 }
8070
8071 static void
8072 decode_complex_addend (unsigned long *start,   /* in bits */
8073                        unsigned long *oplen,   /* in bits */
8074                        unsigned long *len,     /* in bits */
8075                        unsigned long *wordsz,  /* in bytes */
8076                        unsigned long *chunksz, /* in bytes */
8077                        unsigned long *lsb0_p,
8078                        unsigned long *signed_p,
8079                        unsigned long *trunc_p,
8080                        unsigned long encoded)
8081 {
8082   * start     =  encoded        & 0x3F;
8083   * len       = (encoded >>  6) & 0x3F;
8084   * oplen     = (encoded >> 12) & 0x3F;
8085   * wordsz    = (encoded >> 18) & 0xF;
8086   * chunksz   = (encoded >> 22) & 0xF;
8087   * lsb0_p    = (encoded >> 27) & 1;
8088   * signed_p  = (encoded >> 28) & 1;
8089   * trunc_p   = (encoded >> 29) & 1;
8090 }
8091
8092 bfd_reloc_status_type
8093 bfd_elf_perform_complex_relocation (bfd *input_bfd,
8094                                     asection *input_section ATTRIBUTE_UNUSED,
8095                                     bfd_byte *contents,
8096                                     Elf_Internal_Rela *rel,
8097                                     bfd_vma relocation)
8098 {
8099   bfd_vma shift, x, mask;
8100   unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
8101   bfd_reloc_status_type r;
8102
8103   /*  Perform this reloc, since it is complex.
8104       (this is not to say that it necessarily refers to a complex
8105       symbol; merely that it is a self-describing CGEN based reloc.
8106       i.e. the addend has the complete reloc information (bit start, end,
8107       word size, etc) encoded within it.).  */
8108
8109   decode_complex_addend (&start, &oplen, &len, &wordsz,
8110                          &chunksz, &lsb0_p, &signed_p,
8111                          &trunc_p, rel->r_addend);
8112
8113   mask = (((1L << (len - 1)) - 1) << 1) | 1;
8114
8115   if (lsb0_p)
8116     shift = (start + 1) - len;
8117   else
8118     shift = (8 * wordsz) - (start + len);
8119
8120   x = get_value (wordsz, chunksz, input_bfd,
8121                  contents + rel->r_offset * bfd_octets_per_byte (input_bfd));
8122
8123 #ifdef DEBUG
8124   printf ("Doing complex reloc: "
8125           "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
8126           "chunksz %ld, start %ld, len %ld, oplen %ld\n"
8127           "    dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
8128           lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
8129           oplen, (unsigned long) x, (unsigned long) mask,
8130           (unsigned long) relocation);
8131 #endif
8132
8133   r = bfd_reloc_ok;
8134   if (! trunc_p)
8135     /* Now do an overflow check.  */
8136     r = bfd_check_overflow ((signed_p
8137                              ? complain_overflow_signed
8138                              : complain_overflow_unsigned),
8139                             len, 0, (8 * wordsz),
8140                             relocation);
8141
8142   /* Do the deed.  */
8143   x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
8144
8145 #ifdef DEBUG
8146   printf ("           relocation: %8.8lx\n"
8147           "         shifted mask: %8.8lx\n"
8148           " shifted/masked reloc: %8.8lx\n"
8149           "               result: %8.8lx\n",
8150           (unsigned long) relocation, (unsigned long) (mask << shift),
8151           (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
8152 #endif
8153   put_value (wordsz, chunksz, input_bfd, x,
8154              contents + rel->r_offset * bfd_octets_per_byte (input_bfd));
8155   return r;
8156 }
8157
8158 /* Functions to read r_offset from external (target order) reloc
8159    entry.  Faster than bfd_getl32 et al, because we let the compiler
8160    know the value is aligned.  */
8161
8162 static bfd_vma
8163 ext32l_r_offset (const void *p)
8164 {
8165   union aligned32
8166   {
8167     uint32_t v;
8168     unsigned char c[4];
8169   };
8170   const union aligned32 *a
8171     = (const union aligned32 *) &((const Elf32_External_Rel *) p)->r_offset;
8172
8173   uint32_t aval = (  (uint32_t) a->c[0]
8174                    | (uint32_t) a->c[1] << 8
8175                    | (uint32_t) a->c[2] << 16
8176                    | (uint32_t) a->c[3] << 24);
8177   return aval;
8178 }
8179
8180 static bfd_vma
8181 ext32b_r_offset (const void *p)
8182 {
8183   union aligned32
8184   {
8185     uint32_t v;
8186     unsigned char c[4];
8187   };
8188   const union aligned32 *a
8189     = (const union aligned32 *) &((const Elf32_External_Rel *) p)->r_offset;
8190
8191   uint32_t aval = (  (uint32_t) a->c[0] << 24
8192                    | (uint32_t) a->c[1] << 16
8193                    | (uint32_t) a->c[2] << 8
8194                    | (uint32_t) a->c[3]);
8195   return aval;
8196 }
8197
8198 #ifdef BFD_HOST_64_BIT
8199 static bfd_vma
8200 ext64l_r_offset (const void *p)
8201 {
8202   union aligned64
8203   {
8204     uint64_t v;
8205     unsigned char c[8];
8206   };
8207   const union aligned64 *a
8208     = (const union aligned64 *) &((const Elf64_External_Rel *) p)->r_offset;
8209
8210   uint64_t aval = (  (uint64_t) a->c[0]
8211                    | (uint64_t) a->c[1] << 8
8212                    | (uint64_t) a->c[2] << 16
8213                    | (uint64_t) a->c[3] << 24
8214                    | (uint64_t) a->c[4] << 32
8215                    | (uint64_t) a->c[5] << 40
8216                    | (uint64_t) a->c[6] << 48
8217                    | (uint64_t) a->c[7] << 56);
8218   return aval;
8219 }
8220
8221 static bfd_vma
8222 ext64b_r_offset (const void *p)
8223 {
8224   union aligned64
8225   {
8226     uint64_t v;
8227     unsigned char c[8];
8228   };
8229   const union aligned64 *a
8230     = (const union aligned64 *) &((const Elf64_External_Rel *) p)->r_offset;
8231
8232   uint64_t aval = (  (uint64_t) a->c[0] << 56
8233                    | (uint64_t) a->c[1] << 48
8234                    | (uint64_t) a->c[2] << 40
8235                    | (uint64_t) a->c[3] << 32
8236                    | (uint64_t) a->c[4] << 24
8237                    | (uint64_t) a->c[5] << 16
8238                    | (uint64_t) a->c[6] << 8
8239                    | (uint64_t) a->c[7]);
8240   return aval;
8241 }
8242 #endif
8243
8244 /* When performing a relocatable link, the input relocations are
8245    preserved.  But, if they reference global symbols, the indices
8246    referenced must be updated.  Update all the relocations found in
8247    RELDATA.  */
8248
8249 static bfd_boolean
8250 elf_link_adjust_relocs (bfd *abfd,
8251                         struct bfd_elf_section_reloc_data *reldata,
8252                         bfd_boolean sort)
8253 {
8254   unsigned int i;
8255   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8256   bfd_byte *erela;
8257   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8258   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8259   bfd_vma r_type_mask;
8260   int r_sym_shift;
8261   unsigned int count = reldata->count;
8262   struct elf_link_hash_entry **rel_hash = reldata->hashes;
8263
8264   if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
8265     {
8266       swap_in = bed->s->swap_reloc_in;
8267       swap_out = bed->s->swap_reloc_out;
8268     }
8269   else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
8270     {
8271       swap_in = bed->s->swap_reloca_in;
8272       swap_out = bed->s->swap_reloca_out;
8273     }
8274   else
8275     abort ();
8276
8277   if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
8278     abort ();
8279
8280   if (bed->s->arch_size == 32)
8281     {
8282       r_type_mask = 0xff;
8283       r_sym_shift = 8;
8284     }
8285   else
8286     {
8287       r_type_mask = 0xffffffff;
8288       r_sym_shift = 32;
8289     }
8290
8291   erela = reldata->hdr->contents;
8292   for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
8293     {
8294       Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
8295       unsigned int j;
8296
8297       if (*rel_hash == NULL)
8298         continue;
8299
8300       BFD_ASSERT ((*rel_hash)->indx >= 0);
8301
8302       (*swap_in) (abfd, erela, irela);
8303       for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
8304         irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
8305                            | (irela[j].r_info & r_type_mask));
8306       (*swap_out) (abfd, irela, erela);
8307     }
8308
8309   if (sort && count != 0)
8310     {
8311       bfd_vma (*ext_r_off) (const void *);
8312       bfd_vma r_off;
8313       size_t elt_size;
8314       bfd_byte *base, *end, *p, *loc;
8315       bfd_byte *buf = NULL;
8316
8317       if (bed->s->arch_size == 32)
8318         {
8319           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8320             ext_r_off = ext32l_r_offset;
8321           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8322             ext_r_off = ext32b_r_offset;
8323           else
8324             abort ();
8325         }
8326       else
8327         {
8328 #ifdef BFD_HOST_64_BIT
8329           if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
8330             ext_r_off = ext64l_r_offset;
8331           else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
8332             ext_r_off = ext64b_r_offset;
8333           else
8334 #endif
8335             abort ();
8336         }
8337
8338       /*  Must use a stable sort here.  A modified insertion sort,
8339           since the relocs are mostly sorted already.  */
8340       elt_size = reldata->hdr->sh_entsize;
8341       base = reldata->hdr->contents;
8342       end = base + count * elt_size;
8343       if (elt_size > sizeof (Elf64_External_Rela))
8344         abort ();
8345
8346       /* Ensure the first element is lowest.  This acts as a sentinel,
8347          speeding the main loop below.  */
8348       r_off = (*ext_r_off) (base);
8349       for (p = loc = base; (p += elt_size) < end; )
8350         {
8351           bfd_vma r_off2 = (*ext_r_off) (p);
8352           if (r_off > r_off2)
8353             {
8354               r_off = r_off2;
8355               loc = p;
8356             }
8357         }
8358       if (loc != base)
8359         {
8360           /* Don't just swap *base and *loc as that changes the order
8361              of the original base[0] and base[1] if they happen to
8362              have the same r_offset.  */
8363           bfd_byte onebuf[sizeof (Elf64_External_Rela)];
8364           memcpy (onebuf, loc, elt_size);
8365           memmove (base + elt_size, base, loc - base);
8366           memcpy (base, onebuf, elt_size);
8367         }
8368
8369       for (p = base + elt_size; (p += elt_size) < end; )
8370         {
8371           /* base to p is sorted, *p is next to insert.  */
8372           r_off = (*ext_r_off) (p);
8373           /* Search the sorted region for location to insert.  */
8374           loc = p - elt_size;
8375           while (r_off < (*ext_r_off) (loc))
8376             loc -= elt_size;
8377           loc += elt_size;
8378           if (loc != p)
8379             {
8380               /* Chances are there is a run of relocs to insert here,
8381                  from one of more input files.  Files are not always
8382                  linked in order due to the way elf_link_input_bfd is
8383                  called.  See pr17666.  */
8384               size_t sortlen = p - loc;
8385               bfd_vma r_off2 = (*ext_r_off) (loc);
8386               size_t runlen = elt_size;
8387               size_t buf_size = 96 * 1024;
8388               while (p + runlen < end
8389                      && (sortlen <= buf_size
8390                          || runlen + elt_size <= buf_size)
8391                      && r_off2 > (*ext_r_off) (p + runlen))
8392                 runlen += elt_size;
8393               if (buf == NULL)
8394                 {
8395                   buf = bfd_malloc (buf_size);
8396                   if (buf == NULL)
8397                     return FALSE;
8398                 }
8399               if (runlen < sortlen)
8400                 {
8401                   memcpy (buf, p, runlen);
8402                   memmove (loc + runlen, loc, sortlen);
8403                   memcpy (loc, buf, runlen);
8404                 }
8405               else
8406                 {
8407                   memcpy (buf, loc, sortlen);
8408                   memmove (loc, p, runlen);
8409                   memcpy (loc + runlen, buf, sortlen);
8410                 }
8411               p += runlen - elt_size;
8412             }
8413         }
8414       /* Hashes are no longer valid.  */
8415       free (reldata->hashes);
8416       reldata->hashes = NULL;
8417       free (buf);
8418     }
8419   return TRUE;
8420 }
8421
8422 struct elf_link_sort_rela
8423 {
8424   union {
8425     bfd_vma offset;
8426     bfd_vma sym_mask;
8427   } u;
8428   enum elf_reloc_type_class type;
8429   /* We use this as an array of size int_rels_per_ext_rel.  */
8430   Elf_Internal_Rela rela[1];
8431 };
8432
8433 static int
8434 elf_link_sort_cmp1 (const void *A, const void *B)
8435 {
8436   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8437   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8438   int relativea, relativeb;
8439
8440   relativea = a->type == reloc_class_relative;
8441   relativeb = b->type == reloc_class_relative;
8442
8443   if (relativea < relativeb)
8444     return 1;
8445   if (relativea > relativeb)
8446     return -1;
8447   if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8448     return -1;
8449   if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8450     return 1;
8451   if (a->rela->r_offset < b->rela->r_offset)
8452     return -1;
8453   if (a->rela->r_offset > b->rela->r_offset)
8454     return 1;
8455   return 0;
8456 }
8457
8458 static int
8459 elf_link_sort_cmp2 (const void *A, const void *B)
8460 {
8461   const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8462   const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8463
8464   if (a->type < b->type)
8465     return -1;
8466   if (a->type > b->type)
8467     return 1;
8468   if (a->u.offset < b->u.offset)
8469     return -1;
8470   if (a->u.offset > b->u.offset)
8471     return 1;
8472   if (a->rela->r_offset < b->rela->r_offset)
8473     return -1;
8474   if (a->rela->r_offset > b->rela->r_offset)
8475     return 1;
8476   return 0;
8477 }
8478
8479 static size_t
8480 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8481 {
8482   asection *dynamic_relocs;
8483   asection *rela_dyn;
8484   asection *rel_dyn;
8485   bfd_size_type count, size;
8486   size_t i, ret, sort_elt, ext_size;
8487   bfd_byte *sort, *s_non_relative, *p;
8488   struct elf_link_sort_rela *sq;
8489   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8490   int i2e = bed->s->int_rels_per_ext_rel;
8491   void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8492   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8493   struct bfd_link_order *lo;
8494   bfd_vma r_sym_mask;
8495   bfd_boolean use_rela;
8496
8497   /* Find a dynamic reloc section.  */
8498   rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8499   rel_dyn  = bfd_get_section_by_name (abfd, ".rel.dyn");
8500   if (rela_dyn != NULL && rela_dyn->size > 0
8501       && rel_dyn != NULL && rel_dyn->size > 0)
8502     {
8503       bfd_boolean use_rela_initialised = FALSE;
8504
8505       /* This is just here to stop gcc from complaining.
8506          It's initialization checking code is not perfect.  */
8507       use_rela = TRUE;
8508
8509       /* Both sections are present.  Examine the sizes
8510          of the indirect sections to help us choose.  */
8511       for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8512         if (lo->type == bfd_indirect_link_order)
8513           {
8514             asection *o = lo->u.indirect.section;
8515
8516             if ((o->size % bed->s->sizeof_rela) == 0)
8517               {
8518                 if ((o->size % bed->s->sizeof_rel) == 0)
8519                   /* Section size is divisible by both rel and rela sizes.
8520                      It is of no help to us.  */
8521                   ;
8522                 else
8523                   {
8524                     /* Section size is only divisible by rela.  */
8525                     if (use_rela_initialised && (use_rela == FALSE))
8526                       {
8527                         _bfd_error_handler
8528                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8529                         bfd_set_error (bfd_error_invalid_operation);
8530                         return 0;
8531                       }
8532                     else
8533                       {
8534                         use_rela = TRUE;
8535                         use_rela_initialised = TRUE;
8536                       }
8537                   }
8538               }
8539             else if ((o->size % bed->s->sizeof_rel) == 0)
8540               {
8541                 /* Section size is only divisible by rel.  */
8542                 if (use_rela_initialised && (use_rela == TRUE))
8543                   {
8544                     _bfd_error_handler
8545                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8546                     bfd_set_error (bfd_error_invalid_operation);
8547                     return 0;
8548                   }
8549                 else
8550                   {
8551                     use_rela = FALSE;
8552                     use_rela_initialised = TRUE;
8553                   }
8554               }
8555             else
8556               {
8557                 /* The section size is not divisible by either - something is wrong.  */
8558                 _bfd_error_handler
8559                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8560                 bfd_set_error (bfd_error_invalid_operation);
8561                 return 0;
8562               }
8563           }
8564
8565       for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8566         if (lo->type == bfd_indirect_link_order)
8567           {
8568             asection *o = lo->u.indirect.section;
8569
8570             if ((o->size % bed->s->sizeof_rela) == 0)
8571               {
8572                 if ((o->size % bed->s->sizeof_rel) == 0)
8573                   /* Section size is divisible by both rel and rela sizes.
8574                      It is of no help to us.  */
8575                   ;
8576                 else
8577                   {
8578                     /* Section size is only divisible by rela.  */
8579                     if (use_rela_initialised && (use_rela == FALSE))
8580                       {
8581                         _bfd_error_handler
8582                           (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8583                         bfd_set_error (bfd_error_invalid_operation);
8584                         return 0;
8585                       }
8586                     else
8587                       {
8588                         use_rela = TRUE;
8589                         use_rela_initialised = TRUE;
8590                       }
8591                   }
8592               }
8593             else if ((o->size % bed->s->sizeof_rel) == 0)
8594               {
8595                 /* Section size is only divisible by rel.  */
8596                 if (use_rela_initialised && (use_rela == TRUE))
8597                   {
8598                     _bfd_error_handler
8599                       (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8600                     bfd_set_error (bfd_error_invalid_operation);
8601                     return 0;
8602                   }
8603                 else
8604                   {
8605                     use_rela = FALSE;
8606                     use_rela_initialised = TRUE;
8607                   }
8608               }
8609             else
8610               {
8611                 /* The section size is not divisible by either - something is wrong.  */
8612                 _bfd_error_handler
8613                   (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8614                 bfd_set_error (bfd_error_invalid_operation);
8615                 return 0;
8616               }
8617           }
8618
8619       if (! use_rela_initialised)
8620         /* Make a guess.  */
8621         use_rela = TRUE;
8622     }
8623   else if (rela_dyn != NULL && rela_dyn->size > 0)
8624     use_rela = TRUE;
8625   else if (rel_dyn != NULL && rel_dyn->size > 0)
8626     use_rela = FALSE;
8627   else
8628     return 0;
8629
8630   if (use_rela)
8631     {
8632       dynamic_relocs = rela_dyn;
8633       ext_size = bed->s->sizeof_rela;
8634       swap_in = bed->s->swap_reloca_in;
8635       swap_out = bed->s->swap_reloca_out;
8636     }
8637   else
8638     {
8639       dynamic_relocs = rel_dyn;
8640       ext_size = bed->s->sizeof_rel;
8641       swap_in = bed->s->swap_reloc_in;
8642       swap_out = bed->s->swap_reloc_out;
8643     }
8644
8645   size = 0;
8646   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8647     if (lo->type == bfd_indirect_link_order)
8648       size += lo->u.indirect.section->size;
8649
8650   if (size != dynamic_relocs->size)
8651     return 0;
8652
8653   sort_elt = (sizeof (struct elf_link_sort_rela)
8654               + (i2e - 1) * sizeof (Elf_Internal_Rela));
8655
8656   count = dynamic_relocs->size / ext_size;
8657   if (count == 0)
8658     return 0;
8659   sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8660
8661   if (sort == NULL)
8662     {
8663       (*info->callbacks->warning)
8664         (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8665       return 0;
8666     }
8667
8668   if (bed->s->arch_size == 32)
8669     r_sym_mask = ~(bfd_vma) 0xff;
8670   else
8671     r_sym_mask = ~(bfd_vma) 0xffffffff;
8672
8673   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8674     if (lo->type == bfd_indirect_link_order)
8675       {
8676         bfd_byte *erel, *erelend;
8677         asection *o = lo->u.indirect.section;
8678
8679         if (o->contents == NULL && o->size != 0)
8680           {
8681             /* This is a reloc section that is being handled as a normal
8682                section.  See bfd_section_from_shdr.  We can't combine
8683                relocs in this case.  */
8684             free (sort);
8685             return 0;
8686           }
8687         erel = o->contents;
8688         erelend = o->contents + o->size;
8689         /* FIXME: octets_per_byte.  */
8690         p = sort + o->output_offset / ext_size * sort_elt;
8691
8692         while (erel < erelend)
8693           {
8694             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8695
8696             (*swap_in) (abfd, erel, s->rela);
8697             s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
8698             s->u.sym_mask = r_sym_mask;
8699             p += sort_elt;
8700             erel += ext_size;
8701           }
8702       }
8703
8704   qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8705
8706   for (i = 0, p = sort; i < count; i++, p += sort_elt)
8707     {
8708       struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8709       if (s->type != reloc_class_relative)
8710         break;
8711     }
8712   ret = i;
8713   s_non_relative = p;
8714
8715   sq = (struct elf_link_sort_rela *) s_non_relative;
8716   for (; i < count; i++, p += sort_elt)
8717     {
8718       struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8719       if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8720         sq = sp;
8721       sp->u.offset = sq->rela->r_offset;
8722     }
8723
8724   qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8725
8726   for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8727     if (lo->type == bfd_indirect_link_order)
8728       {
8729         bfd_byte *erel, *erelend;
8730         asection *o = lo->u.indirect.section;
8731
8732         erel = o->contents;
8733         erelend = o->contents + o->size;
8734         /* FIXME: octets_per_byte.  */
8735         p = sort + o->output_offset / ext_size * sort_elt;
8736         while (erel < erelend)
8737           {
8738             struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8739             (*swap_out) (abfd, s->rela, erel);
8740             p += sort_elt;
8741             erel += ext_size;
8742           }
8743       }
8744
8745   free (sort);
8746   *psec = dynamic_relocs;
8747   return ret;
8748 }
8749
8750 /* Add a symbol to the output symbol string table.  */
8751
8752 static int
8753 elf_link_output_symstrtab (struct elf_final_link_info *flinfo,
8754                            const char *name,
8755                            Elf_Internal_Sym *elfsym,
8756                            asection *input_sec,
8757                            struct elf_link_hash_entry *h)
8758 {
8759   int (*output_symbol_hook)
8760     (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8761      struct elf_link_hash_entry *);
8762   struct elf_link_hash_table *hash_table;
8763   const struct elf_backend_data *bed;
8764   bfd_size_type strtabsize;
8765
8766   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
8767
8768   bed = get_elf_backend_data (flinfo->output_bfd);
8769   output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8770   if (output_symbol_hook != NULL)
8771     {
8772       int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
8773       if (ret != 1)
8774         return ret;
8775     }
8776
8777   if (name == NULL
8778       || *name == '\0'
8779       || (input_sec->flags & SEC_EXCLUDE))
8780     elfsym->st_name = (unsigned long) -1;
8781   else
8782     {
8783       /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8784          to get the final offset for st_name.  */
8785       elfsym->st_name
8786         = (unsigned long) _bfd_elf_strtab_add (flinfo->symstrtab,
8787                                                name, FALSE);
8788       if (elfsym->st_name == (unsigned long) -1)
8789         return 0;
8790     }
8791
8792   hash_table = elf_hash_table (flinfo->info);
8793   strtabsize = hash_table->strtabsize;
8794   if (strtabsize <= hash_table->strtabcount)
8795     {
8796       strtabsize += strtabsize;
8797       hash_table->strtabsize = strtabsize;
8798       strtabsize *= sizeof (*hash_table->strtab);
8799       hash_table->strtab
8800         = (struct elf_sym_strtab *) bfd_realloc (hash_table->strtab,
8801                                                  strtabsize);
8802       if (hash_table->strtab == NULL)
8803         return 0;
8804     }
8805   hash_table->strtab[hash_table->strtabcount].sym = *elfsym;
8806   hash_table->strtab[hash_table->strtabcount].dest_index
8807     = hash_table->strtabcount;
8808   hash_table->strtab[hash_table->strtabcount].destshndx_index
8809     = flinfo->symshndxbuf ? bfd_get_symcount (flinfo->output_bfd) : 0;
8810
8811   bfd_get_symcount (flinfo->output_bfd) += 1;
8812   hash_table->strtabcount += 1;
8813
8814   return 1;
8815 }
8816
8817 /* Swap symbols out to the symbol table and flush the output symbols to
8818    the file.  */
8819
8820 static bfd_boolean
8821 elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
8822 {
8823   struct elf_link_hash_table *hash_table = elf_hash_table (flinfo->info);
8824   bfd_size_type amt, i;
8825   const struct elf_backend_data *bed;
8826   bfd_byte *symbuf;
8827   Elf_Internal_Shdr *hdr;
8828   file_ptr pos;
8829   bfd_boolean ret;
8830
8831   if (!hash_table->strtabcount)
8832     return TRUE;
8833
8834   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
8835
8836   bed = get_elf_backend_data (flinfo->output_bfd);
8837
8838   amt = bed->s->sizeof_sym * hash_table->strtabcount;
8839   symbuf = (bfd_byte *) bfd_malloc (amt);
8840   if (symbuf == NULL)
8841     return FALSE;
8842
8843   if (flinfo->symshndxbuf)
8844     {
8845       amt = (sizeof (Elf_External_Sym_Shndx)
8846              * (bfd_get_symcount (flinfo->output_bfd)));
8847       flinfo->symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
8848       if (flinfo->symshndxbuf == NULL)
8849         {
8850           free (symbuf);
8851           return FALSE;
8852         }
8853     }
8854
8855   for (i = 0; i < hash_table->strtabcount; i++)
8856     {
8857       struct elf_sym_strtab *elfsym = &hash_table->strtab[i];
8858       if (elfsym->sym.st_name == (unsigned long) -1)
8859         elfsym->sym.st_name = 0;
8860       else
8861         elfsym->sym.st_name
8862           = (unsigned long) _bfd_elf_strtab_offset (flinfo->symstrtab,
8863                                                     elfsym->sym.st_name);
8864       bed->s->swap_symbol_out (flinfo->output_bfd, &elfsym->sym,
8865                                ((bfd_byte *) symbuf
8866                                 + (elfsym->dest_index
8867                                    * bed->s->sizeof_sym)),
8868                                (flinfo->symshndxbuf
8869                                 + elfsym->destshndx_index));
8870     }
8871
8872   hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
8873   pos = hdr->sh_offset + hdr->sh_size;
8874   amt = hash_table->strtabcount * bed->s->sizeof_sym;
8875   if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) == 0
8876       && bfd_bwrite (symbuf, amt, flinfo->output_bfd) == amt)
8877     {
8878       hdr->sh_size += amt;
8879       ret = TRUE;
8880     }
8881   else
8882     ret = FALSE;
8883
8884   free (symbuf);
8885
8886   free (hash_table->strtab);
8887   hash_table->strtab = NULL;
8888
8889   return ret;
8890 }
8891
8892 /* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
8893
8894 static bfd_boolean
8895 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8896 {
8897   if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8898       && sym->st_shndx < SHN_LORESERVE)
8899     {
8900       /* The gABI doesn't support dynamic symbols in output sections
8901          beyond 64k.  */
8902       (*_bfd_error_handler)
8903         (_("%B: Too many sections: %d (>= %d)"),
8904          abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8905       bfd_set_error (bfd_error_nonrepresentable_section);
8906       return FALSE;
8907     }
8908   return TRUE;
8909 }
8910
8911 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8912    allowing an unsatisfied unversioned symbol in the DSO to match a
8913    versioned symbol that would normally require an explicit version.
8914    We also handle the case that a DSO references a hidden symbol
8915    which may be satisfied by a versioned symbol in another DSO.  */
8916
8917 static bfd_boolean
8918 elf_link_check_versioned_symbol (struct bfd_link_info *info,
8919                                  const struct elf_backend_data *bed,
8920                                  struct elf_link_hash_entry *h)
8921 {
8922   bfd *abfd;
8923   struct elf_link_loaded_list *loaded;
8924
8925   if (!is_elf_hash_table (info->hash))
8926     return FALSE;
8927
8928   /* Check indirect symbol.  */
8929   while (h->root.type == bfd_link_hash_indirect)
8930     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8931
8932   switch (h->root.type)
8933     {
8934     default:
8935       abfd = NULL;
8936       break;
8937
8938     case bfd_link_hash_undefined:
8939     case bfd_link_hash_undefweak:
8940       abfd = h->root.u.undef.abfd;
8941       if ((abfd->flags & DYNAMIC) == 0
8942           || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8943         return FALSE;
8944       break;
8945
8946     case bfd_link_hash_defined:
8947     case bfd_link_hash_defweak:
8948       abfd = h->root.u.def.section->owner;
8949       break;
8950
8951     case bfd_link_hash_common:
8952       abfd = h->root.u.c.p->section->owner;
8953       break;
8954     }
8955   BFD_ASSERT (abfd != NULL);
8956
8957   for (loaded = elf_hash_table (info)->loaded;
8958        loaded != NULL;
8959        loaded = loaded->next)
8960     {
8961       bfd *input;
8962       Elf_Internal_Shdr *hdr;
8963       bfd_size_type symcount;
8964       bfd_size_type extsymcount;
8965       bfd_size_type extsymoff;
8966       Elf_Internal_Shdr *versymhdr;
8967       Elf_Internal_Sym *isym;
8968       Elf_Internal_Sym *isymend;
8969       Elf_Internal_Sym *isymbuf;
8970       Elf_External_Versym *ever;
8971       Elf_External_Versym *extversym;
8972
8973       input = loaded->abfd;
8974
8975       /* We check each DSO for a possible hidden versioned definition.  */
8976       if (input == abfd
8977           || (input->flags & DYNAMIC) == 0
8978           || elf_dynversym (input) == 0)
8979         continue;
8980
8981       hdr = &elf_tdata (input)->dynsymtab_hdr;
8982
8983       symcount = hdr->sh_size / bed->s->sizeof_sym;
8984       if (elf_bad_symtab (input))
8985         {
8986           extsymcount = symcount;
8987           extsymoff = 0;
8988         }
8989       else
8990         {
8991           extsymcount = symcount - hdr->sh_info;
8992           extsymoff = hdr->sh_info;
8993         }
8994
8995       if (extsymcount == 0)
8996         continue;
8997
8998       isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8999                                       NULL, NULL, NULL);
9000       if (isymbuf == NULL)
9001         return FALSE;
9002
9003       /* Read in any version definitions.  */
9004       versymhdr = &elf_tdata (input)->dynversym_hdr;
9005       extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
9006       if (extversym == NULL)
9007         goto error_ret;
9008
9009       if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
9010           || (bfd_bread (extversym, versymhdr->sh_size, input)
9011               != versymhdr->sh_size))
9012         {
9013           free (extversym);
9014         error_ret:
9015           free (isymbuf);
9016           return FALSE;
9017         }
9018
9019       ever = extversym + extsymoff;
9020       isymend = isymbuf + extsymcount;
9021       for (isym = isymbuf; isym < isymend; isym++, ever++)
9022         {
9023           const char *name;
9024           Elf_Internal_Versym iver;
9025           unsigned short version_index;
9026
9027           if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
9028               || isym->st_shndx == SHN_UNDEF)
9029             continue;
9030
9031           name = bfd_elf_string_from_elf_section (input,
9032                                                   hdr->sh_link,
9033                                                   isym->st_name);
9034           if (strcmp (name, h->root.root.string) != 0)
9035             continue;
9036
9037           _bfd_elf_swap_versym_in (input, ever, &iver);
9038
9039           if ((iver.vs_vers & VERSYM_HIDDEN) == 0
9040               && !(h->def_regular
9041                    && h->forced_local))
9042             {
9043               /* If we have a non-hidden versioned sym, then it should
9044                  have provided a definition for the undefined sym unless
9045                  it is defined in a non-shared object and forced local.
9046                */
9047               abort ();
9048             }
9049
9050           version_index = iver.vs_vers & VERSYM_VERSION;
9051           if (version_index == 1 || version_index == 2)
9052             {
9053               /* This is the base or first version.  We can use it.  */
9054               free (extversym);
9055               free (isymbuf);
9056               return TRUE;
9057             }
9058         }
9059
9060       free (extversym);
9061       free (isymbuf);
9062     }
9063
9064   return FALSE;
9065 }
9066
9067 /* Convert ELF common symbol TYPE.  */
9068
9069 static int
9070 elf_link_convert_common_type (struct bfd_link_info *info, int type)
9071 {
9072   /* Commom symbol can only appear in relocatable link.  */
9073   if (!bfd_link_relocatable (info))
9074     abort ();
9075   switch (info->elf_stt_common)
9076     {
9077     case unchanged:
9078       break;
9079     case elf_stt_common:
9080       type = STT_COMMON;
9081       break;
9082     case no_elf_stt_common:
9083       type = STT_OBJECT;
9084       break;
9085     }
9086   return type;
9087 }
9088
9089 /* Add an external symbol to the symbol table.  This is called from
9090    the hash table traversal routine.  When generating a shared object,
9091    we go through the symbol table twice.  The first time we output
9092    anything that might have been forced to local scope in a version
9093    script.  The second time we output the symbols that are still
9094    global symbols.  */
9095
9096 static bfd_boolean
9097 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
9098 {
9099   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
9100   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
9101   struct elf_final_link_info *flinfo = eoinfo->flinfo;
9102   bfd_boolean strip;
9103   Elf_Internal_Sym sym;
9104   asection *input_sec;
9105   const struct elf_backend_data *bed;
9106   long indx;
9107   int ret;
9108   unsigned int type;
9109   /* A symbol is bound locally if it is forced local or it is locally
9110      defined, hidden versioned, not referenced by shared library and
9111      not exported when linking executable.  */
9112   bfd_boolean local_bind = (h->forced_local
9113                             || (bfd_link_executable (flinfo->info)
9114                                 && !flinfo->info->export_dynamic
9115                                 && !h->dynamic
9116                                 && !h->ref_dynamic
9117                                 && h->def_regular
9118                                 && h->versioned == versioned_hidden));
9119
9120   if (h->root.type == bfd_link_hash_warning)
9121     {
9122       h = (struct elf_link_hash_entry *) h->root.u.i.link;
9123       if (h->root.type == bfd_link_hash_new)
9124         return TRUE;
9125     }
9126
9127   /* Decide whether to output this symbol in this pass.  */
9128   if (eoinfo->localsyms)
9129     {
9130       if (!local_bind)
9131         return TRUE;
9132     }
9133   else
9134     {
9135       if (local_bind)
9136         return TRUE;
9137     }
9138
9139   bed = get_elf_backend_data (flinfo->output_bfd);
9140
9141   if (h->root.type == bfd_link_hash_undefined)
9142     {
9143       /* If we have an undefined symbol reference here then it must have
9144          come from a shared library that is being linked in.  (Undefined
9145          references in regular files have already been handled unless
9146          they are in unreferenced sections which are removed by garbage
9147          collection).  */
9148       bfd_boolean ignore_undef = FALSE;
9149
9150       /* Some symbols may be special in that the fact that they're
9151          undefined can be safely ignored - let backend determine that.  */
9152       if (bed->elf_backend_ignore_undef_symbol)
9153         ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
9154
9155       /* If we are reporting errors for this situation then do so now.  */
9156       if (!ignore_undef
9157           && h->ref_dynamic
9158           && (!h->ref_regular || flinfo->info->gc_sections)
9159           && !elf_link_check_versioned_symbol (flinfo->info, bed, h)
9160           && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
9161         {
9162           if (!(flinfo->info->callbacks->undefined_symbol
9163                 (flinfo->info, h->root.root.string,
9164                  h->ref_regular ? NULL : h->root.u.undef.abfd,
9165                  NULL, 0,
9166                  (flinfo->info->unresolved_syms_in_shared_libs
9167                   == RM_GENERATE_ERROR))))
9168             {
9169               bfd_set_error (bfd_error_bad_value);
9170               eoinfo->failed = TRUE;
9171               return FALSE;
9172             }
9173         }
9174     }
9175
9176   /* We should also warn if a forced local symbol is referenced from
9177      shared libraries.  */
9178   if (bfd_link_executable (flinfo->info)
9179       && h->forced_local
9180       && h->ref_dynamic
9181       && h->def_regular
9182       && !h->dynamic_def
9183       && h->ref_dynamic_nonweak
9184       && !elf_link_check_versioned_symbol (flinfo->info, bed, h))
9185     {
9186       bfd *def_bfd;
9187       const char *msg;
9188       struct elf_link_hash_entry *hi = h;
9189
9190       /* Check indirect symbol.  */
9191       while (hi->root.type == bfd_link_hash_indirect)
9192         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
9193
9194       if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
9195         msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
9196       else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
9197         msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
9198       else
9199         msg = _("%B: local symbol `%s' in %B is referenced by DSO");
9200       def_bfd = flinfo->output_bfd;
9201       if (hi->root.u.def.section != bfd_abs_section_ptr)
9202         def_bfd = hi->root.u.def.section->owner;
9203       (*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
9204                              h->root.root.string);
9205       bfd_set_error (bfd_error_bad_value);
9206       eoinfo->failed = TRUE;
9207       return FALSE;
9208     }
9209
9210   /* We don't want to output symbols that have never been mentioned by
9211      a regular file, or that we have been told to strip.  However, if
9212      h->indx is set to -2, the symbol is used by a reloc and we must
9213      output it.  */
9214   strip = FALSE;
9215   if (h->indx == -2)
9216     ;
9217   else if ((h->def_dynamic
9218             || h->ref_dynamic
9219             || h->root.type == bfd_link_hash_new)
9220            && !h->def_regular
9221            && !h->ref_regular)
9222     strip = TRUE;
9223   else if (flinfo->info->strip == strip_all)
9224     strip = TRUE;
9225   else if (flinfo->info->strip == strip_some
9226            && bfd_hash_lookup (flinfo->info->keep_hash,
9227                                h->root.root.string, FALSE, FALSE) == NULL)
9228     strip = TRUE;
9229   else if ((h->root.type == bfd_link_hash_defined
9230             || h->root.type == bfd_link_hash_defweak)
9231            && ((flinfo->info->strip_discarded
9232                 && discarded_section (h->root.u.def.section))
9233                || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0
9234                    && h->root.u.def.section->owner != NULL
9235                    && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
9236     strip = TRUE;
9237   else if ((h->root.type == bfd_link_hash_undefined
9238             || h->root.type == bfd_link_hash_undefweak)
9239            && h->root.u.undef.abfd != NULL
9240            && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
9241     strip = TRUE;
9242
9243   type = h->type;
9244
9245   /* If we're stripping it, and it's not a dynamic symbol, there's
9246      nothing else to do.   However, if it is a forced local symbol or
9247      an ifunc symbol we need to give the backend finish_dynamic_symbol
9248      function a chance to make it dynamic.  */
9249   if (strip
9250       && h->dynindx == -1
9251       && type != STT_GNU_IFUNC
9252       && !h->forced_local)
9253     return TRUE;
9254
9255   sym.st_value = 0;
9256   sym.st_size = h->size;
9257   sym.st_other = h->other;
9258   switch (h->root.type)
9259     {
9260     default:
9261     case bfd_link_hash_new:
9262     case bfd_link_hash_warning:
9263       abort ();
9264       return FALSE;
9265
9266     case bfd_link_hash_undefined:
9267     case bfd_link_hash_undefweak:
9268       input_sec = bfd_und_section_ptr;
9269       sym.st_shndx = SHN_UNDEF;
9270       break;
9271
9272     case bfd_link_hash_defined:
9273     case bfd_link_hash_defweak:
9274       {
9275         input_sec = h->root.u.def.section;
9276         if (input_sec->output_section != NULL)
9277           {
9278             sym.st_shndx =
9279               _bfd_elf_section_from_bfd_section (flinfo->output_bfd,
9280                                                  input_sec->output_section);
9281             if (sym.st_shndx == SHN_BAD)
9282               {
9283                 (*_bfd_error_handler)
9284                   (_("%B: could not find output section %A for input section %A"),
9285                    flinfo->output_bfd, input_sec->output_section, input_sec);
9286                 bfd_set_error (bfd_error_nonrepresentable_section);
9287                 eoinfo->failed = TRUE;
9288                 return FALSE;
9289               }
9290
9291             /* ELF symbols in relocatable files are section relative,
9292                but in nonrelocatable files they are virtual
9293                addresses.  */
9294             sym.st_value = h->root.u.def.value + input_sec->output_offset;
9295             if (!bfd_link_relocatable (flinfo->info))
9296               {
9297                 sym.st_value += input_sec->output_section->vma;
9298                 if (h->type == STT_TLS)
9299                   {
9300                     asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
9301                     if (tls_sec != NULL)
9302                       sym.st_value -= tls_sec->vma;
9303                   }
9304               }
9305           }
9306         else
9307           {
9308             BFD_ASSERT (input_sec->owner == NULL
9309                         || (input_sec->owner->flags & DYNAMIC) != 0);
9310             sym.st_shndx = SHN_UNDEF;
9311             input_sec = bfd_und_section_ptr;
9312           }
9313       }
9314       break;
9315
9316     case bfd_link_hash_common:
9317       input_sec = h->root.u.c.p->section;
9318       sym.st_shndx = bed->common_section_index (input_sec);
9319       sym.st_value = 1 << h->root.u.c.p->alignment_power;
9320       break;
9321
9322     case bfd_link_hash_indirect:
9323       /* These symbols are created by symbol versioning.  They point
9324          to the decorated version of the name.  For example, if the
9325          symbol foo@@GNU_1.2 is the default, which should be used when
9326          foo is used with no version, then we add an indirect symbol
9327          foo which points to foo@@GNU_1.2.  We ignore these symbols,
9328          since the indirected symbol is already in the hash table.  */
9329       return TRUE;
9330     }
9331
9332   if (type == STT_COMMON || type == STT_OBJECT)
9333     switch (h->root.type)
9334       {
9335       case bfd_link_hash_common:
9336         type = elf_link_convert_common_type (flinfo->info, type);
9337         break;
9338       case bfd_link_hash_defined:
9339       case bfd_link_hash_defweak:
9340         if (bed->common_definition (&sym))
9341           type = elf_link_convert_common_type (flinfo->info, type);
9342         else
9343           type = STT_OBJECT;
9344         break;
9345       case bfd_link_hash_undefined:
9346       case bfd_link_hash_undefweak:
9347         break;
9348       default:
9349         abort ();
9350       }
9351
9352   if (local_bind)
9353     {
9354       sym.st_info = ELF_ST_INFO (STB_LOCAL, type);
9355       /* Turn off visibility on local symbol.  */
9356       sym.st_other &= ~ELF_ST_VISIBILITY (-1);
9357     }
9358   /* Set STB_GNU_UNIQUE only if symbol is defined in regular object.  */
9359   else if (h->unique_global && h->def_regular)
9360     sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, type);
9361   else if (h->root.type == bfd_link_hash_undefweak
9362            || h->root.type == bfd_link_hash_defweak)
9363     sym.st_info = ELF_ST_INFO (STB_WEAK, type);
9364   else
9365     sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
9366   sym.st_target_internal = h->target_internal;
9367
9368   /* Give the processor backend a chance to tweak the symbol value,
9369      and also to finish up anything that needs to be done for this
9370      symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
9371      forced local syms when non-shared is due to a historical quirk.
9372      STT_GNU_IFUNC symbol must go through PLT.  */
9373   if ((h->type == STT_GNU_IFUNC
9374        && h->def_regular
9375        && !bfd_link_relocatable (flinfo->info))
9376       || ((h->dynindx != -1
9377            || h->forced_local)
9378           && ((bfd_link_pic (flinfo->info)
9379                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9380                    || h->root.type != bfd_link_hash_undefweak))
9381               || !h->forced_local)
9382           && elf_hash_table (flinfo->info)->dynamic_sections_created))
9383     {
9384       if (! ((*bed->elf_backend_finish_dynamic_symbol)
9385              (flinfo->output_bfd, flinfo->info, h, &sym)))
9386         {
9387           eoinfo->failed = TRUE;
9388           return FALSE;
9389         }
9390     }
9391
9392   /* If we are marking the symbol as undefined, and there are no
9393      non-weak references to this symbol from a regular object, then
9394      mark the symbol as weak undefined; if there are non-weak
9395      references, mark the symbol as strong.  We can't do this earlier,
9396      because it might not be marked as undefined until the
9397      finish_dynamic_symbol routine gets through with it.  */
9398   if (sym.st_shndx == SHN_UNDEF
9399       && h->ref_regular
9400       && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
9401           || ELF_ST_BIND (sym.st_info) == STB_WEAK))
9402     {
9403       int bindtype;
9404       type = ELF_ST_TYPE (sym.st_info);
9405
9406       /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
9407       if (type == STT_GNU_IFUNC)
9408         type = STT_FUNC;
9409
9410       if (h->ref_regular_nonweak)
9411         bindtype = STB_GLOBAL;
9412       else
9413         bindtype = STB_WEAK;
9414       sym.st_info = ELF_ST_INFO (bindtype, type);
9415     }
9416
9417   /* If this is a symbol defined in a dynamic library, don't use the
9418      symbol size from the dynamic library.  Relinking an executable
9419      against a new library may introduce gratuitous changes in the
9420      executable's symbols if we keep the size.  */
9421   if (sym.st_shndx == SHN_UNDEF
9422       && !h->def_regular
9423       && h->def_dynamic)
9424     sym.st_size = 0;
9425
9426   /* If a non-weak symbol with non-default visibility is not defined
9427      locally, it is a fatal error.  */
9428   if (!bfd_link_relocatable (flinfo->info)
9429       && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
9430       && ELF_ST_BIND (sym.st_info) != STB_WEAK
9431       && h->root.type == bfd_link_hash_undefined
9432       && !h->def_regular)
9433     {
9434       const char *msg;
9435
9436       if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
9437         msg = _("%B: protected symbol `%s' isn't defined");
9438       else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
9439         msg = _("%B: internal symbol `%s' isn't defined");
9440       else
9441         msg = _("%B: hidden symbol `%s' isn't defined");
9442       (*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
9443       bfd_set_error (bfd_error_bad_value);
9444       eoinfo->failed = TRUE;
9445       return FALSE;
9446     }
9447
9448   /* If this symbol should be put in the .dynsym section, then put it
9449      there now.  We already know the symbol index.  We also fill in
9450      the entry in the .hash section.  */
9451   if (elf_hash_table (flinfo->info)->dynsym != NULL
9452       && h->dynindx != -1
9453       && elf_hash_table (flinfo->info)->dynamic_sections_created)
9454     {
9455       bfd_byte *esym;
9456
9457       /* Since there is no version information in the dynamic string,
9458          if there is no version info in symbol version section, we will
9459          have a run-time problem if not linking executable, referenced
9460          by shared library, not locally defined, or not bound locally.
9461       */
9462       if (h->verinfo.verdef == NULL
9463           && !local_bind
9464           && (!bfd_link_executable (flinfo->info)
9465               || h->ref_dynamic
9466               || !h->def_regular))
9467         {
9468           char *p = strrchr (h->root.root.string, ELF_VER_CHR);
9469
9470           if (p && p [1] != '\0')
9471             {
9472               (*_bfd_error_handler)
9473                 (_("%B: No symbol version section for versioned symbol `%s'"),
9474                  flinfo->output_bfd, h->root.root.string);
9475               eoinfo->failed = TRUE;
9476               return FALSE;
9477             }
9478         }
9479
9480       sym.st_name = h->dynstr_index;
9481       esym = (elf_hash_table (flinfo->info)->dynsym->contents
9482               + h->dynindx * bed->s->sizeof_sym);
9483       if (!check_dynsym (flinfo->output_bfd, &sym))
9484         {
9485           eoinfo->failed = TRUE;
9486           return FALSE;
9487         }
9488       bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
9489
9490       if (flinfo->hash_sec != NULL)
9491         {
9492           size_t hash_entry_size;
9493           bfd_byte *bucketpos;
9494           bfd_vma chain;
9495           size_t bucketcount;
9496           size_t bucket;
9497
9498           bucketcount = elf_hash_table (flinfo->info)->bucketcount;
9499           bucket = h->u.elf_hash_value % bucketcount;
9500
9501           hash_entry_size
9502             = elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
9503           bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
9504                        + (bucket + 2) * hash_entry_size);
9505           chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
9506           bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
9507                    bucketpos);
9508           bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
9509                    ((bfd_byte *) flinfo->hash_sec->contents
9510                     + (bucketcount + 2 + h->dynindx) * hash_entry_size));
9511         }
9512
9513       if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
9514         {
9515           Elf_Internal_Versym iversym;
9516           Elf_External_Versym *eversym;
9517
9518           if (!h->def_regular)
9519             {
9520               if (h->verinfo.verdef == NULL
9521                   || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
9522                       & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
9523                 iversym.vs_vers = 0;
9524               else
9525                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
9526             }
9527           else
9528             {
9529               if (h->verinfo.vertree == NULL)
9530                 iversym.vs_vers = 1;
9531               else
9532                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
9533               if (flinfo->info->create_default_symver)
9534                 iversym.vs_vers++;
9535             }
9536
9537           /* Turn on VERSYM_HIDDEN only if the hidden versioned symbol is
9538              defined locally.  */
9539           if (h->versioned == versioned_hidden && h->def_regular)
9540             iversym.vs_vers |= VERSYM_HIDDEN;
9541
9542           eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
9543           eversym += h->dynindx;
9544           _bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
9545         }
9546     }
9547
9548   /* If the symbol is undefined, and we didn't output it to .dynsym,
9549      strip it from .symtab too.  Obviously we can't do this for
9550      relocatable output or when needed for --emit-relocs.  */
9551   else if (input_sec == bfd_und_section_ptr
9552            && h->indx != -2
9553            && !bfd_link_relocatable (flinfo->info))
9554     return TRUE;
9555   /* Also strip others that we couldn't earlier due to dynamic symbol
9556      processing.  */
9557   if (strip)
9558     return TRUE;
9559   if ((input_sec->flags & SEC_EXCLUDE) != 0)
9560     return TRUE;
9561
9562   /* Output a FILE symbol so that following locals are not associated
9563      with the wrong input file.  We need one for forced local symbols
9564      if we've seen more than one FILE symbol or when we have exactly
9565      one FILE symbol but global symbols are present in a file other
9566      than the one with the FILE symbol.  We also need one if linker
9567      defined symbols are present.  In practice these conditions are
9568      always met, so just emit the FILE symbol unconditionally.  */
9569   if (eoinfo->localsyms
9570       && !eoinfo->file_sym_done
9571       && eoinfo->flinfo->filesym_count != 0)
9572     {
9573       Elf_Internal_Sym fsym;
9574
9575       memset (&fsym, 0, sizeof (fsym));
9576       fsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9577       fsym.st_shndx = SHN_ABS;
9578       if (!elf_link_output_symstrtab (eoinfo->flinfo, NULL, &fsym,
9579                                       bfd_und_section_ptr, NULL))
9580         return FALSE;
9581
9582       eoinfo->file_sym_done = TRUE;
9583     }
9584
9585   indx = bfd_get_symcount (flinfo->output_bfd);
9586   ret = elf_link_output_symstrtab (flinfo, h->root.root.string, &sym,
9587                                    input_sec, h);
9588   if (ret == 0)
9589     {
9590       eoinfo->failed = TRUE;
9591       return FALSE;
9592     }
9593   else if (ret == 1)
9594     h->indx = indx;
9595   else if (h->indx == -2)
9596     abort();
9597
9598   return TRUE;
9599 }
9600
9601 /* Return TRUE if special handling is done for relocs in SEC against
9602    symbols defined in discarded sections.  */
9603
9604 static bfd_boolean
9605 elf_section_ignore_discarded_relocs (asection *sec)
9606 {
9607   const struct elf_backend_data *bed;
9608
9609   switch (sec->sec_info_type)
9610     {
9611     case SEC_INFO_TYPE_STABS:
9612     case SEC_INFO_TYPE_EH_FRAME:
9613     case SEC_INFO_TYPE_EH_FRAME_ENTRY:
9614       return TRUE;
9615     default:
9616       break;
9617     }
9618
9619   bed = get_elf_backend_data (sec->owner);
9620   if (bed->elf_backend_ignore_discarded_relocs != NULL
9621       && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9622     return TRUE;
9623
9624   return FALSE;
9625 }
9626
9627 /* Return a mask saying how ld should treat relocations in SEC against
9628    symbols defined in discarded sections.  If this function returns
9629    COMPLAIN set, ld will issue a warning message.  If this function
9630    returns PRETEND set, and the discarded section was link-once and the
9631    same size as the kept link-once section, ld will pretend that the
9632    symbol was actually defined in the kept section.  Otherwise ld will
9633    zero the reloc (at least that is the intent, but some cooperation by
9634    the target dependent code is needed, particularly for REL targets).  */
9635
9636 unsigned int
9637 _bfd_elf_default_action_discarded (asection *sec)
9638 {
9639   if (sec->flags & SEC_DEBUGGING)
9640     return PRETEND;
9641
9642   if (strcmp (".eh_frame", sec->name) == 0)
9643     return 0;
9644
9645   if (strcmp (".gcc_except_table", sec->name) == 0)
9646     return 0;
9647
9648   return COMPLAIN | PRETEND;
9649 }
9650
9651 /* Find a match between a section and a member of a section group.  */
9652
9653 static asection *
9654 match_group_member (asection *sec, asection *group,
9655                     struct bfd_link_info *info)
9656 {
9657   asection *first = elf_next_in_group (group);
9658   asection *s = first;
9659
9660   while (s != NULL)
9661     {
9662       if (bfd_elf_match_symbols_in_sections (s, sec, info))
9663         return s;
9664
9665       s = elf_next_in_group (s);
9666       if (s == first)
9667         break;
9668     }
9669
9670   return NULL;
9671 }
9672
9673 /* Check if the kept section of a discarded section SEC can be used
9674    to replace it.  Return the replacement if it is OK.  Otherwise return
9675    NULL.  */
9676
9677 asection *
9678 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9679 {
9680   asection *kept;
9681
9682   kept = sec->kept_section;
9683   if (kept != NULL)
9684     {
9685       if ((kept->flags & SEC_GROUP) != 0)
9686         kept = match_group_member (sec, kept, info);
9687       if (kept != NULL
9688           && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9689               != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9690         kept = NULL;
9691       sec->kept_section = kept;
9692     }
9693   return kept;
9694 }
9695
9696 /* Link an input file into the linker output file.  This function
9697    handles all the sections and relocations of the input file at once.
9698    This is so that we only have to read the local symbols once, and
9699    don't have to keep them in memory.  */
9700
9701 static bfd_boolean
9702 elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
9703 {
9704   int (*relocate_section)
9705     (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9706      Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9707   bfd *output_bfd;
9708   Elf_Internal_Shdr *symtab_hdr;
9709   size_t locsymcount;
9710   size_t extsymoff;
9711   Elf_Internal_Sym *isymbuf;
9712   Elf_Internal_Sym *isym;
9713   Elf_Internal_Sym *isymend;
9714   long *pindex;
9715   asection **ppsection;
9716   asection *o;
9717   const struct elf_backend_data *bed;
9718   struct elf_link_hash_entry **sym_hashes;
9719   bfd_size_type address_size;
9720   bfd_vma r_type_mask;
9721   int r_sym_shift;
9722   bfd_boolean have_file_sym = FALSE;
9723
9724   output_bfd = flinfo->output_bfd;
9725   bed = get_elf_backend_data (output_bfd);
9726   relocate_section = bed->elf_backend_relocate_section;
9727
9728   /* If this is a dynamic object, we don't want to do anything here:
9729      we don't want the local symbols, and we don't want the section
9730      contents.  */
9731   if ((input_bfd->flags & DYNAMIC) != 0)
9732     return TRUE;
9733
9734   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9735   if (elf_bad_symtab (input_bfd))
9736     {
9737       locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9738       extsymoff = 0;
9739     }
9740   else
9741     {
9742       locsymcount = symtab_hdr->sh_info;
9743       extsymoff = symtab_hdr->sh_info;
9744     }
9745
9746   /* Read the local symbols.  */
9747   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9748   if (isymbuf == NULL && locsymcount != 0)
9749     {
9750       isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9751                                       flinfo->internal_syms,
9752                                       flinfo->external_syms,
9753                                       flinfo->locsym_shndx);
9754       if (isymbuf == NULL)
9755         return FALSE;
9756     }
9757
9758   /* Find local symbol sections and adjust values of symbols in
9759      SEC_MERGE sections.  Write out those local symbols we know are
9760      going into the output file.  */
9761   isymend = isymbuf + locsymcount;
9762   for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
9763        isym < isymend;
9764        isym++, pindex++, ppsection++)
9765     {
9766       asection *isec;
9767       const char *name;
9768       Elf_Internal_Sym osym;
9769       long indx;
9770       int ret;
9771
9772       *pindex = -1;
9773
9774       if (elf_bad_symtab (input_bfd))
9775         {
9776           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9777             {
9778               *ppsection = NULL;
9779               continue;
9780             }
9781         }
9782
9783       if (isym->st_shndx == SHN_UNDEF)
9784         isec = bfd_und_section_ptr;
9785       else if (isym->st_shndx == SHN_ABS)
9786         isec = bfd_abs_section_ptr;
9787       else if (isym->st_shndx == SHN_COMMON)
9788         isec = bfd_com_section_ptr;
9789       else
9790         {
9791           isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9792           if (isec == NULL)
9793             {
9794               /* Don't attempt to output symbols with st_shnx in the
9795                  reserved range other than SHN_ABS and SHN_COMMON.  */
9796               *ppsection = NULL;
9797               continue;
9798             }
9799           else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
9800                    && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9801             isym->st_value =
9802               _bfd_merged_section_offset (output_bfd, &isec,
9803                                           elf_section_data (isec)->sec_info,
9804                                           isym->st_value);
9805         }
9806
9807       *ppsection = isec;
9808
9809       /* Don't output the first, undefined, symbol.  In fact, don't
9810          output any undefined local symbol.  */
9811       if (isec == bfd_und_section_ptr)
9812         continue;
9813
9814       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9815         {
9816           /* We never output section symbols.  Instead, we use the
9817              section symbol of the corresponding section in the output
9818              file.  */
9819           continue;
9820         }
9821
9822       /* If we are stripping all symbols, we don't want to output this
9823          one.  */
9824       if (flinfo->info->strip == strip_all)
9825         continue;
9826
9827       /* If we are discarding all local symbols, we don't want to
9828          output this one.  If we are generating a relocatable output
9829          file, then some of the local symbols may be required by
9830          relocs; we output them below as we discover that they are
9831          needed.  */
9832       if (flinfo->info->discard == discard_all)
9833         continue;
9834
9835       /* If this symbol is defined in a section which we are
9836          discarding, we don't need to keep it.  */
9837       if (isym->st_shndx != SHN_UNDEF
9838           && isym->st_shndx < SHN_LORESERVE
9839           && bfd_section_removed_from_list (output_bfd,
9840                                             isec->output_section))
9841         continue;
9842
9843       /* Get the name of the symbol.  */
9844       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9845                                               isym->st_name);
9846       if (name == NULL)
9847         return FALSE;
9848
9849       /* See if we are discarding symbols with this name.  */
9850       if ((flinfo->info->strip == strip_some
9851            && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
9852                == NULL))
9853           || (((flinfo->info->discard == discard_sec_merge
9854                 && (isec->flags & SEC_MERGE)
9855                 && !bfd_link_relocatable (flinfo->info))
9856                || flinfo->info->discard == discard_l)
9857               && bfd_is_local_label_name (input_bfd, name)))
9858         continue;
9859
9860       if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
9861         {
9862           if (input_bfd->lto_output)
9863             /* -flto puts a temp file name here.  This means builds
9864                are not reproducible.  Discard the symbol.  */
9865             continue;
9866           have_file_sym = TRUE;
9867           flinfo->filesym_count += 1;
9868         }
9869       if (!have_file_sym)
9870         {
9871           /* In the absence of debug info, bfd_find_nearest_line uses
9872              FILE symbols to determine the source file for local
9873              function symbols.  Provide a FILE symbol here if input
9874              files lack such, so that their symbols won't be
9875              associated with a previous input file.  It's not the
9876              source file, but the best we can do.  */
9877           have_file_sym = TRUE;
9878           flinfo->filesym_count += 1;
9879           memset (&osym, 0, sizeof (osym));
9880           osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
9881           osym.st_shndx = SHN_ABS;
9882           if (!elf_link_output_symstrtab (flinfo,
9883                                           (input_bfd->lto_output ? NULL
9884                                            : input_bfd->filename),
9885                                           &osym, bfd_abs_section_ptr,
9886                                           NULL))
9887             return FALSE;
9888         }
9889
9890       osym = *isym;
9891
9892       /* Adjust the section index for the output file.  */
9893       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9894                                                          isec->output_section);
9895       if (osym.st_shndx == SHN_BAD)
9896         return FALSE;
9897
9898       /* ELF symbols in relocatable files are section relative, but
9899          in executable files they are virtual addresses.  Note that
9900          this code assumes that all ELF sections have an associated
9901          BFD section with a reasonable value for output_offset; below
9902          we assume that they also have a reasonable value for
9903          output_section.  Any special sections must be set up to meet
9904          these requirements.  */
9905       osym.st_value += isec->output_offset;
9906       if (!bfd_link_relocatable (flinfo->info))
9907         {
9908           osym.st_value += isec->output_section->vma;
9909           if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9910             {
9911               /* STT_TLS symbols are relative to PT_TLS segment base.  */
9912               BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
9913               osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
9914             }
9915         }
9916
9917       indx = bfd_get_symcount (output_bfd);
9918       ret = elf_link_output_symstrtab (flinfo, name, &osym, isec, NULL);
9919       if (ret == 0)
9920         return FALSE;
9921       else if (ret == 1)
9922         *pindex = indx;
9923     }
9924
9925   if (bed->s->arch_size == 32)
9926     {
9927       r_type_mask = 0xff;
9928       r_sym_shift = 8;
9929       address_size = 4;
9930     }
9931   else
9932     {
9933       r_type_mask = 0xffffffff;
9934       r_sym_shift = 32;
9935       address_size = 8;
9936     }
9937
9938   /* Relocate the contents of each section.  */
9939   sym_hashes = elf_sym_hashes (input_bfd);
9940   for (o = input_bfd->sections; o != NULL; o = o->next)
9941     {
9942       bfd_byte *contents;
9943
9944       if (! o->linker_mark)
9945         {
9946           /* This section was omitted from the link.  */
9947           continue;
9948         }
9949
9950       if (bfd_link_relocatable (flinfo->info)
9951           && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9952         {
9953           /* Deal with the group signature symbol.  */
9954           struct bfd_elf_section_data *sec_data = elf_section_data (o);
9955           unsigned long symndx = sec_data->this_hdr.sh_info;
9956           asection *osec = o->output_section;
9957
9958           if (symndx >= locsymcount
9959               || (elf_bad_symtab (input_bfd)
9960                   && flinfo->sections[symndx] == NULL))
9961             {
9962               struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9963               while (h->root.type == bfd_link_hash_indirect
9964                      || h->root.type == bfd_link_hash_warning)
9965                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9966               /* Arrange for symbol to be output.  */
9967               h->indx = -2;
9968               elf_section_data (osec)->this_hdr.sh_info = -2;
9969             }
9970           else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9971             {
9972               /* We'll use the output section target_index.  */
9973               asection *sec = flinfo->sections[symndx]->output_section;
9974               elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9975             }
9976           else
9977             {
9978               if (flinfo->indices[symndx] == -1)
9979                 {
9980                   /* Otherwise output the local symbol now.  */
9981                   Elf_Internal_Sym sym = isymbuf[symndx];
9982                   asection *sec = flinfo->sections[symndx]->output_section;
9983                   const char *name;
9984                   long indx;
9985                   int ret;
9986
9987                   name = bfd_elf_string_from_elf_section (input_bfd,
9988                                                           symtab_hdr->sh_link,
9989                                                           sym.st_name);
9990                   if (name == NULL)
9991                     return FALSE;
9992
9993                   sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9994                                                                     sec);
9995                   if (sym.st_shndx == SHN_BAD)
9996                     return FALSE;
9997
9998                   sym.st_value += o->output_offset;
9999
10000                   indx = bfd_get_symcount (output_bfd);
10001                   ret = elf_link_output_symstrtab (flinfo, name, &sym, o,
10002                                                    NULL);
10003                   if (ret == 0)
10004                     return FALSE;
10005                   else if (ret == 1)
10006                     flinfo->indices[symndx] = indx;
10007                   else
10008                     abort ();
10009                 }
10010               elf_section_data (osec)->this_hdr.sh_info
10011                 = flinfo->indices[symndx];
10012             }
10013         }
10014
10015       if ((o->flags & SEC_HAS_CONTENTS) == 0
10016           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
10017         continue;
10018
10019       if ((o->flags & SEC_LINKER_CREATED) != 0)
10020         {
10021           /* Section was created by _bfd_elf_link_create_dynamic_sections
10022              or somesuch.  */
10023           continue;
10024         }
10025
10026       /* Get the contents of the section.  They have been cached by a
10027          relaxation routine.  Note that o is a section in an input
10028          file, so the contents field will not have been set by any of
10029          the routines which work on output files.  */
10030       if (elf_section_data (o)->this_hdr.contents != NULL)
10031         {
10032           contents = elf_section_data (o)->this_hdr.contents;
10033           if (bed->caches_rawsize
10034               && o->rawsize != 0
10035               && o->rawsize < o->size)
10036             {
10037               memcpy (flinfo->contents, contents, o->rawsize);
10038               contents = flinfo->contents;
10039             }
10040         }
10041       else
10042         {
10043           contents = flinfo->contents;
10044           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
10045             return FALSE;
10046         }
10047
10048       if ((o->flags & SEC_RELOC) != 0)
10049         {
10050           Elf_Internal_Rela *internal_relocs;
10051           Elf_Internal_Rela *rel, *relend;
10052           int action_discarded;
10053           int ret;
10054
10055           /* Get the swapped relocs.  */
10056           internal_relocs
10057             = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
10058                                          flinfo->internal_relocs, FALSE);
10059           if (internal_relocs == NULL
10060               && o->reloc_count > 0)
10061             return FALSE;
10062
10063           /* We need to reverse-copy input .ctors/.dtors sections if
10064              they are placed in .init_array/.finit_array for output.  */
10065           if (o->size > address_size
10066               && ((strncmp (o->name, ".ctors", 6) == 0
10067                    && strcmp (o->output_section->name,
10068                               ".init_array") == 0)
10069                   || (strncmp (o->name, ".dtors", 6) == 0
10070                       && strcmp (o->output_section->name,
10071                                  ".fini_array") == 0))
10072               && (o->name[6] == 0 || o->name[6] == '.'))
10073             {
10074               if (o->size != o->reloc_count * address_size)
10075                 {
10076                   (*_bfd_error_handler)
10077                     (_("error: %B: size of section %A is not "
10078                        "multiple of address size"),
10079                      input_bfd, o);
10080                   bfd_set_error (bfd_error_on_input);
10081                   return FALSE;
10082                 }
10083               o->flags |= SEC_ELF_REVERSE_COPY;
10084             }
10085
10086           action_discarded = -1;
10087           if (!elf_section_ignore_discarded_relocs (o))
10088             action_discarded = (*bed->action_discarded) (o);
10089
10090           /* Run through the relocs evaluating complex reloc symbols and
10091              looking for relocs against symbols from discarded sections
10092              or section symbols from removed link-once sections.
10093              Complain about relocs against discarded sections.  Zero
10094              relocs against removed link-once sections.  */
10095
10096           rel = internal_relocs;
10097           relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
10098           for ( ; rel < relend; rel++)
10099             {
10100               unsigned long r_symndx = rel->r_info >> r_sym_shift;
10101               unsigned int s_type;
10102               asection **ps, *sec;
10103               struct elf_link_hash_entry *h = NULL;
10104               const char *sym_name;
10105
10106               if (r_symndx == STN_UNDEF)
10107                 continue;
10108
10109               if (r_symndx >= locsymcount
10110                   || (elf_bad_symtab (input_bfd)
10111                       && flinfo->sections[r_symndx] == NULL))
10112                 {
10113                   h = sym_hashes[r_symndx - extsymoff];
10114
10115                   /* Badly formatted input files can contain relocs that
10116                      reference non-existant symbols.  Check here so that
10117                      we do not seg fault.  */
10118                   if (h == NULL)
10119                     {
10120                       char buffer [32];
10121
10122                       sprintf_vma (buffer, rel->r_info);
10123                       (*_bfd_error_handler)
10124                         (_("error: %B contains a reloc (0x%s) for section %A "
10125                            "that references a non-existent global symbol"),
10126                          input_bfd, o, buffer);
10127                       bfd_set_error (bfd_error_bad_value);
10128                       return FALSE;
10129                     }
10130
10131                   while (h->root.type == bfd_link_hash_indirect
10132                          || h->root.type == bfd_link_hash_warning)
10133                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10134
10135                   s_type = h->type;
10136
10137                   /* If a plugin symbol is referenced from a non-IR file,
10138                      mark the symbol as undefined.  Note that the
10139                      linker may attach linker created dynamic sections
10140                      to the plugin bfd.  Symbols defined in linker
10141                      created sections are not plugin symbols.  */
10142                   if (h->root.non_ir_ref
10143                       && (h->root.type == bfd_link_hash_defined
10144                           || h->root.type == bfd_link_hash_defweak)
10145                       && (h->root.u.def.section->flags
10146                           & SEC_LINKER_CREATED) == 0
10147                       && h->root.u.def.section->owner != NULL
10148                       && (h->root.u.def.section->owner->flags
10149                           & BFD_PLUGIN) != 0)
10150                     {
10151                       h->root.type = bfd_link_hash_undefined;
10152                       h->root.u.undef.abfd = h->root.u.def.section->owner;
10153                     }
10154
10155                   ps = NULL;
10156                   if (h->root.type == bfd_link_hash_defined
10157                       || h->root.type == bfd_link_hash_defweak)
10158                     ps = &h->root.u.def.section;
10159
10160                   sym_name = h->root.root.string;
10161                 }
10162               else
10163                 {
10164                   Elf_Internal_Sym *sym = isymbuf + r_symndx;
10165
10166                   s_type = ELF_ST_TYPE (sym->st_info);
10167                   ps = &flinfo->sections[r_symndx];
10168                   sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
10169                                                sym, *ps);
10170                 }
10171
10172               if ((s_type == STT_RELC || s_type == STT_SRELC)
10173                   && !bfd_link_relocatable (flinfo->info))
10174                 {
10175                   bfd_vma val;
10176                   bfd_vma dot = (rel->r_offset
10177                                  + o->output_offset + o->output_section->vma);
10178 #ifdef DEBUG
10179                   printf ("Encountered a complex symbol!");
10180                   printf (" (input_bfd %s, section %s, reloc %ld\n",
10181                           input_bfd->filename, o->name,
10182                           (long) (rel - internal_relocs));
10183                   printf (" symbol: idx  %8.8lx, name %s\n",
10184                           r_symndx, sym_name);
10185                   printf (" reloc : info %8.8lx, addr %8.8lx\n",
10186                           (unsigned long) rel->r_info,
10187                           (unsigned long) rel->r_offset);
10188 #endif
10189                   if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
10190                                     isymbuf, locsymcount, s_type == STT_SRELC))
10191                     return FALSE;
10192
10193                   /* Symbol evaluated OK.  Update to absolute value.  */
10194                   set_symbol_value (input_bfd, isymbuf, locsymcount,
10195                                     r_symndx, val);
10196                   continue;
10197                 }
10198
10199               if (action_discarded != -1 && ps != NULL)
10200                 {
10201                   /* Complain if the definition comes from a
10202                      discarded section.  */
10203                   if ((sec = *ps) != NULL && discarded_section (sec))
10204                     {
10205                       BFD_ASSERT (r_symndx != STN_UNDEF);
10206                       if (action_discarded & COMPLAIN)
10207                         (*flinfo->info->callbacks->einfo)
10208                           (_("%X`%s' referenced in section `%A' of %B: "
10209                              "defined in discarded section `%A' of %B\n"),
10210                            sym_name, o, input_bfd, sec, sec->owner);
10211
10212                       /* Try to do the best we can to support buggy old
10213                          versions of gcc.  Pretend that the symbol is
10214                          really defined in the kept linkonce section.
10215                          FIXME: This is quite broken.  Modifying the
10216                          symbol here means we will be changing all later
10217                          uses of the symbol, not just in this section.  */
10218                       if (action_discarded & PRETEND)
10219                         {
10220                           asection *kept;
10221
10222                           kept = _bfd_elf_check_kept_section (sec,
10223                                                               flinfo->info);
10224                           if (kept != NULL)
10225                             {
10226                               *ps = kept;
10227                               continue;
10228                             }
10229                         }
10230                     }
10231                 }
10232             }
10233
10234           /* Relocate the section by invoking a back end routine.
10235
10236              The back end routine is responsible for adjusting the
10237              section contents as necessary, and (if using Rela relocs
10238              and generating a relocatable output file) adjusting the
10239              reloc addend as necessary.
10240
10241              The back end routine does not have to worry about setting
10242              the reloc address or the reloc symbol index.
10243
10244              The back end routine is given a pointer to the swapped in
10245              internal symbols, and can access the hash table entries
10246              for the external symbols via elf_sym_hashes (input_bfd).
10247
10248              When generating relocatable output, the back end routine
10249              must handle STB_LOCAL/STT_SECTION symbols specially.  The
10250              output symbol is going to be a section symbol
10251              corresponding to the output section, which will require
10252              the addend to be adjusted.  */
10253
10254           ret = (*relocate_section) (output_bfd, flinfo->info,
10255                                      input_bfd, o, contents,
10256                                      internal_relocs,
10257                                      isymbuf,
10258                                      flinfo->sections);
10259           if (!ret)
10260             return FALSE;
10261
10262           if (ret == 2
10263               || bfd_link_relocatable (flinfo->info)
10264               || flinfo->info->emitrelocations)
10265             {
10266               Elf_Internal_Rela *irela;
10267               Elf_Internal_Rela *irelaend, *irelamid;
10268               bfd_vma last_offset;
10269               struct elf_link_hash_entry **rel_hash;
10270               struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
10271               Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
10272               unsigned int next_erel;
10273               bfd_boolean rela_normal;
10274               struct bfd_elf_section_data *esdi, *esdo;
10275
10276               esdi = elf_section_data (o);
10277               esdo = elf_section_data (o->output_section);
10278               rela_normal = FALSE;
10279
10280               /* Adjust the reloc addresses and symbol indices.  */
10281
10282               irela = internal_relocs;
10283               irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
10284               rel_hash = esdo->rel.hashes + esdo->rel.count;
10285               /* We start processing the REL relocs, if any.  When we reach
10286                  IRELAMID in the loop, we switch to the RELA relocs.  */
10287               irelamid = irela;
10288               if (esdi->rel.hdr != NULL)
10289                 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
10290                              * bed->s->int_rels_per_ext_rel);
10291               rel_hash_list = rel_hash;
10292               rela_hash_list = NULL;
10293               last_offset = o->output_offset;
10294               if (!bfd_link_relocatable (flinfo->info))
10295                 last_offset += o->output_section->vma;
10296               for (next_erel = 0; irela < irelaend; irela++, next_erel++)
10297                 {
10298                   unsigned long r_symndx;
10299                   asection *sec;
10300                   Elf_Internal_Sym sym;
10301
10302                   if (next_erel == bed->s->int_rels_per_ext_rel)
10303                     {
10304                       rel_hash++;
10305                       next_erel = 0;
10306                     }
10307
10308                   if (irela == irelamid)
10309                     {
10310                       rel_hash = esdo->rela.hashes + esdo->rela.count;
10311                       rela_hash_list = rel_hash;
10312                       rela_normal = bed->rela_normal;
10313                     }
10314
10315                   irela->r_offset = _bfd_elf_section_offset (output_bfd,
10316                                                              flinfo->info, o,
10317                                                              irela->r_offset);
10318                   if (irela->r_offset >= (bfd_vma) -2)
10319                     {
10320                       /* This is a reloc for a deleted entry or somesuch.
10321                          Turn it into an R_*_NONE reloc, at the same
10322                          offset as the last reloc.  elf_eh_frame.c and
10323                          bfd_elf_discard_info rely on reloc offsets
10324                          being ordered.  */
10325                       irela->r_offset = last_offset;
10326                       irela->r_info = 0;
10327                       irela->r_addend = 0;
10328                       continue;
10329                     }
10330
10331                   irela->r_offset += o->output_offset;
10332
10333                   /* Relocs in an executable have to be virtual addresses.  */
10334                   if (!bfd_link_relocatable (flinfo->info))
10335                     irela->r_offset += o->output_section->vma;
10336
10337                   last_offset = irela->r_offset;
10338
10339                   r_symndx = irela->r_info >> r_sym_shift;
10340                   if (r_symndx == STN_UNDEF)
10341                     continue;
10342
10343                   if (r_symndx >= locsymcount
10344                       || (elf_bad_symtab (input_bfd)
10345                           && flinfo->sections[r_symndx] == NULL))
10346                     {
10347                       struct elf_link_hash_entry *rh;
10348                       unsigned long indx;
10349
10350                       /* This is a reloc against a global symbol.  We
10351                          have not yet output all the local symbols, so
10352                          we do not know the symbol index of any global
10353                          symbol.  We set the rel_hash entry for this
10354                          reloc to point to the global hash table entry
10355                          for this symbol.  The symbol index is then
10356                          set at the end of bfd_elf_final_link.  */
10357                       indx = r_symndx - extsymoff;
10358                       rh = elf_sym_hashes (input_bfd)[indx];
10359                       while (rh->root.type == bfd_link_hash_indirect
10360                              || rh->root.type == bfd_link_hash_warning)
10361                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
10362
10363                       /* Setting the index to -2 tells
10364                          elf_link_output_extsym that this symbol is
10365                          used by a reloc.  */
10366                       BFD_ASSERT (rh->indx < 0);
10367                       rh->indx = -2;
10368
10369                       *rel_hash = rh;
10370
10371                       continue;
10372                     }
10373
10374                   /* This is a reloc against a local symbol.  */
10375
10376                   *rel_hash = NULL;
10377                   sym = isymbuf[r_symndx];
10378                   sec = flinfo->sections[r_symndx];
10379                   if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
10380                     {
10381                       /* I suppose the backend ought to fill in the
10382                          section of any STT_SECTION symbol against a
10383                          processor specific section.  */
10384                       r_symndx = STN_UNDEF;
10385                       if (bfd_is_abs_section (sec))
10386                         ;
10387                       else if (sec == NULL || sec->owner == NULL)
10388                         {
10389                           bfd_set_error (bfd_error_bad_value);
10390                           return FALSE;
10391                         }
10392                       else
10393                         {
10394                           asection *osec = sec->output_section;
10395
10396                           /* If we have discarded a section, the output
10397                              section will be the absolute section.  In
10398                              case of discarded SEC_MERGE sections, use
10399                              the kept section.  relocate_section should
10400                              have already handled discarded linkonce
10401                              sections.  */
10402                           if (bfd_is_abs_section (osec)
10403                               && sec->kept_section != NULL
10404                               && sec->kept_section->output_section != NULL)
10405                             {
10406                               osec = sec->kept_section->output_section;
10407                               irela->r_addend -= osec->vma;
10408                             }
10409
10410                           if (!bfd_is_abs_section (osec))
10411                             {
10412                               r_symndx = osec->target_index;
10413                               if (r_symndx == STN_UNDEF)
10414                                 {
10415                                   irela->r_addend += osec->vma;
10416                                   osec = _bfd_nearby_section (output_bfd, osec,
10417                                                               osec->vma);
10418                                   irela->r_addend -= osec->vma;
10419                                   r_symndx = osec->target_index;
10420                                 }
10421                             }
10422                         }
10423
10424                       /* Adjust the addend according to where the
10425                          section winds up in the output section.  */
10426                       if (rela_normal)
10427                         irela->r_addend += sec->output_offset;
10428                     }
10429                   else
10430                     {
10431                       if (flinfo->indices[r_symndx] == -1)
10432                         {
10433                           unsigned long shlink;
10434                           const char *name;
10435                           asection *osec;
10436                           long indx;
10437
10438                           if (flinfo->info->strip == strip_all)
10439                             {
10440                               /* You can't do ld -r -s.  */
10441                               bfd_set_error (bfd_error_invalid_operation);
10442                               return FALSE;
10443                             }
10444
10445                           /* This symbol was skipped earlier, but
10446                              since it is needed by a reloc, we
10447                              must output it now.  */
10448                           shlink = symtab_hdr->sh_link;
10449                           name = (bfd_elf_string_from_elf_section
10450                                   (input_bfd, shlink, sym.st_name));
10451                           if (name == NULL)
10452                             return FALSE;
10453
10454                           osec = sec->output_section;
10455                           sym.st_shndx =
10456                             _bfd_elf_section_from_bfd_section (output_bfd,
10457                                                                osec);
10458                           if (sym.st_shndx == SHN_BAD)
10459                             return FALSE;
10460
10461                           sym.st_value += sec->output_offset;
10462                           if (!bfd_link_relocatable (flinfo->info))
10463                             {
10464                               sym.st_value += osec->vma;
10465                               if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
10466                                 {
10467                                   /* STT_TLS symbols are relative to PT_TLS
10468                                      segment base.  */
10469                                   BFD_ASSERT (elf_hash_table (flinfo->info)
10470                                               ->tls_sec != NULL);
10471                                   sym.st_value -= (elf_hash_table (flinfo->info)
10472                                                    ->tls_sec->vma);
10473                                 }
10474                             }
10475
10476                           indx = bfd_get_symcount (output_bfd);
10477                           ret = elf_link_output_symstrtab (flinfo, name,
10478                                                            &sym, sec,
10479                                                            NULL);
10480                           if (ret == 0)
10481                             return FALSE;
10482                           else if (ret == 1)
10483                             flinfo->indices[r_symndx] = indx;
10484                           else
10485                             abort ();
10486                         }
10487
10488                       r_symndx = flinfo->indices[r_symndx];
10489                     }
10490
10491                   irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
10492                                    | (irela->r_info & r_type_mask));
10493                 }
10494
10495               /* Swap out the relocs.  */
10496               input_rel_hdr = esdi->rel.hdr;
10497               if (input_rel_hdr && input_rel_hdr->sh_size != 0)
10498                 {
10499                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10500                                                      input_rel_hdr,
10501                                                      internal_relocs,
10502                                                      rel_hash_list))
10503                     return FALSE;
10504                   internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
10505                                       * bed->s->int_rels_per_ext_rel);
10506                   rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
10507                 }
10508
10509               input_rela_hdr = esdi->rela.hdr;
10510               if (input_rela_hdr && input_rela_hdr->sh_size != 0)
10511                 {
10512                   if (!bed->elf_backend_emit_relocs (output_bfd, o,
10513                                                      input_rela_hdr,
10514                                                      internal_relocs,
10515                                                      rela_hash_list))
10516                     return FALSE;
10517                 }
10518             }
10519         }
10520
10521       /* Write out the modified section contents.  */
10522       if (bed->elf_backend_write_section
10523           && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
10524                                                 contents))
10525         {
10526           /* Section written out.  */
10527         }
10528       else switch (o->sec_info_type)
10529         {
10530         case SEC_INFO_TYPE_STABS:
10531           if (! (_bfd_write_section_stabs
10532                  (output_bfd,
10533                   &elf_hash_table (flinfo->info)->stab_info,
10534                   o, &elf_section_data (o)->sec_info, contents)))
10535             return FALSE;
10536           break;
10537         case SEC_INFO_TYPE_MERGE:
10538           if (! _bfd_write_merged_section (output_bfd, o,
10539                                            elf_section_data (o)->sec_info))
10540             return FALSE;
10541           break;
10542         case SEC_INFO_TYPE_EH_FRAME:
10543           {
10544             if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
10545                                                    o, contents))
10546               return FALSE;
10547           }
10548           break;
10549         case SEC_INFO_TYPE_EH_FRAME_ENTRY:
10550           {
10551             if (! _bfd_elf_write_section_eh_frame_entry (output_bfd,
10552                                                          flinfo->info,
10553                                                          o, contents))
10554               return FALSE;
10555           }
10556           break;
10557         default:
10558           {
10559             if (! (o->flags & SEC_EXCLUDE))
10560               {
10561                 file_ptr offset = (file_ptr) o->output_offset;
10562                 bfd_size_type todo = o->size;
10563
10564                 offset *= bfd_octets_per_byte (output_bfd);
10565
10566                 if ((o->flags & SEC_ELF_REVERSE_COPY))
10567                   {
10568                     /* Reverse-copy input section to output.  */
10569                     do
10570                       {
10571                         todo -= address_size;
10572                         if (! bfd_set_section_contents (output_bfd,
10573                                                         o->output_section,
10574                                                         contents + todo,
10575                                                         offset,
10576                                                         address_size))
10577                           return FALSE;
10578                         if (todo == 0)
10579                           break;
10580                         offset += address_size;
10581                       }
10582                     while (1);
10583                   }
10584                 else if (! bfd_set_section_contents (output_bfd,
10585                                                      o->output_section,
10586                                                      contents,
10587                                                      offset, todo))
10588                   return FALSE;
10589               }
10590           }
10591           break;
10592         }
10593     }
10594
10595   return TRUE;
10596 }
10597
10598 /* Generate a reloc when linking an ELF file.  This is a reloc
10599    requested by the linker, and does not come from any input file.  This
10600    is used to build constructor and destructor tables when linking
10601    with -Ur.  */
10602
10603 static bfd_boolean
10604 elf_reloc_link_order (bfd *output_bfd,
10605                       struct bfd_link_info *info,
10606                       asection *output_section,
10607                       struct bfd_link_order *link_order)
10608 {
10609   reloc_howto_type *howto;
10610   long indx;
10611   bfd_vma offset;
10612   bfd_vma addend;
10613   struct bfd_elf_section_reloc_data *reldata;
10614   struct elf_link_hash_entry **rel_hash_ptr;
10615   Elf_Internal_Shdr *rel_hdr;
10616   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10617   Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
10618   bfd_byte *erel;
10619   unsigned int i;
10620   struct bfd_elf_section_data *esdo = elf_section_data (output_section);
10621
10622   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
10623   if (howto == NULL)
10624     {
10625       bfd_set_error (bfd_error_bad_value);
10626       return FALSE;
10627     }
10628
10629   addend = link_order->u.reloc.p->addend;
10630
10631   if (esdo->rel.hdr)
10632     reldata = &esdo->rel;
10633   else if (esdo->rela.hdr)
10634     reldata = &esdo->rela;
10635   else
10636     {
10637       reldata = NULL;
10638       BFD_ASSERT (0);
10639     }
10640
10641   /* Figure out the symbol index.  */
10642   rel_hash_ptr = reldata->hashes + reldata->count;
10643   if (link_order->type == bfd_section_reloc_link_order)
10644     {
10645       indx = link_order->u.reloc.p->u.section->target_index;
10646       BFD_ASSERT (indx != 0);
10647       *rel_hash_ptr = NULL;
10648     }
10649   else
10650     {
10651       struct elf_link_hash_entry *h;
10652
10653       /* Treat a reloc against a defined symbol as though it were
10654          actually against the section.  */
10655       h = ((struct elf_link_hash_entry *)
10656            bfd_wrapped_link_hash_lookup (output_bfd, info,
10657                                          link_order->u.reloc.p->u.name,
10658                                          FALSE, FALSE, TRUE));
10659       if (h != NULL
10660           && (h->root.type == bfd_link_hash_defined
10661               || h->root.type == bfd_link_hash_defweak))
10662         {
10663           asection *section;
10664
10665           section = h->root.u.def.section;
10666           indx = section->output_section->target_index;
10667           *rel_hash_ptr = NULL;
10668           /* It seems that we ought to add the symbol value to the
10669              addend here, but in practice it has already been added
10670              because it was passed to constructor_callback.  */
10671           addend += section->output_section->vma + section->output_offset;
10672         }
10673       else if (h != NULL)
10674         {
10675           /* Setting the index to -2 tells elf_link_output_extsym that
10676              this symbol is used by a reloc.  */
10677           h->indx = -2;
10678           *rel_hash_ptr = h;
10679           indx = 0;
10680         }
10681       else
10682         {
10683           if (! ((*info->callbacks->unattached_reloc)
10684                  (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10685             return FALSE;
10686           indx = 0;
10687         }
10688     }
10689
10690   /* If this is an inplace reloc, we must write the addend into the
10691      object file.  */
10692   if (howto->partial_inplace && addend != 0)
10693     {
10694       bfd_size_type size;
10695       bfd_reloc_status_type rstat;
10696       bfd_byte *buf;
10697       bfd_boolean ok;
10698       const char *sym_name;
10699
10700       size = (bfd_size_type) bfd_get_reloc_size (howto);
10701       buf = (bfd_byte *) bfd_zmalloc (size);
10702       if (buf == NULL && size != 0)
10703         return FALSE;
10704       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10705       switch (rstat)
10706         {
10707         case bfd_reloc_ok:
10708           break;
10709
10710         default:
10711         case bfd_reloc_outofrange:
10712           abort ();
10713
10714         case bfd_reloc_overflow:
10715           if (link_order->type == bfd_section_reloc_link_order)
10716             sym_name = bfd_section_name (output_bfd,
10717                                          link_order->u.reloc.p->u.section);
10718           else
10719             sym_name = link_order->u.reloc.p->u.name;
10720           if (! ((*info->callbacks->reloc_overflow)
10721                  (info, NULL, sym_name, howto->name, addend, NULL,
10722                   NULL, (bfd_vma) 0)))
10723             {
10724               free (buf);
10725               return FALSE;
10726             }
10727           break;
10728         }
10729
10730       ok = bfd_set_section_contents (output_bfd, output_section, buf,
10731                                      link_order->offset
10732                                      * bfd_octets_per_byte (output_bfd),
10733                                      size);
10734       free (buf);
10735       if (! ok)
10736         return FALSE;
10737     }
10738
10739   /* The address of a reloc is relative to the section in a
10740      relocatable file, and is a virtual address in an executable
10741      file.  */
10742   offset = link_order->offset;
10743   if (! bfd_link_relocatable (info))
10744     offset += output_section->vma;
10745
10746   for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10747     {
10748       irel[i].r_offset = offset;
10749       irel[i].r_info = 0;
10750       irel[i].r_addend = 0;
10751     }
10752   if (bed->s->arch_size == 32)
10753     irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10754   else
10755     irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10756
10757   rel_hdr = reldata->hdr;
10758   erel = rel_hdr->contents;
10759   if (rel_hdr->sh_type == SHT_REL)
10760     {
10761       erel += reldata->count * bed->s->sizeof_rel;
10762       (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10763     }
10764   else
10765     {
10766       irel[0].r_addend = addend;
10767       erel += reldata->count * bed->s->sizeof_rela;
10768       (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10769     }
10770
10771   ++reldata->count;
10772
10773   return TRUE;
10774 }
10775
10776
10777 /* Get the output vma of the section pointed to by the sh_link field.  */
10778
10779 static bfd_vma
10780 elf_get_linked_section_vma (struct bfd_link_order *p)
10781 {
10782   Elf_Internal_Shdr **elf_shdrp;
10783   asection *s;
10784   int elfsec;
10785
10786   s = p->u.indirect.section;
10787   elf_shdrp = elf_elfsections (s->owner);
10788   elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10789   elfsec = elf_shdrp[elfsec]->sh_link;
10790   /* PR 290:
10791      The Intel C compiler generates SHT_IA_64_UNWIND with
10792      SHF_LINK_ORDER.  But it doesn't set the sh_link or
10793      sh_info fields.  Hence we could get the situation
10794      where elfsec is 0.  */
10795   if (elfsec == 0)
10796     {
10797       const struct elf_backend_data *bed
10798         = get_elf_backend_data (s->owner);
10799       if (bed->link_order_error_handler)
10800         bed->link_order_error_handler
10801           (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10802       return 0;
10803     }
10804   else
10805     {
10806       s = elf_shdrp[elfsec]->bfd_section;
10807       return s->output_section->vma + s->output_offset;
10808     }
10809 }
10810
10811
10812 /* Compare two sections based on the locations of the sections they are
10813    linked to.  Used by elf_fixup_link_order.  */
10814
10815 static int
10816 compare_link_order (const void * a, const void * b)
10817 {
10818   bfd_vma apos;
10819   bfd_vma bpos;
10820
10821   apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10822   bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10823   if (apos < bpos)
10824     return -1;
10825   return apos > bpos;
10826 }
10827
10828
10829 /* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
10830    order as their linked sections.  Returns false if this could not be done
10831    because an output section includes both ordered and unordered
10832    sections.  Ideally we'd do this in the linker proper.  */
10833
10834 static bfd_boolean
10835 elf_fixup_link_order (bfd *abfd, asection *o)
10836 {
10837   int seen_linkorder;
10838   int seen_other;
10839   int n;
10840   struct bfd_link_order *p;
10841   bfd *sub;
10842   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10843   unsigned elfsec;
10844   struct bfd_link_order **sections;
10845   asection *s, *other_sec, *linkorder_sec;
10846   bfd_vma offset;
10847
10848   other_sec = NULL;
10849   linkorder_sec = NULL;
10850   seen_other = 0;
10851   seen_linkorder = 0;
10852   for (p = o->map_head.link_order; p != NULL; p = p->next)
10853     {
10854       if (p->type == bfd_indirect_link_order)
10855         {
10856           s = p->u.indirect.section;
10857           sub = s->owner;
10858           if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10859               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10860               && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10861               && elfsec < elf_numsections (sub)
10862               && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10863               && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10864             {
10865               seen_linkorder++;
10866               linkorder_sec = s;
10867             }
10868           else
10869             {
10870               seen_other++;
10871               other_sec = s;
10872             }
10873         }
10874       else
10875         seen_other++;
10876
10877       if (seen_other && seen_linkorder)
10878         {
10879           if (other_sec && linkorder_sec)
10880             (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10881                                    o, linkorder_sec,
10882                                    linkorder_sec->owner, other_sec,
10883                                    other_sec->owner);
10884           else
10885             (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10886                                    o);
10887           bfd_set_error (bfd_error_bad_value);
10888           return FALSE;
10889         }
10890     }
10891
10892   if (!seen_linkorder)
10893     return TRUE;
10894
10895   sections = (struct bfd_link_order **)
10896     bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10897   if (sections == NULL)
10898     return FALSE;
10899   seen_linkorder = 0;
10900
10901   for (p = o->map_head.link_order; p != NULL; p = p->next)
10902     {
10903       sections[seen_linkorder++] = p;
10904     }
10905   /* Sort the input sections in the order of their linked section.  */
10906   qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10907          compare_link_order);
10908
10909   /* Change the offsets of the sections.  */
10910   offset = 0;
10911   for (n = 0; n < seen_linkorder; n++)
10912     {
10913       s = sections[n]->u.indirect.section;
10914       offset &= ~(bfd_vma) 0 << s->alignment_power;
10915       s->output_offset = offset / bfd_octets_per_byte (abfd);
10916       sections[n]->offset = offset;
10917       offset += sections[n]->size;
10918     }
10919
10920   free (sections);
10921   return TRUE;
10922 }
10923
10924 static void
10925 elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
10926 {
10927   asection *o;
10928
10929   if (flinfo->symstrtab != NULL)
10930     _bfd_elf_strtab_free (flinfo->symstrtab);
10931   if (flinfo->contents != NULL)
10932     free (flinfo->contents);
10933   if (flinfo->external_relocs != NULL)
10934     free (flinfo->external_relocs);
10935   if (flinfo->internal_relocs != NULL)
10936     free (flinfo->internal_relocs);
10937   if (flinfo->external_syms != NULL)
10938     free (flinfo->external_syms);
10939   if (flinfo->locsym_shndx != NULL)
10940     free (flinfo->locsym_shndx);
10941   if (flinfo->internal_syms != NULL)
10942     free (flinfo->internal_syms);
10943   if (flinfo->indices != NULL)
10944     free (flinfo->indices);
10945   if (flinfo->sections != NULL)
10946     free (flinfo->sections);
10947   if (flinfo->symshndxbuf != NULL)
10948     free (flinfo->symshndxbuf);
10949   for (o = obfd->sections; o != NULL; o = o->next)
10950     {
10951       struct bfd_elf_section_data *esdo = elf_section_data (o);
10952       if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
10953         free (esdo->rel.hashes);
10954       if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
10955         free (esdo->rela.hashes);
10956     }
10957 }
10958
10959 /* Do the final step of an ELF link.  */
10960
10961 bfd_boolean
10962 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10963 {
10964   bfd_boolean dynamic;
10965   bfd_boolean emit_relocs;
10966   bfd *dynobj;
10967   struct elf_final_link_info flinfo;
10968   asection *o;
10969   struct bfd_link_order *p;
10970   bfd *sub;
10971   bfd_size_type max_contents_size;
10972   bfd_size_type max_external_reloc_size;
10973   bfd_size_type max_internal_reloc_count;
10974   bfd_size_type max_sym_count;
10975   bfd_size_type max_sym_shndx_count;
10976   Elf_Internal_Sym elfsym;
10977   unsigned int i;
10978   Elf_Internal_Shdr *symtab_hdr;
10979   Elf_Internal_Shdr *symtab_shndx_hdr;
10980   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10981   struct elf_outext_info eoinfo;
10982   bfd_boolean merged;
10983   size_t relativecount = 0;
10984   asection *reldyn = 0;
10985   bfd_size_type amt;
10986   asection *attr_section = NULL;
10987   bfd_vma attr_size = 0;
10988   const char *std_attrs_section;
10989
10990   if (! is_elf_hash_table (info->hash))
10991     return FALSE;
10992
10993   if (bfd_link_pic (info))
10994     abfd->flags |= DYNAMIC;
10995
10996   dynamic = elf_hash_table (info)->dynamic_sections_created;
10997   dynobj = elf_hash_table (info)->dynobj;
10998
10999   emit_relocs = (bfd_link_relocatable (info)
11000                  || info->emitrelocations);
11001
11002   flinfo.info = info;
11003   flinfo.output_bfd = abfd;
11004   flinfo.symstrtab = _bfd_elf_strtab_init ();
11005   if (flinfo.symstrtab == NULL)
11006     return FALSE;
11007
11008   if (! dynamic)
11009     {
11010       flinfo.hash_sec = NULL;
11011       flinfo.symver_sec = NULL;
11012     }
11013   else
11014     {
11015       flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
11016       /* Note that dynsym_sec can be NULL (on VMS).  */
11017       flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
11018       /* Note that it is OK if symver_sec is NULL.  */
11019     }
11020
11021   flinfo.contents = NULL;
11022   flinfo.external_relocs = NULL;
11023   flinfo.internal_relocs = NULL;
11024   flinfo.external_syms = NULL;
11025   flinfo.locsym_shndx = NULL;
11026   flinfo.internal_syms = NULL;
11027   flinfo.indices = NULL;
11028   flinfo.sections = NULL;
11029   flinfo.symshndxbuf = NULL;
11030   flinfo.filesym_count = 0;
11031
11032   /* The object attributes have been merged.  Remove the input
11033      sections from the link, and set the contents of the output
11034      secton.  */
11035   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
11036   for (o = abfd->sections; o != NULL; o = o->next)
11037     {
11038       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
11039           || strcmp (o->name, ".gnu.attributes") == 0)
11040         {
11041           for (p = o->map_head.link_order; p != NULL; p = p->next)
11042             {
11043               asection *input_section;
11044
11045               if (p->type != bfd_indirect_link_order)
11046                 continue;
11047               input_section = p->u.indirect.section;
11048               /* Hack: reset the SEC_HAS_CONTENTS flag so that
11049                  elf_link_input_bfd ignores this section.  */
11050               input_section->flags &= ~SEC_HAS_CONTENTS;
11051             }
11052
11053           attr_size = bfd_elf_obj_attr_size (abfd);
11054           if (attr_size)
11055             {
11056               bfd_set_section_size (abfd, o, attr_size);
11057               attr_section = o;
11058               /* Skip this section later on.  */
11059               o->map_head.link_order = NULL;
11060             }
11061           else
11062             o->flags |= SEC_EXCLUDE;
11063         }
11064     }
11065
11066   /* Count up the number of relocations we will output for each output
11067      section, so that we know the sizes of the reloc sections.  We
11068      also figure out some maximum sizes.  */
11069   max_contents_size = 0;
11070   max_external_reloc_size = 0;
11071   max_internal_reloc_count = 0;
11072   max_sym_count = 0;
11073   max_sym_shndx_count = 0;
11074   merged = FALSE;
11075   for (o = abfd->sections; o != NULL; o = o->next)
11076     {
11077       struct bfd_elf_section_data *esdo = elf_section_data (o);
11078       o->reloc_count = 0;
11079
11080       for (p = o->map_head.link_order; p != NULL; p = p->next)
11081         {
11082           unsigned int reloc_count = 0;
11083           unsigned int additional_reloc_count = 0;
11084           struct bfd_elf_section_data *esdi = NULL;
11085
11086           if (p->type == bfd_section_reloc_link_order
11087               || p->type == bfd_symbol_reloc_link_order)
11088             reloc_count = 1;
11089           else if (p->type == bfd_indirect_link_order)
11090             {
11091               asection *sec;
11092
11093               sec = p->u.indirect.section;
11094               esdi = elf_section_data (sec);
11095
11096               /* Mark all sections which are to be included in the
11097                  link.  This will normally be every section.  We need
11098                  to do this so that we can identify any sections which
11099                  the linker has decided to not include.  */
11100               sec->linker_mark = TRUE;
11101
11102               if (sec->flags & SEC_MERGE)
11103                 merged = TRUE;
11104
11105               if (esdo->this_hdr.sh_type == SHT_REL
11106                   || esdo->this_hdr.sh_type == SHT_RELA)
11107                 /* Some backends use reloc_count in relocation sections
11108                    to count particular types of relocs.  Of course,
11109                    reloc sections themselves can't have relocations.  */
11110                 reloc_count = 0;
11111               else if (emit_relocs)
11112                 {
11113                   reloc_count = sec->reloc_count;
11114                   if (bed->elf_backend_count_additional_relocs)
11115                     {
11116                       int c;
11117                       c = (*bed->elf_backend_count_additional_relocs) (sec);
11118                       additional_reloc_count += c;
11119                     }
11120                 }
11121               else if (bed->elf_backend_count_relocs)
11122                 reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
11123
11124               if (sec->rawsize > max_contents_size)
11125                 max_contents_size = sec->rawsize;
11126               if (sec->size > max_contents_size)
11127                 max_contents_size = sec->size;
11128
11129               /* We are interested in just local symbols, not all
11130                  symbols.  */
11131               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
11132                   && (sec->owner->flags & DYNAMIC) == 0)
11133                 {
11134                   size_t sym_count;
11135
11136                   if (elf_bad_symtab (sec->owner))
11137                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
11138                                  / bed->s->sizeof_sym);
11139                   else
11140                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
11141
11142                   if (sym_count > max_sym_count)
11143                     max_sym_count = sym_count;
11144
11145                   if (sym_count > max_sym_shndx_count
11146                       && elf_symtab_shndx_list (sec->owner) != NULL)
11147                     max_sym_shndx_count = sym_count;
11148
11149                   if ((sec->flags & SEC_RELOC) != 0)
11150                     {
11151                       size_t ext_size = 0;
11152
11153                       if (esdi->rel.hdr != NULL)
11154                         ext_size = esdi->rel.hdr->sh_size;
11155                       if (esdi->rela.hdr != NULL)
11156                         ext_size += esdi->rela.hdr->sh_size;
11157
11158                       if (ext_size > max_external_reloc_size)
11159                         max_external_reloc_size = ext_size;
11160                       if (sec->reloc_count > max_internal_reloc_count)
11161                         max_internal_reloc_count = sec->reloc_count;
11162                     }
11163                 }
11164             }
11165
11166           if (reloc_count == 0)
11167             continue;
11168
11169           reloc_count += additional_reloc_count;
11170           o->reloc_count += reloc_count;
11171
11172           if (p->type == bfd_indirect_link_order && emit_relocs)
11173             {
11174               if (esdi->rel.hdr)
11175                 {
11176                   esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
11177                   esdo->rel.count += additional_reloc_count;
11178                 }
11179               if (esdi->rela.hdr)
11180                 {
11181                   esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
11182                   esdo->rela.count += additional_reloc_count;
11183                 }
11184             }
11185           else
11186             {
11187               if (o->use_rela_p)
11188                 esdo->rela.count += reloc_count;
11189               else
11190                 esdo->rel.count += reloc_count;
11191             }
11192         }
11193
11194       if (o->reloc_count > 0)
11195         o->flags |= SEC_RELOC;
11196       else
11197         {
11198           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
11199              set it (this is probably a bug) and if it is set
11200              assign_section_numbers will create a reloc section.  */
11201           o->flags &=~ SEC_RELOC;
11202         }
11203
11204       /* If the SEC_ALLOC flag is not set, force the section VMA to
11205          zero.  This is done in elf_fake_sections as well, but forcing
11206          the VMA to 0 here will ensure that relocs against these
11207          sections are handled correctly.  */
11208       if ((o->flags & SEC_ALLOC) == 0
11209           && ! o->user_set_vma)
11210         o->vma = 0;
11211     }
11212
11213   if (! bfd_link_relocatable (info) && merged)
11214     elf_link_hash_traverse (elf_hash_table (info),
11215                             _bfd_elf_link_sec_merge_syms, abfd);
11216
11217   /* Figure out the file positions for everything but the symbol table
11218      and the relocs.  We set symcount to force assign_section_numbers
11219      to create a symbol table.  */
11220   bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
11221   BFD_ASSERT (! abfd->output_has_begun);
11222   if (! _bfd_elf_compute_section_file_positions (abfd, info))
11223     goto error_return;
11224
11225   /* Set sizes, and assign file positions for reloc sections.  */
11226   for (o = abfd->sections; o != NULL; o = o->next)
11227     {
11228       struct bfd_elf_section_data *esdo = elf_section_data (o);
11229       if ((o->flags & SEC_RELOC) != 0)
11230         {
11231           if (esdo->rel.hdr
11232               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
11233             goto error_return;
11234
11235           if (esdo->rela.hdr
11236               && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
11237             goto error_return;
11238         }
11239
11240       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
11241          to count upwards while actually outputting the relocations.  */
11242       esdo->rel.count = 0;
11243       esdo->rela.count = 0;
11244
11245       if (esdo->this_hdr.sh_offset == (file_ptr) -1)
11246         {
11247           /* Cache the section contents so that they can be compressed
11248              later.  Use bfd_malloc since it will be freed by
11249              bfd_compress_section_contents.  */
11250           unsigned char *contents = esdo->this_hdr.contents;
11251           if ((o->flags & SEC_ELF_COMPRESS) == 0 || contents != NULL)
11252             abort ();
11253           contents
11254             = (unsigned char *) bfd_malloc (esdo->this_hdr.sh_size);
11255           if (contents == NULL)
11256             goto error_return;
11257           esdo->this_hdr.contents = contents;
11258         }
11259     }
11260
11261   /* We have now assigned file positions for all the sections except
11262      .symtab, .strtab, and non-loaded reloc sections.  We start the
11263      .symtab section at the current file position, and write directly
11264      to it.  We build the .strtab section in memory.  */
11265   bfd_get_symcount (abfd) = 0;
11266   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11267   /* sh_name is set in prep_headers.  */
11268   symtab_hdr->sh_type = SHT_SYMTAB;
11269   /* sh_flags, sh_addr and sh_size all start off zero.  */
11270   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
11271   /* sh_link is set in assign_section_numbers.  */
11272   /* sh_info is set below.  */
11273   /* sh_offset is set just below.  */
11274   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
11275
11276   if (max_sym_count < 20)
11277     max_sym_count = 20;
11278   elf_hash_table (info)->strtabsize = max_sym_count;
11279   amt = max_sym_count * sizeof (struct elf_sym_strtab);
11280   elf_hash_table (info)->strtab
11281     = (struct elf_sym_strtab *) bfd_malloc (amt);
11282   if (elf_hash_table (info)->strtab == NULL)
11283     goto error_return;
11284   /* The real buffer will be allocated in elf_link_swap_symbols_out.  */
11285   flinfo.symshndxbuf
11286     = (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF)
11287        ? (Elf_External_Sym_Shndx *) -1 : NULL);
11288
11289   if (info->strip != strip_all || emit_relocs)
11290     {
11291       file_ptr off = elf_next_file_pos (abfd);
11292
11293       _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
11294
11295       /* Note that at this point elf_next_file_pos (abfd) is
11296          incorrect.  We do not yet know the size of the .symtab section.
11297          We correct next_file_pos below, after we do know the size.  */
11298
11299       /* Start writing out the symbol table.  The first symbol is always a
11300          dummy symbol.  */
11301       elfsym.st_value = 0;
11302       elfsym.st_size = 0;
11303       elfsym.st_info = 0;
11304       elfsym.st_other = 0;
11305       elfsym.st_shndx = SHN_UNDEF;
11306       elfsym.st_target_internal = 0;
11307       if (elf_link_output_symstrtab (&flinfo, NULL, &elfsym,
11308                                      bfd_und_section_ptr, NULL) != 1)
11309         goto error_return;
11310
11311       /* Output a symbol for each section.  We output these even if we are
11312          discarding local symbols, since they are used for relocs.  These
11313          symbols have no names.  We store the index of each one in the
11314          index field of the section, so that we can find it again when
11315          outputting relocs.  */
11316
11317       elfsym.st_size = 0;
11318       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11319       elfsym.st_other = 0;
11320       elfsym.st_value = 0;
11321       elfsym.st_target_internal = 0;
11322       for (i = 1; i < elf_numsections (abfd); i++)
11323         {
11324           o = bfd_section_from_elf_index (abfd, i);
11325           if (o != NULL)
11326             {
11327               o->target_index = bfd_get_symcount (abfd);
11328               elfsym.st_shndx = i;
11329               if (!bfd_link_relocatable (info))
11330                 elfsym.st_value = o->vma;
11331               if (elf_link_output_symstrtab (&flinfo, NULL, &elfsym, o,
11332                                              NULL) != 1)
11333                 goto error_return;
11334             }
11335         }
11336     }
11337
11338   /* Allocate some memory to hold information read in from the input
11339      files.  */
11340   if (max_contents_size != 0)
11341     {
11342       flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
11343       if (flinfo.contents == NULL)
11344         goto error_return;
11345     }
11346
11347   if (max_external_reloc_size != 0)
11348     {
11349       flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
11350       if (flinfo.external_relocs == NULL)
11351         goto error_return;
11352     }
11353
11354   if (max_internal_reloc_count != 0)
11355     {
11356       amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
11357       amt *= sizeof (Elf_Internal_Rela);
11358       flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
11359       if (flinfo.internal_relocs == NULL)
11360         goto error_return;
11361     }
11362
11363   if (max_sym_count != 0)
11364     {
11365       amt = max_sym_count * bed->s->sizeof_sym;
11366       flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
11367       if (flinfo.external_syms == NULL)
11368         goto error_return;
11369
11370       amt = max_sym_count * sizeof (Elf_Internal_Sym);
11371       flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
11372       if (flinfo.internal_syms == NULL)
11373         goto error_return;
11374
11375       amt = max_sym_count * sizeof (long);
11376       flinfo.indices = (long int *) bfd_malloc (amt);
11377       if (flinfo.indices == NULL)
11378         goto error_return;
11379
11380       amt = max_sym_count * sizeof (asection *);
11381       flinfo.sections = (asection **) bfd_malloc (amt);
11382       if (flinfo.sections == NULL)
11383         goto error_return;
11384     }
11385
11386   if (max_sym_shndx_count != 0)
11387     {
11388       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
11389       flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
11390       if (flinfo.locsym_shndx == NULL)
11391         goto error_return;
11392     }
11393
11394   if (elf_hash_table (info)->tls_sec)
11395     {
11396       bfd_vma base, end = 0;
11397       asection *sec;
11398
11399       for (sec = elf_hash_table (info)->tls_sec;
11400            sec && (sec->flags & SEC_THREAD_LOCAL);
11401            sec = sec->next)
11402         {
11403           bfd_size_type size = sec->size;
11404
11405           if (size == 0
11406               && (sec->flags & SEC_HAS_CONTENTS) == 0)
11407             {
11408               struct bfd_link_order *ord = sec->map_tail.link_order;
11409
11410               if (ord != NULL)
11411                 size = ord->offset + ord->size;
11412             }
11413           end = sec->vma + size;
11414         }
11415       base = elf_hash_table (info)->tls_sec->vma;
11416       /* Only align end of TLS section if static TLS doesn't have special
11417          alignment requirements.  */
11418       if (bed->static_tls_alignment == 1)
11419         end = align_power (end,
11420                            elf_hash_table (info)->tls_sec->alignment_power);
11421       elf_hash_table (info)->tls_size = end - base;
11422     }
11423
11424   /* Reorder SHF_LINK_ORDER sections.  */
11425   for (o = abfd->sections; o != NULL; o = o->next)
11426     {
11427       if (!elf_fixup_link_order (abfd, o))
11428         return FALSE;
11429     }
11430
11431   if (!_bfd_elf_fixup_eh_frame_hdr (info))
11432     return FALSE;
11433
11434   /* Since ELF permits relocations to be against local symbols, we
11435      must have the local symbols available when we do the relocations.
11436      Since we would rather only read the local symbols once, and we
11437      would rather not keep them in memory, we handle all the
11438      relocations for a single input file at the same time.
11439
11440      Unfortunately, there is no way to know the total number of local
11441      symbols until we have seen all of them, and the local symbol
11442      indices precede the global symbol indices.  This means that when
11443      we are generating relocatable output, and we see a reloc against
11444      a global symbol, we can not know the symbol index until we have
11445      finished examining all the local symbols to see which ones we are
11446      going to output.  To deal with this, we keep the relocations in
11447      memory, and don't output them until the end of the link.  This is
11448      an unfortunate waste of memory, but I don't see a good way around
11449      it.  Fortunately, it only happens when performing a relocatable
11450      link, which is not the common case.  FIXME: If keep_memory is set
11451      we could write the relocs out and then read them again; I don't
11452      know how bad the memory loss will be.  */
11453
11454   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11455     sub->output_has_begun = FALSE;
11456   for (o = abfd->sections; o != NULL; o = o->next)
11457     {
11458       for (p = o->map_head.link_order; p != NULL; p = p->next)
11459         {
11460           if (p->type == bfd_indirect_link_order
11461               && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
11462                   == bfd_target_elf_flavour)
11463               && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
11464             {
11465               if (! sub->output_has_begun)
11466                 {
11467                   if (! elf_link_input_bfd (&flinfo, sub))
11468                     goto error_return;
11469                   sub->output_has_begun = TRUE;
11470                 }
11471             }
11472           else if (p->type == bfd_section_reloc_link_order
11473                    || p->type == bfd_symbol_reloc_link_order)
11474             {
11475               if (! elf_reloc_link_order (abfd, info, o, p))
11476                 goto error_return;
11477             }
11478           else
11479             {
11480               if (! _bfd_default_link_order (abfd, info, o, p))
11481                 {
11482                   if (p->type == bfd_indirect_link_order
11483                       && (bfd_get_flavour (sub)
11484                           == bfd_target_elf_flavour)
11485                       && (elf_elfheader (sub)->e_ident[EI_CLASS]
11486                           != bed->s->elfclass))
11487                     {
11488                       const char *iclass, *oclass;
11489
11490                       switch (bed->s->elfclass)
11491                         {
11492                         case ELFCLASS64: oclass = "ELFCLASS64"; break;
11493                         case ELFCLASS32: oclass = "ELFCLASS32"; break;
11494                         case ELFCLASSNONE: oclass = "ELFCLASSNONE"; break;
11495                         default: abort ();
11496                         }
11497
11498                       switch (elf_elfheader (sub)->e_ident[EI_CLASS])
11499                         {
11500                         case ELFCLASS64: iclass = "ELFCLASS64"; break;
11501                         case ELFCLASS32: iclass = "ELFCLASS32"; break;
11502                         case ELFCLASSNONE: iclass = "ELFCLASSNONE"; break;
11503                         default: abort ();
11504                         }
11505
11506                       bfd_set_error (bfd_error_wrong_format);
11507                       (*_bfd_error_handler)
11508                         (_("%B: file class %s incompatible with %s"),
11509                          sub, iclass, oclass);
11510                     }
11511
11512                   goto error_return;
11513                 }
11514             }
11515         }
11516     }
11517
11518   /* Free symbol buffer if needed.  */
11519   if (!info->reduce_memory_overheads)
11520     {
11521       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
11522         if (bfd_get_flavour (sub) == bfd_target_elf_flavour
11523             && elf_tdata (sub)->symbuf)
11524           {
11525             free (elf_tdata (sub)->symbuf);
11526             elf_tdata (sub)->symbuf = NULL;
11527           }
11528     }
11529
11530   /* Output any global symbols that got converted to local in a
11531      version script or due to symbol visibility.  We do this in a
11532      separate step since ELF requires all local symbols to appear
11533      prior to any global symbols.  FIXME: We should only do this if
11534      some global symbols were, in fact, converted to become local.
11535      FIXME: Will this work correctly with the Irix 5 linker?  */
11536   eoinfo.failed = FALSE;
11537   eoinfo.flinfo = &flinfo;
11538   eoinfo.localsyms = TRUE;
11539   eoinfo.file_sym_done = FALSE;
11540   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11541   if (eoinfo.failed)
11542     return FALSE;
11543
11544   /* If backend needs to output some local symbols not present in the hash
11545      table, do it now.  */
11546   if (bed->elf_backend_output_arch_local_syms
11547       && (info->strip != strip_all || emit_relocs))
11548     {
11549       typedef int (*out_sym_func)
11550         (void *, const char *, Elf_Internal_Sym *, asection *,
11551          struct elf_link_hash_entry *);
11552
11553       if (! ((*bed->elf_backend_output_arch_local_syms)
11554              (abfd, info, &flinfo,
11555               (out_sym_func) elf_link_output_symstrtab)))
11556         return FALSE;
11557     }
11558
11559   /* That wrote out all the local symbols.  Finish up the symbol table
11560      with the global symbols. Even if we want to strip everything we
11561      can, we still need to deal with those global symbols that got
11562      converted to local in a version script.  */
11563
11564   /* The sh_info field records the index of the first non local symbol.  */
11565   symtab_hdr->sh_info = bfd_get_symcount (abfd);
11566
11567   if (dynamic
11568       && elf_hash_table (info)->dynsym != NULL
11569       && (elf_hash_table (info)->dynsym->output_section
11570           != bfd_abs_section_ptr))
11571     {
11572       Elf_Internal_Sym sym;
11573       bfd_byte *dynsym = elf_hash_table (info)->dynsym->contents;
11574       long last_local = 0;
11575
11576       /* Write out the section symbols for the output sections.  */
11577       if (bfd_link_pic (info)
11578           || elf_hash_table (info)->is_relocatable_executable)
11579         {
11580           asection *s;
11581
11582           sym.st_size = 0;
11583           sym.st_name = 0;
11584           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
11585           sym.st_other = 0;
11586           sym.st_target_internal = 0;
11587
11588           for (s = abfd->sections; s != NULL; s = s->next)
11589             {
11590               int indx;
11591               bfd_byte *dest;
11592               long dynindx;
11593
11594               dynindx = elf_section_data (s)->dynindx;
11595               if (dynindx <= 0)
11596                 continue;
11597               indx = elf_section_data (s)->this_idx;
11598               BFD_ASSERT (indx > 0);
11599               sym.st_shndx = indx;
11600               if (! check_dynsym (abfd, &sym))
11601                 return FALSE;
11602               sym.st_value = s->vma;
11603               dest = dynsym + dynindx * bed->s->sizeof_sym;
11604               if (last_local < dynindx)
11605                 last_local = dynindx;
11606               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11607             }
11608         }
11609
11610       /* Write out the local dynsyms.  */
11611       if (elf_hash_table (info)->dynlocal)
11612         {
11613           struct elf_link_local_dynamic_entry *e;
11614           for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
11615             {
11616               asection *s;
11617               bfd_byte *dest;
11618
11619               /* Copy the internal symbol and turn off visibility.
11620                  Note that we saved a word of storage and overwrote
11621                  the original st_name with the dynstr_index.  */
11622               sym = e->isym;
11623               sym.st_other &= ~ELF_ST_VISIBILITY (-1);
11624
11625               s = bfd_section_from_elf_index (e->input_bfd,
11626                                               e->isym.st_shndx);
11627               if (s != NULL)
11628                 {
11629                   sym.st_shndx =
11630                     elf_section_data (s->output_section)->this_idx;
11631                   if (! check_dynsym (abfd, &sym))
11632                     return FALSE;
11633                   sym.st_value = (s->output_section->vma
11634                                   + s->output_offset
11635                                   + e->isym.st_value);
11636                 }
11637
11638               if (last_local < e->dynindx)
11639                 last_local = e->dynindx;
11640
11641               dest = dynsym + e->dynindx * bed->s->sizeof_sym;
11642               bed->s->swap_symbol_out (abfd, &sym, dest, 0);
11643             }
11644         }
11645
11646       elf_section_data (elf_hash_table (info)->dynsym->output_section)->this_hdr.sh_info =
11647         last_local + 1;
11648     }
11649
11650   /* We get the global symbols from the hash table.  */
11651   eoinfo.failed = FALSE;
11652   eoinfo.localsyms = FALSE;
11653   eoinfo.flinfo = &flinfo;
11654   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
11655   if (eoinfo.failed)
11656     return FALSE;
11657
11658   /* If backend needs to output some symbols not present in the hash
11659      table, do it now.  */
11660   if (bed->elf_backend_output_arch_syms
11661       && (info->strip != strip_all || emit_relocs))
11662     {
11663       typedef int (*out_sym_func)
11664         (void *, const char *, Elf_Internal_Sym *, asection *,
11665          struct elf_link_hash_entry *);
11666
11667       if (! ((*bed->elf_backend_output_arch_syms)
11668              (abfd, info, &flinfo,
11669               (out_sym_func) elf_link_output_symstrtab)))
11670         return FALSE;
11671     }
11672
11673   /* Finalize the .strtab section.  */
11674   _bfd_elf_strtab_finalize (flinfo.symstrtab);
11675
11676   /* Swap out the .strtab section. */
11677   if (!elf_link_swap_symbols_out (&flinfo))
11678     return FALSE;
11679
11680   /* Now we know the size of the symtab section.  */
11681   if (bfd_get_symcount (abfd) > 0)
11682     {
11683       /* Finish up and write out the symbol string table (.strtab)
11684          section.  */
11685       Elf_Internal_Shdr *symstrtab_hdr;
11686       file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
11687
11688       symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
11689       if (symtab_shndx_hdr != NULL && symtab_shndx_hdr->sh_name != 0)
11690         {
11691           symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
11692           symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
11693           symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
11694           amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
11695           symtab_shndx_hdr->sh_size = amt;
11696
11697           off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
11698                                                            off, TRUE);
11699
11700           if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
11701               || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
11702             return FALSE;
11703         }
11704
11705       symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
11706       /* sh_name was set in prep_headers.  */
11707       symstrtab_hdr->sh_type = SHT_STRTAB;
11708       symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
11709       symstrtab_hdr->sh_addr = 0;
11710       symstrtab_hdr->sh_size = _bfd_elf_strtab_size (flinfo.symstrtab);
11711       symstrtab_hdr->sh_entsize = 0;
11712       symstrtab_hdr->sh_link = 0;
11713       symstrtab_hdr->sh_info = 0;
11714       /* sh_offset is set just below.  */
11715       symstrtab_hdr->sh_addralign = 1;
11716
11717       off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
11718                                                        off, TRUE);
11719       elf_next_file_pos (abfd) = off;
11720
11721       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
11722           || ! _bfd_elf_strtab_emit (abfd, flinfo.symstrtab))
11723         return FALSE;
11724     }
11725
11726   /* Adjust the relocs to have the correct symbol indices.  */
11727   for (o = abfd->sections; o != NULL; o = o->next)
11728     {
11729       struct bfd_elf_section_data *esdo = elf_section_data (o);
11730       bfd_boolean sort;
11731       if ((o->flags & SEC_RELOC) == 0)
11732         continue;
11733
11734       sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o);
11735       if (esdo->rel.hdr != NULL
11736           && !elf_link_adjust_relocs (abfd, &esdo->rel, sort))
11737         return FALSE;
11738       if (esdo->rela.hdr != NULL
11739           && !elf_link_adjust_relocs (abfd, &esdo->rela, sort))
11740         return FALSE;
11741
11742       /* Set the reloc_count field to 0 to prevent write_relocs from
11743          trying to swap the relocs out itself.  */
11744       o->reloc_count = 0;
11745     }
11746
11747   if (dynamic && info->combreloc && dynobj != NULL)
11748     relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11749
11750   /* If we are linking against a dynamic object, or generating a
11751      shared library, finish up the dynamic linking information.  */
11752   if (dynamic)
11753     {
11754       bfd_byte *dyncon, *dynconend;
11755
11756       /* Fix up .dynamic entries.  */
11757       o = bfd_get_linker_section (dynobj, ".dynamic");
11758       BFD_ASSERT (o != NULL);
11759
11760       dyncon = o->contents;
11761       dynconend = o->contents + o->size;
11762       for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11763         {
11764           Elf_Internal_Dyn dyn;
11765           const char *name;
11766           unsigned int type;
11767
11768           bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11769
11770           switch (dyn.d_tag)
11771             {
11772             default:
11773               continue;
11774             case DT_NULL:
11775               if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11776                 {
11777                   switch (elf_section_data (reldyn)->this_hdr.sh_type)
11778                     {
11779                     case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11780                     case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11781                     default: continue;
11782                     }
11783                   dyn.d_un.d_val = relativecount;
11784                   relativecount = 0;
11785                   break;
11786                 }
11787               continue;
11788
11789             case DT_INIT:
11790               name = info->init_function;
11791               goto get_sym;
11792             case DT_FINI:
11793               name = info->fini_function;
11794             get_sym:
11795               {
11796                 struct elf_link_hash_entry *h;
11797
11798                 h = elf_link_hash_lookup (elf_hash_table (info), name,
11799                                           FALSE, FALSE, TRUE);
11800                 if (h != NULL
11801                     && (h->root.type == bfd_link_hash_defined
11802                         || h->root.type == bfd_link_hash_defweak))
11803                   {
11804                     dyn.d_un.d_ptr = h->root.u.def.value;
11805                     o = h->root.u.def.section;
11806                     if (o->output_section != NULL)
11807                       dyn.d_un.d_ptr += (o->output_section->vma
11808                                          + o->output_offset);
11809                     else
11810                       {
11811                         /* The symbol is imported from another shared
11812                            library and does not apply to this one.  */
11813                         dyn.d_un.d_ptr = 0;
11814                       }
11815                     break;
11816                   }
11817               }
11818               continue;
11819
11820             case DT_PREINIT_ARRAYSZ:
11821               name = ".preinit_array";
11822               goto get_size;
11823             case DT_INIT_ARRAYSZ:
11824               name = ".init_array";
11825               goto get_size;
11826             case DT_FINI_ARRAYSZ:
11827               name = ".fini_array";
11828             get_size:
11829               o = bfd_get_section_by_name (abfd, name);
11830               if (o == NULL)
11831                 {
11832                   (*_bfd_error_handler)
11833                     (_("%B: could not find output section %s"), abfd, name);
11834                   goto error_return;
11835                 }
11836               if (o->size == 0)
11837                 (*_bfd_error_handler)
11838                   (_("warning: %s section has zero size"), name);
11839               dyn.d_un.d_val = o->size;
11840               break;
11841
11842             case DT_PREINIT_ARRAY:
11843               name = ".preinit_array";
11844               goto get_vma;
11845             case DT_INIT_ARRAY:
11846               name = ".init_array";
11847               goto get_vma;
11848             case DT_FINI_ARRAY:
11849               name = ".fini_array";
11850               goto get_vma;
11851
11852             case DT_HASH:
11853               name = ".hash";
11854               goto get_vma;
11855             case DT_GNU_HASH:
11856               name = ".gnu.hash";
11857               goto get_vma;
11858             case DT_STRTAB:
11859               name = ".dynstr";
11860               goto get_vma;
11861             case DT_SYMTAB:
11862               name = ".dynsym";
11863               goto get_vma;
11864             case DT_VERDEF:
11865               name = ".gnu.version_d";
11866               goto get_vma;
11867             case DT_VERNEED:
11868               name = ".gnu.version_r";
11869               goto get_vma;
11870             case DT_VERSYM:
11871               name = ".gnu.version";
11872             get_vma:
11873               o = bfd_get_section_by_name (abfd, name);
11874               if (o == NULL)
11875                 {
11876                   (*_bfd_error_handler)
11877                     (_("%B: could not find output section %s"), abfd, name);
11878                   goto error_return;
11879                 }
11880               if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11881                 {
11882                   (*_bfd_error_handler)
11883                     (_("warning: section '%s' is being made into a note"), name);
11884                   bfd_set_error (bfd_error_nonrepresentable_section);
11885                   goto error_return;
11886                 }
11887               dyn.d_un.d_ptr = o->vma;
11888               break;
11889
11890             case DT_REL:
11891             case DT_RELA:
11892             case DT_RELSZ:
11893             case DT_RELASZ:
11894               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11895                 type = SHT_REL;
11896               else
11897                 type = SHT_RELA;
11898               dyn.d_un.d_val = 0;
11899               dyn.d_un.d_ptr = 0;
11900               for (i = 1; i < elf_numsections (abfd); i++)
11901                 {
11902                   Elf_Internal_Shdr *hdr;
11903
11904                   hdr = elf_elfsections (abfd)[i];
11905                   if (hdr->sh_type == type
11906                       && (hdr->sh_flags & SHF_ALLOC) != 0)
11907                     {
11908                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11909                         dyn.d_un.d_val += hdr->sh_size;
11910                       else
11911                         {
11912                           if (dyn.d_un.d_ptr == 0
11913                               || hdr->sh_addr < dyn.d_un.d_ptr)
11914                             dyn.d_un.d_ptr = hdr->sh_addr;
11915                         }
11916                     }
11917                 }
11918               break;
11919             }
11920           bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11921         }
11922     }
11923
11924   /* If we have created any dynamic sections, then output them.  */
11925   if (dynobj != NULL)
11926     {
11927       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11928         goto error_return;
11929
11930       /* Check for DT_TEXTREL (late, in case the backend removes it).  */
11931       if (((info->warn_shared_textrel && bfd_link_pic (info))
11932            || info->error_textrel)
11933           && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
11934         {
11935           bfd_byte *dyncon, *dynconend;
11936
11937           dyncon = o->contents;
11938           dynconend = o->contents + o->size;
11939           for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11940             {
11941               Elf_Internal_Dyn dyn;
11942
11943               bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11944
11945               if (dyn.d_tag == DT_TEXTREL)
11946                 {
11947                   if (info->error_textrel)
11948                     info->callbacks->einfo
11949                       (_("%P%X: read-only segment has dynamic relocations.\n"));
11950                   else
11951                     info->callbacks->einfo
11952                       (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11953                   break;
11954                 }
11955             }
11956         }
11957
11958       for (o = dynobj->sections; o != NULL; o = o->next)
11959         {
11960           if ((o->flags & SEC_HAS_CONTENTS) == 0
11961               || o->size == 0
11962               || o->output_section == bfd_abs_section_ptr)
11963             continue;
11964           if ((o->flags & SEC_LINKER_CREATED) == 0)
11965             {
11966               /* At this point, we are only interested in sections
11967                  created by _bfd_elf_link_create_dynamic_sections.  */
11968               continue;
11969             }
11970           if (elf_hash_table (info)->stab_info.stabstr == o)
11971             continue;
11972           if (elf_hash_table (info)->eh_info.hdr_sec == o)
11973             continue;
11974           if (strcmp (o->name, ".dynstr") != 0)
11975             {
11976               if (! bfd_set_section_contents (abfd, o->output_section,
11977                                               o->contents,
11978                                               (file_ptr) o->output_offset
11979                                               * bfd_octets_per_byte (abfd),
11980                                               o->size))
11981                 goto error_return;
11982             }
11983           else
11984             {
11985               /* The contents of the .dynstr section are actually in a
11986                  stringtab.  */
11987               file_ptr off;
11988
11989               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11990               if (bfd_seek (abfd, off, SEEK_SET) != 0
11991                   || ! _bfd_elf_strtab_emit (abfd,
11992                                              elf_hash_table (info)->dynstr))
11993                 goto error_return;
11994             }
11995         }
11996     }
11997
11998   if (bfd_link_relocatable (info))
11999     {
12000       bfd_boolean failed = FALSE;
12001
12002       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
12003       if (failed)
12004         goto error_return;
12005     }
12006
12007   /* If we have optimized stabs strings, output them.  */
12008   if (elf_hash_table (info)->stab_info.stabstr != NULL)
12009     {
12010       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
12011         goto error_return;
12012     }
12013
12014   if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
12015     goto error_return;
12016
12017   elf_final_link_free (abfd, &flinfo);
12018
12019   elf_linker (abfd) = TRUE;
12020
12021   if (attr_section)
12022     {
12023       bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
12024       if (contents == NULL)
12025         return FALSE;   /* Bail out and fail.  */
12026       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
12027       bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
12028       free (contents);
12029     }
12030
12031   return TRUE;
12032
12033  error_return:
12034   elf_final_link_free (abfd, &flinfo);
12035   return FALSE;
12036 }
12037 \f
12038 /* Initialize COOKIE for input bfd ABFD.  */
12039
12040 static bfd_boolean
12041 init_reloc_cookie (struct elf_reloc_cookie *cookie,
12042                    struct bfd_link_info *info, bfd *abfd)
12043 {
12044   Elf_Internal_Shdr *symtab_hdr;
12045   const struct elf_backend_data *bed;
12046
12047   bed = get_elf_backend_data (abfd);
12048   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12049
12050   cookie->abfd = abfd;
12051   cookie->sym_hashes = elf_sym_hashes (abfd);
12052   cookie->bad_symtab = elf_bad_symtab (abfd);
12053   if (cookie->bad_symtab)
12054     {
12055       cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12056       cookie->extsymoff = 0;
12057     }
12058   else
12059     {
12060       cookie->locsymcount = symtab_hdr->sh_info;
12061       cookie->extsymoff = symtab_hdr->sh_info;
12062     }
12063
12064   if (bed->s->arch_size == 32)
12065     cookie->r_sym_shift = 8;
12066   else
12067     cookie->r_sym_shift = 32;
12068
12069   cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
12070   if (cookie->locsyms == NULL && cookie->locsymcount != 0)
12071     {
12072       cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
12073                                               cookie->locsymcount, 0,
12074                                               NULL, NULL, NULL);
12075       if (cookie->locsyms == NULL)
12076         {
12077           info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
12078           return FALSE;
12079         }
12080       if (info->keep_memory)
12081         symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
12082     }
12083   return TRUE;
12084 }
12085
12086 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
12087
12088 static void
12089 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
12090 {
12091   Elf_Internal_Shdr *symtab_hdr;
12092
12093   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12094   if (cookie->locsyms != NULL
12095       && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
12096     free (cookie->locsyms);
12097 }
12098
12099 /* Initialize the relocation information in COOKIE for input section SEC
12100    of input bfd ABFD.  */
12101
12102 static bfd_boolean
12103 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
12104                         struct bfd_link_info *info, bfd *abfd,
12105                         asection *sec)
12106 {
12107   const struct elf_backend_data *bed;
12108
12109   if (sec->reloc_count == 0)
12110     {
12111       cookie->rels = NULL;
12112       cookie->relend = NULL;
12113     }
12114   else
12115     {
12116       bed = get_elf_backend_data (abfd);
12117
12118       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12119                                                 info->keep_memory);
12120       if (cookie->rels == NULL)
12121         return FALSE;
12122       cookie->rel = cookie->rels;
12123       cookie->relend = (cookie->rels
12124                         + sec->reloc_count * bed->s->int_rels_per_ext_rel);
12125     }
12126   cookie->rel = cookie->rels;
12127   return TRUE;
12128 }
12129
12130 /* Free the memory allocated by init_reloc_cookie_rels,
12131    if appropriate.  */
12132
12133 static void
12134 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
12135                         asection *sec)
12136 {
12137   if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
12138     free (cookie->rels);
12139 }
12140
12141 /* Initialize the whole of COOKIE for input section SEC.  */
12142
12143 static bfd_boolean
12144 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
12145                                struct bfd_link_info *info,
12146                                asection *sec)
12147 {
12148   if (!init_reloc_cookie (cookie, info, sec->owner))
12149     goto error1;
12150   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
12151     goto error2;
12152   return TRUE;
12153
12154  error2:
12155   fini_reloc_cookie (cookie, sec->owner);
12156  error1:
12157   return FALSE;
12158 }
12159
12160 /* Free the memory allocated by init_reloc_cookie_for_section,
12161    if appropriate.  */
12162
12163 static void
12164 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
12165                                asection *sec)
12166 {
12167   fini_reloc_cookie_rels (cookie, sec);
12168   fini_reloc_cookie (cookie, sec->owner);
12169 }
12170 \f
12171 /* Garbage collect unused sections.  */
12172
12173 /* Default gc_mark_hook.  */
12174
12175 asection *
12176 _bfd_elf_gc_mark_hook (asection *sec,
12177                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
12178                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
12179                        struct elf_link_hash_entry *h,
12180                        Elf_Internal_Sym *sym)
12181 {
12182   if (h != NULL)
12183     {
12184       switch (h->root.type)
12185         {
12186         case bfd_link_hash_defined:
12187         case bfd_link_hash_defweak:
12188           return h->root.u.def.section;
12189
12190         case bfd_link_hash_common:
12191           return h->root.u.c.p->section;
12192
12193         default:
12194           break;
12195         }
12196     }
12197   else
12198     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
12199
12200   return NULL;
12201 }
12202
12203 /* COOKIE->rel describes a relocation against section SEC, which is
12204    a section we've decided to keep.  Return the section that contains
12205    the relocation symbol, or NULL if no section contains it.  */
12206
12207 asection *
12208 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
12209                        elf_gc_mark_hook_fn gc_mark_hook,
12210                        struct elf_reloc_cookie *cookie,
12211                        bfd_boolean *start_stop)
12212 {
12213   unsigned long r_symndx;
12214   struct elf_link_hash_entry *h;
12215
12216   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
12217   if (r_symndx == STN_UNDEF)
12218     return NULL;
12219
12220   if (r_symndx >= cookie->locsymcount
12221       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12222     {
12223       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
12224       if (h == NULL)
12225         {
12226           info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
12227                                   sec->owner);
12228           return NULL;
12229         }
12230       while (h->root.type == bfd_link_hash_indirect
12231              || h->root.type == bfd_link_hash_warning)
12232         h = (struct elf_link_hash_entry *) h->root.u.i.link;
12233       h->mark = 1;
12234       /* If this symbol is weak and there is a non-weak definition, we
12235          keep the non-weak definition because many backends put
12236          dynamic reloc info on the non-weak definition for code
12237          handling copy relocs.  */
12238       if (h->u.weakdef != NULL)
12239         h->u.weakdef->mark = 1;
12240
12241       if (start_stop != NULL
12242           && (h->root.type == bfd_link_hash_undefined
12243               || h->root.type == bfd_link_hash_undefweak))
12244         {
12245           /* To work around a glibc bug, mark all XXX input sections
12246              when there is an as yet undefined reference to __start_XXX
12247              or __stop_XXX symbols.  The linker will later define such
12248              symbols for orphan input sections that have a name
12249              representable as a C identifier.  */
12250           const char *sec_name = NULL;
12251           if (strncmp (h->root.root.string, "__start_", 8) == 0)
12252             sec_name = h->root.root.string + 8;
12253           else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
12254             sec_name = h->root.root.string + 7;
12255
12256           if (sec_name != NULL && *sec_name != '\0')
12257             {
12258               bfd *i;
12259
12260               for (i = info->input_bfds; i != NULL; i = i->link.next)
12261                 {
12262                   asection *s = bfd_get_section_by_name (i, sec_name);
12263                   if (s != NULL && !s->gc_mark)
12264                     {
12265                       *start_stop = TRUE;
12266                       return s;
12267                     }
12268                 }
12269             }
12270         }
12271
12272       return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
12273     }
12274
12275   return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
12276                           &cookie->locsyms[r_symndx]);
12277 }
12278
12279 /* COOKIE->rel describes a relocation against section SEC, which is
12280    a section we've decided to keep.  Mark the section that contains
12281    the relocation symbol.  */
12282
12283 bfd_boolean
12284 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
12285                         asection *sec,
12286                         elf_gc_mark_hook_fn gc_mark_hook,
12287                         struct elf_reloc_cookie *cookie)
12288 {
12289   asection *rsec;
12290   bfd_boolean start_stop = FALSE;
12291
12292   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie, &start_stop);
12293   while (rsec != NULL)
12294     {
12295       if (!rsec->gc_mark)
12296         {
12297           if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
12298               || (rsec->owner->flags & DYNAMIC) != 0)
12299             rsec->gc_mark = 1;
12300           else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
12301             return FALSE;
12302         }
12303       if (!start_stop)
12304         break;
12305       rsec = bfd_get_next_section_by_name (rsec->owner, rsec);
12306     }
12307   return TRUE;
12308 }
12309
12310 /* The mark phase of garbage collection.  For a given section, mark
12311    it and any sections in this section's group, and all the sections
12312    which define symbols to which it refers.  */
12313
12314 bfd_boolean
12315 _bfd_elf_gc_mark (struct bfd_link_info *info,
12316                   asection *sec,
12317                   elf_gc_mark_hook_fn gc_mark_hook)
12318 {
12319   bfd_boolean ret;
12320   asection *group_sec, *eh_frame;
12321
12322   sec->gc_mark = 1;
12323
12324   /* Mark all the sections in the group.  */
12325   group_sec = elf_section_data (sec)->next_in_group;
12326   if (group_sec && !group_sec->gc_mark)
12327     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
12328       return FALSE;
12329
12330   /* Look through the section relocs.  */
12331   ret = TRUE;
12332   eh_frame = elf_eh_frame_section (sec->owner);
12333   if ((sec->flags & SEC_RELOC) != 0
12334       && sec->reloc_count > 0
12335       && sec != eh_frame)
12336     {
12337       struct elf_reloc_cookie cookie;
12338
12339       if (!init_reloc_cookie_for_section (&cookie, info, sec))
12340         ret = FALSE;
12341       else
12342         {
12343           for (; cookie.rel < cookie.relend; cookie.rel++)
12344             if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
12345               {
12346                 ret = FALSE;
12347                 break;
12348               }
12349           fini_reloc_cookie_for_section (&cookie, sec);
12350         }
12351     }
12352
12353   if (ret && eh_frame && elf_fde_list (sec))
12354     {
12355       struct elf_reloc_cookie cookie;
12356
12357       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
12358         ret = FALSE;
12359       else
12360         {
12361           if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
12362                                       gc_mark_hook, &cookie))
12363             ret = FALSE;
12364           fini_reloc_cookie_for_section (&cookie, eh_frame);
12365         }
12366     }
12367
12368   eh_frame = elf_section_eh_frame_entry (sec);
12369   if (ret && eh_frame && !eh_frame->gc_mark)
12370     if (!_bfd_elf_gc_mark (info, eh_frame, gc_mark_hook))
12371       ret = FALSE;
12372
12373   return ret;
12374 }
12375
12376 /* Scan and mark sections in a special or debug section group.  */
12377
12378 static void
12379 _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
12380 {
12381   /* Point to first section of section group.  */
12382   asection *ssec;
12383   /* Used to iterate the section group.  */
12384   asection *msec;
12385
12386   bfd_boolean is_special_grp = TRUE;
12387   bfd_boolean is_debug_grp = TRUE;
12388
12389   /* First scan to see if group contains any section other than debug
12390      and special section.  */
12391   ssec = msec = elf_next_in_group (grp);
12392   do
12393     {
12394       if ((msec->flags & SEC_DEBUGGING) == 0)
12395         is_debug_grp = FALSE;
12396
12397       if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
12398         is_special_grp = FALSE;
12399
12400       msec = elf_next_in_group (msec);
12401     }
12402   while (msec != ssec);
12403
12404   /* If this is a pure debug section group or pure special section group,
12405      keep all sections in this group.  */
12406   if (is_debug_grp || is_special_grp)
12407     {
12408       do
12409         {
12410           msec->gc_mark = 1;
12411           msec = elf_next_in_group (msec);
12412         }
12413       while (msec != ssec);
12414     }
12415 }
12416
12417 /* Keep debug and special sections.  */
12418
12419 bfd_boolean
12420 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12421                                  elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
12422 {
12423   bfd *ibfd;
12424
12425   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12426     {
12427       asection *isec;
12428       bfd_boolean some_kept;
12429       bfd_boolean debug_frag_seen;
12430
12431       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12432         continue;
12433
12434       /* Ensure all linker created sections are kept,
12435          see if any other section is already marked,
12436          and note if we have any fragmented debug sections.  */
12437       debug_frag_seen = some_kept = FALSE;
12438       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12439         {
12440           if ((isec->flags & SEC_LINKER_CREATED) != 0)
12441             isec->gc_mark = 1;
12442           else if (isec->gc_mark)
12443             some_kept = TRUE;
12444
12445           if (debug_frag_seen == FALSE
12446               && (isec->flags & SEC_DEBUGGING)
12447               && CONST_STRNEQ (isec->name, ".debug_line."))
12448             debug_frag_seen = TRUE;
12449         }
12450
12451       /* If no section in this file will be kept, then we can
12452          toss out the debug and special sections.  */
12453       if (!some_kept)
12454         continue;
12455
12456       /* Keep debug and special sections like .comment when they are
12457          not part of a group.  Also keep section groups that contain
12458          just debug sections or special sections.  */
12459       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12460         {
12461           if ((isec->flags & SEC_GROUP) != 0)
12462             _bfd_elf_gc_mark_debug_special_section_group (isec);
12463           else if (((isec->flags & SEC_DEBUGGING) != 0
12464                     || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
12465                    && elf_next_in_group (isec) == NULL)
12466             isec->gc_mark = 1;
12467         }
12468
12469       if (! debug_frag_seen)
12470         continue;
12471
12472       /* Look for CODE sections which are going to be discarded,
12473          and find and discard any fragmented debug sections which
12474          are associated with that code section.  */
12475       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
12476         if ((isec->flags & SEC_CODE) != 0
12477             && isec->gc_mark == 0)
12478           {
12479             unsigned int ilen;
12480             asection *dsec;
12481
12482             ilen = strlen (isec->name);
12483
12484             /* Association is determined by the name of the debug section
12485                containing the name of the code section as a suffix.  For
12486                example .debug_line.text.foo is a debug section associated
12487                with .text.foo.  */
12488             for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
12489               {
12490                 unsigned int dlen;
12491
12492                 if (dsec->gc_mark == 0
12493                     || (dsec->flags & SEC_DEBUGGING) == 0)
12494                   continue;
12495
12496                 dlen = strlen (dsec->name);
12497
12498                 if (dlen > ilen
12499                     && strncmp (dsec->name + (dlen - ilen),
12500                                 isec->name, ilen) == 0)
12501                   {
12502                     dsec->gc_mark = 0;
12503                   }
12504               }
12505           }
12506     }
12507   return TRUE;
12508 }
12509
12510 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
12511
12512 struct elf_gc_sweep_symbol_info
12513 {
12514   struct bfd_link_info *info;
12515   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
12516                        bfd_boolean);
12517 };
12518
12519 static bfd_boolean
12520 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
12521 {
12522   if (!h->mark
12523       && (((h->root.type == bfd_link_hash_defined
12524             || h->root.type == bfd_link_hash_defweak)
12525            && !((h->def_regular || ELF_COMMON_DEF_P (h))
12526                 && h->root.u.def.section->gc_mark))
12527           || h->root.type == bfd_link_hash_undefined
12528           || h->root.type == bfd_link_hash_undefweak))
12529     {
12530       struct elf_gc_sweep_symbol_info *inf;
12531
12532       inf = (struct elf_gc_sweep_symbol_info *) data;
12533       (*inf->hide_symbol) (inf->info, h, TRUE);
12534       h->def_regular = 0;
12535       h->ref_regular = 0;
12536       h->ref_regular_nonweak = 0;
12537     }
12538
12539   return TRUE;
12540 }
12541
12542 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
12543
12544 typedef bfd_boolean (*gc_sweep_hook_fn)
12545   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
12546
12547 static bfd_boolean
12548 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
12549 {
12550   bfd *sub;
12551   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12552   gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
12553   unsigned long section_sym_count;
12554   struct elf_gc_sweep_symbol_info sweep_info;
12555
12556   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12557     {
12558       asection *o;
12559
12560       if (bfd_get_flavour (sub) != bfd_target_elf_flavour
12561           || !(*bed->relocs_compatible) (sub->xvec, abfd->xvec))
12562         continue;
12563
12564       for (o = sub->sections; o != NULL; o = o->next)
12565         {
12566           /* When any section in a section group is kept, we keep all
12567              sections in the section group.  If the first member of
12568              the section group is excluded, we will also exclude the
12569              group section.  */
12570           if (o->flags & SEC_GROUP)
12571             {
12572               asection *first = elf_next_in_group (o);
12573               o->gc_mark = first->gc_mark;
12574             }
12575
12576           if (o->gc_mark)
12577             continue;
12578
12579           /* Skip sweeping sections already excluded.  */
12580           if (o->flags & SEC_EXCLUDE)
12581             continue;
12582
12583           /* Since this is early in the link process, it is simple
12584              to remove a section from the output.  */
12585           o->flags |= SEC_EXCLUDE;
12586
12587           if (info->print_gc_sections && o->size != 0)
12588             _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
12589
12590           /* But we also have to update some of the relocation
12591              info we collected before.  */
12592           if (gc_sweep_hook
12593               && (o->flags & SEC_RELOC) != 0
12594               && o->reloc_count != 0
12595               && !((info->strip == strip_all || info->strip == strip_debugger)
12596                    && (o->flags & SEC_DEBUGGING) != 0)
12597               && !bfd_is_abs_section (o->output_section))
12598             {
12599               Elf_Internal_Rela *internal_relocs;
12600               bfd_boolean r;
12601
12602               internal_relocs
12603                 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
12604                                              info->keep_memory);
12605               if (internal_relocs == NULL)
12606                 return FALSE;
12607
12608               r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
12609
12610               if (elf_section_data (o)->relocs != internal_relocs)
12611                 free (internal_relocs);
12612
12613               if (!r)
12614                 return FALSE;
12615             }
12616         }
12617     }
12618
12619   /* Remove the symbols that were in the swept sections from the dynamic
12620      symbol table.  GCFIXME: Anyone know how to get them out of the
12621      static symbol table as well?  */
12622   sweep_info.info = info;
12623   sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
12624   elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
12625                           &sweep_info);
12626
12627   _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
12628   return TRUE;
12629 }
12630
12631 /* Propagate collected vtable information.  This is called through
12632    elf_link_hash_traverse.  */
12633
12634 static bfd_boolean
12635 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
12636 {
12637   /* Those that are not vtables.  */
12638   if (h->vtable == NULL || h->vtable->parent == NULL)
12639     return TRUE;
12640
12641   /* Those vtables that do not have parents, we cannot merge.  */
12642   if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
12643     return TRUE;
12644
12645   /* If we've already been done, exit.  */
12646   if (h->vtable->used && h->vtable->used[-1])
12647     return TRUE;
12648
12649   /* Make sure the parent's table is up to date.  */
12650   elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
12651
12652   if (h->vtable->used == NULL)
12653     {
12654       /* None of this table's entries were referenced.  Re-use the
12655          parent's table.  */
12656       h->vtable->used = h->vtable->parent->vtable->used;
12657       h->vtable->size = h->vtable->parent->vtable->size;
12658     }
12659   else
12660     {
12661       size_t n;
12662       bfd_boolean *cu, *pu;
12663
12664       /* Or the parent's entries into ours.  */
12665       cu = h->vtable->used;
12666       cu[-1] = TRUE;
12667       pu = h->vtable->parent->vtable->used;
12668       if (pu != NULL)
12669         {
12670           const struct elf_backend_data *bed;
12671           unsigned int log_file_align;
12672
12673           bed = get_elf_backend_data (h->root.u.def.section->owner);
12674           log_file_align = bed->s->log_file_align;
12675           n = h->vtable->parent->vtable->size >> log_file_align;
12676           while (n--)
12677             {
12678               if (*pu)
12679                 *cu = TRUE;
12680               pu++;
12681               cu++;
12682             }
12683         }
12684     }
12685
12686   return TRUE;
12687 }
12688
12689 static bfd_boolean
12690 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
12691 {
12692   asection *sec;
12693   bfd_vma hstart, hend;
12694   Elf_Internal_Rela *relstart, *relend, *rel;
12695   const struct elf_backend_data *bed;
12696   unsigned int log_file_align;
12697
12698   /* Take care of both those symbols that do not describe vtables as
12699      well as those that are not loaded.  */
12700   if (h->vtable == NULL || h->vtable->parent == NULL)
12701     return TRUE;
12702
12703   BFD_ASSERT (h->root.type == bfd_link_hash_defined
12704               || h->root.type == bfd_link_hash_defweak);
12705
12706   sec = h->root.u.def.section;
12707   hstart = h->root.u.def.value;
12708   hend = hstart + h->size;
12709
12710   relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
12711   if (!relstart)
12712     return *(bfd_boolean *) okp = FALSE;
12713   bed = get_elf_backend_data (sec->owner);
12714   log_file_align = bed->s->log_file_align;
12715
12716   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
12717
12718   for (rel = relstart; rel < relend; ++rel)
12719     if (rel->r_offset >= hstart && rel->r_offset < hend)
12720       {
12721         /* If the entry is in use, do nothing.  */
12722         if (h->vtable->used
12723             && (rel->r_offset - hstart) < h->vtable->size)
12724           {
12725             bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
12726             if (h->vtable->used[entry])
12727               continue;
12728           }
12729         /* Otherwise, kill it.  */
12730         rel->r_offset = rel->r_info = rel->r_addend = 0;
12731       }
12732
12733   return TRUE;
12734 }
12735
12736 /* Mark sections containing dynamically referenced symbols.  When
12737    building shared libraries, we must assume that any visible symbol is
12738    referenced.  */
12739
12740 bfd_boolean
12741 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
12742 {
12743   struct bfd_link_info *info = (struct bfd_link_info *) inf;
12744   struct bfd_elf_dynamic_list *d = info->dynamic_list;
12745
12746   if ((h->root.type == bfd_link_hash_defined
12747        || h->root.type == bfd_link_hash_defweak)
12748       && (h->ref_dynamic
12749           || ((h->def_regular || ELF_COMMON_DEF_P (h))
12750               && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
12751               && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
12752               && (!bfd_link_executable (info)
12753                   || info->export_dynamic
12754                   || (h->dynamic
12755                       && d != NULL
12756                       && (*d->match) (&d->head, NULL, h->root.root.string)))
12757               && (h->versioned >= versioned
12758                   || !bfd_hide_sym_by_version (info->version_info,
12759                                                h->root.root.string)))))
12760     h->root.u.def.section->flags |= SEC_KEEP;
12761
12762   return TRUE;
12763 }
12764
12765 /* Keep all sections containing symbols undefined on the command-line,
12766    and the section containing the entry symbol.  */
12767
12768 void
12769 _bfd_elf_gc_keep (struct bfd_link_info *info)
12770 {
12771   struct bfd_sym_chain *sym;
12772
12773   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
12774     {
12775       struct elf_link_hash_entry *h;
12776
12777       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
12778                                 FALSE, FALSE, FALSE);
12779
12780       if (h != NULL
12781           && (h->root.type == bfd_link_hash_defined
12782               || h->root.type == bfd_link_hash_defweak)
12783           && !bfd_is_abs_section (h->root.u.def.section))
12784         h->root.u.def.section->flags |= SEC_KEEP;
12785     }
12786 }
12787
12788 bfd_boolean
12789 bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED,
12790                                 struct bfd_link_info *info)
12791 {
12792   bfd *ibfd = info->input_bfds;
12793
12794   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12795     {
12796       asection *sec;
12797       struct elf_reloc_cookie cookie;
12798
12799       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
12800         continue;
12801
12802       if (!init_reloc_cookie (&cookie, info, ibfd))
12803         return FALSE;
12804
12805       for (sec = ibfd->sections; sec; sec = sec->next)
12806         {
12807           if (CONST_STRNEQ (bfd_section_name (ibfd, sec), ".eh_frame_entry")
12808               && init_reloc_cookie_rels (&cookie, info, ibfd, sec))
12809             {
12810               _bfd_elf_parse_eh_frame_entry (info, sec, &cookie);
12811               fini_reloc_cookie_rels (&cookie, sec);
12812             }
12813         }
12814     }
12815   return TRUE;
12816 }
12817
12818 /* Do mark and sweep of unused sections.  */
12819
12820 bfd_boolean
12821 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
12822 {
12823   bfd_boolean ok = TRUE;
12824   bfd *sub;
12825   elf_gc_mark_hook_fn gc_mark_hook;
12826   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12827   struct elf_link_hash_table *htab;
12828
12829   if (!bed->can_gc_sections
12830       || !is_elf_hash_table (info->hash))
12831     {
12832       (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12833       return TRUE;
12834     }
12835
12836   bed->gc_keep (info);
12837   htab = elf_hash_table (info);
12838
12839   /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
12840      at the .eh_frame section if we can mark the FDEs individually.  */
12841   for (sub = info->input_bfds;
12842        info->eh_frame_hdr_type != COMPACT_EH_HDR && sub != NULL;
12843        sub = sub->link.next)
12844     {
12845       asection *sec;
12846       struct elf_reloc_cookie cookie;
12847
12848       sec = bfd_get_section_by_name (sub, ".eh_frame");
12849       while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12850         {
12851           _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12852           if (elf_section_data (sec)->sec_info
12853               && (sec->flags & SEC_LINKER_CREATED) == 0)
12854             elf_eh_frame_section (sub) = sec;
12855           fini_reloc_cookie_for_section (&cookie, sec);
12856           sec = bfd_get_next_section_by_name (NULL, sec);
12857         }
12858     }
12859
12860   /* Apply transitive closure to the vtable entry usage info.  */
12861   elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
12862   if (!ok)
12863     return FALSE;
12864
12865   /* Kill the vtable relocations that were not used.  */
12866   elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
12867   if (!ok)
12868     return FALSE;
12869
12870   /* Mark dynamically referenced symbols.  */
12871   if (htab->dynamic_sections_created)
12872     elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info);
12873
12874   /* Grovel through relocs to find out who stays ...  */
12875   gc_mark_hook = bed->gc_mark_hook;
12876   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12877     {
12878       asection *o;
12879
12880       if (bfd_get_flavour (sub) != bfd_target_elf_flavour
12881           || !(*bed->relocs_compatible) (sub->xvec, abfd->xvec))
12882         continue;
12883
12884       /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12885          Also treat note sections as a root, if the section is not part
12886          of a group.  */
12887       for (o = sub->sections; o != NULL; o = o->next)
12888         if (!o->gc_mark
12889             && (o->flags & SEC_EXCLUDE) == 0
12890             && ((o->flags & SEC_KEEP) != 0
12891                 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12892                     && elf_next_in_group (o) == NULL )))
12893           {
12894             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12895               return FALSE;
12896           }
12897     }
12898
12899   /* Allow the backend to mark additional target specific sections.  */
12900   bed->gc_mark_extra_sections (info, gc_mark_hook);
12901
12902   /* ... and mark SEC_EXCLUDE for those that go.  */
12903   return elf_gc_sweep (abfd, info);
12904 }
12905 \f
12906 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
12907
12908 bfd_boolean
12909 bfd_elf_gc_record_vtinherit (bfd *abfd,
12910                              asection *sec,
12911                              struct elf_link_hash_entry *h,
12912                              bfd_vma offset)
12913 {
12914   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12915   struct elf_link_hash_entry **search, *child;
12916   bfd_size_type extsymcount;
12917   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12918
12919   /* The sh_info field of the symtab header tells us where the
12920      external symbols start.  We don't care about the local symbols at
12921      this point.  */
12922   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12923   if (!elf_bad_symtab (abfd))
12924     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12925
12926   sym_hashes = elf_sym_hashes (abfd);
12927   sym_hashes_end = sym_hashes + extsymcount;
12928
12929   /* Hunt down the child symbol, which is in this section at the same
12930      offset as the relocation.  */
12931   for (search = sym_hashes; search != sym_hashes_end; ++search)
12932     {
12933       if ((child = *search) != NULL
12934           && (child->root.type == bfd_link_hash_defined
12935               || child->root.type == bfd_link_hash_defweak)
12936           && child->root.u.def.section == sec
12937           && child->root.u.def.value == offset)
12938         goto win;
12939     }
12940
12941   (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12942                          abfd, sec, (unsigned long) offset);
12943   bfd_set_error (bfd_error_invalid_operation);
12944   return FALSE;
12945
12946  win:
12947   if (!child->vtable)
12948     {
12949       child->vtable = ((struct elf_link_virtual_table_entry *)
12950                        bfd_zalloc (abfd, sizeof (*child->vtable)));
12951       if (!child->vtable)
12952         return FALSE;
12953     }
12954   if (!h)
12955     {
12956       /* This *should* only be the absolute section.  It could potentially
12957          be that someone has defined a non-global vtable though, which
12958          would be bad.  It isn't worth paging in the local symbols to be
12959          sure though; that case should simply be handled by the assembler.  */
12960
12961       child->vtable->parent = (struct elf_link_hash_entry *) -1;
12962     }
12963   else
12964     child->vtable->parent = h;
12965
12966   return TRUE;
12967 }
12968
12969 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
12970
12971 bfd_boolean
12972 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12973                            asection *sec ATTRIBUTE_UNUSED,
12974                            struct elf_link_hash_entry *h,
12975                            bfd_vma addend)
12976 {
12977   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12978   unsigned int log_file_align = bed->s->log_file_align;
12979
12980   if (!h->vtable)
12981     {
12982       h->vtable = ((struct elf_link_virtual_table_entry *)
12983                    bfd_zalloc (abfd, sizeof (*h->vtable)));
12984       if (!h->vtable)
12985         return FALSE;
12986     }
12987
12988   if (addend >= h->vtable->size)
12989     {
12990       size_t size, bytes, file_align;
12991       bfd_boolean *ptr = h->vtable->used;
12992
12993       /* While the symbol is undefined, we have to be prepared to handle
12994          a zero size.  */
12995       file_align = 1 << log_file_align;
12996       if (h->root.type == bfd_link_hash_undefined)
12997         size = addend + file_align;
12998       else
12999         {
13000           size = h->size;
13001           if (addend >= size)
13002             {
13003               /* Oops!  We've got a reference past the defined end of
13004                  the table.  This is probably a bug -- shall we warn?  */
13005               size = addend + file_align;
13006             }
13007         }
13008       size = (size + file_align - 1) & -file_align;
13009
13010       /* Allocate one extra entry for use as a "done" flag for the
13011          consolidation pass.  */
13012       bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
13013
13014       if (ptr)
13015         {
13016           ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
13017
13018           if (ptr != NULL)
13019             {
13020               size_t oldbytes;
13021
13022               oldbytes = (((h->vtable->size >> log_file_align) + 1)
13023                           * sizeof (bfd_boolean));
13024               memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
13025             }
13026         }
13027       else
13028         ptr = (bfd_boolean *) bfd_zmalloc (bytes);
13029
13030       if (ptr == NULL)
13031         return FALSE;
13032
13033       /* And arrange for that done flag to be at index -1.  */
13034       h->vtable->used = ptr + 1;
13035       h->vtable->size = size;
13036     }
13037
13038   h->vtable->used[addend >> log_file_align] = TRUE;
13039
13040   return TRUE;
13041 }
13042
13043 /* Map an ELF section header flag to its corresponding string.  */
13044 typedef struct
13045 {
13046   char *flag_name;
13047   flagword flag_value;
13048 } elf_flags_to_name_table;
13049
13050 static elf_flags_to_name_table elf_flags_to_names [] =
13051 {
13052   { "SHF_WRITE", SHF_WRITE },
13053   { "SHF_ALLOC", SHF_ALLOC },
13054   { "SHF_EXECINSTR", SHF_EXECINSTR },
13055   { "SHF_MERGE", SHF_MERGE },
13056   { "SHF_STRINGS", SHF_STRINGS },
13057   { "SHF_INFO_LINK", SHF_INFO_LINK},
13058   { "SHF_LINK_ORDER", SHF_LINK_ORDER},
13059   { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
13060   { "SHF_GROUP", SHF_GROUP },
13061   { "SHF_TLS", SHF_TLS },
13062   { "SHF_MASKOS", SHF_MASKOS },
13063   { "SHF_EXCLUDE", SHF_EXCLUDE },
13064 };
13065
13066 /* Returns TRUE if the section is to be included, otherwise FALSE.  */
13067 bfd_boolean
13068 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
13069                               struct flag_info *flaginfo,
13070                               asection *section)
13071 {
13072   const bfd_vma sh_flags = elf_section_flags (section);
13073
13074   if (!flaginfo->flags_initialized)
13075     {
13076       bfd *obfd = info->output_bfd;
13077       const struct elf_backend_data *bed = get_elf_backend_data (obfd);
13078       struct flag_info_list *tf = flaginfo->flag_list;
13079       int with_hex = 0;
13080       int without_hex = 0;
13081
13082       for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
13083         {
13084           unsigned i;
13085           flagword (*lookup) (char *);
13086
13087           lookup = bed->elf_backend_lookup_section_flags_hook;
13088           if (lookup != NULL)
13089             {
13090               flagword hexval = (*lookup) ((char *) tf->name);
13091
13092               if (hexval != 0)
13093                 {
13094                   if (tf->with == with_flags)
13095                     with_hex |= hexval;
13096                   else if (tf->with == without_flags)
13097                     without_hex |= hexval;
13098                   tf->valid = TRUE;
13099                   continue;
13100                 }
13101             }
13102           for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
13103             {
13104               if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
13105                 {
13106                   if (tf->with == with_flags)
13107                     with_hex |= elf_flags_to_names[i].flag_value;
13108                   else if (tf->with == without_flags)
13109                     without_hex |= elf_flags_to_names[i].flag_value;
13110                   tf->valid = TRUE;
13111                   break;
13112                 }
13113             }
13114           if (!tf->valid)
13115             {
13116               info->callbacks->einfo
13117                 (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
13118               return FALSE;
13119             }
13120         }
13121       flaginfo->flags_initialized = TRUE;
13122       flaginfo->only_with_flags |= with_hex;
13123       flaginfo->not_with_flags |= without_hex;
13124     }
13125
13126   if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
13127     return FALSE;
13128
13129   if ((flaginfo->not_with_flags & sh_flags) != 0)
13130     return FALSE;
13131
13132   return TRUE;
13133 }
13134
13135 struct alloc_got_off_arg {
13136   bfd_vma gotoff;
13137   struct bfd_link_info *info;
13138 };
13139
13140 /* We need a special top-level link routine to convert got reference counts
13141    to real got offsets.  */
13142
13143 static bfd_boolean
13144 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
13145 {
13146   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
13147   bfd *obfd = gofarg->info->output_bfd;
13148   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
13149
13150   if (h->got.refcount > 0)
13151     {
13152       h->got.offset = gofarg->gotoff;
13153       gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
13154     }
13155   else
13156     h->got.offset = (bfd_vma) -1;
13157
13158   return TRUE;
13159 }
13160
13161 /* And an accompanying bit to work out final got entry offsets once
13162    we're done.  Should be called from final_link.  */
13163
13164 bfd_boolean
13165 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
13166                                         struct bfd_link_info *info)
13167 {
13168   bfd *i;
13169   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13170   bfd_vma gotoff;
13171   struct alloc_got_off_arg gofarg;
13172
13173   BFD_ASSERT (abfd == info->output_bfd);
13174
13175   if (! is_elf_hash_table (info->hash))
13176     return FALSE;
13177
13178   /* The GOT offset is relative to the .got section, but the GOT header is
13179      put into the .got.plt section, if the backend uses it.  */
13180   if (bed->want_got_plt)
13181     gotoff = 0;
13182   else
13183     gotoff = bed->got_header_size;
13184
13185   /* Do the local .got entries first.  */
13186   for (i = info->input_bfds; i; i = i->link.next)
13187     {
13188       bfd_signed_vma *local_got;
13189       bfd_size_type j, locsymcount;
13190       Elf_Internal_Shdr *symtab_hdr;
13191
13192       if (bfd_get_flavour (i) != bfd_target_elf_flavour)
13193         continue;
13194
13195       local_got = elf_local_got_refcounts (i);
13196       if (!local_got)
13197         continue;
13198
13199       symtab_hdr = &elf_tdata (i)->symtab_hdr;
13200       if (elf_bad_symtab (i))
13201         locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
13202       else
13203         locsymcount = symtab_hdr->sh_info;
13204
13205       for (j = 0; j < locsymcount; ++j)
13206         {
13207           if (local_got[j] > 0)
13208             {
13209               local_got[j] = gotoff;
13210               gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
13211             }
13212           else
13213             local_got[j] = (bfd_vma) -1;
13214         }
13215     }
13216
13217   /* Then the global .got entries.  .plt refcounts are handled by
13218      adjust_dynamic_symbol  */
13219   gofarg.gotoff = gotoff;
13220   gofarg.info = info;
13221   elf_link_hash_traverse (elf_hash_table (info),
13222                           elf_gc_allocate_got_offsets,
13223                           &gofarg);
13224   return TRUE;
13225 }
13226
13227 /* Many folk need no more in the way of final link than this, once
13228    got entry reference counting is enabled.  */
13229
13230 bfd_boolean
13231 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
13232 {
13233   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
13234     return FALSE;
13235
13236   /* Invoke the regular ELF backend linker to do all the work.  */
13237   return bfd_elf_final_link (abfd, info);
13238 }
13239
13240 bfd_boolean
13241 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
13242 {
13243   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
13244
13245   if (rcookie->bad_symtab)
13246     rcookie->rel = rcookie->rels;
13247
13248   for (; rcookie->rel < rcookie->relend; rcookie->rel++)
13249     {
13250       unsigned long r_symndx;
13251
13252       if (! rcookie->bad_symtab)
13253         if (rcookie->rel->r_offset > offset)
13254           return FALSE;
13255       if (rcookie->rel->r_offset != offset)
13256         continue;
13257
13258       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
13259       if (r_symndx == STN_UNDEF)
13260         return TRUE;
13261
13262       if (r_symndx >= rcookie->locsymcount
13263           || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
13264         {
13265           struct elf_link_hash_entry *h;
13266
13267           h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
13268
13269           while (h->root.type == bfd_link_hash_indirect
13270                  || h->root.type == bfd_link_hash_warning)
13271             h = (struct elf_link_hash_entry *) h->root.u.i.link;
13272
13273           if ((h->root.type == bfd_link_hash_defined
13274                || h->root.type == bfd_link_hash_defweak)
13275               && (h->root.u.def.section->owner != rcookie->abfd
13276                   || h->root.u.def.section->kept_section != NULL
13277                   || discarded_section (h->root.u.def.section)))
13278             return TRUE;
13279         }
13280       else
13281         {
13282           /* It's not a relocation against a global symbol,
13283              but it could be a relocation against a local
13284              symbol for a discarded section.  */
13285           asection *isec;
13286           Elf_Internal_Sym *isym;
13287
13288           /* Need to: get the symbol; get the section.  */
13289           isym = &rcookie->locsyms[r_symndx];
13290           isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
13291           if (isec != NULL
13292               && (isec->kept_section != NULL
13293                   || discarded_section (isec)))
13294             return TRUE;
13295         }
13296       return FALSE;
13297     }
13298   return FALSE;
13299 }
13300
13301 /* Discard unneeded references to discarded sections.
13302    Returns -1 on error, 1 if any section's size was changed, 0 if
13303    nothing changed.  This function assumes that the relocations are in
13304    sorted order, which is true for all known assemblers.  */
13305
13306 int
13307 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
13308 {
13309   struct elf_reloc_cookie cookie;
13310   asection *o;
13311   bfd *abfd;
13312   int changed = 0;
13313
13314   if (info->traditional_format
13315       || !is_elf_hash_table (info->hash))
13316     return 0;
13317
13318   o = bfd_get_section_by_name (output_bfd, ".stab");
13319   if (o != NULL)
13320     {
13321       asection *i;
13322
13323       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13324         {
13325           if (i->size == 0
13326               || i->reloc_count == 0
13327               || i->sec_info_type != SEC_INFO_TYPE_STABS)
13328             continue;
13329
13330           abfd = i->owner;
13331           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
13332             continue;
13333
13334           if (!init_reloc_cookie_for_section (&cookie, info, i))
13335             return -1;
13336
13337           if (_bfd_discard_section_stabs (abfd, i,
13338                                           elf_section_data (i)->sec_info,
13339                                           bfd_elf_reloc_symbol_deleted_p,
13340                                           &cookie))
13341             changed = 1;
13342
13343           fini_reloc_cookie_for_section (&cookie, i);
13344         }
13345     }
13346
13347   o = NULL;
13348   if (info->eh_frame_hdr_type != COMPACT_EH_HDR)
13349     o = bfd_get_section_by_name (output_bfd, ".eh_frame");
13350   if (o != NULL)
13351     {
13352       asection *i;
13353
13354       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
13355         {
13356           if (i->size == 0)
13357             continue;
13358
13359           abfd = i->owner;
13360           if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
13361             continue;
13362
13363           if (!init_reloc_cookie_for_section (&cookie, info, i))
13364             return -1;
13365
13366           _bfd_elf_parse_eh_frame (abfd, info, i, &cookie);
13367           if (_bfd_elf_discard_section_eh_frame (abfd, info, i,
13368                                                  bfd_elf_reloc_symbol_deleted_p,
13369                                                  &cookie))
13370             changed = 1;
13371
13372           fini_reloc_cookie_for_section (&cookie, i);
13373         }
13374     }
13375
13376   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
13377     {
13378       const struct elf_backend_data *bed;
13379
13380       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
13381         continue;
13382
13383       bed = get_elf_backend_data (abfd);
13384
13385       if (bed->elf_backend_discard_info != NULL)
13386         {
13387           if (!init_reloc_cookie (&cookie, info, abfd))
13388             return -1;
13389
13390           if ((*bed->elf_backend_discard_info) (abfd, &cookie, info))
13391             changed = 1;
13392
13393           fini_reloc_cookie (&cookie, abfd);
13394         }
13395     }
13396
13397   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
13398     _bfd_elf_end_eh_frame_parsing (info);
13399
13400   if (info->eh_frame_hdr_type
13401       && !bfd_link_relocatable (info)
13402       && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
13403     changed = 1;
13404
13405   return changed;
13406 }
13407
13408 bfd_boolean
13409 _bfd_elf_section_already_linked (bfd *abfd,
13410                                  asection *sec,
13411                                  struct bfd_link_info *info)
13412 {
13413   flagword flags;
13414   const char *name, *key;
13415   struct bfd_section_already_linked *l;
13416   struct bfd_section_already_linked_hash_entry *already_linked_list;
13417
13418   if (sec->output_section == bfd_abs_section_ptr)
13419     return FALSE;
13420
13421   flags = sec->flags;
13422
13423   /* Return if it isn't a linkonce section.  A comdat group section
13424      also has SEC_LINK_ONCE set.  */
13425   if ((flags & SEC_LINK_ONCE) == 0)
13426     return FALSE;
13427
13428   /* Don't put group member sections on our list of already linked
13429      sections.  They are handled as a group via their group section.  */
13430   if (elf_sec_group (sec) != NULL)
13431     return FALSE;
13432
13433   /* For a SHT_GROUP section, use the group signature as the key.  */
13434   name = sec->name;
13435   if ((flags & SEC_GROUP) != 0
13436       && elf_next_in_group (sec) != NULL
13437       && elf_group_name (elf_next_in_group (sec)) != NULL)
13438     key = elf_group_name (elf_next_in_group (sec));
13439   else
13440     {
13441       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
13442       if (CONST_STRNEQ (name, ".gnu.linkonce.")
13443           && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
13444         key++;
13445       else
13446         /* Must be a user linkonce section that doesn't follow gcc's
13447            naming convention.  In this case we won't be matching
13448            single member groups.  */
13449         key = name;
13450     }
13451
13452   already_linked_list = bfd_section_already_linked_table_lookup (key);
13453
13454   for (l = already_linked_list->entry; l != NULL; l = l->next)
13455     {
13456       /* We may have 2 different types of sections on the list: group
13457          sections with a signature of <key> (<key> is some string),
13458          and linkonce sections named .gnu.linkonce.<type>.<key>.
13459          Match like sections.  LTO plugin sections are an exception.
13460          They are always named .gnu.linkonce.t.<key> and match either
13461          type of section.  */
13462       if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
13463            && ((flags & SEC_GROUP) != 0
13464                || strcmp (name, l->sec->name) == 0))
13465           || (l->sec->owner->flags & BFD_PLUGIN) != 0)
13466         {
13467           /* The section has already been linked.  See if we should
13468              issue a warning.  */
13469           if (!_bfd_handle_already_linked (sec, l, info))
13470             return FALSE;
13471
13472           if (flags & SEC_GROUP)
13473             {
13474               asection *first = elf_next_in_group (sec);
13475               asection *s = first;
13476
13477               while (s != NULL)
13478                 {
13479                   s->output_section = bfd_abs_section_ptr;
13480                   /* Record which group discards it.  */
13481                   s->kept_section = l->sec;
13482                   s = elf_next_in_group (s);
13483                   /* These lists are circular.  */
13484                   if (s == first)
13485                     break;
13486                 }
13487             }
13488
13489           return TRUE;
13490         }
13491     }
13492
13493   /* A single member comdat group section may be discarded by a
13494      linkonce section and vice versa.  */
13495   if ((flags & SEC_GROUP) != 0)
13496     {
13497       asection *first = elf_next_in_group (sec);
13498
13499       if (first != NULL && elf_next_in_group (first) == first)
13500         /* Check this single member group against linkonce sections.  */
13501         for (l = already_linked_list->entry; l != NULL; l = l->next)
13502           if ((l->sec->flags & SEC_GROUP) == 0
13503               && bfd_elf_match_symbols_in_sections (l->sec, first, info))
13504             {
13505               first->output_section = bfd_abs_section_ptr;
13506               first->kept_section = l->sec;
13507               sec->output_section = bfd_abs_section_ptr;
13508               break;
13509             }
13510     }
13511   else
13512     /* Check this linkonce section against single member groups.  */
13513     for (l = already_linked_list->entry; l != NULL; l = l->next)
13514       if (l->sec->flags & SEC_GROUP)
13515         {
13516           asection *first = elf_next_in_group (l->sec);
13517
13518           if (first != NULL
13519               && elf_next_in_group (first) == first
13520               && bfd_elf_match_symbols_in_sections (first, sec, info))
13521             {
13522               sec->output_section = bfd_abs_section_ptr;
13523               sec->kept_section = first;
13524               break;
13525             }
13526         }
13527
13528   /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
13529      referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
13530      specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
13531      prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
13532      matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
13533      but its `.gnu.linkonce.t.F' is discarded means we chose one-only
13534      `.gnu.linkonce.t.F' section from a different bfd not requiring any
13535      `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
13536      The reverse order cannot happen as there is never a bfd with only the
13537      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
13538      matter as here were are looking only for cross-bfd sections.  */
13539
13540   if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
13541     for (l = already_linked_list->entry; l != NULL; l = l->next)
13542       if ((l->sec->flags & SEC_GROUP) == 0
13543           && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
13544         {
13545           if (abfd != l->sec->owner)
13546             sec->output_section = bfd_abs_section_ptr;
13547           break;
13548         }
13549
13550   /* This is the first section with this name.  Record it.  */
13551   if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
13552     info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
13553   return sec->output_section == bfd_abs_section_ptr;
13554 }
13555
13556 bfd_boolean
13557 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
13558 {
13559   return sym->st_shndx == SHN_COMMON;
13560 }
13561
13562 unsigned int
13563 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
13564 {
13565   return SHN_COMMON;
13566 }
13567
13568 asection *
13569 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
13570 {
13571   return bfd_com_section_ptr;
13572 }
13573
13574 bfd_vma
13575 _bfd_elf_default_got_elt_size (bfd *abfd,
13576                                struct bfd_link_info *info ATTRIBUTE_UNUSED,
13577                                struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
13578                                bfd *ibfd ATTRIBUTE_UNUSED,
13579                                unsigned long symndx ATTRIBUTE_UNUSED)
13580 {
13581   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13582   return bed->s->arch_size / 8;
13583 }
13584
13585 /* Routines to support the creation of dynamic relocs.  */
13586
13587 /* Returns the name of the dynamic reloc section associated with SEC.  */
13588
13589 static const char *
13590 get_dynamic_reloc_section_name (bfd *       abfd,
13591                                 asection *  sec,
13592                                 bfd_boolean is_rela)
13593 {
13594   char *name;
13595   const char *old_name = bfd_get_section_name (NULL, sec);
13596   const char *prefix = is_rela ? ".rela" : ".rel";
13597
13598   if (old_name == NULL)
13599     return NULL;
13600
13601   name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
13602   sprintf (name, "%s%s", prefix, old_name);
13603
13604   return name;
13605 }
13606
13607 /* Returns the dynamic reloc section associated with SEC.
13608    If necessary compute the name of the dynamic reloc section based
13609    on SEC's name (looked up in ABFD's string table) and the setting
13610    of IS_RELA.  */
13611
13612 asection *
13613 _bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
13614                                     asection *  sec,
13615                                     bfd_boolean is_rela)
13616 {
13617   asection * reloc_sec = elf_section_data (sec)->sreloc;
13618
13619   if (reloc_sec == NULL)
13620     {
13621       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13622
13623       if (name != NULL)
13624         {
13625           reloc_sec = bfd_get_linker_section (abfd, name);
13626
13627           if (reloc_sec != NULL)
13628             elf_section_data (sec)->sreloc = reloc_sec;
13629         }
13630     }
13631
13632   return reloc_sec;
13633 }
13634
13635 /* Returns the dynamic reloc section associated with SEC.  If the
13636    section does not exist it is created and attached to the DYNOBJ
13637    bfd and stored in the SRELOC field of SEC's elf_section_data
13638    structure.
13639
13640    ALIGNMENT is the alignment for the newly created section and
13641    IS_RELA defines whether the name should be .rela.<SEC's name>
13642    or .rel.<SEC's name>.  The section name is looked up in the
13643    string table associated with ABFD.  */
13644
13645 asection *
13646 _bfd_elf_make_dynamic_reloc_section (asection *sec,
13647                                      bfd *dynobj,
13648                                      unsigned int alignment,
13649                                      bfd *abfd,
13650                                      bfd_boolean is_rela)
13651 {
13652   asection * reloc_sec = elf_section_data (sec)->sreloc;
13653
13654   if (reloc_sec == NULL)
13655     {
13656       const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
13657
13658       if (name == NULL)
13659         return NULL;
13660
13661       reloc_sec = bfd_get_linker_section (dynobj, name);
13662
13663       if (reloc_sec == NULL)
13664         {
13665           flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY
13666                             | SEC_IN_MEMORY | SEC_LINKER_CREATED);
13667           if ((sec->flags & SEC_ALLOC) != 0)
13668             flags |= SEC_ALLOC | SEC_LOAD;
13669
13670           reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
13671           if (reloc_sec != NULL)
13672             {
13673               /* _bfd_elf_get_sec_type_attr chooses a section type by
13674                  name.  Override as it may be wrong, eg. for a user
13675                  section named "auto" we'll get ".relauto" which is
13676                  seen to be a .rela section.  */
13677               elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
13678               if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
13679                 reloc_sec = NULL;
13680             }
13681         }
13682
13683       elf_section_data (sec)->sreloc = reloc_sec;
13684     }
13685
13686   return reloc_sec;
13687 }
13688
13689 /* Copy the ELF symbol type and other attributes for a linker script
13690    assignment from HSRC to HDEST.  Generally this should be treated as
13691    if we found a strong non-dynamic definition for HDEST (except that
13692    ld ignores multiple definition errors).  */
13693 void
13694 _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
13695                                      struct bfd_link_hash_entry *hdest,
13696                                      struct bfd_link_hash_entry *hsrc)
13697 {
13698   struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest;
13699   struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc;
13700   Elf_Internal_Sym isym;
13701
13702   ehdest->type = ehsrc->type;
13703   ehdest->target_internal = ehsrc->target_internal;
13704
13705   isym.st_other = ehsrc->other;
13706   elf_merge_st_other (abfd, ehdest, &isym, NULL, TRUE, FALSE);
13707 }
13708
13709 /* Append a RELA relocation REL to section S in BFD.  */
13710
13711 void
13712 elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13713 {
13714   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13715   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
13716   BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
13717   bed->s->swap_reloca_out (abfd, rel, loc);
13718 }
13719
13720 /* Append a REL relocation REL to section S in BFD.  */
13721
13722 void
13723 elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
13724 {
13725   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13726   bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
13727   BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
13728   bed->s->swap_reloc_out (abfd, rel, loc);
13729 }