Another generic ELF target assertion failure
[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           sections_being_created = (bfd_boolean *)
2040             bfd_zalloc2 (abfd, elf_numsections (abfd), sizeof (bfd_boolean));
2041           sections_being_created_abfd = abfd;
2042         }
2043       if (sections_being_created [shindex])
2044         {
2045           _bfd_error_handler
2046             (_("%pB: warning: loop in section dependencies detected"), abfd);
2047           return FALSE;
2048         }
2049       sections_being_created [shindex] = TRUE;
2050     }
2051
2052   hdr = elf_elfsections (abfd)[shindex];
2053   ehdr = elf_elfheader (abfd);
2054   name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
2055                                           hdr->sh_name);
2056   if (name == NULL)
2057     goto fail;
2058
2059   bed = get_elf_backend_data (abfd);
2060   switch (hdr->sh_type)
2061     {
2062     case SHT_NULL:
2063       /* Inactive section. Throw it away.  */
2064       goto success;
2065
2066     case SHT_PROGBITS:          /* Normal section with contents.  */
2067     case SHT_NOBITS:            /* .bss section.  */
2068     case SHT_HASH:              /* .hash section.  */
2069     case SHT_NOTE:              /* .note section.  */
2070     case SHT_INIT_ARRAY:        /* .init_array section.  */
2071     case SHT_FINI_ARRAY:        /* .fini_array section.  */
2072     case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
2073     case SHT_GNU_LIBLIST:       /* .gnu.liblist section.  */
2074     case SHT_GNU_HASH:          /* .gnu.hash section.  */
2075       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2076       goto success;
2077
2078     case SHT_DYNAMIC:   /* Dynamic linking information.  */
2079       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2080         goto fail;
2081
2082       if (hdr->sh_link > elf_numsections (abfd))
2083         {
2084           /* PR 10478: Accept Solaris binaries with a sh_link
2085              field set to SHN_BEFORE or SHN_AFTER.  */
2086           switch (bfd_get_arch (abfd))
2087             {
2088             case bfd_arch_i386:
2089             case bfd_arch_sparc:
2090               if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
2091                   || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
2092                 break;
2093               /* Otherwise fall through.  */
2094             default:
2095               goto fail;
2096             }
2097         }
2098       else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
2099         goto fail;
2100       else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
2101         {
2102           Elf_Internal_Shdr *dynsymhdr;
2103
2104           /* The shared libraries distributed with hpux11 have a bogus
2105              sh_link field for the ".dynamic" section.  Find the
2106              string table for the ".dynsym" section instead.  */
2107           if (elf_dynsymtab (abfd) != 0)
2108             {
2109               dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
2110               hdr->sh_link = dynsymhdr->sh_link;
2111             }
2112           else
2113             {
2114               unsigned int i, num_sec;
2115
2116               num_sec = elf_numsections (abfd);
2117               for (i = 1; i < num_sec; i++)
2118                 {
2119                   dynsymhdr = elf_elfsections (abfd)[i];
2120                   if (dynsymhdr->sh_type == SHT_DYNSYM)
2121                     {
2122                       hdr->sh_link = dynsymhdr->sh_link;
2123                       break;
2124                     }
2125                 }
2126             }
2127         }
2128       goto success;
2129
2130     case SHT_SYMTAB:            /* A symbol table.  */
2131       if (elf_onesymtab (abfd) == shindex)
2132         goto success;
2133
2134       if (hdr->sh_entsize != bed->s->sizeof_sym)
2135         goto fail;
2136
2137       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2138         {
2139           if (hdr->sh_size != 0)
2140             goto fail;
2141           /* Some assemblers erroneously set sh_info to one with a
2142              zero sh_size.  ld sees this as a global symbol count
2143              of (unsigned) -1.  Fix it here.  */
2144           hdr->sh_info = 0;
2145           goto success;
2146         }
2147
2148       /* PR 18854: A binary might contain more than one symbol table.
2149          Unusual, but possible.  Warn, but continue.  */
2150       if (elf_onesymtab (abfd) != 0)
2151         {
2152           _bfd_error_handler
2153             /* xgettext:c-format */
2154             (_("%pB: warning: multiple symbol tables detected"
2155                " - ignoring the table in section %u"),
2156              abfd, shindex);
2157           goto success;
2158         }
2159       elf_onesymtab (abfd) = shindex;
2160       elf_symtab_hdr (abfd) = *hdr;
2161       elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
2162       abfd->flags |= HAS_SYMS;
2163
2164       /* Sometimes a shared object will map in the symbol table.  If
2165          SHF_ALLOC is set, and this is a shared object, then we also
2166          treat this section as a BFD section.  We can not base the
2167          decision purely on SHF_ALLOC, because that flag is sometimes
2168          set in a relocatable object file, which would confuse the
2169          linker.  */
2170       if ((hdr->sh_flags & SHF_ALLOC) != 0
2171           && (abfd->flags & DYNAMIC) != 0
2172           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2173                                                 shindex))
2174         goto fail;
2175
2176       /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2177          can't read symbols without that section loaded as well.  It
2178          is most likely specified by the next section header.  */
2179       {
2180         elf_section_list * entry;
2181         unsigned int i, num_sec;
2182
2183         for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2184           if (entry->hdr.sh_link == shindex)
2185             goto success;
2186
2187         num_sec = elf_numsections (abfd);
2188         for (i = shindex + 1; i < num_sec; i++)
2189           {
2190             Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2191
2192             if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2193                 && hdr2->sh_link == shindex)
2194               break;
2195           }
2196
2197         if (i == num_sec)
2198           for (i = 1; i < shindex; i++)
2199             {
2200               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2201
2202               if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2203                   && hdr2->sh_link == shindex)
2204                 break;
2205             }
2206
2207         if (i != shindex)
2208           ret = bfd_section_from_shdr (abfd, i);
2209         /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2210         goto success;
2211       }
2212
2213     case SHT_DYNSYM:            /* A dynamic symbol table.  */
2214       if (elf_dynsymtab (abfd) == shindex)
2215         goto success;
2216
2217       if (hdr->sh_entsize != bed->s->sizeof_sym)
2218         goto fail;
2219
2220       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2221         {
2222           if (hdr->sh_size != 0)
2223             goto fail;
2224
2225           /* Some linkers erroneously set sh_info to one with a
2226              zero sh_size.  ld sees this as a global symbol count
2227              of (unsigned) -1.  Fix it here.  */
2228           hdr->sh_info = 0;
2229           goto success;
2230         }
2231
2232       /* PR 18854: A binary might contain more than one dynamic symbol table.
2233          Unusual, but possible.  Warn, but continue.  */
2234       if (elf_dynsymtab (abfd) != 0)
2235         {
2236           _bfd_error_handler
2237             /* xgettext:c-format */
2238             (_("%pB: warning: multiple dynamic symbol tables detected"
2239                " - ignoring the table in section %u"),
2240              abfd, shindex);
2241           goto success;
2242         }
2243       elf_dynsymtab (abfd) = shindex;
2244       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
2245       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2246       abfd->flags |= HAS_SYMS;
2247
2248       /* Besides being a symbol table, we also treat this as a regular
2249          section, so that objcopy can handle it.  */
2250       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2251       goto success;
2252
2253     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections.  */
2254       {
2255         elf_section_list * entry;
2256
2257         for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2258           if (entry->ndx == shindex)
2259             goto success;
2260
2261         entry = bfd_alloc (abfd, sizeof (*entry));
2262         if (entry == NULL)
2263           goto fail;
2264         entry->ndx = shindex;
2265         entry->hdr = * hdr;
2266         entry->next = elf_symtab_shndx_list (abfd);
2267         elf_symtab_shndx_list (abfd) = entry;
2268         elf_elfsections (abfd)[shindex] = & entry->hdr;
2269         goto success;
2270       }
2271
2272     case SHT_STRTAB:            /* A string table.  */
2273       if (hdr->bfd_section != NULL)
2274         goto success;
2275
2276       if (ehdr->e_shstrndx == shindex)
2277         {
2278           elf_tdata (abfd)->shstrtab_hdr = *hdr;
2279           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
2280           goto success;
2281         }
2282
2283       if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
2284         {
2285         symtab_strtab:
2286           elf_tdata (abfd)->strtab_hdr = *hdr;
2287           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
2288           goto success;
2289         }
2290
2291       if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2292         {
2293         dynsymtab_strtab:
2294           elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2295           hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2296           elf_elfsections (abfd)[shindex] = hdr;
2297           /* We also treat this as a regular section, so that objcopy
2298              can handle it.  */
2299           ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2300                                                  shindex);
2301           goto success;
2302         }
2303
2304       /* If the string table isn't one of the above, then treat it as a
2305          regular section.  We need to scan all the headers to be sure,
2306          just in case this strtab section appeared before the above.  */
2307       if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2308         {
2309           unsigned int i, num_sec;
2310
2311           num_sec = elf_numsections (abfd);
2312           for (i = 1; i < num_sec; i++)
2313             {
2314               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2315               if (hdr2->sh_link == shindex)
2316                 {
2317                   /* Prevent endless recursion on broken objects.  */
2318                   if (i == shindex)
2319                     goto fail;
2320                   if (! bfd_section_from_shdr (abfd, i))
2321                     goto fail;
2322                   if (elf_onesymtab (abfd) == i)
2323                     goto symtab_strtab;
2324                   if (elf_dynsymtab (abfd) == i)
2325                     goto dynsymtab_strtab;
2326                 }
2327             }
2328         }
2329       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2330       goto success;
2331
2332     case SHT_REL:
2333     case SHT_RELA:
2334       /* *These* do a lot of work -- but build no sections!  */
2335       {
2336         asection *target_sect;
2337         Elf_Internal_Shdr *hdr2, **p_hdr;
2338         unsigned int num_sec = elf_numsections (abfd);
2339         struct bfd_elf_section_data *esdt;
2340
2341         if (hdr->sh_entsize
2342             != (bfd_size_type) (hdr->sh_type == SHT_REL
2343                                 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
2344           goto fail;
2345
2346         /* Check for a bogus link to avoid crashing.  */
2347         if (hdr->sh_link >= num_sec)
2348           {
2349             _bfd_error_handler
2350               /* xgettext:c-format */
2351               (_("%pB: invalid link %u for reloc section %s (index %u)"),
2352                abfd, hdr->sh_link, name, shindex);
2353             ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2354                                                    shindex);
2355             goto success;
2356           }
2357
2358         /* For some incomprehensible reason Oracle distributes
2359            libraries for Solaris in which some of the objects have
2360            bogus sh_link fields.  It would be nice if we could just
2361            reject them, but, unfortunately, some people need to use
2362            them.  We scan through the section headers; if we find only
2363            one suitable symbol table, we clobber the sh_link to point
2364            to it.  I hope this doesn't break anything.
2365
2366            Don't do it on executable nor shared library.  */
2367         if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
2368             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2369             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2370           {
2371             unsigned int scan;
2372             int found;
2373
2374             found = 0;
2375             for (scan = 1; scan < num_sec; scan++)
2376               {
2377                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2378                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2379                   {
2380                     if (found != 0)
2381                       {
2382                         found = 0;
2383                         break;
2384                       }
2385                     found = scan;
2386                   }
2387               }
2388             if (found != 0)
2389               hdr->sh_link = found;
2390           }
2391
2392         /* Get the symbol table.  */
2393         if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2394              || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2395             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2396           goto fail;
2397
2398         /* If this is an alloc section in an executable or shared
2399            library, or the reloc section does not use the main symbol
2400            table we don't treat it as a reloc section.  BFD can't
2401            adequately represent such a section, so at least for now,
2402            we don't try.  We just present it as a normal section.  We
2403            also can't use it as a reloc section if it points to the
2404            null section, an invalid section, another reloc section, or
2405            its sh_link points to the null section.  */
2406         if (((abfd->flags & (DYNAMIC | EXEC_P)) != 0
2407              && (hdr->sh_flags & SHF_ALLOC) != 0)
2408             || hdr->sh_link == SHN_UNDEF
2409             || hdr->sh_link != elf_onesymtab (abfd)
2410             || hdr->sh_info == SHN_UNDEF
2411             || hdr->sh_info >= num_sec
2412             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2413             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2414           {
2415             ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2416                                                    shindex);
2417             goto success;
2418           }
2419
2420         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2421           goto fail;
2422
2423         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2424         if (target_sect == NULL)
2425           goto fail;
2426
2427         esdt = elf_section_data (target_sect);
2428         if (hdr->sh_type == SHT_RELA)
2429           p_hdr = &esdt->rela.hdr;
2430         else
2431           p_hdr = &esdt->rel.hdr;
2432
2433         /* PR 17512: file: 0b4f81b7.  */
2434         if (*p_hdr != NULL)
2435           goto fail;
2436         hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
2437         if (hdr2 == NULL)
2438           goto fail;
2439         *hdr2 = *hdr;
2440         *p_hdr = hdr2;
2441         elf_elfsections (abfd)[shindex] = hdr2;
2442         target_sect->reloc_count += (NUM_SHDR_ENTRIES (hdr)
2443                                      * bed->s->int_rels_per_ext_rel);
2444         target_sect->flags |= SEC_RELOC;
2445         target_sect->relocation = NULL;
2446         target_sect->rel_filepos = hdr->sh_offset;
2447         /* In the section to which the relocations apply, mark whether
2448            its relocations are of the REL or RELA variety.  */
2449         if (hdr->sh_size != 0)
2450           {
2451             if (hdr->sh_type == SHT_RELA)
2452               target_sect->use_rela_p = 1;
2453           }
2454         abfd->flags |= HAS_RELOC;
2455         goto success;
2456       }
2457
2458     case SHT_GNU_verdef:
2459       elf_dynverdef (abfd) = shindex;
2460       elf_tdata (abfd)->dynverdef_hdr = *hdr;
2461       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2462       goto success;
2463
2464     case SHT_GNU_versym:
2465       if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2466         goto fail;
2467
2468       elf_dynversym (abfd) = shindex;
2469       elf_tdata (abfd)->dynversym_hdr = *hdr;
2470       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2471       goto success;
2472
2473     case SHT_GNU_verneed:
2474       elf_dynverref (abfd) = shindex;
2475       elf_tdata (abfd)->dynverref_hdr = *hdr;
2476       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2477       goto success;
2478
2479     case SHT_SHLIB:
2480       goto success;
2481
2482     case SHT_GROUP:
2483       if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
2484         goto fail;
2485
2486       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2487         goto fail;
2488
2489       goto success;
2490
2491     default:
2492       /* Possibly an attributes section.  */
2493       if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2494           || hdr->sh_type == bed->obj_attrs_section_type)
2495         {
2496           if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2497             goto fail;
2498           _bfd_elf_parse_attributes (abfd, hdr);
2499           goto success;
2500         }
2501
2502       /* Check for any processor-specific section types.  */
2503       if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2504         goto success;
2505
2506       if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2507         {
2508           if ((hdr->sh_flags & SHF_ALLOC) != 0)
2509             /* FIXME: How to properly handle allocated section reserved
2510                for applications?  */
2511             _bfd_error_handler
2512               /* xgettext:c-format */
2513               (_("%pB: unknown type [%#x] section `%s'"),
2514                abfd, hdr->sh_type, name);
2515           else
2516             {
2517               /* Allow sections reserved for applications.  */
2518               ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2519                                                      shindex);
2520               goto success;
2521             }
2522         }
2523       else if (hdr->sh_type >= SHT_LOPROC
2524                && hdr->sh_type <= SHT_HIPROC)
2525         /* FIXME: We should handle this section.  */
2526         _bfd_error_handler
2527           /* xgettext:c-format */
2528           (_("%pB: unknown type [%#x] section `%s'"),
2529            abfd, hdr->sh_type, name);
2530       else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2531         {
2532           /* Unrecognised OS-specific sections.  */
2533           if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2534             /* SHF_OS_NONCONFORMING indicates that special knowledge is
2535                required to correctly process the section and the file should
2536                be rejected with an error message.  */
2537             _bfd_error_handler
2538               /* xgettext:c-format */
2539               (_("%pB: unknown type [%#x] section `%s'"),
2540                abfd, hdr->sh_type, name);
2541           else
2542             {
2543               /* Otherwise it should be processed.  */
2544               ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2545               goto success;
2546             }
2547         }
2548       else
2549         /* FIXME: We should handle this section.  */
2550         _bfd_error_handler
2551           /* xgettext:c-format */
2552           (_("%pB: unknown type [%#x] section `%s'"),
2553            abfd, hdr->sh_type, name);
2554
2555       goto fail;
2556     }
2557
2558  fail:
2559   ret = FALSE;
2560  success:
2561   if (sections_being_created && sections_being_created_abfd == abfd)
2562     sections_being_created [shindex] = FALSE;
2563   if (-- nesting == 0)
2564     {
2565       sections_being_created = NULL;
2566       sections_being_created_abfd = abfd;
2567     }
2568   return ret;
2569 }
2570
2571 /* Return the local symbol specified by ABFD, R_SYMNDX.  */
2572
2573 Elf_Internal_Sym *
2574 bfd_sym_from_r_symndx (struct sym_cache *cache,
2575                        bfd *abfd,
2576                        unsigned long r_symndx)
2577 {
2578   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2579
2580   if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2581     {
2582       Elf_Internal_Shdr *symtab_hdr;
2583       unsigned char esym[sizeof (Elf64_External_Sym)];
2584       Elf_External_Sym_Shndx eshndx;
2585
2586       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2587       if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2588                                 &cache->sym[ent], esym, &eshndx) == NULL)
2589         return NULL;
2590
2591       if (cache->abfd != abfd)
2592         {
2593           memset (cache->indx, -1, sizeof (cache->indx));
2594           cache->abfd = abfd;
2595         }
2596       cache->indx[ent] = r_symndx;
2597     }
2598
2599   return &cache->sym[ent];
2600 }
2601
2602 /* Given an ELF section number, retrieve the corresponding BFD
2603    section.  */
2604
2605 asection *
2606 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2607 {
2608   if (sec_index >= elf_numsections (abfd))
2609     return NULL;
2610   return elf_elfsections (abfd)[sec_index]->bfd_section;
2611 }
2612
2613 static const struct bfd_elf_special_section special_sections_b[] =
2614 {
2615   { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2616   { NULL,                   0,  0, 0,            0 }
2617 };
2618
2619 static const struct bfd_elf_special_section special_sections_c[] =
2620 {
2621   { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2622   { NULL,                       0, 0, 0,            0 }
2623 };
2624
2625 static const struct bfd_elf_special_section special_sections_d[] =
2626 {
2627   { STRING_COMMA_LEN (".data"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2628   { STRING_COMMA_LEN (".data1"),         0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2629   /* There are more DWARF sections than these, but they needn't be added here
2630      unless you have to cope with broken compilers that don't emit section
2631      attributes or you want to help the user writing assembler.  */
2632   { STRING_COMMA_LEN (".debug"),         0, SHT_PROGBITS, 0 },
2633   { STRING_COMMA_LEN (".debug_line"),    0, SHT_PROGBITS, 0 },
2634   { STRING_COMMA_LEN (".debug_info"),    0, SHT_PROGBITS, 0 },
2635   { STRING_COMMA_LEN (".debug_abbrev"),  0, SHT_PROGBITS, 0 },
2636   { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2637   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  SHF_ALLOC },
2638   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   SHF_ALLOC },
2639   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   SHF_ALLOC },
2640   { NULL,                      0,        0, 0,            0 }
2641 };
2642
2643 static const struct bfd_elf_special_section special_sections_f[] =
2644 {
2645   { STRING_COMMA_LEN (".fini"),        0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2646   { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2647   { NULL,                          0 , 0, 0,              0 }
2648 };
2649
2650 static const struct bfd_elf_special_section special_sections_g[] =
2651 {
2652   { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS,      SHF_ALLOC + SHF_WRITE },
2653   { STRING_COMMA_LEN (".gnu.lto_"),       -1, SHT_PROGBITS,    SHF_EXCLUDE },
2654   { STRING_COMMA_LEN (".got"),             0, SHT_PROGBITS,    SHF_ALLOC + SHF_WRITE },
2655   { STRING_COMMA_LEN (".gnu.version"),     0, SHT_GNU_versym,  0 },
2656   { STRING_COMMA_LEN (".gnu.version_d"),   0, SHT_GNU_verdef,  0 },
2657   { STRING_COMMA_LEN (".gnu.version_r"),   0, SHT_GNU_verneed, 0 },
2658   { STRING_COMMA_LEN (".gnu.liblist"),     0, SHT_GNU_LIBLIST, SHF_ALLOC },
2659   { STRING_COMMA_LEN (".gnu.conflict"),    0, SHT_RELA,        SHF_ALLOC },
2660   { STRING_COMMA_LEN (".gnu.hash"),        0, SHT_GNU_HASH,    SHF_ALLOC },
2661   { NULL,                        0,        0, 0,               0 }
2662 };
2663
2664 static const struct bfd_elf_special_section special_sections_h[] =
2665 {
2666   { STRING_COMMA_LEN (".hash"), 0, SHT_HASH,     SHF_ALLOC },
2667   { NULL,                    0, 0, 0,            0 }
2668 };
2669
2670 static const struct bfd_elf_special_section special_sections_i[] =
2671 {
2672   { STRING_COMMA_LEN (".init"),        0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2673   { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2674   { STRING_COMMA_LEN (".interp"),      0, SHT_PROGBITS,   0 },
2675   { NULL,                      0,      0, 0,              0 }
2676 };
2677
2678 static const struct bfd_elf_special_section special_sections_l[] =
2679 {
2680   { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2681   { NULL,                    0, 0, 0,            0 }
2682 };
2683
2684 static const struct bfd_elf_special_section special_sections_n[] =
2685 {
2686   { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2687   { STRING_COMMA_LEN (".note"),          -1, SHT_NOTE,     0 },
2688   { NULL,                    0,           0, 0,            0 }
2689 };
2690
2691 static const struct bfd_elf_special_section special_sections_p[] =
2692 {
2693   { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2694   { STRING_COMMA_LEN (".plt"),            0, SHT_PROGBITS,      SHF_ALLOC + SHF_EXECINSTR },
2695   { NULL,                   0,            0, 0,                 0 }
2696 };
2697
2698 static const struct bfd_elf_special_section special_sections_r[] =
2699 {
2700   { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2701   { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2702   { STRING_COMMA_LEN (".rela"),   -1, SHT_RELA,     0 },
2703   { STRING_COMMA_LEN (".rel"),    -1, SHT_REL,      0 },
2704   { NULL,                   0,     0, 0,            0 }
2705 };
2706
2707 static const struct bfd_elf_special_section special_sections_s[] =
2708 {
2709   { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2710   { STRING_COMMA_LEN (".strtab"),   0, SHT_STRTAB, 0 },
2711   { STRING_COMMA_LEN (".symtab"),   0, SHT_SYMTAB, 0 },
2712   /* See struct bfd_elf_special_section declaration for the semantics of
2713      this special case where .prefix_length != strlen (.prefix).  */
2714   { ".stabstr",                 5,  3, SHT_STRTAB, 0 },
2715   { NULL,                       0,  0, 0,          0 }
2716 };
2717
2718 static const struct bfd_elf_special_section special_sections_t[] =
2719 {
2720   { STRING_COMMA_LEN (".text"),  -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2721   { STRING_COMMA_LEN (".tbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2722   { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2723   { NULL,                     0,  0, 0,            0 }
2724 };
2725
2726 static const struct bfd_elf_special_section special_sections_z[] =
2727 {
2728   { STRING_COMMA_LEN (".zdebug_line"),    0, SHT_PROGBITS, 0 },
2729   { STRING_COMMA_LEN (".zdebug_info"),    0, SHT_PROGBITS, 0 },
2730   { STRING_COMMA_LEN (".zdebug_abbrev"),  0, SHT_PROGBITS, 0 },
2731   { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2732   { NULL,                     0,  0, 0,            0 }
2733 };
2734
2735 static const struct bfd_elf_special_section * const special_sections[] =
2736 {
2737   special_sections_b,           /* 'b' */
2738   special_sections_c,           /* 'c' */
2739   special_sections_d,           /* 'd' */
2740   NULL,                         /* 'e' */
2741   special_sections_f,           /* 'f' */
2742   special_sections_g,           /* 'g' */
2743   special_sections_h,           /* 'h' */
2744   special_sections_i,           /* 'i' */
2745   NULL,                         /* 'j' */
2746   NULL,                         /* 'k' */
2747   special_sections_l,           /* 'l' */
2748   NULL,                         /* 'm' */
2749   special_sections_n,           /* 'n' */
2750   NULL,                         /* 'o' */
2751   special_sections_p,           /* 'p' */
2752   NULL,                         /* 'q' */
2753   special_sections_r,           /* 'r' */
2754   special_sections_s,           /* 's' */
2755   special_sections_t,           /* 't' */
2756   NULL,                         /* 'u' */
2757   NULL,                         /* 'v' */
2758   NULL,                         /* 'w' */
2759   NULL,                         /* 'x' */
2760   NULL,                         /* 'y' */
2761   special_sections_z            /* 'z' */
2762 };
2763
2764 const struct bfd_elf_special_section *
2765 _bfd_elf_get_special_section (const char *name,
2766                               const struct bfd_elf_special_section *spec,
2767                               unsigned int rela)
2768 {
2769   int i;
2770   int len;
2771
2772   len = strlen (name);
2773
2774   for (i = 0; spec[i].prefix != NULL; i++)
2775     {
2776       int suffix_len;
2777       int prefix_len = spec[i].prefix_length;
2778
2779       if (len < prefix_len)
2780         continue;
2781       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2782         continue;
2783
2784       suffix_len = spec[i].suffix_length;
2785       if (suffix_len <= 0)
2786         {
2787           if (name[prefix_len] != 0)
2788             {
2789               if (suffix_len == 0)
2790                 continue;
2791               if (name[prefix_len] != '.'
2792                   && (suffix_len == -2
2793                       || (rela && spec[i].type == SHT_REL)))
2794                 continue;
2795             }
2796         }
2797       else
2798         {
2799           if (len < prefix_len + suffix_len)
2800             continue;
2801           if (memcmp (name + len - suffix_len,
2802                       spec[i].prefix + prefix_len,
2803                       suffix_len) != 0)
2804             continue;
2805         }
2806       return &spec[i];
2807     }
2808
2809   return NULL;
2810 }
2811
2812 const struct bfd_elf_special_section *
2813 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2814 {
2815   int i;
2816   const struct bfd_elf_special_section *spec;
2817   const struct elf_backend_data *bed;
2818
2819   /* See if this is one of the special sections.  */
2820   if (sec->name == NULL)
2821     return NULL;
2822
2823   bed = get_elf_backend_data (abfd);
2824   spec = bed->special_sections;
2825   if (spec)
2826     {
2827       spec = _bfd_elf_get_special_section (sec->name,
2828                                            bed->special_sections,
2829                                            sec->use_rela_p);
2830       if (spec != NULL)
2831         return spec;
2832     }
2833
2834   if (sec->name[0] != '.')
2835     return NULL;
2836
2837   i = sec->name[1] - 'b';
2838   if (i < 0 || i > 'z' - 'b')
2839     return NULL;
2840
2841   spec = special_sections[i];
2842
2843   if (spec == NULL)
2844     return NULL;
2845
2846   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2847 }
2848
2849 bfd_boolean
2850 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2851 {
2852   struct bfd_elf_section_data *sdata;
2853   const struct elf_backend_data *bed;
2854   const struct bfd_elf_special_section *ssect;
2855
2856   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2857   if (sdata == NULL)
2858     {
2859       sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2860                                                           sizeof (*sdata));
2861       if (sdata == NULL)
2862         return FALSE;
2863       sec->used_by_bfd = sdata;
2864     }
2865
2866   /* Indicate whether or not this section should use RELA relocations.  */
2867   bed = get_elf_backend_data (abfd);
2868   sec->use_rela_p = bed->default_use_rela_p;
2869
2870   /* When we read a file, we don't need to set ELF section type and
2871      flags.  They will be overridden in _bfd_elf_make_section_from_shdr
2872      anyway.  We will set ELF section type and flags for all linker
2873      created sections.  If user specifies BFD section flags, we will
2874      set ELF section type and flags based on BFD section flags in
2875      elf_fake_sections.  Special handling for .init_array/.fini_array
2876      output sections since they may contain .ctors/.dtors input
2877      sections.  We don't want _bfd_elf_init_private_section_data to
2878      copy ELF section type from .ctors/.dtors input sections.  */
2879   if (abfd->direction != read_direction
2880       || (sec->flags & SEC_LINKER_CREATED) != 0)
2881     {
2882       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2883       if (ssect != NULL
2884           && (!sec->flags
2885               || (sec->flags & SEC_LINKER_CREATED) != 0
2886               || ssect->type == SHT_INIT_ARRAY
2887               || ssect->type == SHT_FINI_ARRAY))
2888         {
2889           elf_section_type (sec) = ssect->type;
2890           elf_section_flags (sec) = ssect->attr;
2891         }
2892     }
2893
2894   return _bfd_generic_new_section_hook (abfd, sec);
2895 }
2896
2897 /* Create a new bfd section from an ELF program header.
2898
2899    Since program segments have no names, we generate a synthetic name
2900    of the form segment<NUM>, where NUM is generally the index in the
2901    program header table.  For segments that are split (see below) we
2902    generate the names segment<NUM>a and segment<NUM>b.
2903
2904    Note that some program segments may have a file size that is different than
2905    (less than) the memory size.  All this means is that at execution the
2906    system must allocate the amount of memory specified by the memory size,
2907    but only initialize it with the first "file size" bytes read from the
2908    file.  This would occur for example, with program segments consisting
2909    of combined data+bss.
2910
2911    To handle the above situation, this routine generates TWO bfd sections
2912    for the single program segment.  The first has the length specified by
2913    the file size of the segment, and the second has the length specified
2914    by the difference between the two sizes.  In effect, the segment is split
2915    into its initialized and uninitialized parts.
2916
2917  */
2918
2919 bfd_boolean
2920 _bfd_elf_make_section_from_phdr (bfd *abfd,
2921                                  Elf_Internal_Phdr *hdr,
2922                                  int hdr_index,
2923                                  const char *type_name)
2924 {
2925   asection *newsect;
2926   char *name;
2927   char namebuf[64];
2928   size_t len;
2929   int split;
2930
2931   split = ((hdr->p_memsz > 0)
2932             && (hdr->p_filesz > 0)
2933             && (hdr->p_memsz > hdr->p_filesz));
2934
2935   if (hdr->p_filesz > 0)
2936     {
2937       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2938       len = strlen (namebuf) + 1;
2939       name = (char *) bfd_alloc (abfd, len);
2940       if (!name)
2941         return FALSE;
2942       memcpy (name, namebuf, len);
2943       newsect = bfd_make_section (abfd, name);
2944       if (newsect == NULL)
2945         return FALSE;
2946       newsect->vma = hdr->p_vaddr;
2947       newsect->lma = hdr->p_paddr;
2948       newsect->size = hdr->p_filesz;
2949       newsect->filepos = hdr->p_offset;
2950       newsect->flags |= SEC_HAS_CONTENTS;
2951       newsect->alignment_power = bfd_log2 (hdr->p_align);
2952       if (hdr->p_type == PT_LOAD)
2953         {
2954           newsect->flags |= SEC_ALLOC;
2955           newsect->flags |= SEC_LOAD;
2956           if (hdr->p_flags & PF_X)
2957             {
2958               /* FIXME: all we known is that it has execute PERMISSION,
2959                  may be data.  */
2960               newsect->flags |= SEC_CODE;
2961             }
2962         }
2963       if (!(hdr->p_flags & PF_W))
2964         {
2965           newsect->flags |= SEC_READONLY;
2966         }
2967     }
2968
2969   if (hdr->p_memsz > hdr->p_filesz)
2970     {
2971       bfd_vma align;
2972
2973       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2974       len = strlen (namebuf) + 1;
2975       name = (char *) bfd_alloc (abfd, len);
2976       if (!name)
2977         return FALSE;
2978       memcpy (name, namebuf, len);
2979       newsect = bfd_make_section (abfd, name);
2980       if (newsect == NULL)
2981         return FALSE;
2982       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2983       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2984       newsect->size = hdr->p_memsz - hdr->p_filesz;
2985       newsect->filepos = hdr->p_offset + hdr->p_filesz;
2986       align = newsect->vma & -newsect->vma;
2987       if (align == 0 || align > hdr->p_align)
2988         align = hdr->p_align;
2989       newsect->alignment_power = bfd_log2 (align);
2990       if (hdr->p_type == PT_LOAD)
2991         {
2992           /* Hack for gdb.  Segments that have not been modified do
2993              not have their contents written to a core file, on the
2994              assumption that a debugger can find the contents in the
2995              executable.  We flag this case by setting the fake
2996              section size to zero.  Note that "real" bss sections will
2997              always have their contents dumped to the core file.  */
2998           if (bfd_get_format (abfd) == bfd_core)
2999             newsect->size = 0;
3000           newsect->flags |= SEC_ALLOC;
3001           if (hdr->p_flags & PF_X)
3002             newsect->flags |= SEC_CODE;
3003         }
3004       if (!(hdr->p_flags & PF_W))
3005         newsect->flags |= SEC_READONLY;
3006     }
3007
3008   return TRUE;
3009 }
3010
3011 bfd_boolean
3012 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
3013 {
3014   const struct elf_backend_data *bed;
3015
3016   switch (hdr->p_type)
3017     {
3018     case PT_NULL:
3019       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
3020
3021     case PT_LOAD:
3022       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
3023
3024     case PT_DYNAMIC:
3025       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
3026
3027     case PT_INTERP:
3028       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
3029
3030     case PT_NOTE:
3031       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
3032         return FALSE;
3033       if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz,
3034                             hdr->p_align))
3035         return FALSE;
3036       return TRUE;
3037
3038     case PT_SHLIB:
3039       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
3040
3041     case PT_PHDR:
3042       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
3043
3044     case PT_GNU_EH_FRAME:
3045       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
3046                                               "eh_frame_hdr");
3047
3048     case PT_GNU_STACK:
3049       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
3050
3051     case PT_GNU_RELRO:
3052       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
3053
3054     default:
3055       /* Check for any processor-specific program segment types.  */
3056       bed = get_elf_backend_data (abfd);
3057       return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
3058     }
3059 }
3060
3061 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3062    REL or RELA.  */
3063
3064 Elf_Internal_Shdr *
3065 _bfd_elf_single_rel_hdr (asection *sec)
3066 {
3067   if (elf_section_data (sec)->rel.hdr)
3068     {
3069       BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
3070       return elf_section_data (sec)->rel.hdr;
3071     }
3072   else
3073     return elf_section_data (sec)->rela.hdr;
3074 }
3075
3076 static bfd_boolean
3077 _bfd_elf_set_reloc_sh_name (bfd *abfd,
3078                             Elf_Internal_Shdr *rel_hdr,
3079                             const char *sec_name,
3080                             bfd_boolean use_rela_p)
3081 {
3082   char *name = (char *) bfd_alloc (abfd,
3083                                    sizeof ".rela" + strlen (sec_name));
3084   if (name == NULL)
3085     return FALSE;
3086
3087   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
3088   rel_hdr->sh_name =
3089     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
3090                                         FALSE);
3091   if (rel_hdr->sh_name == (unsigned int) -1)
3092     return FALSE;
3093
3094   return TRUE;
3095 }
3096
3097 /* Allocate and initialize a section-header for a new reloc section,
3098    containing relocations against ASECT.  It is stored in RELDATA.  If
3099    USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3100    relocations.  */
3101
3102 static bfd_boolean
3103 _bfd_elf_init_reloc_shdr (bfd *abfd,
3104                           struct bfd_elf_section_reloc_data *reldata,
3105                           const char *sec_name,
3106                           bfd_boolean use_rela_p,
3107                           bfd_boolean delay_st_name_p)
3108 {
3109   Elf_Internal_Shdr *rel_hdr;
3110   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3111
3112   BFD_ASSERT (reldata->hdr == NULL);
3113   rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
3114   reldata->hdr = rel_hdr;
3115
3116   if (delay_st_name_p)
3117     rel_hdr->sh_name = (unsigned int) -1;
3118   else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
3119                                         use_rela_p))
3120     return FALSE;
3121   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
3122   rel_hdr->sh_entsize = (use_rela_p
3123                          ? bed->s->sizeof_rela
3124                          : bed->s->sizeof_rel);
3125   rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
3126   rel_hdr->sh_flags = 0;
3127   rel_hdr->sh_addr = 0;
3128   rel_hdr->sh_size = 0;
3129   rel_hdr->sh_offset = 0;
3130
3131   return TRUE;
3132 }
3133
3134 /* Return the default section type based on the passed in section flags.  */
3135
3136 int
3137 bfd_elf_get_default_section_type (flagword flags)
3138 {
3139   if ((flags & (SEC_ALLOC | SEC_IS_COMMON)) != 0
3140       && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3141     return SHT_NOBITS;
3142   return SHT_PROGBITS;
3143 }
3144
3145 struct fake_section_arg
3146 {
3147   struct bfd_link_info *link_info;
3148   bfd_boolean failed;
3149 };
3150
3151 /* Set up an ELF internal section header for a section.  */
3152
3153 static void
3154 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
3155 {
3156   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
3157   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3158   struct bfd_elf_section_data *esd = elf_section_data (asect);
3159   Elf_Internal_Shdr *this_hdr;
3160   unsigned int sh_type;
3161   const char *name = asect->name;
3162   bfd_boolean delay_st_name_p = FALSE;
3163
3164   if (arg->failed)
3165     {
3166       /* We already failed; just get out of the bfd_map_over_sections
3167          loop.  */
3168       return;
3169     }
3170
3171   this_hdr = &esd->this_hdr;
3172
3173   if (arg->link_info)
3174     {
3175       /* ld: compress DWARF debug sections with names: .debug_*.  */
3176       if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
3177           && (asect->flags & SEC_DEBUGGING)
3178           && name[1] == 'd'
3179           && name[6] == '_')
3180         {
3181           /* Set SEC_ELF_COMPRESS to indicate this section should be
3182              compressed.  */
3183           asect->flags |= SEC_ELF_COMPRESS;
3184
3185           /* If this section will be compressed, delay adding section
3186              name to section name section after it is compressed in
3187              _bfd_elf_assign_file_positions_for_non_load.  */
3188           delay_st_name_p = TRUE;
3189         }
3190     }
3191   else if ((asect->flags & SEC_ELF_RENAME))
3192     {
3193       /* objcopy: rename output DWARF debug section.  */
3194       if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
3195         {
3196           /* When we decompress or compress with SHF_COMPRESSED,
3197              convert section name from .zdebug_* to .debug_* if
3198              needed.  */
3199           if (name[1] == 'z')
3200             {
3201               char *new_name = convert_zdebug_to_debug (abfd, name);
3202               if (new_name == NULL)
3203                 {
3204                   arg->failed = TRUE;
3205                   return;
3206                 }
3207               name = new_name;
3208             }
3209         }
3210       else if (asect->compress_status == COMPRESS_SECTION_DONE)
3211         {
3212           /* PR binutils/18087: Compression does not always make a
3213              section smaller.  So only rename the section when
3214              compression has actually taken place.  If input section
3215              name is .zdebug_*, we should never compress it again.  */
3216           char *new_name = convert_debug_to_zdebug (abfd, name);
3217           if (new_name == NULL)
3218             {
3219               arg->failed = TRUE;
3220               return;
3221             }
3222           BFD_ASSERT (name[1] != 'z');
3223           name = new_name;
3224         }
3225     }
3226
3227   if (delay_st_name_p)
3228     this_hdr->sh_name = (unsigned int) -1;
3229   else
3230     {
3231       this_hdr->sh_name
3232         = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3233                                               name, FALSE);
3234       if (this_hdr->sh_name == (unsigned int) -1)
3235         {
3236           arg->failed = TRUE;
3237           return;
3238         }
3239     }
3240
3241   /* Don't clear sh_flags. Assembler may set additional bits.  */
3242
3243   if ((asect->flags & SEC_ALLOC) != 0
3244       || asect->user_set_vma)
3245     this_hdr->sh_addr = asect->vma;
3246   else
3247     this_hdr->sh_addr = 0;
3248
3249   this_hdr->sh_offset = 0;
3250   this_hdr->sh_size = asect->size;
3251   this_hdr->sh_link = 0;
3252   /* PR 17512: file: 0eb809fe, 8b0535ee.  */
3253   if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
3254     {
3255       _bfd_error_handler
3256         /* xgettext:c-format */
3257         (_("%pB: error: alignment power %d of section `%pA' is too big"),
3258          abfd, asect->alignment_power, asect);
3259       arg->failed = TRUE;
3260       return;
3261     }
3262   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
3263   /* The sh_entsize and sh_info fields may have been set already by
3264      copy_private_section_data.  */
3265
3266   this_hdr->bfd_section = asect;
3267   this_hdr->contents = NULL;
3268
3269   /* If the section type is unspecified, we set it based on
3270      asect->flags.  */
3271   if ((asect->flags & SEC_GROUP) != 0)
3272     sh_type = SHT_GROUP;
3273   else
3274     sh_type = bfd_elf_get_default_section_type (asect->flags);
3275
3276   if (this_hdr->sh_type == SHT_NULL)
3277     this_hdr->sh_type = sh_type;
3278   else if (this_hdr->sh_type == SHT_NOBITS
3279            && sh_type == SHT_PROGBITS
3280            && (asect->flags & SEC_ALLOC) != 0)
3281     {
3282       /* Warn if we are changing a NOBITS section to PROGBITS, but
3283          allow the link to proceed.  This can happen when users link
3284          non-bss input sections to bss output sections, or emit data
3285          to a bss output section via a linker script.  */
3286       _bfd_error_handler
3287         (_("warning: section `%pA' type changed to PROGBITS"), asect);
3288       this_hdr->sh_type = sh_type;
3289     }
3290
3291   switch (this_hdr->sh_type)
3292     {
3293     default:
3294       break;
3295
3296     case SHT_STRTAB:
3297     case SHT_NOTE:
3298     case SHT_NOBITS:
3299     case SHT_PROGBITS:
3300       break;
3301
3302     case SHT_INIT_ARRAY:
3303     case SHT_FINI_ARRAY:
3304     case SHT_PREINIT_ARRAY:
3305       this_hdr->sh_entsize = bed->s->arch_size / 8;
3306       break;
3307
3308     case SHT_HASH:
3309       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
3310       break;
3311
3312     case SHT_DYNSYM:
3313       this_hdr->sh_entsize = bed->s->sizeof_sym;
3314       break;
3315
3316     case SHT_DYNAMIC:
3317       this_hdr->sh_entsize = bed->s->sizeof_dyn;
3318       break;
3319
3320     case SHT_RELA:
3321       if (get_elf_backend_data (abfd)->may_use_rela_p)
3322         this_hdr->sh_entsize = bed->s->sizeof_rela;
3323       break;
3324
3325      case SHT_REL:
3326       if (get_elf_backend_data (abfd)->may_use_rel_p)
3327         this_hdr->sh_entsize = bed->s->sizeof_rel;
3328       break;
3329
3330      case SHT_GNU_versym:
3331       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
3332       break;
3333
3334      case SHT_GNU_verdef:
3335       this_hdr->sh_entsize = 0;
3336       /* objcopy or strip will copy over sh_info, but may not set
3337          cverdefs.  The linker will set cverdefs, but sh_info will be
3338          zero.  */
3339       if (this_hdr->sh_info == 0)
3340         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
3341       else
3342         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
3343                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
3344       break;
3345
3346     case SHT_GNU_verneed:
3347       this_hdr->sh_entsize = 0;
3348       /* objcopy or strip will copy over sh_info, but may not set
3349          cverrefs.  The linker will set cverrefs, but sh_info will be
3350          zero.  */
3351       if (this_hdr->sh_info == 0)
3352         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
3353       else
3354         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
3355                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
3356       break;
3357
3358     case SHT_GROUP:
3359       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
3360       break;
3361
3362     case SHT_GNU_HASH:
3363       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
3364       break;
3365     }
3366
3367   if ((asect->flags & SEC_ALLOC) != 0)
3368     this_hdr->sh_flags |= SHF_ALLOC;
3369   if ((asect->flags & SEC_READONLY) == 0)
3370     this_hdr->sh_flags |= SHF_WRITE;
3371   if ((asect->flags & SEC_CODE) != 0)
3372     this_hdr->sh_flags |= SHF_EXECINSTR;
3373   if ((asect->flags & SEC_MERGE) != 0)
3374     {
3375       this_hdr->sh_flags |= SHF_MERGE;
3376       this_hdr->sh_entsize = asect->entsize;
3377     }
3378   if ((asect->flags & SEC_STRINGS) != 0)
3379     this_hdr->sh_flags |= SHF_STRINGS;
3380   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
3381     this_hdr->sh_flags |= SHF_GROUP;
3382   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
3383     {
3384       this_hdr->sh_flags |= SHF_TLS;
3385       if (asect->size == 0
3386           && (asect->flags & SEC_HAS_CONTENTS) == 0)
3387         {
3388           struct bfd_link_order *o = asect->map_tail.link_order;
3389
3390           this_hdr->sh_size = 0;
3391           if (o != NULL)
3392             {
3393               this_hdr->sh_size = o->offset + o->size;
3394               if (this_hdr->sh_size != 0)
3395                 this_hdr->sh_type = SHT_NOBITS;
3396             }
3397         }
3398     }
3399   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
3400     this_hdr->sh_flags |= SHF_EXCLUDE;
3401
3402   /* If the section has relocs, set up a section header for the
3403      SHT_REL[A] section.  If two relocation sections are required for
3404      this section, it is up to the processor-specific back-end to
3405      create the other.  */
3406   if ((asect->flags & SEC_RELOC) != 0)
3407     {
3408       /* When doing a relocatable link, create both REL and RELA sections if
3409          needed.  */
3410       if (arg->link_info
3411           /* Do the normal setup if we wouldn't create any sections here.  */
3412           && esd->rel.count + esd->rela.count > 0
3413           && (bfd_link_relocatable (arg->link_info)
3414               || arg->link_info->emitrelocations))
3415         {
3416           if (esd->rel.count && esd->rel.hdr == NULL
3417               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name,
3418                                             FALSE, delay_st_name_p))
3419             {
3420               arg->failed = TRUE;
3421               return;
3422             }
3423           if (esd->rela.count && esd->rela.hdr == NULL
3424               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name,
3425                                             TRUE, delay_st_name_p))
3426             {
3427               arg->failed = TRUE;
3428               return;
3429             }
3430         }
3431       else if (!_bfd_elf_init_reloc_shdr (abfd,
3432                                           (asect->use_rela_p
3433                                            ? &esd->rela : &esd->rel),
3434                                           name,
3435                                           asect->use_rela_p,
3436                                           delay_st_name_p))
3437         {
3438           arg->failed = TRUE;
3439           return;
3440         }
3441     }
3442
3443   /* Check for processor-specific section types.  */
3444   sh_type = this_hdr->sh_type;
3445   if (bed->elf_backend_fake_sections
3446       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
3447     {
3448       arg->failed = TRUE;
3449       return;
3450     }
3451
3452   if (sh_type == SHT_NOBITS && asect->size != 0)
3453     {
3454       /* Don't change the header type from NOBITS if we are being
3455          called for objcopy --only-keep-debug.  */
3456       this_hdr->sh_type = sh_type;
3457     }
3458 }
3459
3460 /* Fill in the contents of a SHT_GROUP section.  Called from
3461    _bfd_elf_compute_section_file_positions for gas, objcopy, and
3462    when ELF targets use the generic linker, ld.  Called for ld -r
3463    from bfd_elf_final_link.  */
3464
3465 void
3466 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
3467 {
3468   bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
3469   asection *elt, *first;
3470   unsigned char *loc;
3471   bfd_boolean gas;
3472
3473   /* Ignore linker created group section.  See elfNN_ia64_object_p in
3474      elfxx-ia64.c.  */
3475   if ((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP
3476       || sec->size == 0
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_malloc2 (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 #if SIZEOF_LONG == SIZEOF_INT
8277   if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
8278     {
8279       bfd_set_error (bfd_error_file_too_big);
8280       return -1;
8281     }
8282 #endif
8283   return (asect->reloc_count + 1) * sizeof (arelent *);
8284 }
8285
8286 /* Canonicalize the relocs.  */
8287
8288 long
8289 _bfd_elf_canonicalize_reloc (bfd *abfd,
8290                              sec_ptr section,
8291                              arelent **relptr,
8292                              asymbol **symbols)
8293 {
8294   arelent *tblptr;
8295   unsigned int i;
8296   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8297
8298   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
8299     return -1;
8300
8301   tblptr = section->relocation;
8302   for (i = 0; i < section->reloc_count; i++)
8303     *relptr++ = tblptr++;
8304
8305   *relptr = NULL;
8306
8307   return section->reloc_count;
8308 }
8309
8310 long
8311 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
8312 {
8313   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8314   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
8315
8316   if (symcount >= 0)
8317     bfd_get_symcount (abfd) = symcount;
8318   return symcount;
8319 }
8320
8321 long
8322 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8323                                       asymbol **allocation)
8324 {
8325   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8326   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
8327
8328   if (symcount >= 0)
8329     bfd_get_dynamic_symcount (abfd) = symcount;
8330   return symcount;
8331 }
8332
8333 /* Return the size required for the dynamic reloc entries.  Any loadable
8334    section that was actually installed in the BFD, and has type SHT_REL
8335    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8336    dynamic reloc section.  */
8337
8338 long
8339 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
8340 {
8341   bfd_size_type count;
8342   asection *s;
8343
8344   if (elf_dynsymtab (abfd) == 0)
8345     {
8346       bfd_set_error (bfd_error_invalid_operation);
8347       return -1;
8348     }
8349
8350   count = 1;
8351   for (s = abfd->sections; s != NULL; s = s->next)
8352     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8353         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8354             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8355       {
8356         count += s->size / elf_section_data (s)->this_hdr.sh_entsize;
8357         if (count > LONG_MAX / sizeof (arelent *))
8358           {
8359             bfd_set_error (bfd_error_file_too_big);
8360             return -1;
8361           }
8362       }
8363   return count * sizeof (arelent *);
8364 }
8365
8366 /* Canonicalize the dynamic relocation entries.  Note that we return the
8367    dynamic relocations as a single block, although they are actually
8368    associated with particular sections; the interface, which was
8369    designed for SunOS style shared libraries, expects that there is only
8370    one set of dynamic relocs.  Any loadable section that was actually
8371    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8372    dynamic symbol table, is considered to be a dynamic reloc section.  */
8373
8374 long
8375 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8376                                      arelent **storage,
8377                                      asymbol **syms)
8378 {
8379   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8380   asection *s;
8381   long ret;
8382
8383   if (elf_dynsymtab (abfd) == 0)
8384     {
8385       bfd_set_error (bfd_error_invalid_operation);
8386       return -1;
8387     }
8388
8389   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8390   ret = 0;
8391   for (s = abfd->sections; s != NULL; s = s->next)
8392     {
8393       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8394           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8395               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8396         {
8397           arelent *p;
8398           long count, i;
8399
8400           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
8401             return -1;
8402           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
8403           p = s->relocation;
8404           for (i = 0; i < count; i++)
8405             *storage++ = p++;
8406           ret += count;
8407         }
8408     }
8409
8410   *storage = NULL;
8411
8412   return ret;
8413 }
8414 \f
8415 /* Read in the version information.  */
8416
8417 bfd_boolean
8418 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
8419 {
8420   bfd_byte *contents = NULL;
8421   unsigned int freeidx = 0;
8422
8423   if (elf_dynverref (abfd) != 0)
8424     {
8425       Elf_Internal_Shdr *hdr;
8426       Elf_External_Verneed *everneed;
8427       Elf_Internal_Verneed *iverneed;
8428       unsigned int i;
8429       bfd_byte *contents_end;
8430
8431       hdr = &elf_tdata (abfd)->dynverref_hdr;
8432
8433       if (hdr->sh_info == 0
8434           || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
8435         {
8436 error_return_bad_verref:
8437           _bfd_error_handler
8438             (_("%pB: .gnu.version_r invalid entry"), abfd);
8439           bfd_set_error (bfd_error_bad_value);
8440 error_return_verref:
8441           elf_tdata (abfd)->verref = NULL;
8442           elf_tdata (abfd)->cverrefs = 0;
8443           goto error_return;
8444         }
8445
8446       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8447       if (contents == NULL)
8448         goto error_return_verref;
8449
8450       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8451           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8452         goto error_return_verref;
8453
8454       elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
8455         bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
8456
8457       if (elf_tdata (abfd)->verref == NULL)
8458         goto error_return_verref;
8459
8460       BFD_ASSERT (sizeof (Elf_External_Verneed)
8461                   == sizeof (Elf_External_Vernaux));
8462       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
8463       everneed = (Elf_External_Verneed *) contents;
8464       iverneed = elf_tdata (abfd)->verref;
8465       for (i = 0; i < hdr->sh_info; i++, iverneed++)
8466         {
8467           Elf_External_Vernaux *evernaux;
8468           Elf_Internal_Vernaux *ivernaux;
8469           unsigned int j;
8470
8471           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8472
8473           iverneed->vn_bfd = abfd;
8474
8475           iverneed->vn_filename =
8476             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8477                                              iverneed->vn_file);
8478           if (iverneed->vn_filename == NULL)
8479             goto error_return_bad_verref;
8480
8481           if (iverneed->vn_cnt == 0)
8482             iverneed->vn_auxptr = NULL;
8483           else
8484             {
8485               iverneed->vn_auxptr = (struct elf_internal_vernaux *)
8486                   bfd_alloc2 (abfd, iverneed->vn_cnt,
8487                               sizeof (Elf_Internal_Vernaux));
8488               if (iverneed->vn_auxptr == NULL)
8489                 goto error_return_verref;
8490             }
8491
8492           if (iverneed->vn_aux
8493               > (size_t) (contents_end - (bfd_byte *) everneed))
8494             goto error_return_bad_verref;
8495
8496           evernaux = ((Elf_External_Vernaux *)
8497                       ((bfd_byte *) everneed + iverneed->vn_aux));
8498           ivernaux = iverneed->vn_auxptr;
8499           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8500             {
8501               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8502
8503               ivernaux->vna_nodename =
8504                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8505                                                  ivernaux->vna_name);
8506               if (ivernaux->vna_nodename == NULL)
8507                 goto error_return_bad_verref;
8508
8509               if (ivernaux->vna_other > freeidx)
8510                 freeidx = ivernaux->vna_other;
8511
8512               ivernaux->vna_nextptr = NULL;
8513               if (ivernaux->vna_next == 0)
8514                 {
8515                   iverneed->vn_cnt = j + 1;
8516                   break;
8517                 }
8518               if (j + 1 < iverneed->vn_cnt)
8519                 ivernaux->vna_nextptr = ivernaux + 1;
8520
8521               if (ivernaux->vna_next
8522                   > (size_t) (contents_end - (bfd_byte *) evernaux))
8523                 goto error_return_bad_verref;
8524
8525               evernaux = ((Elf_External_Vernaux *)
8526                           ((bfd_byte *) evernaux + ivernaux->vna_next));
8527             }
8528
8529           iverneed->vn_nextref = NULL;
8530           if (iverneed->vn_next == 0)
8531             break;
8532           if (i + 1 < hdr->sh_info)
8533             iverneed->vn_nextref = iverneed + 1;
8534
8535           if (iverneed->vn_next
8536               > (size_t) (contents_end - (bfd_byte *) everneed))
8537             goto error_return_bad_verref;
8538
8539           everneed = ((Elf_External_Verneed *)
8540                       ((bfd_byte *) everneed + iverneed->vn_next));
8541         }
8542       elf_tdata (abfd)->cverrefs = i;
8543
8544       free (contents);
8545       contents = NULL;
8546     }
8547
8548   if (elf_dynverdef (abfd) != 0)
8549     {
8550       Elf_Internal_Shdr *hdr;
8551       Elf_External_Verdef *everdef;
8552       Elf_Internal_Verdef *iverdef;
8553       Elf_Internal_Verdef *iverdefarr;
8554       Elf_Internal_Verdef iverdefmem;
8555       unsigned int i;
8556       unsigned int maxidx;
8557       bfd_byte *contents_end_def, *contents_end_aux;
8558
8559       hdr = &elf_tdata (abfd)->dynverdef_hdr;
8560
8561       if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8562         {
8563         error_return_bad_verdef:
8564           _bfd_error_handler
8565             (_("%pB: .gnu.version_d invalid entry"), abfd);
8566           bfd_set_error (bfd_error_bad_value);
8567         error_return_verdef:
8568           elf_tdata (abfd)->verdef = NULL;
8569           elf_tdata (abfd)->cverdefs = 0;
8570           goto error_return;
8571         }
8572
8573       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8574       if (contents == NULL)
8575         goto error_return_verdef;
8576       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8577           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8578         goto error_return_verdef;
8579
8580       BFD_ASSERT (sizeof (Elf_External_Verdef)
8581                   >= sizeof (Elf_External_Verdaux));
8582       contents_end_def = contents + hdr->sh_size
8583                          - sizeof (Elf_External_Verdef);
8584       contents_end_aux = contents + hdr->sh_size
8585                          - sizeof (Elf_External_Verdaux);
8586
8587       /* We know the number of entries in the section but not the maximum
8588          index.  Therefore we have to run through all entries and find
8589          the maximum.  */
8590       everdef = (Elf_External_Verdef *) contents;
8591       maxidx = 0;
8592       for (i = 0; i < hdr->sh_info; ++i)
8593         {
8594           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8595
8596           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8597             goto error_return_bad_verdef;
8598           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8599             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
8600
8601           if (iverdefmem.vd_next == 0)
8602             break;
8603
8604           if (iverdefmem.vd_next
8605               > (size_t) (contents_end_def - (bfd_byte *) everdef))
8606             goto error_return_bad_verdef;
8607
8608           everdef = ((Elf_External_Verdef *)
8609                      ((bfd_byte *) everdef + iverdefmem.vd_next));
8610         }
8611
8612       if (default_imported_symver)
8613         {
8614           if (freeidx > maxidx)
8615             maxidx = ++freeidx;
8616           else
8617             freeidx = ++maxidx;
8618         }
8619
8620       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8621         bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
8622       if (elf_tdata (abfd)->verdef == NULL)
8623         goto error_return_verdef;
8624
8625       elf_tdata (abfd)->cverdefs = maxidx;
8626
8627       everdef = (Elf_External_Verdef *) contents;
8628       iverdefarr = elf_tdata (abfd)->verdef;
8629       for (i = 0; i < hdr->sh_info; i++)
8630         {
8631           Elf_External_Verdaux *everdaux;
8632           Elf_Internal_Verdaux *iverdaux;
8633           unsigned int j;
8634
8635           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8636
8637           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
8638             goto error_return_bad_verdef;
8639
8640           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
8641           memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
8642
8643           iverdef->vd_bfd = abfd;
8644
8645           if (iverdef->vd_cnt == 0)
8646             iverdef->vd_auxptr = NULL;
8647           else
8648             {
8649               iverdef->vd_auxptr = (struct elf_internal_verdaux *)
8650                   bfd_alloc2 (abfd, iverdef->vd_cnt,
8651                               sizeof (Elf_Internal_Verdaux));
8652               if (iverdef->vd_auxptr == NULL)
8653                 goto error_return_verdef;
8654             }
8655
8656           if (iverdef->vd_aux
8657               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
8658             goto error_return_bad_verdef;
8659
8660           everdaux = ((Elf_External_Verdaux *)
8661                       ((bfd_byte *) everdef + iverdef->vd_aux));
8662           iverdaux = iverdef->vd_auxptr;
8663           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8664             {
8665               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8666
8667               iverdaux->vda_nodename =
8668                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8669                                                  iverdaux->vda_name);
8670               if (iverdaux->vda_nodename == NULL)
8671                 goto error_return_bad_verdef;
8672
8673               iverdaux->vda_nextptr = NULL;
8674               if (iverdaux->vda_next == 0)
8675                 {
8676                   iverdef->vd_cnt = j + 1;
8677                   break;
8678                 }
8679               if (j + 1 < iverdef->vd_cnt)
8680                 iverdaux->vda_nextptr = iverdaux + 1;
8681
8682               if (iverdaux->vda_next
8683                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
8684                 goto error_return_bad_verdef;
8685
8686               everdaux = ((Elf_External_Verdaux *)
8687                           ((bfd_byte *) everdaux + iverdaux->vda_next));
8688             }
8689
8690           iverdef->vd_nodename = NULL;
8691           if (iverdef->vd_cnt)
8692             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
8693
8694           iverdef->vd_nextdef = NULL;
8695           if (iverdef->vd_next == 0)
8696             break;
8697           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
8698             iverdef->vd_nextdef = iverdef + 1;
8699
8700           everdef = ((Elf_External_Verdef *)
8701                      ((bfd_byte *) everdef + iverdef->vd_next));
8702         }
8703
8704       free (contents);
8705       contents = NULL;
8706     }
8707   else if (default_imported_symver)
8708     {
8709       if (freeidx < 3)
8710         freeidx = 3;
8711       else
8712         freeidx++;
8713
8714       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8715           bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
8716       if (elf_tdata (abfd)->verdef == NULL)
8717         goto error_return;
8718
8719       elf_tdata (abfd)->cverdefs = freeidx;
8720     }
8721
8722   /* Create a default version based on the soname.  */
8723   if (default_imported_symver)
8724     {
8725       Elf_Internal_Verdef *iverdef;
8726       Elf_Internal_Verdaux *iverdaux;
8727
8728       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
8729
8730       iverdef->vd_version = VER_DEF_CURRENT;
8731       iverdef->vd_flags = 0;
8732       iverdef->vd_ndx = freeidx;
8733       iverdef->vd_cnt = 1;
8734
8735       iverdef->vd_bfd = abfd;
8736
8737       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8738       if (iverdef->vd_nodename == NULL)
8739         goto error_return_verdef;
8740       iverdef->vd_nextdef = NULL;
8741       iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8742                             bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
8743       if (iverdef->vd_auxptr == NULL)
8744         goto error_return_verdef;
8745
8746       iverdaux = iverdef->vd_auxptr;
8747       iverdaux->vda_nodename = iverdef->vd_nodename;
8748     }
8749
8750   return TRUE;
8751
8752  error_return:
8753   if (contents != NULL)
8754     free (contents);
8755   return FALSE;
8756 }
8757 \f
8758 asymbol *
8759 _bfd_elf_make_empty_symbol (bfd *abfd)
8760 {
8761   elf_symbol_type *newsym;
8762
8763   newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (*newsym));
8764   if (!newsym)
8765     return NULL;
8766   newsym->symbol.the_bfd = abfd;
8767   return &newsym->symbol;
8768 }
8769
8770 void
8771 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8772                           asymbol *symbol,
8773                           symbol_info *ret)
8774 {
8775   bfd_symbol_info (symbol, ret);
8776 }
8777
8778 /* Return whether a symbol name implies a local symbol.  Most targets
8779    use this function for the is_local_label_name entry point, but some
8780    override it.  */
8781
8782 bfd_boolean
8783 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8784                               const char *name)
8785 {
8786   /* Normal local symbols start with ``.L''.  */
8787   if (name[0] == '.' && name[1] == 'L')
8788     return TRUE;
8789
8790   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8791      DWARF debugging symbols starting with ``..''.  */
8792   if (name[0] == '.' && name[1] == '.')
8793     return TRUE;
8794
8795   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8796      emitting DWARF debugging output.  I suspect this is actually a
8797      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8798      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8799      underscore to be emitted on some ELF targets).  For ease of use,
8800      we treat such symbols as local.  */
8801   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
8802     return TRUE;
8803
8804   /* Treat assembler generated fake symbols, dollar local labels and
8805      forward-backward labels (aka local labels) as locals.
8806      These labels have the form:
8807
8808        L0^A.*                                  (fake symbols)
8809
8810        [.]?L[0123456789]+{^A|^B}[0123456789]*  (local labels)
8811
8812      Versions which start with .L will have already been matched above,
8813      so we only need to match the rest.  */
8814   if (name[0] == 'L' && ISDIGIT (name[1]))
8815     {
8816       bfd_boolean ret = FALSE;
8817       const char * p;
8818       char c;
8819
8820       for (p = name + 2; (c = *p); p++)
8821         {
8822           if (c == 1 || c == 2)
8823             {
8824               if (c == 1 && p == name + 2)
8825                 /* A fake symbol.  */
8826                 return TRUE;
8827
8828               /* FIXME: We are being paranoid here and treating symbols like
8829                  L0^Bfoo as if there were non-local, on the grounds that the
8830                  assembler will never generate them.  But can any symbol
8831                  containing an ASCII value in the range 1-31 ever be anything
8832                  other than some kind of local ?  */
8833               ret = TRUE;
8834             }
8835
8836           if (! ISDIGIT (c))
8837             {
8838               ret = FALSE;
8839               break;
8840             }
8841         }
8842       return ret;
8843     }
8844
8845   return FALSE;
8846 }
8847
8848 alent *
8849 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8850                      asymbol *symbol ATTRIBUTE_UNUSED)
8851 {
8852   abort ();
8853   return NULL;
8854 }
8855
8856 bfd_boolean
8857 _bfd_elf_set_arch_mach (bfd *abfd,
8858                         enum bfd_architecture arch,
8859                         unsigned long machine)
8860 {
8861   /* If this isn't the right architecture for this backend, and this
8862      isn't the generic backend, fail.  */
8863   if (arch != get_elf_backend_data (abfd)->arch
8864       && arch != bfd_arch_unknown
8865       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
8866     return FALSE;
8867
8868   return bfd_default_set_arch_mach (abfd, arch, machine);
8869 }
8870
8871 /* Find the nearest line to a particular section and offset,
8872    for error reporting.  */
8873
8874 bfd_boolean
8875 _bfd_elf_find_nearest_line (bfd *abfd,
8876                             asymbol **symbols,
8877                             asection *section,
8878                             bfd_vma offset,
8879                             const char **filename_ptr,
8880                             const char **functionname_ptr,
8881                             unsigned int *line_ptr,
8882                             unsigned int *discriminator_ptr)
8883 {
8884   bfd_boolean found;
8885
8886   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
8887                                      filename_ptr, functionname_ptr,
8888                                      line_ptr, discriminator_ptr,
8889                                      dwarf_debug_sections, 0,
8890                                      &elf_tdata (abfd)->dwarf2_find_line_info)
8891       || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8892                                         filename_ptr, functionname_ptr,
8893                                         line_ptr))
8894     {
8895       if (!*functionname_ptr)
8896         _bfd_elf_find_function (abfd, symbols, section, offset,
8897                                 *filename_ptr ? NULL : filename_ptr,
8898                                 functionname_ptr);
8899       return TRUE;
8900     }
8901
8902   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
8903                                              &found, filename_ptr,
8904                                              functionname_ptr, line_ptr,
8905                                              &elf_tdata (abfd)->line_info))
8906     return FALSE;
8907   if (found && (*functionname_ptr || *line_ptr))
8908     return TRUE;
8909
8910   if (symbols == NULL)
8911     return FALSE;
8912
8913   if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8914                                 filename_ptr, functionname_ptr))
8915     return FALSE;
8916
8917   *line_ptr = 0;
8918   return TRUE;
8919 }
8920
8921 /* Find the line for a symbol.  */
8922
8923 bfd_boolean
8924 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8925                     const char **filename_ptr, unsigned int *line_ptr)
8926 {
8927   return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8928                                         filename_ptr, NULL, line_ptr, NULL,
8929                                         dwarf_debug_sections, 0,
8930                                         &elf_tdata (abfd)->dwarf2_find_line_info);
8931 }
8932
8933 /* After a call to bfd_find_nearest_line, successive calls to
8934    bfd_find_inliner_info can be used to get source information about
8935    each level of function inlining that terminated at the address
8936    passed to bfd_find_nearest_line.  Currently this is only supported
8937    for DWARF2 with appropriate DWARF3 extensions. */
8938
8939 bfd_boolean
8940 _bfd_elf_find_inliner_info (bfd *abfd,
8941                             const char **filename_ptr,
8942                             const char **functionname_ptr,
8943                             unsigned int *line_ptr)
8944 {
8945   bfd_boolean found;
8946   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8947                                          functionname_ptr, line_ptr,
8948                                          & elf_tdata (abfd)->dwarf2_find_line_info);
8949   return found;
8950 }
8951
8952 int
8953 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
8954 {
8955   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8956   int ret = bed->s->sizeof_ehdr;
8957
8958   if (!bfd_link_relocatable (info))
8959     {
8960       bfd_size_type phdr_size = elf_program_header_size (abfd);
8961
8962       if (phdr_size == (bfd_size_type) -1)
8963         {
8964           struct elf_segment_map *m;
8965
8966           phdr_size = 0;
8967           for (m = elf_seg_map (abfd); m != NULL; m = m->next)
8968             phdr_size += bed->s->sizeof_phdr;
8969
8970           if (phdr_size == 0)
8971             phdr_size = get_program_header_size (abfd, info);
8972         }
8973
8974       elf_program_header_size (abfd) = phdr_size;
8975       ret += phdr_size;
8976     }
8977
8978   return ret;
8979 }
8980
8981 bfd_boolean
8982 _bfd_elf_set_section_contents (bfd *abfd,
8983                                sec_ptr section,
8984                                const void *location,
8985                                file_ptr offset,
8986                                bfd_size_type count)
8987 {
8988   Elf_Internal_Shdr *hdr;
8989   file_ptr pos;
8990
8991   if (! abfd->output_has_begun
8992       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
8993     return FALSE;
8994
8995   if (!count)
8996     return TRUE;
8997
8998   hdr = &elf_section_data (section)->this_hdr;
8999   if (hdr->sh_offset == (file_ptr) -1)
9000     {
9001       /* We must compress this section.  Write output to the buffer.  */
9002       unsigned char *contents = hdr->contents;
9003       if ((offset + count) > hdr->sh_size
9004           || (section->flags & SEC_ELF_COMPRESS) == 0
9005           || contents == NULL)
9006         abort ();
9007       memcpy (contents + offset, location, count);
9008       return TRUE;
9009     }
9010   pos = hdr->sh_offset + offset;
9011   if (bfd_seek (abfd, pos, SEEK_SET) != 0
9012       || bfd_bwrite (location, count, abfd) != count)
9013     return FALSE;
9014
9015   return TRUE;
9016 }
9017
9018 bfd_boolean
9019 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
9020                            arelent *cache_ptr ATTRIBUTE_UNUSED,
9021                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
9022 {
9023   abort ();
9024   return FALSE;
9025 }
9026
9027 /* Try to convert a non-ELF reloc into an ELF one.  */
9028
9029 bfd_boolean
9030 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
9031 {
9032   /* Check whether we really have an ELF howto.  */
9033
9034   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
9035     {
9036       bfd_reloc_code_real_type code;
9037       reloc_howto_type *howto;
9038
9039       /* Alien reloc: Try to determine its type to replace it with an
9040          equivalent ELF reloc.  */
9041
9042       if (areloc->howto->pc_relative)
9043         {
9044           switch (areloc->howto->bitsize)
9045             {
9046             case 8:
9047               code = BFD_RELOC_8_PCREL;
9048               break;
9049             case 12:
9050               code = BFD_RELOC_12_PCREL;
9051               break;
9052             case 16:
9053               code = BFD_RELOC_16_PCREL;
9054               break;
9055             case 24:
9056               code = BFD_RELOC_24_PCREL;
9057               break;
9058             case 32:
9059               code = BFD_RELOC_32_PCREL;
9060               break;
9061             case 64:
9062               code = BFD_RELOC_64_PCREL;
9063               break;
9064             default:
9065               goto fail;
9066             }
9067
9068           howto = bfd_reloc_type_lookup (abfd, code);
9069
9070           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
9071             {
9072               if (howto->pcrel_offset)
9073                 areloc->addend += areloc->address;
9074               else
9075                 areloc->addend -= areloc->address; /* addend is unsigned!! */
9076             }
9077         }
9078       else
9079         {
9080           switch (areloc->howto->bitsize)
9081             {
9082             case 8:
9083               code = BFD_RELOC_8;
9084               break;
9085             case 14:
9086               code = BFD_RELOC_14;
9087               break;
9088             case 16:
9089               code = BFD_RELOC_16;
9090               break;
9091             case 26:
9092               code = BFD_RELOC_26;
9093               break;
9094             case 32:
9095               code = BFD_RELOC_32;
9096               break;
9097             case 64:
9098               code = BFD_RELOC_64;
9099               break;
9100             default:
9101               goto fail;
9102             }
9103
9104           howto = bfd_reloc_type_lookup (abfd, code);
9105         }
9106
9107       if (howto)
9108         areloc->howto = howto;
9109       else
9110         goto fail;
9111     }
9112
9113   return TRUE;
9114
9115  fail:
9116   /* xgettext:c-format */
9117   _bfd_error_handler (_("%pB: %s unsupported"),
9118                       abfd, areloc->howto->name);
9119   bfd_set_error (bfd_error_bad_value);
9120   return FALSE;
9121 }
9122
9123 bfd_boolean
9124 _bfd_elf_close_and_cleanup (bfd *abfd)
9125 {
9126   struct elf_obj_tdata *tdata = elf_tdata (abfd);
9127   if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
9128     {
9129       if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
9130         _bfd_elf_strtab_free (elf_shstrtab (abfd));
9131       _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
9132     }
9133
9134   return _bfd_generic_close_and_cleanup (abfd);
9135 }
9136
9137 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9138    in the relocation's offset.  Thus we cannot allow any sort of sanity
9139    range-checking to interfere.  There is nothing else to do in processing
9140    this reloc.  */
9141
9142 bfd_reloc_status_type
9143 _bfd_elf_rel_vtable_reloc_fn
9144   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
9145    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
9146    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
9147    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
9148 {
9149   return bfd_reloc_ok;
9150 }
9151 \f
9152 /* Elf core file support.  Much of this only works on native
9153    toolchains, since we rely on knowing the
9154    machine-dependent procfs structure in order to pick
9155    out details about the corefile.  */
9156
9157 #ifdef HAVE_SYS_PROCFS_H
9158 /* Needed for new procfs interface on sparc-solaris.  */
9159 # define _STRUCTURED_PROC 1
9160 # include <sys/procfs.h>
9161 #endif
9162
9163 /* Return a PID that identifies a "thread" for threaded cores, or the
9164    PID of the main process for non-threaded cores.  */
9165
9166 static int
9167 elfcore_make_pid (bfd *abfd)
9168 {
9169   int pid;
9170
9171   pid = elf_tdata (abfd)->core->lwpid;
9172   if (pid == 0)
9173     pid = elf_tdata (abfd)->core->pid;
9174
9175   return pid;
9176 }
9177
9178 /* If there isn't a section called NAME, make one, using
9179    data from SECT.  Note, this function will generate a
9180    reference to NAME, so you shouldn't deallocate or
9181    overwrite it.  */
9182
9183 static bfd_boolean
9184 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
9185 {
9186   asection *sect2;
9187
9188   if (bfd_get_section_by_name (abfd, name) != NULL)
9189     return TRUE;
9190
9191   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
9192   if (sect2 == NULL)
9193     return FALSE;
9194
9195   sect2->size = sect->size;
9196   sect2->filepos = sect->filepos;
9197   sect2->alignment_power = sect->alignment_power;
9198   return TRUE;
9199 }
9200
9201 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
9202    actually creates up to two pseudosections:
9203    - For the single-threaded case, a section named NAME, unless
9204      such a section already exists.
9205    - For the multi-threaded case, a section named "NAME/PID", where
9206      PID is elfcore_make_pid (abfd).
9207    Both pseudosections have identical contents.  */
9208 bfd_boolean
9209 _bfd_elfcore_make_pseudosection (bfd *abfd,
9210                                  char *name,
9211                                  size_t size,
9212                                  ufile_ptr filepos)
9213 {
9214   char buf[100];
9215   char *threaded_name;
9216   size_t len;
9217   asection *sect;
9218
9219   /* Build the section name.  */
9220
9221   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
9222   len = strlen (buf) + 1;
9223   threaded_name = (char *) bfd_alloc (abfd, len);
9224   if (threaded_name == NULL)
9225     return FALSE;
9226   memcpy (threaded_name, buf, len);
9227
9228   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9229                                              SEC_HAS_CONTENTS);
9230   if (sect == NULL)
9231     return FALSE;
9232   sect->size = size;
9233   sect->filepos = filepos;
9234   sect->alignment_power = 2;
9235
9236   return elfcore_maybe_make_sect (abfd, name, sect);
9237 }
9238
9239 /* prstatus_t exists on:
9240      solaris 2.5+
9241      linux 2.[01] + glibc
9242      unixware 4.2
9243 */
9244
9245 #if defined (HAVE_PRSTATUS_T)
9246
9247 static bfd_boolean
9248 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
9249 {
9250   size_t size;
9251   int offset;
9252
9253   if (note->descsz == sizeof (prstatus_t))
9254     {
9255       prstatus_t prstat;
9256
9257       size = sizeof (prstat.pr_reg);
9258       offset   = offsetof (prstatus_t, pr_reg);
9259       memcpy (&prstat, note->descdata, sizeof (prstat));
9260
9261       /* Do not overwrite the core signal if it
9262          has already been set by another thread.  */
9263       if (elf_tdata (abfd)->core->signal == 0)
9264         elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9265       if (elf_tdata (abfd)->core->pid == 0)
9266         elf_tdata (abfd)->core->pid = prstat.pr_pid;
9267
9268       /* pr_who exists on:
9269          solaris 2.5+
9270          unixware 4.2
9271          pr_who doesn't exist on:
9272          linux 2.[01]
9273          */
9274 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9275       elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9276 #else
9277       elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9278 #endif
9279     }
9280 #if defined (HAVE_PRSTATUS32_T)
9281   else if (note->descsz == sizeof (prstatus32_t))
9282     {
9283       /* 64-bit host, 32-bit corefile */
9284       prstatus32_t prstat;
9285
9286       size = sizeof (prstat.pr_reg);
9287       offset   = offsetof (prstatus32_t, pr_reg);
9288       memcpy (&prstat, note->descdata, sizeof (prstat));
9289
9290       /* Do not overwrite the core signal if it
9291          has already been set by another thread.  */
9292       if (elf_tdata (abfd)->core->signal == 0)
9293         elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9294       if (elf_tdata (abfd)->core->pid == 0)
9295         elf_tdata (abfd)->core->pid = prstat.pr_pid;
9296
9297       /* pr_who exists on:
9298          solaris 2.5+
9299          unixware 4.2
9300          pr_who doesn't exist on:
9301          linux 2.[01]
9302          */
9303 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9304       elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9305 #else
9306       elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9307 #endif
9308     }
9309 #endif /* HAVE_PRSTATUS32_T */
9310   else
9311     {
9312       /* Fail - we don't know how to handle any other
9313          note size (ie. data object type).  */
9314       return TRUE;
9315     }
9316
9317   /* Make a ".reg/999" section and a ".reg" section.  */
9318   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9319                                           size, note->descpos + offset);
9320 }
9321 #endif /* defined (HAVE_PRSTATUS_T) */
9322
9323 /* Create a pseudosection containing the exact contents of NOTE.  */
9324 static bfd_boolean
9325 elfcore_make_note_pseudosection (bfd *abfd,
9326                                  char *name,
9327                                  Elf_Internal_Note *note)
9328 {
9329   return _bfd_elfcore_make_pseudosection (abfd, name,
9330                                           note->descsz, note->descpos);
9331 }
9332
9333 /* There isn't a consistent prfpregset_t across platforms,
9334    but it doesn't matter, because we don't have to pick this
9335    data structure apart.  */
9336
9337 static bfd_boolean
9338 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
9339 {
9340   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9341 }
9342
9343 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9344    type of NT_PRXFPREG.  Just include the whole note's contents
9345    literally.  */
9346
9347 static bfd_boolean
9348 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
9349 {
9350   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9351 }
9352
9353 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9354    with a note type of NT_X86_XSTATE.  Just include the whole note's
9355    contents literally.  */
9356
9357 static bfd_boolean
9358 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9359 {
9360   return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9361 }
9362
9363 static bfd_boolean
9364 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9365 {
9366   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9367 }
9368
9369 static bfd_boolean
9370 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9371 {
9372   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9373 }
9374
9375 static bfd_boolean
9376 elfcore_grok_ppc_tar (bfd *abfd, Elf_Internal_Note *note)
9377 {
9378   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tar", note);
9379 }
9380
9381 static bfd_boolean
9382 elfcore_grok_ppc_ppr (bfd *abfd, Elf_Internal_Note *note)
9383 {
9384   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ppr", note);
9385 }
9386
9387 static bfd_boolean
9388 elfcore_grok_ppc_dscr (bfd *abfd, Elf_Internal_Note *note)
9389 {
9390   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-dscr", note);
9391 }
9392
9393 static bfd_boolean
9394 elfcore_grok_ppc_ebb (bfd *abfd, Elf_Internal_Note *note)
9395 {
9396   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ebb", note);
9397 }
9398
9399 static bfd_boolean
9400 elfcore_grok_ppc_pmu (bfd *abfd, Elf_Internal_Note *note)
9401 {
9402   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-pmu", note);
9403 }
9404
9405 static bfd_boolean
9406 elfcore_grok_ppc_tm_cgpr (bfd *abfd, Elf_Internal_Note *note)
9407 {
9408   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cgpr", note);
9409 }
9410
9411 static bfd_boolean
9412 elfcore_grok_ppc_tm_cfpr (bfd *abfd, Elf_Internal_Note *note)
9413 {
9414   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cfpr", note);
9415 }
9416
9417 static bfd_boolean
9418 elfcore_grok_ppc_tm_cvmx (bfd *abfd, Elf_Internal_Note *note)
9419 {
9420   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvmx", note);
9421 }
9422
9423 static bfd_boolean
9424 elfcore_grok_ppc_tm_cvsx (bfd *abfd, Elf_Internal_Note *note)
9425 {
9426   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvsx", note);
9427 }
9428
9429 static bfd_boolean
9430 elfcore_grok_ppc_tm_spr (bfd *abfd, Elf_Internal_Note *note)
9431 {
9432   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-spr", note);
9433 }
9434
9435 static bfd_boolean
9436 elfcore_grok_ppc_tm_ctar (bfd *abfd, Elf_Internal_Note *note)
9437 {
9438   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-ctar", note);
9439 }
9440
9441 static bfd_boolean
9442 elfcore_grok_ppc_tm_cppr (bfd *abfd, Elf_Internal_Note *note)
9443 {
9444   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cppr", note);
9445 }
9446
9447 static bfd_boolean
9448 elfcore_grok_ppc_tm_cdscr (bfd *abfd, Elf_Internal_Note *note)
9449 {
9450   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cdscr", note);
9451 }
9452
9453 static bfd_boolean
9454 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9455 {
9456   return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9457 }
9458
9459 static bfd_boolean
9460 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9461 {
9462   return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9463 }
9464
9465 static bfd_boolean
9466 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9467 {
9468   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9469 }
9470
9471 static bfd_boolean
9472 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9473 {
9474   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9475 }
9476
9477 static bfd_boolean
9478 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9479 {
9480   return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9481 }
9482
9483 static bfd_boolean
9484 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9485 {
9486   return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9487 }
9488
9489 static bfd_boolean
9490 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9491 {
9492   return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9493 }
9494
9495 static bfd_boolean
9496 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9497 {
9498   return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9499 }
9500
9501 static bfd_boolean
9502 elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9503 {
9504   return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9505 }
9506
9507 static bfd_boolean
9508 elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9509 {
9510   return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9511 }
9512
9513 static bfd_boolean
9514 elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9515 {
9516   return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9517 }
9518
9519 static bfd_boolean
9520 elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9521 {
9522   return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9523 }
9524
9525 static bfd_boolean
9526 elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9527 {
9528   return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9529 }
9530
9531 static bfd_boolean
9532 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9533 {
9534   return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9535 }
9536
9537 static bfd_boolean
9538 elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9539 {
9540   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9541 }
9542
9543 static bfd_boolean
9544 elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9545 {
9546   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9547 }
9548
9549 static bfd_boolean
9550 elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9551 {
9552   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9553 }
9554
9555 static bfd_boolean
9556 elfcore_grok_aarch_sve (bfd *abfd, Elf_Internal_Note *note)
9557 {
9558   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-sve", note);
9559 }
9560
9561 static bfd_boolean
9562 elfcore_grok_aarch_pauth (bfd *abfd, Elf_Internal_Note *note)
9563 {
9564   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-pauth", note);
9565 }
9566
9567 #if defined (HAVE_PRPSINFO_T)
9568 typedef prpsinfo_t   elfcore_psinfo_t;
9569 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
9570 typedef prpsinfo32_t elfcore_psinfo32_t;
9571 #endif
9572 #endif
9573
9574 #if defined (HAVE_PSINFO_T)
9575 typedef psinfo_t   elfcore_psinfo_t;
9576 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
9577 typedef psinfo32_t elfcore_psinfo32_t;
9578 #endif
9579 #endif
9580
9581 /* return a malloc'ed copy of a string at START which is at
9582    most MAX bytes long, possibly without a terminating '\0'.
9583    the copy will always have a terminating '\0'.  */
9584
9585 char *
9586 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
9587 {
9588   char *dups;
9589   char *end = (char *) memchr (start, '\0', max);
9590   size_t len;
9591
9592   if (end == NULL)
9593     len = max;
9594   else
9595     len = end - start;
9596
9597   dups = (char *) bfd_alloc (abfd, len + 1);
9598   if (dups == NULL)
9599     return NULL;
9600
9601   memcpy (dups, start, len);
9602   dups[len] = '\0';
9603
9604   return dups;
9605 }
9606
9607 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9608 static bfd_boolean
9609 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
9610 {
9611   if (note->descsz == sizeof (elfcore_psinfo_t))
9612     {
9613       elfcore_psinfo_t psinfo;
9614
9615       memcpy (&psinfo, note->descdata, sizeof (psinfo));
9616
9617 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9618       elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9619 #endif
9620       elf_tdata (abfd)->core->program
9621         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9622                                 sizeof (psinfo.pr_fname));
9623
9624       elf_tdata (abfd)->core->command
9625         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9626                                 sizeof (psinfo.pr_psargs));
9627     }
9628 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9629   else if (note->descsz == sizeof (elfcore_psinfo32_t))
9630     {
9631       /* 64-bit host, 32-bit corefile */
9632       elfcore_psinfo32_t psinfo;
9633
9634       memcpy (&psinfo, note->descdata, sizeof (psinfo));
9635
9636 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9637       elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9638 #endif
9639       elf_tdata (abfd)->core->program
9640         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9641                                 sizeof (psinfo.pr_fname));
9642
9643       elf_tdata (abfd)->core->command
9644         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9645                                 sizeof (psinfo.pr_psargs));
9646     }
9647 #endif
9648
9649   else
9650     {
9651       /* Fail - we don't know how to handle any other
9652          note size (ie. data object type).  */
9653       return TRUE;
9654     }
9655
9656   /* Note that for some reason, a spurious space is tacked
9657      onto the end of the args in some (at least one anyway)
9658      implementations, so strip it off if it exists.  */
9659
9660   {
9661     char *command = elf_tdata (abfd)->core->command;
9662     int n = strlen (command);
9663
9664     if (0 < n && command[n - 1] == ' ')
9665       command[n - 1] = '\0';
9666   }
9667
9668   return TRUE;
9669 }
9670 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9671
9672 #if defined (HAVE_PSTATUS_T)
9673 static bfd_boolean
9674 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
9675 {
9676   if (note->descsz == sizeof (pstatus_t)
9677 #if defined (HAVE_PXSTATUS_T)
9678       || note->descsz == sizeof (pxstatus_t)
9679 #endif
9680       )
9681     {
9682       pstatus_t pstat;
9683
9684       memcpy (&pstat, note->descdata, sizeof (pstat));
9685
9686       elf_tdata (abfd)->core->pid = pstat.pr_pid;
9687     }
9688 #if defined (HAVE_PSTATUS32_T)
9689   else if (note->descsz == sizeof (pstatus32_t))
9690     {
9691       /* 64-bit host, 32-bit corefile */
9692       pstatus32_t pstat;
9693
9694       memcpy (&pstat, note->descdata, sizeof (pstat));
9695
9696       elf_tdata (abfd)->core->pid = pstat.pr_pid;
9697     }
9698 #endif
9699   /* Could grab some more details from the "representative"
9700      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9701      NT_LWPSTATUS note, presumably.  */
9702
9703   return TRUE;
9704 }
9705 #endif /* defined (HAVE_PSTATUS_T) */
9706
9707 #if defined (HAVE_LWPSTATUS_T)
9708 static bfd_boolean
9709 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
9710 {
9711   lwpstatus_t lwpstat;
9712   char buf[100];
9713   char *name;
9714   size_t len;
9715   asection *sect;
9716
9717   if (note->descsz != sizeof (lwpstat)
9718 #if defined (HAVE_LWPXSTATUS_T)
9719       && note->descsz != sizeof (lwpxstatus_t)
9720 #endif
9721       )
9722     return TRUE;
9723
9724   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9725
9726   elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
9727   /* Do not overwrite the core signal if it has already been set by
9728      another thread.  */
9729   if (elf_tdata (abfd)->core->signal == 0)
9730     elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
9731
9732   /* Make a ".reg/999" section.  */
9733
9734   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
9735   len = strlen (buf) + 1;
9736   name = bfd_alloc (abfd, len);
9737   if (name == NULL)
9738     return FALSE;
9739   memcpy (name, buf, len);
9740
9741   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9742   if (sect == NULL)
9743     return FALSE;
9744
9745 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9746   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
9747   sect->filepos = note->descpos
9748     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9749 #endif
9750
9751 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9752   sect->size = sizeof (lwpstat.pr_reg);
9753   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9754 #endif
9755
9756   sect->alignment_power = 2;
9757
9758   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
9759     return FALSE;
9760
9761   /* Make a ".reg2/999" section */
9762
9763   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
9764   len = strlen (buf) + 1;
9765   name = bfd_alloc (abfd, len);
9766   if (name == NULL)
9767     return FALSE;
9768   memcpy (name, buf, len);
9769
9770   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9771   if (sect == NULL)
9772     return FALSE;
9773
9774 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9775   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
9776   sect->filepos = note->descpos
9777     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9778 #endif
9779
9780 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9781   sect->size = sizeof (lwpstat.pr_fpreg);
9782   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9783 #endif
9784
9785   sect->alignment_power = 2;
9786
9787   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
9788 }
9789 #endif /* defined (HAVE_LWPSTATUS_T) */
9790
9791 static bfd_boolean
9792 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
9793 {
9794   char buf[30];
9795   char *name;
9796   size_t len;
9797   asection *sect;
9798   int type;
9799   int is_active_thread;
9800   bfd_vma base_addr;
9801
9802   if (note->descsz < 728)
9803     return TRUE;
9804
9805   if (! CONST_STRNEQ (note->namedata, "win32"))
9806     return TRUE;
9807
9808   type = bfd_get_32 (abfd, note->descdata);
9809
9810   switch (type)
9811     {
9812     case 1 /* NOTE_INFO_PROCESS */:
9813       /* FIXME: need to add ->core->command.  */
9814       /* process_info.pid */
9815       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
9816       /* process_info.signal */
9817       elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
9818       break;
9819
9820     case 2 /* NOTE_INFO_THREAD */:
9821       /* Make a ".reg/999" section.  */
9822       /* thread_info.tid */
9823       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
9824
9825       len = strlen (buf) + 1;
9826       name = (char *) bfd_alloc (abfd, len);
9827       if (name == NULL)
9828         return FALSE;
9829
9830       memcpy (name, buf, len);
9831
9832       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9833       if (sect == NULL)
9834         return FALSE;
9835
9836       /* sizeof (thread_info.thread_context) */
9837       sect->size = 716;
9838       /* offsetof (thread_info.thread_context) */
9839       sect->filepos = note->descpos + 12;
9840       sect->alignment_power = 2;
9841
9842       /* thread_info.is_active_thread */
9843       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9844
9845       if (is_active_thread)
9846         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
9847           return FALSE;
9848       break;
9849
9850     case 3 /* NOTE_INFO_MODULE */:
9851       /* Make a ".module/xxxxxxxx" section.  */
9852       /* module_info.base_address */
9853       base_addr = bfd_get_32 (abfd, note->descdata + 4);
9854       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
9855
9856       len = strlen (buf) + 1;
9857       name = (char *) bfd_alloc (abfd, len);
9858       if (name == NULL)
9859         return FALSE;
9860
9861       memcpy (name, buf, len);
9862
9863       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9864
9865       if (sect == NULL)
9866         return FALSE;
9867
9868       sect->size = note->descsz;
9869       sect->filepos = note->descpos;
9870       sect->alignment_power = 2;
9871       break;
9872
9873     default:
9874       return TRUE;
9875     }
9876
9877   return TRUE;
9878 }
9879
9880 static bfd_boolean
9881 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
9882 {
9883   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9884
9885   switch (note->type)
9886     {
9887     default:
9888       return TRUE;
9889
9890     case NT_PRSTATUS:
9891       if (bed->elf_backend_grok_prstatus)
9892         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
9893           return TRUE;
9894 #if defined (HAVE_PRSTATUS_T)
9895       return elfcore_grok_prstatus (abfd, note);
9896 #else
9897       return TRUE;
9898 #endif
9899
9900 #if defined (HAVE_PSTATUS_T)
9901     case NT_PSTATUS:
9902       return elfcore_grok_pstatus (abfd, note);
9903 #endif
9904
9905 #if defined (HAVE_LWPSTATUS_T)
9906     case NT_LWPSTATUS:
9907       return elfcore_grok_lwpstatus (abfd, note);
9908 #endif
9909
9910     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
9911       return elfcore_grok_prfpreg (abfd, note);
9912
9913     case NT_WIN32PSTATUS:
9914       return elfcore_grok_win32pstatus (abfd, note);
9915
9916     case NT_PRXFPREG:           /* Linux SSE extension */
9917       if (note->namesz == 6
9918           && strcmp (note->namedata, "LINUX") == 0)
9919         return elfcore_grok_prxfpreg (abfd, note);
9920       else
9921         return TRUE;
9922
9923     case NT_X86_XSTATE:         /* Linux XSAVE extension */
9924       if (note->namesz == 6
9925           && strcmp (note->namedata, "LINUX") == 0)
9926         return elfcore_grok_xstatereg (abfd, note);
9927       else
9928         return TRUE;
9929
9930     case NT_PPC_VMX:
9931       if (note->namesz == 6
9932           && strcmp (note->namedata, "LINUX") == 0)
9933         return elfcore_grok_ppc_vmx (abfd, note);
9934       else
9935         return TRUE;
9936
9937     case NT_PPC_VSX:
9938       if (note->namesz == 6
9939           && strcmp (note->namedata, "LINUX") == 0)
9940         return elfcore_grok_ppc_vsx (abfd, note);
9941       else
9942         return TRUE;
9943
9944     case NT_PPC_TAR:
9945       if (note->namesz == 6
9946           && strcmp (note->namedata, "LINUX") == 0)
9947         return elfcore_grok_ppc_tar (abfd, note);
9948       else
9949         return TRUE;
9950
9951     case NT_PPC_PPR:
9952       if (note->namesz == 6
9953           && strcmp (note->namedata, "LINUX") == 0)
9954         return elfcore_grok_ppc_ppr (abfd, note);
9955       else
9956         return TRUE;
9957
9958     case NT_PPC_DSCR:
9959       if (note->namesz == 6
9960           && strcmp (note->namedata, "LINUX") == 0)
9961         return elfcore_grok_ppc_dscr (abfd, note);
9962       else
9963         return TRUE;
9964
9965     case NT_PPC_EBB:
9966       if (note->namesz == 6
9967           && strcmp (note->namedata, "LINUX") == 0)
9968         return elfcore_grok_ppc_ebb (abfd, note);
9969       else
9970         return TRUE;
9971
9972     case NT_PPC_PMU:
9973       if (note->namesz == 6
9974           && strcmp (note->namedata, "LINUX") == 0)
9975         return elfcore_grok_ppc_pmu (abfd, note);
9976       else
9977         return TRUE;
9978
9979     case NT_PPC_TM_CGPR:
9980       if (note->namesz == 6
9981           && strcmp (note->namedata, "LINUX") == 0)
9982         return elfcore_grok_ppc_tm_cgpr (abfd, note);
9983       else
9984         return TRUE;
9985
9986     case NT_PPC_TM_CFPR:
9987       if (note->namesz == 6
9988           && strcmp (note->namedata, "LINUX") == 0)
9989         return elfcore_grok_ppc_tm_cfpr (abfd, note);
9990       else
9991         return TRUE;
9992
9993     case NT_PPC_TM_CVMX:
9994       if (note->namesz == 6
9995           && strcmp (note->namedata, "LINUX") == 0)
9996         return elfcore_grok_ppc_tm_cvmx (abfd, note);
9997       else
9998         return TRUE;
9999
10000     case NT_PPC_TM_CVSX:
10001       if (note->namesz == 6
10002           && strcmp (note->namedata, "LINUX") == 0)
10003         return elfcore_grok_ppc_tm_cvsx (abfd, note);
10004       else
10005         return TRUE;
10006
10007     case NT_PPC_TM_SPR:
10008       if (note->namesz == 6
10009           && strcmp (note->namedata, "LINUX") == 0)
10010         return elfcore_grok_ppc_tm_spr (abfd, note);
10011       else
10012         return TRUE;
10013
10014     case NT_PPC_TM_CTAR:
10015       if (note->namesz == 6
10016           && strcmp (note->namedata, "LINUX") == 0)
10017         return elfcore_grok_ppc_tm_ctar (abfd, note);
10018       else
10019         return TRUE;
10020
10021     case NT_PPC_TM_CPPR:
10022       if (note->namesz == 6
10023           && strcmp (note->namedata, "LINUX") == 0)
10024         return elfcore_grok_ppc_tm_cppr (abfd, note);
10025       else
10026         return TRUE;
10027
10028     case NT_PPC_TM_CDSCR:
10029       if (note->namesz == 6
10030           && strcmp (note->namedata, "LINUX") == 0)
10031         return elfcore_grok_ppc_tm_cdscr (abfd, note);
10032       else
10033         return TRUE;
10034
10035     case NT_S390_HIGH_GPRS:
10036       if (note->namesz == 6
10037           && strcmp (note->namedata, "LINUX") == 0)
10038         return elfcore_grok_s390_high_gprs (abfd, note);
10039       else
10040         return TRUE;
10041
10042     case NT_S390_TIMER:
10043       if (note->namesz == 6
10044           && strcmp (note->namedata, "LINUX") == 0)
10045         return elfcore_grok_s390_timer (abfd, note);
10046       else
10047         return TRUE;
10048
10049     case NT_S390_TODCMP:
10050       if (note->namesz == 6
10051           && strcmp (note->namedata, "LINUX") == 0)
10052         return elfcore_grok_s390_todcmp (abfd, note);
10053       else
10054         return TRUE;
10055
10056     case NT_S390_TODPREG:
10057       if (note->namesz == 6
10058           && strcmp (note->namedata, "LINUX") == 0)
10059         return elfcore_grok_s390_todpreg (abfd, note);
10060       else
10061         return TRUE;
10062
10063     case NT_S390_CTRS:
10064       if (note->namesz == 6
10065           && strcmp (note->namedata, "LINUX") == 0)
10066         return elfcore_grok_s390_ctrs (abfd, note);
10067       else
10068         return TRUE;
10069
10070     case NT_S390_PREFIX:
10071       if (note->namesz == 6
10072           && strcmp (note->namedata, "LINUX") == 0)
10073         return elfcore_grok_s390_prefix (abfd, note);
10074       else
10075         return TRUE;
10076
10077     case NT_S390_LAST_BREAK:
10078       if (note->namesz == 6
10079           && strcmp (note->namedata, "LINUX") == 0)
10080         return elfcore_grok_s390_last_break (abfd, note);
10081       else
10082         return TRUE;
10083
10084     case NT_S390_SYSTEM_CALL:
10085       if (note->namesz == 6
10086           && strcmp (note->namedata, "LINUX") == 0)
10087         return elfcore_grok_s390_system_call (abfd, note);
10088       else
10089         return TRUE;
10090
10091     case NT_S390_TDB:
10092       if (note->namesz == 6
10093           && strcmp (note->namedata, "LINUX") == 0)
10094         return elfcore_grok_s390_tdb (abfd, note);
10095       else
10096         return TRUE;
10097
10098     case NT_S390_VXRS_LOW:
10099       if (note->namesz == 6
10100           && strcmp (note->namedata, "LINUX") == 0)
10101         return elfcore_grok_s390_vxrs_low (abfd, note);
10102       else
10103         return TRUE;
10104
10105     case NT_S390_VXRS_HIGH:
10106       if (note->namesz == 6
10107           && strcmp (note->namedata, "LINUX") == 0)
10108         return elfcore_grok_s390_vxrs_high (abfd, note);
10109       else
10110         return TRUE;
10111
10112     case NT_S390_GS_CB:
10113       if (note->namesz == 6
10114           && strcmp (note->namedata, "LINUX") == 0)
10115         return elfcore_grok_s390_gs_cb (abfd, note);
10116       else
10117         return TRUE;
10118
10119     case NT_S390_GS_BC:
10120       if (note->namesz == 6
10121           && strcmp (note->namedata, "LINUX") == 0)
10122         return elfcore_grok_s390_gs_bc (abfd, note);
10123       else
10124         return TRUE;
10125
10126     case NT_ARM_VFP:
10127       if (note->namesz == 6
10128           && strcmp (note->namedata, "LINUX") == 0)
10129         return elfcore_grok_arm_vfp (abfd, note);
10130       else
10131         return TRUE;
10132
10133     case NT_ARM_TLS:
10134       if (note->namesz == 6
10135           && strcmp (note->namedata, "LINUX") == 0)
10136         return elfcore_grok_aarch_tls (abfd, note);
10137       else
10138         return TRUE;
10139
10140     case NT_ARM_HW_BREAK:
10141       if (note->namesz == 6
10142           && strcmp (note->namedata, "LINUX") == 0)
10143         return elfcore_grok_aarch_hw_break (abfd, note);
10144       else
10145         return TRUE;
10146
10147     case NT_ARM_HW_WATCH:
10148       if (note->namesz == 6
10149           && strcmp (note->namedata, "LINUX") == 0)
10150         return elfcore_grok_aarch_hw_watch (abfd, note);
10151       else
10152         return TRUE;
10153
10154     case NT_ARM_SVE:
10155       if (note->namesz == 6
10156           && strcmp (note->namedata, "LINUX") == 0)
10157         return elfcore_grok_aarch_sve (abfd, note);
10158       else
10159         return TRUE;
10160
10161     case NT_ARM_PAC_MASK:
10162       if (note->namesz == 6
10163           && strcmp (note->namedata, "LINUX") == 0)
10164         return elfcore_grok_aarch_pauth (abfd, note);
10165       else
10166         return TRUE;
10167
10168     case NT_PRPSINFO:
10169     case NT_PSINFO:
10170       if (bed->elf_backend_grok_psinfo)
10171         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
10172           return TRUE;
10173 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10174       return elfcore_grok_psinfo (abfd, note);
10175 #else
10176       return TRUE;
10177 #endif
10178
10179     case NT_AUXV:
10180       {
10181         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10182                                                              SEC_HAS_CONTENTS);
10183
10184         if (sect == NULL)
10185           return FALSE;
10186         sect->size = note->descsz;
10187         sect->filepos = note->descpos;
10188         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10189
10190         return TRUE;
10191       }
10192
10193     case NT_FILE:
10194       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
10195                                               note);
10196
10197     case NT_SIGINFO:
10198       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
10199                                               note);
10200
10201     }
10202 }
10203
10204 static bfd_boolean
10205 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
10206 {
10207   struct bfd_build_id* build_id;
10208
10209   if (note->descsz == 0)
10210     return FALSE;
10211
10212   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
10213   if (build_id == NULL)
10214     return FALSE;
10215
10216   build_id->size = note->descsz;
10217   memcpy (build_id->data, note->descdata, note->descsz);
10218   abfd->build_id = build_id;
10219
10220   return TRUE;
10221 }
10222
10223 static bfd_boolean
10224 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
10225 {
10226   switch (note->type)
10227     {
10228     default:
10229       return TRUE;
10230
10231     case NT_GNU_PROPERTY_TYPE_0:
10232       return _bfd_elf_parse_gnu_properties (abfd, note);
10233
10234     case NT_GNU_BUILD_ID:
10235       return elfobj_grok_gnu_build_id (abfd, note);
10236     }
10237 }
10238
10239 static bfd_boolean
10240 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
10241 {
10242   struct sdt_note *cur =
10243     (struct sdt_note *) bfd_alloc (abfd,
10244                                    sizeof (struct sdt_note) + note->descsz);
10245
10246   cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
10247   cur->size = (bfd_size_type) note->descsz;
10248   memcpy (cur->data, note->descdata, note->descsz);
10249
10250   elf_tdata (abfd)->sdt_note_head = cur;
10251
10252   return TRUE;
10253 }
10254
10255 static bfd_boolean
10256 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
10257 {
10258   switch (note->type)
10259     {
10260     case NT_STAPSDT:
10261       return elfobj_grok_stapsdt_note_1 (abfd, note);
10262
10263     default:
10264       return TRUE;
10265     }
10266 }
10267
10268 static bfd_boolean
10269 elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
10270 {
10271   size_t offset;
10272
10273   switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10274     {
10275     case ELFCLASS32:
10276       if (note->descsz < 108)
10277         return FALSE;
10278       break;
10279
10280     case ELFCLASS64:
10281       if (note->descsz < 120)
10282         return FALSE;
10283       break;
10284
10285     default:
10286       return FALSE;
10287     }
10288
10289   /* Check for version 1 in pr_version.  */
10290   if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10291     return FALSE;
10292
10293   offset = 4;
10294
10295   /* Skip over pr_psinfosz. */
10296   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10297     offset += 4;
10298   else
10299     {
10300       offset += 4;      /* Padding before pr_psinfosz. */
10301       offset += 8;
10302     }
10303
10304   /* pr_fname is PRFNAMESZ (16) + 1 bytes in size.  */
10305   elf_tdata (abfd)->core->program
10306     = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
10307   offset += 17;
10308
10309   /* pr_psargs is PRARGSZ (80) + 1 bytes in size.  */
10310   elf_tdata (abfd)->core->command
10311     = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
10312   offset += 81;
10313
10314   /* Padding before pr_pid.  */
10315   offset += 2;
10316
10317   /* The pr_pid field was added in version "1a".  */
10318   if (note->descsz < offset + 4)
10319     return TRUE;
10320
10321   elf_tdata (abfd)->core->pid
10322     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10323
10324   return TRUE;
10325 }
10326
10327 static bfd_boolean
10328 elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
10329 {
10330   size_t offset;
10331   size_t size;
10332   size_t min_size;
10333
10334   /* Compute offset of pr_getregsz, skipping over pr_statussz.
10335      Also compute minimum size of this note.  */
10336   switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10337     {
10338     case ELFCLASS32:
10339       offset = 4 + 4;
10340       min_size = offset + (4 * 2) + 4 + 4 + 4;
10341       break;
10342
10343     case ELFCLASS64:
10344       offset = 4 + 4 + 8;       /* Includes padding before pr_statussz.  */
10345       min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
10346       break;
10347
10348     default:
10349       return FALSE;
10350     }
10351
10352   if (note->descsz < min_size)
10353     return FALSE;
10354
10355   /* Check for version 1 in pr_version.  */
10356   if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10357     return FALSE;
10358
10359   /* Extract size of pr_reg from pr_gregsetsz.  */
10360   /* Skip over pr_gregsetsz and pr_fpregsetsz.  */
10361   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10362     {
10363       size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10364       offset += 4 * 2;
10365     }
10366   else
10367     {
10368       size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10369       offset += 8 * 2;
10370     }
10371
10372   /* Skip over pr_osreldate.  */
10373   offset += 4;
10374
10375   /* Read signal from pr_cursig.  */
10376   if (elf_tdata (abfd)->core->signal == 0)
10377     elf_tdata (abfd)->core->signal
10378       = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10379   offset += 4;
10380
10381   /* Read TID from pr_pid.  */
10382   elf_tdata (abfd)->core->lwpid
10383       = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10384   offset += 4;
10385
10386   /* Padding before pr_reg.  */
10387   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
10388     offset += 4;
10389
10390   /* Make sure that there is enough data remaining in the note.  */
10391   if ((note->descsz - offset) < size)
10392     return FALSE;
10393
10394   /* Make a ".reg/999" section and a ".reg" section.  */
10395   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10396                                           size, note->descpos + offset);
10397 }
10398
10399 static bfd_boolean
10400 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10401 {
10402   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10403
10404   switch (note->type)
10405     {
10406     case NT_PRSTATUS:
10407       if (bed->elf_backend_grok_freebsd_prstatus)
10408         if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10409           return TRUE;
10410       return elfcore_grok_freebsd_prstatus (abfd, note);
10411
10412     case NT_FPREGSET:
10413       return elfcore_grok_prfpreg (abfd, note);
10414
10415     case NT_PRPSINFO:
10416       return elfcore_grok_freebsd_psinfo (abfd, note);
10417
10418     case NT_FREEBSD_THRMISC:
10419       if (note->namesz == 8)
10420         return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10421       else
10422         return TRUE;
10423
10424     case NT_FREEBSD_PROCSTAT_PROC:
10425       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10426                                               note);
10427
10428     case NT_FREEBSD_PROCSTAT_FILES:
10429       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10430                                               note);
10431
10432     case NT_FREEBSD_PROCSTAT_VMMAP:
10433       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10434                                               note);
10435
10436     case NT_FREEBSD_PROCSTAT_AUXV:
10437       {
10438         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10439                                                              SEC_HAS_CONTENTS);
10440
10441         if (sect == NULL)
10442           return FALSE;
10443         sect->size = note->descsz - 4;
10444         sect->filepos = note->descpos + 4;
10445         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10446
10447         return TRUE;
10448       }
10449
10450     case NT_X86_XSTATE:
10451       if (note->namesz == 8)
10452         return elfcore_grok_xstatereg (abfd, note);
10453       else
10454         return TRUE;
10455
10456     case NT_FREEBSD_PTLWPINFO:
10457       return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10458                                               note);
10459
10460     case NT_ARM_VFP:
10461       return elfcore_grok_arm_vfp (abfd, note);
10462
10463     default:
10464       return TRUE;
10465     }
10466 }
10467
10468 static bfd_boolean
10469 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
10470 {
10471   char *cp;
10472
10473   cp = strchr (note->namedata, '@');
10474   if (cp != NULL)
10475     {
10476       *lwpidp = atoi(cp + 1);
10477       return TRUE;
10478     }
10479   return FALSE;
10480 }
10481
10482 static bfd_boolean
10483 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10484 {
10485   if (note->descsz <= 0x7c + 31)
10486     return FALSE;
10487
10488   /* Signal number at offset 0x08. */
10489   elf_tdata (abfd)->core->signal
10490     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10491
10492   /* Process ID at offset 0x50. */
10493   elf_tdata (abfd)->core->pid
10494     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10495
10496   /* Command name at 0x7c (max 32 bytes, including nul). */
10497   elf_tdata (abfd)->core->command
10498     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10499
10500   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10501                                           note);
10502 }
10503
10504 static bfd_boolean
10505 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
10506 {
10507   int lwp;
10508
10509   if (elfcore_netbsd_get_lwpid (note, &lwp))
10510     elf_tdata (abfd)->core->lwpid = lwp;
10511
10512   if (note->type == NT_NETBSDCORE_PROCINFO)
10513     {
10514       /* NetBSD-specific core "procinfo".  Note that we expect to
10515          find this note before any of the others, which is fine,
10516          since the kernel writes this note out first when it
10517          creates a core file.  */
10518
10519       return elfcore_grok_netbsd_procinfo (abfd, note);
10520     }
10521
10522   /* As of Jan 2002 there are no other machine-independent notes
10523      defined for NetBSD core files.  If the note type is less
10524      than the start of the machine-dependent note types, we don't
10525      understand it.  */
10526
10527   if (note->type < NT_NETBSDCORE_FIRSTMACH)
10528     return TRUE;
10529
10530
10531   switch (bfd_get_arch (abfd))
10532     {
10533       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10534          PT_GETFPREGS == mach+2.  */
10535
10536     case bfd_arch_alpha:
10537     case bfd_arch_sparc:
10538       switch (note->type)
10539         {
10540         case NT_NETBSDCORE_FIRSTMACH+0:
10541           return elfcore_make_note_pseudosection (abfd, ".reg", note);
10542
10543         case NT_NETBSDCORE_FIRSTMACH+2:
10544           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10545
10546         default:
10547           return TRUE;
10548         }
10549
10550       /* On all other arch's, PT_GETREGS == mach+1 and
10551          PT_GETFPREGS == mach+3.  */
10552
10553     default:
10554       switch (note->type)
10555         {
10556         case NT_NETBSDCORE_FIRSTMACH+1:
10557           return elfcore_make_note_pseudosection (abfd, ".reg", note);
10558
10559         case NT_NETBSDCORE_FIRSTMACH+3:
10560           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10561
10562         default:
10563           return TRUE;
10564         }
10565     }
10566     /* NOTREACHED */
10567 }
10568
10569 static bfd_boolean
10570 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10571 {
10572   if (note->descsz <= 0x48 + 31)
10573     return FALSE;
10574
10575   /* Signal number at offset 0x08. */
10576   elf_tdata (abfd)->core->signal
10577     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10578
10579   /* Process ID at offset 0x20. */
10580   elf_tdata (abfd)->core->pid
10581     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10582
10583   /* Command name at 0x48 (max 32 bytes, including nul). */
10584   elf_tdata (abfd)->core->command
10585     = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10586
10587   return TRUE;
10588 }
10589
10590 static bfd_boolean
10591 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10592 {
10593   if (note->type == NT_OPENBSD_PROCINFO)
10594     return elfcore_grok_openbsd_procinfo (abfd, note);
10595
10596   if (note->type == NT_OPENBSD_REGS)
10597     return elfcore_make_note_pseudosection (abfd, ".reg", note);
10598
10599   if (note->type == NT_OPENBSD_FPREGS)
10600     return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10601
10602   if (note->type == NT_OPENBSD_XFPREGS)
10603     return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10604
10605   if (note->type == NT_OPENBSD_AUXV)
10606     {
10607       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10608                                                            SEC_HAS_CONTENTS);
10609
10610       if (sect == NULL)
10611         return FALSE;
10612       sect->size = note->descsz;
10613       sect->filepos = note->descpos;
10614       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10615
10616       return TRUE;
10617     }
10618
10619   if (note->type == NT_OPENBSD_WCOOKIE)
10620     {
10621       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10622                                                            SEC_HAS_CONTENTS);
10623
10624       if (sect == NULL)
10625         return FALSE;
10626       sect->size = note->descsz;
10627       sect->filepos = note->descpos;
10628       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10629
10630       return TRUE;
10631     }
10632
10633   return TRUE;
10634 }
10635
10636 static bfd_boolean
10637 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
10638 {
10639   void *ddata = note->descdata;
10640   char buf[100];
10641   char *name;
10642   asection *sect;
10643   short sig;
10644   unsigned flags;
10645
10646   if (note->descsz < 16)
10647     return FALSE;
10648
10649   /* nto_procfs_status 'pid' field is at offset 0.  */
10650   elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
10651
10652   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
10653   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10654
10655   /* nto_procfs_status 'flags' field is at offset 8.  */
10656   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
10657
10658   /* nto_procfs_status 'what' field is at offset 14.  */
10659   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10660     {
10661       elf_tdata (abfd)->core->signal = sig;
10662       elf_tdata (abfd)->core->lwpid = *tid;
10663     }
10664
10665   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
10666      do not come from signals so we make sure we set the current
10667      thread just in case.  */
10668   if (flags & 0x00000080)
10669     elf_tdata (abfd)->core->lwpid = *tid;
10670
10671   /* Make a ".qnx_core_status/%d" section.  */
10672   sprintf (buf, ".qnx_core_status/%ld", *tid);
10673
10674   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10675   if (name == NULL)
10676     return FALSE;
10677   strcpy (name, buf);
10678
10679   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10680   if (sect == NULL)
10681     return FALSE;
10682
10683   sect->size            = note->descsz;
10684   sect->filepos         = note->descpos;
10685   sect->alignment_power = 2;
10686
10687   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10688 }
10689
10690 static bfd_boolean
10691 elfcore_grok_nto_regs (bfd *abfd,
10692                        Elf_Internal_Note *note,
10693                        long tid,
10694                        char *base)
10695 {
10696   char buf[100];
10697   char *name;
10698   asection *sect;
10699
10700   /* Make a "(base)/%d" section.  */
10701   sprintf (buf, "%s/%ld", base, tid);
10702
10703   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10704   if (name == NULL)
10705     return FALSE;
10706   strcpy (name, buf);
10707
10708   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10709   if (sect == NULL)
10710     return FALSE;
10711
10712   sect->size            = note->descsz;
10713   sect->filepos         = note->descpos;
10714   sect->alignment_power = 2;
10715
10716   /* This is the current thread.  */
10717   if (elf_tdata (abfd)->core->lwpid == tid)
10718     return elfcore_maybe_make_sect (abfd, base, sect);
10719
10720   return TRUE;
10721 }
10722
10723 #define BFD_QNT_CORE_INFO       7
10724 #define BFD_QNT_CORE_STATUS     8
10725 #define BFD_QNT_CORE_GREG       9
10726 #define BFD_QNT_CORE_FPREG      10
10727
10728 static bfd_boolean
10729 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
10730 {
10731   /* Every GREG section has a STATUS section before it.  Store the
10732      tid from the previous call to pass down to the next gregs
10733      function.  */
10734   static long tid = 1;
10735
10736   switch (note->type)
10737     {
10738     case BFD_QNT_CORE_INFO:
10739       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10740     case BFD_QNT_CORE_STATUS:
10741       return elfcore_grok_nto_status (abfd, note, &tid);
10742     case BFD_QNT_CORE_GREG:
10743       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10744     case BFD_QNT_CORE_FPREG:
10745       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10746     default:
10747       return TRUE;
10748     }
10749 }
10750
10751 static bfd_boolean
10752 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10753 {
10754   char *name;
10755   asection *sect;
10756   size_t len;
10757
10758   /* Use note name as section name.  */
10759   len = note->namesz;
10760   name = (char *) bfd_alloc (abfd, len);
10761   if (name == NULL)
10762     return FALSE;
10763   memcpy (name, note->namedata, len);
10764   name[len - 1] = '\0';
10765
10766   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10767   if (sect == NULL)
10768     return FALSE;
10769
10770   sect->size            = note->descsz;
10771   sect->filepos         = note->descpos;
10772   sect->alignment_power = 1;
10773
10774   return TRUE;
10775 }
10776
10777 /* Function: elfcore_write_note
10778
10779    Inputs:
10780      buffer to hold note, and current size of buffer
10781      name of note
10782      type of note
10783      data for note
10784      size of data for note
10785
10786    Writes note to end of buffer.  ELF64 notes are written exactly as
10787    for ELF32, despite the current (as of 2006) ELF gabi specifying
10788    that they ought to have 8-byte namesz and descsz field, and have
10789    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
10790
10791    Return:
10792    Pointer to realloc'd buffer, *BUFSIZ updated.  */
10793
10794 char *
10795 elfcore_write_note (bfd *abfd,
10796                     char *buf,
10797                     int *bufsiz,
10798                     const char *name,
10799                     int type,
10800                     const void *input,
10801                     int size)
10802 {
10803   Elf_External_Note *xnp;
10804   size_t namesz;
10805   size_t newspace;
10806   char *dest;
10807
10808   namesz = 0;
10809   if (name != NULL)
10810     namesz = strlen (name) + 1;
10811
10812   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
10813
10814   buf = (char *) realloc (buf, *bufsiz + newspace);
10815   if (buf == NULL)
10816     return buf;
10817   dest = buf + *bufsiz;
10818   *bufsiz += newspace;
10819   xnp = (Elf_External_Note *) dest;
10820   H_PUT_32 (abfd, namesz, xnp->namesz);
10821   H_PUT_32 (abfd, size, xnp->descsz);
10822   H_PUT_32 (abfd, type, xnp->type);
10823   dest = xnp->name;
10824   if (name != NULL)
10825     {
10826       memcpy (dest, name, namesz);
10827       dest += namesz;
10828       while (namesz & 3)
10829         {
10830           *dest++ = '\0';
10831           ++namesz;
10832         }
10833     }
10834   memcpy (dest, input, size);
10835   dest += size;
10836   while (size & 3)
10837     {
10838       *dest++ = '\0';
10839       ++size;
10840     }
10841   return buf;
10842 }
10843
10844 /* gcc-8 warns (*) on all the strncpy calls in this function about
10845    possible string truncation.  The "truncation" is not a bug.  We
10846    have an external representation of structs with fields that are not
10847    necessarily NULL terminated and corresponding internal
10848    representation fields that are one larger so that they can always
10849    be NULL terminated.
10850    gcc versions between 4.2 and 4.6 do not allow pragma control of
10851    diagnostics inside functions, giving a hard error if you try to use
10852    the finer control available with later versions.
10853    gcc prior to 4.2 warns about diagnostic push and pop.
10854    gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10855    unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10856    (*) Depending on your system header files!  */
10857 #if GCC_VERSION >= 8000
10858 # pragma GCC diagnostic push
10859 # pragma GCC diagnostic ignored "-Wstringop-truncation"
10860 #endif
10861 char *
10862 elfcore_write_prpsinfo (bfd  *abfd,
10863                         char *buf,
10864                         int  *bufsiz,
10865                         const char *fname,
10866                         const char *psargs)
10867 {
10868   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10869
10870   if (bed->elf_backend_write_core_note != NULL)
10871     {
10872       char *ret;
10873       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10874                                                  NT_PRPSINFO, fname, psargs);
10875       if (ret != NULL)
10876         return ret;
10877     }
10878
10879 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10880 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10881   if (bed->s->elfclass == ELFCLASS32)
10882     {
10883 #  if defined (HAVE_PSINFO32_T)
10884       psinfo32_t data;
10885       int note_type = NT_PSINFO;
10886 #  else
10887       prpsinfo32_t data;
10888       int note_type = NT_PRPSINFO;
10889 #  endif
10890
10891       memset (&data, 0, sizeof (data));
10892       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10893       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10894       return elfcore_write_note (abfd, buf, bufsiz,
10895                                  "CORE", note_type, &data, sizeof (data));
10896     }
10897   else
10898 # endif
10899     {
10900 # if defined (HAVE_PSINFO_T)
10901       psinfo_t data;
10902       int note_type = NT_PSINFO;
10903 # else
10904       prpsinfo_t data;
10905       int note_type = NT_PRPSINFO;
10906 # endif
10907
10908       memset (&data, 0, sizeof (data));
10909       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10910       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10911       return elfcore_write_note (abfd, buf, bufsiz,
10912                                  "CORE", note_type, &data, sizeof (data));
10913     }
10914 #endif  /* PSINFO_T or PRPSINFO_T */
10915
10916   free (buf);
10917   return NULL;
10918 }
10919 #if GCC_VERSION >= 8000
10920 # pragma GCC diagnostic pop
10921 #endif
10922
10923 char *
10924 elfcore_write_linux_prpsinfo32
10925   (bfd *abfd, char *buf, int *bufsiz,
10926    const struct elf_internal_linux_prpsinfo *prpsinfo)
10927 {
10928   if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10929     {
10930       struct elf_external_linux_prpsinfo32_ugid16 data;
10931
10932       swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10933       return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10934                                  &data, sizeof (data));
10935     }
10936   else
10937     {
10938       struct elf_external_linux_prpsinfo32_ugid32 data;
10939
10940       swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10941       return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10942                                  &data, sizeof (data));
10943     }
10944 }
10945
10946 char *
10947 elfcore_write_linux_prpsinfo64
10948   (bfd *abfd, char *buf, int *bufsiz,
10949    const struct elf_internal_linux_prpsinfo *prpsinfo)
10950 {
10951   if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
10952     {
10953       struct elf_external_linux_prpsinfo64_ugid16 data;
10954
10955       swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
10956       return elfcore_write_note (abfd, buf, bufsiz,
10957                                  "CORE", NT_PRPSINFO, &data, sizeof (data));
10958     }
10959   else
10960     {
10961       struct elf_external_linux_prpsinfo64_ugid32 data;
10962
10963       swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
10964       return elfcore_write_note (abfd, buf, bufsiz,
10965                                  "CORE", NT_PRPSINFO, &data, sizeof (data));
10966     }
10967 }
10968
10969 char *
10970 elfcore_write_prstatus (bfd *abfd,
10971                         char *buf,
10972                         int *bufsiz,
10973                         long pid,
10974                         int cursig,
10975                         const void *gregs)
10976 {
10977   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10978
10979   if (bed->elf_backend_write_core_note != NULL)
10980     {
10981       char *ret;
10982       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10983                                                  NT_PRSTATUS,
10984                                                  pid, cursig, gregs);
10985       if (ret != NULL)
10986         return ret;
10987     }
10988
10989 #if defined (HAVE_PRSTATUS_T)
10990 #if defined (HAVE_PRSTATUS32_T)
10991   if (bed->s->elfclass == ELFCLASS32)
10992     {
10993       prstatus32_t prstat;
10994
10995       memset (&prstat, 0, sizeof (prstat));
10996       prstat.pr_pid = pid;
10997       prstat.pr_cursig = cursig;
10998       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10999       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
11000                                  NT_PRSTATUS, &prstat, sizeof (prstat));
11001     }
11002   else
11003 #endif
11004     {
11005       prstatus_t prstat;
11006
11007       memset (&prstat, 0, sizeof (prstat));
11008       prstat.pr_pid = pid;
11009       prstat.pr_cursig = cursig;
11010       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
11011       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
11012                                  NT_PRSTATUS, &prstat, sizeof (prstat));
11013     }
11014 #endif /* HAVE_PRSTATUS_T */
11015
11016   free (buf);
11017   return NULL;
11018 }
11019
11020 #if defined (HAVE_LWPSTATUS_T)
11021 char *
11022 elfcore_write_lwpstatus (bfd *abfd,
11023                          char *buf,
11024                          int *bufsiz,
11025                          long pid,
11026                          int cursig,
11027                          const void *gregs)
11028 {
11029   lwpstatus_t lwpstat;
11030   const char *note_name = "CORE";
11031
11032   memset (&lwpstat, 0, sizeof (lwpstat));
11033   lwpstat.pr_lwpid  = pid >> 16;
11034   lwpstat.pr_cursig = cursig;
11035 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11036   memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
11037 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11038 #if !defined(gregs)
11039   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
11040           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
11041 #else
11042   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
11043           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
11044 #endif
11045 #endif
11046   return elfcore_write_note (abfd, buf, bufsiz, note_name,
11047                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
11048 }
11049 #endif /* HAVE_LWPSTATUS_T */
11050
11051 #if defined (HAVE_PSTATUS_T)
11052 char *
11053 elfcore_write_pstatus (bfd *abfd,
11054                        char *buf,
11055                        int *bufsiz,
11056                        long pid,
11057                        int cursig ATTRIBUTE_UNUSED,
11058                        const void *gregs ATTRIBUTE_UNUSED)
11059 {
11060   const char *note_name = "CORE";
11061 #if defined (HAVE_PSTATUS32_T)
11062   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11063
11064   if (bed->s->elfclass == ELFCLASS32)
11065     {
11066       pstatus32_t pstat;
11067
11068       memset (&pstat, 0, sizeof (pstat));
11069       pstat.pr_pid = pid & 0xffff;
11070       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11071                                 NT_PSTATUS, &pstat, sizeof (pstat));
11072       return buf;
11073     }
11074   else
11075 #endif
11076     {
11077       pstatus_t pstat;
11078
11079       memset (&pstat, 0, sizeof (pstat));
11080       pstat.pr_pid = pid & 0xffff;
11081       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11082                                 NT_PSTATUS, &pstat, sizeof (pstat));
11083       return buf;
11084     }
11085 }
11086 #endif /* HAVE_PSTATUS_T */
11087
11088 char *
11089 elfcore_write_prfpreg (bfd *abfd,
11090                        char *buf,
11091                        int *bufsiz,
11092                        const void *fpregs,
11093                        int size)
11094 {
11095   const char *note_name = "CORE";
11096   return elfcore_write_note (abfd, buf, bufsiz,
11097                              note_name, NT_FPREGSET, fpregs, size);
11098 }
11099
11100 char *
11101 elfcore_write_prxfpreg (bfd *abfd,
11102                         char *buf,
11103                         int *bufsiz,
11104                         const void *xfpregs,
11105                         int size)
11106 {
11107   char *note_name = "LINUX";
11108   return elfcore_write_note (abfd, buf, bufsiz,
11109                              note_name, NT_PRXFPREG, xfpregs, size);
11110 }
11111
11112 char *
11113 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
11114                          const void *xfpregs, int size)
11115 {
11116   char *note_name;
11117   if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
11118     note_name = "FreeBSD";
11119   else
11120     note_name = "LINUX";
11121   return elfcore_write_note (abfd, buf, bufsiz,
11122                              note_name, NT_X86_XSTATE, xfpregs, size);
11123 }
11124
11125 char *
11126 elfcore_write_ppc_vmx (bfd *abfd,
11127                        char *buf,
11128                        int *bufsiz,
11129                        const void *ppc_vmx,
11130                        int size)
11131 {
11132   char *note_name = "LINUX";
11133   return elfcore_write_note (abfd, buf, bufsiz,
11134                              note_name, NT_PPC_VMX, ppc_vmx, size);
11135 }
11136
11137 char *
11138 elfcore_write_ppc_vsx (bfd *abfd,
11139                        char *buf,
11140                        int *bufsiz,
11141                        const void *ppc_vsx,
11142                        int size)
11143 {
11144   char *note_name = "LINUX";
11145   return elfcore_write_note (abfd, buf, bufsiz,
11146                              note_name, NT_PPC_VSX, ppc_vsx, size);
11147 }
11148
11149 char *
11150 elfcore_write_ppc_tar (bfd *abfd,
11151                        char *buf,
11152                        int *bufsiz,
11153                        const void *ppc_tar,
11154                        int size)
11155 {
11156   char *note_name = "LINUX";
11157   return elfcore_write_note (abfd, buf, bufsiz,
11158                              note_name, NT_PPC_TAR, ppc_tar, size);
11159 }
11160
11161 char *
11162 elfcore_write_ppc_ppr (bfd *abfd,
11163                        char *buf,
11164                        int *bufsiz,
11165                        const void *ppc_ppr,
11166                        int size)
11167 {
11168   char *note_name = "LINUX";
11169   return elfcore_write_note (abfd, buf, bufsiz,
11170                              note_name, NT_PPC_PPR, ppc_ppr, size);
11171 }
11172
11173 char *
11174 elfcore_write_ppc_dscr (bfd *abfd,
11175                         char *buf,
11176                         int *bufsiz,
11177                         const void *ppc_dscr,
11178                         int size)
11179 {
11180   char *note_name = "LINUX";
11181   return elfcore_write_note (abfd, buf, bufsiz,
11182                              note_name, NT_PPC_DSCR, ppc_dscr, size);
11183 }
11184
11185 char *
11186 elfcore_write_ppc_ebb (bfd *abfd,
11187                        char *buf,
11188                        int *bufsiz,
11189                        const void *ppc_ebb,
11190                        int size)
11191 {
11192   char *note_name = "LINUX";
11193   return elfcore_write_note (abfd, buf, bufsiz,
11194                              note_name, NT_PPC_EBB, ppc_ebb, size);
11195 }
11196
11197 char *
11198 elfcore_write_ppc_pmu (bfd *abfd,
11199                        char *buf,
11200                        int *bufsiz,
11201                        const void *ppc_pmu,
11202                        int size)
11203 {
11204   char *note_name = "LINUX";
11205   return elfcore_write_note (abfd, buf, bufsiz,
11206                              note_name, NT_PPC_PMU, ppc_pmu, size);
11207 }
11208
11209 char *
11210 elfcore_write_ppc_tm_cgpr (bfd *abfd,
11211                            char *buf,
11212                            int *bufsiz,
11213                            const void *ppc_tm_cgpr,
11214                            int size)
11215 {
11216   char *note_name = "LINUX";
11217   return elfcore_write_note (abfd, buf, bufsiz,
11218                              note_name, NT_PPC_TM_CGPR, ppc_tm_cgpr, size);
11219 }
11220
11221 char *
11222 elfcore_write_ppc_tm_cfpr (bfd *abfd,
11223                            char *buf,
11224                            int *bufsiz,
11225                            const void *ppc_tm_cfpr,
11226                            int size)
11227 {
11228   char *note_name = "LINUX";
11229   return elfcore_write_note (abfd, buf, bufsiz,
11230                              note_name, NT_PPC_TM_CFPR, ppc_tm_cfpr, size);
11231 }
11232
11233 char *
11234 elfcore_write_ppc_tm_cvmx (bfd *abfd,
11235                            char *buf,
11236                            int *bufsiz,
11237                            const void *ppc_tm_cvmx,
11238                            int size)
11239 {
11240   char *note_name = "LINUX";
11241   return elfcore_write_note (abfd, buf, bufsiz,
11242                              note_name, NT_PPC_TM_CVMX, ppc_tm_cvmx, size);
11243 }
11244
11245 char *
11246 elfcore_write_ppc_tm_cvsx (bfd *abfd,
11247                            char *buf,
11248                            int *bufsiz,
11249                            const void *ppc_tm_cvsx,
11250                            int size)
11251 {
11252   char *note_name = "LINUX";
11253   return elfcore_write_note (abfd, buf, bufsiz,
11254                              note_name, NT_PPC_TM_CVSX, ppc_tm_cvsx, size);
11255 }
11256
11257 char *
11258 elfcore_write_ppc_tm_spr (bfd *abfd,
11259                           char *buf,
11260                           int *bufsiz,
11261                           const void *ppc_tm_spr,
11262                           int size)
11263 {
11264   char *note_name = "LINUX";
11265   return elfcore_write_note (abfd, buf, bufsiz,
11266                              note_name, NT_PPC_TM_SPR, ppc_tm_spr, size);
11267 }
11268
11269 char *
11270 elfcore_write_ppc_tm_ctar (bfd *abfd,
11271                            char *buf,
11272                            int *bufsiz,
11273                            const void *ppc_tm_ctar,
11274                            int size)
11275 {
11276   char *note_name = "LINUX";
11277   return elfcore_write_note (abfd, buf, bufsiz,
11278                              note_name, NT_PPC_TM_CTAR, ppc_tm_ctar, size);
11279 }
11280
11281 char *
11282 elfcore_write_ppc_tm_cppr (bfd *abfd,
11283                            char *buf,
11284                            int *bufsiz,
11285                            const void *ppc_tm_cppr,
11286                            int size)
11287 {
11288   char *note_name = "LINUX";
11289   return elfcore_write_note (abfd, buf, bufsiz,
11290                              note_name, NT_PPC_TM_CPPR, ppc_tm_cppr, size);
11291 }
11292
11293 char *
11294 elfcore_write_ppc_tm_cdscr (bfd *abfd,
11295                             char *buf,
11296                             int *bufsiz,
11297                             const void *ppc_tm_cdscr,
11298                             int size)
11299 {
11300   char *note_name = "LINUX";
11301   return elfcore_write_note (abfd, buf, bufsiz,
11302                              note_name, NT_PPC_TM_CDSCR, ppc_tm_cdscr, size);
11303 }
11304
11305 static char *
11306 elfcore_write_s390_high_gprs (bfd *abfd,
11307                               char *buf,
11308                               int *bufsiz,
11309                               const void *s390_high_gprs,
11310                               int size)
11311 {
11312   char *note_name = "LINUX";
11313   return elfcore_write_note (abfd, buf, bufsiz,
11314                              note_name, NT_S390_HIGH_GPRS,
11315                              s390_high_gprs, size);
11316 }
11317
11318 char *
11319 elfcore_write_s390_timer (bfd *abfd,
11320                           char *buf,
11321                           int *bufsiz,
11322                           const void *s390_timer,
11323                           int size)
11324 {
11325   char *note_name = "LINUX";
11326   return elfcore_write_note (abfd, buf, bufsiz,
11327                              note_name, NT_S390_TIMER, s390_timer, size);
11328 }
11329
11330 char *
11331 elfcore_write_s390_todcmp (bfd *abfd,
11332                            char *buf,
11333                            int *bufsiz,
11334                            const void *s390_todcmp,
11335                            int size)
11336 {
11337   char *note_name = "LINUX";
11338   return elfcore_write_note (abfd, buf, bufsiz,
11339                              note_name, NT_S390_TODCMP, s390_todcmp, size);
11340 }
11341
11342 char *
11343 elfcore_write_s390_todpreg (bfd *abfd,
11344                             char *buf,
11345                             int *bufsiz,
11346                             const void *s390_todpreg,
11347                             int size)
11348 {
11349   char *note_name = "LINUX";
11350   return elfcore_write_note (abfd, buf, bufsiz,
11351                              note_name, NT_S390_TODPREG, s390_todpreg, size);
11352 }
11353
11354 char *
11355 elfcore_write_s390_ctrs (bfd *abfd,
11356                          char *buf,
11357                          int *bufsiz,
11358                          const void *s390_ctrs,
11359                          int size)
11360 {
11361   char *note_name = "LINUX";
11362   return elfcore_write_note (abfd, buf, bufsiz,
11363                              note_name, NT_S390_CTRS, s390_ctrs, size);
11364 }
11365
11366 char *
11367 elfcore_write_s390_prefix (bfd *abfd,
11368                            char *buf,
11369                            int *bufsiz,
11370                            const void *s390_prefix,
11371                            int size)
11372 {
11373   char *note_name = "LINUX";
11374   return elfcore_write_note (abfd, buf, bufsiz,
11375                              note_name, NT_S390_PREFIX, s390_prefix, size);
11376 }
11377
11378 char *
11379 elfcore_write_s390_last_break (bfd *abfd,
11380                                char *buf,
11381                                int *bufsiz,
11382                                const void *s390_last_break,
11383                                int size)
11384 {
11385   char *note_name = "LINUX";
11386   return elfcore_write_note (abfd, buf, bufsiz,
11387                              note_name, NT_S390_LAST_BREAK,
11388                              s390_last_break, size);
11389 }
11390
11391 char *
11392 elfcore_write_s390_system_call (bfd *abfd,
11393                                 char *buf,
11394                                 int *bufsiz,
11395                                 const void *s390_system_call,
11396                                 int size)
11397 {
11398   char *note_name = "LINUX";
11399   return elfcore_write_note (abfd, buf, bufsiz,
11400                              note_name, NT_S390_SYSTEM_CALL,
11401                              s390_system_call, size);
11402 }
11403
11404 char *
11405 elfcore_write_s390_tdb (bfd *abfd,
11406                         char *buf,
11407                         int *bufsiz,
11408                         const void *s390_tdb,
11409                         int size)
11410 {
11411   char *note_name = "LINUX";
11412   return elfcore_write_note (abfd, buf, bufsiz,
11413                              note_name, NT_S390_TDB, s390_tdb, size);
11414 }
11415
11416 char *
11417 elfcore_write_s390_vxrs_low (bfd *abfd,
11418                              char *buf,
11419                              int *bufsiz,
11420                              const void *s390_vxrs_low,
11421                              int size)
11422 {
11423   char *note_name = "LINUX";
11424   return elfcore_write_note (abfd, buf, bufsiz,
11425                              note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
11426 }
11427
11428 char *
11429 elfcore_write_s390_vxrs_high (bfd *abfd,
11430                              char *buf,
11431                              int *bufsiz,
11432                              const void *s390_vxrs_high,
11433                              int size)
11434 {
11435   char *note_name = "LINUX";
11436   return elfcore_write_note (abfd, buf, bufsiz,
11437                              note_name, NT_S390_VXRS_HIGH,
11438                              s390_vxrs_high, size);
11439 }
11440
11441 char *
11442 elfcore_write_s390_gs_cb (bfd *abfd,
11443                           char *buf,
11444                           int *bufsiz,
11445                           const void *s390_gs_cb,
11446                           int size)
11447 {
11448   char *note_name = "LINUX";
11449   return elfcore_write_note (abfd, buf, bufsiz,
11450                              note_name, NT_S390_GS_CB,
11451                              s390_gs_cb, size);
11452 }
11453
11454 char *
11455 elfcore_write_s390_gs_bc (bfd *abfd,
11456                           char *buf,
11457                           int *bufsiz,
11458                           const void *s390_gs_bc,
11459                           int size)
11460 {
11461   char *note_name = "LINUX";
11462   return elfcore_write_note (abfd, buf, bufsiz,
11463                              note_name, NT_S390_GS_BC,
11464                              s390_gs_bc, size);
11465 }
11466
11467 char *
11468 elfcore_write_arm_vfp (bfd *abfd,
11469                        char *buf,
11470                        int *bufsiz,
11471                        const void *arm_vfp,
11472                        int size)
11473 {
11474   char *note_name = "LINUX";
11475   return elfcore_write_note (abfd, buf, bufsiz,
11476                              note_name, NT_ARM_VFP, arm_vfp, size);
11477 }
11478
11479 char *
11480 elfcore_write_aarch_tls (bfd *abfd,
11481                        char *buf,
11482                        int *bufsiz,
11483                        const void *aarch_tls,
11484                        int size)
11485 {
11486   char *note_name = "LINUX";
11487   return elfcore_write_note (abfd, buf, bufsiz,
11488                              note_name, NT_ARM_TLS, aarch_tls, size);
11489 }
11490
11491 char *
11492 elfcore_write_aarch_hw_break (bfd *abfd,
11493                             char *buf,
11494                             int *bufsiz,
11495                             const void *aarch_hw_break,
11496                             int size)
11497 {
11498   char *note_name = "LINUX";
11499   return elfcore_write_note (abfd, buf, bufsiz,
11500                              note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11501 }
11502
11503 char *
11504 elfcore_write_aarch_hw_watch (bfd *abfd,
11505                             char *buf,
11506                             int *bufsiz,
11507                             const void *aarch_hw_watch,
11508                             int size)
11509 {
11510   char *note_name = "LINUX";
11511   return elfcore_write_note (abfd, buf, bufsiz,
11512                              note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11513 }
11514
11515 char *
11516 elfcore_write_aarch_sve (bfd *abfd,
11517                          char *buf,
11518                          int *bufsiz,
11519                          const void *aarch_sve,
11520                          int size)
11521 {
11522   char *note_name = "LINUX";
11523   return elfcore_write_note (abfd, buf, bufsiz,
11524                              note_name, NT_ARM_SVE, aarch_sve, size);
11525 }
11526
11527 char *
11528 elfcore_write_aarch_pauth (bfd *abfd,
11529                            char *buf,
11530                            int *bufsiz,
11531                            const void *aarch_pauth,
11532                            int size)
11533 {
11534   char *note_name = "LINUX";
11535   return elfcore_write_note (abfd, buf, bufsiz,
11536                              note_name, NT_ARM_PAC_MASK, aarch_pauth, size);
11537 }
11538
11539 char *
11540 elfcore_write_register_note (bfd *abfd,
11541                              char *buf,
11542                              int *bufsiz,
11543                              const char *section,
11544                              const void *data,
11545                              int size)
11546 {
11547   if (strcmp (section, ".reg2") == 0)
11548     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11549   if (strcmp (section, ".reg-xfp") == 0)
11550     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
11551   if (strcmp (section, ".reg-xstate") == 0)
11552     return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
11553   if (strcmp (section, ".reg-ppc-vmx") == 0)
11554     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
11555   if (strcmp (section, ".reg-ppc-vsx") == 0)
11556     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
11557   if (strcmp (section, ".reg-ppc-tar") == 0)
11558     return elfcore_write_ppc_tar (abfd, buf, bufsiz, data, size);
11559   if (strcmp (section, ".reg-ppc-ppr") == 0)
11560     return elfcore_write_ppc_ppr (abfd, buf, bufsiz, data, size);
11561   if (strcmp (section, ".reg-ppc-dscr") == 0)
11562     return elfcore_write_ppc_dscr (abfd, buf, bufsiz, data, size);
11563   if (strcmp (section, ".reg-ppc-ebb") == 0)
11564     return elfcore_write_ppc_ebb (abfd, buf, bufsiz, data, size);
11565   if (strcmp (section, ".reg-ppc-pmu") == 0)
11566     return elfcore_write_ppc_pmu (abfd, buf, bufsiz, data, size);
11567   if (strcmp (section, ".reg-ppc-tm-cgpr") == 0)
11568     return elfcore_write_ppc_tm_cgpr (abfd, buf, bufsiz, data, size);
11569   if (strcmp (section, ".reg-ppc-tm-cfpr") == 0)
11570     return elfcore_write_ppc_tm_cfpr (abfd, buf, bufsiz, data, size);
11571   if (strcmp (section, ".reg-ppc-tm-cvmx") == 0)
11572     return elfcore_write_ppc_tm_cvmx (abfd, buf, bufsiz, data, size);
11573   if (strcmp (section, ".reg-ppc-tm-cvsx") == 0)
11574     return elfcore_write_ppc_tm_cvsx (abfd, buf, bufsiz, data, size);
11575   if (strcmp (section, ".reg-ppc-tm-spr") == 0)
11576     return elfcore_write_ppc_tm_spr (abfd, buf, bufsiz, data, size);
11577   if (strcmp (section, ".reg-ppc-tm-ctar") == 0)
11578     return elfcore_write_ppc_tm_ctar (abfd, buf, bufsiz, data, size);
11579   if (strcmp (section, ".reg-ppc-tm-cppr") == 0)
11580     return elfcore_write_ppc_tm_cppr (abfd, buf, bufsiz, data, size);
11581   if (strcmp (section, ".reg-ppc-tm-cdscr") == 0)
11582     return elfcore_write_ppc_tm_cdscr (abfd, buf, bufsiz, data, size);
11583   if (strcmp (section, ".reg-s390-high-gprs") == 0)
11584     return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
11585   if (strcmp (section, ".reg-s390-timer") == 0)
11586     return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11587   if (strcmp (section, ".reg-s390-todcmp") == 0)
11588     return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11589   if (strcmp (section, ".reg-s390-todpreg") == 0)
11590     return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11591   if (strcmp (section, ".reg-s390-ctrs") == 0)
11592     return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11593   if (strcmp (section, ".reg-s390-prefix") == 0)
11594     return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
11595   if (strcmp (section, ".reg-s390-last-break") == 0)
11596     return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11597   if (strcmp (section, ".reg-s390-system-call") == 0)
11598     return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
11599   if (strcmp (section, ".reg-s390-tdb") == 0)
11600     return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
11601   if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11602     return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11603   if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11604     return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
11605   if (strcmp (section, ".reg-s390-gs-cb") == 0)
11606     return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11607   if (strcmp (section, ".reg-s390-gs-bc") == 0)
11608     return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
11609   if (strcmp (section, ".reg-arm-vfp") == 0)
11610     return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
11611   if (strcmp (section, ".reg-aarch-tls") == 0)
11612     return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11613   if (strcmp (section, ".reg-aarch-hw-break") == 0)
11614     return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11615   if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11616     return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
11617   if (strcmp (section, ".reg-aarch-sve") == 0)
11618     return elfcore_write_aarch_sve (abfd, buf, bufsiz, data, size);
11619   if (strcmp (section, ".reg-aarch-pauth") == 0)
11620     return elfcore_write_aarch_pauth (abfd, buf, bufsiz, data, size);
11621   return NULL;
11622 }
11623
11624 static bfd_boolean
11625 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11626                  size_t align)
11627 {
11628   char *p;
11629
11630   /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11631      gABI specifies that PT_NOTE alignment should be aligned to 4
11632      bytes for 32-bit objects and to 8 bytes for 64-bit objects.  If
11633      align is less than 4, we use 4 byte alignment.   */
11634   if (align < 4)
11635     align = 4;
11636   if (align != 4 && align != 8)
11637     return FALSE;
11638
11639   p = buf;
11640   while (p < buf + size)
11641     {
11642       Elf_External_Note *xnp = (Elf_External_Note *) p;
11643       Elf_Internal_Note in;
11644
11645       if (offsetof (Elf_External_Note, name) > buf - p + size)
11646         return FALSE;
11647
11648       in.type = H_GET_32 (abfd, xnp->type);
11649
11650       in.namesz = H_GET_32 (abfd, xnp->namesz);
11651       in.namedata = xnp->name;
11652       if (in.namesz > buf - in.namedata + size)
11653         return FALSE;
11654
11655       in.descsz = H_GET_32 (abfd, xnp->descsz);
11656       in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
11657       in.descpos = offset + (in.descdata - buf);
11658       if (in.descsz != 0
11659           && (in.descdata >= buf + size
11660               || in.descsz > buf - in.descdata + size))
11661         return FALSE;
11662
11663       switch (bfd_get_format (abfd))
11664         {
11665         default:
11666           return TRUE;
11667
11668         case bfd_core:
11669           {
11670 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11671             struct
11672             {
11673               const char * string;
11674               size_t len;
11675               bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
11676             }
11677             grokers[] =
11678             {
11679               GROKER_ELEMENT ("", elfcore_grok_note),
11680               GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
11681               GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11682               GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11683               GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11684               GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
11685             };
11686 #undef GROKER_ELEMENT
11687             int i;
11688
11689             for (i = ARRAY_SIZE (grokers); i--;)
11690               {
11691                 if (in.namesz >= grokers[i].len
11692                     && strncmp (in.namedata, grokers[i].string,
11693                                 grokers[i].len) == 0)
11694                   {
11695                     if (! grokers[i].func (abfd, & in))
11696                       return FALSE;
11697                     break;
11698                   }
11699               }
11700             break;
11701           }
11702
11703         case bfd_object:
11704           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11705             {
11706               if (! elfobj_grok_gnu_note (abfd, &in))
11707                 return FALSE;
11708             }
11709           else if (in.namesz == sizeof "stapsdt"
11710                    && strcmp (in.namedata, "stapsdt") == 0)
11711             {
11712               if (! elfobj_grok_stapsdt_note (abfd, &in))
11713                 return FALSE;
11714             }
11715           break;
11716         }
11717
11718       p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
11719     }
11720
11721   return TRUE;
11722 }
11723
11724 static bfd_boolean
11725 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11726                 size_t align)
11727 {
11728   char *buf;
11729
11730   if (size == 0 || (size + 1) == 0)
11731     return TRUE;
11732
11733   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11734     return FALSE;
11735
11736   buf = (char *) bfd_malloc (size + 1);
11737   if (buf == NULL)
11738     return FALSE;
11739
11740   /* PR 17512: file: ec08f814
11741      0-termintate the buffer so that string searches will not overflow.  */
11742   buf[size] = 0;
11743
11744   if (bfd_bread (buf, size, abfd) != size
11745       || !elf_parse_notes (abfd, buf, size, offset, align))
11746     {
11747       free (buf);
11748       return FALSE;
11749     }
11750
11751   free (buf);
11752   return TRUE;
11753 }
11754 \f
11755 /* Providing external access to the ELF program header table.  */
11756
11757 /* Return an upper bound on the number of bytes required to store a
11758    copy of ABFD's program header table entries.  Return -1 if an error
11759    occurs; bfd_get_error will return an appropriate code.  */
11760
11761 long
11762 bfd_get_elf_phdr_upper_bound (bfd *abfd)
11763 {
11764   if (abfd->xvec->flavour != bfd_target_elf_flavour)
11765     {
11766       bfd_set_error (bfd_error_wrong_format);
11767       return -1;
11768     }
11769
11770   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
11771 }
11772
11773 /* Copy ABFD's program header table entries to *PHDRS.  The entries
11774    will be stored as an array of Elf_Internal_Phdr structures, as
11775    defined in include/elf/internal.h.  To find out how large the
11776    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11777
11778    Return the number of program header table entries read, or -1 if an
11779    error occurs; bfd_get_error will return an appropriate code.  */
11780
11781 int
11782 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
11783 {
11784   int num_phdrs;
11785
11786   if (abfd->xvec->flavour != bfd_target_elf_flavour)
11787     {
11788       bfd_set_error (bfd_error_wrong_format);
11789       return -1;
11790     }
11791
11792   num_phdrs = elf_elfheader (abfd)->e_phnum;
11793   if (num_phdrs != 0)
11794     memcpy (phdrs, elf_tdata (abfd)->phdr,
11795             num_phdrs * sizeof (Elf_Internal_Phdr));
11796
11797   return num_phdrs;
11798 }
11799
11800 enum elf_reloc_type_class
11801 _bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11802                            const asection *rel_sec ATTRIBUTE_UNUSED,
11803                            const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
11804 {
11805   return reloc_class_normal;
11806 }
11807
11808 /* For RELA architectures, return the relocation value for a
11809    relocation against a local symbol.  */
11810
11811 bfd_vma
11812 _bfd_elf_rela_local_sym (bfd *abfd,
11813                          Elf_Internal_Sym *sym,
11814                          asection **psec,
11815                          Elf_Internal_Rela *rel)
11816 {
11817   asection *sec = *psec;
11818   bfd_vma relocation;
11819
11820   relocation = (sec->output_section->vma
11821                 + sec->output_offset
11822                 + sym->st_value);
11823   if ((sec->flags & SEC_MERGE)
11824       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
11825       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
11826     {
11827       rel->r_addend =
11828         _bfd_merged_section_offset (abfd, psec,
11829                                     elf_section_data (sec)->sec_info,
11830                                     sym->st_value + rel->r_addend);
11831       if (sec != *psec)
11832         {
11833           /* If we have changed the section, and our original section is
11834              marked with SEC_EXCLUDE, it means that the original
11835              SEC_MERGE section has been completely subsumed in some
11836              other SEC_MERGE section.  In this case, we need to leave
11837              some info around for --emit-relocs.  */
11838           if ((sec->flags & SEC_EXCLUDE) != 0)
11839             sec->kept_section = *psec;
11840           sec = *psec;
11841         }
11842       rel->r_addend -= relocation;
11843       rel->r_addend += sec->output_section->vma + sec->output_offset;
11844     }
11845   return relocation;
11846 }
11847
11848 bfd_vma
11849 _bfd_elf_rel_local_sym (bfd *abfd,
11850                         Elf_Internal_Sym *sym,
11851                         asection **psec,
11852                         bfd_vma addend)
11853 {
11854   asection *sec = *psec;
11855
11856   if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
11857     return sym->st_value + addend;
11858
11859   return _bfd_merged_section_offset (abfd, psec,
11860                                      elf_section_data (sec)->sec_info,
11861                                      sym->st_value + addend);
11862 }
11863
11864 /* Adjust an address within a section.  Given OFFSET within SEC, return
11865    the new offset within the section, based upon changes made to the
11866    section.  Returns -1 if the offset is now invalid.
11867    The offset (in abnd out) is in target sized bytes, however big a
11868    byte may be.  */
11869
11870 bfd_vma
11871 _bfd_elf_section_offset (bfd *abfd,
11872                          struct bfd_link_info *info,
11873                          asection *sec,
11874                          bfd_vma offset)
11875 {
11876   switch (sec->sec_info_type)
11877     {
11878     case SEC_INFO_TYPE_STABS:
11879       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11880                                        offset);
11881     case SEC_INFO_TYPE_EH_FRAME:
11882       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
11883
11884     default:
11885       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11886         {
11887           /* Reverse the offset.  */
11888           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11889           bfd_size_type address_size = bed->s->arch_size / 8;
11890
11891           /* address_size and sec->size are in octets.  Convert
11892              to bytes before subtracting the original offset.  */
11893           offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
11894         }
11895       return offset;
11896     }
11897 }
11898 \f
11899 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
11900    reconstruct an ELF file by reading the segments out of remote memory
11901    based on the ELF file header at EHDR_VMA and the ELF program headers it
11902    points to.  If not null, *LOADBASEP is filled in with the difference
11903    between the VMAs from which the segments were read, and the VMAs the
11904    file headers (and hence BFD's idea of each section's VMA) put them at.
11905
11906    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11907    remote memory at target address VMA into the local buffer at MYADDR; it
11908    should return zero on success or an `errno' code on failure.  TEMPL must
11909    be a BFD for an ELF target with the word size and byte order found in
11910    the remote memory.  */
11911
11912 bfd *
11913 bfd_elf_bfd_from_remote_memory
11914   (bfd *templ,
11915    bfd_vma ehdr_vma,
11916    bfd_size_type size,
11917    bfd_vma *loadbasep,
11918    int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
11919 {
11920   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
11921     (templ, ehdr_vma, size, loadbasep, target_read_memory);
11922 }
11923 \f
11924 long
11925 _bfd_elf_get_synthetic_symtab (bfd *abfd,
11926                                long symcount ATTRIBUTE_UNUSED,
11927                                asymbol **syms ATTRIBUTE_UNUSED,
11928                                long dynsymcount,
11929                                asymbol **dynsyms,
11930                                asymbol **ret)
11931 {
11932   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11933   asection *relplt;
11934   asymbol *s;
11935   const char *relplt_name;
11936   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11937   arelent *p;
11938   long count, i, n;
11939   size_t size;
11940   Elf_Internal_Shdr *hdr;
11941   char *names;
11942   asection *plt;
11943
11944   *ret = NULL;
11945
11946   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
11947     return 0;
11948
11949   if (dynsymcount <= 0)
11950     return 0;
11951
11952   if (!bed->plt_sym_val)
11953     return 0;
11954
11955   relplt_name = bed->relplt_name;
11956   if (relplt_name == NULL)
11957     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
11958   relplt = bfd_get_section_by_name (abfd, relplt_name);
11959   if (relplt == NULL)
11960     return 0;
11961
11962   hdr = &elf_section_data (relplt)->this_hdr;
11963   if (hdr->sh_link != elf_dynsymtab (abfd)
11964       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
11965     return 0;
11966
11967   plt = bfd_get_section_by_name (abfd, ".plt");
11968   if (plt == NULL)
11969     return 0;
11970
11971   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
11972   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
11973     return -1;
11974
11975   count = relplt->size / hdr->sh_entsize;
11976   size = count * sizeof (asymbol);
11977   p = relplt->relocation;
11978   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11979     {
11980       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
11981       if (p->addend != 0)
11982         {
11983 #ifdef BFD64
11984           size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
11985 #else
11986           size += sizeof ("+0x") - 1 + 8;
11987 #endif
11988         }
11989     }
11990
11991   s = *ret = (asymbol *) bfd_malloc (size);
11992   if (s == NULL)
11993     return -1;
11994
11995   names = (char *) (s + count);
11996   p = relplt->relocation;
11997   n = 0;
11998   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11999     {
12000       size_t len;
12001       bfd_vma addr;
12002
12003       addr = bed->plt_sym_val (i, plt, p);
12004       if (addr == (bfd_vma) -1)
12005         continue;
12006
12007       *s = **p->sym_ptr_ptr;
12008       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
12009          we are defining a symbol, ensure one of them is set.  */
12010       if ((s->flags & BSF_LOCAL) == 0)
12011         s->flags |= BSF_GLOBAL;
12012       s->flags |= BSF_SYNTHETIC;
12013       s->section = plt;
12014       s->value = addr - plt->vma;
12015       s->name = names;
12016       s->udata.p = NULL;
12017       len = strlen ((*p->sym_ptr_ptr)->name);
12018       memcpy (names, (*p->sym_ptr_ptr)->name, len);
12019       names += len;
12020       if (p->addend != 0)
12021         {
12022           char buf[30], *a;
12023
12024           memcpy (names, "+0x", sizeof ("+0x") - 1);
12025           names += sizeof ("+0x") - 1;
12026           bfd_sprintf_vma (abfd, buf, p->addend);
12027           for (a = buf; *a == '0'; ++a)
12028             ;
12029           len = strlen (a);
12030           memcpy (names, a, len);
12031           names += len;
12032         }
12033       memcpy (names, "@plt", sizeof ("@plt"));
12034       names += sizeof ("@plt");
12035       ++s, ++n;
12036     }
12037
12038   return n;
12039 }
12040
12041 /* It is only used by x86-64 so far.
12042    ??? This repeats *COM* id of zero.  sec->id is supposed to be unique,
12043    but current usage would allow all of _bfd_std_section to be zero.  */
12044 static const asymbol lcomm_sym
12045   = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
12046 asection _bfd_elf_large_com_section
12047   = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
12048                       "LARGE_COMMON", 0, SEC_IS_COMMON);
12049
12050 void
12051 _bfd_elf_post_process_headers (bfd * abfd,
12052                                struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
12053 {
12054   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
12055
12056   i_ehdrp = elf_elfheader (abfd);
12057
12058   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
12059
12060   /* To make things simpler for the loader on Linux systems we set the
12061      osabi field to ELFOSABI_GNU if the binary contains symbols of
12062      the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding.  */
12063   if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
12064       && elf_tdata (abfd)->has_gnu_symbols)
12065     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
12066 }
12067
12068
12069 /* Return TRUE for ELF symbol types that represent functions.
12070    This is the default version of this function, which is sufficient for
12071    most targets.  It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC.  */
12072
12073 bfd_boolean
12074 _bfd_elf_is_function_type (unsigned int type)
12075 {
12076   return (type == STT_FUNC
12077           || type == STT_GNU_IFUNC);
12078 }
12079
12080 /* If the ELF symbol SYM might be a function in SEC, return the
12081    function size and set *CODE_OFF to the function's entry point,
12082    otherwise return zero.  */
12083
12084 bfd_size_type
12085 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
12086                              bfd_vma *code_off)
12087 {
12088   bfd_size_type size;
12089
12090   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
12091                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
12092       || sym->section != sec)
12093     return 0;
12094
12095   *code_off = sym->value;
12096   size = 0;
12097   if (!(sym->flags & BSF_SYNTHETIC))
12098     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
12099   if (size == 0)
12100     size = 1;
12101   return size;
12102 }