Prevent a buffer overrun error when attempting to parse a corrupt ELF file.
[external/binutils.git] / bfd / elf.c
1 /* ELF executable support for BFD.
2
3    Copyright (C) 1993-2019 Free Software Foundation, Inc.
4
5    This file is part of BFD, the Binary File Descriptor library.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22
23 /*
24 SECTION
25         ELF backends
26
27         BFD support for ELF formats is being worked on.
28         Currently, the best supported back ends are for sparc and i386
29         (running svr4 or Solaris 2).
30
31         Documentation of the internals of the support code still needs
32         to be written.  The code is changing quickly enough that we
33         haven't bothered yet.  */
34
35 /* For sparc64-cross-sparc32.  */
36 #define _SYSCALL32
37 #include "sysdep.h"
38 #include <limits.h>
39 #include "bfd.h"
40 #include "bfdlink.h"
41 #include "libbfd.h"
42 #define ARCH_SIZE 0
43 #include "elf-bfd.h"
44 #include "libiberty.h"
45 #include "safe-ctype.h"
46 #include "elf-linux-core.h"
47
48 #ifdef CORE_HEADER
49 #include CORE_HEADER
50 #endif
51
52 static int elf_sort_sections (const void *, const void *);
53 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
54 static bfd_boolean prep_headers (bfd *);
55 static bfd_boolean swap_out_syms (bfd *, struct elf_strtab_hash **, int) ;
56 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type,
57                                    size_t align) ;
58 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
59                                     file_ptr offset, size_t align);
60
61 /* Swap version information in and out.  The version information is
62    currently size independent.  If that ever changes, this code will
63    need to move into elfcode.h.  */
64
65 /* Swap in a Verdef structure.  */
66
67 void
68 _bfd_elf_swap_verdef_in (bfd *abfd,
69                          const Elf_External_Verdef *src,
70                          Elf_Internal_Verdef *dst)
71 {
72   dst->vd_version = H_GET_16 (abfd, src->vd_version);
73   dst->vd_flags   = H_GET_16 (abfd, src->vd_flags);
74   dst->vd_ndx     = H_GET_16 (abfd, src->vd_ndx);
75   dst->vd_cnt     = H_GET_16 (abfd, src->vd_cnt);
76   dst->vd_hash    = H_GET_32 (abfd, src->vd_hash);
77   dst->vd_aux     = H_GET_32 (abfd, src->vd_aux);
78   dst->vd_next    = H_GET_32 (abfd, src->vd_next);
79 }
80
81 /* Swap out a Verdef structure.  */
82
83 void
84 _bfd_elf_swap_verdef_out (bfd *abfd,
85                           const Elf_Internal_Verdef *src,
86                           Elf_External_Verdef *dst)
87 {
88   H_PUT_16 (abfd, src->vd_version, dst->vd_version);
89   H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
90   H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
91   H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
92   H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
93   H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
94   H_PUT_32 (abfd, src->vd_next, dst->vd_next);
95 }
96
97 /* Swap in a Verdaux structure.  */
98
99 void
100 _bfd_elf_swap_verdaux_in (bfd *abfd,
101                           const Elf_External_Verdaux *src,
102                           Elf_Internal_Verdaux *dst)
103 {
104   dst->vda_name = H_GET_32 (abfd, src->vda_name);
105   dst->vda_next = H_GET_32 (abfd, src->vda_next);
106 }
107
108 /* Swap out a Verdaux structure.  */
109
110 void
111 _bfd_elf_swap_verdaux_out (bfd *abfd,
112                            const Elf_Internal_Verdaux *src,
113                            Elf_External_Verdaux *dst)
114 {
115   H_PUT_32 (abfd, src->vda_name, dst->vda_name);
116   H_PUT_32 (abfd, src->vda_next, dst->vda_next);
117 }
118
119 /* Swap in a Verneed structure.  */
120
121 void
122 _bfd_elf_swap_verneed_in (bfd *abfd,
123                           const Elf_External_Verneed *src,
124                           Elf_Internal_Verneed *dst)
125 {
126   dst->vn_version = H_GET_16 (abfd, src->vn_version);
127   dst->vn_cnt     = H_GET_16 (abfd, src->vn_cnt);
128   dst->vn_file    = H_GET_32 (abfd, src->vn_file);
129   dst->vn_aux     = H_GET_32 (abfd, src->vn_aux);
130   dst->vn_next    = H_GET_32 (abfd, src->vn_next);
131 }
132
133 /* Swap out a Verneed structure.  */
134
135 void
136 _bfd_elf_swap_verneed_out (bfd *abfd,
137                            const Elf_Internal_Verneed *src,
138                            Elf_External_Verneed *dst)
139 {
140   H_PUT_16 (abfd, src->vn_version, dst->vn_version);
141   H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
142   H_PUT_32 (abfd, src->vn_file, dst->vn_file);
143   H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
144   H_PUT_32 (abfd, src->vn_next, dst->vn_next);
145 }
146
147 /* Swap in a Vernaux structure.  */
148
149 void
150 _bfd_elf_swap_vernaux_in (bfd *abfd,
151                           const Elf_External_Vernaux *src,
152                           Elf_Internal_Vernaux *dst)
153 {
154   dst->vna_hash  = H_GET_32 (abfd, src->vna_hash);
155   dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
156   dst->vna_other = H_GET_16 (abfd, src->vna_other);
157   dst->vna_name  = H_GET_32 (abfd, src->vna_name);
158   dst->vna_next  = H_GET_32 (abfd, src->vna_next);
159 }
160
161 /* Swap out a Vernaux structure.  */
162
163 void
164 _bfd_elf_swap_vernaux_out (bfd *abfd,
165                            const Elf_Internal_Vernaux *src,
166                            Elf_External_Vernaux *dst)
167 {
168   H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
169   H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
170   H_PUT_16 (abfd, src->vna_other, dst->vna_other);
171   H_PUT_32 (abfd, src->vna_name, dst->vna_name);
172   H_PUT_32 (abfd, src->vna_next, dst->vna_next);
173 }
174
175 /* Swap in a Versym structure.  */
176
177 void
178 _bfd_elf_swap_versym_in (bfd *abfd,
179                          const Elf_External_Versym *src,
180                          Elf_Internal_Versym *dst)
181 {
182   dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
183 }
184
185 /* Swap out a Versym structure.  */
186
187 void
188 _bfd_elf_swap_versym_out (bfd *abfd,
189                           const Elf_Internal_Versym *src,
190                           Elf_External_Versym *dst)
191 {
192   H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
193 }
194
195 /* Standard ELF hash function.  Do not change this function; you will
196    cause invalid hash tables to be generated.  */
197
198 unsigned long
199 bfd_elf_hash (const char *namearg)
200 {
201   const unsigned char *name = (const unsigned char *) namearg;
202   unsigned long h = 0;
203   unsigned long g;
204   int ch;
205
206   while ((ch = *name++) != '\0')
207     {
208       h = (h << 4) + ch;
209       if ((g = (h & 0xf0000000)) != 0)
210         {
211           h ^= g >> 24;
212           /* The ELF ABI says `h &= ~g', but this is equivalent in
213              this case and on some machines one insn instead of two.  */
214           h ^= g;
215         }
216     }
217   return h & 0xffffffff;
218 }
219
220 /* DT_GNU_HASH hash function.  Do not change this function; you will
221    cause invalid hash tables to be generated.  */
222
223 unsigned long
224 bfd_elf_gnu_hash (const char *namearg)
225 {
226   const unsigned char *name = (const unsigned char *) namearg;
227   unsigned long h = 5381;
228   unsigned char ch;
229
230   while ((ch = *name++) != '\0')
231     h = (h << 5) + h + ch;
232   return h & 0xffffffff;
233 }
234
235 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
236    the object_id field of an elf_obj_tdata field set to OBJECT_ID.  */
237 bfd_boolean
238 bfd_elf_allocate_object (bfd *abfd,
239                          size_t object_size,
240                          enum elf_target_id object_id)
241 {
242   BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
243   abfd->tdata.any = bfd_zalloc (abfd, object_size);
244   if (abfd->tdata.any == NULL)
245     return FALSE;
246
247   elf_object_id (abfd) = object_id;
248   if (abfd->direction != read_direction)
249     {
250       struct output_elf_obj_tdata *o = bfd_zalloc (abfd, sizeof *o);
251       if (o == NULL)
252         return FALSE;
253       elf_tdata (abfd)->o = o;
254       elf_program_header_size (abfd) = (bfd_size_type) -1;
255     }
256   return TRUE;
257 }
258
259
260 bfd_boolean
261 bfd_elf_make_object (bfd *abfd)
262 {
263   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
264   return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
265                                   bed->target_id);
266 }
267
268 bfd_boolean
269 bfd_elf_mkcorefile (bfd *abfd)
270 {
271   /* I think this can be done just like an object file.  */
272   if (!abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd))
273     return FALSE;
274   elf_tdata (abfd)->core = bfd_zalloc (abfd, sizeof (*elf_tdata (abfd)->core));
275   return elf_tdata (abfd)->core != NULL;
276 }
277
278 static char *
279 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
280 {
281   Elf_Internal_Shdr **i_shdrp;
282   bfd_byte *shstrtab = NULL;
283   file_ptr offset;
284   bfd_size_type shstrtabsize;
285
286   i_shdrp = elf_elfsections (abfd);
287   if (i_shdrp == 0
288       || shindex >= elf_numsections (abfd)
289       || i_shdrp[shindex] == 0)
290     return NULL;
291
292   shstrtab = i_shdrp[shindex]->contents;
293   if (shstrtab == NULL)
294     {
295       /* No cached one, attempt to read, and cache what we read.  */
296       offset = i_shdrp[shindex]->sh_offset;
297       shstrtabsize = i_shdrp[shindex]->sh_size;
298
299       /* Allocate and clear an extra byte at the end, to prevent crashes
300          in case the string table is not terminated.  */
301       if (shstrtabsize + 1 <= 1
302           || shstrtabsize > bfd_get_file_size (abfd)
303           || bfd_seek (abfd, offset, SEEK_SET) != 0
304           || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL)
305         shstrtab = NULL;
306       else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
307         {
308           if (bfd_get_error () != bfd_error_system_call)
309             bfd_set_error (bfd_error_file_truncated);
310           bfd_release (abfd, shstrtab);
311           shstrtab = NULL;
312           /* Once we've failed to read it, make sure we don't keep
313              trying.  Otherwise, we'll keep allocating space for
314              the string table over and over.  */
315           i_shdrp[shindex]->sh_size = 0;
316         }
317       else
318         shstrtab[shstrtabsize] = '\0';
319       i_shdrp[shindex]->contents = shstrtab;
320     }
321   return (char *) shstrtab;
322 }
323
324 char *
325 bfd_elf_string_from_elf_section (bfd *abfd,
326                                  unsigned int shindex,
327                                  unsigned int strindex)
328 {
329   Elf_Internal_Shdr *hdr;
330
331   if (strindex == 0)
332     return "";
333
334   if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
335     return NULL;
336
337   hdr = elf_elfsections (abfd)[shindex];
338
339   if (hdr->contents == NULL)
340     {
341       if (hdr->sh_type != SHT_STRTAB && hdr->sh_type < SHT_LOOS)
342         {
343           /* PR 17512: file: f057ec89.  */
344           /* xgettext:c-format */
345           _bfd_error_handler (_("%pB: attempt to load strings from"
346                                 " a non-string section (number %d)"),
347                               abfd, shindex);
348           return NULL;
349         }
350
351       if (bfd_elf_get_str_section (abfd, shindex) == NULL)
352         return NULL;
353     }
354   else
355     {
356       /* PR 24273: The string section's contents may have already
357          been loaded elsewhere, eg because a corrupt file has the
358          string section index in the ELF header pointing at a group
359          section.  So be paranoid, and test that the last byte of
360          the section is zero.  */
361       if (hdr->sh_size == 0 || hdr->contents[hdr->sh_size - 1] != 0)
362         return NULL;
363     }
364
365   if (strindex >= hdr->sh_size)
366     {
367       unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
368       _bfd_error_handler
369         /* xgettext:c-format */
370         (_("%pB: invalid string offset %u >= %" PRIu64 " for section `%s'"),
371          abfd, strindex, (uint64_t) hdr->sh_size,
372          (shindex == shstrndx && strindex == hdr->sh_name
373           ? ".shstrtab"
374           : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
375       return NULL;
376     }
377
378   return ((char *) hdr->contents) + strindex;
379 }
380
381 /* Read and convert symbols to internal format.
382    SYMCOUNT specifies the number of symbols to read, starting from
383    symbol SYMOFFSET.  If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
384    are non-NULL, they are used to store the internal symbols, external
385    symbols, and symbol section index extensions, respectively.
386    Returns a pointer to the internal symbol buffer (malloced if necessary)
387    or NULL if there were no symbols or some kind of problem.  */
388
389 Elf_Internal_Sym *
390 bfd_elf_get_elf_syms (bfd *ibfd,
391                       Elf_Internal_Shdr *symtab_hdr,
392                       size_t symcount,
393                       size_t symoffset,
394                       Elf_Internal_Sym *intsym_buf,
395                       void *extsym_buf,
396                       Elf_External_Sym_Shndx *extshndx_buf)
397 {
398   Elf_Internal_Shdr *shndx_hdr;
399   void *alloc_ext;
400   const bfd_byte *esym;
401   Elf_External_Sym_Shndx *alloc_extshndx;
402   Elf_External_Sym_Shndx *shndx;
403   Elf_Internal_Sym *alloc_intsym;
404   Elf_Internal_Sym *isym;
405   Elf_Internal_Sym *isymend;
406   const struct elf_backend_data *bed;
407   size_t extsym_size;
408   bfd_size_type amt;
409   file_ptr pos;
410
411   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
412     abort ();
413
414   if (symcount == 0)
415     return intsym_buf;
416
417   /* Normal syms might have section extension entries.  */
418   shndx_hdr = NULL;
419   if (elf_symtab_shndx_list (ibfd) != NULL)
420     {
421       elf_section_list * entry;
422       Elf_Internal_Shdr **sections = elf_elfsections (ibfd);
423
424       /* Find an index section that is linked to this symtab section.  */
425       for (entry = elf_symtab_shndx_list (ibfd); entry != NULL; entry = entry->next)
426         {
427           /* PR 20063.  */
428           if (entry->hdr.sh_link >= elf_numsections (ibfd))
429             continue;
430
431           if (sections[entry->hdr.sh_link] == symtab_hdr)
432             {
433               shndx_hdr = & entry->hdr;
434               break;
435             };
436         }
437
438       if (shndx_hdr == NULL)
439         {
440           if (symtab_hdr == & elf_symtab_hdr (ibfd))
441             /* Not really accurate, but this was how the old code used to work.  */
442             shndx_hdr = & elf_symtab_shndx_list (ibfd)->hdr;
443           /* Otherwise we do nothing.  The assumption is that
444              the index table will not be needed.  */
445         }
446     }
447
448   /* Read the symbols.  */
449   alloc_ext = NULL;
450   alloc_extshndx = NULL;
451   alloc_intsym = NULL;
452   bed = get_elf_backend_data (ibfd);
453   extsym_size = bed->s->sizeof_sym;
454   amt = (bfd_size_type) symcount * extsym_size;
455   pos = symtab_hdr->sh_offset + symoffset * extsym_size;
456   if (extsym_buf == NULL)
457     {
458       alloc_ext = bfd_malloc2 (symcount, extsym_size);
459       extsym_buf = alloc_ext;
460     }
461   if (extsym_buf == NULL
462       || bfd_seek (ibfd, pos, SEEK_SET) != 0
463       || bfd_bread (extsym_buf, amt, ibfd) != amt)
464     {
465       intsym_buf = NULL;
466       goto out;
467     }
468
469   if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
470     extshndx_buf = NULL;
471   else
472     {
473       amt = (bfd_size_type) symcount * sizeof (Elf_External_Sym_Shndx);
474       pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
475       if (extshndx_buf == NULL)
476         {
477           alloc_extshndx = (Elf_External_Sym_Shndx *)
478               bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
479           extshndx_buf = alloc_extshndx;
480         }
481       if (extshndx_buf == NULL
482           || bfd_seek (ibfd, pos, SEEK_SET) != 0
483           || bfd_bread (extshndx_buf, amt, ibfd) != amt)
484         {
485           intsym_buf = NULL;
486           goto out;
487         }
488     }
489
490   if (intsym_buf == NULL)
491     {
492       alloc_intsym = (Elf_Internal_Sym *)
493           bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
494       intsym_buf = alloc_intsym;
495       if (intsym_buf == NULL)
496         goto out;
497     }
498
499   /* Convert the symbols to internal form.  */
500   isymend = intsym_buf + symcount;
501   for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
502            shndx = extshndx_buf;
503        isym < isymend;
504        esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
505     if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
506       {
507         symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
508         /* xgettext:c-format */
509         _bfd_error_handler (_("%pB symbol number %lu references"
510                               " nonexistent SHT_SYMTAB_SHNDX section"),
511                             ibfd, (unsigned long) symoffset);
512         if (alloc_intsym != NULL)
513           free (alloc_intsym);
514         intsym_buf = NULL;
515         goto out;
516       }
517
518  out:
519   if (alloc_ext != NULL)
520     free (alloc_ext);
521   if (alloc_extshndx != NULL)
522     free (alloc_extshndx);
523
524   return intsym_buf;
525 }
526
527 /* Look up a symbol name.  */
528 const char *
529 bfd_elf_sym_name (bfd *abfd,
530                   Elf_Internal_Shdr *symtab_hdr,
531                   Elf_Internal_Sym *isym,
532                   asection *sym_sec)
533 {
534   const char *name;
535   unsigned int iname = isym->st_name;
536   unsigned int shindex = symtab_hdr->sh_link;
537
538   if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
539       /* Check for a bogus st_shndx to avoid crashing.  */
540       && isym->st_shndx < elf_numsections (abfd))
541     {
542       iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
543       shindex = elf_elfheader (abfd)->e_shstrndx;
544     }
545
546   name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
547   if (name == NULL)
548     name = "(null)";
549   else if (sym_sec && *name == '\0')
550     name = bfd_section_name (abfd, sym_sec);
551
552   return name;
553 }
554
555 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
556    sections.  The first element is the flags, the rest are section
557    pointers.  */
558
559 typedef union elf_internal_group {
560   Elf_Internal_Shdr *shdr;
561   unsigned int flags;
562 } Elf_Internal_Group;
563
564 /* Return the name of the group signature symbol.  Why isn't the
565    signature just a string?  */
566
567 static const char *
568 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
569 {
570   Elf_Internal_Shdr *hdr;
571   unsigned char esym[sizeof (Elf64_External_Sym)];
572   Elf_External_Sym_Shndx eshndx;
573   Elf_Internal_Sym isym;
574
575   /* First we need to ensure the symbol table is available.  Make sure
576      that it is a symbol table section.  */
577   if (ghdr->sh_link >= elf_numsections (abfd))
578     return NULL;
579   hdr = elf_elfsections (abfd) [ghdr->sh_link];
580   if (hdr->sh_type != SHT_SYMTAB
581       || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
582     return NULL;
583
584   /* Go read the symbol.  */
585   hdr = &elf_tdata (abfd)->symtab_hdr;
586   if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
587                             &isym, esym, &eshndx) == NULL)
588     return NULL;
589
590   return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
591 }
592
593 /* Set next_in_group list pointer, and group name for NEWSECT.  */
594
595 static bfd_boolean
596 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
597 {
598   unsigned int num_group = elf_tdata (abfd)->num_group;
599
600   /* If num_group is zero, read in all SHT_GROUP sections.  The count
601      is set to -1 if there are no SHT_GROUP sections.  */
602   if (num_group == 0)
603     {
604       unsigned int i, shnum;
605
606       /* First count the number of groups.  If we have a SHT_GROUP
607          section with just a flag word (ie. sh_size is 4), ignore it.  */
608       shnum = elf_numsections (abfd);
609       num_group = 0;
610
611 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize)    \
612         (   (shdr)->sh_type == SHT_GROUP                \
613          && (shdr)->sh_size >= minsize                  \
614          && (shdr)->sh_entsize == GRP_ENTRY_SIZE        \
615          && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
616
617       for (i = 0; i < shnum; i++)
618         {
619           Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
620
621           if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
622             num_group += 1;
623         }
624
625       if (num_group == 0)
626         {
627           num_group = (unsigned) -1;
628           elf_tdata (abfd)->num_group = num_group;
629           elf_tdata (abfd)->group_sect_ptr = NULL;
630         }
631       else
632         {
633           /* We keep a list of elf section headers for group sections,
634              so we can find them quickly.  */
635           bfd_size_type amt;
636
637           elf_tdata (abfd)->num_group = num_group;
638           elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
639               bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
640           if (elf_tdata (abfd)->group_sect_ptr == NULL)
641             return FALSE;
642           memset (elf_tdata (abfd)->group_sect_ptr, 0,
643                   num_group * sizeof (Elf_Internal_Shdr *));
644           num_group = 0;
645
646           for (i = 0; i < shnum; i++)
647             {
648               Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
649
650               if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
651                 {
652                   unsigned char *src;
653                   Elf_Internal_Group *dest;
654
655                   /* Make sure the group section has a BFD section
656                      attached to it.  */
657                   if (!bfd_section_from_shdr (abfd, i))
658                     return FALSE;
659
660                   /* Add to list of sections.  */
661                   elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
662                   num_group += 1;
663
664                   /* Read the raw contents.  */
665                   BFD_ASSERT (sizeof (*dest) >= 4);
666                   amt = shdr->sh_size * sizeof (*dest) / 4;
667                   shdr->contents = (unsigned char *)
668                     bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
669                   /* PR binutils/4110: Handle corrupt group headers.  */
670                   if (shdr->contents == NULL)
671                     {
672                       _bfd_error_handler
673                         /* xgettext:c-format */
674                         (_("%pB: corrupt size field in group section"
675                            " header: %#" PRIx64),
676                          abfd, (uint64_t) shdr->sh_size);
677                       bfd_set_error (bfd_error_bad_value);
678                       -- num_group;
679                       continue;
680                     }
681
682                   memset (shdr->contents, 0, amt);
683
684                   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
685                       || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
686                           != shdr->sh_size))
687                     {
688                       _bfd_error_handler
689                         /* xgettext:c-format */
690                         (_("%pB: invalid size field in group section"
691                            " header: %#" PRIx64 ""),
692                          abfd, (uint64_t) shdr->sh_size);
693                       bfd_set_error (bfd_error_bad_value);
694                       -- num_group;
695                       /* PR 17510: If the group contents are even
696                          partially corrupt, do not allow any of the
697                          contents to be used.  */
698                       memset (shdr->contents, 0, amt);
699                       continue;
700                     }
701
702                   /* Translate raw contents, a flag word followed by an
703                      array of elf section indices all in target byte order,
704                      to the flag word followed by an array of elf section
705                      pointers.  */
706                   src = shdr->contents + shdr->sh_size;
707                   dest = (Elf_Internal_Group *) (shdr->contents + amt);
708
709                   while (1)
710                     {
711                       unsigned int idx;
712
713                       src -= 4;
714                       --dest;
715                       idx = H_GET_32 (abfd, src);
716                       if (src == shdr->contents)
717                         {
718                           dest->flags = idx;
719                           if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
720                             shdr->bfd_section->flags
721                               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
722                           break;
723                         }
724                       if (idx < shnum)
725                         {
726                           dest->shdr = elf_elfsections (abfd)[idx];
727                           /* PR binutils/23199: All sections in a
728                              section group should be marked with
729                              SHF_GROUP.  But some tools generate
730                              broken objects without SHF_GROUP.  Fix
731                              them up here.  */
732                           dest->shdr->sh_flags |= SHF_GROUP;
733                         }
734                       if (idx >= shnum
735                           || dest->shdr->sh_type == SHT_GROUP)
736                         {
737                           _bfd_error_handler
738                             (_("%pB: invalid entry in SHT_GROUP section [%u]"),
739                                abfd, i);
740                           dest->shdr = NULL;
741                         }
742                     }
743                 }
744             }
745
746           /* PR 17510: Corrupt binaries might contain invalid groups.  */
747           if (num_group != (unsigned) elf_tdata (abfd)->num_group)
748             {
749               elf_tdata (abfd)->num_group = num_group;
750
751               /* If all groups are invalid then fail.  */
752               if (num_group == 0)
753                 {
754                   elf_tdata (abfd)->group_sect_ptr = NULL;
755                   elf_tdata (abfd)->num_group = num_group = -1;
756                   _bfd_error_handler
757                     (_("%pB: no valid group sections found"), abfd);
758                   bfd_set_error (bfd_error_bad_value);
759                 }
760             }
761         }
762     }
763
764   if (num_group != (unsigned) -1)
765     {
766       unsigned int search_offset = elf_tdata (abfd)->group_search_offset;
767       unsigned int j;
768
769       for (j = 0; j < num_group; j++)
770         {
771           /* Begin search from previous found group.  */
772           unsigned i = (j + search_offset) % num_group;
773
774           Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
775           Elf_Internal_Group *idx;
776           bfd_size_type n_elt;
777
778           if (shdr == NULL)
779             continue;
780
781           idx = (Elf_Internal_Group *) shdr->contents;
782           if (idx == NULL || shdr->sh_size < 4)
783             {
784               /* See PR 21957 for a reproducer.  */
785               /* xgettext:c-format */
786               _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
787                                   abfd, shdr->bfd_section);
788               elf_tdata (abfd)->group_sect_ptr[i] = NULL;
789               bfd_set_error (bfd_error_bad_value);
790               return FALSE;
791             }
792           n_elt = shdr->sh_size / 4;
793
794           /* Look through this group's sections to see if current
795              section is a member.  */
796           while (--n_elt != 0)
797             if ((++idx)->shdr == hdr)
798               {
799                 asection *s = NULL;
800
801                 /* We are a member of this group.  Go looking through
802                    other members to see if any others are linked via
803                    next_in_group.  */
804                 idx = (Elf_Internal_Group *) shdr->contents;
805                 n_elt = shdr->sh_size / 4;
806                 while (--n_elt != 0)
807                   if ((++idx)->shdr != NULL
808                       && (s = idx->shdr->bfd_section) != NULL
809                       && elf_next_in_group (s) != NULL)
810                     break;
811                 if (n_elt != 0)
812                   {
813                     /* Snarf the group name from other member, and
814                        insert current section in circular list.  */
815                     elf_group_name (newsect) = elf_group_name (s);
816                     elf_next_in_group (newsect) = elf_next_in_group (s);
817                     elf_next_in_group (s) = newsect;
818                   }
819                 else
820                   {
821                     const char *gname;
822
823                     gname = group_signature (abfd, shdr);
824                     if (gname == NULL)
825                       return FALSE;
826                     elf_group_name (newsect) = gname;
827
828                     /* Start a circular list with one element.  */
829                     elf_next_in_group (newsect) = newsect;
830                   }
831
832                 /* If the group section has been created, point to the
833                    new member.  */
834                 if (shdr->bfd_section != NULL)
835                   elf_next_in_group (shdr->bfd_section) = newsect;
836
837                 elf_tdata (abfd)->group_search_offset = i;
838                 j = num_group - 1;
839                 break;
840               }
841         }
842     }
843
844   if (elf_group_name (newsect) == NULL)
845     {
846       /* xgettext:c-format */
847       _bfd_error_handler (_("%pB: no group info for section '%pA'"),
848                           abfd, newsect);
849       return FALSE;
850     }
851   return TRUE;
852 }
853
854 bfd_boolean
855 _bfd_elf_setup_sections (bfd *abfd)
856 {
857   unsigned int i;
858   unsigned int num_group = elf_tdata (abfd)->num_group;
859   bfd_boolean result = TRUE;
860   asection *s;
861
862   /* Process SHF_LINK_ORDER.  */
863   for (s = abfd->sections; s != NULL; s = s->next)
864     {
865       Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
866       if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
867         {
868           unsigned int elfsec = this_hdr->sh_link;
869           /* FIXME: The old Intel compiler and old strip/objcopy may
870              not set the sh_link or sh_info fields.  Hence we could
871              get the situation where elfsec is 0.  */
872           if (elfsec == 0)
873             {
874               const struct elf_backend_data *bed = get_elf_backend_data (abfd);
875               if (bed->link_order_error_handler)
876                 bed->link_order_error_handler
877                   /* xgettext:c-format */
878                   (_("%pB: warning: sh_link not set for section `%pA'"),
879                    abfd, s);
880             }
881           else
882             {
883               asection *linksec = NULL;
884
885               if (elfsec < elf_numsections (abfd))
886                 {
887                   this_hdr = elf_elfsections (abfd)[elfsec];
888                   linksec = this_hdr->bfd_section;
889                 }
890
891               /* PR 1991, 2008:
892                  Some strip/objcopy may leave an incorrect value in
893                  sh_link.  We don't want to proceed.  */
894               if (linksec == NULL)
895                 {
896                   _bfd_error_handler
897                     /* xgettext:c-format */
898                     (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
899                      s->owner, elfsec, s);
900                   result = FALSE;
901                 }
902
903               elf_linked_to_section (s) = linksec;
904             }
905         }
906       else if (this_hdr->sh_type == SHT_GROUP
907                && elf_next_in_group (s) == NULL)
908         {
909           _bfd_error_handler
910             /* xgettext:c-format */
911             (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
912              abfd, elf_section_data (s)->this_idx);
913           result = FALSE;
914         }
915     }
916
917   /* Process section groups.  */
918   if (num_group == (unsigned) -1)
919     return result;
920
921   for (i = 0; i < num_group; i++)
922     {
923       Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
924       Elf_Internal_Group *idx;
925       unsigned int n_elt;
926
927       /* PR binutils/18758: Beware of corrupt binaries with invalid group data.  */
928       if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
929         {
930           _bfd_error_handler
931             /* xgettext:c-format */
932             (_("%pB: section group entry number %u is corrupt"),
933              abfd, i);
934           result = FALSE;
935           continue;
936         }
937
938       idx = (Elf_Internal_Group *) shdr->contents;
939       n_elt = shdr->sh_size / 4;
940
941       while (--n_elt != 0)
942         {
943           ++ idx;
944
945           if (idx->shdr == NULL)
946             continue;
947           else if (idx->shdr->bfd_section)
948             elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
949           else if (idx->shdr->sh_type != SHT_RELA
950                    && idx->shdr->sh_type != SHT_REL)
951             {
952               /* There are some unknown sections in the group.  */
953               _bfd_error_handler
954                 /* xgettext:c-format */
955                 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
956                  abfd,
957                  idx->shdr->sh_type,
958                  bfd_elf_string_from_elf_section (abfd,
959                                                   (elf_elfheader (abfd)
960                                                    ->e_shstrndx),
961                                                   idx->shdr->sh_name),
962                  shdr->bfd_section);
963               result = FALSE;
964             }
965         }
966     }
967
968   return result;
969 }
970
971 bfd_boolean
972 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
973 {
974   return elf_next_in_group (sec) != NULL;
975 }
976
977 static char *
978 convert_debug_to_zdebug (bfd *abfd, const char *name)
979 {
980   unsigned int len = strlen (name);
981   char *new_name = bfd_alloc (abfd, len + 2);
982   if (new_name == NULL)
983     return NULL;
984   new_name[0] = '.';
985   new_name[1] = 'z';
986   memcpy (new_name + 2, name + 1, len);
987   return new_name;
988 }
989
990 static char *
991 convert_zdebug_to_debug (bfd *abfd, const char *name)
992 {
993   unsigned int len = strlen (name);
994   char *new_name = bfd_alloc (abfd, len);
995   if (new_name == NULL)
996     return NULL;
997   new_name[0] = '.';
998   memcpy (new_name + 1, name + 2, len - 1);
999   return new_name;
1000 }
1001
1002 /* Make a BFD section from an ELF section.  We store a pointer to the
1003    BFD section in the bfd_section field of the header.  */
1004
1005 bfd_boolean
1006 _bfd_elf_make_section_from_shdr (bfd *abfd,
1007                                  Elf_Internal_Shdr *hdr,
1008                                  const char *name,
1009                                  int shindex)
1010 {
1011   asection *newsect;
1012   flagword flags;
1013   const struct elf_backend_data *bed;
1014
1015   if (hdr->bfd_section != NULL)
1016     return TRUE;
1017
1018   newsect = bfd_make_section_anyway (abfd, name);
1019   if (newsect == NULL)
1020     return FALSE;
1021
1022   hdr->bfd_section = newsect;
1023   elf_section_data (newsect)->this_hdr = *hdr;
1024   elf_section_data (newsect)->this_idx = shindex;
1025
1026   /* Always use the real type/flags.  */
1027   elf_section_type (newsect) = hdr->sh_type;
1028   elf_section_flags (newsect) = hdr->sh_flags;
1029
1030   newsect->filepos = hdr->sh_offset;
1031
1032   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
1033       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
1034       || ! bfd_set_section_alignment (abfd, newsect,
1035                                       bfd_log2 (hdr->sh_addralign)))
1036     return FALSE;
1037
1038   flags = SEC_NO_FLAGS;
1039   if (hdr->sh_type != SHT_NOBITS)
1040     flags |= SEC_HAS_CONTENTS;
1041   if (hdr->sh_type == SHT_GROUP)
1042     flags |= SEC_GROUP;
1043   if ((hdr->sh_flags & SHF_ALLOC) != 0)
1044     {
1045       flags |= SEC_ALLOC;
1046       if (hdr->sh_type != SHT_NOBITS)
1047         flags |= SEC_LOAD;
1048     }
1049   if ((hdr->sh_flags & SHF_WRITE) == 0)
1050     flags |= SEC_READONLY;
1051   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
1052     flags |= SEC_CODE;
1053   else if ((flags & SEC_LOAD) != 0)
1054     flags |= SEC_DATA;
1055   if ((hdr->sh_flags & SHF_MERGE) != 0)
1056     {
1057       flags |= SEC_MERGE;
1058       newsect->entsize = hdr->sh_entsize;
1059     }
1060   if ((hdr->sh_flags & SHF_STRINGS) != 0)
1061     flags |= SEC_STRINGS;
1062   if (hdr->sh_flags & SHF_GROUP)
1063     if (!setup_group (abfd, hdr, newsect))
1064       return FALSE;
1065   if ((hdr->sh_flags & SHF_TLS) != 0)
1066     flags |= SEC_THREAD_LOCAL;
1067   if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
1068     flags |= SEC_EXCLUDE;
1069
1070   if ((flags & SEC_ALLOC) == 0)
1071     {
1072       /* The debugging sections appear to be recognized only by name,
1073          not any sort of flag.  Their SEC_ALLOC bits are cleared.  */
1074       if (name [0] == '.')
1075         {
1076           const char *p;
1077           int n;
1078           if (name[1] == 'd')
1079             p = ".debug", n = 6;
1080           else if (name[1] == 'g' && name[2] == 'n')
1081             p = ".gnu.linkonce.wi.", n = 17;
1082           else if (name[1] == 'g' && name[2] == 'd')
1083             p = ".gdb_index", n = 11; /* yes we really do mean 11.  */
1084           else if (name[1] == 'l')
1085             p = ".line", n = 5;
1086           else if (name[1] == 's')
1087             p = ".stab", n = 5;
1088           else if (name[1] == 'z')
1089             p = ".zdebug", n = 7;
1090           else
1091             p = NULL, n = 0;
1092           if (p != NULL && strncmp (name, p, n) == 0)
1093             flags |= SEC_DEBUGGING;
1094         }
1095     }
1096
1097   /* As a GNU extension, if the name begins with .gnu.linkonce, we
1098      only link a single copy of the section.  This is used to support
1099      g++.  g++ will emit each template expansion in its own section.
1100      The symbols will be defined as weak, so that multiple definitions
1101      are permitted.  The GNU linker extension is to actually discard
1102      all but one of the sections.  */
1103   if (CONST_STRNEQ (name, ".gnu.linkonce")
1104       && elf_next_in_group (newsect) == NULL)
1105     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1106
1107   bed = get_elf_backend_data (abfd);
1108   if (bed->elf_backend_section_flags)
1109     if (! bed->elf_backend_section_flags (&flags, hdr))
1110       return FALSE;
1111
1112   if (! bfd_set_section_flags (abfd, newsect, flags))
1113     return FALSE;
1114
1115   /* We do not parse the PT_NOTE segments as we are interested even in the
1116      separate debug info files which may have the segments offsets corrupted.
1117      PT_NOTEs from the core files are currently not parsed using BFD.  */
1118   if (hdr->sh_type == SHT_NOTE)
1119     {
1120       bfd_byte *contents;
1121
1122       if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
1123         return FALSE;
1124
1125       elf_parse_notes (abfd, (char *) contents, hdr->sh_size,
1126                        hdr->sh_offset, hdr->sh_addralign);
1127       free (contents);
1128     }
1129
1130   if ((flags & SEC_ALLOC) != 0)
1131     {
1132       Elf_Internal_Phdr *phdr;
1133       unsigned int i, nload;
1134
1135       /* Some ELF linkers produce binaries with all the program header
1136          p_paddr fields zero.  If we have such a binary with more than
1137          one PT_LOAD header, then leave the section lma equal to vma
1138          so that we don't create sections with overlapping lma.  */
1139       phdr = elf_tdata (abfd)->phdr;
1140       for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1141         if (phdr->p_paddr != 0)
1142           break;
1143         else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
1144           ++nload;
1145       if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
1146         return TRUE;
1147
1148       phdr = elf_tdata (abfd)->phdr;
1149       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1150         {
1151           if (((phdr->p_type == PT_LOAD
1152                 && (hdr->sh_flags & SHF_TLS) == 0)
1153                || phdr->p_type == PT_TLS)
1154               && ELF_SECTION_IN_SEGMENT (hdr, phdr))
1155             {
1156               if ((flags & SEC_LOAD) == 0)
1157                 newsect->lma = (phdr->p_paddr
1158                                 + hdr->sh_addr - phdr->p_vaddr);
1159               else
1160                 /* We used to use the same adjustment for SEC_LOAD
1161                    sections, but that doesn't work if the segment
1162                    is packed with code from multiple VMAs.
1163                    Instead we calculate the section LMA based on
1164                    the segment LMA.  It is assumed that the
1165                    segment will contain sections with contiguous
1166                    LMAs, even if the VMAs are not.  */
1167                 newsect->lma = (phdr->p_paddr
1168                                 + hdr->sh_offset - phdr->p_offset);
1169
1170               /* With contiguous segments, we can't tell from file
1171                  offsets whether a section with zero size should
1172                  be placed at the end of one segment or the
1173                  beginning of the next.  Decide based on vaddr.  */
1174               if (hdr->sh_addr >= phdr->p_vaddr
1175                   && (hdr->sh_addr + hdr->sh_size
1176                       <= phdr->p_vaddr + phdr->p_memsz))
1177                 break;
1178             }
1179         }
1180     }
1181
1182   /* Compress/decompress DWARF debug sections with names: .debug_* and
1183      .zdebug_*, after the section flags is set.  */
1184   if ((flags & SEC_DEBUGGING)
1185       && ((name[1] == 'd' && name[6] == '_')
1186           || (name[1] == 'z' && name[7] == '_')))
1187     {
1188       enum { nothing, compress, decompress } action = nothing;
1189       int compression_header_size;
1190       bfd_size_type uncompressed_size;
1191       unsigned int uncompressed_align_power;
1192       bfd_boolean compressed
1193         = bfd_is_section_compressed_with_header (abfd, newsect,
1194                                                  &compression_header_size,
1195                                                  &uncompressed_size,
1196                                                  &uncompressed_align_power);
1197       if (compressed)
1198         {
1199           /* Compressed section.  Check if we should decompress.  */
1200           if ((abfd->flags & BFD_DECOMPRESS))
1201             action = decompress;
1202         }
1203
1204       /* Compress the uncompressed section or convert from/to .zdebug*
1205          section.  Check if we should compress.  */
1206       if (action == nothing)
1207         {
1208           if (newsect->size != 0
1209               && (abfd->flags & BFD_COMPRESS)
1210               && compression_header_size >= 0
1211               && uncompressed_size > 0
1212               && (!compressed
1213                   || ((compression_header_size > 0)
1214                       != ((abfd->flags & BFD_COMPRESS_GABI) != 0))))
1215             action = compress;
1216           else
1217             return TRUE;
1218         }
1219
1220       if (action == compress)
1221         {
1222           if (!bfd_init_section_compress_status (abfd, newsect))
1223             {
1224               _bfd_error_handler
1225                 /* xgettext:c-format */
1226                 (_("%pB: unable to initialize compress status for section %s"),
1227                  abfd, name);
1228               return FALSE;
1229             }
1230         }
1231       else
1232         {
1233           if (!bfd_init_section_decompress_status (abfd, newsect))
1234             {
1235               _bfd_error_handler
1236                 /* xgettext:c-format */
1237                 (_("%pB: unable to initialize decompress status for section %s"),
1238                  abfd, name);
1239               return FALSE;
1240             }
1241         }
1242
1243       if (abfd->is_linker_input)
1244         {
1245           if (name[1] == 'z'
1246               && (action == decompress
1247                   || (action == compress
1248                       && (abfd->flags & BFD_COMPRESS_GABI) != 0)))
1249             {
1250               /* Convert section name from .zdebug_* to .debug_* so
1251                  that linker will consider this section as a debug
1252                  section.  */
1253               char *new_name = convert_zdebug_to_debug (abfd, name);
1254               if (new_name == NULL)
1255                 return FALSE;
1256               bfd_rename_section (abfd, newsect, new_name);
1257             }
1258         }
1259       else
1260         /* For objdump, don't rename the section.  For objcopy, delay
1261            section rename to elf_fake_sections.  */
1262         newsect->flags |= SEC_ELF_RENAME;
1263     }
1264
1265   return TRUE;
1266 }
1267
1268 const char *const bfd_elf_section_type_names[] =
1269 {
1270   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1271   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1272   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1273 };
1274
1275 /* ELF relocs are against symbols.  If we are producing relocatable
1276    output, and the reloc is against an external symbol, and nothing
1277    has given us any additional addend, the resulting reloc will also
1278    be against the same symbol.  In such a case, we don't want to
1279    change anything about the way the reloc is handled, since it will
1280    all be done at final link time.  Rather than put special case code
1281    into bfd_perform_relocation, all the reloc types use this howto
1282    function.  It just short circuits the reloc if producing
1283    relocatable output against an external symbol.  */
1284
1285 bfd_reloc_status_type
1286 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1287                        arelent *reloc_entry,
1288                        asymbol *symbol,
1289                        void *data ATTRIBUTE_UNUSED,
1290                        asection *input_section,
1291                        bfd *output_bfd,
1292                        char **error_message ATTRIBUTE_UNUSED)
1293 {
1294   if (output_bfd != NULL
1295       && (symbol->flags & BSF_SECTION_SYM) == 0
1296       && (! reloc_entry->howto->partial_inplace
1297           || reloc_entry->addend == 0))
1298     {
1299       reloc_entry->address += input_section->output_offset;
1300       return bfd_reloc_ok;
1301     }
1302
1303   return bfd_reloc_continue;
1304 }
1305 \f
1306 /* Returns TRUE if section A matches section B.
1307    Names, addresses and links may be different, but everything else
1308    should be the same.  */
1309
1310 static bfd_boolean
1311 section_match (const Elf_Internal_Shdr * a,
1312                const Elf_Internal_Shdr * b)
1313 {
1314   if (a->sh_type != b->sh_type
1315       || ((a->sh_flags ^ b->sh_flags) & ~SHF_INFO_LINK) != 0
1316       || a->sh_addralign != b->sh_addralign
1317       || a->sh_entsize != b->sh_entsize)
1318     return FALSE;
1319   if (a->sh_type == SHT_SYMTAB
1320       || a->sh_type == SHT_STRTAB)
1321     return TRUE;
1322   return a->sh_size == b->sh_size;
1323 }
1324
1325 /* Find a section in OBFD that has the same characteristics
1326    as IHEADER.  Return the index of this section or SHN_UNDEF if
1327    none can be found.  Check's section HINT first, as this is likely
1328    to be the correct section.  */
1329
1330 static unsigned int
1331 find_link (const bfd *obfd, const Elf_Internal_Shdr *iheader,
1332            const unsigned int hint)
1333 {
1334   Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd);
1335   unsigned int i;
1336
1337   BFD_ASSERT (iheader != NULL);
1338
1339   /* See PR 20922 for a reproducer of the NULL test.  */
1340   if (hint < elf_numsections (obfd)
1341       && oheaders[hint] != NULL
1342       && section_match (oheaders[hint], iheader))
1343     return hint;
1344
1345   for (i = 1; i < elf_numsections (obfd); i++)
1346     {
1347       Elf_Internal_Shdr * oheader = oheaders[i];
1348
1349       if (oheader == NULL)
1350         continue;
1351       if (section_match (oheader, iheader))
1352         /* FIXME: Do we care if there is a potential for
1353            multiple matches ?  */
1354         return i;
1355     }
1356
1357   return SHN_UNDEF;
1358 }
1359
1360 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1361    Processor specific section, based upon a matching input section.
1362    Returns TRUE upon success, FALSE otherwise.  */
1363
1364 static bfd_boolean
1365 copy_special_section_fields (const bfd *ibfd,
1366                              bfd *obfd,
1367                              const Elf_Internal_Shdr *iheader,
1368                              Elf_Internal_Shdr *oheader,
1369                              const unsigned int secnum)
1370 {
1371   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
1372   const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1373   bfd_boolean changed = FALSE;
1374   unsigned int sh_link;
1375
1376   if (oheader->sh_type == SHT_NOBITS)
1377     {
1378       /* This is a feature for objcopy --only-keep-debug:
1379          When a section's type is changed to NOBITS, we preserve
1380          the sh_link and sh_info fields so that they can be
1381          matched up with the original.
1382
1383          Note: Strictly speaking these assignments are wrong.
1384          The sh_link and sh_info fields should point to the
1385          relevent sections in the output BFD, which may not be in
1386          the same location as they were in the input BFD.  But
1387          the whole point of this action is to preserve the
1388          original values of the sh_link and sh_info fields, so
1389          that they can be matched up with the section headers in
1390          the original file.  So strictly speaking we may be
1391          creating an invalid ELF file, but it is only for a file
1392          that just contains debug info and only for sections
1393          without any contents.  */
1394       if (oheader->sh_link == 0)
1395         oheader->sh_link = iheader->sh_link;
1396       if (oheader->sh_info == 0)
1397         oheader->sh_info = iheader->sh_info;
1398       return TRUE;
1399     }
1400
1401   /* Allow the target a chance to decide how these fields should be set.  */
1402   if (bed->elf_backend_copy_special_section_fields != NULL
1403       && bed->elf_backend_copy_special_section_fields
1404       (ibfd, obfd, iheader, oheader))
1405     return TRUE;
1406
1407   /* We have an iheader which might match oheader, and which has non-zero
1408      sh_info and/or sh_link fields.  Attempt to follow those links and find
1409      the section in the output bfd which corresponds to the linked section
1410      in the input bfd.  */
1411   if (iheader->sh_link != SHN_UNDEF)
1412     {
1413       /* See PR 20931 for a reproducer.  */
1414       if (iheader->sh_link >= elf_numsections (ibfd))
1415         {
1416           _bfd_error_handler
1417             /* xgettext:c-format */
1418             (_("%pB: invalid sh_link field (%d) in section number %d"),
1419              ibfd, iheader->sh_link, secnum);
1420           return FALSE;
1421         }
1422
1423       sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link);
1424       if (sh_link != SHN_UNDEF)
1425         {
1426           oheader->sh_link = sh_link;
1427           changed = TRUE;
1428         }
1429       else
1430         /* FIXME: Should we install iheader->sh_link
1431            if we could not find a match ?  */
1432         _bfd_error_handler
1433           /* xgettext:c-format */
1434           (_("%pB: failed to find link section for section %d"), obfd, secnum);
1435     }
1436
1437   if (iheader->sh_info)
1438     {
1439       /* The sh_info field can hold arbitrary information, but if the
1440          SHF_LINK_INFO flag is set then it should be interpreted as a
1441          section index.  */
1442       if (iheader->sh_flags & SHF_INFO_LINK)
1443         {
1444           sh_link = find_link (obfd, iheaders[iheader->sh_info],
1445                                iheader->sh_info);
1446           if (sh_link != SHN_UNDEF)
1447             oheader->sh_flags |= SHF_INFO_LINK;
1448         }
1449       else
1450         /* No idea what it means - just copy it.  */
1451         sh_link = iheader->sh_info;
1452
1453       if (sh_link != SHN_UNDEF)
1454         {
1455           oheader->sh_info = sh_link;
1456           changed = TRUE;
1457         }
1458       else
1459         _bfd_error_handler
1460           /* xgettext:c-format */
1461           (_("%pB: failed to find info section for section %d"), obfd, secnum);
1462     }
1463
1464   return changed;
1465 }
1466
1467 /* Copy the program header and other data from one object module to
1468    another.  */
1469
1470 bfd_boolean
1471 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1472 {
1473   const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1474   Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
1475   const struct elf_backend_data *bed;
1476   unsigned int i;
1477
1478   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1479     || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1480     return TRUE;
1481
1482   if (!elf_flags_init (obfd))
1483     {
1484       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1485       elf_flags_init (obfd) = TRUE;
1486     }
1487
1488   elf_gp (obfd) = elf_gp (ibfd);
1489
1490   /* Also copy the EI_OSABI field.  */
1491   elf_elfheader (obfd)->e_ident[EI_OSABI] =
1492     elf_elfheader (ibfd)->e_ident[EI_OSABI];
1493
1494   /* If set, copy the EI_ABIVERSION field.  */
1495   if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION])
1496     elf_elfheader (obfd)->e_ident[EI_ABIVERSION]
1497       = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION];
1498
1499   /* Copy object attributes.  */
1500   _bfd_elf_copy_obj_attributes (ibfd, obfd);
1501
1502   if (iheaders == NULL || oheaders == NULL)
1503     return TRUE;
1504
1505   bed = get_elf_backend_data (obfd);
1506
1507   /* Possibly copy other fields in the section header.  */
1508   for (i = 1; i < elf_numsections (obfd); i++)
1509     {
1510       unsigned int j;
1511       Elf_Internal_Shdr * oheader = oheaders[i];
1512
1513       /* Ignore ordinary sections.  SHT_NOBITS sections are considered however
1514          because of a special case need for generating separate debug info
1515          files.  See below for more details.  */
1516       if (oheader == NULL
1517           || (oheader->sh_type != SHT_NOBITS
1518               && oheader->sh_type < SHT_LOOS))
1519         continue;
1520
1521       /* Ignore empty sections, and sections whose
1522          fields have already been initialised.  */
1523       if (oheader->sh_size == 0
1524           || (oheader->sh_info != 0 && oheader->sh_link != 0))
1525         continue;
1526
1527       /* Scan for the matching section in the input bfd.
1528          First we try for a direct mapping between the input and output sections.  */
1529       for (j = 1; j < elf_numsections (ibfd); j++)
1530         {
1531           const Elf_Internal_Shdr * iheader = iheaders[j];
1532
1533           if (iheader == NULL)
1534             continue;
1535
1536           if (oheader->bfd_section != NULL
1537               && iheader->bfd_section != NULL
1538               && iheader->bfd_section->output_section != NULL
1539               && iheader->bfd_section->output_section == oheader->bfd_section)
1540             {
1541               /* We have found a connection from the input section to the
1542                  output section.  Attempt to copy the header fields.  If
1543                  this fails then do not try any further sections - there
1544                  should only be a one-to-one mapping between input and output. */
1545               if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1546                 j = elf_numsections (ibfd);
1547               break;
1548             }
1549         }
1550
1551       if (j < elf_numsections (ibfd))
1552         continue;
1553
1554       /* That failed.  So try to deduce the corresponding input section.
1555          Unfortunately we cannot compare names as the output string table
1556          is empty, so instead we check size, address and type.  */
1557       for (j = 1; j < elf_numsections (ibfd); j++)
1558         {
1559           const Elf_Internal_Shdr * iheader = iheaders[j];
1560
1561           if (iheader == NULL)
1562             continue;
1563
1564           /* Try matching fields in the input section's header.
1565              Since --only-keep-debug turns all non-debug sections into
1566              SHT_NOBITS sections, the output SHT_NOBITS type matches any
1567              input type.  */
1568           if ((oheader->sh_type == SHT_NOBITS
1569                || iheader->sh_type == oheader->sh_type)
1570               && (iheader->sh_flags & ~ SHF_INFO_LINK)
1571               == (oheader->sh_flags & ~ SHF_INFO_LINK)
1572               && iheader->sh_addralign == oheader->sh_addralign
1573               && iheader->sh_entsize == oheader->sh_entsize
1574               && iheader->sh_size == oheader->sh_size
1575               && iheader->sh_addr == oheader->sh_addr
1576               && (iheader->sh_info != oheader->sh_info
1577                   || iheader->sh_link != oheader->sh_link))
1578             {
1579               if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1580                 break;
1581             }
1582         }
1583
1584       if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS)
1585         {
1586           /* Final attempt.  Call the backend copy function
1587              with a NULL input section.  */
1588           if (bed->elf_backend_copy_special_section_fields != NULL)
1589             bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
1590         }
1591     }
1592
1593   return TRUE;
1594 }
1595
1596 static const char *
1597 get_segment_type (unsigned int p_type)
1598 {
1599   const char *pt;
1600   switch (p_type)
1601     {
1602     case PT_NULL: pt = "NULL"; break;
1603     case PT_LOAD: pt = "LOAD"; break;
1604     case PT_DYNAMIC: pt = "DYNAMIC"; break;
1605     case PT_INTERP: pt = "INTERP"; break;
1606     case PT_NOTE: pt = "NOTE"; break;
1607     case PT_SHLIB: pt = "SHLIB"; break;
1608     case PT_PHDR: pt = "PHDR"; break;
1609     case PT_TLS: pt = "TLS"; break;
1610     case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1611     case PT_GNU_STACK: pt = "STACK"; break;
1612     case PT_GNU_RELRO: pt = "RELRO"; break;
1613     default: pt = NULL; break;
1614     }
1615   return pt;
1616 }
1617
1618 /* Print out the program headers.  */
1619
1620 bfd_boolean
1621 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1622 {
1623   FILE *f = (FILE *) farg;
1624   Elf_Internal_Phdr *p;
1625   asection *s;
1626   bfd_byte *dynbuf = NULL;
1627
1628   p = elf_tdata (abfd)->phdr;
1629   if (p != NULL)
1630     {
1631       unsigned int i, c;
1632
1633       fprintf (f, _("\nProgram Header:\n"));
1634       c = elf_elfheader (abfd)->e_phnum;
1635       for (i = 0; i < c; i++, p++)
1636         {
1637           const char *pt = get_segment_type (p->p_type);
1638           char buf[20];
1639
1640           if (pt == NULL)
1641             {
1642               sprintf (buf, "0x%lx", p->p_type);
1643               pt = buf;
1644             }
1645           fprintf (f, "%8s off    0x", pt);
1646           bfd_fprintf_vma (abfd, f, p->p_offset);
1647           fprintf (f, " vaddr 0x");
1648           bfd_fprintf_vma (abfd, f, p->p_vaddr);
1649           fprintf (f, " paddr 0x");
1650           bfd_fprintf_vma (abfd, f, p->p_paddr);
1651           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1652           fprintf (f, "         filesz 0x");
1653           bfd_fprintf_vma (abfd, f, p->p_filesz);
1654           fprintf (f, " memsz 0x");
1655           bfd_fprintf_vma (abfd, f, p->p_memsz);
1656           fprintf (f, " flags %c%c%c",
1657                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
1658                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
1659                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
1660           if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1661             fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1662           fprintf (f, "\n");
1663         }
1664     }
1665
1666   s = bfd_get_section_by_name (abfd, ".dynamic");
1667   if (s != NULL)
1668     {
1669       unsigned int elfsec;
1670       unsigned long shlink;
1671       bfd_byte *extdyn, *extdynend;
1672       size_t extdynsize;
1673       void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1674
1675       fprintf (f, _("\nDynamic Section:\n"));
1676
1677       if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1678         goto error_return;
1679
1680       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1681       if (elfsec == SHN_BAD)
1682         goto error_return;
1683       shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1684
1685       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1686       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1687
1688       extdyn = dynbuf;
1689       /* PR 17512: file: 6f427532.  */
1690       if (s->size < extdynsize)
1691         goto error_return;
1692       extdynend = extdyn + s->size;
1693       /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1694          Fix range check.  */
1695       for (; extdyn <= (extdynend - extdynsize); extdyn += extdynsize)
1696         {
1697           Elf_Internal_Dyn dyn;
1698           const char *name = "";
1699           char ab[20];
1700           bfd_boolean stringp;
1701           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1702
1703           (*swap_dyn_in) (abfd, extdyn, &dyn);
1704
1705           if (dyn.d_tag == DT_NULL)
1706             break;
1707
1708           stringp = FALSE;
1709           switch (dyn.d_tag)
1710             {
1711             default:
1712               if (bed->elf_backend_get_target_dtag)
1713                 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1714
1715               if (!strcmp (name, ""))
1716                 {
1717                   sprintf (ab, "%#" BFD_VMA_FMT "x", dyn.d_tag);
1718                   name = ab;
1719                 }
1720               break;
1721
1722             case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1723             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1724             case DT_PLTGOT: name = "PLTGOT"; break;
1725             case DT_HASH: name = "HASH"; break;
1726             case DT_STRTAB: name = "STRTAB"; break;
1727             case DT_SYMTAB: name = "SYMTAB"; break;
1728             case DT_RELA: name = "RELA"; break;
1729             case DT_RELASZ: name = "RELASZ"; break;
1730             case DT_RELAENT: name = "RELAENT"; break;
1731             case DT_STRSZ: name = "STRSZ"; break;
1732             case DT_SYMENT: name = "SYMENT"; break;
1733             case DT_INIT: name = "INIT"; break;
1734             case DT_FINI: name = "FINI"; break;
1735             case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1736             case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1737             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1738             case DT_REL: name = "REL"; break;
1739             case DT_RELSZ: name = "RELSZ"; break;
1740             case DT_RELENT: name = "RELENT"; break;
1741             case DT_PLTREL: name = "PLTREL"; break;
1742             case DT_DEBUG: name = "DEBUG"; break;
1743             case DT_TEXTREL: name = "TEXTREL"; break;
1744             case DT_JMPREL: name = "JMPREL"; break;
1745             case DT_BIND_NOW: name = "BIND_NOW"; break;
1746             case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1747             case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1748             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1749             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1750             case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1751             case DT_FLAGS: name = "FLAGS"; break;
1752             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1753             case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1754             case DT_CHECKSUM: name = "CHECKSUM"; break;
1755             case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1756             case DT_MOVEENT: name = "MOVEENT"; break;
1757             case DT_MOVESZ: name = "MOVESZ"; break;
1758             case DT_FEATURE: name = "FEATURE"; break;
1759             case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1760             case DT_SYMINSZ: name = "SYMINSZ"; break;
1761             case DT_SYMINENT: name = "SYMINENT"; break;
1762             case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1763             case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1764             case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1765             case DT_PLTPAD: name = "PLTPAD"; break;
1766             case DT_MOVETAB: name = "MOVETAB"; break;
1767             case DT_SYMINFO: name = "SYMINFO"; break;
1768             case DT_RELACOUNT: name = "RELACOUNT"; break;
1769             case DT_RELCOUNT: name = "RELCOUNT"; break;
1770             case DT_FLAGS_1: name = "FLAGS_1"; break;
1771             case DT_VERSYM: name = "VERSYM"; break;
1772             case DT_VERDEF: name = "VERDEF"; break;
1773             case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1774             case DT_VERNEED: name = "VERNEED"; break;
1775             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1776             case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1777             case DT_USED: name = "USED"; break;
1778             case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1779             case DT_GNU_HASH: name = "GNU_HASH"; break;
1780             }
1781
1782           fprintf (f, "  %-20s ", name);
1783           if (! stringp)
1784             {
1785               fprintf (f, "0x");
1786               bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1787             }
1788           else
1789             {
1790               const char *string;
1791               unsigned int tagv = dyn.d_un.d_val;
1792
1793               string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1794               if (string == NULL)
1795                 goto error_return;
1796               fprintf (f, "%s", string);
1797             }
1798           fprintf (f, "\n");
1799         }
1800
1801       free (dynbuf);
1802       dynbuf = NULL;
1803     }
1804
1805   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1806       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1807     {
1808       if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1809         return FALSE;
1810     }
1811
1812   if (elf_dynverdef (abfd) != 0)
1813     {
1814       Elf_Internal_Verdef *t;
1815
1816       fprintf (f, _("\nVersion definitions:\n"));
1817       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1818         {
1819           fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1820                    t->vd_flags, t->vd_hash,
1821                    t->vd_nodename ? t->vd_nodename : "<corrupt>");
1822           if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1823             {
1824               Elf_Internal_Verdaux *a;
1825
1826               fprintf (f, "\t");
1827               for (a = t->vd_auxptr->vda_nextptr;
1828                    a != NULL;
1829                    a = a->vda_nextptr)
1830                 fprintf (f, "%s ",
1831                          a->vda_nodename ? a->vda_nodename : "<corrupt>");
1832               fprintf (f, "\n");
1833             }
1834         }
1835     }
1836
1837   if (elf_dynverref (abfd) != 0)
1838     {
1839       Elf_Internal_Verneed *t;
1840
1841       fprintf (f, _("\nVersion References:\n"));
1842       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1843         {
1844           Elf_Internal_Vernaux *a;
1845
1846           fprintf (f, _("  required from %s:\n"),
1847                    t->vn_filename ? t->vn_filename : "<corrupt>");
1848           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1849             fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1850                      a->vna_flags, a->vna_other,
1851                      a->vna_nodename ? a->vna_nodename : "<corrupt>");
1852         }
1853     }
1854
1855   return TRUE;
1856
1857  error_return:
1858   if (dynbuf != NULL)
1859     free (dynbuf);
1860   return FALSE;
1861 }
1862
1863 /* Get version string.  */
1864
1865 const char *
1866 _bfd_elf_get_symbol_version_string (bfd *abfd, asymbol *symbol,
1867                                     bfd_boolean *hidden)
1868 {
1869   const char *version_string = NULL;
1870   if (elf_dynversym (abfd) != 0
1871       && (elf_dynverdef (abfd) != 0 || elf_dynverref (abfd) != 0))
1872     {
1873       unsigned int vernum = ((elf_symbol_type *) symbol)->version;
1874
1875       *hidden = (vernum & VERSYM_HIDDEN) != 0;
1876       vernum &= VERSYM_VERSION;
1877
1878       if (vernum == 0)
1879         version_string = "";
1880       else if (vernum == 1
1881                && (vernum > elf_tdata (abfd)->cverdefs
1882                    || (elf_tdata (abfd)->verdef[0].vd_flags
1883                        == VER_FLG_BASE)))
1884         version_string = "Base";
1885       else if (vernum <= elf_tdata (abfd)->cverdefs)
1886         version_string =
1887           elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1888       else
1889         {
1890           Elf_Internal_Verneed *t;
1891
1892           version_string = _("<corrupt>");
1893           for (t = elf_tdata (abfd)->verref;
1894                t != NULL;
1895                t = t->vn_nextref)
1896             {
1897               Elf_Internal_Vernaux *a;
1898
1899               for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1900                 {
1901                   if (a->vna_other == vernum)
1902                     {
1903                       version_string = a->vna_nodename;
1904                       break;
1905                     }
1906                 }
1907             }
1908         }
1909     }
1910   return version_string;
1911 }
1912
1913 /* Display ELF-specific fields of a symbol.  */
1914
1915 void
1916 bfd_elf_print_symbol (bfd *abfd,
1917                       void *filep,
1918                       asymbol *symbol,
1919                       bfd_print_symbol_type how)
1920 {
1921   FILE *file = (FILE *) filep;
1922   switch (how)
1923     {
1924     case bfd_print_symbol_name:
1925       fprintf (file, "%s", symbol->name);
1926       break;
1927     case bfd_print_symbol_more:
1928       fprintf (file, "elf ");
1929       bfd_fprintf_vma (abfd, file, symbol->value);
1930       fprintf (file, " %x", symbol->flags);
1931       break;
1932     case bfd_print_symbol_all:
1933       {
1934         const char *section_name;
1935         const char *name = NULL;
1936         const struct elf_backend_data *bed;
1937         unsigned char st_other;
1938         bfd_vma val;
1939         const char *version_string;
1940         bfd_boolean hidden;
1941
1942         section_name = symbol->section ? symbol->section->name : "(*none*)";
1943
1944         bed = get_elf_backend_data (abfd);
1945         if (bed->elf_backend_print_symbol_all)
1946           name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1947
1948         if (name == NULL)
1949           {
1950             name = symbol->name;
1951             bfd_print_symbol_vandf (abfd, file, symbol);
1952           }
1953
1954         fprintf (file, " %s\t", section_name);
1955         /* Print the "other" value for a symbol.  For common symbols,
1956            we've already printed the size; now print the alignment.
1957            For other symbols, we have no specified alignment, and
1958            we've printed the address; now print the size.  */
1959         if (symbol->section && bfd_is_com_section (symbol->section))
1960           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1961         else
1962           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1963         bfd_fprintf_vma (abfd, file, val);
1964
1965         /* If we have version information, print it.  */
1966         version_string = _bfd_elf_get_symbol_version_string (abfd,
1967                                                              symbol,
1968                                                              &hidden);
1969         if (version_string)
1970           {
1971             if (!hidden)
1972               fprintf (file, "  %-11s", version_string);
1973             else
1974               {
1975                 int i;
1976
1977                 fprintf (file, " (%s)", version_string);
1978                 for (i = 10 - strlen (version_string); i > 0; --i)
1979                   putc (' ', file);
1980               }
1981           }
1982
1983         /* If the st_other field is not zero, print it.  */
1984         st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1985
1986         switch (st_other)
1987           {
1988           case 0: break;
1989           case STV_INTERNAL:  fprintf (file, " .internal");  break;
1990           case STV_HIDDEN:    fprintf (file, " .hidden");    break;
1991           case STV_PROTECTED: fprintf (file, " .protected"); break;
1992           default:
1993             /* Some other non-defined flags are also present, so print
1994                everything hex.  */
1995             fprintf (file, " 0x%02x", (unsigned int) st_other);
1996           }
1997
1998         fprintf (file, " %s", name);
1999       }
2000       break;
2001     }
2002 }
2003 \f
2004 /* ELF .o/exec file reading */
2005
2006 /* Create a new bfd section from an ELF section header.  */
2007
2008 bfd_boolean
2009 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
2010 {
2011   Elf_Internal_Shdr *hdr;
2012   Elf_Internal_Ehdr *ehdr;
2013   const struct elf_backend_data *bed;
2014   const char *name;
2015   bfd_boolean ret = TRUE;
2016   static bfd_boolean * sections_being_created = NULL;
2017   static bfd * sections_being_created_abfd = NULL;
2018   static unsigned int nesting = 0;
2019
2020   if (shindex >= elf_numsections (abfd))
2021     return FALSE;
2022
2023   if (++ nesting > 3)
2024     {
2025       /* PR17512: A corrupt ELF binary might contain a recursive group of
2026          sections, with each the string indices pointing to the next in the
2027          loop.  Detect this here, by refusing to load a section that we are
2028          already in the process of loading.  We only trigger this test if
2029          we have nested at least three sections deep as normal ELF binaries
2030          can expect to recurse at least once.
2031
2032          FIXME: It would be better if this array was attached to the bfd,
2033          rather than being held in a static pointer.  */
2034
2035       if (sections_being_created_abfd != abfd)
2036         sections_being_created = NULL;
2037       if (sections_being_created == NULL)
2038         {
2039           /* FIXME: It would be more efficient to attach this array to the bfd somehow.  */
2040           sections_being_created = (bfd_boolean *)
2041             bfd_zalloc (abfd, elf_numsections (abfd) * sizeof (bfd_boolean));
2042           sections_being_created_abfd = abfd;
2043         }
2044       if (sections_being_created [shindex])
2045         {
2046           _bfd_error_handler
2047             (_("%pB: warning: loop in section dependencies detected"), abfd);
2048           return FALSE;
2049         }
2050       sections_being_created [shindex] = TRUE;
2051     }
2052
2053   hdr = elf_elfsections (abfd)[shindex];
2054   ehdr = elf_elfheader (abfd);
2055   name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
2056                                           hdr->sh_name);
2057   if (name == NULL)
2058     goto fail;
2059
2060   bed = get_elf_backend_data (abfd);
2061   switch (hdr->sh_type)
2062     {
2063     case SHT_NULL:
2064       /* Inactive section. Throw it away.  */
2065       goto success;
2066
2067     case SHT_PROGBITS:          /* Normal section with contents.  */
2068     case SHT_NOBITS:            /* .bss section.  */
2069     case SHT_HASH:              /* .hash section.  */
2070     case SHT_NOTE:              /* .note section.  */
2071     case SHT_INIT_ARRAY:        /* .init_array section.  */
2072     case SHT_FINI_ARRAY:        /* .fini_array section.  */
2073     case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
2074     case SHT_GNU_LIBLIST:       /* .gnu.liblist section.  */
2075     case SHT_GNU_HASH:          /* .gnu.hash section.  */
2076       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2077       goto success;
2078
2079     case SHT_DYNAMIC:   /* Dynamic linking information.  */
2080       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2081         goto fail;
2082
2083       if (hdr->sh_link > elf_numsections (abfd))
2084         {
2085           /* PR 10478: Accept Solaris binaries with a sh_link
2086              field set to SHN_BEFORE or SHN_AFTER.  */
2087           switch (bfd_get_arch (abfd))
2088             {
2089             case bfd_arch_i386:
2090             case bfd_arch_sparc:
2091               if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
2092                   || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
2093                 break;
2094               /* Otherwise fall through.  */
2095             default:
2096               goto fail;
2097             }
2098         }
2099       else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
2100         goto fail;
2101       else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
2102         {
2103           Elf_Internal_Shdr *dynsymhdr;
2104
2105           /* The shared libraries distributed with hpux11 have a bogus
2106              sh_link field for the ".dynamic" section.  Find the
2107              string table for the ".dynsym" section instead.  */
2108           if (elf_dynsymtab (abfd) != 0)
2109             {
2110               dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
2111               hdr->sh_link = dynsymhdr->sh_link;
2112             }
2113           else
2114             {
2115               unsigned int i, num_sec;
2116
2117               num_sec = elf_numsections (abfd);
2118               for (i = 1; i < num_sec; i++)
2119                 {
2120                   dynsymhdr = elf_elfsections (abfd)[i];
2121                   if (dynsymhdr->sh_type == SHT_DYNSYM)
2122                     {
2123                       hdr->sh_link = dynsymhdr->sh_link;
2124                       break;
2125                     }
2126                 }
2127             }
2128         }
2129       goto success;
2130
2131     case SHT_SYMTAB:            /* A symbol table.  */
2132       if (elf_onesymtab (abfd) == shindex)
2133         goto success;
2134
2135       if (hdr->sh_entsize != bed->s->sizeof_sym)
2136         goto fail;
2137
2138       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2139         {
2140           if (hdr->sh_size != 0)
2141             goto fail;
2142           /* Some assemblers erroneously set sh_info to one with a
2143              zero sh_size.  ld sees this as a global symbol count
2144              of (unsigned) -1.  Fix it here.  */
2145           hdr->sh_info = 0;
2146           goto success;
2147         }
2148
2149       /* PR 18854: A binary might contain more than one symbol table.
2150          Unusual, but possible.  Warn, but continue.  */
2151       if (elf_onesymtab (abfd) != 0)
2152         {
2153           _bfd_error_handler
2154             /* xgettext:c-format */
2155             (_("%pB: warning: multiple symbol tables detected"
2156                " - ignoring the table in section %u"),
2157              abfd, shindex);
2158           goto success;
2159         }
2160       elf_onesymtab (abfd) = shindex;
2161       elf_symtab_hdr (abfd) = *hdr;
2162       elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
2163       abfd->flags |= HAS_SYMS;
2164
2165       /* Sometimes a shared object will map in the symbol table.  If
2166          SHF_ALLOC is set, and this is a shared object, then we also
2167          treat this section as a BFD section.  We can not base the
2168          decision purely on SHF_ALLOC, because that flag is sometimes
2169          set in a relocatable object file, which would confuse the
2170          linker.  */
2171       if ((hdr->sh_flags & SHF_ALLOC) != 0
2172           && (abfd->flags & DYNAMIC) != 0
2173           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2174                                                 shindex))
2175         goto fail;
2176
2177       /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2178          can't read symbols without that section loaded as well.  It
2179          is most likely specified by the next section header.  */
2180       {
2181         elf_section_list * entry;
2182         unsigned int i, num_sec;
2183
2184         for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2185           if (entry->hdr.sh_link == shindex)
2186             goto success;
2187
2188         num_sec = elf_numsections (abfd);
2189         for (i = shindex + 1; i < num_sec; i++)
2190           {
2191             Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2192
2193             if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2194                 && hdr2->sh_link == shindex)
2195               break;
2196           }
2197
2198         if (i == num_sec)
2199           for (i = 1; i < shindex; i++)
2200             {
2201               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2202
2203               if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2204                   && hdr2->sh_link == shindex)
2205                 break;
2206             }
2207
2208         if (i != shindex)
2209           ret = bfd_section_from_shdr (abfd, i);
2210         /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2211         goto success;
2212       }
2213
2214     case SHT_DYNSYM:            /* A dynamic symbol table.  */
2215       if (elf_dynsymtab (abfd) == shindex)
2216         goto success;
2217
2218       if (hdr->sh_entsize != bed->s->sizeof_sym)
2219         goto fail;
2220
2221       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2222         {
2223           if (hdr->sh_size != 0)
2224             goto fail;
2225
2226           /* Some linkers erroneously set sh_info to one with a
2227              zero sh_size.  ld sees this as a global symbol count
2228              of (unsigned) -1.  Fix it here.  */
2229           hdr->sh_info = 0;
2230           goto success;
2231         }
2232
2233       /* PR 18854: A binary might contain more than one dynamic symbol table.
2234          Unusual, but possible.  Warn, but continue.  */
2235       if (elf_dynsymtab (abfd) != 0)
2236         {
2237           _bfd_error_handler
2238             /* xgettext:c-format */
2239             (_("%pB: warning: multiple dynamic symbol tables detected"
2240                " - ignoring the table in section %u"),
2241              abfd, shindex);
2242           goto success;
2243         }
2244       elf_dynsymtab (abfd) = shindex;
2245       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
2246       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2247       abfd->flags |= HAS_SYMS;
2248
2249       /* Besides being a symbol table, we also treat this as a regular
2250          section, so that objcopy can handle it.  */
2251       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2252       goto success;
2253
2254     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections.  */
2255       {
2256         elf_section_list * entry;
2257
2258         for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2259           if (entry->ndx == shindex)
2260             goto success;
2261
2262         entry = bfd_alloc (abfd, sizeof * entry);
2263         if (entry == NULL)
2264           goto fail;
2265         entry->ndx = shindex;
2266         entry->hdr = * hdr;
2267         entry->next = elf_symtab_shndx_list (abfd);
2268         elf_symtab_shndx_list (abfd) = entry;
2269         elf_elfsections (abfd)[shindex] = & entry->hdr;
2270         goto success;
2271       }
2272
2273     case SHT_STRTAB:            /* A string table.  */
2274       if (hdr->bfd_section != NULL)
2275         goto success;
2276
2277       if (ehdr->e_shstrndx == shindex)
2278         {
2279           elf_tdata (abfd)->shstrtab_hdr = *hdr;
2280           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
2281           goto success;
2282         }
2283
2284       if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
2285         {
2286         symtab_strtab:
2287           elf_tdata (abfd)->strtab_hdr = *hdr;
2288           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
2289           goto success;
2290         }
2291
2292       if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2293         {
2294         dynsymtab_strtab:
2295           elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2296           hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2297           elf_elfsections (abfd)[shindex] = hdr;
2298           /* We also treat this as a regular section, so that objcopy
2299              can handle it.  */
2300           ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2301                                                  shindex);
2302           goto success;
2303         }
2304
2305       /* If the string table isn't one of the above, then treat it as a
2306          regular section.  We need to scan all the headers to be sure,
2307          just in case this strtab section appeared before the above.  */
2308       if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2309         {
2310           unsigned int i, num_sec;
2311
2312           num_sec = elf_numsections (abfd);
2313           for (i = 1; i < num_sec; i++)
2314             {
2315               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2316               if (hdr2->sh_link == shindex)
2317                 {
2318                   /* Prevent endless recursion on broken objects.  */
2319                   if (i == shindex)
2320                     goto fail;
2321                   if (! bfd_section_from_shdr (abfd, i))
2322                     goto fail;
2323                   if (elf_onesymtab (abfd) == i)
2324                     goto symtab_strtab;
2325                   if (elf_dynsymtab (abfd) == i)
2326                     goto dynsymtab_strtab;
2327                 }
2328             }
2329         }
2330       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2331       goto success;
2332
2333     case SHT_REL:
2334     case SHT_RELA:
2335       /* *These* do a lot of work -- but build no sections!  */
2336       {
2337         asection *target_sect;
2338         Elf_Internal_Shdr *hdr2, **p_hdr;
2339         unsigned int num_sec = elf_numsections (abfd);
2340         struct bfd_elf_section_data *esdt;
2341
2342         if (hdr->sh_entsize
2343             != (bfd_size_type) (hdr->sh_type == SHT_REL
2344                                 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
2345           goto fail;
2346
2347         /* Check for a bogus link to avoid crashing.  */
2348         if (hdr->sh_link >= num_sec)
2349           {
2350             _bfd_error_handler
2351               /* xgettext:c-format */
2352               (_("%pB: invalid link %u for reloc section %s (index %u)"),
2353                abfd, hdr->sh_link, name, shindex);
2354             ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2355                                                    shindex);
2356             goto success;
2357           }
2358
2359         /* For some incomprehensible reason Oracle distributes
2360            libraries for Solaris in which some of the objects have
2361            bogus sh_link fields.  It would be nice if we could just
2362            reject them, but, unfortunately, some people need to use
2363            them.  We scan through the section headers; if we find only
2364            one suitable symbol table, we clobber the sh_link to point
2365            to it.  I hope this doesn't break anything.
2366
2367            Don't do it on executable nor shared library.  */
2368         if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
2369             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2370             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2371           {
2372             unsigned int scan;
2373             int found;
2374
2375             found = 0;
2376             for (scan = 1; scan < num_sec; scan++)
2377               {
2378                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2379                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2380                   {
2381                     if (found != 0)
2382                       {
2383                         found = 0;
2384                         break;
2385                       }
2386                     found = scan;
2387                   }
2388               }
2389             if (found != 0)
2390               hdr->sh_link = found;
2391           }
2392
2393         /* Get the symbol table.  */
2394         if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2395              || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2396             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2397           goto fail;
2398
2399         /* If this is an alloc section in an executable or shared
2400            library, or the reloc section does not use the main symbol
2401            table we don't treat it as a reloc section.  BFD can't
2402            adequately represent such a section, so at least for now,
2403            we don't try.  We just present it as a normal section.  We
2404            also can't use it as a reloc section if it points to the
2405            null section, an invalid section, another reloc section, or
2406            its sh_link points to the null section.  */
2407         if (((abfd->flags & (DYNAMIC | EXEC_P)) != 0
2408              && (hdr->sh_flags & SHF_ALLOC) != 0)
2409             || hdr->sh_link == SHN_UNDEF
2410             || hdr->sh_link != elf_onesymtab (abfd)
2411             || hdr->sh_info == SHN_UNDEF
2412             || hdr->sh_info >= num_sec
2413             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2414             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2415           {
2416             ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2417                                                    shindex);
2418             goto success;
2419           }
2420
2421         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2422           goto fail;
2423
2424         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2425         if (target_sect == NULL)
2426           goto fail;
2427
2428         esdt = elf_section_data (target_sect);
2429         if (hdr->sh_type == SHT_RELA)
2430           p_hdr = &esdt->rela.hdr;
2431         else
2432           p_hdr = &esdt->rel.hdr;
2433
2434         /* PR 17512: file: 0b4f81b7.  */
2435         if (*p_hdr != NULL)
2436           goto fail;
2437         hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
2438         if (hdr2 == NULL)
2439           goto fail;
2440         *hdr2 = *hdr;
2441         *p_hdr = hdr2;
2442         elf_elfsections (abfd)[shindex] = hdr2;
2443         target_sect->reloc_count += (NUM_SHDR_ENTRIES (hdr)
2444                                      * bed->s->int_rels_per_ext_rel);
2445         target_sect->flags |= SEC_RELOC;
2446         target_sect->relocation = NULL;
2447         target_sect->rel_filepos = hdr->sh_offset;
2448         /* In the section to which the relocations apply, mark whether
2449            its relocations are of the REL or RELA variety.  */
2450         if (hdr->sh_size != 0)
2451           {
2452             if (hdr->sh_type == SHT_RELA)
2453               target_sect->use_rela_p = 1;
2454           }
2455         abfd->flags |= HAS_RELOC;
2456         goto success;
2457       }
2458
2459     case SHT_GNU_verdef:
2460       elf_dynverdef (abfd) = shindex;
2461       elf_tdata (abfd)->dynverdef_hdr = *hdr;
2462       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2463       goto success;
2464
2465     case SHT_GNU_versym:
2466       if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2467         goto fail;
2468
2469       elf_dynversym (abfd) = shindex;
2470       elf_tdata (abfd)->dynversym_hdr = *hdr;
2471       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2472       goto success;
2473
2474     case SHT_GNU_verneed:
2475       elf_dynverref (abfd) = shindex;
2476       elf_tdata (abfd)->dynverref_hdr = *hdr;
2477       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2478       goto success;
2479
2480     case SHT_SHLIB:
2481       goto success;
2482
2483     case SHT_GROUP:
2484       if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
2485         goto fail;
2486
2487       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2488         goto fail;
2489
2490       goto success;
2491
2492     default:
2493       /* Possibly an attributes section.  */
2494       if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2495           || hdr->sh_type == bed->obj_attrs_section_type)
2496         {
2497           if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2498             goto fail;
2499           _bfd_elf_parse_attributes (abfd, hdr);
2500           goto success;
2501         }
2502
2503       /* Check for any processor-specific section types.  */
2504       if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2505         goto success;
2506
2507       if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2508         {
2509           if ((hdr->sh_flags & SHF_ALLOC) != 0)
2510             /* FIXME: How to properly handle allocated section reserved
2511                for applications?  */
2512             _bfd_error_handler
2513               /* xgettext:c-format */
2514               (_("%pB: unknown type [%#x] section `%s'"),
2515                abfd, hdr->sh_type, name);
2516           else
2517             {
2518               /* Allow sections reserved for applications.  */
2519               ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2520                                                      shindex);
2521               goto success;
2522             }
2523         }
2524       else if (hdr->sh_type >= SHT_LOPROC
2525                && hdr->sh_type <= SHT_HIPROC)
2526         /* FIXME: We should handle this section.  */
2527         _bfd_error_handler
2528           /* xgettext:c-format */
2529           (_("%pB: unknown type [%#x] section `%s'"),
2530            abfd, hdr->sh_type, name);
2531       else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2532         {
2533           /* Unrecognised OS-specific sections.  */
2534           if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2535             /* SHF_OS_NONCONFORMING indicates that special knowledge is
2536                required to correctly process the section and the file should
2537                be rejected with an error message.  */
2538             _bfd_error_handler
2539               /* xgettext:c-format */
2540               (_("%pB: unknown type [%#x] section `%s'"),
2541                abfd, hdr->sh_type, name);
2542           else
2543             {
2544               /* Otherwise it should be processed.  */
2545               ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2546               goto success;
2547             }
2548         }
2549       else
2550         /* FIXME: We should handle this section.  */
2551         _bfd_error_handler
2552           /* xgettext:c-format */
2553           (_("%pB: unknown type [%#x] section `%s'"),
2554            abfd, hdr->sh_type, name);
2555
2556       goto fail;
2557     }
2558
2559  fail:
2560   ret = FALSE;
2561  success:
2562   if (sections_being_created && sections_being_created_abfd == abfd)
2563     sections_being_created [shindex] = FALSE;
2564   if (-- nesting == 0)
2565     {
2566       sections_being_created = NULL;
2567       sections_being_created_abfd = abfd;
2568     }
2569   return ret;
2570 }
2571
2572 /* Return the local symbol specified by ABFD, R_SYMNDX.  */
2573
2574 Elf_Internal_Sym *
2575 bfd_sym_from_r_symndx (struct sym_cache *cache,
2576                        bfd *abfd,
2577                        unsigned long r_symndx)
2578 {
2579   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2580
2581   if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2582     {
2583       Elf_Internal_Shdr *symtab_hdr;
2584       unsigned char esym[sizeof (Elf64_External_Sym)];
2585       Elf_External_Sym_Shndx eshndx;
2586
2587       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2588       if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2589                                 &cache->sym[ent], esym, &eshndx) == NULL)
2590         return NULL;
2591
2592       if (cache->abfd != abfd)
2593         {
2594           memset (cache->indx, -1, sizeof (cache->indx));
2595           cache->abfd = abfd;
2596         }
2597       cache->indx[ent] = r_symndx;
2598     }
2599
2600   return &cache->sym[ent];
2601 }
2602
2603 /* Given an ELF section number, retrieve the corresponding BFD
2604    section.  */
2605
2606 asection *
2607 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2608 {
2609   if (sec_index >= elf_numsections (abfd))
2610     return NULL;
2611   return elf_elfsections (abfd)[sec_index]->bfd_section;
2612 }
2613
2614 static const struct bfd_elf_special_section special_sections_b[] =
2615 {
2616   { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2617   { NULL,                   0,  0, 0,            0 }
2618 };
2619
2620 static const struct bfd_elf_special_section special_sections_c[] =
2621 {
2622   { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2623   { NULL,                       0, 0, 0,            0 }
2624 };
2625
2626 static const struct bfd_elf_special_section special_sections_d[] =
2627 {
2628   { STRING_COMMA_LEN (".data"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2629   { STRING_COMMA_LEN (".data1"),         0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2630   /* There are more DWARF sections than these, but they needn't be added here
2631      unless you have to cope with broken compilers that don't emit section
2632      attributes or you want to help the user writing assembler.  */
2633   { STRING_COMMA_LEN (".debug"),         0, SHT_PROGBITS, 0 },
2634   { STRING_COMMA_LEN (".debug_line"),    0, SHT_PROGBITS, 0 },
2635   { STRING_COMMA_LEN (".debug_info"),    0, SHT_PROGBITS, 0 },
2636   { STRING_COMMA_LEN (".debug_abbrev"),  0, SHT_PROGBITS, 0 },
2637   { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2638   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  SHF_ALLOC },
2639   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   SHF_ALLOC },
2640   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   SHF_ALLOC },
2641   { NULL,                      0,        0, 0,            0 }
2642 };
2643
2644 static const struct bfd_elf_special_section special_sections_f[] =
2645 {
2646   { STRING_COMMA_LEN (".fini"),        0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2647   { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2648   { NULL,                          0 , 0, 0,              0 }
2649 };
2650
2651 static const struct bfd_elf_special_section special_sections_g[] =
2652 {
2653   { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS,      SHF_ALLOC + SHF_WRITE },
2654   { STRING_COMMA_LEN (".gnu.lto_"),       -1, SHT_PROGBITS,    SHF_EXCLUDE },
2655   { STRING_COMMA_LEN (".got"),             0, SHT_PROGBITS,    SHF_ALLOC + SHF_WRITE },
2656   { STRING_COMMA_LEN (".gnu.version"),     0, SHT_GNU_versym,  0 },
2657   { STRING_COMMA_LEN (".gnu.version_d"),   0, SHT_GNU_verdef,  0 },
2658   { STRING_COMMA_LEN (".gnu.version_r"),   0, SHT_GNU_verneed, 0 },
2659   { STRING_COMMA_LEN (".gnu.liblist"),     0, SHT_GNU_LIBLIST, SHF_ALLOC },
2660   { STRING_COMMA_LEN (".gnu.conflict"),    0, SHT_RELA,        SHF_ALLOC },
2661   { STRING_COMMA_LEN (".gnu.hash"),        0, SHT_GNU_HASH,    SHF_ALLOC },
2662   { NULL,                        0,        0, 0,               0 }
2663 };
2664
2665 static const struct bfd_elf_special_section special_sections_h[] =
2666 {
2667   { STRING_COMMA_LEN (".hash"), 0, SHT_HASH,     SHF_ALLOC },
2668   { NULL,                    0, 0, 0,            0 }
2669 };
2670
2671 static const struct bfd_elf_special_section special_sections_i[] =
2672 {
2673   { STRING_COMMA_LEN (".init"),        0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2674   { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2675   { STRING_COMMA_LEN (".interp"),      0, SHT_PROGBITS,   0 },
2676   { NULL,                      0,      0, 0,              0 }
2677 };
2678
2679 static const struct bfd_elf_special_section special_sections_l[] =
2680 {
2681   { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2682   { NULL,                    0, 0, 0,            0 }
2683 };
2684
2685 static const struct bfd_elf_special_section special_sections_n[] =
2686 {
2687   { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2688   { STRING_COMMA_LEN (".note"),          -1, SHT_NOTE,     0 },
2689   { NULL,                    0,           0, 0,            0 }
2690 };
2691
2692 static const struct bfd_elf_special_section special_sections_p[] =
2693 {
2694   { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2695   { STRING_COMMA_LEN (".plt"),            0, SHT_PROGBITS,      SHF_ALLOC + SHF_EXECINSTR },
2696   { NULL,                   0,            0, 0,                 0 }
2697 };
2698
2699 static const struct bfd_elf_special_section special_sections_r[] =
2700 {
2701   { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2702   { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2703   { STRING_COMMA_LEN (".rela"),   -1, SHT_RELA,     0 },
2704   { STRING_COMMA_LEN (".rel"),    -1, SHT_REL,      0 },
2705   { NULL,                   0,     0, 0,            0 }
2706 };
2707
2708 static const struct bfd_elf_special_section special_sections_s[] =
2709 {
2710   { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2711   { STRING_COMMA_LEN (".strtab"),   0, SHT_STRTAB, 0 },
2712   { STRING_COMMA_LEN (".symtab"),   0, SHT_SYMTAB, 0 },
2713   /* See struct bfd_elf_special_section declaration for the semantics of
2714      this special case where .prefix_length != strlen (.prefix).  */
2715   { ".stabstr",                 5,  3, SHT_STRTAB, 0 },
2716   { NULL,                       0,  0, 0,          0 }
2717 };
2718
2719 static const struct bfd_elf_special_section special_sections_t[] =
2720 {
2721   { STRING_COMMA_LEN (".text"),  -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2722   { STRING_COMMA_LEN (".tbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2723   { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2724   { NULL,                     0,  0, 0,            0 }
2725 };
2726
2727 static const struct bfd_elf_special_section special_sections_z[] =
2728 {
2729   { STRING_COMMA_LEN (".zdebug_line"),    0, SHT_PROGBITS, 0 },
2730   { STRING_COMMA_LEN (".zdebug_info"),    0, SHT_PROGBITS, 0 },
2731   { STRING_COMMA_LEN (".zdebug_abbrev"),  0, SHT_PROGBITS, 0 },
2732   { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2733   { NULL,                     0,  0, 0,            0 }
2734 };
2735
2736 static const struct bfd_elf_special_section * const special_sections[] =
2737 {
2738   special_sections_b,           /* 'b' */
2739   special_sections_c,           /* 'c' */
2740   special_sections_d,           /* 'd' */
2741   NULL,                         /* 'e' */
2742   special_sections_f,           /* 'f' */
2743   special_sections_g,           /* 'g' */
2744   special_sections_h,           /* 'h' */
2745   special_sections_i,           /* 'i' */
2746   NULL,                         /* 'j' */
2747   NULL,                         /* 'k' */
2748   special_sections_l,           /* 'l' */
2749   NULL,                         /* 'm' */
2750   special_sections_n,           /* 'n' */
2751   NULL,                         /* 'o' */
2752   special_sections_p,           /* 'p' */
2753   NULL,                         /* 'q' */
2754   special_sections_r,           /* 'r' */
2755   special_sections_s,           /* 's' */
2756   special_sections_t,           /* 't' */
2757   NULL,                         /* 'u' */
2758   NULL,                         /* 'v' */
2759   NULL,                         /* 'w' */
2760   NULL,                         /* 'x' */
2761   NULL,                         /* 'y' */
2762   special_sections_z            /* 'z' */
2763 };
2764
2765 const struct bfd_elf_special_section *
2766 _bfd_elf_get_special_section (const char *name,
2767                               const struct bfd_elf_special_section *spec,
2768                               unsigned int rela)
2769 {
2770   int i;
2771   int len;
2772
2773   len = strlen (name);
2774
2775   for (i = 0; spec[i].prefix != NULL; i++)
2776     {
2777       int suffix_len;
2778       int prefix_len = spec[i].prefix_length;
2779
2780       if (len < prefix_len)
2781         continue;
2782       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2783         continue;
2784
2785       suffix_len = spec[i].suffix_length;
2786       if (suffix_len <= 0)
2787         {
2788           if (name[prefix_len] != 0)
2789             {
2790               if (suffix_len == 0)
2791                 continue;
2792               if (name[prefix_len] != '.'
2793                   && (suffix_len == -2
2794                       || (rela && spec[i].type == SHT_REL)))
2795                 continue;
2796             }
2797         }
2798       else
2799         {
2800           if (len < prefix_len + suffix_len)
2801             continue;
2802           if (memcmp (name + len - suffix_len,
2803                       spec[i].prefix + prefix_len,
2804                       suffix_len) != 0)
2805             continue;
2806         }
2807       return &spec[i];
2808     }
2809
2810   return NULL;
2811 }
2812
2813 const struct bfd_elf_special_section *
2814 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2815 {
2816   int i;
2817   const struct bfd_elf_special_section *spec;
2818   const struct elf_backend_data *bed;
2819
2820   /* See if this is one of the special sections.  */
2821   if (sec->name == NULL)
2822     return NULL;
2823
2824   bed = get_elf_backend_data (abfd);
2825   spec = bed->special_sections;
2826   if (spec)
2827     {
2828       spec = _bfd_elf_get_special_section (sec->name,
2829                                            bed->special_sections,
2830                                            sec->use_rela_p);
2831       if (spec != NULL)
2832         return spec;
2833     }
2834
2835   if (sec->name[0] != '.')
2836     return NULL;
2837
2838   i = sec->name[1] - 'b';
2839   if (i < 0 || i > 'z' - 'b')
2840     return NULL;
2841
2842   spec = special_sections[i];
2843
2844   if (spec == NULL)
2845     return NULL;
2846
2847   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2848 }
2849
2850 bfd_boolean
2851 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2852 {
2853   struct bfd_elf_section_data *sdata;
2854   const struct elf_backend_data *bed;
2855   const struct bfd_elf_special_section *ssect;
2856
2857   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2858   if (sdata == NULL)
2859     {
2860       sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2861                                                           sizeof (*sdata));
2862       if (sdata == NULL)
2863         return FALSE;
2864       sec->used_by_bfd = sdata;
2865     }
2866
2867   /* Indicate whether or not this section should use RELA relocations.  */
2868   bed = get_elf_backend_data (abfd);
2869   sec->use_rela_p = bed->default_use_rela_p;
2870
2871   /* When we read a file, we don't need to set ELF section type and
2872      flags.  They will be overridden in _bfd_elf_make_section_from_shdr
2873      anyway.  We will set ELF section type and flags for all linker
2874      created sections.  If user specifies BFD section flags, we will
2875      set ELF section type and flags based on BFD section flags in
2876      elf_fake_sections.  Special handling for .init_array/.fini_array
2877      output sections since they may contain .ctors/.dtors input
2878      sections.  We don't want _bfd_elf_init_private_section_data to
2879      copy ELF section type from .ctors/.dtors input sections.  */
2880   if (abfd->direction != read_direction
2881       || (sec->flags & SEC_LINKER_CREATED) != 0)
2882     {
2883       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2884       if (ssect != NULL
2885           && (!sec->flags
2886               || (sec->flags & SEC_LINKER_CREATED) != 0
2887               || ssect->type == SHT_INIT_ARRAY
2888               || ssect->type == SHT_FINI_ARRAY))
2889         {
2890           elf_section_type (sec) = ssect->type;
2891           elf_section_flags (sec) = ssect->attr;
2892         }
2893     }
2894
2895   return _bfd_generic_new_section_hook (abfd, sec);
2896 }
2897
2898 /* Create a new bfd section from an ELF program header.
2899
2900    Since program segments have no names, we generate a synthetic name
2901    of the form segment<NUM>, where NUM is generally the index in the
2902    program header table.  For segments that are split (see below) we
2903    generate the names segment<NUM>a and segment<NUM>b.
2904
2905    Note that some program segments may have a file size that is different than
2906    (less than) the memory size.  All this means is that at execution the
2907    system must allocate the amount of memory specified by the memory size,
2908    but only initialize it with the first "file size" bytes read from the
2909    file.  This would occur for example, with program segments consisting
2910    of combined data+bss.
2911
2912    To handle the above situation, this routine generates TWO bfd sections
2913    for the single program segment.  The first has the length specified by
2914    the file size of the segment, and the second has the length specified
2915    by the difference between the two sizes.  In effect, the segment is split
2916    into its initialized and uninitialized parts.
2917
2918  */
2919
2920 bfd_boolean
2921 _bfd_elf_make_section_from_phdr (bfd *abfd,
2922                                  Elf_Internal_Phdr *hdr,
2923                                  int hdr_index,
2924                                  const char *type_name)
2925 {
2926   asection *newsect;
2927   char *name;
2928   char namebuf[64];
2929   size_t len;
2930   int split;
2931
2932   split = ((hdr->p_memsz > 0)
2933             && (hdr->p_filesz > 0)
2934             && (hdr->p_memsz > hdr->p_filesz));
2935
2936   if (hdr->p_filesz > 0)
2937     {
2938       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2939       len = strlen (namebuf) + 1;
2940       name = (char *) bfd_alloc (abfd, len);
2941       if (!name)
2942         return FALSE;
2943       memcpy (name, namebuf, len);
2944       newsect = bfd_make_section (abfd, name);
2945       if (newsect == NULL)
2946         return FALSE;
2947       newsect->vma = hdr->p_vaddr;
2948       newsect->lma = hdr->p_paddr;
2949       newsect->size = hdr->p_filesz;
2950       newsect->filepos = hdr->p_offset;
2951       newsect->flags |= SEC_HAS_CONTENTS;
2952       newsect->alignment_power = bfd_log2 (hdr->p_align);
2953       if (hdr->p_type == PT_LOAD)
2954         {
2955           newsect->flags |= SEC_ALLOC;
2956           newsect->flags |= SEC_LOAD;
2957           if (hdr->p_flags & PF_X)
2958             {
2959               /* FIXME: all we known is that it has execute PERMISSION,
2960                  may be data.  */
2961               newsect->flags |= SEC_CODE;
2962             }
2963         }
2964       if (!(hdr->p_flags & PF_W))
2965         {
2966           newsect->flags |= SEC_READONLY;
2967         }
2968     }
2969
2970   if (hdr->p_memsz > hdr->p_filesz)
2971     {
2972       bfd_vma align;
2973
2974       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2975       len = strlen (namebuf) + 1;
2976       name = (char *) bfd_alloc (abfd, len);
2977       if (!name)
2978         return FALSE;
2979       memcpy (name, namebuf, len);
2980       newsect = bfd_make_section (abfd, name);
2981       if (newsect == NULL)
2982         return FALSE;
2983       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2984       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2985       newsect->size = hdr->p_memsz - hdr->p_filesz;
2986       newsect->filepos = hdr->p_offset + hdr->p_filesz;
2987       align = newsect->vma & -newsect->vma;
2988       if (align == 0 || align > hdr->p_align)
2989         align = hdr->p_align;
2990       newsect->alignment_power = bfd_log2 (align);
2991       if (hdr->p_type == PT_LOAD)
2992         {
2993           /* Hack for gdb.  Segments that have not been modified do
2994              not have their contents written to a core file, on the
2995              assumption that a debugger can find the contents in the
2996              executable.  We flag this case by setting the fake
2997              section size to zero.  Note that "real" bss sections will
2998              always have their contents dumped to the core file.  */
2999           if (bfd_get_format (abfd) == bfd_core)
3000             newsect->size = 0;
3001           newsect->flags |= SEC_ALLOC;
3002           if (hdr->p_flags & PF_X)
3003             newsect->flags |= SEC_CODE;
3004         }
3005       if (!(hdr->p_flags & PF_W))
3006         newsect->flags |= SEC_READONLY;
3007     }
3008
3009   return TRUE;
3010 }
3011
3012 bfd_boolean
3013 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
3014 {
3015   const struct elf_backend_data *bed;
3016
3017   switch (hdr->p_type)
3018     {
3019     case PT_NULL:
3020       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
3021
3022     case PT_LOAD:
3023       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
3024
3025     case PT_DYNAMIC:
3026       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
3027
3028     case PT_INTERP:
3029       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
3030
3031     case PT_NOTE:
3032       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
3033         return FALSE;
3034       if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz,
3035                             hdr->p_align))
3036         return FALSE;
3037       return TRUE;
3038
3039     case PT_SHLIB:
3040       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
3041
3042     case PT_PHDR:
3043       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
3044
3045     case PT_GNU_EH_FRAME:
3046       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
3047                                               "eh_frame_hdr");
3048
3049     case PT_GNU_STACK:
3050       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
3051
3052     case PT_GNU_RELRO:
3053       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
3054
3055     default:
3056       /* Check for any processor-specific program segment types.  */
3057       bed = get_elf_backend_data (abfd);
3058       return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
3059     }
3060 }
3061
3062 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3063    REL or RELA.  */
3064
3065 Elf_Internal_Shdr *
3066 _bfd_elf_single_rel_hdr (asection *sec)
3067 {
3068   if (elf_section_data (sec)->rel.hdr)
3069     {
3070       BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
3071       return elf_section_data (sec)->rel.hdr;
3072     }
3073   else
3074     return elf_section_data (sec)->rela.hdr;
3075 }
3076
3077 static bfd_boolean
3078 _bfd_elf_set_reloc_sh_name (bfd *abfd,
3079                             Elf_Internal_Shdr *rel_hdr,
3080                             const char *sec_name,
3081                             bfd_boolean use_rela_p)
3082 {
3083   char *name = (char *) bfd_alloc (abfd,
3084                                    sizeof ".rela" + strlen (sec_name));
3085   if (name == NULL)
3086     return FALSE;
3087
3088   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
3089   rel_hdr->sh_name =
3090     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
3091                                         FALSE);
3092   if (rel_hdr->sh_name == (unsigned int) -1)
3093     return FALSE;
3094
3095   return TRUE;
3096 }
3097
3098 /* Allocate and initialize a section-header for a new reloc section,
3099    containing relocations against ASECT.  It is stored in RELDATA.  If
3100    USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3101    relocations.  */
3102
3103 static bfd_boolean
3104 _bfd_elf_init_reloc_shdr (bfd *abfd,
3105                           struct bfd_elf_section_reloc_data *reldata,
3106                           const char *sec_name,
3107                           bfd_boolean use_rela_p,
3108                           bfd_boolean delay_st_name_p)
3109 {
3110   Elf_Internal_Shdr *rel_hdr;
3111   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3112
3113   BFD_ASSERT (reldata->hdr == NULL);
3114   rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
3115   reldata->hdr = rel_hdr;
3116
3117   if (delay_st_name_p)
3118     rel_hdr->sh_name = (unsigned int) -1;
3119   else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
3120                                         use_rela_p))
3121     return FALSE;
3122   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
3123   rel_hdr->sh_entsize = (use_rela_p
3124                          ? bed->s->sizeof_rela
3125                          : bed->s->sizeof_rel);
3126   rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
3127   rel_hdr->sh_flags = 0;
3128   rel_hdr->sh_addr = 0;
3129   rel_hdr->sh_size = 0;
3130   rel_hdr->sh_offset = 0;
3131
3132   return TRUE;
3133 }
3134
3135 /* Return the default section type based on the passed in section flags.  */
3136
3137 int
3138 bfd_elf_get_default_section_type (flagword flags)
3139 {
3140   if ((flags & (SEC_ALLOC | SEC_IS_COMMON)) != 0
3141       && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3142     return SHT_NOBITS;
3143   return SHT_PROGBITS;
3144 }
3145
3146 struct fake_section_arg
3147 {
3148   struct bfd_link_info *link_info;
3149   bfd_boolean failed;
3150 };
3151
3152 /* Set up an ELF internal section header for a section.  */
3153
3154 static void
3155 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
3156 {
3157   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
3158   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3159   struct bfd_elf_section_data *esd = elf_section_data (asect);
3160   Elf_Internal_Shdr *this_hdr;
3161   unsigned int sh_type;
3162   const char *name = asect->name;
3163   bfd_boolean delay_st_name_p = FALSE;
3164
3165   if (arg->failed)
3166     {
3167       /* We already failed; just get out of the bfd_map_over_sections
3168          loop.  */
3169       return;
3170     }
3171
3172   this_hdr = &esd->this_hdr;
3173
3174   if (arg->link_info)
3175     {
3176       /* ld: compress DWARF debug sections with names: .debug_*.  */
3177       if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
3178           && (asect->flags & SEC_DEBUGGING)
3179           && name[1] == 'd'
3180           && name[6] == '_')
3181         {
3182           /* Set SEC_ELF_COMPRESS to indicate this section should be
3183              compressed.  */
3184           asect->flags |= SEC_ELF_COMPRESS;
3185
3186           /* If this section will be compressed, delay adding section
3187              name to section name section after it is compressed in
3188              _bfd_elf_assign_file_positions_for_non_load.  */
3189           delay_st_name_p = TRUE;
3190         }
3191     }
3192   else if ((asect->flags & SEC_ELF_RENAME))
3193     {
3194       /* objcopy: rename output DWARF debug section.  */
3195       if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
3196         {
3197           /* When we decompress or compress with SHF_COMPRESSED,
3198              convert section name from .zdebug_* to .debug_* if
3199              needed.  */
3200           if (name[1] == 'z')
3201             {
3202               char *new_name = convert_zdebug_to_debug (abfd, name);
3203               if (new_name == NULL)
3204                 {
3205                   arg->failed = TRUE;
3206                   return;
3207                 }
3208               name = new_name;
3209             }
3210         }
3211       else if (asect->compress_status == COMPRESS_SECTION_DONE)
3212         {
3213           /* PR binutils/18087: Compression does not always make a
3214              section smaller.  So only rename the section when
3215              compression has actually taken place.  If input section
3216              name is .zdebug_*, we should never compress it again.  */
3217           char *new_name = convert_debug_to_zdebug (abfd, name);
3218           if (new_name == NULL)
3219             {
3220               arg->failed = TRUE;
3221               return;
3222             }
3223           BFD_ASSERT (name[1] != 'z');
3224           name = new_name;
3225         }
3226     }
3227
3228   if (delay_st_name_p)
3229     this_hdr->sh_name = (unsigned int) -1;
3230   else
3231     {
3232       this_hdr->sh_name
3233         = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3234                                               name, FALSE);
3235       if (this_hdr->sh_name == (unsigned int) -1)
3236         {
3237           arg->failed = TRUE;
3238           return;
3239         }
3240     }
3241
3242   /* Don't clear sh_flags. Assembler may set additional bits.  */
3243
3244   if ((asect->flags & SEC_ALLOC) != 0
3245       || asect->user_set_vma)
3246     this_hdr->sh_addr = asect->vma;
3247   else
3248     this_hdr->sh_addr = 0;
3249
3250   this_hdr->sh_offset = 0;
3251   this_hdr->sh_size = asect->size;
3252   this_hdr->sh_link = 0;
3253   /* PR 17512: file: 0eb809fe, 8b0535ee.  */
3254   if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
3255     {
3256       _bfd_error_handler
3257         /* xgettext:c-format */
3258         (_("%pB: error: alignment power %d of section `%pA' is too big"),
3259          abfd, asect->alignment_power, asect);
3260       arg->failed = TRUE;
3261       return;
3262     }
3263   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
3264   /* The sh_entsize and sh_info fields may have been set already by
3265      copy_private_section_data.  */
3266
3267   this_hdr->bfd_section = asect;
3268   this_hdr->contents = NULL;
3269
3270   /* If the section type is unspecified, we set it based on
3271      asect->flags.  */
3272   if ((asect->flags & SEC_GROUP) != 0)
3273     sh_type = SHT_GROUP;
3274   else
3275     sh_type = bfd_elf_get_default_section_type (asect->flags);
3276
3277   if (this_hdr->sh_type == SHT_NULL)
3278     this_hdr->sh_type = sh_type;
3279   else if (this_hdr->sh_type == SHT_NOBITS
3280            && sh_type == SHT_PROGBITS
3281            && (asect->flags & SEC_ALLOC) != 0)
3282     {
3283       /* Warn if we are changing a NOBITS section to PROGBITS, but
3284          allow the link to proceed.  This can happen when users link
3285          non-bss input sections to bss output sections, or emit data
3286          to a bss output section via a linker script.  */
3287       _bfd_error_handler
3288         (_("warning: section `%pA' type changed to PROGBITS"), asect);
3289       this_hdr->sh_type = sh_type;
3290     }
3291
3292   switch (this_hdr->sh_type)
3293     {
3294     default:
3295       break;
3296
3297     case SHT_STRTAB:
3298     case SHT_NOTE:
3299     case SHT_NOBITS:
3300     case SHT_PROGBITS:
3301       break;
3302
3303     case SHT_INIT_ARRAY:
3304     case SHT_FINI_ARRAY:
3305     case SHT_PREINIT_ARRAY:
3306       this_hdr->sh_entsize = bed->s->arch_size / 8;
3307       break;
3308
3309     case SHT_HASH:
3310       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
3311       break;
3312
3313     case SHT_DYNSYM:
3314       this_hdr->sh_entsize = bed->s->sizeof_sym;
3315       break;
3316
3317     case SHT_DYNAMIC:
3318       this_hdr->sh_entsize = bed->s->sizeof_dyn;
3319       break;
3320
3321     case SHT_RELA:
3322       if (get_elf_backend_data (abfd)->may_use_rela_p)
3323         this_hdr->sh_entsize = bed->s->sizeof_rela;
3324       break;
3325
3326      case SHT_REL:
3327       if (get_elf_backend_data (abfd)->may_use_rel_p)
3328         this_hdr->sh_entsize = bed->s->sizeof_rel;
3329       break;
3330
3331      case SHT_GNU_versym:
3332       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
3333       break;
3334
3335      case SHT_GNU_verdef:
3336       this_hdr->sh_entsize = 0;
3337       /* objcopy or strip will copy over sh_info, but may not set
3338          cverdefs.  The linker will set cverdefs, but sh_info will be
3339          zero.  */
3340       if (this_hdr->sh_info == 0)
3341         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
3342       else
3343         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
3344                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
3345       break;
3346
3347     case SHT_GNU_verneed:
3348       this_hdr->sh_entsize = 0;
3349       /* objcopy or strip will copy over sh_info, but may not set
3350          cverrefs.  The linker will set cverrefs, but sh_info will be
3351          zero.  */
3352       if (this_hdr->sh_info == 0)
3353         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
3354       else
3355         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
3356                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
3357       break;
3358
3359     case SHT_GROUP:
3360       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
3361       break;
3362
3363     case SHT_GNU_HASH:
3364       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
3365       break;
3366     }
3367
3368   if ((asect->flags & SEC_ALLOC) != 0)
3369     this_hdr->sh_flags |= SHF_ALLOC;
3370   if ((asect->flags & SEC_READONLY) == 0)
3371     this_hdr->sh_flags |= SHF_WRITE;
3372   if ((asect->flags & SEC_CODE) != 0)
3373     this_hdr->sh_flags |= SHF_EXECINSTR;
3374   if ((asect->flags & SEC_MERGE) != 0)
3375     {
3376       this_hdr->sh_flags |= SHF_MERGE;
3377       this_hdr->sh_entsize = asect->entsize;
3378     }
3379   if ((asect->flags & SEC_STRINGS) != 0)
3380     this_hdr->sh_flags |= SHF_STRINGS;
3381   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
3382     this_hdr->sh_flags |= SHF_GROUP;
3383   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
3384     {
3385       this_hdr->sh_flags |= SHF_TLS;
3386       if (asect->size == 0
3387           && (asect->flags & SEC_HAS_CONTENTS) == 0)
3388         {
3389           struct bfd_link_order *o = asect->map_tail.link_order;
3390
3391           this_hdr->sh_size = 0;
3392           if (o != NULL)
3393             {
3394               this_hdr->sh_size = o->offset + o->size;
3395               if (this_hdr->sh_size != 0)
3396                 this_hdr->sh_type = SHT_NOBITS;
3397             }
3398         }
3399     }
3400   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
3401     this_hdr->sh_flags |= SHF_EXCLUDE;
3402
3403   /* If the section has relocs, set up a section header for the
3404      SHT_REL[A] section.  If two relocation sections are required for
3405      this section, it is up to the processor-specific back-end to
3406      create the other.  */
3407   if ((asect->flags & SEC_RELOC) != 0)
3408     {
3409       /* When doing a relocatable link, create both REL and RELA sections if
3410          needed.  */
3411       if (arg->link_info
3412           /* Do the normal setup if we wouldn't create any sections here.  */
3413           && esd->rel.count + esd->rela.count > 0
3414           && (bfd_link_relocatable (arg->link_info)
3415               || arg->link_info->emitrelocations))
3416         {
3417           if (esd->rel.count && esd->rel.hdr == NULL
3418               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name,
3419                                             FALSE, delay_st_name_p))
3420             {
3421               arg->failed = TRUE;
3422               return;
3423             }
3424           if (esd->rela.count && esd->rela.hdr == NULL
3425               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name,
3426                                             TRUE, delay_st_name_p))
3427             {
3428               arg->failed = TRUE;
3429               return;
3430             }
3431         }
3432       else if (!_bfd_elf_init_reloc_shdr (abfd,
3433                                           (asect->use_rela_p
3434                                            ? &esd->rela : &esd->rel),
3435                                           name,
3436                                           asect->use_rela_p,
3437                                           delay_st_name_p))
3438         {
3439           arg->failed = TRUE;
3440           return;
3441         }
3442     }
3443
3444   /* Check for processor-specific section types.  */
3445   sh_type = this_hdr->sh_type;
3446   if (bed->elf_backend_fake_sections
3447       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
3448     {
3449       arg->failed = TRUE;
3450       return;
3451     }
3452
3453   if (sh_type == SHT_NOBITS && asect->size != 0)
3454     {
3455       /* Don't change the header type from NOBITS if we are being
3456          called for objcopy --only-keep-debug.  */
3457       this_hdr->sh_type = sh_type;
3458     }
3459 }
3460
3461 /* Fill in the contents of a SHT_GROUP section.  Called from
3462    _bfd_elf_compute_section_file_positions for gas, objcopy, and
3463    when ELF targets use the generic linker, ld.  Called for ld -r
3464    from bfd_elf_final_link.  */
3465
3466 void
3467 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
3468 {
3469   bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
3470   asection *elt, *first;
3471   unsigned char *loc;
3472   bfd_boolean gas;
3473
3474   /* Ignore linker created group section.  See elfNN_ia64_object_p in
3475      elfxx-ia64.c.  */
3476   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
3477       || *failedptr)
3478     return;
3479
3480   if (elf_section_data (sec)->this_hdr.sh_info == 0)
3481     {
3482       unsigned long symindx = 0;
3483
3484       /* elf_group_id will have been set up by objcopy and the
3485          generic linker.  */
3486       if (elf_group_id (sec) != NULL)
3487         symindx = elf_group_id (sec)->udata.i;
3488
3489       if (symindx == 0)
3490         {
3491           /* If called from the assembler, swap_out_syms will have set up
3492              elf_section_syms.  */
3493           BFD_ASSERT (elf_section_syms (abfd) != NULL);
3494           symindx = elf_section_syms (abfd)[sec->index]->udata.i;
3495         }
3496       elf_section_data (sec)->this_hdr.sh_info = symindx;
3497     }
3498   else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
3499     {
3500       /* The ELF backend linker sets sh_info to -2 when the group
3501          signature symbol is global, and thus the index can't be
3502          set until all local symbols are output.  */
3503       asection *igroup;
3504       struct bfd_elf_section_data *sec_data;
3505       unsigned long symndx;
3506       unsigned long extsymoff;
3507       struct elf_link_hash_entry *h;
3508
3509       /* The point of this little dance to the first SHF_GROUP section
3510          then back to the SHT_GROUP section is that this gets us to
3511          the SHT_GROUP in the input object.  */
3512       igroup = elf_sec_group (elf_next_in_group (sec));
3513       sec_data = elf_section_data (igroup);
3514       symndx = sec_data->this_hdr.sh_info;
3515       extsymoff = 0;
3516       if (!elf_bad_symtab (igroup->owner))
3517         {
3518           Elf_Internal_Shdr *symtab_hdr;
3519
3520           symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
3521           extsymoff = symtab_hdr->sh_info;
3522         }
3523       h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
3524       while (h->root.type == bfd_link_hash_indirect
3525              || h->root.type == bfd_link_hash_warning)
3526         h = (struct elf_link_hash_entry *) h->root.u.i.link;
3527
3528       elf_section_data (sec)->this_hdr.sh_info = h->indx;
3529     }
3530
3531   /* The contents won't be allocated for "ld -r" or objcopy.  */
3532   gas = TRUE;
3533   if (sec->contents == NULL)
3534     {
3535       gas = FALSE;
3536       sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
3537
3538       /* Arrange for the section to be written out.  */
3539       elf_section_data (sec)->this_hdr.contents = sec->contents;
3540       if (sec->contents == NULL)
3541         {
3542           *failedptr = TRUE;
3543           return;
3544         }
3545     }
3546
3547   loc = sec->contents + sec->size;
3548
3549   /* Get the pointer to the first section in the group that gas
3550      squirreled away here.  objcopy arranges for this to be set to the
3551      start of the input section group.  */
3552   first = elt = elf_next_in_group (sec);
3553
3554   /* First element is a flag word.  Rest of section is elf section
3555      indices for all the sections of the group.  Write them backwards
3556      just to keep the group in the same order as given in .section
3557      directives, not that it matters.  */
3558   while (elt != NULL)
3559     {
3560       asection *s;
3561
3562       s = elt;
3563       if (!gas)
3564         s = s->output_section;
3565       if (s != NULL
3566           && !bfd_is_abs_section (s))
3567         {
3568           struct bfd_elf_section_data *elf_sec = elf_section_data (s);
3569           struct bfd_elf_section_data *input_elf_sec = elf_section_data (elt);
3570
3571           if (elf_sec->rel.hdr != NULL
3572               && (gas
3573                   || (input_elf_sec->rel.hdr != NULL
3574                       && input_elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0))
3575             {
3576               elf_sec->rel.hdr->sh_flags |= SHF_GROUP;
3577               loc -= 4;
3578               H_PUT_32 (abfd, elf_sec->rel.idx, loc);
3579             }
3580           if (elf_sec->rela.hdr != NULL
3581               && (gas
3582                   || (input_elf_sec->rela.hdr != NULL
3583                       && input_elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0))
3584             {
3585               elf_sec->rela.hdr->sh_flags |= SHF_GROUP;
3586               loc -= 4;
3587               H_PUT_32 (abfd, elf_sec->rela.idx, loc);
3588             }
3589           loc -= 4;
3590           H_PUT_32 (abfd, elf_sec->this_idx, loc);
3591         }
3592       elt = elf_next_in_group (elt);
3593       if (elt == first)
3594         break;
3595     }
3596
3597   loc -= 4;
3598   BFD_ASSERT (loc == sec->contents);
3599
3600   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
3601 }
3602
3603 /* Given NAME, the name of a relocation section stripped of its
3604    .rel/.rela prefix, return the section in ABFD to which the
3605    relocations apply.  */
3606
3607 asection *
3608 _bfd_elf_plt_get_reloc_section (bfd *abfd, const char *name)
3609 {
3610   /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3611      section likely apply to .got.plt or .got section.  */
3612   if (get_elf_backend_data (abfd)->want_got_plt
3613       && strcmp (name, ".plt") == 0)
3614     {
3615       asection *sec;
3616
3617       name = ".got.plt";
3618       sec = bfd_get_section_by_name (abfd, name);
3619       if (sec != NULL)
3620         return sec;
3621       name = ".got";
3622     }
3623
3624   return bfd_get_section_by_name (abfd, name);
3625 }
3626
3627 /* Return the section to which RELOC_SEC applies.  */
3628
3629 static asection *
3630 elf_get_reloc_section (asection *reloc_sec)
3631 {
3632   const char *name;
3633   unsigned int type;
3634   bfd *abfd;
3635   const struct elf_backend_data *bed;
3636
3637   type = elf_section_data (reloc_sec)->this_hdr.sh_type;
3638   if (type != SHT_REL && type != SHT_RELA)
3639     return NULL;
3640
3641   /* We look up the section the relocs apply to by name.  */
3642   name = reloc_sec->name;
3643   if (strncmp (name, ".rel", 4) != 0)
3644     return NULL;
3645   name += 4;
3646   if (type == SHT_RELA && *name++ != 'a')
3647     return NULL;
3648
3649   abfd = reloc_sec->owner;
3650   bed = get_elf_backend_data (abfd);
3651   return bed->get_reloc_section (abfd, name);
3652 }
3653
3654 /* Assign all ELF section numbers.  The dummy first section is handled here
3655    too.  The link/info pointers for the standard section types are filled
3656    in here too, while we're at it.  */
3657
3658 static bfd_boolean
3659 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
3660 {
3661   struct elf_obj_tdata *t = elf_tdata (abfd);
3662   asection *sec;
3663   unsigned int section_number;
3664   Elf_Internal_Shdr **i_shdrp;
3665   struct bfd_elf_section_data *d;
3666   bfd_boolean need_symtab;
3667
3668   section_number = 1;
3669
3670   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
3671
3672   /* SHT_GROUP sections are in relocatable files only.  */
3673   if (link_info == NULL || !link_info->resolve_section_groups)
3674     {
3675       size_t reloc_count = 0;
3676
3677       /* Put SHT_GROUP sections first.  */
3678       for (sec = abfd->sections; sec != NULL; sec = sec->next)
3679         {
3680           d = elf_section_data (sec);
3681
3682           if (d->this_hdr.sh_type == SHT_GROUP)
3683             {
3684               if (sec->flags & SEC_LINKER_CREATED)
3685                 {
3686                   /* Remove the linker created SHT_GROUP sections.  */
3687                   bfd_section_list_remove (abfd, sec);
3688                   abfd->section_count--;
3689                 }
3690               else
3691                 d->this_idx = section_number++;
3692             }
3693
3694           /* Count relocations.  */
3695           reloc_count += sec->reloc_count;
3696         }
3697
3698       /* Clear HAS_RELOC if there are no relocations.  */
3699       if (reloc_count == 0)
3700         abfd->flags &= ~HAS_RELOC;
3701     }
3702
3703   for (sec = abfd->sections; sec; sec = sec->next)
3704     {
3705       d = elf_section_data (sec);
3706
3707       if (d->this_hdr.sh_type != SHT_GROUP)
3708         d->this_idx = section_number++;
3709       if (d->this_hdr.sh_name != (unsigned int) -1)
3710         _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
3711       if (d->rel.hdr)
3712         {
3713           d->rel.idx = section_number++;
3714           if (d->rel.hdr->sh_name != (unsigned int) -1)
3715             _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
3716         }
3717       else
3718         d->rel.idx = 0;
3719
3720       if (d->rela.hdr)
3721         {
3722           d->rela.idx = section_number++;
3723           if (d->rela.hdr->sh_name != (unsigned int) -1)
3724             _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
3725         }
3726       else
3727         d->rela.idx = 0;
3728     }
3729
3730   need_symtab = (bfd_get_symcount (abfd) > 0
3731                 || (link_info == NULL
3732                     && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3733                         == HAS_RELOC)));
3734   if (need_symtab)
3735     {
3736       elf_onesymtab (abfd) = section_number++;
3737       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
3738       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
3739         {
3740           elf_section_list * entry;
3741
3742           BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL);
3743
3744           entry = bfd_zalloc (abfd, sizeof * entry);
3745           entry->ndx = section_number++;
3746           elf_symtab_shndx_list (abfd) = entry;
3747           entry->hdr.sh_name
3748             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3749                                                   ".symtab_shndx", FALSE);
3750           if (entry->hdr.sh_name == (unsigned int) -1)
3751             return FALSE;
3752         }
3753       elf_strtab_sec (abfd) = section_number++;
3754       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3755     }
3756
3757   elf_shstrtab_sec (abfd) = section_number++;
3758   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3759   elf_elfheader (abfd)->e_shstrndx = elf_shstrtab_sec (abfd);
3760
3761   if (section_number >= SHN_LORESERVE)
3762     {
3763       /* xgettext:c-format */
3764       _bfd_error_handler (_("%pB: too many sections: %u"),
3765                           abfd, section_number);
3766       return FALSE;
3767     }
3768
3769   elf_numsections (abfd) = section_number;
3770   elf_elfheader (abfd)->e_shnum = section_number;
3771
3772   /* Set up the list of section header pointers, in agreement with the
3773      indices.  */
3774   i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3775                                                 sizeof (Elf_Internal_Shdr *));
3776   if (i_shdrp == NULL)
3777     return FALSE;
3778
3779   i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3780                                                  sizeof (Elf_Internal_Shdr));
3781   if (i_shdrp[0] == NULL)
3782     {
3783       bfd_release (abfd, i_shdrp);
3784       return FALSE;
3785     }
3786
3787   elf_elfsections (abfd) = i_shdrp;
3788
3789   i_shdrp[elf_shstrtab_sec (abfd)] = &t->shstrtab_hdr;
3790   if (need_symtab)
3791     {
3792       i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr;
3793       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3794         {
3795           elf_section_list * entry = elf_symtab_shndx_list (abfd);
3796           BFD_ASSERT (entry != NULL);
3797           i_shdrp[entry->ndx] = & entry->hdr;
3798           entry->hdr.sh_link = elf_onesymtab (abfd);
3799         }
3800       i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
3801       t->symtab_hdr.sh_link = elf_strtab_sec (abfd);
3802     }
3803
3804   for (sec = abfd->sections; sec; sec = sec->next)
3805     {
3806       asection *s;
3807
3808       d = elf_section_data (sec);
3809
3810       i_shdrp[d->this_idx] = &d->this_hdr;
3811       if (d->rel.idx != 0)
3812         i_shdrp[d->rel.idx] = d->rel.hdr;
3813       if (d->rela.idx != 0)
3814         i_shdrp[d->rela.idx] = d->rela.hdr;
3815
3816       /* Fill in the sh_link and sh_info fields while we're at it.  */
3817
3818       /* sh_link of a reloc section is the section index of the symbol
3819          table.  sh_info is the section index of the section to which
3820          the relocation entries apply.  */
3821       if (d->rel.idx != 0)
3822         {
3823           d->rel.hdr->sh_link = elf_onesymtab (abfd);
3824           d->rel.hdr->sh_info = d->this_idx;
3825           d->rel.hdr->sh_flags |= SHF_INFO_LINK;
3826         }
3827       if (d->rela.idx != 0)
3828         {
3829           d->rela.hdr->sh_link = elf_onesymtab (abfd);
3830           d->rela.hdr->sh_info = d->this_idx;
3831           d->rela.hdr->sh_flags |= SHF_INFO_LINK;
3832         }
3833
3834       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3835       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3836         {
3837           s = elf_linked_to_section (sec);
3838           if (s)
3839             {
3840               /* elf_linked_to_section points to the input section.  */
3841               if (link_info != NULL)
3842                 {
3843                   /* Check discarded linkonce section.  */
3844                   if (discarded_section (s))
3845                     {
3846                       asection *kept;
3847                       _bfd_error_handler
3848                         /* xgettext:c-format */
3849                         (_("%pB: sh_link of section `%pA' points to"
3850                            " discarded section `%pA' of `%pB'"),
3851                          abfd, d->this_hdr.bfd_section,
3852                          s, s->owner);
3853                       /* Point to the kept section if it has the same
3854                          size as the discarded one.  */
3855                       kept = _bfd_elf_check_kept_section (s, link_info);
3856                       if (kept == NULL)
3857                         {
3858                           bfd_set_error (bfd_error_bad_value);
3859                           return FALSE;
3860                         }
3861                       s = kept;
3862                     }
3863
3864                   s = s->output_section;
3865                   BFD_ASSERT (s != NULL);
3866                 }
3867               else
3868                 {
3869                   /* Handle objcopy. */
3870                   if (s->output_section == NULL)
3871                     {
3872                       _bfd_error_handler
3873                         /* xgettext:c-format */
3874                         (_("%pB: sh_link of section `%pA' points to"
3875                            " removed section `%pA' of `%pB'"),
3876                          abfd, d->this_hdr.bfd_section, s, s->owner);
3877                       bfd_set_error (bfd_error_bad_value);
3878                       return FALSE;
3879                     }
3880                   s = s->output_section;
3881                 }
3882               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3883             }
3884           else
3885             {
3886               /* PR 290:
3887                  The Intel C compiler generates SHT_IA_64_UNWIND with
3888                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
3889                  sh_info fields.  Hence we could get the situation
3890                  where s is NULL.  */
3891               const struct elf_backend_data *bed
3892                 = get_elf_backend_data (abfd);
3893               if (bed->link_order_error_handler)
3894                 bed->link_order_error_handler
3895                   /* xgettext:c-format */
3896                   (_("%pB: warning: sh_link not set for section `%pA'"),
3897                    abfd, sec);
3898             }
3899         }
3900
3901       switch (d->this_hdr.sh_type)
3902         {
3903         case SHT_REL:
3904         case SHT_RELA:
3905           /* A reloc section which we are treating as a normal BFD
3906              section.  sh_link is the section index of the symbol
3907              table.  sh_info is the section index of the section to
3908              which the relocation entries apply.  We assume that an
3909              allocated reloc section uses the dynamic symbol table.
3910              FIXME: How can we be sure?  */
3911           s = bfd_get_section_by_name (abfd, ".dynsym");
3912           if (s != NULL)
3913             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3914
3915           s = elf_get_reloc_section (sec);
3916           if (s != NULL)
3917             {
3918               d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3919               d->this_hdr.sh_flags |= SHF_INFO_LINK;
3920             }
3921           break;
3922
3923         case SHT_STRTAB:
3924           /* We assume that a section named .stab*str is a stabs
3925              string section.  We look for a section with the same name
3926              but without the trailing ``str'', and set its sh_link
3927              field to point to this section.  */
3928           if (CONST_STRNEQ (sec->name, ".stab")
3929               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3930             {
3931               size_t len;
3932               char *alc;
3933
3934               len = strlen (sec->name);
3935               alc = (char *) bfd_malloc (len - 2);
3936               if (alc == NULL)
3937                 return FALSE;
3938               memcpy (alc, sec->name, len - 3);
3939               alc[len - 3] = '\0';
3940               s = bfd_get_section_by_name (abfd, alc);
3941               free (alc);
3942               if (s != NULL)
3943                 {
3944                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3945
3946                   /* This is a .stab section.  */
3947                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3948                     elf_section_data (s)->this_hdr.sh_entsize
3949                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3950                 }
3951             }
3952           break;
3953
3954         case SHT_DYNAMIC:
3955         case SHT_DYNSYM:
3956         case SHT_GNU_verneed:
3957         case SHT_GNU_verdef:
3958           /* sh_link is the section header index of the string table
3959              used for the dynamic entries, or the symbol table, or the
3960              version strings.  */
3961           s = bfd_get_section_by_name (abfd, ".dynstr");
3962           if (s != NULL)
3963             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3964           break;
3965
3966         case SHT_GNU_LIBLIST:
3967           /* sh_link is the section header index of the prelink library
3968              list used for the dynamic entries, or the symbol table, or
3969              the version strings.  */
3970           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3971                                              ? ".dynstr" : ".gnu.libstr");
3972           if (s != NULL)
3973             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3974           break;
3975
3976         case SHT_HASH:
3977         case SHT_GNU_HASH:
3978         case SHT_GNU_versym:
3979           /* sh_link is the section header index of the symbol table
3980              this hash table or version table is for.  */
3981           s = bfd_get_section_by_name (abfd, ".dynsym");
3982           if (s != NULL)
3983             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3984           break;
3985
3986         case SHT_GROUP:
3987           d->this_hdr.sh_link = elf_onesymtab (abfd);
3988         }
3989     }
3990
3991   /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3992      _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3993      debug section name from .debug_* to .zdebug_* if needed.  */
3994
3995   return TRUE;
3996 }
3997
3998 static bfd_boolean
3999 sym_is_global (bfd *abfd, asymbol *sym)
4000 {
4001   /* If the backend has a special mapping, use it.  */
4002   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4003   if (bed->elf_backend_sym_is_global)
4004     return (*bed->elf_backend_sym_is_global) (abfd, sym);
4005
4006   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
4007           || bfd_is_und_section (bfd_get_section (sym))
4008           || bfd_is_com_section (bfd_get_section (sym)));
4009 }
4010
4011 /* Filter global symbols of ABFD to include in the import library.  All
4012    SYMCOUNT symbols of ABFD can be examined from their pointers in
4013    SYMS.  Pointers of symbols to keep should be stored contiguously at
4014    the beginning of that array.
4015
4016    Returns the number of symbols to keep.  */
4017
4018 unsigned int
4019 _bfd_elf_filter_global_symbols (bfd *abfd, struct bfd_link_info *info,
4020                                 asymbol **syms, long symcount)
4021 {
4022   long src_count, dst_count = 0;
4023
4024   for (src_count = 0; src_count < symcount; src_count++)
4025     {
4026       asymbol *sym = syms[src_count];
4027       char *name = (char *) bfd_asymbol_name (sym);
4028       struct bfd_link_hash_entry *h;
4029
4030       if (!sym_is_global (abfd, sym))
4031         continue;
4032
4033       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
4034       if (h == NULL)
4035         continue;
4036       if (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak)
4037         continue;
4038       if (h->linker_def || h->ldscript_def)
4039         continue;
4040
4041       syms[dst_count++] = sym;
4042     }
4043
4044   syms[dst_count] = NULL;
4045
4046   return dst_count;
4047 }
4048
4049 /* Don't output section symbols for sections that are not going to be
4050    output, that are duplicates or there is no BFD section.  */
4051
4052 static bfd_boolean
4053 ignore_section_sym (bfd *abfd, asymbol *sym)
4054 {
4055   elf_symbol_type *type_ptr;
4056
4057   if (sym == NULL)
4058     return FALSE;
4059
4060   if ((sym->flags & BSF_SECTION_SYM) == 0)
4061     return FALSE;
4062
4063   if (sym->section == NULL)
4064     return TRUE;
4065
4066   type_ptr = elf_symbol_from (abfd, sym);
4067   return ((type_ptr != NULL
4068            && type_ptr->internal_elf_sym.st_shndx != 0
4069            && bfd_is_abs_section (sym->section))
4070           || !(sym->section->owner == abfd
4071                || (sym->section->output_section != NULL
4072                    && sym->section->output_section->owner == abfd
4073                    && sym->section->output_offset == 0)
4074                || bfd_is_abs_section (sym->section)));
4075 }
4076
4077 /* Map symbol from it's internal number to the external number, moving
4078    all local symbols to be at the head of the list.  */
4079
4080 static bfd_boolean
4081 elf_map_symbols (bfd *abfd, unsigned int *pnum_locals)
4082 {
4083   unsigned int symcount = bfd_get_symcount (abfd);
4084   asymbol **syms = bfd_get_outsymbols (abfd);
4085   asymbol **sect_syms;
4086   unsigned int num_locals = 0;
4087   unsigned int num_globals = 0;
4088   unsigned int num_locals2 = 0;
4089   unsigned int num_globals2 = 0;
4090   unsigned int max_index = 0;
4091   unsigned int idx;
4092   asection *asect;
4093   asymbol **new_syms;
4094
4095 #ifdef DEBUG
4096   fprintf (stderr, "elf_map_symbols\n");
4097   fflush (stderr);
4098 #endif
4099
4100   for (asect = abfd->sections; asect; asect = asect->next)
4101     {
4102       if (max_index < asect->index)
4103         max_index = asect->index;
4104     }
4105
4106   max_index++;
4107   sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
4108   if (sect_syms == NULL)
4109     return FALSE;
4110   elf_section_syms (abfd) = sect_syms;
4111   elf_num_section_syms (abfd) = max_index;
4112
4113   /* Init sect_syms entries for any section symbols we have already
4114      decided to output.  */
4115   for (idx = 0; idx < symcount; idx++)
4116     {
4117       asymbol *sym = syms[idx];
4118
4119       if ((sym->flags & BSF_SECTION_SYM) != 0
4120           && sym->value == 0
4121           && !ignore_section_sym (abfd, sym)
4122           && !bfd_is_abs_section (sym->section))
4123         {
4124           asection *sec = sym->section;
4125
4126           if (sec->owner != abfd)
4127             sec = sec->output_section;
4128
4129           sect_syms[sec->index] = syms[idx];
4130         }
4131     }
4132
4133   /* Classify all of the symbols.  */
4134   for (idx = 0; idx < symcount; idx++)
4135     {
4136       if (sym_is_global (abfd, syms[idx]))
4137         num_globals++;
4138       else if (!ignore_section_sym (abfd, syms[idx]))
4139         num_locals++;
4140     }
4141
4142   /* We will be adding a section symbol for each normal BFD section.  Most
4143      sections will already have a section symbol in outsymbols, but
4144      eg. SHT_GROUP sections will not, and we need the section symbol mapped
4145      at least in that case.  */
4146   for (asect = abfd->sections; asect; asect = asect->next)
4147     {
4148       if (sect_syms[asect->index] == NULL)
4149         {
4150           if (!sym_is_global (abfd, asect->symbol))
4151             num_locals++;
4152           else
4153             num_globals++;
4154         }
4155     }
4156
4157   /* Now sort the symbols so the local symbols are first.  */
4158   new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
4159                                       sizeof (asymbol *));
4160
4161   if (new_syms == NULL)
4162     return FALSE;
4163
4164   for (idx = 0; idx < symcount; idx++)
4165     {
4166       asymbol *sym = syms[idx];
4167       unsigned int i;
4168
4169       if (sym_is_global (abfd, sym))
4170         i = num_locals + num_globals2++;
4171       else if (!ignore_section_sym (abfd, sym))
4172         i = num_locals2++;
4173       else
4174         continue;
4175       new_syms[i] = sym;
4176       sym->udata.i = i + 1;
4177     }
4178   for (asect = abfd->sections; asect; asect = asect->next)
4179     {
4180       if (sect_syms[asect->index] == NULL)
4181         {
4182           asymbol *sym = asect->symbol;
4183           unsigned int i;
4184
4185           sect_syms[asect->index] = sym;
4186           if (!sym_is_global (abfd, sym))
4187             i = num_locals2++;
4188           else
4189             i = num_locals + num_globals2++;
4190           new_syms[i] = sym;
4191           sym->udata.i = i + 1;
4192         }
4193     }
4194
4195   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
4196
4197   *pnum_locals = num_locals;
4198   return TRUE;
4199 }
4200
4201 /* Align to the maximum file alignment that could be required for any
4202    ELF data structure.  */
4203
4204 static inline file_ptr
4205 align_file_position (file_ptr off, int align)
4206 {
4207   return (off + align - 1) & ~(align - 1);
4208 }
4209
4210 /* Assign a file position to a section, optionally aligning to the
4211    required section alignment.  */
4212
4213 file_ptr
4214 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
4215                                            file_ptr offset,
4216                                            bfd_boolean align)
4217 {
4218   if (align && i_shdrp->sh_addralign > 1)
4219     offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
4220   i_shdrp->sh_offset = offset;
4221   if (i_shdrp->bfd_section != NULL)
4222     i_shdrp->bfd_section->filepos = offset;
4223   if (i_shdrp->sh_type != SHT_NOBITS)
4224     offset += i_shdrp->sh_size;
4225   return offset;
4226 }
4227
4228 /* Compute the file positions we are going to put the sections at, and
4229    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
4230    is not NULL, this is being called by the ELF backend linker.  */
4231
4232 bfd_boolean
4233 _bfd_elf_compute_section_file_positions (bfd *abfd,
4234                                          struct bfd_link_info *link_info)
4235 {
4236   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4237   struct fake_section_arg fsargs;
4238   bfd_boolean failed;
4239   struct elf_strtab_hash *strtab = NULL;
4240   Elf_Internal_Shdr *shstrtab_hdr;
4241   bfd_boolean need_symtab;
4242
4243   if (abfd->output_has_begun)
4244     return TRUE;
4245
4246   /* Do any elf backend specific processing first.  */
4247   if (bed->elf_backend_begin_write_processing)
4248     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
4249
4250   if (! prep_headers (abfd))
4251     return FALSE;
4252
4253   /* Post process the headers if necessary.  */
4254   (*bed->elf_backend_post_process_headers) (abfd, link_info);
4255
4256   fsargs.failed = FALSE;
4257   fsargs.link_info = link_info;
4258   bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
4259   if (fsargs.failed)
4260     return FALSE;
4261
4262   if (!assign_section_numbers (abfd, link_info))
4263     return FALSE;
4264
4265   /* The backend linker builds symbol table information itself.  */
4266   need_symtab = (link_info == NULL
4267                  && (bfd_get_symcount (abfd) > 0
4268                      || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
4269                          == HAS_RELOC)));
4270   if (need_symtab)
4271     {
4272       /* Non-zero if doing a relocatable link.  */
4273       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
4274
4275       if (! swap_out_syms (abfd, &strtab, relocatable_p))
4276         return FALSE;
4277     }
4278
4279   failed = FALSE;
4280   if (link_info == NULL)
4281     {
4282       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
4283       if (failed)
4284         return FALSE;
4285     }
4286
4287   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
4288   /* sh_name was set in prep_headers.  */
4289   shstrtab_hdr->sh_type = SHT_STRTAB;
4290   shstrtab_hdr->sh_flags = bed->elf_strtab_flags;
4291   shstrtab_hdr->sh_addr = 0;
4292   /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load.  */
4293   shstrtab_hdr->sh_entsize = 0;
4294   shstrtab_hdr->sh_link = 0;
4295   shstrtab_hdr->sh_info = 0;
4296   /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load.  */
4297   shstrtab_hdr->sh_addralign = 1;
4298
4299   if (!assign_file_positions_except_relocs (abfd, link_info))
4300     return FALSE;
4301
4302   if (need_symtab)
4303     {
4304       file_ptr off;
4305       Elf_Internal_Shdr *hdr;
4306
4307       off = elf_next_file_pos (abfd);
4308
4309       hdr = & elf_symtab_hdr (abfd);
4310       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4311
4312       if (elf_symtab_shndx_list (abfd) != NULL)
4313         {
4314           hdr = & elf_symtab_shndx_list (abfd)->hdr;
4315           if (hdr->sh_size != 0)
4316             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4317           /* FIXME: What about other symtab_shndx sections in the list ?  */
4318         }
4319
4320       hdr = &elf_tdata (abfd)->strtab_hdr;
4321       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4322
4323       elf_next_file_pos (abfd) = off;
4324
4325       /* Now that we know where the .strtab section goes, write it
4326          out.  */
4327       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4328           || ! _bfd_elf_strtab_emit (abfd, strtab))
4329         return FALSE;
4330       _bfd_elf_strtab_free (strtab);
4331     }
4332
4333   abfd->output_has_begun = TRUE;
4334
4335   return TRUE;
4336 }
4337
4338 /* Make an initial estimate of the size of the program header.  If we
4339    get the number wrong here, we'll redo section placement.  */
4340
4341 static bfd_size_type
4342 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
4343 {
4344   size_t segs;
4345   asection *s;
4346   const struct elf_backend_data *bed;
4347
4348   /* Assume we will need exactly two PT_LOAD segments: one for text
4349      and one for data.  */
4350   segs = 2;
4351
4352   s = bfd_get_section_by_name (abfd, ".interp");
4353   if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->size != 0)
4354     {
4355       /* If we have a loadable interpreter section, we need a
4356          PT_INTERP segment.  In this case, assume we also need a
4357          PT_PHDR segment, although that may not be true for all
4358          targets.  */
4359       segs += 2;
4360     }
4361
4362   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4363     {
4364       /* We need a PT_DYNAMIC segment.  */
4365       ++segs;
4366     }
4367
4368   if (info != NULL && info->relro)
4369     {
4370       /* We need a PT_GNU_RELRO segment.  */
4371       ++segs;
4372     }
4373
4374   if (elf_eh_frame_hdr (abfd))
4375     {
4376       /* We need a PT_GNU_EH_FRAME segment.  */
4377       ++segs;
4378     }
4379
4380   if (elf_stack_flags (abfd))
4381     {
4382       /* We need a PT_GNU_STACK segment.  */
4383       ++segs;
4384     }
4385
4386   s = bfd_get_section_by_name (abfd,
4387                                NOTE_GNU_PROPERTY_SECTION_NAME);
4388   if (s != NULL && s->size != 0)
4389     {
4390       /* We need a PT_GNU_PROPERTY segment.  */
4391       ++segs;
4392     }
4393
4394   for (s = abfd->sections; s != NULL; s = s->next)
4395     {
4396       if ((s->flags & SEC_LOAD) != 0
4397           && elf_section_type (s) == SHT_NOTE)
4398         {
4399           unsigned int alignment_power;
4400           /* We need a PT_NOTE segment.  */
4401           ++segs;
4402           /* Try to create just one PT_NOTE segment for all adjacent
4403              loadable SHT_NOTE sections.  gABI requires that within a
4404              PT_NOTE segment (and also inside of each SHT_NOTE section)
4405              each note should have the same alignment.  So we check
4406              whether the sections are correctly aligned.  */
4407           alignment_power = s->alignment_power;
4408           while (s->next != NULL
4409                  && s->next->alignment_power == alignment_power
4410                  && (s->next->flags & SEC_LOAD) != 0
4411                  && elf_section_type (s->next) == SHT_NOTE)
4412             s = s->next;
4413         }
4414     }
4415
4416   for (s = abfd->sections; s != NULL; s = s->next)
4417     {
4418       if (s->flags & SEC_THREAD_LOCAL)
4419         {
4420           /* We need a PT_TLS segment.  */
4421           ++segs;
4422           break;
4423         }
4424     }
4425
4426   bed = get_elf_backend_data (abfd);
4427
4428  if ((abfd->flags & D_PAGED) != 0)
4429    {
4430      /* Add a PT_GNU_MBIND segment for each mbind section.  */
4431      unsigned int page_align_power = bfd_log2 (bed->commonpagesize);
4432      for (s = abfd->sections; s != NULL; s = s->next)
4433        if (elf_section_flags (s) & SHF_GNU_MBIND)
4434          {
4435            if (elf_section_data (s)->this_hdr.sh_info
4436                > PT_GNU_MBIND_NUM)
4437              {
4438                _bfd_error_handler
4439                  /* xgettext:c-format */
4440                  (_("%pB: GNU_MBIN section `%pA' has invalid sh_info field: %d"),
4441                      abfd, s, elf_section_data (s)->this_hdr.sh_info);
4442                continue;
4443              }
4444            /* Align mbind section to page size.  */
4445            if (s->alignment_power < page_align_power)
4446              s->alignment_power = page_align_power;
4447            segs ++;
4448          }
4449    }
4450
4451  /* Let the backend count up any program headers it might need.  */
4452  if (bed->elf_backend_additional_program_headers)
4453     {
4454       int a;
4455
4456       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
4457       if (a == -1)
4458         abort ();
4459       segs += a;
4460     }
4461
4462   return segs * bed->s->sizeof_phdr;
4463 }
4464
4465 /* Find the segment that contains the output_section of section.  */
4466
4467 Elf_Internal_Phdr *
4468 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
4469 {
4470   struct elf_segment_map *m;
4471   Elf_Internal_Phdr *p;
4472
4473   for (m = elf_seg_map (abfd), p = elf_tdata (abfd)->phdr;
4474        m != NULL;
4475        m = m->next, p++)
4476     {
4477       int i;
4478
4479       for (i = m->count - 1; i >= 0; i--)
4480         if (m->sections[i] == section)
4481           return p;
4482     }
4483
4484   return NULL;
4485 }
4486
4487 /* Create a mapping from a set of sections to a program segment.  */
4488
4489 static struct elf_segment_map *
4490 make_mapping (bfd *abfd,
4491               asection **sections,
4492               unsigned int from,
4493               unsigned int to,
4494               bfd_boolean phdr)
4495 {
4496   struct elf_segment_map *m;
4497   unsigned int i;
4498   asection **hdrpp;
4499   bfd_size_type amt;
4500
4501   amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4502   amt += (to - from) * sizeof (asection *);
4503   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4504   if (m == NULL)
4505     return NULL;
4506   m->next = NULL;
4507   m->p_type = PT_LOAD;
4508   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
4509     m->sections[i - from] = *hdrpp;
4510   m->count = to - from;
4511
4512   if (from == 0 && phdr)
4513     {
4514       /* Include the headers in the first PT_LOAD segment.  */
4515       m->includes_filehdr = 1;
4516       m->includes_phdrs = 1;
4517     }
4518
4519   return m;
4520 }
4521
4522 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
4523    on failure.  */
4524
4525 struct elf_segment_map *
4526 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
4527 {
4528   struct elf_segment_map *m;
4529
4530   m = (struct elf_segment_map *) bfd_zalloc (abfd,
4531                                              sizeof (struct elf_segment_map));
4532   if (m == NULL)
4533     return NULL;
4534   m->next = NULL;
4535   m->p_type = PT_DYNAMIC;
4536   m->count = 1;
4537   m->sections[0] = dynsec;
4538
4539   return m;
4540 }
4541
4542 /* Possibly add or remove segments from the segment map.  */
4543
4544 static bfd_boolean
4545 elf_modify_segment_map (bfd *abfd,
4546                         struct bfd_link_info *info,
4547                         bfd_boolean remove_empty_load)
4548 {
4549   struct elf_segment_map **m;
4550   const struct elf_backend_data *bed;
4551
4552   /* The placement algorithm assumes that non allocated sections are
4553      not in PT_LOAD segments.  We ensure this here by removing such
4554      sections from the segment map.  We also remove excluded
4555      sections.  Finally, any PT_LOAD segment without sections is
4556      removed.  */
4557   m = &elf_seg_map (abfd);
4558   while (*m)
4559     {
4560       unsigned int i, new_count;
4561
4562       for (new_count = 0, i = 0; i < (*m)->count; i++)
4563         {
4564           if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
4565               && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
4566                   || (*m)->p_type != PT_LOAD))
4567             {
4568               (*m)->sections[new_count] = (*m)->sections[i];
4569               new_count++;
4570             }
4571         }
4572       (*m)->count = new_count;
4573
4574       if (remove_empty_load
4575           && (*m)->p_type == PT_LOAD
4576           && (*m)->count == 0
4577           && !(*m)->includes_phdrs)
4578         *m = (*m)->next;
4579       else
4580         m = &(*m)->next;
4581     }
4582
4583   bed = get_elf_backend_data (abfd);
4584   if (bed->elf_backend_modify_segment_map != NULL)
4585     {
4586       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
4587         return FALSE;
4588     }
4589
4590   return TRUE;
4591 }
4592
4593 #define IS_TBSS(s) \
4594   ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4595
4596 /* Set up a mapping from BFD sections to program segments.  */
4597
4598 bfd_boolean
4599 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
4600 {
4601   unsigned int count;
4602   struct elf_segment_map *m;
4603   asection **sections = NULL;
4604   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4605   bfd_boolean no_user_phdrs;
4606
4607   no_user_phdrs = elf_seg_map (abfd) == NULL;
4608
4609   if (info != NULL)
4610     info->user_phdrs = !no_user_phdrs;
4611
4612   if (no_user_phdrs && bfd_count_sections (abfd) != 0)
4613     {
4614       asection *s;
4615       unsigned int i;
4616       struct elf_segment_map *mfirst;
4617       struct elf_segment_map **pm;
4618       asection *last_hdr;
4619       bfd_vma last_size;
4620       unsigned int hdr_index;
4621       bfd_vma maxpagesize;
4622       asection **hdrpp;
4623       bfd_boolean phdr_in_segment;
4624       bfd_boolean writable;
4625       bfd_boolean executable;
4626       int tls_count = 0;
4627       asection *first_tls = NULL;
4628       asection *first_mbind = NULL;
4629       asection *dynsec, *eh_frame_hdr;
4630       bfd_size_type amt;
4631       bfd_vma addr_mask, wrap_to = 0;
4632       bfd_size_type phdr_size;
4633
4634       /* Select the allocated sections, and sort them.  */
4635
4636       sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
4637                                             sizeof (asection *));
4638       if (sections == NULL)
4639         goto error_return;
4640
4641       /* Calculate top address, avoiding undefined behaviour of shift
4642          left operator when shift count is equal to size of type
4643          being shifted.  */
4644       addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
4645       addr_mask = (addr_mask << 1) + 1;
4646
4647       i = 0;
4648       for (s = abfd->sections; s != NULL; s = s->next)
4649         {
4650           if ((s->flags & SEC_ALLOC) != 0)
4651             {
4652               sections[i] = s;
4653               ++i;
4654               /* A wrapping section potentially clashes with header.  */
4655               if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
4656                 wrap_to = (s->lma + s->size) & addr_mask;
4657             }
4658         }
4659       BFD_ASSERT (i <= bfd_count_sections (abfd));
4660       count = i;
4661
4662       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
4663
4664       phdr_size = elf_program_header_size (abfd);
4665       if (phdr_size == (bfd_size_type) -1)
4666         phdr_size = get_program_header_size (abfd, info);
4667       phdr_size += bed->s->sizeof_ehdr;
4668       maxpagesize = bed->maxpagesize;
4669       if (maxpagesize == 0)
4670         maxpagesize = 1;
4671       phdr_in_segment = info != NULL && info->load_phdrs;
4672       if (count != 0
4673           && (((sections[0]->lma & addr_mask) & (maxpagesize - 1))
4674               >= (phdr_size & (maxpagesize - 1))))
4675         /* For compatibility with old scripts that may not be using
4676            SIZEOF_HEADERS, add headers when it looks like space has
4677            been left for them.  */
4678         phdr_in_segment = TRUE;
4679
4680       /* Build the mapping.  */
4681       mfirst = NULL;
4682       pm = &mfirst;
4683
4684       /* If we have a .interp section, then create a PT_PHDR segment for
4685          the program headers and a PT_INTERP segment for the .interp
4686          section.  */
4687       s = bfd_get_section_by_name (abfd, ".interp");
4688       if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->size != 0)
4689         {
4690           amt = sizeof (struct elf_segment_map);
4691           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4692           if (m == NULL)
4693             goto error_return;
4694           m->next = NULL;
4695           m->p_type = PT_PHDR;
4696           m->p_flags = PF_R;
4697           m->p_flags_valid = 1;
4698           m->includes_phdrs = 1;
4699           phdr_in_segment = TRUE;
4700           *pm = m;
4701           pm = &m->next;
4702
4703           amt = sizeof (struct elf_segment_map);
4704           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4705           if (m == NULL)
4706             goto error_return;
4707           m->next = NULL;
4708           m->p_type = PT_INTERP;
4709           m->count = 1;
4710           m->sections[0] = s;
4711
4712           *pm = m;
4713           pm = &m->next;
4714         }
4715
4716       /* Look through the sections.  We put sections in the same program
4717          segment when the start of the second section can be placed within
4718          a few bytes of the end of the first section.  */
4719       last_hdr = NULL;
4720       last_size = 0;
4721       hdr_index = 0;
4722       writable = FALSE;
4723       executable = FALSE;
4724       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
4725       if (dynsec != NULL
4726           && (dynsec->flags & SEC_LOAD) == 0)
4727         dynsec = NULL;
4728
4729       if ((abfd->flags & D_PAGED) == 0)
4730         phdr_in_segment = FALSE;
4731
4732       /* Deal with -Ttext or something similar such that the first section
4733          is not adjacent to the program headers.  This is an
4734          approximation, since at this point we don't know exactly how many
4735          program headers we will need.  */
4736       if (phdr_in_segment && count > 0)
4737         {
4738           bfd_vma phdr_lma;
4739           bfd_boolean separate_phdr = FALSE;
4740
4741           phdr_lma = (sections[0]->lma - phdr_size) & addr_mask & -maxpagesize;
4742           if (info != NULL
4743               && info->separate_code
4744               && (sections[0]->flags & SEC_CODE) != 0)
4745             {
4746               /* If data sections should be separate from code and
4747                  thus not executable, and the first section is
4748                  executable then put the file and program headers in
4749                  their own PT_LOAD.  */
4750               separate_phdr = TRUE;
4751               if ((((phdr_lma + phdr_size - 1) & addr_mask & -maxpagesize)
4752                    == (sections[0]->lma & addr_mask & -maxpagesize)))
4753                 {
4754                   /* The file and program headers are currently on the
4755                      same page as the first section.  Put them on the
4756                      previous page if we can.  */
4757                   if (phdr_lma >= maxpagesize)
4758                     phdr_lma -= maxpagesize;
4759                   else
4760                     separate_phdr = FALSE;
4761                 }
4762             }
4763           if ((sections[0]->lma & addr_mask) < phdr_lma
4764               || (sections[0]->lma & addr_mask) < phdr_size)
4765             /* If file and program headers would be placed at the end
4766                of memory then it's probably better to omit them.  */
4767             phdr_in_segment = FALSE;
4768           else if (phdr_lma < wrap_to)
4769             /* If a section wraps around to where we'll be placing
4770                file and program headers, then the headers will be
4771                overwritten.  */
4772             phdr_in_segment = FALSE;
4773           else if (separate_phdr)
4774             {
4775               m = make_mapping (abfd, sections, 0, 0, phdr_in_segment);
4776               if (m == NULL)
4777                 goto error_return;
4778               m->p_paddr = phdr_lma;
4779               m->p_vaddr_offset
4780                 = (sections[0]->vma - phdr_size) & addr_mask & -maxpagesize;
4781               m->p_paddr_valid = 1;
4782               *pm = m;
4783               pm = &m->next;
4784               phdr_in_segment = FALSE;
4785             }
4786         }
4787
4788       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
4789         {
4790           asection *hdr;
4791           bfd_boolean new_segment;
4792
4793           hdr = *hdrpp;
4794
4795           /* See if this section and the last one will fit in the same
4796              segment.  */
4797
4798           if (last_hdr == NULL)
4799             {
4800               /* If we don't have a segment yet, then we don't need a new
4801                  one (we build the last one after this loop).  */
4802               new_segment = FALSE;
4803             }
4804           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
4805             {
4806               /* If this section has a different relation between the
4807                  virtual address and the load address, then we need a new
4808                  segment.  */
4809               new_segment = TRUE;
4810             }
4811           else if (hdr->lma < last_hdr->lma + last_size
4812                    || last_hdr->lma + last_size < last_hdr->lma)
4813             {
4814               /* If this section has a load address that makes it overlap
4815                  the previous section, then we need a new segment.  */
4816               new_segment = TRUE;
4817             }
4818           else if ((abfd->flags & D_PAGED) != 0
4819                    && (((last_hdr->lma + last_size - 1) & -maxpagesize)
4820                        == (hdr->lma & -maxpagesize)))
4821             {
4822               /* If we are demand paged then we can't map two disk
4823                  pages onto the same memory page.  */
4824               new_segment = FALSE;
4825             }
4826           /* In the next test we have to be careful when last_hdr->lma is close
4827              to the end of the address space.  If the aligned address wraps
4828              around to the start of the address space, then there are no more
4829              pages left in memory and it is OK to assume that the current
4830              section can be included in the current segment.  */
4831           else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4832                     + maxpagesize > last_hdr->lma)
4833                    && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4834                        + maxpagesize <= hdr->lma))
4835             {
4836               /* If putting this section in this segment would force us to
4837                  skip a page in the segment, then we need a new segment.  */
4838               new_segment = TRUE;
4839             }
4840           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
4841                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
4842             {
4843               /* We don't want to put a loaded section after a
4844                  nonloaded (ie. bss style) section in the same segment
4845                  as that will force the non-loaded section to be loaded.
4846                  Consider .tbss sections as loaded for this purpose.  */
4847               new_segment = TRUE;
4848             }
4849           else if ((abfd->flags & D_PAGED) == 0)
4850             {
4851               /* If the file is not demand paged, which means that we
4852                  don't require the sections to be correctly aligned in the
4853                  file, then there is no other reason for a new segment.  */
4854               new_segment = FALSE;
4855             }
4856           else if (info != NULL
4857                    && info->separate_code
4858                    && executable != ((hdr->flags & SEC_CODE) != 0))
4859             {
4860               new_segment = TRUE;
4861             }
4862           else if (! writable
4863                    && (hdr->flags & SEC_READONLY) == 0)
4864             {
4865               /* We don't want to put a writable section in a read only
4866                  segment.  */
4867               new_segment = TRUE;
4868             }
4869           else
4870             {
4871               /* Otherwise, we can use the same segment.  */
4872               new_segment = FALSE;
4873             }
4874
4875           /* Allow interested parties a chance to override our decision.  */
4876           if (last_hdr != NULL
4877               && info != NULL
4878               && info->callbacks->override_segment_assignment != NULL)
4879             new_segment
4880               = info->callbacks->override_segment_assignment (info, abfd, hdr,
4881                                                               last_hdr,
4882                                                               new_segment);
4883
4884           if (! new_segment)
4885             {
4886               if ((hdr->flags & SEC_READONLY) == 0)
4887                 writable = TRUE;
4888               if ((hdr->flags & SEC_CODE) != 0)
4889                 executable = TRUE;
4890               last_hdr = hdr;
4891               /* .tbss sections effectively have zero size.  */
4892               last_size = !IS_TBSS (hdr) ? hdr->size : 0;
4893               continue;
4894             }
4895
4896           /* We need a new program segment.  We must create a new program
4897              header holding all the sections from hdr_index until hdr.  */
4898
4899           m = make_mapping (abfd, sections, hdr_index, i, phdr_in_segment);
4900           if (m == NULL)
4901             goto error_return;
4902
4903           *pm = m;
4904           pm = &m->next;
4905
4906           if ((hdr->flags & SEC_READONLY) == 0)
4907             writable = TRUE;
4908           else
4909             writable = FALSE;
4910
4911           if ((hdr->flags & SEC_CODE) == 0)
4912             executable = FALSE;
4913           else
4914             executable = TRUE;
4915
4916           last_hdr = hdr;
4917           /* .tbss sections effectively have zero size.  */
4918           last_size = !IS_TBSS (hdr) ? hdr->size : 0;
4919           hdr_index = i;
4920           phdr_in_segment = FALSE;
4921         }
4922
4923       /* Create a final PT_LOAD program segment, but not if it's just
4924          for .tbss.  */
4925       if (last_hdr != NULL
4926           && (i - hdr_index != 1
4927               || !IS_TBSS (last_hdr)))
4928         {
4929           m = make_mapping (abfd, sections, hdr_index, i, phdr_in_segment);
4930           if (m == NULL)
4931             goto error_return;
4932
4933           *pm = m;
4934           pm = &m->next;
4935         }
4936
4937       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
4938       if (dynsec != NULL)
4939         {
4940           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4941           if (m == NULL)
4942             goto error_return;
4943           *pm = m;
4944           pm = &m->next;
4945         }
4946
4947       /* For each batch of consecutive loadable SHT_NOTE  sections,
4948          add a PT_NOTE segment.  We don't use bfd_get_section_by_name,
4949          because if we link together nonloadable .note sections and
4950          loadable .note sections, we will generate two .note sections
4951          in the output file.  */
4952       for (s = abfd->sections; s != NULL; s = s->next)
4953         {
4954           if ((s->flags & SEC_LOAD) != 0
4955               && elf_section_type (s) == SHT_NOTE)
4956             {
4957               asection *s2;
4958               unsigned int alignment_power = s->alignment_power;
4959
4960               count = 1;
4961               for (s2 = s; s2->next != NULL; s2 = s2->next)
4962                 {
4963                   if (s2->next->alignment_power == alignment_power
4964                       && (s2->next->flags & SEC_LOAD) != 0
4965                       && elf_section_type (s2->next) == SHT_NOTE
4966                       && align_power (s2->lma + s2->size,
4967                                       alignment_power)
4968                       == s2->next->lma)
4969                     count++;
4970                   else
4971                     break;
4972                 }
4973               amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4974               amt += count * sizeof (asection *);
4975               m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4976               if (m == NULL)
4977                 goto error_return;
4978               m->next = NULL;
4979               m->p_type = PT_NOTE;
4980               m->count = count;
4981               while (count > 1)
4982                 {
4983                   m->sections[m->count - count--] = s;
4984                   BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4985                   s = s->next;
4986                 }
4987               m->sections[m->count - 1] = s;
4988               BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4989               *pm = m;
4990               pm = &m->next;
4991             }
4992           if (s->flags & SEC_THREAD_LOCAL)
4993             {
4994               if (! tls_count)
4995                 first_tls = s;
4996               tls_count++;
4997             }
4998           if (first_mbind == NULL
4999               && (elf_section_flags (s) & SHF_GNU_MBIND) != 0)
5000             first_mbind = s;
5001         }
5002
5003       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
5004       if (tls_count > 0)
5005         {
5006           amt = sizeof (struct elf_segment_map) - sizeof (asection *);
5007           amt += tls_count * sizeof (asection *);
5008           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5009           if (m == NULL)
5010             goto error_return;
5011           m->next = NULL;
5012           m->p_type = PT_TLS;
5013           m->count = tls_count;
5014           /* Mandated PF_R.  */
5015           m->p_flags = PF_R;
5016           m->p_flags_valid = 1;
5017           s = first_tls;
5018           for (i = 0; i < (unsigned int) tls_count; ++i)
5019             {
5020               if ((s->flags & SEC_THREAD_LOCAL) == 0)
5021                 {
5022                   _bfd_error_handler
5023                     (_("%pB: TLS sections are not adjacent:"), abfd);
5024                   s = first_tls;
5025                   i = 0;
5026                   while (i < (unsigned int) tls_count)
5027                     {
5028                       if ((s->flags & SEC_THREAD_LOCAL) != 0)
5029                         {
5030                           _bfd_error_handler (_("           TLS: %pA"), s);
5031                           i++;
5032                         }
5033                       else
5034                         _bfd_error_handler (_(" non-TLS: %pA"), s);
5035                       s = s->next;
5036                     }
5037                   bfd_set_error (bfd_error_bad_value);
5038                   goto error_return;
5039                 }
5040               m->sections[i] = s;
5041               s = s->next;
5042             }
5043
5044           *pm = m;
5045           pm = &m->next;
5046         }
5047
5048       if (first_mbind && (abfd->flags & D_PAGED) != 0)
5049         for (s = first_mbind; s != NULL; s = s->next)
5050           if ((elf_section_flags (s) & SHF_GNU_MBIND) != 0
5051               && (elf_section_data (s)->this_hdr.sh_info
5052                   <= PT_GNU_MBIND_NUM))
5053             {
5054               /* Mandated PF_R.  */
5055               unsigned long p_flags = PF_R;
5056               if ((s->flags & SEC_READONLY) == 0)
5057                 p_flags |= PF_W;
5058               if ((s->flags & SEC_CODE) != 0)
5059                 p_flags |= PF_X;
5060
5061               amt = sizeof (struct elf_segment_map) + sizeof (asection *);
5062               m = bfd_zalloc (abfd, amt);
5063               if (m == NULL)
5064                 goto error_return;
5065               m->next = NULL;
5066               m->p_type = (PT_GNU_MBIND_LO
5067                            + elf_section_data (s)->this_hdr.sh_info);
5068               m->count = 1;
5069               m->p_flags_valid = 1;
5070               m->sections[0] = s;
5071               m->p_flags = p_flags;
5072
5073               *pm = m;
5074               pm = &m->next;
5075             }
5076
5077       s = bfd_get_section_by_name (abfd,
5078                                    NOTE_GNU_PROPERTY_SECTION_NAME);
5079       if (s != NULL && s->size != 0)
5080         {
5081           amt = sizeof (struct elf_segment_map) + sizeof (asection *);
5082           m = bfd_zalloc (abfd, amt);
5083           if (m == NULL)
5084             goto error_return;
5085           m->next = NULL;
5086           m->p_type = PT_GNU_PROPERTY;
5087           m->count = 1;
5088           m->p_flags_valid = 1;
5089           m->sections[0] = s;
5090           m->p_flags = PF_R;
5091           *pm = m;
5092           pm = &m->next;
5093         }
5094
5095       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5096          segment.  */
5097       eh_frame_hdr = elf_eh_frame_hdr (abfd);
5098       if (eh_frame_hdr != NULL
5099           && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
5100         {
5101           amt = sizeof (struct elf_segment_map);
5102           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5103           if (m == NULL)
5104             goto error_return;
5105           m->next = NULL;
5106           m->p_type = PT_GNU_EH_FRAME;
5107           m->count = 1;
5108           m->sections[0] = eh_frame_hdr->output_section;
5109
5110           *pm = m;
5111           pm = &m->next;
5112         }
5113
5114       if (elf_stack_flags (abfd))
5115         {
5116           amt = sizeof (struct elf_segment_map);
5117           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5118           if (m == NULL)
5119             goto error_return;
5120           m->next = NULL;
5121           m->p_type = PT_GNU_STACK;
5122           m->p_flags = elf_stack_flags (abfd);
5123           m->p_align = bed->stack_align;
5124           m->p_flags_valid = 1;
5125           m->p_align_valid = m->p_align != 0;
5126           if (info->stacksize > 0)
5127             {
5128               m->p_size = info->stacksize;
5129               m->p_size_valid = 1;
5130             }
5131
5132           *pm = m;
5133           pm = &m->next;
5134         }
5135
5136       if (info != NULL && info->relro)
5137         {
5138           for (m = mfirst; m != NULL; m = m->next)
5139             {
5140               if (m->p_type == PT_LOAD
5141                   && m->count != 0
5142                   && m->sections[0]->vma >= info->relro_start
5143                   && m->sections[0]->vma < info->relro_end)
5144                 {
5145                   i = m->count;
5146                   while (--i != (unsigned) -1)
5147                     if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
5148                         == (SEC_LOAD | SEC_HAS_CONTENTS))
5149                       break;
5150
5151                   if (i != (unsigned) -1)
5152                     break;
5153                 }
5154             }
5155
5156           /* Make a PT_GNU_RELRO segment only when it isn't empty.  */
5157           if (m != NULL)
5158             {
5159               amt = sizeof (struct elf_segment_map);
5160               m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5161               if (m == NULL)
5162                 goto error_return;
5163               m->next = NULL;
5164               m->p_type = PT_GNU_RELRO;
5165               *pm = m;
5166               pm = &m->next;
5167             }
5168         }
5169
5170       free (sections);
5171       elf_seg_map (abfd) = mfirst;
5172     }
5173
5174   if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
5175     return FALSE;
5176
5177   for (count = 0, m = elf_seg_map (abfd); m != NULL; m = m->next)
5178     ++count;
5179   elf_program_header_size (abfd) = count * bed->s->sizeof_phdr;
5180
5181   return TRUE;
5182
5183  error_return:
5184   if (sections != NULL)
5185     free (sections);
5186   return FALSE;
5187 }
5188
5189 /* Sort sections by address.  */
5190
5191 static int
5192 elf_sort_sections (const void *arg1, const void *arg2)
5193 {
5194   const asection *sec1 = *(const asection **) arg1;
5195   const asection *sec2 = *(const asection **) arg2;
5196   bfd_size_type size1, size2;
5197
5198   /* Sort by LMA first, since this is the address used to
5199      place the section into a segment.  */
5200   if (sec1->lma < sec2->lma)
5201     return -1;
5202   else if (sec1->lma > sec2->lma)
5203     return 1;
5204
5205   /* Then sort by VMA.  Normally the LMA and the VMA will be
5206      the same, and this will do nothing.  */
5207   if (sec1->vma < sec2->vma)
5208     return -1;
5209   else if (sec1->vma > sec2->vma)
5210     return 1;
5211
5212   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
5213
5214 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5215
5216   if (TOEND (sec1))
5217     {
5218       if (TOEND (sec2))
5219         {
5220           /* If the indices are the same, do not return 0
5221              here, but continue to try the next comparison.  */
5222           if (sec1->target_index - sec2->target_index != 0)
5223             return sec1->target_index - sec2->target_index;
5224         }
5225       else
5226         return 1;
5227     }
5228   else if (TOEND (sec2))
5229     return -1;
5230
5231 #undef TOEND
5232
5233   /* Sort by size, to put zero sized sections
5234      before others at the same address.  */
5235
5236   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
5237   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
5238
5239   if (size1 < size2)
5240     return -1;
5241   if (size1 > size2)
5242     return 1;
5243
5244   return sec1->target_index - sec2->target_index;
5245 }
5246
5247 /* Ian Lance Taylor writes:
5248
5249    We shouldn't be using % with a negative signed number.  That's just
5250    not good.  We have to make sure either that the number is not
5251    negative, or that the number has an unsigned type.  When the types
5252    are all the same size they wind up as unsigned.  When file_ptr is a
5253    larger signed type, the arithmetic winds up as signed long long,
5254    which is wrong.
5255
5256    What we're trying to say here is something like ``increase OFF by
5257    the least amount that will cause it to be equal to the VMA modulo
5258    the page size.''  */
5259 /* In other words, something like:
5260
5261    vma_offset = m->sections[0]->vma % bed->maxpagesize;
5262    off_offset = off % bed->maxpagesize;
5263    if (vma_offset < off_offset)
5264      adjustment = vma_offset + bed->maxpagesize - off_offset;
5265    else
5266      adjustment = vma_offset - off_offset;
5267
5268    which can be collapsed into the expression below.  */
5269
5270 static file_ptr
5271 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
5272 {
5273   /* PR binutils/16199: Handle an alignment of zero.  */
5274   if (maxpagesize == 0)
5275     maxpagesize = 1;
5276   return ((vma - off) % maxpagesize);
5277 }
5278
5279 static void
5280 print_segment_map (const struct elf_segment_map *m)
5281 {
5282   unsigned int j;
5283   const char *pt = get_segment_type (m->p_type);
5284   char buf[32];
5285
5286   if (pt == NULL)
5287     {
5288       if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
5289         sprintf (buf, "LOPROC+%7.7x",
5290                  (unsigned int) (m->p_type - PT_LOPROC));
5291       else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
5292         sprintf (buf, "LOOS+%7.7x",
5293                  (unsigned int) (m->p_type - PT_LOOS));
5294       else
5295         snprintf (buf, sizeof (buf), "%8.8x",
5296                   (unsigned int) m->p_type);
5297       pt = buf;
5298     }
5299   fflush (stdout);
5300   fprintf (stderr, "%s:", pt);
5301   for (j = 0; j < m->count; j++)
5302     fprintf (stderr, " %s", m->sections [j]->name);
5303   putc ('\n',stderr);
5304   fflush (stderr);
5305 }
5306
5307 static bfd_boolean
5308 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
5309 {
5310   void *buf;
5311   bfd_boolean ret;
5312
5313   if (bfd_seek (abfd, pos, SEEK_SET) != 0)
5314     return FALSE;
5315   buf = bfd_zmalloc (len);
5316   if (buf == NULL)
5317     return FALSE;
5318   ret = bfd_bwrite (buf, len, abfd) == len;
5319   free (buf);
5320   return ret;
5321 }
5322
5323 /* Assign file positions to the sections based on the mapping from
5324    sections to segments.  This function also sets up some fields in
5325    the file header.  */
5326
5327 static bfd_boolean
5328 assign_file_positions_for_load_sections (bfd *abfd,
5329                                          struct bfd_link_info *link_info)
5330 {
5331   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5332   struct elf_segment_map *m;
5333   Elf_Internal_Phdr *phdrs;
5334   Elf_Internal_Phdr *p;
5335   file_ptr off;
5336   bfd_size_type maxpagesize;
5337   unsigned int pt_load_count = 0;
5338   unsigned int alloc;
5339   unsigned int i, j;
5340   bfd_vma header_pad = 0;
5341
5342   if (link_info == NULL
5343       && !_bfd_elf_map_sections_to_segments (abfd, link_info))
5344     return FALSE;
5345
5346   alloc = 0;
5347   for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5348     {
5349       ++alloc;
5350       if (m->header_size)
5351         header_pad = m->header_size;
5352     }
5353
5354   if (alloc)
5355     {
5356       elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
5357       elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
5358     }
5359   else
5360     {
5361       /* PR binutils/12467.  */
5362       elf_elfheader (abfd)->e_phoff = 0;
5363       elf_elfheader (abfd)->e_phentsize = 0;
5364     }
5365
5366   elf_elfheader (abfd)->e_phnum = alloc;
5367
5368   if (elf_program_header_size (abfd) == (bfd_size_type) -1)
5369     elf_program_header_size (abfd) = alloc * bed->s->sizeof_phdr;
5370   else
5371     BFD_ASSERT (elf_program_header_size (abfd)
5372                 >= alloc * bed->s->sizeof_phdr);
5373
5374   if (alloc == 0)
5375     {
5376       elf_next_file_pos (abfd) = bed->s->sizeof_ehdr;
5377       return TRUE;
5378     }
5379
5380   /* We're writing the size in elf_program_header_size (abfd),
5381      see assign_file_positions_except_relocs, so make sure we have
5382      that amount allocated, with trailing space cleared.
5383      The variable alloc contains the computed need, while
5384      elf_program_header_size (abfd) contains the size used for the
5385      layout.
5386      See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5387      where the layout is forced to according to a larger size in the
5388      last iterations for the testcase ld-elf/header.  */
5389   BFD_ASSERT (elf_program_header_size (abfd) % bed->s->sizeof_phdr
5390               == 0);
5391   phdrs = (Elf_Internal_Phdr *)
5392      bfd_zalloc2 (abfd,
5393                   (elf_program_header_size (abfd) / bed->s->sizeof_phdr),
5394                   sizeof (Elf_Internal_Phdr));
5395   elf_tdata (abfd)->phdr = phdrs;
5396   if (phdrs == NULL)
5397     return FALSE;
5398
5399   maxpagesize = 1;
5400   if ((abfd->flags & D_PAGED) != 0)
5401     maxpagesize = bed->maxpagesize;
5402
5403   off = bed->s->sizeof_ehdr;
5404   off += alloc * bed->s->sizeof_phdr;
5405   if (header_pad < (bfd_vma) off)
5406     header_pad = 0;
5407   else
5408     header_pad -= off;
5409   off += header_pad;
5410
5411   for (m = elf_seg_map (abfd), p = phdrs, j = 0;
5412        m != NULL;
5413        m = m->next, p++, j++)
5414     {
5415       asection **secpp;
5416       bfd_vma off_adjust;
5417       bfd_boolean no_contents;
5418
5419       /* If elf_segment_map is not from map_sections_to_segments, the
5420          sections may not be correctly ordered.  NOTE: sorting should
5421          not be done to the PT_NOTE section of a corefile, which may
5422          contain several pseudo-sections artificially created by bfd.
5423          Sorting these pseudo-sections breaks things badly.  */
5424       if (m->count > 1
5425           && !(elf_elfheader (abfd)->e_type == ET_CORE
5426                && m->p_type == PT_NOTE))
5427         qsort (m->sections, (size_t) m->count, sizeof (asection *),
5428                elf_sort_sections);
5429
5430       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5431          number of sections with contents contributing to both p_filesz
5432          and p_memsz, followed by a number of sections with no contents
5433          that just contribute to p_memsz.  In this loop, OFF tracks next
5434          available file offset for PT_LOAD and PT_NOTE segments.  */
5435       p->p_type = m->p_type;
5436       p->p_flags = m->p_flags;
5437
5438       if (m->count == 0)
5439         p->p_vaddr = m->p_vaddr_offset;
5440       else
5441         p->p_vaddr = m->sections[0]->vma + m->p_vaddr_offset;
5442
5443       if (m->p_paddr_valid)
5444         p->p_paddr = m->p_paddr;
5445       else if (m->count == 0)
5446         p->p_paddr = 0;
5447       else
5448         p->p_paddr = m->sections[0]->lma + m->p_vaddr_offset;
5449
5450       if (p->p_type == PT_LOAD
5451           && (abfd->flags & D_PAGED) != 0)
5452         {
5453           /* p_align in demand paged PT_LOAD segments effectively stores
5454              the maximum page size.  When copying an executable with
5455              objcopy, we set m->p_align from the input file.  Use this
5456              value for maxpagesize rather than bed->maxpagesize, which
5457              may be different.  Note that we use maxpagesize for PT_TLS
5458              segment alignment later in this function, so we are relying
5459              on at least one PT_LOAD segment appearing before a PT_TLS
5460              segment.  */
5461           if (m->p_align_valid)
5462             maxpagesize = m->p_align;
5463
5464           p->p_align = maxpagesize;
5465           pt_load_count += 1;
5466         }
5467       else if (m->p_align_valid)
5468         p->p_align = m->p_align;
5469       else if (m->count == 0)
5470         p->p_align = 1 << bed->s->log_file_align;
5471       else
5472         p->p_align = 0;
5473
5474       no_contents = FALSE;
5475       off_adjust = 0;
5476       if (p->p_type == PT_LOAD
5477           && m->count > 0)
5478         {
5479           bfd_size_type align;
5480           unsigned int align_power = 0;
5481
5482           if (m->p_align_valid)
5483             align = p->p_align;
5484           else
5485             {
5486               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5487                 {
5488                   unsigned int secalign;
5489
5490                   secalign = bfd_get_section_alignment (abfd, *secpp);
5491                   if (secalign > align_power)
5492                     align_power = secalign;
5493                 }
5494               align = (bfd_size_type) 1 << align_power;
5495               if (align < maxpagesize)
5496                 align = maxpagesize;
5497             }
5498
5499           for (i = 0; i < m->count; i++)
5500             if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
5501               /* If we aren't making room for this section, then
5502                  it must be SHT_NOBITS regardless of what we've
5503                  set via struct bfd_elf_special_section.  */
5504               elf_section_type (m->sections[i]) = SHT_NOBITS;
5505
5506           /* Find out whether this segment contains any loadable
5507              sections.  */
5508           no_contents = TRUE;
5509           for (i = 0; i < m->count; i++)
5510             if (elf_section_type (m->sections[i]) != SHT_NOBITS)
5511               {
5512                 no_contents = FALSE;
5513                 break;
5514               }
5515
5516           off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
5517
5518           /* Broken hardware and/or kernel require that files do not
5519              map the same page with different permissions on some hppa
5520              processors.  */
5521           if (pt_load_count > 1
5522               && bed->no_page_alias
5523               && (off & (maxpagesize - 1)) != 0
5524               && (off & -maxpagesize) == ((off + off_adjust) & -maxpagesize))
5525             off_adjust += maxpagesize;
5526           off += off_adjust;
5527           if (no_contents)
5528             {
5529               /* We shouldn't need to align the segment on disk since
5530                  the segment doesn't need file space, but the gABI
5531                  arguably requires the alignment and glibc ld.so
5532                  checks it.  So to comply with the alignment
5533                  requirement but not waste file space, we adjust
5534                  p_offset for just this segment.  (OFF_ADJUST is
5535                  subtracted from OFF later.)  This may put p_offset
5536                  past the end of file, but that shouldn't matter.  */
5537             }
5538           else
5539             off_adjust = 0;
5540         }
5541       /* Make sure the .dynamic section is the first section in the
5542          PT_DYNAMIC segment.  */
5543       else if (p->p_type == PT_DYNAMIC
5544                && m->count > 1
5545                && strcmp (m->sections[0]->name, ".dynamic") != 0)
5546         {
5547           _bfd_error_handler
5548             (_("%pB: The first section in the PT_DYNAMIC segment"
5549                " is not the .dynamic section"),
5550              abfd);
5551           bfd_set_error (bfd_error_bad_value);
5552           return FALSE;
5553         }
5554       /* Set the note section type to SHT_NOTE.  */
5555       else if (p->p_type == PT_NOTE)
5556         for (i = 0; i < m->count; i++)
5557           elf_section_type (m->sections[i]) = SHT_NOTE;
5558
5559       p->p_offset = 0;
5560       p->p_filesz = 0;
5561       p->p_memsz = 0;
5562
5563       if (m->includes_filehdr)
5564         {
5565           if (!m->p_flags_valid)
5566             p->p_flags |= PF_R;
5567           p->p_filesz = bed->s->sizeof_ehdr;
5568           p->p_memsz = bed->s->sizeof_ehdr;
5569           if (m->count > 0)
5570             {
5571               if (p->p_vaddr < (bfd_vma) off
5572                   || (!m->p_paddr_valid
5573                       && p->p_paddr < (bfd_vma) off))
5574                 {
5575                   _bfd_error_handler
5576                     (_("%pB: not enough room for program headers,"
5577                        " try linking with -N"),
5578                      abfd);
5579                   bfd_set_error (bfd_error_bad_value);
5580                   return FALSE;
5581                 }
5582
5583               p->p_vaddr -= off;
5584               if (!m->p_paddr_valid)
5585                 p->p_paddr -= off;
5586             }
5587         }
5588
5589       if (m->includes_phdrs)
5590         {
5591           if (!m->p_flags_valid)
5592             p->p_flags |= PF_R;
5593
5594           if (!m->includes_filehdr)
5595             {
5596               p->p_offset = bed->s->sizeof_ehdr;
5597
5598               if (m->count > 0)
5599                 {
5600                   p->p_vaddr -= off - p->p_offset;
5601                   if (!m->p_paddr_valid)
5602                     p->p_paddr -= off - p->p_offset;
5603                 }
5604             }
5605
5606           p->p_filesz += alloc * bed->s->sizeof_phdr;
5607           p->p_memsz += alloc * bed->s->sizeof_phdr;
5608           if (m->count)
5609             {
5610               p->p_filesz += header_pad;
5611               p->p_memsz += header_pad;
5612             }
5613         }
5614
5615       if (p->p_type == PT_LOAD
5616           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
5617         {
5618           if (!m->includes_filehdr && !m->includes_phdrs)
5619             p->p_offset = off;
5620           else
5621             {
5622               file_ptr adjust;
5623
5624               adjust = off - (p->p_offset + p->p_filesz);
5625               if (!no_contents)
5626                 p->p_filesz += adjust;
5627               p->p_memsz += adjust;
5628             }
5629         }
5630
5631       /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5632          maps.  Set filepos for sections in PT_LOAD segments, and in
5633          core files, for sections in PT_NOTE segments.
5634          assign_file_positions_for_non_load_sections will set filepos
5635          for other sections and update p_filesz for other segments.  */
5636       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5637         {
5638           asection *sec;
5639           bfd_size_type align;
5640           Elf_Internal_Shdr *this_hdr;
5641
5642           sec = *secpp;
5643           this_hdr = &elf_section_data (sec)->this_hdr;
5644           align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
5645
5646           if ((p->p_type == PT_LOAD
5647                || p->p_type == PT_TLS)
5648               && (this_hdr->sh_type != SHT_NOBITS
5649                   || ((this_hdr->sh_flags & SHF_ALLOC) != 0
5650                       && ((this_hdr->sh_flags & SHF_TLS) == 0
5651                           || p->p_type == PT_TLS))))
5652             {
5653               bfd_vma p_start = p->p_paddr;
5654               bfd_vma p_end = p_start + p->p_memsz;
5655               bfd_vma s_start = sec->lma;
5656               bfd_vma adjust = s_start - p_end;
5657
5658               if (adjust != 0
5659                   && (s_start < p_end
5660                       || p_end < p_start))
5661                 {
5662                   _bfd_error_handler
5663                     /* xgettext:c-format */
5664                     (_("%pB: section %pA lma %#" PRIx64 " adjusted to %#" PRIx64),
5665                      abfd, sec, (uint64_t) s_start, (uint64_t) p_end);
5666                   adjust = 0;
5667                   sec->lma = p_end;
5668                 }
5669               p->p_memsz += adjust;
5670
5671               if (this_hdr->sh_type != SHT_NOBITS)
5672                 {
5673                   if (p->p_filesz + adjust < p->p_memsz)
5674                     {
5675                       /* We have a PROGBITS section following NOBITS ones.
5676                          Allocate file space for the NOBITS section(s) and
5677                          zero it.  */
5678                       adjust = p->p_memsz - p->p_filesz;
5679                       if (!write_zeros (abfd, off, adjust))
5680                         return FALSE;
5681                     }
5682                   off += adjust;
5683                   p->p_filesz += adjust;
5684                 }
5685             }
5686
5687           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
5688             {
5689               /* The section at i == 0 is the one that actually contains
5690                  everything.  */
5691               if (i == 0)
5692                 {
5693                   this_hdr->sh_offset = sec->filepos = off;
5694                   off += this_hdr->sh_size;
5695                   p->p_filesz = this_hdr->sh_size;
5696                   p->p_memsz = 0;
5697                   p->p_align = 1;
5698                 }
5699               else
5700                 {
5701                   /* The rest are fake sections that shouldn't be written.  */
5702                   sec->filepos = 0;
5703                   sec->size = 0;
5704                   sec->flags = 0;
5705                   continue;
5706                 }
5707             }
5708           else
5709             {
5710               if (p->p_type == PT_LOAD)
5711                 {
5712                   this_hdr->sh_offset = sec->filepos = off;
5713                   if (this_hdr->sh_type != SHT_NOBITS)
5714                     off += this_hdr->sh_size;
5715                 }
5716               else if (this_hdr->sh_type == SHT_NOBITS
5717                        && (this_hdr->sh_flags & SHF_TLS) != 0
5718                        && this_hdr->sh_offset == 0)
5719                 {
5720                   /* This is a .tbss section that didn't get a PT_LOAD.
5721                      (See _bfd_elf_map_sections_to_segments "Create a
5722                      final PT_LOAD".)  Set sh_offset to the value it
5723                      would have if we had created a zero p_filesz and
5724                      p_memsz PT_LOAD header for the section.  This
5725                      also makes the PT_TLS header have the same
5726                      p_offset value.  */
5727                   bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
5728                                                           off, align);
5729                   this_hdr->sh_offset = sec->filepos = off + adjust;
5730                 }
5731
5732               if (this_hdr->sh_type != SHT_NOBITS)
5733                 {
5734                   p->p_filesz += this_hdr->sh_size;
5735                   /* A load section without SHF_ALLOC is something like
5736                      a note section in a PT_NOTE segment.  These take
5737                      file space but are not loaded into memory.  */
5738                   if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5739                     p->p_memsz += this_hdr->sh_size;
5740                 }
5741               else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5742                 {
5743                   if (p->p_type == PT_TLS)
5744                     p->p_memsz += this_hdr->sh_size;
5745
5746                   /* .tbss is special.  It doesn't contribute to p_memsz of
5747                      normal segments.  */
5748                   else if ((this_hdr->sh_flags & SHF_TLS) == 0)
5749                     p->p_memsz += this_hdr->sh_size;
5750                 }
5751
5752               if (align > p->p_align
5753                   && !m->p_align_valid
5754                   && (p->p_type != PT_LOAD
5755                       || (abfd->flags & D_PAGED) == 0))
5756                 p->p_align = align;
5757             }
5758
5759           if (!m->p_flags_valid)
5760             {
5761               p->p_flags |= PF_R;
5762               if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
5763                 p->p_flags |= PF_X;
5764               if ((this_hdr->sh_flags & SHF_WRITE) != 0)
5765                 p->p_flags |= PF_W;
5766             }
5767         }
5768
5769       off -= off_adjust;
5770
5771       /* Check that all sections are in a PT_LOAD segment.
5772          Don't check funky gdb generated core files.  */
5773       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
5774         {
5775           bfd_boolean check_vma = TRUE;
5776
5777           for (i = 1; i < m->count; i++)
5778             if (m->sections[i]->vma == m->sections[i - 1]->vma
5779                 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
5780                                        ->this_hdr), p) != 0
5781                 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
5782                                        ->this_hdr), p) != 0)
5783               {
5784                 /* Looks like we have overlays packed into the segment.  */
5785                 check_vma = FALSE;
5786                 break;
5787               }
5788
5789           for (i = 0; i < m->count; i++)
5790             {
5791               Elf_Internal_Shdr *this_hdr;
5792               asection *sec;
5793
5794               sec = m->sections[i];
5795               this_hdr = &(elf_section_data(sec)->this_hdr);
5796               if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
5797                   && !ELF_TBSS_SPECIAL (this_hdr, p))
5798                 {
5799                   _bfd_error_handler
5800                     /* xgettext:c-format */
5801                     (_("%pB: section `%pA' can't be allocated in segment %d"),
5802                      abfd, sec, j);
5803                   print_segment_map (m);
5804                 }
5805             }
5806         }
5807     }
5808
5809   elf_next_file_pos (abfd) = off;
5810   return TRUE;
5811 }
5812
5813 /* Assign file positions for the other sections.  */
5814
5815 static bfd_boolean
5816 assign_file_positions_for_non_load_sections (bfd *abfd,
5817                                              struct bfd_link_info *link_info)
5818 {
5819   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5820   Elf_Internal_Shdr **i_shdrpp;
5821   Elf_Internal_Shdr **hdrpp, **end_hdrpp;
5822   Elf_Internal_Phdr *phdrs;
5823   Elf_Internal_Phdr *p;
5824   struct elf_segment_map *m;
5825   struct elf_segment_map *hdrs_segment;
5826   bfd_vma filehdr_vaddr, filehdr_paddr;
5827   bfd_vma phdrs_vaddr, phdrs_paddr;
5828   file_ptr off;
5829   unsigned int count;
5830
5831   i_shdrpp = elf_elfsections (abfd);
5832   end_hdrpp = i_shdrpp + elf_numsections (abfd);
5833   off = elf_next_file_pos (abfd);
5834   for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
5835     {
5836       Elf_Internal_Shdr *hdr;
5837
5838       hdr = *hdrpp;
5839       if (hdr->bfd_section != NULL
5840           && (hdr->bfd_section->filepos != 0
5841               || (hdr->sh_type == SHT_NOBITS
5842                   && hdr->contents == NULL)))
5843         BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5844       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
5845         {
5846           if (hdr->sh_size != 0)
5847             _bfd_error_handler
5848               /* xgettext:c-format */
5849               (_("%pB: warning: allocated section `%s' not in segment"),
5850                abfd,
5851                (hdr->bfd_section == NULL
5852                 ? "*unknown*"
5853                 : hdr->bfd_section->name));
5854           /* We don't need to page align empty sections.  */
5855           if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5856             off += vma_page_aligned_bias (hdr->sh_addr, off,
5857                                           bed->maxpagesize);
5858           else
5859             off += vma_page_aligned_bias (hdr->sh_addr, off,
5860                                           hdr->sh_addralign);
5861           off = _bfd_elf_assign_file_position_for_section (hdr, off,
5862                                                            FALSE);
5863         }
5864       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5865                 && hdr->bfd_section == NULL)
5866                || (hdr->bfd_section != NULL
5867                    && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5868                    /* Compress DWARF debug sections.  */
5869                || hdr == i_shdrpp[elf_onesymtab (abfd)]
5870                || (elf_symtab_shndx_list (abfd) != NULL
5871                    && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
5872                || hdr == i_shdrpp[elf_strtab_sec (abfd)]
5873                || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
5874         hdr->sh_offset = -1;
5875       else
5876         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5877     }
5878
5879   /* Now that we have set the section file positions, we can set up
5880      the file positions for the non PT_LOAD segments.  */
5881   count = 0;
5882   filehdr_vaddr = 0;
5883   filehdr_paddr = 0;
5884   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
5885   phdrs_paddr = 0;
5886   hdrs_segment = NULL;
5887   phdrs = elf_tdata (abfd)->phdr;
5888   for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5889     {
5890       ++count;
5891       if (p->p_type != PT_LOAD)
5892         continue;
5893
5894       if (m->includes_filehdr)
5895         {
5896           filehdr_vaddr = p->p_vaddr;
5897           filehdr_paddr = p->p_paddr;
5898         }
5899       if (m->includes_phdrs)
5900         {
5901           phdrs_vaddr = p->p_vaddr;
5902           phdrs_paddr = p->p_paddr;
5903           if (m->includes_filehdr)
5904             {
5905               hdrs_segment = m;
5906               phdrs_vaddr += bed->s->sizeof_ehdr;
5907               phdrs_paddr += bed->s->sizeof_ehdr;
5908             }
5909         }
5910     }
5911
5912   if (hdrs_segment != NULL && link_info != NULL)
5913     {
5914       /* There is a segment that contains both the file headers and the
5915          program headers, so provide a symbol __ehdr_start pointing there.
5916          A program can use this to examine itself robustly.  */
5917
5918       struct elf_link_hash_entry *hash
5919         = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
5920                                 FALSE, FALSE, TRUE);
5921       /* If the symbol was referenced and not defined, define it.  */
5922       if (hash != NULL
5923           && (hash->root.type == bfd_link_hash_new
5924               || hash->root.type == bfd_link_hash_undefined
5925               || hash->root.type == bfd_link_hash_undefweak
5926               || hash->root.type == bfd_link_hash_common))
5927         {
5928           asection *s = NULL;
5929           if (hdrs_segment->count != 0)
5930             /* The segment contains sections, so use the first one.  */
5931             s = hdrs_segment->sections[0];
5932           else
5933             /* Use the first (i.e. lowest-addressed) section in any segment.  */
5934             for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5935               if (m->count != 0)
5936                 {
5937                   s = m->sections[0];
5938                   break;
5939                 }
5940
5941           if (s != NULL)
5942             {
5943               hash->root.u.def.value = filehdr_vaddr - s->vma;
5944               hash->root.u.def.section = s;
5945             }
5946           else
5947             {
5948               hash->root.u.def.value = filehdr_vaddr;
5949               hash->root.u.def.section = bfd_abs_section_ptr;
5950             }
5951
5952           hash->root.type = bfd_link_hash_defined;
5953           hash->def_regular = 1;
5954           hash->non_elf = 0;
5955         }
5956     }
5957
5958   for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5959     {
5960       if (p->p_type == PT_GNU_RELRO)
5961         {
5962           bfd_vma start, end;
5963           bfd_boolean ok;
5964
5965           if (link_info != NULL)
5966             {
5967               /* During linking the range of the RELRO segment is passed
5968                  in link_info.  Note that there may be padding between
5969                  relro_start and the first RELRO section.  */
5970               start = link_info->relro_start;
5971               end = link_info->relro_end;
5972             }
5973           else if (m->count != 0)
5974             {
5975               if (!m->p_size_valid)
5976                 abort ();
5977               start = m->sections[0]->vma;
5978               end = start + m->p_size;
5979             }
5980           else
5981             {
5982               start = 0;
5983               end = 0;
5984             }
5985
5986           ok = FALSE;
5987           if (start < end)
5988             {
5989               struct elf_segment_map *lm;
5990               const Elf_Internal_Phdr *lp;
5991               unsigned int i;
5992
5993               /* Find a LOAD segment containing a section in the RELRO
5994                  segment.  */
5995               for (lm = elf_seg_map (abfd), lp = phdrs;
5996                    lm != NULL;
5997                    lm = lm->next, lp++)
5998                 {
5999                   if (lp->p_type == PT_LOAD
6000                       && lm->count != 0
6001                       && (lm->sections[lm->count - 1]->vma
6002                           + (!IS_TBSS (lm->sections[lm->count - 1])
6003                              ? lm->sections[lm->count - 1]->size
6004                              : 0)) > start
6005                       && lm->sections[0]->vma < end)
6006                     break;
6007                 }
6008
6009               if (lm != NULL)
6010                 {
6011                   /* Find the section starting the RELRO segment.  */
6012                   for (i = 0; i < lm->count; i++)
6013                     {
6014                       asection *s = lm->sections[i];
6015                       if (s->vma >= start
6016                           && s->vma < end
6017                           && s->size != 0)
6018                         break;
6019                     }
6020
6021                   if (i < lm->count)
6022                     {
6023                       p->p_vaddr = lm->sections[i]->vma;
6024                       p->p_paddr = lm->sections[i]->lma;
6025                       p->p_offset = lm->sections[i]->filepos;
6026                       p->p_memsz = end - p->p_vaddr;
6027                       p->p_filesz = p->p_memsz;
6028
6029                       /* The RELRO segment typically ends a few bytes
6030                          into .got.plt but other layouts are possible.
6031                          In cases where the end does not match any
6032                          loaded section (for instance is in file
6033                          padding), trim p_filesz back to correspond to
6034                          the end of loaded section contents.  */
6035                       if (p->p_filesz > lp->p_vaddr + lp->p_filesz - p->p_vaddr)
6036                         p->p_filesz = lp->p_vaddr + lp->p_filesz - p->p_vaddr;
6037
6038                       /* Preserve the alignment and flags if they are
6039                          valid.  The gold linker generates RW/4 for
6040                          the PT_GNU_RELRO section.  It is better for
6041                          objcopy/strip to honor these attributes
6042                          otherwise gdb will choke when using separate
6043                          debug files.  */
6044                       if (!m->p_align_valid)
6045                         p->p_align = 1;
6046                       if (!m->p_flags_valid)
6047                         p->p_flags = PF_R;
6048                       ok = TRUE;
6049                     }
6050                 }
6051             }
6052           if (link_info != NULL)
6053             BFD_ASSERT (ok);
6054           if (!ok)
6055             memset (p, 0, sizeof *p);
6056         }
6057       else if (p->p_type == PT_GNU_STACK)
6058         {
6059           if (m->p_size_valid)
6060             p->p_memsz = m->p_size;
6061         }
6062       else if (m->count != 0)
6063         {
6064           unsigned int i;
6065
6066           if (p->p_type != PT_LOAD
6067               && (p->p_type != PT_NOTE
6068                   || bfd_get_format (abfd) != bfd_core))
6069             {
6070               /* A user specified segment layout may include a PHDR
6071                  segment that overlaps with a LOAD segment...  */
6072               if (p->p_type == PT_PHDR)
6073                 {
6074                   m->count = 0;
6075                   continue;
6076                 }
6077
6078               if (m->includes_filehdr || m->includes_phdrs)
6079                 {
6080                   /* PR 17512: file: 2195325e.  */
6081                   _bfd_error_handler
6082                     (_("%pB: error: non-load segment %d includes file header "
6083                        "and/or program header"),
6084                      abfd, (int) (p - phdrs));
6085                   return FALSE;
6086                 }
6087
6088               p->p_filesz = 0;
6089               p->p_offset = m->sections[0]->filepos;
6090               for (i = m->count; i-- != 0;)
6091                 {
6092                   asection *sect = m->sections[i];
6093                   Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
6094                   if (hdr->sh_type != SHT_NOBITS)
6095                     {
6096                       p->p_filesz = (sect->filepos - m->sections[0]->filepos
6097                                      + hdr->sh_size);
6098                       break;
6099                     }
6100                 }
6101             }
6102         }
6103       else if (m->includes_filehdr)
6104         {
6105           p->p_vaddr = filehdr_vaddr;
6106           if (! m->p_paddr_valid)
6107             p->p_paddr = filehdr_paddr;
6108         }
6109       else if (m->includes_phdrs)
6110         {
6111           p->p_vaddr = phdrs_vaddr;
6112           if (! m->p_paddr_valid)
6113             p->p_paddr = phdrs_paddr;
6114         }
6115     }
6116
6117   elf_next_file_pos (abfd) = off;
6118
6119   return TRUE;
6120 }
6121
6122 static elf_section_list *
6123 find_section_in_list (unsigned int i, elf_section_list * list)
6124 {
6125   for (;list != NULL; list = list->next)
6126     if (list->ndx == i)
6127       break;
6128   return list;
6129 }
6130
6131 /* Work out the file positions of all the sections.  This is called by
6132    _bfd_elf_compute_section_file_positions.  All the section sizes and
6133    VMAs must be known before this is called.
6134
6135    Reloc sections come in two flavours: Those processed specially as
6136    "side-channel" data attached to a section to which they apply, and
6137    those that bfd doesn't process as relocations.  The latter sort are
6138    stored in a normal bfd section by bfd_section_from_shdr.   We don't
6139    consider the former sort here, unless they form part of the loadable
6140    image.  Reloc sections not assigned here will be handled later by
6141    assign_file_positions_for_relocs.
6142
6143    We also don't set the positions of the .symtab and .strtab here.  */
6144
6145 static bfd_boolean
6146 assign_file_positions_except_relocs (bfd *abfd,
6147                                      struct bfd_link_info *link_info)
6148 {
6149   struct elf_obj_tdata *tdata = elf_tdata (abfd);
6150   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6151   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6152
6153   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
6154       && bfd_get_format (abfd) != bfd_core)
6155     {
6156       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
6157       unsigned int num_sec = elf_numsections (abfd);
6158       Elf_Internal_Shdr **hdrpp;
6159       unsigned int i;
6160       file_ptr off;
6161
6162       /* Start after the ELF header.  */
6163       off = i_ehdrp->e_ehsize;
6164
6165       /* We are not creating an executable, which means that we are
6166          not creating a program header, and that the actual order of
6167          the sections in the file is unimportant.  */
6168       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
6169         {
6170           Elf_Internal_Shdr *hdr;
6171
6172           hdr = *hdrpp;
6173           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
6174                && hdr->bfd_section == NULL)
6175               || (hdr->bfd_section != NULL
6176                   && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
6177                   /* Compress DWARF debug sections.  */
6178               || i == elf_onesymtab (abfd)
6179               || (elf_symtab_shndx_list (abfd) != NULL
6180                   && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
6181               || i == elf_strtab_sec (abfd)
6182               || i == elf_shstrtab_sec (abfd))
6183             {
6184               hdr->sh_offset = -1;
6185             }
6186           else
6187             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
6188         }
6189
6190       elf_next_file_pos (abfd) = off;
6191     }
6192   else
6193     {
6194       unsigned int alloc;
6195
6196       /* Assign file positions for the loaded sections based on the
6197          assignment of sections to segments.  */
6198       if (!assign_file_positions_for_load_sections (abfd, link_info))
6199         return FALSE;
6200
6201       /* And for non-load sections.  */
6202       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
6203         return FALSE;
6204
6205       if (bed->elf_backend_modify_program_headers != NULL)
6206         {
6207           if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
6208             return FALSE;
6209         }
6210
6211       /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.  */
6212       if (link_info != NULL && bfd_link_pie (link_info))
6213         {
6214           unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
6215           Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
6216           Elf_Internal_Phdr *end_segment = &segment[num_segments];
6217
6218           /* Find the lowest p_vaddr in PT_LOAD segments.  */
6219           bfd_vma p_vaddr = (bfd_vma) -1;
6220           for (; segment < end_segment; segment++)
6221             if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
6222               p_vaddr = segment->p_vaddr;
6223
6224           /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6225              segments is non-zero.  */
6226           if (p_vaddr)
6227             i_ehdrp->e_type = ET_EXEC;
6228         }
6229
6230       /* Write out the program headers.  */
6231       alloc = elf_elfheader (abfd)->e_phnum;
6232       if (alloc == 0)
6233         return TRUE;
6234
6235       /* PR ld/20815 - Check that the program header segment, if present, will
6236          be loaded into memory.  FIXME: The check below is not sufficient as
6237          really all PT_LOAD segments should be checked before issuing an error
6238          message.  Plus the PHDR segment does not have to be the first segment
6239          in the program header table.  But this version of the check should
6240          catch all real world use cases.
6241
6242          FIXME: We used to have code here to sort the PT_LOAD segments into
6243          ascending order, as per the ELF spec.  But this breaks some programs,
6244          including the Linux kernel.  But really either the spec should be
6245          changed or the programs updated.  */
6246       if (alloc > 1
6247           && tdata->phdr[0].p_type == PT_PHDR
6248           && (bed->elf_backend_allow_non_load_phdr == NULL
6249               || !bed->elf_backend_allow_non_load_phdr (abfd, tdata->phdr,
6250                                                         alloc))
6251           && tdata->phdr[1].p_type == PT_LOAD
6252           && (tdata->phdr[1].p_vaddr > tdata->phdr[0].p_vaddr
6253               || (tdata->phdr[1].p_vaddr + tdata->phdr[1].p_memsz
6254                   < tdata->phdr[0].p_vaddr + tdata->phdr[0].p_memsz)))
6255         {
6256           /* The fix for this error is usually to edit the linker script being
6257              used and set up the program headers manually.  Either that or
6258              leave room for the headers at the start of the SECTIONS.  */
6259           _bfd_error_handler (_("%pB: error: PHDR segment not covered"
6260                                 " by LOAD segment"),
6261                               abfd);
6262           return FALSE;
6263         }
6264
6265       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
6266           || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
6267         return FALSE;
6268     }
6269
6270   return TRUE;
6271 }
6272
6273 static bfd_boolean
6274 prep_headers (bfd *abfd)
6275 {
6276   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form.  */
6277   struct elf_strtab_hash *shstrtab;
6278   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6279
6280   i_ehdrp = elf_elfheader (abfd);
6281
6282   shstrtab = _bfd_elf_strtab_init ();
6283   if (shstrtab == NULL)
6284     return FALSE;
6285
6286   elf_shstrtab (abfd) = shstrtab;
6287
6288   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
6289   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
6290   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
6291   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
6292
6293   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
6294   i_ehdrp->e_ident[EI_DATA] =
6295     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
6296   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
6297
6298   if ((abfd->flags & DYNAMIC) != 0)
6299     i_ehdrp->e_type = ET_DYN;
6300   else if ((abfd->flags & EXEC_P) != 0)
6301     i_ehdrp->e_type = ET_EXEC;
6302   else if (bfd_get_format (abfd) == bfd_core)
6303     i_ehdrp->e_type = ET_CORE;
6304   else
6305     i_ehdrp->e_type = ET_REL;
6306
6307   switch (bfd_get_arch (abfd))
6308     {
6309     case bfd_arch_unknown:
6310       i_ehdrp->e_machine = EM_NONE;
6311       break;
6312
6313       /* There used to be a long list of cases here, each one setting
6314          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6315          in the corresponding bfd definition.  To avoid duplication,
6316          the switch was removed.  Machines that need special handling
6317          can generally do it in elf_backend_final_write_processing(),
6318          unless they need the information earlier than the final write.
6319          Such need can generally be supplied by replacing the tests for
6320          e_machine with the conditions used to determine it.  */
6321     default:
6322       i_ehdrp->e_machine = bed->elf_machine_code;
6323     }
6324
6325   i_ehdrp->e_version = bed->s->ev_current;
6326   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
6327
6328   /* No program header, for now.  */
6329   i_ehdrp->e_phoff = 0;
6330   i_ehdrp->e_phentsize = 0;
6331   i_ehdrp->e_phnum = 0;
6332
6333   /* Each bfd section is section header entry.  */
6334   i_ehdrp->e_entry = bfd_get_start_address (abfd);
6335   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
6336
6337   /* If we're building an executable, we'll need a program header table.  */
6338   if (abfd->flags & EXEC_P)
6339     /* It all happens later.  */
6340     ;
6341   else
6342     {
6343       i_ehdrp->e_phentsize = 0;
6344       i_ehdrp->e_phoff = 0;
6345     }
6346
6347   elf_tdata (abfd)->symtab_hdr.sh_name =
6348     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
6349   elf_tdata (abfd)->strtab_hdr.sh_name =
6350     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
6351   elf_tdata (abfd)->shstrtab_hdr.sh_name =
6352     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
6353   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
6354       || elf_tdata (abfd)->strtab_hdr.sh_name == (unsigned int) -1
6355       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
6356     return FALSE;
6357
6358   return TRUE;
6359 }
6360
6361 /* Assign file positions for all the reloc sections which are not part
6362    of the loadable file image, and the file position of section headers.  */
6363
6364 static bfd_boolean
6365 _bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
6366 {
6367   file_ptr off;
6368   Elf_Internal_Shdr **shdrpp, **end_shdrpp;
6369   Elf_Internal_Shdr *shdrp;
6370   Elf_Internal_Ehdr *i_ehdrp;
6371   const struct elf_backend_data *bed;
6372
6373   off = elf_next_file_pos (abfd);
6374
6375   shdrpp = elf_elfsections (abfd);
6376   end_shdrpp = shdrpp + elf_numsections (abfd);
6377   for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
6378     {
6379       shdrp = *shdrpp;
6380       if (shdrp->sh_offset == -1)
6381         {
6382           asection *sec = shdrp->bfd_section;
6383           bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
6384                                 || shdrp->sh_type == SHT_RELA);
6385           if (is_rel
6386               || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
6387             {
6388               if (!is_rel)
6389                 {
6390                   const char *name = sec->name;
6391                   struct bfd_elf_section_data *d;
6392
6393                   /* Compress DWARF debug sections.  */
6394                   if (!bfd_compress_section (abfd, sec,
6395                                              shdrp->contents))
6396                     return FALSE;
6397
6398                   if (sec->compress_status == COMPRESS_SECTION_DONE
6399                       && (abfd->flags & BFD_COMPRESS_GABI) == 0)
6400                     {
6401                       /* If section is compressed with zlib-gnu, convert
6402                          section name from .debug_* to .zdebug_*.  */
6403                       char *new_name
6404                         = convert_debug_to_zdebug (abfd, name);
6405                       if (new_name == NULL)
6406                         return FALSE;
6407                       name = new_name;
6408                     }
6409                   /* Add section name to section name section.  */
6410                   if (shdrp->sh_name != (unsigned int) -1)
6411                     abort ();
6412                   shdrp->sh_name
6413                     = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
6414                                                           name, FALSE);
6415                   d = elf_section_data (sec);
6416
6417                   /* Add reloc section name to section name section.  */
6418                   if (d->rel.hdr
6419                       && !_bfd_elf_set_reloc_sh_name (abfd,
6420                                                       d->rel.hdr,
6421                                                       name, FALSE))
6422                     return FALSE;
6423                   if (d->rela.hdr
6424                       && !_bfd_elf_set_reloc_sh_name (abfd,
6425                                                       d->rela.hdr,
6426                                                       name, TRUE))
6427                     return FALSE;
6428
6429                   /* Update section size and contents.  */
6430                   shdrp->sh_size = sec->size;
6431                   shdrp->contents = sec->contents;
6432                   shdrp->bfd_section->contents = NULL;
6433                 }
6434               off = _bfd_elf_assign_file_position_for_section (shdrp,
6435                                                                off,
6436                                                                TRUE);
6437             }
6438         }
6439     }
6440
6441   /* Place section name section after DWARF debug sections have been
6442      compressed.  */
6443   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
6444   shdrp = &elf_tdata (abfd)->shstrtab_hdr;
6445   shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
6446   off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
6447
6448   /* Place the section headers.  */
6449   i_ehdrp = elf_elfheader (abfd);
6450   bed = get_elf_backend_data (abfd);
6451   off = align_file_position (off, 1 << bed->s->log_file_align);
6452   i_ehdrp->e_shoff = off;
6453   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
6454   elf_next_file_pos (abfd) = off;
6455
6456   return TRUE;
6457 }
6458
6459 bfd_boolean
6460 _bfd_elf_write_object_contents (bfd *abfd)
6461 {
6462   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6463   Elf_Internal_Shdr **i_shdrp;
6464   bfd_boolean failed;
6465   unsigned int count, num_sec;
6466   struct elf_obj_tdata *t;
6467
6468   if (! abfd->output_has_begun
6469       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6470     return FALSE;
6471   /* Do not rewrite ELF data when the BFD has been opened for update.
6472      abfd->output_has_begun was set to TRUE on opening, so creation of new
6473      sections, and modification of existing section sizes was restricted.
6474      This means the ELF header, program headers and section headers can't have
6475      changed.
6476      If the contents of any sections has been modified, then those changes have
6477      already been written to the BFD.  */
6478   else if (abfd->direction == both_direction)
6479     {
6480       BFD_ASSERT (abfd->output_has_begun);
6481       return TRUE;
6482     }
6483
6484   i_shdrp = elf_elfsections (abfd);
6485
6486   failed = FALSE;
6487   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
6488   if (failed)
6489     return FALSE;
6490
6491   if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
6492     return FALSE;
6493
6494   /* After writing the headers, we need to write the sections too...  */
6495   num_sec = elf_numsections (abfd);
6496   for (count = 1; count < num_sec; count++)
6497     {
6498       i_shdrp[count]->sh_name
6499         = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
6500                                   i_shdrp[count]->sh_name);
6501       if (bed->elf_backend_section_processing)
6502         if (!(*bed->elf_backend_section_processing) (abfd, i_shdrp[count]))
6503           return FALSE;
6504       if (i_shdrp[count]->contents)
6505         {
6506           bfd_size_type amt = i_shdrp[count]->sh_size;
6507
6508           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
6509               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
6510             return FALSE;
6511         }
6512     }
6513
6514   /* Write out the section header names.  */
6515   t = elf_tdata (abfd);
6516   if (elf_shstrtab (abfd) != NULL
6517       && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
6518           || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
6519     return FALSE;
6520
6521   if (bed->elf_backend_final_write_processing)
6522     (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
6523
6524   if (!bed->s->write_shdrs_and_ehdr (abfd))
6525     return FALSE;
6526
6527   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
6528   if (t->o->build_id.after_write_object_contents != NULL)
6529     return (*t->o->build_id.after_write_object_contents) (abfd);
6530
6531   return TRUE;
6532 }
6533
6534 bfd_boolean
6535 _bfd_elf_write_corefile_contents (bfd *abfd)
6536 {
6537   /* Hopefully this can be done just like an object file.  */
6538   return _bfd_elf_write_object_contents (abfd);
6539 }
6540
6541 /* Given a section, search the header to find them.  */
6542
6543 unsigned int
6544 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
6545 {
6546   const struct elf_backend_data *bed;
6547   unsigned int sec_index;
6548
6549   if (elf_section_data (asect) != NULL
6550       && elf_section_data (asect)->this_idx != 0)
6551     return elf_section_data (asect)->this_idx;
6552
6553   if (bfd_is_abs_section (asect))
6554     sec_index = SHN_ABS;
6555   else if (bfd_is_com_section (asect))
6556     sec_index = SHN_COMMON;
6557   else if (bfd_is_und_section (asect))
6558     sec_index = SHN_UNDEF;
6559   else
6560     sec_index = SHN_BAD;
6561
6562   bed = get_elf_backend_data (abfd);
6563   if (bed->elf_backend_section_from_bfd_section)
6564     {
6565       int retval = sec_index;
6566
6567       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
6568         return retval;
6569     }
6570
6571   if (sec_index == SHN_BAD)
6572     bfd_set_error (bfd_error_nonrepresentable_section);
6573
6574   return sec_index;
6575 }
6576
6577 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6578    on error.  */
6579
6580 int
6581 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
6582 {
6583   asymbol *asym_ptr = *asym_ptr_ptr;
6584   int idx;
6585   flagword flags = asym_ptr->flags;
6586
6587   /* When gas creates relocations against local labels, it creates its
6588      own symbol for the section, but does put the symbol into the
6589      symbol chain, so udata is 0.  When the linker is generating
6590      relocatable output, this section symbol may be for one of the
6591      input sections rather than the output section.  */
6592   if (asym_ptr->udata.i == 0
6593       && (flags & BSF_SECTION_SYM)
6594       && asym_ptr->section)
6595     {
6596       asection *sec;
6597       int indx;
6598
6599       sec = asym_ptr->section;
6600       if (sec->owner != abfd && sec->output_section != NULL)
6601         sec = sec->output_section;
6602       if (sec->owner == abfd
6603           && (indx = sec->index) < elf_num_section_syms (abfd)
6604           && elf_section_syms (abfd)[indx] != NULL)
6605         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
6606     }
6607
6608   idx = asym_ptr->udata.i;
6609
6610   if (idx == 0)
6611     {
6612       /* This case can occur when using --strip-symbol on a symbol
6613          which is used in a relocation entry.  */
6614       _bfd_error_handler
6615         /* xgettext:c-format */
6616         (_("%pB: symbol `%s' required but not present"),
6617          abfd, bfd_asymbol_name (asym_ptr));
6618       bfd_set_error (bfd_error_no_symbols);
6619       return -1;
6620     }
6621
6622 #if DEBUG & 4
6623   {
6624     fprintf (stderr,
6625              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6626              (long) asym_ptr, asym_ptr->name, idx, flags);
6627     fflush (stderr);
6628   }
6629 #endif
6630
6631   return idx;
6632 }
6633
6634 /* Rewrite program header information.  */
6635
6636 static bfd_boolean
6637 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
6638 {
6639   Elf_Internal_Ehdr *iehdr;
6640   struct elf_segment_map *map;
6641   struct elf_segment_map *map_first;
6642   struct elf_segment_map **pointer_to_map;
6643   Elf_Internal_Phdr *segment;
6644   asection *section;
6645   unsigned int i;
6646   unsigned int num_segments;
6647   bfd_boolean phdr_included = FALSE;
6648   bfd_boolean p_paddr_valid;
6649   bfd_vma maxpagesize;
6650   struct elf_segment_map *phdr_adjust_seg = NULL;
6651   unsigned int phdr_adjust_num = 0;
6652   const struct elf_backend_data *bed;
6653
6654   bed = get_elf_backend_data (ibfd);
6655   iehdr = elf_elfheader (ibfd);
6656
6657   map_first = NULL;
6658   pointer_to_map = &map_first;
6659
6660   num_segments = elf_elfheader (ibfd)->e_phnum;
6661   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
6662
6663   /* Returns the end address of the segment + 1.  */
6664 #define SEGMENT_END(segment, start)                                     \
6665   (start + (segment->p_memsz > segment->p_filesz                        \
6666             ? segment->p_memsz : segment->p_filesz))
6667
6668 #define SECTION_SIZE(section, segment)                                  \
6669   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
6670     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
6671    ? section->size : 0)
6672
6673   /* Returns TRUE if the given section is contained within
6674      the given segment.  VMA addresses are compared.  */
6675 #define IS_CONTAINED_BY_VMA(section, segment)                           \
6676   (section->vma >= segment->p_vaddr                                     \
6677    && (section->vma + SECTION_SIZE (section, segment)                   \
6678        <= (SEGMENT_END (segment, segment->p_vaddr))))
6679
6680   /* Returns TRUE if the given section is contained within
6681      the given segment.  LMA addresses are compared.  */
6682 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
6683   (section->lma >= base                                                 \
6684    && (section->lma + SECTION_SIZE (section, segment) >= section->lma)  \
6685    && (section->lma + SECTION_SIZE (section, segment)                   \
6686        <= SEGMENT_END (segment, base)))
6687
6688   /* Handle PT_NOTE segment.  */
6689 #define IS_NOTE(p, s)                                                   \
6690   (p->p_type == PT_NOTE                                                 \
6691    && elf_section_type (s) == SHT_NOTE                                  \
6692    && (bfd_vma) s->filepos >= p->p_offset                               \
6693    && ((bfd_vma) s->filepos + s->size                                   \
6694        <= p->p_offset + p->p_filesz))
6695
6696   /* Special case: corefile "NOTE" section containing regs, prpsinfo
6697      etc.  */
6698 #define IS_COREFILE_NOTE(p, s)                                          \
6699   (IS_NOTE (p, s)                                                       \
6700    && bfd_get_format (ibfd) == bfd_core                                 \
6701    && s->vma == 0                                                       \
6702    && s->lma == 0)
6703
6704   /* The complicated case when p_vaddr is 0 is to handle the Solaris
6705      linker, which generates a PT_INTERP section with p_vaddr and
6706      p_memsz set to 0.  */
6707 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
6708   (p->p_vaddr == 0                                                      \
6709    && p->p_paddr == 0                                                   \
6710    && p->p_memsz == 0                                                   \
6711    && p->p_filesz > 0                                                   \
6712    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
6713    && s->size > 0                                                       \
6714    && (bfd_vma) s->filepos >= p->p_offset                               \
6715    && ((bfd_vma) s->filepos + s->size                                   \
6716        <= p->p_offset + p->p_filesz))
6717
6718   /* Decide if the given section should be included in the given segment.
6719      A section will be included if:
6720        1. It is within the address space of the segment -- we use the LMA
6721           if that is set for the segment and the VMA otherwise,
6722        2. It is an allocated section or a NOTE section in a PT_NOTE
6723           segment.
6724        3. There is an output section associated with it,
6725        4. The section has not already been allocated to a previous segment.
6726        5. PT_GNU_STACK segments do not include any sections.
6727        6. PT_TLS segment includes only SHF_TLS sections.
6728        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6729        8. PT_DYNAMIC should not contain empty sections at the beginning
6730           (with the possible exception of .dynamic).  */
6731 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)              \
6732   ((((segment->p_paddr                                                  \
6733       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
6734       : IS_CONTAINED_BY_VMA (section, segment))                         \
6735      && (section->flags & SEC_ALLOC) != 0)                              \
6736     || IS_NOTE (segment, section))                                      \
6737    && segment->p_type != PT_GNU_STACK                                   \
6738    && (segment->p_type != PT_TLS                                        \
6739        || (section->flags & SEC_THREAD_LOCAL))                          \
6740    && (segment->p_type == PT_LOAD                                       \
6741        || segment->p_type == PT_TLS                                     \
6742        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
6743    && (segment->p_type != PT_DYNAMIC                                    \
6744        || SECTION_SIZE (section, segment) > 0                           \
6745        || (segment->p_paddr                                             \
6746            ? segment->p_paddr != section->lma                           \
6747            : segment->p_vaddr != section->vma)                          \
6748        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
6749            == 0))                                                       \
6750    && (segment->p_type != PT_LOAD || !section->segment_mark))
6751
6752 /* If the output section of a section in the input segment is NULL,
6753    it is removed from the corresponding output segment.   */
6754 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
6755   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)          \
6756    && section->output_section != NULL)
6757
6758   /* Returns TRUE iff seg1 starts after the end of seg2.  */
6759 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
6760   (seg1->field >= SEGMENT_END (seg2, seg2->field))
6761
6762   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6763      their VMA address ranges and their LMA address ranges overlap.
6764      It is possible to have overlapping VMA ranges without overlapping LMA
6765      ranges.  RedBoot images for example can have both .data and .bss mapped
6766      to the same VMA range, but with the .data section mapped to a different
6767      LMA.  */
6768 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
6769   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
6770         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
6771    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
6772         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6773
6774   /* Initialise the segment mark field.  */
6775   for (section = ibfd->sections; section != NULL; section = section->next)
6776     section->segment_mark = FALSE;
6777
6778   /* The Solaris linker creates program headers in which all the
6779      p_paddr fields are zero.  When we try to objcopy or strip such a
6780      file, we get confused.  Check for this case, and if we find it
6781      don't set the p_paddr_valid fields.  */
6782   p_paddr_valid = FALSE;
6783   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6784        i < num_segments;
6785        i++, segment++)
6786     if (segment->p_paddr != 0)
6787       {
6788         p_paddr_valid = TRUE;
6789         break;
6790       }
6791
6792   /* Scan through the segments specified in the program header
6793      of the input BFD.  For this first scan we look for overlaps
6794      in the loadable segments.  These can be created by weird
6795      parameters to objcopy.  Also, fix some solaris weirdness.  */
6796   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6797        i < num_segments;
6798        i++, segment++)
6799     {
6800       unsigned int j;
6801       Elf_Internal_Phdr *segment2;
6802
6803       if (segment->p_type == PT_INTERP)
6804         for (section = ibfd->sections; section; section = section->next)
6805           if (IS_SOLARIS_PT_INTERP (segment, section))
6806             {
6807               /* Mininal change so that the normal section to segment
6808                  assignment code will work.  */
6809               segment->p_vaddr = section->vma;
6810               break;
6811             }
6812
6813       if (segment->p_type != PT_LOAD)
6814         {
6815           /* Remove PT_GNU_RELRO segment.  */
6816           if (segment->p_type == PT_GNU_RELRO)
6817             segment->p_type = PT_NULL;
6818           continue;
6819         }
6820
6821       /* Determine if this segment overlaps any previous segments.  */
6822       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
6823         {
6824           bfd_signed_vma extra_length;
6825
6826           if (segment2->p_type != PT_LOAD
6827               || !SEGMENT_OVERLAPS (segment, segment2))
6828             continue;
6829
6830           /* Merge the two segments together.  */
6831           if (segment2->p_vaddr < segment->p_vaddr)
6832             {
6833               /* Extend SEGMENT2 to include SEGMENT and then delete
6834                  SEGMENT.  */
6835               extra_length = (SEGMENT_END (segment, segment->p_vaddr)
6836                               - SEGMENT_END (segment2, segment2->p_vaddr));
6837
6838               if (extra_length > 0)
6839                 {
6840                   segment2->p_memsz += extra_length;
6841                   segment2->p_filesz += extra_length;
6842                 }
6843
6844               segment->p_type = PT_NULL;
6845
6846               /* Since we have deleted P we must restart the outer loop.  */
6847               i = 0;
6848               segment = elf_tdata (ibfd)->phdr;
6849               break;
6850             }
6851           else
6852             {
6853               /* Extend SEGMENT to include SEGMENT2 and then delete
6854                  SEGMENT2.  */
6855               extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
6856                               - SEGMENT_END (segment, segment->p_vaddr));
6857
6858               if (extra_length > 0)
6859                 {
6860                   segment->p_memsz += extra_length;
6861                   segment->p_filesz += extra_length;
6862                 }
6863
6864               segment2->p_type = PT_NULL;
6865             }
6866         }
6867     }
6868
6869   /* The second scan attempts to assign sections to segments.  */
6870   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6871        i < num_segments;
6872        i++, segment++)
6873     {
6874       unsigned int section_count;
6875       asection **sections;
6876       asection *output_section;
6877       unsigned int isec;
6878       asection *matching_lma;
6879       asection *suggested_lma;
6880       unsigned int j;
6881       bfd_size_type amt;
6882       asection *first_section;
6883
6884       if (segment->p_type == PT_NULL)
6885         continue;
6886
6887       first_section = NULL;
6888       /* Compute how many sections might be placed into this segment.  */
6889       for (section = ibfd->sections, section_count = 0;
6890            section != NULL;
6891            section = section->next)
6892         {
6893           /* Find the first section in the input segment, which may be
6894              removed from the corresponding output segment.   */
6895           if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6896             {
6897               if (first_section == NULL)
6898                 first_section = section;
6899               if (section->output_section != NULL)
6900                 ++section_count;
6901             }
6902         }
6903
6904       /* Allocate a segment map big enough to contain
6905          all of the sections we have selected.  */
6906       amt = sizeof (struct elf_segment_map) - sizeof (asection *);
6907       amt += (bfd_size_type) section_count * sizeof (asection *);
6908       map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6909       if (map == NULL)
6910         return FALSE;
6911
6912       /* Initialise the fields of the segment map.  Default to
6913          using the physical address of the segment in the input BFD.  */
6914       map->next = NULL;
6915       map->p_type = segment->p_type;
6916       map->p_flags = segment->p_flags;
6917       map->p_flags_valid = 1;
6918
6919       /* If the first section in the input segment is removed, there is
6920          no need to preserve segment physical address in the corresponding
6921          output segment.  */
6922       if (!first_section || first_section->output_section != NULL)
6923         {
6924           map->p_paddr = segment->p_paddr;
6925           map->p_paddr_valid = p_paddr_valid;
6926         }
6927
6928       /* Determine if this segment contains the ELF file header
6929          and if it contains the program headers themselves.  */
6930       map->includes_filehdr = (segment->p_offset == 0
6931                                && segment->p_filesz >= iehdr->e_ehsize);
6932       map->includes_phdrs = 0;
6933
6934       if (!phdr_included || segment->p_type != PT_LOAD)
6935         {
6936           map->includes_phdrs =
6937             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6938              && (segment->p_offset + segment->p_filesz
6939                  >= ((bfd_vma) iehdr->e_phoff
6940                      + iehdr->e_phnum * iehdr->e_phentsize)));
6941
6942           if (segment->p_type == PT_LOAD && map->includes_phdrs)
6943             phdr_included = TRUE;
6944         }
6945
6946       if (section_count == 0)
6947         {
6948           /* Special segments, such as the PT_PHDR segment, may contain
6949              no sections, but ordinary, loadable segments should contain
6950              something.  They are allowed by the ELF spec however, so only
6951              a warning is produced.
6952              There is however the valid use case of embedded systems which
6953              have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6954              flash memory with zeros.  No warning is shown for that case.  */
6955           if (segment->p_type == PT_LOAD
6956               && (segment->p_filesz > 0 || segment->p_memsz == 0))
6957             /* xgettext:c-format */
6958             _bfd_error_handler
6959               (_("%pB: warning: empty loadable segment detected"
6960                  " at vaddr=%#" PRIx64 ", is this intentional?"),
6961                ibfd, (uint64_t) segment->p_vaddr);
6962
6963           map->p_vaddr_offset = segment->p_vaddr;
6964           map->count = 0;
6965           *pointer_to_map = map;
6966           pointer_to_map = &map->next;
6967
6968           continue;
6969         }
6970
6971       /* Now scan the sections in the input BFD again and attempt
6972          to add their corresponding output sections to the segment map.
6973          The problem here is how to handle an output section which has
6974          been moved (ie had its LMA changed).  There are four possibilities:
6975
6976          1. None of the sections have been moved.
6977             In this case we can continue to use the segment LMA from the
6978             input BFD.
6979
6980          2. All of the sections have been moved by the same amount.
6981             In this case we can change the segment's LMA to match the LMA
6982             of the first section.
6983
6984          3. Some of the sections have been moved, others have not.
6985             In this case those sections which have not been moved can be
6986             placed in the current segment which will have to have its size,
6987             and possibly its LMA changed, and a new segment or segments will
6988             have to be created to contain the other sections.
6989
6990          4. The sections have been moved, but not by the same amount.
6991             In this case we can change the segment's LMA to match the LMA
6992             of the first section and we will have to create a new segment
6993             or segments to contain the other sections.
6994
6995          In order to save time, we allocate an array to hold the section
6996          pointers that we are interested in.  As these sections get assigned
6997          to a segment, they are removed from this array.  */
6998
6999       sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
7000       if (sections == NULL)
7001         return FALSE;
7002
7003       /* Step One: Scan for segment vs section LMA conflicts.
7004          Also add the sections to the section array allocated above.
7005          Also add the sections to the current segment.  In the common
7006          case, where the sections have not been moved, this means that
7007          we have completely filled the segment, and there is nothing
7008          more to do.  */
7009       isec = 0;
7010       matching_lma = NULL;
7011       suggested_lma = NULL;
7012
7013       for (section = first_section, j = 0;
7014            section != NULL;
7015            section = section->next)
7016         {
7017           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
7018             {
7019               output_section = section->output_section;
7020
7021               sections[j++] = section;
7022
7023               /* The Solaris native linker always sets p_paddr to 0.
7024                  We try to catch that case here, and set it to the
7025                  correct value.  Note - some backends require that
7026                  p_paddr be left as zero.  */
7027               if (!p_paddr_valid
7028                   && segment->p_vaddr != 0
7029                   && !bed->want_p_paddr_set_to_zero
7030                   && isec == 0
7031                   && output_section->lma != 0
7032                   && (align_power (segment->p_vaddr
7033                                    + (map->includes_filehdr
7034                                       ? iehdr->e_ehsize : 0)
7035                                    + (map->includes_phdrs
7036                                       ? iehdr->e_phnum * iehdr->e_phentsize
7037                                       : 0),
7038                                    output_section->alignment_power)
7039                       == output_section->vma))
7040                 map->p_paddr = segment->p_vaddr;
7041
7042               /* Match up the physical address of the segment with the
7043                  LMA address of the output section.  */
7044               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7045                   || IS_COREFILE_NOTE (segment, section)
7046                   || (bed->want_p_paddr_set_to_zero
7047                       && IS_CONTAINED_BY_VMA (output_section, segment)))
7048                 {
7049                   if (matching_lma == NULL
7050                       || output_section->lma < matching_lma->lma)
7051                     matching_lma = output_section;
7052
7053                   /* We assume that if the section fits within the segment
7054                      then it does not overlap any other section within that
7055                      segment.  */
7056                   map->sections[isec++] = output_section;
7057                 }
7058               else if (suggested_lma == NULL)
7059                 suggested_lma = output_section;
7060
7061               if (j == section_count)
7062                 break;
7063             }
7064         }
7065
7066       BFD_ASSERT (j == section_count);
7067
7068       /* Step Two: Adjust the physical address of the current segment,
7069          if necessary.  */
7070       if (isec == section_count)
7071         {
7072           /* All of the sections fitted within the segment as currently
7073              specified.  This is the default case.  Add the segment to
7074              the list of built segments and carry on to process the next
7075              program header in the input BFD.  */
7076           map->count = section_count;
7077           *pointer_to_map = map;
7078           pointer_to_map = &map->next;
7079
7080           if (p_paddr_valid
7081               && !bed->want_p_paddr_set_to_zero
7082               && matching_lma->lma != map->p_paddr
7083               && !map->includes_filehdr
7084               && !map->includes_phdrs)
7085             /* There is some padding before the first section in the
7086                segment.  So, we must account for that in the output
7087                segment's vma.  */
7088             map->p_vaddr_offset = map->p_paddr - matching_lma->lma;
7089
7090           free (sections);
7091           continue;
7092         }
7093       else
7094         {
7095           /* Change the current segment's physical address to match
7096              the LMA of the first section that fitted, or if no
7097              section fitted, the first section.  */
7098           if (matching_lma == NULL)
7099             matching_lma = suggested_lma;
7100
7101           map->p_paddr = matching_lma->lma;
7102
7103           /* Offset the segment physical address from the lma
7104              to allow for space taken up by elf headers.  */
7105           if (map->includes_phdrs)
7106             {
7107               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
7108
7109               /* iehdr->e_phnum is just an estimate of the number
7110                  of program headers that we will need.  Make a note
7111                  here of the number we used and the segment we chose
7112                  to hold these headers, so that we can adjust the
7113                  offset when we know the correct value.  */
7114               phdr_adjust_num = iehdr->e_phnum;
7115               phdr_adjust_seg = map;
7116             }
7117
7118           if (map->includes_filehdr)
7119             {
7120               bfd_vma align = (bfd_vma) 1 << matching_lma->alignment_power;
7121               map->p_paddr -= iehdr->e_ehsize;
7122               /* We've subtracted off the size of headers from the
7123                  first section lma, but there may have been some
7124                  alignment padding before that section too.  Try to
7125                  account for that by adjusting the segment lma down to
7126                  the same alignment.  */
7127               if (segment->p_align != 0 && segment->p_align < align)
7128                 align = segment->p_align;
7129               map->p_paddr &= -align;
7130             }
7131         }
7132
7133       /* Step Three: Loop over the sections again, this time assigning
7134          those that fit to the current segment and removing them from the
7135          sections array; but making sure not to leave large gaps.  Once all
7136          possible sections have been assigned to the current segment it is
7137          added to the list of built segments and if sections still remain
7138          to be assigned, a new segment is constructed before repeating
7139          the loop.  */
7140       isec = 0;
7141       do
7142         {
7143           map->count = 0;
7144           suggested_lma = NULL;
7145
7146           /* Fill the current segment with sections that fit.  */
7147           for (j = 0; j < section_count; j++)
7148             {
7149               section = sections[j];
7150
7151               if (section == NULL)
7152                 continue;
7153
7154               output_section = section->output_section;
7155
7156               BFD_ASSERT (output_section != NULL);
7157
7158               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7159                   || IS_COREFILE_NOTE (segment, section))
7160                 {
7161                   if (map->count == 0)
7162                     {
7163                       /* If the first section in a segment does not start at
7164                          the beginning of the segment, then something is
7165                          wrong.  */
7166                       if (align_power (map->p_paddr
7167                                        + (map->includes_filehdr
7168                                           ? iehdr->e_ehsize : 0)
7169                                        + (map->includes_phdrs
7170                                           ? iehdr->e_phnum * iehdr->e_phentsize
7171                                           : 0),
7172                                        output_section->alignment_power)
7173                           != output_section->lma)
7174                         abort ();
7175                     }
7176                   else
7177                     {
7178                       asection *prev_sec;
7179
7180                       prev_sec = map->sections[map->count - 1];
7181
7182                       /* If the gap between the end of the previous section
7183                          and the start of this section is more than
7184                          maxpagesize then we need to start a new segment.  */
7185                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
7186                                       maxpagesize)
7187                            < BFD_ALIGN (output_section->lma, maxpagesize))
7188                           || (prev_sec->lma + prev_sec->size
7189                               > output_section->lma))
7190                         {
7191                           if (suggested_lma == NULL)
7192                             suggested_lma = output_section;
7193
7194                           continue;
7195                         }
7196                     }
7197
7198                   map->sections[map->count++] = output_section;
7199                   ++isec;
7200                   sections[j] = NULL;
7201                   if (segment->p_type == PT_LOAD)
7202                     section->segment_mark = TRUE;
7203                 }
7204               else if (suggested_lma == NULL)
7205                 suggested_lma = output_section;
7206             }
7207
7208           /* PR 23932.  A corrupt input file may contain sections that cannot
7209              be assigned to any segment - because for example they have a
7210              negative size - or segments that do not contain any sections.  */
7211           if (map->count == 0)
7212             {
7213               bfd_set_error (bfd_error_bad_value);
7214               free (sections);
7215               return FALSE;
7216             }
7217
7218           /* Add the current segment to the list of built segments.  */
7219           *pointer_to_map = map;
7220           pointer_to_map = &map->next;
7221
7222           if (isec < section_count)
7223             {
7224               /* We still have not allocated all of the sections to
7225                  segments.  Create a new segment here, initialise it
7226                  and carry on looping.  */
7227               amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7228               amt += (bfd_size_type) section_count * sizeof (asection *);
7229               map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7230               if (map == NULL)
7231                 {
7232                   free (sections);
7233                   return FALSE;
7234                 }
7235
7236               /* Initialise the fields of the segment map.  Set the physical
7237                  physical address to the LMA of the first section that has
7238                  not yet been assigned.  */
7239               map->next = NULL;
7240               map->p_type = segment->p_type;
7241               map->p_flags = segment->p_flags;
7242               map->p_flags_valid = 1;
7243               map->p_paddr = suggested_lma->lma;
7244               map->p_paddr_valid = p_paddr_valid;
7245               map->includes_filehdr = 0;
7246               map->includes_phdrs = 0;
7247             }
7248         }
7249       while (isec < section_count);
7250
7251       free (sections);
7252     }
7253
7254   elf_seg_map (obfd) = map_first;
7255
7256   /* If we had to estimate the number of program headers that were
7257      going to be needed, then check our estimate now and adjust
7258      the offset if necessary.  */
7259   if (phdr_adjust_seg != NULL)
7260     {
7261       unsigned int count;
7262
7263       for (count = 0, map = map_first; map != NULL; map = map->next)
7264         count++;
7265
7266       if (count > phdr_adjust_num)
7267         phdr_adjust_seg->p_paddr
7268           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
7269
7270       for (map = map_first; map != NULL; map = map->next)
7271         if (map->p_type == PT_PHDR)
7272           {
7273             bfd_vma adjust
7274               = phdr_adjust_seg->includes_filehdr ? iehdr->e_ehsize : 0;
7275             map->p_paddr = phdr_adjust_seg->p_paddr + adjust;
7276             break;
7277           }
7278     }
7279
7280 #undef SEGMENT_END
7281 #undef SECTION_SIZE
7282 #undef IS_CONTAINED_BY_VMA
7283 #undef IS_CONTAINED_BY_LMA
7284 #undef IS_NOTE
7285 #undef IS_COREFILE_NOTE
7286 #undef IS_SOLARIS_PT_INTERP
7287 #undef IS_SECTION_IN_INPUT_SEGMENT
7288 #undef INCLUDE_SECTION_IN_SEGMENT
7289 #undef SEGMENT_AFTER_SEGMENT
7290 #undef SEGMENT_OVERLAPS
7291   return TRUE;
7292 }
7293
7294 /* Copy ELF program header information.  */
7295
7296 static bfd_boolean
7297 copy_elf_program_header (bfd *ibfd, bfd *obfd)
7298 {
7299   Elf_Internal_Ehdr *iehdr;
7300   struct elf_segment_map *map;
7301   struct elf_segment_map *map_first;
7302   struct elf_segment_map **pointer_to_map;
7303   Elf_Internal_Phdr *segment;
7304   unsigned int i;
7305   unsigned int num_segments;
7306   bfd_boolean phdr_included = FALSE;
7307   bfd_boolean p_paddr_valid;
7308
7309   iehdr = elf_elfheader (ibfd);
7310
7311   map_first = NULL;
7312   pointer_to_map = &map_first;
7313
7314   /* If all the segment p_paddr fields are zero, don't set
7315      map->p_paddr_valid.  */
7316   p_paddr_valid = FALSE;
7317   num_segments = elf_elfheader (ibfd)->e_phnum;
7318   for (i = 0, segment = elf_tdata (ibfd)->phdr;
7319        i < num_segments;
7320        i++, segment++)
7321     if (segment->p_paddr != 0)
7322       {
7323         p_paddr_valid = TRUE;
7324         break;
7325       }
7326
7327   for (i = 0, segment = elf_tdata (ibfd)->phdr;
7328        i < num_segments;
7329        i++, segment++)
7330     {
7331       asection *section;
7332       unsigned int section_count;
7333       bfd_size_type amt;
7334       Elf_Internal_Shdr *this_hdr;
7335       asection *first_section = NULL;
7336       asection *lowest_section;
7337       bfd_boolean no_contents = TRUE;
7338
7339       /* Compute how many sections are in this segment.  */
7340       for (section = ibfd->sections, section_count = 0;
7341            section != NULL;
7342            section = section->next)
7343         {
7344           this_hdr = &(elf_section_data(section)->this_hdr);
7345           if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7346             {
7347               if (first_section == NULL)
7348                 first_section = section;
7349               if (elf_section_type (section) != SHT_NOBITS)
7350                 no_contents = FALSE;
7351               section_count++;
7352             }
7353         }
7354
7355       /* Allocate a segment map big enough to contain
7356          all of the sections we have selected.  */
7357       amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7358       amt += (bfd_size_type) section_count * sizeof (asection *);
7359       map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7360       if (map == NULL)
7361         return FALSE;
7362
7363       /* Initialize the fields of the output segment map with the
7364          input segment.  */
7365       map->next = NULL;
7366       map->p_type = segment->p_type;
7367       map->p_flags = segment->p_flags;
7368       map->p_flags_valid = 1;
7369       map->p_paddr = segment->p_paddr;
7370       map->p_paddr_valid = p_paddr_valid;
7371       map->p_align = segment->p_align;
7372       map->p_align_valid = 1;
7373       map->p_vaddr_offset = 0;
7374
7375       if (map->p_type == PT_GNU_RELRO
7376           || map->p_type == PT_GNU_STACK)
7377         {
7378           /* The PT_GNU_RELRO segment may contain the first a few
7379              bytes in the .got.plt section even if the whole .got.plt
7380              section isn't in the PT_GNU_RELRO segment.  We won't
7381              change the size of the PT_GNU_RELRO segment.
7382              Similarly, PT_GNU_STACK size is significant on uclinux
7383              systems.    */
7384           map->p_size = segment->p_memsz;
7385           map->p_size_valid = 1;
7386         }
7387
7388       /* Determine if this segment contains the ELF file header
7389          and if it contains the program headers themselves.  */
7390       map->includes_filehdr = (segment->p_offset == 0
7391                                && segment->p_filesz >= iehdr->e_ehsize);
7392
7393       map->includes_phdrs = 0;
7394       if (! phdr_included || segment->p_type != PT_LOAD)
7395         {
7396           map->includes_phdrs =
7397             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
7398              && (segment->p_offset + segment->p_filesz
7399                  >= ((bfd_vma) iehdr->e_phoff
7400                      + iehdr->e_phnum * iehdr->e_phentsize)));
7401
7402           if (segment->p_type == PT_LOAD && map->includes_phdrs)
7403             phdr_included = TRUE;
7404         }
7405
7406       lowest_section = NULL;
7407       if (section_count != 0)
7408         {
7409           unsigned int isec = 0;
7410
7411           for (section = first_section;
7412                section != NULL;
7413                section = section->next)
7414             {
7415               this_hdr = &(elf_section_data(section)->this_hdr);
7416               if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7417                 {
7418                   map->sections[isec++] = section->output_section;
7419                   if ((section->flags & SEC_ALLOC) != 0)
7420                     {
7421                       bfd_vma seg_off;
7422
7423                       if (lowest_section == NULL
7424                           || section->lma < lowest_section->lma)
7425                         lowest_section = section;
7426
7427                       /* Section lmas are set up from PT_LOAD header
7428                          p_paddr in _bfd_elf_make_section_from_shdr.
7429                          If this header has a p_paddr that disagrees
7430                          with the section lma, flag the p_paddr as
7431                          invalid.  */
7432                       if ((section->flags & SEC_LOAD) != 0)
7433                         seg_off = this_hdr->sh_offset - segment->p_offset;
7434                       else
7435                         seg_off = this_hdr->sh_addr - segment->p_vaddr;
7436                       if (section->lma - segment->p_paddr != seg_off)
7437                         map->p_paddr_valid = FALSE;
7438                     }
7439                   if (isec == section_count)
7440                     break;
7441                 }
7442             }
7443         }
7444
7445       if (map->includes_filehdr && lowest_section != NULL)
7446         {
7447           /* Try to keep the space used by the headers plus any
7448              padding fixed.  If there are sections with file contents
7449              in this segment then the lowest sh_offset is the best
7450              guess.  Otherwise the segment only has file contents for
7451              the headers, and p_filesz is the best guess.  */
7452           if (no_contents)
7453             map->header_size = segment->p_filesz;
7454           else
7455             map->header_size = lowest_section->filepos;
7456         }
7457
7458       if (section_count == 0)
7459         map->p_vaddr_offset = segment->p_vaddr;
7460       else if (!map->includes_phdrs
7461                && !map->includes_filehdr
7462                && map->p_paddr_valid)
7463         /* Account for padding before the first section.  */
7464         map->p_vaddr_offset = (segment->p_paddr
7465                                - (lowest_section ? lowest_section->lma : 0));
7466
7467       map->count = section_count;
7468       *pointer_to_map = map;
7469       pointer_to_map = &map->next;
7470     }
7471
7472   elf_seg_map (obfd) = map_first;
7473   return TRUE;
7474 }
7475
7476 /* Copy private BFD data.  This copies or rewrites ELF program header
7477    information.  */
7478
7479 static bfd_boolean
7480 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7481 {
7482   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7483       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7484     return TRUE;
7485
7486   if (elf_tdata (ibfd)->phdr == NULL)
7487     return TRUE;
7488
7489   if (ibfd->xvec == obfd->xvec)
7490     {
7491       /* Check to see if any sections in the input BFD
7492          covered by ELF program header have changed.  */
7493       Elf_Internal_Phdr *segment;
7494       asection *section, *osec;
7495       unsigned int i, num_segments;
7496       Elf_Internal_Shdr *this_hdr;
7497       const struct elf_backend_data *bed;
7498
7499       bed = get_elf_backend_data (ibfd);
7500
7501       /* Regenerate the segment map if p_paddr is set to 0.  */
7502       if (bed->want_p_paddr_set_to_zero)
7503         goto rewrite;
7504
7505       /* Initialize the segment mark field.  */
7506       for (section = obfd->sections; section != NULL;
7507            section = section->next)
7508         section->segment_mark = FALSE;
7509
7510       num_segments = elf_elfheader (ibfd)->e_phnum;
7511       for (i = 0, segment = elf_tdata (ibfd)->phdr;
7512            i < num_segments;
7513            i++, segment++)
7514         {
7515           /* PR binutils/3535.  The Solaris linker always sets the p_paddr
7516              and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7517              which severly confuses things, so always regenerate the segment
7518              map in this case.  */
7519           if (segment->p_paddr == 0
7520               && segment->p_memsz == 0
7521               && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
7522             goto rewrite;
7523
7524           for (section = ibfd->sections;
7525                section != NULL; section = section->next)
7526             {
7527               /* We mark the output section so that we know it comes
7528                  from the input BFD.  */
7529               osec = section->output_section;
7530               if (osec)
7531                 osec->segment_mark = TRUE;
7532
7533               /* Check if this section is covered by the segment.  */
7534               this_hdr = &(elf_section_data(section)->this_hdr);
7535               if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7536                 {
7537                   /* FIXME: Check if its output section is changed or
7538                      removed.  What else do we need to check?  */
7539                   if (osec == NULL
7540                       || section->flags != osec->flags
7541                       || section->lma != osec->lma
7542                       || section->vma != osec->vma
7543                       || section->size != osec->size
7544                       || section->rawsize != osec->rawsize
7545                       || section->alignment_power != osec->alignment_power)
7546                     goto rewrite;
7547                 }
7548             }
7549         }
7550
7551       /* Check to see if any output section do not come from the
7552          input BFD.  */
7553       for (section = obfd->sections; section != NULL;
7554            section = section->next)
7555         {
7556           if (!section->segment_mark)
7557             goto rewrite;
7558           else
7559             section->segment_mark = FALSE;
7560         }
7561
7562       return copy_elf_program_header (ibfd, obfd);
7563     }
7564
7565 rewrite:
7566   if (ibfd->xvec == obfd->xvec)
7567     {
7568       /* When rewriting program header, set the output maxpagesize to
7569          the maximum alignment of input PT_LOAD segments.  */
7570       Elf_Internal_Phdr *segment;
7571       unsigned int i;
7572       unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7573       bfd_vma maxpagesize = 0;
7574
7575       for (i = 0, segment = elf_tdata (ibfd)->phdr;
7576            i < num_segments;
7577            i++, segment++)
7578         if (segment->p_type == PT_LOAD
7579             && maxpagesize < segment->p_align)
7580           {
7581             /* PR 17512: file: f17299af.  */
7582             if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
7583               /* xgettext:c-format */
7584               _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7585                                     PRIx64 " is too large"),
7586                                   ibfd, (uint64_t) segment->p_align);
7587             else
7588               maxpagesize = segment->p_align;
7589           }
7590
7591       if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7592         bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7593     }
7594
7595   return rewrite_elf_program_header (ibfd, obfd);
7596 }
7597
7598 /* Initialize private output section information from input section.  */
7599
7600 bfd_boolean
7601 _bfd_elf_init_private_section_data (bfd *ibfd,
7602                                     asection *isec,
7603                                     bfd *obfd,
7604                                     asection *osec,
7605                                     struct bfd_link_info *link_info)
7606
7607 {
7608   Elf_Internal_Shdr *ihdr, *ohdr;
7609   bfd_boolean final_link = (link_info != NULL
7610                             && !bfd_link_relocatable (link_info));
7611
7612   if (ibfd->xvec->flavour != bfd_target_elf_flavour
7613       || obfd->xvec->flavour != bfd_target_elf_flavour)
7614     return TRUE;
7615
7616   BFD_ASSERT (elf_section_data (osec) != NULL);
7617
7618   /* For objcopy and relocatable link, don't copy the output ELF
7619      section type from input if the output BFD section flags have been
7620      set to something different.  For a final link allow some flags
7621      that the linker clears to differ.  */
7622   if (elf_section_type (osec) == SHT_NULL
7623       && (osec->flags == isec->flags
7624           || (final_link
7625               && ((osec->flags ^ isec->flags)
7626                   & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
7627     elf_section_type (osec) = elf_section_type (isec);
7628
7629   /* FIXME: Is this correct for all OS/PROC specific flags?  */
7630   elf_section_flags (osec) |= (elf_section_flags (isec)
7631                                & (SHF_MASKOS | SHF_MASKPROC));
7632
7633   /* Copy sh_info from input for mbind section.  */
7634   if (elf_section_flags (isec) & SHF_GNU_MBIND)
7635     elf_section_data (osec)->this_hdr.sh_info
7636       = elf_section_data (isec)->this_hdr.sh_info;
7637
7638   /* Set things up for objcopy and relocatable link.  The output
7639      SHT_GROUP section will have its elf_next_in_group pointing back
7640      to the input group members.  Ignore linker created group section.
7641      See elfNN_ia64_object_p in elfxx-ia64.c.  */
7642   if ((link_info == NULL
7643        || !link_info->resolve_section_groups)
7644       && (elf_sec_group (isec) == NULL
7645           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
7646     {
7647       if (elf_section_flags (isec) & SHF_GROUP)
7648         elf_section_flags (osec) |= SHF_GROUP;
7649       elf_next_in_group (osec) = elf_next_in_group (isec);
7650       elf_section_data (osec)->group = elf_section_data (isec)->group;
7651     }
7652
7653   /* If not decompress, preserve SHF_COMPRESSED.  */
7654   if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
7655     elf_section_flags (osec) |= (elf_section_flags (isec)
7656                                  & SHF_COMPRESSED);
7657
7658   ihdr = &elf_section_data (isec)->this_hdr;
7659
7660   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7661      don't use the output section of the linked-to section since it
7662      may be NULL at this point.  */
7663   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7664     {
7665       ohdr = &elf_section_data (osec)->this_hdr;
7666       ohdr->sh_flags |= SHF_LINK_ORDER;
7667       elf_linked_to_section (osec) = elf_linked_to_section (isec);
7668     }
7669
7670   osec->use_rela_p = isec->use_rela_p;
7671
7672   return TRUE;
7673 }
7674
7675 /* Copy private section information.  This copies over the entsize
7676    field, and sometimes the info field.  */
7677
7678 bfd_boolean
7679 _bfd_elf_copy_private_section_data (bfd *ibfd,
7680                                     asection *isec,
7681                                     bfd *obfd,
7682                                     asection *osec)
7683 {
7684   Elf_Internal_Shdr *ihdr, *ohdr;
7685
7686   if (ibfd->xvec->flavour != bfd_target_elf_flavour
7687       || obfd->xvec->flavour != bfd_target_elf_flavour)
7688     return TRUE;
7689
7690   ihdr = &elf_section_data (isec)->this_hdr;
7691   ohdr = &elf_section_data (osec)->this_hdr;
7692
7693   ohdr->sh_entsize = ihdr->sh_entsize;
7694
7695   if (ihdr->sh_type == SHT_SYMTAB
7696       || ihdr->sh_type == SHT_DYNSYM
7697       || ihdr->sh_type == SHT_GNU_verneed
7698       || ihdr->sh_type == SHT_GNU_verdef)
7699     ohdr->sh_info = ihdr->sh_info;
7700
7701   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7702                                              NULL);
7703 }
7704
7705 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7706    necessary if we are removing either the SHT_GROUP section or any of
7707    the group member sections.  DISCARDED is the value that a section's
7708    output_section has if the section will be discarded, NULL when this
7709    function is called from objcopy, bfd_abs_section_ptr when called
7710    from the linker.  */
7711
7712 bfd_boolean
7713 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
7714 {
7715   asection *isec;
7716
7717   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
7718     if (elf_section_type (isec) == SHT_GROUP)
7719       {
7720         asection *first = elf_next_in_group (isec);
7721         asection *s = first;
7722         bfd_size_type removed = 0;
7723
7724         while (s != NULL)
7725           {
7726             /* If this member section is being output but the
7727                SHT_GROUP section is not, then clear the group info
7728                set up by _bfd_elf_copy_private_section_data.  */
7729             if (s->output_section != discarded
7730                 && isec->output_section == discarded)
7731               {
7732                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
7733                 elf_group_name (s->output_section) = NULL;
7734               }
7735             /* Conversely, if the member section is not being output
7736                but the SHT_GROUP section is, then adjust its size.  */
7737             else if (s->output_section == discarded
7738                      && isec->output_section != discarded)
7739               {
7740                 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
7741                 removed += 4;
7742                 if (elf_sec->rel.hdr != NULL
7743                     && (elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0)
7744                   removed += 4;
7745                 if (elf_sec->rela.hdr != NULL
7746                     && (elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0)
7747                   removed += 4;
7748               }
7749             s = elf_next_in_group (s);
7750             if (s == first)
7751               break;
7752           }
7753         if (removed != 0)
7754           {
7755             if (discarded != NULL)
7756               {
7757                 /* If we've been called for ld -r, then we need to
7758                    adjust the input section size.  */
7759                 if (isec->rawsize == 0)
7760                   isec->rawsize = isec->size;
7761                 isec->size = isec->rawsize - removed;
7762                 if (isec->size <= 4)
7763                   {
7764                     isec->size = 0;
7765                     isec->flags |= SEC_EXCLUDE;
7766                   }
7767               }
7768             else
7769               {
7770                 /* Adjust the output section size when called from
7771                    objcopy. */
7772                 isec->output_section->size -= removed;
7773                 if (isec->output_section->size <= 4)
7774                   {
7775                     isec->output_section->size = 0;
7776                     isec->output_section->flags |= SEC_EXCLUDE;
7777                   }
7778               }
7779           }
7780       }
7781
7782   return TRUE;
7783 }
7784
7785 /* Copy private header information.  */
7786
7787 bfd_boolean
7788 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7789 {
7790   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7791       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7792     return TRUE;
7793
7794   /* Copy over private BFD data if it has not already been copied.
7795      This must be done here, rather than in the copy_private_bfd_data
7796      entry point, because the latter is called after the section
7797      contents have been set, which means that the program headers have
7798      already been worked out.  */
7799   if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
7800     {
7801       if (! copy_private_bfd_data (ibfd, obfd))
7802         return FALSE;
7803     }
7804
7805   return _bfd_elf_fixup_group_sections (ibfd, NULL);
7806 }
7807
7808 /* Copy private symbol information.  If this symbol is in a section
7809    which we did not map into a BFD section, try to map the section
7810    index correctly.  We use special macro definitions for the mapped
7811    section indices; these definitions are interpreted by the
7812    swap_out_syms function.  */
7813
7814 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7815 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7816 #define MAP_STRTAB    (SHN_HIOS + 3)
7817 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
7818 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7819
7820 bfd_boolean
7821 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
7822                                    asymbol *isymarg,
7823                                    bfd *obfd,
7824                                    asymbol *osymarg)
7825 {
7826   elf_symbol_type *isym, *osym;
7827
7828   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7829       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7830     return TRUE;
7831
7832   isym = elf_symbol_from (ibfd, isymarg);
7833   osym = elf_symbol_from (obfd, osymarg);
7834
7835   if (isym != NULL
7836       && isym->internal_elf_sym.st_shndx != 0
7837       && osym != NULL
7838       && bfd_is_abs_section (isym->symbol.section))
7839     {
7840       unsigned int shndx;
7841
7842       shndx = isym->internal_elf_sym.st_shndx;
7843       if (shndx == elf_onesymtab (ibfd))
7844         shndx = MAP_ONESYMTAB;
7845       else if (shndx == elf_dynsymtab (ibfd))
7846         shndx = MAP_DYNSYMTAB;
7847       else if (shndx == elf_strtab_sec (ibfd))
7848         shndx = MAP_STRTAB;
7849       else if (shndx == elf_shstrtab_sec (ibfd))
7850         shndx = MAP_SHSTRTAB;
7851       else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
7852         shndx = MAP_SYM_SHNDX;
7853       osym->internal_elf_sym.st_shndx = shndx;
7854     }
7855
7856   return TRUE;
7857 }
7858
7859 /* Swap out the symbols.  */
7860
7861 static bfd_boolean
7862 swap_out_syms (bfd *abfd,
7863                struct elf_strtab_hash **sttp,
7864                int relocatable_p)
7865 {
7866   const struct elf_backend_data *bed;
7867   int symcount;
7868   asymbol **syms;
7869   struct elf_strtab_hash *stt;
7870   Elf_Internal_Shdr *symtab_hdr;
7871   Elf_Internal_Shdr *symtab_shndx_hdr;
7872   Elf_Internal_Shdr *symstrtab_hdr;
7873   struct elf_sym_strtab *symstrtab;
7874   bfd_byte *outbound_syms;
7875   bfd_byte *outbound_shndx;
7876   unsigned long outbound_syms_index;
7877   unsigned long outbound_shndx_index;
7878   int idx;
7879   unsigned int num_locals;
7880   bfd_size_type amt;
7881   bfd_boolean name_local_sections;
7882
7883   if (!elf_map_symbols (abfd, &num_locals))
7884     return FALSE;
7885
7886   /* Dump out the symtabs.  */
7887   stt = _bfd_elf_strtab_init ();
7888   if (stt == NULL)
7889     return FALSE;
7890
7891   bed = get_elf_backend_data (abfd);
7892   symcount = bfd_get_symcount (abfd);
7893   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7894   symtab_hdr->sh_type = SHT_SYMTAB;
7895   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7896   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
7897   symtab_hdr->sh_info = num_locals + 1;
7898   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
7899
7900   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7901   symstrtab_hdr->sh_type = SHT_STRTAB;
7902
7903   /* Allocate buffer to swap out the .strtab section.  */
7904   symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1)
7905                                                     * sizeof (*symstrtab));
7906   if (symstrtab == NULL)
7907     {
7908       _bfd_elf_strtab_free (stt);
7909       return FALSE;
7910     }
7911
7912   outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
7913                                            bed->s->sizeof_sym);
7914   if (outbound_syms == NULL)
7915     {
7916 error_return:
7917       _bfd_elf_strtab_free (stt);
7918       free (symstrtab);
7919       return FALSE;
7920     }
7921   symtab_hdr->contents = outbound_syms;
7922   outbound_syms_index = 0;
7923
7924   outbound_shndx = NULL;
7925   outbound_shndx_index = 0;
7926
7927   if (elf_symtab_shndx_list (abfd))
7928     {
7929       symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7930       if (symtab_shndx_hdr->sh_name != 0)
7931         {
7932           amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7933           outbound_shndx =  (bfd_byte *)
7934             bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7935           if (outbound_shndx == NULL)
7936             goto error_return;
7937
7938           symtab_shndx_hdr->contents = outbound_shndx;
7939           symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7940           symtab_shndx_hdr->sh_size = amt;
7941           symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7942           symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7943         }
7944       /* FIXME: What about any other headers in the list ?  */
7945     }
7946
7947   /* Now generate the data (for "contents").  */
7948   {
7949     /* Fill in zeroth symbol and swap it out.  */
7950     Elf_Internal_Sym sym;
7951     sym.st_name = 0;
7952     sym.st_value = 0;
7953     sym.st_size = 0;
7954     sym.st_info = 0;
7955     sym.st_other = 0;
7956     sym.st_shndx = SHN_UNDEF;
7957     sym.st_target_internal = 0;
7958     symstrtab[0].sym = sym;
7959     symstrtab[0].dest_index = outbound_syms_index;
7960     symstrtab[0].destshndx_index = outbound_shndx_index;
7961     outbound_syms_index++;
7962     if (outbound_shndx != NULL)
7963       outbound_shndx_index++;
7964   }
7965
7966   name_local_sections
7967     = (bed->elf_backend_name_local_section_symbols
7968        && bed->elf_backend_name_local_section_symbols (abfd));
7969
7970   syms = bfd_get_outsymbols (abfd);
7971   for (idx = 0; idx < symcount;)
7972     {
7973       Elf_Internal_Sym sym;
7974       bfd_vma value = syms[idx]->value;
7975       elf_symbol_type *type_ptr;
7976       flagword flags = syms[idx]->flags;
7977       int type;
7978
7979       if (!name_local_sections
7980           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
7981         {
7982           /* Local section symbols have no name.  */
7983           sym.st_name = (unsigned long) -1;
7984         }
7985       else
7986         {
7987           /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7988              to get the final offset for st_name.  */
7989           sym.st_name
7990             = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
7991                                                    FALSE);
7992           if (sym.st_name == (unsigned long) -1)
7993             goto error_return;
7994         }
7995
7996       type_ptr = elf_symbol_from (abfd, syms[idx]);
7997
7998       if ((flags & BSF_SECTION_SYM) == 0
7999           && bfd_is_com_section (syms[idx]->section))
8000         {
8001           /* ELF common symbols put the alignment into the `value' field,
8002              and the size into the `size' field.  This is backwards from
8003              how BFD handles it, so reverse it here.  */
8004           sym.st_size = value;
8005           if (type_ptr == NULL
8006               || type_ptr->internal_elf_sym.st_value == 0)
8007             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
8008           else
8009             sym.st_value = type_ptr->internal_elf_sym.st_value;
8010           sym.st_shndx = _bfd_elf_section_from_bfd_section
8011             (abfd, syms[idx]->section);
8012         }
8013       else
8014         {
8015           asection *sec = syms[idx]->section;
8016           unsigned int shndx;
8017
8018           if (sec->output_section)
8019             {
8020               value += sec->output_offset;
8021               sec = sec->output_section;
8022             }
8023
8024           /* Don't add in the section vma for relocatable output.  */
8025           if (! relocatable_p)
8026             value += sec->vma;
8027           sym.st_value = value;
8028           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
8029
8030           if (bfd_is_abs_section (sec)
8031               && type_ptr != NULL
8032               && type_ptr->internal_elf_sym.st_shndx != 0)
8033             {
8034               /* This symbol is in a real ELF section which we did
8035                  not create as a BFD section.  Undo the mapping done
8036                  by copy_private_symbol_data.  */
8037               shndx = type_ptr->internal_elf_sym.st_shndx;
8038               switch (shndx)
8039                 {
8040                 case MAP_ONESYMTAB:
8041                   shndx = elf_onesymtab (abfd);
8042                   break;
8043                 case MAP_DYNSYMTAB:
8044                   shndx = elf_dynsymtab (abfd);
8045                   break;
8046                 case MAP_STRTAB:
8047                   shndx = elf_strtab_sec (abfd);
8048                   break;
8049                 case MAP_SHSTRTAB:
8050                   shndx = elf_shstrtab_sec (abfd);
8051                   break;
8052                 case MAP_SYM_SHNDX:
8053                   if (elf_symtab_shndx_list (abfd))
8054                     shndx = elf_symtab_shndx_list (abfd)->ndx;
8055                   break;
8056                 default:
8057                   shndx = SHN_ABS;
8058                   break;
8059                 }
8060             }
8061           else
8062             {
8063               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8064
8065               if (shndx == SHN_BAD)
8066                 {
8067                   asection *sec2;
8068
8069                   /* Writing this would be a hell of a lot easier if
8070                      we had some decent documentation on bfd, and
8071                      knew what to expect of the library, and what to
8072                      demand of applications.  For example, it
8073                      appears that `objcopy' might not set the
8074                      section of a symbol to be a section that is
8075                      actually in the output file.  */
8076                   sec2 = bfd_get_section_by_name (abfd, sec->name);
8077                   if (sec2 != NULL)
8078                     shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
8079                   if (shndx == SHN_BAD)
8080                     {
8081                       /* xgettext:c-format */
8082                       _bfd_error_handler
8083                         (_("unable to find equivalent output section"
8084                            " for symbol '%s' from section '%s'"),
8085                          syms[idx]->name ? syms[idx]->name : "<Local sym>",
8086                          sec->name);
8087                       bfd_set_error (bfd_error_invalid_operation);
8088                       goto error_return;
8089                     }
8090                 }
8091             }
8092
8093           sym.st_shndx = shndx;
8094         }
8095
8096       if ((flags & BSF_THREAD_LOCAL) != 0)
8097         type = STT_TLS;
8098       else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
8099         type = STT_GNU_IFUNC;
8100       else if ((flags & BSF_FUNCTION) != 0)
8101         type = STT_FUNC;
8102       else if ((flags & BSF_OBJECT) != 0)
8103         type = STT_OBJECT;
8104       else if ((flags & BSF_RELC) != 0)
8105         type = STT_RELC;
8106       else if ((flags & BSF_SRELC) != 0)
8107         type = STT_SRELC;
8108       else
8109         type = STT_NOTYPE;
8110
8111       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
8112         type = STT_TLS;
8113
8114       /* Processor-specific types.  */
8115       if (type_ptr != NULL
8116           && bed->elf_backend_get_symbol_type)
8117         type = ((*bed->elf_backend_get_symbol_type)
8118                 (&type_ptr->internal_elf_sym, type));
8119
8120       if (flags & BSF_SECTION_SYM)
8121         {
8122           if (flags & BSF_GLOBAL)
8123             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8124           else
8125             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
8126         }
8127       else if (bfd_is_com_section (syms[idx]->section))
8128         {
8129           if (type != STT_TLS)
8130             {
8131               if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
8132                 type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
8133                         ? STT_COMMON : STT_OBJECT);
8134               else
8135                 type = ((flags & BSF_ELF_COMMON) != 0
8136                         ? STT_COMMON : STT_OBJECT);
8137             }
8138           sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
8139         }
8140       else if (bfd_is_und_section (syms[idx]->section))
8141         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
8142                                     ? STB_WEAK
8143                                     : STB_GLOBAL),
8144                                    type);
8145       else if (flags & BSF_FILE)
8146         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8147       else
8148         {
8149           int bind = STB_LOCAL;
8150
8151           if (flags & BSF_LOCAL)
8152             bind = STB_LOCAL;
8153           else if (flags & BSF_GNU_UNIQUE)
8154             bind = STB_GNU_UNIQUE;
8155           else if (flags & BSF_WEAK)
8156             bind = STB_WEAK;
8157           else if (flags & BSF_GLOBAL)
8158             bind = STB_GLOBAL;
8159
8160           sym.st_info = ELF_ST_INFO (bind, type);
8161         }
8162
8163       if (type_ptr != NULL)
8164         {
8165           sym.st_other = type_ptr->internal_elf_sym.st_other;
8166           sym.st_target_internal
8167             = type_ptr->internal_elf_sym.st_target_internal;
8168         }
8169       else
8170         {
8171           sym.st_other = 0;
8172           sym.st_target_internal = 0;
8173         }
8174
8175       idx++;
8176       symstrtab[idx].sym = sym;
8177       symstrtab[idx].dest_index = outbound_syms_index;
8178       symstrtab[idx].destshndx_index = outbound_shndx_index;
8179
8180       outbound_syms_index++;
8181       if (outbound_shndx != NULL)
8182         outbound_shndx_index++;
8183     }
8184
8185   /* Finalize the .strtab section.  */
8186   _bfd_elf_strtab_finalize (stt);
8187
8188   /* Swap out the .strtab section.  */
8189   for (idx = 0; idx <= symcount; idx++)
8190     {
8191       struct elf_sym_strtab *elfsym = &symstrtab[idx];
8192       if (elfsym->sym.st_name == (unsigned long) -1)
8193         elfsym->sym.st_name = 0;
8194       else
8195         elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
8196                                                       elfsym->sym.st_name);
8197       bed->s->swap_symbol_out (abfd, &elfsym->sym,
8198                                (outbound_syms
8199                                 + (elfsym->dest_index
8200                                    * bed->s->sizeof_sym)),
8201                                (outbound_shndx
8202                                 + (elfsym->destshndx_index
8203                                    * sizeof (Elf_External_Sym_Shndx))));
8204     }
8205   free (symstrtab);
8206
8207   *sttp = stt;
8208   symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
8209   symstrtab_hdr->sh_type = SHT_STRTAB;
8210   symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
8211   symstrtab_hdr->sh_addr = 0;
8212   symstrtab_hdr->sh_entsize = 0;
8213   symstrtab_hdr->sh_link = 0;
8214   symstrtab_hdr->sh_info = 0;
8215   symstrtab_hdr->sh_addralign = 1;
8216
8217   return TRUE;
8218 }
8219
8220 /* Return the number of bytes required to hold the symtab vector.
8221
8222    Note that we base it on the count plus 1, since we will null terminate
8223    the vector allocated based on this size.  However, the ELF symbol table
8224    always has a dummy entry as symbol #0, so it ends up even.  */
8225
8226 long
8227 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
8228 {
8229   bfd_size_type symcount;
8230   long symtab_size;
8231   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
8232
8233   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8234   if (symcount >= LONG_MAX / sizeof (asymbol *))
8235     {
8236       bfd_set_error (bfd_error_file_too_big);
8237       return -1;
8238     }
8239   symtab_size = (symcount + 1) * (sizeof (asymbol *));
8240   if (symcount > 0)
8241     symtab_size -= sizeof (asymbol *);
8242
8243   return symtab_size;
8244 }
8245
8246 long
8247 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
8248 {
8249   bfd_size_type symcount;
8250   long symtab_size;
8251   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
8252
8253   if (elf_dynsymtab (abfd) == 0)
8254     {
8255       bfd_set_error (bfd_error_invalid_operation);
8256       return -1;
8257     }
8258
8259   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8260   if (symcount >= LONG_MAX / sizeof (asymbol *))
8261     {
8262       bfd_set_error (bfd_error_file_too_big);
8263       return -1;
8264     }
8265   symtab_size = (symcount + 1) * (sizeof (asymbol *));
8266   if (symcount > 0)
8267     symtab_size -= sizeof (asymbol *);
8268
8269   return symtab_size;
8270 }
8271
8272 long
8273 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
8274                                 sec_ptr asect)
8275 {
8276   return (asect->reloc_count + 1) * sizeof (arelent *);
8277 }
8278
8279 /* Canonicalize the relocs.  */
8280
8281 long
8282 _bfd_elf_canonicalize_reloc (bfd *abfd,
8283                              sec_ptr section,
8284                              arelent **relptr,
8285                              asymbol **symbols)
8286 {
8287   arelent *tblptr;
8288   unsigned int i;
8289   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8290
8291   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
8292     return -1;
8293
8294   tblptr = section->relocation;
8295   for (i = 0; i < section->reloc_count; i++)
8296     *relptr++ = tblptr++;
8297
8298   *relptr = NULL;
8299
8300   return section->reloc_count;
8301 }
8302
8303 long
8304 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
8305 {
8306   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8307   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
8308
8309   if (symcount >= 0)
8310     bfd_get_symcount (abfd) = symcount;
8311   return symcount;
8312 }
8313
8314 long
8315 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8316                                       asymbol **allocation)
8317 {
8318   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8319   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
8320
8321   if (symcount >= 0)
8322     bfd_get_dynamic_symcount (abfd) = symcount;
8323   return symcount;
8324 }
8325
8326 /* Return the size required for the dynamic reloc entries.  Any loadable
8327    section that was actually installed in the BFD, and has type SHT_REL
8328    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8329    dynamic reloc section.  */
8330
8331 long
8332 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
8333 {
8334   bfd_size_type count;
8335   asection *s;
8336
8337   if (elf_dynsymtab (abfd) == 0)
8338     {
8339       bfd_set_error (bfd_error_invalid_operation);
8340       return -1;
8341     }
8342
8343   count = 1;
8344   for (s = abfd->sections; s != NULL; s = s->next)
8345     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8346         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8347             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8348       {
8349         count += s->size / elf_section_data (s)->this_hdr.sh_entsize;
8350         if (count > LONG_MAX / sizeof (arelent *))
8351           {
8352             bfd_set_error (bfd_error_file_too_big);
8353             return -1;
8354           }
8355       }
8356   return count * sizeof (arelent *);
8357 }
8358
8359 /* Canonicalize the dynamic relocation entries.  Note that we return the
8360    dynamic relocations as a single block, although they are actually
8361    associated with particular sections; the interface, which was
8362    designed for SunOS style shared libraries, expects that there is only
8363    one set of dynamic relocs.  Any loadable section that was actually
8364    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8365    dynamic symbol table, is considered to be a dynamic reloc section.  */
8366
8367 long
8368 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8369                                      arelent **storage,
8370                                      asymbol **syms)
8371 {
8372   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8373   asection *s;
8374   long ret;
8375
8376   if (elf_dynsymtab (abfd) == 0)
8377     {
8378       bfd_set_error (bfd_error_invalid_operation);
8379       return -1;
8380     }
8381
8382   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8383   ret = 0;
8384   for (s = abfd->sections; s != NULL; s = s->next)
8385     {
8386       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8387           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8388               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8389         {
8390           arelent *p;
8391           long count, i;
8392
8393           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
8394             return -1;
8395           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
8396           p = s->relocation;
8397           for (i = 0; i < count; i++)
8398             *storage++ = p++;
8399           ret += count;
8400         }
8401     }
8402
8403   *storage = NULL;
8404
8405   return ret;
8406 }
8407 \f
8408 /* Read in the version information.  */
8409
8410 bfd_boolean
8411 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
8412 {
8413   bfd_byte *contents = NULL;
8414   unsigned int freeidx = 0;
8415
8416   if (elf_dynverref (abfd) != 0)
8417     {
8418       Elf_Internal_Shdr *hdr;
8419       Elf_External_Verneed *everneed;
8420       Elf_Internal_Verneed *iverneed;
8421       unsigned int i;
8422       bfd_byte *contents_end;
8423
8424       hdr = &elf_tdata (abfd)->dynverref_hdr;
8425
8426       if (hdr->sh_info == 0
8427           || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
8428         {
8429 error_return_bad_verref:
8430           _bfd_error_handler
8431             (_("%pB: .gnu.version_r invalid entry"), abfd);
8432           bfd_set_error (bfd_error_bad_value);
8433 error_return_verref:
8434           elf_tdata (abfd)->verref = NULL;
8435           elf_tdata (abfd)->cverrefs = 0;
8436           goto error_return;
8437         }
8438
8439       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8440       if (contents == NULL)
8441         goto error_return_verref;
8442
8443       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8444           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8445         goto error_return_verref;
8446
8447       elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
8448         bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
8449
8450       if (elf_tdata (abfd)->verref == NULL)
8451         goto error_return_verref;
8452
8453       BFD_ASSERT (sizeof (Elf_External_Verneed)
8454                   == sizeof (Elf_External_Vernaux));
8455       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
8456       everneed = (Elf_External_Verneed *) contents;
8457       iverneed = elf_tdata (abfd)->verref;
8458       for (i = 0; i < hdr->sh_info; i++, iverneed++)
8459         {
8460           Elf_External_Vernaux *evernaux;
8461           Elf_Internal_Vernaux *ivernaux;
8462           unsigned int j;
8463
8464           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8465
8466           iverneed->vn_bfd = abfd;
8467
8468           iverneed->vn_filename =
8469             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8470                                              iverneed->vn_file);
8471           if (iverneed->vn_filename == NULL)
8472             goto error_return_bad_verref;
8473
8474           if (iverneed->vn_cnt == 0)
8475             iverneed->vn_auxptr = NULL;
8476           else
8477             {
8478               iverneed->vn_auxptr = (struct elf_internal_vernaux *)
8479                   bfd_alloc2 (abfd, iverneed->vn_cnt,
8480                               sizeof (Elf_Internal_Vernaux));
8481               if (iverneed->vn_auxptr == NULL)
8482                 goto error_return_verref;
8483             }
8484
8485           if (iverneed->vn_aux
8486               > (size_t) (contents_end - (bfd_byte *) everneed))
8487             goto error_return_bad_verref;
8488
8489           evernaux = ((Elf_External_Vernaux *)
8490                       ((bfd_byte *) everneed + iverneed->vn_aux));
8491           ivernaux = iverneed->vn_auxptr;
8492           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8493             {
8494               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8495
8496               ivernaux->vna_nodename =
8497                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8498                                                  ivernaux->vna_name);
8499               if (ivernaux->vna_nodename == NULL)
8500                 goto error_return_bad_verref;
8501
8502               if (ivernaux->vna_other > freeidx)
8503                 freeidx = ivernaux->vna_other;
8504
8505               ivernaux->vna_nextptr = NULL;
8506               if (ivernaux->vna_next == 0)
8507                 {
8508                   iverneed->vn_cnt = j + 1;
8509                   break;
8510                 }
8511               if (j + 1 < iverneed->vn_cnt)
8512                 ivernaux->vna_nextptr = ivernaux + 1;
8513
8514               if (ivernaux->vna_next
8515                   > (size_t) (contents_end - (bfd_byte *) evernaux))
8516                 goto error_return_bad_verref;
8517
8518               evernaux = ((Elf_External_Vernaux *)
8519                           ((bfd_byte *) evernaux + ivernaux->vna_next));
8520             }
8521
8522           iverneed->vn_nextref = NULL;
8523           if (iverneed->vn_next == 0)
8524             break;
8525           if (i + 1 < hdr->sh_info)
8526             iverneed->vn_nextref = iverneed + 1;
8527
8528           if (iverneed->vn_next
8529               > (size_t) (contents_end - (bfd_byte *) everneed))
8530             goto error_return_bad_verref;
8531
8532           everneed = ((Elf_External_Verneed *)
8533                       ((bfd_byte *) everneed + iverneed->vn_next));
8534         }
8535       elf_tdata (abfd)->cverrefs = i;
8536
8537       free (contents);
8538       contents = NULL;
8539     }
8540
8541   if (elf_dynverdef (abfd) != 0)
8542     {
8543       Elf_Internal_Shdr *hdr;
8544       Elf_External_Verdef *everdef;
8545       Elf_Internal_Verdef *iverdef;
8546       Elf_Internal_Verdef *iverdefarr;
8547       Elf_Internal_Verdef iverdefmem;
8548       unsigned int i;
8549       unsigned int maxidx;
8550       bfd_byte *contents_end_def, *contents_end_aux;
8551
8552       hdr = &elf_tdata (abfd)->dynverdef_hdr;
8553
8554       if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8555         {
8556         error_return_bad_verdef:
8557           _bfd_error_handler
8558             (_("%pB: .gnu.version_d invalid entry"), abfd);
8559           bfd_set_error (bfd_error_bad_value);
8560         error_return_verdef:
8561           elf_tdata (abfd)->verdef = NULL;
8562           elf_tdata (abfd)->cverdefs = 0;
8563           goto error_return;
8564         }
8565
8566       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8567       if (contents == NULL)
8568         goto error_return_verdef;
8569       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8570           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8571         goto error_return_verdef;
8572
8573       BFD_ASSERT (sizeof (Elf_External_Verdef)
8574                   >= sizeof (Elf_External_Verdaux));
8575       contents_end_def = contents + hdr->sh_size
8576                          - sizeof (Elf_External_Verdef);
8577       contents_end_aux = contents + hdr->sh_size
8578                          - sizeof (Elf_External_Verdaux);
8579
8580       /* We know the number of entries in the section but not the maximum
8581          index.  Therefore we have to run through all entries and find
8582          the maximum.  */
8583       everdef = (Elf_External_Verdef *) contents;
8584       maxidx = 0;
8585       for (i = 0; i < hdr->sh_info; ++i)
8586         {
8587           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8588
8589           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8590             goto error_return_bad_verdef;
8591           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8592             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
8593
8594           if (iverdefmem.vd_next == 0)
8595             break;
8596
8597           if (iverdefmem.vd_next
8598               > (size_t) (contents_end_def - (bfd_byte *) everdef))
8599             goto error_return_bad_verdef;
8600
8601           everdef = ((Elf_External_Verdef *)
8602                      ((bfd_byte *) everdef + iverdefmem.vd_next));
8603         }
8604
8605       if (default_imported_symver)
8606         {
8607           if (freeidx > maxidx)
8608             maxidx = ++freeidx;
8609           else
8610             freeidx = ++maxidx;
8611         }
8612
8613       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8614         bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
8615       if (elf_tdata (abfd)->verdef == NULL)
8616         goto error_return_verdef;
8617
8618       elf_tdata (abfd)->cverdefs = maxidx;
8619
8620       everdef = (Elf_External_Verdef *) contents;
8621       iverdefarr = elf_tdata (abfd)->verdef;
8622       for (i = 0; i < hdr->sh_info; i++)
8623         {
8624           Elf_External_Verdaux *everdaux;
8625           Elf_Internal_Verdaux *iverdaux;
8626           unsigned int j;
8627
8628           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8629
8630           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
8631             goto error_return_bad_verdef;
8632
8633           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
8634           memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
8635
8636           iverdef->vd_bfd = abfd;
8637
8638           if (iverdef->vd_cnt == 0)
8639             iverdef->vd_auxptr = NULL;
8640           else
8641             {
8642               iverdef->vd_auxptr = (struct elf_internal_verdaux *)
8643                   bfd_alloc2 (abfd, iverdef->vd_cnt,
8644                               sizeof (Elf_Internal_Verdaux));
8645               if (iverdef->vd_auxptr == NULL)
8646                 goto error_return_verdef;
8647             }
8648
8649           if (iverdef->vd_aux
8650               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
8651             goto error_return_bad_verdef;
8652
8653           everdaux = ((Elf_External_Verdaux *)
8654                       ((bfd_byte *) everdef + iverdef->vd_aux));
8655           iverdaux = iverdef->vd_auxptr;
8656           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8657             {
8658               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8659
8660               iverdaux->vda_nodename =
8661                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8662                                                  iverdaux->vda_name);
8663               if (iverdaux->vda_nodename == NULL)
8664                 goto error_return_bad_verdef;
8665
8666               iverdaux->vda_nextptr = NULL;
8667               if (iverdaux->vda_next == 0)
8668                 {
8669                   iverdef->vd_cnt = j + 1;
8670                   break;
8671                 }
8672               if (j + 1 < iverdef->vd_cnt)
8673                 iverdaux->vda_nextptr = iverdaux + 1;
8674
8675               if (iverdaux->vda_next
8676                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
8677                 goto error_return_bad_verdef;
8678
8679               everdaux = ((Elf_External_Verdaux *)
8680                           ((bfd_byte *) everdaux + iverdaux->vda_next));
8681             }
8682
8683           iverdef->vd_nodename = NULL;
8684           if (iverdef->vd_cnt)
8685             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
8686
8687           iverdef->vd_nextdef = NULL;
8688           if (iverdef->vd_next == 0)
8689             break;
8690           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
8691             iverdef->vd_nextdef = iverdef + 1;
8692
8693           everdef = ((Elf_External_Verdef *)
8694                      ((bfd_byte *) everdef + iverdef->vd_next));
8695         }
8696
8697       free (contents);
8698       contents = NULL;
8699     }
8700   else if (default_imported_symver)
8701     {
8702       if (freeidx < 3)
8703         freeidx = 3;
8704       else
8705         freeidx++;
8706
8707       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8708           bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
8709       if (elf_tdata (abfd)->verdef == NULL)
8710         goto error_return;
8711
8712       elf_tdata (abfd)->cverdefs = freeidx;
8713     }
8714
8715   /* Create a default version based on the soname.  */
8716   if (default_imported_symver)
8717     {
8718       Elf_Internal_Verdef *iverdef;
8719       Elf_Internal_Verdaux *iverdaux;
8720
8721       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
8722
8723       iverdef->vd_version = VER_DEF_CURRENT;
8724       iverdef->vd_flags = 0;
8725       iverdef->vd_ndx = freeidx;
8726       iverdef->vd_cnt = 1;
8727
8728       iverdef->vd_bfd = abfd;
8729
8730       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8731       if (iverdef->vd_nodename == NULL)
8732         goto error_return_verdef;
8733       iverdef->vd_nextdef = NULL;
8734       iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8735                             bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
8736       if (iverdef->vd_auxptr == NULL)
8737         goto error_return_verdef;
8738
8739       iverdaux = iverdef->vd_auxptr;
8740       iverdaux->vda_nodename = iverdef->vd_nodename;
8741     }
8742
8743   return TRUE;
8744
8745  error_return:
8746   if (contents != NULL)
8747     free (contents);
8748   return FALSE;
8749 }
8750 \f
8751 asymbol *
8752 _bfd_elf_make_empty_symbol (bfd *abfd)
8753 {
8754   elf_symbol_type *newsym;
8755
8756   newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof * newsym);
8757   if (!newsym)
8758     return NULL;
8759   newsym->symbol.the_bfd = abfd;
8760   return &newsym->symbol;
8761 }
8762
8763 void
8764 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8765                           asymbol *symbol,
8766                           symbol_info *ret)
8767 {
8768   bfd_symbol_info (symbol, ret);
8769 }
8770
8771 /* Return whether a symbol name implies a local symbol.  Most targets
8772    use this function for the is_local_label_name entry point, but some
8773    override it.  */
8774
8775 bfd_boolean
8776 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8777                               const char *name)
8778 {
8779   /* Normal local symbols start with ``.L''.  */
8780   if (name[0] == '.' && name[1] == 'L')
8781     return TRUE;
8782
8783   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8784      DWARF debugging symbols starting with ``..''.  */
8785   if (name[0] == '.' && name[1] == '.')
8786     return TRUE;
8787
8788   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8789      emitting DWARF debugging output.  I suspect this is actually a
8790      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8791      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8792      underscore to be emitted on some ELF targets).  For ease of use,
8793      we treat such symbols as local.  */
8794   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
8795     return TRUE;
8796
8797   /* Treat assembler generated fake symbols, dollar local labels and
8798      forward-backward labels (aka local labels) as locals.
8799      These labels have the form:
8800
8801        L0^A.*                                  (fake symbols)
8802
8803        [.]?L[0123456789]+{^A|^B}[0123456789]*  (local labels)
8804
8805      Versions which start with .L will have already been matched above,
8806      so we only need to match the rest.  */
8807   if (name[0] == 'L' && ISDIGIT (name[1]))
8808     {
8809       bfd_boolean ret = FALSE;
8810       const char * p;
8811       char c;
8812
8813       for (p = name + 2; (c = *p); p++)
8814         {
8815           if (c == 1 || c == 2)
8816             {
8817               if (c == 1 && p == name + 2)
8818                 /* A fake symbol.  */
8819                 return TRUE;
8820
8821               /* FIXME: We are being paranoid here and treating symbols like
8822                  L0^Bfoo as if there were non-local, on the grounds that the
8823                  assembler will never generate them.  But can any symbol
8824                  containing an ASCII value in the range 1-31 ever be anything
8825                  other than some kind of local ?  */
8826               ret = TRUE;
8827             }
8828
8829           if (! ISDIGIT (c))
8830             {
8831               ret = FALSE;
8832               break;
8833             }
8834         }
8835       return ret;
8836     }
8837
8838   return FALSE;
8839 }
8840
8841 alent *
8842 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8843                      asymbol *symbol ATTRIBUTE_UNUSED)
8844 {
8845   abort ();
8846   return NULL;
8847 }
8848
8849 bfd_boolean
8850 _bfd_elf_set_arch_mach (bfd *abfd,
8851                         enum bfd_architecture arch,
8852                         unsigned long machine)
8853 {
8854   /* If this isn't the right architecture for this backend, and this
8855      isn't the generic backend, fail.  */
8856   if (arch != get_elf_backend_data (abfd)->arch
8857       && arch != bfd_arch_unknown
8858       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
8859     return FALSE;
8860
8861   return bfd_default_set_arch_mach (abfd, arch, machine);
8862 }
8863
8864 /* Find the nearest line to a particular section and offset,
8865    for error reporting.  */
8866
8867 bfd_boolean
8868 _bfd_elf_find_nearest_line (bfd *abfd,
8869                             asymbol **symbols,
8870                             asection *section,
8871                             bfd_vma offset,
8872                             const char **filename_ptr,
8873                             const char **functionname_ptr,
8874                             unsigned int *line_ptr,
8875                             unsigned int *discriminator_ptr)
8876 {
8877   bfd_boolean found;
8878
8879   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
8880                                      filename_ptr, functionname_ptr,
8881                                      line_ptr, discriminator_ptr,
8882                                      dwarf_debug_sections, 0,
8883                                      &elf_tdata (abfd)->dwarf2_find_line_info)
8884       || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8885                                         filename_ptr, functionname_ptr,
8886                                         line_ptr))
8887     {
8888       if (!*functionname_ptr)
8889         _bfd_elf_find_function (abfd, symbols, section, offset,
8890                                 *filename_ptr ? NULL : filename_ptr,
8891                                 functionname_ptr);
8892       return TRUE;
8893     }
8894
8895   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
8896                                              &found, filename_ptr,
8897                                              functionname_ptr, line_ptr,
8898                                              &elf_tdata (abfd)->line_info))
8899     return FALSE;
8900   if (found && (*functionname_ptr || *line_ptr))
8901     return TRUE;
8902
8903   if (symbols == NULL)
8904     return FALSE;
8905
8906   if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8907                                 filename_ptr, functionname_ptr))
8908     return FALSE;
8909
8910   *line_ptr = 0;
8911   return TRUE;
8912 }
8913
8914 /* Find the line for a symbol.  */
8915
8916 bfd_boolean
8917 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8918                     const char **filename_ptr, unsigned int *line_ptr)
8919 {
8920   return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8921                                         filename_ptr, NULL, line_ptr, NULL,
8922                                         dwarf_debug_sections, 0,
8923                                         &elf_tdata (abfd)->dwarf2_find_line_info);
8924 }
8925
8926 /* After a call to bfd_find_nearest_line, successive calls to
8927    bfd_find_inliner_info can be used to get source information about
8928    each level of function inlining that terminated at the address
8929    passed to bfd_find_nearest_line.  Currently this is only supported
8930    for DWARF2 with appropriate DWARF3 extensions. */
8931
8932 bfd_boolean
8933 _bfd_elf_find_inliner_info (bfd *abfd,
8934                             const char **filename_ptr,
8935                             const char **functionname_ptr,
8936                             unsigned int *line_ptr)
8937 {
8938   bfd_boolean found;
8939   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8940                                          functionname_ptr, line_ptr,
8941                                          & elf_tdata (abfd)->dwarf2_find_line_info);
8942   return found;
8943 }
8944
8945 int
8946 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
8947 {
8948   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8949   int ret = bed->s->sizeof_ehdr;
8950
8951   if (!bfd_link_relocatable (info))
8952     {
8953       bfd_size_type phdr_size = elf_program_header_size (abfd);
8954
8955       if (phdr_size == (bfd_size_type) -1)
8956         {
8957           struct elf_segment_map *m;
8958
8959           phdr_size = 0;
8960           for (m = elf_seg_map (abfd); m != NULL; m = m->next)
8961             phdr_size += bed->s->sizeof_phdr;
8962
8963           if (phdr_size == 0)
8964             phdr_size = get_program_header_size (abfd, info);
8965         }
8966
8967       elf_program_header_size (abfd) = phdr_size;
8968       ret += phdr_size;
8969     }
8970
8971   return ret;
8972 }
8973
8974 bfd_boolean
8975 _bfd_elf_set_section_contents (bfd *abfd,
8976                                sec_ptr section,
8977                                const void *location,
8978                                file_ptr offset,
8979                                bfd_size_type count)
8980 {
8981   Elf_Internal_Shdr *hdr;
8982   file_ptr pos;
8983
8984   if (! abfd->output_has_begun
8985       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
8986     return FALSE;
8987
8988   if (!count)
8989     return TRUE;
8990
8991   hdr = &elf_section_data (section)->this_hdr;
8992   if (hdr->sh_offset == (file_ptr) -1)
8993     {
8994       /* We must compress this section.  Write output to the buffer.  */
8995       unsigned char *contents = hdr->contents;
8996       if ((offset + count) > hdr->sh_size
8997           || (section->flags & SEC_ELF_COMPRESS) == 0
8998           || contents == NULL)
8999         abort ();
9000       memcpy (contents + offset, location, count);
9001       return TRUE;
9002     }
9003   pos = hdr->sh_offset + offset;
9004   if (bfd_seek (abfd, pos, SEEK_SET) != 0
9005       || bfd_bwrite (location, count, abfd) != count)
9006     return FALSE;
9007
9008   return TRUE;
9009 }
9010
9011 bfd_boolean
9012 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
9013                            arelent *cache_ptr ATTRIBUTE_UNUSED,
9014                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
9015 {
9016   abort ();
9017   return FALSE;
9018 }
9019
9020 /* Try to convert a non-ELF reloc into an ELF one.  */
9021
9022 bfd_boolean
9023 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
9024 {
9025   /* Check whether we really have an ELF howto.  */
9026
9027   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
9028     {
9029       bfd_reloc_code_real_type code;
9030       reloc_howto_type *howto;
9031
9032       /* Alien reloc: Try to determine its type to replace it with an
9033          equivalent ELF reloc.  */
9034
9035       if (areloc->howto->pc_relative)
9036         {
9037           switch (areloc->howto->bitsize)
9038             {
9039             case 8:
9040               code = BFD_RELOC_8_PCREL;
9041               break;
9042             case 12:
9043               code = BFD_RELOC_12_PCREL;
9044               break;
9045             case 16:
9046               code = BFD_RELOC_16_PCREL;
9047               break;
9048             case 24:
9049               code = BFD_RELOC_24_PCREL;
9050               break;
9051             case 32:
9052               code = BFD_RELOC_32_PCREL;
9053               break;
9054             case 64:
9055               code = BFD_RELOC_64_PCREL;
9056               break;
9057             default:
9058               goto fail;
9059             }
9060
9061           howto = bfd_reloc_type_lookup (abfd, code);
9062
9063           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
9064             {
9065               if (howto->pcrel_offset)
9066                 areloc->addend += areloc->address;
9067               else
9068                 areloc->addend -= areloc->address; /* addend is unsigned!! */
9069             }
9070         }
9071       else
9072         {
9073           switch (areloc->howto->bitsize)
9074             {
9075             case 8:
9076               code = BFD_RELOC_8;
9077               break;
9078             case 14:
9079               code = BFD_RELOC_14;
9080               break;
9081             case 16:
9082               code = BFD_RELOC_16;
9083               break;
9084             case 26:
9085               code = BFD_RELOC_26;
9086               break;
9087             case 32:
9088               code = BFD_RELOC_32;
9089               break;
9090             case 64:
9091               code = BFD_RELOC_64;
9092               break;
9093             default:
9094               goto fail;
9095             }
9096
9097           howto = bfd_reloc_type_lookup (abfd, code);
9098         }
9099
9100       if (howto)
9101         areloc->howto = howto;
9102       else
9103         goto fail;
9104     }
9105
9106   return TRUE;
9107
9108  fail:
9109   /* xgettext:c-format */
9110   _bfd_error_handler (_("%pB: %s unsupported"),
9111                       abfd, areloc->howto->name);
9112   bfd_set_error (bfd_error_bad_value);
9113   return FALSE;
9114 }
9115
9116 bfd_boolean
9117 _bfd_elf_close_and_cleanup (bfd *abfd)
9118 {
9119   struct elf_obj_tdata *tdata = elf_tdata (abfd);
9120   if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
9121     {
9122       if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
9123         _bfd_elf_strtab_free (elf_shstrtab (abfd));
9124       _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
9125     }
9126
9127   return _bfd_generic_close_and_cleanup (abfd);
9128 }
9129
9130 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9131    in the relocation's offset.  Thus we cannot allow any sort of sanity
9132    range-checking to interfere.  There is nothing else to do in processing
9133    this reloc.  */
9134
9135 bfd_reloc_status_type
9136 _bfd_elf_rel_vtable_reloc_fn
9137   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
9138    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
9139    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
9140    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
9141 {
9142   return bfd_reloc_ok;
9143 }
9144 \f
9145 /* Elf core file support.  Much of this only works on native
9146    toolchains, since we rely on knowing the
9147    machine-dependent procfs structure in order to pick
9148    out details about the corefile.  */
9149
9150 #ifdef HAVE_SYS_PROCFS_H
9151 /* Needed for new procfs interface on sparc-solaris.  */
9152 # define _STRUCTURED_PROC 1
9153 # include <sys/procfs.h>
9154 #endif
9155
9156 /* Return a PID that identifies a "thread" for threaded cores, or the
9157    PID of the main process for non-threaded cores.  */
9158
9159 static int
9160 elfcore_make_pid (bfd *abfd)
9161 {
9162   int pid;
9163
9164   pid = elf_tdata (abfd)->core->lwpid;
9165   if (pid == 0)
9166     pid = elf_tdata (abfd)->core->pid;
9167
9168   return pid;
9169 }
9170
9171 /* If there isn't a section called NAME, make one, using
9172    data from SECT.  Note, this function will generate a
9173    reference to NAME, so you shouldn't deallocate or
9174    overwrite it.  */
9175
9176 static bfd_boolean
9177 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
9178 {
9179   asection *sect2;
9180
9181   if (bfd_get_section_by_name (abfd, name) != NULL)
9182     return TRUE;
9183
9184   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
9185   if (sect2 == NULL)
9186     return FALSE;
9187
9188   sect2->size = sect->size;
9189   sect2->filepos = sect->filepos;
9190   sect2->alignment_power = sect->alignment_power;
9191   return TRUE;
9192 }
9193
9194 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
9195    actually creates up to two pseudosections:
9196    - For the single-threaded case, a section named NAME, unless
9197      such a section already exists.
9198    - For the multi-threaded case, a section named "NAME/PID", where
9199      PID is elfcore_make_pid (abfd).
9200    Both pseudosections have identical contents.  */
9201 bfd_boolean
9202 _bfd_elfcore_make_pseudosection (bfd *abfd,
9203                                  char *name,
9204                                  size_t size,
9205                                  ufile_ptr filepos)
9206 {
9207   char buf[100];
9208   char *threaded_name;
9209   size_t len;
9210   asection *sect;
9211
9212   /* Build the section name.  */
9213
9214   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
9215   len = strlen (buf) + 1;
9216   threaded_name = (char *) bfd_alloc (abfd, len);
9217   if (threaded_name == NULL)
9218     return FALSE;
9219   memcpy (threaded_name, buf, len);
9220
9221   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9222                                              SEC_HAS_CONTENTS);
9223   if (sect == NULL)
9224     return FALSE;
9225   sect->size = size;
9226   sect->filepos = filepos;
9227   sect->alignment_power = 2;
9228
9229   return elfcore_maybe_make_sect (abfd, name, sect);
9230 }
9231
9232 /* prstatus_t exists on:
9233      solaris 2.5+
9234      linux 2.[01] + glibc
9235      unixware 4.2
9236 */
9237
9238 #if defined (HAVE_PRSTATUS_T)
9239
9240 static bfd_boolean
9241 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
9242 {
9243   size_t size;
9244   int offset;
9245
9246   if (note->descsz == sizeof (prstatus_t))
9247     {
9248       prstatus_t prstat;
9249
9250       size = sizeof (prstat.pr_reg);
9251       offset   = offsetof (prstatus_t, pr_reg);
9252       memcpy (&prstat, note->descdata, sizeof (prstat));
9253
9254       /* Do not overwrite the core signal if it
9255          has already been set by another thread.  */
9256       if (elf_tdata (abfd)->core->signal == 0)
9257         elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9258       if (elf_tdata (abfd)->core->pid == 0)
9259         elf_tdata (abfd)->core->pid = prstat.pr_pid;
9260
9261       /* pr_who exists on:
9262          solaris 2.5+
9263          unixware 4.2
9264          pr_who doesn't exist on:
9265          linux 2.[01]
9266          */
9267 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9268       elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9269 #else
9270       elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9271 #endif
9272     }
9273 #if defined (HAVE_PRSTATUS32_T)
9274   else if (note->descsz == sizeof (prstatus32_t))
9275     {
9276       /* 64-bit host, 32-bit corefile */
9277       prstatus32_t prstat;
9278
9279       size = sizeof (prstat.pr_reg);
9280       offset   = offsetof (prstatus32_t, pr_reg);
9281       memcpy (&prstat, note->descdata, sizeof (prstat));
9282
9283       /* Do not overwrite the core signal if it
9284          has already been set by another thread.  */
9285       if (elf_tdata (abfd)->core->signal == 0)
9286         elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9287       if (elf_tdata (abfd)->core->pid == 0)
9288         elf_tdata (abfd)->core->pid = prstat.pr_pid;
9289
9290       /* pr_who exists on:
9291          solaris 2.5+
9292          unixware 4.2
9293          pr_who doesn't exist on:
9294          linux 2.[01]
9295          */
9296 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9297       elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9298 #else
9299       elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9300 #endif
9301     }
9302 #endif /* HAVE_PRSTATUS32_T */
9303   else
9304     {
9305       /* Fail - we don't know how to handle any other
9306          note size (ie. data object type).  */
9307       return TRUE;
9308     }
9309
9310   /* Make a ".reg/999" section and a ".reg" section.  */
9311   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9312                                           size, note->descpos + offset);
9313 }
9314 #endif /* defined (HAVE_PRSTATUS_T) */
9315
9316 /* Create a pseudosection containing the exact contents of NOTE.  */
9317 static bfd_boolean
9318 elfcore_make_note_pseudosection (bfd *abfd,
9319                                  char *name,
9320                                  Elf_Internal_Note *note)
9321 {
9322   return _bfd_elfcore_make_pseudosection (abfd, name,
9323                                           note->descsz, note->descpos);
9324 }
9325
9326 /* There isn't a consistent prfpregset_t across platforms,
9327    but it doesn't matter, because we don't have to pick this
9328    data structure apart.  */
9329
9330 static bfd_boolean
9331 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
9332 {
9333   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9334 }
9335
9336 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9337    type of NT_PRXFPREG.  Just include the whole note's contents
9338    literally.  */
9339
9340 static bfd_boolean
9341 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
9342 {
9343   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9344 }
9345
9346 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9347    with a note type of NT_X86_XSTATE.  Just include the whole note's
9348    contents literally.  */
9349
9350 static bfd_boolean
9351 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9352 {
9353   return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9354 }
9355
9356 static bfd_boolean
9357 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9358 {
9359   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9360 }
9361
9362 static bfd_boolean
9363 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9364 {
9365   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9366 }
9367
9368 static bfd_boolean
9369 elfcore_grok_ppc_tar (bfd *abfd, Elf_Internal_Note *note)
9370 {
9371   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tar", note);
9372 }
9373
9374 static bfd_boolean
9375 elfcore_grok_ppc_ppr (bfd *abfd, Elf_Internal_Note *note)
9376 {
9377   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ppr", note);
9378 }
9379
9380 static bfd_boolean
9381 elfcore_grok_ppc_dscr (bfd *abfd, Elf_Internal_Note *note)
9382 {
9383   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-dscr", note);
9384 }
9385
9386 static bfd_boolean
9387 elfcore_grok_ppc_ebb (bfd *abfd, Elf_Internal_Note *note)
9388 {
9389   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ebb", note);
9390 }
9391
9392 static bfd_boolean
9393 elfcore_grok_ppc_pmu (bfd *abfd, Elf_Internal_Note *note)
9394 {
9395   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-pmu", note);
9396 }
9397
9398 static bfd_boolean
9399 elfcore_grok_ppc_tm_cgpr (bfd *abfd, Elf_Internal_Note *note)
9400 {
9401   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cgpr", note);
9402 }
9403
9404 static bfd_boolean
9405 elfcore_grok_ppc_tm_cfpr (bfd *abfd, Elf_Internal_Note *note)
9406 {
9407   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cfpr", note);
9408 }
9409
9410 static bfd_boolean
9411 elfcore_grok_ppc_tm_cvmx (bfd *abfd, Elf_Internal_Note *note)
9412 {
9413   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvmx", note);
9414 }
9415
9416 static bfd_boolean
9417 elfcore_grok_ppc_tm_cvsx (bfd *abfd, Elf_Internal_Note *note)
9418 {
9419   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvsx", note);
9420 }
9421
9422 static bfd_boolean
9423 elfcore_grok_ppc_tm_spr (bfd *abfd, Elf_Internal_Note *note)
9424 {
9425   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-spr", note);
9426 }
9427
9428 static bfd_boolean
9429 elfcore_grok_ppc_tm_ctar (bfd *abfd, Elf_Internal_Note *note)
9430 {
9431   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-ctar", note);
9432 }
9433
9434 static bfd_boolean
9435 elfcore_grok_ppc_tm_cppr (bfd *abfd, Elf_Internal_Note *note)
9436 {
9437   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cppr", note);
9438 }
9439
9440 static bfd_boolean
9441 elfcore_grok_ppc_tm_cdscr (bfd *abfd, Elf_Internal_Note *note)
9442 {
9443   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cdscr", note);
9444 }
9445
9446 static bfd_boolean
9447 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9448 {
9449   return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9450 }
9451
9452 static bfd_boolean
9453 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9454 {
9455   return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9456 }
9457
9458 static bfd_boolean
9459 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9460 {
9461   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9462 }
9463
9464 static bfd_boolean
9465 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9466 {
9467   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9468 }
9469
9470 static bfd_boolean
9471 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9472 {
9473   return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9474 }
9475
9476 static bfd_boolean
9477 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9478 {
9479   return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9480 }
9481
9482 static bfd_boolean
9483 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9484 {
9485   return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9486 }
9487
9488 static bfd_boolean
9489 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9490 {
9491   return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9492 }
9493
9494 static bfd_boolean
9495 elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9496 {
9497   return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9498 }
9499
9500 static bfd_boolean
9501 elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9502 {
9503   return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9504 }
9505
9506 static bfd_boolean
9507 elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9508 {
9509   return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9510 }
9511
9512 static bfd_boolean
9513 elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9514 {
9515   return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9516 }
9517
9518 static bfd_boolean
9519 elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9520 {
9521   return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9522 }
9523
9524 static bfd_boolean
9525 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9526 {
9527   return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9528 }
9529
9530 static bfd_boolean
9531 elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9532 {
9533   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9534 }
9535
9536 static bfd_boolean
9537 elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9538 {
9539   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9540 }
9541
9542 static bfd_boolean
9543 elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9544 {
9545   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9546 }
9547
9548 static bfd_boolean
9549 elfcore_grok_aarch_sve (bfd *abfd, Elf_Internal_Note *note)
9550 {
9551   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-sve", note);
9552 }
9553
9554 static bfd_boolean
9555 elfcore_grok_aarch_pauth (bfd *abfd, Elf_Internal_Note *note)
9556 {
9557   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-pauth", note);
9558 }
9559
9560 #if defined (HAVE_PRPSINFO_T)
9561 typedef prpsinfo_t   elfcore_psinfo_t;
9562 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
9563 typedef prpsinfo32_t elfcore_psinfo32_t;
9564 #endif
9565 #endif
9566
9567 #if defined (HAVE_PSINFO_T)
9568 typedef psinfo_t   elfcore_psinfo_t;
9569 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
9570 typedef psinfo32_t elfcore_psinfo32_t;
9571 #endif
9572 #endif
9573
9574 /* return a malloc'ed copy of a string at START which is at
9575    most MAX bytes long, possibly without a terminating '\0'.
9576    the copy will always have a terminating '\0'.  */
9577
9578 char *
9579 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
9580 {
9581   char *dups;
9582   char *end = (char *) memchr (start, '\0', max);
9583   size_t len;
9584
9585   if (end == NULL)
9586     len = max;
9587   else
9588     len = end - start;
9589
9590   dups = (char *) bfd_alloc (abfd, len + 1);
9591   if (dups == NULL)
9592     return NULL;
9593
9594   memcpy (dups, start, len);
9595   dups[len] = '\0';
9596
9597   return dups;
9598 }
9599
9600 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9601 static bfd_boolean
9602 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
9603 {
9604   if (note->descsz == sizeof (elfcore_psinfo_t))
9605     {
9606       elfcore_psinfo_t psinfo;
9607
9608       memcpy (&psinfo, note->descdata, sizeof (psinfo));
9609
9610 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9611       elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9612 #endif
9613       elf_tdata (abfd)->core->program
9614         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9615                                 sizeof (psinfo.pr_fname));
9616
9617       elf_tdata (abfd)->core->command
9618         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9619                                 sizeof (psinfo.pr_psargs));
9620     }
9621 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9622   else if (note->descsz == sizeof (elfcore_psinfo32_t))
9623     {
9624       /* 64-bit host, 32-bit corefile */
9625       elfcore_psinfo32_t psinfo;
9626
9627       memcpy (&psinfo, note->descdata, sizeof (psinfo));
9628
9629 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9630       elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9631 #endif
9632       elf_tdata (abfd)->core->program
9633         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9634                                 sizeof (psinfo.pr_fname));
9635
9636       elf_tdata (abfd)->core->command
9637         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9638                                 sizeof (psinfo.pr_psargs));
9639     }
9640 #endif
9641
9642   else
9643     {
9644       /* Fail - we don't know how to handle any other
9645          note size (ie. data object type).  */
9646       return TRUE;
9647     }
9648
9649   /* Note that for some reason, a spurious space is tacked
9650      onto the end of the args in some (at least one anyway)
9651      implementations, so strip it off if it exists.  */
9652
9653   {
9654     char *command = elf_tdata (abfd)->core->command;
9655     int n = strlen (command);
9656
9657     if (0 < n && command[n - 1] == ' ')
9658       command[n - 1] = '\0';
9659   }
9660
9661   return TRUE;
9662 }
9663 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9664
9665 #if defined (HAVE_PSTATUS_T)
9666 static bfd_boolean
9667 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
9668 {
9669   if (note->descsz == sizeof (pstatus_t)
9670 #if defined (HAVE_PXSTATUS_T)
9671       || note->descsz == sizeof (pxstatus_t)
9672 #endif
9673       )
9674     {
9675       pstatus_t pstat;
9676
9677       memcpy (&pstat, note->descdata, sizeof (pstat));
9678
9679       elf_tdata (abfd)->core->pid = pstat.pr_pid;
9680     }
9681 #if defined (HAVE_PSTATUS32_T)
9682   else if (note->descsz == sizeof (pstatus32_t))
9683     {
9684       /* 64-bit host, 32-bit corefile */
9685       pstatus32_t pstat;
9686
9687       memcpy (&pstat, note->descdata, sizeof (pstat));
9688
9689       elf_tdata (abfd)->core->pid = pstat.pr_pid;
9690     }
9691 #endif
9692   /* Could grab some more details from the "representative"
9693      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9694      NT_LWPSTATUS note, presumably.  */
9695
9696   return TRUE;
9697 }
9698 #endif /* defined (HAVE_PSTATUS_T) */
9699
9700 #if defined (HAVE_LWPSTATUS_T)
9701 static bfd_boolean
9702 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
9703 {
9704   lwpstatus_t lwpstat;
9705   char buf[100];
9706   char *name;
9707   size_t len;
9708   asection *sect;
9709
9710   if (note->descsz != sizeof (lwpstat)
9711 #if defined (HAVE_LWPXSTATUS_T)
9712       && note->descsz != sizeof (lwpxstatus_t)
9713 #endif
9714       )
9715     return TRUE;
9716
9717   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9718
9719   elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
9720   /* Do not overwrite the core signal if it has already been set by
9721      another thread.  */
9722   if (elf_tdata (abfd)->core->signal == 0)
9723     elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
9724
9725   /* Make a ".reg/999" section.  */
9726
9727   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
9728   len = strlen (buf) + 1;
9729   name = bfd_alloc (abfd, len);
9730   if (name == NULL)
9731     return FALSE;
9732   memcpy (name, buf, len);
9733
9734   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9735   if (sect == NULL)
9736     return FALSE;
9737
9738 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9739   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
9740   sect->filepos = note->descpos
9741     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9742 #endif
9743
9744 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9745   sect->size = sizeof (lwpstat.pr_reg);
9746   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9747 #endif
9748
9749   sect->alignment_power = 2;
9750
9751   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
9752     return FALSE;
9753
9754   /* Make a ".reg2/999" section */
9755
9756   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
9757   len = strlen (buf) + 1;
9758   name = bfd_alloc (abfd, len);
9759   if (name == NULL)
9760     return FALSE;
9761   memcpy (name, buf, len);
9762
9763   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9764   if (sect == NULL)
9765     return FALSE;
9766
9767 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9768   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
9769   sect->filepos = note->descpos
9770     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9771 #endif
9772
9773 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9774   sect->size = sizeof (lwpstat.pr_fpreg);
9775   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9776 #endif
9777
9778   sect->alignment_power = 2;
9779
9780   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
9781 }
9782 #endif /* defined (HAVE_LWPSTATUS_T) */
9783
9784 static bfd_boolean
9785 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
9786 {
9787   char buf[30];
9788   char *name;
9789   size_t len;
9790   asection *sect;
9791   int type;
9792   int is_active_thread;
9793   bfd_vma base_addr;
9794
9795   if (note->descsz < 728)
9796     return TRUE;
9797
9798   if (! CONST_STRNEQ (note->namedata, "win32"))
9799     return TRUE;
9800
9801   type = bfd_get_32 (abfd, note->descdata);
9802
9803   switch (type)
9804     {
9805     case 1 /* NOTE_INFO_PROCESS */:
9806       /* FIXME: need to add ->core->command.  */
9807       /* process_info.pid */
9808       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
9809       /* process_info.signal */
9810       elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
9811       break;
9812
9813     case 2 /* NOTE_INFO_THREAD */:
9814       /* Make a ".reg/999" section.  */
9815       /* thread_info.tid */
9816       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
9817
9818       len = strlen (buf) + 1;
9819       name = (char *) bfd_alloc (abfd, len);
9820       if (name == NULL)
9821         return FALSE;
9822
9823       memcpy (name, buf, len);
9824
9825       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9826       if (sect == NULL)
9827         return FALSE;
9828
9829       /* sizeof (thread_info.thread_context) */
9830       sect->size = 716;
9831       /* offsetof (thread_info.thread_context) */
9832       sect->filepos = note->descpos + 12;
9833       sect->alignment_power = 2;
9834
9835       /* thread_info.is_active_thread */
9836       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9837
9838       if (is_active_thread)
9839         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
9840           return FALSE;
9841       break;
9842
9843     case 3 /* NOTE_INFO_MODULE */:
9844       /* Make a ".module/xxxxxxxx" section.  */
9845       /* module_info.base_address */
9846       base_addr = bfd_get_32 (abfd, note->descdata + 4);
9847       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
9848
9849       len = strlen (buf) + 1;
9850       name = (char *) bfd_alloc (abfd, len);
9851       if (name == NULL)
9852         return FALSE;
9853
9854       memcpy (name, buf, len);
9855
9856       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9857
9858       if (sect == NULL)
9859         return FALSE;
9860
9861       sect->size = note->descsz;
9862       sect->filepos = note->descpos;
9863       sect->alignment_power = 2;
9864       break;
9865
9866     default:
9867       return TRUE;
9868     }
9869
9870   return TRUE;
9871 }
9872
9873 static bfd_boolean
9874 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
9875 {
9876   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9877
9878   switch (note->type)
9879     {
9880     default:
9881       return TRUE;
9882
9883     case NT_PRSTATUS:
9884       if (bed->elf_backend_grok_prstatus)
9885         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
9886           return TRUE;
9887 #if defined (HAVE_PRSTATUS_T)
9888       return elfcore_grok_prstatus (abfd, note);
9889 #else
9890       return TRUE;
9891 #endif
9892
9893 #if defined (HAVE_PSTATUS_T)
9894     case NT_PSTATUS:
9895       return elfcore_grok_pstatus (abfd, note);
9896 #endif
9897
9898 #if defined (HAVE_LWPSTATUS_T)
9899     case NT_LWPSTATUS:
9900       return elfcore_grok_lwpstatus (abfd, note);
9901 #endif
9902
9903     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
9904       return elfcore_grok_prfpreg (abfd, note);
9905
9906     case NT_WIN32PSTATUS:
9907       return elfcore_grok_win32pstatus (abfd, note);
9908
9909     case NT_PRXFPREG:           /* Linux SSE extension */
9910       if (note->namesz == 6
9911           && strcmp (note->namedata, "LINUX") == 0)
9912         return elfcore_grok_prxfpreg (abfd, note);
9913       else
9914         return TRUE;
9915
9916     case NT_X86_XSTATE:         /* Linux XSAVE extension */
9917       if (note->namesz == 6
9918           && strcmp (note->namedata, "LINUX") == 0)
9919         return elfcore_grok_xstatereg (abfd, note);
9920       else
9921         return TRUE;
9922
9923     case NT_PPC_VMX:
9924       if (note->namesz == 6
9925           && strcmp (note->namedata, "LINUX") == 0)
9926         return elfcore_grok_ppc_vmx (abfd, note);
9927       else
9928         return TRUE;
9929
9930     case NT_PPC_VSX:
9931       if (note->namesz == 6
9932           && strcmp (note->namedata, "LINUX") == 0)
9933         return elfcore_grok_ppc_vsx (abfd, note);
9934       else
9935         return TRUE;
9936
9937     case NT_PPC_TAR:
9938       if (note->namesz == 6
9939           && strcmp (note->namedata, "LINUX") == 0)
9940         return elfcore_grok_ppc_tar (abfd, note);
9941       else
9942         return TRUE;
9943
9944     case NT_PPC_PPR:
9945       if (note->namesz == 6
9946           && strcmp (note->namedata, "LINUX") == 0)
9947         return elfcore_grok_ppc_ppr (abfd, note);
9948       else
9949         return TRUE;
9950
9951     case NT_PPC_DSCR:
9952       if (note->namesz == 6
9953           && strcmp (note->namedata, "LINUX") == 0)
9954         return elfcore_grok_ppc_dscr (abfd, note);
9955       else
9956         return TRUE;
9957
9958     case NT_PPC_EBB:
9959       if (note->namesz == 6
9960           && strcmp (note->namedata, "LINUX") == 0)
9961         return elfcore_grok_ppc_ebb (abfd, note);
9962       else
9963         return TRUE;
9964
9965     case NT_PPC_PMU:
9966       if (note->namesz == 6
9967           && strcmp (note->namedata, "LINUX") == 0)
9968         return elfcore_grok_ppc_pmu (abfd, note);
9969       else
9970         return TRUE;
9971
9972     case NT_PPC_TM_CGPR:
9973       if (note->namesz == 6
9974           && strcmp (note->namedata, "LINUX") == 0)
9975         return elfcore_grok_ppc_tm_cgpr (abfd, note);
9976       else
9977         return TRUE;
9978
9979     case NT_PPC_TM_CFPR:
9980       if (note->namesz == 6
9981           && strcmp (note->namedata, "LINUX") == 0)
9982         return elfcore_grok_ppc_tm_cfpr (abfd, note);
9983       else
9984         return TRUE;
9985
9986     case NT_PPC_TM_CVMX:
9987       if (note->namesz == 6
9988           && strcmp (note->namedata, "LINUX") == 0)
9989         return elfcore_grok_ppc_tm_cvmx (abfd, note);
9990       else
9991         return TRUE;
9992
9993     case NT_PPC_TM_CVSX:
9994       if (note->namesz == 6
9995           && strcmp (note->namedata, "LINUX") == 0)
9996         return elfcore_grok_ppc_tm_cvsx (abfd, note);
9997       else
9998         return TRUE;
9999
10000     case NT_PPC_TM_SPR:
10001       if (note->namesz == 6
10002           && strcmp (note->namedata, "LINUX") == 0)
10003         return elfcore_grok_ppc_tm_spr (abfd, note);
10004       else
10005         return TRUE;
10006
10007     case NT_PPC_TM_CTAR:
10008       if (note->namesz == 6
10009           && strcmp (note->namedata, "LINUX") == 0)
10010         return elfcore_grok_ppc_tm_ctar (abfd, note);
10011       else
10012         return TRUE;
10013
10014     case NT_PPC_TM_CPPR:
10015       if (note->namesz == 6
10016           && strcmp (note->namedata, "LINUX") == 0)
10017         return elfcore_grok_ppc_tm_cppr (abfd, note);
10018       else
10019         return TRUE;
10020
10021     case NT_PPC_TM_CDSCR:
10022       if (note->namesz == 6
10023           && strcmp (note->namedata, "LINUX") == 0)
10024         return elfcore_grok_ppc_tm_cdscr (abfd, note);
10025       else
10026         return TRUE;
10027
10028     case NT_S390_HIGH_GPRS:
10029       if (note->namesz == 6
10030           && strcmp (note->namedata, "LINUX") == 0)
10031         return elfcore_grok_s390_high_gprs (abfd, note);
10032       else
10033         return TRUE;
10034
10035     case NT_S390_TIMER:
10036       if (note->namesz == 6
10037           && strcmp (note->namedata, "LINUX") == 0)
10038         return elfcore_grok_s390_timer (abfd, note);
10039       else
10040         return TRUE;
10041
10042     case NT_S390_TODCMP:
10043       if (note->namesz == 6
10044           && strcmp (note->namedata, "LINUX") == 0)
10045         return elfcore_grok_s390_todcmp (abfd, note);
10046       else
10047         return TRUE;
10048
10049     case NT_S390_TODPREG:
10050       if (note->namesz == 6
10051           && strcmp (note->namedata, "LINUX") == 0)
10052         return elfcore_grok_s390_todpreg (abfd, note);
10053       else
10054         return TRUE;
10055
10056     case NT_S390_CTRS:
10057       if (note->namesz == 6
10058           && strcmp (note->namedata, "LINUX") == 0)
10059         return elfcore_grok_s390_ctrs (abfd, note);
10060       else
10061         return TRUE;
10062
10063     case NT_S390_PREFIX:
10064       if (note->namesz == 6
10065           && strcmp (note->namedata, "LINUX") == 0)
10066         return elfcore_grok_s390_prefix (abfd, note);
10067       else
10068         return TRUE;
10069
10070     case NT_S390_LAST_BREAK:
10071       if (note->namesz == 6
10072           && strcmp (note->namedata, "LINUX") == 0)
10073         return elfcore_grok_s390_last_break (abfd, note);
10074       else
10075         return TRUE;
10076
10077     case NT_S390_SYSTEM_CALL:
10078       if (note->namesz == 6
10079           && strcmp (note->namedata, "LINUX") == 0)
10080         return elfcore_grok_s390_system_call (abfd, note);
10081       else
10082         return TRUE;
10083
10084     case NT_S390_TDB:
10085       if (note->namesz == 6
10086           && strcmp (note->namedata, "LINUX") == 0)
10087         return elfcore_grok_s390_tdb (abfd, note);
10088       else
10089         return TRUE;
10090
10091     case NT_S390_VXRS_LOW:
10092       if (note->namesz == 6
10093           && strcmp (note->namedata, "LINUX") == 0)
10094         return elfcore_grok_s390_vxrs_low (abfd, note);
10095       else
10096         return TRUE;
10097
10098     case NT_S390_VXRS_HIGH:
10099       if (note->namesz == 6
10100           && strcmp (note->namedata, "LINUX") == 0)
10101         return elfcore_grok_s390_vxrs_high (abfd, note);
10102       else
10103         return TRUE;
10104
10105     case NT_S390_GS_CB:
10106       if (note->namesz == 6
10107           && strcmp (note->namedata, "LINUX") == 0)
10108         return elfcore_grok_s390_gs_cb (abfd, note);
10109       else
10110         return TRUE;
10111
10112     case NT_S390_GS_BC:
10113       if (note->namesz == 6
10114           && strcmp (note->namedata, "LINUX") == 0)
10115         return elfcore_grok_s390_gs_bc (abfd, note);
10116       else
10117         return TRUE;
10118
10119     case NT_ARM_VFP:
10120       if (note->namesz == 6
10121           && strcmp (note->namedata, "LINUX") == 0)
10122         return elfcore_grok_arm_vfp (abfd, note);
10123       else
10124         return TRUE;
10125
10126     case NT_ARM_TLS:
10127       if (note->namesz == 6
10128           && strcmp (note->namedata, "LINUX") == 0)
10129         return elfcore_grok_aarch_tls (abfd, note);
10130       else
10131         return TRUE;
10132
10133     case NT_ARM_HW_BREAK:
10134       if (note->namesz == 6
10135           && strcmp (note->namedata, "LINUX") == 0)
10136         return elfcore_grok_aarch_hw_break (abfd, note);
10137       else
10138         return TRUE;
10139
10140     case NT_ARM_HW_WATCH:
10141       if (note->namesz == 6
10142           && strcmp (note->namedata, "LINUX") == 0)
10143         return elfcore_grok_aarch_hw_watch (abfd, note);
10144       else
10145         return TRUE;
10146
10147     case NT_ARM_SVE:
10148       if (note->namesz == 6
10149           && strcmp (note->namedata, "LINUX") == 0)
10150         return elfcore_grok_aarch_sve (abfd, note);
10151       else
10152         return TRUE;
10153
10154     case NT_ARM_PAC_MASK:
10155       if (note->namesz == 6
10156           && strcmp (note->namedata, "LINUX") == 0)
10157         return elfcore_grok_aarch_pauth (abfd, note);
10158       else
10159         return TRUE;
10160
10161     case NT_PRPSINFO:
10162     case NT_PSINFO:
10163       if (bed->elf_backend_grok_psinfo)
10164         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
10165           return TRUE;
10166 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10167       return elfcore_grok_psinfo (abfd, note);
10168 #else
10169       return TRUE;
10170 #endif
10171
10172     case NT_AUXV:
10173       {
10174         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10175                                                              SEC_HAS_CONTENTS);
10176
10177         if (sect == NULL)
10178           return FALSE;
10179         sect->size = note->descsz;
10180         sect->filepos = note->descpos;
10181         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10182
10183         return TRUE;
10184       }
10185
10186     case NT_FILE:
10187       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
10188                                               note);
10189
10190     case NT_SIGINFO:
10191       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
10192                                               note);
10193
10194     }
10195 }
10196
10197 static bfd_boolean
10198 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
10199 {
10200   struct bfd_build_id* build_id;
10201
10202   if (note->descsz == 0)
10203     return FALSE;
10204
10205   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
10206   if (build_id == NULL)
10207     return FALSE;
10208
10209   build_id->size = note->descsz;
10210   memcpy (build_id->data, note->descdata, note->descsz);
10211   abfd->build_id = build_id;
10212
10213   return TRUE;
10214 }
10215
10216 static bfd_boolean
10217 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
10218 {
10219   switch (note->type)
10220     {
10221     default:
10222       return TRUE;
10223
10224     case NT_GNU_PROPERTY_TYPE_0:
10225       return _bfd_elf_parse_gnu_properties (abfd, note);
10226
10227     case NT_GNU_BUILD_ID:
10228       return elfobj_grok_gnu_build_id (abfd, note);
10229     }
10230 }
10231
10232 static bfd_boolean
10233 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
10234 {
10235   struct sdt_note *cur =
10236     (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
10237                                    + note->descsz);
10238
10239   cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
10240   cur->size = (bfd_size_type) note->descsz;
10241   memcpy (cur->data, note->descdata, note->descsz);
10242
10243   elf_tdata (abfd)->sdt_note_head = cur;
10244
10245   return TRUE;
10246 }
10247
10248 static bfd_boolean
10249 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
10250 {
10251   switch (note->type)
10252     {
10253     case NT_STAPSDT:
10254       return elfobj_grok_stapsdt_note_1 (abfd, note);
10255
10256     default:
10257       return TRUE;
10258     }
10259 }
10260
10261 static bfd_boolean
10262 elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
10263 {
10264   size_t offset;
10265
10266   switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10267     {
10268     case ELFCLASS32:
10269       if (note->descsz < 108)
10270         return FALSE;
10271       break;
10272
10273     case ELFCLASS64:
10274       if (note->descsz < 120)
10275         return FALSE;
10276       break;
10277
10278     default:
10279       return FALSE;
10280     }
10281
10282   /* Check for version 1 in pr_version.  */
10283   if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10284     return FALSE;
10285
10286   offset = 4;
10287
10288   /* Skip over pr_psinfosz. */
10289   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10290     offset += 4;
10291   else
10292     {
10293       offset += 4;      /* Padding before pr_psinfosz. */
10294       offset += 8;
10295     }
10296
10297   /* pr_fname is PRFNAMESZ (16) + 1 bytes in size.  */
10298   elf_tdata (abfd)->core->program
10299     = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
10300   offset += 17;
10301
10302   /* pr_psargs is PRARGSZ (80) + 1 bytes in size.  */
10303   elf_tdata (abfd)->core->command
10304     = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
10305   offset += 81;
10306
10307   /* Padding before pr_pid.  */
10308   offset += 2;
10309
10310   /* The pr_pid field was added in version "1a".  */
10311   if (note->descsz < offset + 4)
10312     return TRUE;
10313
10314   elf_tdata (abfd)->core->pid
10315     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10316
10317   return TRUE;
10318 }
10319
10320 static bfd_boolean
10321 elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
10322 {
10323   size_t offset;
10324   size_t size;
10325   size_t min_size;
10326
10327   /* Compute offset of pr_getregsz, skipping over pr_statussz.
10328      Also compute minimum size of this note.  */
10329   switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10330     {
10331     case ELFCLASS32:
10332       offset = 4 + 4;
10333       min_size = offset + (4 * 2) + 4 + 4 + 4;
10334       break;
10335
10336     case ELFCLASS64:
10337       offset = 4 + 4 + 8;       /* Includes padding before pr_statussz.  */
10338       min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
10339       break;
10340
10341     default:
10342       return FALSE;
10343     }
10344
10345   if (note->descsz < min_size)
10346     return FALSE;
10347
10348   /* Check for version 1 in pr_version.  */
10349   if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10350     return FALSE;
10351
10352   /* Extract size of pr_reg from pr_gregsetsz.  */
10353   /* Skip over pr_gregsetsz and pr_fpregsetsz.  */
10354   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10355     {
10356       size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10357       offset += 4 * 2;
10358     }
10359   else
10360     {
10361       size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10362       offset += 8 * 2;
10363     }
10364
10365   /* Skip over pr_osreldate.  */
10366   offset += 4;
10367
10368   /* Read signal from pr_cursig.  */
10369   if (elf_tdata (abfd)->core->signal == 0)
10370     elf_tdata (abfd)->core->signal
10371       = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10372   offset += 4;
10373
10374   /* Read TID from pr_pid.  */
10375   elf_tdata (abfd)->core->lwpid
10376       = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10377   offset += 4;
10378
10379   /* Padding before pr_reg.  */
10380   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
10381     offset += 4;
10382
10383   /* Make sure that there is enough data remaining in the note.  */
10384   if ((note->descsz - offset) < size)
10385     return FALSE;
10386
10387   /* Make a ".reg/999" section and a ".reg" section.  */
10388   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10389                                           size, note->descpos + offset);
10390 }
10391
10392 static bfd_boolean
10393 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10394 {
10395   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10396
10397   switch (note->type)
10398     {
10399     case NT_PRSTATUS:
10400       if (bed->elf_backend_grok_freebsd_prstatus)
10401         if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10402           return TRUE;
10403       return elfcore_grok_freebsd_prstatus (abfd, note);
10404
10405     case NT_FPREGSET:
10406       return elfcore_grok_prfpreg (abfd, note);
10407
10408     case NT_PRPSINFO:
10409       return elfcore_grok_freebsd_psinfo (abfd, note);
10410
10411     case NT_FREEBSD_THRMISC:
10412       if (note->namesz == 8)
10413         return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10414       else
10415         return TRUE;
10416
10417     case NT_FREEBSD_PROCSTAT_PROC:
10418       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10419                                               note);
10420
10421     case NT_FREEBSD_PROCSTAT_FILES:
10422       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10423                                               note);
10424
10425     case NT_FREEBSD_PROCSTAT_VMMAP:
10426       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10427                                               note);
10428
10429     case NT_FREEBSD_PROCSTAT_AUXV:
10430       {
10431         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10432                                                              SEC_HAS_CONTENTS);
10433
10434         if (sect == NULL)
10435           return FALSE;
10436         sect->size = note->descsz - 4;
10437         sect->filepos = note->descpos + 4;
10438         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10439
10440         return TRUE;
10441       }
10442
10443     case NT_X86_XSTATE:
10444       if (note->namesz == 8)
10445         return elfcore_grok_xstatereg (abfd, note);
10446       else
10447         return TRUE;
10448
10449     case NT_FREEBSD_PTLWPINFO:
10450       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10451                                               note);
10452
10453     case NT_ARM_VFP:
10454       return elfcore_grok_arm_vfp (abfd, note);
10455
10456     default:
10457       return TRUE;
10458     }
10459 }
10460
10461 static bfd_boolean
10462 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
10463 {
10464   char *cp;
10465
10466   cp = strchr (note->namedata, '@');
10467   if (cp != NULL)
10468     {
10469       *lwpidp = atoi(cp + 1);
10470       return TRUE;
10471     }
10472   return FALSE;
10473 }
10474
10475 static bfd_boolean
10476 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10477 {
10478   if (note->descsz <= 0x7c + 31)
10479     return FALSE;
10480
10481   /* Signal number at offset 0x08. */
10482   elf_tdata (abfd)->core->signal
10483     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10484
10485   /* Process ID at offset 0x50. */
10486   elf_tdata (abfd)->core->pid
10487     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10488
10489   /* Command name at 0x7c (max 32 bytes, including nul). */
10490   elf_tdata (abfd)->core->command
10491     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10492
10493   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10494                                           note);
10495 }
10496
10497 static bfd_boolean
10498 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
10499 {
10500   int lwp;
10501
10502   if (elfcore_netbsd_get_lwpid (note, &lwp))
10503     elf_tdata (abfd)->core->lwpid = lwp;
10504
10505   if (note->type == NT_NETBSDCORE_PROCINFO)
10506     {
10507       /* NetBSD-specific core "procinfo".  Note that we expect to
10508          find this note before any of the others, which is fine,
10509          since the kernel writes this note out first when it
10510          creates a core file.  */
10511
10512       return elfcore_grok_netbsd_procinfo (abfd, note);
10513     }
10514
10515   /* As of Jan 2002 there are no other machine-independent notes
10516      defined for NetBSD core files.  If the note type is less
10517      than the start of the machine-dependent note types, we don't
10518      understand it.  */
10519
10520   if (note->type < NT_NETBSDCORE_FIRSTMACH)
10521     return TRUE;
10522
10523
10524   switch (bfd_get_arch (abfd))
10525     {
10526       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10527          PT_GETFPREGS == mach+2.  */
10528
10529     case bfd_arch_alpha:
10530     case bfd_arch_sparc:
10531       switch (note->type)
10532         {
10533         case NT_NETBSDCORE_FIRSTMACH+0:
10534           return elfcore_make_note_pseudosection (abfd, ".reg", note);
10535
10536         case NT_NETBSDCORE_FIRSTMACH+2:
10537           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10538
10539         default:
10540           return TRUE;
10541         }
10542
10543       /* On all other arch's, PT_GETREGS == mach+1 and
10544          PT_GETFPREGS == mach+3.  */
10545
10546     default:
10547       switch (note->type)
10548         {
10549         case NT_NETBSDCORE_FIRSTMACH+1:
10550           return elfcore_make_note_pseudosection (abfd, ".reg", note);
10551
10552         case NT_NETBSDCORE_FIRSTMACH+3:
10553           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10554
10555         default:
10556           return TRUE;
10557         }
10558     }
10559     /* NOTREACHED */
10560 }
10561
10562 static bfd_boolean
10563 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10564 {
10565   if (note->descsz <= 0x48 + 31)
10566     return FALSE;
10567
10568   /* Signal number at offset 0x08. */
10569   elf_tdata (abfd)->core->signal
10570     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10571
10572   /* Process ID at offset 0x20. */
10573   elf_tdata (abfd)->core->pid
10574     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10575
10576   /* Command name at 0x48 (max 32 bytes, including nul). */
10577   elf_tdata (abfd)->core->command
10578     = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10579
10580   return TRUE;
10581 }
10582
10583 static bfd_boolean
10584 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10585 {
10586   if (note->type == NT_OPENBSD_PROCINFO)
10587     return elfcore_grok_openbsd_procinfo (abfd, note);
10588
10589   if (note->type == NT_OPENBSD_REGS)
10590     return elfcore_make_note_pseudosection (abfd, ".reg", note);
10591
10592   if (note->type == NT_OPENBSD_FPREGS)
10593     return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10594
10595   if (note->type == NT_OPENBSD_XFPREGS)
10596     return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10597
10598   if (note->type == NT_OPENBSD_AUXV)
10599     {
10600       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10601                                                            SEC_HAS_CONTENTS);
10602
10603       if (sect == NULL)
10604         return FALSE;
10605       sect->size = note->descsz;
10606       sect->filepos = note->descpos;
10607       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10608
10609       return TRUE;
10610     }
10611
10612   if (note->type == NT_OPENBSD_WCOOKIE)
10613     {
10614       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10615                                                            SEC_HAS_CONTENTS);
10616
10617       if (sect == NULL)
10618         return FALSE;
10619       sect->size = note->descsz;
10620       sect->filepos = note->descpos;
10621       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10622
10623       return TRUE;
10624     }
10625
10626   return TRUE;
10627 }
10628
10629 static bfd_boolean
10630 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
10631 {
10632   void *ddata = note->descdata;
10633   char buf[100];
10634   char *name;
10635   asection *sect;
10636   short sig;
10637   unsigned flags;
10638
10639   if (note->descsz < 16)
10640     return FALSE;
10641
10642   /* nto_procfs_status 'pid' field is at offset 0.  */
10643   elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
10644
10645   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
10646   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10647
10648   /* nto_procfs_status 'flags' field is at offset 8.  */
10649   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
10650
10651   /* nto_procfs_status 'what' field is at offset 14.  */
10652   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10653     {
10654       elf_tdata (abfd)->core->signal = sig;
10655       elf_tdata (abfd)->core->lwpid = *tid;
10656     }
10657
10658   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
10659      do not come from signals so we make sure we set the current
10660      thread just in case.  */
10661   if (flags & 0x00000080)
10662     elf_tdata (abfd)->core->lwpid = *tid;
10663
10664   /* Make a ".qnx_core_status/%d" section.  */
10665   sprintf (buf, ".qnx_core_status/%ld", *tid);
10666
10667   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10668   if (name == NULL)
10669     return FALSE;
10670   strcpy (name, buf);
10671
10672   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10673   if (sect == NULL)
10674     return FALSE;
10675
10676   sect->size            = note->descsz;
10677   sect->filepos         = note->descpos;
10678   sect->alignment_power = 2;
10679
10680   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10681 }
10682
10683 static bfd_boolean
10684 elfcore_grok_nto_regs (bfd *abfd,
10685                        Elf_Internal_Note *note,
10686                        long tid,
10687                        char *base)
10688 {
10689   char buf[100];
10690   char *name;
10691   asection *sect;
10692
10693   /* Make a "(base)/%d" section.  */
10694   sprintf (buf, "%s/%ld", base, tid);
10695
10696   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10697   if (name == NULL)
10698     return FALSE;
10699   strcpy (name, buf);
10700
10701   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10702   if (sect == NULL)
10703     return FALSE;
10704
10705   sect->size            = note->descsz;
10706   sect->filepos         = note->descpos;
10707   sect->alignment_power = 2;
10708
10709   /* This is the current thread.  */
10710   if (elf_tdata (abfd)->core->lwpid == tid)
10711     return elfcore_maybe_make_sect (abfd, base, sect);
10712
10713   return TRUE;
10714 }
10715
10716 #define BFD_QNT_CORE_INFO       7
10717 #define BFD_QNT_CORE_STATUS     8
10718 #define BFD_QNT_CORE_GREG       9
10719 #define BFD_QNT_CORE_FPREG      10
10720
10721 static bfd_boolean
10722 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
10723 {
10724   /* Every GREG section has a STATUS section before it.  Store the
10725      tid from the previous call to pass down to the next gregs
10726      function.  */
10727   static long tid = 1;
10728
10729   switch (note->type)
10730     {
10731     case BFD_QNT_CORE_INFO:
10732       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10733     case BFD_QNT_CORE_STATUS:
10734       return elfcore_grok_nto_status (abfd, note, &tid);
10735     case BFD_QNT_CORE_GREG:
10736       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10737     case BFD_QNT_CORE_FPREG:
10738       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10739     default:
10740       return TRUE;
10741     }
10742 }
10743
10744 static bfd_boolean
10745 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10746 {
10747   char *name;
10748   asection *sect;
10749   size_t len;
10750
10751   /* Use note name as section name.  */
10752   len = note->namesz;
10753   name = (char *) bfd_alloc (abfd, len);
10754   if (name == NULL)
10755     return FALSE;
10756   memcpy (name, note->namedata, len);
10757   name[len - 1] = '\0';
10758
10759   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10760   if (sect == NULL)
10761     return FALSE;
10762
10763   sect->size            = note->descsz;
10764   sect->filepos         = note->descpos;
10765   sect->alignment_power = 1;
10766
10767   return TRUE;
10768 }
10769
10770 /* Function: elfcore_write_note
10771
10772    Inputs:
10773      buffer to hold note, and current size of buffer
10774      name of note
10775      type of note
10776      data for note
10777      size of data for note
10778
10779    Writes note to end of buffer.  ELF64 notes are written exactly as
10780    for ELF32, despite the current (as of 2006) ELF gabi specifying
10781    that they ought to have 8-byte namesz and descsz field, and have
10782    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
10783
10784    Return:
10785    Pointer to realloc'd buffer, *BUFSIZ updated.  */
10786
10787 char *
10788 elfcore_write_note (bfd *abfd,
10789                     char *buf,
10790                     int *bufsiz,
10791                     const char *name,
10792                     int type,
10793                     const void *input,
10794                     int size)
10795 {
10796   Elf_External_Note *xnp;
10797   size_t namesz;
10798   size_t newspace;
10799   char *dest;
10800
10801   namesz = 0;
10802   if (name != NULL)
10803     namesz = strlen (name) + 1;
10804
10805   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
10806
10807   buf = (char *) realloc (buf, *bufsiz + newspace);
10808   if (buf == NULL)
10809     return buf;
10810   dest = buf + *bufsiz;
10811   *bufsiz += newspace;
10812   xnp = (Elf_External_Note *) dest;
10813   H_PUT_32 (abfd, namesz, xnp->namesz);
10814   H_PUT_32 (abfd, size, xnp->descsz);
10815   H_PUT_32 (abfd, type, xnp->type);
10816   dest = xnp->name;
10817   if (name != NULL)
10818     {
10819       memcpy (dest, name, namesz);
10820       dest += namesz;
10821       while (namesz & 3)
10822         {
10823           *dest++ = '\0';
10824           ++namesz;
10825         }
10826     }
10827   memcpy (dest, input, size);
10828   dest += size;
10829   while (size & 3)
10830     {
10831       *dest++ = '\0';
10832       ++size;
10833     }
10834   return buf;
10835 }
10836
10837 /* gcc-8 warns (*) on all the strncpy calls in this function about
10838    possible string truncation.  The "truncation" is not a bug.  We
10839    have an external representation of structs with fields that are not
10840    necessarily NULL terminated and corresponding internal
10841    representation fields that are one larger so that they can always
10842    be NULL terminated.
10843    gcc versions between 4.2 and 4.6 do not allow pragma control of
10844    diagnostics inside functions, giving a hard error if you try to use
10845    the finer control available with later versions.
10846    gcc prior to 4.2 warns about diagnostic push and pop.
10847    gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10848    unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10849    (*) Depending on your system header files!  */
10850 #if GCC_VERSION >= 8000
10851 # pragma GCC diagnostic push
10852 # pragma GCC diagnostic ignored "-Wstringop-truncation"
10853 #endif
10854 char *
10855 elfcore_write_prpsinfo (bfd  *abfd,
10856                         char *buf,
10857                         int  *bufsiz,
10858                         const char *fname,
10859                         const char *psargs)
10860 {
10861   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10862
10863   if (bed->elf_backend_write_core_note != NULL)
10864     {
10865       char *ret;
10866       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10867                                                  NT_PRPSINFO, fname, psargs);
10868       if (ret != NULL)
10869         return ret;
10870     }
10871
10872 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10873 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10874   if (bed->s->elfclass == ELFCLASS32)
10875     {
10876 #  if defined (HAVE_PSINFO32_T)
10877       psinfo32_t data;
10878       int note_type = NT_PSINFO;
10879 #  else
10880       prpsinfo32_t data;
10881       int note_type = NT_PRPSINFO;
10882 #  endif
10883
10884       memset (&data, 0, sizeof (data));
10885       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10886       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10887       return elfcore_write_note (abfd, buf, bufsiz,
10888                                  "CORE", note_type, &data, sizeof (data));
10889     }
10890   else
10891 # endif
10892     {
10893 # if defined (HAVE_PSINFO_T)
10894       psinfo_t data;
10895       int note_type = NT_PSINFO;
10896 # else
10897       prpsinfo_t data;
10898       int note_type = NT_PRPSINFO;
10899 # endif
10900
10901       memset (&data, 0, sizeof (data));
10902       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10903       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10904       return elfcore_write_note (abfd, buf, bufsiz,
10905                                  "CORE", note_type, &data, sizeof (data));
10906     }
10907 #endif  /* PSINFO_T or PRPSINFO_T */
10908
10909   free (buf);
10910   return NULL;
10911 }
10912 #if GCC_VERSION >= 8000
10913 # pragma GCC diagnostic pop
10914 #endif
10915
10916 char *
10917 elfcore_write_linux_prpsinfo32
10918   (bfd *abfd, char *buf, int *bufsiz,
10919    const struct elf_internal_linux_prpsinfo *prpsinfo)
10920 {
10921   if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10922     {
10923       struct elf_external_linux_prpsinfo32_ugid16 data;
10924
10925       swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10926       return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10927                                  &data, sizeof (data));
10928     }
10929   else
10930     {
10931       struct elf_external_linux_prpsinfo32_ugid32 data;
10932
10933       swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10934       return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10935                                  &data, sizeof (data));
10936     }
10937 }
10938
10939 char *
10940 elfcore_write_linux_prpsinfo64
10941   (bfd *abfd, char *buf, int *bufsiz,
10942    const struct elf_internal_linux_prpsinfo *prpsinfo)
10943 {
10944   if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
10945     {
10946       struct elf_external_linux_prpsinfo64_ugid16 data;
10947
10948       swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
10949       return elfcore_write_note (abfd, buf, bufsiz,
10950                                  "CORE", NT_PRPSINFO, &data, sizeof (data));
10951     }
10952   else
10953     {
10954       struct elf_external_linux_prpsinfo64_ugid32 data;
10955
10956       swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
10957       return elfcore_write_note (abfd, buf, bufsiz,
10958                                  "CORE", NT_PRPSINFO, &data, sizeof (data));
10959     }
10960 }
10961
10962 char *
10963 elfcore_write_prstatus (bfd *abfd,
10964                         char *buf,
10965                         int *bufsiz,
10966                         long pid,
10967                         int cursig,
10968                         const void *gregs)
10969 {
10970   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10971
10972   if (bed->elf_backend_write_core_note != NULL)
10973     {
10974       char *ret;
10975       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10976                                                  NT_PRSTATUS,
10977                                                  pid, cursig, gregs);
10978       if (ret != NULL)
10979         return ret;
10980     }
10981
10982 #if defined (HAVE_PRSTATUS_T)
10983 #if defined (HAVE_PRSTATUS32_T)
10984   if (bed->s->elfclass == ELFCLASS32)
10985     {
10986       prstatus32_t prstat;
10987
10988       memset (&prstat, 0, sizeof (prstat));
10989       prstat.pr_pid = pid;
10990       prstat.pr_cursig = cursig;
10991       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10992       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10993                                  NT_PRSTATUS, &prstat, sizeof (prstat));
10994     }
10995   else
10996 #endif
10997     {
10998       prstatus_t prstat;
10999
11000       memset (&prstat, 0, sizeof (prstat));
11001       prstat.pr_pid = pid;
11002       prstat.pr_cursig = cursig;
11003       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
11004       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
11005                                  NT_PRSTATUS, &prstat, sizeof (prstat));
11006     }
11007 #endif /* HAVE_PRSTATUS_T */
11008
11009   free (buf);
11010   return NULL;
11011 }
11012
11013 #if defined (HAVE_LWPSTATUS_T)
11014 char *
11015 elfcore_write_lwpstatus (bfd *abfd,
11016                          char *buf,
11017                          int *bufsiz,
11018                          long pid,
11019                          int cursig,
11020                          const void *gregs)
11021 {
11022   lwpstatus_t lwpstat;
11023   const char *note_name = "CORE";
11024
11025   memset (&lwpstat, 0, sizeof (lwpstat));
11026   lwpstat.pr_lwpid  = pid >> 16;
11027   lwpstat.pr_cursig = cursig;
11028 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11029   memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
11030 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11031 #if !defined(gregs)
11032   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
11033           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
11034 #else
11035   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
11036           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
11037 #endif
11038 #endif
11039   return elfcore_write_note (abfd, buf, bufsiz, note_name,
11040                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
11041 }
11042 #endif /* HAVE_LWPSTATUS_T */
11043
11044 #if defined (HAVE_PSTATUS_T)
11045 char *
11046 elfcore_write_pstatus (bfd *abfd,
11047                        char *buf,
11048                        int *bufsiz,
11049                        long pid,
11050                        int cursig ATTRIBUTE_UNUSED,
11051                        const void *gregs ATTRIBUTE_UNUSED)
11052 {
11053   const char *note_name = "CORE";
11054 #if defined (HAVE_PSTATUS32_T)
11055   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11056
11057   if (bed->s->elfclass == ELFCLASS32)
11058     {
11059       pstatus32_t pstat;
11060
11061       memset (&pstat, 0, sizeof (pstat));
11062       pstat.pr_pid = pid & 0xffff;
11063       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11064                                 NT_PSTATUS, &pstat, sizeof (pstat));
11065       return buf;
11066     }
11067   else
11068 #endif
11069     {
11070       pstatus_t pstat;
11071
11072       memset (&pstat, 0, sizeof (pstat));
11073       pstat.pr_pid = pid & 0xffff;
11074       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11075                                 NT_PSTATUS, &pstat, sizeof (pstat));
11076       return buf;
11077     }
11078 }
11079 #endif /* HAVE_PSTATUS_T */
11080
11081 char *
11082 elfcore_write_prfpreg (bfd *abfd,
11083                        char *buf,
11084                        int *bufsiz,
11085                        const void *fpregs,
11086                        int size)
11087 {
11088   const char *note_name = "CORE";
11089   return elfcore_write_note (abfd, buf, bufsiz,
11090                              note_name, NT_FPREGSET, fpregs, size);
11091 }
11092
11093 char *
11094 elfcore_write_prxfpreg (bfd *abfd,
11095                         char *buf,
11096                         int *bufsiz,
11097                         const void *xfpregs,
11098                         int size)
11099 {
11100   char *note_name = "LINUX";
11101   return elfcore_write_note (abfd, buf, bufsiz,
11102                              note_name, NT_PRXFPREG, xfpregs, size);
11103 }
11104
11105 char *
11106 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
11107                          const void *xfpregs, int size)
11108 {
11109   char *note_name;
11110   if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
11111     note_name = "FreeBSD";
11112   else
11113     note_name = "LINUX";
11114   return elfcore_write_note (abfd, buf, bufsiz,
11115                              note_name, NT_X86_XSTATE, xfpregs, size);
11116 }
11117
11118 char *
11119 elfcore_write_ppc_vmx (bfd *abfd,
11120                        char *buf,
11121                        int *bufsiz,
11122                        const void *ppc_vmx,
11123                        int size)
11124 {
11125   char *note_name = "LINUX";
11126   return elfcore_write_note (abfd, buf, bufsiz,
11127                              note_name, NT_PPC_VMX, ppc_vmx, size);
11128 }
11129
11130 char *
11131 elfcore_write_ppc_vsx (bfd *abfd,
11132                        char *buf,
11133                        int *bufsiz,
11134                        const void *ppc_vsx,
11135                        int size)
11136 {
11137   char *note_name = "LINUX";
11138   return elfcore_write_note (abfd, buf, bufsiz,
11139                              note_name, NT_PPC_VSX, ppc_vsx, size);
11140 }
11141
11142 char *
11143 elfcore_write_ppc_tar (bfd *abfd,
11144                        char *buf,
11145                        int *bufsiz,
11146                        const void *ppc_tar,
11147                        int size)
11148 {
11149   char *note_name = "LINUX";
11150   return elfcore_write_note (abfd, buf, bufsiz,
11151                              note_name, NT_PPC_TAR, ppc_tar, size);
11152 }
11153
11154 char *
11155 elfcore_write_ppc_ppr (bfd *abfd,
11156                        char *buf,
11157                        int *bufsiz,
11158                        const void *ppc_ppr,
11159                        int size)
11160 {
11161   char *note_name = "LINUX";
11162   return elfcore_write_note (abfd, buf, bufsiz,
11163                              note_name, NT_PPC_PPR, ppc_ppr, size);
11164 }
11165
11166 char *
11167 elfcore_write_ppc_dscr (bfd *abfd,
11168                         char *buf,
11169                         int *bufsiz,
11170                         const void *ppc_dscr,
11171                         int size)
11172 {
11173   char *note_name = "LINUX";
11174   return elfcore_write_note (abfd, buf, bufsiz,
11175                              note_name, NT_PPC_DSCR, ppc_dscr, size);
11176 }
11177
11178 char *
11179 elfcore_write_ppc_ebb (bfd *abfd,
11180                        char *buf,
11181                        int *bufsiz,
11182                        const void *ppc_ebb,
11183                        int size)
11184 {
11185   char *note_name = "LINUX";
11186   return elfcore_write_note (abfd, buf, bufsiz,
11187                              note_name, NT_PPC_EBB, ppc_ebb, size);
11188 }
11189
11190 char *
11191 elfcore_write_ppc_pmu (bfd *abfd,
11192                        char *buf,
11193                        int *bufsiz,
11194                        const void *ppc_pmu,
11195                        int size)
11196 {
11197   char *note_name = "LINUX";
11198   return elfcore_write_note (abfd, buf, bufsiz,
11199                              note_name, NT_PPC_PMU, ppc_pmu, size);
11200 }
11201
11202 char *
11203 elfcore_write_ppc_tm_cgpr (bfd *abfd,
11204                            char *buf,
11205                            int *bufsiz,
11206                            const void *ppc_tm_cgpr,
11207                            int size)
11208 {
11209   char *note_name = "LINUX";
11210   return elfcore_write_note (abfd, buf, bufsiz,
11211                              note_name, NT_PPC_TM_CGPR, ppc_tm_cgpr, size);
11212 }
11213
11214 char *
11215 elfcore_write_ppc_tm_cfpr (bfd *abfd,
11216                            char *buf,
11217                            int *bufsiz,
11218                            const void *ppc_tm_cfpr,
11219                            int size)
11220 {
11221   char *note_name = "LINUX";
11222   return elfcore_write_note (abfd, buf, bufsiz,
11223                              note_name, NT_PPC_TM_CFPR, ppc_tm_cfpr, size);
11224 }
11225
11226 char *
11227 elfcore_write_ppc_tm_cvmx (bfd *abfd,
11228                            char *buf,
11229                            int *bufsiz,
11230                            const void *ppc_tm_cvmx,
11231                            int size)
11232 {
11233   char *note_name = "LINUX";
11234   return elfcore_write_note (abfd, buf, bufsiz,
11235                              note_name, NT_PPC_TM_CVMX, ppc_tm_cvmx, size);
11236 }
11237
11238 char *
11239 elfcore_write_ppc_tm_cvsx (bfd *abfd,
11240                            char *buf,
11241                            int *bufsiz,
11242                            const void *ppc_tm_cvsx,
11243                            int size)
11244 {
11245   char *note_name = "LINUX";
11246   return elfcore_write_note (abfd, buf, bufsiz,
11247                              note_name, NT_PPC_TM_CVSX, ppc_tm_cvsx, size);
11248 }
11249
11250 char *
11251 elfcore_write_ppc_tm_spr (bfd *abfd,
11252                           char *buf,
11253                           int *bufsiz,
11254                           const void *ppc_tm_spr,
11255                           int size)
11256 {
11257   char *note_name = "LINUX";
11258   return elfcore_write_note (abfd, buf, bufsiz,
11259                              note_name, NT_PPC_TM_SPR, ppc_tm_spr, size);
11260 }
11261
11262 char *
11263 elfcore_write_ppc_tm_ctar (bfd *abfd,
11264                            char *buf,
11265                            int *bufsiz,
11266                            const void *ppc_tm_ctar,
11267                            int size)
11268 {
11269   char *note_name = "LINUX";
11270   return elfcore_write_note (abfd, buf, bufsiz,
11271                              note_name, NT_PPC_TM_CTAR, ppc_tm_ctar, size);
11272 }
11273
11274 char *
11275 elfcore_write_ppc_tm_cppr (bfd *abfd,
11276                            char *buf,
11277                            int *bufsiz,
11278                            const void *ppc_tm_cppr,
11279                            int size)
11280 {
11281   char *note_name = "LINUX";
11282   return elfcore_write_note (abfd, buf, bufsiz,
11283                              note_name, NT_PPC_TM_CPPR, ppc_tm_cppr, size);
11284 }
11285
11286 char *
11287 elfcore_write_ppc_tm_cdscr (bfd *abfd,
11288                             char *buf,
11289                             int *bufsiz,
11290                             const void *ppc_tm_cdscr,
11291                             int size)
11292 {
11293   char *note_name = "LINUX";
11294   return elfcore_write_note (abfd, buf, bufsiz,
11295                              note_name, NT_PPC_TM_CDSCR, ppc_tm_cdscr, size);
11296 }
11297
11298 static char *
11299 elfcore_write_s390_high_gprs (bfd *abfd,
11300                               char *buf,
11301                               int *bufsiz,
11302                               const void *s390_high_gprs,
11303                               int size)
11304 {
11305   char *note_name = "LINUX";
11306   return elfcore_write_note (abfd, buf, bufsiz,
11307                              note_name, NT_S390_HIGH_GPRS,
11308                              s390_high_gprs, size);
11309 }
11310
11311 char *
11312 elfcore_write_s390_timer (bfd *abfd,
11313                           char *buf,
11314                           int *bufsiz,
11315                           const void *s390_timer,
11316                           int size)
11317 {
11318   char *note_name = "LINUX";
11319   return elfcore_write_note (abfd, buf, bufsiz,
11320                              note_name, NT_S390_TIMER, s390_timer, size);
11321 }
11322
11323 char *
11324 elfcore_write_s390_todcmp (bfd *abfd,
11325                            char *buf,
11326                            int *bufsiz,
11327                            const void *s390_todcmp,
11328                            int size)
11329 {
11330   char *note_name = "LINUX";
11331   return elfcore_write_note (abfd, buf, bufsiz,
11332                              note_name, NT_S390_TODCMP, s390_todcmp, size);
11333 }
11334
11335 char *
11336 elfcore_write_s390_todpreg (bfd *abfd,
11337                             char *buf,
11338                             int *bufsiz,
11339                             const void *s390_todpreg,
11340                             int size)
11341 {
11342   char *note_name = "LINUX";
11343   return elfcore_write_note (abfd, buf, bufsiz,
11344                              note_name, NT_S390_TODPREG, s390_todpreg, size);
11345 }
11346
11347 char *
11348 elfcore_write_s390_ctrs (bfd *abfd,
11349                          char *buf,
11350                          int *bufsiz,
11351                          const void *s390_ctrs,
11352                          int size)
11353 {
11354   char *note_name = "LINUX";
11355   return elfcore_write_note (abfd, buf, bufsiz,
11356                              note_name, NT_S390_CTRS, s390_ctrs, size);
11357 }
11358
11359 char *
11360 elfcore_write_s390_prefix (bfd *abfd,
11361                            char *buf,
11362                            int *bufsiz,
11363                            const void *s390_prefix,
11364                            int size)
11365 {
11366   char *note_name = "LINUX";
11367   return elfcore_write_note (abfd, buf, bufsiz,
11368                              note_name, NT_S390_PREFIX, s390_prefix, size);
11369 }
11370
11371 char *
11372 elfcore_write_s390_last_break (bfd *abfd,
11373                                char *buf,
11374                                int *bufsiz,
11375                                const void *s390_last_break,
11376                                int size)
11377 {
11378   char *note_name = "LINUX";
11379   return elfcore_write_note (abfd, buf, bufsiz,
11380                              note_name, NT_S390_LAST_BREAK,
11381                              s390_last_break, size);
11382 }
11383
11384 char *
11385 elfcore_write_s390_system_call (bfd *abfd,
11386                                 char *buf,
11387                                 int *bufsiz,
11388                                 const void *s390_system_call,
11389                                 int size)
11390 {
11391   char *note_name = "LINUX";
11392   return elfcore_write_note (abfd, buf, bufsiz,
11393                              note_name, NT_S390_SYSTEM_CALL,
11394                              s390_system_call, size);
11395 }
11396
11397 char *
11398 elfcore_write_s390_tdb (bfd *abfd,
11399                         char *buf,
11400                         int *bufsiz,
11401                         const void *s390_tdb,
11402                         int size)
11403 {
11404   char *note_name = "LINUX";
11405   return elfcore_write_note (abfd, buf, bufsiz,
11406                              note_name, NT_S390_TDB, s390_tdb, size);
11407 }
11408
11409 char *
11410 elfcore_write_s390_vxrs_low (bfd *abfd,
11411                              char *buf,
11412                              int *bufsiz,
11413                              const void *s390_vxrs_low,
11414                              int size)
11415 {
11416   char *note_name = "LINUX";
11417   return elfcore_write_note (abfd, buf, bufsiz,
11418                              note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
11419 }
11420
11421 char *
11422 elfcore_write_s390_vxrs_high (bfd *abfd,
11423                              char *buf,
11424                              int *bufsiz,
11425                              const void *s390_vxrs_high,
11426                              int size)
11427 {
11428   char *note_name = "LINUX";
11429   return elfcore_write_note (abfd, buf, bufsiz,
11430                              note_name, NT_S390_VXRS_HIGH,
11431                              s390_vxrs_high, size);
11432 }
11433
11434 char *
11435 elfcore_write_s390_gs_cb (bfd *abfd,
11436                           char *buf,
11437                           int *bufsiz,
11438                           const void *s390_gs_cb,
11439                           int size)
11440 {
11441   char *note_name = "LINUX";
11442   return elfcore_write_note (abfd, buf, bufsiz,
11443                              note_name, NT_S390_GS_CB,
11444                              s390_gs_cb, size);
11445 }
11446
11447 char *
11448 elfcore_write_s390_gs_bc (bfd *abfd,
11449                           char *buf,
11450                           int *bufsiz,
11451                           const void *s390_gs_bc,
11452                           int size)
11453 {
11454   char *note_name = "LINUX";
11455   return elfcore_write_note (abfd, buf, bufsiz,
11456                              note_name, NT_S390_GS_BC,
11457                              s390_gs_bc, size);
11458 }
11459
11460 char *
11461 elfcore_write_arm_vfp (bfd *abfd,
11462                        char *buf,
11463                        int *bufsiz,
11464                        const void *arm_vfp,
11465                        int size)
11466 {
11467   char *note_name = "LINUX";
11468   return elfcore_write_note (abfd, buf, bufsiz,
11469                              note_name, NT_ARM_VFP, arm_vfp, size);
11470 }
11471
11472 char *
11473 elfcore_write_aarch_tls (bfd *abfd,
11474                        char *buf,
11475                        int *bufsiz,
11476                        const void *aarch_tls,
11477                        int size)
11478 {
11479   char *note_name = "LINUX";
11480   return elfcore_write_note (abfd, buf, bufsiz,
11481                              note_name, NT_ARM_TLS, aarch_tls, size);
11482 }
11483
11484 char *
11485 elfcore_write_aarch_hw_break (bfd *abfd,
11486                             char *buf,
11487                             int *bufsiz,
11488                             const void *aarch_hw_break,
11489                             int size)
11490 {
11491   char *note_name = "LINUX";
11492   return elfcore_write_note (abfd, buf, bufsiz,
11493                              note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11494 }
11495
11496 char *
11497 elfcore_write_aarch_hw_watch (bfd *abfd,
11498                             char *buf,
11499                             int *bufsiz,
11500                             const void *aarch_hw_watch,
11501                             int size)
11502 {
11503   char *note_name = "LINUX";
11504   return elfcore_write_note (abfd, buf, bufsiz,
11505                              note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11506 }
11507
11508 char *
11509 elfcore_write_aarch_sve (bfd *abfd,
11510                          char *buf,
11511                          int *bufsiz,
11512                          const void *aarch_sve,
11513                          int size)
11514 {
11515   char *note_name = "LINUX";
11516   return elfcore_write_note (abfd, buf, bufsiz,
11517                              note_name, NT_ARM_SVE, aarch_sve, size);
11518 }
11519
11520 char *
11521 elfcore_write_aarch_pauth (bfd *abfd,
11522                            char *buf,
11523                            int *bufsiz,
11524                            const void *aarch_pauth,
11525                            int size)
11526 {
11527   char *note_name = "LINUX";
11528   return elfcore_write_note (abfd, buf, bufsiz,
11529                              note_name, NT_ARM_PAC_MASK, aarch_pauth, size);
11530 }
11531
11532 char *
11533 elfcore_write_register_note (bfd *abfd,
11534                              char *buf,
11535                              int *bufsiz,
11536                              const char *section,
11537                              const void *data,
11538                              int size)
11539 {
11540   if (strcmp (section, ".reg2") == 0)
11541     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11542   if (strcmp (section, ".reg-xfp") == 0)
11543     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
11544   if (strcmp (section, ".reg-xstate") == 0)
11545     return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
11546   if (strcmp (section, ".reg-ppc-vmx") == 0)
11547     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
11548   if (strcmp (section, ".reg-ppc-vsx") == 0)
11549     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
11550   if (strcmp (section, ".reg-ppc-tar") == 0)
11551     return elfcore_write_ppc_tar (abfd, buf, bufsiz, data, size);
11552   if (strcmp (section, ".reg-ppc-ppr") == 0)
11553     return elfcore_write_ppc_ppr (abfd, buf, bufsiz, data, size);
11554   if (strcmp (section, ".reg-ppc-dscr") == 0)
11555     return elfcore_write_ppc_dscr (abfd, buf, bufsiz, data, size);
11556   if (strcmp (section, ".reg-ppc-ebb") == 0)
11557     return elfcore_write_ppc_ebb (abfd, buf, bufsiz, data, size);
11558   if (strcmp (section, ".reg-ppc-pmu") == 0)
11559     return elfcore_write_ppc_pmu (abfd, buf, bufsiz, data, size);
11560   if (strcmp (section, ".reg-ppc-tm-cgpr") == 0)
11561     return elfcore_write_ppc_tm_cgpr (abfd, buf, bufsiz, data, size);
11562   if (strcmp (section, ".reg-ppc-tm-cfpr") == 0)
11563     return elfcore_write_ppc_tm_cfpr (abfd, buf, bufsiz, data, size);
11564   if (strcmp (section, ".reg-ppc-tm-cvmx") == 0)
11565     return elfcore_write_ppc_tm_cvmx (abfd, buf, bufsiz, data, size);
11566   if (strcmp (section, ".reg-ppc-tm-cvsx") == 0)
11567     return elfcore_write_ppc_tm_cvsx (abfd, buf, bufsiz, data, size);
11568   if (strcmp (section, ".reg-ppc-tm-spr") == 0)
11569     return elfcore_write_ppc_tm_spr (abfd, buf, bufsiz, data, size);
11570   if (strcmp (section, ".reg-ppc-tm-ctar") == 0)
11571     return elfcore_write_ppc_tm_ctar (abfd, buf, bufsiz, data, size);
11572   if (strcmp (section, ".reg-ppc-tm-cppr") == 0)
11573     return elfcore_write_ppc_tm_cppr (abfd, buf, bufsiz, data, size);
11574   if (strcmp (section, ".reg-ppc-tm-cdscr") == 0)
11575     return elfcore_write_ppc_tm_cdscr (abfd, buf, bufsiz, data, size);
11576   if (strcmp (section, ".reg-s390-high-gprs") == 0)
11577     return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
11578   if (strcmp (section, ".reg-s390-timer") == 0)
11579     return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11580   if (strcmp (section, ".reg-s390-todcmp") == 0)
11581     return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11582   if (strcmp (section, ".reg-s390-todpreg") == 0)
11583     return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11584   if (strcmp (section, ".reg-s390-ctrs") == 0)
11585     return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11586   if (strcmp (section, ".reg-s390-prefix") == 0)
11587     return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
11588   if (strcmp (section, ".reg-s390-last-break") == 0)
11589     return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11590   if (strcmp (section, ".reg-s390-system-call") == 0)
11591     return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
11592   if (strcmp (section, ".reg-s390-tdb") == 0)
11593     return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
11594   if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11595     return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11596   if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11597     return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
11598   if (strcmp (section, ".reg-s390-gs-cb") == 0)
11599     return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11600   if (strcmp (section, ".reg-s390-gs-bc") == 0)
11601     return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
11602   if (strcmp (section, ".reg-arm-vfp") == 0)
11603     return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
11604   if (strcmp (section, ".reg-aarch-tls") == 0)
11605     return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11606   if (strcmp (section, ".reg-aarch-hw-break") == 0)
11607     return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11608   if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11609     return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
11610   if (strcmp (section, ".reg-aarch-sve") == 0)
11611     return elfcore_write_aarch_sve (abfd, buf, bufsiz, data, size);
11612   if (strcmp (section, ".reg-aarch-pauth") == 0)
11613     return elfcore_write_aarch_pauth (abfd, buf, bufsiz, data, size);
11614   return NULL;
11615 }
11616
11617 static bfd_boolean
11618 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11619                  size_t align)
11620 {
11621   char *p;
11622
11623   /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11624      gABI specifies that PT_NOTE alignment should be aligned to 4
11625      bytes for 32-bit objects and to 8 bytes for 64-bit objects.  If
11626      align is less than 4, we use 4 byte alignment.   */
11627   if (align < 4)
11628     align = 4;
11629   if (align != 4 && align != 8)
11630     return FALSE;
11631
11632   p = buf;
11633   while (p < buf + size)
11634     {
11635       Elf_External_Note *xnp = (Elf_External_Note *) p;
11636       Elf_Internal_Note in;
11637
11638       if (offsetof (Elf_External_Note, name) > buf - p + size)
11639         return FALSE;
11640
11641       in.type = H_GET_32 (abfd, xnp->type);
11642
11643       in.namesz = H_GET_32 (abfd, xnp->namesz);
11644       in.namedata = xnp->name;
11645       if (in.namesz > buf - in.namedata + size)
11646         return FALSE;
11647
11648       in.descsz = H_GET_32 (abfd, xnp->descsz);
11649       in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
11650       in.descpos = offset + (in.descdata - buf);
11651       if (in.descsz != 0
11652           && (in.descdata >= buf + size
11653               || in.descsz > buf - in.descdata + size))
11654         return FALSE;
11655
11656       switch (bfd_get_format (abfd))
11657         {
11658         default:
11659           return TRUE;
11660
11661         case bfd_core:
11662           {
11663 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11664             struct
11665             {
11666               const char * string;
11667               size_t len;
11668               bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
11669             }
11670             grokers[] =
11671             {
11672               GROKER_ELEMENT ("", elfcore_grok_note),
11673               GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
11674               GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11675               GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11676               GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11677               GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
11678             };
11679 #undef GROKER_ELEMENT
11680             int i;
11681
11682             for (i = ARRAY_SIZE (grokers); i--;)
11683               {
11684                 if (in.namesz >= grokers[i].len
11685                     && strncmp (in.namedata, grokers[i].string,
11686                                 grokers[i].len) == 0)
11687                   {
11688                     if (! grokers[i].func (abfd, & in))
11689                       return FALSE;
11690                     break;
11691                   }
11692               }
11693             break;
11694           }
11695
11696         case bfd_object:
11697           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11698             {
11699               if (! elfobj_grok_gnu_note (abfd, &in))
11700                 return FALSE;
11701             }
11702           else if (in.namesz == sizeof "stapsdt"
11703                    && strcmp (in.namedata, "stapsdt") == 0)
11704             {
11705               if (! elfobj_grok_stapsdt_note (abfd, &in))
11706                 return FALSE;
11707             }
11708           break;
11709         }
11710
11711       p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
11712     }
11713
11714   return TRUE;
11715 }
11716
11717 static bfd_boolean
11718 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11719                 size_t align)
11720 {
11721   char *buf;
11722
11723   if (size == 0 || (size + 1) == 0)
11724     return TRUE;
11725
11726   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11727     return FALSE;
11728
11729   buf = (char *) bfd_malloc (size + 1);
11730   if (buf == NULL)
11731     return FALSE;
11732
11733   /* PR 17512: file: ec08f814
11734      0-termintate the buffer so that string searches will not overflow.  */
11735   buf[size] = 0;
11736
11737   if (bfd_bread (buf, size, abfd) != size
11738       || !elf_parse_notes (abfd, buf, size, offset, align))
11739     {
11740       free (buf);
11741       return FALSE;
11742     }
11743
11744   free (buf);
11745   return TRUE;
11746 }
11747 \f
11748 /* Providing external access to the ELF program header table.  */
11749
11750 /* Return an upper bound on the number of bytes required to store a
11751    copy of ABFD's program header table entries.  Return -1 if an error
11752    occurs; bfd_get_error will return an appropriate code.  */
11753
11754 long
11755 bfd_get_elf_phdr_upper_bound (bfd *abfd)
11756 {
11757   if (abfd->xvec->flavour != bfd_target_elf_flavour)
11758     {
11759       bfd_set_error (bfd_error_wrong_format);
11760       return -1;
11761     }
11762
11763   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
11764 }
11765
11766 /* Copy ABFD's program header table entries to *PHDRS.  The entries
11767    will be stored as an array of Elf_Internal_Phdr structures, as
11768    defined in include/elf/internal.h.  To find out how large the
11769    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11770
11771    Return the number of program header table entries read, or -1 if an
11772    error occurs; bfd_get_error will return an appropriate code.  */
11773
11774 int
11775 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
11776 {
11777   int num_phdrs;
11778
11779   if (abfd->xvec->flavour != bfd_target_elf_flavour)
11780     {
11781       bfd_set_error (bfd_error_wrong_format);
11782       return -1;
11783     }
11784
11785   num_phdrs = elf_elfheader (abfd)->e_phnum;
11786   if (num_phdrs != 0)
11787     memcpy (phdrs, elf_tdata (abfd)->phdr,
11788             num_phdrs * sizeof (Elf_Internal_Phdr));
11789
11790   return num_phdrs;
11791 }
11792
11793 enum elf_reloc_type_class
11794 _bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11795                            const asection *rel_sec ATTRIBUTE_UNUSED,
11796                            const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
11797 {
11798   return reloc_class_normal;
11799 }
11800
11801 /* For RELA architectures, return the relocation value for a
11802    relocation against a local symbol.  */
11803
11804 bfd_vma
11805 _bfd_elf_rela_local_sym (bfd *abfd,
11806                          Elf_Internal_Sym *sym,
11807                          asection **psec,
11808                          Elf_Internal_Rela *rel)
11809 {
11810   asection *sec = *psec;
11811   bfd_vma relocation;
11812
11813   relocation = (sec->output_section->vma
11814                 + sec->output_offset
11815                 + sym->st_value);
11816   if ((sec->flags & SEC_MERGE)
11817       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
11818       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
11819     {
11820       rel->r_addend =
11821         _bfd_merged_section_offset (abfd, psec,
11822                                     elf_section_data (sec)->sec_info,
11823                                     sym->st_value + rel->r_addend);
11824       if (sec != *psec)
11825         {
11826           /* If we have changed the section, and our original section is
11827              marked with SEC_EXCLUDE, it means that the original
11828              SEC_MERGE section has been completely subsumed in some
11829              other SEC_MERGE section.  In this case, we need to leave
11830              some info around for --emit-relocs.  */
11831           if ((sec->flags & SEC_EXCLUDE) != 0)
11832             sec->kept_section = *psec;
11833           sec = *psec;
11834         }
11835       rel->r_addend -= relocation;
11836       rel->r_addend += sec->output_section->vma + sec->output_offset;
11837     }
11838   return relocation;
11839 }
11840
11841 bfd_vma
11842 _bfd_elf_rel_local_sym (bfd *abfd,
11843                         Elf_Internal_Sym *sym,
11844                         asection **psec,
11845                         bfd_vma addend)
11846 {
11847   asection *sec = *psec;
11848
11849   if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
11850     return sym->st_value + addend;
11851
11852   return _bfd_merged_section_offset (abfd, psec,
11853                                      elf_section_data (sec)->sec_info,
11854                                      sym->st_value + addend);
11855 }
11856
11857 /* Adjust an address within a section.  Given OFFSET within SEC, return
11858    the new offset within the section, based upon changes made to the
11859    section.  Returns -1 if the offset is now invalid.
11860    The offset (in abnd out) is in target sized bytes, however big a
11861    byte may be.  */
11862
11863 bfd_vma
11864 _bfd_elf_section_offset (bfd *abfd,
11865                          struct bfd_link_info *info,
11866                          asection *sec,
11867                          bfd_vma offset)
11868 {
11869   switch (sec->sec_info_type)
11870     {
11871     case SEC_INFO_TYPE_STABS:
11872       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11873                                        offset);
11874     case SEC_INFO_TYPE_EH_FRAME:
11875       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
11876
11877     default:
11878       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11879         {
11880           /* Reverse the offset.  */
11881           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11882           bfd_size_type address_size = bed->s->arch_size / 8;
11883
11884           /* address_size and sec->size are in octets.  Convert
11885              to bytes before subtracting the original offset.  */
11886           offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
11887         }
11888       return offset;
11889     }
11890 }
11891 \f
11892 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
11893    reconstruct an ELF file by reading the segments out of remote memory
11894    based on the ELF file header at EHDR_VMA and the ELF program headers it
11895    points to.  If not null, *LOADBASEP is filled in with the difference
11896    between the VMAs from which the segments were read, and the VMAs the
11897    file headers (and hence BFD's idea of each section's VMA) put them at.
11898
11899    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11900    remote memory at target address VMA into the local buffer at MYADDR; it
11901    should return zero on success or an `errno' code on failure.  TEMPL must
11902    be a BFD for an ELF target with the word size and byte order found in
11903    the remote memory.  */
11904
11905 bfd *
11906 bfd_elf_bfd_from_remote_memory
11907   (bfd *templ,
11908    bfd_vma ehdr_vma,
11909    bfd_size_type size,
11910    bfd_vma *loadbasep,
11911    int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
11912 {
11913   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
11914     (templ, ehdr_vma, size, loadbasep, target_read_memory);
11915 }
11916 \f
11917 long
11918 _bfd_elf_get_synthetic_symtab (bfd *abfd,
11919                                long symcount ATTRIBUTE_UNUSED,
11920                                asymbol **syms ATTRIBUTE_UNUSED,
11921                                long dynsymcount,
11922                                asymbol **dynsyms,
11923                                asymbol **ret)
11924 {
11925   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11926   asection *relplt;
11927   asymbol *s;
11928   const char *relplt_name;
11929   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11930   arelent *p;
11931   long count, i, n;
11932   size_t size;
11933   Elf_Internal_Shdr *hdr;
11934   char *names;
11935   asection *plt;
11936
11937   *ret = NULL;
11938
11939   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
11940     return 0;
11941
11942   if (dynsymcount <= 0)
11943     return 0;
11944
11945   if (!bed->plt_sym_val)
11946     return 0;
11947
11948   relplt_name = bed->relplt_name;
11949   if (relplt_name == NULL)
11950     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
11951   relplt = bfd_get_section_by_name (abfd, relplt_name);
11952   if (relplt == NULL)
11953     return 0;
11954
11955   hdr = &elf_section_data (relplt)->this_hdr;
11956   if (hdr->sh_link != elf_dynsymtab (abfd)
11957       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
11958     return 0;
11959
11960   plt = bfd_get_section_by_name (abfd, ".plt");
11961   if (plt == NULL)
11962     return 0;
11963
11964   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
11965   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
11966     return -1;
11967
11968   count = relplt->size / hdr->sh_entsize;
11969   size = count * sizeof (asymbol);
11970   p = relplt->relocation;
11971   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11972     {
11973       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
11974       if (p->addend != 0)
11975         {
11976 #ifdef BFD64
11977           size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
11978 #else
11979           size += sizeof ("+0x") - 1 + 8;
11980 #endif
11981         }
11982     }
11983
11984   s = *ret = (asymbol *) bfd_malloc (size);
11985   if (s == NULL)
11986     return -1;
11987
11988   names = (char *) (s + count);
11989   p = relplt->relocation;
11990   n = 0;
11991   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11992     {
11993       size_t len;
11994       bfd_vma addr;
11995
11996       addr = bed->plt_sym_val (i, plt, p);
11997       if (addr == (bfd_vma) -1)
11998         continue;
11999
12000       *s = **p->sym_ptr_ptr;
12001       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
12002          we are defining a symbol, ensure one of them is set.  */
12003       if ((s->flags & BSF_LOCAL) == 0)
12004         s->flags |= BSF_GLOBAL;
12005       s->flags |= BSF_SYNTHETIC;
12006       s->section = plt;
12007       s->value = addr - plt->vma;
12008       s->name = names;
12009       s->udata.p = NULL;
12010       len = strlen ((*p->sym_ptr_ptr)->name);
12011       memcpy (names, (*p->sym_ptr_ptr)->name, len);
12012       names += len;
12013       if (p->addend != 0)
12014         {
12015           char buf[30], *a;
12016
12017           memcpy (names, "+0x", sizeof ("+0x") - 1);
12018           names += sizeof ("+0x") - 1;
12019           bfd_sprintf_vma (abfd, buf, p->addend);
12020           for (a = buf; *a == '0'; ++a)
12021             ;
12022           len = strlen (a);
12023           memcpy (names, a, len);
12024           names += len;
12025         }
12026       memcpy (names, "@plt", sizeof ("@plt"));
12027       names += sizeof ("@plt");
12028       ++s, ++n;
12029     }
12030
12031   return n;
12032 }
12033
12034 /* It is only used by x86-64 so far.
12035    ??? This repeats *COM* id of zero.  sec->id is supposed to be unique,
12036    but current usage would allow all of _bfd_std_section to be zero.  */
12037 static const asymbol lcomm_sym
12038   = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
12039 asection _bfd_elf_large_com_section
12040   = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
12041                       "LARGE_COMMON", 0, SEC_IS_COMMON);
12042
12043 void
12044 _bfd_elf_post_process_headers (bfd * abfd,
12045                                struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
12046 {
12047   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
12048
12049   i_ehdrp = elf_elfheader (abfd);
12050
12051   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
12052
12053   /* To make things simpler for the loader on Linux systems we set the
12054      osabi field to ELFOSABI_GNU if the binary contains symbols of
12055      the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding.  */
12056   if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
12057       && elf_tdata (abfd)->has_gnu_symbols)
12058     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
12059 }
12060
12061
12062 /* Return TRUE for ELF symbol types that represent functions.
12063    This is the default version of this function, which is sufficient for
12064    most targets.  It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC.  */
12065
12066 bfd_boolean
12067 _bfd_elf_is_function_type (unsigned int type)
12068 {
12069   return (type == STT_FUNC
12070           || type == STT_GNU_IFUNC);
12071 }
12072
12073 /* If the ELF symbol SYM might be a function in SEC, return the
12074    function size and set *CODE_OFF to the function's entry point,
12075    otherwise return zero.  */
12076
12077 bfd_size_type
12078 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
12079                              bfd_vma *code_off)
12080 {
12081   bfd_size_type size;
12082
12083   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
12084                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
12085       || sym->section != sec)
12086     return 0;
12087
12088   *code_off = sym->value;
12089   size = 0;
12090   if (!(sym->flags & BSF_SYNTHETIC))
12091     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
12092   if (size == 0)
12093     size = 1;
12094   return size;
12095 }