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
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_generic_object (bfd *abfd)
255 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
260 bfd_elf_mkcorefile (bfd *abfd)
262 /* I think this can be done just like an object file. */
263 return bfd_elf_make_generic_object (abfd);
267 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
269 Elf_Internal_Shdr **i_shdrp;
270 bfd_byte *shstrtab = NULL;
272 bfd_size_type shstrtabsize;
274 i_shdrp = elf_elfsections (abfd);
276 || shindex >= elf_numsections (abfd)
277 || i_shdrp[shindex] == 0)
280 shstrtab = i_shdrp[shindex]->contents;
281 if (shstrtab == NULL)
283 /* No cached one, attempt to read, and cache what we read. */
284 offset = i_shdrp[shindex]->sh_offset;
285 shstrtabsize = i_shdrp[shindex]->sh_size;
287 /* Allocate and clear an extra byte at the end, to prevent crashes
288 in case the string table is not terminated. */
289 if (shstrtabsize + 1 <= 1
290 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL
291 || bfd_seek (abfd, offset, SEEK_SET) != 0)
293 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
295 if (bfd_get_error () != bfd_error_system_call)
296 bfd_set_error (bfd_error_file_truncated);
298 /* Once we've failed to read it, make sure we don't keep
299 trying. Otherwise, we'll keep allocating space for
300 the string table over and over. */
301 i_shdrp[shindex]->sh_size = 0;
304 shstrtab[shstrtabsize] = '\0';
305 i_shdrp[shindex]->contents = shstrtab;
307 return (char *) shstrtab;
311 bfd_elf_string_from_elf_section (bfd *abfd,
312 unsigned int shindex,
313 unsigned int strindex)
315 Elf_Internal_Shdr *hdr;
320 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
323 hdr = elf_elfsections (abfd)[shindex];
325 if (hdr->contents == NULL
326 && bfd_elf_get_str_section (abfd, shindex) == NULL)
329 if (strindex >= hdr->sh_size)
331 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
332 (*_bfd_error_handler)
333 (_("%B: invalid string offset %u >= %lu for section `%s'"),
334 abfd, strindex, (unsigned long) hdr->sh_size,
335 (shindex == shstrndx && strindex == hdr->sh_name
337 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
341 return ((char *) hdr->contents) + strindex;
344 /* Read and convert symbols to internal format.
345 SYMCOUNT specifies the number of symbols to read, starting from
346 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
347 are non-NULL, they are used to store the internal symbols, external
348 symbols, and symbol section index extensions, respectively.
349 Returns a pointer to the internal symbol buffer (malloced if necessary)
350 or NULL if there were no symbols or some kind of problem. */
353 bfd_elf_get_elf_syms (bfd *ibfd,
354 Elf_Internal_Shdr *symtab_hdr,
357 Elf_Internal_Sym *intsym_buf,
359 Elf_External_Sym_Shndx *extshndx_buf)
361 Elf_Internal_Shdr *shndx_hdr;
363 const bfd_byte *esym;
364 Elf_External_Sym_Shndx *alloc_extshndx;
365 Elf_External_Sym_Shndx *shndx;
366 Elf_Internal_Sym *alloc_intsym;
367 Elf_Internal_Sym *isym;
368 Elf_Internal_Sym *isymend;
369 const struct elf_backend_data *bed;
374 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
380 /* Normal syms might have section extension entries. */
382 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
383 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
385 /* Read the symbols. */
387 alloc_extshndx = NULL;
389 bed = get_elf_backend_data (ibfd);
390 extsym_size = bed->s->sizeof_sym;
391 amt = symcount * extsym_size;
392 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
393 if (extsym_buf == NULL)
395 alloc_ext = bfd_malloc2 (symcount, extsym_size);
396 extsym_buf = alloc_ext;
398 if (extsym_buf == NULL
399 || bfd_seek (ibfd, pos, SEEK_SET) != 0
400 || bfd_bread (extsym_buf, amt, ibfd) != amt)
406 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
410 amt = symcount * sizeof (Elf_External_Sym_Shndx);
411 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
412 if (extshndx_buf == NULL)
414 alloc_extshndx = (Elf_External_Sym_Shndx *)
415 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
416 extshndx_buf = alloc_extshndx;
418 if (extshndx_buf == NULL
419 || bfd_seek (ibfd, pos, SEEK_SET) != 0
420 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
427 if (intsym_buf == NULL)
429 alloc_intsym = (Elf_Internal_Sym *)
430 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
431 intsym_buf = alloc_intsym;
432 if (intsym_buf == NULL)
436 /* Convert the symbols to internal form. */
437 isymend = intsym_buf + symcount;
438 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
439 shndx = extshndx_buf;
441 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
442 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
444 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
445 (*_bfd_error_handler) (_("%B symbol number %lu references "
446 "nonexistent SHT_SYMTAB_SHNDX section"),
447 ibfd, (unsigned long) symoffset);
448 if (alloc_intsym != NULL)
455 if (alloc_ext != NULL)
457 if (alloc_extshndx != NULL)
458 free (alloc_extshndx);
463 /* Look up a symbol name. */
465 bfd_elf_sym_name (bfd *abfd,
466 Elf_Internal_Shdr *symtab_hdr,
467 Elf_Internal_Sym *isym,
471 unsigned int iname = isym->st_name;
472 unsigned int shindex = symtab_hdr->sh_link;
474 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
475 /* Check for a bogus st_shndx to avoid crashing. */
476 && isym->st_shndx < elf_numsections (abfd))
478 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
479 shindex = elf_elfheader (abfd)->e_shstrndx;
482 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
485 else if (sym_sec && *name == '\0')
486 name = bfd_section_name (abfd, sym_sec);
491 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
492 sections. The first element is the flags, the rest are section
495 typedef union elf_internal_group {
496 Elf_Internal_Shdr *shdr;
498 } Elf_Internal_Group;
500 /* Return the name of the group signature symbol. Why isn't the
501 signature just a string? */
504 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
506 Elf_Internal_Shdr *hdr;
507 unsigned char esym[sizeof (Elf64_External_Sym)];
508 Elf_External_Sym_Shndx eshndx;
509 Elf_Internal_Sym isym;
511 /* First we need to ensure the symbol table is available. Make sure
512 that it is a symbol table section. */
513 if (ghdr->sh_link >= elf_numsections (abfd))
515 hdr = elf_elfsections (abfd) [ghdr->sh_link];
516 if (hdr->sh_type != SHT_SYMTAB
517 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
520 /* Go read the symbol. */
521 hdr = &elf_tdata (abfd)->symtab_hdr;
522 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
523 &isym, esym, &eshndx) == NULL)
526 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
529 /* Set next_in_group list pointer, and group name for NEWSECT. */
532 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
534 unsigned int num_group = elf_tdata (abfd)->num_group;
536 /* If num_group is zero, read in all SHT_GROUP sections. The count
537 is set to -1 if there are no SHT_GROUP sections. */
540 unsigned int i, shnum;
542 /* First count the number of groups. If we have a SHT_GROUP
543 section with just a flag word (ie. sh_size is 4), ignore it. */
544 shnum = elf_numsections (abfd);
547 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
548 ( (shdr)->sh_type == SHT_GROUP \
549 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
550 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
551 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
553 for (i = 0; i < shnum; i++)
555 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
557 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
563 num_group = (unsigned) -1;
564 elf_tdata (abfd)->num_group = num_group;
568 /* We keep a list of elf section headers for group sections,
569 so we can find them quickly. */
572 elf_tdata (abfd)->num_group = num_group;
573 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
574 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
575 if (elf_tdata (abfd)->group_sect_ptr == NULL)
579 for (i = 0; i < shnum; i++)
581 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
583 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
586 Elf_Internal_Group *dest;
588 /* Add to list of sections. */
589 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
592 /* Read the raw contents. */
593 BFD_ASSERT (sizeof (*dest) >= 4);
594 amt = shdr->sh_size * sizeof (*dest) / 4;
595 shdr->contents = (unsigned char *)
596 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
597 /* PR binutils/4110: Handle corrupt group headers. */
598 if (shdr->contents == NULL)
601 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
602 bfd_set_error (bfd_error_bad_value);
606 memset (shdr->contents, 0, amt);
608 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
609 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
613 /* Translate raw contents, a flag word followed by an
614 array of elf section indices all in target byte order,
615 to the flag word followed by an array of elf section
617 src = shdr->contents + shdr->sh_size;
618 dest = (Elf_Internal_Group *) (shdr->contents + amt);
625 idx = H_GET_32 (abfd, src);
626 if (src == shdr->contents)
629 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
630 shdr->bfd_section->flags
631 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
636 ((*_bfd_error_handler)
637 (_("%B: invalid SHT_GROUP entry"), abfd));
640 dest->shdr = elf_elfsections (abfd)[idx];
647 if (num_group != (unsigned) -1)
651 for (i = 0; i < num_group; i++)
653 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
654 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
655 unsigned int n_elt = shdr->sh_size / 4;
657 /* Look through this group's sections to see if current
658 section is a member. */
660 if ((++idx)->shdr == hdr)
664 /* We are a member of this group. Go looking through
665 other members to see if any others are linked via
667 idx = (Elf_Internal_Group *) shdr->contents;
668 n_elt = shdr->sh_size / 4;
670 if ((s = (++idx)->shdr->bfd_section) != NULL
671 && elf_next_in_group (s) != NULL)
675 /* Snarf the group name from other member, and
676 insert current section in circular list. */
677 elf_group_name (newsect) = elf_group_name (s);
678 elf_next_in_group (newsect) = elf_next_in_group (s);
679 elf_next_in_group (s) = newsect;
685 gname = group_signature (abfd, shdr);
688 elf_group_name (newsect) = gname;
690 /* Start a circular list with one element. */
691 elf_next_in_group (newsect) = newsect;
694 /* If the group section has been created, point to the
696 if (shdr->bfd_section != NULL)
697 elf_next_in_group (shdr->bfd_section) = newsect;
705 if (elf_group_name (newsect) == NULL)
707 (*_bfd_error_handler) (_("%B: no group info for section %A"),
714 _bfd_elf_setup_sections (bfd *abfd)
717 unsigned int num_group = elf_tdata (abfd)->num_group;
718 bfd_boolean result = TRUE;
721 /* Process SHF_LINK_ORDER. */
722 for (s = abfd->sections; s != NULL; s = s->next)
724 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
725 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
727 unsigned int elfsec = this_hdr->sh_link;
728 /* FIXME: The old Intel compiler and old strip/objcopy may
729 not set the sh_link or sh_info fields. Hence we could
730 get the situation where elfsec is 0. */
733 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
734 if (bed->link_order_error_handler)
735 bed->link_order_error_handler
736 (_("%B: warning: sh_link not set for section `%A'"),
741 asection *linksec = NULL;
743 if (elfsec < elf_numsections (abfd))
745 this_hdr = elf_elfsections (abfd)[elfsec];
746 linksec = this_hdr->bfd_section;
750 Some strip/objcopy may leave an incorrect value in
751 sh_link. We don't want to proceed. */
754 (*_bfd_error_handler)
755 (_("%B: sh_link [%d] in section `%A' is incorrect"),
756 s->owner, s, elfsec);
760 elf_linked_to_section (s) = linksec;
765 /* Process section groups. */
766 if (num_group == (unsigned) -1)
769 for (i = 0; i < num_group; i++)
771 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
772 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
773 unsigned int n_elt = shdr->sh_size / 4;
776 if ((++idx)->shdr->bfd_section)
777 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
778 else if (idx->shdr->sh_type == SHT_RELA
779 || idx->shdr->sh_type == SHT_REL)
780 /* We won't include relocation sections in section groups in
781 output object files. We adjust the group section size here
782 so that relocatable link will work correctly when
783 relocation sections are in section group in input object
785 shdr->bfd_section->size -= 4;
788 /* There are some unknown sections in the group. */
789 (*_bfd_error_handler)
790 (_("%B: unknown [%d] section `%s' in group [%s]"),
792 (unsigned int) idx->shdr->sh_type,
793 bfd_elf_string_from_elf_section (abfd,
794 (elf_elfheader (abfd)
797 shdr->bfd_section->name);
805 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
807 return elf_next_in_group (sec) != NULL;
810 /* Make a BFD section from an ELF section. We store a pointer to the
811 BFD section in the bfd_section field of the header. */
814 _bfd_elf_make_section_from_shdr (bfd *abfd,
815 Elf_Internal_Shdr *hdr,
821 const struct elf_backend_data *bed;
823 if (hdr->bfd_section != NULL)
825 BFD_ASSERT (strcmp (name,
826 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
830 newsect = bfd_make_section_anyway (abfd, name);
834 hdr->bfd_section = newsect;
835 elf_section_data (newsect)->this_hdr = *hdr;
836 elf_section_data (newsect)->this_idx = shindex;
838 /* Always use the real type/flags. */
839 elf_section_type (newsect) = hdr->sh_type;
840 elf_section_flags (newsect) = hdr->sh_flags;
842 newsect->filepos = hdr->sh_offset;
844 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
845 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
846 || ! bfd_set_section_alignment (abfd, newsect,
847 bfd_log2 (hdr->sh_addralign)))
850 flags = SEC_NO_FLAGS;
851 if (hdr->sh_type != SHT_NOBITS)
852 flags |= SEC_HAS_CONTENTS;
853 if (hdr->sh_type == SHT_GROUP)
854 flags |= SEC_GROUP | SEC_EXCLUDE;
855 if ((hdr->sh_flags & SHF_ALLOC) != 0)
858 if (hdr->sh_type != SHT_NOBITS)
861 if ((hdr->sh_flags & SHF_WRITE) == 0)
862 flags |= SEC_READONLY;
863 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
865 else if ((flags & SEC_LOAD) != 0)
867 if ((hdr->sh_flags & SHF_MERGE) != 0)
870 newsect->entsize = hdr->sh_entsize;
871 if ((hdr->sh_flags & SHF_STRINGS) != 0)
872 flags |= SEC_STRINGS;
874 if (hdr->sh_flags & SHF_GROUP)
875 if (!setup_group (abfd, hdr, newsect))
877 if ((hdr->sh_flags & SHF_TLS) != 0)
878 flags |= SEC_THREAD_LOCAL;
879 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
880 flags |= SEC_EXCLUDE;
882 if ((flags & SEC_ALLOC) == 0)
884 /* The debugging sections appear to be recognized only by name,
885 not any sort of flag. Their SEC_ALLOC bits are cleared. */
890 } debug_sections [] =
892 { STRING_COMMA_LEN ("debug") }, /* 'd' */
893 { NULL, 0 }, /* 'e' */
894 { NULL, 0 }, /* 'f' */
895 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
896 { NULL, 0 }, /* 'h' */
897 { NULL, 0 }, /* 'i' */
898 { NULL, 0 }, /* 'j' */
899 { NULL, 0 }, /* 'k' */
900 { STRING_COMMA_LEN ("line") }, /* 'l' */
901 { NULL, 0 }, /* 'm' */
902 { NULL, 0 }, /* 'n' */
903 { NULL, 0 }, /* 'o' */
904 { NULL, 0 }, /* 'p' */
905 { NULL, 0 }, /* 'q' */
906 { NULL, 0 }, /* 'r' */
907 { STRING_COMMA_LEN ("stab") }, /* 's' */
908 { NULL, 0 }, /* 't' */
909 { NULL, 0 }, /* 'u' */
910 { NULL, 0 }, /* 'v' */
911 { NULL, 0 }, /* 'w' */
912 { NULL, 0 }, /* 'x' */
913 { NULL, 0 }, /* 'y' */
914 { STRING_COMMA_LEN ("zdebug") } /* 'z' */
919 int i = name [1] - 'd';
921 && i < (int) ARRAY_SIZE (debug_sections)
922 && debug_sections [i].name != NULL
923 && strncmp (&name [1], debug_sections [i].name,
924 debug_sections [i].len) == 0)
925 flags |= SEC_DEBUGGING;
929 /* As a GNU extension, if the name begins with .gnu.linkonce, we
930 only link a single copy of the section. This is used to support
931 g++. g++ will emit each template expansion in its own section.
932 The symbols will be defined as weak, so that multiple definitions
933 are permitted. The GNU linker extension is to actually discard
934 all but one of the sections. */
935 if (CONST_STRNEQ (name, ".gnu.linkonce")
936 && elf_next_in_group (newsect) == NULL)
937 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
939 bed = get_elf_backend_data (abfd);
940 if (bed->elf_backend_section_flags)
941 if (! bed->elf_backend_section_flags (&flags, hdr))
944 if (! bfd_set_section_flags (abfd, newsect, flags))
947 /* We do not parse the PT_NOTE segments as we are interested even in the
948 separate debug info files which may have the segments offsets corrupted.
949 PT_NOTEs from the core files are currently not parsed using BFD. */
950 if (hdr->sh_type == SHT_NOTE)
954 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
957 elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1);
961 if ((flags & SEC_ALLOC) != 0)
963 Elf_Internal_Phdr *phdr;
964 unsigned int i, nload;
966 /* Some ELF linkers produce binaries with all the program header
967 p_paddr fields zero. If we have such a binary with more than
968 one PT_LOAD header, then leave the section lma equal to vma
969 so that we don't create sections with overlapping lma. */
970 phdr = elf_tdata (abfd)->phdr;
971 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
972 if (phdr->p_paddr != 0)
974 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
976 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
979 phdr = elf_tdata (abfd)->phdr;
980 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
982 if (phdr->p_type == PT_LOAD
983 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
985 if ((flags & SEC_LOAD) == 0)
986 newsect->lma = (phdr->p_paddr
987 + hdr->sh_addr - phdr->p_vaddr);
989 /* We used to use the same adjustment for SEC_LOAD
990 sections, but that doesn't work if the segment
991 is packed with code from multiple VMAs.
992 Instead we calculate the section LMA based on
993 the segment LMA. It is assumed that the
994 segment will contain sections with contiguous
995 LMAs, even if the VMAs are not. */
996 newsect->lma = (phdr->p_paddr
997 + hdr->sh_offset - phdr->p_offset);
999 /* With contiguous segments, we can't tell from file
1000 offsets whether a section with zero size should
1001 be placed at the end of one segment or the
1002 beginning of the next. Decide based on vaddr. */
1003 if (hdr->sh_addr >= phdr->p_vaddr
1004 && (hdr->sh_addr + hdr->sh_size
1005 <= phdr->p_vaddr + phdr->p_memsz))
1014 const char *const bfd_elf_section_type_names[] = {
1015 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1016 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1017 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1020 /* ELF relocs are against symbols. If we are producing relocatable
1021 output, and the reloc is against an external symbol, and nothing
1022 has given us any additional addend, the resulting reloc will also
1023 be against the same symbol. In such a case, we don't want to
1024 change anything about the way the reloc is handled, since it will
1025 all be done at final link time. Rather than put special case code
1026 into bfd_perform_relocation, all the reloc types use this howto
1027 function. It just short circuits the reloc if producing
1028 relocatable output against an external symbol. */
1030 bfd_reloc_status_type
1031 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1032 arelent *reloc_entry,
1034 void *data ATTRIBUTE_UNUSED,
1035 asection *input_section,
1037 char **error_message ATTRIBUTE_UNUSED)
1039 if (output_bfd != NULL
1040 && (symbol->flags & BSF_SECTION_SYM) == 0
1041 && (! reloc_entry->howto->partial_inplace
1042 || reloc_entry->addend == 0))
1044 reloc_entry->address += input_section->output_offset;
1045 return bfd_reloc_ok;
1048 return bfd_reloc_continue;
1051 /* Copy the program header and other data from one object module to
1055 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1057 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1058 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1061 BFD_ASSERT (!elf_flags_init (obfd)
1062 || (elf_elfheader (obfd)->e_flags
1063 == elf_elfheader (ibfd)->e_flags));
1065 elf_gp (obfd) = elf_gp (ibfd);
1066 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1067 elf_flags_init (obfd) = TRUE;
1069 /* Copy object attributes. */
1070 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1075 get_segment_type (unsigned int p_type)
1080 case PT_NULL: pt = "NULL"; break;
1081 case PT_LOAD: pt = "LOAD"; break;
1082 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1083 case PT_INTERP: pt = "INTERP"; break;
1084 case PT_NOTE: pt = "NOTE"; break;
1085 case PT_SHLIB: pt = "SHLIB"; break;
1086 case PT_PHDR: pt = "PHDR"; break;
1087 case PT_TLS: pt = "TLS"; break;
1088 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1089 case PT_GNU_STACK: pt = "STACK"; break;
1090 case PT_GNU_RELRO: pt = "RELRO"; break;
1091 default: pt = NULL; break;
1096 /* Print out the program headers. */
1099 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1101 FILE *f = (FILE *) farg;
1102 Elf_Internal_Phdr *p;
1104 bfd_byte *dynbuf = NULL;
1106 p = elf_tdata (abfd)->phdr;
1111 fprintf (f, _("\nProgram Header:\n"));
1112 c = elf_elfheader (abfd)->e_phnum;
1113 for (i = 0; i < c; i++, p++)
1115 const char *pt = get_segment_type (p->p_type);
1120 sprintf (buf, "0x%lx", p->p_type);
1123 fprintf (f, "%8s off 0x", pt);
1124 bfd_fprintf_vma (abfd, f, p->p_offset);
1125 fprintf (f, " vaddr 0x");
1126 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1127 fprintf (f, " paddr 0x");
1128 bfd_fprintf_vma (abfd, f, p->p_paddr);
1129 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1130 fprintf (f, " filesz 0x");
1131 bfd_fprintf_vma (abfd, f, p->p_filesz);
1132 fprintf (f, " memsz 0x");
1133 bfd_fprintf_vma (abfd, f, p->p_memsz);
1134 fprintf (f, " flags %c%c%c",
1135 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1136 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1137 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1138 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1139 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1144 s = bfd_get_section_by_name (abfd, ".dynamic");
1147 unsigned int elfsec;
1148 unsigned long shlink;
1149 bfd_byte *extdyn, *extdynend;
1151 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1153 fprintf (f, _("\nDynamic Section:\n"));
1155 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1158 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1159 if (elfsec == SHN_BAD)
1161 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1163 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1164 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1167 extdynend = extdyn + s->size;
1168 for (; extdyn < extdynend; extdyn += extdynsize)
1170 Elf_Internal_Dyn dyn;
1171 const char *name = "";
1173 bfd_boolean stringp;
1174 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1176 (*swap_dyn_in) (abfd, extdyn, &dyn);
1178 if (dyn.d_tag == DT_NULL)
1185 if (bed->elf_backend_get_target_dtag)
1186 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1188 if (!strcmp (name, ""))
1190 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1195 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1196 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1197 case DT_PLTGOT: name = "PLTGOT"; break;
1198 case DT_HASH: name = "HASH"; break;
1199 case DT_STRTAB: name = "STRTAB"; break;
1200 case DT_SYMTAB: name = "SYMTAB"; break;
1201 case DT_RELA: name = "RELA"; break;
1202 case DT_RELASZ: name = "RELASZ"; break;
1203 case DT_RELAENT: name = "RELAENT"; break;
1204 case DT_STRSZ: name = "STRSZ"; break;
1205 case DT_SYMENT: name = "SYMENT"; break;
1206 case DT_INIT: name = "INIT"; break;
1207 case DT_FINI: name = "FINI"; break;
1208 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1209 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1210 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1211 case DT_REL: name = "REL"; break;
1212 case DT_RELSZ: name = "RELSZ"; break;
1213 case DT_RELENT: name = "RELENT"; break;
1214 case DT_PLTREL: name = "PLTREL"; break;
1215 case DT_DEBUG: name = "DEBUG"; break;
1216 case DT_TEXTREL: name = "TEXTREL"; break;
1217 case DT_JMPREL: name = "JMPREL"; break;
1218 case DT_BIND_NOW: name = "BIND_NOW"; break;
1219 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1220 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1221 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1222 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1223 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1224 case DT_FLAGS: name = "FLAGS"; break;
1225 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1226 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1227 case DT_CHECKSUM: name = "CHECKSUM"; break;
1228 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1229 case DT_MOVEENT: name = "MOVEENT"; break;
1230 case DT_MOVESZ: name = "MOVESZ"; break;
1231 case DT_FEATURE: name = "FEATURE"; break;
1232 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1233 case DT_SYMINSZ: name = "SYMINSZ"; break;
1234 case DT_SYMINENT: name = "SYMINENT"; break;
1235 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1236 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1237 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1238 case DT_PLTPAD: name = "PLTPAD"; break;
1239 case DT_MOVETAB: name = "MOVETAB"; break;
1240 case DT_SYMINFO: name = "SYMINFO"; break;
1241 case DT_RELACOUNT: name = "RELACOUNT"; break;
1242 case DT_RELCOUNT: name = "RELCOUNT"; break;
1243 case DT_FLAGS_1: name = "FLAGS_1"; break;
1244 case DT_VERSYM: name = "VERSYM"; break;
1245 case DT_VERDEF: name = "VERDEF"; break;
1246 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1247 case DT_VERNEED: name = "VERNEED"; break;
1248 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1249 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1250 case DT_USED: name = "USED"; break;
1251 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1252 case DT_GNU_HASH: name = "GNU_HASH"; break;
1255 fprintf (f, " %-20s ", name);
1259 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1264 unsigned int tagv = dyn.d_un.d_val;
1266 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1269 fprintf (f, "%s", string);
1278 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1279 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1281 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1285 if (elf_dynverdef (abfd) != 0)
1287 Elf_Internal_Verdef *t;
1289 fprintf (f, _("\nVersion definitions:\n"));
1290 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1292 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1293 t->vd_flags, t->vd_hash,
1294 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1295 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1297 Elf_Internal_Verdaux *a;
1300 for (a = t->vd_auxptr->vda_nextptr;
1304 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1310 if (elf_dynverref (abfd) != 0)
1312 Elf_Internal_Verneed *t;
1314 fprintf (f, _("\nVersion References:\n"));
1315 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1317 Elf_Internal_Vernaux *a;
1319 fprintf (f, _(" required from %s:\n"),
1320 t->vn_filename ? t->vn_filename : "<corrupt>");
1321 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1322 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1323 a->vna_flags, a->vna_other,
1324 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1336 /* Display ELF-specific fields of a symbol. */
1339 bfd_elf_print_symbol (bfd *abfd,
1342 bfd_print_symbol_type how)
1344 FILE *file = (FILE *) filep;
1347 case bfd_print_symbol_name:
1348 fprintf (file, "%s", symbol->name);
1350 case bfd_print_symbol_more:
1351 fprintf (file, "elf ");
1352 bfd_fprintf_vma (abfd, file, symbol->value);
1353 fprintf (file, " %lx", (unsigned long) symbol->flags);
1355 case bfd_print_symbol_all:
1357 const char *section_name;
1358 const char *name = NULL;
1359 const struct elf_backend_data *bed;
1360 unsigned char st_other;
1363 section_name = symbol->section ? symbol->section->name : "(*none*)";
1365 bed = get_elf_backend_data (abfd);
1366 if (bed->elf_backend_print_symbol_all)
1367 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1371 name = symbol->name;
1372 bfd_print_symbol_vandf (abfd, file, symbol);
1375 fprintf (file, " %s\t", section_name);
1376 /* Print the "other" value for a symbol. For common symbols,
1377 we've already printed the size; now print the alignment.
1378 For other symbols, we have no specified alignment, and
1379 we've printed the address; now print the size. */
1380 if (symbol->section && bfd_is_com_section (symbol->section))
1381 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1383 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1384 bfd_fprintf_vma (abfd, file, val);
1386 /* If we have version information, print it. */
1387 if (elf_tdata (abfd)->dynversym_section != 0
1388 && (elf_tdata (abfd)->dynverdef_section != 0
1389 || elf_tdata (abfd)->dynverref_section != 0))
1391 unsigned int vernum;
1392 const char *version_string;
1394 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1397 version_string = "";
1398 else if (vernum == 1)
1399 version_string = "Base";
1400 else if (vernum <= elf_tdata (abfd)->cverdefs)
1402 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1405 Elf_Internal_Verneed *t;
1407 version_string = "";
1408 for (t = elf_tdata (abfd)->verref;
1412 Elf_Internal_Vernaux *a;
1414 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1416 if (a->vna_other == vernum)
1418 version_string = a->vna_nodename;
1425 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1426 fprintf (file, " %-11s", version_string);
1431 fprintf (file, " (%s)", version_string);
1432 for (i = 10 - strlen (version_string); i > 0; --i)
1437 /* If the st_other field is not zero, print it. */
1438 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1443 case STV_INTERNAL: fprintf (file, " .internal"); break;
1444 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1445 case STV_PROTECTED: fprintf (file, " .protected"); break;
1447 /* Some other non-defined flags are also present, so print
1449 fprintf (file, " 0x%02x", (unsigned int) st_other);
1452 fprintf (file, " %s", name);
1458 /* Allocate an ELF string table--force the first byte to be zero. */
1460 struct bfd_strtab_hash *
1461 _bfd_elf_stringtab_init (void)
1463 struct bfd_strtab_hash *ret;
1465 ret = _bfd_stringtab_init ();
1470 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1471 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1472 if (loc == (bfd_size_type) -1)
1474 _bfd_stringtab_free (ret);
1481 /* ELF .o/exec file reading */
1483 /* Create a new bfd section from an ELF section header. */
1486 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1488 Elf_Internal_Shdr *hdr;
1489 Elf_Internal_Ehdr *ehdr;
1490 const struct elf_backend_data *bed;
1493 if (shindex >= elf_numsections (abfd))
1496 hdr = elf_elfsections (abfd)[shindex];
1497 ehdr = elf_elfheader (abfd);
1498 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1503 bed = get_elf_backend_data (abfd);
1504 switch (hdr->sh_type)
1507 /* Inactive section. Throw it away. */
1510 case SHT_PROGBITS: /* Normal section with contents. */
1511 case SHT_NOBITS: /* .bss section. */
1512 case SHT_HASH: /* .hash section. */
1513 case SHT_NOTE: /* .note section. */
1514 case SHT_INIT_ARRAY: /* .init_array section. */
1515 case SHT_FINI_ARRAY: /* .fini_array section. */
1516 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1517 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1518 case SHT_GNU_HASH: /* .gnu.hash section. */
1519 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1521 case SHT_DYNAMIC: /* Dynamic linking information. */
1522 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1524 if (hdr->sh_link > elf_numsections (abfd))
1526 /* PR 10478: Accept Solaris binaries with a sh_link
1527 field set to SHN_BEFORE or SHN_AFTER. */
1528 switch (bfd_get_arch (abfd))
1531 case bfd_arch_sparc:
1532 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1533 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1535 /* Otherwise fall through. */
1540 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
1542 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1544 Elf_Internal_Shdr *dynsymhdr;
1546 /* The shared libraries distributed with hpux11 have a bogus
1547 sh_link field for the ".dynamic" section. Find the
1548 string table for the ".dynsym" section instead. */
1549 if (elf_dynsymtab (abfd) != 0)
1551 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1552 hdr->sh_link = dynsymhdr->sh_link;
1556 unsigned int i, num_sec;
1558 num_sec = elf_numsections (abfd);
1559 for (i = 1; i < num_sec; i++)
1561 dynsymhdr = elf_elfsections (abfd)[i];
1562 if (dynsymhdr->sh_type == SHT_DYNSYM)
1564 hdr->sh_link = dynsymhdr->sh_link;
1572 case SHT_SYMTAB: /* A symbol table */
1573 if (elf_onesymtab (abfd) == shindex)
1576 if (hdr->sh_entsize != bed->s->sizeof_sym)
1578 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
1580 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1581 elf_onesymtab (abfd) = shindex;
1582 elf_tdata (abfd)->symtab_hdr = *hdr;
1583 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1584 abfd->flags |= HAS_SYMS;
1586 /* Sometimes a shared object will map in the symbol table. If
1587 SHF_ALLOC is set, and this is a shared object, then we also
1588 treat this section as a BFD section. We can not base the
1589 decision purely on SHF_ALLOC, because that flag is sometimes
1590 set in a relocatable object file, which would confuse the
1592 if ((hdr->sh_flags & SHF_ALLOC) != 0
1593 && (abfd->flags & DYNAMIC) != 0
1594 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1598 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1599 can't read symbols without that section loaded as well. It
1600 is most likely specified by the next section header. */
1601 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1603 unsigned int i, num_sec;
1605 num_sec = elf_numsections (abfd);
1606 for (i = shindex + 1; i < num_sec; i++)
1608 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1609 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1610 && hdr2->sh_link == shindex)
1614 for (i = 1; i < shindex; i++)
1616 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1617 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1618 && hdr2->sh_link == shindex)
1622 return bfd_section_from_shdr (abfd, i);
1626 case SHT_DYNSYM: /* A dynamic symbol table */
1627 if (elf_dynsymtab (abfd) == shindex)
1630 if (hdr->sh_entsize != bed->s->sizeof_sym)
1632 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1633 elf_dynsymtab (abfd) = shindex;
1634 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1635 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1636 abfd->flags |= HAS_SYMS;
1638 /* Besides being a symbol table, we also treat this as a regular
1639 section, so that objcopy can handle it. */
1640 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1642 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1643 if (elf_symtab_shndx (abfd) == shindex)
1646 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1647 elf_symtab_shndx (abfd) = shindex;
1648 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1649 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1652 case SHT_STRTAB: /* A string table */
1653 if (hdr->bfd_section != NULL)
1655 if (ehdr->e_shstrndx == shindex)
1657 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1658 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1661 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1664 elf_tdata (abfd)->strtab_hdr = *hdr;
1665 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1668 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1671 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1672 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1673 elf_elfsections (abfd)[shindex] = hdr;
1674 /* We also treat this as a regular section, so that objcopy
1676 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1680 /* If the string table isn't one of the above, then treat it as a
1681 regular section. We need to scan all the headers to be sure,
1682 just in case this strtab section appeared before the above. */
1683 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1685 unsigned int i, num_sec;
1687 num_sec = elf_numsections (abfd);
1688 for (i = 1; i < num_sec; i++)
1690 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1691 if (hdr2->sh_link == shindex)
1693 /* Prevent endless recursion on broken objects. */
1696 if (! bfd_section_from_shdr (abfd, i))
1698 if (elf_onesymtab (abfd) == i)
1700 if (elf_dynsymtab (abfd) == i)
1701 goto dynsymtab_strtab;
1705 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1709 /* *These* do a lot of work -- but build no sections! */
1711 asection *target_sect;
1712 Elf_Internal_Shdr *hdr2;
1713 unsigned int num_sec = elf_numsections (abfd);
1716 != (bfd_size_type) (hdr->sh_type == SHT_REL
1717 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1720 /* Check for a bogus link to avoid crashing. */
1721 if (hdr->sh_link >= num_sec)
1723 ((*_bfd_error_handler)
1724 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1725 abfd, hdr->sh_link, name, shindex));
1726 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1730 /* For some incomprehensible reason Oracle distributes
1731 libraries for Solaris in which some of the objects have
1732 bogus sh_link fields. It would be nice if we could just
1733 reject them, but, unfortunately, some people need to use
1734 them. We scan through the section headers; if we find only
1735 one suitable symbol table, we clobber the sh_link to point
1736 to it. I hope this doesn't break anything.
1738 Don't do it on executable nor shared library. */
1739 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
1740 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1741 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1747 for (scan = 1; scan < num_sec; scan++)
1749 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1750 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1761 hdr->sh_link = found;
1764 /* Get the symbol table. */
1765 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1766 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1767 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1770 /* If this reloc section does not use the main symbol table we
1771 don't treat it as a reloc section. BFD can't adequately
1772 represent such a section, so at least for now, we don't
1773 try. We just present it as a normal section. We also
1774 can't use it as a reloc section if it points to the null
1775 section, an invalid section, another reloc section, or its
1776 sh_link points to the null section. */
1777 if (hdr->sh_link != elf_onesymtab (abfd)
1778 || hdr->sh_link == SHN_UNDEF
1779 || hdr->sh_info == SHN_UNDEF
1780 || hdr->sh_info >= num_sec
1781 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1782 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
1783 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1786 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1788 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1789 if (target_sect == NULL)
1792 if ((target_sect->flags & SEC_RELOC) == 0
1793 || target_sect->reloc_count == 0)
1794 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1798 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1799 amt = sizeof (*hdr2);
1800 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1803 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1806 elf_elfsections (abfd)[shindex] = hdr2;
1807 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1808 target_sect->flags |= SEC_RELOC;
1809 target_sect->relocation = NULL;
1810 target_sect->rel_filepos = hdr->sh_offset;
1811 /* In the section to which the relocations apply, mark whether
1812 its relocations are of the REL or RELA variety. */
1813 if (hdr->sh_size != 0)
1814 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
1815 abfd->flags |= HAS_RELOC;
1819 case SHT_GNU_verdef:
1820 elf_dynverdef (abfd) = shindex;
1821 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1822 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1824 case SHT_GNU_versym:
1825 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1827 elf_dynversym (abfd) = shindex;
1828 elf_tdata (abfd)->dynversym_hdr = *hdr;
1829 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1831 case SHT_GNU_verneed:
1832 elf_dynverref (abfd) = shindex;
1833 elf_tdata (abfd)->dynverref_hdr = *hdr;
1834 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1840 if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
1842 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1844 if (hdr->contents != NULL)
1846 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1847 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
1850 if (idx->flags & GRP_COMDAT)
1851 hdr->bfd_section->flags
1852 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1854 /* We try to keep the same section order as it comes in. */
1856 while (--n_elt != 0)
1860 if (idx->shdr != NULL
1861 && (s = idx->shdr->bfd_section) != NULL
1862 && elf_next_in_group (s) != NULL)
1864 elf_next_in_group (hdr->bfd_section) = s;
1872 /* Possibly an attributes section. */
1873 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1874 || hdr->sh_type == bed->obj_attrs_section_type)
1876 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1878 _bfd_elf_parse_attributes (abfd, hdr);
1882 /* Check for any processor-specific section types. */
1883 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1886 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1888 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1889 /* FIXME: How to properly handle allocated section reserved
1890 for applications? */
1891 (*_bfd_error_handler)
1892 (_("%B: don't know how to handle allocated, application "
1893 "specific section `%s' [0x%8x]"),
1894 abfd, name, hdr->sh_type);
1896 /* Allow sections reserved for applications. */
1897 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1900 else if (hdr->sh_type >= SHT_LOPROC
1901 && hdr->sh_type <= SHT_HIPROC)
1902 /* FIXME: We should handle this section. */
1903 (*_bfd_error_handler)
1904 (_("%B: don't know how to handle processor specific section "
1906 abfd, name, hdr->sh_type);
1907 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
1909 /* Unrecognised OS-specific sections. */
1910 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1911 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1912 required to correctly process the section and the file should
1913 be rejected with an error message. */
1914 (*_bfd_error_handler)
1915 (_("%B: don't know how to handle OS specific section "
1917 abfd, name, hdr->sh_type);
1919 /* Otherwise it should be processed. */
1920 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1923 /* FIXME: We should handle this section. */
1924 (*_bfd_error_handler)
1925 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1926 abfd, name, hdr->sh_type);
1934 /* Return the local symbol specified by ABFD, R_SYMNDX. */
1937 bfd_sym_from_r_symndx (struct sym_cache *cache,
1939 unsigned long r_symndx)
1941 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1943 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
1945 Elf_Internal_Shdr *symtab_hdr;
1946 unsigned char esym[sizeof (Elf64_External_Sym)];
1947 Elf_External_Sym_Shndx eshndx;
1949 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1950 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
1951 &cache->sym[ent], esym, &eshndx) == NULL)
1954 if (cache->abfd != abfd)
1956 memset (cache->indx, -1, sizeof (cache->indx));
1959 cache->indx[ent] = r_symndx;
1962 return &cache->sym[ent];
1965 /* Given an ELF section number, retrieve the corresponding BFD
1969 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
1971 if (sec_index >= elf_numsections (abfd))
1973 return elf_elfsections (abfd)[sec_index]->bfd_section;
1976 static const struct bfd_elf_special_section special_sections_b[] =
1978 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1979 { NULL, 0, 0, 0, 0 }
1982 static const struct bfd_elf_special_section special_sections_c[] =
1984 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
1985 { NULL, 0, 0, 0, 0 }
1988 static const struct bfd_elf_special_section special_sections_d[] =
1990 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1991 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1992 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
1993 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
1994 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
1995 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
1996 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
1997 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
1998 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
1999 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2000 { NULL, 0, 0, 0, 0 }
2003 static const struct bfd_elf_special_section special_sections_f[] =
2005 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2006 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2007 { NULL, 0, 0, 0, 0 }
2010 static const struct bfd_elf_special_section special_sections_g[] =
2012 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2013 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2014 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2015 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2016 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2017 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2018 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2019 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2020 { NULL, 0, 0, 0, 0 }
2023 static const struct bfd_elf_special_section special_sections_h[] =
2025 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2026 { NULL, 0, 0, 0, 0 }
2029 static const struct bfd_elf_special_section special_sections_i[] =
2031 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2032 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2033 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2034 { NULL, 0, 0, 0, 0 }
2037 static const struct bfd_elf_special_section special_sections_l[] =
2039 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2040 { NULL, 0, 0, 0, 0 }
2043 static const struct bfd_elf_special_section special_sections_n[] =
2045 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2046 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2047 { NULL, 0, 0, 0, 0 }
2050 static const struct bfd_elf_special_section special_sections_p[] =
2052 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2053 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2054 { NULL, 0, 0, 0, 0 }
2057 static const struct bfd_elf_special_section special_sections_r[] =
2059 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2060 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2061 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2062 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2063 { NULL, 0, 0, 0, 0 }
2066 static const struct bfd_elf_special_section special_sections_s[] =
2068 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2069 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2070 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2071 /* See struct bfd_elf_special_section declaration for the semantics of
2072 this special case where .prefix_length != strlen (.prefix). */
2073 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2074 { NULL, 0, 0, 0, 0 }
2077 static const struct bfd_elf_special_section special_sections_t[] =
2079 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2080 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2081 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2082 { NULL, 0, 0, 0, 0 }
2085 static const struct bfd_elf_special_section special_sections_z[] =
2087 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2088 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2089 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2090 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2091 { NULL, 0, 0, 0, 0 }
2094 static const struct bfd_elf_special_section *special_sections[] =
2096 special_sections_b, /* 'b' */
2097 special_sections_c, /* 'c' */
2098 special_sections_d, /* 'd' */
2100 special_sections_f, /* 'f' */
2101 special_sections_g, /* 'g' */
2102 special_sections_h, /* 'h' */
2103 special_sections_i, /* 'i' */
2106 special_sections_l, /* 'l' */
2108 special_sections_n, /* 'n' */
2110 special_sections_p, /* 'p' */
2112 special_sections_r, /* 'r' */
2113 special_sections_s, /* 's' */
2114 special_sections_t, /* 't' */
2120 special_sections_z /* 'z' */
2123 const struct bfd_elf_special_section *
2124 _bfd_elf_get_special_section (const char *name,
2125 const struct bfd_elf_special_section *spec,
2131 len = strlen (name);
2133 for (i = 0; spec[i].prefix != NULL; i++)
2136 int prefix_len = spec[i].prefix_length;
2138 if (len < prefix_len)
2140 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2143 suffix_len = spec[i].suffix_length;
2144 if (suffix_len <= 0)
2146 if (name[prefix_len] != 0)
2148 if (suffix_len == 0)
2150 if (name[prefix_len] != '.'
2151 && (suffix_len == -2
2152 || (rela && spec[i].type == SHT_REL)))
2158 if (len < prefix_len + suffix_len)
2160 if (memcmp (name + len - suffix_len,
2161 spec[i].prefix + prefix_len,
2171 const struct bfd_elf_special_section *
2172 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2175 const struct bfd_elf_special_section *spec;
2176 const struct elf_backend_data *bed;
2178 /* See if this is one of the special sections. */
2179 if (sec->name == NULL)
2182 bed = get_elf_backend_data (abfd);
2183 spec = bed->special_sections;
2186 spec = _bfd_elf_get_special_section (sec->name,
2187 bed->special_sections,
2193 if (sec->name[0] != '.')
2196 i = sec->name[1] - 'b';
2197 if (i < 0 || i > 'z' - 'b')
2200 spec = special_sections[i];
2205 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2209 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2211 struct bfd_elf_section_data *sdata;
2212 const struct elf_backend_data *bed;
2213 const struct bfd_elf_special_section *ssect;
2215 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2218 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2222 sec->used_by_bfd = sdata;
2225 /* Indicate whether or not this section should use RELA relocations. */
2226 bed = get_elf_backend_data (abfd);
2227 sec->use_rela_p = bed->default_use_rela_p;
2229 /* When we read a file, we don't need to set ELF section type and
2230 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2231 anyway. We will set ELF section type and flags for all linker
2232 created sections. If user specifies BFD section flags, we will
2233 set ELF section type and flags based on BFD section flags in
2234 elf_fake_sections. */
2235 if ((!sec->flags && abfd->direction != read_direction)
2236 || (sec->flags & SEC_LINKER_CREATED) != 0)
2238 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2241 elf_section_type (sec) = ssect->type;
2242 elf_section_flags (sec) = ssect->attr;
2246 return _bfd_generic_new_section_hook (abfd, sec);
2249 /* Create a new bfd section from an ELF program header.
2251 Since program segments have no names, we generate a synthetic name
2252 of the form segment<NUM>, where NUM is generally the index in the
2253 program header table. For segments that are split (see below) we
2254 generate the names segment<NUM>a and segment<NUM>b.
2256 Note that some program segments may have a file size that is different than
2257 (less than) the memory size. All this means is that at execution the
2258 system must allocate the amount of memory specified by the memory size,
2259 but only initialize it with the first "file size" bytes read from the
2260 file. This would occur for example, with program segments consisting
2261 of combined data+bss.
2263 To handle the above situation, this routine generates TWO bfd sections
2264 for the single program segment. The first has the length specified by
2265 the file size of the segment, and the second has the length specified
2266 by the difference between the two sizes. In effect, the segment is split
2267 into its initialized and uninitialized parts.
2272 _bfd_elf_make_section_from_phdr (bfd *abfd,
2273 Elf_Internal_Phdr *hdr,
2275 const char *type_name)
2283 split = ((hdr->p_memsz > 0)
2284 && (hdr->p_filesz > 0)
2285 && (hdr->p_memsz > hdr->p_filesz));
2287 if (hdr->p_filesz > 0)
2289 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2290 len = strlen (namebuf) + 1;
2291 name = (char *) bfd_alloc (abfd, len);
2294 memcpy (name, namebuf, len);
2295 newsect = bfd_make_section (abfd, name);
2296 if (newsect == NULL)
2298 newsect->vma = hdr->p_vaddr;
2299 newsect->lma = hdr->p_paddr;
2300 newsect->size = hdr->p_filesz;
2301 newsect->filepos = hdr->p_offset;
2302 newsect->flags |= SEC_HAS_CONTENTS;
2303 newsect->alignment_power = bfd_log2 (hdr->p_align);
2304 if (hdr->p_type == PT_LOAD)
2306 newsect->flags |= SEC_ALLOC;
2307 newsect->flags |= SEC_LOAD;
2308 if (hdr->p_flags & PF_X)
2310 /* FIXME: all we known is that it has execute PERMISSION,
2312 newsect->flags |= SEC_CODE;
2315 if (!(hdr->p_flags & PF_W))
2317 newsect->flags |= SEC_READONLY;
2321 if (hdr->p_memsz > hdr->p_filesz)
2325 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2326 len = strlen (namebuf) + 1;
2327 name = (char *) bfd_alloc (abfd, len);
2330 memcpy (name, namebuf, len);
2331 newsect = bfd_make_section (abfd, name);
2332 if (newsect == NULL)
2334 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2335 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2336 newsect->size = hdr->p_memsz - hdr->p_filesz;
2337 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2338 align = newsect->vma & -newsect->vma;
2339 if (align == 0 || align > hdr->p_align)
2340 align = hdr->p_align;
2341 newsect->alignment_power = bfd_log2 (align);
2342 if (hdr->p_type == PT_LOAD)
2344 /* Hack for gdb. Segments that have not been modified do
2345 not have their contents written to a core file, on the
2346 assumption that a debugger can find the contents in the
2347 executable. We flag this case by setting the fake
2348 section size to zero. Note that "real" bss sections will
2349 always have their contents dumped to the core file. */
2350 if (bfd_get_format (abfd) == bfd_core)
2352 newsect->flags |= SEC_ALLOC;
2353 if (hdr->p_flags & PF_X)
2354 newsect->flags |= SEC_CODE;
2356 if (!(hdr->p_flags & PF_W))
2357 newsect->flags |= SEC_READONLY;
2364 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2366 const struct elf_backend_data *bed;
2368 switch (hdr->p_type)
2371 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2374 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2377 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2380 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2383 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2385 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2390 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2393 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2395 case PT_GNU_EH_FRAME:
2396 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2400 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2403 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2406 /* Check for any processor-specific program segment types. */
2407 bed = get_elf_backend_data (abfd);
2408 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2412 /* Initialize REL_HDR, the section-header for new section, containing
2413 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2414 relocations; otherwise, we use REL relocations. */
2417 _bfd_elf_init_reloc_shdr (bfd *abfd,
2418 Elf_Internal_Shdr *rel_hdr,
2420 bfd_boolean use_rela_p)
2423 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2424 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2426 name = (char *) bfd_alloc (abfd, amt);
2429 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2431 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2433 if (rel_hdr->sh_name == (unsigned int) -1)
2435 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2436 rel_hdr->sh_entsize = (use_rela_p
2437 ? bed->s->sizeof_rela
2438 : bed->s->sizeof_rel);
2439 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2440 rel_hdr->sh_flags = 0;
2441 rel_hdr->sh_addr = 0;
2442 rel_hdr->sh_size = 0;
2443 rel_hdr->sh_offset = 0;
2448 /* Return the default section type based on the passed in section flags. */
2451 bfd_elf_get_default_section_type (flagword flags)
2453 if ((flags & SEC_ALLOC) != 0
2454 && ((flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0
2455 || (flags & SEC_NEVER_LOAD) != 0))
2457 return SHT_PROGBITS;
2460 /* Set up an ELF internal section header for a section. */
2463 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2465 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2466 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2467 Elf_Internal_Shdr *this_hdr;
2468 unsigned int sh_type;
2472 /* We already failed; just get out of the bfd_map_over_sections
2477 this_hdr = &elf_section_data (asect)->this_hdr;
2479 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2480 asect->name, FALSE);
2481 if (this_hdr->sh_name == (unsigned int) -1)
2487 /* Don't clear sh_flags. Assembler may set additional bits. */
2489 if ((asect->flags & SEC_ALLOC) != 0
2490 || asect->user_set_vma)
2491 this_hdr->sh_addr = asect->vma;
2493 this_hdr->sh_addr = 0;
2495 this_hdr->sh_offset = 0;
2496 this_hdr->sh_size = asect->size;
2497 this_hdr->sh_link = 0;
2498 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2499 /* The sh_entsize and sh_info fields may have been set already by
2500 copy_private_section_data. */
2502 this_hdr->bfd_section = asect;
2503 this_hdr->contents = NULL;
2505 /* If the section type is unspecified, we set it based on
2507 if ((asect->flags & SEC_GROUP) != 0)
2508 sh_type = SHT_GROUP;
2510 sh_type = bfd_elf_get_default_section_type (asect->flags);
2512 if (this_hdr->sh_type == SHT_NULL)
2513 this_hdr->sh_type = sh_type;
2514 else if (this_hdr->sh_type == SHT_NOBITS
2515 && sh_type == SHT_PROGBITS
2516 && (asect->flags & SEC_ALLOC) != 0)
2518 /* Warn if we are changing a NOBITS section to PROGBITS, but
2519 allow the link to proceed. This can happen when users link
2520 non-bss input sections to bss output sections, or emit data
2521 to a bss output section via a linker script. */
2522 (*_bfd_error_handler)
2523 (_("warning: section `%A' type changed to PROGBITS"), asect);
2524 this_hdr->sh_type = sh_type;
2527 switch (this_hdr->sh_type)
2533 case SHT_INIT_ARRAY:
2534 case SHT_FINI_ARRAY:
2535 case SHT_PREINIT_ARRAY:
2542 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2546 this_hdr->sh_entsize = bed->s->sizeof_sym;
2550 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2554 if (get_elf_backend_data (abfd)->may_use_rela_p)
2555 this_hdr->sh_entsize = bed->s->sizeof_rela;
2559 if (get_elf_backend_data (abfd)->may_use_rel_p)
2560 this_hdr->sh_entsize = bed->s->sizeof_rel;
2563 case SHT_GNU_versym:
2564 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2567 case SHT_GNU_verdef:
2568 this_hdr->sh_entsize = 0;
2569 /* objcopy or strip will copy over sh_info, but may not set
2570 cverdefs. The linker will set cverdefs, but sh_info will be
2572 if (this_hdr->sh_info == 0)
2573 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2575 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2576 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2579 case SHT_GNU_verneed:
2580 this_hdr->sh_entsize = 0;
2581 /* objcopy or strip will copy over sh_info, but may not set
2582 cverrefs. The linker will set cverrefs, but sh_info will be
2584 if (this_hdr->sh_info == 0)
2585 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2587 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2588 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2592 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2596 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2600 if ((asect->flags & SEC_ALLOC) != 0)
2601 this_hdr->sh_flags |= SHF_ALLOC;
2602 if ((asect->flags & SEC_READONLY) == 0)
2603 this_hdr->sh_flags |= SHF_WRITE;
2604 if ((asect->flags & SEC_CODE) != 0)
2605 this_hdr->sh_flags |= SHF_EXECINSTR;
2606 if ((asect->flags & SEC_MERGE) != 0)
2608 this_hdr->sh_flags |= SHF_MERGE;
2609 this_hdr->sh_entsize = asect->entsize;
2610 if ((asect->flags & SEC_STRINGS) != 0)
2611 this_hdr->sh_flags |= SHF_STRINGS;
2613 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2614 this_hdr->sh_flags |= SHF_GROUP;
2615 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2617 this_hdr->sh_flags |= SHF_TLS;
2618 if (asect->size == 0
2619 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2621 struct bfd_link_order *o = asect->map_tail.link_order;
2623 this_hdr->sh_size = 0;
2626 this_hdr->sh_size = o->offset + o->size;
2627 if (this_hdr->sh_size != 0)
2628 this_hdr->sh_type = SHT_NOBITS;
2632 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2633 this_hdr->sh_flags |= SHF_EXCLUDE;
2635 /* Check for processor-specific section types. */
2636 sh_type = this_hdr->sh_type;
2637 if (bed->elf_backend_fake_sections
2638 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2641 if (sh_type == SHT_NOBITS && asect->size != 0)
2643 /* Don't change the header type from NOBITS if we are being
2644 called for objcopy --only-keep-debug. */
2645 this_hdr->sh_type = sh_type;
2648 /* If the section has relocs, set up a section header for the
2649 SHT_REL[A] section. If two relocation sections are required for
2650 this section, it is up to the processor-specific back-end to
2651 create the other. */
2652 if ((asect->flags & SEC_RELOC) != 0
2653 && !_bfd_elf_init_reloc_shdr (abfd,
2654 &elf_section_data (asect)->rel_hdr,
2660 /* Fill in the contents of a SHT_GROUP section. Called from
2661 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2662 when ELF targets use the generic linker, ld. Called for ld -r
2663 from bfd_elf_final_link. */
2666 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2668 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2669 asection *elt, *first;
2673 /* Ignore linker created group section. See elfNN_ia64_object_p in
2675 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2679 if (elf_section_data (sec)->this_hdr.sh_info == 0)
2681 unsigned long symindx = 0;
2683 /* elf_group_id will have been set up by objcopy and the
2685 if (elf_group_id (sec) != NULL)
2686 symindx = elf_group_id (sec)->udata.i;
2690 /* If called from the assembler, swap_out_syms will have set up
2691 elf_section_syms. */
2692 BFD_ASSERT (elf_section_syms (abfd) != NULL);
2693 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2695 elf_section_data (sec)->this_hdr.sh_info = symindx;
2697 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2699 /* The ELF backend linker sets sh_info to -2 when the group
2700 signature symbol is global, and thus the index can't be
2701 set until all local symbols are output. */
2702 asection *igroup = elf_sec_group (elf_next_in_group (sec));
2703 struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2704 unsigned long symndx = sec_data->this_hdr.sh_info;
2705 unsigned long extsymoff = 0;
2706 struct elf_link_hash_entry *h;
2708 if (!elf_bad_symtab (igroup->owner))
2710 Elf_Internal_Shdr *symtab_hdr;
2712 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2713 extsymoff = symtab_hdr->sh_info;
2715 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2716 while (h->root.type == bfd_link_hash_indirect
2717 || h->root.type == bfd_link_hash_warning)
2718 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2720 elf_section_data (sec)->this_hdr.sh_info = h->indx;
2723 /* The contents won't be allocated for "ld -r" or objcopy. */
2725 if (sec->contents == NULL)
2728 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
2730 /* Arrange for the section to be written out. */
2731 elf_section_data (sec)->this_hdr.contents = sec->contents;
2732 if (sec->contents == NULL)
2739 loc = sec->contents + sec->size;
2741 /* Get the pointer to the first section in the group that gas
2742 squirreled away here. objcopy arranges for this to be set to the
2743 start of the input section group. */
2744 first = elt = elf_next_in_group (sec);
2746 /* First element is a flag word. Rest of section is elf section
2747 indices for all the sections of the group. Write them backwards
2748 just to keep the group in the same order as given in .section
2749 directives, not that it matters. */
2756 s = s->output_section;
2758 && !bfd_is_abs_section (s))
2760 unsigned int idx = elf_section_data (s)->this_idx;
2763 H_PUT_32 (abfd, idx, loc);
2765 elt = elf_next_in_group (elt);
2770 if ((loc -= 4) != sec->contents)
2773 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2776 /* Assign all ELF section numbers. The dummy first section is handled here
2777 too. The link/info pointers for the standard section types are filled
2778 in here too, while we're at it. */
2781 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2783 struct elf_obj_tdata *t = elf_tdata (abfd);
2785 unsigned int section_number, secn;
2786 Elf_Internal_Shdr **i_shdrp;
2787 struct bfd_elf_section_data *d;
2788 bfd_boolean need_symtab;
2792 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2794 /* SHT_GROUP sections are in relocatable files only. */
2795 if (link_info == NULL || link_info->relocatable)
2797 /* Put SHT_GROUP sections first. */
2798 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2800 d = elf_section_data (sec);
2802 if (d->this_hdr.sh_type == SHT_GROUP)
2804 if (sec->flags & SEC_LINKER_CREATED)
2806 /* Remove the linker created SHT_GROUP sections. */
2807 bfd_section_list_remove (abfd, sec);
2808 abfd->section_count--;
2811 d->this_idx = section_number++;
2816 for (sec = abfd->sections; sec; sec = sec->next)
2818 d = elf_section_data (sec);
2820 if (d->this_hdr.sh_type != SHT_GROUP)
2821 d->this_idx = section_number++;
2822 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2823 if ((sec->flags & SEC_RELOC) == 0)
2827 d->rel_idx = section_number++;
2828 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2833 d->rel_idx2 = section_number++;
2834 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2840 t->shstrtab_section = section_number++;
2841 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2842 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2844 need_symtab = (bfd_get_symcount (abfd) > 0
2845 || (link_info == NULL
2846 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2850 t->symtab_section = section_number++;
2851 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2852 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2854 t->symtab_shndx_section = section_number++;
2855 t->symtab_shndx_hdr.sh_name
2856 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2857 ".symtab_shndx", FALSE);
2858 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2861 t->strtab_section = section_number++;
2862 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2865 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2866 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2868 elf_numsections (abfd) = section_number;
2869 elf_elfheader (abfd)->e_shnum = section_number;
2871 /* Set up the list of section header pointers, in agreement with the
2873 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
2874 sizeof (Elf_Internal_Shdr *));
2875 if (i_shdrp == NULL)
2878 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
2879 sizeof (Elf_Internal_Shdr));
2880 if (i_shdrp[0] == NULL)
2882 bfd_release (abfd, i_shdrp);
2886 elf_elfsections (abfd) = i_shdrp;
2888 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2891 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2892 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
2894 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2895 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2897 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2898 t->symtab_hdr.sh_link = t->strtab_section;
2901 for (sec = abfd->sections; sec; sec = sec->next)
2906 d = elf_section_data (sec);
2908 i_shdrp[d->this_idx] = &d->this_hdr;
2909 if (d->rel_idx != 0)
2910 i_shdrp[d->rel_idx] = &d->rel_hdr;
2911 if (d->rel_idx2 != 0)
2912 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2914 /* Fill in the sh_link and sh_info fields while we're at it. */
2916 /* sh_link of a reloc section is the section index of the symbol
2917 table. sh_info is the section index of the section to which
2918 the relocation entries apply. */
2919 if (d->rel_idx != 0)
2921 d->rel_hdr.sh_link = t->symtab_section;
2922 d->rel_hdr.sh_info = d->this_idx;
2924 if (d->rel_idx2 != 0)
2926 d->rel_hdr2->sh_link = t->symtab_section;
2927 d->rel_hdr2->sh_info = d->this_idx;
2930 /* We need to set up sh_link for SHF_LINK_ORDER. */
2931 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2933 s = elf_linked_to_section (sec);
2936 /* elf_linked_to_section points to the input section. */
2937 if (link_info != NULL)
2939 /* Check discarded linkonce section. */
2940 if (elf_discarded_section (s))
2943 (*_bfd_error_handler)
2944 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2945 abfd, d->this_hdr.bfd_section,
2947 /* Point to the kept section if it has the same
2948 size as the discarded one. */
2949 kept = _bfd_elf_check_kept_section (s, link_info);
2952 bfd_set_error (bfd_error_bad_value);
2958 s = s->output_section;
2959 BFD_ASSERT (s != NULL);
2963 /* Handle objcopy. */
2964 if (s->output_section == NULL)
2966 (*_bfd_error_handler)
2967 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2968 abfd, d->this_hdr.bfd_section, s, s->owner);
2969 bfd_set_error (bfd_error_bad_value);
2972 s = s->output_section;
2974 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2979 The Intel C compiler generates SHT_IA_64_UNWIND with
2980 SHF_LINK_ORDER. But it doesn't set the sh_link or
2981 sh_info fields. Hence we could get the situation
2983 const struct elf_backend_data *bed
2984 = get_elf_backend_data (abfd);
2985 if (bed->link_order_error_handler)
2986 bed->link_order_error_handler
2987 (_("%B: warning: sh_link not set for section `%A'"),
2992 switch (d->this_hdr.sh_type)
2996 /* A reloc section which we are treating as a normal BFD
2997 section. sh_link is the section index of the symbol
2998 table. sh_info is the section index of the section to
2999 which the relocation entries apply. We assume that an
3000 allocated reloc section uses the dynamic symbol table.
3001 FIXME: How can we be sure? */
3002 s = bfd_get_section_by_name (abfd, ".dynsym");
3004 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3006 /* We look up the section the relocs apply to by name. */
3008 if (d->this_hdr.sh_type == SHT_REL)
3012 s = bfd_get_section_by_name (abfd, name);
3014 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3018 /* We assume that a section named .stab*str is a stabs
3019 string section. We look for a section with the same name
3020 but without the trailing ``str'', and set its sh_link
3021 field to point to this section. */
3022 if (CONST_STRNEQ (sec->name, ".stab")
3023 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3028 len = strlen (sec->name);
3029 alc = (char *) bfd_malloc (len - 2);
3032 memcpy (alc, sec->name, len - 3);
3033 alc[len - 3] = '\0';
3034 s = bfd_get_section_by_name (abfd, alc);
3038 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3040 /* This is a .stab section. */
3041 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3042 elf_section_data (s)->this_hdr.sh_entsize
3043 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3050 case SHT_GNU_verneed:
3051 case SHT_GNU_verdef:
3052 /* sh_link is the section header index of the string table
3053 used for the dynamic entries, or the symbol table, or the
3055 s = bfd_get_section_by_name (abfd, ".dynstr");
3057 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3060 case SHT_GNU_LIBLIST:
3061 /* sh_link is the section header index of the prelink library
3062 list used for the dynamic entries, or the symbol table, or
3063 the version strings. */
3064 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3065 ? ".dynstr" : ".gnu.libstr");
3067 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3072 case SHT_GNU_versym:
3073 /* sh_link is the section header index of the symbol table
3074 this hash table or version table is for. */
3075 s = bfd_get_section_by_name (abfd, ".dynsym");
3077 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3081 d->this_hdr.sh_link = t->symtab_section;
3085 for (secn = 1; secn < section_number; ++secn)
3086 if (i_shdrp[secn] == NULL)
3087 i_shdrp[secn] = i_shdrp[0];
3089 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3090 i_shdrp[secn]->sh_name);
3094 /* Map symbol from it's internal number to the external number, moving
3095 all local symbols to be at the head of the list. */
3098 sym_is_global (bfd *abfd, asymbol *sym)
3100 /* If the backend has a special mapping, use it. */
3101 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3102 if (bed->elf_backend_sym_is_global)
3103 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3105 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3106 || bfd_is_und_section (bfd_get_section (sym))
3107 || bfd_is_com_section (bfd_get_section (sym)));
3110 /* Don't output section symbols for sections that are not going to be
3114 ignore_section_sym (bfd *abfd, asymbol *sym)
3116 return ((sym->flags & BSF_SECTION_SYM) != 0
3117 && !(sym->section->owner == abfd
3118 || (sym->section->output_section->owner == abfd
3119 && sym->section->output_offset == 0)));
3123 elf_map_symbols (bfd *abfd)
3125 unsigned int symcount = bfd_get_symcount (abfd);
3126 asymbol **syms = bfd_get_outsymbols (abfd);
3127 asymbol **sect_syms;
3128 unsigned int num_locals = 0;
3129 unsigned int num_globals = 0;
3130 unsigned int num_locals2 = 0;
3131 unsigned int num_globals2 = 0;
3138 fprintf (stderr, "elf_map_symbols\n");
3142 for (asect = abfd->sections; asect; asect = asect->next)
3144 if (max_index < asect->index)
3145 max_index = asect->index;
3149 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3150 if (sect_syms == NULL)
3152 elf_section_syms (abfd) = sect_syms;
3153 elf_num_section_syms (abfd) = max_index;
3155 /* Init sect_syms entries for any section symbols we have already
3156 decided to output. */
3157 for (idx = 0; idx < symcount; idx++)
3159 asymbol *sym = syms[idx];
3161 if ((sym->flags & BSF_SECTION_SYM) != 0
3163 && !ignore_section_sym (abfd, sym))
3165 asection *sec = sym->section;
3167 if (sec->owner != abfd)
3168 sec = sec->output_section;
3170 sect_syms[sec->index] = syms[idx];
3174 /* Classify all of the symbols. */
3175 for (idx = 0; idx < symcount; idx++)
3177 if (ignore_section_sym (abfd, syms[idx]))
3179 if (!sym_is_global (abfd, syms[idx]))
3185 /* We will be adding a section symbol for each normal BFD section. Most
3186 sections will already have a section symbol in outsymbols, but
3187 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3188 at least in that case. */
3189 for (asect = abfd->sections; asect; asect = asect->next)
3191 if (sect_syms[asect->index] == NULL)
3193 if (!sym_is_global (abfd, asect->symbol))
3200 /* Now sort the symbols so the local symbols are first. */
3201 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3202 sizeof (asymbol *));
3204 if (new_syms == NULL)
3207 for (idx = 0; idx < symcount; idx++)
3209 asymbol *sym = syms[idx];
3212 if (ignore_section_sym (abfd, sym))
3214 if (!sym_is_global (abfd, sym))
3217 i = num_locals + num_globals2++;
3219 sym->udata.i = i + 1;
3221 for (asect = abfd->sections; asect; asect = asect->next)
3223 if (sect_syms[asect->index] == NULL)
3225 asymbol *sym = asect->symbol;
3228 sect_syms[asect->index] = sym;
3229 if (!sym_is_global (abfd, sym))
3232 i = num_locals + num_globals2++;
3234 sym->udata.i = i + 1;
3238 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3240 elf_num_locals (abfd) = num_locals;
3241 elf_num_globals (abfd) = num_globals;
3245 /* Align to the maximum file alignment that could be required for any
3246 ELF data structure. */
3248 static inline file_ptr
3249 align_file_position (file_ptr off, int align)
3251 return (off + align - 1) & ~(align - 1);
3254 /* Assign a file position to a section, optionally aligning to the
3255 required section alignment. */
3258 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3262 if (align && i_shdrp->sh_addralign > 1)
3263 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3264 i_shdrp->sh_offset = offset;
3265 if (i_shdrp->bfd_section != NULL)
3266 i_shdrp->bfd_section->filepos = offset;
3267 if (i_shdrp->sh_type != SHT_NOBITS)
3268 offset += i_shdrp->sh_size;
3272 /* Compute the file positions we are going to put the sections at, and
3273 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3274 is not NULL, this is being called by the ELF backend linker. */
3277 _bfd_elf_compute_section_file_positions (bfd *abfd,
3278 struct bfd_link_info *link_info)
3280 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3282 struct bfd_strtab_hash *strtab = NULL;
3283 Elf_Internal_Shdr *shstrtab_hdr;
3284 bfd_boolean need_symtab;
3286 if (abfd->output_has_begun)
3289 /* Do any elf backend specific processing first. */
3290 if (bed->elf_backend_begin_write_processing)
3291 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3293 if (! prep_headers (abfd))
3296 /* Post process the headers if necessary. */
3297 if (bed->elf_backend_post_process_headers)
3298 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3301 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3305 if (!assign_section_numbers (abfd, link_info))
3308 /* The backend linker builds symbol table information itself. */
3309 need_symtab = (link_info == NULL
3310 && (bfd_get_symcount (abfd) > 0
3311 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3315 /* Non-zero if doing a relocatable link. */
3316 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3318 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3322 if (link_info == NULL)
3324 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3329 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3330 /* sh_name was set in prep_headers. */
3331 shstrtab_hdr->sh_type = SHT_STRTAB;
3332 shstrtab_hdr->sh_flags = 0;
3333 shstrtab_hdr->sh_addr = 0;
3334 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3335 shstrtab_hdr->sh_entsize = 0;
3336 shstrtab_hdr->sh_link = 0;
3337 shstrtab_hdr->sh_info = 0;
3338 /* sh_offset is set in assign_file_positions_except_relocs. */
3339 shstrtab_hdr->sh_addralign = 1;
3341 if (!assign_file_positions_except_relocs (abfd, link_info))
3347 Elf_Internal_Shdr *hdr;
3349 off = elf_tdata (abfd)->next_file_pos;
3351 hdr = &elf_tdata (abfd)->symtab_hdr;
3352 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3354 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3355 if (hdr->sh_size != 0)
3356 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3358 hdr = &elf_tdata (abfd)->strtab_hdr;
3359 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3361 elf_tdata (abfd)->next_file_pos = off;
3363 /* Now that we know where the .strtab section goes, write it
3365 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3366 || ! _bfd_stringtab_emit (abfd, strtab))
3368 _bfd_stringtab_free (strtab);
3371 abfd->output_has_begun = TRUE;
3376 /* Make an initial estimate of the size of the program header. If we
3377 get the number wrong here, we'll redo section placement. */
3379 static bfd_size_type
3380 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3384 const struct elf_backend_data *bed;
3386 /* Assume we will need exactly two PT_LOAD segments: one for text
3387 and one for data. */
3390 s = bfd_get_section_by_name (abfd, ".interp");
3391 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3393 /* If we have a loadable interpreter section, we need a
3394 PT_INTERP segment. In this case, assume we also need a
3395 PT_PHDR segment, although that may not be true for all
3400 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3402 /* We need a PT_DYNAMIC segment. */
3406 if (info != NULL && info->relro)
3408 /* We need a PT_GNU_RELRO segment. */
3412 if (elf_tdata (abfd)->eh_frame_hdr)
3414 /* We need a PT_GNU_EH_FRAME segment. */
3418 if (elf_tdata (abfd)->stack_flags)
3420 /* We need a PT_GNU_STACK segment. */
3424 for (s = abfd->sections; s != NULL; s = s->next)
3426 if ((s->flags & SEC_LOAD) != 0
3427 && CONST_STRNEQ (s->name, ".note"))
3429 /* We need a PT_NOTE segment. */
3431 /* Try to create just one PT_NOTE segment
3432 for all adjacent loadable .note* sections.
3433 gABI requires that within a PT_NOTE segment
3434 (and also inside of each SHT_NOTE section)
3435 each note is padded to a multiple of 4 size,
3436 so we check whether the sections are correctly
3438 if (s->alignment_power == 2)
3439 while (s->next != NULL
3440 && s->next->alignment_power == 2
3441 && (s->next->flags & SEC_LOAD) != 0
3442 && CONST_STRNEQ (s->next->name, ".note"))
3447 for (s = abfd->sections; s != NULL; s = s->next)
3449 if (s->flags & SEC_THREAD_LOCAL)
3451 /* We need a PT_TLS segment. */
3457 /* Let the backend count up any program headers it might need. */
3458 bed = get_elf_backend_data (abfd);
3459 if (bed->elf_backend_additional_program_headers)
3463 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3469 return segs * bed->s->sizeof_phdr;
3472 /* Find the segment that contains the output_section of section. */
3475 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3477 struct elf_segment_map *m;
3478 Elf_Internal_Phdr *p;
3480 for (m = elf_tdata (abfd)->segment_map,
3481 p = elf_tdata (abfd)->phdr;
3487 for (i = m->count - 1; i >= 0; i--)
3488 if (m->sections[i] == section)
3495 /* Create a mapping from a set of sections to a program segment. */
3497 static struct elf_segment_map *
3498 make_mapping (bfd *abfd,
3499 asection **sections,
3504 struct elf_segment_map *m;
3509 amt = sizeof (struct elf_segment_map);
3510 amt += (to - from - 1) * sizeof (asection *);
3511 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3515 m->p_type = PT_LOAD;
3516 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3517 m->sections[i - from] = *hdrpp;
3518 m->count = to - from;
3520 if (from == 0 && phdr)
3522 /* Include the headers in the first PT_LOAD segment. */
3523 m->includes_filehdr = 1;
3524 m->includes_phdrs = 1;
3530 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3533 struct elf_segment_map *
3534 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3536 struct elf_segment_map *m;
3538 m = (struct elf_segment_map *) bfd_zalloc (abfd,
3539 sizeof (struct elf_segment_map));
3543 m->p_type = PT_DYNAMIC;
3545 m->sections[0] = dynsec;
3550 /* Possibly add or remove segments from the segment map. */
3553 elf_modify_segment_map (bfd *abfd,
3554 struct bfd_link_info *info,
3555 bfd_boolean remove_empty_load)
3557 struct elf_segment_map **m;
3558 const struct elf_backend_data *bed;
3560 /* The placement algorithm assumes that non allocated sections are
3561 not in PT_LOAD segments. We ensure this here by removing such
3562 sections from the segment map. We also remove excluded
3563 sections. Finally, any PT_LOAD segment without sections is
3565 m = &elf_tdata (abfd)->segment_map;
3568 unsigned int i, new_count;
3570 for (new_count = 0, i = 0; i < (*m)->count; i++)
3572 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3573 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3574 || (*m)->p_type != PT_LOAD))
3576 (*m)->sections[new_count] = (*m)->sections[i];
3580 (*m)->count = new_count;
3582 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3588 bed = get_elf_backend_data (abfd);
3589 if (bed->elf_backend_modify_segment_map != NULL)
3591 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3598 /* Set up a mapping from BFD sections to program segments. */
3601 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3604 struct elf_segment_map *m;
3605 asection **sections = NULL;
3606 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3607 bfd_boolean no_user_phdrs;
3609 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3610 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3614 struct elf_segment_map *mfirst;
3615 struct elf_segment_map **pm;
3618 unsigned int phdr_index;
3619 bfd_vma maxpagesize;
3621 bfd_boolean phdr_in_segment = TRUE;
3622 bfd_boolean writable;
3624 asection *first_tls = NULL;
3625 asection *dynsec, *eh_frame_hdr;
3628 /* Select the allocated sections, and sort them. */
3630 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3631 sizeof (asection *));
3632 if (sections == NULL)
3636 for (s = abfd->sections; s != NULL; s = s->next)
3638 if ((s->flags & SEC_ALLOC) != 0)
3644 BFD_ASSERT (i <= bfd_count_sections (abfd));
3647 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3649 /* Build the mapping. */
3654 /* If we have a .interp section, then create a PT_PHDR segment for
3655 the program headers and a PT_INTERP segment for the .interp
3657 s = bfd_get_section_by_name (abfd, ".interp");
3658 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3660 amt = sizeof (struct elf_segment_map);
3661 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3665 m->p_type = PT_PHDR;
3666 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3667 m->p_flags = PF_R | PF_X;
3668 m->p_flags_valid = 1;
3669 m->includes_phdrs = 1;
3674 amt = sizeof (struct elf_segment_map);
3675 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3679 m->p_type = PT_INTERP;
3687 /* Look through the sections. We put sections in the same program
3688 segment when the start of the second section can be placed within
3689 a few bytes of the end of the first section. */
3693 maxpagesize = bed->maxpagesize;
3695 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3697 && (dynsec->flags & SEC_LOAD) == 0)
3700 /* Deal with -Ttext or something similar such that the first section
3701 is not adjacent to the program headers. This is an
3702 approximation, since at this point we don't know exactly how many
3703 program headers we will need. */
3706 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3708 if (phdr_size == (bfd_size_type) -1)
3709 phdr_size = get_program_header_size (abfd, info);
3710 if ((abfd->flags & D_PAGED) == 0
3711 || sections[0]->lma < phdr_size
3712 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3713 phdr_in_segment = FALSE;
3716 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3719 bfd_boolean new_segment;
3723 /* See if this section and the last one will fit in the same
3726 if (last_hdr == NULL)
3728 /* If we don't have a segment yet, then we don't need a new
3729 one (we build the last one after this loop). */
3730 new_segment = FALSE;
3732 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3734 /* If this section has a different relation between the
3735 virtual address and the load address, then we need a new
3739 else if (hdr->lma < last_hdr->lma + last_size
3740 || last_hdr->lma + last_size < last_hdr->lma)
3742 /* If this section has a load address that makes it overlap
3743 the previous section, then we need a new segment. */
3746 /* In the next test we have to be careful when last_hdr->lma is close
3747 to the end of the address space. If the aligned address wraps
3748 around to the start of the address space, then there are no more
3749 pages left in memory and it is OK to assume that the current
3750 section can be included in the current segment. */
3751 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3753 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3756 /* If putting this section in this segment would force us to
3757 skip a page in the segment, then we need a new segment. */
3760 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3761 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3763 /* We don't want to put a loadable section after a
3764 nonloadable section in the same segment.
3765 Consider .tbss sections as loadable for this purpose. */
3768 else if ((abfd->flags & D_PAGED) == 0)
3770 /* If the file is not demand paged, which means that we
3771 don't require the sections to be correctly aligned in the
3772 file, then there is no other reason for a new segment. */
3773 new_segment = FALSE;
3776 && (hdr->flags & SEC_READONLY) == 0
3777 && (((last_hdr->lma + last_size - 1)
3778 & ~(maxpagesize - 1))
3779 != (hdr->lma & ~(maxpagesize - 1))))
3781 /* We don't want to put a writable section in a read only
3782 segment, unless they are on the same page in memory
3783 anyhow. We already know that the last section does not
3784 bring us past the current section on the page, so the
3785 only case in which the new section is not on the same
3786 page as the previous section is when the previous section
3787 ends precisely on a page boundary. */
3792 /* Otherwise, we can use the same segment. */
3793 new_segment = FALSE;
3796 /* Allow interested parties a chance to override our decision. */
3797 if (last_hdr != NULL
3799 && info->callbacks->override_segment_assignment != NULL)
3801 = info->callbacks->override_segment_assignment (info, abfd, hdr,
3807 if ((hdr->flags & SEC_READONLY) == 0)
3810 /* .tbss sections effectively have zero size. */
3811 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3812 != SEC_THREAD_LOCAL)
3813 last_size = hdr->size;
3819 /* We need a new program segment. We must create a new program
3820 header holding all the sections from phdr_index until hdr. */
3822 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3829 if ((hdr->flags & SEC_READONLY) == 0)
3835 /* .tbss sections effectively have zero size. */
3836 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3837 last_size = hdr->size;
3841 phdr_in_segment = FALSE;
3844 /* Create a final PT_LOAD program segment. */
3845 if (last_hdr != NULL)
3847 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3855 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3858 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3865 /* For each batch of consecutive loadable .note sections,
3866 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3867 because if we link together nonloadable .note sections and
3868 loadable .note sections, we will generate two .note sections
3869 in the output file. FIXME: Using names for section types is
3871 for (s = abfd->sections; s != NULL; s = s->next)
3873 if ((s->flags & SEC_LOAD) != 0
3874 && CONST_STRNEQ (s->name, ".note"))
3879 amt = sizeof (struct elf_segment_map);
3880 if (s->alignment_power == 2)
3881 for (s2 = s; s2->next != NULL; s2 = s2->next)
3883 if (s2->next->alignment_power == 2
3884 && (s2->next->flags & SEC_LOAD) != 0
3885 && CONST_STRNEQ (s2->next->name, ".note")
3886 && align_power (s2->vma + s2->size, 2)
3892 amt += (count - 1) * sizeof (asection *);
3893 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3897 m->p_type = PT_NOTE;
3901 m->sections[m->count - count--] = s;
3902 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3905 m->sections[m->count - 1] = s;
3906 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3910 if (s->flags & SEC_THREAD_LOCAL)
3918 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3921 amt = sizeof (struct elf_segment_map);
3922 amt += (tls_count - 1) * sizeof (asection *);
3923 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3928 m->count = tls_count;
3929 /* Mandated PF_R. */
3931 m->p_flags_valid = 1;
3932 for (i = 0; i < (unsigned int) tls_count; ++i)
3934 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3935 m->sections[i] = first_tls;
3936 first_tls = first_tls->next;
3943 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3945 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3946 if (eh_frame_hdr != NULL
3947 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3949 amt = sizeof (struct elf_segment_map);
3950 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3954 m->p_type = PT_GNU_EH_FRAME;
3956 m->sections[0] = eh_frame_hdr->output_section;
3962 if (elf_tdata (abfd)->stack_flags)
3964 amt = sizeof (struct elf_segment_map);
3965 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3969 m->p_type = PT_GNU_STACK;
3970 m->p_flags = elf_tdata (abfd)->stack_flags;
3971 m->p_flags_valid = 1;
3977 if (info != NULL && info->relro)
3979 for (m = mfirst; m != NULL; m = m->next)
3981 if (m->p_type == PT_LOAD)
3983 asection *last = m->sections[m->count - 1];
3984 bfd_vma vaddr = m->sections[0]->vma;
3985 bfd_vma filesz = last->vma - vaddr + last->size;
3987 if (vaddr < info->relro_end
3988 && vaddr >= info->relro_start
3989 && (vaddr + filesz) >= info->relro_end)
3994 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3997 amt = sizeof (struct elf_segment_map);
3998 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4002 m->p_type = PT_GNU_RELRO;
4004 m->p_flags_valid = 1;
4012 elf_tdata (abfd)->segment_map = mfirst;
4015 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
4018 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4020 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
4025 if (sections != NULL)
4030 /* Sort sections by address. */
4033 elf_sort_sections (const void *arg1, const void *arg2)
4035 const asection *sec1 = *(const asection **) arg1;
4036 const asection *sec2 = *(const asection **) arg2;
4037 bfd_size_type size1, size2;
4039 /* Sort by LMA first, since this is the address used to
4040 place the section into a segment. */
4041 if (sec1->lma < sec2->lma)
4043 else if (sec1->lma > sec2->lma)
4046 /* Then sort by VMA. Normally the LMA and the VMA will be
4047 the same, and this will do nothing. */
4048 if (sec1->vma < sec2->vma)
4050 else if (sec1->vma > sec2->vma)
4053 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4055 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4061 /* If the indicies are the same, do not return 0
4062 here, but continue to try the next comparison. */
4063 if (sec1->target_index - sec2->target_index != 0)
4064 return sec1->target_index - sec2->target_index;
4069 else if (TOEND (sec2))
4074 /* Sort by size, to put zero sized sections
4075 before others at the same address. */
4077 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4078 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4085 return sec1->target_index - sec2->target_index;
4088 /* Ian Lance Taylor writes:
4090 We shouldn't be using % with a negative signed number. That's just
4091 not good. We have to make sure either that the number is not
4092 negative, or that the number has an unsigned type. When the types
4093 are all the same size they wind up as unsigned. When file_ptr is a
4094 larger signed type, the arithmetic winds up as signed long long,
4097 What we're trying to say here is something like ``increase OFF by
4098 the least amount that will cause it to be equal to the VMA modulo
4100 /* In other words, something like:
4102 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4103 off_offset = off % bed->maxpagesize;
4104 if (vma_offset < off_offset)
4105 adjustment = vma_offset + bed->maxpagesize - off_offset;
4107 adjustment = vma_offset - off_offset;
4109 which can can be collapsed into the expression below. */
4112 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4114 return ((vma - off) % maxpagesize);
4118 print_segment_map (const struct elf_segment_map *m)
4121 const char *pt = get_segment_type (m->p_type);
4126 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4127 sprintf (buf, "LOPROC+%7.7x",
4128 (unsigned int) (m->p_type - PT_LOPROC));
4129 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4130 sprintf (buf, "LOOS+%7.7x",
4131 (unsigned int) (m->p_type - PT_LOOS));
4133 snprintf (buf, sizeof (buf), "%8.8x",
4134 (unsigned int) m->p_type);
4137 fprintf (stderr, "%s:", pt);
4138 for (j = 0; j < m->count; j++)
4139 fprintf (stderr, " %s", m->sections [j]->name);
4144 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
4149 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4151 buf = bfd_zmalloc (len);
4154 ret = bfd_bwrite (buf, len, abfd) == len;
4159 /* Assign file positions to the sections based on the mapping from
4160 sections to segments. This function also sets up some fields in
4164 assign_file_positions_for_load_sections (bfd *abfd,
4165 struct bfd_link_info *link_info)
4167 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4168 struct elf_segment_map *m;
4169 Elf_Internal_Phdr *phdrs;
4170 Elf_Internal_Phdr *p;
4172 bfd_size_type maxpagesize;
4175 bfd_vma header_pad = 0;
4177 if (link_info == NULL
4178 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
4182 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4186 header_pad = m->header_size;
4189 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4190 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4191 elf_elfheader (abfd)->e_phnum = alloc;
4193 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4194 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4196 BFD_ASSERT (elf_tdata (abfd)->program_header_size
4197 >= alloc * bed->s->sizeof_phdr);
4201 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4205 /* We're writing the size in elf_tdata (abfd)->program_header_size,
4206 see assign_file_positions_except_relocs, so make sure we have
4207 that amount allocated, with trailing space cleared.
4208 The variable alloc contains the computed need, while elf_tdata
4209 (abfd)->program_header_size contains the size used for the
4211 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4212 where the layout is forced to according to a larger size in the
4213 last iterations for the testcase ld-elf/header. */
4214 BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr
4216 phdrs = (Elf_Internal_Phdr *)
4218 (elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr),
4219 sizeof (Elf_Internal_Phdr));
4220 elf_tdata (abfd)->phdr = phdrs;
4225 if ((abfd->flags & D_PAGED) != 0)
4226 maxpagesize = bed->maxpagesize;
4228 off = bed->s->sizeof_ehdr;
4229 off += alloc * bed->s->sizeof_phdr;
4230 if (header_pad < (bfd_vma) off)
4236 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4238 m = m->next, p++, j++)
4242 bfd_boolean no_contents;
4244 /* If elf_segment_map is not from map_sections_to_segments, the
4245 sections may not be correctly ordered. NOTE: sorting should
4246 not be done to the PT_NOTE section of a corefile, which may
4247 contain several pseudo-sections artificially created by bfd.
4248 Sorting these pseudo-sections breaks things badly. */
4250 && !(elf_elfheader (abfd)->e_type == ET_CORE
4251 && m->p_type == PT_NOTE))
4252 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4255 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4256 number of sections with contents contributing to both p_filesz
4257 and p_memsz, followed by a number of sections with no contents
4258 that just contribute to p_memsz. In this loop, OFF tracks next
4259 available file offset for PT_LOAD and PT_NOTE segments. */
4260 p->p_type = m->p_type;
4261 p->p_flags = m->p_flags;
4266 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4268 if (m->p_paddr_valid)
4269 p->p_paddr = m->p_paddr;
4270 else if (m->count == 0)
4273 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4275 if (p->p_type == PT_LOAD
4276 && (abfd->flags & D_PAGED) != 0)
4278 /* p_align in demand paged PT_LOAD segments effectively stores
4279 the maximum page size. When copying an executable with
4280 objcopy, we set m->p_align from the input file. Use this
4281 value for maxpagesize rather than bed->maxpagesize, which
4282 may be different. Note that we use maxpagesize for PT_TLS
4283 segment alignment later in this function, so we are relying
4284 on at least one PT_LOAD segment appearing before a PT_TLS
4286 if (m->p_align_valid)
4287 maxpagesize = m->p_align;
4289 p->p_align = maxpagesize;
4291 else if (m->p_align_valid)
4292 p->p_align = m->p_align;
4293 else if (m->count == 0)
4294 p->p_align = 1 << bed->s->log_file_align;
4298 no_contents = FALSE;
4300 if (p->p_type == PT_LOAD
4303 bfd_size_type align;
4304 unsigned int align_power = 0;
4306 if (m->p_align_valid)
4310 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4312 unsigned int secalign;
4314 secalign = bfd_get_section_alignment (abfd, *secpp);
4315 if (secalign > align_power)
4316 align_power = secalign;
4318 align = (bfd_size_type) 1 << align_power;
4319 if (align < maxpagesize)
4320 align = maxpagesize;
4323 for (i = 0; i < m->count; i++)
4324 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4325 /* If we aren't making room for this section, then
4326 it must be SHT_NOBITS regardless of what we've
4327 set via struct bfd_elf_special_section. */
4328 elf_section_type (m->sections[i]) = SHT_NOBITS;
4330 /* Find out whether this segment contains any loadable
4333 for (i = 0; i < m->count; i++)
4334 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4336 no_contents = FALSE;
4340 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
4344 /* We shouldn't need to align the segment on disk since
4345 the segment doesn't need file space, but the gABI
4346 arguably requires the alignment and glibc ld.so
4347 checks it. So to comply with the alignment
4348 requirement but not waste file space, we adjust
4349 p_offset for just this segment. (OFF_ADJUST is
4350 subtracted from OFF later.) This may put p_offset
4351 past the end of file, but that shouldn't matter. */
4356 /* Make sure the .dynamic section is the first section in the
4357 PT_DYNAMIC segment. */
4358 else if (p->p_type == PT_DYNAMIC
4360 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4363 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4365 bfd_set_error (bfd_error_bad_value);
4368 /* Set the note section type to SHT_NOTE. */
4369 else if (p->p_type == PT_NOTE)
4370 for (i = 0; i < m->count; i++)
4371 elf_section_type (m->sections[i]) = SHT_NOTE;
4377 if (m->includes_filehdr)
4379 if (!m->p_flags_valid)
4381 p->p_filesz = bed->s->sizeof_ehdr;
4382 p->p_memsz = bed->s->sizeof_ehdr;
4385 BFD_ASSERT (p->p_type == PT_LOAD);
4387 if (p->p_vaddr < (bfd_vma) off)
4389 (*_bfd_error_handler)
4390 (_("%B: Not enough room for program headers, try linking with -N"),
4392 bfd_set_error (bfd_error_bad_value);
4397 if (!m->p_paddr_valid)
4402 if (m->includes_phdrs)
4404 if (!m->p_flags_valid)
4407 if (!m->includes_filehdr)
4409 p->p_offset = bed->s->sizeof_ehdr;
4413 BFD_ASSERT (p->p_type == PT_LOAD);
4414 p->p_vaddr -= off - p->p_offset;
4415 if (!m->p_paddr_valid)
4416 p->p_paddr -= off - p->p_offset;
4420 p->p_filesz += alloc * bed->s->sizeof_phdr;
4421 p->p_memsz += alloc * bed->s->sizeof_phdr;
4424 p->p_filesz += header_pad;
4425 p->p_memsz += header_pad;
4429 if (p->p_type == PT_LOAD
4430 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4432 if (!m->includes_filehdr && !m->includes_phdrs)
4438 adjust = off - (p->p_offset + p->p_filesz);
4440 p->p_filesz += adjust;
4441 p->p_memsz += adjust;
4445 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4446 maps. Set filepos for sections in PT_LOAD segments, and in
4447 core files, for sections in PT_NOTE segments.
4448 assign_file_positions_for_non_load_sections will set filepos
4449 for other sections and update p_filesz for other segments. */
4450 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4453 bfd_size_type align;
4454 Elf_Internal_Shdr *this_hdr;
4457 this_hdr = &elf_section_data (sec)->this_hdr;
4458 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4460 if ((p->p_type == PT_LOAD
4461 || p->p_type == PT_TLS)
4462 && (this_hdr->sh_type != SHT_NOBITS
4463 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4464 && ((this_hdr->sh_flags & SHF_TLS) == 0
4465 || p->p_type == PT_TLS))))
4467 bfd_vma p_start = p->p_paddr;
4468 bfd_vma p_end = p_start + p->p_memsz;
4469 bfd_vma s_start = sec->lma;
4470 bfd_vma adjust = s_start - p_end;
4475 (*_bfd_error_handler)
4476 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
4477 (unsigned long) s_start, (unsigned long) p_end);
4481 p->p_memsz += adjust;
4483 if (this_hdr->sh_type != SHT_NOBITS)
4485 if (p->p_filesz + adjust < p->p_memsz)
4487 /* We have a PROGBITS section following NOBITS ones.
4488 Allocate file space for the NOBITS section(s) and
4490 adjust = p->p_memsz - p->p_filesz;
4491 if (!write_zeros (abfd, off, adjust))
4495 p->p_filesz += adjust;
4499 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4501 /* The section at i == 0 is the one that actually contains
4505 this_hdr->sh_offset = sec->filepos = off;
4506 off += this_hdr->sh_size;
4507 p->p_filesz = this_hdr->sh_size;
4513 /* The rest are fake sections that shouldn't be written. */
4522 if (p->p_type == PT_LOAD)
4524 this_hdr->sh_offset = sec->filepos = off;
4525 if (this_hdr->sh_type != SHT_NOBITS)
4526 off += this_hdr->sh_size;
4529 if (this_hdr->sh_type != SHT_NOBITS)
4531 p->p_filesz += this_hdr->sh_size;
4532 /* A load section without SHF_ALLOC is something like
4533 a note section in a PT_NOTE segment. These take
4534 file space but are not loaded into memory. */
4535 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4536 p->p_memsz += this_hdr->sh_size;
4538 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4540 if (p->p_type == PT_TLS)
4541 p->p_memsz += this_hdr->sh_size;
4543 /* .tbss is special. It doesn't contribute to p_memsz of
4545 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4546 p->p_memsz += this_hdr->sh_size;
4549 if (align > p->p_align
4550 && !m->p_align_valid
4551 && (p->p_type != PT_LOAD
4552 || (abfd->flags & D_PAGED) == 0))
4556 if (!m->p_flags_valid)
4559 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4561 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4567 /* Check that all sections are in a PT_LOAD segment.
4568 Don't check funky gdb generated core files. */
4569 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4571 bfd_boolean check_vma = TRUE;
4573 for (i = 1; i < m->count; i++)
4574 if (m->sections[i]->vma == m->sections[i - 1]->vma
4575 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
4576 ->this_hdr), p) != 0
4577 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
4578 ->this_hdr), p) != 0)
4580 /* Looks like we have overlays packed into the segment. */
4585 for (i = 0; i < m->count; i++)
4587 Elf_Internal_Shdr *this_hdr;
4590 sec = m->sections[i];
4591 this_hdr = &(elf_section_data(sec)->this_hdr);
4592 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0))
4594 (*_bfd_error_handler)
4595 (_("%B: section `%A' can't be allocated in segment %d"),
4597 print_segment_map (m);
4603 elf_tdata (abfd)->next_file_pos = off;
4607 /* Assign file positions for the other sections. */
4610 assign_file_positions_for_non_load_sections (bfd *abfd,
4611 struct bfd_link_info *link_info)
4613 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4614 Elf_Internal_Shdr **i_shdrpp;
4615 Elf_Internal_Shdr **hdrpp;
4616 Elf_Internal_Phdr *phdrs;
4617 Elf_Internal_Phdr *p;
4618 struct elf_segment_map *m;
4619 bfd_vma filehdr_vaddr, filehdr_paddr;
4620 bfd_vma phdrs_vaddr, phdrs_paddr;
4622 unsigned int num_sec;
4626 i_shdrpp = elf_elfsections (abfd);
4627 num_sec = elf_numsections (abfd);
4628 off = elf_tdata (abfd)->next_file_pos;
4629 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4631 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4632 Elf_Internal_Shdr *hdr;
4635 if (hdr->bfd_section != NULL
4636 && (hdr->bfd_section->filepos != 0
4637 || (hdr->sh_type == SHT_NOBITS
4638 && hdr->contents == NULL)))
4639 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4640 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4642 (*_bfd_error_handler)
4643 (_("%B: warning: allocated section `%s' not in segment"),
4645 (hdr->bfd_section == NULL
4647 : hdr->bfd_section->name));
4648 /* We don't need to page align empty sections. */
4649 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4650 off += vma_page_aligned_bias (hdr->sh_addr, off,
4653 off += vma_page_aligned_bias (hdr->sh_addr, off,
4655 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4658 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4659 && hdr->bfd_section == NULL)
4660 || hdr == i_shdrpp[tdata->symtab_section]
4661 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4662 || hdr == i_shdrpp[tdata->strtab_section])
4663 hdr->sh_offset = -1;
4665 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4668 /* Now that we have set the section file positions, we can set up
4669 the file positions for the non PT_LOAD segments. */
4673 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4675 phdrs = elf_tdata (abfd)->phdr;
4676 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4681 if (p->p_type != PT_LOAD)
4684 if (m->includes_filehdr)
4686 filehdr_vaddr = p->p_vaddr;
4687 filehdr_paddr = p->p_paddr;
4689 if (m->includes_phdrs)
4691 phdrs_vaddr = p->p_vaddr;
4692 phdrs_paddr = p->p_paddr;
4693 if (m->includes_filehdr)
4695 phdrs_vaddr += bed->s->sizeof_ehdr;
4696 phdrs_paddr += bed->s->sizeof_ehdr;
4701 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4705 if (p->p_type == PT_GNU_RELRO)
4707 const Elf_Internal_Phdr *lp;
4709 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4711 if (link_info != NULL)
4713 /* During linking the range of the RELRO segment is passed
4715 for (lp = phdrs; lp < phdrs + count; ++lp)
4717 if (lp->p_type == PT_LOAD
4718 && lp->p_vaddr >= link_info->relro_start
4719 && lp->p_vaddr < link_info->relro_end
4720 && lp->p_vaddr + lp->p_filesz >= link_info->relro_end)
4726 /* Otherwise we are copying an executable or shared
4727 library, but we need to use the same linker logic. */
4728 for (lp = phdrs; lp < phdrs + count; ++lp)
4730 if (lp->p_type == PT_LOAD
4731 && lp->p_paddr == p->p_paddr)
4736 if (lp < phdrs + count)
4738 p->p_vaddr = lp->p_vaddr;
4739 p->p_paddr = lp->p_paddr;
4740 p->p_offset = lp->p_offset;
4741 if (link_info != NULL)
4742 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4743 else if (m->p_size_valid)
4744 p->p_filesz = m->p_size;
4747 p->p_memsz = p->p_filesz;
4749 p->p_flags = (lp->p_flags & ~PF_W);
4753 memset (p, 0, sizeof *p);
4754 p->p_type = PT_NULL;
4757 else if (m->count != 0)
4759 if (p->p_type != PT_LOAD
4760 && (p->p_type != PT_NOTE
4761 || bfd_get_format (abfd) != bfd_core))
4763 Elf_Internal_Shdr *hdr;
4766 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4768 sect = m->sections[m->count - 1];
4769 hdr = &elf_section_data (sect)->this_hdr;
4770 p->p_filesz = sect->filepos - m->sections[0]->filepos;
4771 if (hdr->sh_type != SHT_NOBITS)
4772 p->p_filesz += hdr->sh_size;
4773 p->p_offset = m->sections[0]->filepos;
4776 else if (m->includes_filehdr)
4778 p->p_vaddr = filehdr_vaddr;
4779 if (! m->p_paddr_valid)
4780 p->p_paddr = filehdr_paddr;
4782 else if (m->includes_phdrs)
4784 p->p_vaddr = phdrs_vaddr;
4785 if (! m->p_paddr_valid)
4786 p->p_paddr = phdrs_paddr;
4790 elf_tdata (abfd)->next_file_pos = off;
4795 /* Work out the file positions of all the sections. This is called by
4796 _bfd_elf_compute_section_file_positions. All the section sizes and
4797 VMAs must be known before this is called.
4799 Reloc sections come in two flavours: Those processed specially as
4800 "side-channel" data attached to a section to which they apply, and
4801 those that bfd doesn't process as relocations. The latter sort are
4802 stored in a normal bfd section by bfd_section_from_shdr. We don't
4803 consider the former sort here, unless they form part of the loadable
4804 image. Reloc sections not assigned here will be handled later by
4805 assign_file_positions_for_relocs.
4807 We also don't set the positions of the .symtab and .strtab here. */
4810 assign_file_positions_except_relocs (bfd *abfd,
4811 struct bfd_link_info *link_info)
4813 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4814 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4816 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4818 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4819 && bfd_get_format (abfd) != bfd_core)
4821 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4822 unsigned int num_sec = elf_numsections (abfd);
4823 Elf_Internal_Shdr **hdrpp;
4826 /* Start after the ELF header. */
4827 off = i_ehdrp->e_ehsize;
4829 /* We are not creating an executable, which means that we are
4830 not creating a program header, and that the actual order of
4831 the sections in the file is unimportant. */
4832 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4834 Elf_Internal_Shdr *hdr;
4837 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4838 && hdr->bfd_section == NULL)
4839 || i == tdata->symtab_section
4840 || i == tdata->symtab_shndx_section
4841 || i == tdata->strtab_section)
4843 hdr->sh_offset = -1;
4846 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4853 /* Assign file positions for the loaded sections based on the
4854 assignment of sections to segments. */
4855 if (!assign_file_positions_for_load_sections (abfd, link_info))
4858 /* And for non-load sections. */
4859 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4862 if (bed->elf_backend_modify_program_headers != NULL)
4864 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4868 /* Write out the program headers. */
4869 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4870 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4871 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4874 off = tdata->next_file_pos;
4877 /* Place the section headers. */
4878 off = align_file_position (off, 1 << bed->s->log_file_align);
4879 i_ehdrp->e_shoff = off;
4880 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4882 tdata->next_file_pos = off;
4888 prep_headers (bfd *abfd)
4890 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
4891 struct elf_strtab_hash *shstrtab;
4892 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4894 i_ehdrp = elf_elfheader (abfd);
4896 shstrtab = _bfd_elf_strtab_init ();
4897 if (shstrtab == NULL)
4900 elf_shstrtab (abfd) = shstrtab;
4902 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4903 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4904 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4905 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4907 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4908 i_ehdrp->e_ident[EI_DATA] =
4909 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4910 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4912 if ((abfd->flags & DYNAMIC) != 0)
4913 i_ehdrp->e_type = ET_DYN;
4914 else if ((abfd->flags & EXEC_P) != 0)
4915 i_ehdrp->e_type = ET_EXEC;
4916 else if (bfd_get_format (abfd) == bfd_core)
4917 i_ehdrp->e_type = ET_CORE;
4919 i_ehdrp->e_type = ET_REL;
4921 switch (bfd_get_arch (abfd))
4923 case bfd_arch_unknown:
4924 i_ehdrp->e_machine = EM_NONE;
4927 /* There used to be a long list of cases here, each one setting
4928 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4929 in the corresponding bfd definition. To avoid duplication,
4930 the switch was removed. Machines that need special handling
4931 can generally do it in elf_backend_final_write_processing(),
4932 unless they need the information earlier than the final write.
4933 Such need can generally be supplied by replacing the tests for
4934 e_machine with the conditions used to determine it. */
4936 i_ehdrp->e_machine = bed->elf_machine_code;
4939 i_ehdrp->e_version = bed->s->ev_current;
4940 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4942 /* No program header, for now. */
4943 i_ehdrp->e_phoff = 0;
4944 i_ehdrp->e_phentsize = 0;
4945 i_ehdrp->e_phnum = 0;
4947 /* Each bfd section is section header entry. */
4948 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4949 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4951 /* If we're building an executable, we'll need a program header table. */
4952 if (abfd->flags & EXEC_P)
4953 /* It all happens later. */
4957 i_ehdrp->e_phentsize = 0;
4958 i_ehdrp->e_phoff = 0;
4961 elf_tdata (abfd)->symtab_hdr.sh_name =
4962 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4963 elf_tdata (abfd)->strtab_hdr.sh_name =
4964 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4965 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4966 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4967 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4968 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4969 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4975 /* Assign file positions for all the reloc sections which are not part
4976 of the loadable file image. */
4979 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4982 unsigned int i, num_sec;
4983 Elf_Internal_Shdr **shdrpp;
4985 off = elf_tdata (abfd)->next_file_pos;
4987 num_sec = elf_numsections (abfd);
4988 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4990 Elf_Internal_Shdr *shdrp;
4993 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4994 && shdrp->sh_offset == -1)
4995 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4998 elf_tdata (abfd)->next_file_pos = off;
5002 _bfd_elf_write_object_contents (bfd *abfd)
5004 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5005 Elf_Internal_Shdr **i_shdrp;
5007 unsigned int count, num_sec;
5009 if (! abfd->output_has_begun
5010 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
5013 i_shdrp = elf_elfsections (abfd);
5016 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5020 _bfd_elf_assign_file_positions_for_relocs (abfd);
5022 /* After writing the headers, we need to write the sections too... */
5023 num_sec = elf_numsections (abfd);
5024 for (count = 1; count < num_sec; count++)
5026 if (bed->elf_backend_section_processing)
5027 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5028 if (i_shdrp[count]->contents)
5030 bfd_size_type amt = i_shdrp[count]->sh_size;
5032 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
5033 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
5038 /* Write out the section header names. */
5039 if (elf_shstrtab (abfd) != NULL
5040 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
5041 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
5044 if (bed->elf_backend_final_write_processing)
5045 (*bed->elf_backend_final_write_processing) (abfd,
5046 elf_tdata (abfd)->linker);
5048 if (!bed->s->write_shdrs_and_ehdr (abfd))
5051 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5052 if (elf_tdata (abfd)->after_write_object_contents)
5053 return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
5059 _bfd_elf_write_corefile_contents (bfd *abfd)
5061 /* Hopefully this can be done just like an object file. */
5062 return _bfd_elf_write_object_contents (abfd);
5065 /* Given a section, search the header to find them. */
5068 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5070 const struct elf_backend_data *bed;
5071 unsigned int sec_index;
5073 if (elf_section_data (asect) != NULL
5074 && elf_section_data (asect)->this_idx != 0)
5075 return elf_section_data (asect)->this_idx;
5077 if (bfd_is_abs_section (asect))
5078 sec_index = SHN_ABS;
5079 else if (bfd_is_com_section (asect))
5080 sec_index = SHN_COMMON;
5081 else if (bfd_is_und_section (asect))
5082 sec_index = SHN_UNDEF;
5084 sec_index = SHN_BAD;
5086 bed = get_elf_backend_data (abfd);
5087 if (bed->elf_backend_section_from_bfd_section)
5089 int retval = sec_index;
5091 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5095 if (sec_index == SHN_BAD)
5096 bfd_set_error (bfd_error_nonrepresentable_section);
5101 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5105 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5107 asymbol *asym_ptr = *asym_ptr_ptr;
5109 flagword flags = asym_ptr->flags;
5111 /* When gas creates relocations against local labels, it creates its
5112 own symbol for the section, but does put the symbol into the
5113 symbol chain, so udata is 0. When the linker is generating
5114 relocatable output, this section symbol may be for one of the
5115 input sections rather than the output section. */
5116 if (asym_ptr->udata.i == 0
5117 && (flags & BSF_SECTION_SYM)
5118 && asym_ptr->section)
5123 sec = asym_ptr->section;
5124 if (sec->owner != abfd && sec->output_section != NULL)
5125 sec = sec->output_section;
5126 if (sec->owner == abfd
5127 && (indx = sec->index) < elf_num_section_syms (abfd)
5128 && elf_section_syms (abfd)[indx] != NULL)
5129 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5132 idx = asym_ptr->udata.i;
5136 /* This case can occur when using --strip-symbol on a symbol
5137 which is used in a relocation entry. */
5138 (*_bfd_error_handler)
5139 (_("%B: symbol `%s' required but not present"),
5140 abfd, bfd_asymbol_name (asym_ptr));
5141 bfd_set_error (bfd_error_no_symbols);
5148 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5149 (long) asym_ptr, asym_ptr->name, idx, flags,
5150 elf_symbol_flags (flags));
5158 /* Rewrite program header information. */
5161 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5163 Elf_Internal_Ehdr *iehdr;
5164 struct elf_segment_map *map;
5165 struct elf_segment_map *map_first;
5166 struct elf_segment_map **pointer_to_map;
5167 Elf_Internal_Phdr *segment;
5170 unsigned int num_segments;
5171 bfd_boolean phdr_included = FALSE;
5172 bfd_boolean p_paddr_valid;
5173 bfd_vma maxpagesize;
5174 struct elf_segment_map *phdr_adjust_seg = NULL;
5175 unsigned int phdr_adjust_num = 0;
5176 const struct elf_backend_data *bed;
5178 bed = get_elf_backend_data (ibfd);
5179 iehdr = elf_elfheader (ibfd);
5182 pointer_to_map = &map_first;
5184 num_segments = elf_elfheader (ibfd)->e_phnum;
5185 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5187 /* Returns the end address of the segment + 1. */
5188 #define SEGMENT_END(segment, start) \
5189 (start + (segment->p_memsz > segment->p_filesz \
5190 ? segment->p_memsz : segment->p_filesz))
5192 #define SECTION_SIZE(section, segment) \
5193 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5194 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5195 ? section->size : 0)
5197 /* Returns TRUE if the given section is contained within
5198 the given segment. VMA addresses are compared. */
5199 #define IS_CONTAINED_BY_VMA(section, segment) \
5200 (section->vma >= segment->p_vaddr \
5201 && (section->vma + SECTION_SIZE (section, segment) \
5202 <= (SEGMENT_END (segment, segment->p_vaddr))))
5204 /* Returns TRUE if the given section is contained within
5205 the given segment. LMA addresses are compared. */
5206 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5207 (section->lma >= base \
5208 && (section->lma + SECTION_SIZE (section, segment) \
5209 <= SEGMENT_END (segment, base)))
5211 /* Handle PT_NOTE segment. */
5212 #define IS_NOTE(p, s) \
5213 (p->p_type == PT_NOTE \
5214 && elf_section_type (s) == SHT_NOTE \
5215 && (bfd_vma) s->filepos >= p->p_offset \
5216 && ((bfd_vma) s->filepos + s->size \
5217 <= p->p_offset + p->p_filesz))
5219 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5221 #define IS_COREFILE_NOTE(p, s) \
5223 && bfd_get_format (ibfd) == bfd_core \
5227 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5228 linker, which generates a PT_INTERP section with p_vaddr and
5229 p_memsz set to 0. */
5230 #define IS_SOLARIS_PT_INTERP(p, s) \
5232 && p->p_paddr == 0 \
5233 && p->p_memsz == 0 \
5234 && p->p_filesz > 0 \
5235 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5237 && (bfd_vma) s->filepos >= p->p_offset \
5238 && ((bfd_vma) s->filepos + s->size \
5239 <= p->p_offset + p->p_filesz))
5241 /* Decide if the given section should be included in the given segment.
5242 A section will be included if:
5243 1. It is within the address space of the segment -- we use the LMA
5244 if that is set for the segment and the VMA otherwise,
5245 2. It is an allocated section or a NOTE section in a PT_NOTE
5247 3. There is an output section associated with it,
5248 4. The section has not already been allocated to a previous segment.
5249 5. PT_GNU_STACK segments do not include any sections.
5250 6. PT_TLS segment includes only SHF_TLS sections.
5251 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5252 8. PT_DYNAMIC should not contain empty sections at the beginning
5253 (with the possible exception of .dynamic). */
5254 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5255 ((((segment->p_paddr \
5256 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5257 : IS_CONTAINED_BY_VMA (section, segment)) \
5258 && (section->flags & SEC_ALLOC) != 0) \
5259 || IS_NOTE (segment, section)) \
5260 && segment->p_type != PT_GNU_STACK \
5261 && (segment->p_type != PT_TLS \
5262 || (section->flags & SEC_THREAD_LOCAL)) \
5263 && (segment->p_type == PT_LOAD \
5264 || segment->p_type == PT_TLS \
5265 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5266 && (segment->p_type != PT_DYNAMIC \
5267 || SECTION_SIZE (section, segment) > 0 \
5268 || (segment->p_paddr \
5269 ? segment->p_paddr != section->lma \
5270 : segment->p_vaddr != section->vma) \
5271 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5273 && !section->segment_mark)
5275 /* If the output section of a section in the input segment is NULL,
5276 it is removed from the corresponding output segment. */
5277 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5278 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5279 && section->output_section != NULL)
5281 /* Returns TRUE iff seg1 starts after the end of seg2. */
5282 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5283 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5285 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5286 their VMA address ranges and their LMA address ranges overlap.
5287 It is possible to have overlapping VMA ranges without overlapping LMA
5288 ranges. RedBoot images for example can have both .data and .bss mapped
5289 to the same VMA range, but with the .data section mapped to a different
5291 #define SEGMENT_OVERLAPS(seg1, seg2) \
5292 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5293 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5294 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5295 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5297 /* Initialise the segment mark field. */
5298 for (section = ibfd->sections; section != NULL; section = section->next)
5299 section->segment_mark = FALSE;
5301 /* The Solaris linker creates program headers in which all the
5302 p_paddr fields are zero. When we try to objcopy or strip such a
5303 file, we get confused. Check for this case, and if we find it
5304 don't set the p_paddr_valid fields. */
5305 p_paddr_valid = FALSE;
5306 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5309 if (segment->p_paddr != 0)
5311 p_paddr_valid = TRUE;
5315 /* Scan through the segments specified in the program header
5316 of the input BFD. For this first scan we look for overlaps
5317 in the loadable segments. These can be created by weird
5318 parameters to objcopy. Also, fix some solaris weirdness. */
5319 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5324 Elf_Internal_Phdr *segment2;
5326 if (segment->p_type == PT_INTERP)
5327 for (section = ibfd->sections; section; section = section->next)
5328 if (IS_SOLARIS_PT_INTERP (segment, section))
5330 /* Mininal change so that the normal section to segment
5331 assignment code will work. */
5332 segment->p_vaddr = section->vma;
5336 if (segment->p_type != PT_LOAD)
5338 /* Remove PT_GNU_RELRO segment. */
5339 if (segment->p_type == PT_GNU_RELRO)
5340 segment->p_type = PT_NULL;
5344 /* Determine if this segment overlaps any previous segments. */
5345 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5347 bfd_signed_vma extra_length;
5349 if (segment2->p_type != PT_LOAD
5350 || !SEGMENT_OVERLAPS (segment, segment2))
5353 /* Merge the two segments together. */
5354 if (segment2->p_vaddr < segment->p_vaddr)
5356 /* Extend SEGMENT2 to include SEGMENT and then delete
5358 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5359 - SEGMENT_END (segment2, segment2->p_vaddr));
5361 if (extra_length > 0)
5363 segment2->p_memsz += extra_length;
5364 segment2->p_filesz += extra_length;
5367 segment->p_type = PT_NULL;
5369 /* Since we have deleted P we must restart the outer loop. */
5371 segment = elf_tdata (ibfd)->phdr;
5376 /* Extend SEGMENT to include SEGMENT2 and then delete
5378 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5379 - SEGMENT_END (segment, segment->p_vaddr));
5381 if (extra_length > 0)
5383 segment->p_memsz += extra_length;
5384 segment->p_filesz += extra_length;
5387 segment2->p_type = PT_NULL;
5392 /* The second scan attempts to assign sections to segments. */
5393 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5397 unsigned int section_count;
5398 asection **sections;
5399 asection *output_section;
5401 bfd_vma matching_lma;
5402 bfd_vma suggested_lma;
5405 asection *first_section;
5406 bfd_boolean first_matching_lma;
5407 bfd_boolean first_suggested_lma;
5409 if (segment->p_type == PT_NULL)
5412 first_section = NULL;
5413 /* Compute how many sections might be placed into this segment. */
5414 for (section = ibfd->sections, section_count = 0;
5416 section = section->next)
5418 /* Find the first section in the input segment, which may be
5419 removed from the corresponding output segment. */
5420 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5422 if (first_section == NULL)
5423 first_section = section;
5424 if (section->output_section != NULL)
5429 /* Allocate a segment map big enough to contain
5430 all of the sections we have selected. */
5431 amt = sizeof (struct elf_segment_map);
5432 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5433 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
5437 /* Initialise the fields of the segment map. Default to
5438 using the physical address of the segment in the input BFD. */
5440 map->p_type = segment->p_type;
5441 map->p_flags = segment->p_flags;
5442 map->p_flags_valid = 1;
5444 /* If the first section in the input segment is removed, there is
5445 no need to preserve segment physical address in the corresponding
5447 if (!first_section || first_section->output_section != NULL)
5449 map->p_paddr = segment->p_paddr;
5450 map->p_paddr_valid = p_paddr_valid;
5453 /* Determine if this segment contains the ELF file header
5454 and if it contains the program headers themselves. */
5455 map->includes_filehdr = (segment->p_offset == 0
5456 && segment->p_filesz >= iehdr->e_ehsize);
5457 map->includes_phdrs = 0;
5459 if (!phdr_included || segment->p_type != PT_LOAD)
5461 map->includes_phdrs =
5462 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5463 && (segment->p_offset + segment->p_filesz
5464 >= ((bfd_vma) iehdr->e_phoff
5465 + iehdr->e_phnum * iehdr->e_phentsize)));
5467 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5468 phdr_included = TRUE;
5471 if (section_count == 0)
5473 /* Special segments, such as the PT_PHDR segment, may contain
5474 no sections, but ordinary, loadable segments should contain
5475 something. They are allowed by the ELF spec however, so only
5476 a warning is produced. */
5477 if (segment->p_type == PT_LOAD)
5478 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5479 " detected, is this intentional ?\n"),
5483 *pointer_to_map = map;
5484 pointer_to_map = &map->next;
5489 /* Now scan the sections in the input BFD again and attempt
5490 to add their corresponding output sections to the segment map.
5491 The problem here is how to handle an output section which has
5492 been moved (ie had its LMA changed). There are four possibilities:
5494 1. None of the sections have been moved.
5495 In this case we can continue to use the segment LMA from the
5498 2. All of the sections have been moved by the same amount.
5499 In this case we can change the segment's LMA to match the LMA
5500 of the first section.
5502 3. Some of the sections have been moved, others have not.
5503 In this case those sections which have not been moved can be
5504 placed in the current segment which will have to have its size,
5505 and possibly its LMA changed, and a new segment or segments will
5506 have to be created to contain the other sections.
5508 4. The sections have been moved, but not by the same amount.
5509 In this case we can change the segment's LMA to match the LMA
5510 of the first section and we will have to create a new segment
5511 or segments to contain the other sections.
5513 In order to save time, we allocate an array to hold the section
5514 pointers that we are interested in. As these sections get assigned
5515 to a segment, they are removed from this array. */
5517 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
5518 if (sections == NULL)
5521 /* Step One: Scan for segment vs section LMA conflicts.
5522 Also add the sections to the section array allocated above.
5523 Also add the sections to the current segment. In the common
5524 case, where the sections have not been moved, this means that
5525 we have completely filled the segment, and there is nothing
5530 first_matching_lma = TRUE;
5531 first_suggested_lma = TRUE;
5533 for (section = ibfd->sections;
5535 section = section->next)
5536 if (section == first_section)
5539 for (j = 0; section != NULL; section = section->next)
5541 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5543 output_section = section->output_section;
5545 sections[j++] = section;
5547 /* The Solaris native linker always sets p_paddr to 0.
5548 We try to catch that case here, and set it to the
5549 correct value. Note - some backends require that
5550 p_paddr be left as zero. */
5552 && segment->p_vaddr != 0
5553 && !bed->want_p_paddr_set_to_zero
5555 && output_section->lma != 0
5556 && output_section->vma == (segment->p_vaddr
5557 + (map->includes_filehdr
5560 + (map->includes_phdrs
5562 * iehdr->e_phentsize)
5564 map->p_paddr = segment->p_vaddr;
5566 /* Match up the physical address of the segment with the
5567 LMA address of the output section. */
5568 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5569 || IS_COREFILE_NOTE (segment, section)
5570 || (bed->want_p_paddr_set_to_zero
5571 && IS_CONTAINED_BY_VMA (output_section, segment)))
5573 if (first_matching_lma || output_section->lma < matching_lma)
5575 matching_lma = output_section->lma;
5576 first_matching_lma = FALSE;
5579 /* We assume that if the section fits within the segment
5580 then it does not overlap any other section within that
5582 map->sections[isec++] = output_section;
5584 else if (first_suggested_lma)
5586 suggested_lma = output_section->lma;
5587 first_suggested_lma = FALSE;
5590 if (j == section_count)
5595 BFD_ASSERT (j == section_count);
5597 /* Step Two: Adjust the physical address of the current segment,
5599 if (isec == section_count)
5601 /* All of the sections fitted within the segment as currently
5602 specified. This is the default case. Add the segment to
5603 the list of built segments and carry on to process the next
5604 program header in the input BFD. */
5605 map->count = section_count;
5606 *pointer_to_map = map;
5607 pointer_to_map = &map->next;
5610 && !bed->want_p_paddr_set_to_zero
5611 && matching_lma != map->p_paddr
5612 && !map->includes_filehdr
5613 && !map->includes_phdrs)
5614 /* There is some padding before the first section in the
5615 segment. So, we must account for that in the output
5617 map->p_vaddr_offset = matching_lma - map->p_paddr;
5624 if (!first_matching_lma)
5626 /* At least one section fits inside the current segment.
5627 Keep it, but modify its physical address to match the
5628 LMA of the first section that fitted. */
5629 map->p_paddr = matching_lma;
5633 /* None of the sections fitted inside the current segment.
5634 Change the current segment's physical address to match
5635 the LMA of the first section. */
5636 map->p_paddr = suggested_lma;
5639 /* Offset the segment physical address from the lma
5640 to allow for space taken up by elf headers. */
5641 if (map->includes_filehdr)
5643 if (map->p_paddr >= iehdr->e_ehsize)
5644 map->p_paddr -= iehdr->e_ehsize;
5647 map->includes_filehdr = FALSE;
5648 map->includes_phdrs = FALSE;
5652 if (map->includes_phdrs)
5654 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5656 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5658 /* iehdr->e_phnum is just an estimate of the number
5659 of program headers that we will need. Make a note
5660 here of the number we used and the segment we chose
5661 to hold these headers, so that we can adjust the
5662 offset when we know the correct value. */
5663 phdr_adjust_num = iehdr->e_phnum;
5664 phdr_adjust_seg = map;
5667 map->includes_phdrs = FALSE;
5671 /* Step Three: Loop over the sections again, this time assigning
5672 those that fit to the current segment and removing them from the
5673 sections array; but making sure not to leave large gaps. Once all
5674 possible sections have been assigned to the current segment it is
5675 added to the list of built segments and if sections still remain
5676 to be assigned, a new segment is constructed before repeating
5683 first_suggested_lma = TRUE;
5685 /* Fill the current segment with sections that fit. */
5686 for (j = 0; j < section_count; j++)
5688 section = sections[j];
5690 if (section == NULL)
5693 output_section = section->output_section;
5695 BFD_ASSERT (output_section != NULL);
5697 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5698 || IS_COREFILE_NOTE (segment, section))
5700 if (map->count == 0)
5702 /* If the first section in a segment does not start at
5703 the beginning of the segment, then something is
5705 if (output_section->lma
5707 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5708 + (map->includes_phdrs
5709 ? iehdr->e_phnum * iehdr->e_phentsize
5717 prev_sec = map->sections[map->count - 1];
5719 /* If the gap between the end of the previous section
5720 and the start of this section is more than
5721 maxpagesize then we need to start a new segment. */
5722 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5724 < BFD_ALIGN (output_section->lma, maxpagesize))
5725 || (prev_sec->lma + prev_sec->size
5726 > output_section->lma))
5728 if (first_suggested_lma)
5730 suggested_lma = output_section->lma;
5731 first_suggested_lma = FALSE;
5738 map->sections[map->count++] = output_section;
5741 section->segment_mark = TRUE;
5743 else if (first_suggested_lma)
5745 suggested_lma = output_section->lma;
5746 first_suggested_lma = FALSE;
5750 BFD_ASSERT (map->count > 0);
5752 /* Add the current segment to the list of built segments. */
5753 *pointer_to_map = map;
5754 pointer_to_map = &map->next;
5756 if (isec < section_count)
5758 /* We still have not allocated all of the sections to
5759 segments. Create a new segment here, initialise it
5760 and carry on looping. */
5761 amt = sizeof (struct elf_segment_map);
5762 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5763 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
5770 /* Initialise the fields of the segment map. Set the physical
5771 physical address to the LMA of the first section that has
5772 not yet been assigned. */
5774 map->p_type = segment->p_type;
5775 map->p_flags = segment->p_flags;
5776 map->p_flags_valid = 1;
5777 map->p_paddr = suggested_lma;
5778 map->p_paddr_valid = p_paddr_valid;
5779 map->includes_filehdr = 0;
5780 map->includes_phdrs = 0;
5783 while (isec < section_count);
5788 elf_tdata (obfd)->segment_map = map_first;
5790 /* If we had to estimate the number of program headers that were
5791 going to be needed, then check our estimate now and adjust
5792 the offset if necessary. */
5793 if (phdr_adjust_seg != NULL)
5797 for (count = 0, map = map_first; map != NULL; map = map->next)
5800 if (count > phdr_adjust_num)
5801 phdr_adjust_seg->p_paddr
5802 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5807 #undef IS_CONTAINED_BY_VMA
5808 #undef IS_CONTAINED_BY_LMA
5810 #undef IS_COREFILE_NOTE
5811 #undef IS_SOLARIS_PT_INTERP
5812 #undef IS_SECTION_IN_INPUT_SEGMENT
5813 #undef INCLUDE_SECTION_IN_SEGMENT
5814 #undef SEGMENT_AFTER_SEGMENT
5815 #undef SEGMENT_OVERLAPS
5819 /* Copy ELF program header information. */
5822 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5824 Elf_Internal_Ehdr *iehdr;
5825 struct elf_segment_map *map;
5826 struct elf_segment_map *map_first;
5827 struct elf_segment_map **pointer_to_map;
5828 Elf_Internal_Phdr *segment;
5830 unsigned int num_segments;
5831 bfd_boolean phdr_included = FALSE;
5832 bfd_boolean p_paddr_valid;
5834 iehdr = elf_elfheader (ibfd);
5837 pointer_to_map = &map_first;
5839 /* If all the segment p_paddr fields are zero, don't set
5840 map->p_paddr_valid. */
5841 p_paddr_valid = FALSE;
5842 num_segments = elf_elfheader (ibfd)->e_phnum;
5843 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5846 if (segment->p_paddr != 0)
5848 p_paddr_valid = TRUE;
5852 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5857 unsigned int section_count;
5859 Elf_Internal_Shdr *this_hdr;
5860 asection *first_section = NULL;
5861 asection *lowest_section = NULL;
5863 /* Compute how many sections are in this segment. */
5864 for (section = ibfd->sections, section_count = 0;
5866 section = section->next)
5868 this_hdr = &(elf_section_data(section)->this_hdr);
5869 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
5872 first_section = lowest_section = section;
5873 if (section->lma < lowest_section->lma)
5874 lowest_section = section;
5879 /* Allocate a segment map big enough to contain
5880 all of the sections we have selected. */
5881 amt = sizeof (struct elf_segment_map);
5882 if (section_count != 0)
5883 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5884 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
5888 /* Initialize the fields of the output segment map with the
5891 map->p_type = segment->p_type;
5892 map->p_flags = segment->p_flags;
5893 map->p_flags_valid = 1;
5894 map->p_paddr = segment->p_paddr;
5895 map->p_paddr_valid = p_paddr_valid;
5896 map->p_align = segment->p_align;
5897 map->p_align_valid = 1;
5898 map->p_vaddr_offset = 0;
5900 if (map->p_type == PT_GNU_RELRO)
5902 /* The PT_GNU_RELRO segment may contain the first a few
5903 bytes in the .got.plt section even if the whole .got.plt
5904 section isn't in the PT_GNU_RELRO segment. We won't
5905 change the size of the PT_GNU_RELRO segment. */
5906 map->p_size = segment->p_memsz;
5907 map->p_size_valid = 1;
5910 /* Determine if this segment contains the ELF file header
5911 and if it contains the program headers themselves. */
5912 map->includes_filehdr = (segment->p_offset == 0
5913 && segment->p_filesz >= iehdr->e_ehsize);
5915 map->includes_phdrs = 0;
5916 if (! phdr_included || segment->p_type != PT_LOAD)
5918 map->includes_phdrs =
5919 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5920 && (segment->p_offset + segment->p_filesz
5921 >= ((bfd_vma) iehdr->e_phoff
5922 + iehdr->e_phnum * iehdr->e_phentsize)));
5924 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5925 phdr_included = TRUE;
5928 if (map->includes_filehdr && first_section)
5929 /* We need to keep the space used by the headers fixed. */
5930 map->header_size = first_section->vma - segment->p_vaddr;
5932 if (!map->includes_phdrs
5933 && !map->includes_filehdr
5934 && map->p_paddr_valid)
5935 /* There is some other padding before the first section. */
5936 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
5937 - segment->p_paddr);
5939 if (section_count != 0)
5941 unsigned int isec = 0;
5943 for (section = first_section;
5945 section = section->next)
5947 this_hdr = &(elf_section_data(section)->this_hdr);
5948 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
5950 map->sections[isec++] = section->output_section;
5951 if (isec == section_count)
5957 map->count = section_count;
5958 *pointer_to_map = map;
5959 pointer_to_map = &map->next;
5962 elf_tdata (obfd)->segment_map = map_first;
5966 /* Copy private BFD data. This copies or rewrites ELF program header
5970 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5972 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5973 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5976 if (elf_tdata (ibfd)->phdr == NULL)
5979 if (ibfd->xvec == obfd->xvec)
5981 /* Check to see if any sections in the input BFD
5982 covered by ELF program header have changed. */
5983 Elf_Internal_Phdr *segment;
5984 asection *section, *osec;
5985 unsigned int i, num_segments;
5986 Elf_Internal_Shdr *this_hdr;
5987 const struct elf_backend_data *bed;
5989 bed = get_elf_backend_data (ibfd);
5991 /* Regenerate the segment map if p_paddr is set to 0. */
5992 if (bed->want_p_paddr_set_to_zero)
5995 /* Initialize the segment mark field. */
5996 for (section = obfd->sections; section != NULL;
5997 section = section->next)
5998 section->segment_mark = FALSE;
6000 num_segments = elf_elfheader (ibfd)->e_phnum;
6001 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6005 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6006 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6007 which severly confuses things, so always regenerate the segment
6008 map in this case. */
6009 if (segment->p_paddr == 0
6010 && segment->p_memsz == 0
6011 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
6014 for (section = ibfd->sections;
6015 section != NULL; section = section->next)
6017 /* We mark the output section so that we know it comes
6018 from the input BFD. */
6019 osec = section->output_section;
6021 osec->segment_mark = TRUE;
6023 /* Check if this section is covered by the segment. */
6024 this_hdr = &(elf_section_data(section)->this_hdr);
6025 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6027 /* FIXME: Check if its output section is changed or
6028 removed. What else do we need to check? */
6030 || section->flags != osec->flags
6031 || section->lma != osec->lma
6032 || section->vma != osec->vma
6033 || section->size != osec->size
6034 || section->rawsize != osec->rawsize
6035 || section->alignment_power != osec->alignment_power)
6041 /* Check to see if any output section do not come from the
6043 for (section = obfd->sections; section != NULL;
6044 section = section->next)
6046 if (section->segment_mark == FALSE)
6049 section->segment_mark = FALSE;
6052 return copy_elf_program_header (ibfd, obfd);
6056 return rewrite_elf_program_header (ibfd, obfd);
6059 /* Initialize private output section information from input section. */
6062 _bfd_elf_init_private_section_data (bfd *ibfd,
6066 struct bfd_link_info *link_info)
6069 Elf_Internal_Shdr *ihdr, *ohdr;
6070 bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
6072 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6073 || obfd->xvec->flavour != bfd_target_elf_flavour)
6076 /* For objcopy and relocatable link, don't copy the output ELF
6077 section type from input if the output BFD section flags have been
6078 set to something different. For a final link allow some flags
6079 that the linker clears to differ. */
6080 if (elf_section_type (osec) == SHT_NULL
6081 && (osec->flags == isec->flags
6083 && ((osec->flags ^ isec->flags)
6084 & ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES)) == 0)))
6085 elf_section_type (osec) = elf_section_type (isec);
6087 /* FIXME: Is this correct for all OS/PROC specific flags? */
6088 elf_section_flags (osec) |= (elf_section_flags (isec)
6089 & (SHF_MASKOS | SHF_MASKPROC));
6091 /* Set things up for objcopy and relocatable link. The output
6092 SHT_GROUP section will have its elf_next_in_group pointing back
6093 to the input group members. Ignore linker created group section.
6094 See elfNN_ia64_object_p in elfxx-ia64.c. */
6097 if (elf_sec_group (isec) == NULL
6098 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6100 if (elf_section_flags (isec) & SHF_GROUP)
6101 elf_section_flags (osec) |= SHF_GROUP;
6102 elf_next_in_group (osec) = elf_next_in_group (isec);
6103 elf_section_data (osec)->group = elf_section_data (isec)->group;
6107 ihdr = &elf_section_data (isec)->this_hdr;
6109 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6110 don't use the output section of the linked-to section since it
6111 may be NULL at this point. */
6112 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6114 ohdr = &elf_section_data (osec)->this_hdr;
6115 ohdr->sh_flags |= SHF_LINK_ORDER;
6116 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6119 osec->use_rela_p = isec->use_rela_p;
6124 /* Copy private section information. This copies over the entsize
6125 field, and sometimes the info field. */
6128 _bfd_elf_copy_private_section_data (bfd *ibfd,
6133 Elf_Internal_Shdr *ihdr, *ohdr;
6135 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6136 || obfd->xvec->flavour != bfd_target_elf_flavour)
6139 ihdr = &elf_section_data (isec)->this_hdr;
6140 ohdr = &elf_section_data (osec)->this_hdr;
6142 ohdr->sh_entsize = ihdr->sh_entsize;
6144 if (ihdr->sh_type == SHT_SYMTAB
6145 || ihdr->sh_type == SHT_DYNSYM
6146 || ihdr->sh_type == SHT_GNU_verneed
6147 || ihdr->sh_type == SHT_GNU_verdef)
6148 ohdr->sh_info = ihdr->sh_info;
6150 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6154 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6155 necessary if we are removing either the SHT_GROUP section or any of
6156 the group member sections. DISCARDED is the value that a section's
6157 output_section has if the section will be discarded, NULL when this
6158 function is called from objcopy, bfd_abs_section_ptr when called
6162 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
6166 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6167 if (elf_section_type (isec) == SHT_GROUP)
6169 asection *first = elf_next_in_group (isec);
6170 asection *s = first;
6171 bfd_size_type removed = 0;
6175 /* If this member section is being output but the
6176 SHT_GROUP section is not, then clear the group info
6177 set up by _bfd_elf_copy_private_section_data. */
6178 if (s->output_section != discarded
6179 && isec->output_section == discarded)
6181 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6182 elf_group_name (s->output_section) = NULL;
6184 /* Conversely, if the member section is not being output
6185 but the SHT_GROUP section is, then adjust its size. */
6186 else if (s->output_section == discarded
6187 && isec->output_section != discarded)
6189 s = elf_next_in_group (s);
6195 if (discarded != NULL)
6197 /* If we've been called for ld -r, then we need to
6198 adjust the input section size. This function may
6199 be called multiple times, so save the original
6201 if (isec->rawsize == 0)
6202 isec->rawsize = isec->size;
6203 isec->size = isec->rawsize - removed;
6207 /* Adjust the output section size when called from
6209 isec->output_section->size -= removed;
6217 /* Copy private header information. */
6220 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6222 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6223 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6226 /* Copy over private BFD data if it has not already been copied.
6227 This must be done here, rather than in the copy_private_bfd_data
6228 entry point, because the latter is called after the section
6229 contents have been set, which means that the program headers have
6230 already been worked out. */
6231 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6233 if (! copy_private_bfd_data (ibfd, obfd))
6237 return _bfd_elf_fixup_group_sections (ibfd, NULL);
6240 /* Copy private symbol information. If this symbol is in a section
6241 which we did not map into a BFD section, try to map the section
6242 index correctly. We use special macro definitions for the mapped
6243 section indices; these definitions are interpreted by the
6244 swap_out_syms function. */
6246 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6247 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6248 #define MAP_STRTAB (SHN_HIOS + 3)
6249 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6250 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6253 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6258 elf_symbol_type *isym, *osym;
6260 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6261 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6264 isym = elf_symbol_from (ibfd, isymarg);
6265 osym = elf_symbol_from (obfd, osymarg);
6268 && isym->internal_elf_sym.st_shndx != 0
6270 && bfd_is_abs_section (isym->symbol.section))
6274 shndx = isym->internal_elf_sym.st_shndx;
6275 if (shndx == elf_onesymtab (ibfd))
6276 shndx = MAP_ONESYMTAB;
6277 else if (shndx == elf_dynsymtab (ibfd))
6278 shndx = MAP_DYNSYMTAB;
6279 else if (shndx == elf_tdata (ibfd)->strtab_section)
6281 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6282 shndx = MAP_SHSTRTAB;
6283 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6284 shndx = MAP_SYM_SHNDX;
6285 osym->internal_elf_sym.st_shndx = shndx;
6291 /* Swap out the symbols. */
6294 swap_out_syms (bfd *abfd,
6295 struct bfd_strtab_hash **sttp,
6298 const struct elf_backend_data *bed;
6301 struct bfd_strtab_hash *stt;
6302 Elf_Internal_Shdr *symtab_hdr;
6303 Elf_Internal_Shdr *symtab_shndx_hdr;
6304 Elf_Internal_Shdr *symstrtab_hdr;
6305 bfd_byte *outbound_syms;
6306 bfd_byte *outbound_shndx;
6309 bfd_boolean name_local_sections;
6311 if (!elf_map_symbols (abfd))
6314 /* Dump out the symtabs. */
6315 stt = _bfd_elf_stringtab_init ();
6319 bed = get_elf_backend_data (abfd);
6320 symcount = bfd_get_symcount (abfd);
6321 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6322 symtab_hdr->sh_type = SHT_SYMTAB;
6323 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6324 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6325 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6326 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6328 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6329 symstrtab_hdr->sh_type = SHT_STRTAB;
6331 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6332 bed->s->sizeof_sym);
6333 if (outbound_syms == NULL)
6335 _bfd_stringtab_free (stt);
6338 symtab_hdr->contents = outbound_syms;
6340 outbound_shndx = NULL;
6341 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6342 if (symtab_shndx_hdr->sh_name != 0)
6344 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6345 outbound_shndx = (bfd_byte *)
6346 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
6347 if (outbound_shndx == NULL)
6349 _bfd_stringtab_free (stt);
6353 symtab_shndx_hdr->contents = outbound_shndx;
6354 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6355 symtab_shndx_hdr->sh_size = amt;
6356 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6357 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6360 /* Now generate the data (for "contents"). */
6362 /* Fill in zeroth symbol and swap it out. */
6363 Elf_Internal_Sym sym;
6369 sym.st_shndx = SHN_UNDEF;
6370 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6371 outbound_syms += bed->s->sizeof_sym;
6372 if (outbound_shndx != NULL)
6373 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6377 = (bed->elf_backend_name_local_section_symbols
6378 && bed->elf_backend_name_local_section_symbols (abfd));
6380 syms = bfd_get_outsymbols (abfd);
6381 for (idx = 0; idx < symcount; idx++)
6383 Elf_Internal_Sym sym;
6384 bfd_vma value = syms[idx]->value;
6385 elf_symbol_type *type_ptr;
6386 flagword flags = syms[idx]->flags;
6389 if (!name_local_sections
6390 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6392 /* Local section symbols have no name. */
6397 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6400 if (sym.st_name == (unsigned long) -1)
6402 _bfd_stringtab_free (stt);
6407 type_ptr = elf_symbol_from (abfd, syms[idx]);
6409 if ((flags & BSF_SECTION_SYM) == 0
6410 && bfd_is_com_section (syms[idx]->section))
6412 /* ELF common symbols put the alignment into the `value' field,
6413 and the size into the `size' field. This is backwards from
6414 how BFD handles it, so reverse it here. */
6415 sym.st_size = value;
6416 if (type_ptr == NULL
6417 || type_ptr->internal_elf_sym.st_value == 0)
6418 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6420 sym.st_value = type_ptr->internal_elf_sym.st_value;
6421 sym.st_shndx = _bfd_elf_section_from_bfd_section
6422 (abfd, syms[idx]->section);
6426 asection *sec = syms[idx]->section;
6429 if (sec->output_section)
6431 value += sec->output_offset;
6432 sec = sec->output_section;
6435 /* Don't add in the section vma for relocatable output. */
6436 if (! relocatable_p)
6438 sym.st_value = value;
6439 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6441 if (bfd_is_abs_section (sec)
6443 && type_ptr->internal_elf_sym.st_shndx != 0)
6445 /* This symbol is in a real ELF section which we did
6446 not create as a BFD section. Undo the mapping done
6447 by copy_private_symbol_data. */
6448 shndx = type_ptr->internal_elf_sym.st_shndx;
6452 shndx = elf_onesymtab (abfd);
6455 shndx = elf_dynsymtab (abfd);
6458 shndx = elf_tdata (abfd)->strtab_section;
6461 shndx = elf_tdata (abfd)->shstrtab_section;
6464 shndx = elf_tdata (abfd)->symtab_shndx_section;
6472 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6474 if (shndx == SHN_BAD)
6478 /* Writing this would be a hell of a lot easier if
6479 we had some decent documentation on bfd, and
6480 knew what to expect of the library, and what to
6481 demand of applications. For example, it
6482 appears that `objcopy' might not set the
6483 section of a symbol to be a section that is
6484 actually in the output file. */
6485 sec2 = bfd_get_section_by_name (abfd, sec->name);
6488 _bfd_error_handler (_("\
6489 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6490 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6492 bfd_set_error (bfd_error_invalid_operation);
6493 _bfd_stringtab_free (stt);
6497 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6498 BFD_ASSERT (shndx != SHN_BAD);
6502 sym.st_shndx = shndx;
6505 if ((flags & BSF_THREAD_LOCAL) != 0)
6507 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6508 type = STT_GNU_IFUNC;
6509 else if ((flags & BSF_FUNCTION) != 0)
6511 else if ((flags & BSF_OBJECT) != 0)
6513 else if ((flags & BSF_RELC) != 0)
6515 else if ((flags & BSF_SRELC) != 0)
6520 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6523 /* Processor-specific types. */
6524 if (type_ptr != NULL
6525 && bed->elf_backend_get_symbol_type)
6526 type = ((*bed->elf_backend_get_symbol_type)
6527 (&type_ptr->internal_elf_sym, type));
6529 if (flags & BSF_SECTION_SYM)
6531 if (flags & BSF_GLOBAL)
6532 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6534 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6536 else if (bfd_is_com_section (syms[idx]->section))
6538 #ifdef USE_STT_COMMON
6539 if (type == STT_OBJECT)
6540 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6543 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6545 else if (bfd_is_und_section (syms[idx]->section))
6546 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6550 else if (flags & BSF_FILE)
6551 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6554 int bind = STB_LOCAL;
6556 if (flags & BSF_LOCAL)
6558 else if (flags & BSF_GNU_UNIQUE)
6559 bind = STB_GNU_UNIQUE;
6560 else if (flags & BSF_WEAK)
6562 else if (flags & BSF_GLOBAL)
6565 sym.st_info = ELF_ST_INFO (bind, type);
6568 if (type_ptr != NULL)
6569 sym.st_other = type_ptr->internal_elf_sym.st_other;
6573 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6574 outbound_syms += bed->s->sizeof_sym;
6575 if (outbound_shndx != NULL)
6576 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6580 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6581 symstrtab_hdr->sh_type = SHT_STRTAB;
6583 symstrtab_hdr->sh_flags = 0;
6584 symstrtab_hdr->sh_addr = 0;
6585 symstrtab_hdr->sh_entsize = 0;
6586 symstrtab_hdr->sh_link = 0;
6587 symstrtab_hdr->sh_info = 0;
6588 symstrtab_hdr->sh_addralign = 1;
6593 /* Return the number of bytes required to hold the symtab vector.
6595 Note that we base it on the count plus 1, since we will null terminate
6596 the vector allocated based on this size. However, the ELF symbol table
6597 always has a dummy entry as symbol #0, so it ends up even. */
6600 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6604 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6606 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6607 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6609 symtab_size -= sizeof (asymbol *);
6615 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6619 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6621 if (elf_dynsymtab (abfd) == 0)
6623 bfd_set_error (bfd_error_invalid_operation);
6627 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6628 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6630 symtab_size -= sizeof (asymbol *);
6636 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6639 return (asect->reloc_count + 1) * sizeof (arelent *);
6642 /* Canonicalize the relocs. */
6645 _bfd_elf_canonicalize_reloc (bfd *abfd,
6652 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6654 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6657 tblptr = section->relocation;
6658 for (i = 0; i < section->reloc_count; i++)
6659 *relptr++ = tblptr++;
6663 return section->reloc_count;
6667 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6669 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6670 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6673 bfd_get_symcount (abfd) = symcount;
6678 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6679 asymbol **allocation)
6681 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6682 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6685 bfd_get_dynamic_symcount (abfd) = symcount;
6689 /* Return the size required for the dynamic reloc entries. Any loadable
6690 section that was actually installed in the BFD, and has type SHT_REL
6691 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6692 dynamic reloc section. */
6695 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6700 if (elf_dynsymtab (abfd) == 0)
6702 bfd_set_error (bfd_error_invalid_operation);
6706 ret = sizeof (arelent *);
6707 for (s = abfd->sections; s != NULL; s = s->next)
6708 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6709 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6710 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6711 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6712 * sizeof (arelent *));
6717 /* Canonicalize the dynamic relocation entries. Note that we return the
6718 dynamic relocations as a single block, although they are actually
6719 associated with particular sections; the interface, which was
6720 designed for SunOS style shared libraries, expects that there is only
6721 one set of dynamic relocs. Any loadable section that was actually
6722 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6723 dynamic symbol table, is considered to be a dynamic reloc section. */
6726 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6730 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6734 if (elf_dynsymtab (abfd) == 0)
6736 bfd_set_error (bfd_error_invalid_operation);
6740 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6742 for (s = abfd->sections; s != NULL; s = s->next)
6744 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6745 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6746 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6751 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6753 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6755 for (i = 0; i < count; i++)
6766 /* Read in the version information. */
6769 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6771 bfd_byte *contents = NULL;
6772 unsigned int freeidx = 0;
6774 if (elf_dynverref (abfd) != 0)
6776 Elf_Internal_Shdr *hdr;
6777 Elf_External_Verneed *everneed;
6778 Elf_Internal_Verneed *iverneed;
6780 bfd_byte *contents_end;
6782 hdr = &elf_tdata (abfd)->dynverref_hdr;
6784 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
6785 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
6786 if (elf_tdata (abfd)->verref == NULL)
6789 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6791 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
6792 if (contents == NULL)
6794 error_return_verref:
6795 elf_tdata (abfd)->verref = NULL;
6796 elf_tdata (abfd)->cverrefs = 0;
6799 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6800 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6801 goto error_return_verref;
6803 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6804 goto error_return_verref;
6806 BFD_ASSERT (sizeof (Elf_External_Verneed)
6807 == sizeof (Elf_External_Vernaux));
6808 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6809 everneed = (Elf_External_Verneed *) contents;
6810 iverneed = elf_tdata (abfd)->verref;
6811 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6813 Elf_External_Vernaux *evernaux;
6814 Elf_Internal_Vernaux *ivernaux;
6817 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6819 iverneed->vn_bfd = abfd;
6821 iverneed->vn_filename =
6822 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6824 if (iverneed->vn_filename == NULL)
6825 goto error_return_verref;
6827 if (iverneed->vn_cnt == 0)
6828 iverneed->vn_auxptr = NULL;
6831 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
6832 bfd_alloc2 (abfd, iverneed->vn_cnt,
6833 sizeof (Elf_Internal_Vernaux));
6834 if (iverneed->vn_auxptr == NULL)
6835 goto error_return_verref;
6838 if (iverneed->vn_aux
6839 > (size_t) (contents_end - (bfd_byte *) everneed))
6840 goto error_return_verref;
6842 evernaux = ((Elf_External_Vernaux *)
6843 ((bfd_byte *) everneed + iverneed->vn_aux));
6844 ivernaux = iverneed->vn_auxptr;
6845 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6847 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6849 ivernaux->vna_nodename =
6850 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6851 ivernaux->vna_name);
6852 if (ivernaux->vna_nodename == NULL)
6853 goto error_return_verref;
6855 if (j + 1 < iverneed->vn_cnt)
6856 ivernaux->vna_nextptr = ivernaux + 1;
6858 ivernaux->vna_nextptr = NULL;
6860 if (ivernaux->vna_next
6861 > (size_t) (contents_end - (bfd_byte *) evernaux))
6862 goto error_return_verref;
6864 evernaux = ((Elf_External_Vernaux *)
6865 ((bfd_byte *) evernaux + ivernaux->vna_next));
6867 if (ivernaux->vna_other > freeidx)
6868 freeidx = ivernaux->vna_other;
6871 if (i + 1 < hdr->sh_info)
6872 iverneed->vn_nextref = iverneed + 1;
6874 iverneed->vn_nextref = NULL;
6876 if (iverneed->vn_next
6877 > (size_t) (contents_end - (bfd_byte *) everneed))
6878 goto error_return_verref;
6880 everneed = ((Elf_External_Verneed *)
6881 ((bfd_byte *) everneed + iverneed->vn_next));
6888 if (elf_dynverdef (abfd) != 0)
6890 Elf_Internal_Shdr *hdr;
6891 Elf_External_Verdef *everdef;
6892 Elf_Internal_Verdef *iverdef;
6893 Elf_Internal_Verdef *iverdefarr;
6894 Elf_Internal_Verdef iverdefmem;
6896 unsigned int maxidx;
6897 bfd_byte *contents_end_def, *contents_end_aux;
6899 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6901 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
6902 if (contents == NULL)
6904 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6905 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6908 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6911 BFD_ASSERT (sizeof (Elf_External_Verdef)
6912 >= sizeof (Elf_External_Verdaux));
6913 contents_end_def = contents + hdr->sh_size
6914 - sizeof (Elf_External_Verdef);
6915 contents_end_aux = contents + hdr->sh_size
6916 - sizeof (Elf_External_Verdaux);
6918 /* We know the number of entries in the section but not the maximum
6919 index. Therefore we have to run through all entries and find
6921 everdef = (Elf_External_Verdef *) contents;
6923 for (i = 0; i < hdr->sh_info; ++i)
6925 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6927 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6928 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6930 if (iverdefmem.vd_next
6931 > (size_t) (contents_end_def - (bfd_byte *) everdef))
6934 everdef = ((Elf_External_Verdef *)
6935 ((bfd_byte *) everdef + iverdefmem.vd_next));
6938 if (default_imported_symver)
6940 if (freeidx > maxidx)
6945 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
6946 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
6947 if (elf_tdata (abfd)->verdef == NULL)
6950 elf_tdata (abfd)->cverdefs = maxidx;
6952 everdef = (Elf_External_Verdef *) contents;
6953 iverdefarr = elf_tdata (abfd)->verdef;
6954 for (i = 0; i < hdr->sh_info; i++)
6956 Elf_External_Verdaux *everdaux;
6957 Elf_Internal_Verdaux *iverdaux;
6960 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6962 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6964 error_return_verdef:
6965 elf_tdata (abfd)->verdef = NULL;
6966 elf_tdata (abfd)->cverdefs = 0;
6970 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6971 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6973 iverdef->vd_bfd = abfd;
6975 if (iverdef->vd_cnt == 0)
6976 iverdef->vd_auxptr = NULL;
6979 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
6980 bfd_alloc2 (abfd, iverdef->vd_cnt,
6981 sizeof (Elf_Internal_Verdaux));
6982 if (iverdef->vd_auxptr == NULL)
6983 goto error_return_verdef;
6987 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6988 goto error_return_verdef;
6990 everdaux = ((Elf_External_Verdaux *)
6991 ((bfd_byte *) everdef + iverdef->vd_aux));
6992 iverdaux = iverdef->vd_auxptr;
6993 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6995 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6997 iverdaux->vda_nodename =
6998 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6999 iverdaux->vda_name);
7000 if (iverdaux->vda_nodename == NULL)
7001 goto error_return_verdef;
7003 if (j + 1 < iverdef->vd_cnt)
7004 iverdaux->vda_nextptr = iverdaux + 1;
7006 iverdaux->vda_nextptr = NULL;
7008 if (iverdaux->vda_next
7009 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7010 goto error_return_verdef;
7012 everdaux = ((Elf_External_Verdaux *)
7013 ((bfd_byte *) everdaux + iverdaux->vda_next));
7016 if (iverdef->vd_cnt)
7017 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
7019 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
7020 iverdef->vd_nextdef = iverdef + 1;
7022 iverdef->vd_nextdef = NULL;
7024 everdef = ((Elf_External_Verdef *)
7025 ((bfd_byte *) everdef + iverdef->vd_next));
7031 else if (default_imported_symver)
7038 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7039 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
7040 if (elf_tdata (abfd)->verdef == NULL)
7043 elf_tdata (abfd)->cverdefs = freeidx;
7046 /* Create a default version based on the soname. */
7047 if (default_imported_symver)
7049 Elf_Internal_Verdef *iverdef;
7050 Elf_Internal_Verdaux *iverdaux;
7052 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
7054 iverdef->vd_version = VER_DEF_CURRENT;
7055 iverdef->vd_flags = 0;
7056 iverdef->vd_ndx = freeidx;
7057 iverdef->vd_cnt = 1;
7059 iverdef->vd_bfd = abfd;
7061 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7062 if (iverdef->vd_nodename == NULL)
7063 goto error_return_verdef;
7064 iverdef->vd_nextdef = NULL;
7065 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7066 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
7067 if (iverdef->vd_auxptr == NULL)
7068 goto error_return_verdef;
7070 iverdaux = iverdef->vd_auxptr;
7071 iverdaux->vda_nodename = iverdef->vd_nodename;
7072 iverdaux->vda_nextptr = NULL;
7078 if (contents != NULL)
7084 _bfd_elf_make_empty_symbol (bfd *abfd)
7086 elf_symbol_type *newsym;
7087 bfd_size_type amt = sizeof (elf_symbol_type);
7089 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
7094 newsym->symbol.the_bfd = abfd;
7095 return &newsym->symbol;
7100 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7104 bfd_symbol_info (symbol, ret);
7107 /* Return whether a symbol name implies a local symbol. Most targets
7108 use this function for the is_local_label_name entry point, but some
7112 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7115 /* Normal local symbols start with ``.L''. */
7116 if (name[0] == '.' && name[1] == 'L')
7119 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7120 DWARF debugging symbols starting with ``..''. */
7121 if (name[0] == '.' && name[1] == '.')
7124 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7125 emitting DWARF debugging output. I suspect this is actually a
7126 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7127 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7128 underscore to be emitted on some ELF targets). For ease of use,
7129 we treat such symbols as local. */
7130 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7137 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7138 asymbol *symbol ATTRIBUTE_UNUSED)
7145 _bfd_elf_set_arch_mach (bfd *abfd,
7146 enum bfd_architecture arch,
7147 unsigned long machine)
7149 /* If this isn't the right architecture for this backend, and this
7150 isn't the generic backend, fail. */
7151 if (arch != get_elf_backend_data (abfd)->arch
7152 && arch != bfd_arch_unknown
7153 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7156 return bfd_default_set_arch_mach (abfd, arch, machine);
7159 /* Find the function to a particular section and offset,
7160 for error reporting. */
7163 elf_find_function (bfd *abfd,
7167 const char **filename_ptr,
7168 const char **functionname_ptr)
7170 const char *filename;
7171 asymbol *func, *file;
7174 /* ??? Given multiple file symbols, it is impossible to reliably
7175 choose the right file name for global symbols. File symbols are
7176 local symbols, and thus all file symbols must sort before any
7177 global symbols. The ELF spec may be interpreted to say that a
7178 file symbol must sort before other local symbols, but currently
7179 ld -r doesn't do this. So, for ld -r output, it is possible to
7180 make a better choice of file name for local symbols by ignoring
7181 file symbols appearing after a given local symbol. */
7182 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7183 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7189 state = nothing_seen;
7191 for (p = symbols; *p != NULL; p++)
7196 q = (elf_symbol_type *) *p;
7198 type = ELF_ST_TYPE (q->internal_elf_sym.st_info);
7203 if (state == symbol_seen)
7204 state = file_after_symbol_seen;
7207 if (!bed->is_function_type (type))
7210 if (bfd_get_section (&q->symbol) == section
7211 && q->symbol.value >= low_func
7212 && q->symbol.value <= offset)
7214 func = (asymbol *) q;
7215 low_func = q->symbol.value;
7218 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7219 || state != file_after_symbol_seen))
7220 filename = bfd_asymbol_name (file);
7224 if (state == nothing_seen)
7225 state = symbol_seen;
7232 *filename_ptr = filename;
7233 if (functionname_ptr)
7234 *functionname_ptr = bfd_asymbol_name (func);
7239 /* Find the nearest line to a particular section and offset,
7240 for error reporting. */
7243 _bfd_elf_find_nearest_line (bfd *abfd,
7247 const char **filename_ptr,
7248 const char **functionname_ptr,
7249 unsigned int *line_ptr)
7253 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7254 filename_ptr, functionname_ptr,
7257 if (!*functionname_ptr)
7258 elf_find_function (abfd, section, symbols, offset,
7259 *filename_ptr ? NULL : filename_ptr,
7265 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7266 filename_ptr, functionname_ptr,
7268 &elf_tdata (abfd)->dwarf2_find_line_info))
7270 if (!*functionname_ptr)
7271 elf_find_function (abfd, section, symbols, offset,
7272 *filename_ptr ? NULL : filename_ptr,
7278 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7279 &found, filename_ptr,
7280 functionname_ptr, line_ptr,
7281 &elf_tdata (abfd)->line_info))
7283 if (found && (*functionname_ptr || *line_ptr))
7286 if (symbols == NULL)
7289 if (! elf_find_function (abfd, section, symbols, offset,
7290 filename_ptr, functionname_ptr))
7297 /* Find the line for a symbol. */
7300 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7301 const char **filename_ptr, unsigned int *line_ptr)
7303 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7304 filename_ptr, line_ptr, 0,
7305 &elf_tdata (abfd)->dwarf2_find_line_info);
7308 /* After a call to bfd_find_nearest_line, successive calls to
7309 bfd_find_inliner_info can be used to get source information about
7310 each level of function inlining that terminated at the address
7311 passed to bfd_find_nearest_line. Currently this is only supported
7312 for DWARF2 with appropriate DWARF3 extensions. */
7315 _bfd_elf_find_inliner_info (bfd *abfd,
7316 const char **filename_ptr,
7317 const char **functionname_ptr,
7318 unsigned int *line_ptr)
7321 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7322 functionname_ptr, line_ptr,
7323 & elf_tdata (abfd)->dwarf2_find_line_info);
7328 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7330 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7331 int ret = bed->s->sizeof_ehdr;
7333 if (!info->relocatable)
7335 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7337 if (phdr_size == (bfd_size_type) -1)
7339 struct elf_segment_map *m;
7342 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7343 phdr_size += bed->s->sizeof_phdr;
7346 phdr_size = get_program_header_size (abfd, info);
7349 elf_tdata (abfd)->program_header_size = phdr_size;
7357 _bfd_elf_set_section_contents (bfd *abfd,
7359 const void *location,
7361 bfd_size_type count)
7363 Elf_Internal_Shdr *hdr;
7366 if (! abfd->output_has_begun
7367 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7370 hdr = &elf_section_data (section)->this_hdr;
7371 pos = hdr->sh_offset + offset;
7372 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7373 || bfd_bwrite (location, count, abfd) != count)
7380 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7381 arelent *cache_ptr ATTRIBUTE_UNUSED,
7382 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7387 /* Try to convert a non-ELF reloc into an ELF one. */
7390 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7392 /* Check whether we really have an ELF howto. */
7394 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7396 bfd_reloc_code_real_type code;
7397 reloc_howto_type *howto;
7399 /* Alien reloc: Try to determine its type to replace it with an
7400 equivalent ELF reloc. */
7402 if (areloc->howto->pc_relative)
7404 switch (areloc->howto->bitsize)
7407 code = BFD_RELOC_8_PCREL;
7410 code = BFD_RELOC_12_PCREL;
7413 code = BFD_RELOC_16_PCREL;
7416 code = BFD_RELOC_24_PCREL;
7419 code = BFD_RELOC_32_PCREL;
7422 code = BFD_RELOC_64_PCREL;
7428 howto = bfd_reloc_type_lookup (abfd, code);
7430 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7432 if (howto->pcrel_offset)
7433 areloc->addend += areloc->address;
7435 areloc->addend -= areloc->address; /* addend is unsigned!! */
7440 switch (areloc->howto->bitsize)
7446 code = BFD_RELOC_14;
7449 code = BFD_RELOC_16;
7452 code = BFD_RELOC_26;
7455 code = BFD_RELOC_32;
7458 code = BFD_RELOC_64;
7464 howto = bfd_reloc_type_lookup (abfd, code);
7468 areloc->howto = howto;
7476 (*_bfd_error_handler)
7477 (_("%B: unsupported relocation type %s"),
7478 abfd, areloc->howto->name);
7479 bfd_set_error (bfd_error_bad_value);
7484 _bfd_elf_close_and_cleanup (bfd *abfd)
7486 if (bfd_get_format (abfd) == bfd_object)
7488 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7489 _bfd_elf_strtab_free (elf_shstrtab (abfd));
7490 _bfd_dwarf2_cleanup_debug_info (abfd);
7493 return _bfd_generic_close_and_cleanup (abfd);
7496 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7497 in the relocation's offset. Thus we cannot allow any sort of sanity
7498 range-checking to interfere. There is nothing else to do in processing
7501 bfd_reloc_status_type
7502 _bfd_elf_rel_vtable_reloc_fn
7503 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7504 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7505 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7506 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7508 return bfd_reloc_ok;
7511 /* Elf core file support. Much of this only works on native
7512 toolchains, since we rely on knowing the
7513 machine-dependent procfs structure in order to pick
7514 out details about the corefile. */
7516 #ifdef HAVE_SYS_PROCFS_H
7517 /* Needed for new procfs interface on sparc-solaris. */
7518 # define _STRUCTURED_PROC 1
7519 # include <sys/procfs.h>
7522 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7525 elfcore_make_pid (bfd *abfd)
7527 return ((elf_tdata (abfd)->core_lwpid << 16)
7528 + (elf_tdata (abfd)->core_pid));
7531 /* If there isn't a section called NAME, make one, using
7532 data from SECT. Note, this function will generate a
7533 reference to NAME, so you shouldn't deallocate or
7537 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7541 if (bfd_get_section_by_name (abfd, name) != NULL)
7544 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7548 sect2->size = sect->size;
7549 sect2->filepos = sect->filepos;
7550 sect2->alignment_power = sect->alignment_power;
7554 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7555 actually creates up to two pseudosections:
7556 - For the single-threaded case, a section named NAME, unless
7557 such a section already exists.
7558 - For the multi-threaded case, a section named "NAME/PID", where
7559 PID is elfcore_make_pid (abfd).
7560 Both pseudosections have identical contents. */
7562 _bfd_elfcore_make_pseudosection (bfd *abfd,
7568 char *threaded_name;
7572 /* Build the section name. */
7574 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7575 len = strlen (buf) + 1;
7576 threaded_name = (char *) bfd_alloc (abfd, len);
7577 if (threaded_name == NULL)
7579 memcpy (threaded_name, buf, len);
7581 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7586 sect->filepos = filepos;
7587 sect->alignment_power = 2;
7589 return elfcore_maybe_make_sect (abfd, name, sect);
7592 /* prstatus_t exists on:
7594 linux 2.[01] + glibc
7598 #if defined (HAVE_PRSTATUS_T)
7601 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7606 if (note->descsz == sizeof (prstatus_t))
7610 size = sizeof (prstat.pr_reg);
7611 offset = offsetof (prstatus_t, pr_reg);
7612 memcpy (&prstat, note->descdata, sizeof (prstat));
7614 /* Do not overwrite the core signal if it
7615 has already been set by another thread. */
7616 if (elf_tdata (abfd)->core_signal == 0)
7617 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7618 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7620 /* pr_who exists on:
7623 pr_who doesn't exist on:
7626 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7627 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7630 #if defined (HAVE_PRSTATUS32_T)
7631 else if (note->descsz == sizeof (prstatus32_t))
7633 /* 64-bit host, 32-bit corefile */
7634 prstatus32_t prstat;
7636 size = sizeof (prstat.pr_reg);
7637 offset = offsetof (prstatus32_t, pr_reg);
7638 memcpy (&prstat, note->descdata, sizeof (prstat));
7640 /* Do not overwrite the core signal if it
7641 has already been set by another thread. */
7642 if (elf_tdata (abfd)->core_signal == 0)
7643 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7644 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7646 /* pr_who exists on:
7649 pr_who doesn't exist on:
7652 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7653 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7656 #endif /* HAVE_PRSTATUS32_T */
7659 /* Fail - we don't know how to handle any other
7660 note size (ie. data object type). */
7664 /* Make a ".reg/999" section and a ".reg" section. */
7665 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7666 size, note->descpos + offset);
7668 #endif /* defined (HAVE_PRSTATUS_T) */
7670 /* Create a pseudosection containing the exact contents of NOTE. */
7672 elfcore_make_note_pseudosection (bfd *abfd,
7674 Elf_Internal_Note *note)
7676 return _bfd_elfcore_make_pseudosection (abfd, name,
7677 note->descsz, note->descpos);
7680 /* There isn't a consistent prfpregset_t across platforms,
7681 but it doesn't matter, because we don't have to pick this
7682 data structure apart. */
7685 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7687 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7690 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7691 type of NT_PRXFPREG. Just include the whole note's contents
7695 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7697 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7700 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
7701 with a note type of NT_X86_XSTATE. Just include the whole note's
7702 contents literally. */
7705 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
7707 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
7711 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7713 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7717 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7719 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7723 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
7725 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
7729 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
7731 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
7735 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
7737 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
7741 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
7743 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
7747 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
7749 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
7753 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
7755 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
7758 #if defined (HAVE_PRPSINFO_T)
7759 typedef prpsinfo_t elfcore_psinfo_t;
7760 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7761 typedef prpsinfo32_t elfcore_psinfo32_t;
7765 #if defined (HAVE_PSINFO_T)
7766 typedef psinfo_t elfcore_psinfo_t;
7767 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7768 typedef psinfo32_t elfcore_psinfo32_t;
7772 /* return a malloc'ed copy of a string at START which is at
7773 most MAX bytes long, possibly without a terminating '\0'.
7774 the copy will always have a terminating '\0'. */
7777 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7780 char *end = (char *) memchr (start, '\0', max);
7788 dups = (char *) bfd_alloc (abfd, len + 1);
7792 memcpy (dups, start, len);
7798 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7800 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7802 if (note->descsz == sizeof (elfcore_psinfo_t))
7804 elfcore_psinfo_t psinfo;
7806 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7808 elf_tdata (abfd)->core_program
7809 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7810 sizeof (psinfo.pr_fname));
7812 elf_tdata (abfd)->core_command
7813 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7814 sizeof (psinfo.pr_psargs));
7816 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7817 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7819 /* 64-bit host, 32-bit corefile */
7820 elfcore_psinfo32_t psinfo;
7822 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7824 elf_tdata (abfd)->core_program
7825 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7826 sizeof (psinfo.pr_fname));
7828 elf_tdata (abfd)->core_command
7829 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7830 sizeof (psinfo.pr_psargs));
7836 /* Fail - we don't know how to handle any other
7837 note size (ie. data object type). */
7841 /* Note that for some reason, a spurious space is tacked
7842 onto the end of the args in some (at least one anyway)
7843 implementations, so strip it off if it exists. */
7846 char *command = elf_tdata (abfd)->core_command;
7847 int n = strlen (command);
7849 if (0 < n && command[n - 1] == ' ')
7850 command[n - 1] = '\0';
7855 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7857 #if defined (HAVE_PSTATUS_T)
7859 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7861 if (note->descsz == sizeof (pstatus_t)
7862 #if defined (HAVE_PXSTATUS_T)
7863 || note->descsz == sizeof (pxstatus_t)
7869 memcpy (&pstat, note->descdata, sizeof (pstat));
7871 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7873 #if defined (HAVE_PSTATUS32_T)
7874 else if (note->descsz == sizeof (pstatus32_t))
7876 /* 64-bit host, 32-bit corefile */
7879 memcpy (&pstat, note->descdata, sizeof (pstat));
7881 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7884 /* Could grab some more details from the "representative"
7885 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7886 NT_LWPSTATUS note, presumably. */
7890 #endif /* defined (HAVE_PSTATUS_T) */
7892 #if defined (HAVE_LWPSTATUS_T)
7894 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7896 lwpstatus_t lwpstat;
7902 if (note->descsz != sizeof (lwpstat)
7903 #if defined (HAVE_LWPXSTATUS_T)
7904 && note->descsz != sizeof (lwpxstatus_t)
7909 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7911 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7912 /* Do not overwrite the core signal if it has already been set by
7914 if (elf_tdata (abfd)->core_signal == 0)
7915 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7917 /* Make a ".reg/999" section. */
7919 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7920 len = strlen (buf) + 1;
7921 name = bfd_alloc (abfd, len);
7924 memcpy (name, buf, len);
7926 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7930 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7931 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7932 sect->filepos = note->descpos
7933 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7936 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7937 sect->size = sizeof (lwpstat.pr_reg);
7938 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7941 sect->alignment_power = 2;
7943 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7946 /* Make a ".reg2/999" section */
7948 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7949 len = strlen (buf) + 1;
7950 name = bfd_alloc (abfd, len);
7953 memcpy (name, buf, len);
7955 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7959 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7960 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7961 sect->filepos = note->descpos
7962 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7965 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7966 sect->size = sizeof (lwpstat.pr_fpreg);
7967 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7970 sect->alignment_power = 2;
7972 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7974 #endif /* defined (HAVE_LWPSTATUS_T) */
7977 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7984 int is_active_thread;
7987 if (note->descsz < 728)
7990 if (! CONST_STRNEQ (note->namedata, "win32"))
7993 type = bfd_get_32 (abfd, note->descdata);
7997 case 1 /* NOTE_INFO_PROCESS */:
7998 /* FIXME: need to add ->core_command. */
7999 /* process_info.pid */
8000 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
8001 /* process_info.signal */
8002 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
8005 case 2 /* NOTE_INFO_THREAD */:
8006 /* Make a ".reg/999" section. */
8007 /* thread_info.tid */
8008 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
8010 len = strlen (buf) + 1;
8011 name = (char *) bfd_alloc (abfd, len);
8015 memcpy (name, buf, len);
8017 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8021 /* sizeof (thread_info.thread_context) */
8023 /* offsetof (thread_info.thread_context) */
8024 sect->filepos = note->descpos + 12;
8025 sect->alignment_power = 2;
8027 /* thread_info.is_active_thread */
8028 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8030 if (is_active_thread)
8031 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
8035 case 3 /* NOTE_INFO_MODULE */:
8036 /* Make a ".module/xxxxxxxx" section. */
8037 /* module_info.base_address */
8038 base_addr = bfd_get_32 (abfd, note->descdata + 4);
8039 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
8041 len = strlen (buf) + 1;
8042 name = (char *) bfd_alloc (abfd, len);
8046 memcpy (name, buf, len);
8048 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8053 sect->size = note->descsz;
8054 sect->filepos = note->descpos;
8055 sect->alignment_power = 2;
8066 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
8068 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8076 if (bed->elf_backend_grok_prstatus)
8077 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
8079 #if defined (HAVE_PRSTATUS_T)
8080 return elfcore_grok_prstatus (abfd, note);
8085 #if defined (HAVE_PSTATUS_T)
8087 return elfcore_grok_pstatus (abfd, note);
8090 #if defined (HAVE_LWPSTATUS_T)
8092 return elfcore_grok_lwpstatus (abfd, note);
8095 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
8096 return elfcore_grok_prfpreg (abfd, note);
8098 case NT_WIN32PSTATUS:
8099 return elfcore_grok_win32pstatus (abfd, note);
8101 case NT_PRXFPREG: /* Linux SSE extension */
8102 if (note->namesz == 6
8103 && strcmp (note->namedata, "LINUX") == 0)
8104 return elfcore_grok_prxfpreg (abfd, note);
8108 case NT_X86_XSTATE: /* Linux XSAVE extension */
8109 if (note->namesz == 6
8110 && strcmp (note->namedata, "LINUX") == 0)
8111 return elfcore_grok_xstatereg (abfd, note);
8116 if (note->namesz == 6
8117 && strcmp (note->namedata, "LINUX") == 0)
8118 return elfcore_grok_ppc_vmx (abfd, note);
8123 if (note->namesz == 6
8124 && strcmp (note->namedata, "LINUX") == 0)
8125 return elfcore_grok_ppc_vsx (abfd, note);
8129 case NT_S390_HIGH_GPRS:
8130 if (note->namesz == 6
8131 && strcmp (note->namedata, "LINUX") == 0)
8132 return elfcore_grok_s390_high_gprs (abfd, note);
8137 if (note->namesz == 6
8138 && strcmp (note->namedata, "LINUX") == 0)
8139 return elfcore_grok_s390_timer (abfd, note);
8143 case NT_S390_TODCMP:
8144 if (note->namesz == 6
8145 && strcmp (note->namedata, "LINUX") == 0)
8146 return elfcore_grok_s390_todcmp (abfd, note);
8150 case NT_S390_TODPREG:
8151 if (note->namesz == 6
8152 && strcmp (note->namedata, "LINUX") == 0)
8153 return elfcore_grok_s390_todpreg (abfd, note);
8158 if (note->namesz == 6
8159 && strcmp (note->namedata, "LINUX") == 0)
8160 return elfcore_grok_s390_ctrs (abfd, note);
8164 case NT_S390_PREFIX:
8165 if (note->namesz == 6
8166 && strcmp (note->namedata, "LINUX") == 0)
8167 return elfcore_grok_s390_prefix (abfd, note);
8173 if (bed->elf_backend_grok_psinfo)
8174 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
8176 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8177 return elfcore_grok_psinfo (abfd, note);
8184 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8189 sect->size = note->descsz;
8190 sect->filepos = note->descpos;
8191 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8199 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8201 elf_tdata (abfd)->build_id_size = note->descsz;
8202 elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz);
8203 if (elf_tdata (abfd)->build_id == NULL)
8206 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8212 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8219 case NT_GNU_BUILD_ID:
8220 return elfobj_grok_gnu_build_id (abfd, note);
8225 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8229 cp = strchr (note->namedata, '@');
8232 *lwpidp = atoi(cp + 1);
8239 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8241 /* Signal number at offset 0x08. */
8242 elf_tdata (abfd)->core_signal
8243 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8245 /* Process ID at offset 0x50. */
8246 elf_tdata (abfd)->core_pid
8247 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8249 /* Command name at 0x7c (max 32 bytes, including nul). */
8250 elf_tdata (abfd)->core_command
8251 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8253 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8258 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8262 if (elfcore_netbsd_get_lwpid (note, &lwp))
8263 elf_tdata (abfd)->core_lwpid = lwp;
8265 if (note->type == NT_NETBSDCORE_PROCINFO)
8267 /* NetBSD-specific core "procinfo". Note that we expect to
8268 find this note before any of the others, which is fine,
8269 since the kernel writes this note out first when it
8270 creates a core file. */
8272 return elfcore_grok_netbsd_procinfo (abfd, note);
8275 /* As of Jan 2002 there are no other machine-independent notes
8276 defined for NetBSD core files. If the note type is less
8277 than the start of the machine-dependent note types, we don't
8280 if (note->type < NT_NETBSDCORE_FIRSTMACH)
8284 switch (bfd_get_arch (abfd))
8286 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8287 PT_GETFPREGS == mach+2. */
8289 case bfd_arch_alpha:
8290 case bfd_arch_sparc:
8293 case NT_NETBSDCORE_FIRSTMACH+0:
8294 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8296 case NT_NETBSDCORE_FIRSTMACH+2:
8297 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8303 /* On all other arch's, PT_GETREGS == mach+1 and
8304 PT_GETFPREGS == mach+3. */
8309 case NT_NETBSDCORE_FIRSTMACH+1:
8310 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8312 case NT_NETBSDCORE_FIRSTMACH+3:
8313 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8323 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8325 /* Signal number at offset 0x08. */
8326 elf_tdata (abfd)->core_signal
8327 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8329 /* Process ID at offset 0x20. */
8330 elf_tdata (abfd)->core_pid
8331 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8333 /* Command name at 0x48 (max 32 bytes, including nul). */
8334 elf_tdata (abfd)->core_command
8335 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8341 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8343 if (note->type == NT_OPENBSD_PROCINFO)
8344 return elfcore_grok_openbsd_procinfo (abfd, note);
8346 if (note->type == NT_OPENBSD_REGS)
8347 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8349 if (note->type == NT_OPENBSD_FPREGS)
8350 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8352 if (note->type == NT_OPENBSD_XFPREGS)
8353 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8355 if (note->type == NT_OPENBSD_AUXV)
8357 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8362 sect->size = note->descsz;
8363 sect->filepos = note->descpos;
8364 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8369 if (note->type == NT_OPENBSD_WCOOKIE)
8371 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8376 sect->size = note->descsz;
8377 sect->filepos = note->descpos;
8378 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8387 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8389 void *ddata = note->descdata;
8396 /* nto_procfs_status 'pid' field is at offset 0. */
8397 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8399 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8400 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8402 /* nto_procfs_status 'flags' field is at offset 8. */
8403 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8405 /* nto_procfs_status 'what' field is at offset 14. */
8406 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8408 elf_tdata (abfd)->core_signal = sig;
8409 elf_tdata (abfd)->core_lwpid = *tid;
8412 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8413 do not come from signals so we make sure we set the current
8414 thread just in case. */
8415 if (flags & 0x00000080)
8416 elf_tdata (abfd)->core_lwpid = *tid;
8418 /* Make a ".qnx_core_status/%d" section. */
8419 sprintf (buf, ".qnx_core_status/%ld", *tid);
8421 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8426 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8430 sect->size = note->descsz;
8431 sect->filepos = note->descpos;
8432 sect->alignment_power = 2;
8434 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8438 elfcore_grok_nto_regs (bfd *abfd,
8439 Elf_Internal_Note *note,
8447 /* Make a "(base)/%d" section. */
8448 sprintf (buf, "%s/%ld", base, tid);
8450 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8455 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8459 sect->size = note->descsz;
8460 sect->filepos = note->descpos;
8461 sect->alignment_power = 2;
8463 /* This is the current thread. */
8464 if (elf_tdata (abfd)->core_lwpid == tid)
8465 return elfcore_maybe_make_sect (abfd, base, sect);
8470 #define BFD_QNT_CORE_INFO 7
8471 #define BFD_QNT_CORE_STATUS 8
8472 #define BFD_QNT_CORE_GREG 9
8473 #define BFD_QNT_CORE_FPREG 10
8476 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8478 /* Every GREG section has a STATUS section before it. Store the
8479 tid from the previous call to pass down to the next gregs
8481 static long tid = 1;
8485 case BFD_QNT_CORE_INFO:
8486 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8487 case BFD_QNT_CORE_STATUS:
8488 return elfcore_grok_nto_status (abfd, note, &tid);
8489 case BFD_QNT_CORE_GREG:
8490 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8491 case BFD_QNT_CORE_FPREG:
8492 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8499 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8505 /* Use note name as section name. */
8507 name = (char *) bfd_alloc (abfd, len);
8510 memcpy (name, note->namedata, len);
8511 name[len - 1] = '\0';
8513 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8517 sect->size = note->descsz;
8518 sect->filepos = note->descpos;
8519 sect->alignment_power = 1;
8524 /* Function: elfcore_write_note
8527 buffer to hold note, and current size of buffer
8531 size of data for note
8533 Writes note to end of buffer. ELF64 notes are written exactly as
8534 for ELF32, despite the current (as of 2006) ELF gabi specifying
8535 that they ought to have 8-byte namesz and descsz field, and have
8536 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8539 Pointer to realloc'd buffer, *BUFSIZ updated. */
8542 elfcore_write_note (bfd *abfd,
8550 Elf_External_Note *xnp;
8557 namesz = strlen (name) + 1;
8559 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8561 buf = (char *) realloc (buf, *bufsiz + newspace);
8564 dest = buf + *bufsiz;
8565 *bufsiz += newspace;
8566 xnp = (Elf_External_Note *) dest;
8567 H_PUT_32 (abfd, namesz, xnp->namesz);
8568 H_PUT_32 (abfd, size, xnp->descsz);
8569 H_PUT_32 (abfd, type, xnp->type);
8573 memcpy (dest, name, namesz);
8581 memcpy (dest, input, size);
8591 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8593 elfcore_write_prpsinfo (bfd *abfd,
8599 const char *note_name = "CORE";
8600 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8602 if (bed->elf_backend_write_core_note != NULL)
8605 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8606 NT_PRPSINFO, fname, psargs);
8611 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8612 if (bed->s->elfclass == ELFCLASS32)
8614 #if defined (HAVE_PSINFO32_T)
8616 int note_type = NT_PSINFO;
8619 int note_type = NT_PRPSINFO;
8622 memset (&data, 0, sizeof (data));
8623 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8624 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8625 return elfcore_write_note (abfd, buf, bufsiz,
8626 note_name, note_type, &data, sizeof (data));
8631 #if defined (HAVE_PSINFO_T)
8633 int note_type = NT_PSINFO;
8636 int note_type = NT_PRPSINFO;
8639 memset (&data, 0, sizeof (data));
8640 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8641 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8642 return elfcore_write_note (abfd, buf, bufsiz,
8643 note_name, note_type, &data, sizeof (data));
8646 #endif /* PSINFO_T or PRPSINFO_T */
8648 #if defined (HAVE_PRSTATUS_T)
8650 elfcore_write_prstatus (bfd *abfd,
8657 const char *note_name = "CORE";
8658 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8660 if (bed->elf_backend_write_core_note != NULL)
8663 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8665 pid, cursig, gregs);
8670 #if defined (HAVE_PRSTATUS32_T)
8671 if (bed->s->elfclass == ELFCLASS32)
8673 prstatus32_t prstat;
8675 memset (&prstat, 0, sizeof (prstat));
8676 prstat.pr_pid = pid;
8677 prstat.pr_cursig = cursig;
8678 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8679 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8680 NT_PRSTATUS, &prstat, sizeof (prstat));
8687 memset (&prstat, 0, sizeof (prstat));
8688 prstat.pr_pid = pid;
8689 prstat.pr_cursig = cursig;
8690 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8691 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8692 NT_PRSTATUS, &prstat, sizeof (prstat));
8695 #endif /* HAVE_PRSTATUS_T */
8697 #if defined (HAVE_LWPSTATUS_T)
8699 elfcore_write_lwpstatus (bfd *abfd,
8706 lwpstatus_t lwpstat;
8707 const char *note_name = "CORE";
8709 memset (&lwpstat, 0, sizeof (lwpstat));
8710 lwpstat.pr_lwpid = pid >> 16;
8711 lwpstat.pr_cursig = cursig;
8712 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8713 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8714 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8716 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8717 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8719 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8720 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8723 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8724 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8726 #endif /* HAVE_LWPSTATUS_T */
8728 #if defined (HAVE_PSTATUS_T)
8730 elfcore_write_pstatus (bfd *abfd,
8734 int cursig ATTRIBUTE_UNUSED,
8735 const void *gregs ATTRIBUTE_UNUSED)
8737 const char *note_name = "CORE";
8738 #if defined (HAVE_PSTATUS32_T)
8739 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8741 if (bed->s->elfclass == ELFCLASS32)
8745 memset (&pstat, 0, sizeof (pstat));
8746 pstat.pr_pid = pid & 0xffff;
8747 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8748 NT_PSTATUS, &pstat, sizeof (pstat));
8756 memset (&pstat, 0, sizeof (pstat));
8757 pstat.pr_pid = pid & 0xffff;
8758 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8759 NT_PSTATUS, &pstat, sizeof (pstat));
8763 #endif /* HAVE_PSTATUS_T */
8766 elfcore_write_prfpreg (bfd *abfd,
8772 const char *note_name = "CORE";
8773 return elfcore_write_note (abfd, buf, bufsiz,
8774 note_name, NT_FPREGSET, fpregs, size);
8778 elfcore_write_prxfpreg (bfd *abfd,
8781 const void *xfpregs,
8784 char *note_name = "LINUX";
8785 return elfcore_write_note (abfd, buf, bufsiz,
8786 note_name, NT_PRXFPREG, xfpregs, size);
8790 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
8791 const void *xfpregs, int size)
8793 char *note_name = "LINUX";
8794 return elfcore_write_note (abfd, buf, bufsiz,
8795 note_name, NT_X86_XSTATE, xfpregs, size);
8799 elfcore_write_ppc_vmx (bfd *abfd,
8802 const void *ppc_vmx,
8805 char *note_name = "LINUX";
8806 return elfcore_write_note (abfd, buf, bufsiz,
8807 note_name, NT_PPC_VMX, ppc_vmx, size);
8811 elfcore_write_ppc_vsx (bfd *abfd,
8814 const void *ppc_vsx,
8817 char *note_name = "LINUX";
8818 return elfcore_write_note (abfd, buf, bufsiz,
8819 note_name, NT_PPC_VSX, ppc_vsx, size);
8823 elfcore_write_s390_high_gprs (bfd *abfd,
8826 const void *s390_high_gprs,
8829 char *note_name = "LINUX";
8830 return elfcore_write_note (abfd, buf, bufsiz,
8831 note_name, NT_S390_HIGH_GPRS,
8832 s390_high_gprs, size);
8836 elfcore_write_s390_timer (bfd *abfd,
8839 const void *s390_timer,
8842 char *note_name = "LINUX";
8843 return elfcore_write_note (abfd, buf, bufsiz,
8844 note_name, NT_S390_TIMER, s390_timer, size);
8848 elfcore_write_s390_todcmp (bfd *abfd,
8851 const void *s390_todcmp,
8854 char *note_name = "LINUX";
8855 return elfcore_write_note (abfd, buf, bufsiz,
8856 note_name, NT_S390_TODCMP, s390_todcmp, size);
8860 elfcore_write_s390_todpreg (bfd *abfd,
8863 const void *s390_todpreg,
8866 char *note_name = "LINUX";
8867 return elfcore_write_note (abfd, buf, bufsiz,
8868 note_name, NT_S390_TODPREG, s390_todpreg, size);
8872 elfcore_write_s390_ctrs (bfd *abfd,
8875 const void *s390_ctrs,
8878 char *note_name = "LINUX";
8879 return elfcore_write_note (abfd, buf, bufsiz,
8880 note_name, NT_S390_CTRS, s390_ctrs, size);
8884 elfcore_write_s390_prefix (bfd *abfd,
8887 const void *s390_prefix,
8890 char *note_name = "LINUX";
8891 return elfcore_write_note (abfd, buf, bufsiz,
8892 note_name, NT_S390_PREFIX, s390_prefix, size);
8896 elfcore_write_register_note (bfd *abfd,
8899 const char *section,
8903 if (strcmp (section, ".reg2") == 0)
8904 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
8905 if (strcmp (section, ".reg-xfp") == 0)
8906 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
8907 if (strcmp (section, ".reg-xstate") == 0)
8908 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
8909 if (strcmp (section, ".reg-ppc-vmx") == 0)
8910 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
8911 if (strcmp (section, ".reg-ppc-vsx") == 0)
8912 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
8913 if (strcmp (section, ".reg-s390-high-gprs") == 0)
8914 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
8915 if (strcmp (section, ".reg-s390-timer") == 0)
8916 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
8917 if (strcmp (section, ".reg-s390-todcmp") == 0)
8918 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
8919 if (strcmp (section, ".reg-s390-todpreg") == 0)
8920 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
8921 if (strcmp (section, ".reg-s390-ctrs") == 0)
8922 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
8923 if (strcmp (section, ".reg-s390-prefix") == 0)
8924 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
8929 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
8934 while (p < buf + size)
8936 /* FIXME: bad alignment assumption. */
8937 Elf_External_Note *xnp = (Elf_External_Note *) p;
8938 Elf_Internal_Note in;
8940 if (offsetof (Elf_External_Note, name) > buf - p + size)
8943 in.type = H_GET_32 (abfd, xnp->type);
8945 in.namesz = H_GET_32 (abfd, xnp->namesz);
8946 in.namedata = xnp->name;
8947 if (in.namesz > buf - in.namedata + size)
8950 in.descsz = H_GET_32 (abfd, xnp->descsz);
8951 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8952 in.descpos = offset + (in.descdata - buf);
8954 && (in.descdata >= buf + size
8955 || in.descsz > buf - in.descdata + size))
8958 switch (bfd_get_format (abfd))
8964 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8966 if (! elfcore_grok_netbsd_note (abfd, &in))
8969 else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
8971 if (! elfcore_grok_openbsd_note (abfd, &in))
8974 else if (CONST_STRNEQ (in.namedata, "QNX"))
8976 if (! elfcore_grok_nto_note (abfd, &in))
8979 else if (CONST_STRNEQ (in.namedata, "SPU/"))
8981 if (! elfcore_grok_spu_note (abfd, &in))
8986 if (! elfcore_grok_note (abfd, &in))
8992 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8994 if (! elfobj_grok_gnu_note (abfd, &in))
9000 p = in.descdata + BFD_ALIGN (in.descsz, 4);
9007 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9014 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9017 buf = (char *) bfd_malloc (size);
9021 if (bfd_bread (buf, size, abfd) != size
9022 || !elf_parse_notes (abfd, buf, size, offset))
9032 /* Providing external access to the ELF program header table. */
9034 /* Return an upper bound on the number of bytes required to store a
9035 copy of ABFD's program header table entries. Return -1 if an error
9036 occurs; bfd_get_error will return an appropriate code. */
9039 bfd_get_elf_phdr_upper_bound (bfd *abfd)
9041 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9043 bfd_set_error (bfd_error_wrong_format);
9047 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
9050 /* Copy ABFD's program header table entries to *PHDRS. The entries
9051 will be stored as an array of Elf_Internal_Phdr structures, as
9052 defined in include/elf/internal.h. To find out how large the
9053 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9055 Return the number of program header table entries read, or -1 if an
9056 error occurs; bfd_get_error will return an appropriate code. */
9059 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
9063 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9065 bfd_set_error (bfd_error_wrong_format);
9069 num_phdrs = elf_elfheader (abfd)->e_phnum;
9070 memcpy (phdrs, elf_tdata (abfd)->phdr,
9071 num_phdrs * sizeof (Elf_Internal_Phdr));
9076 enum elf_reloc_type_class
9077 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
9079 return reloc_class_normal;
9082 /* For RELA architectures, return the relocation value for a
9083 relocation against a local symbol. */
9086 _bfd_elf_rela_local_sym (bfd *abfd,
9087 Elf_Internal_Sym *sym,
9089 Elf_Internal_Rela *rel)
9091 asection *sec = *psec;
9094 relocation = (sec->output_section->vma
9095 + sec->output_offset
9097 if ((sec->flags & SEC_MERGE)
9098 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
9099 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
9102 _bfd_merged_section_offset (abfd, psec,
9103 elf_section_data (sec)->sec_info,
9104 sym->st_value + rel->r_addend);
9107 /* If we have changed the section, and our original section is
9108 marked with SEC_EXCLUDE, it means that the original
9109 SEC_MERGE section has been completely subsumed in some
9110 other SEC_MERGE section. In this case, we need to leave
9111 some info around for --emit-relocs. */
9112 if ((sec->flags & SEC_EXCLUDE) != 0)
9113 sec->kept_section = *psec;
9116 rel->r_addend -= relocation;
9117 rel->r_addend += sec->output_section->vma + sec->output_offset;
9123 _bfd_elf_rel_local_sym (bfd *abfd,
9124 Elf_Internal_Sym *sym,
9128 asection *sec = *psec;
9130 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
9131 return sym->st_value + addend;
9133 return _bfd_merged_section_offset (abfd, psec,
9134 elf_section_data (sec)->sec_info,
9135 sym->st_value + addend);
9139 _bfd_elf_section_offset (bfd *abfd,
9140 struct bfd_link_info *info,
9144 switch (sec->sec_info_type)
9146 case ELF_INFO_TYPE_STABS:
9147 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9149 case ELF_INFO_TYPE_EH_FRAME:
9150 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
9156 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
9157 reconstruct an ELF file by reading the segments out of remote memory
9158 based on the ELF file header at EHDR_VMA and the ELF program headers it
9159 points to. If not null, *LOADBASEP is filled in with the difference
9160 between the VMAs from which the segments were read, and the VMAs the
9161 file headers (and hence BFD's idea of each section's VMA) put them at.
9163 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9164 remote memory at target address VMA into the local buffer at MYADDR; it
9165 should return zero on success or an `errno' code on failure. TEMPL must
9166 be a BFD for an ELF target with the word size and byte order found in
9167 the remote memory. */
9170 bfd_elf_bfd_from_remote_memory
9174 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
9176 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9177 (templ, ehdr_vma, loadbasep, target_read_memory);
9181 _bfd_elf_get_synthetic_symtab (bfd *abfd,
9182 long symcount ATTRIBUTE_UNUSED,
9183 asymbol **syms ATTRIBUTE_UNUSED,
9188 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9191 const char *relplt_name;
9192 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9196 Elf_Internal_Shdr *hdr;
9202 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9205 if (dynsymcount <= 0)
9208 if (!bed->plt_sym_val)
9211 relplt_name = bed->relplt_name;
9212 if (relplt_name == NULL)
9213 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
9214 relplt = bfd_get_section_by_name (abfd, relplt_name);
9218 hdr = &elf_section_data (relplt)->this_hdr;
9219 if (hdr->sh_link != elf_dynsymtab (abfd)
9220 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9223 plt = bfd_get_section_by_name (abfd, ".plt");
9227 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
9228 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
9231 count = relplt->size / hdr->sh_entsize;
9232 size = count * sizeof (asymbol);
9233 p = relplt->relocation;
9234 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9236 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9240 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9242 size += sizeof ("+0x") - 1 + 8;
9247 s = *ret = (asymbol *) bfd_malloc (size);
9251 names = (char *) (s + count);
9252 p = relplt->relocation;
9254 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9259 addr = bed->plt_sym_val (i, plt, p);
9260 if (addr == (bfd_vma) -1)
9263 *s = **p->sym_ptr_ptr;
9264 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
9265 we are defining a symbol, ensure one of them is set. */
9266 if ((s->flags & BSF_LOCAL) == 0)
9267 s->flags |= BSF_GLOBAL;
9268 s->flags |= BSF_SYNTHETIC;
9270 s->value = addr - plt->vma;
9273 len = strlen ((*p->sym_ptr_ptr)->name);
9274 memcpy (names, (*p->sym_ptr_ptr)->name, len);
9280 memcpy (names, "+0x", sizeof ("+0x") - 1);
9281 names += sizeof ("+0x") - 1;
9282 bfd_sprintf_vma (abfd, buf, p->addend);
9283 for (a = buf; *a == '0'; ++a)
9286 memcpy (names, a, len);
9289 memcpy (names, "@plt", sizeof ("@plt"));
9290 names += sizeof ("@plt");
9297 /* It is only used by x86-64 so far. */
9298 asection _bfd_elf_large_com_section
9299 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
9300 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
9303 _bfd_elf_set_osabi (bfd * abfd,
9304 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9306 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
9308 i_ehdrp = elf_elfheader (abfd);
9310 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
9312 /* To make things simpler for the loader on Linux systems we set the
9313 osabi field to ELFOSABI_LINUX if the binary contains symbols of
9314 the STT_GNU_IFUNC type. */
9315 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
9316 && elf_tdata (abfd)->has_ifunc_symbols)
9317 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
9321 /* Return TRUE for ELF symbol types that represent functions.
9322 This is the default version of this function, which is sufficient for
9323 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
9326 _bfd_elf_is_function_type (unsigned int type)
9328 return (type == STT_FUNC
9329 || type == STT_GNU_IFUNC);