Merge branch 'vendor/OPENSSL'
[dragonfly.git] / contrib / binutils-2.22 / 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                 && (hdr->sh_flags & SHF_TLS) == 0)
981                || phdr->p_type == PT_TLS)
982               && ELF_SECTION_IN_SEGMENT (hdr, phdr))
983             {
984               if ((flags & SEC_LOAD) == 0)
985                 newsect->lma = (phdr->p_paddr
986                                 + hdr->sh_addr - phdr->p_vaddr);
987               else
988                 /* We used to use the same adjustment for SEC_LOAD
989                    sections, but that doesn't work if the segment
990                    is packed with code from multiple VMAs.
991                    Instead we calculate the section LMA based on
992                    the segment LMA.  It is assumed that the
993                    segment will contain sections with contiguous
994                    LMAs, even if the VMAs are not.  */
995                 newsect->lma = (phdr->p_paddr
996                                 + hdr->sh_offset - phdr->p_offset);
997
998               /* With contiguous segments, we can't tell from file
999                  offsets whether a section with zero size should
1000                  be placed at the end of one segment or the
1001                  beginning of the next.  Decide based on vaddr.  */
1002               if (hdr->sh_addr >= phdr->p_vaddr
1003                   && (hdr->sh_addr + hdr->sh_size
1004                       <= phdr->p_vaddr + phdr->p_memsz))
1005                 break;
1006             }
1007         }
1008     }
1009
1010   /* Compress/decompress DWARF debug sections with names: .debug_* and
1011      .zdebug_*, after the section flags is set.  */
1012   if ((flags & SEC_DEBUGGING)
1013       && ((name[1] == 'd' && name[6] == '_')
1014           || (name[1] == 'z' && name[7] == '_')))
1015     {
1016       enum { nothing, compress, decompress } action = nothing;
1017       char *new_name;
1018
1019       if (bfd_is_section_compressed (abfd, newsect))
1020         {
1021           /* Compressed section.  Check if we should decompress.  */
1022           if ((abfd->flags & BFD_DECOMPRESS))
1023             action = decompress;
1024         }
1025       else
1026         {
1027           /* Normal section.  Check if we should compress.  */
1028           if ((abfd->flags & BFD_COMPRESS))
1029             action = compress;
1030         }
1031
1032       new_name = NULL;
1033       switch (action)
1034         {
1035         case nothing:
1036           break;
1037         case compress:
1038           if (!bfd_init_section_compress_status (abfd, newsect))
1039             {
1040               (*_bfd_error_handler)
1041                 (_("%B: unable to initialize commpress status for section %s"),
1042                  abfd, name);
1043               return FALSE;
1044             }
1045           if (name[1] != 'z')
1046             {
1047               unsigned int len = strlen (name);
1048
1049               new_name = bfd_alloc (abfd, len + 2);
1050               if (new_name == NULL)
1051                 return FALSE;
1052               new_name[0] = '.';
1053               new_name[1] = 'z';
1054               memcpy (new_name + 2, name + 1, len);
1055             }
1056           break;
1057         case decompress:
1058           if (!bfd_init_section_decompress_status (abfd, newsect))
1059             {
1060               (*_bfd_error_handler)
1061                 (_("%B: unable to initialize decommpress status for section %s"),
1062                  abfd, name);
1063               return FALSE;
1064             }
1065           if (name[1] == 'z')
1066             {
1067               unsigned int len = strlen (name);
1068
1069               new_name = bfd_alloc (abfd, len);
1070               if (new_name == NULL)
1071                 return FALSE;
1072               new_name[0] = '.';
1073               memcpy (new_name + 1, name + 2, len - 1);
1074             }
1075           break;
1076         }
1077       if (new_name != NULL)
1078         bfd_rename_section (abfd, newsect, new_name);
1079     }
1080
1081   return TRUE;
1082 }
1083
1084 const char *const bfd_elf_section_type_names[] = {
1085   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1086   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1087   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1088 };
1089
1090 /* ELF relocs are against symbols.  If we are producing relocatable
1091    output, and the reloc is against an external symbol, and nothing
1092    has given us any additional addend, the resulting reloc will also
1093    be against the same symbol.  In such a case, we don't want to
1094    change anything about the way the reloc is handled, since it will
1095    all be done at final link time.  Rather than put special case code
1096    into bfd_perform_relocation, all the reloc types use this howto
1097    function.  It just short circuits the reloc if producing
1098    relocatable output against an external symbol.  */
1099
1100 bfd_reloc_status_type
1101 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1102                        arelent *reloc_entry,
1103                        asymbol *symbol,
1104                        void *data ATTRIBUTE_UNUSED,
1105                        asection *input_section,
1106                        bfd *output_bfd,
1107                        char **error_message ATTRIBUTE_UNUSED)
1108 {
1109   if (output_bfd != NULL
1110       && (symbol->flags & BSF_SECTION_SYM) == 0
1111       && (! reloc_entry->howto->partial_inplace
1112           || reloc_entry->addend == 0))
1113     {
1114       reloc_entry->address += input_section->output_offset;
1115       return bfd_reloc_ok;
1116     }
1117
1118   return bfd_reloc_continue;
1119 }
1120 \f
1121 /* Copy the program header and other data from one object module to
1122    another.  */
1123
1124 bfd_boolean
1125 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1126 {
1127   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1128       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1129     return TRUE;
1130
1131   BFD_ASSERT (!elf_flags_init (obfd)
1132               || (elf_elfheader (obfd)->e_flags
1133                   == elf_elfheader (ibfd)->e_flags));
1134
1135   elf_gp (obfd) = elf_gp (ibfd);
1136   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1137   elf_flags_init (obfd) = TRUE;
1138
1139   /* Copy object attributes.  */
1140   _bfd_elf_copy_obj_attributes (ibfd, obfd);
1141   return TRUE;
1142 }
1143
1144 static const char *
1145 get_segment_type (unsigned int p_type)
1146 {
1147   const char *pt;
1148   switch (p_type)
1149     {
1150     case PT_NULL: pt = "NULL"; break;
1151     case PT_LOAD: pt = "LOAD"; break;
1152     case PT_DYNAMIC: pt = "DYNAMIC"; break;
1153     case PT_INTERP: pt = "INTERP"; break;
1154     case PT_NOTE: pt = "NOTE"; break;
1155     case PT_SHLIB: pt = "SHLIB"; break;
1156     case PT_PHDR: pt = "PHDR"; break;
1157     case PT_TLS: pt = "TLS"; break;
1158     case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1159     case PT_GNU_STACK: pt = "STACK"; break;
1160     case PT_GNU_RELRO: pt = "RELRO"; break;
1161     default: pt = NULL; break;
1162     }
1163   return pt;
1164 }
1165
1166 /* Print out the program headers.  */
1167
1168 bfd_boolean
1169 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1170 {
1171   FILE *f = (FILE *) farg;
1172   Elf_Internal_Phdr *p;
1173   asection *s;
1174   bfd_byte *dynbuf = NULL;
1175
1176   p = elf_tdata (abfd)->phdr;
1177   if (p != NULL)
1178     {
1179       unsigned int i, c;
1180
1181       fprintf (f, _("\nProgram Header:\n"));
1182       c = elf_elfheader (abfd)->e_phnum;
1183       for (i = 0; i < c; i++, p++)
1184         {
1185           const char *pt = get_segment_type (p->p_type);
1186           char buf[20];
1187
1188           if (pt == NULL)
1189             {
1190               sprintf (buf, "0x%lx", p->p_type);
1191               pt = buf;
1192             }
1193           fprintf (f, "%8s off    0x", pt);
1194           bfd_fprintf_vma (abfd, f, p->p_offset);
1195           fprintf (f, " vaddr 0x");
1196           bfd_fprintf_vma (abfd, f, p->p_vaddr);
1197           fprintf (f, " paddr 0x");
1198           bfd_fprintf_vma (abfd, f, p->p_paddr);
1199           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1200           fprintf (f, "         filesz 0x");
1201           bfd_fprintf_vma (abfd, f, p->p_filesz);
1202           fprintf (f, " memsz 0x");
1203           bfd_fprintf_vma (abfd, f, p->p_memsz);
1204           fprintf (f, " flags %c%c%c",
1205                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
1206                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
1207                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
1208           if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1209             fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1210           fprintf (f, "\n");
1211         }
1212     }
1213
1214   s = bfd_get_section_by_name (abfd, ".dynamic");
1215   if (s != NULL)
1216     {
1217       unsigned int elfsec;
1218       unsigned long shlink;
1219       bfd_byte *extdyn, *extdynend;
1220       size_t extdynsize;
1221       void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1222
1223       fprintf (f, _("\nDynamic Section:\n"));
1224
1225       if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1226         goto error_return;
1227
1228       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1229       if (elfsec == SHN_BAD)
1230         goto error_return;
1231       shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1232
1233       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1234       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1235
1236       extdyn = dynbuf;
1237       extdynend = extdyn + s->size;
1238       for (; extdyn < extdynend; extdyn += extdynsize)
1239         {
1240           Elf_Internal_Dyn dyn;
1241           const char *name = "";
1242           char ab[20];
1243           bfd_boolean stringp;
1244           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1245
1246           (*swap_dyn_in) (abfd, extdyn, &dyn);
1247
1248           if (dyn.d_tag == DT_NULL)
1249             break;
1250
1251           stringp = FALSE;
1252           switch (dyn.d_tag)
1253             {
1254             default:
1255               if (bed->elf_backend_get_target_dtag)
1256                 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1257
1258               if (!strcmp (name, ""))
1259                 {
1260                   sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1261                   name = ab;
1262                 }
1263               break;
1264
1265             case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1266             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1267             case DT_PLTGOT: name = "PLTGOT"; break;
1268             case DT_HASH: name = "HASH"; break;
1269             case DT_STRTAB: name = "STRTAB"; break;
1270             case DT_SYMTAB: name = "SYMTAB"; break;
1271             case DT_RELA: name = "RELA"; break;
1272             case DT_RELASZ: name = "RELASZ"; break;
1273             case DT_RELAENT: name = "RELAENT"; break;
1274             case DT_STRSZ: name = "STRSZ"; break;
1275             case DT_SYMENT: name = "SYMENT"; break;
1276             case DT_INIT: name = "INIT"; break;
1277             case DT_FINI: name = "FINI"; break;
1278             case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1279             case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1280             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1281             case DT_REL: name = "REL"; break;
1282             case DT_RELSZ: name = "RELSZ"; break;
1283             case DT_RELENT: name = "RELENT"; break;
1284             case DT_PLTREL: name = "PLTREL"; break;
1285             case DT_DEBUG: name = "DEBUG"; break;
1286             case DT_TEXTREL: name = "TEXTREL"; break;
1287             case DT_JMPREL: name = "JMPREL"; break;
1288             case DT_BIND_NOW: name = "BIND_NOW"; break;
1289             case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1290             case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1291             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1292             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1293             case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1294             case DT_FLAGS: name = "FLAGS"; break;
1295             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1296             case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1297             case DT_CHECKSUM: name = "CHECKSUM"; break;
1298             case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1299             case DT_MOVEENT: name = "MOVEENT"; break;
1300             case DT_MOVESZ: name = "MOVESZ"; break;
1301             case DT_FEATURE: name = "FEATURE"; break;
1302             case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1303             case DT_SYMINSZ: name = "SYMINSZ"; break;
1304             case DT_SYMINENT: name = "SYMINENT"; break;
1305             case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1306             case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1307             case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1308             case DT_PLTPAD: name = "PLTPAD"; break;
1309             case DT_MOVETAB: name = "MOVETAB"; break;
1310             case DT_SYMINFO: name = "SYMINFO"; break;
1311             case DT_RELACOUNT: name = "RELACOUNT"; break;
1312             case DT_RELCOUNT: name = "RELCOUNT"; break;
1313             case DT_FLAGS_1: name = "FLAGS_1"; break;
1314             case DT_VERSYM: name = "VERSYM"; break;
1315             case DT_VERDEF: name = "VERDEF"; break;
1316             case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1317             case DT_VERNEED: name = "VERNEED"; break;
1318             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1319             case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1320             case DT_USED: name = "USED"; break;
1321             case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1322             case DT_GNU_HASH: name = "GNU_HASH"; break;
1323             }
1324
1325           fprintf (f, "  %-20s ", name);
1326           if (! stringp)
1327             {
1328               fprintf (f, "0x");
1329               bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1330             }
1331           else
1332             {
1333               const char *string;
1334               unsigned int tagv = dyn.d_un.d_val;
1335
1336               string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1337               if (string == NULL)
1338                 goto error_return;
1339               fprintf (f, "%s", string);
1340             }
1341           fprintf (f, "\n");
1342         }
1343
1344       free (dynbuf);
1345       dynbuf = NULL;
1346     }
1347
1348   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1349       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1350     {
1351       if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1352         return FALSE;
1353     }
1354
1355   if (elf_dynverdef (abfd) != 0)
1356     {
1357       Elf_Internal_Verdef *t;
1358
1359       fprintf (f, _("\nVersion definitions:\n"));
1360       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1361         {
1362           fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1363                    t->vd_flags, t->vd_hash,
1364                    t->vd_nodename ? t->vd_nodename : "<corrupt>");
1365           if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1366             {
1367               Elf_Internal_Verdaux *a;
1368
1369               fprintf (f, "\t");
1370               for (a = t->vd_auxptr->vda_nextptr;
1371                    a != NULL;
1372                    a = a->vda_nextptr)
1373                 fprintf (f, "%s ",
1374                          a->vda_nodename ? a->vda_nodename : "<corrupt>");
1375               fprintf (f, "\n");
1376             }
1377         }
1378     }
1379
1380   if (elf_dynverref (abfd) != 0)
1381     {
1382       Elf_Internal_Verneed *t;
1383
1384       fprintf (f, _("\nVersion References:\n"));
1385       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1386         {
1387           Elf_Internal_Vernaux *a;
1388
1389           fprintf (f, _("  required from %s:\n"),
1390                    t->vn_filename ? t->vn_filename : "<corrupt>");
1391           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1392             fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1393                      a->vna_flags, a->vna_other,
1394                      a->vna_nodename ? a->vna_nodename : "<corrupt>");
1395         }
1396     }
1397
1398   return TRUE;
1399
1400  error_return:
1401   if (dynbuf != NULL)
1402     free (dynbuf);
1403   return FALSE;
1404 }
1405
1406 /* Display ELF-specific fields of a symbol.  */
1407
1408 void
1409 bfd_elf_print_symbol (bfd *abfd,
1410                       void *filep,
1411                       asymbol *symbol,
1412                       bfd_print_symbol_type how)
1413 {
1414   FILE *file = (FILE *) filep;
1415   switch (how)
1416     {
1417     case bfd_print_symbol_name:
1418       fprintf (file, "%s", symbol->name);
1419       break;
1420     case bfd_print_symbol_more:
1421       fprintf (file, "elf ");
1422       bfd_fprintf_vma (abfd, file, symbol->value);
1423       fprintf (file, " %lx", (unsigned long) symbol->flags);
1424       break;
1425     case bfd_print_symbol_all:
1426       {
1427         const char *section_name;
1428         const char *name = NULL;
1429         const struct elf_backend_data *bed;
1430         unsigned char st_other;
1431         bfd_vma val;
1432
1433         section_name = symbol->section ? symbol->section->name : "(*none*)";
1434
1435         bed = get_elf_backend_data (abfd);
1436         if (bed->elf_backend_print_symbol_all)
1437           name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1438
1439         if (name == NULL)
1440           {
1441             name = symbol->name;
1442             bfd_print_symbol_vandf (abfd, file, symbol);
1443           }
1444
1445         fprintf (file, " %s\t", section_name);
1446         /* Print the "other" value for a symbol.  For common symbols,
1447            we've already printed the size; now print the alignment.
1448            For other symbols, we have no specified alignment, and
1449            we've printed the address; now print the size.  */
1450         if (symbol->section && bfd_is_com_section (symbol->section))
1451           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1452         else
1453           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1454         bfd_fprintf_vma (abfd, file, val);
1455
1456         /* If we have version information, print it.  */
1457         if (elf_tdata (abfd)->dynversym_section != 0
1458             && (elf_tdata (abfd)->dynverdef_section != 0
1459                 || elf_tdata (abfd)->dynverref_section != 0))
1460           {
1461             unsigned int vernum;
1462             const char *version_string;
1463
1464             vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1465
1466             if (vernum == 0)
1467               version_string = "";
1468             else if (vernum == 1)
1469               version_string = "Base";
1470             else if (vernum <= elf_tdata (abfd)->cverdefs)
1471               version_string =
1472                 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1473             else
1474               {
1475                 Elf_Internal_Verneed *t;
1476
1477                 version_string = "";
1478                 for (t = elf_tdata (abfd)->verref;
1479                      t != NULL;
1480                      t = t->vn_nextref)
1481                   {
1482                     Elf_Internal_Vernaux *a;
1483
1484                     for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1485                       {
1486                         if (a->vna_other == vernum)
1487                           {
1488                             version_string = a->vna_nodename;
1489                             break;
1490                           }
1491                       }
1492                   }
1493               }
1494
1495             if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1496               fprintf (file, "  %-11s", version_string);
1497             else
1498               {
1499                 int i;
1500
1501                 fprintf (file, " (%s)", version_string);
1502                 for (i = 10 - strlen (version_string); i > 0; --i)
1503                   putc (' ', file);
1504               }
1505           }
1506
1507         /* If the st_other field is not zero, print it.  */
1508         st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1509
1510         switch (st_other)
1511           {
1512           case 0: break;
1513           case STV_INTERNAL:  fprintf (file, " .internal");  break;
1514           case STV_HIDDEN:    fprintf (file, " .hidden");    break;
1515           case STV_PROTECTED: fprintf (file, " .protected"); break;
1516           default:
1517             /* Some other non-defined flags are also present, so print
1518                everything hex.  */
1519             fprintf (file, " 0x%02x", (unsigned int) st_other);
1520           }
1521
1522         fprintf (file, " %s", name);
1523       }
1524       break;
1525     }
1526 }
1527
1528 /* Allocate an ELF string table--force the first byte to be zero.  */
1529
1530 struct bfd_strtab_hash *
1531 _bfd_elf_stringtab_init (void)
1532 {
1533   struct bfd_strtab_hash *ret;
1534
1535   ret = _bfd_stringtab_init ();
1536   if (ret != NULL)
1537     {
1538       bfd_size_type loc;
1539
1540       loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1541       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1542       if (loc == (bfd_size_type) -1)
1543         {
1544           _bfd_stringtab_free (ret);
1545           ret = NULL;
1546         }
1547     }
1548   return ret;
1549 }
1550 \f
1551 /* ELF .o/exec file reading */
1552
1553 /* Create a new bfd section from an ELF section header.  */
1554
1555 bfd_boolean
1556 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1557 {
1558   Elf_Internal_Shdr *hdr;
1559   Elf_Internal_Ehdr *ehdr;
1560   const struct elf_backend_data *bed;
1561   const char *name;
1562
1563   if (shindex >= elf_numsections (abfd))
1564     return FALSE;
1565
1566   hdr = elf_elfsections (abfd)[shindex];
1567   ehdr = elf_elfheader (abfd);
1568   name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1569                                           hdr->sh_name);
1570   if (name == NULL)
1571     return FALSE;
1572
1573   bed = get_elf_backend_data (abfd);
1574   switch (hdr->sh_type)
1575     {
1576     case SHT_NULL:
1577       /* Inactive section. Throw it away.  */
1578       return TRUE;
1579
1580     case SHT_PROGBITS:  /* Normal section with contents.  */
1581     case SHT_NOBITS:    /* .bss section.  */
1582     case SHT_HASH:      /* .hash section.  */
1583     case SHT_NOTE:      /* .note section.  */
1584     case SHT_INIT_ARRAY:        /* .init_array section.  */
1585     case SHT_FINI_ARRAY:        /* .fini_array section.  */
1586     case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
1587     case SHT_GNU_LIBLIST:       /* .gnu.liblist section.  */
1588     case SHT_GNU_HASH:          /* .gnu.hash section.  */
1589       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1590
1591     case SHT_DYNAMIC:   /* Dynamic linking information.  */
1592       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1593         return FALSE;
1594       if (hdr->sh_link > elf_numsections (abfd))
1595         {
1596           /* PR 10478: Accept Solaris binaries with a sh_link
1597              field set to SHN_BEFORE or SHN_AFTER.  */
1598           switch (bfd_get_arch (abfd))
1599             {
1600             case bfd_arch_i386:
1601             case bfd_arch_sparc:
1602               if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1603                   || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1604                 break;
1605               /* Otherwise fall through.  */
1606             default:
1607               return FALSE;
1608             }
1609         }
1610       else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
1611         return FALSE;
1612       else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1613         {
1614           Elf_Internal_Shdr *dynsymhdr;
1615
1616           /* The shared libraries distributed with hpux11 have a bogus
1617              sh_link field for the ".dynamic" section.  Find the
1618              string table for the ".dynsym" section instead.  */
1619           if (elf_dynsymtab (abfd) != 0)
1620             {
1621               dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1622               hdr->sh_link = dynsymhdr->sh_link;
1623             }
1624           else
1625             {
1626               unsigned int i, num_sec;
1627
1628               num_sec = elf_numsections (abfd);
1629               for (i = 1; i < num_sec; i++)
1630                 {
1631                   dynsymhdr = elf_elfsections (abfd)[i];
1632                   if (dynsymhdr->sh_type == SHT_DYNSYM)
1633                     {
1634                       hdr->sh_link = dynsymhdr->sh_link;
1635                       break;
1636                     }
1637                 }
1638             }
1639         }
1640       break;
1641
1642     case SHT_SYMTAB:            /* A symbol table */
1643       if (elf_onesymtab (abfd) == shindex)
1644         return TRUE;
1645
1646       if (hdr->sh_entsize != bed->s->sizeof_sym)
1647         return FALSE;
1648       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
1649         return FALSE;
1650       BFD_ASSERT (elf_onesymtab (abfd) == 0);
1651       elf_onesymtab (abfd) = shindex;
1652       elf_tdata (abfd)->symtab_hdr = *hdr;
1653       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1654       abfd->flags |= HAS_SYMS;
1655
1656       /* Sometimes a shared object will map in the symbol table.  If
1657          SHF_ALLOC is set, and this is a shared object, then we also
1658          treat this section as a BFD section.  We can not base the
1659          decision purely on SHF_ALLOC, because that flag is sometimes
1660          set in a relocatable object file, which would confuse the
1661          linker.  */
1662       if ((hdr->sh_flags & SHF_ALLOC) != 0
1663           && (abfd->flags & DYNAMIC) != 0
1664           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1665                                                 shindex))
1666         return FALSE;
1667
1668       /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1669          can't read symbols without that section loaded as well.  It
1670          is most likely specified by the next section header.  */
1671       if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1672         {
1673           unsigned int i, num_sec;
1674
1675           num_sec = elf_numsections (abfd);
1676           for (i = shindex + 1; i < num_sec; i++)
1677             {
1678               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1679               if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1680                   && hdr2->sh_link == shindex)
1681                 break;
1682             }
1683           if (i == num_sec)
1684             for (i = 1; i < shindex; i++)
1685               {
1686                 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1687                 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1688                     && hdr2->sh_link == shindex)
1689                   break;
1690               }
1691           if (i != shindex)
1692             return bfd_section_from_shdr (abfd, i);
1693         }
1694       return TRUE;
1695
1696     case SHT_DYNSYM:            /* A dynamic symbol table */
1697       if (elf_dynsymtab (abfd) == shindex)
1698         return TRUE;
1699
1700       if (hdr->sh_entsize != bed->s->sizeof_sym)
1701         return FALSE;
1702       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1703       elf_dynsymtab (abfd) = shindex;
1704       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1705       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1706       abfd->flags |= HAS_SYMS;
1707
1708       /* Besides being a symbol table, we also treat this as a regular
1709          section, so that objcopy can handle it.  */
1710       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1711
1712     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections */
1713       if (elf_symtab_shndx (abfd) == shindex)
1714         return TRUE;
1715
1716       BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1717       elf_symtab_shndx (abfd) = shindex;
1718       elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1719       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1720       return TRUE;
1721
1722     case SHT_STRTAB:            /* A string table */
1723       if (hdr->bfd_section != NULL)
1724         return TRUE;
1725       if (ehdr->e_shstrndx == shindex)
1726         {
1727           elf_tdata (abfd)->shstrtab_hdr = *hdr;
1728           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1729           return TRUE;
1730         }
1731       if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1732         {
1733         symtab_strtab:
1734           elf_tdata (abfd)->strtab_hdr = *hdr;
1735           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1736           return TRUE;
1737         }
1738       if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1739         {
1740         dynsymtab_strtab:
1741           elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1742           hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1743           elf_elfsections (abfd)[shindex] = hdr;
1744           /* We also treat this as a regular section, so that objcopy
1745              can handle it.  */
1746           return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1747                                                   shindex);
1748         }
1749
1750       /* If the string table isn't one of the above, then treat it as a
1751          regular section.  We need to scan all the headers to be sure,
1752          just in case this strtab section appeared before the above.  */
1753       if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1754         {
1755           unsigned int i, num_sec;
1756
1757           num_sec = elf_numsections (abfd);
1758           for (i = 1; i < num_sec; i++)
1759             {
1760               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1761               if (hdr2->sh_link == shindex)
1762                 {
1763                   /* Prevent endless recursion on broken objects.  */
1764                   if (i == shindex)
1765                     return FALSE;
1766                   if (! bfd_section_from_shdr (abfd, i))
1767                     return FALSE;
1768                   if (elf_onesymtab (abfd) == i)
1769                     goto symtab_strtab;
1770                   if (elf_dynsymtab (abfd) == i)
1771                     goto dynsymtab_strtab;
1772                 }
1773             }
1774         }
1775       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1776
1777     case SHT_REL:
1778     case SHT_RELA:
1779       /* *These* do a lot of work -- but build no sections!  */
1780       {
1781         asection *target_sect;
1782         Elf_Internal_Shdr *hdr2, **p_hdr;
1783         unsigned int num_sec = elf_numsections (abfd);
1784         struct bfd_elf_section_data *esdt;
1785         bfd_size_type amt;
1786
1787         if (hdr->sh_entsize
1788             != (bfd_size_type) (hdr->sh_type == SHT_REL
1789                                 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1790           return FALSE;
1791
1792         /* Check for a bogus link to avoid crashing.  */
1793         if (hdr->sh_link >= num_sec)
1794           {
1795             ((*_bfd_error_handler)
1796              (_("%B: invalid link %lu for reloc section %s (index %u)"),
1797               abfd, hdr->sh_link, name, shindex));
1798             return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1799                                                     shindex);
1800           }
1801
1802         /* For some incomprehensible reason Oracle distributes
1803            libraries for Solaris in which some of the objects have
1804            bogus sh_link fields.  It would be nice if we could just
1805            reject them, but, unfortunately, some people need to use
1806            them.  We scan through the section headers; if we find only
1807            one suitable symbol table, we clobber the sh_link to point
1808            to it.  I hope this doesn't break anything.
1809
1810            Don't do it on executable nor shared library.  */
1811         if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
1812             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1813             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1814           {
1815             unsigned int scan;
1816             int found;
1817
1818             found = 0;
1819             for (scan = 1; scan < num_sec; scan++)
1820               {
1821                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1822                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1823                   {
1824                     if (found != 0)
1825                       {
1826                         found = 0;
1827                         break;
1828                       }
1829                     found = scan;
1830                   }
1831               }
1832             if (found != 0)
1833               hdr->sh_link = found;
1834           }
1835
1836         /* Get the symbol table.  */
1837         if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1838              || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1839             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1840           return FALSE;
1841
1842         /* If this reloc section does not use the main symbol table we
1843            don't treat it as a reloc section.  BFD can't adequately
1844            represent such a section, so at least for now, we don't
1845            try.  We just present it as a normal section.  We also
1846            can't use it as a reloc section if it points to the null
1847            section, an invalid section, another reloc section, or its
1848            sh_link points to the null section.  */
1849         if (hdr->sh_link != elf_onesymtab (abfd)
1850             || hdr->sh_link == SHN_UNDEF
1851             || hdr->sh_info == SHN_UNDEF
1852             || hdr->sh_info >= num_sec
1853             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1854             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
1855           return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1856                                                   shindex);
1857
1858         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1859           return FALSE;
1860         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1861         if (target_sect == NULL)
1862           return FALSE;
1863
1864         esdt = elf_section_data (target_sect);
1865         if (hdr->sh_type == SHT_RELA)
1866           p_hdr = &esdt->rela.hdr;
1867         else
1868           p_hdr = &esdt->rel.hdr;
1869
1870         BFD_ASSERT (*p_hdr == NULL);
1871         amt = sizeof (*hdr2);
1872         hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1873         if (hdr2 == NULL)
1874           return FALSE;
1875         *hdr2 = *hdr;
1876         *p_hdr = hdr2;
1877         elf_elfsections (abfd)[shindex] = hdr2;
1878         target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1879         target_sect->flags |= SEC_RELOC;
1880         target_sect->relocation = NULL;
1881         target_sect->rel_filepos = hdr->sh_offset;
1882         /* In the section to which the relocations apply, mark whether
1883            its relocations are of the REL or RELA variety.  */
1884         if (hdr->sh_size != 0)
1885           {
1886             if (hdr->sh_type == SHT_RELA)
1887               target_sect->use_rela_p = 1;
1888           }
1889         abfd->flags |= HAS_RELOC;
1890         return TRUE;
1891       }
1892
1893     case SHT_GNU_verdef:
1894       elf_dynverdef (abfd) = shindex;
1895       elf_tdata (abfd)->dynverdef_hdr = *hdr;
1896       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1897
1898     case SHT_GNU_versym:
1899       if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1900         return FALSE;
1901       elf_dynversym (abfd) = shindex;
1902       elf_tdata (abfd)->dynversym_hdr = *hdr;
1903       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1904
1905     case SHT_GNU_verneed:
1906       elf_dynverref (abfd) = shindex;
1907       elf_tdata (abfd)->dynverref_hdr = *hdr;
1908       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1909
1910     case SHT_SHLIB:
1911       return TRUE;
1912
1913     case SHT_GROUP:
1914       if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
1915         return FALSE;
1916       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1917         return FALSE;
1918       if (hdr->contents != NULL)
1919         {
1920           Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1921           unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
1922           asection *s;
1923
1924           if (idx->flags & GRP_COMDAT)
1925             hdr->bfd_section->flags
1926               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1927
1928           /* We try to keep the same section order as it comes in.  */
1929           idx += n_elt;
1930           while (--n_elt != 0)
1931             {
1932               --idx;
1933
1934               if (idx->shdr != NULL
1935                   && (s = idx->shdr->bfd_section) != NULL
1936                   && elf_next_in_group (s) != NULL)
1937                 {
1938                   elf_next_in_group (hdr->bfd_section) = s;
1939                   break;
1940                 }
1941             }
1942         }
1943       break;
1944
1945     default:
1946       /* Possibly an attributes section.  */
1947       if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1948           || hdr->sh_type == bed->obj_attrs_section_type)
1949         {
1950           if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1951             return FALSE;
1952           _bfd_elf_parse_attributes (abfd, hdr);
1953           return TRUE;
1954         }
1955
1956       /* Check for any processor-specific section types.  */
1957       if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1958         return TRUE;
1959
1960       if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1961         {
1962           if ((hdr->sh_flags & SHF_ALLOC) != 0)
1963             /* FIXME: How to properly handle allocated section reserved
1964                for applications?  */
1965             (*_bfd_error_handler)
1966               (_("%B: don't know how to handle allocated, application "
1967                  "specific section `%s' [0x%8x]"),
1968                abfd, name, hdr->sh_type);
1969           else
1970             /* Allow sections reserved for applications.  */
1971             return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1972                                                     shindex);
1973         }
1974       else if (hdr->sh_type >= SHT_LOPROC
1975                && hdr->sh_type <= SHT_HIPROC)
1976         /* FIXME: We should handle this section.  */
1977         (*_bfd_error_handler)
1978           (_("%B: don't know how to handle processor specific section "
1979              "`%s' [0x%8x]"),
1980            abfd, name, hdr->sh_type);
1981       else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
1982         {
1983           /* Unrecognised OS-specific sections.  */
1984           if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1985             /* SHF_OS_NONCONFORMING indicates that special knowledge is
1986                required to correctly process the section and the file should
1987                be rejected with an error message.  */
1988             (*_bfd_error_handler)
1989               (_("%B: don't know how to handle OS specific section "
1990                  "`%s' [0x%8x]"),
1991                abfd, name, hdr->sh_type);
1992           else
1993             /* Otherwise it should be processed.  */
1994             return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1995         }
1996       else
1997         /* FIXME: We should handle this section.  */
1998         (*_bfd_error_handler)
1999           (_("%B: don't know how to handle section `%s' [0x%8x]"),
2000            abfd, name, hdr->sh_type);
2001
2002       return FALSE;
2003     }
2004
2005   return TRUE;
2006 }
2007
2008 /* Return the local symbol specified by ABFD, R_SYMNDX.  */
2009
2010 Elf_Internal_Sym *
2011 bfd_sym_from_r_symndx (struct sym_cache *cache,
2012                        bfd *abfd,
2013                        unsigned long r_symndx)
2014 {
2015   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2016
2017   if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2018     {
2019       Elf_Internal_Shdr *symtab_hdr;
2020       unsigned char esym[sizeof (Elf64_External_Sym)];
2021       Elf_External_Sym_Shndx eshndx;
2022
2023       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2024       if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2025                                 &cache->sym[ent], esym, &eshndx) == NULL)
2026         return NULL;
2027
2028       if (cache->abfd != abfd)
2029         {
2030           memset (cache->indx, -1, sizeof (cache->indx));
2031           cache->abfd = abfd;
2032         }
2033       cache->indx[ent] = r_symndx;
2034     }
2035
2036   return &cache->sym[ent];
2037 }
2038
2039 /* Given an ELF section number, retrieve the corresponding BFD
2040    section.  */
2041
2042 asection *
2043 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2044 {
2045   if (sec_index >= elf_numsections (abfd))
2046     return NULL;
2047   return elf_elfsections (abfd)[sec_index]->bfd_section;
2048 }
2049
2050 static const struct bfd_elf_special_section special_sections_b[] =
2051 {
2052   { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2053   { NULL,                   0,  0, 0,            0 }
2054 };
2055
2056 static const struct bfd_elf_special_section special_sections_c[] =
2057 {
2058   { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2059   { NULL,                       0, 0, 0,            0 }
2060 };
2061
2062 static const struct bfd_elf_special_section special_sections_d[] =
2063 {
2064   { STRING_COMMA_LEN (".data"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2065   { STRING_COMMA_LEN (".data1"),         0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2066   { STRING_COMMA_LEN (".debug"),         0, SHT_PROGBITS, 0 },
2067   { STRING_COMMA_LEN (".debug_line"),    0, SHT_PROGBITS, 0 },
2068   { STRING_COMMA_LEN (".debug_info"),    0, SHT_PROGBITS, 0 },
2069   { STRING_COMMA_LEN (".debug_abbrev"),  0, SHT_PROGBITS, 0 },
2070   { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2071   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  SHF_ALLOC },
2072   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   SHF_ALLOC },
2073   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   SHF_ALLOC },
2074   { NULL,                      0,        0, 0,            0 }
2075 };
2076
2077 static const struct bfd_elf_special_section special_sections_f[] =
2078 {
2079   { STRING_COMMA_LEN (".fini"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2080   { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2081   { NULL,                          0, 0, 0,              0 }
2082 };
2083
2084 static const struct bfd_elf_special_section special_sections_g[] =
2085 {
2086   { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS,      SHF_ALLOC + SHF_WRITE },
2087   { STRING_COMMA_LEN (".gnu.lto_"),       -1, SHT_PROGBITS,    SHF_EXCLUDE },
2088   { STRING_COMMA_LEN (".got"),             0, SHT_PROGBITS,    SHF_ALLOC + SHF_WRITE },
2089   { STRING_COMMA_LEN (".gnu.version"),     0, SHT_GNU_versym,  0 },
2090   { STRING_COMMA_LEN (".gnu.version_d"),   0, SHT_GNU_verdef,  0 },
2091   { STRING_COMMA_LEN (".gnu.version_r"),   0, SHT_GNU_verneed, 0 },
2092   { STRING_COMMA_LEN (".gnu.liblist"),     0, SHT_GNU_LIBLIST, SHF_ALLOC },
2093   { STRING_COMMA_LEN (".gnu.conflict"),    0, SHT_RELA,        SHF_ALLOC },
2094   { STRING_COMMA_LEN (".gnu.hash"),        0, SHT_GNU_HASH,    SHF_ALLOC },
2095   { NULL,                        0,        0, 0,               0 }
2096 };
2097
2098 static const struct bfd_elf_special_section special_sections_h[] =
2099 {
2100   { STRING_COMMA_LEN (".hash"), 0, SHT_HASH,     SHF_ALLOC },
2101   { NULL,                    0, 0, 0,            0 }
2102 };
2103
2104 static const struct bfd_elf_special_section special_sections_i[] =
2105 {
2106   { STRING_COMMA_LEN (".init"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2107   { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2108   { STRING_COMMA_LEN (".interp"),     0, SHT_PROGBITS,   0 },
2109   { NULL,                      0,     0, 0,              0 }
2110 };
2111
2112 static const struct bfd_elf_special_section special_sections_l[] =
2113 {
2114   { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2115   { NULL,                    0, 0, 0,            0 }
2116 };
2117
2118 static const struct bfd_elf_special_section special_sections_n[] =
2119 {
2120   { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2121   { STRING_COMMA_LEN (".note"),          -1, SHT_NOTE,     0 },
2122   { NULL,                    0,           0, 0,            0 }
2123 };
2124
2125 static const struct bfd_elf_special_section special_sections_p[] =
2126 {
2127   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2128   { STRING_COMMA_LEN (".plt"),           0, SHT_PROGBITS,      SHF_ALLOC + SHF_EXECINSTR },
2129   { NULL,                   0,           0, 0,                 0 }
2130 };
2131
2132 static const struct bfd_elf_special_section special_sections_r[] =
2133 {
2134   { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2135   { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2136   { STRING_COMMA_LEN (".rela"),   -1, SHT_RELA,     0 },
2137   { STRING_COMMA_LEN (".rel"),    -1, SHT_REL,      0 },
2138   { NULL,                   0,     0, 0,            0 }
2139 };
2140
2141 static const struct bfd_elf_special_section special_sections_s[] =
2142 {
2143   { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2144   { STRING_COMMA_LEN (".strtab"),   0, SHT_STRTAB, 0 },
2145   { STRING_COMMA_LEN (".symtab"),   0, SHT_SYMTAB, 0 },
2146   /* See struct bfd_elf_special_section declaration for the semantics of
2147      this special case where .prefix_length != strlen (.prefix).  */
2148   { ".stabstr",                 5,  3, SHT_STRTAB, 0 },
2149   { NULL,                       0,  0, 0,          0 }
2150 };
2151
2152 static const struct bfd_elf_special_section special_sections_t[] =
2153 {
2154   { STRING_COMMA_LEN (".text"),  -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2155   { STRING_COMMA_LEN (".tbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2156   { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2157   { NULL,                     0,  0, 0,            0 }
2158 };
2159
2160 static const struct bfd_elf_special_section special_sections_z[] =
2161 {
2162   { STRING_COMMA_LEN (".zdebug_line"),    0, SHT_PROGBITS, 0 },
2163   { STRING_COMMA_LEN (".zdebug_info"),    0, SHT_PROGBITS, 0 },
2164   { STRING_COMMA_LEN (".zdebug_abbrev"),  0, SHT_PROGBITS, 0 },
2165   { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2166   { NULL,                     0,  0, 0,            0 }
2167 };
2168
2169 static const struct bfd_elf_special_section * const special_sections[] =
2170 {
2171   special_sections_b,           /* 'b' */
2172   special_sections_c,           /* 'c' */
2173   special_sections_d,           /* 'd' */
2174   NULL,                         /* 'e' */
2175   special_sections_f,           /* 'f' */
2176   special_sections_g,           /* 'g' */
2177   special_sections_h,           /* 'h' */
2178   special_sections_i,           /* 'i' */
2179   NULL,                         /* 'j' */
2180   NULL,                         /* 'k' */
2181   special_sections_l,           /* 'l' */
2182   NULL,                         /* 'm' */
2183   special_sections_n,           /* 'n' */
2184   NULL,                         /* 'o' */
2185   special_sections_p,           /* 'p' */
2186   NULL,                         /* 'q' */
2187   special_sections_r,           /* 'r' */
2188   special_sections_s,           /* 's' */
2189   special_sections_t,           /* 't' */
2190   NULL,                         /* 'u' */
2191   NULL,                         /* 'v' */
2192   NULL,                         /* 'w' */
2193   NULL,                         /* 'x' */
2194   NULL,                         /* 'y' */
2195   special_sections_z            /* 'z' */
2196 };
2197
2198 const struct bfd_elf_special_section *
2199 _bfd_elf_get_special_section (const char *name,
2200                               const struct bfd_elf_special_section *spec,
2201                               unsigned int rela)
2202 {
2203   int i;
2204   int len;
2205
2206   len = strlen (name);
2207
2208   for (i = 0; spec[i].prefix != NULL; i++)
2209     {
2210       int suffix_len;
2211       int prefix_len = spec[i].prefix_length;
2212
2213       if (len < prefix_len)
2214         continue;
2215       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2216         continue;
2217
2218       suffix_len = spec[i].suffix_length;
2219       if (suffix_len <= 0)
2220         {
2221           if (name[prefix_len] != 0)
2222             {
2223               if (suffix_len == 0)
2224                 continue;
2225               if (name[prefix_len] != '.'
2226                   && (suffix_len == -2
2227                       || (rela && spec[i].type == SHT_REL)))
2228                 continue;
2229             }
2230         }
2231       else
2232         {
2233           if (len < prefix_len + suffix_len)
2234             continue;
2235           if (memcmp (name + len - suffix_len,
2236                       spec[i].prefix + prefix_len,
2237                       suffix_len) != 0)
2238             continue;
2239         }
2240       return &spec[i];
2241     }
2242
2243   return NULL;
2244 }
2245
2246 const struct bfd_elf_special_section *
2247 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2248 {
2249   int i;
2250   const struct bfd_elf_special_section *spec;
2251   const struct elf_backend_data *bed;
2252
2253   /* See if this is one of the special sections.  */
2254   if (sec->name == NULL)
2255     return NULL;
2256
2257   bed = get_elf_backend_data (abfd);
2258   spec = bed->special_sections;
2259   if (spec)
2260     {
2261       spec = _bfd_elf_get_special_section (sec->name,
2262                                            bed->special_sections,
2263                                            sec->use_rela_p);
2264       if (spec != NULL)
2265         return spec;
2266     }
2267
2268   if (sec->name[0] != '.')
2269     return NULL;
2270
2271   i = sec->name[1] - 'b';
2272   if (i < 0 || i > 'z' - 'b')
2273     return NULL;
2274
2275   spec = special_sections[i];
2276
2277   if (spec == NULL)
2278     return NULL;
2279
2280   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2281 }
2282
2283 bfd_boolean
2284 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2285 {
2286   struct bfd_elf_section_data *sdata;
2287   const struct elf_backend_data *bed;
2288   const struct bfd_elf_special_section *ssect;
2289
2290   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2291   if (sdata == NULL)
2292     {
2293       sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2294                                                           sizeof (*sdata));
2295       if (sdata == NULL)
2296         return FALSE;
2297       sec->used_by_bfd = sdata;
2298     }
2299
2300   /* Indicate whether or not this section should use RELA relocations.  */
2301   bed = get_elf_backend_data (abfd);
2302   sec->use_rela_p = bed->default_use_rela_p;
2303
2304   /* When we read a file, we don't need to set ELF section type and
2305      flags.  They will be overridden in _bfd_elf_make_section_from_shdr
2306      anyway.  We will set ELF section type and flags for all linker
2307      created sections.  If user specifies BFD section flags, we will
2308      set ELF section type and flags based on BFD section flags in
2309      elf_fake_sections.  Special handling for .init_array/.fini_array
2310      output sections since they may contain .ctors/.dtors input
2311      sections.  We don't want _bfd_elf_init_private_section_data to
2312      copy ELF section type from .ctors/.dtors input sections.  */
2313   if (abfd->direction != read_direction
2314       || (sec->flags & SEC_LINKER_CREATED) != 0)
2315     {
2316       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2317       if (ssect != NULL
2318           && (!sec->flags
2319               || (sec->flags & SEC_LINKER_CREATED) != 0
2320               || ssect->type == SHT_INIT_ARRAY
2321               || ssect->type == SHT_FINI_ARRAY))
2322         {
2323           elf_section_type (sec) = ssect->type;
2324           elf_section_flags (sec) = ssect->attr;
2325         }
2326     }
2327
2328   return _bfd_generic_new_section_hook (abfd, sec);
2329 }
2330
2331 /* Create a new bfd section from an ELF program header.
2332
2333    Since program segments have no names, we generate a synthetic name
2334    of the form segment<NUM>, where NUM is generally the index in the
2335    program header table.  For segments that are split (see below) we
2336    generate the names segment<NUM>a and segment<NUM>b.
2337
2338    Note that some program segments may have a file size that is different than
2339    (less than) the memory size.  All this means is that at execution the
2340    system must allocate the amount of memory specified by the memory size,
2341    but only initialize it with the first "file size" bytes read from the
2342    file.  This would occur for example, with program segments consisting
2343    of combined data+bss.
2344
2345    To handle the above situation, this routine generates TWO bfd sections
2346    for the single program segment.  The first has the length specified by
2347    the file size of the segment, and the second has the length specified
2348    by the difference between the two sizes.  In effect, the segment is split
2349    into its initialized and uninitialized parts.
2350
2351  */
2352
2353 bfd_boolean
2354 _bfd_elf_make_section_from_phdr (bfd *abfd,
2355                                  Elf_Internal_Phdr *hdr,
2356                                  int hdr_index,
2357                                  const char *type_name)
2358 {
2359   asection *newsect;
2360   char *name;
2361   char namebuf[64];
2362   size_t len;
2363   int split;
2364
2365   split = ((hdr->p_memsz > 0)
2366             && (hdr->p_filesz > 0)
2367             && (hdr->p_memsz > hdr->p_filesz));
2368
2369   if (hdr->p_filesz > 0)
2370     {
2371       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2372       len = strlen (namebuf) + 1;
2373       name = (char *) bfd_alloc (abfd, len);
2374       if (!name)
2375         return FALSE;
2376       memcpy (name, namebuf, len);
2377       newsect = bfd_make_section (abfd, name);
2378       if (newsect == NULL)
2379         return FALSE;
2380       newsect->vma = hdr->p_vaddr;
2381       newsect->lma = hdr->p_paddr;
2382       newsect->size = hdr->p_filesz;
2383       newsect->filepos = hdr->p_offset;
2384       newsect->flags |= SEC_HAS_CONTENTS;
2385       newsect->alignment_power = bfd_log2 (hdr->p_align);
2386       if (hdr->p_type == PT_LOAD)
2387         {
2388           newsect->flags |= SEC_ALLOC;
2389           newsect->flags |= SEC_LOAD;
2390           if (hdr->p_flags & PF_X)
2391             {
2392               /* FIXME: all we known is that it has execute PERMISSION,
2393                  may be data.  */
2394               newsect->flags |= SEC_CODE;
2395             }
2396         }
2397       if (!(hdr->p_flags & PF_W))
2398         {
2399           newsect->flags |= SEC_READONLY;
2400         }
2401     }
2402
2403   if (hdr->p_memsz > hdr->p_filesz)
2404     {
2405       bfd_vma align;
2406
2407       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2408       len = strlen (namebuf) + 1;
2409       name = (char *) bfd_alloc (abfd, len);
2410       if (!name)
2411         return FALSE;
2412       memcpy (name, namebuf, len);
2413       newsect = bfd_make_section (abfd, name);
2414       if (newsect == NULL)
2415         return FALSE;
2416       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2417       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2418       newsect->size = hdr->p_memsz - hdr->p_filesz;
2419       newsect->filepos = hdr->p_offset + hdr->p_filesz;
2420       align = newsect->vma & -newsect->vma;
2421       if (align == 0 || align > hdr->p_align)
2422         align = hdr->p_align;
2423       newsect->alignment_power = bfd_log2 (align);
2424       if (hdr->p_type == PT_LOAD)
2425         {
2426           /* Hack for gdb.  Segments that have not been modified do
2427              not have their contents written to a core file, on the
2428              assumption that a debugger can find the contents in the
2429              executable.  We flag this case by setting the fake
2430              section size to zero.  Note that "real" bss sections will
2431              always have their contents dumped to the core file.  */
2432           if (bfd_get_format (abfd) == bfd_core)
2433             newsect->size = 0;
2434           newsect->flags |= SEC_ALLOC;
2435           if (hdr->p_flags & PF_X)
2436             newsect->flags |= SEC_CODE;
2437         }
2438       if (!(hdr->p_flags & PF_W))
2439         newsect->flags |= SEC_READONLY;
2440     }
2441
2442   return TRUE;
2443 }
2444
2445 bfd_boolean
2446 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2447 {
2448   const struct elf_backend_data *bed;
2449
2450   switch (hdr->p_type)
2451     {
2452     case PT_NULL:
2453       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2454
2455     case PT_LOAD:
2456       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2457
2458     case PT_DYNAMIC:
2459       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2460
2461     case PT_INTERP:
2462       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2463
2464     case PT_NOTE:
2465       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2466         return FALSE;
2467       if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2468         return FALSE;
2469       return TRUE;
2470
2471     case PT_SHLIB:
2472       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2473
2474     case PT_PHDR:
2475       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2476
2477     case PT_GNU_EH_FRAME:
2478       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2479                                               "eh_frame_hdr");
2480
2481     case PT_GNU_STACK:
2482       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2483
2484     case PT_GNU_RELRO:
2485       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2486
2487     default:
2488       /* Check for any processor-specific program segment types.  */
2489       bed = get_elf_backend_data (abfd);
2490       return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2491     }
2492 }
2493
2494 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2495    REL or RELA.  */
2496
2497 Elf_Internal_Shdr *
2498 _bfd_elf_single_rel_hdr (asection *sec)
2499 {
2500   if (elf_section_data (sec)->rel.hdr)
2501     {
2502       BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2503       return elf_section_data (sec)->rel.hdr;
2504     }
2505   else
2506     return elf_section_data (sec)->rela.hdr;
2507 }
2508
2509 /* Allocate and initialize a section-header for a new reloc section,
2510    containing relocations against ASECT.  It is stored in RELDATA.  If
2511    USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2512    relocations.  */
2513
2514 bfd_boolean
2515 _bfd_elf_init_reloc_shdr (bfd *abfd,
2516                           struct bfd_elf_section_reloc_data *reldata,
2517                           asection *asect,
2518                           bfd_boolean use_rela_p)
2519 {
2520   Elf_Internal_Shdr *rel_hdr;
2521   char *name;
2522   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2523   bfd_size_type amt;
2524
2525   amt = sizeof (Elf_Internal_Shdr);
2526   BFD_ASSERT (reldata->hdr == NULL);
2527   rel_hdr = bfd_zalloc (abfd, amt);
2528   reldata->hdr = rel_hdr;
2529
2530   amt = sizeof ".rela" + strlen (asect->name);      
2531   name = (char *) bfd_alloc (abfd, amt);
2532   if (name == NULL)
2533     return FALSE;
2534   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2535   rel_hdr->sh_name =
2536     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2537                                         FALSE);
2538   if (rel_hdr->sh_name == (unsigned int) -1)
2539     return FALSE;
2540   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2541   rel_hdr->sh_entsize = (use_rela_p
2542                          ? bed->s->sizeof_rela
2543                          : bed->s->sizeof_rel);
2544   rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2545   rel_hdr->sh_flags = 0;
2546   rel_hdr->sh_addr = 0;
2547   rel_hdr->sh_size = 0;
2548   rel_hdr->sh_offset = 0;
2549
2550   return TRUE;
2551 }
2552
2553 /* Return the default section type based on the passed in section flags.  */
2554
2555 int
2556 bfd_elf_get_default_section_type (flagword flags)
2557 {
2558   if ((flags & SEC_ALLOC) != 0
2559       && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2560     return SHT_NOBITS;
2561   return SHT_PROGBITS;
2562 }
2563
2564 struct fake_section_arg
2565 {
2566   struct bfd_link_info *link_info;
2567   bfd_boolean failed;
2568 };
2569
2570 /* Set up an ELF internal section header for a section.  */
2571
2572 static void
2573 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
2574 {
2575   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
2576   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2577   struct bfd_elf_section_data *esd = elf_section_data (asect);
2578   Elf_Internal_Shdr *this_hdr;
2579   unsigned int sh_type;
2580
2581   if (arg->failed)
2582     {
2583       /* We already failed; just get out of the bfd_map_over_sections
2584          loop.  */
2585       return;
2586     }
2587
2588   this_hdr = &esd->this_hdr;
2589
2590   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2591                                                           asect->name, FALSE);
2592   if (this_hdr->sh_name == (unsigned int) -1)
2593     {
2594       arg->failed = TRUE;
2595       return;
2596     }
2597
2598   /* Don't clear sh_flags. Assembler may set additional bits.  */
2599
2600   if ((asect->flags & SEC_ALLOC) != 0
2601       || asect->user_set_vma)
2602     this_hdr->sh_addr = asect->vma;
2603   else
2604     this_hdr->sh_addr = 0;
2605
2606   this_hdr->sh_offset = 0;
2607   this_hdr->sh_size = asect->size;
2608   this_hdr->sh_link = 0;
2609   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2610   /* The sh_entsize and sh_info fields may have been set already by
2611      copy_private_section_data.  */
2612
2613   this_hdr->bfd_section = asect;
2614   this_hdr->contents = NULL;
2615
2616   /* If the section type is unspecified, we set it based on
2617      asect->flags.  */
2618   if ((asect->flags & SEC_GROUP) != 0)
2619     sh_type = SHT_GROUP;
2620   else
2621     sh_type = bfd_elf_get_default_section_type (asect->flags);
2622
2623   if (this_hdr->sh_type == SHT_NULL)
2624     this_hdr->sh_type = sh_type;
2625   else if (this_hdr->sh_type == SHT_NOBITS
2626            && sh_type == SHT_PROGBITS
2627            && (asect->flags & SEC_ALLOC) != 0)
2628     {
2629       /* Warn if we are changing a NOBITS section to PROGBITS, but
2630          allow the link to proceed.  This can happen when users link
2631          non-bss input sections to bss output sections, or emit data
2632          to a bss output section via a linker script.  */
2633       (*_bfd_error_handler)
2634         (_("warning: section `%A' type changed to PROGBITS"), asect);
2635       this_hdr->sh_type = sh_type;
2636     }
2637
2638   switch (this_hdr->sh_type)
2639     {
2640     default:
2641       break;
2642
2643     case SHT_STRTAB:
2644     case SHT_INIT_ARRAY:
2645     case SHT_FINI_ARRAY:
2646     case SHT_PREINIT_ARRAY:
2647     case SHT_NOTE:
2648     case SHT_NOBITS:
2649     case SHT_PROGBITS:
2650       break;
2651
2652     case SHT_HASH:
2653       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2654       break;
2655
2656     case SHT_DYNSYM:
2657       this_hdr->sh_entsize = bed->s->sizeof_sym;
2658       break;
2659
2660     case SHT_DYNAMIC:
2661       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2662       break;
2663
2664     case SHT_RELA:
2665       if (get_elf_backend_data (abfd)->may_use_rela_p)
2666         this_hdr->sh_entsize = bed->s->sizeof_rela;
2667       break;
2668
2669      case SHT_REL:
2670       if (get_elf_backend_data (abfd)->may_use_rel_p)
2671         this_hdr->sh_entsize = bed->s->sizeof_rel;
2672       break;
2673
2674      case SHT_GNU_versym:
2675       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2676       break;
2677
2678      case SHT_GNU_verdef:
2679       this_hdr->sh_entsize = 0;
2680       /* objcopy or strip will copy over sh_info, but may not set
2681          cverdefs.  The linker will set cverdefs, but sh_info will be
2682          zero.  */
2683       if (this_hdr->sh_info == 0)
2684         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2685       else
2686         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2687                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2688       break;
2689
2690     case SHT_GNU_verneed:
2691       this_hdr->sh_entsize = 0;
2692       /* objcopy or strip will copy over sh_info, but may not set
2693          cverrefs.  The linker will set cverrefs, but sh_info will be
2694          zero.  */
2695       if (this_hdr->sh_info == 0)
2696         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2697       else
2698         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2699                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2700       break;
2701
2702     case SHT_GROUP:
2703       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2704       break;
2705
2706     case SHT_GNU_HASH:
2707       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2708       break;
2709     }
2710
2711   if ((asect->flags & SEC_ALLOC) != 0)
2712     this_hdr->sh_flags |= SHF_ALLOC;
2713   if ((asect->flags & SEC_READONLY) == 0)
2714     this_hdr->sh_flags |= SHF_WRITE;
2715   if ((asect->flags & SEC_CODE) != 0)
2716     this_hdr->sh_flags |= SHF_EXECINSTR;
2717   if ((asect->flags & SEC_MERGE) != 0)
2718     {
2719       this_hdr->sh_flags |= SHF_MERGE;
2720       this_hdr->sh_entsize = asect->entsize;
2721       if ((asect->flags & SEC_STRINGS) != 0)
2722         this_hdr->sh_flags |= SHF_STRINGS;
2723     }
2724   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2725     this_hdr->sh_flags |= SHF_GROUP;
2726   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2727     {
2728       this_hdr->sh_flags |= SHF_TLS;
2729       if (asect->size == 0
2730           && (asect->flags & SEC_HAS_CONTENTS) == 0)
2731         {
2732           struct bfd_link_order *o = asect->map_tail.link_order;
2733
2734           this_hdr->sh_size = 0;
2735           if (o != NULL)
2736             {
2737               this_hdr->sh_size = o->offset + o->size;
2738               if (this_hdr->sh_size != 0)
2739                 this_hdr->sh_type = SHT_NOBITS;
2740             }
2741         }
2742     }
2743   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2744     this_hdr->sh_flags |= SHF_EXCLUDE;
2745
2746   /* If the section has relocs, set up a section header for the
2747      SHT_REL[A] section.  If two relocation sections are required for
2748      this section, it is up to the processor-specific back-end to
2749      create the other.  */
2750   if ((asect->flags & SEC_RELOC) != 0)
2751     {
2752       /* When doing a relocatable link, create both REL and RELA sections if
2753          needed.  */
2754       if (arg->link_info
2755           /* Do the normal setup if we wouldn't create any sections here.  */
2756           && esd->rel.count + esd->rela.count > 0
2757           && (arg->link_info->relocatable || arg->link_info->emitrelocations))
2758         {
2759           if (esd->rel.count && esd->rel.hdr == NULL
2760               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
2761             {
2762               arg->failed = TRUE;
2763               return;
2764             }
2765           if (esd->rela.count && esd->rela.hdr == NULL
2766               && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
2767             {
2768               arg->failed = TRUE;
2769               return;
2770             }
2771         }
2772       else if (!_bfd_elf_init_reloc_shdr (abfd,
2773                                           (asect->use_rela_p
2774                                            ? &esd->rela : &esd->rel),
2775                                           asect,
2776                                           asect->use_rela_p))
2777           arg->failed = TRUE;
2778     }
2779
2780   /* Check for processor-specific section types.  */
2781   sh_type = this_hdr->sh_type;
2782   if (bed->elf_backend_fake_sections
2783       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2784     arg->failed = TRUE;
2785
2786   if (sh_type == SHT_NOBITS && asect->size != 0)
2787     {
2788       /* Don't change the header type from NOBITS if we are being
2789          called for objcopy --only-keep-debug.  */
2790       this_hdr->sh_type = sh_type;
2791     }
2792 }
2793
2794 /* Fill in the contents of a SHT_GROUP section.  Called from
2795    _bfd_elf_compute_section_file_positions for gas, objcopy, and
2796    when ELF targets use the generic linker, ld.  Called for ld -r
2797    from bfd_elf_final_link.  */
2798
2799 void
2800 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2801 {
2802   bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2803   asection *elt, *first;
2804   unsigned char *loc;
2805   bfd_boolean gas;
2806
2807   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2808      elfxx-ia64.c.  */
2809   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2810       || *failedptr)
2811     return;
2812
2813   if (elf_section_data (sec)->this_hdr.sh_info == 0)
2814     {
2815       unsigned long symindx = 0;
2816
2817       /* elf_group_id will have been set up by objcopy and the
2818          generic linker.  */
2819       if (elf_group_id (sec) != NULL)
2820         symindx = elf_group_id (sec)->udata.i;
2821
2822       if (symindx == 0)
2823         {
2824           /* If called from the assembler, swap_out_syms will have set up
2825              elf_section_syms.  */
2826           BFD_ASSERT (elf_section_syms (abfd) != NULL);
2827           symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2828         }
2829       elf_section_data (sec)->this_hdr.sh_info = symindx;
2830     }
2831   else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2832     {
2833       /* The ELF backend linker sets sh_info to -2 when the group
2834          signature symbol is global, and thus the index can't be
2835          set until all local symbols are output.  */
2836       asection *igroup = elf_sec_group (elf_next_in_group (sec));
2837       struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2838       unsigned long symndx = sec_data->this_hdr.sh_info;
2839       unsigned long extsymoff = 0;
2840       struct elf_link_hash_entry *h;
2841
2842       if (!elf_bad_symtab (igroup->owner))
2843         {
2844           Elf_Internal_Shdr *symtab_hdr;
2845
2846           symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2847           extsymoff = symtab_hdr->sh_info;
2848         }
2849       h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2850       while (h->root.type == bfd_link_hash_indirect
2851              || h->root.type == bfd_link_hash_warning)
2852         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2853
2854       elf_section_data (sec)->this_hdr.sh_info = h->indx;
2855     }
2856
2857   /* The contents won't be allocated for "ld -r" or objcopy.  */
2858   gas = TRUE;
2859   if (sec->contents == NULL)
2860     {
2861       gas = FALSE;
2862       sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
2863
2864       /* Arrange for the section to be written out.  */
2865       elf_section_data (sec)->this_hdr.contents = sec->contents;
2866       if (sec->contents == NULL)
2867         {
2868           *failedptr = TRUE;
2869           return;
2870         }
2871     }
2872
2873   loc = sec->contents + sec->size;
2874
2875   /* Get the pointer to the first section in the group that gas
2876      squirreled away here.  objcopy arranges for this to be set to the
2877      start of the input section group.  */
2878   first = elt = elf_next_in_group (sec);
2879
2880   /* First element is a flag word.  Rest of section is elf section
2881      indices for all the sections of the group.  Write them backwards
2882      just to keep the group in the same order as given in .section
2883      directives, not that it matters.  */
2884   while (elt != NULL)
2885     {
2886       asection *s;
2887
2888       s = elt;
2889       if (!gas)
2890         s = s->output_section;
2891       if (s != NULL
2892           && !bfd_is_abs_section (s))
2893         {
2894           unsigned int idx = elf_section_data (s)->this_idx;
2895
2896           loc -= 4;
2897           H_PUT_32 (abfd, idx, loc);
2898         }
2899       elt = elf_next_in_group (elt);
2900       if (elt == first)
2901         break;
2902     }
2903
2904   if ((loc -= 4) != sec->contents)
2905     abort ();
2906
2907   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2908 }
2909
2910 /* Assign all ELF section numbers.  The dummy first section is handled here
2911    too.  The link/info pointers for the standard section types are filled
2912    in here too, while we're at it.  */
2913
2914 static bfd_boolean
2915 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2916 {
2917   struct elf_obj_tdata *t = elf_tdata (abfd);
2918   asection *sec;
2919   unsigned int section_number, secn;
2920   Elf_Internal_Shdr **i_shdrp;
2921   struct bfd_elf_section_data *d;
2922   bfd_boolean need_symtab;
2923
2924   section_number = 1;
2925
2926   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2927
2928   /* SHT_GROUP sections are in relocatable files only.  */
2929   if (link_info == NULL || link_info->relocatable)
2930     {
2931       /* Put SHT_GROUP sections first.  */
2932       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2933         {
2934           d = elf_section_data (sec);
2935
2936           if (d->this_hdr.sh_type == SHT_GROUP)
2937             {
2938               if (sec->flags & SEC_LINKER_CREATED)
2939                 {
2940                   /* Remove the linker created SHT_GROUP sections.  */
2941                   bfd_section_list_remove (abfd, sec);
2942                   abfd->section_count--;
2943                 }
2944               else
2945                 d->this_idx = section_number++;
2946             }
2947         }
2948     }
2949
2950   for (sec = abfd->sections; sec; sec = sec->next)
2951     {
2952       d = elf_section_data (sec);
2953
2954       if (d->this_hdr.sh_type != SHT_GROUP)
2955         d->this_idx = section_number++;
2956       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2957       if (d->rel.hdr)
2958         {
2959           d->rel.idx = section_number++;
2960           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2961         }
2962       else
2963         d->rel.idx = 0;
2964
2965       if (d->rela.hdr)
2966         {
2967           d->rela.idx = section_number++;
2968           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2969         }
2970       else
2971         d->rela.idx = 0;
2972     }
2973
2974   t->shstrtab_section = section_number++;
2975   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2976   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2977
2978   need_symtab = (bfd_get_symcount (abfd) > 0
2979                 || (link_info == NULL
2980                     && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2981                         == HAS_RELOC)));
2982   if (need_symtab)
2983     {
2984       t->symtab_section = section_number++;
2985       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2986       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2987         {
2988           t->symtab_shndx_section = section_number++;
2989           t->symtab_shndx_hdr.sh_name
2990             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2991                                                   ".symtab_shndx", FALSE);
2992           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2993             return FALSE;
2994         }
2995       t->strtab_section = section_number++;
2996       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2997     }
2998
2999   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3000   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3001
3002   elf_numsections (abfd) = section_number;
3003   elf_elfheader (abfd)->e_shnum = section_number;
3004
3005   /* Set up the list of section header pointers, in agreement with the
3006      indices.  */
3007   i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3008                                                 sizeof (Elf_Internal_Shdr *));
3009   if (i_shdrp == NULL)
3010     return FALSE;
3011
3012   i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3013                                                  sizeof (Elf_Internal_Shdr));
3014   if (i_shdrp[0] == NULL)
3015     {
3016       bfd_release (abfd, i_shdrp);
3017       return FALSE;
3018     }
3019
3020   elf_elfsections (abfd) = i_shdrp;
3021
3022   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3023   if (need_symtab)
3024     {
3025       i_shdrp[t->symtab_section] = &t->symtab_hdr;
3026       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3027         {
3028           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3029           t->symtab_shndx_hdr.sh_link = t->symtab_section;
3030         }
3031       i_shdrp[t->strtab_section] = &t->strtab_hdr;
3032       t->symtab_hdr.sh_link = t->strtab_section;
3033     }
3034
3035   for (sec = abfd->sections; sec; sec = sec->next)
3036     {
3037       asection *s;
3038       const char *name;
3039
3040       d = elf_section_data (sec);
3041
3042       i_shdrp[d->this_idx] = &d->this_hdr;
3043       if (d->rel.idx != 0)
3044         i_shdrp[d->rel.idx] = d->rel.hdr;
3045       if (d->rela.idx != 0)
3046         i_shdrp[d->rela.idx] = d->rela.hdr;
3047
3048       /* Fill in the sh_link and sh_info fields while we're at it.  */
3049
3050       /* sh_link of a reloc section is the section index of the symbol
3051          table.  sh_info is the section index of the section to which
3052          the relocation entries apply.  */
3053       if (d->rel.idx != 0)
3054         {
3055           d->rel.hdr->sh_link = t->symtab_section;
3056           d->rel.hdr->sh_info = d->this_idx;
3057         }
3058       if (d->rela.idx != 0)
3059         {
3060           d->rela.hdr->sh_link = t->symtab_section;
3061           d->rela.hdr->sh_info = d->this_idx;
3062         }
3063
3064       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3065       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3066         {
3067           s = elf_linked_to_section (sec);
3068           if (s)
3069             {
3070               /* elf_linked_to_section points to the input section.  */
3071               if (link_info != NULL)
3072                 {
3073                   /* Check discarded linkonce section.  */
3074                   if (elf_discarded_section (s))
3075                     {
3076                       asection *kept;
3077                       (*_bfd_error_handler)
3078                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3079                          abfd, d->this_hdr.bfd_section,
3080                          s, s->owner);
3081                       /* Point to the kept section if it has the same
3082                          size as the discarded one.  */
3083                       kept = _bfd_elf_check_kept_section (s, link_info);
3084                       if (kept == NULL)
3085                         {
3086                           bfd_set_error (bfd_error_bad_value);
3087                           return FALSE;
3088                         }
3089                       s = kept;
3090                     }
3091
3092                   s = s->output_section;
3093                   BFD_ASSERT (s != NULL);
3094                 }
3095               else
3096                 {
3097                   /* Handle objcopy. */
3098                   if (s->output_section == NULL)
3099                     {
3100                       (*_bfd_error_handler)
3101                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3102                          abfd, d->this_hdr.bfd_section, s, s->owner);
3103                       bfd_set_error (bfd_error_bad_value);
3104                       return FALSE;
3105                     }
3106                   s = s->output_section;
3107                 }
3108               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3109             }
3110           else
3111             {
3112               /* PR 290:
3113                  The Intel C compiler generates SHT_IA_64_UNWIND with
3114                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
3115                  sh_info fields.  Hence we could get the situation
3116                  where s is NULL.  */
3117               const struct elf_backend_data *bed
3118                 = get_elf_backend_data (abfd);
3119               if (bed->link_order_error_handler)
3120                 bed->link_order_error_handler
3121                   (_("%B: warning: sh_link not set for section `%A'"),
3122                    abfd, sec);
3123             }
3124         }
3125
3126       switch (d->this_hdr.sh_type)
3127         {
3128         case SHT_REL:
3129         case SHT_RELA:
3130           /* A reloc section which we are treating as a normal BFD
3131              section.  sh_link is the section index of the symbol
3132              table.  sh_info is the section index of the section to
3133              which the relocation entries apply.  We assume that an
3134              allocated reloc section uses the dynamic symbol table.
3135              FIXME: How can we be sure?  */
3136           s = bfd_get_section_by_name (abfd, ".dynsym");
3137           if (s != NULL)
3138             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3139
3140           /* We look up the section the relocs apply to by name.  */
3141           name = sec->name;
3142           if (d->this_hdr.sh_type == SHT_REL)
3143             name += 4;
3144           else
3145             name += 5;
3146           s = bfd_get_section_by_name (abfd, name);
3147           if (s != NULL)
3148             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3149           break;
3150
3151         case SHT_STRTAB:
3152           /* We assume that a section named .stab*str is a stabs
3153              string section.  We look for a section with the same name
3154              but without the trailing ``str'', and set its sh_link
3155              field to point to this section.  */
3156           if (CONST_STRNEQ (sec->name, ".stab")
3157               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3158             {
3159               size_t len;
3160               char *alc;
3161
3162               len = strlen (sec->name);
3163               alc = (char *) bfd_malloc (len - 2);
3164               if (alc == NULL)
3165                 return FALSE;
3166               memcpy (alc, sec->name, len - 3);
3167               alc[len - 3] = '\0';
3168               s = bfd_get_section_by_name (abfd, alc);
3169               free (alc);
3170               if (s != NULL)
3171                 {
3172                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3173
3174                   /* This is a .stab section.  */
3175                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3176                     elf_section_data (s)->this_hdr.sh_entsize
3177                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3178                 }
3179             }
3180           break;
3181
3182         case SHT_DYNAMIC:
3183         case SHT_DYNSYM:
3184         case SHT_GNU_verneed:
3185         case SHT_GNU_verdef:
3186           /* sh_link is the section header index of the string table
3187              used for the dynamic entries, or the symbol table, or the
3188              version strings.  */
3189           s = bfd_get_section_by_name (abfd, ".dynstr");
3190           if (s != NULL)
3191             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3192           break;
3193
3194         case SHT_GNU_LIBLIST:
3195           /* sh_link is the section header index of the prelink library
3196              list used for the dynamic entries, or the symbol table, or
3197              the version strings.  */
3198           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3199                                              ? ".dynstr" : ".gnu.libstr");
3200           if (s != NULL)
3201             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3202           break;
3203
3204         case SHT_HASH:
3205         case SHT_GNU_HASH:
3206         case SHT_GNU_versym:
3207           /* sh_link is the section header index of the symbol table
3208              this hash table or version table is for.  */
3209           s = bfd_get_section_by_name (abfd, ".dynsym");
3210           if (s != NULL)
3211             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3212           break;
3213
3214         case SHT_GROUP:
3215           d->this_hdr.sh_link = t->symtab_section;
3216         }
3217     }
3218
3219   for (secn = 1; secn < section_number; ++secn)
3220     if (i_shdrp[secn] == NULL)
3221       i_shdrp[secn] = i_shdrp[0];
3222     else
3223       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3224                                                        i_shdrp[secn]->sh_name);
3225   return TRUE;
3226 }
3227
3228 /* Map symbol from it's internal number to the external number, moving
3229    all local symbols to be at the head of the list.  */
3230
3231 static bfd_boolean
3232 sym_is_global (bfd *abfd, asymbol *sym)
3233 {
3234   /* If the backend has a special mapping, use it.  */
3235   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3236   if (bed->elf_backend_sym_is_global)
3237     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3238
3239   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3240           || bfd_is_und_section (bfd_get_section (sym))
3241           || bfd_is_com_section (bfd_get_section (sym)));
3242 }
3243
3244 /* Don't output section symbols for sections that are not going to be
3245    output.  */
3246
3247 static bfd_boolean
3248 ignore_section_sym (bfd *abfd, asymbol *sym)
3249 {
3250   return ((sym->flags & BSF_SECTION_SYM) != 0
3251           && !(sym->section->owner == abfd
3252                || (sym->section->output_section->owner == abfd
3253                    && sym->section->output_offset == 0)));
3254 }
3255
3256 static bfd_boolean
3257 elf_map_symbols (bfd *abfd)
3258 {
3259   unsigned int symcount = bfd_get_symcount (abfd);
3260   asymbol **syms = bfd_get_outsymbols (abfd);
3261   asymbol **sect_syms;
3262   unsigned int num_locals = 0;
3263   unsigned int num_globals = 0;
3264   unsigned int num_locals2 = 0;
3265   unsigned int num_globals2 = 0;
3266   int max_index = 0;
3267   unsigned int idx;
3268   asection *asect;
3269   asymbol **new_syms;
3270
3271 #ifdef DEBUG
3272   fprintf (stderr, "elf_map_symbols\n");
3273   fflush (stderr);
3274 #endif
3275
3276   for (asect = abfd->sections; asect; asect = asect->next)
3277     {
3278       if (max_index < asect->index)
3279         max_index = asect->index;
3280     }
3281
3282   max_index++;
3283   sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3284   if (sect_syms == NULL)
3285     return FALSE;
3286   elf_section_syms (abfd) = sect_syms;
3287   elf_num_section_syms (abfd) = max_index;
3288
3289   /* Init sect_syms entries for any section symbols we have already
3290      decided to output.  */
3291   for (idx = 0; idx < symcount; idx++)
3292     {
3293       asymbol *sym = syms[idx];
3294
3295       if ((sym->flags & BSF_SECTION_SYM) != 0
3296           && sym->value == 0
3297           && !ignore_section_sym (abfd, sym))
3298         {
3299           asection *sec = sym->section;
3300
3301           if (sec->owner != abfd)
3302             sec = sec->output_section;
3303
3304           sect_syms[sec->index] = syms[idx];
3305         }
3306     }
3307
3308   /* Classify all of the symbols.  */
3309   for (idx = 0; idx < symcount; idx++)
3310     {
3311       if (ignore_section_sym (abfd, syms[idx]))
3312         continue;
3313       if (!sym_is_global (abfd, syms[idx]))
3314         num_locals++;
3315       else
3316         num_globals++;
3317     }
3318
3319   /* We will be adding a section symbol for each normal BFD section.  Most
3320      sections will already have a section symbol in outsymbols, but
3321      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3322      at least in that case.  */
3323   for (asect = abfd->sections; asect; asect = asect->next)
3324     {
3325       if (sect_syms[asect->index] == NULL)
3326         {
3327           if (!sym_is_global (abfd, asect->symbol))
3328             num_locals++;
3329           else
3330             num_globals++;
3331         }
3332     }
3333
3334   /* Now sort the symbols so the local symbols are first.  */
3335   new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3336                                       sizeof (asymbol *));
3337
3338   if (new_syms == NULL)
3339     return FALSE;
3340
3341   for (idx = 0; idx < symcount; idx++)
3342     {
3343       asymbol *sym = syms[idx];
3344       unsigned int i;
3345
3346       if (ignore_section_sym (abfd, sym))
3347         continue;
3348       if (!sym_is_global (abfd, sym))
3349         i = num_locals2++;
3350       else
3351         i = num_locals + num_globals2++;
3352       new_syms[i] = sym;
3353       sym->udata.i = i + 1;
3354     }
3355   for (asect = abfd->sections; asect; asect = asect->next)
3356     {
3357       if (sect_syms[asect->index] == NULL)
3358         {
3359           asymbol *sym = asect->symbol;
3360           unsigned int i;
3361
3362           sect_syms[asect->index] = sym;
3363           if (!sym_is_global (abfd, sym))
3364             i = num_locals2++;
3365           else
3366             i = num_locals + num_globals2++;
3367           new_syms[i] = sym;
3368           sym->udata.i = i + 1;
3369         }
3370     }
3371
3372   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3373
3374   elf_num_locals (abfd) = num_locals;
3375   elf_num_globals (abfd) = num_globals;
3376   return TRUE;
3377 }
3378
3379 /* Align to the maximum file alignment that could be required for any
3380    ELF data structure.  */
3381
3382 static inline file_ptr
3383 align_file_position (file_ptr off, int align)
3384 {
3385   return (off + align - 1) & ~(align - 1);
3386 }
3387
3388 /* Assign a file position to a section, optionally aligning to the
3389    required section alignment.  */
3390
3391 file_ptr
3392 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3393                                            file_ptr offset,
3394                                            bfd_boolean align)
3395 {
3396   if (align && i_shdrp->sh_addralign > 1)
3397     offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3398   i_shdrp->sh_offset = offset;
3399   if (i_shdrp->bfd_section != NULL)
3400     i_shdrp->bfd_section->filepos = offset;
3401   if (i_shdrp->sh_type != SHT_NOBITS)
3402     offset += i_shdrp->sh_size;
3403   return offset;
3404 }
3405
3406 /* Compute the file positions we are going to put the sections at, and
3407    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3408    is not NULL, this is being called by the ELF backend linker.  */
3409
3410 bfd_boolean
3411 _bfd_elf_compute_section_file_positions (bfd *abfd,
3412                                          struct bfd_link_info *link_info)
3413 {
3414   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3415   struct fake_section_arg fsargs;
3416   bfd_boolean failed;
3417   struct bfd_strtab_hash *strtab = NULL;
3418   Elf_Internal_Shdr *shstrtab_hdr;
3419   bfd_boolean need_symtab;
3420
3421   if (abfd->output_has_begun)
3422     return TRUE;
3423
3424   /* Do any elf backend specific processing first.  */
3425   if (bed->elf_backend_begin_write_processing)
3426     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3427
3428   if (! prep_headers (abfd))
3429     return FALSE;
3430
3431   /* Post process the headers if necessary.  */
3432   if (bed->elf_backend_post_process_headers)
3433     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3434
3435   fsargs.failed = FALSE;
3436   fsargs.link_info = link_info;
3437   bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
3438   if (fsargs.failed)
3439     return FALSE;
3440
3441   if (!assign_section_numbers (abfd, link_info))
3442     return FALSE;
3443
3444   /* The backend linker builds symbol table information itself.  */
3445   need_symtab = (link_info == NULL
3446                  && (bfd_get_symcount (abfd) > 0
3447                      || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3448                          == HAS_RELOC)));
3449   if (need_symtab)
3450     {
3451       /* Non-zero if doing a relocatable link.  */
3452       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3453
3454       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3455         return FALSE;
3456     }
3457
3458   failed = FALSE;
3459   if (link_info == NULL)
3460     {
3461       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3462       if (failed)
3463         return FALSE;
3464     }
3465
3466   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3467   /* sh_name was set in prep_headers.  */
3468   shstrtab_hdr->sh_type = SHT_STRTAB;
3469   shstrtab_hdr->sh_flags = 0;
3470   shstrtab_hdr->sh_addr = 0;
3471   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3472   shstrtab_hdr->sh_entsize = 0;
3473   shstrtab_hdr->sh_link = 0;
3474   shstrtab_hdr->sh_info = 0;
3475   /* sh_offset is set in assign_file_positions_except_relocs.  */
3476   shstrtab_hdr->sh_addralign = 1;
3477
3478   if (!assign_file_positions_except_relocs (abfd, link_info))
3479     return FALSE;
3480
3481   if (need_symtab)
3482     {
3483       file_ptr off;
3484       Elf_Internal_Shdr *hdr;
3485
3486       off = elf_tdata (abfd)->next_file_pos;
3487
3488       hdr = &elf_tdata (abfd)->symtab_hdr;
3489       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3490
3491       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3492       if (hdr->sh_size != 0)
3493         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3494
3495       hdr = &elf_tdata (abfd)->strtab_hdr;
3496       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3497
3498       elf_tdata (abfd)->next_file_pos = off;
3499
3500       /* Now that we know where the .strtab section goes, write it
3501          out.  */
3502       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3503           || ! _bfd_stringtab_emit (abfd, strtab))
3504         return FALSE;
3505       _bfd_stringtab_free (strtab);
3506     }
3507
3508   abfd->output_has_begun = TRUE;
3509
3510   return TRUE;
3511 }
3512
3513 /* Make an initial estimate of the size of the program header.  If we
3514    get the number wrong here, we'll redo section placement.  */
3515
3516 static bfd_size_type
3517 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3518 {
3519   size_t segs;
3520   asection *s;
3521   const struct elf_backend_data *bed;
3522
3523   /* Assume we will need exactly two PT_LOAD segments: one for text
3524      and one for data.  */
3525   segs = 2;
3526
3527   s = bfd_get_section_by_name (abfd, ".interp");
3528   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3529     {
3530       /* If we have a loadable interpreter section, we need a
3531          PT_INTERP segment.  In this case, assume we also need a
3532          PT_PHDR segment, although that may not be true for all
3533          targets.  */
3534       segs += 2;
3535     }
3536
3537   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3538     {
3539       /* We need a PT_DYNAMIC segment.  */
3540       ++segs;
3541     }
3542
3543   if (info != NULL && info->relro)
3544     {
3545       /* We need a PT_GNU_RELRO segment.  */
3546       ++segs;
3547     }
3548
3549   if (elf_tdata (abfd)->eh_frame_hdr)
3550     {
3551       /* We need a PT_GNU_EH_FRAME segment.  */
3552       ++segs;
3553     }
3554
3555   if (elf_tdata (abfd)->stack_flags)
3556     {
3557       /* We need a PT_GNU_STACK segment.  */
3558       ++segs;
3559     }
3560
3561   for (s = abfd->sections; s != NULL; s = s->next)
3562     {
3563       if ((s->flags & SEC_LOAD) != 0
3564           && CONST_STRNEQ (s->name, ".note"))
3565         {
3566           /* We need a PT_NOTE segment.  */
3567           ++segs;
3568           /* Try to create just one PT_NOTE segment
3569              for all adjacent loadable .note* sections.
3570              gABI requires that within a PT_NOTE segment
3571              (and also inside of each SHT_NOTE section)
3572              each note is padded to a multiple of 4 size,
3573              so we check whether the sections are correctly
3574              aligned.  */
3575           if (s->alignment_power == 2)
3576             while (s->next != NULL
3577                    && s->next->alignment_power == 2
3578                    && (s->next->flags & SEC_LOAD) != 0
3579                    && CONST_STRNEQ (s->next->name, ".note"))
3580               s = s->next;
3581         }
3582     }
3583
3584   for (s = abfd->sections; s != NULL; s = s->next)
3585     {
3586       if (s->flags & SEC_THREAD_LOCAL)
3587         {
3588           /* We need a PT_TLS segment.  */
3589           ++segs;
3590           break;
3591         }
3592     }
3593
3594   /* Let the backend count up any program headers it might need.  */
3595   bed = get_elf_backend_data (abfd);
3596   if (bed->elf_backend_additional_program_headers)
3597     {
3598       int a;
3599
3600       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3601       if (a == -1)
3602         abort ();
3603       segs += a;
3604     }
3605
3606   return segs * bed->s->sizeof_phdr;
3607 }
3608
3609 /* Find the segment that contains the output_section of section.  */
3610
3611 Elf_Internal_Phdr *
3612 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3613 {
3614   struct elf_segment_map *m;
3615   Elf_Internal_Phdr *p;
3616
3617   for (m = elf_tdata (abfd)->segment_map,
3618          p = elf_tdata (abfd)->phdr;
3619        m != NULL;
3620        m = m->next, p++)
3621     {
3622       int i;
3623
3624       for (i = m->count - 1; i >= 0; i--)
3625         if (m->sections[i] == section)
3626           return p;
3627     }
3628
3629   return NULL;
3630 }
3631
3632 /* Create a mapping from a set of sections to a program segment.  */
3633
3634 static struct elf_segment_map *
3635 make_mapping (bfd *abfd,
3636               asection **sections,
3637               unsigned int from,
3638               unsigned int to,
3639               bfd_boolean phdr)
3640 {
3641   struct elf_segment_map *m;
3642   unsigned int i;
3643   asection **hdrpp;
3644   bfd_size_type amt;
3645
3646   amt = sizeof (struct elf_segment_map);
3647   amt += (to - from - 1) * sizeof (asection *);
3648   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3649   if (m == NULL)
3650     return NULL;
3651   m->next = NULL;
3652   m->p_type = PT_LOAD;
3653   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3654     m->sections[i - from] = *hdrpp;
3655   m->count = to - from;
3656
3657   if (from == 0 && phdr)
3658     {
3659       /* Include the headers in the first PT_LOAD segment.  */
3660       m->includes_filehdr = 1;
3661       m->includes_phdrs = 1;
3662     }
3663
3664   return m;
3665 }
3666
3667 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3668    on failure.  */
3669
3670 struct elf_segment_map *
3671 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3672 {
3673   struct elf_segment_map *m;
3674
3675   m = (struct elf_segment_map *) bfd_zalloc (abfd,
3676                                              sizeof (struct elf_segment_map));
3677   if (m == NULL)
3678     return NULL;
3679   m->next = NULL;
3680   m->p_type = PT_DYNAMIC;
3681   m->count = 1;
3682   m->sections[0] = dynsec;
3683
3684   return m;
3685 }
3686
3687 /* Possibly add or remove segments from the segment map.  */
3688
3689 static bfd_boolean
3690 elf_modify_segment_map (bfd *abfd,
3691                         struct bfd_link_info *info,
3692                         bfd_boolean remove_empty_load)
3693 {
3694   struct elf_segment_map **m;
3695   const struct elf_backend_data *bed;
3696
3697   /* The placement algorithm assumes that non allocated sections are
3698      not in PT_LOAD segments.  We ensure this here by removing such
3699      sections from the segment map.  We also remove excluded
3700      sections.  Finally, any PT_LOAD segment without sections is
3701      removed.  */
3702   m = &elf_tdata (abfd)->segment_map;
3703   while (*m)
3704     {
3705       unsigned int i, new_count;
3706
3707       for (new_count = 0, i = 0; i < (*m)->count; i++)
3708         {
3709           if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3710               && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3711                   || (*m)->p_type != PT_LOAD))
3712             {
3713               (*m)->sections[new_count] = (*m)->sections[i];
3714               new_count++;
3715             }
3716         }
3717       (*m)->count = new_count;
3718
3719       if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3720         *m = (*m)->next;
3721       else
3722         m = &(*m)->next;
3723     }
3724
3725   bed = get_elf_backend_data (abfd);
3726   if (bed->elf_backend_modify_segment_map != NULL)
3727     {
3728       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3729         return FALSE;
3730     }
3731
3732   return TRUE;
3733 }
3734
3735 /* Set up a mapping from BFD sections to program segments.  */
3736
3737 bfd_boolean
3738 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3739 {
3740   unsigned int count;
3741   struct elf_segment_map *m;
3742   asection **sections = NULL;
3743   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3744   bfd_boolean no_user_phdrs;
3745
3746   no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3747   if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3748     {
3749       asection *s;
3750       unsigned int i;
3751       struct elf_segment_map *mfirst;
3752       struct elf_segment_map **pm;
3753       asection *last_hdr;
3754       bfd_vma last_size;
3755       unsigned int phdr_index;
3756       bfd_vma maxpagesize;
3757       asection **hdrpp;
3758       bfd_boolean phdr_in_segment = TRUE;
3759       bfd_boolean writable;
3760       int tls_count = 0;
3761       asection *first_tls = NULL;
3762       asection *dynsec, *eh_frame_hdr;
3763       bfd_size_type amt;
3764       bfd_vma addr_mask, wrap_to = 0;
3765
3766       /* Select the allocated sections, and sort them.  */
3767
3768       sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3769                                             sizeof (asection *));
3770       if (sections == NULL)
3771         goto error_return;
3772
3773       /* Calculate top address, avoiding undefined behaviour of shift
3774          left operator when shift count is equal to size of type
3775          being shifted.  */
3776       addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
3777       addr_mask = (addr_mask << 1) + 1;
3778
3779       i = 0;
3780       for (s = abfd->sections; s != NULL; s = s->next)
3781         {
3782           if ((s->flags & SEC_ALLOC) != 0)
3783             {
3784               sections[i] = s;
3785               ++i;
3786               /* A wrapping section potentially clashes with header.  */
3787               if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
3788                 wrap_to = (s->lma + s->size) & addr_mask;
3789             }
3790         }
3791       BFD_ASSERT (i <= bfd_count_sections (abfd));
3792       count = i;
3793
3794       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3795
3796       /* Build the mapping.  */
3797
3798       mfirst = NULL;
3799       pm = &mfirst;
3800
3801       /* If we have a .interp section, then create a PT_PHDR segment for
3802          the program headers and a PT_INTERP segment for the .interp
3803          section.  */
3804       s = bfd_get_section_by_name (abfd, ".interp");
3805       if (s != NULL && (s->flags & SEC_LOAD) != 0)
3806         {
3807           amt = sizeof (struct elf_segment_map);
3808           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3809           if (m == NULL)
3810             goto error_return;
3811           m->next = NULL;
3812           m->p_type = PT_PHDR;
3813           /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3814           m->p_flags = PF_R | PF_X;
3815           m->p_flags_valid = 1;
3816           m->includes_phdrs = 1;
3817
3818           *pm = m;
3819           pm = &m->next;
3820
3821           amt = sizeof (struct elf_segment_map);
3822           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3823           if (m == NULL)
3824             goto error_return;
3825           m->next = NULL;
3826           m->p_type = PT_INTERP;
3827           m->count = 1;
3828           m->sections[0] = s;
3829
3830           *pm = m;
3831           pm = &m->next;
3832         }
3833
3834       /* Look through the sections.  We put sections in the same program
3835          segment when the start of the second section can be placed within
3836          a few bytes of the end of the first section.  */
3837       last_hdr = NULL;
3838       last_size = 0;
3839       phdr_index = 0;
3840       maxpagesize = bed->maxpagesize;
3841       writable = FALSE;
3842       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3843       if (dynsec != NULL
3844           && (dynsec->flags & SEC_LOAD) == 0)
3845         dynsec = NULL;
3846
3847       /* Deal with -Ttext or something similar such that the first section
3848          is not adjacent to the program headers.  This is an
3849          approximation, since at this point we don't know exactly how many
3850          program headers we will need.  */
3851       if (count > 0)
3852         {
3853           bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3854
3855           if (phdr_size == (bfd_size_type) -1)
3856             phdr_size = get_program_header_size (abfd, info);
3857           if ((abfd->flags & D_PAGED) == 0
3858               || (sections[0]->lma & addr_mask) < phdr_size
3859               || ((sections[0]->lma & addr_mask) % maxpagesize
3860                   < phdr_size % maxpagesize)
3861               || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
3862             phdr_in_segment = FALSE;
3863         }
3864
3865       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3866         {
3867           asection *hdr;
3868           bfd_boolean new_segment;
3869
3870           hdr = *hdrpp;
3871
3872           /* See if this section and the last one will fit in the same
3873              segment.  */
3874
3875           if (last_hdr == NULL)
3876             {
3877               /* If we don't have a segment yet, then we don't need a new
3878                  one (we build the last one after this loop).  */
3879               new_segment = FALSE;
3880             }
3881           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3882             {
3883               /* If this section has a different relation between the
3884                  virtual address and the load address, then we need a new
3885                  segment.  */
3886               new_segment = TRUE;
3887             }
3888           else if (hdr->lma < last_hdr->lma + last_size
3889                    || last_hdr->lma + last_size < last_hdr->lma)
3890             {
3891               /* If this section has a load address that makes it overlap
3892                  the previous section, then we need a new segment.  */
3893               new_segment = TRUE;
3894             }
3895           /* In the next test we have to be careful when last_hdr->lma is close
3896              to the end of the address space.  If the aligned address wraps
3897              around to the start of the address space, then there are no more
3898              pages left in memory and it is OK to assume that the current
3899              section can be included in the current segment.  */
3900           else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3901                     > last_hdr->lma)
3902                    && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3903                        <= hdr->lma))
3904             {
3905               /* If putting this section in this segment would force us to
3906                  skip a page in the segment, then we need a new segment.  */
3907               new_segment = TRUE;
3908             }
3909           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3910                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3911             {
3912               /* We don't want to put a loadable section after a
3913                  nonloadable section in the same segment.
3914                  Consider .tbss sections as loadable for this purpose.  */
3915               new_segment = TRUE;
3916             }
3917           else if ((abfd->flags & D_PAGED) == 0)
3918             {
3919               /* If the file is not demand paged, which means that we
3920                  don't require the sections to be correctly aligned in the
3921                  file, then there is no other reason for a new segment.  */
3922               new_segment = FALSE;
3923             }
3924           else if (! writable
3925                    && (hdr->flags & SEC_READONLY) == 0
3926                    && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3927                        != (hdr->lma & -maxpagesize)))
3928             {
3929               /* We don't want to put a writable section in a read only
3930                  segment, unless they are on the same page in memory
3931                  anyhow.  We already know that the last section does not
3932                  bring us past the current section on the page, so the
3933                  only case in which the new section is not on the same
3934                  page as the previous section is when the previous section
3935                  ends precisely on a page boundary.  */
3936               new_segment = TRUE;
3937             }
3938           else
3939             {
3940               /* Otherwise, we can use the same segment.  */
3941               new_segment = FALSE;
3942             }
3943
3944           /* Allow interested parties a chance to override our decision.  */
3945           if (last_hdr != NULL
3946               && info != NULL
3947               && info->callbacks->override_segment_assignment != NULL)
3948             new_segment
3949               = info->callbacks->override_segment_assignment (info, abfd, hdr,
3950                                                               last_hdr,
3951                                                               new_segment);
3952
3953           if (! new_segment)
3954             {
3955               if ((hdr->flags & SEC_READONLY) == 0)
3956                 writable = TRUE;
3957               last_hdr = hdr;
3958               /* .tbss sections effectively have zero size.  */
3959               if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3960                   != SEC_THREAD_LOCAL)