1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
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).
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. */
37 /* For sparc64-cross-sparc32. */
45 #include "libiberty.h"
46 #include "safe-ctype.h"
52 static int elf_sort_sections (const void *, const void *);
53 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
54 static bfd_boolean prep_headers (bfd *);
55 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
56 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
57 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
60 /* Swap version information in and out. The version information is
61 currently size independent. If that ever changes, this code will
62 need to move into elfcode.h. */
64 /* Swap in a Verdef structure. */
67 _bfd_elf_swap_verdef_in (bfd *abfd,
68 const Elf_External_Verdef *src,
69 Elf_Internal_Verdef *dst)
71 dst->vd_version = H_GET_16 (abfd, src->vd_version);
72 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
73 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
74 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
75 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
76 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
77 dst->vd_next = H_GET_32 (abfd, src->vd_next);
80 /* Swap out a Verdef structure. */
83 _bfd_elf_swap_verdef_out (bfd *abfd,
84 const Elf_Internal_Verdef *src,
85 Elf_External_Verdef *dst)
87 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
88 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
89 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
90 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
91 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
92 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
93 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
96 /* Swap in a Verdaux structure. */
99 _bfd_elf_swap_verdaux_in (bfd *abfd,
100 const Elf_External_Verdaux *src,
101 Elf_Internal_Verdaux *dst)
103 dst->vda_name = H_GET_32 (abfd, src->vda_name);
104 dst->vda_next = H_GET_32 (abfd, src->vda_next);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (bfd *abfd,
111 const Elf_Internal_Verdaux *src,
112 Elf_External_Verdaux *dst)
114 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
115 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
118 /* Swap in a Verneed structure. */
121 _bfd_elf_swap_verneed_in (bfd *abfd,
122 const Elf_External_Verneed *src,
123 Elf_Internal_Verneed *dst)
125 dst->vn_version = H_GET_16 (abfd, src->vn_version);
126 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
127 dst->vn_file = H_GET_32 (abfd, src->vn_file);
128 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
129 dst->vn_next = H_GET_32 (abfd, src->vn_next);
132 /* Swap out a Verneed structure. */
135 _bfd_elf_swap_verneed_out (bfd *abfd,
136 const Elf_Internal_Verneed *src,
137 Elf_External_Verneed *dst)
139 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
140 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
141 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
142 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
143 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
146 /* Swap in a Vernaux structure. */
149 _bfd_elf_swap_vernaux_in (bfd *abfd,
150 const Elf_External_Vernaux *src,
151 Elf_Internal_Vernaux *dst)
153 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
154 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
155 dst->vna_other = H_GET_16 (abfd, src->vna_other);
156 dst->vna_name = H_GET_32 (abfd, src->vna_name);
157 dst->vna_next = H_GET_32 (abfd, src->vna_next);
160 /* Swap out a Vernaux structure. */
163 _bfd_elf_swap_vernaux_out (bfd *abfd,
164 const Elf_Internal_Vernaux *src,
165 Elf_External_Vernaux *dst)
167 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
168 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
169 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
170 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
171 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
174 /* Swap in a Versym structure. */
177 _bfd_elf_swap_versym_in (bfd *abfd,
178 const Elf_External_Versym *src,
179 Elf_Internal_Versym *dst)
181 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
184 /* Swap out a Versym structure. */
187 _bfd_elf_swap_versym_out (bfd *abfd,
188 const Elf_Internal_Versym *src,
189 Elf_External_Versym *dst)
191 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
194 /* Standard ELF hash function. Do not change this function; you will
195 cause invalid hash tables to be generated. */
198 bfd_elf_hash (const char *namearg)
200 const unsigned char *name = (const unsigned char *) namearg;
205 while ((ch = *name++) != '\0')
208 if ((g = (h & 0xf0000000)) != 0)
211 /* The ELF ABI says `h &= ~g', but this is equivalent in
212 this case and on some machines one insn instead of two. */
216 return h & 0xffffffff;
219 /* DT_GNU_HASH hash function. Do not change this function; you will
220 cause invalid hash tables to be generated. */
223 bfd_elf_gnu_hash (const char *namearg)
225 const unsigned char *name = (const unsigned char *) namearg;
226 unsigned long h = 5381;
229 while ((ch = *name++) != '\0')
230 h = (h << 5) + h + ch;
231 return h & 0xffffffff;
234 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
235 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
237 bfd_elf_allocate_object (bfd *abfd,
239 enum elf_target_id object_id)
241 BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
242 abfd->tdata.any = bfd_zalloc (abfd, object_size);
243 if (abfd->tdata.any == NULL)
246 elf_object_id (abfd) = object_id;
247 elf_program_header_size (abfd) = (bfd_size_type) -1;
253 bfd_elf_make_object (bfd *abfd)
255 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
256 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
261 bfd_elf_mkcorefile (bfd *abfd)
263 /* I think this can be done just like an object file. */
264 return abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd);
268 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
270 Elf_Internal_Shdr **i_shdrp;
271 bfd_byte *shstrtab = NULL;
273 bfd_size_type shstrtabsize;
275 i_shdrp = elf_elfsections (abfd);
277 || shindex >= elf_numsections (abfd)
278 || i_shdrp[shindex] == 0)
281 shstrtab = i_shdrp[shindex]->contents;
282 if (shstrtab == NULL)
284 /* No cached one, attempt to read, and cache what we read. */
285 offset = i_shdrp[shindex]->sh_offset;
286 shstrtabsize = i_shdrp[shindex]->sh_size;
288 /* Allocate and clear an extra byte at the end, to prevent crashes
289 in case the string table is not terminated. */
290 if (shstrtabsize + 1 <= 1
291 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL
292 || bfd_seek (abfd, offset, SEEK_SET) != 0)
294 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
296 if (bfd_get_error () != bfd_error_system_call)
297 bfd_set_error (bfd_error_file_truncated);
299 /* Once we've failed to read it, make sure we don't keep
300 trying. Otherwise, we'll keep allocating space for
301 the string table over and over. */
302 i_shdrp[shindex]->sh_size = 0;
305 shstrtab[shstrtabsize] = '\0';
306 i_shdrp[shindex]->contents = shstrtab;
308 return (char *) shstrtab;
312 bfd_elf_string_from_elf_section (bfd *abfd,
313 unsigned int shindex,
314 unsigned int strindex)
316 Elf_Internal_Shdr *hdr;
321 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
324 hdr = elf_elfsections (abfd)[shindex];
326 if (hdr->contents == NULL
327 && bfd_elf_get_str_section (abfd, shindex) == NULL)
330 if (strindex >= hdr->sh_size)
332 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
333 (*_bfd_error_handler)
334 (_("%B: invalid string offset %u >= %lu for section `%s'"),
335 abfd, strindex, (unsigned long) hdr->sh_size,
336 (shindex == shstrndx && strindex == hdr->sh_name
338 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
342 return ((char *) hdr->contents) + strindex;
345 /* Read and convert symbols to internal format.
346 SYMCOUNT specifies the number of symbols to read, starting from
347 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
348 are non-NULL, they are used to store the internal symbols, external
349 symbols, and symbol section index extensions, respectively.
350 Returns a pointer to the internal symbol buffer (malloced if necessary)
351 or NULL if there were no symbols or some kind of problem. */
354 bfd_elf_get_elf_syms (bfd *ibfd,
355 Elf_Internal_Shdr *symtab_hdr,
358 Elf_Internal_Sym *intsym_buf,
360 Elf_External_Sym_Shndx *extshndx_buf)
362 Elf_Internal_Shdr *shndx_hdr;
364 const bfd_byte *esym;
365 Elf_External_Sym_Shndx *alloc_extshndx;
366 Elf_External_Sym_Shndx *shndx;
367 Elf_Internal_Sym *alloc_intsym;
368 Elf_Internal_Sym *isym;
369 Elf_Internal_Sym *isymend;
370 const struct elf_backend_data *bed;
375 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
381 /* Normal syms might have section extension entries. */
383 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
384 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
386 /* Read the symbols. */
388 alloc_extshndx = NULL;
390 bed = get_elf_backend_data (ibfd);
391 extsym_size = bed->s->sizeof_sym;
392 amt = symcount * extsym_size;
393 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
394 if (extsym_buf == NULL)
396 alloc_ext = bfd_malloc2 (symcount, extsym_size);
397 extsym_buf = alloc_ext;
399 if (extsym_buf == NULL
400 || bfd_seek (ibfd, pos, SEEK_SET) != 0
401 || bfd_bread (extsym_buf, amt, ibfd) != amt)
407 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
411 amt = symcount * sizeof (Elf_External_Sym_Shndx);
412 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
413 if (extshndx_buf == NULL)
415 alloc_extshndx = (Elf_External_Sym_Shndx *)
416 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
417 extshndx_buf = alloc_extshndx;
419 if (extshndx_buf == NULL
420 || bfd_seek (ibfd, pos, SEEK_SET) != 0
421 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
428 if (intsym_buf == NULL)
430 alloc_intsym = (Elf_Internal_Sym *)
431 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
432 intsym_buf = alloc_intsym;
433 if (intsym_buf == NULL)
437 /* Convert the symbols to internal form. */
438 isymend = intsym_buf + symcount;
439 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
440 shndx = extshndx_buf;
442 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
443 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
445 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
446 (*_bfd_error_handler) (_("%B symbol number %lu references "
447 "nonexistent SHT_SYMTAB_SHNDX section"),
448 ibfd, (unsigned long) symoffset);
449 if (alloc_intsym != NULL)
456 if (alloc_ext != NULL)
458 if (alloc_extshndx != NULL)
459 free (alloc_extshndx);
464 /* Look up a symbol name. */
466 bfd_elf_sym_name (bfd *abfd,
467 Elf_Internal_Shdr *symtab_hdr,
468 Elf_Internal_Sym *isym,
472 unsigned int iname = isym->st_name;
473 unsigned int shindex = symtab_hdr->sh_link;
475 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
476 /* Check for a bogus st_shndx to avoid crashing. */
477 && isym->st_shndx < elf_numsections (abfd))
479 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
480 shindex = elf_elfheader (abfd)->e_shstrndx;
483 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
486 else if (sym_sec && *name == '\0')
487 name = bfd_section_name (abfd, sym_sec);
492 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
493 sections. The first element is the flags, the rest are section
496 typedef union elf_internal_group {
497 Elf_Internal_Shdr *shdr;
499 } Elf_Internal_Group;
501 /* Return the name of the group signature symbol. Why isn't the
502 signature just a string? */
505 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
507 Elf_Internal_Shdr *hdr;
508 unsigned char esym[sizeof (Elf64_External_Sym)];
509 Elf_External_Sym_Shndx eshndx;
510 Elf_Internal_Sym isym;
512 /* First we need to ensure the symbol table is available. Make sure
513 that it is a symbol table section. */
514 if (ghdr->sh_link >= elf_numsections (abfd))
516 hdr = elf_elfsections (abfd) [ghdr->sh_link];
517 if (hdr->sh_type != SHT_SYMTAB
518 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
521 /* Go read the symbol. */
522 hdr = &elf_tdata (abfd)->symtab_hdr;
523 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
524 &isym, esym, &eshndx) == NULL)
527 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
530 /* Set next_in_group list pointer, and group name for NEWSECT. */
533 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
535 unsigned int num_group = elf_tdata (abfd)->num_group;
537 /* If num_group is zero, read in all SHT_GROUP sections. The count
538 is set to -1 if there are no SHT_GROUP sections. */
541 unsigned int i, shnum;
543 /* First count the number of groups. If we have a SHT_GROUP
544 section with just a flag word (ie. sh_size is 4), ignore it. */
545 shnum = elf_numsections (abfd);
548 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
549 ( (shdr)->sh_type == SHT_GROUP \
550 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
551 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
552 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
554 for (i = 0; i < shnum; i++)
556 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
558 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
564 num_group = (unsigned) -1;
565 elf_tdata (abfd)->num_group = num_group;
569 /* We keep a list of elf section headers for group sections,
570 so we can find them quickly. */
573 elf_tdata (abfd)->num_group = num_group;
574 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
575 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
576 if (elf_tdata (abfd)->group_sect_ptr == NULL)
580 for (i = 0; i < shnum; i++)
582 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
584 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
587 Elf_Internal_Group *dest;
589 /* Add to list of sections. */
590 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
593 /* Read the raw contents. */
594 BFD_ASSERT (sizeof (*dest) >= 4);
595 amt = shdr->sh_size * sizeof (*dest) / 4;
596 shdr->contents = (unsigned char *)
597 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
598 /* PR binutils/4110: Handle corrupt group headers. */
599 if (shdr->contents == NULL)
602 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
603 bfd_set_error (bfd_error_bad_value);
607 memset (shdr->contents, 0, amt);
609 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
610 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
614 /* Translate raw contents, a flag word followed by an
615 array of elf section indices all in target byte order,
616 to the flag word followed by an array of elf section
618 src = shdr->contents + shdr->sh_size;
619 dest = (Elf_Internal_Group *) (shdr->contents + amt);
626 idx = H_GET_32 (abfd, src);
627 if (src == shdr->contents)
630 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
631 shdr->bfd_section->flags
632 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
637 ((*_bfd_error_handler)
638 (_("%B: invalid SHT_GROUP entry"), abfd));
641 dest->shdr = elf_elfsections (abfd)[idx];
648 if (num_group != (unsigned) -1)
652 for (i = 0; i < num_group; i++)
654 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
655 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
656 unsigned int n_elt = shdr->sh_size / 4;
658 /* Look through this group's sections to see if current
659 section is a member. */
661 if ((++idx)->shdr == hdr)
665 /* We are a member of this group. Go looking through
666 other members to see if any others are linked via
668 idx = (Elf_Internal_Group *) shdr->contents;
669 n_elt = shdr->sh_size / 4;
671 if ((s = (++idx)->shdr->bfd_section) != NULL
672 && elf_next_in_group (s) != NULL)
676 /* Snarf the group name from other member, and
677 insert current section in circular list. */
678 elf_group_name (newsect) = elf_group_name (s);
679 elf_next_in_group (newsect) = elf_next_in_group (s);
680 elf_next_in_group (s) = newsect;
686 gname = group_signature (abfd, shdr);
689 elf_group_name (newsect) = gname;
691 /* Start a circular list with one element. */
692 elf_next_in_group (newsect) = newsect;
695 /* If the group section has been created, point to the
697 if (shdr->bfd_section != NULL)
698 elf_next_in_group (shdr->bfd_section) = newsect;
706 if (elf_group_name (newsect) == NULL)
708 (*_bfd_error_handler) (_("%B: no group info for section %A"),
715 _bfd_elf_setup_sections (bfd *abfd)
718 unsigned int num_group = elf_tdata (abfd)->num_group;
719 bfd_boolean result = TRUE;
722 /* Process SHF_LINK_ORDER. */
723 for (s = abfd->sections; s != NULL; s = s->next)
725 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
726 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
728 unsigned int elfsec = this_hdr->sh_link;
729 /* FIXME: The old Intel compiler and old strip/objcopy may
730 not set the sh_link or sh_info fields. Hence we could
731 get the situation where elfsec is 0. */
734 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
735 if (bed->link_order_error_handler)
736 bed->link_order_error_handler
737 (_("%B: warning: sh_link not set for section `%A'"),
742 asection *linksec = NULL;
744 if (elfsec < elf_numsections (abfd))
746 this_hdr = elf_elfsections (abfd)[elfsec];
747 linksec = this_hdr->bfd_section;
751 Some strip/objcopy may leave an incorrect value in
752 sh_link. We don't want to proceed. */
755 (*_bfd_error_handler)
756 (_("%B: sh_link [%d] in section `%A' is incorrect"),
757 s->owner, s, elfsec);
761 elf_linked_to_section (s) = linksec;
766 /* Process section groups. */
767 if (num_group == (unsigned) -1)
770 for (i = 0; i < num_group; i++)
772 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
773 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
774 unsigned int n_elt = shdr->sh_size / 4;
777 if ((++idx)->shdr->bfd_section)
778 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
779 else if (idx->shdr->sh_type == SHT_RELA
780 || idx->shdr->sh_type == SHT_REL)
781 /* We won't include relocation sections in section groups in
782 output object files. We adjust the group section size here
783 so that relocatable link will work correctly when
784 relocation sections are in section group in input object
786 shdr->bfd_section->size -= 4;
789 /* There are some unknown sections in the group. */
790 (*_bfd_error_handler)
791 (_("%B: unknown [%d] section `%s' in group [%s]"),
793 (unsigned int) idx->shdr->sh_type,
794 bfd_elf_string_from_elf_section (abfd,
795 (elf_elfheader (abfd)
798 shdr->bfd_section->name);
806 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
808 return elf_next_in_group (sec) != NULL;
811 /* Make a BFD section from an ELF section. We store a pointer to the
812 BFD section in the bfd_section field of the header. */
815 _bfd_elf_make_section_from_shdr (bfd *abfd,
816 Elf_Internal_Shdr *hdr,
822 const struct elf_backend_data *bed;
824 if (hdr->bfd_section != NULL)
827 newsect = bfd_make_section_anyway (abfd, name);
831 hdr->bfd_section = newsect;
832 elf_section_data (newsect)->this_hdr = *hdr;
833 elf_section_data (newsect)->this_idx = shindex;
835 /* Always use the real type/flags. */
836 elf_section_type (newsect) = hdr->sh_type;
837 elf_section_flags (newsect) = hdr->sh_flags;
839 newsect->filepos = hdr->sh_offset;
841 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
842 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
843 || ! bfd_set_section_alignment (abfd, newsect,
844 bfd_log2 (hdr->sh_addralign)))
847 flags = SEC_NO_FLAGS;
848 if (hdr->sh_type != SHT_NOBITS)
849 flags |= SEC_HAS_CONTENTS;
850 if (hdr->sh_type == SHT_GROUP)
851 flags |= SEC_GROUP | SEC_EXCLUDE;
852 if ((hdr->sh_flags & SHF_ALLOC) != 0)
855 if (hdr->sh_type != SHT_NOBITS)
858 if ((hdr->sh_flags & SHF_WRITE) == 0)
859 flags |= SEC_READONLY;
860 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
862 else if ((flags & SEC_LOAD) != 0)
864 if ((hdr->sh_flags & SHF_MERGE) != 0)
867 newsect->entsize = hdr->sh_entsize;
868 if ((hdr->sh_flags & SHF_STRINGS) != 0)
869 flags |= SEC_STRINGS;
871 if (hdr->sh_flags & SHF_GROUP)
872 if (!setup_group (abfd, hdr, newsect))
874 if ((hdr->sh_flags & SHF_TLS) != 0)
875 flags |= SEC_THREAD_LOCAL;
876 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
877 flags |= SEC_EXCLUDE;
879 if ((flags & SEC_ALLOC) == 0)
881 /* The debugging sections appear to be recognized only by name,
882 not any sort of flag. Their SEC_ALLOC bits are cleared. */
887 } debug_sections [] =
889 { STRING_COMMA_LEN ("debug") }, /* 'd' */
890 { NULL, 0 }, /* 'e' */
891 { NULL, 0 }, /* 'f' */
892 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
893 { NULL, 0 }, /* 'h' */
894 { NULL, 0 }, /* 'i' */
895 { NULL, 0 }, /* 'j' */
896 { NULL, 0 }, /* 'k' */
897 { STRING_COMMA_LEN ("line") }, /* 'l' */
898 { NULL, 0 }, /* 'm' */
899 { NULL, 0 }, /* 'n' */
900 { NULL, 0 }, /* 'o' */
901 { NULL, 0 }, /* 'p' */
902 { NULL, 0 }, /* 'q' */
903 { NULL, 0 }, /* 'r' */
904 { STRING_COMMA_LEN ("stab") }, /* 's' */
905 { NULL, 0 }, /* 't' */
906 { NULL, 0 }, /* 'u' */
907 { NULL, 0 }, /* 'v' */
908 { NULL, 0 }, /* 'w' */
909 { NULL, 0 }, /* 'x' */
910 { NULL, 0 }, /* 'y' */
911 { STRING_COMMA_LEN ("zdebug") } /* 'z' */
916 int i = name [1] - 'd';
918 && i < (int) ARRAY_SIZE (debug_sections)
919 && debug_sections [i].name != NULL
920 && strncmp (&name [1], debug_sections [i].name,
921 debug_sections [i].len) == 0)
922 flags |= SEC_DEBUGGING;
926 /* As a GNU extension, if the name begins with .gnu.linkonce, we
927 only link a single copy of the section. This is used to support
928 g++. g++ will emit each template expansion in its own section.
929 The symbols will be defined as weak, so that multiple definitions
930 are permitted. The GNU linker extension is to actually discard
931 all but one of the sections. */
932 if (CONST_STRNEQ (name, ".gnu.linkonce")
933 && elf_next_in_group (newsect) == NULL)
934 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
936 bed = get_elf_backend_data (abfd);
937 if (bed->elf_backend_section_flags)
938 if (! bed->elf_backend_section_flags (&flags, hdr))
941 if (! bfd_set_section_flags (abfd, newsect, flags))
944 /* We do not parse the PT_NOTE segments as we are interested even in the
945 separate debug info files which may have the segments offsets corrupted.
946 PT_NOTEs from the core files are currently not parsed using BFD. */
947 if (hdr->sh_type == SHT_NOTE)
951 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
954 elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1);
958 if ((flags & SEC_ALLOC) != 0)
960 Elf_Internal_Phdr *phdr;
961 unsigned int i, nload;
963 /* Some ELF linkers produce binaries with all the program header
964 p_paddr fields zero. If we have such a binary with more than
965 one PT_LOAD header, then leave the section lma equal to vma
966 so that we don't create sections with overlapping lma. */
967 phdr = elf_tdata (abfd)->phdr;
968 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
969 if (phdr->p_paddr != 0)
971 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
973 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
976 phdr = elf_tdata (abfd)->phdr;
977 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
979 if (((phdr->p_type == PT_LOAD
980 && (hdr->sh_flags & SHF_TLS) == 0)
981 || phdr->p_type == PT_TLS)
982 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
984 if ((flags & SEC_LOAD) == 0)
985 newsect->lma = (phdr->p_paddr
986 + hdr->sh_addr - phdr->p_vaddr);
988 /* We used to use the same adjustment for SEC_LOAD
989 sections, but that doesn't work if the segment
990 is packed with code from multiple VMAs.
991 Instead we calculate the section LMA based on
992 the segment LMA. It is assumed that the
993 segment will contain sections with contiguous
994 LMAs, even if the VMAs are not. */
995 newsect->lma = (phdr->p_paddr
996 + hdr->sh_offset - phdr->p_offset);
998 /* With contiguous segments, we can't tell from file
999 offsets whether a section with zero size should
1000 be placed at the end of one segment or the
1001 beginning of the next. Decide based on vaddr. */
1002 if (hdr->sh_addr >= phdr->p_vaddr
1003 && (hdr->sh_addr + hdr->sh_size
1004 <= phdr->p_vaddr + phdr->p_memsz))
1010 /* Compress/decompress DWARF debug sections with names: .debug_* and
1011 .zdebug_*, after the section flags is set. */
1012 if ((flags & SEC_DEBUGGING)
1013 && ((name[1] == 'd' && name[6] == '_')
1014 || (name[1] == 'z' && name[7] == '_')))
1016 enum { nothing, compress, decompress } action = nothing;
1019 if (bfd_is_section_compressed (abfd, newsect))
1021 /* Compressed section. Check if we should decompress. */
1022 if ((abfd->flags & BFD_DECOMPRESS))
1023 action = decompress;
1027 /* Normal section. Check if we should compress. */
1028 if ((abfd->flags & BFD_COMPRESS))
1038 if (!bfd_init_section_compress_status (abfd, newsect))
1040 (*_bfd_error_handler)
1041 (_("%B: unable to initialize commpress status for section %s"),
1047 unsigned int len = strlen (name);
1049 new_name = bfd_alloc (abfd, len + 2);
1050 if (new_name == NULL)
1054 memcpy (new_name + 2, name + 1, len);
1058 if (!bfd_init_section_decompress_status (abfd, newsect))
1060 (*_bfd_error_handler)
1061 (_("%B: unable to initialize decommpress status for section %s"),
1067 unsigned int len = strlen (name);
1069 new_name = bfd_alloc (abfd, len);
1070 if (new_name == NULL)
1073 memcpy (new_name + 1, name + 2, len - 1);
1077 if (new_name != NULL)
1078 bfd_rename_section (abfd, newsect, new_name);
1084 const char *const bfd_elf_section_type_names[] = {
1085 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1086 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1087 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1090 /* ELF relocs are against symbols. If we are producing relocatable
1091 output, and the reloc is against an external symbol, and nothing
1092 has given us any additional addend, the resulting reloc will also
1093 be against the same symbol. In such a case, we don't want to
1094 change anything about the way the reloc is handled, since it will
1095 all be done at final link time. Rather than put special case code
1096 into bfd_perform_relocation, all the reloc types use this howto
1097 function. It just short circuits the reloc if producing
1098 relocatable output against an external symbol. */
1100 bfd_reloc_status_type
1101 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1102 arelent *reloc_entry,
1104 void *data ATTRIBUTE_UNUSED,
1105 asection *input_section,
1107 char **error_message ATTRIBUTE_UNUSED)
1109 if (output_bfd != NULL
1110 && (symbol->flags & BSF_SECTION_SYM) == 0
1111 && (! reloc_entry->howto->partial_inplace
1112 || reloc_entry->addend == 0))
1114 reloc_entry->address += input_section->output_offset;
1115 return bfd_reloc_ok;
1118 return bfd_reloc_continue;
1121 /* Copy the program header and other data from one object module to
1125 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1127 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1128 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1131 BFD_ASSERT (!elf_flags_init (obfd)
1132 || (elf_elfheader (obfd)->e_flags
1133 == elf_elfheader (ibfd)->e_flags));
1135 elf_gp (obfd) = elf_gp (ibfd);
1136 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1137 elf_flags_init (obfd) = TRUE;
1139 /* Copy object attributes. */
1140 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1145 get_segment_type (unsigned int p_type)
1150 case PT_NULL: pt = "NULL"; break;
1151 case PT_LOAD: pt = "LOAD"; break;
1152 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1153 case PT_INTERP: pt = "INTERP"; break;
1154 case PT_NOTE: pt = "NOTE"; break;
1155 case PT_SHLIB: pt = "SHLIB"; break;
1156 case PT_PHDR: pt = "PHDR"; break;
1157 case PT_TLS: pt = "TLS"; break;
1158 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1159 case PT_GNU_STACK: pt = "STACK"; break;
1160 case PT_GNU_RELRO: pt = "RELRO"; break;
1161 default: pt = NULL; break;
1166 /* Print out the program headers. */
1169 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1171 FILE *f = (FILE *) farg;
1172 Elf_Internal_Phdr *p;
1174 bfd_byte *dynbuf = NULL;
1176 p = elf_tdata (abfd)->phdr;
1181 fprintf (f, _("\nProgram Header:\n"));
1182 c = elf_elfheader (abfd)->e_phnum;
1183 for (i = 0; i < c; i++, p++)
1185 const char *pt = get_segment_type (p->p_type);
1190 sprintf (buf, "0x%lx", p->p_type);
1193 fprintf (f, "%8s off 0x", pt);
1194 bfd_fprintf_vma (abfd, f, p->p_offset);
1195 fprintf (f, " vaddr 0x");
1196 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1197 fprintf (f, " paddr 0x");
1198 bfd_fprintf_vma (abfd, f, p->p_paddr);
1199 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1200 fprintf (f, " filesz 0x");
1201 bfd_fprintf_vma (abfd, f, p->p_filesz);
1202 fprintf (f, " memsz 0x");
1203 bfd_fprintf_vma (abfd, f, p->p_memsz);
1204 fprintf (f, " flags %c%c%c",
1205 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1206 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1207 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1208 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1209 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1214 s = bfd_get_section_by_name (abfd, ".dynamic");
1217 unsigned int elfsec;
1218 unsigned long shlink;
1219 bfd_byte *extdyn, *extdynend;
1221 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1223 fprintf (f, _("\nDynamic Section:\n"));
1225 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1228 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1229 if (elfsec == SHN_BAD)
1231 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1233 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1234 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1237 extdynend = extdyn + s->size;
1238 for (; extdyn < extdynend; extdyn += extdynsize)
1240 Elf_Internal_Dyn dyn;
1241 const char *name = "";
1243 bfd_boolean stringp;
1244 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1246 (*swap_dyn_in) (abfd, extdyn, &dyn);
1248 if (dyn.d_tag == DT_NULL)
1255 if (bed->elf_backend_get_target_dtag)
1256 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1258 if (!strcmp (name, ""))
1260 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1265 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1266 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1267 case DT_PLTGOT: name = "PLTGOT"; break;
1268 case DT_HASH: name = "HASH"; break;
1269 case DT_STRTAB: name = "STRTAB"; break;
1270 case DT_SYMTAB: name = "SYMTAB"; break;
1271 case DT_RELA: name = "RELA"; break;
1272 case DT_RELASZ: name = "RELASZ"; break;
1273 case DT_RELAENT: name = "RELAENT"; break;
1274 case DT_STRSZ: name = "STRSZ"; break;
1275 case DT_SYMENT: name = "SYMENT"; break;
1276 case DT_INIT: name = "INIT"; break;
1277 case DT_FINI: name = "FINI"; break;
1278 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1279 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1280 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1281 case DT_REL: name = "REL"; break;
1282 case DT_RELSZ: name = "RELSZ"; break;
1283 case DT_RELENT: name = "RELENT"; break;
1284 case DT_PLTREL: name = "PLTREL"; break;
1285 case DT_DEBUG: name = "DEBUG"; break;
1286 case DT_TEXTREL: name = "TEXTREL"; break;
1287 case DT_JMPREL: name = "JMPREL"; break;
1288 case DT_BIND_NOW: name = "BIND_NOW"; break;
1289 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1290 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1291 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1292 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1293 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1294 case DT_FLAGS: name = "FLAGS"; break;
1295 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1296 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1297 case DT_CHECKSUM: name = "CHECKSUM"; break;
1298 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1299 case DT_MOVEENT: name = "MOVEENT"; break;
1300 case DT_MOVESZ: name = "MOVESZ"; break;
1301 case DT_FEATURE: name = "FEATURE"; break;
1302 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1303 case DT_SYMINSZ: name = "SYMINSZ"; break;
1304 case DT_SYMINENT: name = "SYMINENT"; break;
1305 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1306 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1307 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1308 case DT_PLTPAD: name = "PLTPAD"; break;
1309 case DT_MOVETAB: name = "MOVETAB"; break;
1310 case DT_SYMINFO: name = "SYMINFO"; break;
1311 case DT_RELACOUNT: name = "RELACOUNT"; break;
1312 case DT_RELCOUNT: name = "RELCOUNT"; break;
1313 case DT_FLAGS_1: name = "FLAGS_1"; break;
1314 case DT_VERSYM: name = "VERSYM"; break;
1315 case DT_VERDEF: name = "VERDEF"; break;
1316 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1317 case DT_VERNEED: name = "VERNEED"; break;
1318 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1319 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1320 case DT_USED: name = "USED"; break;
1321 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1322 case DT_GNU_HASH: name = "GNU_HASH"; break;
1325 fprintf (f, " %-20s ", name);
1329 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1334 unsigned int tagv = dyn.d_un.d_val;
1336 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1339 fprintf (f, "%s", string);
1348 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1349 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1351 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1355 if (elf_dynverdef (abfd) != 0)
1357 Elf_Internal_Verdef *t;
1359 fprintf (f, _("\nVersion definitions:\n"));
1360 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1362 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1363 t->vd_flags, t->vd_hash,
1364 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1365 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1367 Elf_Internal_Verdaux *a;
1370 for (a = t->vd_auxptr->vda_nextptr;
1374 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1380 if (elf_dynverref (abfd) != 0)
1382 Elf_Internal_Verneed *t;
1384 fprintf (f, _("\nVersion References:\n"));
1385 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1387 Elf_Internal_Vernaux *a;
1389 fprintf (f, _(" required from %s:\n"),
1390 t->vn_filename ? t->vn_filename : "<corrupt>");
1391 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1392 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1393 a->vna_flags, a->vna_other,
1394 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1406 /* Display ELF-specific fields of a symbol. */
1409 bfd_elf_print_symbol (bfd *abfd,
1412 bfd_print_symbol_type how)
1414 FILE *file = (FILE *) filep;
1417 case bfd_print_symbol_name:
1418 fprintf (file, "%s", symbol->name);
1420 case bfd_print_symbol_more:
1421 fprintf (file, "elf ");
1422 bfd_fprintf_vma (abfd, file, symbol->value);
1423 fprintf (file, " %lx", (unsigned long) symbol->flags);
1425 case bfd_print_symbol_all:
1427 const char *section_name;
1428 const char *name = NULL;
1429 const struct elf_backend_data *bed;
1430 unsigned char st_other;
1433 section_name = symbol->section ? symbol->section->name : "(*none*)";
1435 bed = get_elf_backend_data (abfd);
1436 if (bed->elf_backend_print_symbol_all)
1437 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1441 name = symbol->name;
1442 bfd_print_symbol_vandf (abfd, file, symbol);
1445 fprintf (file, " %s\t", section_name);
1446 /* Print the "other" value for a symbol. For common symbols,
1447 we've already printed the size; now print the alignment.
1448 For other symbols, we have no specified alignment, and
1449 we've printed the address; now print the size. */
1450 if (symbol->section && bfd_is_com_section (symbol->section))
1451 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1453 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1454 bfd_fprintf_vma (abfd, file, val);
1456 /* If we have version information, print it. */
1457 if (elf_tdata (abfd)->dynversym_section != 0
1458 && (elf_tdata (abfd)->dynverdef_section != 0
1459 || elf_tdata (abfd)->dynverref_section != 0))
1461 unsigned int vernum;
1462 const char *version_string;
1464 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1467 version_string = "";
1468 else if (vernum == 1)
1469 version_string = "Base";
1470 else if (vernum <= elf_tdata (abfd)->cverdefs)
1472 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1475 Elf_Internal_Verneed *t;
1477 version_string = "";
1478 for (t = elf_tdata (abfd)->verref;
1482 Elf_Internal_Vernaux *a;
1484 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1486 if (a->vna_other == vernum)
1488 version_string = a->vna_nodename;
1495 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1496 fprintf (file, " %-11s", version_string);
1501 fprintf (file, " (%s)", version_string);
1502 for (i = 10 - strlen (version_string); i > 0; --i)
1507 /* If the st_other field is not zero, print it. */
1508 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1513 case STV_INTERNAL: fprintf (file, " .internal"); break;
1514 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1515 case STV_PROTECTED: fprintf (file, " .protected"); break;
1517 /* Some other non-defined flags are also present, so print
1519 fprintf (file, " 0x%02x", (unsigned int) st_other);
1522 fprintf (file, " %s", name);
1528 /* Allocate an ELF string table--force the first byte to be zero. */
1530 struct bfd_strtab_hash *
1531 _bfd_elf_stringtab_init (void)
1533 struct bfd_strtab_hash *ret;
1535 ret = _bfd_stringtab_init ();
1540 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1541 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1542 if (loc == (bfd_size_type) -1)
1544 _bfd_stringtab_free (ret);
1551 /* ELF .o/exec file reading */
1553 /* Create a new bfd section from an ELF section header. */
1556 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1558 Elf_Internal_Shdr *hdr;
1559 Elf_Internal_Ehdr *ehdr;
1560 const struct elf_backend_data *bed;
1563 if (shindex >= elf_numsections (abfd))
1566 hdr = elf_elfsections (abfd)[shindex];
1567 ehdr = elf_elfheader (abfd);
1568 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1573 bed = get_elf_backend_data (abfd);
1574 switch (hdr->sh_type)
1577 /* Inactive section. Throw it away. */
1580 case SHT_PROGBITS: /* Normal section with contents. */
1581 case SHT_NOBITS: /* .bss section. */
1582 case SHT_HASH: /* .hash section. */
1583 case SHT_NOTE: /* .note section. */
1584 case SHT_INIT_ARRAY: /* .init_array section. */
1585 case SHT_FINI_ARRAY: /* .fini_array section. */
1586 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1587 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1588 case SHT_GNU_HASH: /* .gnu.hash section. */
1589 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1591 case SHT_DYNAMIC: /* Dynamic linking information. */
1592 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1594 if (hdr->sh_link > elf_numsections (abfd))
1596 /* PR 10478: Accept Solaris binaries with a sh_link
1597 field set to SHN_BEFORE or SHN_AFTER. */
1598 switch (bfd_get_arch (abfd))
1601 case bfd_arch_sparc:
1602 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1603 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1605 /* Otherwise fall through. */
1610 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
1612 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1614 Elf_Internal_Shdr *dynsymhdr;
1616 /* The shared libraries distributed with hpux11 have a bogus
1617 sh_link field for the ".dynamic" section. Find the
1618 string table for the ".dynsym" section instead. */
1619 if (elf_dynsymtab (abfd) != 0)
1621 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1622 hdr->sh_link = dynsymhdr->sh_link;
1626 unsigned int i, num_sec;
1628 num_sec = elf_numsections (abfd);
1629 for (i = 1; i < num_sec; i++)
1631 dynsymhdr = elf_elfsections (abfd)[i];
1632 if (dynsymhdr->sh_type == SHT_DYNSYM)
1634 hdr->sh_link = dynsymhdr->sh_link;
1642 case SHT_SYMTAB: /* A symbol table */
1643 if (elf_onesymtab (abfd) == shindex)
1646 if (hdr->sh_entsize != bed->s->sizeof_sym)
1648 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
1650 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1651 elf_onesymtab (abfd) = shindex;
1652 elf_tdata (abfd)->symtab_hdr = *hdr;
1653 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1654 abfd->flags |= HAS_SYMS;
1656 /* Sometimes a shared object will map in the symbol table. If
1657 SHF_ALLOC is set, and this is a shared object, then we also
1658 treat this section as a BFD section. We can not base the
1659 decision purely on SHF_ALLOC, because that flag is sometimes
1660 set in a relocatable object file, which would confuse the
1662 if ((hdr->sh_flags & SHF_ALLOC) != 0
1663 && (abfd->flags & DYNAMIC) != 0
1664 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1668 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1669 can't read symbols without that section loaded as well. It
1670 is most likely specified by the next section header. */
1671 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1673 unsigned int i, num_sec;
1675 num_sec = elf_numsections (abfd);
1676 for (i = shindex + 1; i < num_sec; i++)
1678 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1679 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1680 && hdr2->sh_link == shindex)
1684 for (i = 1; i < shindex; i++)
1686 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1687 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1688 && hdr2->sh_link == shindex)
1692 return bfd_section_from_shdr (abfd, i);
1696 case SHT_DYNSYM: /* A dynamic symbol table */
1697 if (elf_dynsymtab (abfd) == shindex)
1700 if (hdr->sh_entsize != bed->s->sizeof_sym)
1702 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1703 elf_dynsymtab (abfd) = shindex;
1704 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1705 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1706 abfd->flags |= HAS_SYMS;
1708 /* Besides being a symbol table, we also treat this as a regular
1709 section, so that objcopy can handle it. */
1710 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1712 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1713 if (elf_symtab_shndx (abfd) == shindex)
1716 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1717 elf_symtab_shndx (abfd) = shindex;
1718 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1719 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1722 case SHT_STRTAB: /* A string table */
1723 if (hdr->bfd_section != NULL)
1725 if (ehdr->e_shstrndx == shindex)
1727 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1728 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1731 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1734 elf_tdata (abfd)->strtab_hdr = *hdr;
1735 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1738 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1741 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1742 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1743 elf_elfsections (abfd)[shindex] = hdr;
1744 /* We also treat this as a regular section, so that objcopy
1746 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1750 /* If the string table isn't one of the above, then treat it as a
1751 regular section. We need to scan all the headers to be sure,
1752 just in case this strtab section appeared before the above. */
1753 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1755 unsigned int i, num_sec;
1757 num_sec = elf_numsections (abfd);
1758 for (i = 1; i < num_sec; i++)
1760 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1761 if (hdr2->sh_link == shindex)
1763 /* Prevent endless recursion on broken objects. */
1766 if (! bfd_section_from_shdr (abfd, i))
1768 if (elf_onesymtab (abfd) == i)
1770 if (elf_dynsymtab (abfd) == i)
1771 goto dynsymtab_strtab;
1775 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1779 /* *These* do a lot of work -- but build no sections! */
1781 asection *target_sect;
1782 Elf_Internal_Shdr *hdr2, **p_hdr;
1783 unsigned int num_sec = elf_numsections (abfd);
1784 struct bfd_elf_section_data *esdt;
1788 != (bfd_size_type) (hdr->sh_type == SHT_REL
1789 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1792 /* Check for a bogus link to avoid crashing. */
1793 if (hdr->sh_link >= num_sec)
1795 ((*_bfd_error_handler)
1796 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1797 abfd, hdr->sh_link, name, shindex));
1798 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1802 /* For some incomprehensible reason Oracle distributes
1803 libraries for Solaris in which some of the objects have
1804 bogus sh_link fields. It would be nice if we could just
1805 reject them, but, unfortunately, some people need to use
1806 them. We scan through the section headers; if we find only
1807 one suitable symbol table, we clobber the sh_link to point
1808 to it. I hope this doesn't break anything.
1810 Don't do it on executable nor shared library. */
1811 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
1812 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1813 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1819 for (scan = 1; scan < num_sec; scan++)
1821 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1822 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1833 hdr->sh_link = found;
1836 /* Get the symbol table. */
1837 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1838 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1839 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1842 /* If this reloc section does not use the main symbol table we
1843 don't treat it as a reloc section. BFD can't adequately
1844 represent such a section, so at least for now, we don't
1845 try. We just present it as a normal section. We also
1846 can't use it as a reloc section if it points to the null
1847 section, an invalid section, another reloc section, or its
1848 sh_link points to the null section. */
1849 if (hdr->sh_link != elf_onesymtab (abfd)
1850 || hdr->sh_link == SHN_UNDEF
1851 || hdr->sh_info == SHN_UNDEF
1852 || hdr->sh_info >= num_sec
1853 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1854 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
1855 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1858 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1860 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1861 if (target_sect == NULL)
1864 esdt = elf_section_data (target_sect);
1865 if (hdr->sh_type == SHT_RELA)
1866 p_hdr = &esdt->rela.hdr;
1868 p_hdr = &esdt->rel.hdr;
1870 BFD_ASSERT (*p_hdr == NULL);
1871 amt = sizeof (*hdr2);
1872 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1877 elf_elfsections (abfd)[shindex] = hdr2;
1878 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1879 target_sect->flags |= SEC_RELOC;
1880 target_sect->relocation = NULL;
1881 target_sect->rel_filepos = hdr->sh_offset;
1882 /* In the section to which the relocations apply, mark whether
1883 its relocations are of the REL or RELA variety. */
1884 if (hdr->sh_size != 0)
1886 if (hdr->sh_type == SHT_RELA)
1887 target_sect->use_rela_p = 1;
1889 abfd->flags |= HAS_RELOC;
1893 case SHT_GNU_verdef:
1894 elf_dynverdef (abfd) = shindex;
1895 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1896 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1898 case SHT_GNU_versym:
1899 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1901 elf_dynversym (abfd) = shindex;
1902 elf_tdata (abfd)->dynversym_hdr = *hdr;
1903 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1905 case SHT_GNU_verneed:
1906 elf_dynverref (abfd) = shindex;
1907 elf_tdata (abfd)->dynverref_hdr = *hdr;
1908 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1914 if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
1916 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1918 if (hdr->contents != NULL)
1920 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1921 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
1924 if (idx->flags & GRP_COMDAT)
1925 hdr->bfd_section->flags
1926 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1928 /* We try to keep the same section order as it comes in. */
1930 while (--n_elt != 0)
1934 if (idx->shdr != NULL
1935 && (s = idx->shdr->bfd_section) != NULL
1936 && elf_next_in_group (s) != NULL)
1938 elf_next_in_group (hdr->bfd_section) = s;
1946 /* Possibly an attributes section. */
1947 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1948 || hdr->sh_type == bed->obj_attrs_section_type)
1950 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1952 _bfd_elf_parse_attributes (abfd, hdr);
1956 /* Check for any processor-specific section types. */
1957 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1960 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1962 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1963 /* FIXME: How to properly handle allocated section reserved
1964 for applications? */
1965 (*_bfd_error_handler)
1966 (_("%B: don't know how to handle allocated, application "
1967 "specific section `%s' [0x%8x]"),
1968 abfd, name, hdr->sh_type);
1970 /* Allow sections reserved for applications. */
1971 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1974 else if (hdr->sh_type >= SHT_LOPROC
1975 && hdr->sh_type <= SHT_HIPROC)
1976 /* FIXME: We should handle this section. */
1977 (*_bfd_error_handler)
1978 (_("%B: don't know how to handle processor specific section "
1980 abfd, name, hdr->sh_type);
1981 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
1983 /* Unrecognised OS-specific sections. */
1984 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1985 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1986 required to correctly process the section and the file should
1987 be rejected with an error message. */
1988 (*_bfd_error_handler)
1989 (_("%B: don't know how to handle OS specific section "
1991 abfd, name, hdr->sh_type);
1993 /* Otherwise it should be processed. */
1994 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1997 /* FIXME: We should handle this section. */
1998 (*_bfd_error_handler)
1999 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2000 abfd, name, hdr->sh_type);
2008 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2011 bfd_sym_from_r_symndx (struct sym_cache *cache,
2013 unsigned long r_symndx)
2015 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2017 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2019 Elf_Internal_Shdr *symtab_hdr;
2020 unsigned char esym[sizeof (Elf64_External_Sym)];
2021 Elf_External_Sym_Shndx eshndx;
2023 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2024 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2025 &cache->sym[ent], esym, &eshndx) == NULL)
2028 if (cache->abfd != abfd)
2030 memset (cache->indx, -1, sizeof (cache->indx));
2033 cache->indx[ent] = r_symndx;
2036 return &cache->sym[ent];
2039 /* Given an ELF section number, retrieve the corresponding BFD
2043 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2045 if (sec_index >= elf_numsections (abfd))
2047 return elf_elfsections (abfd)[sec_index]->bfd_section;
2050 static const struct bfd_elf_special_section special_sections_b[] =
2052 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2053 { NULL, 0, 0, 0, 0 }
2056 static const struct bfd_elf_special_section special_sections_c[] =
2058 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2059 { NULL, 0, 0, 0, 0 }
2062 static const struct bfd_elf_special_section special_sections_d[] =
2064 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2065 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2066 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2067 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2068 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2069 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2070 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2071 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2072 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2073 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2074 { NULL, 0, 0, 0, 0 }
2077 static const struct bfd_elf_special_section special_sections_f[] =
2079 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2080 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2081 { NULL, 0, 0, 0, 0 }
2084 static const struct bfd_elf_special_section special_sections_g[] =
2086 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2087 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE },
2088 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2089 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2090 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2091 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2092 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2093 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2094 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2095 { NULL, 0, 0, 0, 0 }
2098 static const struct bfd_elf_special_section special_sections_h[] =
2100 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2101 { NULL, 0, 0, 0, 0 }
2104 static const struct bfd_elf_special_section special_sections_i[] =
2106 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2107 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2108 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2109 { NULL, 0, 0, 0, 0 }
2112 static const struct bfd_elf_special_section special_sections_l[] =
2114 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2115 { NULL, 0, 0, 0, 0 }
2118 static const struct bfd_elf_special_section special_sections_n[] =
2120 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2121 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2122 { NULL, 0, 0, 0, 0 }
2125 static const struct bfd_elf_special_section special_sections_p[] =
2127 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2128 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2129 { NULL, 0, 0, 0, 0 }
2132 static const struct bfd_elf_special_section special_sections_r[] =
2134 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2135 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2136 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2137 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2138 { NULL, 0, 0, 0, 0 }
2141 static const struct bfd_elf_special_section special_sections_s[] =
2143 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2144 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2145 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2146 /* See struct bfd_elf_special_section declaration for the semantics of
2147 this special case where .prefix_length != strlen (.prefix). */
2148 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2149 { NULL, 0, 0, 0, 0 }
2152 static const struct bfd_elf_special_section special_sections_t[] =
2154 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2155 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2156 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2157 { NULL, 0, 0, 0, 0 }
2160 static const struct bfd_elf_special_section special_sections_z[] =
2162 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2163 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2164 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2165 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2166 { NULL, 0, 0, 0, 0 }
2169 static const struct bfd_elf_special_section * const special_sections[] =
2171 special_sections_b, /* 'b' */
2172 special_sections_c, /* 'c' */
2173 special_sections_d, /* 'd' */
2175 special_sections_f, /* 'f' */
2176 special_sections_g, /* 'g' */
2177 special_sections_h, /* 'h' */
2178 special_sections_i, /* 'i' */
2181 special_sections_l, /* 'l' */
2183 special_sections_n, /* 'n' */
2185 special_sections_p, /* 'p' */
2187 special_sections_r, /* 'r' */
2188 special_sections_s, /* 's' */
2189 special_sections_t, /* 't' */
2195 special_sections_z /* 'z' */
2198 const struct bfd_elf_special_section *
2199 _bfd_elf_get_special_section (const char *name,
2200 const struct bfd_elf_special_section *spec,
2206 len = strlen (name);
2208 for (i = 0; spec[i].prefix != NULL; i++)
2211 int prefix_len = spec[i].prefix_length;
2213 if (len < prefix_len)
2215 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2218 suffix_len = spec[i].suffix_length;
2219 if (suffix_len <= 0)
2221 if (name[prefix_len] != 0)
2223 if (suffix_len == 0)
2225 if (name[prefix_len] != '.'
2226 && (suffix_len == -2
2227 || (rela && spec[i].type == SHT_REL)))
2233 if (len < prefix_len + suffix_len)
2235 if (memcmp (name + len - suffix_len,
2236 spec[i].prefix + prefix_len,
2246 const struct bfd_elf_special_section *
2247 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2250 const struct bfd_elf_special_section *spec;
2251 const struct elf_backend_data *bed;
2253 /* See if this is one of the special sections. */
2254 if (sec->name == NULL)
2257 bed = get_elf_backend_data (abfd);
2258 spec = bed->special_sections;
2261 spec = _bfd_elf_get_special_section (sec->name,
2262 bed->special_sections,
2268 if (sec->name[0] != '.')
2271 i = sec->name[1] - 'b';
2272 if (i < 0 || i > 'z' - 'b')
2275 spec = special_sections[i];
2280 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2284 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2286 struct bfd_elf_section_data *sdata;
2287 const struct elf_backend_data *bed;
2288 const struct bfd_elf_special_section *ssect;
2290 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2293 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2297 sec->used_by_bfd = sdata;
2300 /* Indicate whether or not this section should use RELA relocations. */
2301 bed = get_elf_backend_data (abfd);
2302 sec->use_rela_p = bed->default_use_rela_p;
2304 /* When we read a file, we don't need to set ELF section type and
2305 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2306 anyway. We will set ELF section type and flags for all linker
2307 created sections. If user specifies BFD section flags, we will
2308 set ELF section type and flags based on BFD section flags in
2309 elf_fake_sections. Special handling for .init_array/.fini_array
2310 output sections since they may contain .ctors/.dtors input
2311 sections. We don't want _bfd_elf_init_private_section_data to
2312 copy ELF section type from .ctors/.dtors input sections. */
2313 if (abfd->direction != read_direction
2314 || (sec->flags & SEC_LINKER_CREATED) != 0)
2316 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2319 || (sec->flags & SEC_LINKER_CREATED) != 0
2320 || ssect->type == SHT_INIT_ARRAY
2321 || ssect->type == SHT_FINI_ARRAY))
2323 elf_section_type (sec) = ssect->type;
2324 elf_section_flags (sec) = ssect->attr;
2328 return _bfd_generic_new_section_hook (abfd, sec);
2331 /* Create a new bfd section from an ELF program header.
2333 Since program segments have no names, we generate a synthetic name
2334 of the form segment<NUM>, where NUM is generally the index in the
2335 program header table. For segments that are split (see below) we
2336 generate the names segment<NUM>a and segment<NUM>b.
2338 Note that some program segments may have a file size that is different than
2339 (less than) the memory size. All this means is that at execution the
2340 system must allocate the amount of memory specified by the memory size,
2341 but only initialize it with the first "file size" bytes read from the
2342 file. This would occur for example, with program segments consisting
2343 of combined data+bss.
2345 To handle the above situation, this routine generates TWO bfd sections
2346 for the single program segment. The first has the length specified by
2347 the file size of the segment, and the second has the length specified
2348 by the difference between the two sizes. In effect, the segment is split
2349 into its initialized and uninitialized parts.
2354 _bfd_elf_make_section_from_phdr (bfd *abfd,
2355 Elf_Internal_Phdr *hdr,
2357 const char *type_name)
2365 split = ((hdr->p_memsz > 0)
2366 && (hdr->p_filesz > 0)
2367 && (hdr->p_memsz > hdr->p_filesz));
2369 if (hdr->p_filesz > 0)
2371 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2372 len = strlen (namebuf) + 1;
2373 name = (char *) bfd_alloc (abfd, len);
2376 memcpy (name, namebuf, len);
2377 newsect = bfd_make_section (abfd, name);
2378 if (newsect == NULL)
2380 newsect->vma = hdr->p_vaddr;
2381 newsect->lma = hdr->p_paddr;
2382 newsect->size = hdr->p_filesz;
2383 newsect->filepos = hdr->p_offset;
2384 newsect->flags |= SEC_HAS_CONTENTS;
2385 newsect->alignment_power = bfd_log2 (hdr->p_align);
2386 if (hdr->p_type == PT_LOAD)
2388 newsect->flags |= SEC_ALLOC;
2389 newsect->flags |= SEC_LOAD;
2390 if (hdr->p_flags & PF_X)
2392 /* FIXME: all we known is that it has execute PERMISSION,
2394 newsect->flags |= SEC_CODE;
2397 if (!(hdr->p_flags & PF_W))
2399 newsect->flags |= SEC_READONLY;
2403 if (hdr->p_memsz > hdr->p_filesz)
2407 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2408 len = strlen (namebuf) + 1;
2409 name = (char *) bfd_alloc (abfd, len);
2412 memcpy (name, namebuf, len);
2413 newsect = bfd_make_section (abfd, name);
2414 if (newsect == NULL)
2416 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2417 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2418 newsect->size = hdr->p_memsz - hdr->p_filesz;
2419 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2420 align = newsect->vma & -newsect->vma;
2421 if (align == 0 || align > hdr->p_align)
2422 align = hdr->p_align;
2423 newsect->alignment_power = bfd_log2 (align);
2424 if (hdr->p_type == PT_LOAD)
2426 /* Hack for gdb. Segments that have not been modified do
2427 not have their contents written to a core file, on the
2428 assumption that a debugger can find the contents in the
2429 executable. We flag this case by setting the fake
2430 section size to zero. Note that "real" bss sections will
2431 always have their contents dumped to the core file. */
2432 if (bfd_get_format (abfd) == bfd_core)
2434 newsect->flags |= SEC_ALLOC;
2435 if (hdr->p_flags & PF_X)
2436 newsect->flags |= SEC_CODE;
2438 if (!(hdr->p_flags & PF_W))
2439 newsect->flags |= SEC_READONLY;
2446 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2448 const struct elf_backend_data *bed;
2450 switch (hdr->p_type)
2453 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2456 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2459 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2462 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2465 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2467 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2472 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2475 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2477 case PT_GNU_EH_FRAME:
2478 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2482 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2485 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2488 /* Check for any processor-specific program segment types. */
2489 bed = get_elf_backend_data (abfd);
2490 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2494 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2498 _bfd_elf_single_rel_hdr (asection *sec)
2500 if (elf_section_data (sec)->rel.hdr)
2502 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2503 return elf_section_data (sec)->rel.hdr;
2506 return elf_section_data (sec)->rela.hdr;
2509 /* Allocate and initialize a section-header for a new reloc section,
2510 containing relocations against ASECT. It is stored in RELDATA. If
2511 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2515 _bfd_elf_init_reloc_shdr (bfd *abfd,
2516 struct bfd_elf_section_reloc_data *reldata,
2518 bfd_boolean use_rela_p)
2520 Elf_Internal_Shdr *rel_hdr;
2522 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2525 amt = sizeof (Elf_Internal_Shdr);
2526 BFD_ASSERT (reldata->hdr == NULL);
2527 rel_hdr = bfd_zalloc (abfd, amt);
2528 reldata->hdr = rel_hdr;
2530 amt = sizeof ".rela" + strlen (asect->name);
2531 name = (char *) bfd_alloc (abfd, amt);
2534 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2536 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2538 if (rel_hdr->sh_name == (unsigned int) -1)
2540 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2541 rel_hdr->sh_entsize = (use_rela_p
2542 ? bed->s->sizeof_rela
2543 : bed->s->sizeof_rel);
2544 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2545 rel_hdr->sh_flags = 0;
2546 rel_hdr->sh_addr = 0;
2547 rel_hdr->sh_size = 0;
2548 rel_hdr->sh_offset = 0;
2553 /* Return the default section type based on the passed in section flags. */
2556 bfd_elf_get_default_section_type (flagword flags)
2558 if ((flags & SEC_ALLOC) != 0
2559 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2561 return SHT_PROGBITS;
2564 struct fake_section_arg
2566 struct bfd_link_info *link_info;
2570 /* Set up an ELF internal section header for a section. */
2573 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
2575 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
2576 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2577 struct bfd_elf_section_data *esd = elf_section_data (asect);
2578 Elf_Internal_Shdr *this_hdr;
2579 unsigned int sh_type;
2583 /* We already failed; just get out of the bfd_map_over_sections
2588 this_hdr = &esd->this_hdr;
2590 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2591 asect->name, FALSE);
2592 if (this_hdr->sh_name == (unsigned int) -1)
2598 /* Don't clear sh_flags. Assembler may set additional bits. */
2600 if ((asect->flags & SEC_ALLOC) != 0
2601 || asect->user_set_vma)
2602 this_hdr->sh_addr = asect->vma;
2604 this_hdr->sh_addr = 0;
2606 this_hdr->sh_offset = 0;
2607 this_hdr->sh_size = asect->size;
2608 this_hdr->sh_link = 0;
2609 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2610 /* The sh_entsize and sh_info fields may have been set already by
2611 copy_private_section_data. */
2613 this_hdr->bfd_section = asect;
2614 this_hdr->contents = NULL;
2616 /* If the section type is unspecified, we set it based on
2618 if ((asect->flags & SEC_GROUP) != 0)
2619 sh_type = SHT_GROUP;
2621 sh_type = bfd_elf_get_default_section_type (asect->flags);
2623 if (this_hdr->sh_type == SHT_NULL)
2624 this_hdr->sh_type = sh_type;
2625 else if (this_hdr->sh_type == SHT_NOBITS
2626 && sh_type == SHT_PROGBITS
2627 && (asect->flags & SEC_ALLOC) != 0)
2629 /* Warn if we are changing a NOBITS section to PROGBITS, but
2630 allow the link to proceed. This can happen when users link
2631 non-bss input sections to bss output sections, or emit data
2632 to a bss output section via a linker script. */
2633 (*_bfd_error_handler)
2634 (_("warning: section `%A' type changed to PROGBITS"), asect);
2635 this_hdr->sh_type = sh_type;
2638 switch (this_hdr->sh_type)
2644 case SHT_INIT_ARRAY:
2645 case SHT_FINI_ARRAY:
2646 case SHT_PREINIT_ARRAY:
2653 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2657 this_hdr->sh_entsize = bed->s->sizeof_sym;
2661 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2665 if (get_elf_backend_data (abfd)->may_use_rela_p)
2666 this_hdr->sh_entsize = bed->s->sizeof_rela;
2670 if (get_elf_backend_data (abfd)->may_use_rel_p)
2671 this_hdr->sh_entsize = bed->s->sizeof_rel;
2674 case SHT_GNU_versym:
2675 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2678 case SHT_GNU_verdef:
2679 this_hdr->sh_entsize = 0;
2680 /* objcopy or strip will copy over sh_info, but may not set
2681 cverdefs. The linker will set cverdefs, but sh_info will be
2683 if (this_hdr->sh_info == 0)
2684 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2686 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2687 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2690 case SHT_GNU_verneed:
2691 this_hdr->sh_entsize = 0;
2692 /* objcopy or strip will copy over sh_info, but may not set
2693 cverrefs. The linker will set cverrefs, but sh_info will be
2695 if (this_hdr->sh_info == 0)
2696 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2698 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2699 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2703 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2707 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2711 if ((asect->flags & SEC_ALLOC) != 0)
2712 this_hdr->sh_flags |= SHF_ALLOC;
2713 if ((asect->flags & SEC_READONLY) == 0)
2714 this_hdr->sh_flags |= SHF_WRITE;
2715 if ((asect->flags & SEC_CODE) != 0)
2716 this_hdr->sh_flags |= SHF_EXECINSTR;
2717 if ((asect->flags & SEC_MERGE) != 0)
2719 this_hdr->sh_flags |= SHF_MERGE;
2720 this_hdr->sh_entsize = asect->entsize;
2721 if ((asect->flags & SEC_STRINGS) != 0)
2722 this_hdr->sh_flags |= SHF_STRINGS;
2724 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2725 this_hdr->sh_flags |= SHF_GROUP;
2726 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2728 this_hdr->sh_flags |= SHF_TLS;
2729 if (asect->size == 0
2730 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2732 struct bfd_link_order *o = asect->map_tail.link_order;
2734 this_hdr->sh_size = 0;
2737 this_hdr->sh_size = o->offset + o->size;
2738 if (this_hdr->sh_size != 0)
2739 this_hdr->sh_type = SHT_NOBITS;
2743 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2744 this_hdr->sh_flags |= SHF_EXCLUDE;
2746 /* If the section has relocs, set up a section header for the
2747 SHT_REL[A] section. If two relocation sections are required for
2748 this section, it is up to the processor-specific back-end to
2749 create the other. */
2750 if ((asect->flags & SEC_RELOC) != 0)
2752 /* When doing a relocatable link, create both REL and RELA sections if
2755 /* Do the normal setup if we wouldn't create any sections here. */
2756 && esd->rel.count + esd->rela.count > 0
2757 && (arg->link_info->relocatable || arg->link_info->emitrelocations))
2759 if (esd->rel.count && esd->rel.hdr == NULL
2760 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
2765 if (esd->rela.count && esd->rela.hdr == NULL
2766 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
2772 else if (!_bfd_elf_init_reloc_shdr (abfd,
2774 ? &esd->rela : &esd->rel),
2780 /* Check for processor-specific section types. */
2781 sh_type = this_hdr->sh_type;
2782 if (bed->elf_backend_fake_sections
2783 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2786 if (sh_type == SHT_NOBITS && asect->size != 0)
2788 /* Don't change the header type from NOBITS if we are being
2789 called for objcopy --only-keep-debug. */
2790 this_hdr->sh_type = sh_type;
2794 /* Fill in the contents of a SHT_GROUP section. Called from
2795 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2796 when ELF targets use the generic linker, ld. Called for ld -r
2797 from bfd_elf_final_link. */
2800 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2802 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2803 asection *elt, *first;
2807 /* Ignore linker created group section. See elfNN_ia64_object_p in
2809 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2813 if (elf_section_data (sec)->this_hdr.sh_info == 0)
2815 unsigned long symindx = 0;
2817 /* elf_group_id will have been set up by objcopy and the
2819 if (elf_group_id (sec) != NULL)
2820 symindx = elf_group_id (sec)->udata.i;
2824 /* If called from the assembler, swap_out_syms will have set up
2825 elf_section_syms. */
2826 BFD_ASSERT (elf_section_syms (abfd) != NULL);
2827 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2829 elf_section_data (sec)->this_hdr.sh_info = symindx;
2831 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2833 /* The ELF backend linker sets sh_info to -2 when the group
2834 signature symbol is global, and thus the index can't be
2835 set until all local symbols are output. */
2836 asection *igroup = elf_sec_group (elf_next_in_group (sec));
2837 struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2838 unsigned long symndx = sec_data->this_hdr.sh_info;
2839 unsigned long extsymoff = 0;
2840 struct elf_link_hash_entry *h;
2842 if (!elf_bad_symtab (igroup->owner))
2844 Elf_Internal_Shdr *symtab_hdr;
2846 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2847 extsymoff = symtab_hdr->sh_info;
2849 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2850 while (h->root.type == bfd_link_hash_indirect
2851 || h->root.type == bfd_link_hash_warning)
2852 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2854 elf_section_data (sec)->this_hdr.sh_info = h->indx;
2857 /* The contents won't be allocated for "ld -r" or objcopy. */
2859 if (sec->contents == NULL)
2862 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
2864 /* Arrange for the section to be written out. */
2865 elf_section_data (sec)->this_hdr.contents = sec->contents;
2866 if (sec->contents == NULL)
2873 loc = sec->contents + sec->size;
2875 /* Get the pointer to the first section in the group that gas
2876 squirreled away here. objcopy arranges for this to be set to the
2877 start of the input section group. */
2878 first = elt = elf_next_in_group (sec);
2880 /* First element is a flag word. Rest of section is elf section
2881 indices for all the sections of the group. Write them backwards
2882 just to keep the group in the same order as given in .section
2883 directives, not that it matters. */
2890 s = s->output_section;
2892 && !bfd_is_abs_section (s))
2894 unsigned int idx = elf_section_data (s)->this_idx;
2897 H_PUT_32 (abfd, idx, loc);
2899 elt = elf_next_in_group (elt);
2904 if ((loc -= 4) != sec->contents)
2907 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2910 /* Assign all ELF section numbers. The dummy first section is handled here
2911 too. The link/info pointers for the standard section types are filled
2912 in here too, while we're at it. */
2915 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2917 struct elf_obj_tdata *t = elf_tdata (abfd);
2919 unsigned int section_number, secn;
2920 Elf_Internal_Shdr **i_shdrp;
2921 struct bfd_elf_section_data *d;
2922 bfd_boolean need_symtab;
2926 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2928 /* SHT_GROUP sections are in relocatable files only. */
2929 if (link_info == NULL || link_info->relocatable)
2931 /* Put SHT_GROUP sections first. */
2932 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2934 d = elf_section_data (sec);
2936 if (d->this_hdr.sh_type == SHT_GROUP)
2938 if (sec->flags & SEC_LINKER_CREATED)
2940 /* Remove the linker created SHT_GROUP sections. */
2941 bfd_section_list_remove (abfd, sec);
2942 abfd->section_count--;
2945 d->this_idx = section_number++;
2950 for (sec = abfd->sections; sec; sec = sec->next)
2952 d = elf_section_data (sec);
2954 if (d->this_hdr.sh_type != SHT_GROUP)
2955 d->this_idx = section_number++;
2956 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2959 d->rel.idx = section_number++;
2960 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2967 d->rela.idx = section_number++;
2968 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2974 t->shstrtab_section = section_number++;
2975 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2976 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2978 need_symtab = (bfd_get_symcount (abfd) > 0
2979 || (link_info == NULL
2980 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2984 t->symtab_section = section_number++;
2985 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2986 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2988 t->symtab_shndx_section = section_number++;
2989 t->symtab_shndx_hdr.sh_name
2990 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2991 ".symtab_shndx", FALSE);
2992 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2995 t->strtab_section = section_number++;
2996 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2999 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3000 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3002 elf_numsections (abfd) = section_number;
3003 elf_elfheader (abfd)->e_shnum = section_number;
3005 /* Set up the list of section header pointers, in agreement with the
3007 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3008 sizeof (Elf_Internal_Shdr *));
3009 if (i_shdrp == NULL)
3012 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3013 sizeof (Elf_Internal_Shdr));
3014 if (i_shdrp[0] == NULL)
3016 bfd_release (abfd, i_shdrp);
3020 elf_elfsections (abfd) = i_shdrp;
3022 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3025 i_shdrp[t->symtab_section] = &t->symtab_hdr;
3026 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3028 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3029 t->symtab_shndx_hdr.sh_link = t->symtab_section;
3031 i_shdrp[t->strtab_section] = &t->strtab_hdr;
3032 t->symtab_hdr.sh_link = t->strtab_section;
3035 for (sec = abfd->sections; sec; sec = sec->next)
3040 d = elf_section_data (sec);
3042 i_shdrp[d->this_idx] = &d->this_hdr;
3043 if (d->rel.idx != 0)
3044 i_shdrp[d->rel.idx] = d->rel.hdr;
3045 if (d->rela.idx != 0)
3046 i_shdrp[d->rela.idx] = d->rela.hdr;
3048 /* Fill in the sh_link and sh_info fields while we're at it. */
3050 /* sh_link of a reloc section is the section index of the symbol
3051 table. sh_info is the section index of the section to which
3052 the relocation entries apply. */
3053 if (d->rel.idx != 0)
3055 d->rel.hdr->sh_link = t->symtab_section;
3056 d->rel.hdr->sh_info = d->this_idx;
3058 if (d->rela.idx != 0)
3060 d->rela.hdr->sh_link = t->symtab_section;
3061 d->rela.hdr->sh_info = d->this_idx;
3064 /* We need to set up sh_link for SHF_LINK_ORDER. */
3065 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3067 s = elf_linked_to_section (sec);
3070 /* elf_linked_to_section points to the input section. */
3071 if (link_info != NULL)
3073 /* Check discarded linkonce section. */
3074 if (elf_discarded_section (s))
3077 (*_bfd_error_handler)
3078 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3079 abfd, d->this_hdr.bfd_section,
3081 /* Point to the kept section if it has the same
3082 size as the discarded one. */
3083 kept = _bfd_elf_check_kept_section (s, link_info);
3086 bfd_set_error (bfd_error_bad_value);
3092 s = s->output_section;
3093 BFD_ASSERT (s != NULL);
3097 /* Handle objcopy. */
3098 if (s->output_section == NULL)
3100 (*_bfd_error_handler)
3101 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3102 abfd, d->this_hdr.bfd_section, s, s->owner);
3103 bfd_set_error (bfd_error_bad_value);
3106 s = s->output_section;
3108 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3113 The Intel C compiler generates SHT_IA_64_UNWIND with
3114 SHF_LINK_ORDER. But it doesn't set the sh_link or
3115 sh_info fields. Hence we could get the situation
3117 const struct elf_backend_data *bed
3118 = get_elf_backend_data (abfd);
3119 if (bed->link_order_error_handler)
3120 bed->link_order_error_handler
3121 (_("%B: warning: sh_link not set for section `%A'"),
3126 switch (d->this_hdr.sh_type)
3130 /* A reloc section which we are treating as a normal BFD
3131 section. sh_link is the section index of the symbol
3132 table. sh_info is the section index of the section to
3133 which the relocation entries apply. We assume that an
3134 allocated reloc section uses the dynamic symbol table.
3135 FIXME: How can we be sure? */
3136 s = bfd_get_section_by_name (abfd, ".dynsym");
3138 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3140 /* We look up the section the relocs apply to by name. */
3142 if (d->this_hdr.sh_type == SHT_REL)
3146 s = bfd_get_section_by_name (abfd, name);
3148 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3152 /* We assume that a section named .stab*str is a stabs
3153 string section. We look for a section with the same name
3154 but without the trailing ``str'', and set its sh_link
3155 field to point to this section. */
3156 if (CONST_STRNEQ (sec->name, ".stab")
3157 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3162 len = strlen (sec->name);
3163 alc = (char *) bfd_malloc (len - 2);
3166 memcpy (alc, sec->name, len - 3);
3167 alc[len - 3] = '\0';
3168 s = bfd_get_section_by_name (abfd, alc);
3172 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3174 /* This is a .stab section. */
3175 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3176 elf_section_data (s)->this_hdr.sh_entsize
3177 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3184 case SHT_GNU_verneed:
3185 case SHT_GNU_verdef:
3186 /* sh_link is the section header index of the string table
3187 used for the dynamic entries, or the symbol table, or the
3189 s = bfd_get_section_by_name (abfd, ".dynstr");
3191 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3194 case SHT_GNU_LIBLIST:
3195 /* sh_link is the section header index of the prelink library
3196 list used for the dynamic entries, or the symbol table, or
3197 the version strings. */
3198 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3199 ? ".dynstr" : ".gnu.libstr");
3201 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3206 case SHT_GNU_versym:
3207 /* sh_link is the section header index of the symbol table
3208 this hash table or version table is for. */
3209 s = bfd_get_section_by_name (abfd, ".dynsym");
3211 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3215 d->this_hdr.sh_link = t->symtab_section;
3219 for (secn = 1; secn < section_number; ++secn)
3220 if (i_shdrp[secn] == NULL)
3221 i_shdrp[secn] = i_shdrp[0];
3223 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3224 i_shdrp[secn]->sh_name);
3228 /* Map symbol from it's internal number to the external number, moving
3229 all local symbols to be at the head of the list. */
3232 sym_is_global (bfd *abfd, asymbol *sym)
3234 /* If the backend has a special mapping, use it. */
3235 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3236 if (bed->elf_backend_sym_is_global)
3237 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3239 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3240 || bfd_is_und_section (bfd_get_section (sym))
3241 || bfd_is_com_section (bfd_get_section (sym)));
3244 /* Don't output section symbols for sections that are not going to be
3248 ignore_section_sym (bfd *abfd, asymbol *sym)
3250 return ((sym->flags & BSF_SECTION_SYM) != 0
3251 && !(sym->section->owner == abfd
3252 || (sym->section->output_section->owner == abfd
3253 && sym->section->output_offset == 0)));
3257 elf_map_symbols (bfd *abfd)
3259 unsigned int symcount = bfd_get_symcount (abfd);
3260 asymbol **syms = bfd_get_outsymbols (abfd);
3261 asymbol **sect_syms;
3262 unsigned int num_locals = 0;
3263 unsigned int num_globals = 0;
3264 unsigned int num_locals2 = 0;
3265 unsigned int num_globals2 = 0;
3272 fprintf (stderr, "elf_map_symbols\n");
3276 for (asect = abfd->sections; asect; asect = asect->next)
3278 if (max_index < asect->index)
3279 max_index = asect->index;
3283 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3284 if (sect_syms == NULL)
3286 elf_section_syms (abfd) = sect_syms;
3287 elf_num_section_syms (abfd) = max_index;
3289 /* Init sect_syms entries for any section symbols we have already
3290 decided to output. */
3291 for (idx = 0; idx < symcount; idx++)
3293 asymbol *sym = syms[idx];
3295 if ((sym->flags & BSF_SECTION_SYM) != 0
3297 && !ignore_section_sym (abfd, sym))
3299 asection *sec = sym->section;
3301 if (sec->owner != abfd)
3302 sec = sec->output_section;
3304 sect_syms[sec->index] = syms[idx];
3308 /* Classify all of the symbols. */
3309 for (idx = 0; idx < symcount; idx++)
3311 if (ignore_section_sym (abfd, syms[idx]))
3313 if (!sym_is_global (abfd, syms[idx]))
3319 /* We will be adding a section symbol for each normal BFD section. Most
3320 sections will already have a section symbol in outsymbols, but
3321 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3322 at least in that case. */
3323 for (asect = abfd->sections; asect; asect = asect->next)
3325 if (sect_syms[asect->index] == NULL)
3327 if (!sym_is_global (abfd, asect->symbol))
3334 /* Now sort the symbols so the local symbols are first. */
3335 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3336 sizeof (asymbol *));
3338 if (new_syms == NULL)
3341 for (idx = 0; idx < symcount; idx++)
3343 asymbol *sym = syms[idx];
3346 if (ignore_section_sym (abfd, sym))
3348 if (!sym_is_global (abfd, sym))
3351 i = num_locals + num_globals2++;
3353 sym->udata.i = i + 1;
3355 for (asect = abfd->sections; asect; asect = asect->next)
3357 if (sect_syms[asect->index] == NULL)
3359 asymbol *sym = asect->symbol;
3362 sect_syms[asect->index] = sym;
3363 if (!sym_is_global (abfd, sym))
3366 i = num_locals + num_globals2++;
3368 sym->udata.i = i + 1;
3372 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3374 elf_num_locals (abfd) = num_locals;
3375 elf_num_globals (abfd) = num_globals;
3379 /* Align to the maximum file alignment that could be required for any
3380 ELF data structure. */
3382 static inline file_ptr
3383 align_file_position (file_ptr off, int align)
3385 return (off + align - 1) & ~(align - 1);
3388 /* Assign a file position to a section, optionally aligning to the
3389 required section alignment. */
3392 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3396 if (align && i_shdrp->sh_addralign > 1)
3397 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3398 i_shdrp->sh_offset = offset;
3399 if (i_shdrp->bfd_section != NULL)
3400 i_shdrp->bfd_section->filepos = offset;
3401 if (i_shdrp->sh_type != SHT_NOBITS)
3402 offset += i_shdrp->sh_size;
3406 /* Compute the file positions we are going to put the sections at, and
3407 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3408 is not NULL, this is being called by the ELF backend linker. */
3411 _bfd_elf_compute_section_file_positions (bfd *abfd,
3412 struct bfd_link_info *link_info)
3414 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3415 struct fake_section_arg fsargs;
3417 struct bfd_strtab_hash *strtab = NULL;
3418 Elf_Internal_Shdr *shstrtab_hdr;
3419 bfd_boolean need_symtab;
3421 if (abfd->output_has_begun)
3424 /* Do any elf backend specific processing first. */
3425 if (bed->elf_backend_begin_write_processing)
3426 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3428 if (! prep_headers (abfd))
3431 /* Post process the headers if necessary. */
3432 if (bed->elf_backend_post_process_headers)
3433 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3435 fsargs.failed = FALSE;
3436 fsargs.link_info = link_info;
3437 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
3441 if (!assign_section_numbers (abfd, link_info))
3444 /* The backend linker builds symbol table information itself. */
3445 need_symtab = (link_info == NULL
3446 && (bfd_get_symcount (abfd) > 0
3447 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3451 /* Non-zero if doing a relocatable link. */
3452 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3454 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3459 if (link_info == NULL)
3461 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3466 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3467 /* sh_name was set in prep_headers. */
3468 shstrtab_hdr->sh_type = SHT_STRTAB;
3469 shstrtab_hdr->sh_flags = 0;
3470 shstrtab_hdr->sh_addr = 0;
3471 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3472 shstrtab_hdr->sh_entsize = 0;
3473 shstrtab_hdr->sh_link = 0;
3474 shstrtab_hdr->sh_info = 0;
3475 /* sh_offset is set in assign_file_positions_except_relocs. */
3476 shstrtab_hdr->sh_addralign = 1;
3478 if (!assign_file_positions_except_relocs (abfd, link_info))
3484 Elf_Internal_Shdr *hdr;
3486 off = elf_tdata (abfd)->next_file_pos;
3488 hdr = &elf_tdata (abfd)->symtab_hdr;
3489 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3491 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3492 if (hdr->sh_size != 0)
3493 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3495 hdr = &elf_tdata (abfd)->strtab_hdr;
3496 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3498 elf_tdata (abfd)->next_file_pos = off;
3500 /* Now that we know where the .strtab section goes, write it
3502 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3503 || ! _bfd_stringtab_emit (abfd, strtab))
3505 _bfd_stringtab_free (strtab);
3508 abfd->output_has_begun = TRUE;
3513 /* Make an initial estimate of the size of the program header. If we
3514 get the number wrong here, we'll redo section placement. */
3516 static bfd_size_type
3517 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3521 const struct elf_backend_data *bed;
3523 /* Assume we will need exactly two PT_LOAD segments: one for text
3524 and one for data. */
3527 s = bfd_get_section_by_name (abfd, ".interp");
3528 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3530 /* If we have a loadable interpreter section, we need a
3531 PT_INTERP segment. In this case, assume we also need a
3532 PT_PHDR segment, although that may not be true for all
3537 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3539 /* We need a PT_DYNAMIC segment. */
3543 if (info != NULL && info->relro)
3545 /* We need a PT_GNU_RELRO segment. */
3549 if (elf_tdata (abfd)->eh_frame_hdr)
3551 /* We need a PT_GNU_EH_FRAME segment. */
3555 if (elf_tdata (abfd)->stack_flags)
3557 /* We need a PT_GNU_STACK segment. */
3561 for (s = abfd->sections; s != NULL; s = s->next)
3563 if ((s->flags & SEC_LOAD) != 0
3564 && CONST_STRNEQ (s->name, ".note"))
3566 /* We need a PT_NOTE segment. */
3568 /* Try to create just one PT_NOTE segment
3569 for all adjacent loadable .note* sections.
3570 gABI requires that within a PT_NOTE segment
3571 (and also inside of each SHT_NOTE section)
3572 each note is padded to a multiple of 4 size,
3573 so we check whether the sections are correctly
3575 if (s->alignment_power == 2)
3576 while (s->next != NULL
3577 && s->next->alignment_power == 2
3578 && (s->next->flags & SEC_LOAD) != 0
3579 && CONST_STRNEQ (s->next->name, ".note"))
3584 for (s = abfd->sections; s != NULL; s = s->next)
3586 if (s->flags & SEC_THREAD_LOCAL)
3588 /* We need a PT_TLS segment. */
3594 /* Let the backend count up any program headers it might need. */
3595 bed = get_elf_backend_data (abfd);
3596 if (bed->elf_backend_additional_program_headers)
3600 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3606 return segs * bed->s->sizeof_phdr;
3609 /* Find the segment that contains the output_section of section. */
3612 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3614 struct elf_segment_map *m;
3615 Elf_Internal_Phdr *p;
3617 for (m = elf_tdata (abfd)->segment_map,
3618 p = elf_tdata (abfd)->phdr;
3624 for (i = m->count - 1; i >= 0; i--)
3625 if (m->sections[i] == section)
3632 /* Create a mapping from a set of sections to a program segment. */
3634 static struct elf_segment_map *
3635 make_mapping (bfd *abfd,
3636 asection **sections,
3641 struct elf_segment_map *m;
3646 amt = sizeof (struct elf_segment_map);
3647 amt += (to - from - 1) * sizeof (asection *);
3648 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3652 m->p_type = PT_LOAD;
3653 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3654 m->sections[i - from] = *hdrpp;
3655 m->count = to - from;
3657 if (from == 0 && phdr)
3659 /* Include the headers in the first PT_LOAD segment. */
3660 m->includes_filehdr = 1;
3661 m->includes_phdrs = 1;
3667 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3670 struct elf_segment_map *
3671 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3673 struct elf_segment_map *m;
3675 m = (struct elf_segment_map *) bfd_zalloc (abfd,
3676 sizeof (struct elf_segment_map));
3680 m->p_type = PT_DYNAMIC;
3682 m->sections[0] = dynsec;
3687 /* Possibly add or remove segments from the segment map. */
3690 elf_modify_segment_map (bfd *abfd,
3691 struct bfd_link_info *info,
3692 bfd_boolean remove_empty_load)
3694 struct elf_segment_map **m;
3695 const struct elf_backend_data *bed;
3697 /* The placement algorithm assumes that non allocated sections are
3698 not in PT_LOAD segments. We ensure this here by removing such
3699 sections from the segment map. We also remove excluded
3700 sections. Finally, any PT_LOAD segment without sections is
3702 m = &elf_tdata (abfd)->segment_map;
3705 unsigned int i, new_count;
3707 for (new_count = 0, i = 0; i < (*m)->count; i++)
3709 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3710 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3711 || (*m)->p_type != PT_LOAD))
3713 (*m)->sections[new_count] = (*m)->sections[i];
3717 (*m)->count = new_count;
3719 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3725 bed = get_elf_backend_data (abfd);
3726 if (bed->elf_backend_modify_segment_map != NULL)
3728 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3735 /* Set up a mapping from BFD sections to program segments. */
3738 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3741 struct elf_segment_map *m;
3742 asection **sections = NULL;
3743 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3744 bfd_boolean no_user_phdrs;
3746 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3747 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3751 struct elf_segment_map *mfirst;
3752 struct elf_segment_map **pm;
3755 unsigned int phdr_index;
3756 bfd_vma maxpagesize;
3758 bfd_boolean phdr_in_segment = TRUE;
3759 bfd_boolean writable;
3761 asection *first_tls = NULL;
3762 asection *dynsec, *eh_frame_hdr;
3764 bfd_vma addr_mask, wrap_to = 0;
3766 /* Select the allocated sections, and sort them. */
3768 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3769 sizeof (asection *));
3770 if (sections == NULL)
3773 /* Calculate top address, avoiding undefined behaviour of shift
3774 left operator when shift count is equal to size of type
3776 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
3777 addr_mask = (addr_mask << 1) + 1;
3780 for (s = abfd->sections; s != NULL; s = s->next)
3782 if ((s->flags & SEC_ALLOC) != 0)
3786 /* A wrapping section potentially clashes with header. */
3787 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
3788 wrap_to = (s->lma + s->size) & addr_mask;
3791 BFD_ASSERT (i <= bfd_count_sections (abfd));
3794 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3796 /* Build the mapping. */
3801 /* If we have a .interp section, then create a PT_PHDR segment for
3802 the program headers and a PT_INTERP segment for the .interp
3804 s = bfd_get_section_by_name (abfd, ".interp");
3805 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3807 amt = sizeof (struct elf_segment_map);
3808 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3812 m->p_type = PT_PHDR;
3813 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3814 m->p_flags = PF_R | PF_X;
3815 m->p_flags_valid = 1;
3816 m->includes_phdrs = 1;
3821 amt = sizeof (struct elf_segment_map);
3822 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3826 m->p_type = PT_INTERP;
3834 /* Look through the sections. We put sections in the same program
3835 segment when the start of the second section can be placed within
3836 a few bytes of the end of the first section. */
3840 maxpagesize = bed->maxpagesize;
3842 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3844 && (dynsec->flags & SEC_LOAD) == 0)
3847 /* Deal with -Ttext or something similar such that the first section
3848 is not adjacent to the program headers. This is an
3849 approximation, since at this point we don't know exactly how many
3850 program headers we will need. */
3853 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3855 if (phdr_size == (bfd_size_type) -1)
3856 phdr_size = get_program_header_size (abfd, info);
3857 if ((abfd->flags & D_PAGED) == 0
3858 || (sections[0]->lma & addr_mask) < phdr_size
3859 || ((sections[0]->lma & addr_mask) % maxpagesize
3860 < phdr_size % maxpagesize)
3861 || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
3862 phdr_in_segment = FALSE;
3865 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3868 bfd_boolean new_segment;
3872 /* See if this section and the last one will fit in the same
3875 if (last_hdr == NULL)
3877 /* If we don't have a segment yet, then we don't need a new
3878 one (we build the last one after this loop). */
3879 new_segment = FALSE;
3881 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3883 /* If this section has a different relation between the
3884 virtual address and the load address, then we need a new
3888 else if (hdr->lma < last_hdr->lma + last_size
3889 || last_hdr->lma + last_size < last_hdr->lma)
3891 /* If this section has a load address that makes it overlap
3892 the previous section, then we need a new segment. */
3895 /* In the next test we have to be careful when last_hdr->lma is close
3896 to the end of the address space. If the aligned address wraps
3897 around to the start of the address space, then there are no more
3898 pages left in memory and it is OK to assume that the current
3899 section can be included in the current segment. */
3900 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3902 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3905 /* If putting this section in this segment would force us to
3906 skip a page in the segment, then we need a new segment. */
3909 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3910 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3912 /* We don't want to put a loadable section after a
3913 nonloadable section in the same segment.
3914 Consider .tbss sections as loadable for this purpose. */
3917 else if ((abfd->flags & D_PAGED) == 0)
3919 /* If the file is not demand paged, which means that we
3920 don't require the sections to be correctly aligned in the
3921 file, then there is no other reason for a new segment. */
3922 new_segment = FALSE;
3925 && (hdr->flags & SEC_READONLY) == 0
3926 && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3927 != (hdr->lma & -maxpagesize)))
3929 /* We don't want to put a writable section in a read only
3930 segment, unless they are on the same page in memory
3931 anyhow. We already know that the last section does not
3932 bring us past the current section on the page, so the
3933 only case in which the new section is not on the same
3934 page as the previous section is when the previous section
3935 ends precisely on a page boundary. */
3940 /* Otherwise, we can use the same segment. */
3941 new_segment = FALSE;
3944 /* Allow interested parties a chance to override our decision. */
3945 if (last_hdr != NULL
3947 && info->callbacks->override_segment_assignment != NULL)
3949 = info->callbacks->override_segment_assignment (info, abfd, hdr,
3955 if ((hdr->flags & SEC_READONLY) == 0)
3958 /* .tbss sections effectively have zero size. */
3959 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3960 != SEC_THREAD_LOCAL)
3961 last_size = hdr->size;
3967 /* We need a new program segment. We must create a new program
3968 header holding all the sections from phdr_index until hdr. */
3970 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3977 if ((hdr->flags & SEC_READONLY) == 0)
3983 /* .tbss sections effectively have zero size. */
3984 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3985 last_size = hdr->size;
3989 phdr_in_segment = FALSE;
3992 /* Create a final PT_LOAD program segment, but not if it's just
3994 if (last_hdr != NULL
3995 && (i - phdr_index != 1
3996 || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3997 != SEC_THREAD_LOCAL)))
3999 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4007 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4010 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4017 /* For each batch of consecutive loadable .note sections,
4018 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4019 because if we link together nonloadable .note sections and
4020 loadable .note sections, we will generate two .note sections
4021 in the output file. FIXME: Using names for section types is
4023 for (s = abfd->sections; s != NULL; s = s->next)
4025 if ((s->flags & SEC_LOAD) != 0
4026 && CONST_STRNEQ (s->name, ".note"))
4031 amt = sizeof (struct elf_segment_map);
4032 if (s->alignment_power == 2)
4033 for (s2 = s; s2->next != NULL; s2 = s2->next)
4035 if (s2->next->alignment_power == 2
4036 && (s2->next->flags & SEC_LOAD) != 0
4037 && CONST_STRNEQ (s2->next->name, ".note")
4038 && align_power (s2->lma + s2->size, 2)
4044 amt += (count - 1) * sizeof (asection *);
4045 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4049 m->p_type = PT_NOTE;
4053 m->sections[m->count - count--] = s;
4054 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4057 m->sections[m->count - 1] = s;
4058 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4062 if (s->flags & SEC_THREAD_LOCAL)
4070 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4073 amt = sizeof (struct elf_segment_map);
4074 amt += (tls_count - 1) * sizeof (asection *);
4075 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4080 m->count = tls_count;
4081 /* Mandated PF_R. */
4083 m->p_flags_valid = 1;
4084 for (i = 0; i < (unsigned int) tls_count; ++i)
4086 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
4087 m->sections[i] = first_tls;
4088 first_tls = first_tls->next;
4095 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4097 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
4098 if (eh_frame_hdr != NULL
4099 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4101 amt = sizeof (struct elf_segment_map);
4102 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4106 m->p_type = PT_GNU_EH_FRAME;
4108 m->sections[0] = eh_frame_hdr->output_section;
4114 if (elf_tdata (abfd)->stack_flags)
4116 amt = sizeof (struct elf_segment_map);
4117 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4121 m->p_type = PT_GNU_STACK;
4122 m->p_flags = elf_tdata (abfd)->stack_flags;
4123 m->p_flags_valid = 1;
4129 if (info != NULL && info->relro)
4131 for (m = mfirst; m != NULL; m = m->next)
4133 if (m->p_type == PT_LOAD)
4135 asection *last = m->sections[m->count - 1];
4136 bfd_vma vaddr = m->sections[0]->vma;
4137 bfd_vma filesz = last->vma - vaddr + last->size;
4139 if (vaddr < info->relro_end
4140 && vaddr >= info->relro_start
4141 && (vaddr + filesz) >= info->relro_end)
4146 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4149 amt = sizeof (struct elf_segment_map);
4150 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4154 m->p_type = PT_GNU_RELRO;
4156 m->p_flags_valid = 1;
4164 elf_tdata (abfd)->segment_map = mfirst;
4167 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
4170 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4172 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
4177 if (sections != NULL)
4182 /* Sort sections by address. */
4185 elf_sort_sections (const void *arg1, const void *arg2)
4187 const asection *sec1 = *(const asection **) arg1;
4188 const asection *sec2 = *(const asection **) arg2;
4189 bfd_size_type size1, size2;
4191 /* Sort by LMA first, since this is the address used to
4192 place the section into a segment. */
4193 if (sec1->lma < sec2->lma)
4195 else if (sec1->lma > sec2->lma)
4198 /* Then sort by VMA. Normally the LMA and the VMA will be
4199 the same, and this will do nothing. */
4200 if (sec1->vma < sec2->vma)
4202 else if (sec1->vma > sec2->vma)
4205 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4207 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4213 /* If the indicies are the same, do not return 0
4214 here, but continue to try the next comparison. */
4215 if (sec1->target_index - sec2->target_index != 0)
4216 return sec1->target_index - sec2->target_index;
4221 else if (TOEND (sec2))
4226 /* Sort by size, to put zero sized sections
4227 before others at the same address. */
4229 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4230 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4237 return sec1->target_index - sec2->target_index;
4240 /* Ian Lance Taylor writes:
4242 We shouldn't be using % with a negative signed number. That's just
4243 not good. We have to make sure either that the number is not
4244 negative, or that the number has an unsigned type. When the types
4245 are all the same size they wind up as unsigned. When file_ptr is a
4246 larger signed type, the arithmetic winds up as signed long long,
4249 What we're trying to say here is something like ``increase OFF by
4250 the least amount that will cause it to be equal to the VMA modulo
4252 /* In other words, something like:
4254 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4255 off_offset = off % bed->maxpagesize;
4256 if (vma_offset < off_offset)
4257 adjustment = vma_offset + bed->maxpagesize - off_offset;
4259 adjustment = vma_offset - off_offset;
4261 which can can be collapsed into the expression below. */
4264 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4266 return ((vma - off) % maxpagesize);
4270 print_segment_map (const struct elf_segment_map *m)
4273 const char *pt = get_segment_type (m->p_type);
4278 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4279 sprintf (buf, "LOPROC+%7.7x",
4280 (unsigned int) (m->p_type - PT_LOPROC));
4281 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4282 sprintf (buf, "LOOS+%7.7x",
4283 (unsigned int) (m->p_type - PT_LOOS));
4285 snprintf (buf, sizeof (buf), "%8.8x",
4286 (unsigned int) m->p_type);
4290 fprintf (stderr, "%s:", pt);
4291 for (j = 0; j < m->count; j++)
4292 fprintf (stderr, " %s", m->sections [j]->name);
4298 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
4303 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4305 buf = bfd_zmalloc (len);
4308 ret = bfd_bwrite (buf, len, abfd) == len;
4313 /* Assign file positions to the sections based on the mapping from
4314 sections to segments. This function also sets up some fields in
4318 assign_file_positions_for_load_sections (bfd *abfd,
4319 struct bfd_link_info *link_info)
4321 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4322 struct elf_segment_map *m;
4323 Elf_Internal_Phdr *phdrs;
4324 Elf_Internal_Phdr *p;
4326 bfd_size_type maxpagesize;
4329 bfd_vma header_pad = 0;
4331 if (link_info == NULL
4332 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
4336 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4340 header_pad = m->header_size;
4345 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4346 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4350 /* PR binutils/12467. */
4351 elf_elfheader (abfd)->e_phoff = 0;
4352 elf_elfheader (abfd)->e_phentsize = 0;
4355 elf_elfheader (abfd)->e_phnum = alloc;
4357 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4358 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4360 BFD_ASSERT (elf_tdata (abfd)->program_header_size
4361 >= alloc * bed->s->sizeof_phdr);
4365 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4369 /* We're writing the size in elf_tdata (abfd)->program_header_size,
4370 see assign_file_positions_except_relocs, so make sure we have
4371 that amount allocated, with trailing space cleared.
4372 The variable alloc contains the computed need, while elf_tdata
4373 (abfd)->program_header_size contains the size used for the
4375 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4376 where the layout is forced to according to a larger size in the
4377 last iterations for the testcase ld-elf/header. */
4378 BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr
4380 phdrs = (Elf_Internal_Phdr *)
4382 (elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr),
4383 sizeof (Elf_Internal_Phdr));
4384 elf_tdata (abfd)->phdr = phdrs;
4389 if ((abfd->flags & D_PAGED) != 0)
4390 maxpagesize = bed->maxpagesize;
4392 off = bed->s->sizeof_ehdr;
4393 off += alloc * bed->s->sizeof_phdr;
4394 if (header_pad < (bfd_vma) off)
4400 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4402 m = m->next, p++, j++)
4406 bfd_boolean no_contents;
4408 /* If elf_segment_map is not from map_sections_to_segments, the
4409 sections may not be correctly ordered. NOTE: sorting should
4410 not be done to the PT_NOTE section of a corefile, which may
4411 contain several pseudo-sections artificially created by bfd.
4412 Sorting these pseudo-sections breaks things badly. */
4414 && !(elf_elfheader (abfd)->e_type == ET_CORE
4415 && m->p_type == PT_NOTE))
4416 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4419 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4420 number of sections with contents contributing to both p_filesz
4421 and p_memsz, followed by a number of sections with no contents
4422 that just contribute to p_memsz. In this loop, OFF tracks next
4423 available file offset for PT_LOAD and PT_NOTE segments. */
4424 p->p_type = m->p_type;
4425 p->p_flags = m->p_flags;
4430 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4432 if (m->p_paddr_valid)
4433 p->p_paddr = m->p_paddr;
4434 else if (m->count == 0)
4437 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4439 if (p->p_type == PT_LOAD
4440 && (abfd->flags & D_PAGED) != 0)
4442 /* p_align in demand paged PT_LOAD segments effectively stores
4443 the maximum page size. When copying an executable with
4444 objcopy, we set m->p_align from the input file. Use this
4445 value for maxpagesize rather than bed->maxpagesize, which
4446 may be different. Note that we use maxpagesize for PT_TLS
4447 segment alignment later in this function, so we are relying
4448 on at least one PT_LOAD segment appearing before a PT_TLS
4450 if (m->p_align_valid)
4451 maxpagesize = m->p_align;
4453 p->p_align = maxpagesize;
4455 else if (m->p_align_valid)
4456 p->p_align = m->p_align;
4457 else if (m->count == 0)
4458 p->p_align = 1 << bed->s->log_file_align;
4462 no_contents = FALSE;
4464 if (p->p_type == PT_LOAD
4467 bfd_size_type align;
4468 unsigned int align_power = 0;
4470 if (m->p_align_valid)
4474 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4476 unsigned int secalign;
4478 secalign = bfd_get_section_alignment (abfd, *secpp);
4479 if (secalign > align_power)
4480 align_power = secalign;
4482 align = (bfd_size_type) 1 << align_power;
4483 if (align < maxpagesize)
4484 align = maxpagesize;
4487 for (i = 0; i < m->count; i++)
4488 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4489 /* If we aren't making room for this section, then
4490 it must be SHT_NOBITS regardless of what we've
4491 set via struct bfd_elf_special_section. */
4492 elf_section_type (m->sections[i]) = SHT_NOBITS;
4494 /* Find out whether this segment contains any loadable
4497 for (i = 0; i < m->count; i++)
4498 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4500 no_contents = FALSE;
4504 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
4508 /* We shouldn't need to align the segment on disk since
4509 the segment doesn't need file space, but the gABI
4510 arguably requires the alignment and glibc ld.so
4511 checks it. So to comply with the alignment
4512 requirement but not waste file space, we adjust
4513 p_offset for just this segment. (OFF_ADJUST is
4514 subtracted from OFF later.) This may put p_offset
4515 past the end of file, but that shouldn't matter. */
4520 /* Make sure the .dynamic section is the first section in the
4521 PT_DYNAMIC segment. */
4522 else if (p->p_type == PT_DYNAMIC
4524 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4527 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4529 bfd_set_error (bfd_error_bad_value);
4532 /* Set the note section type to SHT_NOTE. */
4533 else if (p->p_type == PT_NOTE)
4534 for (i = 0; i < m->count; i++)
4535 elf_section_type (m->sections[i]) = SHT_NOTE;
4541 if (m->includes_filehdr)
4543 if (!m->p_flags_valid)
4545 p->p_filesz = bed->s->sizeof_ehdr;
4546 p->p_memsz = bed->s->sizeof_ehdr;
4549 BFD_ASSERT (p->p_type == PT_LOAD);
4551 if (p->p_vaddr < (bfd_vma) off)
4553 (*_bfd_error_handler)
4554 (_("%B: Not enough room for program headers, try linking with -N"),
4556 bfd_set_error (bfd_error_bad_value);
4561 if (!m->p_paddr_valid)
4566 if (m->includes_phdrs)
4568 if (!m->p_flags_valid)
4571 if (!m->includes_filehdr)
4573 p->p_offset = bed->s->sizeof_ehdr;
4577 BFD_ASSERT (p->p_type == PT_LOAD);
4578 p->p_vaddr -= off - p->p_offset;
4579 if (!m->p_paddr_valid)
4580 p->p_paddr -= off - p->p_offset;
4584 p->p_filesz += alloc * bed->s->sizeof_phdr;
4585 p->p_memsz += alloc * bed->s->sizeof_phdr;
4588 p->p_filesz += header_pad;
4589 p->p_memsz += header_pad;
4593 if (p->p_type == PT_LOAD
4594 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4596 if (!m->includes_filehdr && !m->includes_phdrs)
4602 adjust = off - (p->p_offset + p->p_filesz);
4604 p->p_filesz += adjust;
4605 p->p_memsz += adjust;
4609 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4610 maps. Set filepos for sections in PT_LOAD segments, and in
4611 core files, for sections in PT_NOTE segments.
4612 assign_file_positions_for_non_load_sections will set filepos
4613 for other sections and update p_filesz for other segments. */
4614 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4617 bfd_size_type align;
4618 Elf_Internal_Shdr *this_hdr;
4621 this_hdr = &elf_section_data (sec)->this_hdr;
4622 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4624 if ((p->p_type == PT_LOAD
4625 || p->p_type == PT_TLS)
4626 && (this_hdr->sh_type != SHT_NOBITS
4627 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4628 && ((this_hdr->sh_flags & SHF_TLS) == 0
4629 || p->p_type == PT_TLS))))
4631 bfd_vma p_start = p->p_paddr;
4632 bfd_vma p_end = p_start + p->p_memsz;
4633 bfd_vma s_start = sec->lma;
4634 bfd_vma adjust = s_start - p_end;
4638 || p_end < p_start))
4640 (*_bfd_error_handler)
4641 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
4642 (unsigned long) s_start, (unsigned long) p_end);
4646 p->p_memsz += adjust;
4648 if (this_hdr->sh_type != SHT_NOBITS)
4650 if (p->p_filesz + adjust < p->p_memsz)
4652 /* We have a PROGBITS section following NOBITS ones.
4653 Allocate file space for the NOBITS section(s) and
4655 adjust = p->p_memsz - p->p_filesz;
4656 if (!write_zeros (abfd, off, adjust))
4660 p->p_filesz += adjust;
4664 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4666 /* The section at i == 0 is the one that actually contains
4670 this_hdr->sh_offset = sec->filepos = off;
4671 off += this_hdr->sh_size;
4672 p->p_filesz = this_hdr->sh_size;
4678 /* The rest are fake sections that shouldn't be written. */
4687 if (p->p_type == PT_LOAD)
4689 this_hdr->sh_offset = sec->filepos = off;
4690 if (this_hdr->sh_type != SHT_NOBITS)
4691 off += this_hdr->sh_size;
4694 if (this_hdr->sh_type != SHT_NOBITS)
4696 p->p_filesz += this_hdr->sh_size;
4697 /* A load section without SHF_ALLOC is something like
4698 a note section in a PT_NOTE segment. These take
4699 file space but are not loaded into memory. */
4700 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4701 p->p_memsz += this_hdr->sh_size;
4703 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4705 if (p->p_type == PT_TLS)
4706 p->p_memsz += this_hdr->sh_size;
4708 /* .tbss is special. It doesn't contribute to p_memsz of
4710 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4711 p->p_memsz += this_hdr->sh_size;
4714 if (align > p->p_align
4715 && !m->p_align_valid
4716 && (p->p_type != PT_LOAD
4717 || (abfd->flags & D_PAGED) == 0))
4721 if (!m->p_flags_valid)
4724 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4726 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4732 /* Check that all sections are in a PT_LOAD segment.
4733 Don't check funky gdb generated core files. */
4734 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4736 bfd_boolean check_vma = TRUE;
4738 for (i = 1; i < m->count; i++)
4739 if (m->sections[i]->vma == m->sections[i - 1]->vma
4740 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
4741 ->this_hdr), p) != 0
4742 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
4743 ->this_hdr), p) != 0)
4745 /* Looks like we have overlays packed into the segment. */
4750 for (i = 0; i < m->count; i++)
4752 Elf_Internal_Shdr *this_hdr;
4755 sec = m->sections[i];
4756 this_hdr = &(elf_section_data(sec)->this_hdr);
4757 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
4758 && !ELF_TBSS_SPECIAL (this_hdr, p))
4760 (*_bfd_error_handler)
4761 (_("%B: section `%A' can't be allocated in segment %d"),
4763 print_segment_map (m);
4769 elf_tdata (abfd)->next_file_pos = off;
4773 /* Assign file positions for the other sections. */
4776 assign_file_positions_for_non_load_sections (bfd *abfd,
4777 struct bfd_link_info *link_info)
4779 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4780 Elf_Internal_Shdr **i_shdrpp;
4781 Elf_Internal_Shdr **hdrpp;
4782 Elf_Internal_Phdr *phdrs;
4783 Elf_Internal_Phdr *p;
4784 struct elf_segment_map *m;
4785 bfd_vma filehdr_vaddr, filehdr_paddr;
4786 bfd_vma phdrs_vaddr, phdrs_paddr;
4788 unsigned int num_sec;
4792 i_shdrpp = elf_elfsections (abfd);
4793 num_sec = elf_numsections (abfd);
4794 off = elf_tdata (abfd)->next_file_pos;
4795 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4797 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4798 Elf_Internal_Shdr *hdr;
4801 if (hdr->bfd_section != NULL
4802 && (hdr->bfd_section->filepos != 0
4803 || (hdr->sh_type == SHT_NOBITS
4804 && hdr->contents == NULL)))
4805 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4806 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4808 (*_bfd_error_handler)
4809 (_("%B: warning: allocated section `%s' not in segment"),
4811 (hdr->bfd_section == NULL
4813 : hdr->bfd_section->name));
4814 /* We don't need to page align empty sections. */
4815 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4816 off += vma_page_aligned_bias (hdr->sh_addr, off,
4819 off += vma_page_aligned_bias (hdr->sh_addr, off,
4821 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4824 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4825 && hdr->bfd_section == NULL)
4826 || hdr == i_shdrpp[tdata->symtab_section]
4827 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4828 || hdr == i_shdrpp[tdata->strtab_section])
4829 hdr->sh_offset = -1;
4831 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4834 /* Now that we have set the section file positions, we can set up
4835 the file positions for the non PT_LOAD segments. */
4839 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4841 phdrs = elf_tdata (abfd)->phdr;
4842 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4847 if (p->p_type != PT_LOAD)
4850 if (m->includes_filehdr)
4852 filehdr_vaddr = p->p_vaddr;
4853 filehdr_paddr = p->p_paddr;
4855 if (m->includes_phdrs)
4857 phdrs_vaddr = p->p_vaddr;
4858 phdrs_paddr = p->p_paddr;
4859 if (m->includes_filehdr)
4861 phdrs_vaddr += bed->s->sizeof_ehdr;
4862 phdrs_paddr += bed->s->sizeof_ehdr;
4867 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4871 if (p->p_type == PT_GNU_RELRO)
4873 const Elf_Internal_Phdr *lp;
4875 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4877 if (link_info != NULL)
4879 /* During linking the range of the RELRO segment is passed
4881 for (lp = phdrs; lp < phdrs + count; ++lp)
4883 if (lp->p_type == PT_LOAD
4884 && lp->p_vaddr >= link_info->relro_start
4885 && lp->p_vaddr < link_info->relro_end
4886 && lp->p_vaddr + lp->p_filesz >= link_info->relro_end)
4892 /* Otherwise we are copying an executable or shared
4893 library, but we need to use the same linker logic. */
4894 for (lp = phdrs; lp < phdrs + count; ++lp)
4896 if (lp->p_type == PT_LOAD
4897 && lp->p_paddr == p->p_paddr)
4902 if (lp < phdrs + count)
4904 p->p_vaddr = lp->p_vaddr;
4905 p->p_paddr = lp->p_paddr;
4906 p->p_offset = lp->p_offset;
4907 if (link_info != NULL)
4908 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4909 else if (m->p_size_valid)
4910 p->p_filesz = m->p_size;
4913 p->p_memsz = p->p_filesz;
4915 p->p_flags = (lp->p_flags & ~PF_W);
4919 memset (p, 0, sizeof *p);
4920 p->p_type = PT_NULL;
4923 else if (m->count != 0)
4925 if (p->p_type != PT_LOAD
4926 && (p->p_type != PT_NOTE
4927 || bfd_get_format (abfd) != bfd_core))
4929 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4932 p->p_offset = m->sections[0]->filepos;
4933 for (i = m->count; i-- != 0;)
4935 asection *sect = m->sections[i];
4936 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
4937 if (hdr->sh_type != SHT_NOBITS)
4939 p->p_filesz = (sect->filepos - m->sections[0]->filepos
4946 else if (m->includes_filehdr)
4948 p->p_vaddr = filehdr_vaddr;
4949 if (! m->p_paddr_valid)
4950 p->p_paddr = filehdr_paddr;
4952 else if (m->includes_phdrs)
4954 p->p_vaddr = phdrs_vaddr;
4955 if (! m->p_paddr_valid)
4956 p->p_paddr = phdrs_paddr;
4960 elf_tdata (abfd)->next_file_pos = off;
4965 /* Work out the file positions of all the sections. This is called by
4966 _bfd_elf_compute_section_file_positions. All the section sizes and
4967 VMAs must be known before this is called.
4969 Reloc sections come in two flavours: Those processed specially as
4970 "side-channel" data attached to a section to which they apply, and
4971 those that bfd doesn't process as relocations. The latter sort are
4972 stored in a normal bfd section by bfd_section_from_shdr. We don't
4973 consider the former sort here, unless they form part of the loadable
4974 image. Reloc sections not assigned here will be handled later by
4975 assign_file_positions_for_relocs.
4977 We also don't set the positions of the .symtab and .strtab here. */
4980 assign_file_positions_except_relocs (bfd *abfd,
4981 struct bfd_link_info *link_info)
4983 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4984 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4986 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4988 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4989 && bfd_get_format (abfd) != bfd_core)
4991 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4992 unsigned int num_sec = elf_numsections (abfd);
4993 Elf_Internal_Shdr **hdrpp;
4996 /* Start after the ELF header. */
4997 off = i_ehdrp->e_ehsize;
4999 /* We are not creating an executable, which means that we are
5000 not creating a program header, and that the actual order of
5001 the sections in the file is unimportant. */
5002 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
5004 Elf_Internal_Shdr *hdr;
5007 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5008 && hdr->bfd_section == NULL)
5009 || i == tdata->symtab_section
5010 || i == tdata->symtab_shndx_section
5011 || i == tdata->strtab_section)
5013 hdr->sh_offset = -1;
5016 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5023 /* Assign file positions for the loaded sections based on the
5024 assignment of sections to segments. */
5025 if (!assign_file_positions_for_load_sections (abfd, link_info))
5028 /* And for non-load sections. */
5029 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
5032 if (bed->elf_backend_modify_program_headers != NULL)
5034 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
5038 /* Write out the program headers. */
5039 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
5040 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
5041 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
5044 off = tdata->next_file_pos;
5047 /* Place the section headers. */
5048 off = align_file_position (off, 1 << bed->s->log_file_align);
5049 i_ehdrp->e_shoff = off;
5050 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
5052 tdata->next_file_pos = off;
5058 prep_headers (bfd *abfd)
5060 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
5061 struct elf_strtab_hash *shstrtab;
5062 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5064 i_ehdrp = elf_elfheader (abfd);
5066 shstrtab = _bfd_elf_strtab_init ();
5067 if (shstrtab == NULL)
5070 elf_shstrtab (abfd) = shstrtab;
5072 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
5073 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
5074 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
5075 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
5077 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
5078 i_ehdrp->e_ident[EI_DATA] =
5079 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
5080 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
5082 if ((abfd->flags & DYNAMIC) != 0)
5083 i_ehdrp->e_type = ET_DYN;
5084 else if ((abfd->flags & EXEC_P) != 0)
5085 i_ehdrp->e_type = ET_EXEC;
5086 else if (bfd_get_format (abfd) == bfd_core)
5087 i_ehdrp->e_type = ET_CORE;
5089 i_ehdrp->e_type = ET_REL;
5091 switch (bfd_get_arch (abfd))
5093 case bfd_arch_unknown:
5094 i_ehdrp->e_machine = EM_NONE;
5097 /* There used to be a long list of cases here, each one setting
5098 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5099 in the corresponding bfd definition. To avoid duplication,
5100 the switch was removed. Machines that need special handling
5101 can generally do it in elf_backend_final_write_processing(),
5102 unless they need the information earlier than the final write.
5103 Such need can generally be supplied by replacing the tests for
5104 e_machine with the conditions used to determine it. */
5106 i_ehdrp->e_machine = bed->elf_machine_code;
5109 i_ehdrp->e_version = bed->s->ev_current;
5110 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5112 /* No program header, for now. */
5113 i_ehdrp->e_phoff = 0;
5114 i_ehdrp->e_phentsize = 0;
5115 i_ehdrp->e_phnum = 0;
5117 /* Each bfd section is section header entry. */
5118 i_ehdrp->e_entry = bfd_get_start_address (abfd);
5119 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5121 /* If we're building an executable, we'll need a program header table. */
5122 if (abfd->flags & EXEC_P)
5123 /* It all happens later. */
5127 i_ehdrp->e_phentsize = 0;
5128 i_ehdrp->e_phoff = 0;
5131 elf_tdata (abfd)->symtab_hdr.sh_name =
5132 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
5133 elf_tdata (abfd)->strtab_hdr.sh_name =
5134 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
5135 elf_tdata (abfd)->shstrtab_hdr.sh_name =
5136 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
5137 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5138 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5139 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
5145 /* Assign file positions for all the reloc sections which are not part
5146 of the loadable file image. */
5149 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
5152 unsigned int i, num_sec;
5153 Elf_Internal_Shdr **shdrpp;
5155 off = elf_tdata (abfd)->next_file_pos;
5157 num_sec = elf_numsections (abfd);
5158 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
5160 Elf_Internal_Shdr *shdrp;
5163 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
5164 && shdrp->sh_offset == -1)
5165 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
5168 elf_tdata (abfd)->next_file_pos = off;
5172 _bfd_elf_write_object_contents (bfd *abfd)
5174 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5175 Elf_Internal_Shdr **i_shdrp;
5177 unsigned int count, num_sec;
5179 if (! abfd->output_has_begun
5180 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
5183 i_shdrp = elf_elfsections (abfd);
5186 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5190 _bfd_elf_assign_file_positions_for_relocs (abfd);
5192 /* After writing the headers, we need to write the sections too... */
5193 num_sec = elf_numsections (abfd);
5194 for (count = 1; count < num_sec; count++)
5196 if (bed->elf_backend_section_processing)
5197 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5198 if (i_shdrp[count]->contents)
5200 bfd_size_type amt = i_shdrp[count]->sh_size;
5202 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
5203 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
5208 /* Write out the section header names. */
5209 if (elf_shstrtab (abfd) != NULL
5210 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
5211 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
5214 if (bed->elf_backend_final_write_processing)
5215 (*bed->elf_backend_final_write_processing) (abfd,
5216 elf_tdata (abfd)->linker);
5218 if (!bed->s->write_shdrs_and_ehdr (abfd))
5221 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5222 if (elf_tdata (abfd)->after_write_object_contents)
5223 return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
5229 _bfd_elf_write_corefile_contents (bfd *abfd)
5231 /* Hopefully this can be done just like an object file. */
5232 return _bfd_elf_write_object_contents (abfd);
5235 /* Given a section, search the header to find them. */
5238 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5240 const struct elf_backend_data *bed;
5241 unsigned int sec_index;
5243 if (elf_section_data (asect) != NULL
5244 && elf_section_data (asect)->this_idx != 0)
5245 return elf_section_data (asect)->this_idx;
5247 if (bfd_is_abs_section (asect))
5248 sec_index = SHN_ABS;
5249 else if (bfd_is_com_section (asect))
5250 sec_index = SHN_COMMON;
5251 else if (bfd_is_und_section (asect))
5252 sec_index = SHN_UNDEF;
5254 sec_index = SHN_BAD;
5256 bed = get_elf_backend_data (abfd);
5257 if (bed->elf_backend_section_from_bfd_section)
5259 int retval = sec_index;
5261 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5265 if (sec_index == SHN_BAD)
5266 bfd_set_error (bfd_error_nonrepresentable_section);
5271 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5275 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5277 asymbol *asym_ptr = *asym_ptr_ptr;
5279 flagword flags = asym_ptr->flags;
5281 /* When gas creates relocations against local labels, it creates its
5282 own symbol for the section, but does put the symbol into the
5283 symbol chain, so udata is 0. When the linker is generating
5284 relocatable output, this section symbol may be for one of the
5285 input sections rather than the output section. */
5286 if (asym_ptr->udata.i == 0
5287 && (flags & BSF_SECTION_SYM)
5288 && asym_ptr->section)
5293 sec = asym_ptr->section;
5294 if (sec->owner != abfd && sec->output_section != NULL)
5295 sec = sec->output_section;
5296 if (sec->owner == abfd
5297 && (indx = sec->index) < elf_num_section_syms (abfd)
5298 && elf_section_syms (abfd)[indx] != NULL)
5299 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5302 idx = asym_ptr->udata.i;
5306 /* This case can occur when using --strip-symbol on a symbol
5307 which is used in a relocation entry. */
5308 (*_bfd_error_handler)
5309 (_("%B: symbol `%s' required but not present"),
5310 abfd, bfd_asymbol_name (asym_ptr));
5311 bfd_set_error (bfd_error_no_symbols);
5318 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5319 (long) asym_ptr, asym_ptr->name, idx, (long) flags);
5327 /* Rewrite program header information. */
5330 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5332 Elf_Internal_Ehdr *iehdr;
5333 struct elf_segment_map *map;
5334 struct elf_segment_map *map_first;
5335 struct elf_segment_map **pointer_to_map;
5336 Elf_Internal_Phdr *segment;
5339 unsigned int num_segments;
5340 bfd_boolean phdr_included = FALSE;
5341 bfd_boolean p_paddr_valid;
5342 bfd_vma maxpagesize;
5343 struct elf_segment_map *phdr_adjust_seg = NULL;
5344 unsigned int phdr_adjust_num = 0;
5345 const struct elf_backend_data *bed;
5347 bed = get_elf_backend_data (ibfd);
5348 iehdr = elf_elfheader (ibfd);
5351 pointer_to_map = &map_first;
5353 num_segments = elf_elfheader (ibfd)->e_phnum;
5354 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5356 /* Returns the end address of the segment + 1. */
5357 #define SEGMENT_END(segment, start) \
5358 (start + (segment->p_memsz > segment->p_filesz \
5359 ? segment->p_memsz : segment->p_filesz))
5361 #define SECTION_SIZE(section, segment) \
5362 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5363 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5364 ? section->size : 0)
5366 /* Returns TRUE if the given section is contained within
5367 the given segment. VMA addresses are compared. */
5368 #define IS_CONTAINED_BY_VMA(section, segment) \
5369 (section->vma >= segment->p_vaddr \
5370 && (section->vma + SECTION_SIZE (section, segment) \
5371 <= (SEGMENT_END (segment, segment->p_vaddr))))
5373 /* Returns TRUE if the given section is contained within
5374 the given segment. LMA addresses are compared. */
5375 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5376 (section->lma >= base \
5377 && (section->lma + SECTION_SIZE (section, segment) \
5378 <= SEGMENT_END (segment, base)))
5380 /* Handle PT_NOTE segment. */
5381 #define IS_NOTE(p, s) \
5382 (p->p_type == PT_NOTE \
5383 && elf_section_type (s) == SHT_NOTE \
5384 && (bfd_vma) s->filepos >= p->p_offset \
5385 && ((bfd_vma) s->filepos + s->size \
5386 <= p->p_offset + p->p_filesz))
5388 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5390 #define IS_COREFILE_NOTE(p, s) \
5392 && bfd_get_format (ibfd) == bfd_core \
5396 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5397 linker, which generates a PT_INTERP section with p_vaddr and
5398 p_memsz set to 0. */
5399 #define IS_SOLARIS_PT_INTERP(p, s) \
5401 && p->p_paddr == 0 \
5402 && p->p_memsz == 0 \
5403 && p->p_filesz > 0 \
5404 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5406 && (bfd_vma) s->filepos >= p->p_offset \
5407 && ((bfd_vma) s->filepos + s->size \
5408 <= p->p_offset + p->p_filesz))
5410 /* Decide if the given section should be included in the given segment.
5411 A section will be included if:
5412 1. It is within the address space of the segment -- we use the LMA
5413 if that is set for the segment and the VMA otherwise,
5414 2. It is an allocated section or a NOTE section in a PT_NOTE
5416 3. There is an output section associated with it,
5417 4. The section has not already been allocated to a previous segment.
5418 5. PT_GNU_STACK segments do not include any sections.
5419 6. PT_TLS segment includes only SHF_TLS sections.
5420 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5421 8. PT_DYNAMIC should not contain empty sections at the beginning
5422 (with the possible exception of .dynamic). */
5423 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5424 ((((segment->p_paddr \
5425 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5426 : IS_CONTAINED_BY_VMA (section, segment)) \
5427 && (section->flags & SEC_ALLOC) != 0) \
5428 || IS_NOTE (segment, section)) \
5429 && segment->p_type != PT_GNU_STACK \
5430 && (segment->p_type != PT_TLS \
5431 || (section->flags & SEC_THREAD_LOCAL)) \
5432 && (segment->p_type == PT_LOAD \
5433 || segment->p_type == PT_TLS \
5434 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5435 && (segment->p_type != PT_DYNAMIC \
5436 || SECTION_SIZE (section, segment) > 0 \
5437 || (segment->p_paddr \
5438 ? segment->p_paddr != section->lma \
5439 : segment->p_vaddr != section->vma) \
5440 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5442 && !section->segment_mark)
5444 /* If the output section of a section in the input segment is NULL,
5445 it is removed from the corresponding output segment. */
5446 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5447 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5448 && section->output_section != NULL)
5450 /* Returns TRUE iff seg1 starts after the end of seg2. */
5451 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5452 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5454 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5455 their VMA address ranges and their LMA address ranges overlap.
5456 It is possible to have overlapping VMA ranges without overlapping LMA
5457 ranges. RedBoot images for example can have both .data and .bss mapped
5458 to the same VMA range, but with the .data section mapped to a different
5460 #define SEGMENT_OVERLAPS(seg1, seg2) \
5461 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5462 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5463 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5464 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5466 /* Initialise the segment mark field. */
5467 for (section = ibfd->sections; section != NULL; section = section->next)
5468 section->segment_mark = FALSE;
5470 /* The Solaris linker creates program headers in which all the
5471 p_paddr fields are zero. When we try to objcopy or strip such a
5472 file, we get confused. Check for this case, and if we find it
5473 don't set the p_paddr_valid fields. */
5474 p_paddr_valid = FALSE;
5475 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5478 if (segment->p_paddr != 0)
5480 p_paddr_valid = TRUE;
5484 /* Scan through the segments specified in the program header
5485 of the input BFD. For this first scan we look for overlaps
5486 in the loadable segments. These can be created by weird
5487 parameters to objcopy. Also, fix some solaris weirdness. */
5488 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5493 Elf_Internal_Phdr *segment2;
5495 if (segment->p_type == PT_INTERP)
5496 for (section = ibfd->sections; section; section = section->next)
5497 if (IS_SOLARIS_PT_INTERP (segment, section))
5499 /* Mininal change so that the normal section to segment
5500 assignment code will work. */
5501 segment->p_vaddr = section->vma;
5505 if (segment->p_type != PT_LOAD)
5507 /* Remove PT_GNU_RELRO segment. */
5508 if (segment->p_type == PT_GNU_RELRO)
5509 segment->p_type = PT_NULL;
5513 /* Determine if this segment overlaps any previous segments. */
5514 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5516 bfd_signed_vma extra_length;
5518 if (segment2->p_type != PT_LOAD
5519 || !SEGMENT_OVERLAPS (segment, segment2))
5522 /* Merge the two segments together. */
5523 if (segment2->p_vaddr < segment->p_vaddr)
5525 /* Extend SEGMENT2 to include SEGMENT and then delete
5527 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5528 - SEGMENT_END (segment2, segment2->p_vaddr));
5530 if (extra_length > 0)
5532 segment2->p_memsz += extra_length;
5533 segment2->p_filesz += extra_length;
5536 segment->p_type = PT_NULL;
5538 /* Since we have deleted P we must restart the outer loop. */
5540 segment = elf_tdata (ibfd)->phdr;
5545 /* Extend SEGMENT to include SEGMENT2 and then delete
5547 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5548 - SEGMENT_END (segment, segment->p_vaddr));
5550 if (extra_length > 0)
5552 segment->p_memsz += extra_length;
5553 segment->p_filesz += extra_length;
5556 segment2->p_type = PT_NULL;
5561 /* The second scan attempts to assign sections to segments. */
5562 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5566 unsigned int section_count;
5567 asection **sections;
5568 asection *output_section;
5570 bfd_vma matching_lma;
5571 bfd_vma suggested_lma;
5574 asection *first_section;
5575 bfd_boolean first_matching_lma;
5576 bfd_boolean first_suggested_lma;
5578 if (segment->p_type == PT_NULL)
5581 first_section = NULL;
5582 /* Compute how many sections might be placed into this segment. */
5583 for (section = ibfd->sections, section_count = 0;
5585 section = section->next)
5587 /* Find the first section in the input segment, which may be
5588 removed from the corresponding output segment. */
5589 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5591 if (first_section == NULL)
5592 first_section = section;
5593 if (section->output_section != NULL)
5598 /* Allocate a segment map big enough to contain
5599 all of the sections we have selected. */
5600 amt = sizeof (struct elf_segment_map);
5601 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5602 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
5606 /* Initialise the fields of the segment map. Default to
5607 using the physical address of the segment in the input BFD. */
5609 map->p_type = segment->p_type;
5610 map->p_flags = segment->p_flags;
5611 map->p_flags_valid = 1;
5613 /* If the first section in the input segment is removed, there is
5614 no need to preserve segment physical address in the corresponding
5616 if (!first_section || first_section->output_section != NULL)
5618 map->p_paddr = segment->p_paddr;
5619 map->p_paddr_valid = p_paddr_valid;
5622 /* Determine if this segment contains the ELF file header
5623 and if it contains the program headers themselves. */
5624 map->includes_filehdr = (segment->p_offset == 0
5625 && segment->p_filesz >= iehdr->e_ehsize);
5626 map->includes_phdrs = 0;
5628 if (!phdr_included || segment->p_type != PT_LOAD)
5630 map->includes_phdrs =
5631 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5632 && (segment->p_offset + segment->p_filesz
5633 >= ((bfd_vma) iehdr->e_phoff
5634 + iehdr->e_phnum * iehdr->e_phentsize)));
5636 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5637 phdr_included = TRUE;
5640 if (section_count == 0)
5642 /* Special segments, such as the PT_PHDR segment, may contain
5643 no sections, but ordinary, loadable segments should contain
5644 something. They are allowed by the ELF spec however, so only
5645 a warning is produced. */
5646 if (segment->p_type == PT_LOAD)
5647 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5648 " detected, is this intentional ?\n"),
5652 *pointer_to_map = map;
5653 pointer_to_map = &map->next;
5658 /* Now scan the sections in the input BFD again and attempt
5659 to add their corresponding output sections to the segment map.
5660 The problem here is how to handle an output section which has
5661 been moved (ie had its LMA changed). There are four possibilities:
5663 1. None of the sections have been moved.
5664 In this case we can continue to use the segment LMA from the
5667 2. All of the sections have been moved by the same amount.
5668 In this case we can change the segment's LMA to match the LMA
5669 of the first section.
5671 3. Some of the sections have been moved, others have not.
5672 In this case those sections which have not been moved can be
5673 placed in the current segment which will have to have its size,
5674 and possibly its LMA changed, and a new segment or segments will
5675 have to be created to contain the other sections.
5677 4. The sections have been moved, but not by the same amount.
5678 In this case we can change the segment's LMA to match the LMA
5679 of the first section and we will have to create a new segment
5680 or segments to contain the other sections.
5682 In order to save time, we allocate an array to hold the section
5683 pointers that we are interested in. As these sections get assigned
5684 to a segment, they are removed from this array. */
5686 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
5687 if (sections == NULL)
5690 /* Step One: Scan for segment vs section LMA conflicts.
5691 Also add the sections to the section array allocated above.
5692 Also add the sections to the current segment. In the common
5693 case, where the sections have not been moved, this means that
5694 we have completely filled the segment, and there is nothing
5699 first_matching_lma = TRUE;
5700 first_suggested_lma = TRUE;
5702 for (section = ibfd->sections;
5704 section = section->next)
5705 if (section == first_section)
5708 for (j = 0; section != NULL; section = section->next)
5710 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5712 output_section = section->output_section;
5714 sections[j++] = section;
5716 /* The Solaris native linker always sets p_paddr to 0.
5717 We try to catch that case here, and set it to the
5718 correct value. Note - some backends require that
5719 p_paddr be left as zero. */
5721 && segment->p_vaddr != 0
5722 && !bed->want_p_paddr_set_to_zero
5724 && output_section->lma != 0
5725 && output_section->vma == (segment->p_vaddr
5726 + (map->includes_filehdr
5729 + (map->includes_phdrs
5731 * iehdr->e_phentsize)
5733 map->p_paddr = segment->p_vaddr;
5735 /* Match up the physical address of the segment with the
5736 LMA address of the output section. */
5737 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5738 || IS_COREFILE_NOTE (segment, section)
5739 || (bed->want_p_paddr_set_to_zero
5740 && IS_CONTAINED_BY_VMA (output_section, segment)))
5742 if (first_matching_lma || output_section->lma < matching_lma)
5744 matching_lma = output_section->lma;
5745 first_matching_lma = FALSE;
5748 /* We assume that if the section fits within the segment
5749 then it does not overlap any other section within that
5751 map->sections[isec++] = output_section;
5753 else if (first_suggested_lma)
5755 suggested_lma = output_section->lma;
5756 first_suggested_lma = FALSE;
5759 if (j == section_count)
5764 BFD_ASSERT (j == section_count);
5766 /* Step Two: Adjust the physical address of the current segment,
5768 if (isec == section_count)
5770 /* All of the sections fitted within the segment as currently
5771 specified. This is the default case. Add the segment to
5772 the list of built segments and carry on to process the next
5773 program header in the input BFD. */
5774 map->count = section_count;
5775 *pointer_to_map = map;
5776 pointer_to_map = &map->next;
5779 && !bed->want_p_paddr_set_to_zero
5780 && matching_lma != map->p_paddr
5781 && !map->includes_filehdr
5782 && !map->includes_phdrs)
5783 /* There is some padding before the first section in the
5784 segment. So, we must account for that in the output
5786 map->p_vaddr_offset = matching_lma - map->p_paddr;
5793 if (!first_matching_lma)
5795 /* At least one section fits inside the current segment.
5796 Keep it, but modify its physical address to match the
5797 LMA of the first section that fitted. */
5798 map->p_paddr = matching_lma;
5802 /* None of the sections fitted inside the current segment.
5803 Change the current segment's physical address to match
5804 the LMA of the first section. */
5805 map->p_paddr = suggested_lma;
5808 /* Offset the segment physical address from the lma
5809 to allow for space taken up by elf headers. */
5810 if (map->includes_filehdr)
5812 if (map->p_paddr >= iehdr->e_ehsize)
5813 map->p_paddr -= iehdr->e_ehsize;
5816 map->includes_filehdr = FALSE;
5817 map->includes_phdrs = FALSE;
5821 if (map->includes_phdrs)
5823 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5825 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5827 /* iehdr->e_phnum is just an estimate of the number
5828 of program headers that we will need. Make a note
5829 here of the number we used and the segment we chose
5830 to hold these headers, so that we can adjust the
5831 offset when we know the correct value. */
5832 phdr_adjust_num = iehdr->e_phnum;
5833 phdr_adjust_seg = map;
5836 map->includes_phdrs = FALSE;
5840 /* Step Three: Loop over the sections again, this time assigning
5841 those that fit to the current segment and removing them from the
5842 sections array; but making sure not to leave large gaps. Once all
5843 possible sections have been assigned to the current segment it is
5844 added to the list of built segments and if sections still remain
5845 to be assigned, a new segment is constructed before repeating
5852 first_suggested_lma = TRUE;
5854 /* Fill the current segment with sections that fit. */
5855 for (j = 0; j < section_count; j++)
5857 section = sections[j];
5859 if (section == NULL)
5862 output_section = section->output_section;
5864 BFD_ASSERT (output_section != NULL);
5866 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5867 || IS_COREFILE_NOTE (segment, section))
5869 if (map->count == 0)
5871 /* If the first section in a segment does not start at
5872 the beginning of the segment, then something is
5874 if (output_section->lma
5876 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5877 + (map->includes_phdrs
5878 ? iehdr->e_phnum * iehdr->e_phentsize
5886 prev_sec = map->sections[map->count - 1];
5888 /* If the gap between the end of the previous section
5889 and the start of this section is more than
5890 maxpagesize then we need to start a new segment. */
5891 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5893 < BFD_ALIGN (output_section->lma, maxpagesize))
5894 || (prev_sec->lma + prev_sec->size
5895 > output_section->lma))
5897 if (first_suggested_lma)
5899 suggested_lma = output_section->lma;
5900 first_suggested_lma = FALSE;
5907 map->sections[map->count++] = output_section;
5910 section->segment_mark = TRUE;
5912 else if (first_suggested_lma)
5914 suggested_lma = output_section->lma;
5915 first_suggested_lma = FALSE;
5919 BFD_ASSERT (map->count > 0);
5921 /* Add the current segment to the list of built segments. */
5922 *pointer_to_map = map;
5923 pointer_to_map = &map->next;
5925 if (isec < section_count)
5927 /* We still have not allocated all of the sections to
5928 segments. Create a new segment here, initialise it
5929 and carry on looping. */
5930 amt = sizeof (struct elf_segment_map);
5931 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5932 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
5939 /* Initialise the fields of the segment map. Set the physical
5940 physical address to the LMA of the first section that has
5941 not yet been assigned. */
5943 map->p_type = segment->p_type;
5944 map->p_flags = segment->p_flags;
5945 map->p_flags_valid = 1;
5946 map->p_paddr = suggested_lma;
5947 map->p_paddr_valid = p_paddr_valid;
5948 map->includes_filehdr = 0;
5949 map->includes_phdrs = 0;
5952 while (isec < section_count);
5957 elf_tdata (obfd)->segment_map = map_first;
5959 /* If we had to estimate the number of program headers that were
5960 going to be needed, then check our estimate now and adjust
5961 the offset if necessary. */
5962 if (phdr_adjust_seg != NULL)
5966 for (count = 0, map = map_first; map != NULL; map = map->next)
5969 if (count > phdr_adjust_num)
5970 phdr_adjust_seg->p_paddr
5971 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5976 #undef IS_CONTAINED_BY_VMA
5977 #undef IS_CONTAINED_BY_LMA
5979 #undef IS_COREFILE_NOTE
5980 #undef IS_SOLARIS_PT_INTERP
5981 #undef IS_SECTION_IN_INPUT_SEGMENT
5982 #undef INCLUDE_SECTION_IN_SEGMENT
5983 #undef SEGMENT_AFTER_SEGMENT
5984 #undef SEGMENT_OVERLAPS
5988 /* Copy ELF program header information. */
5991 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5993 Elf_Internal_Ehdr *iehdr;
5994 struct elf_segment_map *map;
5995 struct elf_segment_map *map_first;
5996 struct elf_segment_map **pointer_to_map;
5997 Elf_Internal_Phdr *segment;
5999 unsigned int num_segments;
6000 bfd_boolean phdr_included = FALSE;
6001 bfd_boolean p_paddr_valid;
6003 iehdr = elf_elfheader (ibfd);
6006 pointer_to_map = &map_first;
6008 /* If all the segment p_paddr fields are zero, don't set
6009 map->p_paddr_valid. */
6010 p_paddr_valid = FALSE;
6011 num_segments = elf_elfheader (ibfd)->e_phnum;
6012 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6015 if (segment->p_paddr != 0)
6017 p_paddr_valid = TRUE;
6021 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6026 unsigned int section_count;
6028 Elf_Internal_Shdr *this_hdr;
6029 asection *first_section = NULL;
6030 asection *lowest_section;
6032 /* Compute how many sections are in this segment. */
6033 for (section = ibfd->sections, section_count = 0;
6035 section = section->next)
6037 this_hdr = &(elf_section_data(section)->this_hdr);
6038 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6040 if (first_section == NULL)
6041 first_section = section;
6046 /* Allocate a segment map big enough to contain
6047 all of the sections we have selected. */
6048 amt = sizeof (struct elf_segment_map);
6049 if (section_count != 0)
6050 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6051 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6055 /* Initialize the fields of the output segment map with the
6058 map->p_type = segment->p_type;
6059 map->p_flags = segment->p_flags;
6060 map->p_flags_valid = 1;
6061 map->p_paddr = segment->p_paddr;
6062 map->p_paddr_valid = p_paddr_valid;
6063 map->p_align = segment->p_align;
6064 map->p_align_valid = 1;
6065 map->p_vaddr_offset = 0;
6067 if (map->p_type == PT_GNU_RELRO)
6069 /* The PT_GNU_RELRO segment may contain the first a few
6070 bytes in the .got.plt section even if the whole .got.plt
6071 section isn't in the PT_GNU_RELRO segment. We won't
6072 change the size of the PT_GNU_RELRO segment. */
6073 map->p_size = segment->p_memsz;
6074 map->p_size_valid = 1;
6077 /* Determine if this segment contains the ELF file header
6078 and if it contains the program headers themselves. */
6079 map->includes_filehdr = (segment->p_offset == 0
6080 && segment->p_filesz >= iehdr->e_ehsize);
6082 map->includes_phdrs = 0;
6083 if (! phdr_included || segment->p_type != PT_LOAD)
6085 map->includes_phdrs =
6086 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6087 && (segment->p_offset + segment->p_filesz
6088 >= ((bfd_vma) iehdr->e_phoff
6089 + iehdr->e_phnum * iehdr->e_phentsize)));
6091 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6092 phdr_included = TRUE;
6095 lowest_section = first_section;
6096 if (section_count != 0)
6098 unsigned int isec = 0;
6100 for (section = first_section;
6102 section = section->next)
6104 this_hdr = &(elf_section_data(section)->this_hdr);
6105 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6107 map->sections[isec++] = section->output_section;
6108 if (section->lma < lowest_section->lma)
6109 lowest_section = section;
6110 if ((section->flags & SEC_ALLOC) != 0)
6114 /* Section lmas are set up from PT_LOAD header
6115 p_paddr in _bfd_elf_make_section_from_shdr.
6116 If this header has a p_paddr that disagrees
6117 with the section lma, flag the p_paddr as
6119 if ((section->flags & SEC_LOAD) != 0)
6120 seg_off = this_hdr->sh_offset - segment->p_offset;
6122 seg_off = this_hdr->sh_addr - segment->p_vaddr;
6123 if (section->lma - segment->p_paddr != seg_off)
6124 map->p_paddr_valid = FALSE;
6126 if (isec == section_count)
6132 if (map->includes_filehdr && lowest_section != NULL)
6133 /* We need to keep the space used by the headers fixed. */
6134 map->header_size = lowest_section->vma - segment->p_vaddr;
6136 if (!map->includes_phdrs
6137 && !map->includes_filehdr
6138 && map->p_paddr_valid)
6139 /* There is some other padding before the first section. */
6140 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
6141 - segment->p_paddr);
6143 map->count = section_count;
6144 *pointer_to_map = map;
6145 pointer_to_map = &map->next;
6148 elf_tdata (obfd)->segment_map = map_first;
6152 /* Copy private BFD data. This copies or rewrites ELF program header
6156 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6158 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6159 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6162 if (elf_tdata (ibfd)->phdr == NULL)
6165 if (ibfd->xvec == obfd->xvec)
6167 /* Check to see if any sections in the input BFD
6168 covered by ELF program header have changed. */
6169 Elf_Internal_Phdr *segment;
6170 asection *section, *osec;
6171 unsigned int i, num_segments;
6172 Elf_Internal_Shdr *this_hdr;
6173 const struct elf_backend_data *bed;
6175 bed = get_elf_backend_data (ibfd);
6177 /* Regenerate the segment map if p_paddr is set to 0. */
6178 if (bed->want_p_paddr_set_to_zero)
6181 /* Initialize the segment mark field. */
6182 for (section = obfd->sections; section != NULL;
6183 section = section->next)
6184 section->segment_mark = FALSE;
6186 num_segments = elf_elfheader (ibfd)->e_phnum;
6187 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6191 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6192 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6193 which severly confuses things, so always regenerate the segment
6194 map in this case. */
6195 if (segment->p_paddr == 0
6196 && segment->p_memsz == 0
6197 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
6200 for (section = ibfd->sections;
6201 section != NULL; section = section->next)
6203 /* We mark the output section so that we know it comes
6204 from the input BFD. */
6205 osec = section->output_section;
6207 osec->segment_mark = TRUE;
6209 /* Check if this section is covered by the segment. */
6210 this_hdr = &(elf_section_data(section)->this_hdr);
6211 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6213 /* FIXME: Check if its output section is changed or
6214 removed. What else do we need to check? */
6216 || section->flags != osec->flags
6217 || section->lma != osec->lma
6218 || section->vma != osec->vma
6219 || section->size != osec->size
6220 || section->rawsize != osec->rawsize
6221 || section->alignment_power != osec->alignment_power)
6227 /* Check to see if any output section do not come from the
6229 for (section = obfd->sections; section != NULL;
6230 section = section->next)
6232 if (section->segment_mark == FALSE)
6235 section->segment_mark = FALSE;
6238 return copy_elf_program_header (ibfd, obfd);
6242 return rewrite_elf_program_header (ibfd, obfd);
6245 /* Initialize private output section information from input section. */
6248 _bfd_elf_init_private_section_data (bfd *ibfd,
6252 struct bfd_link_info *link_info)
6255 Elf_Internal_Shdr *ihdr, *ohdr;
6256 bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
6258 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6259 || obfd->xvec->flavour != bfd_target_elf_flavour)
6262 /* For objcopy and relocatable link, don't copy the output ELF
6263 section type from input if the output BFD section flags have been
6264 set to something different. For a final link allow some flags
6265 that the linker clears to differ. */
6266 if (elf_section_type (osec) == SHT_NULL
6267 && (osec->flags == isec->flags
6269 && ((osec->flags ^ isec->flags)
6270 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
6271 elf_section_type (osec) = elf_section_type (isec);
6273 /* FIXME: Is this correct for all OS/PROC specific flags? */
6274 elf_section_flags (osec) |= (elf_section_flags (isec)
6275 & (SHF_MASKOS | SHF_MASKPROC));
6277 /* Set things up for objcopy and relocatable link. The output
6278 SHT_GROUP section will have its elf_next_in_group pointing back
6279 to the input group members. Ignore linker created group section.
6280 See elfNN_ia64_object_p in elfxx-ia64.c. */
6283 if (elf_sec_group (isec) == NULL
6284 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6286 if (elf_section_flags (isec) & SHF_GROUP)
6287 elf_section_flags (osec) |= SHF_GROUP;
6288 elf_next_in_group (osec) = elf_next_in_group (isec);
6289 elf_section_data (osec)->group = elf_section_data (isec)->group;
6293 ihdr = &elf_section_data (isec)->this_hdr;
6295 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6296 don't use the output section of the linked-to section since it
6297 may be NULL at this point. */
6298 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6300 ohdr = &elf_section_data (osec)->this_hdr;
6301 ohdr->sh_flags |= SHF_LINK_ORDER;
6302 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6305 osec->use_rela_p = isec->use_rela_p;
6310 /* Copy private section information. This copies over the entsize
6311 field, and sometimes the info field. */
6314 _bfd_elf_copy_private_section_data (bfd *ibfd,
6319 Elf_Internal_Shdr *ihdr, *ohdr;
6321 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6322 || obfd->xvec->flavour != bfd_target_elf_flavour)
6325 ihdr = &elf_section_data (isec)->this_hdr;
6326 ohdr = &elf_section_data (osec)->this_hdr;
6328 ohdr->sh_entsize = ihdr->sh_entsize;
6330 if (ihdr->sh_type == SHT_SYMTAB
6331 || ihdr->sh_type == SHT_DYNSYM
6332 || ihdr->sh_type == SHT_GNU_verneed
6333 || ihdr->sh_type == SHT_GNU_verdef)
6334 ohdr->sh_info = ihdr->sh_info;
6336 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6340 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6341 necessary if we are removing either the SHT_GROUP section or any of
6342 the group member sections. DISCARDED is the value that a section's
6343 output_section has if the section will be discarded, NULL when this
6344 function is called from objcopy, bfd_abs_section_ptr when called
6348 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
6352 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6353 if (elf_section_type (isec) == SHT_GROUP)
6355 asection *first = elf_next_in_group (isec);
6356 asection *s = first;
6357 bfd_size_type removed = 0;
6361 /* If this member section is being output but the
6362 SHT_GROUP section is not, then clear the group info
6363 set up by _bfd_elf_copy_private_section_data. */
6364 if (s->output_section != discarded
6365 && isec->output_section == discarded)
6367 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6368 elf_group_name (s->output_section) = NULL;
6370 /* Conversely, if the member section is not being output
6371 but the SHT_GROUP section is, then adjust its size. */
6372 else if (s->output_section == discarded
6373 && isec->output_section != discarded)
6375 s = elf_next_in_group (s);
6381 if (discarded != NULL)
6383 /* If we've been called for ld -r, then we need to
6384 adjust the input section size. This function may
6385 be called multiple times, so save the original
6387 if (isec->rawsize == 0)
6388 isec->rawsize = isec->size;
6389 isec->size = isec->rawsize - removed;
6393 /* Adjust the output section size when called from
6395 isec->output_section->size -= removed;
6403 /* Copy private header information. */
6406 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6408 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6409 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6412 /* Copy over private BFD data if it has not already been copied.
6413 This must be done here, rather than in the copy_private_bfd_data
6414 entry point, because the latter is called after the section
6415 contents have been set, which means that the program headers have
6416 already been worked out. */
6417 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6419 if (! copy_private_bfd_data (ibfd, obfd))
6423 return _bfd_elf_fixup_group_sections (ibfd, NULL);
6426 /* Copy private symbol information. If this symbol is in a section
6427 which we did not map into a BFD section, try to map the section
6428 index correctly. We use special macro definitions for the mapped
6429 section indices; these definitions are interpreted by the
6430 swap_out_syms function. */
6432 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6433 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6434 #define MAP_STRTAB (SHN_HIOS + 3)
6435 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6436 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6439 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6444 elf_symbol_type *isym, *osym;
6446 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6447 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6450 isym = elf_symbol_from (ibfd, isymarg);
6451 osym = elf_symbol_from (obfd, osymarg);
6454 && isym->internal_elf_sym.st_shndx != 0
6456 && bfd_is_abs_section (isym->symbol.section))
6460 shndx = isym->internal_elf_sym.st_shndx;
6461 if (shndx == elf_onesymtab (ibfd))
6462 shndx = MAP_ONESYMTAB;
6463 else if (shndx == elf_dynsymtab (ibfd))
6464 shndx = MAP_DYNSYMTAB;
6465 else if (shndx == elf_tdata (ibfd)->strtab_section)
6467 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6468 shndx = MAP_SHSTRTAB;
6469 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6470 shndx = MAP_SYM_SHNDX;
6471 osym->internal_elf_sym.st_shndx = shndx;
6477 /* Swap out the symbols. */
6480 swap_out_syms (bfd *abfd,
6481 struct bfd_strtab_hash **sttp,
6484 const struct elf_backend_data *bed;
6487 struct bfd_strtab_hash *stt;
6488 Elf_Internal_Shdr *symtab_hdr;
6489 Elf_Internal_Shdr *symtab_shndx_hdr;
6490 Elf_Internal_Shdr *symstrtab_hdr;
6491 bfd_byte *outbound_syms;
6492 bfd_byte *outbound_shndx;
6495 bfd_boolean name_local_sections;
6497 if (!elf_map_symbols (abfd))
6500 /* Dump out the symtabs. */
6501 stt = _bfd_elf_stringtab_init ();
6505 bed = get_elf_backend_data (abfd);
6506 symcount = bfd_get_symcount (abfd);
6507 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6508 symtab_hdr->sh_type = SHT_SYMTAB;
6509 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6510 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6511 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6512 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6514 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6515 symstrtab_hdr->sh_type = SHT_STRTAB;
6517 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6518 bed->s->sizeof_sym);
6519 if (outbound_syms == NULL)
6521 _bfd_stringtab_free (stt);
6524 symtab_hdr->contents = outbound_syms;
6526 outbound_shndx = NULL;
6527 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6528 if (symtab_shndx_hdr->sh_name != 0)
6530 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6531 outbound_shndx = (bfd_byte *)
6532 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
6533 if (outbound_shndx == NULL)
6535 _bfd_stringtab_free (stt);
6539 symtab_shndx_hdr->contents = outbound_shndx;
6540 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6541 symtab_shndx_hdr->sh_size = amt;
6542 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6543 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6546 /* Now generate the data (for "contents"). */
6548 /* Fill in zeroth symbol and swap it out. */
6549 Elf_Internal_Sym sym;
6555 sym.st_shndx = SHN_UNDEF;
6556 sym.st_target_internal = 0;
6557 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6558 outbound_syms += bed->s->sizeof_sym;
6559 if (outbound_shndx != NULL)
6560 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6564 = (bed->elf_backend_name_local_section_symbols
6565 && bed->elf_backend_name_local_section_symbols (abfd));
6567 syms = bfd_get_outsymbols (abfd);
6568 for (idx = 0; idx < symcount; idx++)
6570 Elf_Internal_Sym sym;
6571 bfd_vma value = syms[idx]->value;
6572 elf_symbol_type *type_ptr;
6573 flagword flags = syms[idx]->flags;
6576 if (!name_local_sections
6577 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6579 /* Local section symbols have no name. */
6584 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6587 if (sym.st_name == (unsigned long) -1)
6589 _bfd_stringtab_free (stt);
6594 type_ptr = elf_symbol_from (abfd, syms[idx]);
6596 if ((flags & BSF_SECTION_SYM) == 0
6597 && bfd_is_com_section (syms[idx]->section))
6599 /* ELF common symbols put the alignment into the `value' field,
6600 and the size into the `size' field. This is backwards from
6601 how BFD handles it, so reverse it here. */
6602 sym.st_size = value;
6603 if (type_ptr == NULL
6604 || type_ptr->internal_elf_sym.st_value == 0)
6605 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6607 sym.st_value = type_ptr->internal_elf_sym.st_value;
6608 sym.st_shndx = _bfd_elf_section_from_bfd_section
6609 (abfd, syms[idx]->section);
6613 asection *sec = syms[idx]->section;
6616 if (sec->output_section)
6618 value += sec->output_offset;
6619 sec = sec->output_section;
6622 /* Don't add in the section vma for relocatable output. */
6623 if (! relocatable_p)
6625 sym.st_value = value;
6626 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6628 if (bfd_is_abs_section (sec)
6630 && type_ptr->internal_elf_sym.st_shndx != 0)
6632 /* This symbol is in a real ELF section which we did
6633 not create as a BFD section. Undo the mapping done
6634 by copy_private_symbol_data. */
6635 shndx = type_ptr->internal_elf_sym.st_shndx;
6639 shndx = elf_onesymtab (abfd);
6642 shndx = elf_dynsymtab (abfd);
6645 shndx = elf_tdata (abfd)->strtab_section;
6648 shndx = elf_tdata (abfd)->shstrtab_section;
6651 shndx = elf_tdata (abfd)->symtab_shndx_section;
6659 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6661 if (shndx == SHN_BAD)
6665 /* Writing this would be a hell of a lot easier if
6666 we had some decent documentation on bfd, and
6667 knew what to expect of the library, and what to
6668 demand of applications. For example, it
6669 appears that `objcopy' might not set the
6670 section of a symbol to be a section that is
6671 actually in the output file. */
6672 sec2 = bfd_get_section_by_name (abfd, sec->name);
6675 _bfd_error_handler (_("\
6676 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6677 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6679 bfd_set_error (bfd_error_invalid_operation);
6680 _bfd_stringtab_free (stt);
6684 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6685 BFD_ASSERT (shndx != SHN_BAD);
6689 sym.st_shndx = shndx;
6692 if ((flags & BSF_THREAD_LOCAL) != 0)
6694 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6695 type = STT_GNU_IFUNC;
6696 else if ((flags & BSF_FUNCTION) != 0)
6698 else if ((flags & BSF_OBJECT) != 0)
6700 else if ((flags & BSF_RELC) != 0)
6702 else if ((flags & BSF_SRELC) != 0)
6707 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6710 /* Processor-specific types. */
6711 if (type_ptr != NULL
6712 && bed->elf_backend_get_symbol_type)
6713 type = ((*bed->elf_backend_get_symbol_type)
6714 (&type_ptr->internal_elf_sym, type));
6716 if (flags & BSF_SECTION_SYM)
6718 if (flags & BSF_GLOBAL)
6719 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6721 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6723 else if (bfd_is_com_section (syms[idx]->section))
6725 #ifdef USE_STT_COMMON
6726 if (type == STT_OBJECT)
6727 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6730 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6732 else if (bfd_is_und_section (syms[idx]->section))
6733 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6737 else if (flags & BSF_FILE)
6738 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6741 int bind = STB_LOCAL;
6743 if (flags & BSF_LOCAL)
6745 else if (flags & BSF_GNU_UNIQUE)
6746 bind = STB_GNU_UNIQUE;
6747 else if (flags & BSF_WEAK)
6749 else if (flags & BSF_GLOBAL)
6752 sym.st_info = ELF_ST_INFO (bind, type);
6755 if (type_ptr != NULL)
6757 sym.st_other = type_ptr->internal_elf_sym.st_other;
6758 sym.st_target_internal
6759 = type_ptr->internal_elf_sym.st_target_internal;
6764 sym.st_target_internal = 0;
6767 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6768 outbound_syms += bed->s->sizeof_sym;
6769 if (outbound_shndx != NULL)
6770 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6774 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6775 symstrtab_hdr->sh_type = SHT_STRTAB;
6777 symstrtab_hdr->sh_flags = 0;
6778 symstrtab_hdr->sh_addr = 0;
6779 symstrtab_hdr->sh_entsize = 0;
6780 symstrtab_hdr->sh_link = 0;
6781 symstrtab_hdr->sh_info = 0;
6782 symstrtab_hdr->sh_addralign = 1;
6787 /* Return the number of bytes required to hold the symtab vector.
6789 Note that we base it on the count plus 1, since we will null terminate
6790 the vector allocated based on this size. However, the ELF symbol table
6791 always has a dummy entry as symbol #0, so it ends up even. */
6794 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6798 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6800 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6801 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6803 symtab_size -= sizeof (asymbol *);
6809 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6813 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6815 if (elf_dynsymtab (abfd) == 0)
6817 bfd_set_error (bfd_error_invalid_operation);
6821 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6822 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6824 symtab_size -= sizeof (asymbol *);
6830 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6833 return (asect->reloc_count + 1) * sizeof (arelent *);
6836 /* Canonicalize the relocs. */
6839 _bfd_elf_canonicalize_reloc (bfd *abfd,
6846 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6848 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6851 tblptr = section->relocation;
6852 for (i = 0; i < section->reloc_count; i++)
6853 *relptr++ = tblptr++;
6857 return section->reloc_count;
6861 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6863 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6864 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6867 bfd_get_symcount (abfd) = symcount;
6872 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6873 asymbol **allocation)
6875 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6876 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6879 bfd_get_dynamic_symcount (abfd) = symcount;
6883 /* Return the size required for the dynamic reloc entries. Any loadable
6884 section that was actually installed in the BFD, and has type SHT_REL
6885 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6886 dynamic reloc section. */
6889 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6894 if (elf_dynsymtab (abfd) == 0)
6896 bfd_set_error (bfd_error_invalid_operation);
6900 ret = sizeof (arelent *);
6901 for (s = abfd->sections; s != NULL; s = s->next)
6902 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6903 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6904 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6905 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6906 * sizeof (arelent *));
6911 /* Canonicalize the dynamic relocation entries. Note that we return the
6912 dynamic relocations as a single block, although they are actually
6913 associated with particular sections; the interface, which was
6914 designed for SunOS style shared libraries, expects that there is only
6915 one set of dynamic relocs. Any loadable section that was actually
6916 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6917 dynamic symbol table, is considered to be a dynamic reloc section. */
6920 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6924 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6928 if (elf_dynsymtab (abfd) == 0)
6930 bfd_set_error (bfd_error_invalid_operation);
6934 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6936 for (s = abfd->sections; s != NULL; s = s->next)
6938 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6939 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6940 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6945 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6947 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6949 for (i = 0; i < count; i++)
6960 /* Read in the version information. */
6963 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6965 bfd_byte *contents = NULL;
6966 unsigned int freeidx = 0;
6968 if (elf_dynverref (abfd) != 0)
6970 Elf_Internal_Shdr *hdr;
6971 Elf_External_Verneed *everneed;
6972 Elf_Internal_Verneed *iverneed;
6974 bfd_byte *contents_end;
6976 hdr = &elf_tdata (abfd)->dynverref_hdr;
6978 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
6979 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
6980 if (elf_tdata (abfd)->verref == NULL)
6983 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6985 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
6986 if (contents == NULL)
6988 error_return_verref:
6989 elf_tdata (abfd)->verref = NULL;
6990 elf_tdata (abfd)->cverrefs = 0;
6993 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6994 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6995 goto error_return_verref;
6997 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6998 goto error_return_verref;
7000 BFD_ASSERT (sizeof (Elf_External_Verneed)
7001 == sizeof (Elf_External_Vernaux));
7002 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
7003 everneed = (Elf_External_Verneed *) contents;
7004 iverneed = elf_tdata (abfd)->verref;
7005 for (i = 0; i < hdr->sh_info; i++, iverneed++)
7007 Elf_External_Vernaux *evernaux;
7008 Elf_Internal_Vernaux *ivernaux;
7011 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7013 iverneed->vn_bfd = abfd;
7015 iverneed->vn_filename =
7016 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7018 if (iverneed->vn_filename == NULL)
7019 goto error_return_verref;
7021 if (iverneed->vn_cnt == 0)
7022 iverneed->vn_auxptr = NULL;
7025 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7026 bfd_alloc2 (abfd, iverneed->vn_cnt,
7027 sizeof (Elf_Internal_Vernaux));
7028 if (iverneed->vn_auxptr == NULL)
7029 goto error_return_verref;
7032 if (iverneed->vn_aux
7033 > (size_t) (contents_end - (bfd_byte *) everneed))
7034 goto error_return_verref;
7036 evernaux = ((Elf_External_Vernaux *)
7037 ((bfd_byte *) everneed + iverneed->vn_aux));
7038 ivernaux = iverneed->vn_auxptr;
7039 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
7041 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
7043 ivernaux->vna_nodename =
7044 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7045 ivernaux->vna_name);
7046 if (ivernaux->vna_nodename == NULL)
7047 goto error_return_verref;
7049 if (j + 1 < iverneed->vn_cnt)
7050 ivernaux->vna_nextptr = ivernaux + 1;
7052 ivernaux->vna_nextptr = NULL;
7054 if (ivernaux->vna_next
7055 > (size_t) (contents_end - (bfd_byte *) evernaux))
7056 goto error_return_verref;
7058 evernaux = ((Elf_External_Vernaux *)
7059 ((bfd_byte *) evernaux + ivernaux->vna_next));
7061 if (ivernaux->vna_other > freeidx)
7062 freeidx = ivernaux->vna_other;
7065 if (i + 1 < hdr->sh_info)
7066 iverneed->vn_nextref = iverneed + 1;
7068 iverneed->vn_nextref = NULL;
7070 if (iverneed->vn_next
7071 > (size_t) (contents_end - (bfd_byte *) everneed))
7072 goto error_return_verref;
7074 everneed = ((Elf_External_Verneed *)
7075 ((bfd_byte *) everneed + iverneed->vn_next));
7082 if (elf_dynverdef (abfd) != 0)
7084 Elf_Internal_Shdr *hdr;
7085 Elf_External_Verdef *everdef;
7086 Elf_Internal_Verdef *iverdef;
7087 Elf_Internal_Verdef *iverdefarr;
7088 Elf_Internal_Verdef iverdefmem;
7090 unsigned int maxidx;
7091 bfd_byte *contents_end_def, *contents_end_aux;
7093 hdr = &elf_tdata (abfd)->dynverdef_hdr;
7095 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7096 if (contents == NULL)
7098 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7099 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7102 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
7105 BFD_ASSERT (sizeof (Elf_External_Verdef)
7106 >= sizeof (Elf_External_Verdaux));
7107 contents_end_def = contents + hdr->sh_size
7108 - sizeof (Elf_External_Verdef);
7109 contents_end_aux = contents + hdr->sh_size
7110 - sizeof (Elf_External_Verdaux);
7112 /* We know the number of entries in the section but not the maximum
7113 index. Therefore we have to run through all entries and find
7115 everdef = (Elf_External_Verdef *) contents;
7117 for (i = 0; i < hdr->sh_info; ++i)
7119 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7121 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
7122 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
7124 if (iverdefmem.vd_next
7125 > (size_t) (contents_end_def - (bfd_byte *) everdef))
7128 everdef = ((Elf_External_Verdef *)
7129 ((bfd_byte *) everdef + iverdefmem.vd_next));
7132 if (default_imported_symver)
7134 if (freeidx > maxidx)
7139 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7140 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
7141 if (elf_tdata (abfd)->verdef == NULL)
7144 elf_tdata (abfd)->cverdefs = maxidx;
7146 everdef = (Elf_External_Verdef *) contents;
7147 iverdefarr = elf_tdata (abfd)->verdef;
7148 for (i = 0; i < hdr->sh_info; i++)
7150 Elf_External_Verdaux *everdaux;
7151 Elf_Internal_Verdaux *iverdaux;
7154 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7156 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
7158 error_return_verdef:
7159 elf_tdata (abfd)->verdef = NULL;
7160 elf_tdata (abfd)->cverdefs = 0;
7164 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
7165 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
7167 iverdef->vd_bfd = abfd;
7169 if (iverdef->vd_cnt == 0)
7170 iverdef->vd_auxptr = NULL;
7173 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7174 bfd_alloc2 (abfd, iverdef->vd_cnt,
7175 sizeof (Elf_Internal_Verdaux));
7176 if (iverdef->vd_auxptr == NULL)
7177 goto error_return_verdef;
7181 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
7182 goto error_return_verdef;
7184 everdaux = ((Elf_External_Verdaux *)
7185 ((bfd_byte *) everdef + iverdef->vd_aux));
7186 iverdaux = iverdef->vd_auxptr;
7187 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
7189 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
7191 iverdaux->vda_nodename =
7192 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7193 iverdaux->vda_name);
7194 if (iverdaux->vda_nodename == NULL)
7195 goto error_return_verdef;
7197 if (j + 1 < iverdef->vd_cnt)
7198 iverdaux->vda_nextptr = iverdaux + 1;
7200 iverdaux->vda_nextptr = NULL;
7202 if (iverdaux->vda_next
7203 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7204 goto error_return_verdef;
7206 everdaux = ((Elf_External_Verdaux *)
7207 ((bfd_byte *) everdaux + iverdaux->vda_next));
7210 if (iverdef->vd_cnt)
7211 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
7213 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
7214 iverdef->vd_nextdef = iverdef + 1;
7216 iverdef->vd_nextdef = NULL;
7218 everdef = ((Elf_External_Verdef *)
7219 ((bfd_byte *) everdef + iverdef->vd_next));
7225 else if (default_imported_symver)
7232 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7233 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
7234 if (elf_tdata (abfd)->verdef == NULL)
7237 elf_tdata (abfd)->cverdefs = freeidx;
7240 /* Create a default version based on the soname. */
7241 if (default_imported_symver)
7243 Elf_Internal_Verdef *iverdef;
7244 Elf_Internal_Verdaux *iverdaux;
7246 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
7248 iverdef->vd_version = VER_DEF_CURRENT;
7249 iverdef->vd_flags = 0;
7250 iverdef->vd_ndx = freeidx;
7251 iverdef->vd_cnt = 1;
7253 iverdef->vd_bfd = abfd;
7255 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7256 if (iverdef->vd_nodename == NULL)
7257 goto error_return_verdef;
7258 iverdef->vd_nextdef = NULL;
7259 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7260 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
7261 if (iverdef->vd_auxptr == NULL)
7262 goto error_return_verdef;
7264 iverdaux = iverdef->vd_auxptr;
7265 iverdaux->vda_nodename = iverdef->vd_nodename;
7266 iverdaux->vda_nextptr = NULL;
7272 if (contents != NULL)
7278 _bfd_elf_make_empty_symbol (bfd *abfd)
7280 elf_symbol_type *newsym;
7281 bfd_size_type amt = sizeof (elf_symbol_type);
7283 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
7288 newsym->symbol.the_bfd = abfd;
7289 return &newsym->symbol;
7294 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7298 bfd_symbol_info (symbol, ret);
7301 /* Return whether a symbol name implies a local symbol. Most targets
7302 use this function for the is_local_label_name entry point, but some
7306 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7309 /* Normal local symbols start with ``.L''. */
7310 if (name[0] == '.' && name[1] == 'L')
7313 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7314 DWARF debugging symbols starting with ``..''. */
7315 if (name[0] == '.' && name[1] == '.')
7318 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7319 emitting DWARF debugging output. I suspect this is actually a
7320 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7321 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7322 underscore to be emitted on some ELF targets). For ease of use,
7323 we treat such symbols as local. */
7324 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7331 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7332 asymbol *symbol ATTRIBUTE_UNUSED)
7339 _bfd_elf_set_arch_mach (bfd *abfd,
7340 enum bfd_architecture arch,
7341 unsigned long machine)
7343 /* If this isn't the right architecture for this backend, and this
7344 isn't the generic backend, fail. */
7345 if (arch != get_elf_backend_data (abfd)->arch
7346 && arch != bfd_arch_unknown
7347 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7350 return bfd_default_set_arch_mach (abfd, arch, machine);
7353 /* Find the function to a particular section and offset,
7354 for error reporting. */
7357 elf_find_function (bfd *abfd,
7361 const char **filename_ptr,
7362 const char **functionname_ptr)
7364 const char *filename;
7365 asymbol *func, *file;
7368 /* ??? Given multiple file symbols, it is impossible to reliably
7369 choose the right file name for global symbols. File symbols are
7370 local symbols, and thus all file symbols must sort before any
7371 global symbols. The ELF spec may be interpreted to say that a
7372 file symbol must sort before other local symbols, but currently
7373 ld -r doesn't do this. So, for ld -r output, it is possible to
7374 make a better choice of file name for local symbols by ignoring
7375 file symbols appearing after a given local symbol. */
7376 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7377 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7383 state = nothing_seen;
7385 for (p = symbols; *p != NULL; p++)
7390 q = (elf_symbol_type *) *p;
7392 type = ELF_ST_TYPE (q->internal_elf_sym.st_info);
7397 if (state == symbol_seen)
7398 state = file_after_symbol_seen;
7401 if (!bed->is_function_type (type))
7404 if (bfd_get_section (&q->symbol) == section
7405 && q->symbol.value >= low_func
7406 && q->symbol.value <= offset)
7408 func = (asymbol *) q;
7409 low_func = q->symbol.value;
7412 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7413 || state != file_after_symbol_seen))
7414 filename = bfd_asymbol_name (file);
7418 if (state == nothing_seen)
7419 state = symbol_seen;
7426 *filename_ptr = filename;
7427 if (functionname_ptr)
7428 *functionname_ptr = bfd_asymbol_name (func);
7433 /* Find the nearest line to a particular section and offset,
7434 for error reporting. */
7437 _bfd_elf_find_nearest_line (bfd *abfd,
7441 const char **filename_ptr,
7442 const char **functionname_ptr,
7443 unsigned int *line_ptr)
7447 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7448 filename_ptr, functionname_ptr,
7451 if (!*functionname_ptr)
7452 elf_find_function (abfd, section, symbols, offset,
7453 *filename_ptr ? NULL : filename_ptr,
7459 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7460 filename_ptr, functionname_ptr,
7462 &elf_tdata (abfd)->dwarf2_find_line_info))
7464 if (!*functionname_ptr)
7465 elf_find_function (abfd, section, symbols, offset,
7466 *filename_ptr ? NULL : filename_ptr,
7472 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7473 &found, filename_ptr,
7474 functionname_ptr, line_ptr,
7475 &elf_tdata (abfd)->line_info))
7477 if (found && (*functionname_ptr || *line_ptr))
7480 if (symbols == NULL)
7483 if (! elf_find_function (abfd, section, symbols, offset,
7484 filename_ptr, functionname_ptr))
7491 /* Find the line for a symbol. */
7494 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7495 const char **filename_ptr, unsigned int *line_ptr)
7497 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7498 filename_ptr, line_ptr, 0,
7499 &elf_tdata (abfd)->dwarf2_find_line_info);
7502 /* After a call to bfd_find_nearest_line, successive calls to
7503 bfd_find_inliner_info can be used to get source information about
7504 each level of function inlining that terminated at the address
7505 passed to bfd_find_nearest_line. Currently this is only supported
7506 for DWARF2 with appropriate DWARF3 extensions. */
7509 _bfd_elf_find_inliner_info (bfd *abfd,
7510 const char **filename_ptr,
7511 const char **functionname_ptr,
7512 unsigned int *line_ptr)
7515 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7516 functionname_ptr, line_ptr,
7517 & elf_tdata (abfd)->dwarf2_find_line_info);
7522 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7524 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7525 int ret = bed->s->sizeof_ehdr;
7527 if (!info->relocatable)
7529 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7531 if (phdr_size == (bfd_size_type) -1)
7533 struct elf_segment_map *m;
7536 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7537 phdr_size += bed->s->sizeof_phdr;
7540 phdr_size = get_program_header_size (abfd, info);
7543 elf_tdata (abfd)->program_header_size = phdr_size;
7551 _bfd_elf_set_section_contents (bfd *abfd,
7553 const void *location,
7555 bfd_size_type count)
7557 Elf_Internal_Shdr *hdr;
7560 if (! abfd->output_has_begun
7561 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7564 hdr = &elf_section_data (section)->this_hdr;
7565 pos = hdr->sh_offset + offset;
7566 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7567 || bfd_bwrite (location, count, abfd) != count)
7574 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7575 arelent *cache_ptr ATTRIBUTE_UNUSED,
7576 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7581 /* Try to convert a non-ELF reloc into an ELF one. */
7584 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7586 /* Check whether we really have an ELF howto. */
7588 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7590 bfd_reloc_code_real_type code;
7591 reloc_howto_type *howto;
7593 /* Alien reloc: Try to determine its type to replace it with an
7594 equivalent ELF reloc. */
7596 if (areloc->howto->pc_relative)
7598 switch (areloc->howto->bitsize)
7601 code = BFD_RELOC_8_PCREL;
7604 code = BFD_RELOC_12_PCREL;
7607 code = BFD_RELOC_16_PCREL;
7610 code = BFD_RELOC_24_PCREL;
7613 code = BFD_RELOC_32_PCREL;
7616 code = BFD_RELOC_64_PCREL;
7622 howto = bfd_reloc_type_lookup (abfd, code);
7624 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7626 if (howto->pcrel_offset)
7627 areloc->addend += areloc->address;
7629 areloc->addend -= areloc->address; /* addend is unsigned!! */
7634 switch (areloc->howto->bitsize)
7640 code = BFD_RELOC_14;
7643 code = BFD_RELOC_16;
7646 code = BFD_RELOC_26;
7649 code = BFD_RELOC_32;
7652 code = BFD_RELOC_64;
7658 howto = bfd_reloc_type_lookup (abfd, code);
7662 areloc->howto = howto;
7670 (*_bfd_error_handler)
7671 (_("%B: unsupported relocation type %s"),
7672 abfd, areloc->howto->name);
7673 bfd_set_error (bfd_error_bad_value);
7678 _bfd_elf_close_and_cleanup (bfd *abfd)
7680 if (bfd_get_format (abfd) == bfd_object)
7682 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7683 _bfd_elf_strtab_free (elf_shstrtab (abfd));
7684 _bfd_dwarf2_cleanup_debug_info (abfd);
7687 return _bfd_generic_close_and_cleanup (abfd);
7690 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7691 in the relocation's offset. Thus we cannot allow any sort of sanity
7692 range-checking to interfere. There is nothing else to do in processing
7695 bfd_reloc_status_type
7696 _bfd_elf_rel_vtable_reloc_fn
7697 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7698 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7699 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7700 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7702 return bfd_reloc_ok;
7705 /* Elf core file support. Much of this only works on native
7706 toolchains, since we rely on knowing the
7707 machine-dependent procfs structure in order to pick
7708 out details about the corefile. */
7710 #ifdef HAVE_SYS_PROCFS_H
7711 /* Needed for new procfs interface on sparc-solaris. */
7712 # define _STRUCTURED_PROC 1
7713 # include <sys/procfs.h>
7716 /* Return a PID that identifies a "thread" for threaded cores, or the
7717 PID of the main process for non-threaded cores. */
7720 elfcore_make_pid (bfd *abfd)
7724 pid = elf_tdata (abfd)->core_lwpid;
7726 pid = elf_tdata (abfd)->core_pid;
7731 /* If there isn't a section called NAME, make one, using
7732 data from SECT. Note, this function will generate a
7733 reference to NAME, so you shouldn't deallocate or
7737 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7741 if (bfd_get_section_by_name (abfd, name) != NULL)
7744 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7748 sect2->size = sect->size;
7749 sect2->filepos = sect->filepos;
7750 sect2->alignment_power = sect->alignment_power;
7754 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7755 actually creates up to two pseudosections:
7756 - For the single-threaded case, a section named NAME, unless
7757 such a section already exists.
7758 - For the multi-threaded case, a section named "NAME/PID", where
7759 PID is elfcore_make_pid (abfd).
7760 Both pseudosections have identical contents. */
7762 _bfd_elfcore_make_pseudosection (bfd *abfd,
7768 char *threaded_name;
7772 /* Build the section name. */
7774 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7775 len = strlen (buf) + 1;
7776 threaded_name = (char *) bfd_alloc (abfd, len);
7777 if (threaded_name == NULL)
7779 memcpy (threaded_name, buf, len);
7781 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7786 sect->filepos = filepos;
7787 sect->alignment_power = 2;
7789 return elfcore_maybe_make_sect (abfd, name, sect);
7792 /* prstatus_t exists on:
7794 linux 2.[01] + glibc
7798 #if defined (HAVE_PRSTATUS_T)
7801 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7806 if (note->descsz == sizeof (prstatus_t))
7810 size = sizeof (prstat.pr_reg);
7811 offset = offsetof (prstatus_t, pr_reg);
7812 memcpy (&prstat, note->descdata, sizeof (prstat));
7814 /* Do not overwrite the core signal if it
7815 has already been set by another thread. */
7816 if (elf_tdata (abfd)->core_signal == 0)
7817 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7818 if (elf_tdata (abfd)->core_pid == 0)
7819 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7821 /* pr_who exists on:
7824 pr_who doesn't exist on:
7827 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7828 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7830 elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
7833 #if defined (HAVE_PRSTATUS32_T)
7834 else if (note->descsz == sizeof (prstatus32_t))
7836 /* 64-bit host, 32-bit corefile */
7837 prstatus32_t prstat;
7839 size = sizeof (prstat.pr_reg);
7840 offset = offsetof (prstatus32_t, pr_reg);
7841 memcpy (&prstat, note->descdata, sizeof (prstat));
7843 /* Do not overwrite the core signal if it
7844 has already been set by another thread. */
7845 if (elf_tdata (abfd)->core_signal == 0)
7846 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7847 if (elf_tdata (abfd)->core_pid == 0)
7848 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7850 /* pr_who exists on:
7853 pr_who doesn't exist on:
7856 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7857 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7859 elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
7862 #endif /* HAVE_PRSTATUS32_T */
7865 /* Fail - we don't know how to handle any other
7866 note size (ie. data object type). */
7870 /* Make a ".reg/999" section and a ".reg" section. */
7871 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7872 size, note->descpos + offset);
7874 #endif /* defined (HAVE_PRSTATUS_T) */
7876 /* Create a pseudosection containing the exact contents of NOTE. */
7878 elfcore_make_note_pseudosection (bfd *abfd,
7880 Elf_Internal_Note *note)
7882 return _bfd_elfcore_make_pseudosection (abfd, name,
7883 note->descsz, note->descpos);
7886 /* There isn't a consistent prfpregset_t across platforms,
7887 but it doesn't matter, because we don't have to pick this
7888 data structure apart. */
7891 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7893 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7896 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7897 type of NT_PRXFPREG. Just include the whole note's contents
7901 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7903 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7906 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
7907 with a note type of NT_X86_XSTATE. Just include the whole note's
7908 contents literally. */
7911 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
7913 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
7917 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7919 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7923 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7925 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7929 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
7931 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
7935 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
7937 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
7941 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
7943 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
7947 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
7949 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
7953 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
7955 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
7959 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
7961 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
7964 #if defined (HAVE_PRPSINFO_T)
7965 typedef prpsinfo_t elfcore_psinfo_t;
7966 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7967 typedef prpsinfo32_t elfcore_psinfo32_t;
7971 #if defined (HAVE_PSINFO_T)
7972 typedef psinfo_t elfcore_psinfo_t;
7973 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7974 typedef psinfo32_t elfcore_psinfo32_t;
7978 /* return a malloc'ed copy of a string at START which is at
7979 most MAX bytes long, possibly without a terminating '\0'.
7980 the copy will always have a terminating '\0'. */
7983 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7986 char *end = (char *) memchr (start, '\0', max);
7994 dups = (char *) bfd_alloc (abfd, len + 1);
7998 memcpy (dups, start, len);
8004 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8006 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
8008 if (note->descsz == sizeof (elfcore_psinfo_t))
8010 elfcore_psinfo_t psinfo;
8012 memcpy (&psinfo, note->descdata, sizeof (psinfo));
8014 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8015 elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8017 elf_tdata (abfd)->core_program
8018 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8019 sizeof (psinfo.pr_fname));
8021 elf_tdata (abfd)->core_command
8022 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8023 sizeof (psinfo.pr_psargs));
8025 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8026 else if (note->descsz == sizeof (elfcore_psinfo32_t))
8028 /* 64-bit host, 32-bit corefile */
8029 elfcore_psinfo32_t psinfo;
8031 memcpy (&psinfo, note->descdata, sizeof (psinfo));
8033 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8034 elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8036 elf_tdata (abfd)->core_program
8037 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8038 sizeof (psinfo.pr_fname));
8040 elf_tdata (abfd)->core_command
8041 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8042 sizeof (psinfo.pr_psargs));
8048 /* Fail - we don't know how to handle any other
8049 note size (ie. data object type). */
8053 /* Note that for some reason, a spurious space is tacked
8054 onto the end of the args in some (at least one anyway)
8055 implementations, so strip it off if it exists. */
8058 char *command = elf_tdata (abfd)->core_command;
8059 int n = strlen (command);
8061 if (0 < n && command[n - 1] == ' ')
8062 command[n - 1] = '\0';
8067 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8069 #if defined (HAVE_PSTATUS_T)
8071 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
8073 if (note->descsz == sizeof (pstatus_t)
8074 #if defined (HAVE_PXSTATUS_T)
8075 || note->descsz == sizeof (pxstatus_t)
8081 memcpy (&pstat, note->descdata, sizeof (pstat));
8083 elf_tdata (abfd)->core_pid = pstat.pr_pid;
8085 #if defined (HAVE_PSTATUS32_T)
8086 else if (note->descsz == sizeof (pstatus32_t))
8088 /* 64-bit host, 32-bit corefile */
8091 memcpy (&pstat, note->descdata, sizeof (pstat));
8093 elf_tdata (abfd)->core_pid = pstat.pr_pid;
8096 /* Could grab some more details from the "representative"
8097 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8098 NT_LWPSTATUS note, presumably. */
8102 #endif /* defined (HAVE_PSTATUS_T) */
8104 #if defined (HAVE_LWPSTATUS_T)
8106 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
8108 lwpstatus_t lwpstat;
8114 if (note->descsz != sizeof (lwpstat)
8115 #if defined (HAVE_LWPXSTATUS_T)
8116 && note->descsz != sizeof (lwpxstatus_t)
8121 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
8123 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
8124 /* Do not overwrite the core signal if it has already been set by
8126 if (elf_tdata (abfd)->core_signal == 0)
8127 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
8129 /* Make a ".reg/999" section. */
8131 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
8132 len = strlen (buf) + 1;
8133 name = bfd_alloc (abfd, len);
8136 memcpy (name, buf, len);
8138 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8142 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8143 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
8144 sect->filepos = note->descpos
8145 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
8148 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8149 sect->size = sizeof (lwpstat.pr_reg);
8150 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
8153 sect->alignment_power = 2;
8155 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
8158 /* Make a ".reg2/999" section */
8160 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
8161 len = strlen (buf) + 1;
8162 name = bfd_alloc (abfd, len);
8165 memcpy (name, buf, len);
8167 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8171 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8172 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
8173 sect->filepos = note->descpos
8174 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
8177 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8178 sect->size = sizeof (lwpstat.pr_fpreg);
8179 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
8182 sect->alignment_power = 2;
8184 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
8186 #endif /* defined (HAVE_LWPSTATUS_T) */
8189 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
8196 int is_active_thread;
8199 if (note->descsz < 728)
8202 if (! CONST_STRNEQ (note->namedata, "win32"))
8205 type = bfd_get_32 (abfd, note->descdata);
8209 case 1 /* NOTE_INFO_PROCESS */:
8210 /* FIXME: need to add ->core_command. */
8211 /* process_info.pid */
8212 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
8213 /* process_info.signal */
8214 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
8217 case 2 /* NOTE_INFO_THREAD */:
8218 /* Make a ".reg/999" section. */
8219 /* thread_info.tid */
8220 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
8222 len = strlen (buf) + 1;
8223 name = (char *) bfd_alloc (abfd, len);
8227 memcpy (name, buf, len);
8229 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8233 /* sizeof (thread_info.thread_context) */
8235 /* offsetof (thread_info.thread_context) */
8236 sect->filepos = note->descpos + 12;
8237 sect->alignment_power = 2;
8239 /* thread_info.is_active_thread */
8240 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8242 if (is_active_thread)
8243 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
8247 case 3 /* NOTE_INFO_MODULE */:
8248 /* Make a ".module/xxxxxxxx" section. */
8249 /* module_info.base_address */
8250 base_addr = bfd_get_32 (abfd, note->descdata + 4);
8251 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
8253 len = strlen (buf) + 1;
8254 name = (char *) bfd_alloc (abfd, len);
8258 memcpy (name, buf, len);
8260 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8265 sect->size = note->descsz;
8266 sect->filepos = note->descpos;
8267 sect->alignment_power = 2;
8278 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
8280 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8288 if (bed->elf_backend_grok_prstatus)
8289 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
8291 #if defined (HAVE_PRSTATUS_T)
8292 return elfcore_grok_prstatus (abfd, note);
8297 #if defined (HAVE_PSTATUS_T)
8299 return elfcore_grok_pstatus (abfd, note);
8302 #if defined (HAVE_LWPSTATUS_T)
8304 return elfcore_grok_lwpstatus (abfd, note);
8307 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
8308 return elfcore_grok_prfpreg (abfd, note);
8310 case NT_WIN32PSTATUS:
8311 return elfcore_grok_win32pstatus (abfd, note);
8313 case NT_PRXFPREG: /* Linux SSE extension */
8314 if (note->namesz == 6
8315 && strcmp (note->namedata, "LINUX") == 0)
8316 return elfcore_grok_prxfpreg (abfd, note);
8320 case NT_X86_XSTATE: /* Linux XSAVE extension */
8321 if (note->namesz == 6
8322 && strcmp (note->namedata, "LINUX") == 0)
8323 return elfcore_grok_xstatereg (abfd, note);
8328 if (note->namesz == 6
8329 && strcmp (note->namedata, "LINUX") == 0)
8330 return elfcore_grok_ppc_vmx (abfd, note);
8335 if (note->namesz == 6
8336 && strcmp (note->namedata, "LINUX") == 0)
8337 return elfcore_grok_ppc_vsx (abfd, note);
8341 case NT_S390_HIGH_GPRS:
8342 if (note->namesz == 6
8343 && strcmp (note->namedata, "LINUX") == 0)
8344 return elfcore_grok_s390_high_gprs (abfd, note);
8349 if (note->namesz == 6
8350 && strcmp (note->namedata, "LINUX") == 0)
8351 return elfcore_grok_s390_timer (abfd, note);
8355 case NT_S390_TODCMP:
8356 if (note->namesz == 6
8357 && strcmp (note->namedata, "LINUX") == 0)
8358 return elfcore_grok_s390_todcmp (abfd, note);
8362 case NT_S390_TODPREG:
8363 if (note->namesz == 6
8364 && strcmp (note->namedata, "LINUX") == 0)
8365 return elfcore_grok_s390_todpreg (abfd, note);
8370 if (note->namesz == 6
8371 && strcmp (note->namedata, "LINUX") == 0)
8372 return elfcore_grok_s390_ctrs (abfd, note);
8376 case NT_S390_PREFIX:
8377 if (note->namesz == 6
8378 && strcmp (note->namedata, "LINUX") == 0)
8379 return elfcore_grok_s390_prefix (abfd, note);
8385 if (bed->elf_backend_grok_psinfo)
8386 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
8388 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8389 return elfcore_grok_psinfo (abfd, note);
8396 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8401 sect->size = note->descsz;
8402 sect->filepos = note->descpos;
8403 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8411 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8413 elf_tdata (abfd)->build_id_size = note->descsz;
8414 elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz);
8415 if (elf_tdata (abfd)->build_id == NULL)
8418 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8424 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8431 case NT_GNU_BUILD_ID:
8432 return elfobj_grok_gnu_build_id (abfd, note);
8437 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
8439 struct sdt_note *cur =
8440 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
8443 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
8444 cur->size = (bfd_size_type) note->descsz;
8445 memcpy (cur->data, note->descdata, note->descsz);
8447 elf_tdata (abfd)->sdt_note_head = cur;
8453 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
8458 return elfobj_grok_stapsdt_note_1 (abfd, note);
8466 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8470 cp = strchr (note->namedata, '@');
8473 *lwpidp = atoi(cp + 1);
8480 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8482 /* Signal number at offset 0x08. */
8483 elf_tdata (abfd)->core_signal
8484 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8486 /* Process ID at offset 0x50. */
8487 elf_tdata (abfd)->core_pid
8488 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8490 /* Command name at 0x7c (max 32 bytes, including nul). */
8491 elf_tdata (abfd)->core_command
8492 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8494 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8499 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8503 if (elfcore_netbsd_get_lwpid (note, &lwp))
8504 elf_tdata (abfd)->core_lwpid = lwp;
8506 if (note->type == NT_NETBSDCORE_PROCINFO)
8508 /* NetBSD-specific core "procinfo". Note that we expect to
8509 find this note before any of the others, which is fine,
8510 since the kernel writes this note out first when it
8511 creates a core file. */
8513 return elfcore_grok_netbsd_procinfo (abfd, note);
8516 /* As of Jan 2002 there are no other machine-independent notes
8517 defined for NetBSD core files. If the note type is less
8518 than the start of the machine-dependent note types, we don't
8521 if (note->type < NT_NETBSDCORE_FIRSTMACH)
8525 switch (bfd_get_arch (abfd))
8527 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8528 PT_GETFPREGS == mach+2. */
8530 case bfd_arch_alpha:
8531 case bfd_arch_sparc:
8534 case NT_NETBSDCORE_FIRSTMACH+0:
8535 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8537 case NT_NETBSDCORE_FIRSTMACH+2:
8538 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8544 /* On all other arch's, PT_GETREGS == mach+1 and
8545 PT_GETFPREGS == mach+3. */
8550 case NT_NETBSDCORE_FIRSTMACH+1:
8551 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8553 case NT_NETBSDCORE_FIRSTMACH+3:
8554 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8564 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8566 /* Signal number at offset 0x08. */
8567 elf_tdata (abfd)->core_signal
8568 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8570 /* Process ID at offset 0x20. */
8571 elf_tdata (abfd)->core_pid
8572 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8574 /* Command name at 0x48 (max 32 bytes, including nul). */
8575 elf_tdata (abfd)->core_command
8576 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8582 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8584 if (note->type == NT_OPENBSD_PROCINFO)
8585 return elfcore_grok_openbsd_procinfo (abfd, note);
8587 if (note->type == NT_OPENBSD_REGS)
8588 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8590 if (note->type == NT_OPENBSD_FPREGS)
8591 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8593 if (note->type == NT_OPENBSD_XFPREGS)
8594 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8596 if (note->type == NT_OPENBSD_AUXV)
8598 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8603 sect->size = note->descsz;
8604 sect->filepos = note->descpos;
8605 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8610 if (note->type == NT_OPENBSD_WCOOKIE)
8612 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8617 sect->size = note->descsz;
8618 sect->filepos = note->descpos;
8619 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8628 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8630 void *ddata = note->descdata;
8637 /* nto_procfs_status 'pid' field is at offset 0. */
8638 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8640 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8641 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8643 /* nto_procfs_status 'flags' field is at offset 8. */
8644 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8646 /* nto_procfs_status 'what' field is at offset 14. */
8647 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8649 elf_tdata (abfd)->core_signal = sig;
8650 elf_tdata (abfd)->core_lwpid = *tid;
8653 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8654 do not come from signals so we make sure we set the current
8655 thread just in case. */
8656 if (flags & 0x00000080)
8657 elf_tdata (abfd)->core_lwpid = *tid;
8659 /* Make a ".qnx_core_status/%d" section. */
8660 sprintf (buf, ".qnx_core_status/%ld", *tid);
8662 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8667 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8671 sect->size = note->descsz;
8672 sect->filepos = note->descpos;
8673 sect->alignment_power = 2;
8675 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8679 elfcore_grok_nto_regs (bfd *abfd,
8680 Elf_Internal_Note *note,
8688 /* Make a "(base)/%d" section. */
8689 sprintf (buf, "%s/%ld", base, tid);
8691 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8696 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8700 sect->size = note->descsz;
8701 sect->filepos = note->descpos;
8702 sect->alignment_power = 2;
8704 /* This is the current thread. */
8705 if (elf_tdata (abfd)->core_lwpid == tid)
8706 return elfcore_maybe_make_sect (abfd, base, sect);
8711 #define BFD_QNT_CORE_INFO 7
8712 #define BFD_QNT_CORE_STATUS 8
8713 #define BFD_QNT_CORE_GREG 9
8714 #define BFD_QNT_CORE_FPREG 10
8717 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8719 /* Every GREG section has a STATUS section before it. Store the
8720 tid from the previous call to pass down to the next gregs
8722 static long tid = 1;
8726 case BFD_QNT_CORE_INFO:
8727 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8728 case BFD_QNT_CORE_STATUS:
8729 return elfcore_grok_nto_status (abfd, note, &tid);
8730 case BFD_QNT_CORE_GREG:
8731 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8732 case BFD_QNT_CORE_FPREG:
8733 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8740 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8746 /* Use note name as section name. */
8748 name = (char *) bfd_alloc (abfd, len);
8751 memcpy (name, note->namedata, len);
8752 name[len - 1] = '\0';
8754 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8758 sect->size = note->descsz;
8759 sect->filepos = note->descpos;
8760 sect->alignment_power = 1;
8765 /* Function: elfcore_write_note
8768 buffer to hold note, and current size of buffer
8772 size of data for note
8774 Writes note to end of buffer. ELF64 notes are written exactly as
8775 for ELF32, despite the current (as of 2006) ELF gabi specifying
8776 that they ought to have 8-byte namesz and descsz field, and have
8777 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8780 Pointer to realloc'd buffer, *BUFSIZ updated. */
8783 elfcore_write_note (bfd *abfd,
8791 Elf_External_Note *xnp;
8798 namesz = strlen (name) + 1;
8800 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8802 buf = (char *) realloc (buf, *bufsiz + newspace);
8805 dest = buf + *bufsiz;
8806 *bufsiz += newspace;
8807 xnp = (Elf_External_Note *) dest;
8808 H_PUT_32 (abfd, namesz, xnp->namesz);
8809 H_PUT_32 (abfd, size, xnp->descsz);
8810 H_PUT_32 (abfd, type, xnp->type);
8814 memcpy (dest, name, namesz);
8822 memcpy (dest, input, size);
8832 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8834 elfcore_write_prpsinfo (bfd *abfd,
8840 const char *note_name = "CORE";
8841 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8843 if (bed->elf_backend_write_core_note != NULL)
8846 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8847 NT_PRPSINFO, fname, psargs);
8852 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8853 if (bed->s->elfclass == ELFCLASS32)
8855 #if defined (HAVE_PSINFO32_T)
8857 int note_type = NT_PSINFO;
8860 int note_type = NT_PRPSINFO;
8863 memset (&data, 0, sizeof (data));
8864 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8865 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8866 return elfcore_write_note (abfd, buf, bufsiz,
8867 note_name, note_type, &data, sizeof (data));
8872 #if defined (HAVE_PSINFO_T)
8874 int note_type = NT_PSINFO;
8877 int note_type = NT_PRPSINFO;
8880 memset (&data, 0, sizeof (data));
8881 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8882 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8883 return elfcore_write_note (abfd, buf, bufsiz,
8884 note_name, note_type, &data, sizeof (data));
8887 #endif /* PSINFO_T or PRPSINFO_T */
8889 #if defined (HAVE_PRSTATUS_T)
8891 elfcore_write_prstatus (bfd *abfd,
8898 const char *note_name = "CORE";
8899 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8901 if (bed->elf_backend_write_core_note != NULL)
8904 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8906 pid, cursig, gregs);
8911 #if defined (HAVE_PRSTATUS32_T)
8912 if (bed->s->elfclass == ELFCLASS32)
8914 prstatus32_t prstat;
8916 memset (&prstat, 0, sizeof (prstat));
8917 prstat.pr_pid = pid;
8918 prstat.pr_cursig = cursig;
8919 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8920 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8921 NT_PRSTATUS, &prstat, sizeof (prstat));
8928 memset (&prstat, 0, sizeof (prstat));
8929 prstat.pr_pid = pid;
8930 prstat.pr_cursig = cursig;
8931 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8932 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8933 NT_PRSTATUS, &prstat, sizeof (prstat));
8936 #endif /* HAVE_PRSTATUS_T */
8938 #if defined (HAVE_LWPSTATUS_T)
8940 elfcore_write_lwpstatus (bfd *abfd,
8947 lwpstatus_t lwpstat;
8948 const char *note_name = "CORE";
8950 memset (&lwpstat, 0, sizeof (lwpstat));
8951 lwpstat.pr_lwpid = pid >> 16;
8952 lwpstat.pr_cursig = cursig;
8953 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8954 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8955 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8957 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8958 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8960 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8961 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8964 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8965 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8967 #endif /* HAVE_LWPSTATUS_T */
8969 #if defined (HAVE_PSTATUS_T)
8971 elfcore_write_pstatus (bfd *abfd,
8975 int cursig ATTRIBUTE_UNUSED,
8976 const void *gregs ATTRIBUTE_UNUSED)
8978 const char *note_name = "CORE";
8979 #if defined (HAVE_PSTATUS32_T)
8980 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8982 if (bed->s->elfclass == ELFCLASS32)
8986 memset (&pstat, 0, sizeof (pstat));
8987 pstat.pr_pid = pid & 0xffff;
8988 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8989 NT_PSTATUS, &pstat, sizeof (pstat));
8997 memset (&pstat, 0, sizeof (pstat));
8998 pstat.pr_pid = pid & 0xffff;
8999 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9000 NT_PSTATUS, &pstat, sizeof (pstat));
9004 #endif /* HAVE_PSTATUS_T */
9007 elfcore_write_prfpreg (bfd *abfd,
9013 const char *note_name = "CORE";
9014 return elfcore_write_note (abfd, buf, bufsiz,
9015 note_name, NT_FPREGSET, fpregs, size);
9019 elfcore_write_prxfpreg (bfd *abfd,
9022 const void *xfpregs,
9025 char *note_name = "LINUX";
9026 return elfcore_write_note (abfd, buf, bufsiz,
9027 note_name, NT_PRXFPREG, xfpregs, size);
9031 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
9032 const void *xfpregs, int size)
9034 char *note_name = "LINUX";
9035 return elfcore_write_note (abfd, buf, bufsiz,
9036 note_name, NT_X86_XSTATE, xfpregs, size);
9040 elfcore_write_ppc_vmx (bfd *abfd,
9043 const void *ppc_vmx,
9046 char *note_name = "LINUX";
9047 return elfcore_write_note (abfd, buf, bufsiz,
9048 note_name, NT_PPC_VMX, ppc_vmx, size);
9052 elfcore_write_ppc_vsx (bfd *abfd,
9055 const void *ppc_vsx,
9058 char *note_name = "LINUX";
9059 return elfcore_write_note (abfd, buf, bufsiz,
9060 note_name, NT_PPC_VSX, ppc_vsx, size);
9064 elfcore_write_s390_high_gprs (bfd *abfd,
9067 const void *s390_high_gprs,
9070 char *note_name = "LINUX";
9071 return elfcore_write_note (abfd, buf, bufsiz,
9072 note_name, NT_S390_HIGH_GPRS,
9073 s390_high_gprs, size);
9077 elfcore_write_s390_timer (bfd *abfd,
9080 const void *s390_timer,
9083 char *note_name = "LINUX";
9084 return elfcore_write_note (abfd, buf, bufsiz,
9085 note_name, NT_S390_TIMER, s390_timer, size);
9089 elfcore_write_s390_todcmp (bfd *abfd,
9092 const void *s390_todcmp,
9095 char *note_name = "LINUX";
9096 return elfcore_write_note (abfd, buf, bufsiz,
9097 note_name, NT_S390_TODCMP, s390_todcmp, size);
9101 elfcore_write_s390_todpreg (bfd *abfd,
9104 const void *s390_todpreg,
9107 char *note_name = "LINUX";
9108 return elfcore_write_note (abfd, buf, bufsiz,
9109 note_name, NT_S390_TODPREG, s390_todpreg, size);
9113 elfcore_write_s390_ctrs (bfd *abfd,
9116 const void *s390_ctrs,
9119 char *note_name = "LINUX";
9120 return elfcore_write_note (abfd, buf, bufsiz,
9121 note_name, NT_S390_CTRS, s390_ctrs, size);
9125 elfcore_write_s390_prefix (bfd *abfd,
9128 const void *s390_prefix,
9131 char *note_name = "LINUX";
9132 return elfcore_write_note (abfd, buf, bufsiz,
9133 note_name, NT_S390_PREFIX, s390_prefix, size);
9137 elfcore_write_register_note (bfd *abfd,
9140 const char *section,
9144 if (strcmp (section, ".reg2") == 0)
9145 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
9146 if (strcmp (section, ".reg-xfp") == 0)
9147 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
9148 if (strcmp (section, ".reg-xstate") == 0)
9149 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
9150 if (strcmp (section, ".reg-ppc-vmx") == 0)
9151 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
9152 if (strcmp (section, ".reg-ppc-vsx") == 0)
9153 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
9154 if (strcmp (section, ".reg-s390-high-gprs") == 0)
9155 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
9156 if (strcmp (section, ".reg-s390-timer") == 0)
9157 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
9158 if (strcmp (section, ".reg-s390-todcmp") == 0)
9159 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
9160 if (strcmp (section, ".reg-s390-todpreg") == 0)
9161 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
9162 if (strcmp (section, ".reg-s390-ctrs") == 0)
9163 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
9164 if (strcmp (section, ".reg-s390-prefix") == 0)
9165 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
9170 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
9175 while (p < buf + size)
9177 /* FIXME: bad alignment assumption. */
9178 Elf_External_Note *xnp = (Elf_External_Note *) p;
9179 Elf_Internal_Note in;
9181 if (offsetof (Elf_External_Note, name) > buf - p + size)
9184 in.type = H_GET_32 (abfd, xnp->type);
9186 in.namesz = H_GET_32 (abfd, xnp->namesz);
9187 in.namedata = xnp->name;
9188 if (in.namesz > buf - in.namedata + size)
9191 in.descsz = H_GET_32 (abfd, xnp->descsz);
9192 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
9193 in.descpos = offset + (in.descdata - buf);
9195 && (in.descdata >= buf + size
9196 || in.descsz > buf - in.descdata + size))
9199 switch (bfd_get_format (abfd))
9205 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
9207 if (! elfcore_grok_netbsd_note (abfd, &in))
9210 else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
9212 if (! elfcore_grok_openbsd_note (abfd, &in))
9215 else if (CONST_STRNEQ (in.namedata, "QNX"))
9217 if (! elfcore_grok_nto_note (abfd, &in))
9220 else if (CONST_STRNEQ (in.namedata, "SPU/"))
9222 if (! elfcore_grok_spu_note (abfd, &in))
9227 if (! elfcore_grok_note (abfd, &in))
9233 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
9235 if (! elfobj_grok_gnu_note (abfd, &in))
9238 else if (in.namesz == sizeof "stapsdt"
9239 && strcmp (in.namedata, "stapsdt") == 0)
9241 if (! elfobj_grok_stapsdt_note (abfd, &in))
9247 p = in.descdata + BFD_ALIGN (in.descsz, 4);
9254 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9261 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9264 buf = (char *) bfd_malloc (size);
9268 if (bfd_bread (buf, size, abfd) != size
9269 || !elf_parse_notes (abfd, buf, size, offset))
9279 /* Providing external access to the ELF program header table. */
9281 /* Return an upper bound on the number of bytes required to store a
9282 copy of ABFD's program header table entries. Return -1 if an error
9283 occurs; bfd_get_error will return an appropriate code. */
9286 bfd_get_elf_phdr_upper_bound (bfd *abfd)
9288 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9290 bfd_set_error (bfd_error_wrong_format);
9294 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
9297 /* Copy ABFD's program header table entries to *PHDRS. The entries
9298 will be stored as an array of Elf_Internal_Phdr structures, as
9299 defined in include/elf/internal.h. To find out how large the
9300 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9302 Return the number of program header table entries read, or -1 if an
9303 error occurs; bfd_get_error will return an appropriate code. */
9306 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
9310 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9312 bfd_set_error (bfd_error_wrong_format);
9316 num_phdrs = elf_elfheader (abfd)->e_phnum;
9317 memcpy (phdrs, elf_tdata (abfd)->phdr,
9318 num_phdrs * sizeof (Elf_Internal_Phdr));
9323 enum elf_reloc_type_class
9324 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
9326 return reloc_class_normal;
9329 /* For RELA architectures, return the relocation value for a
9330 relocation against a local symbol. */
9333 _bfd_elf_rela_local_sym (bfd *abfd,
9334 Elf_Internal_Sym *sym,
9336 Elf_Internal_Rela *rel)
9338 asection *sec = *psec;
9341 relocation = (sec->output_section->vma
9342 + sec->output_offset
9344 if ((sec->flags & SEC_MERGE)
9345 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
9346 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
9349 _bfd_merged_section_offset (abfd, psec,
9350 elf_section_data (sec)->sec_info,
9351 sym->st_value + rel->r_addend);
9354 /* If we have changed the section, and our original section is
9355 marked with SEC_EXCLUDE, it means that the original
9356 SEC_MERGE section has been completely subsumed in some
9357 other SEC_MERGE section. In this case, we need to leave
9358 some info around for --emit-relocs. */
9359 if ((sec->flags & SEC_EXCLUDE) != 0)
9360 sec->kept_section = *psec;
9363 rel->r_addend -= relocation;
9364 rel->r_addend += sec->output_section->vma + sec->output_offset;
9370 _bfd_elf_rel_local_sym (bfd *abfd,
9371 Elf_Internal_Sym *sym,
9375 asection *sec = *psec;
9377 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
9378 return sym->st_value + addend;
9380 return _bfd_merged_section_offset (abfd, psec,
9381 elf_section_data (sec)->sec_info,
9382 sym->st_value + addend);
9386 _bfd_elf_section_offset (bfd *abfd,
9387 struct bfd_link_info *info,
9391 switch (sec->sec_info_type)
9393 case ELF_INFO_TYPE_STABS:
9394 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9396 case ELF_INFO_TYPE_EH_FRAME:
9397 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
9399 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
9401 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9402 bfd_size_type address_size = bed->s->arch_size / 8;
9403 offset = sec->size - offset - address_size;
9409 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
9410 reconstruct an ELF file by reading the segments out of remote memory
9411 based on the ELF file header at EHDR_VMA and the ELF program headers it
9412 points to. If not null, *LOADBASEP is filled in with the difference
9413 between the VMAs from which the segments were read, and the VMAs the
9414 file headers (and hence BFD's idea of each section's VMA) put them at.
9416 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9417 remote memory at target address VMA into the local buffer at MYADDR; it
9418 should return zero on success or an `errno' code on failure. TEMPL must
9419 be a BFD for an ELF target with the word size and byte order found in
9420 the remote memory. */
9423 bfd_elf_bfd_from_remote_memory
9427 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
9429 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9430 (templ, ehdr_vma, loadbasep, target_read_memory);
9434 _bfd_elf_get_synthetic_symtab (bfd *abfd,
9435 long symcount ATTRIBUTE_UNUSED,
9436 asymbol **syms ATTRIBUTE_UNUSED,
9441 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9444 const char *relplt_name;
9445 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9449 Elf_Internal_Shdr *hdr;
9455 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9458 if (dynsymcount <= 0)
9461 if (!bed->plt_sym_val)
9464 relplt_name = bed->relplt_name;
9465 if (relplt_name == NULL)
9466 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
9467 relplt = bfd_get_section_by_name (abfd, relplt_name);
9471 hdr = &elf_section_data (relplt)->this_hdr;
9472 if (hdr->sh_link != elf_dynsymtab (abfd)
9473 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9476 plt = bfd_get_section_by_name (abfd, ".plt");
9480 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
9481 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
9484 count = relplt->size / hdr->sh_entsize;
9485 size = count * sizeof (asymbol);
9486 p = relplt->relocation;
9487 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9489 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9493 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9495 size += sizeof ("+0x") - 1 + 8;
9500 s = *ret = (asymbol *) bfd_malloc (size);
9504 names = (char *) (s + count);
9505 p = relplt->relocation;
9507 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9512 addr = bed->plt_sym_val (i, plt, p);
9513 if (addr == (bfd_vma) -1)
9516 *s = **p->sym_ptr_ptr;
9517 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
9518 we are defining a symbol, ensure one of them is set. */
9519 if ((s->flags & BSF_LOCAL) == 0)
9520 s->flags |= BSF_GLOBAL;
9521 s->flags |= BSF_SYNTHETIC;
9523 s->value = addr - plt->vma;
9526 len = strlen ((*p->sym_ptr_ptr)->name);
9527 memcpy (names, (*p->sym_ptr_ptr)->name, len);
9533 memcpy (names, "+0x", sizeof ("+0x") - 1);
9534 names += sizeof ("+0x") - 1;
9535 bfd_sprintf_vma (abfd, buf, p->addend);
9536 for (a = buf; *a == '0'; ++a)
9539 memcpy (names, a, len);
9542 memcpy (names, "@plt", sizeof ("@plt"));
9543 names += sizeof ("@plt");
9550 /* It is only used by x86-64 so far. */
9551 asection _bfd_elf_large_com_section
9552 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
9553 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
9556 _bfd_elf_set_osabi (bfd * abfd,
9557 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9559 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
9561 i_ehdrp = elf_elfheader (abfd);
9563 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
9565 /* To make things simpler for the loader on Linux systems we set the
9566 osabi field to ELFOSABI_LINUX if the binary contains symbols of
9567 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
9568 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
9569 && elf_tdata (abfd)->has_gnu_symbols)
9570 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
9574 /* Return TRUE for ELF symbol types that represent functions.
9575 This is the default version of this function, which is sufficient for
9576 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
9579 _bfd_elf_is_function_type (unsigned int type)
9581 return (type == STT_FUNC
9582 || type == STT_GNU_IFUNC);