ktr.4: Forgot an .El
[dragonfly.git] / contrib / binutils-2.21 / 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 (".got"),             0, SHT_PROGBITS,    SHF_ALLOC + SHF_WRITE },
2086   { STRING_COMMA_LEN (".gnu.version"),     0, SHT_GNU_versym,  0 },
2087   { STRING_COMMA_LEN (".gnu.version_d"),   0, SHT_GNU_verdef,  0 },
2088   { STRING_COMMA_LEN (".gnu.version_r"),   0, SHT_GNU_verneed, 0 },
2089   { STRING_COMMA_LEN (".gnu.liblist"),     0, SHT_GNU_LIBLIST, SHF_ALLOC },
2090   { STRING_COMMA_LEN (".gnu.conflict"),    0, SHT_RELA,        SHF_ALLOC },
2091   { STRING_COMMA_LEN (".gnu.hash"),        0, SHT_GNU_HASH,    SHF_ALLOC },
2092   { NULL,                        0,        0, 0,               0 }
2093 };
2094
2095 static const struct bfd_elf_special_section special_sections_h[] =
2096 {
2097   { STRING_COMMA_LEN (".hash"), 0, SHT_HASH,     SHF_ALLOC },
2098   { NULL,                    0, 0, 0,            0 }
2099 };
2100
2101 static const struct bfd_elf_special_section special_sections_i[] =
2102 {
2103   { STRING_COMMA_LEN (".init"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2104   { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2105   { STRING_COMMA_LEN (".interp"),     0, SHT_PROGBITS,   0 },
2106   { NULL,                      0,     0, 0,              0 }
2107 };
2108
2109 static const struct bfd_elf_special_section special_sections_l[] =
2110 {
2111   { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2112   { NULL,                    0, 0, 0,            0 }
2113 };
2114
2115 static const struct bfd_elf_special_section special_sections_n[] =
2116 {
2117   { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2118   { STRING_COMMA_LEN (".note"),          -1, SHT_NOTE,     0 },
2119   { NULL,                    0,           0, 0,            0 }
2120 };
2121
2122 static const struct bfd_elf_special_section special_sections_p[] =
2123 {
2124   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2125   { STRING_COMMA_LEN (".plt"),           0, SHT_PROGBITS,      SHF_ALLOC + SHF_EXECINSTR },
2126   { NULL,                   0,           0, 0,                 0 }
2127 };
2128
2129 static const struct bfd_elf_special_section special_sections_r[] =
2130 {
2131   { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2132   { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2133   { STRING_COMMA_LEN (".rela"),   -1, SHT_RELA,     0 },
2134   { STRING_COMMA_LEN (".rel"),    -1, SHT_REL,      0 },
2135   { NULL,                   0,     0, 0,            0 }
2136 };
2137
2138 static const struct bfd_elf_special_section special_sections_s[] =
2139 {
2140   { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2141   { STRING_COMMA_LEN (".strtab"),   0, SHT_STRTAB, 0 },
2142   { STRING_COMMA_LEN (".symtab"),   0, SHT_SYMTAB, 0 },
2143   /* See struct bfd_elf_special_section declaration for the semantics of
2144      this special case where .prefix_length != strlen (.prefix).  */
2145   { ".stabstr",                 5,  3, SHT_STRTAB, 0 },
2146   { NULL,                       0,  0, 0,          0 }
2147 };
2148
2149 static const struct bfd_elf_special_section special_sections_t[] =
2150 {
2151   { STRING_COMMA_LEN (".text"),  -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2152   { STRING_COMMA_LEN (".tbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2153   { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2154   { NULL,                     0,  0, 0,            0 }
2155 };
2156
2157 static const struct bfd_elf_special_section special_sections_z[] =
2158 {
2159   { STRING_COMMA_LEN (".zdebug_line"),    0, SHT_PROGBITS, 0 },
2160   { STRING_COMMA_LEN (".zdebug_info"),    0, SHT_PROGBITS, 0 },
2161   { STRING_COMMA_LEN (".zdebug_abbrev"),  0, SHT_PROGBITS, 0 },
2162   { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2163   { NULL,                     0,  0, 0,            0 }
2164 };
2165
2166 static const struct bfd_elf_special_section *special_sections[] =
2167 {
2168   special_sections_b,           /* 'b' */
2169   special_sections_c,           /* 'c' */
2170   special_sections_d,           /* 'd' */
2171   NULL,                         /* 'e' */
2172   special_sections_f,           /* 'f' */
2173   special_sections_g,           /* 'g' */
2174   special_sections_h,           /* 'h' */
2175   special_sections_i,           /* 'i' */
2176   NULL,                         /* 'j' */
2177   NULL,                         /* 'k' */
2178   special_sections_l,           /* 'l' */
2179   NULL,                         /* 'm' */
2180   special_sections_n,           /* 'n' */
2181   NULL,                         /* 'o' */
2182   special_sections_p,           /* 'p' */
2183   NULL,                         /* 'q' */
2184   special_sections_r,           /* 'r' */
2185   special_sections_s,           /* 's' */
2186   special_sections_t,           /* 't' */
2187   NULL,                         /* 'u' */
2188   NULL,                         /* 'v' */
2189   NULL,                         /* 'w' */
2190   NULL,                         /* 'x' */
2191   NULL,                         /* 'y' */
2192   special_sections_z            /* 'z' */
2193 };
2194
2195 const struct bfd_elf_special_section *
2196 _bfd_elf_get_special_section (const char *name,
2197                               const struct bfd_elf_special_section *spec,
2198                               unsigned int rela)
2199 {
2200   int i;
2201   int len;
2202
2203   len = strlen (name);
2204
2205   for (i = 0; spec[i].prefix != NULL; i++)
2206     {
2207       int suffix_len;
2208       int prefix_len = spec[i].prefix_length;
2209
2210       if (len < prefix_len)
2211         continue;
2212       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2213         continue;
2214
2215       suffix_len = spec[i].suffix_length;
2216       if (suffix_len <= 0)
2217         {
2218           if (name[prefix_len] != 0)
2219             {
2220               if (suffix_len == 0)
2221                 continue;
2222               if (name[prefix_len] != '.'
2223                   && (suffix_len == -2
2224                       || (rela && spec[i].type == SHT_REL)))
2225                 continue;
2226             }
2227         }
2228       else
2229         {
2230           if (len < prefix_len + suffix_len)
2231             continue;
2232           if (memcmp (name + len - suffix_len,
2233                       spec[i].prefix + prefix_len,
2234                       suffix_len) != 0)
2235             continue;
2236         }
2237       return &spec[i];
2238     }
2239
2240   return NULL;
2241 }
2242
2243 const struct bfd_elf_special_section *
2244 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2245 {
2246   int i;
2247   const struct bfd_elf_special_section *spec;
2248   const struct elf_backend_data *bed;
2249
2250   /* See if this is one of the special sections.  */
2251   if (sec->name == NULL)
2252     return NULL;
2253
2254   bed = get_elf_backend_data (abfd);
2255   spec = bed->special_sections;
2256   if (spec)
2257     {
2258       spec = _bfd_elf_get_special_section (sec->name,
2259                                            bed->special_sections,
2260                                            sec->use_rela_p);
2261       if (spec != NULL)
2262         return spec;
2263     }
2264
2265   if (sec->name[0] != '.')
2266     return NULL;
2267
2268   i = sec->name[1] - 'b';
2269   if (i < 0 || i > 'z' - 'b')
2270     return NULL;
2271
2272   spec = special_sections[i];
2273
2274   if (spec == NULL)
2275     return NULL;
2276
2277   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2278 }
2279
2280 bfd_boolean
2281 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2282 {
2283   struct bfd_elf_section_data *sdata;
2284   const struct elf_backend_data *bed;
2285   const struct bfd_elf_special_section *ssect;
2286
2287   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2288   if (sdata == NULL)
2289     {
2290       sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2291                                                           sizeof (*sdata));
2292       if (sdata == NULL)
2293         return FALSE;
2294       sec->used_by_bfd = sdata;
2295     }
2296
2297   /* Indicate whether or not this section should use RELA relocations.  */
2298   bed = get_elf_backend_data (abfd);
2299   sec->use_rela_p = bed->default_use_rela_p;
2300
2301   /* When we read a file, we don't need to set ELF section type and
2302      flags.  They will be overridden in _bfd_elf_make_section_from_shdr
2303      anyway.  We will set ELF section type and flags for all linker
2304      created sections.  If user specifies BFD section flags, we will
2305      set ELF section type and flags based on BFD section flags in
2306      elf_fake_sections.  */
2307   if ((!sec->flags && abfd->direction != read_direction)
2308       || (sec->flags & SEC_LINKER_CREATED) != 0)
2309     {
2310       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2311       if (ssect != NULL)
2312         {
2313           elf_section_type (sec) = ssect->type;
2314           elf_section_flags (sec) = ssect->attr;
2315         }
2316     }
2317
2318   return _bfd_generic_new_section_hook (abfd, sec);
2319 }
2320
2321 /* Create a new bfd section from an ELF program header.
2322
2323    Since program segments have no names, we generate a synthetic name
2324    of the form segment<NUM>, where NUM is generally the index in the
2325    program header table.  For segments that are split (see below) we
2326    generate the names segment<NUM>a and segment<NUM>b.
2327
2328    Note that some program segments may have a file size that is different than
2329    (less than) the memory size.  All this means is that at execution the
2330    system must allocate the amount of memory specified by the memory size,
2331    but only initialize it with the first "file size" bytes read from the
2332    file.  This would occur for example, with program segments consisting
2333    of combined data+bss.
2334
2335    To handle the above situation, this routine generates TWO bfd sections
2336    for the single program segment.  The first has the length specified by
2337    the file size of the segment, and the second has the length specified
2338    by the difference between the two sizes.  In effect, the segment is split
2339    into its initialized and uninitialized parts.
2340
2341  */
2342
2343 bfd_boolean
2344 _bfd_elf_make_section_from_phdr (bfd *abfd,
2345                                  Elf_Internal_Phdr *hdr,
2346                                  int hdr_index,
2347                                  const char *type_name)
2348 {
2349   asection *newsect;
2350   char *name;
2351   char namebuf[64];
2352   size_t len;
2353   int split;
2354
2355   split = ((hdr->p_memsz > 0)
2356             && (hdr->p_filesz > 0)
2357             && (hdr->p_memsz > hdr->p_filesz));
2358
2359   if (hdr->p_filesz > 0)
2360     {
2361       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2362       len = strlen (namebuf) + 1;
2363       name = (char *) bfd_alloc (abfd, len);
2364       if (!name)
2365         return FALSE;
2366       memcpy (name, namebuf, len);
2367       newsect = bfd_make_section (abfd, name);
2368       if (newsect == NULL)
2369         return FALSE;
2370       newsect->vma = hdr->p_vaddr;
2371       newsect->lma = hdr->p_paddr;
2372       newsect->size = hdr->p_filesz;
2373       newsect->filepos = hdr->p_offset;
2374       newsect->flags |= SEC_HAS_CONTENTS;
2375       newsect->alignment_power = bfd_log2 (hdr->p_align);
2376       if (hdr->p_type == PT_LOAD)
2377         {
2378           newsect->flags |= SEC_ALLOC;
2379           newsect->flags |= SEC_LOAD;
2380           if (hdr->p_flags & PF_X)
2381             {
2382               /* FIXME: all we known is that it has execute PERMISSION,
2383                  may be data.  */
2384               newsect->flags |= SEC_CODE;
2385             }
2386         }
2387       if (!(hdr->p_flags & PF_W))
2388         {
2389           newsect->flags |= SEC_READONLY;
2390         }
2391     }
2392
2393   if (hdr->p_memsz > hdr->p_filesz)
2394     {
2395       bfd_vma align;
2396
2397       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2398       len = strlen (namebuf) + 1;
2399       name = (char *) bfd_alloc (abfd, len);
2400       if (!name)
2401         return FALSE;
2402       memcpy (name, namebuf, len);
2403       newsect = bfd_make_section (abfd, name);
2404       if (newsect == NULL)
2405         return FALSE;
2406       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2407       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2408       newsect->size = hdr->p_memsz - hdr->p_filesz;
2409       newsect->filepos = hdr->p_offset + hdr->p_filesz;
2410       align = newsect->vma & -newsect->vma;
2411       if (align == 0 || align > hdr->p_align)
2412         align = hdr->p_align;
2413       newsect->alignment_power = bfd_log2 (align);
2414       if (hdr->p_type == PT_LOAD)
2415         {
2416           /* Hack for gdb.  Segments that have not been modified do
2417              not have their contents written to a core file, on the
2418              assumption that a debugger can find the contents in the
2419              executable.  We flag this case by setting the fake
2420              section size to zero.  Note that "real" bss sections will
2421              always have their contents dumped to the core file.  */
2422           if (bfd_get_format (abfd) == bfd_core)
2423             newsect->size = 0;
2424           newsect->flags |= SEC_ALLOC;
2425           if (hdr->p_flags & PF_X)
2426             newsect->flags |= SEC_CODE;
2427         }
2428       if (!(hdr->p_flags & PF_W))
2429         newsect->flags |= SEC_READONLY;
2430     }
2431
2432   return TRUE;
2433 }
2434
2435 bfd_boolean
2436 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2437 {
2438   const struct elf_backend_data *bed;
2439
2440   switch (hdr->p_type)
2441     {
2442     case PT_NULL:
2443       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2444
2445     case PT_LOAD:
2446       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2447
2448     case PT_DYNAMIC:
2449       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2450
2451     case PT_INTERP:
2452       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2453
2454     case PT_NOTE:
2455       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2456         return FALSE;
2457       if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2458         return FALSE;
2459       return TRUE;
2460
2461     case PT_SHLIB:
2462       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2463
2464     case PT_PHDR:
2465       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2466
2467     case PT_GNU_EH_FRAME:
2468       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2469                                               "eh_frame_hdr");
2470
2471     case PT_GNU_STACK:
2472       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2473
2474     case PT_GNU_RELRO:
2475       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2476
2477     default:
2478       /* Check for any processor-specific program segment types.  */
2479       bed = get_elf_backend_data (abfd);
2480       return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2481     }
2482 }
2483
2484 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2485    REL or RELA.  */
2486
2487 Elf_Internal_Shdr *
2488 _bfd_elf_single_rel_hdr (asection *sec)
2489 {
2490   if (elf_section_data (sec)->rel.hdr)
2491     {
2492       BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2493       return elf_section_data (sec)->rel.hdr;
2494     }
2495   else
2496     return elf_section_data (sec)->rela.hdr;
2497 }
2498
2499 /* Allocate and initialize a section-header for a new reloc section,
2500    containing relocations against ASECT.  It is stored in RELDATA.  If
2501    USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2502    relocations.  */
2503
2504 bfd_boolean
2505 _bfd_elf_init_reloc_shdr (bfd *abfd,
2506                           struct bfd_elf_section_reloc_data *reldata,
2507                           asection *asect,
2508                           bfd_boolean use_rela_p)
2509 {
2510   Elf_Internal_Shdr *rel_hdr;
2511   char *name;
2512   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2513   bfd_size_type amt;
2514
2515   amt = sizeof (Elf_Internal_Shdr);
2516   BFD_ASSERT (reldata->hdr == NULL);
2517   rel_hdr = bfd_zalloc (abfd, amt);
2518   reldata->hdr = rel_hdr;
2519
2520   amt = sizeof ".rela" + strlen (asect->name);      
2521   name = (char *) bfd_alloc (abfd, amt);
2522   if (name == NULL)
2523     return FALSE;
2524   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2525   rel_hdr->sh_name =
2526     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2527                                         FALSE);
2528   if (rel_hdr->sh_name == (unsigned int) -1)
2529     return FALSE;
2530   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2531   rel_hdr->sh_entsize = (use_rela_p
2532                          ? bed->s->sizeof_rela
2533                          : bed->s->sizeof_rel);
2534   rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2535   rel_hdr->sh_flags = 0;
2536   rel_hdr->sh_addr = 0;
2537   rel_hdr->sh_size = 0;
2538   rel_hdr->sh_offset = 0;
2539
2540   return TRUE;
2541 }
2542
2543 /* Return the default section type based on the passed in section flags.  */
2544
2545 int
2546 bfd_elf_get_default_section_type (flagword flags)
2547 {
2548   if ((flags & SEC_ALLOC) != 0
2549       && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2550     return SHT_NOBITS;
2551   return SHT_PROGBITS;
2552 }
2553
2554 struct fake_section_arg
2555 {
2556   struct bfd_link_info *link_info;
2557   bfd_boolean failed;
2558 };
2559
2560 /* Set up an ELF internal section header for a section.  */
2561
2562 static void
2563 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
2564 {
2565   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
2566   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2567   struct bfd_elf_section_data *esd = elf_section_data (asect);
2568   Elf_Internal_Shdr *this_hdr;
2569   unsigned int sh_type;
2570
2571   if (arg->failed)
2572     {
2573       /* We already failed; just get out of the bfd_map_over_sections
2574          loop.  */
2575       return;
2576     }
2577
2578   this_hdr = &esd->this_hdr;
2579
2580   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2581                                                           asect->name, FALSE);
2582   if (this_hdr->sh_name == (unsigned int) -1)
2583     {
2584       arg->failed = TRUE;
2585       return;
2586     }
2587
2588   /* Don't clear sh_flags. Assembler may set additional bits.  */
2589
2590   if ((asect->flags & SEC_ALLOC) != 0
2591       || asect->user_set_vma)
2592     this_hdr->sh_addr = asect->vma;
2593   else
2594     this_hdr->sh_addr = 0;
2595
2596   this_hdr->sh_offset = 0;
2597   this_hdr->sh_size = asect->size;
2598   this_hdr->sh_link = 0;
2599   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2600   /* The sh_entsize and sh_info fields may have been set already by
2601      copy_private_section_data.  */
2602
2603   this_hdr->bfd_section = asect;
2604   this_hdr->contents = NULL;
2605
2606   /* If the section type is unspecified, we set it based on
2607      asect->flags.  */
2608   if ((asect->flags & SEC_GROUP) != 0)
2609     sh_type = SHT_GROUP;
2610   else
2611     sh_type = bfd_elf_get_default_section_type (asect->flags);
2612
2613   if (this_hdr->sh_type == SHT_NULL)
2614     this_hdr->sh_type = sh_type;
2615   else if (this_hdr->sh_type == SHT_NOBITS
2616            && sh_type == SHT_PROGBITS
2617            && (asect->flags & SEC_ALLOC) != 0)
2618     {
2619       /* Warn if we are changing a NOBITS section to PROGBITS, but
2620          allow the link to proceed.  This can happen when users link
2621          non-bss input sections to bss output sections, or emit data
2622          to a bss output section via a linker script.  */
2623       (*_bfd_error_handler)
2624         (_("warning: section `%A' type changed to PROGBITS"), asect);
2625       this_hdr->sh_type = sh_type;
2626     }
2627
2628   switch (this_hdr->sh_type)
2629     {
2630     default:
2631       break;
2632
2633     case SHT_STRTAB:
2634     case SHT_INIT_ARRAY:
2635     case SHT_FINI_ARRAY:
2636     case SHT_PREINIT_ARRAY:
2637     case SHT_NOTE:
2638     case SHT_NOBITS:
2639     case SHT_PROGBITS:
2640       break;
2641
2642     case SHT_HASH:
2643       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2644       break;
2645
2646     case SHT_DYNSYM:
2647       this_hdr->sh_entsize = bed->s->sizeof_sym;
2648       break;
2649
2650     case SHT_DYNAMIC:
2651       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2652       break;
2653
2654     case SHT_RELA:
2655       if (get_elf_backend_data (abfd)->may_use_rela_p)
2656         this_hdr->sh_entsize = bed->s->sizeof_rela;
2657       break;
2658
2659      case SHT_REL:
2660       if (get_elf_backend_data (abfd)->may_use_rel_p)
2661         this_hdr->sh_entsize = bed->s->sizeof_rel;
2662       break;
2663
2664      case SHT_GNU_versym:
2665       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2666       break;
2667
2668      case SHT_GNU_verdef:
2669       this_hdr->sh_entsize = 0;
2670       /* objcopy or strip will copy over sh_info, but may not set
2671          cverdefs.  The linker will set cverdefs, but sh_info will be
2672          zero.  */
2673       if (this_hdr->sh_info == 0)
2674         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2675       else
2676         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2677                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2678       break;
2679
2680     case SHT_GNU_verneed:
2681       this_hdr->sh_entsize = 0;
2682       /* objcopy or strip will copy over sh_info, but may not set
2683          cverrefs.  The linker will set cverrefs, but sh_info will be
2684          zero.  */
2685       if (this_hdr->sh_info == 0)
2686         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2687       else
2688         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2689                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2690       break;
2691
2692     case SHT_GROUP:
2693       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2694       break;
2695
2696     case SHT_GNU_HASH:
2697       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2698       break;
2699     }
2700
2701   if ((asect->flags & SEC_ALLOC) != 0)
2702     this_hdr->sh_flags |= SHF_ALLOC;
2703   if ((asect->flags & SEC_READONLY) == 0)
2704     this_hdr->sh_flags |= SHF_WRITE;
2705   if ((asect->flags & SEC_CODE) != 0)
2706     this_hdr->sh_flags |= SHF_EXECINSTR;
2707   if ((asect->flags & SEC_MERGE) != 0)
2708     {
2709       this_hdr->sh_flags |= SHF_MERGE;
2710       this_hdr->sh_entsize = asect->entsize;
2711       if ((asect->flags & SEC_STRINGS) != 0)
2712         this_hdr->sh_flags |= SHF_STRINGS;
2713     }
2714   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2715     this_hdr->sh_flags |= SHF_GROUP;
2716   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2717     {
2718       this_hdr->sh_flags |= SHF_TLS;
2719       if (asect->size == 0
2720           && (asect->flags & SEC_HAS_CONTENTS) == 0)
2721         {
2722           struct bfd_link_order *o = asect->map_tail.link_order;
2723
2724           this_hdr->sh_size = 0;
2725           if (o != NULL)
2726             {
2727               this_hdr->sh_size = o->offset + o->size;
2728               if (this_hdr->sh_size != 0)
2729                 this_hdr->sh_type = SHT_NOBITS;
2730             }
2731         }
2732     }
2733   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2734     this_hdr->sh_flags |= SHF_EXCLUDE;
2735
2736   /* If the section has relocs, set up a section header for the
2737      SHT_REL[A] section.  If two relocation sections are required for
2738      this section, it is up to the processor-specific back-end to
2739      create the other.  */
2740   if ((asect->flags & SEC_RELOC) != 0)
2741     {
2742       /* When doing a relocatable link, create both REL and RELA sections if
2743          needed.  */
2744       if (arg->link_info
2745           /* Do the normal setup if we wouldn't create any sections here.  */
2746           && esd->rel.count + esd->rela.count > 0
2747           && (arg->link_info->relocatable || arg->link_info->emitrelocations))
2748         {
2749           if (esd->rel.count && esd->rel.hdr == NULL
2750               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
2751             {
2752               arg->failed = TRUE;
2753               return;
2754             }
2755           if (esd->rela.count && esd->rela.hdr == NULL
2756               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
2757             {
2758               arg->failed = TRUE;
2759               return;
2760             }
2761         }
2762       else if (!_bfd_elf_init_reloc_shdr (abfd,
2763                                           (asect->use_rela_p
2764                                            ? &esd->rela : &esd->rel),
2765                                           asect,
2766                                           asect->use_rela_p))
2767           arg->failed = TRUE;
2768     }
2769
2770   /* Check for processor-specific section types.  */
2771   sh_type = this_hdr->sh_type;
2772   if (bed->elf_backend_fake_sections
2773       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2774     arg->failed = TRUE;
2775
2776   if (sh_type == SHT_NOBITS && asect->size != 0)
2777     {
2778       /* Don't change the header type from NOBITS if we are being
2779          called for objcopy --only-keep-debug.  */
2780       this_hdr->sh_type = sh_type;
2781     }
2782 }
2783
2784 /* Fill in the contents of a SHT_GROUP section.  Called from
2785    _bfd_elf_compute_section_file_positions for gas, objcopy, and
2786    when ELF targets use the generic linker, ld.  Called for ld -r
2787    from bfd_elf_final_link.  */
2788
2789 void
2790 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2791 {
2792   bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2793   asection *elt, *first;
2794   unsigned char *loc;
2795   bfd_boolean gas;
2796
2797   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2798      elfxx-ia64.c.  */
2799   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2800       || *failedptr)
2801     return;
2802
2803   if (elf_section_data (sec)->this_hdr.sh_info == 0)
2804     {
2805       unsigned long symindx = 0;
2806
2807       /* elf_group_id will have been set up by objcopy and the
2808          generic linker.  */
2809       if (elf_group_id (sec) != NULL)
2810         symindx = elf_group_id (sec)->udata.i;
2811
2812       if (symindx == 0)
2813         {
2814           /* If called from the assembler, swap_out_syms will have set up
2815              elf_section_syms.  */
2816           BFD_ASSERT (elf_section_syms (abfd) != NULL);
2817           symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2818         }
2819       elf_section_data (sec)->this_hdr.sh_info = symindx;
2820     }
2821   else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2822     {
2823       /* The ELF backend linker sets sh_info to -2 when the group
2824          signature symbol is global, and thus the index can't be
2825          set until all local symbols are output.  */
2826       asection *igroup = elf_sec_group (elf_next_in_group (sec));
2827       struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2828       unsigned long symndx = sec_data->this_hdr.sh_info;
2829       unsigned long extsymoff = 0;
2830       struct elf_link_hash_entry *h;
2831
2832       if (!elf_bad_symtab (igroup->owner))
2833         {
2834           Elf_Internal_Shdr *symtab_hdr;
2835
2836           symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2837           extsymoff = symtab_hdr->sh_info;
2838         }
2839       h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2840       while (h->root.type == bfd_link_hash_indirect
2841              || h->root.type == bfd_link_hash_warning)
2842         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2843
2844       elf_section_data (sec)->this_hdr.sh_info = h->indx;
2845     }
2846
2847   /* The contents won't be allocated for "ld -r" or objcopy.  */
2848   gas = TRUE;
2849   if (sec->contents == NULL)
2850     {
2851       gas = FALSE;
2852       sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
2853
2854       /* Arrange for the section to be written out.  */
2855       elf_section_data (sec)->this_hdr.contents = sec->contents;
2856       if (sec->contents == NULL)
2857         {
2858           *failedptr = TRUE;
2859           return;
2860         }
2861     }
2862
2863   loc = sec->contents + sec->size;
2864
2865   /* Get the pointer to the first section in the group that gas
2866      squirreled away here.  objcopy arranges for this to be set to the
2867      start of the input section group.  */
2868   first = elt = elf_next_in_group (sec);
2869
2870   /* First element is a flag word.  Rest of section is elf section
2871      indices for all the sections of the group.  Write them backwards
2872      just to keep the group in the same order as given in .section
2873      directives, not that it matters.  */
2874   while (elt != NULL)
2875     {
2876       asection *s;
2877
2878       s = elt;
2879       if (!gas)
2880         s = s->output_section;
2881       if (s != NULL
2882           && !bfd_is_abs_section (s))
2883         {
2884           unsigned int idx = elf_section_data (s)->this_idx;
2885
2886           loc -= 4;
2887           H_PUT_32 (abfd, idx, loc);
2888         }
2889       elt = elf_next_in_group (elt);
2890       if (elt == first)
2891         break;
2892     }
2893
2894   if ((loc -= 4) != sec->contents)
2895     abort ();
2896
2897   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2898 }
2899
2900 /* Assign all ELF section numbers.  The dummy first section is handled here
2901    too.  The link/info pointers for the standard section types are filled
2902    in here too, while we're at it.  */
2903
2904 static bfd_boolean
2905 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2906 {
2907   struct elf_obj_tdata *t = elf_tdata (abfd);
2908   asection *sec;
2909   unsigned int section_number, secn;
2910   Elf_Internal_Shdr **i_shdrp;
2911   struct bfd_elf_section_data *d;
2912   bfd_boolean need_symtab;
2913
2914   section_number = 1;
2915
2916   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2917
2918   /* SHT_GROUP sections are in relocatable files only.  */
2919   if (link_info == NULL || link_info->relocatable)
2920     {
2921       /* Put SHT_GROUP sections first.  */
2922       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2923         {
2924           d = elf_section_data (sec);
2925
2926           if (d->this_hdr.sh_type == SHT_GROUP)
2927             {
2928               if (sec->flags & SEC_LINKER_CREATED)
2929                 {
2930                   /* Remove the linker created SHT_GROUP sections.  */
2931                   bfd_section_list_remove (abfd, sec);
2932                   abfd->section_count--;
2933                 }
2934               else
2935                 d->this_idx = section_number++;
2936             }
2937         }
2938     }
2939
2940   for (sec = abfd->sections; sec; sec = sec->next)
2941     {
2942       d = elf_section_data (sec);
2943
2944       if (d->this_hdr.sh_type != SHT_GROUP)
2945         d->this_idx = section_number++;
2946       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2947       if (d->rel.hdr)
2948         {
2949           d->rel.idx = section_number++;
2950           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2951         }
2952       else
2953         d->rel.idx = 0;
2954
2955       if (d->rela.hdr)
2956         {
2957           d->rela.idx = section_number++;
2958           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2959         }
2960       else
2961         d->rela.idx = 0;
2962     }
2963
2964   t->shstrtab_section = section_number++;
2965   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2966   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2967
2968   need_symtab = (bfd_get_symcount (abfd) > 0
2969                 || (link_info == NULL
2970                     && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2971                         == HAS_RELOC)));
2972   if (need_symtab)
2973     {
2974       t->symtab_section = section_number++;
2975       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2976       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2977         {
2978           t->symtab_shndx_section = section_number++;
2979           t->symtab_shndx_hdr.sh_name
2980             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2981                                                   ".symtab_shndx", FALSE);
2982           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2983             return FALSE;
2984         }
2985       t->strtab_section = section_number++;
2986       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2987     }
2988
2989   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2990   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2991
2992   elf_numsections (abfd) = section_number;
2993   elf_elfheader (abfd)->e_shnum = section_number;
2994
2995   /* Set up the list of section header pointers, in agreement with the
2996      indices.  */
2997   i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
2998                                                 sizeof (Elf_Internal_Shdr *));
2999   if (i_shdrp == NULL)
3000     return FALSE;
3001
3002   i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3003                                                  sizeof (Elf_Internal_Shdr));
3004   if (i_shdrp[0] == NULL)
3005     {
3006       bfd_release (abfd, i_shdrp);
3007       return FALSE;
3008     }
3009
3010   elf_elfsections (abfd) = i_shdrp;
3011
3012   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3013   if (need_symtab)
3014     {
3015       i_shdrp[t->symtab_section] = &t->symtab_hdr;
3016       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3017         {
3018           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3019           t->symtab_shndx_hdr.sh_link = t->symtab_section;
3020         }
3021       i_shdrp[t->strtab_section] = &t->strtab_hdr;
3022       t->symtab_hdr.sh_link = t->strtab_section;
3023     }
3024
3025   for (sec = abfd->sections; sec; sec = sec->next)
3026     {
3027       asection *s;
3028       const char *name;
3029
3030       d = elf_section_data (sec);
3031
3032       i_shdrp[d->this_idx] = &d->this_hdr;
3033       if (d->rel.idx != 0)
3034         i_shdrp[d->rel.idx] = d->rel.hdr;
3035       if (d->rela.idx != 0)
3036         i_shdrp[d->rela.idx] = d->rela.hdr;
3037
3038       /* Fill in the sh_link and sh_info fields while we're at it.  */
3039
3040       /* sh_link of a reloc section is the section index of the symbol
3041          table.  sh_info is the section index of the section to which
3042          the relocation entries apply.  */
3043       if (d->rel.idx != 0)
3044         {
3045           d->rel.hdr->sh_link = t->symtab_section;
3046           d->rel.hdr->sh_info = d->this_idx;
3047         }
3048       if (d->rela.idx != 0)
3049         {
3050           d->rela.hdr->sh_link = t->symtab_section;
3051           d->rela.hdr->sh_info = d->this_idx;
3052         }
3053
3054       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3055       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3056         {
3057           s = elf_linked_to_section (sec);
3058           if (s)
3059             {
3060               /* elf_linked_to_section points to the input section.  */
3061               if (link_info != NULL)
3062                 {
3063                   /* Check discarded linkonce section.  */
3064                   if (elf_discarded_section (s))
3065                     {
3066                       asection *kept;
3067                       (*_bfd_error_handler)
3068                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3069                          abfd, d->this_hdr.bfd_section,
3070                          s, s->owner);
3071                       /* Point to the kept section if it has the same
3072                          size as the discarded one.  */
3073                       kept = _bfd_elf_check_kept_section (s, link_info);
3074                       if (kept == NULL)
3075                         {
3076                           bfd_set_error (bfd_error_bad_value);
3077                           return FALSE;
3078                         }
3079                       s = kept;
3080                     }
3081
3082                   s = s->output_section;
3083                   BFD_ASSERT (s != NULL);
3084                 }
3085               else
3086                 {
3087                   /* Handle objcopy. */
3088                   if (s->output_section == NULL)
3089                     {
3090                       (*_bfd_error_handler)
3091                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3092                          abfd, d->this_hdr.bfd_section, s, s->owner);
3093                       bfd_set_error (bfd_error_bad_value);
3094                       return FALSE;
3095                     }
3096                   s = s->output_section;
3097                 }
3098               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3099             }
3100           else
3101             {
3102               /* PR 290:
3103                  The Intel C compiler generates SHT_IA_64_UNWIND with
3104                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
3105                  sh_info fields.  Hence we could get the situation
3106                  where s is NULL.  */
3107               const struct elf_backend_data *bed
3108                 = get_elf_backend_data (abfd);
3109               if (bed->link_order_error_handler)
3110                 bed->link_order_error_handler
3111                   (_("%B: warning: sh_link not set for section `%A'"),
3112                    abfd, sec);
3113             }
3114         }
3115
3116       switch (d->this_hdr.sh_type)
3117         {
3118         case SHT_REL:
3119         case SHT_RELA:
3120           /* A reloc section which we are treating as a normal BFD
3121              section.  sh_link is the section index of the symbol
3122              table.  sh_info is the section index of the section to
3123              which the relocation entries apply.  We assume that an
3124              allocated reloc section uses the dynamic symbol table.
3125              FIXME: How can we be sure?  */
3126           s = bfd_get_section_by_name (abfd, ".dynsym");
3127           if (s != NULL)
3128             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3129
3130           /* We look up the section the relocs apply to by name.  */
3131           name = sec->name;
3132           if (d->this_hdr.sh_type == SHT_REL)
3133             name += 4;
3134           else
3135             name += 5;
3136           s = bfd_get_section_by_name (abfd, name);
3137           if (s != NULL)
3138             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3139           break;
3140
3141         case SHT_STRTAB:
3142           /* We assume that a section named .stab*str is a stabs
3143              string section.  We look for a section with the same name
3144              but without the trailing ``str'', and set its sh_link
3145              field to point to this section.  */
3146           if (CONST_STRNEQ (sec->name, ".stab")
3147               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3148             {
3149               size_t len;
3150               char *alc;
3151
3152               len = strlen (sec->name);
3153               alc = (char *) bfd_malloc (len - 2);
3154               if (alc == NULL)
3155                 return FALSE;
3156               memcpy (alc, sec->name, len - 3);
3157               alc[len - 3] = '\0';
3158               s = bfd_get_section_by_name (abfd, alc);
3159               free (alc);
3160               if (s != NULL)
3161                 {
3162                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3163
3164                   /* This is a .stab section.  */
3165                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3166                     elf_section_data (s)->this_hdr.sh_entsize
3167                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3168                 }
3169             }
3170           break;
3171
3172         case SHT_DYNAMIC:
3173         case SHT_DYNSYM:
3174         case SHT_GNU_verneed:
3175         case SHT_GNU_verdef:
3176           /* sh_link is the section header index of the string table
3177              used for the dynamic entries, or the symbol table, or the
3178              version strings.  */
3179           s = bfd_get_section_by_name (abfd, ".dynstr");
3180           if (s != NULL)
3181             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3182           break;
3183
3184         case SHT_GNU_LIBLIST:
3185           /* sh_link is the section header index of the prelink library
3186              list used for the dynamic entries, or the symbol table, or
3187              the version strings.  */
3188           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3189                                              ? ".dynstr" : ".gnu.libstr");
3190           if (s != NULL)
3191             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3192           break;
3193
3194         case SHT_HASH:
3195         case SHT_GNU_HASH:
3196         case SHT_GNU_versym:
3197           /* sh_link is the section header index of the symbol table
3198              this hash table or version table is for.  */
3199           s = bfd_get_section_by_name (abfd, ".dynsym");
3200           if (s != NULL)
3201             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3202           break;
3203
3204         case SHT_GROUP:
3205           d->this_hdr.sh_link = t->symtab_section;
3206         }
3207     }
3208
3209   for (secn = 1; secn < section_number; ++secn)
3210     if (i_shdrp[secn] == NULL)
3211       i_shdrp[secn] = i_shdrp[0];
3212     else
3213       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3214                                                        i_shdrp[secn]->sh_name);
3215   return TRUE;
3216 }
3217
3218 /* Map symbol from it's internal number to the external number, moving
3219    all local symbols to be at the head of the list.  */
3220
3221 static bfd_boolean
3222 sym_is_global (bfd *abfd, asymbol *sym)
3223 {
3224   /* If the backend has a special mapping, use it.  */
3225   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3226   if (bed->elf_backend_sym_is_global)
3227     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3228
3229   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3230           || bfd_is_und_section (bfd_get_section (sym))
3231           || bfd_is_com_section (bfd_get_section (sym)));
3232 }
3233
3234 /* Don't output section symbols for sections that are not going to be
3235    output.  */
3236
3237 static bfd_boolean
3238 ignore_section_sym (bfd *abfd, asymbol *sym)
3239 {
3240   return ((sym->flags & BSF_SECTION_SYM) != 0
3241           && !(sym->section->owner == abfd
3242                || (sym->section->output_section->owner == abfd
3243                    && sym->section->output_offset == 0)));
3244 }
3245
3246 static bfd_boolean
3247 elf_map_symbols (bfd *abfd)
3248 {
3249   unsigned int symcount = bfd_get_symcount (abfd);
3250   asymbol **syms = bfd_get_outsymbols (abfd);
3251   asymbol **sect_syms;
3252   unsigned int num_locals = 0;
3253   unsigned int num_globals = 0;
3254   unsigned int num_locals2 = 0;
3255   unsigned int num_globals2 = 0;
3256   int max_index = 0;
3257   unsigned int idx;
3258   asection *asect;
3259   asymbol **new_syms;
3260
3261 #ifdef DEBUG
3262   fprintf (stderr, "elf_map_symbols\n");
3263   fflush (stderr);
3264 #endif
3265
3266   for (asect = abfd->sections; asect; asect = asect->next)
3267     {
3268       if (max_index < asect->index)
3269         max_index = asect->index;
3270     }
3271
3272   max_index++;
3273   sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3274   if (sect_syms == NULL)
3275     return FALSE;
3276   elf_section_syms (abfd) = sect_syms;
3277   elf_num_section_syms (abfd) = max_index;
3278
3279   /* Init sect_syms entries for any section symbols we have already
3280      decided to output.  */
3281   for (idx = 0; idx < symcount; idx++)
3282     {
3283       asymbol *sym = syms[idx];
3284
3285       if ((sym->flags & BSF_SECTION_SYM) != 0
3286           && sym->value == 0
3287           && !ignore_section_sym (abfd, sym))
3288         {
3289           asection *sec = sym->section;
3290
3291           if (sec->owner != abfd)
3292             sec = sec->output_section;
3293
3294           sect_syms[sec->index] = syms[idx];
3295         }
3296     }
3297
3298   /* Classify all of the symbols.  */
3299   for (idx = 0; idx < symcount; idx++)
3300     {
3301       if (ignore_section_sym (abfd, syms[idx]))
3302         continue;
3303       if (!sym_is_global (abfd, syms[idx]))
3304         num_locals++;
3305       else
3306         num_globals++;
3307     }
3308
3309   /* We will be adding a section symbol for each normal BFD section.  Most
3310      sections will already have a section symbol in outsymbols, but
3311      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3312      at least in that case.  */
3313   for (asect = abfd->sections; asect; asect = asect->next)
3314     {
3315       if (sect_syms[asect->index] == NULL)
3316         {
3317           if (!sym_is_global (abfd, asect->symbol))
3318             num_locals++;
3319           else
3320             num_globals++;
3321         }
3322     }
3323
3324   /* Now sort the symbols so the local symbols are first.  */
3325   new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3326                                       sizeof (asymbol *));
3327
3328   if (new_syms == NULL)
3329     return FALSE;
3330
3331   for (idx = 0; idx < symcount; idx++)
3332     {
3333       asymbol *sym = syms[idx];
3334       unsigned int i;
3335
3336       if (ignore_section_sym (abfd, sym))
3337         continue;
3338       if (!sym_is_global (abfd, sym))
3339         i = num_locals2++;
3340       else
3341         i = num_locals + num_globals2++;
3342       new_syms[i] = sym;
3343       sym->udata.i = i + 1;
3344     }
3345   for (asect = abfd->sections; asect; asect = asect->next)
3346     {
3347       if (sect_syms[asect->index] == NULL)
3348         {
3349           asymbol *sym = asect->symbol;
3350           unsigned int i;
3351
3352           sect_syms[asect->index] = sym;
3353           if (!sym_is_global (abfd, sym))
3354             i = num_locals2++;
3355           else
3356             i = num_locals + num_globals2++;
3357           new_syms[i] = sym;
3358           sym->udata.i = i + 1;
3359         }
3360     }
3361
3362   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3363
3364   elf_num_locals (abfd) = num_locals;
3365   elf_num_globals (abfd) = num_globals;
3366   return TRUE;
3367 }
3368
3369 /* Align to the maximum file alignment that could be required for any
3370    ELF data structure.  */
3371
3372 static inline file_ptr
3373 align_file_position (file_ptr off, int align)
3374 {
3375   return (off + align - 1) & ~(align - 1);
3376 }
3377
3378 /* Assign a file position to a section, optionally aligning to the
3379    required section alignment.  */
3380
3381 file_ptr
3382 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3383                                            file_ptr offset,
3384                                            bfd_boolean align)
3385 {
3386   if (align && i_shdrp->sh_addralign > 1)
3387     offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3388   i_shdrp->sh_offset = offset;
3389   if (i_shdrp->bfd_section != NULL)
3390     i_shdrp->bfd_section->filepos = offset;
3391   if (i_shdrp->sh_type != SHT_NOBITS)
3392     offset += i_shdrp->sh_size;
3393   return offset;
3394 }
3395
3396 /* Compute the file positions we are going to put the sections at, and
3397    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3398    is not NULL, this is being called by the ELF backend linker.  */
3399
3400 bfd_boolean
3401 _bfd_elf_compute_section_file_positions (bfd *abfd,
3402                                          struct bfd_link_info *link_info)
3403 {
3404   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3405   struct fake_section_arg fsargs;
3406   bfd_boolean failed;
3407   struct bfd_strtab_hash *strtab = NULL;
3408   Elf_Internal_Shdr *shstrtab_hdr;
3409   bfd_boolean need_symtab;
3410
3411   if (abfd->output_has_begun)
3412     return TRUE;
3413
3414   /* Do any elf backend specific processing first.  */
3415   if (bed->elf_backend_begin_write_processing)
3416     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3417
3418   if (! prep_headers (abfd))
3419     return FALSE;
3420
3421   /* Post process the headers if necessary.  */
3422   if (bed->elf_backend_post_process_headers)
3423     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3424
3425   fsargs.failed = FALSE;
3426   fsargs.link_info = link_info;
3427   bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
3428   if (fsargs.failed)
3429     return FALSE;
3430
3431   if (!assign_section_numbers (abfd, link_info))
3432     return FALSE;
3433
3434   /* The backend linker builds symbol table information itself.  */
3435   need_symtab = (link_info == NULL
3436                  && (bfd_get_symcount (abfd) > 0
3437                      || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3438                          == HAS_RELOC)));
3439   if (need_symtab)
3440     {
3441       /* Non-zero if doing a relocatable link.  */
3442       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3443
3444       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3445         return FALSE;
3446     }
3447
3448   failed = FALSE;
3449   if (link_info == NULL)
3450     {
3451       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3452       if (failed)
3453         return FALSE;
3454     }
3455
3456   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3457   /* sh_name was set in prep_headers.  */
3458   shstrtab_hdr->sh_type = SHT_STRTAB;
3459   shstrtab_hdr->sh_flags = 0;
3460   shstrtab_hdr->sh_addr = 0;
3461   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3462   shstrtab_hdr->sh_entsize = 0;
3463   shstrtab_hdr->sh_link = 0;
3464   shstrtab_hdr->sh_info = 0;
3465   /* sh_offset is set in assign_file_positions_except_relocs.  */
3466   shstrtab_hdr->sh_addralign = 1;
3467
3468   if (!assign_file_positions_except_relocs (abfd, link_info))
3469     return FALSE;
3470
3471   if (need_symtab)
3472     {
3473       file_ptr off;
3474       Elf_Internal_Shdr *hdr;
3475
3476       off = elf_tdata (abfd)->next_file_pos;
3477
3478       hdr = &elf_tdata (abfd)->symtab_hdr;
3479       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3480
3481       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3482       if (hdr->sh_size != 0)
3483         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3484
3485       hdr = &elf_tdata (abfd)->strtab_hdr;
3486       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3487
3488       elf_tdata (abfd)->next_file_pos = off;
3489
3490       /* Now that we know where the .strtab section goes, write it
3491          out.  */
3492       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3493           || ! _bfd_stringtab_emit (abfd, strtab))
3494         return FALSE;
3495       _bfd_stringtab_free (strtab);
3496     }
3497
3498   abfd->output_has_begun = TRUE;
3499
3500   return TRUE;
3501 }
3502
3503 /* Make an initial estimate of the size of the program header.  If we
3504    get the number wrong here, we'll redo section placement.  */
3505
3506 static bfd_size_type
3507 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3508 {
3509   size_t segs;
3510   asection *s;
3511   const struct elf_backend_data *bed;
3512
3513   /* Assume we will need exactly two PT_LOAD segments: one for text
3514      and one for data.  */
3515   segs = 2;
3516
3517   s = bfd_get_section_by_name (abfd, ".interp");
3518   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3519     {
3520       /* If we have a loadable interpreter section, we need a
3521          PT_INTERP segment.  In this case, assume we also need a
3522          PT_PHDR segment, although that may not be true for all
3523          targets.  */
3524       segs += 2;
3525     }
3526
3527   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3528     {
3529       /* We need a PT_DYNAMIC segment.  */
3530       ++segs;
3531     }
3532
3533   if (info != NULL && info->relro)
3534     {
3535       /* We need a PT_GNU_RELRO segment.  */
3536       ++segs;
3537     }
3538
3539   if (elf_tdata (abfd)->eh_frame_hdr)
3540     {
3541       /* We need a PT_GNU_EH_FRAME segment.  */
3542       ++segs;
3543     }
3544
3545   if (elf_tdata (abfd)->stack_flags)
3546     {
3547       /* We need a PT_GNU_STACK segment.  */
3548       ++segs;
3549     }
3550
3551   for (s = abfd->sections; s != NULL; s = s->next)
3552     {
3553       if ((s->flags & SEC_LOAD) != 0
3554           && CONST_STRNEQ (s->name, ".note"))
3555         {
3556           /* We need a PT_NOTE segment.  */
3557           ++segs;
3558           /* Try to create just one PT_NOTE segment
3559              for all adjacent loadable .note* sections.
3560              gABI requires that within a PT_NOTE segment
3561              (and also inside of each SHT_NOTE section)
3562              each note is padded to a multiple of 4 size,
3563              so we check whether the sections are correctly
3564              aligned.  */
3565           if (s->alignment_power == 2)
3566             while (s->next != NULL
3567                    && s->next->alignment_power == 2
3568                    && (s->next->flags & SEC_LOAD) != 0
3569                    && CONST_STRNEQ (s->next->name, ".note"))
3570               s = s->next;
3571         }
3572     }
3573
3574   for (s = abfd->sections; s != NULL; s = s->next)
3575     {
3576       if (s->flags & SEC_THREAD_LOCAL)
3577         {
3578           /* We need a PT_TLS segment.  */
3579           ++segs;
3580           break;
3581         }
3582     }
3583
3584   /* Let the backend count up any program headers it might need.  */
3585   bed = get_elf_backend_data (abfd);
3586   if (bed->elf_backend_additional_program_headers)
3587     {
3588       int a;
3589
3590       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3591       if (a == -1)
3592         abort ();
3593       segs += a;
3594     }
3595
3596   return segs * bed->s->sizeof_phdr;
3597 }
3598
3599 /* Find the segment that contains the output_section of section.  */
3600
3601 Elf_Internal_Phdr *
3602 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3603 {
3604   struct elf_segment_map *m;
3605   Elf_Internal_Phdr *p;
3606
3607   for (m = elf_tdata (abfd)->segment_map,
3608          p = elf_tdata (abfd)->phdr;
3609        m != NULL;
3610        m = m->next, p++)
3611     {
3612       int i;
3613
3614       for (i = m->count - 1; i >= 0; i--)
3615         if (m->sections[i] == section)
3616           return p;
3617     }
3618
3619   return NULL;
3620 }
3621
3622 /* Create a mapping from a set of sections to a program segment.  */
3623
3624 static struct elf_segment_map *
3625 make_mapping (bfd *abfd,
3626               asection **sections,
3627               unsigned int from,
3628               unsigned int to,
3629               bfd_boolean phdr)
3630 {
3631   struct elf_segment_map *m;
3632   unsigned int i;
3633   asection **hdrpp;
3634   bfd_size_type amt;
3635
3636   amt = sizeof (struct elf_segment_map);
3637   amt += (to - from - 1) * sizeof (asection *);
3638   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3639   if (m == NULL)
3640     return NULL;
3641   m->next = NULL;
3642   m->p_type = PT_LOAD;
3643   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3644     m->sections[i - from] = *hdrpp;
3645   m->count = to - from;
3646
3647   if (from == 0 && phdr)
3648     {
3649       /* Include the headers in the first PT_LOAD segment.  */
3650       m->includes_filehdr = 1;
3651       m->includes_phdrs = 1;
3652     }
3653
3654   return m;
3655 }
3656
3657 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3658    on failure.  */
3659
3660 struct elf_segment_map *
3661 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3662 {
3663   struct elf_segment_map *m;
3664
3665   m = (struct elf_segment_map *) bfd_zalloc (abfd,
3666                                              sizeof (struct elf_segment_map));
3667   if (m == NULL)
3668     return NULL;
3669   m->next = NULL;
3670   m->p_type = PT_DYNAMIC;
3671   m->count = 1;
3672   m->sections[0] = dynsec;
3673
3674   return m;
3675 }
3676
3677 /* Possibly add or remove segments from the segment map.  */
3678
3679 static bfd_boolean
3680 elf_modify_segment_map (bfd *abfd,
3681                         struct bfd_link_info *info,
3682                         bfd_boolean remove_empty_load)
3683 {
3684   struct elf_segment_map **m;
3685   const struct elf_backend_data *bed;
3686
3687   /* The placement algorithm assumes that non allocated sections are
3688      not in PT_LOAD segments.  We ensure this here by removing such
3689      sections from the segment map.  We also remove excluded
3690      sections.  Finally, any PT_LOAD segment without sections is
3691      removed.  */
3692   m = &elf_tdata (abfd)->segment_map;
3693   while (*m)
3694     {
3695       unsigned int i, new_count;
3696
3697       for (new_count = 0, i = 0; i < (*m)->count; i++)
3698         {
3699           if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3700               && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3701                   || (*m)->p_type != PT_LOAD))
3702             {
3703               (*m)->sections[new_count] = (*m)->sections[i];
3704               new_count++;
3705             }
3706         }
3707       (*m)->count = new_count;
3708
3709       if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3710         *m = (*m)->next;
3711       else
3712         m = &(*m)->next;
3713     }
3714
3715   bed = get_elf_backend_data (abfd);
3716   if (bed->elf_backend_modify_segment_map != NULL)
3717     {
3718       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3719         return FALSE;
3720     }
3721
3722   return TRUE;
3723 }
3724
3725 /* Set up a mapping from BFD sections to program segments.  */
3726
3727 bfd_boolean
3728 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3729 {
3730   unsigned int count;
3731   struct elf_segment_map *m;
3732   asection **sections = NULL;
3733   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3734   bfd_boolean no_user_phdrs;
3735
3736   no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3737   if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3738     {
3739       asection *s;
3740       unsigned int i;
3741       struct elf_segment_map *mfirst;
3742       struct elf_segment_map **pm;
3743       asection *last_hdr;
3744       bfd_vma last_size;
3745       unsigned int phdr_index;
3746       bfd_vma maxpagesize;
3747       asection **hdrpp;
3748       bfd_boolean phdr_in_segment = TRUE;
3749       bfd_boolean writable;
3750       int tls_count = 0;
3751       asection *first_tls = NULL;
3752       asection *dynsec, *eh_frame_hdr;
3753       bfd_size_type amt;
3754       bfd_vma addr_mask, wrap_to = 0;
3755
3756       /* Select the allocated sections, and sort them.  */
3757
3758       sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3759                                             sizeof (asection *));
3760       if (sections == NULL)
3761         goto error_return;
3762
3763       /* Calculate top address, avoiding undefined behaviour of shift
3764          left operator when shift count is equal to size of type
3765          being shifted.  */
3766       addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
3767       addr_mask = (addr_mask << 1) + 1;
3768
3769       i = 0;
3770       for (s = abfd->sections; s != NULL; s = s->next)
3771         {
3772           if ((s->flags & SEC_ALLOC) != 0)
3773             {
3774               sections[i] = s;
3775               ++i;
3776               /* A wrapping section potentially clashes with header.  */
3777               if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
3778                 wrap_to = (s->lma + s->size) & addr_mask;
3779             }
3780         }
3781       BFD_ASSERT (i <= bfd_count_sections (abfd));
3782       count = i;
3783
3784       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3785
3786       /* Build the mapping.  */
3787
3788       mfirst = NULL;
3789       pm = &mfirst;
3790
3791       /* If we have a .interp section, then create a PT_PHDR segment for
3792          the program headers and a PT_INTERP segment for the .interp
3793          section.  */
3794       s = bfd_get_section_by_name (abfd, ".interp");
3795       if (s != NULL && (s->flags & SEC_LOAD) != 0)
3796         {
3797           amt = sizeof (struct elf_segment_map);
3798           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3799           if (m == NULL)
3800             goto error_return;
3801           m->next = NULL;
3802           m->p_type = PT_PHDR;
3803           /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3804           m->p_flags = PF_R | PF_X;
3805           m->p_flags_valid = 1;
3806           m->includes_phdrs = 1;
3807
3808           *pm = m;
3809           pm = &m->next;
3810
3811           amt = sizeof (struct elf_segment_map);
3812           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3813           if (m == NULL)
3814             goto error_return;
3815           m->next = NULL;
3816           m->p_type = PT_INTERP;
3817           m->count = 1;
3818           m->sections[0] = s;
3819
3820           *pm = m;
3821           pm = &m->next;
3822         }
3823
3824       /* Look through the sections.  We put sections in the same program
3825          segment when the start of the second section can be placed within
3826          a few bytes of the end of the first section.  */
3827       last_hdr = NULL;
3828       last_size = 0;
3829       phdr_index = 0;
3830       maxpagesize = bed->maxpagesize;
3831       writable = FALSE;
3832       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3833       if (dynsec != NULL
3834           && (dynsec->flags & SEC_LOAD) == 0)
3835         dynsec = NULL;
3836
3837       /* Deal with -Ttext or something similar such that the first section
3838          is not adjacent to the program headers.  This is an
3839          approximation, since at this point we don't know exactly how many
3840          program headers we will need.  */
3841       if (count > 0)
3842         {
3843           bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3844
3845           if (phdr_size == (bfd_size_type) -1)
3846             phdr_size = get_program_header_size (abfd, info);
3847           if ((abfd->flags & D_PAGED) == 0
3848               || (sections[0]->lma & addr_mask) < phdr_size
3849               || ((sections[0]->lma & addr_mask) % maxpagesize
3850                   < phdr_size % maxpagesize)
3851               || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
3852             phdr_in_segment = FALSE;
3853         }
3854
3855       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3856         {
3857           asection *hdr;
3858           bfd_boolean new_segment;
3859
3860           hdr = *hdrpp;
3861
3862           /* See if this section and the last one will fit in the same
3863              segment.  */
3864
3865           if (last_hdr == NULL)
3866             {
3867               /* If we don't have a segment yet, then we don't need a new
3868                  one (we build the last one after this loop).  */
3869               new_segment = FALSE;
3870             }
3871           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3872             {
3873               /* If this section has a different relation between the
3874                  virtual address and the load address, then we need a new
3875                  segment.  */
3876               new_segment = TRUE;
3877             }
3878           else if (hdr->lma < last_hdr->lma + last_size
3879                    || last_hdr->lma + last_size < last_hdr->lma)
3880             {
3881               /* If this section has a load address that makes it overlap
3882                  the previous section, then we need a new segment.  */
3883               new_segment = TRUE;
3884             }
3885           /* In the next test we have to be careful when last_hdr->lma is close
3886              to the end of the address space.  If the aligned address wraps
3887              around to the start of the address space, then there are no more
3888              pages left in memory and it is OK to assume that the current
3889              section can be included in the current segment.  */
3890           else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3891                     > last_hdr->lma)
3892                    && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3893                        <= hdr->lma))
3894             {
3895               /* If putting this section in this segment would force us to
3896                  skip a page in the segment, then we need a new segment.  */
3897               new_segment = TRUE;
3898             }
3899           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3900                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3901             {
3902               /* We don't want to put a loadable section after a
3903                  nonloadable section in the same segment.
3904                  Consider .tbss sections as loadable for this purpose.  */
3905               new_segment = TRUE;
3906             }
3907           else if ((abfd->flags & D_PAGED) == 0)
3908             {
3909               /* If the file is not demand paged, which means that we
3910                  don't require the sections to be correctly aligned in the
3911                  file, then there is no other reason for a new segment.  */
3912               new_segment = FALSE;
3913             }
3914           else if (! writable
3915                    && (hdr->flags & SEC_READONLY) == 0
3916                    && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3917                        != (hdr->lma & -maxpagesize)))
3918             {
3919               /* We don't want to put a writable section in a read only
3920                  segment, unless they are on the same page in memory
3921                  anyhow.  We already know that the last section does not
3922                  bring us past the current section on the page, so the
3923                  only case in which the new section is not on the same
3924                  page as the previous section is when the previous section
3925                  ends precisely on a page boundary.  */
3926               new_segment = TRUE;
3927             }
3928           else
3929             {
3930               /* Otherwise, we can use the same segment.  */
3931               new_segment = FALSE;
3932             }
3933
3934           /* Allow interested parties a chance to override our decision.  */
3935           if (last_hdr != NULL
3936               && info != NULL
3937               && info->callbacks->override_segment_assignment != NULL)
3938             new_segment
3939               = info->callbacks->override_segment_assignment (info, abfd, hdr,
3940                                                               last_hdr,
3941                                                               new_segment);
3942
3943           if (! new_segment)
3944             {
3945               if ((hdr->flags & SEC_READONLY) == 0)
3946                 writable = TRUE;
3947               last_hdr = hdr;
3948               /* .tbss sections effectively have zero size.  */
3949               if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3950                   != SEC_THREAD_LOCAL)
3951                 last_size = hdr->size;
3952               else
3953                 last_size = 0;
3954               continue;
3955             }
3956
3957           /* We need a new program segment.  We must create a new program
3958              header holding all the sections from phdr_index until hdr.  */
3959
3960           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3961           if (m == NULL)
3962             goto error_return;
3963
3964           *pm = m;
3965           pm = &m->next;
3966
3967           if ((hdr->flags & SEC_READONLY) == 0)
3968             writable = TRUE;
3969           else
3970             writable = FALSE;
3971
3972           last_hdr = hdr;
3973           /* .tbss sections effectively have zero size.  */
3974           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3975             last_size = hdr->size;
3976           else
3977             last_size = 0;
3978           phdr_index = i;
3979           phdr_in_segment = FALSE;
3980         }
3981
3982       /* Create a final PT_LOAD program segment.  */
3983       if (last_hdr != NULL)
3984         {
3985           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3986           if (m == NULL)
3987             goto error_return;
3988
3989           *pm = m;
3990           pm = &m->next;
3991         }
3992
3993       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3994       if (dynsec != NULL)
3995         {
3996           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3997           if (m == NULL)
3998             goto error_return;
3999           *pm = m;
4000           pm = &m->next;
4001         }
4002
4003       /* For each batch of consecutive loadable .note sections,
4004          add a PT_NOTE segment.  We don't use bfd_get_section_by_name,
4005          because if we link together nonloadable .note sections and
4006          loadable .note sections, we will generate two .note sections
4007          in the output file.  FIXME: Using names for section types is
4008          bogus anyhow.  */
4009       for (s = abfd->sections; s != NULL; s = s->next)
4010         {
4011           if ((s->flags & SEC_LOAD) != 0
4012               && CONST_STRNEQ (s->name, ".note"))
4013             {
4014               asection *s2;
4015
4016               count = 1;
4017               amt = sizeof (struct elf_segment_map);
4018               if (s->alignment_power == 2)
4019                 for (s2 = s; s2->next != NULL; s2 = s2->next)
4020                   {
4021                     if (s2->next->alignment_power == 2
4022                         && (s2->next->flags & SEC_LOAD) != 0
4023                         && CONST_STRNEQ (s2->next->name, ".note")
4024                         && align_power (s2->lma + s2->size, 2)
4025                            == s2->next->lma)
4026                       count++;
4027                     else
4028                       break;
4029                   }
4030               amt += (count - 1) * sizeof (asection *);
4031               m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4032               if (m == NULL)
4033                 goto error_return;
4034               m->next = NULL;
4035               m->p_type = PT_NOTE;
4036               m->count = count;
4037               while (count > 1)
4038                 {
4039                   m->sections[m->count - count--] = s;
4040                   BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4041                   s = s->next;
4042                 }
4043               m->sections[m->count - 1] = s;
4044               BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4045               *pm = m;
4046               pm = &m->next;
4047             }
4048           if (s->flags & SEC_THREAD_LOCAL)
4049             {
4050               if (! tls_count)
4051                 first_tls = s;
4052               tls_count++;
4053             }
4054         }
4055
4056       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
4057       if (tls_count > 0)
4058         {
4059           amt = sizeof (struct elf_segment_map);
4060           amt += (tls_count - 1) * sizeof (asection *);
4061           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4062           if (m == NULL)
4063             goto error_return;
4064           m->next = NULL;
4065           m->p_type = PT_TLS;
4066           m->count = tls_count;
4067           /* Mandated PF_R.  */
4068           m->p_flags = PF_R;
4069           m->p_flags_valid = 1;
4070           for (i = 0; i < (unsigned int) tls_count; ++i)
4071             {
4072               BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
4073               m->sections[i] = first_tls;
4074               first_tls = first_tls->next;
4075             }
4076
4077           *pm = m;
4078           pm = &m->next;
4079         }
4080
4081       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4082          segment.  */
4083       eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
4084       if (eh_frame_hdr != NULL
4085           && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4086         {
4087           amt = sizeof (struct elf_segment_map);
4088           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4089           if (m == NULL)
4090             goto error_return;
4091           m->next = NULL;
4092           m->p_type = PT_GNU_EH_FRAME;
4093           m->count = 1;
4094           m->sections[0] = eh_frame_hdr->output_section;