gdb: Temporarily revert modifications for branch merge
[dragonfly.git] / contrib / gdb-7 / bfd / elf.c
1 /* ELF executable support for BFD.
2
3    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5    Free Software Foundation, Inc.
6
7    This file is part of BFD, the Binary File Descriptor library.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22    MA 02110-1301, USA.  */
23
24
25 /*
26 SECTION
27         ELF backends
28
29         BFD support for ELF formats is being worked on.
30         Currently, the best supported back ends are for sparc and i386
31         (running svr4 or Solaris 2).
32
33         Documentation of the internals of the support code still needs
34         to be written.  The code is changing quickly enough that we
35         haven't bothered yet.  */
36
37 /* For sparc64-cross-sparc32.  */
38 #define _SYSCALL32
39 #include "sysdep.h"
40 #include "bfd.h"
41 #include "bfdlink.h"
42 #include "libbfd.h"
43 #define ARCH_SIZE 0
44 #include "elf-bfd.h"
45 #include "libiberty.h"
46 #include "safe-ctype.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 bfd_strtab_hash **, int) ;
56 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
57 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
58                                     file_ptr offset);
59
60 /* Swap version information in and out.  The version information is
61    currently size independent.  If that ever changes, this code will
62    need to move into elfcode.h.  */
63
64 /* Swap in a Verdef structure.  */
65
66 void
67 _bfd_elf_swap_verdef_in (bfd *abfd,
68                          const Elf_External_Verdef *src,
69                          Elf_Internal_Verdef *dst)
70 {
71   dst->vd_version = H_GET_16 (abfd, src->vd_version);
72   dst->vd_flags   = H_GET_16 (abfd, src->vd_flags);
73   dst->vd_ndx     = H_GET_16 (abfd, src->vd_ndx);
74   dst->vd_cnt     = H_GET_16 (abfd, src->vd_cnt);
75   dst->vd_hash    = H_GET_32 (abfd, src->vd_hash);
76   dst->vd_aux     = H_GET_32 (abfd, src->vd_aux);
77   dst->vd_next    = H_GET_32 (abfd, src->vd_next);
78 }
79
80 /* Swap out a Verdef structure.  */
81
82 void
83 _bfd_elf_swap_verdef_out (bfd *abfd,
84                           const Elf_Internal_Verdef *src,
85                           Elf_External_Verdef *dst)
86 {
87   H_PUT_16 (abfd, src->vd_version, dst->vd_version);
88   H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
89   H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
90   H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
91   H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
92   H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
93   H_PUT_32 (abfd, src->vd_next, dst->vd_next);
94 }
95
96 /* Swap in a Verdaux structure.  */
97
98 void
99 _bfd_elf_swap_verdaux_in (bfd *abfd,
100                           const Elf_External_Verdaux *src,
101                           Elf_Internal_Verdaux *dst)
102 {
103   dst->vda_name = H_GET_32 (abfd, src->vda_name);
104   dst->vda_next = H_GET_32 (abfd, src->vda_next);
105 }
106
107 /* Swap out a Verdaux structure.  */
108
109 void
110 _bfd_elf_swap_verdaux_out (bfd *abfd,
111                            const Elf_Internal_Verdaux *src,
112                            Elf_External_Verdaux *dst)
113 {
114   H_PUT_32 (abfd, src->vda_name, dst->vda_name);
115   H_PUT_32 (abfd, src->vda_next, dst->vda_next);
116 }
117
118 /* Swap in a Verneed structure.  */
119
120 void
121 _bfd_elf_swap_verneed_in (bfd *abfd,
122                           const Elf_External_Verneed *src,
123                           Elf_Internal_Verneed *dst)
124 {
125   dst->vn_version = H_GET_16 (abfd, src->vn_version);
126   dst->vn_cnt     = H_GET_16 (abfd, src->vn_cnt);
127   dst->vn_file    = H_GET_32 (abfd, src->vn_file);
128   dst->vn_aux     = H_GET_32 (abfd, src->vn_aux);
129   dst->vn_next    = H_GET_32 (abfd, src->vn_next);
130 }
131
132 /* Swap out a Verneed structure.  */
133
134 void
135 _bfd_elf_swap_verneed_out (bfd *abfd,
136                            const Elf_Internal_Verneed *src,
137                            Elf_External_Verneed *dst)
138 {
139   H_PUT_16 (abfd, src->vn_version, dst->vn_version);
140   H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
141   H_PUT_32 (abfd, src->vn_file, dst->vn_file);
142   H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
143   H_PUT_32 (abfd, src->vn_next, dst->vn_next);
144 }
145
146 /* Swap in a Vernaux structure.  */
147
148 void
149 _bfd_elf_swap_vernaux_in (bfd *abfd,
150                           const Elf_External_Vernaux *src,
151                           Elf_Internal_Vernaux *dst)
152 {
153   dst->vna_hash  = H_GET_32 (abfd, src->vna_hash);
154   dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
155   dst->vna_other = H_GET_16 (abfd, src->vna_other);
156   dst->vna_name  = H_GET_32 (abfd, src->vna_name);
157   dst->vna_next  = H_GET_32 (abfd, src->vna_next);
158 }
159
160 /* Swap out a Vernaux structure.  */
161
162 void
163 _bfd_elf_swap_vernaux_out (bfd *abfd,
164                            const Elf_Internal_Vernaux *src,
165                            Elf_External_Vernaux *dst)
166 {
167   H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
168   H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
169   H_PUT_16 (abfd, src->vna_other, dst->vna_other);
170   H_PUT_32 (abfd, src->vna_name, dst->vna_name);
171   H_PUT_32 (abfd, src->vna_next, dst->vna_next);
172 }
173
174 /* Swap in a Versym structure.  */
175
176 void
177 _bfd_elf_swap_versym_in (bfd *abfd,
178                          const Elf_External_Versym *src,
179                          Elf_Internal_Versym *dst)
180 {
181   dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
182 }
183
184 /* Swap out a Versym structure.  */
185
186 void
187 _bfd_elf_swap_versym_out (bfd *abfd,
188                           const Elf_Internal_Versym *src,
189                           Elf_External_Versym *dst)
190 {
191   H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
192 }
193
194 /* Standard ELF hash function.  Do not change this function; you will
195    cause invalid hash tables to be generated.  */
196
197 unsigned long
198 bfd_elf_hash (const char *namearg)
199 {
200   const unsigned char *name = (const unsigned char *) namearg;
201   unsigned long h = 0;
202   unsigned long g;
203   int ch;
204
205   while ((ch = *name++) != '\0')
206     {
207       h = (h << 4) + ch;
208       if ((g = (h & 0xf0000000)) != 0)
209         {
210           h ^= g >> 24;
211           /* The ELF ABI says `h &= ~g', but this is equivalent in
212              this case and on some machines one insn instead of two.  */
213           h ^= g;
214         }
215     }
216   return h & 0xffffffff;
217 }
218
219 /* DT_GNU_HASH hash function.  Do not change this function; you will
220    cause invalid hash tables to be generated.  */
221
222 unsigned long
223 bfd_elf_gnu_hash (const char *namearg)
224 {
225   const unsigned char *name = (const unsigned char *) namearg;
226   unsigned long h = 5381;
227   unsigned char ch;
228
229   while ((ch = *name++) != '\0')
230     h = (h << 5) + h + ch;
231   return h & 0xffffffff;
232 }
233
234 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
235    the object_id field of an elf_obj_tdata field set to OBJECT_ID.  */
236 bfd_boolean
237 bfd_elf_allocate_object (bfd *abfd,
238                          size_t object_size,
239                          enum elf_target_id object_id)
240 {
241   BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
242   abfd->tdata.any = bfd_zalloc (abfd, object_size);
243   if (abfd->tdata.any == NULL)
244     return FALSE;
245
246   elf_object_id (abfd) = object_id;
247   elf_program_header_size (abfd) = (bfd_size_type) -1;
248   return TRUE;
249 }
250
251
252 bfd_boolean
253 bfd_elf_make_object (bfd *abfd)
254 {
255   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
256   return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
257                                   bed->target_id);
258 }
259
260 bfd_boolean
261 bfd_elf_mkcorefile (bfd *abfd)
262 {
263   /* I think this can be done just like an object file.  */
264   return abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd);
265 }
266
267 static char *
268 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
269 {
270   Elf_Internal_Shdr **i_shdrp;
271   bfd_byte *shstrtab = NULL;
272   file_ptr offset;
273   bfd_size_type shstrtabsize;
274
275   i_shdrp = elf_elfsections (abfd);
276   if (i_shdrp == 0
277       || shindex >= elf_numsections (abfd)
278       || i_shdrp[shindex] == 0)
279     return NULL;
280
281   shstrtab = i_shdrp[shindex]->contents;
282   if (shstrtab == NULL)
283     {
284       /* No cached one, attempt to read, and cache what we read.  */
285       offset = i_shdrp[shindex]->sh_offset;
286       shstrtabsize = i_shdrp[shindex]->sh_size;
287
288       /* Allocate and clear an extra byte at the end, to prevent crashes
289          in case the string table is not terminated.  */
290       if (shstrtabsize + 1 <= 1
291           || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL
292           || bfd_seek (abfd, offset, SEEK_SET) != 0)
293         shstrtab = NULL;
294       else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
295         {
296           if (bfd_get_error () != bfd_error_system_call)
297             bfd_set_error (bfd_error_file_truncated);
298           shstrtab = NULL;
299           /* Once we've failed to read it, make sure we don't keep
300              trying.  Otherwise, we'll keep allocating space for
301              the string table over and over.  */
302           i_shdrp[shindex]->sh_size = 0;
303         }
304       else
305         shstrtab[shstrtabsize] = '\0';
306       i_shdrp[shindex]->contents = shstrtab;
307     }
308   return (char *) shstrtab;
309 }
310
311 char *
312 bfd_elf_string_from_elf_section (bfd *abfd,
313                                  unsigned int shindex,
314                                  unsigned int strindex)
315 {
316   Elf_Internal_Shdr *hdr;
317
318   if (strindex == 0)
319     return "";
320
321   if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
322     return NULL;
323
324   hdr = elf_elfsections (abfd)[shindex];
325
326   if (hdr->contents == NULL
327       && bfd_elf_get_str_section (abfd, shindex) == NULL)
328     return NULL;
329
330   if (strindex >= hdr->sh_size)
331     {
332       unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
333       (*_bfd_error_handler)
334         (_("%B: invalid string offset %u >= %lu for section `%s'"),
335          abfd, strindex, (unsigned long) hdr->sh_size,
336          (shindex == shstrndx && strindex == hdr->sh_name
337           ? ".shstrtab"
338           : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
339       return NULL;
340     }
341
342   return ((char *) hdr->contents) + strindex;
343 }
344
345 /* Read and convert symbols to internal format.
346    SYMCOUNT specifies the number of symbols to read, starting from
347    symbol SYMOFFSET.  If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
348    are non-NULL, they are used to store the internal symbols, external
349    symbols, and symbol section index extensions, respectively.
350    Returns a pointer to the internal symbol buffer (malloced if necessary)
351    or NULL if there were no symbols or some kind of problem.  */
352
353 Elf_Internal_Sym *
354 bfd_elf_get_elf_syms (bfd *ibfd,
355                       Elf_Internal_Shdr *symtab_hdr,
356                       size_t symcount,
357                       size_t symoffset,
358                       Elf_Internal_Sym *intsym_buf,
359                       void *extsym_buf,
360                       Elf_External_Sym_Shndx *extshndx_buf)
361 {
362   Elf_Internal_Shdr *shndx_hdr;
363   void *alloc_ext;
364   const bfd_byte *esym;
365   Elf_External_Sym_Shndx *alloc_extshndx;
366   Elf_External_Sym_Shndx *shndx;
367   Elf_Internal_Sym *alloc_intsym;
368   Elf_Internal_Sym *isym;
369   Elf_Internal_Sym *isymend;
370   const struct elf_backend_data *bed;
371   size_t extsym_size;
372   bfd_size_type amt;
373   file_ptr pos;
374
375   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
376     abort ();
377
378   if (symcount == 0)
379     return intsym_buf;
380
381   /* Normal syms might have section extension entries.  */
382   shndx_hdr = NULL;
383   if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
384     shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
385
386   /* Read the symbols.  */
387   alloc_ext = NULL;
388   alloc_extshndx = NULL;
389   alloc_intsym = NULL;
390   bed = get_elf_backend_data (ibfd);
391   extsym_size = bed->s->sizeof_sym;
392   amt = symcount * extsym_size;
393   pos = symtab_hdr->sh_offset + symoffset * extsym_size;
394   if (extsym_buf == NULL)
395     {
396       alloc_ext = bfd_malloc2 (symcount, extsym_size);
397       extsym_buf = alloc_ext;
398     }
399   if (extsym_buf == NULL
400       || bfd_seek (ibfd, pos, SEEK_SET) != 0
401       || bfd_bread (extsym_buf, amt, ibfd) != amt)
402     {
403       intsym_buf = NULL;
404       goto out;
405     }
406
407   if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
408     extshndx_buf = NULL;
409   else
410     {
411       amt = symcount * sizeof (Elf_External_Sym_Shndx);
412       pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
413       if (extshndx_buf == NULL)
414         {
415           alloc_extshndx = (Elf_External_Sym_Shndx *)
416               bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
417           extshndx_buf = alloc_extshndx;
418         }
419       if (extshndx_buf == NULL
420           || bfd_seek (ibfd, pos, SEEK_SET) != 0
421           || bfd_bread (extshndx_buf, amt, ibfd) != amt)
422         {
423           intsym_buf = NULL;
424           goto out;
425         }
426     }
427
428   if (intsym_buf == NULL)
429     {
430       alloc_intsym = (Elf_Internal_Sym *)
431           bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
432       intsym_buf = alloc_intsym;
433       if (intsym_buf == NULL)
434         goto out;
435     }
436
437   /* Convert the symbols to internal form.  */
438   isymend = intsym_buf + symcount;
439   for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
440            shndx = extshndx_buf;
441        isym < isymend;
442        esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
443     if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
444       {
445         symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
446         (*_bfd_error_handler) (_("%B symbol number %lu references "
447                                  "nonexistent SHT_SYMTAB_SHNDX section"),
448                                ibfd, (unsigned long) symoffset);
449         if (alloc_intsym != NULL)
450           free (alloc_intsym);
451         intsym_buf = NULL;
452         goto out;
453       }
454
455  out:
456   if (alloc_ext != NULL)
457     free (alloc_ext);
458   if (alloc_extshndx != NULL)
459     free (alloc_extshndx);
460
461   return intsym_buf;
462 }
463
464 /* Look up a symbol name.  */
465 const char *
466 bfd_elf_sym_name (bfd *abfd,
467                   Elf_Internal_Shdr *symtab_hdr,
468                   Elf_Internal_Sym *isym,
469                   asection *sym_sec)
470 {
471   const char *name;
472   unsigned int iname = isym->st_name;
473   unsigned int shindex = symtab_hdr->sh_link;
474
475   if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
476       /* Check for a bogus st_shndx to avoid crashing.  */
477       && isym->st_shndx < elf_numsections (abfd))
478     {
479       iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
480       shindex = elf_elfheader (abfd)->e_shstrndx;
481     }
482
483   name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
484   if (name == NULL)
485     name = "(null)";
486   else if (sym_sec && *name == '\0')
487     name = bfd_section_name (abfd, sym_sec);
488
489   return name;
490 }
491
492 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
493    sections.  The first element is the flags, the rest are section
494    pointers.  */
495
496 typedef union elf_internal_group {
497   Elf_Internal_Shdr *shdr;
498   unsigned int flags;
499 } Elf_Internal_Group;
500
501 /* Return the name of the group signature symbol.  Why isn't the
502    signature just a string?  */
503
504 static const char *
505 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
506 {
507   Elf_Internal_Shdr *hdr;
508   unsigned char esym[sizeof (Elf64_External_Sym)];
509   Elf_External_Sym_Shndx eshndx;
510   Elf_Internal_Sym isym;
511
512   /* First we need to ensure the symbol table is available.  Make sure
513      that it is a symbol table section.  */
514   if (ghdr->sh_link >= elf_numsections (abfd))
515     return NULL;
516   hdr = elf_elfsections (abfd) [ghdr->sh_link];
517   if (hdr->sh_type != SHT_SYMTAB
518       || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
519     return NULL;
520
521   /* Go read the symbol.  */
522   hdr = &elf_tdata (abfd)->symtab_hdr;
523   if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
524                             &isym, esym, &eshndx) == NULL)
525     return NULL;
526
527   return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
528 }
529
530 /* Set next_in_group list pointer, and group name for NEWSECT.  */
531
532 static bfd_boolean
533 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
534 {
535   unsigned int num_group = elf_tdata (abfd)->num_group;
536
537   /* If num_group is zero, read in all SHT_GROUP sections.  The count
538      is set to -1 if there are no SHT_GROUP sections.  */
539   if (num_group == 0)
540     {
541       unsigned int i, shnum;
542
543       /* First count the number of groups.  If we have a SHT_GROUP
544          section with just a flag word (ie. sh_size is 4), ignore it.  */
545       shnum = elf_numsections (abfd);
546       num_group = 0;
547
548 #define IS_VALID_GROUP_SECTION_HEADER(shdr)             \
549         (   (shdr)->sh_type == SHT_GROUP                \
550          && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE)     \
551          && (shdr)->sh_entsize == GRP_ENTRY_SIZE        \
552          && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
553
554       for (i = 0; i < shnum; i++)
555         {
556           Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
557
558           if (IS_VALID_GROUP_SECTION_HEADER (shdr))
559             num_group += 1;
560         }
561
562       if (num_group == 0)
563         {
564           num_group = (unsigned) -1;
565           elf_tdata (abfd)->num_group = num_group;
566         }
567       else
568         {
569           /* We keep a list of elf section headers for group sections,
570              so we can find them quickly.  */
571           bfd_size_type amt;
572
573           elf_tdata (abfd)->num_group = num_group;
574           elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
575               bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
576           if (elf_tdata (abfd)->group_sect_ptr == NULL)
577             return FALSE;
578
579           num_group = 0;
580           for (i = 0; i < shnum; i++)
581             {
582               Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
583
584               if (IS_VALID_GROUP_SECTION_HEADER (shdr))
585                 {
586                   unsigned char *src;
587                   Elf_Internal_Group *dest;
588
589                   /* Add to list of sections.  */
590                   elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
591                   num_group += 1;
592
593                   /* Read the raw contents.  */
594                   BFD_ASSERT (sizeof (*dest) >= 4);
595                   amt = shdr->sh_size * sizeof (*dest) / 4;
596                   shdr->contents = (unsigned char *)
597                       bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
598                   /* PR binutils/4110: Handle corrupt group headers.  */
599                   if (shdr->contents == NULL)
600                     {
601                       _bfd_error_handler
602                         (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
603                       bfd_set_error (bfd_error_bad_value);
604                       return FALSE;
605                     }
606
607                   memset (shdr->contents, 0, amt);
608
609                   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
610                       || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
611                           != shdr->sh_size))
612                     return FALSE;
613
614                   /* Translate raw contents, a flag word followed by an
615                      array of elf section indices all in target byte order,
616                      to the flag word followed by an array of elf section
617                      pointers.  */
618                   src = shdr->contents + shdr->sh_size;
619                   dest = (Elf_Internal_Group *) (shdr->contents + amt);
620                   while (1)
621                     {
622                       unsigned int idx;
623
624                       src -= 4;
625                       --dest;
626                       idx = H_GET_32 (abfd, src);
627                       if (src == shdr->contents)
628                         {
629                           dest->flags = idx;
630                           if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
631                             shdr->bfd_section->flags
632                               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
633                           break;
634                         }
635                       if (idx >= shnum)
636                         {
637                           ((*_bfd_error_handler)
638                            (_("%B: invalid SHT_GROUP entry"), abfd));
639                           idx = 0;
640                         }
641                       dest->shdr = elf_elfsections (abfd)[idx];
642                     }
643                 }
644             }
645         }
646     }
647
648   if (num_group != (unsigned) -1)
649     {
650       unsigned int i;
651
652       for (i = 0; i < num_group; i++)
653         {
654           Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
655           Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
656           unsigned int n_elt = shdr->sh_size / 4;
657
658           /* Look through this group's sections to see if current
659              section is a member.  */
660           while (--n_elt != 0)
661             if ((++idx)->shdr == hdr)
662               {
663                 asection *s = NULL;
664
665                 /* We are a member of this group.  Go looking through
666                    other members to see if any others are linked via
667                    next_in_group.  */
668                 idx = (Elf_Internal_Group *) shdr->contents;
669                 n_elt = shdr->sh_size / 4;
670                 while (--n_elt != 0)
671                   if ((s = (++idx)->shdr->bfd_section) != NULL
672                       && elf_next_in_group (s) != NULL)
673                     break;
674                 if (n_elt != 0)
675                   {
676                     /* Snarf the group name from other member, and
677                        insert current section in circular list.  */
678                     elf_group_name (newsect) = elf_group_name (s);
679                     elf_next_in_group (newsect) = elf_next_in_group (s);
680                     elf_next_in_group (s) = newsect;
681                   }
682                 else
683                   {
684                     const char *gname;
685
686                     gname = group_signature (abfd, shdr);
687                     if (gname == NULL)
688                       return FALSE;
689                     elf_group_name (newsect) = gname;
690
691                     /* Start a circular list with one element.  */
692                     elf_next_in_group (newsect) = newsect;
693                   }
694
695                 /* If the group section has been created, point to the
696                    new member.  */
697                 if (shdr->bfd_section != NULL)
698                   elf_next_in_group (shdr->bfd_section) = newsect;
699
700                 i = num_group - 1;
701                 break;
702               }
703         }
704     }
705
706   if (elf_group_name (newsect) == NULL)
707     {
708       (*_bfd_error_handler) (_("%B: no group info for section %A"),
709                              abfd, newsect);
710     }
711   return TRUE;
712 }
713
714 bfd_boolean
715 _bfd_elf_setup_sections (bfd *abfd)
716 {
717   unsigned int i;
718   unsigned int num_group = elf_tdata (abfd)->num_group;
719   bfd_boolean result = TRUE;
720   asection *s;
721
722   /* Process SHF_LINK_ORDER.  */
723   for (s = abfd->sections; s != NULL; s = s->next)
724     {
725       Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
726       if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
727         {
728           unsigned int elfsec = this_hdr->sh_link;
729           /* FIXME: The old Intel compiler and old strip/objcopy may
730              not set the sh_link or sh_info fields.  Hence we could
731              get the situation where elfsec is 0.  */
732           if (elfsec == 0)
733             {
734               const struct elf_backend_data *bed = get_elf_backend_data (abfd);
735               if (bed->link_order_error_handler)
736                 bed->link_order_error_handler
737                   (_("%B: warning: sh_link not set for section `%A'"),
738                    abfd, s);
739             }
740           else
741             {
742               asection *linksec = NULL;
743
744               if (elfsec < elf_numsections (abfd))
745                 {
746                   this_hdr = elf_elfsections (abfd)[elfsec];
747                   linksec = this_hdr->bfd_section;
748                 }
749
750               /* PR 1991, 2008:
751                  Some strip/objcopy may leave an incorrect value in
752                  sh_link.  We don't want to proceed.  */
753               if (linksec == NULL)
754                 {
755                   (*_bfd_error_handler)
756                     (_("%B: sh_link [%d] in section `%A' is incorrect"),
757                      s->owner, s, elfsec);
758                   result = FALSE;
759                 }
760
761               elf_linked_to_section (s) = linksec;
762             }
763         }
764     }
765
766   /* Process section groups.  */
767   if (num_group == (unsigned) -1)
768     return result;
769
770   for (i = 0; i < num_group; i++)
771     {
772       Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
773       Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
774       unsigned int n_elt = shdr->sh_size / 4;
775
776       while (--n_elt != 0)
777         if ((++idx)->shdr->bfd_section)
778           elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
779         else if (idx->shdr->sh_type == SHT_RELA
780                  || idx->shdr->sh_type == SHT_REL)
781           /* We won't include relocation sections in section groups in
782              output object files. We adjust the group section size here
783              so that relocatable link will work correctly when
784              relocation sections are in section group in input object
785              files.  */
786           shdr->bfd_section->size -= 4;
787         else
788           {
789             /* There are some unknown sections in the group.  */
790             (*_bfd_error_handler)
791               (_("%B: unknown [%d] section `%s' in group [%s]"),
792                abfd,
793                (unsigned int) idx->shdr->sh_type,
794                bfd_elf_string_from_elf_section (abfd,
795                                                 (elf_elfheader (abfd)
796                                                  ->e_shstrndx),
797                                                 idx->shdr->sh_name),
798                shdr->bfd_section->name);
799             result = FALSE;
800           }
801     }
802   return result;
803 }
804
805 bfd_boolean
806 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
807 {
808   return elf_next_in_group (sec) != NULL;
809 }
810
811 /* Make a BFD section from an ELF section.  We store a pointer to the
812    BFD section in the bfd_section field of the header.  */
813
814 bfd_boolean
815 _bfd_elf_make_section_from_shdr (bfd *abfd,
816                                  Elf_Internal_Shdr *hdr,
817                                  const char *name,
818                                  int shindex)
819 {
820   asection *newsect;
821   flagword flags;
822   const struct elf_backend_data *bed;
823
824   if (hdr->bfd_section != NULL)
825     return TRUE;
826
827   newsect = bfd_make_section_anyway (abfd, name);
828   if (newsect == NULL)
829     return FALSE;
830
831   hdr->bfd_section = newsect;
832   elf_section_data (newsect)->this_hdr = *hdr;
833   elf_section_data (newsect)->this_idx = shindex;
834
835   /* Always use the real type/flags.  */
836   elf_section_type (newsect) = hdr->sh_type;
837   elf_section_flags (newsect) = hdr->sh_flags;
838
839   newsect->filepos = hdr->sh_offset;
840
841   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
842       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
843       || ! bfd_set_section_alignment (abfd, newsect,
844                                       bfd_log2 (hdr->sh_addralign)))
845     return FALSE;
846
847   flags = SEC_NO_FLAGS;
848   if (hdr->sh_type != SHT_NOBITS)
849     flags |= SEC_HAS_CONTENTS;
850   if (hdr->sh_type == SHT_GROUP)
851     flags |= SEC_GROUP | SEC_EXCLUDE;
852   if ((hdr->sh_flags & SHF_ALLOC) != 0)
853     {
854       flags |= SEC_ALLOC;
855       if (hdr->sh_type != SHT_NOBITS)
856         flags |= SEC_LOAD;
857     }
858   if ((hdr->sh_flags & SHF_WRITE) == 0)
859     flags |= SEC_READONLY;
860   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
861     flags |= SEC_CODE;
862   else if ((flags & SEC_LOAD) != 0)
863     flags |= SEC_DATA;
864   if ((hdr->sh_flags & SHF_MERGE) != 0)
865     {
866       flags |= SEC_MERGE;
867       newsect->entsize = hdr->sh_entsize;
868       if ((hdr->sh_flags & SHF_STRINGS) != 0)
869         flags |= SEC_STRINGS;
870     }
871   if (hdr->sh_flags & SHF_GROUP)
872     if (!setup_group (abfd, hdr, newsect))
873       return FALSE;
874   if ((hdr->sh_flags & SHF_TLS) != 0)
875     flags |= SEC_THREAD_LOCAL;
876   if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
877     flags |= SEC_EXCLUDE;
878
879   if ((flags & SEC_ALLOC) == 0)
880     {
881       /* The debugging sections appear to be recognized only by name,
882          not any sort of flag.  Their SEC_ALLOC bits are cleared.  */
883       static const struct
884         {
885           const char *name;
886           int len;
887         } debug_sections [] =
888         {
889           { STRING_COMMA_LEN ("debug") },       /* 'd' */
890           { NULL,                0  },  /* 'e' */
891           { NULL,                0  },  /* 'f' */
892           { STRING_COMMA_LEN ("gnu.linkonce.wi.") },    /* 'g' */
893           { NULL,                0  },  /* 'h' */
894           { NULL,                0  },  /* 'i' */
895           { NULL,                0  },  /* 'j' */
896           { NULL,                0  },  /* 'k' */
897           { STRING_COMMA_LEN ("line") },        /* 'l' */
898           { NULL,                0  },  /* 'm' */
899           { NULL,                0  },  /* 'n' */
900           { NULL,                0  },  /* 'o' */
901           { NULL,                0  },  /* 'p' */
902           { NULL,                0  },  /* 'q' */
903           { NULL,                0  },  /* 'r' */
904           { STRING_COMMA_LEN ("stab") },        /* 's' */
905           { NULL,                0  },  /* 't' */
906           { NULL,                0  },  /* 'u' */
907           { NULL,                0  },  /* 'v' */
908           { NULL,                0  },  /* 'w' */
909           { NULL,                0  },  /* 'x' */
910           { NULL,                0  },  /* 'y' */
911           { STRING_COMMA_LEN ("zdebug") }       /* 'z' */
912         };
913
914       if (name [0] == '.')
915         {
916           int i = name [1] - 'd';
917           if (i >= 0
918               && i < (int) ARRAY_SIZE (debug_sections)
919               && debug_sections [i].name != NULL
920               && strncmp (&name [1], debug_sections [i].name,
921                           debug_sections [i].len) == 0)
922             flags |= SEC_DEBUGGING;
923         }
924     }
925
926   /* As a GNU extension, if the name begins with .gnu.linkonce, we
927      only link a single copy of the section.  This is used to support
928      g++.  g++ will emit each template expansion in its own section.
929      The symbols will be defined as weak, so that multiple definitions
930      are permitted.  The GNU linker extension is to actually discard
931      all but one of the sections.  */
932   if (CONST_STRNEQ (name, ".gnu.linkonce")
933       && elf_next_in_group (newsect) == NULL)
934     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
935
936   bed = get_elf_backend_data (abfd);
937   if (bed->elf_backend_section_flags)
938     if (! bed->elf_backend_section_flags (&flags, hdr))
939       return FALSE;
940
941   if (! bfd_set_section_flags (abfd, newsect, flags))
942     return FALSE;
943
944   /* We do not parse the PT_NOTE segments as we are interested even in the
945      separate debug info files which may have the segments offsets corrupted.
946      PT_NOTEs from the core files are currently not parsed using BFD.  */
947   if (hdr->sh_type == SHT_NOTE)
948     {
949       bfd_byte *contents;
950
951       if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
952         return FALSE;
953
954       elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1);
955       free (contents);
956     }
957
958   if ((flags & SEC_ALLOC) != 0)
959     {
960       Elf_Internal_Phdr *phdr;
961       unsigned int i, nload;
962
963       /* Some ELF linkers produce binaries with all the program header
964          p_paddr fields zero.  If we have such a binary with more than
965          one PT_LOAD header, then leave the section lma equal to vma
966          so that we don't create sections with overlapping lma.  */
967       phdr = elf_tdata (abfd)->phdr;
968       for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
969         if (phdr->p_paddr != 0)
970           break;
971         else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
972           ++nload;
973       if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
974         return TRUE;
975
976       phdr = elf_tdata (abfd)->phdr;
977       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
978         {
979           if (phdr->p_type == PT_LOAD
980               && ELF_SECTION_IN_SEGMENT (hdr, phdr))
981             {
982               if ((flags & SEC_LOAD) == 0)
983                 newsect->lma = (phdr->p_paddr
984                                 + hdr->sh_addr - phdr->p_vaddr);
985               else
986                 /* We used to use the same adjustment for SEC_LOAD
987                    sections, but that doesn't work if the segment
988                    is packed with code from multiple VMAs.
989                    Instead we calculate the section LMA based on
990                    the segment LMA.  It is assumed that the
991                    segment will contain sections with contiguous
992                    LMAs, even if the VMAs are not.  */
993                 newsect->lma = (phdr->p_paddr
994                                 + hdr->sh_offset - phdr->p_offset);
995
996               /* With contiguous segments, we can't tell from file
997                  offsets whether a section with zero size should
998                  be placed at the end of one segment or the
999                  beginning of the next.  Decide based on vaddr.  */
1000               if (hdr->sh_addr >= phdr->p_vaddr
1001                   && (hdr->sh_addr + hdr->sh_size
1002                       <= phdr->p_vaddr + phdr->p_memsz))
1003                 break;
1004             }
1005         }
1006     }
1007
1008   /* Compress/decompress DWARF debug sections with names: .debug_* and
1009      .zdebug_*, after the section flags is set.  */
1010   if ((flags & SEC_DEBUGGING)
1011       && ((name[1] == 'd' && name[6] == '_')
1012           || (name[1] == 'z' && name[7] == '_')))
1013     {
1014       enum { nothing, compress, decompress } action = nothing;
1015       char *new_name;
1016
1017       if (bfd_is_section_compressed (abfd, newsect))
1018         {
1019           /* Compressed section.  Check if we should decompress.  */
1020           if ((abfd->flags & BFD_DECOMPRESS))
1021             action = decompress;
1022         }
1023       else
1024         {
1025           /* Normal section.  Check if we should compress.  */
1026           if ((abfd->flags & BFD_COMPRESS))
1027             action = compress;
1028         }
1029
1030       new_name = NULL;
1031       switch (action)
1032         {
1033         case nothing:
1034           break;
1035         case compress:
1036           if (!bfd_init_section_compress_status (abfd, newsect))
1037             {
1038               (*_bfd_error_handler)
1039                 (_("%B: unable to initialize commpress status for section %s"),
1040                  abfd, name);
1041               return FALSE;
1042             }
1043           if (name[1] != 'z')
1044             {
1045               unsigned int len = strlen (name);
1046
1047               new_name = bfd_alloc (abfd, len + 2);
1048               if (new_name == NULL)
1049                 return FALSE;
1050               new_name[0] = '.';
1051               new_name[1] = 'z';
1052               memcpy (new_name + 2, name + 1, len);
1053             }
1054           break;
1055         case decompress:
1056           if (!bfd_init_section_decompress_status (abfd, newsect))
1057             {
1058               (*_bfd_error_handler)
1059                 (_("%B: unable to initialize decommpress status for section %s"),
1060                  abfd, name);
1061               return FALSE;
1062             }
1063           if (name[1] == 'z')
1064             {
1065               unsigned int len = strlen (name);
1066
1067               new_name = bfd_alloc (abfd, len);
1068               if (new_name == NULL)
1069                 return FALSE;
1070               new_name[0] = '.';
1071               memcpy (new_name + 1, name + 2, len - 1);
1072             }
1073           break;
1074         }
1075       if (new_name != NULL)
1076         bfd_rename_section (abfd, newsect, new_name);
1077     }
1078
1079   return TRUE;
1080 }
1081
1082 const char *const bfd_elf_section_type_names[] = {
1083   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1084   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1085   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1086 };
1087
1088 /* ELF relocs are against symbols.  If we are producing relocatable
1089    output, and the reloc is against an external symbol, and nothing
1090    has given us any additional addend, the resulting reloc will also
1091    be against the same symbol.  In such a case, we don't want to
1092    change anything about the way the reloc is handled, since it will
1093    all be done at final link time.  Rather than put special case code
1094    into bfd_perform_relocation, all the reloc types use this howto
1095    function.  It just short circuits the reloc if producing
1096    relocatable output against an external symbol.  */
1097
1098 bfd_reloc_status_type
1099 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1100                        arelent *reloc_entry,
1101                        asymbol *symbol,
1102                        void *data ATTRIBUTE_UNUSED,
1103                        asection *input_section,
1104                        bfd *output_bfd,
1105                        char **error_message ATTRIBUTE_UNUSED)
1106 {
1107   if (output_bfd != NULL
1108       && (symbol->flags & BSF_SECTION_SYM) == 0
1109       && (! reloc_entry->howto->partial_inplace
1110           || reloc_entry->addend == 0))
1111     {
1112       reloc_entry->address += input_section->output_offset;
1113       return bfd_reloc_ok;
1114     }
1115
1116   return bfd_reloc_continue;
1117 }
1118 \f
1119 /* Copy the program header and other data from one object module to
1120    another.  */
1121
1122 bfd_boolean
1123 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1124 {
1125   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1126       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1127     return TRUE;
1128
1129   BFD_ASSERT (!elf_flags_init (obfd)
1130               || (elf_elfheader (obfd)->e_flags
1131                   == elf_elfheader (ibfd)->e_flags));
1132
1133   elf_gp (obfd) = elf_gp (ibfd);
1134   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1135   elf_flags_init (obfd) = TRUE;
1136
1137   /* Copy object attributes.  */
1138   _bfd_elf_copy_obj_attributes (ibfd, obfd);
1139   return TRUE;
1140 }
1141
1142 static const char *
1143 get_segment_type (unsigned int p_type)
1144 {
1145   const char *pt;
1146   switch (p_type)
1147     {
1148     case PT_NULL: pt = "NULL"; break;
1149     case PT_LOAD: pt = "LOAD"; break;
1150     case PT_DYNAMIC: pt = "DYNAMIC"; break;
1151     case PT_INTERP: pt = "INTERP"; break;
1152     case PT_NOTE: pt = "NOTE"; break;
1153     case PT_SHLIB: pt = "SHLIB"; break;
1154     case PT_PHDR: pt = "PHDR"; break;
1155     case PT_TLS: pt = "TLS"; break;
1156     case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1157     case PT_GNU_STACK: pt = "STACK"; break;
1158     case PT_GNU_RELRO: pt = "RELRO"; break;
1159     default: pt = NULL; break;
1160     }
1161   return pt;
1162 }
1163
1164 /* Print out the program headers.  */
1165
1166 bfd_boolean
1167 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1168 {
1169   FILE *f = (FILE *) farg;
1170   Elf_Internal_Phdr *p;
1171   asection *s;
1172   bfd_byte *dynbuf = NULL;
1173
1174   p = elf_tdata (abfd)->phdr;
1175   if (p != NULL)
1176     {
1177       unsigned int i, c;
1178
1179       fprintf (f, _("\nProgram Header:\n"));
1180       c = elf_elfheader (abfd)->e_phnum;
1181       for (i = 0; i < c; i++, p++)
1182         {
1183           const char *pt = get_segment_type (p->p_type);
1184           char buf[20];
1185
1186           if (pt == NULL)
1187             {
1188               sprintf (buf, "0x%lx", p->p_type);
1189               pt = buf;
1190             }
1191           fprintf (f, "%8s off    0x", pt);
1192           bfd_fprintf_vma (abfd, f, p->p_offset);
1193           fprintf (f, " vaddr 0x");
1194           bfd_fprintf_vma (abfd, f, p->p_vaddr);
1195           fprintf (f, " paddr 0x");
1196           bfd_fprintf_vma (abfd, f, p->p_paddr);
1197           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1198           fprintf (f, "         filesz 0x");
1199           bfd_fprintf_vma (abfd, f, p->p_filesz);
1200           fprintf (f, " memsz 0x");
1201           bfd_fprintf_vma (abfd, f, p->p_memsz);
1202           fprintf (f, " flags %c%c%c",
1203                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
1204                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
1205                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
1206           if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1207             fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1208           fprintf (f, "\n");
1209         }
1210     }
1211
1212   s = bfd_get_section_by_name (abfd, ".dynamic");
1213   if (s != NULL)
1214     {
1215       unsigned int elfsec;
1216       unsigned long shlink;
1217       bfd_byte *extdyn, *extdynend;
1218       size_t extdynsize;
1219       void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1220
1221       fprintf (f, _("\nDynamic Section:\n"));
1222
1223       if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1224         goto error_return;
1225
1226       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1227       if (elfsec == SHN_BAD)
1228         goto error_return;
1229       shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1230
1231       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1232       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1233
1234       extdyn = dynbuf;
1235       extdynend = extdyn + s->size;
1236       for (; extdyn < extdynend; extdyn += extdynsize)
1237         {
1238           Elf_Internal_Dyn dyn;
1239           const char *name = "";
1240           char ab[20];
1241           bfd_boolean stringp;
1242           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1243
1244           (*swap_dyn_in) (abfd, extdyn, &dyn);
1245
1246           if (dyn.d_tag == DT_NULL)
1247             break;
1248
1249           stringp = FALSE;
1250           switch (dyn.d_tag)
1251             {
1252             default:
1253               if (bed->elf_backend_get_target_dtag)
1254                 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1255
1256               if (!strcmp (name, ""))
1257                 {
1258                   sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1259                   name = ab;
1260                 }
1261               break;
1262
1263             case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1264             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1265             case DT_PLTGOT: name = "PLTGOT"; break;
1266             case DT_HASH: name = "HASH"; break;
1267             case DT_STRTAB: name = "STRTAB"; break;
1268             case DT_SYMTAB: name = "SYMTAB"; break;
1269             case DT_RELA: name = "RELA"; break;
1270             case DT_RELASZ: name = "RELASZ"; break;
1271             case DT_RELAENT: name = "RELAENT"; break;
1272             case DT_STRSZ: name = "STRSZ"; break;
1273             case DT_SYMENT: name = "SYMENT"; break;
1274             case DT_INIT: name = "INIT"; break;
1275             case DT_FINI: name = "FINI"; break;
1276             case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1277             case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1278             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1279             case DT_REL: name = "REL"; break;
1280             case DT_RELSZ: name = "RELSZ"; break;
1281             case DT_RELENT: name = "RELENT"; break;
1282             case DT_PLTREL: name = "PLTREL"; break;
1283             case DT_DEBUG: name = "DEBUG"; break;
1284             case DT_TEXTREL: name = "TEXTREL"; break;
1285             case DT_JMPREL: name = "JMPREL"; break;
1286             case DT_BIND_NOW: name = "BIND_NOW"; break;
1287             case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1288             case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1289             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1290             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1291             case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1292             case DT_FLAGS: name = "FLAGS"; break;
1293             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1294             case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1295             case DT_CHECKSUM: name = "CHECKSUM"; break;
1296             case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1297             case DT_MOVEENT: name = "MOVEENT"; break;
1298             case DT_MOVESZ: name = "MOVESZ"; break;
1299             case DT_FEATURE: name = "FEATURE"; break;
1300             case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1301             case DT_SYMINSZ: name = "SYMINSZ"; break;
1302             case DT_SYMINENT: name = "SYMINENT"; break;
1303             case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1304             case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1305             case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1306             case DT_PLTPAD: name = "PLTPAD"; break;
1307             case DT_MOVETAB: name = "MOVETAB"; break;
1308             case DT_SYMINFO: name = "SYMINFO"; break;
1309             case DT_RELACOUNT: name = "RELACOUNT"; break;
1310             case DT_RELCOUNT: name = "RELCOUNT"; break;
1311             case DT_FLAGS_1: name = "FLAGS_1"; break;
1312             case DT_VERSYM: name = "VERSYM"; break;
1313             case DT_VERDEF: name = "VERDEF"; break;
1314             case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1315             case DT_VERNEED: name = "VERNEED"; break;
1316             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1317             case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1318             case DT_USED: name = "USED"; break;
1319             case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1320             case DT_GNU_HASH: name = "GNU_HASH"; break;
1321             }
1322
1323           fprintf (f, "  %-20s ", name);
1324           if (! stringp)
1325             {
1326               fprintf (f, "0x");
1327               bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1328             }
1329           else
1330             {
1331               const char *string;
1332               unsigned int tagv = dyn.d_un.d_val;
1333
1334               string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1335               if (string == NULL)
1336                 goto error_return;
1337               fprintf (f, "%s", string);
1338             }
1339           fprintf (f, "\n");
1340         }
1341
1342       free (dynbuf);
1343       dynbuf = NULL;
1344     }
1345
1346   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1347       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1348     {
1349       if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1350         return FALSE;
1351     }
1352
1353   if (elf_dynverdef (abfd) != 0)
1354     {
1355       Elf_Internal_Verdef *t;
1356
1357       fprintf (f, _("\nVersion definitions:\n"));
1358       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1359         {
1360           fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1361                    t->vd_flags, t->vd_hash,
1362                    t->vd_nodename ? t->vd_nodename : "<corrupt>");
1363           if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1364             {
1365               Elf_Internal_Verdaux *a;
1366
1367               fprintf (f, "\t");
1368               for (a = t->vd_auxptr->vda_nextptr;
1369                    a != NULL;
1370                    a = a->vda_nextptr)
1371                 fprintf (f, "%s ",
1372                          a->vda_nodename ? a->vda_nodename : "<corrupt>");
1373               fprintf (f, "\n");
1374             }
1375         }
1376     }
1377
1378   if (elf_dynverref (abfd) != 0)
1379     {
1380       Elf_Internal_Verneed *t;
1381
1382       fprintf (f, _("\nVersion References:\n"));
1383       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1384         {
1385           Elf_Internal_Vernaux *a;
1386
1387           fprintf (f, _("  required from %s:\n"),
1388                    t->vn_filename ? t->vn_filename : "<corrupt>");
1389           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1390             fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1391                      a->vna_flags, a->vna_other,
1392                      a->vna_nodename ? a->vna_nodename : "<corrupt>");
1393         }
1394     }
1395
1396   return TRUE;
1397
1398  error_return:
1399   if (dynbuf != NULL)
1400     free (dynbuf);
1401   return FALSE;
1402 }
1403
1404 /* Display ELF-specific fields of a symbol.  */
1405
1406 void
1407 bfd_elf_print_symbol (bfd *abfd,
1408                       void *filep,
1409                       asymbol *symbol,
1410                       bfd_print_symbol_type how)
1411 {
1412   FILE *file = (FILE *) filep;
1413   switch (how)
1414     {
1415     case bfd_print_symbol_name:
1416       fprintf (file, "%s", symbol->name);
1417       break;
1418     case bfd_print_symbol_more:
1419       fprintf (file, "elf ");
1420       bfd_fprintf_vma (abfd, file, symbol->value);
1421       fprintf (file, " %lx", (unsigned long) symbol->flags);
1422       break;
1423     case bfd_print_symbol_all:
1424       {
1425         const char *section_name;
1426         const char *name = NULL;
1427         const struct elf_backend_data *bed;
1428         unsigned char st_other;
1429         bfd_vma val;
1430
1431         section_name = symbol->section ? symbol->section->name : "(*none*)";
1432
1433         bed = get_elf_backend_data (abfd);
1434         if (bed->elf_backend_print_symbol_all)
1435           name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1436
1437         if (name == NULL)
1438           {
1439             name = symbol->name;
1440             bfd_print_symbol_vandf (abfd, file, symbol);
1441           }
1442
1443         fprintf (file, " %s\t", section_name);
1444         /* Print the "other" value for a symbol.  For common symbols,
1445            we've already printed the size; now print the alignment.
1446            For other symbols, we have no specified alignment, and
1447            we've printed the address; now print the size.  */
1448         if (symbol->section && bfd_is_com_section (symbol->section))
1449           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1450         else
1451           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1452         bfd_fprintf_vma (abfd, file, val);
1453
1454         /* If we have version information, print it.  */
1455         if (elf_tdata (abfd)->dynversym_section != 0
1456             && (elf_tdata (abfd)->dynverdef_section != 0
1457                 || elf_tdata (abfd)->dynverref_section != 0))
1458           {
1459             unsigned int vernum;
1460             const char *version_string;
1461
1462             vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1463
1464             if (vernum == 0)
1465               version_string = "";
1466             else if (vernum == 1)
1467               version_string = "Base";
1468             else if (vernum <= elf_tdata (abfd)->cverdefs)
1469               version_string =
1470                 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1471             else
1472               {
1473                 Elf_Internal_Verneed *t;
1474
1475                 version_string = "";
1476                 for (t = elf_tdata (abfd)->verref;
1477                      t != NULL;
1478                      t = t->vn_nextref)
1479                   {
1480                     Elf_Internal_Vernaux *a;
1481
1482                     for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1483                       {
1484                         if (a->vna_other == vernum)
1485                           {
1486                             version_string = a->vna_nodename;
1487                             break;
1488                           }
1489                       }
1490                   }
1491               }
1492
1493             if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1494               fprintf (file, "  %-11s", version_string);
1495             else
1496               {
1497                 int i;
1498
1499                 fprintf (file, " (%s)", version_string);
1500                 for (i = 10 - strlen (version_string); i > 0; --i)
1501                   putc (' ', file);
1502               }
1503           }
1504
1505         /* If the st_other field is not zero, print it.  */
1506         st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1507
1508         switch (st_other)
1509           {
1510           case 0: break;
1511           case STV_INTERNAL:  fprintf (file, " .internal");  break;
1512           case STV_HIDDEN:    fprintf (file, " .hidden");    break;
1513           case STV_PROTECTED: fprintf (file, " .protected"); break;
1514           default:
1515             /* Some other non-defined flags are also present, so print
1516                everything hex.  */
1517             fprintf (file, " 0x%02x", (unsigned int) st_other);
1518           }
1519
1520         fprintf (file, " %s", name);
1521       }
1522       break;
1523     }
1524 }
1525
1526 /* Allocate an ELF string table--force the first byte to be zero.  */
1527
1528 struct bfd_strtab_hash *
1529 _bfd_elf_stringtab_init (void)
1530 {
1531   struct bfd_strtab_hash *ret;
1532
1533   ret = _bfd_stringtab_init ();
1534   if (ret != NULL)
1535     {
1536       bfd_size_type loc;
1537
1538       loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1539       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1540       if (loc == (bfd_size_type) -1)
1541         {
1542           _bfd_stringtab_free (ret);
1543           ret = NULL;
1544         }
1545     }
1546   return ret;
1547 }
1548 \f
1549 /* ELF .o/exec file reading */
1550
1551 /* Create a new bfd section from an ELF section header.  */
1552
1553 bfd_boolean
1554 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1555 {
1556   Elf_Internal_Shdr *hdr;
1557   Elf_Internal_Ehdr *ehdr;
1558   const struct elf_backend_data *bed;
1559   const char *name;
1560
1561   if (shindex >= elf_numsections (abfd))
1562     return FALSE;
1563
1564   hdr = elf_elfsections (abfd)[shindex];
1565   ehdr = elf_elfheader (abfd);
1566   name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1567                                           hdr->sh_name);
1568   if (name == NULL)
1569     return FALSE;
1570
1571   bed = get_elf_backend_data (abfd);
1572   switch (hdr->sh_type)
1573     {
1574     case SHT_NULL:
1575       /* Inactive section. Throw it away.  */
1576       return TRUE;
1577
1578     case SHT_PROGBITS:  /* Normal section with contents.  */
1579     case SHT_NOBITS:    /* .bss section.  */
1580     case SHT_HASH:      /* .hash section.  */
1581     case SHT_NOTE:      /* .note section.  */
1582     case SHT_INIT_ARRAY:        /* .init_array section.  */
1583     case SHT_FINI_ARRAY:        /* .fini_array section.  */
1584     case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
1585     case SHT_GNU_LIBLIST:       /* .gnu.liblist section.  */
1586     case SHT_GNU_HASH:          /* .gnu.hash section.  */
1587       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1588
1589     case SHT_DYNAMIC:   /* Dynamic linking information.  */
1590       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1591         return FALSE;
1592       if (hdr->sh_link > elf_numsections (abfd))
1593         {
1594           /* PR 10478: Accept Solaris binaries with a sh_link
1595              field set to SHN_BEFORE or SHN_AFTER.  */
1596           switch (bfd_get_arch (abfd))
1597             {
1598             case bfd_arch_i386:
1599             case bfd_arch_sparc:
1600               if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1601                   || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1602                 break;
1603               /* Otherwise fall through.  */
1604             default:
1605               return FALSE;
1606             }
1607         }
1608       else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
1609         return FALSE;
1610       else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1611         {
1612           Elf_Internal_Shdr *dynsymhdr;
1613
1614           /* The shared libraries distributed with hpux11 have a bogus
1615              sh_link field for the ".dynamic" section.  Find the
1616              string table for the ".dynsym" section instead.  */
1617           if (elf_dynsymtab (abfd) != 0)
1618             {
1619               dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1620               hdr->sh_link = dynsymhdr->sh_link;
1621             }
1622           else
1623             {
1624               unsigned int i, num_sec;
1625
1626               num_sec = elf_numsections (abfd);
1627               for (i = 1; i < num_sec; i++)
1628                 {
1629                   dynsymhdr = elf_elfsections (abfd)[i];
1630                   if (dynsymhdr->sh_type == SHT_DYNSYM)
1631                     {
1632                       hdr->sh_link = dynsymhdr->sh_link;
1633                       break;
1634                     }
1635                 }
1636             }
1637         }
1638       break;
1639
1640     case SHT_SYMTAB:            /* A symbol table */
1641       if (elf_onesymtab (abfd) == shindex)
1642         return TRUE;
1643
1644       if (hdr->sh_entsize != bed->s->sizeof_sym)
1645         return FALSE;
1646       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
1647         return FALSE;
1648       BFD_ASSERT (elf_onesymtab (abfd) == 0);
1649       elf_onesymtab (abfd) = shindex;
1650       elf_tdata (abfd)->symtab_hdr = *hdr;
1651       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1652       abfd->flags |= HAS_SYMS;
1653
1654       /* Sometimes a shared object will map in the symbol table.  If
1655          SHF_ALLOC is set, and this is a shared object, then we also
1656          treat this section as a BFD section.  We can not base the
1657          decision purely on SHF_ALLOC, because that flag is sometimes
1658          set in a relocatable object file, which would confuse the
1659          linker.  */
1660       if ((hdr->sh_flags & SHF_ALLOC) != 0
1661           && (abfd->flags & DYNAMIC) != 0
1662           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1663                                                 shindex))
1664         return FALSE;
1665
1666       /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1667          can't read symbols without that section loaded as well.  It
1668          is most likely specified by the next section header.  */
1669       if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1670         {
1671           unsigned int i, num_sec;
1672
1673           num_sec = elf_numsections (abfd);
1674           for (i = shindex + 1; i < num_sec; i++)
1675             {
1676               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1677               if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1678                   && hdr2->sh_link == shindex)
1679                 break;
1680             }
1681           if (i == num_sec)
1682             for (i = 1; i < shindex; i++)
1683               {
1684                 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1685                 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1686                     && hdr2->sh_link == shindex)
1687                   break;
1688               }
1689           if (i != shindex)
1690             return bfd_section_from_shdr (abfd, i);
1691         }
1692       return TRUE;
1693
1694     case SHT_DYNSYM:            /* A dynamic symbol table */
1695       if (elf_dynsymtab (abfd) == shindex)
1696         return TRUE;
1697
1698       if (hdr->sh_entsize != bed->s->sizeof_sym)
1699         return FALSE;
1700       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1701       elf_dynsymtab (abfd) = shindex;
1702       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1703       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1704       abfd->flags |= HAS_SYMS;
1705
1706       /* Besides being a symbol table, we also treat this as a regular
1707          section, so that objcopy can handle it.  */
1708       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1709
1710     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections */
1711       if (elf_symtab_shndx (abfd) == shindex)
1712         return TRUE;
1713
1714       BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1715       elf_symtab_shndx (abfd) = shindex;
1716       elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1717       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1718       return TRUE;
1719
1720     case SHT_STRTAB:            /* A string table */
1721       if (hdr->bfd_section != NULL)
1722         return TRUE;
1723       if (ehdr->e_shstrndx == shindex)
1724         {
1725           elf_tdata (abfd)->shstrtab_hdr = *hdr;
1726           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1727           return TRUE;
1728         }
1729       if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1730         {
1731         symtab_strtab:
1732           elf_tdata (abfd)->strtab_hdr = *hdr;
1733           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1734           return TRUE;
1735         }
1736       if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1737         {
1738         dynsymtab_strtab:
1739           elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1740           hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1741           elf_elfsections (abfd)[shindex] = hdr;
1742           /* We also treat this as a regular section, so that objcopy
1743              can handle it.  */
1744           return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1745                                                   shindex);
1746         }
1747
1748       /* If the string table isn't one of the above, then treat it as a
1749          regular section.  We need to scan all the headers to be sure,
1750          just in case this strtab section appeared before the above.  */
1751       if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1752         {
1753           unsigned int i, num_sec;
1754
1755           num_sec = elf_numsections (abfd);
1756           for (i = 1; i < num_sec; i++)
1757             {
1758               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1759               if (hdr2->sh_link == shindex)
1760                 {
1761                   /* Prevent endless recursion on broken objects.  */
1762                   if (i == shindex)
1763                     return FALSE;
1764                   if (! bfd_section_from_shdr (abfd, i))
1765                     return FALSE;
1766                   if (elf_onesymtab (abfd) == i)
1767                     goto symtab_strtab;
1768                   if (elf_dynsymtab (abfd) == i)
1769                     goto dynsymtab_strtab;
1770                 }
1771             }
1772         }
1773       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1774
1775     case SHT_REL:
1776     case SHT_RELA:
1777       /* *These* do a lot of work -- but build no sections!  */
1778       {
1779         asection *target_sect;
1780         Elf_Internal_Shdr *hdr2, **p_hdr;
1781         unsigned int num_sec = elf_numsections (abfd);
1782         struct bfd_elf_section_data *esdt;
1783         bfd_size_type amt;
1784
1785         if (hdr->sh_entsize
1786             != (bfd_size_type) (hdr->sh_type == SHT_REL
1787                                 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1788           return FALSE;
1789
1790         /* Check for a bogus link to avoid crashing.  */
1791         if (hdr->sh_link >= num_sec)
1792           {
1793             ((*_bfd_error_handler)
1794              (_("%B: invalid link %lu for reloc section %s (index %u)"),
1795               abfd, hdr->sh_link, name, shindex));
1796             return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1797                                                     shindex);
1798           }
1799
1800         /* For some incomprehensible reason Oracle distributes
1801            libraries for Solaris in which some of the objects have
1802            bogus sh_link fields.  It would be nice if we could just
1803            reject them, but, unfortunately, some people need to use
1804            them.  We scan through the section headers; if we find only
1805            one suitable symbol table, we clobber the sh_link to point
1806            to it.  I hope this doesn't break anything.
1807
1808            Don't do it on executable nor shared library.  */
1809         if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
1810             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1811             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1812           {
1813             unsigned int scan;
1814             int found;
1815
1816             found = 0;
1817             for (scan = 1; scan < num_sec; scan++)
1818               {
1819                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1820                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1821                   {
1822                     if (found != 0)
1823                       {
1824                         found = 0;
1825                         break;
1826                       }
1827                     found = scan;
1828                   }
1829               }
1830             if (found != 0)
1831               hdr->sh_link = found;
1832           }
1833
1834         /* Get the symbol table.  */
1835         if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1836              || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1837             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1838           return FALSE;
1839
1840         /* If this reloc section does not use the main symbol table we
1841            don't treat it as a reloc section.  BFD can't adequately
1842            represent such a section, so at least for now, we don't
1843            try.  We just present it as a normal section.  We also
1844            can't use it as a reloc section if it points to the null
1845            section, an invalid section, another reloc section, or its
1846            sh_link points to the null section.  */
1847         if (hdr->sh_link != elf_onesymtab (abfd)
1848             || hdr->sh_link == SHN_UNDEF
1849             || hdr->sh_info == SHN_UNDEF
1850             || hdr->sh_info >= num_sec
1851             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1852             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
1853           return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1854                                                   shindex);
1855
1856         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1857           return FALSE;
1858         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1859         if (target_sect == NULL)
1860           return FALSE;
1861
1862         esdt = elf_section_data (target_sect);
1863         if (hdr->sh_type == SHT_RELA)
1864           p_hdr = &esdt->rela.hdr;
1865         else
1866           p_hdr = &esdt->rel.hdr;
1867
1868         BFD_ASSERT (*p_hdr == NULL);
1869         amt = sizeof (*hdr2);
1870         hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1871         if (hdr2 == NULL)
1872           return FALSE;
1873         *hdr2 = *hdr;
1874         *p_hdr = hdr2;
1875         elf_elfsections (abfd)[shindex] = hdr2;
1876         target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1877         target_sect->flags |= SEC_RELOC;
1878         target_sect->relocation = NULL;
1879         target_sect->rel_filepos = hdr->sh_offset;
1880         /* In the section to which the relocations apply, mark whether
1881            its relocations are of the REL or RELA variety.  */
1882         if (hdr->sh_size != 0)
1883           {
1884             if (hdr->sh_type == SHT_RELA)
1885               target_sect->use_rela_p = 1;
1886           }
1887         abfd->flags |= HAS_RELOC;
1888         return TRUE;
1889       }
1890
1891     case SHT_GNU_verdef:
1892       elf_dynverdef (abfd) = shindex;
1893       elf_tdata (abfd)->dynverdef_hdr = *hdr;
1894       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1895
1896     case SHT_GNU_versym:
1897       if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1898         return FALSE;
1899       elf_dynversym (abfd) = shindex;
1900       elf_tdata (abfd)->dynversym_hdr = *hdr;
1901       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1902
1903     case SHT_GNU_verneed:
1904       elf_dynverref (abfd) = shindex;
1905       elf_tdata (abfd)->dynverref_hdr = *hdr;
1906       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1907
1908     case SHT_SHLIB:
1909       return TRUE;
1910
1911     case SHT_GROUP:
1912       if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
1913         return FALSE;
1914       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1915         return FALSE;
1916       if (hdr->contents != NULL)
1917         {
1918           Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1919           unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
1920           asection *s;
1921
1922           if (idx->flags & GRP_COMDAT)
1923             hdr->bfd_section->flags
1924               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1925
1926           /* We try to keep the same section order as it comes in.  */
1927           idx += n_elt;
1928           while (--n_elt != 0)
1929             {
1930               --idx;
1931
1932               if (idx->shdr != NULL
1933                   && (s = idx->shdr->bfd_section) != NULL
1934                   && elf_next_in_group (s) != NULL)
1935                 {
1936                   elf_next_in_group (hdr->bfd_section) = s;
1937                   break;
1938                 }
1939             }
1940         }
1941       break;
1942
1943     default:
1944       /* Possibly an attributes section.  */
1945       if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1946           || hdr->sh_type == bed->obj_attrs_section_type)
1947         {
1948           if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1949             return FALSE;
1950           _bfd_elf_parse_attributes (abfd, hdr);
1951           return TRUE;
1952         }
1953
1954       /* Check for any processor-specific section types.  */
1955       if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1956         return TRUE;
1957
1958       if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1959         {
1960           if ((hdr->sh_flags & SHF_ALLOC) != 0)
1961             /* FIXME: How to properly handle allocated section reserved
1962                for applications?  */
1963             (*_bfd_error_handler)
1964               (_("%B: don't know how to handle allocated, application "
1965                  "specific section `%s' [0x%8x]"),
1966                abfd, name, hdr->sh_type);
1967           else
1968             /* Allow sections reserved for applications.  */
1969             return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1970                                                     shindex);
1971         }
1972       else if (hdr->sh_type >= SHT_LOPROC
1973                && hdr->sh_type <= SHT_HIPROC)
1974         /* FIXME: We should handle this section.  */
1975         (*_bfd_error_handler)
1976           (_("%B: don't know how to handle processor specific section "
1977              "`%s' [0x%8x]"),
1978            abfd, name, hdr->sh_type);
1979       else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
1980         {
1981           /* Unrecognised OS-specific sections.  */
1982           if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1983             /* SHF_OS_NONCONFORMING indicates that special knowledge is
1984                required to correctly process the section and the file should
1985                be rejected with an error message.  */
1986             (*_bfd_error_handler)
1987               (_("%B: don't know how to handle OS specific section "
1988                  "`%s' [0x%8x]"),
1989                abfd, name, hdr->sh_type);
1990           else
1991             /* Otherwise it should be processed.  */
1992             return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1993         }
1994       else
1995         /* FIXME: We should handle this section.  */
1996         (*_bfd_error_handler)
1997           (_("%B: don't know how to handle section `%s' [0x%8x]"),
1998            abfd, name, hdr->sh_type);
1999
2000       return FALSE;
2001     }
2002
2003   return TRUE;
2004 }
2005
2006 /* Return the local symbol specified by ABFD, R_SYMNDX.  */
2007
2008 Elf_Internal_Sym *
2009 bfd_sym_from_r_symndx (struct sym_cache *cache,
2010                        bfd *abfd,
2011                        unsigned long r_symndx)
2012 {
2013   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2014
2015   if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2016     {
2017       Elf_Internal_Shdr *symtab_hdr;
2018       unsigned char esym[sizeof (Elf64_External_Sym)];
2019       Elf_External_Sym_Shndx eshndx;
2020
2021       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2022       if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2023                                 &cache->sym[ent], esym, &eshndx) == NULL)
2024         return NULL;
2025
2026       if (cache->abfd != abfd)
2027         {
2028           memset (cache->indx, -1, sizeof (cache->indx));
2029           cache->abfd = abfd;
2030         }
2031       cache->indx[ent] = r_symndx;
2032     }
2033
2034   return &cache->sym[ent];
2035 }
2036
2037 /* Given an ELF section number, retrieve the corresponding BFD
2038    section.  */
2039
2040 asection *
2041 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2042 {
2043   if (sec_index >= elf_numsections (abfd))
2044     return NULL;
2045   return elf_elfsections (abfd)[sec_index]->bfd_section;
2046 }
2047
2048 static const struct bfd_elf_special_section special_sections_b[] =
2049 {
2050   { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2051   { NULL,                   0,  0, 0,            0 }
2052 };
2053
2054 static const struct bfd_elf_special_section special_sections_c[] =
2055 {
2056   { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2057   { NULL,                       0, 0, 0,            0 }
2058 };
2059
2060 static const struct bfd_elf_special_section special_sections_d[] =
2061 {
2062   { STRING_COMMA_LEN (".data"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2063   { STRING_COMMA_LEN (".data1"),         0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2064   { STRING_COMMA_LEN (".debug"),         0, SHT_PROGBITS, 0 },
2065   { STRING_COMMA_LEN (".debug_line"),    0, SHT_PROGBITS, 0 },
2066   { STRING_COMMA_LEN (".debug_info"),    0, SHT_PROGBITS, 0 },
2067   { STRING_COMMA_LEN (".debug_abbrev"),  0, SHT_PROGBITS, 0 },
2068   { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2069   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  SHF_ALLOC },
2070   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   SHF_ALLOC },
2071   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   SHF_ALLOC },
2072   { NULL,                      0,        0, 0,            0 }
2073 };
2074
2075 static const struct bfd_elf_special_section special_sections_f[] =
2076 {
2077   { STRING_COMMA_LEN (".fini"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2078   { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2079   { NULL,                          0, 0, 0,              0 }
2080 };
2081
2082 static const struct bfd_elf_special_section special_sections_g[] =
2083 {
2084   { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS,      SHF_ALLOC + SHF_WRITE },
2085   { STRING_COMMA_LEN (".gnu.lto_"),       -1, SHT_PROGBITS,    SHF_EXCLUDE },
2086   { STRING_COMMA_LEN (".got"),             0, SHT_PROGBITS,    SHF_ALLOC + SHF_WRITE },
2087   { STRING_COMMA_LEN (".gnu.version"),     0, SHT_GNU_versym,  0 },
2088   { STRING_COMMA_LEN (".gnu.version_d"),   0, SHT_GNU_verdef,  0 },
2089   { STRING_COMMA_LEN (".gnu.version_r"),   0, SHT_GNU_verneed, 0 },
2090   { STRING_COMMA_LEN (".gnu.liblist"),     0, SHT_GNU_LIBLIST, SHF_ALLOC },
2091   { STRING_COMMA_LEN (".gnu.conflict"),    0, SHT_RELA,        SHF_ALLOC },
2092   { STRING_COMMA_LEN (".gnu.hash"),        0, SHT_GNU_HASH,    SHF_ALLOC },
2093   { NULL,                        0,        0, 0,               0 }
2094 };
2095
2096 static const struct bfd_elf_special_section special_sections_h[] =
2097 {
2098   { STRING_COMMA_LEN (".hash"), 0, SHT_HASH,     SHF_ALLOC },
2099   { NULL,                    0, 0, 0,            0 }
2100 };
2101
2102 static const struct bfd_elf_special_section special_sections_i[] =
2103 {
2104   { STRING_COMMA_LEN (".init"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2105   { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2106   { STRING_COMMA_LEN (".interp"),     0, SHT_PROGBITS,   0 },
2107   { NULL,                      0,     0, 0,              0 }
2108 };
2109
2110 static const struct bfd_elf_special_section special_sections_l[] =
2111 {
2112   { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2113   { NULL,                    0, 0, 0,            0 }
2114 };
2115
2116 static const struct bfd_elf_special_section special_sections_n[] =
2117 {
2118   { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2119   { STRING_COMMA_LEN (".note"),          -1, SHT_NOTE,     0 },
2120   { NULL,                    0,           0, 0,            0 }
2121 };
2122
2123 static const struct bfd_elf_special_section special_sections_p[] =
2124 {
2125   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2126   { STRING_COMMA_LEN (".plt"),           0, SHT_PROGBITS,      SHF_ALLOC + SHF_EXECINSTR },
2127   { NULL,                   0,           0, 0,                 0 }
2128 };
2129
2130 static const struct bfd_elf_special_section special_sections_r[] =
2131 {
2132   { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2133   { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2134   { STRING_COMMA_LEN (".rela"),   -1, SHT_RELA,     0 },
2135   { STRING_COMMA_LEN (".rel"),    -1, SHT_REL,      0 },
2136   { NULL,                   0,     0, 0,            0 }
2137 };
2138
2139 static const struct bfd_elf_special_section special_sections_s[] =
2140 {
2141   { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2142   { STRING_COMMA_LEN (".strtab"),   0, SHT_STRTAB, 0 },
2143   { STRING_COMMA_LEN (".symtab"),   0, SHT_SYMTAB, 0 },
2144   /* See struct bfd_elf_special_section declaration for the semantics of
2145      this special case where .prefix_length != strlen (.prefix).  */
2146   { ".stabstr",                 5,  3, SHT_STRTAB, 0 },
2147   { NULL,                       0,  0, 0,          0 }
2148 };
2149
2150 static const struct bfd_elf_special_section special_sections_t[] =
2151 {
2152   { STRING_COMMA_LEN (".text"),  -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2153   { STRING_COMMA_LEN (".tbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2154   { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2155   { NULL,                     0,  0, 0,            0 }
2156 };
2157
2158 static const struct bfd_elf_special_section special_sections_z[] =
2159 {
2160   { STRING_COMMA_LEN (".zdebug_line"),    0, SHT_PROGBITS, 0 },
2161   { STRING_COMMA_LEN (".zdebug_info"),    0, SHT_PROGBITS, 0 },
2162   { STRING_COMMA_LEN (".zdebug_abbrev"),  0, SHT_PROGBITS, 0 },
2163   { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2164   { NULL,                     0,  0, 0,            0 }
2165 };
2166
2167 static const struct bfd_elf_special_section *special_sections[] =
2168 {
2169   special_sections_b,           /* 'b' */
2170   special_sections_c,           /* 'c' */
2171   special_sections_d,           /* 'd' */
2172   NULL,                         /* 'e' */
2173   special_sections_f,           /* 'f' */
2174   special_sections_g,           /* 'g' */
2175   special_sections_h,           /* 'h' */
2176   special_sections_i,           /* 'i' */
2177   NULL,                         /* 'j' */
2178   NULL,                         /* 'k' */
2179   special_sections_l,           /* 'l' */
2180   NULL,                         /* 'm' */
2181   special_sections_n,           /* 'n' */
2182   NULL,                         /* 'o' */
2183   special_sections_p,           /* 'p' */
2184   NULL,                         /* 'q' */
2185   special_sections_r,           /* 'r' */
2186   special_sections_s,           /* 's' */
2187   special_sections_t,           /* 't' */
2188   NULL,                         /* 'u' */
2189   NULL,                         /* 'v' */
2190   NULL,                         /* 'w' */
2191   NULL,                         /* 'x' */
2192   NULL,                         /* 'y' */
2193   special_sections_z            /* 'z' */
2194 };
2195
2196 const struct bfd_elf_special_section *
2197 _bfd_elf_get_special_section (const char *name,
2198                               const struct bfd_elf_special_section *spec,
2199                               unsigned int rela)
2200 {
2201   int i;
2202   int len;
2203
2204   len = strlen (name);
2205
2206   for (i = 0; spec[i].prefix != NULL; i++)
2207     {
2208       int suffix_len;
2209       int prefix_len = spec[i].prefix_length;
2210
2211       if (len < prefix_len)
2212         continue;
2213       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2214         continue;
2215
2216       suffix_len = spec[i].suffix_length;
2217       if (suffix_len <= 0)
2218         {
2219           if (name[prefix_len] != 0)
2220             {
2221               if (suffix_len == 0)
2222                 continue;
2223               if (name[prefix_len] != '.'
2224                   && (suffix_len == -2
2225                       || (rela && spec[i].type == SHT_REL)))
2226                 continue;
2227             }
2228         }
2229       else
2230         {
2231           if (len < prefix_len + suffix_len)
2232             continue;
2233           if (memcmp (name + len - suffix_len,
2234                       spec[i].prefix + prefix_len,
2235                       suffix_len) != 0)
2236             continue;
2237         }
2238       return &spec[i];
2239     }
2240
2241   return NULL;
2242 }
2243
2244 const struct bfd_elf_special_section *
2245 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2246 {
2247   int i;
2248   const struct bfd_elf_special_section *spec;
2249   const struct elf_backend_data *bed;
2250
2251   /* See if this is one of the special sections.  */
2252   if (sec->name == NULL)
2253     return NULL;
2254
2255   bed = get_elf_backend_data (abfd);
2256   spec = bed->special_sections;
2257   if (spec)
2258     {
2259       spec = _bfd_elf_get_special_section (sec->name,
2260                                            bed->special_sections,
2261                                            sec->use_rela_p);
2262       if (spec != NULL)
2263         return spec;
2264     }
2265
2266   if (sec->name[0] != '.')
2267     return NULL;
2268
2269   i = sec->name[1] - 'b';
2270   if (i < 0 || i > 'z' - 'b')
2271     return NULL;
2272
2273   spec = special_sections[i];
2274
2275   if (spec == NULL)
2276     return NULL;
2277
2278   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2279 }
2280
2281 bfd_boolean
2282 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2283 {
2284   struct bfd_elf_section_data *sdata;
2285   const struct elf_backend_data *bed;
2286   const struct bfd_elf_special_section *ssect;
2287
2288   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2289   if (sdata == NULL)
2290     {
2291       sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2292                                                           sizeof (*sdata));
2293       if (sdata == NULL)
2294         return FALSE;
2295       sec->used_by_bfd = sdata;
2296     }
2297
2298   /* Indicate whether or not this section should use RELA relocations.  */
2299   bed = get_elf_backend_data (abfd);
2300   sec->use_rela_p = bed->default_use_rela_p;
2301
2302   /* When we read a file, we don't need to set ELF section type and
2303      flags.  They will be overridden in _bfd_elf_make_section_from_shdr
2304      anyway.  We will set ELF section type and flags for all linker
2305      created sections.  If user specifies BFD section flags, we will
2306      set ELF section type and flags based on BFD section flags in
2307      elf_fake_sections.  Special handling for .init_array/.fini_array
2308      output sections since they may contain .ctors/.dtors input
2309      sections.  We don't want _bfd_elf_init_private_section_data to
2310      copy ELF section type from .ctors/.dtors input sections.  */
2311   if (abfd->direction != read_direction
2312       || (sec->flags & SEC_LINKER_CREATED) != 0)
2313     {
2314       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2315       if (ssect != NULL
2316           && (!sec->flags
2317               || (sec->flags & SEC_LINKER_CREATED) != 0
2318               || ssect->type == SHT_INIT_ARRAY
2319               || ssect->type == SHT_FINI_ARRAY))
2320         {
2321           elf_section_type (sec) = ssect->type;
2322           elf_section_flags (sec) = ssect->attr;
2323         }
2324     }
2325
2326   return _bfd_generic_new_section_hook (abfd, sec);
2327 }
2328
2329 /* Create a new bfd section from an ELF program header.
2330
2331    Since program segments have no names, we generate a synthetic name
2332    of the form segment<NUM>, where NUM is generally the index in the
2333    program header table.  For segments that are split (see below) we
2334    generate the names segment<NUM>a and segment<NUM>b.
2335
2336    Note that some program segments may have a file size that is different than
2337    (less than) the memory size.  All this means is that at execution the
2338    system must allocate the amount of memory specified by the memory size,
2339    but only initialize it with the first "file size" bytes read from the
2340    file.  This would occur for example, with program segments consisting
2341    of combined data+bss.
2342
2343    To handle the above situation, this routine generates TWO bfd sections
2344    for the single program segment.  The first has the length specified by
2345    the file size of the segment, and the second has the length specified
2346    by the difference between the two sizes.  In effect, the segment is split
2347    into its initialized and uninitialized parts.
2348
2349  */
2350
2351 bfd_boolean
2352 _bfd_elf_make_section_from_phdr (bfd *abfd,
2353                                  Elf_Internal_Phdr *hdr,
2354                                  int hdr_index,
2355                                  const char *type_name)
2356 {
2357   asection *newsect;
2358   char *name;
2359   char namebuf[64];
2360   size_t len;
2361   int split;
2362
2363   split = ((hdr->p_memsz > 0)
2364             && (hdr->p_filesz > 0)
2365             && (hdr->p_memsz > hdr->p_filesz));
2366
2367   if (hdr->p_filesz > 0)
2368     {
2369       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2370       len = strlen (namebuf) + 1;
2371       name = (char *) bfd_alloc (abfd, len);
2372       if (!name)
2373         return FALSE;
2374       memcpy (name, namebuf, len);
2375       newsect = bfd_make_section (abfd, name);
2376       if (newsect == NULL)
2377         return FALSE;
2378       newsect->vma = hdr->p_vaddr;
2379       newsect->lma = hdr->p_paddr;
2380       newsect->size = hdr->p_filesz;
2381       newsect->filepos = hdr->p_offset;
2382       newsect->flags |= SEC_HAS_CONTENTS;
2383       newsect->alignment_power = bfd_log2 (hdr->p_align);
2384       if (hdr->p_type == PT_LOAD)
2385         {
2386           newsect->flags |= SEC_ALLOC;
2387           newsect->flags |= SEC_LOAD;
2388           if (hdr->p_flags & PF_X)
2389             {
2390               /* FIXME: all we known is that it has execute PERMISSION,
2391                  may be data.  */
2392               newsect->flags |= SEC_CODE;
2393             }
2394         }
2395       if (!(hdr->p_flags & PF_W))
2396         {
2397           newsect->flags |= SEC_READONLY;
2398         }
2399     }
2400
2401   if (hdr->p_memsz > hdr->p_filesz)
2402     {
2403       bfd_vma align;
2404
2405       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2406       len = strlen (namebuf) + 1;
2407       name = (char *) bfd_alloc (abfd, len);
2408       if (!name)
2409         return FALSE;
2410       memcpy (name, namebuf, len);
2411       newsect = bfd_make_section (abfd, name);
2412       if (newsect == NULL)
2413         return FALSE;
2414       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2415       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2416       newsect->size = hdr->p_memsz - hdr->p_filesz;
2417       newsect->filepos = hdr->p_offset + hdr->p_filesz;
2418       align = newsect->vma & -newsect->vma;
2419       if (align == 0 || align > hdr->p_align)
2420         align = hdr->p_align;
2421       newsect->alignment_power = bfd_log2 (align);
2422       if (hdr->p_type == PT_LOAD)
2423         {
2424           /* Hack for gdb.  Segments that have not been modified do
2425              not have their contents written to a core file, on the
2426              assumption that a debugger can find the contents in the
2427              executable.  We flag this case by setting the fake
2428              section size to zero.  Note that "real" bss sections will
2429              always have their contents dumped to the core file.  */
2430           if (bfd_get_format (abfd) == bfd_core)
2431             newsect->size = 0;
2432           newsect->flags |= SEC_ALLOC;
2433           if (hdr->p_flags & PF_X)
2434             newsect->flags |= SEC_CODE;
2435         }
2436       if (!(hdr->p_flags & PF_W))
2437         newsect->flags |= SEC_READONLY;
2438     }
2439
2440   return TRUE;
2441 }
2442
2443 bfd_boolean
2444 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2445 {
2446   const struct elf_backend_data *bed;
2447
2448   switch (hdr->p_type)
2449     {
2450     case PT_NULL:
2451       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2452
2453     case PT_LOAD:
2454       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2455
2456     case PT_DYNAMIC:
2457       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2458
2459     case PT_INTERP:
2460       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2461
2462     case PT_NOTE:
2463       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2464         return FALSE;
2465       if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2466         return FALSE;
2467       return TRUE;
2468
2469     case PT_SHLIB:
2470       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2471
2472     case PT_PHDR:
2473       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2474
2475     case PT_GNU_EH_FRAME:
2476       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2477                                               "eh_frame_hdr");
2478
2479     case PT_GNU_STACK:
2480       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2481
2482     case PT_GNU_RELRO:
2483       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2484
2485     default:
2486       /* Check for any processor-specific program segment types.  */
2487       bed = get_elf_backend_data (abfd);
2488       return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2489     }
2490 }
2491
2492 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2493    REL or RELA.  */
2494
2495 Elf_Internal_Shdr *
2496 _bfd_elf_single_rel_hdr (asection *sec)
2497 {
2498   if (elf_section_data (sec)->rel.hdr)
2499     {
2500       BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2501       return elf_section_data (sec)->rel.hdr;
2502     }
2503   else
2504     return elf_section_data (sec)->rela.hdr;
2505 }
2506
2507 /* Allocate and initialize a section-header for a new reloc section,
2508    containing relocations against ASECT.  It is stored in RELDATA.  If
2509    USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2510    relocations.  */
2511
2512 bfd_boolean
2513 _bfd_elf_init_reloc_shdr (bfd *abfd,
2514                           struct bfd_elf_section_reloc_data *reldata,
2515                           asection *asect,
2516                           bfd_boolean use_rela_p)
2517 {
2518   Elf_Internal_Shdr *rel_hdr;
2519   char *name;
2520   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2521   bfd_size_type amt;
2522
2523   amt = sizeof (Elf_Internal_Shdr);
2524   BFD_ASSERT (reldata->hdr == NULL);
2525   rel_hdr = bfd_zalloc (abfd, amt);
2526   reldata->hdr = rel_hdr;
2527
2528   amt = sizeof ".rela" + strlen (asect->name);      
2529   name = (char *) bfd_alloc (abfd, amt);
2530   if (name == NULL)
2531     return FALSE;
2532   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2533   rel_hdr->sh_name =
2534     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2535                                         FALSE);
2536   if (rel_hdr->sh_name == (unsigned int) -1)
2537     return FALSE;
2538   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2539   rel_hdr->sh_entsize = (use_rela_p
2540                          ? bed->s->sizeof_rela
2541                          : bed->s->sizeof_rel);
2542   rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2543   rel_hdr->sh_flags = 0;
2544   rel_hdr->sh_addr = 0;
2545   rel_hdr->sh_size = 0;
2546   rel_hdr->sh_offset = 0;
2547
2548   return TRUE;
2549 }
2550
2551 /* Return the default section type based on the passed in section flags.  */
2552
2553 int
2554 bfd_elf_get_default_section_type (flagword flags)
2555 {
2556   if ((flags & SEC_ALLOC) != 0
2557       && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2558     return SHT_NOBITS;
2559   return SHT_PROGBITS;
2560 }
2561
2562 struct fake_section_arg
2563 {
2564   struct bfd_link_info *link_info;
2565   bfd_boolean failed;
2566 };
2567
2568 /* Set up an ELF internal section header for a section.  */
2569
2570 static void
2571 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
2572 {
2573   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
2574   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2575   struct bfd_elf_section_data *esd = elf_section_data (asect);
2576   Elf_Internal_Shdr *this_hdr;
2577   unsigned int sh_type;
2578
2579   if (arg->failed)
2580     {
2581       /* We already failed; just get out of the bfd_map_over_sections
2582          loop.  */
2583       return;
2584     }
2585
2586   this_hdr = &esd->this_hdr;
2587
2588   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2589                                                           asect->name, FALSE);
2590   if (this_hdr->sh_name == (unsigned int) -1)
2591     {
2592       arg->failed = TRUE;
2593       return;
2594     }
2595
2596   /* Don't clear sh_flags. Assembler may set additional bits.  */
2597
2598   if ((asect->flags & SEC_ALLOC) != 0
2599       || asect->user_set_vma)
2600     this_hdr->sh_addr = asect->vma;
2601   else
2602     this_hdr->sh_addr = 0;
2603
2604   this_hdr->sh_offset = 0;
2605   this_hdr->sh_size = asect->size;
2606   this_hdr->sh_link = 0;
2607   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2608   /* The sh_entsize and sh_info fields may have been set already by
2609      copy_private_section_data.  */
2610
2611   this_hdr->bfd_section = asect;
2612   this_hdr->contents = NULL;
2613
2614   /* If the section type is unspecified, we set it based on
2615      asect->flags.  */
2616   if ((asect->flags & SEC_GROUP) != 0)
2617     sh_type = SHT_GROUP;
2618   else
2619     sh_type = bfd_elf_get_default_section_type (asect->flags);
2620
2621   if (this_hdr->sh_type == SHT_NULL)
2622     this_hdr->sh_type = sh_type;
2623   else if (this_hdr->sh_type == SHT_NOBITS
2624            && sh_type == SHT_PROGBITS
2625            && (asect->flags & SEC_ALLOC) != 0)
2626     {
2627       /* Warn if we are changing a NOBITS section to PROGBITS, but
2628          allow the link to proceed.  This can happen when users link
2629          non-bss input sections to bss output sections, or emit data
2630          to a bss output section via a linker script.  */
2631       (*_bfd_error_handler)
2632         (_("warning: section `%A' type changed to PROGBITS"), asect);
2633       this_hdr->sh_type = sh_type;
2634     }
2635
2636   switch (this_hdr->sh_type)
2637     {
2638     default:
2639       break;
2640
2641     case SHT_STRTAB:
2642     case SHT_INIT_ARRAY:
2643     case SHT_FINI_ARRAY:
2644     case SHT_PREINIT_ARRAY:
2645     case SHT_NOTE:
2646     case SHT_NOBITS:
2647     case SHT_PROGBITS:
2648       break;
2649
2650     case SHT_HASH:
2651       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2652       break;
2653
2654     case SHT_DYNSYM:
2655       this_hdr->sh_entsize = bed->s->sizeof_sym;
2656       break;
2657
2658     case SHT_DYNAMIC:
2659       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2660       break;
2661
2662     case SHT_RELA:
2663       if (get_elf_backend_data (abfd)->may_use_rela_p)
2664         this_hdr->sh_entsize = bed->s->sizeof_rela;
2665       break;
2666
2667      case SHT_REL:
2668       if (get_elf_backend_data (abfd)->may_use_rel_p)
2669         this_hdr->sh_entsize = bed->s->sizeof_rel;
2670       break;
2671
2672      case SHT_GNU_versym:
2673       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2674       break;
2675
2676      case SHT_GNU_verdef:
2677       this_hdr->sh_entsize = 0;
2678       /* objcopy or strip will copy over sh_info, but may not set
2679          cverdefs.  The linker will set cverdefs, but sh_info will be
2680          zero.  */
2681       if (this_hdr->sh_info == 0)
2682         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2683       else
2684         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2685                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2686       break;
2687
2688     case SHT_GNU_verneed:
2689       this_hdr->sh_entsize = 0;
2690       /* objcopy or strip will copy over sh_info, but may not set
2691          cverrefs.  The linker will set cverrefs, but sh_info will be
2692          zero.  */
2693       if (this_hdr->sh_info == 0)
2694         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2695       else
2696         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2697                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2698       break;
2699
2700     case SHT_GROUP:
2701       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2702       break;
2703
2704     case SHT_GNU_HASH:
2705       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2706       break;
2707     }
2708
2709   if ((asect->flags & SEC_ALLOC) != 0)
2710     this_hdr->sh_flags |= SHF_ALLOC;
2711   if ((asect->flags & SEC_READONLY) == 0)
2712     this_hdr->sh_flags |= SHF_WRITE;
2713   if ((asect->flags & SEC_CODE) != 0)
2714     this_hdr->sh_flags |= SHF_EXECINSTR;
2715   if ((asect->flags & SEC_MERGE) != 0)
2716     {
2717       this_hdr->sh_flags |= SHF_MERGE;
2718       this_hdr->sh_entsize = asect->entsize;
2719       if ((asect->flags & SEC_STRINGS) != 0)
2720         this_hdr->sh_flags |= SHF_STRINGS;
2721     }
2722   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2723     this_hdr->sh_flags |= SHF_GROUP;
2724   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2725     {
2726       this_hdr->sh_flags |= SHF_TLS;
2727       if (asect->size == 0
2728           && (asect->flags & SEC_HAS_CONTENTS) == 0)
2729         {
2730           struct bfd_link_order *o = asect->map_tail.link_order;
2731
2732           this_hdr->sh_size = 0;
2733           if (o != NULL)
2734             {
2735               this_hdr->sh_size = o->offset + o->size;
2736               if (this_hdr->sh_size != 0)
2737                 this_hdr->sh_type = SHT_NOBITS;
2738             }
2739         }
2740     }
2741   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2742     this_hdr->sh_flags |= SHF_EXCLUDE;
2743
2744   /* If the section has relocs, set up a section header for the
2745      SHT_REL[A] section.  If two relocation sections are required for
2746      this section, it is up to the processor-specific back-end to
2747      create the other.  */
2748   if ((asect->flags & SEC_RELOC) != 0)
2749     {
2750       /* When doing a relocatable link, create both REL and RELA sections if
2751          needed.  */
2752       if (arg->link_info
2753           /* Do the normal setup if we wouldn't create any sections here.  */
2754           && esd->rel.count + esd->rela.count > 0
2755           && (arg->link_info->relocatable || arg->link_info->emitrelocations))
2756         {
2757           if (esd->rel.count && esd->rel.hdr == NULL
2758               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
2759             {
2760               arg->failed = TRUE;
2761               return;
2762             }
2763           if (esd->rela.count && esd->rela.hdr == NULL
2764               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
2765             {
2766               arg->failed = TRUE;
2767               return;
2768             }
2769         }
2770       else if (!_bfd_elf_init_reloc_shdr (abfd,
2771                                           (asect->use_rela_p
2772                                            ? &esd->rela : &esd->rel),
2773                                           asect,
2774                                           asect->use_rela_p))
2775           arg->failed = TRUE;
2776     }
2777
2778   /* Check for processor-specific section types.  */
2779   sh_type = this_hdr->sh_type;
2780   if (bed->elf_backend_fake_sections
2781       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2782     arg->failed = TRUE;
2783
2784   if (sh_type == SHT_NOBITS && asect->size != 0)
2785     {
2786       /* Don't change the header type from NOBITS if we are being
2787          called for objcopy --only-keep-debug.  */
2788       this_hdr->sh_type = sh_type;
2789     }
2790 }
2791
2792 /* Fill in the contents of a SHT_GROUP section.  Called from
2793    _bfd_elf_compute_section_file_positions for gas, objcopy, and
2794    when ELF targets use the generic linker, ld.  Called for ld -r
2795    from bfd_elf_final_link.  */
2796
2797 void
2798 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2799 {
2800   bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2801   asection *elt, *first;
2802   unsigned char *loc;
2803   bfd_boolean gas;
2804
2805   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2806      elfxx-ia64.c.  */
2807   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2808       || *failedptr)
2809     return;
2810
2811   if (elf_section_data (sec)->this_hdr.sh_info == 0)
2812     {
2813       unsigned long symindx = 0;
2814
2815       /* elf_group_id will have been set up by objcopy and the
2816          generic linker.  */
2817       if (elf_group_id (sec) != NULL)
2818         symindx = elf_group_id (sec)->udata.i;
2819
2820       if (symindx == 0)
2821         {
2822           /* If called from the assembler, swap_out_syms will have set up
2823              elf_section_syms.  */
2824           BFD_ASSERT (elf_section_syms (abfd) != NULL);
2825           symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2826         }
2827       elf_section_data (sec)->this_hdr.sh_info = symindx;
2828     }
2829   else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2830     {
2831       /* The ELF backend linker sets sh_info to -2 when the group
2832          signature symbol is global, and thus the index can't be
2833          set until all local symbols are output.  */
2834       asection *igroup = elf_sec_group (elf_next_in_group (sec));
2835       struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2836       unsigned long symndx = sec_data->this_hdr.sh_info;
2837       unsigned long extsymoff = 0;
2838       struct elf_link_hash_entry *h;
2839
2840       if (!elf_bad_symtab (igroup->owner))
2841         {
2842           Elf_Internal_Shdr *symtab_hdr;
2843
2844           symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2845           extsymoff = symtab_hdr->sh_info;
2846         }
2847       h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2848       while (h->root.type == bfd_link_hash_indirect
2849              || h->root.type == bfd_link_hash_warning)
2850         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2851
2852       elf_section_data (sec)->this_hdr.sh_info = h->indx;
2853     }
2854
2855   /* The contents won't be allocated for "ld -r" or objcopy.  */
2856   gas = TRUE;
2857   if (sec->contents == NULL)
2858     {
2859       gas = FALSE;
2860       sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
2861
2862       /* Arrange for the section to be written out.  */
2863       elf_section_data (sec)->this_hdr.contents = sec->contents;
2864       if (sec->contents == NULL)
2865         {
2866           *failedptr = TRUE;
2867           return;
2868         }
2869     }
2870
2871   loc = sec->contents + sec->size;
2872
2873   /* Get the pointer to the first section in the group that gas
2874      squirreled away here.  objcopy arranges for this to be set to the
2875      start of the input section group.  */
2876   first = elt = elf_next_in_group (sec);
2877
2878   /* First element is a flag word.  Rest of section is elf section
2879      indices for all the sections of the group.  Write them backwards
2880      just to keep the group in the same order as given in .section
2881      directives, not that it matters.  */
2882   while (elt != NULL)
2883     {
2884       asection *s;
2885
2886       s = elt;
2887       if (!gas)
2888         s = s->output_section;
2889       if (s != NULL
2890           && !bfd_is_abs_section (s))
2891         {
2892           unsigned int idx = elf_section_data (s)->this_idx;
2893
2894           loc -= 4;
2895           H_PUT_32 (abfd, idx, loc);
2896         }
2897       elt = elf_next_in_group (elt);
2898       if (elt == first)
2899         break;
2900     }
2901
2902   if ((loc -= 4) != sec->contents)
2903     abort ();
2904
2905   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2906 }
2907
2908 /* Assign all ELF section numbers.  The dummy first section is handled here
2909    too.  The link/info pointers for the standard section types are filled
2910    in here too, while we're at it.  */
2911
2912 static bfd_boolean
2913 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2914 {
2915   struct elf_obj_tdata *t = elf_tdata (abfd);
2916   asection *sec;
2917   unsigned int section_number, secn;
2918   Elf_Internal_Shdr **i_shdrp;
2919   struct bfd_elf_section_data *d;
2920   bfd_boolean need_symtab;
2921
2922   section_number = 1;
2923
2924   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2925
2926   /* SHT_GROUP sections are in relocatable files only.  */
2927   if (link_info == NULL || link_info->relocatable)
2928     {
2929       /* Put SHT_GROUP sections first.  */
2930       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2931         {
2932           d = elf_section_data (sec);
2933
2934           if (d->this_hdr.sh_type == SHT_GROUP)
2935             {
2936               if (sec->flags & SEC_LINKER_CREATED)
2937                 {
2938                   /* Remove the linker created SHT_GROUP sections.  */
2939                   bfd_section_list_remove (abfd, sec);
2940                   abfd->section_count--;
2941                 }
2942               else
2943                 d->this_idx = section_number++;
2944             }
2945         }
2946     }
2947
2948   for (sec = abfd->sections; sec; sec = sec->next)
2949     {
2950       d = elf_section_data (sec);
2951
2952       if (d->this_hdr.sh_type != SHT_GROUP)
2953         d->this_idx = section_number++;
2954       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2955       if (d->rel.hdr)
2956         {
2957           d->rel.idx = section_number++;
2958           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2959         }
2960       else
2961         d->rel.idx = 0;
2962
2963       if (d->rela.hdr)
2964         {
2965           d->rela.idx = section_number++;
2966           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2967         }
2968       else
2969         d->rela.idx = 0;
2970     }
2971
2972   t->shstrtab_section = section_number++;
2973   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2974   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2975
2976   need_symtab = (bfd_get_symcount (abfd) > 0
2977                 || (link_info == NULL
2978                     && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2979                         == HAS_RELOC)));
2980   if (need_symtab)
2981     {
2982       t->symtab_section = section_number++;
2983       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2984       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2985         {
2986           t->symtab_shndx_section = section_number++;
2987           t->symtab_shndx_hdr.sh_name
2988             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2989                                                   ".symtab_shndx", FALSE);
2990           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2991             return FALSE;
2992         }
2993       t->strtab_section = section_number++;
2994       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2995     }
2996
2997   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2998   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2999
3000   elf_numsections (abfd) = section_number;
3001   elf_elfheader (abfd)->e_shnum = section_number;
3002
3003   /* Set up the list of section header pointers, in agreement with the
3004      indices.  */
3005   i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3006                                                 sizeof (Elf_Internal_Shdr *));
3007   if (i_shdrp == NULL)
3008     return FALSE;
3009
3010   i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3011                                                  sizeof (Elf_Internal_Shdr));
3012   if (i_shdrp[0] == NULL)
3013     {
3014       bfd_release (abfd, i_shdrp);
3015       return FALSE;
3016     }
3017
3018   elf_elfsections (abfd) = i_shdrp;
3019
3020   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3021   if (need_symtab)
3022     {
3023       i_shdrp[t->symtab_section] = &t->symtab_hdr;
3024       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3025         {
3026           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3027           t->symtab_shndx_hdr.sh_link = t->symtab_section;
3028         }
3029       i_shdrp[t->strtab_section] = &t->strtab_hdr;
3030       t->symtab_hdr.sh_link = t->strtab_section;
3031     }
3032
3033   for (sec = abfd->sections; sec; sec = sec->next)
3034     {
3035       asection *s;
3036       const char *name;
3037
3038       d = elf_section_data (sec);
3039
3040       i_shdrp[d->this_idx] = &d->this_hdr;
3041       if (d->rel.idx != 0)
3042         i_shdrp[d->rel.idx] = d->rel.hdr;
3043       if (d->rela.idx != 0)
3044         i_shdrp[d->rela.idx] = d->rela.hdr;
3045
3046       /* Fill in the sh_link and sh_info fields while we're at it.  */
3047
3048       /* sh_link of a reloc section is the section index of the symbol
3049          table.  sh_info is the section index of the section to which
3050          the relocation entries apply.  */
3051       if (d->rel.idx != 0)
3052         {
3053           d->rel.hdr->sh_link = t->symtab_section;
3054           d->rel.hdr->sh_info = d->this_idx;
3055         }
3056       if (d->rela.idx != 0)
3057         {
3058           d->rela.hdr->sh_link = t->symtab_section;
3059           d->rela.hdr->sh_info = d->this_idx;
3060         }
3061
3062       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3063       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3064         {
3065           s = elf_linked_to_section (sec);
3066           if (s)
3067             {
3068               /* elf_linked_to_section points to the input section.  */
3069               if (link_info != NULL)
3070                 {
3071                   /* Check discarded linkonce section.  */
3072                   if (elf_discarded_section (s))
3073                     {
3074                       asection *kept;
3075                       (*_bfd_error_handler)
3076                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3077                          abfd, d->this_hdr.bfd_section,
3078                          s, s->owner);
3079                       /* Point to the kept section if it has the same
3080                          size as the discarded one.  */
3081                       kept = _bfd_elf_check_kept_section (s, link_info);
3082                       if (kept == NULL)
3083                         {
3084                           bfd_set_error (bfd_error_bad_value);
3085                           return FALSE;
3086                         }
3087                       s = kept;
3088                     }
3089
3090                   s = s->output_section;
3091                   BFD_ASSERT (s != NULL);
3092                 }
3093               else
3094                 {
3095                   /* Handle objcopy. */
3096                   if (s->output_section == NULL)
3097                     {
3098                       (*_bfd_error_handler)
3099                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3100                          abfd, d->this_hdr.bfd_section, s, s->owner);
3101                       bfd_set_error (bfd_error_bad_value);
3102                       return FALSE;
3103                     }
3104                   s = s->output_section;
3105                 }
3106               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3107             }
3108           else
3109             {
3110               /* PR 290:
3111                  The Intel C compiler generates SHT_IA_64_UNWIND with
3112                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
3113                  sh_info fields.  Hence we could get the situation
3114                  where s is NULL.  */
3115               const struct elf_backend_data *bed
3116                 = get_elf_backend_data (abfd);
3117               if (bed->link_order_error_handler)
3118                 bed->link_order_error_handler
3119                   (_("%B: warning: sh_link not set for section `%A'"),
3120                    abfd, sec);
3121             }
3122         }
3123
3124       switch (d->this_hdr.sh_type)
3125         {
3126         case SHT_REL:
3127         case SHT_RELA:
3128           /* A reloc section which we are treating as a normal BFD
3129              section.  sh_link is the section index of the symbol
3130              table.  sh_info is the section index of the section to
3131              which the relocation entries apply.  We assume that an
3132              allocated reloc section uses the dynamic symbol table.
3133              FIXME: How can we be sure?  */
3134           s = bfd_get_section_by_name (abfd, ".dynsym");
3135           if (s != NULL)
3136             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3137
3138           /* We look up the section the relocs apply to by name.  */
3139           name = sec->name;
3140           if (d->this_hdr.sh_type == SHT_REL)
3141             name += 4;
3142           else
3143             name += 5;
3144           s = bfd_get_section_by_name (abfd, name);
3145           if (s != NULL)
3146             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3147           break;
3148
3149         case SHT_STRTAB:
3150           /* We assume that a section named .stab*str is a stabs
3151              string section.  We look for a section with the same name
3152              but without the trailing ``str'', and set its sh_link
3153              field to point to this section.  */
3154           if (CONST_STRNEQ (sec->name, ".stab")
3155               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3156             {
3157               size_t len;
3158               char *alc;
3159
3160               len = strlen (sec->name);
3161               alc = (char *) bfd_malloc (len - 2);
3162               if (alc == NULL)
3163                 return FALSE;
3164               memcpy (alc, sec->name, len - 3);
3165               alc[len - 3] = '\0';
3166               s = bfd_get_section_by_name (abfd, alc);
3167               free (alc);
3168               if (s != NULL)
3169                 {
3170                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3171
3172                   /* This is a .stab section.  */
3173                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3174                     elf_section_data (s)->this_hdr.sh_entsize
3175                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3176                 }
3177             }
3178           break;
3179
3180         case SHT_DYNAMIC:
3181         case SHT_DYNSYM:
3182         case SHT_GNU_verneed:
3183         case SHT_GNU_verdef:
3184           /* sh_link is the section header index of the string table
3185              used for the dynamic entries, or the symbol table, or the
3186              version strings.  */
3187           s = bfd_get_section_by_name (abfd, ".dynstr");
3188           if (s != NULL)
3189             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3190           break;
3191
3192         case SHT_GNU_LIBLIST:
3193           /* sh_link is the section header index of the prelink library
3194              list used for the dynamic entries, or the symbol table, or
3195              the version strings.  */
3196           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3197                                              ? ".dynstr" : ".gnu.libstr");
3198           if (s != NULL)
3199             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3200           break;
3201
3202         case SHT_HASH:
3203         case SHT_GNU_HASH:
3204         case SHT_GNU_versym:
3205           /* sh_link is the section header index of the symbol table
3206              this hash table or version table is for.  */
3207           s = bfd_get_section_by_name (abfd, ".dynsym");
3208           if (s != NULL)
3209             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3210           break;
3211
3212         case SHT_GROUP:
3213           d->this_hdr.sh_link = t->symtab_section;
3214         }
3215     }
3216
3217   for (secn = 1; secn < section_number; ++secn)
3218     if (i_shdrp[secn] == NULL)
3219       i_shdrp[secn] = i_shdrp[0];
3220     else
3221       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3222                                                        i_shdrp[secn]->sh_name);
3223   return TRUE;
3224 }
3225
3226 /* Map symbol from it's internal number to the external number, moving
3227    all local symbols to be at the head of the list.  */
3228
3229 static bfd_boolean
3230 sym_is_global (bfd *abfd, asymbol *sym)
3231 {
3232   /* If the backend has a special mapping, use it.  */
3233   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3234   if (bed->elf_backend_sym_is_global)
3235     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3236
3237   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3238           || bfd_is_und_section (bfd_get_section (sym))
3239           || bfd_is_com_section (bfd_get_section (sym)));
3240 }
3241
3242 /* Don't output section symbols for sections that are not going to be
3243    output.  */
3244
3245 static bfd_boolean
3246 ignore_section_sym (bfd *abfd, asymbol *sym)
3247 {
3248   return ((sym->flags & BSF_SECTION_SYM) != 0
3249           && !(sym->section->owner == abfd
3250                || (sym->section->output_section->owner == abfd
3251                    && sym->section->output_offset == 0)));
3252 }
3253
3254 static bfd_boolean
3255 elf_map_symbols (bfd *abfd)
3256 {
3257   unsigned int symcount = bfd_get_symcount (abfd);
3258   asymbol **syms = bfd_get_outsymbols (abfd);
3259   asymbol **sect_syms;
3260   unsigned int num_locals = 0;
3261   unsigned int num_globals = 0;
3262   unsigned int num_locals2 = 0;
3263   unsigned int num_globals2 = 0;
3264   int max_index = 0;
3265   unsigned int idx;
3266   asection *asect;
3267   asymbol **new_syms;
3268
3269 #ifdef DEBUG
3270   fprintf (stderr, "elf_map_symbols\n");
3271   fflush (stderr);
3272 #endif
3273
3274   for (asect = abfd->sections; asect; asect = asect->next)
3275     {
3276       if (max_index < asect->index)
3277         max_index = asect->index;
3278     }
3279
3280   max_index++;
3281   sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3282   if (sect_syms == NULL)
3283     return FALSE;
3284   elf_section_syms (abfd) = sect_syms;
3285   elf_num_section_syms (abfd) = max_index;
3286
3287   /* Init sect_syms entries for any section symbols we have already
3288      decided to output.  */
3289   for (idx = 0; idx < symcount; idx++)
3290     {
3291       asymbol *sym = syms[idx];
3292
3293       if ((sym->flags & BSF_SECTION_SYM) != 0
3294           && sym->value == 0
3295           && !ignore_section_sym (abfd, sym))
3296         {
3297           asection *sec = sym->section;
3298
3299           if (sec->owner != abfd)
3300             sec = sec->output_section;
3301
3302           sect_syms[sec->index] = syms[idx];
3303         }
3304     }
3305
3306   /* Classify all of the symbols.  */
3307   for (idx = 0; idx < symcount; idx++)
3308     {
3309       if (ignore_section_sym (abfd, syms[idx]))
3310         continue;
3311       if (!sym_is_global (abfd, syms[idx]))
3312         num_locals++;
3313       else
3314         num_globals++;
3315     }
3316
3317   /* We will be adding a section symbol for each normal BFD section.  Most
3318      sections will already have a section symbol in outsymbols, but
3319      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3320      at least in that case.  */
3321   for (asect = abfd->sections; asect; asect = asect->next)
3322     {
3323       if (sect_syms[asect->index] == NULL)
3324         {
3325           if (!sym_is_global (abfd, asect->symbol))
3326             num_locals++;
3327           else
3328             num_globals++;
3329         }
3330     }
3331
3332   /* Now sort the symbols so the local symbols are first.  */
3333   new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3334                                       sizeof (asymbol *));
3335
3336   if (new_syms == NULL)
3337     return FALSE;
3338
3339   for (idx = 0; idx < symcount; idx++)
3340     {
3341       asymbol *sym = syms[idx];
3342       unsigned int i;
3343
3344       if (ignore_section_sym (abfd, sym))
3345         continue;
3346       if (!sym_is_global (abfd, sym))
3347         i = num_locals2++;
3348       else
3349         i = num_locals + num_globals2++;
3350       new_syms[i] = sym;
3351       sym->udata.i = i + 1;
3352     }
3353   for (asect = abfd->sections; asect; asect = asect->next)
3354     {
3355       if (sect_syms[asect->index] == NULL)
3356         {
3357           asymbol *sym = asect->symbol;
3358           unsigned int i;
3359
3360           sect_syms[asect->index] = sym;
3361           if (!sym_is_global (abfd, sym))
3362             i = num_locals2++;
3363           else
3364             i = num_locals + num_globals2++;
3365           new_syms[i] = sym;
3366           sym->udata.i = i + 1;
3367         }
3368     }
3369
3370   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3371
3372   elf_num_locals (abfd) = num_locals;
3373   elf_num_globals (abfd) = num_globals;
3374   return TRUE;
3375 }
3376
3377 /* Align to the maximum file alignment that could be required for any
3378    ELF data structure.  */
3379
3380 static inline file_ptr
3381 align_file_position (file_ptr off, int align)
3382 {
3383   return (off + align - 1) & ~(align - 1);
3384 }
3385
3386 /* Assign a file position to a section, optionally aligning to the
3387    required section alignment.  */
3388
3389 file_ptr
3390 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3391                                            file_ptr offset,
3392                                            bfd_boolean align)
3393 {
3394   if (align && i_shdrp->sh_addralign > 1)
3395     offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3396   i_shdrp->sh_offset = offset;
3397   if (i_shdrp->bfd_section != NULL)
3398     i_shdrp->bfd_section->filepos = offset;
3399   if (i_shdrp->sh_type != SHT_NOBITS)
3400     offset += i_shdrp->sh_size;
3401   return offset;
3402 }
3403
3404 /* Compute the file positions we are going to put the sections at, and
3405    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3406    is not NULL, this is being called by the ELF backend linker.  */
3407
3408 bfd_boolean
3409 _bfd_elf_compute_section_file_positions (bfd *abfd,
3410                                          struct bfd_link_info *link_info)
3411 {
3412   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3413   struct fake_section_arg fsargs;
3414   bfd_boolean failed;
3415   struct bfd_strtab_hash *strtab = NULL;
3416   Elf_Internal_Shdr *shstrtab_hdr;
3417   bfd_boolean need_symtab;
3418
3419   if (abfd->output_has_begun)
3420     return TRUE;
3421
3422   /* Do any elf backend specific processing first.  */
3423   if (bed->elf_backend_begin_write_processing)
3424     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3425
3426   if (! prep_headers (abfd))
3427     return FALSE;
3428
3429   /* Post process the headers if necessary.  */
3430   if (bed->elf_backend_post_process_headers)
3431     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3432
3433   fsargs.failed = FALSE;
3434   fsargs.link_info = link_info;
3435   bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
3436   if (fsargs.failed)
3437     return FALSE;
3438
3439   if (!assign_section_numbers (abfd, link_info))
3440     return FALSE;
3441
3442   /* The backend linker builds symbol table information itself.  */
3443   need_symtab = (link_info == NULL
3444                  && (bfd_get_symcount (abfd) > 0
3445                      || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3446                          == HAS_RELOC)));
3447   if (need_symtab)
3448     {
3449       /* Non-zero if doing a relocatable link.  */
3450       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3451
3452       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3453         return FALSE;
3454     }
3455
3456   failed = FALSE;
3457   if (link_info == NULL)
3458     {
3459       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3460       if (failed)
3461         return FALSE;
3462     }
3463
3464   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3465   /* sh_name was set in prep_headers.  */
3466   shstrtab_hdr->sh_type = SHT_STRTAB;
3467   shstrtab_hdr->sh_flags = 0;
3468   shstrtab_hdr->sh_addr = 0;
3469   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3470   shstrtab_hdr->sh_entsize = 0;
3471   shstrtab_hdr->sh_link = 0;
3472   shstrtab_hdr->sh_info = 0;
3473   /* sh_offset is set in assign_file_positions_except_relocs.  */
3474   shstrtab_hdr->sh_addralign = 1;
3475
3476   if (!assign_file_positions_except_relocs (abfd, link_info))
3477     return FALSE;
3478
3479   if (need_symtab)
3480     {
3481       file_ptr off;
3482       Elf_Internal_Shdr *hdr;
3483
3484       off = elf_tdata (abfd)->next_file_pos;
3485
3486       hdr = &elf_tdata (abfd)->symtab_hdr;
3487       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3488
3489       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3490       if (hdr->sh_size != 0)
3491         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3492
3493       hdr = &elf_tdata (abfd)->strtab_hdr;
3494       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3495
3496       elf_tdata (abfd)->next_file_pos = off;
3497
3498       /* Now that we know where the .strtab section goes, write it
3499          out.  */
3500       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3501           || ! _bfd_stringtab_emit (abfd, strtab))
3502         return FALSE;
3503       _bfd_stringtab_free (strtab);
3504     }
3505
3506   abfd->output_has_begun = TRUE;
3507
3508   return TRUE;
3509 }
3510
3511 /* Make an initial estimate of the size of the program header.  If we
3512    get the number wrong here, we'll redo section placement.  */
3513
3514 static bfd_size_type
3515 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3516 {
3517   size_t segs;
3518   asection *s;
3519   const struct elf_backend_data *bed;
3520
3521   /* Assume we will need exactly two PT_LOAD segments: one for text
3522      and one for data.  */
3523   segs = 2;
3524
3525   s = bfd_get_section_by_name (abfd, ".interp");
3526   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3527     {
3528       /* If we have a loadable interpreter section, we need a
3529          PT_INTERP segment.  In this case, assume we also need a
3530          PT_PHDR segment, although that may not be true for all
3531          targets.  */
3532       segs += 2;
3533     }
3534
3535   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3536     {
3537       /* We need a PT_DYNAMIC segment.  */
3538       ++segs;
3539     }
3540
3541   if (info != NULL && info->relro)
3542     {
3543       /* We need a PT_GNU_RELRO segment.  */
3544       ++segs;
3545     }
3546
3547   if (elf_tdata (abfd)->eh_frame_hdr)
3548     {
3549       /* We need a PT_GNU_EH_FRAME segment.  */
3550       ++segs;
3551     }
3552
3553   if (elf_tdata (abfd)->stack_flags)
3554     {
3555       /* We need a PT_GNU_STACK segment.  */
3556       ++segs;
3557     }
3558
3559   for (s = abfd->sections; s != NULL; s = s->next)
3560     {
3561       if ((s->flags & SEC_LOAD) != 0
3562           && CONST_STRNEQ (s->name, ".note"))
3563         {
3564           /* We need a PT_NOTE segment.  */
3565           ++segs;
3566           /* Try to create just one PT_NOTE segment
3567              for all adjacent loadable .note* sections.
3568              gABI requires that within a PT_NOTE segment
3569              (and also inside of each SHT_NOTE section)
3570              each note is padded to a multiple of 4 size,
3571              so we check whether the sections are correctly
3572              aligned.  */
3573           if (s->alignment_power == 2)
3574             while (s->next != NULL
3575                    && s->next->alignment_power == 2
3576                    && (s->next->flags & SEC_LOAD) != 0
3577                    && CONST_STRNEQ (s->next->name, ".note"))
3578               s = s->next;
3579         }
3580     }
3581
3582   for (s = abfd->sections; s != NULL; s = s->next)
3583     {
3584       if (s->flags & SEC_THREAD_LOCAL)
3585         {
3586           /* We need a PT_TLS segment.  */
3587           ++segs;
3588           break;
3589         }
3590     }
3591
3592   /* Let the backend count up any program headers it might need.  */
3593   bed = get_elf_backend_data (abfd);
3594   if (bed->elf_backend_additional_program_headers)
3595     {
3596       int a;
3597
3598       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3599       if (a == -1)
3600         abort ();
3601       segs += a;
3602     }
3603
3604   return segs * bed->s->sizeof_phdr;
3605 }
3606
3607 /* Find the segment that contains the output_section of section.  */
3608
3609 Elf_Internal_Phdr *
3610 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3611 {
3612   struct elf_segment_map *m;
3613   Elf_Internal_Phdr *p;
3614
3615   for (m = elf_tdata (abfd)->segment_map,
3616          p = elf_tdata (abfd)->phdr;
3617        m != NULL;
3618        m = m->next, p++)
3619     {
3620       int i;
3621
3622       for (i = m->count - 1; i >= 0; i--)
3623         if (m->sections[i] == section)
3624           return p;
3625     }
3626
3627   return NULL;
3628 }
3629
3630 /* Create a mapping from a set of sections to a program segment.  */
3631
3632 static struct elf_segment_map *
3633 make_mapping (bfd *abfd,
3634               asection **sections,
3635               unsigned int from,
3636               unsigned int to,
3637               bfd_boolean phdr)
3638 {
3639   struct elf_segment_map *m;
3640   unsigned int i;
3641   asection **hdrpp;
3642   bfd_size_type amt;
3643
3644   amt = sizeof (struct elf_segment_map);
3645   amt += (to - from - 1) * sizeof (asection *);
3646   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3647   if (m == NULL)
3648     return NULL;
3649   m->next = NULL;
3650   m->p_type = PT_LOAD;
3651   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3652     m->sections[i - from] = *hdrpp;
3653   m->count = to - from;
3654
3655   if (from == 0 && phdr)
3656     {
3657       /* Include the headers in the first PT_LOAD segment.  */
3658       m->includes_filehdr = 1;
3659       m->includes_phdrs = 1;
3660     }
3661
3662   return m;
3663 }
3664
3665 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3666    on failure.  */
3667
3668 struct elf_segment_map *
3669 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3670 {
3671   struct elf_segment_map *m;
3672
3673   m = (struct elf_segment_map *) bfd_zalloc (abfd,
3674                                              sizeof (struct elf_segment_map));
3675   if (m == NULL)
3676     return NULL;
3677   m->next = NULL;
3678   m->p_type = PT_DYNAMIC;
3679   m->count = 1;
3680   m->sections[0] = dynsec;
3681
3682   return m;
3683 }
3684
3685 /* Possibly add or remove segments from the segment map.  */
3686
3687 static bfd_boolean
3688 elf_modify_segment_map (bfd *abfd,
3689                         struct bfd_link_info *info,
3690                         bfd_boolean remove_empty_load)
3691 {
3692   struct elf_segment_map **m;
3693   const struct elf_backend_data *bed;
3694
3695   /* The placement algorithm assumes that non allocated sections are
3696      not in PT_LOAD segments.  We ensure this here by removing such
3697      sections from the segment map.  We also remove excluded
3698      sections.  Finally, any PT_LOAD segment without sections is
3699      removed.  */
3700   m = &elf_tdata (abfd)->segment_map;
3701   while (*m)
3702     {
3703       unsigned int i, new_count;
3704
3705       for (new_count = 0, i = 0; i < (*m)->count; i++)
3706         {
3707           if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3708               && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3709                   || (*m)->p_type != PT_LOAD))
3710             {
3711               (*m)->sections[new_count] = (*m)->sections[i];
3712               new_count++;
3713             }
3714         }
3715       (*m)->count = new_count;
3716
3717       if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3718         *m = (*m)->next;
3719       else
3720         m = &(*m)->next;
3721     }
3722
3723   bed = get_elf_backend_data (abfd);
3724   if (bed->elf_backend_modify_segment_map != NULL)
3725     {
3726       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3727         return FALSE;
3728     }
3729
3730   return TRUE;
3731 }
3732
3733 /* Set up a mapping from BFD sections to program segments.  */
3734
3735 bfd_boolean
3736 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3737 {
3738   unsigned int count;
3739   struct elf_segment_map *m;
3740   asection **sections = NULL;
3741   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3742   bfd_boolean no_user_phdrs;
3743
3744   no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3745   if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3746     {
3747       asection *s;
3748       unsigned int i;
3749       struct elf_segment_map *mfirst;
3750       struct elf_segment_map **pm;
3751       asection *last_hdr;
3752       bfd_vma last_size;
3753       unsigned int phdr_index;
3754       bfd_vma maxpagesize;
3755       asection **hdrpp;
3756       bfd_boolean phdr_in_segment = TRUE;
3757       bfd_boolean writable;
3758       int tls_count = 0;
3759       asection *first_tls = NULL;
3760       asection *dynsec, *eh_frame_hdr;
3761       bfd_size_type amt;
3762       bfd_vma addr_mask, wrap_to = 0;
3763
3764       /* Select the allocated sections, and sort them.  */
3765
3766       sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3767                                             sizeof (asection *));
3768       if (sections == NULL)
3769         goto error_return;
3770
3771       /* Calculate top address, avoiding undefined behaviour of shift
3772          left operator when shift count is equal to size of type
3773          being shifted.  */
3774       addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
3775       addr_mask = (addr_mask << 1) + 1;
3776
3777       i = 0;
3778       for (s = abfd->sections; s != NULL; s = s->next)
3779         {
3780           if ((s->flags & SEC_ALLOC) != 0)
3781             {
3782               sections[i] = s;
3783               ++i;
3784               /* A wrapping section potentially clashes with header.  */
3785               if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
3786                 wrap_to = (s->lma + s->size) & addr_mask;
3787             }
3788         }
3789       BFD_ASSERT (i <= bfd_count_sections (abfd));
3790       count = i;
3791
3792       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3793
3794       /* Build the mapping.  */
3795
3796       mfirst = NULL;
3797       pm = &mfirst;
3798
3799       /* If we have a .interp section, then create a PT_PHDR segment for
3800          the program headers and a PT_INTERP segment for the .interp
3801          section.  */
3802       s = bfd_get_section_by_name (abfd, ".interp");
3803       if (s != NULL && (s->flags & SEC_LOAD) != 0)
3804         {
3805           amt = sizeof (struct elf_segment_map);
3806           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3807           if (m == NULL)
3808             goto error_return;
3809           m->next = NULL;
3810           m->p_type = PT_PHDR;
3811           /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3812           m->p_flags = PF_R | PF_X;
3813           m->p_flags_valid = 1;
3814           m->includes_phdrs = 1;
3815
3816           *pm = m;
3817           pm = &m->next;
3818
3819           amt = sizeof (struct elf_segment_map);
3820           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3821           if (m == NULL)
3822             goto error_return;
3823           m->next = NULL;
3824           m->p_type = PT_INTERP;
3825           m->count = 1;
3826           m->sections[0] = s;
3827
3828           *pm = m;
3829           pm = &m->next;
3830         }
3831
3832       /* Look through the sections.  We put sections in the same program
3833          segment when the start of the second section can be placed within
3834          a few bytes of the end of the first section.  */
3835       last_hdr = NULL;
3836       last_size = 0;
3837       phdr_index = 0;
3838       maxpagesize = bed->maxpagesize;
3839       writable = FALSE;
3840       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3841       if (dynsec != NULL
3842           && (dynsec->flags & SEC_LOAD) == 0)
3843         dynsec = NULL;
3844
3845       /* Deal with -Ttext or something similar such that the first section
3846          is not adjacent to the program headers.  This is an
3847          approximation, since at this point we don't know exactly how many
3848          program headers we will need.  */
3849       if (count > 0)
3850         {
3851           bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3852
3853           if (phdr_size == (bfd_size_type) -1)
3854             phdr_size = get_program_header_size (abfd, info);
3855           if ((abfd->flags & D_PAGED) == 0
3856               || (sections[0]->lma & addr_mask) < phdr_size
3857               || ((sections[0]->lma & addr_mask) % maxpagesize
3858                   < phdr_size % maxpagesize)
3859               || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
3860             phdr_in_segment = FALSE;
3861         }
3862
3863       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3864         {
3865           asection *hdr;
3866           bfd_boolean new_segment;
3867
3868           hdr = *hdrpp;
3869
3870           /* See if this section and the last one will fit in the same
3871              segment.  */
3872
3873           if (last_hdr == NULL)
3874             {
3875               /* If we don't have a segment yet, then we don't need a new
3876                  one (we build the last one after this loop).  */
3877               new_segment = FALSE;
3878             }
3879           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3880             {
3881               /* If this section has a different relation between the
3882                  virtual address and the load address, then we need a new
3883                  segment.  */
3884               new_segment = TRUE;
3885             }
3886           else if (hdr->lma < last_hdr->lma + last_size
3887                    || last_hdr->lma + last_size < last_hdr->lma)
3888             {
3889               /* If this section has a load address that makes it overlap
3890                  the previous section, then we need a new segment.  */
3891               new_segment = TRUE;
3892             }
3893           /* In the next test we have to be careful when last_hdr->lma is close
3894              to the end of the address space.  If the aligned address wraps
3895              around to the start of the address space, then there are no more
3896              pages left in memory and it is OK to assume that the current
3897              section can be included in the current segment.  */
3898           else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3899                     > last_hdr->lma)
3900                    && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3901                        <= hdr->lma))
3902             {
3903               /* If putting this section in this segment would force us to
3904                  skip a page in the segment, then we need a new segment.  */
3905               new_segment = TRUE;
3906             }
3907           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3908                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3909             {
3910               /* We don't want to put a loadable section after a
3911                  nonloadable section in the same segment.
3912                  Consider .tbss sections as loadable for this purpose.  */
3913               new_segment = TRUE;
3914             }
3915           else if ((abfd->flags & D_PAGED) == 0)
3916             {
3917               /* If the file is not demand paged, which means that we
3918                  don't require the sections to be correctly aligned in the
3919                  file, then there is no other reason for a new segment.  */
3920               new_segment = FALSE;
3921             }
3922           else if (! writable
3923                    && (hdr->flags & SEC_READONLY) == 0
3924                    && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3925                        != (hdr->lma & -maxpagesize)))
3926             {
3927               /* We don't want to put a writable section in a read only
3928                  segment, unless they are on the same page in memory
3929                  anyhow.  We already know that the last section does not
3930                  bring us past the current section on the page, so the
3931                  only case in which the new section is not on the same
3932                  page as the previous section is when the previous section
3933                  ends precisely on a page boundary.  */
3934               new_segment = TRUE;
3935             }
3936           else
3937             {
3938               /* Otherwise, we can use the same segment.  */
3939               new_segment = FALSE;
3940             }
3941
3942           /* Allow interested parties a chance to override our decision.  */
3943           if (last_hdr != NULL
3944               && info != NULL
3945               && info->callbacks->override_segment_assignment != NULL)
3946             new_segment
3947               = info->callbacks->override_segment_assignment (info, abfd, hdr,
3948                                                               last_hdr,
3949                                                               new_segment);
3950
3951           if (! new_segment)
3952             {
3953               if ((hdr->flags & SEC_READONLY) == 0)
3954                 writable = TRUE;
3955               last_hdr = hdr;
3956               /* .tbss sections effectively have zero size.  */
3957               if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3958                   != SEC_THREAD_LOCAL)
3959                 last_size = hdr->size;
3960               else
3961                 last_size = 0;
3962               continue;
3963             }
3964
3965           /* We need a new program segment.  We must create a new program
3966              header holding all the sections from phdr_index until hdr.  */
3967
3968           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3969           if (m == NULL)
3970             goto error_return;
3971
3972           *pm = m;
3973           pm = &m->next;
3974
3975           if ((hdr->flags & SEC_READONLY) == 0)
3976             writable = TRUE;
3977           else
3978             writable = FALSE;
3979
3980           last_hdr = hdr;
3981           /* .tbss sections effectively have zero size.  */
3982           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3983             last_size = hdr->size;
3984           else
3985             last_size = 0;
3986           phdr_index = i;
3987           phdr_in_segment = FALSE;
3988         }
3989
3990       /* Create a final PT_LOAD program segment.  */
3991       if (last_hdr != NULL)
3992         {
3993           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3994           if (m == NULL)
3995             goto error_return;
3996
3997           *pm = m;
3998           pm = &m->next;
3999         }
4000
4001       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
4002       if (dynsec != NULL)
4003         {
4004           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4005           if (m == NULL)
4006             goto error_return;
4007           *pm = m;
4008           pm = &m->next;
4009         }
4010
4011       /* For each batch of consecutive loadable .note sections,
4012          add a PT_NOTE segment.  We don't use bfd_get_section_by_name,
4013          because if we link together nonloadable .note sections and
4014          loadable .note sections, we will generate two .note sections
4015          in the output file.  FIXME: Using names for section types is
4016          bogus anyhow.  */
4017       for (s = abfd->sections; s != NULL; s = s->next)
4018         {
4019           if ((s->flags & SEC_LOAD) != 0
4020               && CONST_STRNEQ (s->name, ".note"))
4021             {
4022               asection *s2;
4023
4024               count = 1;
4025               amt = sizeof (struct elf_segment_map);
4026               if (s->alignment_power == 2)
4027                 for (s2 = s; s2->next != NULL; s2 = s2->next)
4028                   {
4029                     if (s2->next->alignment_power == 2
4030                         && (s2->next->flags & SEC_LOAD) != 0
4031                         && CONST_STRNEQ (s2->next->name, ".note")
4032                         && align_power (s2->lma + s2->size, 2)
4033                            == s2->next->lma)
4034                       count++;
4035                     else
4036                       break;
4037                   }
4038               amt += (count - 1) * sizeof (asection *);
4039               m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4040               if (m == NULL)
4041                 goto error_return;
4042               m->next = NULL;
4043               m->p_type = PT_NOTE;
4044               m->count = count;
4045               while (count > 1)
4046                 {
4047                   m->sections[m->count - count--] = s;
4048                   BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4049                   s = s->next;
4050                 }
4051               m->sections[m->count - 1] = s;
4052               BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4053               *pm = m;
4054               pm = &m->next;
4055             }
4056           if (s->flags & SEC_THREAD_LOCAL)
4057             {
4058               if (! tls_count)
4059                 first_tls = s;
4060               tls_count++;
4061             }
4062         }
4063
4064       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
4065       if (tls_count > 0)
4066         {
4067           amt = sizeof (struct elf_segment_map);
4068           amt += (tls_count - 1) * sizeof (asection *);
4069           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4070           if (m == NULL)
4071             goto error_return;
4072           m->next = NULL;
4073           m->p_type = PT_TLS;
4074           m->count = tls_count;
4075           /* Mandated PF_R.  */
4076           m->p_flags = PF_R;
4077           m->p_flags_valid = 1;
4078           for (i = 0; i < (unsigned int) tls_count; ++i)
4079             {
4080               BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
4081               m->sections[i] = first_tls;
4082               first_tls = first_tls->next;
4083             }
4084
4085           *pm = m;
4086           pm = &m->next;
4087         }
4088
4089       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4090          segment.  */
4091       eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
4092       if (eh_frame_hdr != NULL
4093           && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4094         {
4095           amt = sizeof (struct elf_segment_map);
4096           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4097           if (m == NULL)
4098             goto error_return;
4099           m->next = NULL;
4100           m->p_type = PT_GNU_EH_FRAME;
4101           m->count = 1;
4102           m->sections[0] = eh_frame_hdr->output_section;
4103
4104           *pm = m;
4105           pm = &m->next;
4106         }
4107
4108       if (elf_tdata (abfd)->stack_flags)
4109         {
4110           amt = sizeof (struct elf_segment_map);
4111           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4112           if (m == NULL)
4113             goto error_return;
4114           m->next = NULL;
4115           m->p_type = PT_GNU_STACK;
4116           m->p_flags = elf_tdata (abfd)->stack_flags;
4117           m->p_flags_valid = 1;
4118
4119           *pm = m;
4120           pm = &m->next;
4121         }
4122
4123       if (info != NULL && info->relro)
4124         {
4125           for (m = mfirst; m != NULL; m = m->next)
4126   &