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