1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2018 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 BFD support for ELF formats is being worked on.
28 Currently, the best supported back ends are for sparc and i386
29 (running svr4 or Solaris 2).
31 Documentation of the internals of the support code still needs
32 to be written. The code is changing quickly enough that we
33 haven't bothered yet. */
35 /* For sparc64-cross-sparc32. */
43 #include "libiberty.h"
44 #include "safe-ctype.h"
45 #include "elf-linux-core.h"
51 static int elf_sort_sections (const void *, const void *);
52 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
53 static bfd_boolean prep_headers (bfd *);
54 static bfd_boolean swap_out_syms (bfd *, struct elf_strtab_hash **, int) ;
55 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type,
57 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
58 file_ptr offset, size_t align);
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 if (abfd->direction != read_direction)
249 struct output_elf_obj_tdata *o = bfd_zalloc (abfd, sizeof *o);
252 elf_tdata (abfd)->o = o;
253 elf_program_header_size (abfd) = (bfd_size_type) -1;
260 bfd_elf_make_object (bfd *abfd)
262 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
263 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
268 bfd_elf_mkcorefile (bfd *abfd)
270 /* I think this can be done just like an object file. */
271 if (!abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd))
273 elf_tdata (abfd)->core = bfd_zalloc (abfd, sizeof (*elf_tdata (abfd)->core));
274 return elf_tdata (abfd)->core != NULL;
278 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
280 Elf_Internal_Shdr **i_shdrp;
281 bfd_byte *shstrtab = NULL;
283 bfd_size_type shstrtabsize;
285 i_shdrp = elf_elfsections (abfd);
287 || shindex >= elf_numsections (abfd)
288 || i_shdrp[shindex] == 0)
291 shstrtab = i_shdrp[shindex]->contents;
292 if (shstrtab == NULL)
294 /* No cached one, attempt to read, and cache what we read. */
295 offset = i_shdrp[shindex]->sh_offset;
296 shstrtabsize = i_shdrp[shindex]->sh_size;
298 /* Allocate and clear an extra byte at the end, to prevent crashes
299 in case the string table is not terminated. */
300 if (shstrtabsize + 1 <= 1
301 || shstrtabsize > bfd_get_file_size (abfd)
302 || bfd_seek (abfd, offset, SEEK_SET) != 0
303 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL)
305 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
307 if (bfd_get_error () != bfd_error_system_call)
308 bfd_set_error (bfd_error_file_truncated);
309 bfd_release (abfd, shstrtab);
311 /* Once we've failed to read it, make sure we don't keep
312 trying. Otherwise, we'll keep allocating space for
313 the string table over and over. */
314 i_shdrp[shindex]->sh_size = 0;
317 shstrtab[shstrtabsize] = '\0';
318 i_shdrp[shindex]->contents = shstrtab;
320 return (char *) shstrtab;
324 bfd_elf_string_from_elf_section (bfd *abfd,
325 unsigned int shindex,
326 unsigned int strindex)
328 Elf_Internal_Shdr *hdr;
333 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
336 hdr = elf_elfsections (abfd)[shindex];
338 if (hdr->contents == NULL)
340 if (hdr->sh_type != SHT_STRTAB && hdr->sh_type < SHT_LOOS)
342 /* PR 17512: file: f057ec89. */
343 /* xgettext:c-format */
344 _bfd_error_handler (_("%pB: attempt to load strings from"
345 " a non-string section (number %d)"),
350 if (bfd_elf_get_str_section (abfd, shindex) == NULL)
354 if (strindex >= hdr->sh_size)
356 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
358 /* xgettext:c-format */
359 (_("%pB: invalid string offset %u >= %" PRIu64 " for section `%s'"),
360 abfd, strindex, (uint64_t) hdr->sh_size,
361 (shindex == shstrndx && strindex == hdr->sh_name
363 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
367 return ((char *) hdr->contents) + strindex;
370 /* Read and convert symbols to internal format.
371 SYMCOUNT specifies the number of symbols to read, starting from
372 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
373 are non-NULL, they are used to store the internal symbols, external
374 symbols, and symbol section index extensions, respectively.
375 Returns a pointer to the internal symbol buffer (malloced if necessary)
376 or NULL if there were no symbols or some kind of problem. */
379 bfd_elf_get_elf_syms (bfd *ibfd,
380 Elf_Internal_Shdr *symtab_hdr,
383 Elf_Internal_Sym *intsym_buf,
385 Elf_External_Sym_Shndx *extshndx_buf)
387 Elf_Internal_Shdr *shndx_hdr;
389 const bfd_byte *esym;
390 Elf_External_Sym_Shndx *alloc_extshndx;
391 Elf_External_Sym_Shndx *shndx;
392 Elf_Internal_Sym *alloc_intsym;
393 Elf_Internal_Sym *isym;
394 Elf_Internal_Sym *isymend;
395 const struct elf_backend_data *bed;
400 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
406 /* Normal syms might have section extension entries. */
408 if (elf_symtab_shndx_list (ibfd) != NULL)
410 elf_section_list * entry;
411 Elf_Internal_Shdr **sections = elf_elfsections (ibfd);
413 /* Find an index section that is linked to this symtab section. */
414 for (entry = elf_symtab_shndx_list (ibfd); entry != NULL; entry = entry->next)
417 if (entry->hdr.sh_link >= elf_numsections (ibfd))
420 if (sections[entry->hdr.sh_link] == symtab_hdr)
422 shndx_hdr = & entry->hdr;
427 if (shndx_hdr == NULL)
429 if (symtab_hdr == & elf_symtab_hdr (ibfd))
430 /* Not really accurate, but this was how the old code used to work. */
431 shndx_hdr = & elf_symtab_shndx_list (ibfd)->hdr;
432 /* Otherwise we do nothing. The assumption is that
433 the index table will not be needed. */
437 /* Read the symbols. */
439 alloc_extshndx = NULL;
441 bed = get_elf_backend_data (ibfd);
442 extsym_size = bed->s->sizeof_sym;
443 amt = (bfd_size_type) symcount * extsym_size;
444 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
445 if (extsym_buf == NULL)
447 alloc_ext = bfd_malloc2 (symcount, extsym_size);
448 extsym_buf = alloc_ext;
450 if (extsym_buf == NULL
451 || bfd_seek (ibfd, pos, SEEK_SET) != 0
452 || bfd_bread (extsym_buf, amt, ibfd) != amt)
458 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
462 amt = (bfd_size_type) symcount * sizeof (Elf_External_Sym_Shndx);
463 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
464 if (extshndx_buf == NULL)
466 alloc_extshndx = (Elf_External_Sym_Shndx *)
467 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
468 extshndx_buf = alloc_extshndx;
470 if (extshndx_buf == NULL
471 || bfd_seek (ibfd, pos, SEEK_SET) != 0
472 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
479 if (intsym_buf == NULL)
481 alloc_intsym = (Elf_Internal_Sym *)
482 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
483 intsym_buf = alloc_intsym;
484 if (intsym_buf == NULL)
488 /* Convert the symbols to internal form. */
489 isymend = intsym_buf + symcount;
490 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
491 shndx = extshndx_buf;
493 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
494 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
496 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
497 /* xgettext:c-format */
498 _bfd_error_handler (_("%pB symbol number %lu references"
499 " nonexistent SHT_SYMTAB_SHNDX section"),
500 ibfd, (unsigned long) symoffset);
501 if (alloc_intsym != NULL)
508 if (alloc_ext != NULL)
510 if (alloc_extshndx != NULL)
511 free (alloc_extshndx);
516 /* Look up a symbol name. */
518 bfd_elf_sym_name (bfd *abfd,
519 Elf_Internal_Shdr *symtab_hdr,
520 Elf_Internal_Sym *isym,
524 unsigned int iname = isym->st_name;
525 unsigned int shindex = symtab_hdr->sh_link;
527 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
528 /* Check for a bogus st_shndx to avoid crashing. */
529 && isym->st_shndx < elf_numsections (abfd))
531 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
532 shindex = elf_elfheader (abfd)->e_shstrndx;
535 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
538 else if (sym_sec && *name == '\0')
539 name = bfd_section_name (abfd, sym_sec);
544 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
545 sections. The first element is the flags, the rest are section
548 typedef union elf_internal_group {
549 Elf_Internal_Shdr *shdr;
551 } Elf_Internal_Group;
553 /* Return the name of the group signature symbol. Why isn't the
554 signature just a string? */
557 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
559 Elf_Internal_Shdr *hdr;
560 unsigned char esym[sizeof (Elf64_External_Sym)];
561 Elf_External_Sym_Shndx eshndx;
562 Elf_Internal_Sym isym;
564 /* First we need to ensure the symbol table is available. Make sure
565 that it is a symbol table section. */
566 if (ghdr->sh_link >= elf_numsections (abfd))
568 hdr = elf_elfsections (abfd) [ghdr->sh_link];
569 if (hdr->sh_type != SHT_SYMTAB
570 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
573 /* Go read the symbol. */
574 hdr = &elf_tdata (abfd)->symtab_hdr;
575 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
576 &isym, esym, &eshndx) == NULL)
579 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
582 /* Set next_in_group list pointer, and group name for NEWSECT. */
585 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
587 unsigned int num_group = elf_tdata (abfd)->num_group;
589 /* If num_group is zero, read in all SHT_GROUP sections. The count
590 is set to -1 if there are no SHT_GROUP sections. */
593 unsigned int i, shnum;
595 /* First count the number of groups. If we have a SHT_GROUP
596 section with just a flag word (ie. sh_size is 4), ignore it. */
597 shnum = elf_numsections (abfd);
600 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
601 ( (shdr)->sh_type == SHT_GROUP \
602 && (shdr)->sh_size >= minsize \
603 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
604 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
606 for (i = 0; i < shnum; i++)
608 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
610 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
616 num_group = (unsigned) -1;
617 elf_tdata (abfd)->num_group = num_group;
618 elf_tdata (abfd)->group_sect_ptr = NULL;
622 /* We keep a list of elf section headers for group sections,
623 so we can find them quickly. */
626 elf_tdata (abfd)->num_group = num_group;
627 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
628 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
629 if (elf_tdata (abfd)->group_sect_ptr == NULL)
631 memset (elf_tdata (abfd)->group_sect_ptr, 0, num_group * sizeof (Elf_Internal_Shdr *));
634 for (i = 0; i < shnum; i++)
636 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
638 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
641 Elf_Internal_Group *dest;
643 /* Make sure the group section has a BFD section
645 if (!bfd_section_from_shdr (abfd, i))
648 /* Add to list of sections. */
649 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
652 /* Read the raw contents. */
653 BFD_ASSERT (sizeof (*dest) >= 4);
654 amt = shdr->sh_size * sizeof (*dest) / 4;
655 shdr->contents = (unsigned char *)
656 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
657 /* PR binutils/4110: Handle corrupt group headers. */
658 if (shdr->contents == NULL)
661 /* xgettext:c-format */
662 (_("%pB: corrupt size field in group section"
663 " header: %#" PRIx64),
664 abfd, (uint64_t) shdr->sh_size);
665 bfd_set_error (bfd_error_bad_value);
670 memset (shdr->contents, 0, amt);
672 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
673 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
677 /* xgettext:c-format */
678 (_("%pB: invalid size field in group section"
679 " header: %#" PRIx64 ""),
680 abfd, (uint64_t) shdr->sh_size);
681 bfd_set_error (bfd_error_bad_value);
683 /* PR 17510: If the group contents are even
684 partially corrupt, do not allow any of the
685 contents to be used. */
686 memset (shdr->contents, 0, amt);
690 /* Translate raw contents, a flag word followed by an
691 array of elf section indices all in target byte order,
692 to the flag word followed by an array of elf section
694 src = shdr->contents + shdr->sh_size;
695 dest = (Elf_Internal_Group *) (shdr->contents + amt);
703 idx = H_GET_32 (abfd, src);
704 if (src == shdr->contents)
707 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
708 shdr->bfd_section->flags
709 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
715 (_("%pB: invalid SHT_GROUP entry"), abfd);
718 dest->shdr = elf_elfsections (abfd)[idx];
723 /* PR 17510: Corrupt binaries might contain invalid groups. */
724 if (num_group != (unsigned) elf_tdata (abfd)->num_group)
726 elf_tdata (abfd)->num_group = num_group;
728 /* If all groups are invalid then fail. */
731 elf_tdata (abfd)->group_sect_ptr = NULL;
732 elf_tdata (abfd)->num_group = num_group = -1;
734 (_("%pB: no valid group sections found"), abfd);
735 bfd_set_error (bfd_error_bad_value);
741 if (num_group != (unsigned) -1)
743 unsigned int search_offset = elf_tdata (abfd)->group_search_offset;
746 for (j = 0; j < num_group; j++)
748 /* Begin search from previous found group. */
749 unsigned i = (j + search_offset) % num_group;
751 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
752 Elf_Internal_Group *idx;
758 idx = (Elf_Internal_Group *) shdr->contents;
759 if (idx == NULL || shdr->sh_size < 4)
761 /* See PR 21957 for a reproducer. */
762 /* xgettext:c-format */
763 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
764 abfd, shdr->bfd_section);
765 elf_tdata (abfd)->group_sect_ptr[i] = NULL;
766 bfd_set_error (bfd_error_bad_value);
769 n_elt = shdr->sh_size / 4;
771 /* Look through this group's sections to see if current
772 section is a member. */
774 if ((++idx)->shdr == hdr)
778 /* We are a member of this group. Go looking through
779 other members to see if any others are linked via
781 idx = (Elf_Internal_Group *) shdr->contents;
782 n_elt = shdr->sh_size / 4;
784 if ((s = (++idx)->shdr->bfd_section) != NULL
785 && elf_next_in_group (s) != NULL)
789 /* Snarf the group name from other member, and
790 insert current section in circular list. */
791 elf_group_name (newsect) = elf_group_name (s);
792 elf_next_in_group (newsect) = elf_next_in_group (s);
793 elf_next_in_group (s) = newsect;
799 gname = group_signature (abfd, shdr);
802 elf_group_name (newsect) = gname;
804 /* Start a circular list with one element. */
805 elf_next_in_group (newsect) = newsect;
808 /* If the group section has been created, point to the
810 if (shdr->bfd_section != NULL)
811 elf_next_in_group (shdr->bfd_section) = newsect;
813 elf_tdata (abfd)->group_search_offset = i;
820 if (elf_group_name (newsect) == NULL)
822 /* xgettext:c-format */
823 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
831 _bfd_elf_setup_sections (bfd *abfd)
834 unsigned int num_group = elf_tdata (abfd)->num_group;
835 bfd_boolean result = TRUE;
838 /* Process SHF_LINK_ORDER. */
839 for (s = abfd->sections; s != NULL; s = s->next)
841 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
842 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
844 unsigned int elfsec = this_hdr->sh_link;
845 /* FIXME: The old Intel compiler and old strip/objcopy may
846 not set the sh_link or sh_info fields. Hence we could
847 get the situation where elfsec is 0. */
850 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
851 if (bed->link_order_error_handler)
852 bed->link_order_error_handler
853 /* xgettext:c-format */
854 (_("%pB: warning: sh_link not set for section `%pA'"),
859 asection *linksec = NULL;
861 if (elfsec < elf_numsections (abfd))
863 this_hdr = elf_elfsections (abfd)[elfsec];
864 linksec = this_hdr->bfd_section;
868 Some strip/objcopy may leave an incorrect value in
869 sh_link. We don't want to proceed. */
873 /* xgettext:c-format */
874 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
875 s->owner, elfsec, s);
879 elf_linked_to_section (s) = linksec;
882 else if (this_hdr->sh_type == SHT_GROUP
883 && elf_next_in_group (s) == NULL)
886 /* xgettext:c-format */
887 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
888 abfd, elf_section_data (s)->this_idx);
893 /* Process section groups. */
894 if (num_group == (unsigned) -1)
897 for (i = 0; i < num_group; i++)
899 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
900 Elf_Internal_Group *idx;
903 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
904 if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
907 /* xgettext:c-format */
908 (_("%pB: section group entry number %u is corrupt"),
914 idx = (Elf_Internal_Group *) shdr->contents;
915 n_elt = shdr->sh_size / 4;
921 if (idx->shdr == NULL)
923 else if (idx->shdr->bfd_section)
924 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
925 else if (idx->shdr->sh_type != SHT_RELA
926 && idx->shdr->sh_type != SHT_REL)
928 /* There are some unknown sections in the group. */
930 /* xgettext:c-format */
931 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
934 bfd_elf_string_from_elf_section (abfd,
935 (elf_elfheader (abfd)
948 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
950 return elf_next_in_group (sec) != NULL;
954 convert_debug_to_zdebug (bfd *abfd, const char *name)
956 unsigned int len = strlen (name);
957 char *new_name = bfd_alloc (abfd, len + 2);
958 if (new_name == NULL)
962 memcpy (new_name + 2, name + 1, len);
967 convert_zdebug_to_debug (bfd *abfd, const char *name)
969 unsigned int len = strlen (name);
970 char *new_name = bfd_alloc (abfd, len);
971 if (new_name == NULL)
974 memcpy (new_name + 1, name + 2, len - 1);
978 /* Make a BFD section from an ELF section. We store a pointer to the
979 BFD section in the bfd_section field of the header. */
982 _bfd_elf_make_section_from_shdr (bfd *abfd,
983 Elf_Internal_Shdr *hdr,
989 const struct elf_backend_data *bed;
991 if (hdr->bfd_section != NULL)
994 newsect = bfd_make_section_anyway (abfd, name);
998 hdr->bfd_section = newsect;
999 elf_section_data (newsect)->this_hdr = *hdr;
1000 elf_section_data (newsect)->this_idx = shindex;
1002 /* Always use the real type/flags. */
1003 elf_section_type (newsect) = hdr->sh_type;
1004 elf_section_flags (newsect) = hdr->sh_flags;
1006 newsect->filepos = hdr->sh_offset;
1008 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
1009 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
1010 || ! bfd_set_section_alignment (abfd, newsect,
1011 bfd_log2 (hdr->sh_addralign)))
1014 flags = SEC_NO_FLAGS;
1015 if (hdr->sh_type != SHT_NOBITS)
1016 flags |= SEC_HAS_CONTENTS;
1017 if (hdr->sh_type == SHT_GROUP)
1019 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1022 if (hdr->sh_type != SHT_NOBITS)
1025 if ((hdr->sh_flags & SHF_WRITE) == 0)
1026 flags |= SEC_READONLY;
1027 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
1029 else if ((flags & SEC_LOAD) != 0)
1031 if ((hdr->sh_flags & SHF_MERGE) != 0)
1034 newsect->entsize = hdr->sh_entsize;
1036 if ((hdr->sh_flags & SHF_STRINGS) != 0)
1037 flags |= SEC_STRINGS;
1038 if (hdr->sh_flags & SHF_GROUP)
1039 if (!setup_group (abfd, hdr, newsect))
1041 if ((hdr->sh_flags & SHF_TLS) != 0)
1042 flags |= SEC_THREAD_LOCAL;
1043 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
1044 flags |= SEC_EXCLUDE;
1046 if ((flags & SEC_ALLOC) == 0)
1048 /* The debugging sections appear to be recognized only by name,
1049 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1050 if (name [0] == '.')
1055 p = ".debug", n = 6;
1056 else if (name[1] == 'g' && name[2] == 'n')
1057 p = ".gnu.linkonce.wi.", n = 17;
1058 else if (name[1] == 'g' && name[2] == 'd')
1059 p = ".gdb_index", n = 11; /* yes we really do mean 11. */
1060 else if (name[1] == 'l')
1062 else if (name[1] == 's')
1064 else if (name[1] == 'z')
1065 p = ".zdebug", n = 7;
1068 if (p != NULL && strncmp (name, p, n) == 0)
1069 flags |= SEC_DEBUGGING;
1073 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1074 only link a single copy of the section. This is used to support
1075 g++. g++ will emit each template expansion in its own section.
1076 The symbols will be defined as weak, so that multiple definitions
1077 are permitted. The GNU linker extension is to actually discard
1078 all but one of the sections. */
1079 if (CONST_STRNEQ (name, ".gnu.linkonce")
1080 && elf_next_in_group (newsect) == NULL)
1081 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1083 bed = get_elf_backend_data (abfd);
1084 if (bed->elf_backend_section_flags)
1085 if (! bed->elf_backend_section_flags (&flags, hdr))
1088 if (! bfd_set_section_flags (abfd, newsect, flags))
1091 /* We do not parse the PT_NOTE segments as we are interested even in the
1092 separate debug info files which may have the segments offsets corrupted.
1093 PT_NOTEs from the core files are currently not parsed using BFD. */
1094 if (hdr->sh_type == SHT_NOTE)
1098 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
1101 elf_parse_notes (abfd, (char *) contents, hdr->sh_size,
1102 hdr->sh_offset, hdr->sh_addralign);
1106 if ((flags & SEC_ALLOC) != 0)
1108 Elf_Internal_Phdr *phdr;
1109 unsigned int i, nload;
1111 /* Some ELF linkers produce binaries with all the program header
1112 p_paddr fields zero. If we have such a binary with more than
1113 one PT_LOAD header, then leave the section lma equal to vma
1114 so that we don't create sections with overlapping lma. */
1115 phdr = elf_tdata (abfd)->phdr;
1116 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1117 if (phdr->p_paddr != 0)
1119 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
1121 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
1124 phdr = elf_tdata (abfd)->phdr;
1125 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1127 if (((phdr->p_type == PT_LOAD
1128 && (hdr->sh_flags & SHF_TLS) == 0)
1129 || phdr->p_type == PT_TLS)
1130 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
1132 if ((flags & SEC_LOAD) == 0)
1133 newsect->lma = (phdr->p_paddr
1134 + hdr->sh_addr - phdr->p_vaddr);
1136 /* We used to use the same adjustment for SEC_LOAD
1137 sections, but that doesn't work if the segment
1138 is packed with code from multiple VMAs.
1139 Instead we calculate the section LMA based on
1140 the segment LMA. It is assumed that the
1141 segment will contain sections with contiguous
1142 LMAs, even if the VMAs are not. */
1143 newsect->lma = (phdr->p_paddr
1144 + hdr->sh_offset - phdr->p_offset);
1146 /* With contiguous segments, we can't tell from file
1147 offsets whether a section with zero size should
1148 be placed at the end of one segment or the
1149 beginning of the next. Decide based on vaddr. */
1150 if (hdr->sh_addr >= phdr->p_vaddr
1151 && (hdr->sh_addr + hdr->sh_size
1152 <= phdr->p_vaddr + phdr->p_memsz))
1158 /* Compress/decompress DWARF debug sections with names: .debug_* and
1159 .zdebug_*, after the section flags is set. */
1160 if ((flags & SEC_DEBUGGING)
1161 && ((name[1] == 'd' && name[6] == '_')
1162 || (name[1] == 'z' && name[7] == '_')))
1164 enum { nothing, compress, decompress } action = nothing;
1165 int compression_header_size;
1166 bfd_size_type uncompressed_size;
1167 bfd_boolean compressed
1168 = bfd_is_section_compressed_with_header (abfd, newsect,
1169 &compression_header_size,
1170 &uncompressed_size);
1174 /* Compressed section. Check if we should decompress. */
1175 if ((abfd->flags & BFD_DECOMPRESS))
1176 action = decompress;
1179 /* Compress the uncompressed section or convert from/to .zdebug*
1180 section. Check if we should compress. */
1181 if (action == nothing)
1183 if (newsect->size != 0
1184 && (abfd->flags & BFD_COMPRESS)
1185 && compression_header_size >= 0
1186 && uncompressed_size > 0
1188 || ((compression_header_size > 0)
1189 != ((abfd->flags & BFD_COMPRESS_GABI) != 0))))
1195 if (action == compress)
1197 if (!bfd_init_section_compress_status (abfd, newsect))
1200 /* xgettext:c-format */
1201 (_("%pB: unable to initialize compress status for section %s"),
1208 if (!bfd_init_section_decompress_status (abfd, newsect))
1211 /* xgettext:c-format */
1212 (_("%pB: unable to initialize decompress status for section %s"),
1218 if (abfd->is_linker_input)
1221 && (action == decompress
1222 || (action == compress
1223 && (abfd->flags & BFD_COMPRESS_GABI) != 0)))
1225 /* Convert section name from .zdebug_* to .debug_* so
1226 that linker will consider this section as a debug
1228 char *new_name = convert_zdebug_to_debug (abfd, name);
1229 if (new_name == NULL)
1231 bfd_rename_section (abfd, newsect, new_name);
1235 /* For objdump, don't rename the section. For objcopy, delay
1236 section rename to elf_fake_sections. */
1237 newsect->flags |= SEC_ELF_RENAME;
1243 const char *const bfd_elf_section_type_names[] =
1245 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1246 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1247 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1250 /* ELF relocs are against symbols. If we are producing relocatable
1251 output, and the reloc is against an external symbol, and nothing
1252 has given us any additional addend, the resulting reloc will also
1253 be against the same symbol. In such a case, we don't want to
1254 change anything about the way the reloc is handled, since it will
1255 all be done at final link time. Rather than put special case code
1256 into bfd_perform_relocation, all the reloc types use this howto
1257 function. It just short circuits the reloc if producing
1258 relocatable output against an external symbol. */
1260 bfd_reloc_status_type
1261 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1262 arelent *reloc_entry,
1264 void *data ATTRIBUTE_UNUSED,
1265 asection *input_section,
1267 char **error_message ATTRIBUTE_UNUSED)
1269 if (output_bfd != NULL
1270 && (symbol->flags & BSF_SECTION_SYM) == 0
1271 && (! reloc_entry->howto->partial_inplace
1272 || reloc_entry->addend == 0))
1274 reloc_entry->address += input_section->output_offset;
1275 return bfd_reloc_ok;
1278 return bfd_reloc_continue;
1281 /* Returns TRUE if section A matches section B.
1282 Names, addresses and links may be different, but everything else
1283 should be the same. */
1286 section_match (const Elf_Internal_Shdr * a,
1287 const Elf_Internal_Shdr * b)
1290 a->sh_type == b->sh_type
1291 && (a->sh_flags & ~ SHF_INFO_LINK)
1292 == (b->sh_flags & ~ SHF_INFO_LINK)
1293 && a->sh_addralign == b->sh_addralign
1294 && a->sh_size == b->sh_size
1295 && a->sh_entsize == b->sh_entsize
1296 /* FIXME: Check sh_addr ? */
1300 /* Find a section in OBFD that has the same characteristics
1301 as IHEADER. Return the index of this section or SHN_UNDEF if
1302 none can be found. Check's section HINT first, as this is likely
1303 to be the correct section. */
1306 find_link (const bfd *obfd, const Elf_Internal_Shdr *iheader,
1307 const unsigned int hint)
1309 Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd);
1312 BFD_ASSERT (iheader != NULL);
1314 /* See PR 20922 for a reproducer of the NULL test. */
1315 if (hint < elf_numsections (obfd)
1316 && oheaders[hint] != NULL
1317 && section_match (oheaders[hint], iheader))
1320 for (i = 1; i < elf_numsections (obfd); i++)
1322 Elf_Internal_Shdr * oheader = oheaders[i];
1324 if (oheader == NULL)
1326 if (section_match (oheader, iheader))
1327 /* FIXME: Do we care if there is a potential for
1328 multiple matches ? */
1335 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1336 Processor specific section, based upon a matching input section.
1337 Returns TRUE upon success, FALSE otherwise. */
1340 copy_special_section_fields (const bfd *ibfd,
1342 const Elf_Internal_Shdr *iheader,
1343 Elf_Internal_Shdr *oheader,
1344 const unsigned int secnum)
1346 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
1347 const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1348 bfd_boolean changed = FALSE;
1349 unsigned int sh_link;
1351 if (oheader->sh_type == SHT_NOBITS)
1353 /* This is a feature for objcopy --only-keep-debug:
1354 When a section's type is changed to NOBITS, we preserve
1355 the sh_link and sh_info fields so that they can be
1356 matched up with the original.
1358 Note: Strictly speaking these assignments are wrong.
1359 The sh_link and sh_info fields should point to the
1360 relevent sections in the output BFD, which may not be in
1361 the same location as they were in the input BFD. But
1362 the whole point of this action is to preserve the
1363 original values of the sh_link and sh_info fields, so
1364 that they can be matched up with the section headers in
1365 the original file. So strictly speaking we may be
1366 creating an invalid ELF file, but it is only for a file
1367 that just contains debug info and only for sections
1368 without any contents. */
1369 if (oheader->sh_link == 0)
1370 oheader->sh_link = iheader->sh_link;
1371 if (oheader->sh_info == 0)
1372 oheader->sh_info = iheader->sh_info;
1376 /* Allow the target a chance to decide how these fields should be set. */
1377 if (bed->elf_backend_copy_special_section_fields != NULL
1378 && bed->elf_backend_copy_special_section_fields
1379 (ibfd, obfd, iheader, oheader))
1382 /* We have an iheader which might match oheader, and which has non-zero
1383 sh_info and/or sh_link fields. Attempt to follow those links and find
1384 the section in the output bfd which corresponds to the linked section
1385 in the input bfd. */
1386 if (iheader->sh_link != SHN_UNDEF)
1388 /* See PR 20931 for a reproducer. */
1389 if (iheader->sh_link >= elf_numsections (ibfd))
1392 /* xgettext:c-format */
1393 (_("%pB: invalid sh_link field (%d) in section number %d"),
1394 ibfd, iheader->sh_link, secnum);
1398 sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link);
1399 if (sh_link != SHN_UNDEF)
1401 oheader->sh_link = sh_link;
1405 /* FIXME: Should we install iheader->sh_link
1406 if we could not find a match ? */
1408 /* xgettext:c-format */
1409 (_("%pB: failed to find link section for section %d"), obfd, secnum);
1412 if (iheader->sh_info)
1414 /* The sh_info field can hold arbitrary information, but if the
1415 SHF_LINK_INFO flag is set then it should be interpreted as a
1417 if (iheader->sh_flags & SHF_INFO_LINK)
1419 sh_link = find_link (obfd, iheaders[iheader->sh_info],
1421 if (sh_link != SHN_UNDEF)
1422 oheader->sh_flags |= SHF_INFO_LINK;
1425 /* No idea what it means - just copy it. */
1426 sh_link = iheader->sh_info;
1428 if (sh_link != SHN_UNDEF)
1430 oheader->sh_info = sh_link;
1435 /* xgettext:c-format */
1436 (_("%pB: failed to find info section for section %d"), obfd, secnum);
1442 /* Copy the program header and other data from one object module to
1446 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1448 const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1449 Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
1450 const struct elf_backend_data *bed;
1453 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1454 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1457 if (!elf_flags_init (obfd))
1459 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1460 elf_flags_init (obfd) = TRUE;
1463 elf_gp (obfd) = elf_gp (ibfd);
1465 /* Also copy the EI_OSABI field. */
1466 elf_elfheader (obfd)->e_ident[EI_OSABI] =
1467 elf_elfheader (ibfd)->e_ident[EI_OSABI];
1469 /* If set, copy the EI_ABIVERSION field. */
1470 if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION])
1471 elf_elfheader (obfd)->e_ident[EI_ABIVERSION]
1472 = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION];
1474 /* Copy object attributes. */
1475 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1477 if (iheaders == NULL || oheaders == NULL)
1480 bed = get_elf_backend_data (obfd);
1482 /* Possibly copy other fields in the section header. */
1483 for (i = 1; i < elf_numsections (obfd); i++)
1486 Elf_Internal_Shdr * oheader = oheaders[i];
1488 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1489 because of a special case need for generating separate debug info
1490 files. See below for more details. */
1492 || (oheader->sh_type != SHT_NOBITS
1493 && oheader->sh_type < SHT_LOOS))
1496 /* Ignore empty sections, and sections whose
1497 fields have already been initialised. */
1498 if (oheader->sh_size == 0
1499 || (oheader->sh_info != 0 && oheader->sh_link != 0))
1502 /* Scan for the matching section in the input bfd.
1503 First we try for a direct mapping between the input and output sections. */
1504 for (j = 1; j < elf_numsections (ibfd); j++)
1506 const Elf_Internal_Shdr * iheader = iheaders[j];
1508 if (iheader == NULL)
1511 if (oheader->bfd_section != NULL
1512 && iheader->bfd_section != NULL
1513 && iheader->bfd_section->output_section != NULL
1514 && iheader->bfd_section->output_section == oheader->bfd_section)
1516 /* We have found a connection from the input section to the
1517 output section. Attempt to copy the header fields. If
1518 this fails then do not try any further sections - there
1519 should only be a one-to-one mapping between input and output. */
1520 if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1521 j = elf_numsections (ibfd);
1526 if (j < elf_numsections (ibfd))
1529 /* That failed. So try to deduce the corresponding input section.
1530 Unfortunately we cannot compare names as the output string table
1531 is empty, so instead we check size, address and type. */
1532 for (j = 1; j < elf_numsections (ibfd); j++)
1534 const Elf_Internal_Shdr * iheader = iheaders[j];
1536 if (iheader == NULL)
1539 /* Try matching fields in the input section's header.
1540 Since --only-keep-debug turns all non-debug sections into
1541 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1543 if ((oheader->sh_type == SHT_NOBITS
1544 || iheader->sh_type == oheader->sh_type)
1545 && (iheader->sh_flags & ~ SHF_INFO_LINK)
1546 == (oheader->sh_flags & ~ SHF_INFO_LINK)
1547 && iheader->sh_addralign == oheader->sh_addralign
1548 && iheader->sh_entsize == oheader->sh_entsize
1549 && iheader->sh_size == oheader->sh_size
1550 && iheader->sh_addr == oheader->sh_addr
1551 && (iheader->sh_info != oheader->sh_info
1552 || iheader->sh_link != oheader->sh_link))
1554 if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1559 if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS)
1561 /* Final attempt. Call the backend copy function
1562 with a NULL input section. */
1563 if (bed->elf_backend_copy_special_section_fields != NULL)
1564 bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
1572 get_segment_type (unsigned int p_type)
1577 case PT_NULL: pt = "NULL"; break;
1578 case PT_LOAD: pt = "LOAD"; break;
1579 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1580 case PT_INTERP: pt = "INTERP"; break;
1581 case PT_NOTE: pt = "NOTE"; break;
1582 case PT_SHLIB: pt = "SHLIB"; break;
1583 case PT_PHDR: pt = "PHDR"; break;
1584 case PT_TLS: pt = "TLS"; break;
1585 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1586 case PT_GNU_STACK: pt = "STACK"; break;
1587 case PT_GNU_RELRO: pt = "RELRO"; break;
1588 default: pt = NULL; break;
1593 /* Print out the program headers. */
1596 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1598 FILE *f = (FILE *) farg;
1599 Elf_Internal_Phdr *p;
1601 bfd_byte *dynbuf = NULL;
1603 p = elf_tdata (abfd)->phdr;
1608 fprintf (f, _("\nProgram Header:\n"));
1609 c = elf_elfheader (abfd)->e_phnum;
1610 for (i = 0; i < c; i++, p++)
1612 const char *pt = get_segment_type (p->p_type);
1617 sprintf (buf, "0x%lx", p->p_type);
1620 fprintf (f, "%8s off 0x", pt);
1621 bfd_fprintf_vma (abfd, f, p->p_offset);
1622 fprintf (f, " vaddr 0x");
1623 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1624 fprintf (f, " paddr 0x");
1625 bfd_fprintf_vma (abfd, f, p->p_paddr);
1626 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1627 fprintf (f, " filesz 0x");
1628 bfd_fprintf_vma (abfd, f, p->p_filesz);
1629 fprintf (f, " memsz 0x");
1630 bfd_fprintf_vma (abfd, f, p->p_memsz);
1631 fprintf (f, " flags %c%c%c",
1632 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1633 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1634 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1635 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1636 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1641 s = bfd_get_section_by_name (abfd, ".dynamic");
1644 unsigned int elfsec;
1645 unsigned long shlink;
1646 bfd_byte *extdyn, *extdynend;
1648 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1650 fprintf (f, _("\nDynamic Section:\n"));
1652 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1655 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1656 if (elfsec == SHN_BAD)
1658 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1660 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1661 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1664 /* PR 17512: file: 6f427532. */
1665 if (s->size < extdynsize)
1667 extdynend = extdyn + s->size;
1668 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1670 for (; extdyn <= (extdynend - extdynsize); extdyn += extdynsize)
1672 Elf_Internal_Dyn dyn;
1673 const char *name = "";
1675 bfd_boolean stringp;
1676 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1678 (*swap_dyn_in) (abfd, extdyn, &dyn);
1680 if (dyn.d_tag == DT_NULL)
1687 if (bed->elf_backend_get_target_dtag)
1688 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1690 if (!strcmp (name, ""))
1692 sprintf (ab, "%#" BFD_VMA_FMT "x", dyn.d_tag);
1697 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1698 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1699 case DT_PLTGOT: name = "PLTGOT"; break;
1700 case DT_HASH: name = "HASH"; break;
1701 case DT_STRTAB: name = "STRTAB"; break;
1702 case DT_SYMTAB: name = "SYMTAB"; break;
1703 case DT_RELA: name = "RELA"; break;
1704 case DT_RELASZ: name = "RELASZ"; break;
1705 case DT_RELAENT: name = "RELAENT"; break;
1706 case DT_STRSZ: name = "STRSZ"; break;
1707 case DT_SYMENT: name = "SYMENT"; break;
1708 case DT_INIT: name = "INIT"; break;
1709 case DT_FINI: name = "FINI"; break;
1710 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1711 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1712 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1713 case DT_REL: name = "REL"; break;
1714 case DT_RELSZ: name = "RELSZ"; break;
1715 case DT_RELENT: name = "RELENT"; break;
1716 case DT_PLTREL: name = "PLTREL"; break;
1717 case DT_DEBUG: name = "DEBUG"; break;
1718 case DT_TEXTREL: name = "TEXTREL"; break;
1719 case DT_JMPREL: name = "JMPREL"; break;
1720 case DT_BIND_NOW: name = "BIND_NOW"; break;
1721 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1722 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1723 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1724 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1725 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1726 case DT_FLAGS: name = "FLAGS"; break;
1727 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1728 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1729 case DT_CHECKSUM: name = "CHECKSUM"; break;
1730 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1731 case DT_MOVEENT: name = "MOVEENT"; break;
1732 case DT_MOVESZ: name = "MOVESZ"; break;
1733 case DT_FEATURE: name = "FEATURE"; break;
1734 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1735 case DT_SYMINSZ: name = "SYMINSZ"; break;
1736 case DT_SYMINENT: name = "SYMINENT"; break;
1737 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1738 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1739 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1740 case DT_PLTPAD: name = "PLTPAD"; break;
1741 case DT_MOVETAB: name = "MOVETAB"; break;
1742 case DT_SYMINFO: name = "SYMINFO"; break;
1743 case DT_RELACOUNT: name = "RELACOUNT"; break;
1744 case DT_RELCOUNT: name = "RELCOUNT"; break;
1745 case DT_FLAGS_1: name = "FLAGS_1"; break;
1746 case DT_VERSYM: name = "VERSYM"; break;
1747 case DT_VERDEF: name = "VERDEF"; break;
1748 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1749 case DT_VERNEED: name = "VERNEED"; break;
1750 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1751 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1752 case DT_USED: name = "USED"; break;
1753 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1754 case DT_GNU_HASH: name = "GNU_HASH"; break;
1757 fprintf (f, " %-20s ", name);
1761 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1766 unsigned int tagv = dyn.d_un.d_val;
1768 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1771 fprintf (f, "%s", string);
1780 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1781 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1783 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1787 if (elf_dynverdef (abfd) != 0)
1789 Elf_Internal_Verdef *t;
1791 fprintf (f, _("\nVersion definitions:\n"));
1792 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1794 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1795 t->vd_flags, t->vd_hash,
1796 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1797 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1799 Elf_Internal_Verdaux *a;
1802 for (a = t->vd_auxptr->vda_nextptr;
1806 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1812 if (elf_dynverref (abfd) != 0)
1814 Elf_Internal_Verneed *t;
1816 fprintf (f, _("\nVersion References:\n"));
1817 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1819 Elf_Internal_Vernaux *a;
1821 fprintf (f, _(" required from %s:\n"),
1822 t->vn_filename ? t->vn_filename : "<corrupt>");
1823 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1824 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1825 a->vna_flags, a->vna_other,
1826 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1838 /* Get version string. */
1841 _bfd_elf_get_symbol_version_string (bfd *abfd, asymbol *symbol,
1842 bfd_boolean *hidden)
1844 const char *version_string = NULL;
1845 if (elf_dynversym (abfd) != 0
1846 && (elf_dynverdef (abfd) != 0 || elf_dynverref (abfd) != 0))
1848 unsigned int vernum = ((elf_symbol_type *) symbol)->version;
1850 *hidden = (vernum & VERSYM_HIDDEN) != 0;
1851 vernum &= VERSYM_VERSION;
1854 version_string = "";
1855 else if (vernum == 1)
1856 version_string = "Base";
1857 else if (vernum <= elf_tdata (abfd)->cverdefs)
1859 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1862 Elf_Internal_Verneed *t;
1864 version_string = "";
1865 for (t = elf_tdata (abfd)->verref;
1869 Elf_Internal_Vernaux *a;
1871 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1873 if (a->vna_other == vernum)
1875 version_string = a->vna_nodename;
1882 return version_string;
1885 /* Display ELF-specific fields of a symbol. */
1888 bfd_elf_print_symbol (bfd *abfd,
1891 bfd_print_symbol_type how)
1893 FILE *file = (FILE *) filep;
1896 case bfd_print_symbol_name:
1897 fprintf (file, "%s", symbol->name);
1899 case bfd_print_symbol_more:
1900 fprintf (file, "elf ");
1901 bfd_fprintf_vma (abfd, file, symbol->value);
1902 fprintf (file, " %x", symbol->flags);
1904 case bfd_print_symbol_all:
1906 const char *section_name;
1907 const char *name = NULL;
1908 const struct elf_backend_data *bed;
1909 unsigned char st_other;
1911 const char *version_string;
1914 section_name = symbol->section ? symbol->section->name : "(*none*)";
1916 bed = get_elf_backend_data (abfd);
1917 if (bed->elf_backend_print_symbol_all)
1918 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1922 name = symbol->name;
1923 bfd_print_symbol_vandf (abfd, file, symbol);
1926 fprintf (file, " %s\t", section_name);
1927 /* Print the "other" value for a symbol. For common symbols,
1928 we've already printed the size; now print the alignment.
1929 For other symbols, we have no specified alignment, and
1930 we've printed the address; now print the size. */
1931 if (symbol->section && bfd_is_com_section (symbol->section))
1932 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1934 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1935 bfd_fprintf_vma (abfd, file, val);
1937 /* If we have version information, print it. */
1938 version_string = _bfd_elf_get_symbol_version_string (abfd,
1944 fprintf (file, " %-11s", version_string);
1949 fprintf (file, " (%s)", version_string);
1950 for (i = 10 - strlen (version_string); i > 0; --i)
1955 /* If the st_other field is not zero, print it. */
1956 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1961 case STV_INTERNAL: fprintf (file, " .internal"); break;
1962 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1963 case STV_PROTECTED: fprintf (file, " .protected"); break;
1965 /* Some other non-defined flags are also present, so print
1967 fprintf (file, " 0x%02x", (unsigned int) st_other);
1970 fprintf (file, " %s", name);
1976 /* ELF .o/exec file reading */
1978 /* Create a new bfd section from an ELF section header. */
1981 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1983 Elf_Internal_Shdr *hdr;
1984 Elf_Internal_Ehdr *ehdr;
1985 const struct elf_backend_data *bed;
1987 bfd_boolean ret = TRUE;
1988 static bfd_boolean * sections_being_created = NULL;
1989 static bfd * sections_being_created_abfd = NULL;
1990 static unsigned int nesting = 0;
1992 if (shindex >= elf_numsections (abfd))
1997 /* PR17512: A corrupt ELF binary might contain a recursive group of
1998 sections, with each the string indicies pointing to the next in the
1999 loop. Detect this here, by refusing to load a section that we are
2000 already in the process of loading. We only trigger this test if
2001 we have nested at least three sections deep as normal ELF binaries
2002 can expect to recurse at least once.
2004 FIXME: It would be better if this array was attached to the bfd,
2005 rather than being held in a static pointer. */
2007 if (sections_being_created_abfd != abfd)
2008 sections_being_created = NULL;
2009 if (sections_being_created == NULL)
2011 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
2012 sections_being_created = (bfd_boolean *)
2013 bfd_zalloc (abfd, elf_numsections (abfd) * sizeof (bfd_boolean));
2014 sections_being_created_abfd = abfd;
2016 if (sections_being_created [shindex])
2019 (_("%pB: warning: loop in section dependencies detected"), abfd);
2022 sections_being_created [shindex] = TRUE;
2025 hdr = elf_elfsections (abfd)[shindex];
2026 ehdr = elf_elfheader (abfd);
2027 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
2032 bed = get_elf_backend_data (abfd);
2033 switch (hdr->sh_type)
2036 /* Inactive section. Throw it away. */
2039 case SHT_PROGBITS: /* Normal section with contents. */
2040 case SHT_NOBITS: /* .bss section. */
2041 case SHT_HASH: /* .hash section. */
2042 case SHT_NOTE: /* .note section. */
2043 case SHT_INIT_ARRAY: /* .init_array section. */
2044 case SHT_FINI_ARRAY: /* .fini_array section. */
2045 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
2046 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
2047 case SHT_GNU_HASH: /* .gnu.hash section. */
2048 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2051 case SHT_DYNAMIC: /* Dynamic linking information. */
2052 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2055 if (hdr->sh_link > elf_numsections (abfd))
2057 /* PR 10478: Accept Solaris binaries with a sh_link
2058 field set to SHN_BEFORE or SHN_AFTER. */
2059 switch (bfd_get_arch (abfd))
2062 case bfd_arch_sparc:
2063 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
2064 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
2066 /* Otherwise fall through. */
2071 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
2073 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
2075 Elf_Internal_Shdr *dynsymhdr;
2077 /* The shared libraries distributed with hpux11 have a bogus
2078 sh_link field for the ".dynamic" section. Find the
2079 string table for the ".dynsym" section instead. */
2080 if (elf_dynsymtab (abfd) != 0)
2082 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
2083 hdr->sh_link = dynsymhdr->sh_link;
2087 unsigned int i, num_sec;
2089 num_sec = elf_numsections (abfd);
2090 for (i = 1; i < num_sec; i++)
2092 dynsymhdr = elf_elfsections (abfd)[i];
2093 if (dynsymhdr->sh_type == SHT_DYNSYM)
2095 hdr->sh_link = dynsymhdr->sh_link;
2103 case SHT_SYMTAB: /* A symbol table. */
2104 if (elf_onesymtab (abfd) == shindex)
2107 if (hdr->sh_entsize != bed->s->sizeof_sym)
2110 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2112 if (hdr->sh_size != 0)
2114 /* Some assemblers erroneously set sh_info to one with a
2115 zero sh_size. ld sees this as a global symbol count
2116 of (unsigned) -1. Fix it here. */
2121 /* PR 18854: A binary might contain more than one symbol table.
2122 Unusual, but possible. Warn, but continue. */
2123 if (elf_onesymtab (abfd) != 0)
2126 /* xgettext:c-format */
2127 (_("%pB: warning: multiple symbol tables detected"
2128 " - ignoring the table in section %u"),
2132 elf_onesymtab (abfd) = shindex;
2133 elf_symtab_hdr (abfd) = *hdr;
2134 elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
2135 abfd->flags |= HAS_SYMS;
2137 /* Sometimes a shared object will map in the symbol table. If
2138 SHF_ALLOC is set, and this is a shared object, then we also
2139 treat this section as a BFD section. We can not base the
2140 decision purely on SHF_ALLOC, because that flag is sometimes
2141 set in a relocatable object file, which would confuse the
2143 if ((hdr->sh_flags & SHF_ALLOC) != 0
2144 && (abfd->flags & DYNAMIC) != 0
2145 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2149 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2150 can't read symbols without that section loaded as well. It
2151 is most likely specified by the next section header. */
2153 elf_section_list * entry;
2154 unsigned int i, num_sec;
2156 for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2157 if (entry->hdr.sh_link == shindex)
2160 num_sec = elf_numsections (abfd);
2161 for (i = shindex + 1; i < num_sec; i++)
2163 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2165 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2166 && hdr2->sh_link == shindex)
2171 for (i = 1; i < shindex; i++)
2173 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2175 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2176 && hdr2->sh_link == shindex)
2181 ret = bfd_section_from_shdr (abfd, i);
2182 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2186 case SHT_DYNSYM: /* A dynamic symbol table. */
2187 if (elf_dynsymtab (abfd) == shindex)
2190 if (hdr->sh_entsize != bed->s->sizeof_sym)
2193 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2195 if (hdr->sh_size != 0)
2198 /* Some linkers erroneously set sh_info to one with a
2199 zero sh_size. ld sees this as a global symbol count
2200 of (unsigned) -1. Fix it here. */
2205 /* PR 18854: A binary might contain more than one dynamic symbol table.
2206 Unusual, but possible. Warn, but continue. */
2207 if (elf_dynsymtab (abfd) != 0)
2210 /* xgettext:c-format */
2211 (_("%pB: warning: multiple dynamic symbol tables detected"
2212 " - ignoring the table in section %u"),
2216 elf_dynsymtab (abfd) = shindex;
2217 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
2218 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2219 abfd->flags |= HAS_SYMS;
2221 /* Besides being a symbol table, we also treat this as a regular
2222 section, so that objcopy can handle it. */
2223 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2226 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections. */
2228 elf_section_list * entry;
2230 for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2231 if (entry->ndx == shindex)
2234 entry = bfd_alloc (abfd, sizeof * entry);
2237 entry->ndx = shindex;
2239 entry->next = elf_symtab_shndx_list (abfd);
2240 elf_symtab_shndx_list (abfd) = entry;
2241 elf_elfsections (abfd)[shindex] = & entry->hdr;
2245 case SHT_STRTAB: /* A string table. */
2246 if (hdr->bfd_section != NULL)
2249 if (ehdr->e_shstrndx == shindex)
2251 elf_tdata (abfd)->shstrtab_hdr = *hdr;
2252 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
2256 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
2259 elf_tdata (abfd)->strtab_hdr = *hdr;
2260 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
2264 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2267 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2268 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2269 elf_elfsections (abfd)[shindex] = hdr;
2270 /* We also treat this as a regular section, so that objcopy
2272 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2277 /* If the string table isn't one of the above, then treat it as a
2278 regular section. We need to scan all the headers to be sure,
2279 just in case this strtab section appeared before the above. */
2280 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2282 unsigned int i, num_sec;
2284 num_sec = elf_numsections (abfd);
2285 for (i = 1; i < num_sec; i++)
2287 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2288 if (hdr2->sh_link == shindex)
2290 /* Prevent endless recursion on broken objects. */
2293 if (! bfd_section_from_shdr (abfd, i))
2295 if (elf_onesymtab (abfd) == i)
2297 if (elf_dynsymtab (abfd) == i)
2298 goto dynsymtab_strtab;
2302 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2307 /* *These* do a lot of work -- but build no sections! */
2309 asection *target_sect;
2310 Elf_Internal_Shdr *hdr2, **p_hdr;
2311 unsigned int num_sec = elf_numsections (abfd);
2312 struct bfd_elf_section_data *esdt;
2315 != (bfd_size_type) (hdr->sh_type == SHT_REL
2316 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
2319 /* Check for a bogus link to avoid crashing. */
2320 if (hdr->sh_link >= num_sec)
2323 /* xgettext:c-format */
2324 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2325 abfd, hdr->sh_link, name, shindex);
2326 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2331 /* For some incomprehensible reason Oracle distributes
2332 libraries for Solaris in which some of the objects have
2333 bogus sh_link fields. It would be nice if we could just
2334 reject them, but, unfortunately, some people need to use
2335 them. We scan through the section headers; if we find only
2336 one suitable symbol table, we clobber the sh_link to point
2337 to it. I hope this doesn't break anything.
2339 Don't do it on executable nor shared library. */
2340 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
2341 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2342 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2348 for (scan = 1; scan < num_sec; scan++)
2350 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2351 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2362 hdr->sh_link = found;
2365 /* Get the symbol table. */
2366 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2367 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2368 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2371 /* If this reloc section does not use the main symbol table we
2372 don't treat it as a reloc section. BFD can't adequately
2373 represent such a section, so at least for now, we don't
2374 try. We just present it as a normal section. We also
2375 can't use it as a reloc section if it points to the null
2376 section, an invalid section, another reloc section, or its
2377 sh_link points to the null section. */
2378 if (hdr->sh_link != elf_onesymtab (abfd)
2379 || hdr->sh_link == SHN_UNDEF
2380 || hdr->sh_info == SHN_UNDEF
2381 || hdr->sh_info >= num_sec
2382 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2383 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2385 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2390 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2393 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2394 if (target_sect == NULL)
2397 esdt = elf_section_data (target_sect);
2398 if (hdr->sh_type == SHT_RELA)
2399 p_hdr = &esdt->rela.hdr;
2401 p_hdr = &esdt->rel.hdr;
2403 /* PR 17512: file: 0b4f81b7. */
2406 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
2411 elf_elfsections (abfd)[shindex] = hdr2;
2412 target_sect->reloc_count += (NUM_SHDR_ENTRIES (hdr)
2413 * bed->s->int_rels_per_ext_rel);
2414 target_sect->flags |= SEC_RELOC;
2415 target_sect->relocation = NULL;
2416 target_sect->rel_filepos = hdr->sh_offset;
2417 /* In the section to which the relocations apply, mark whether
2418 its relocations are of the REL or RELA variety. */
2419 if (hdr->sh_size != 0)
2421 if (hdr->sh_type == SHT_RELA)
2422 target_sect->use_rela_p = 1;
2424 abfd->flags |= HAS_RELOC;
2428 case SHT_GNU_verdef:
2429 elf_dynverdef (abfd) = shindex;
2430 elf_tdata (abfd)->dynverdef_hdr = *hdr;
2431 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2434 case SHT_GNU_versym:
2435 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2438 elf_dynversym (abfd) = shindex;
2439 elf_tdata (abfd)->dynversym_hdr = *hdr;
2440 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2443 case SHT_GNU_verneed:
2444 elf_dynverref (abfd) = shindex;
2445 elf_tdata (abfd)->dynverref_hdr = *hdr;
2446 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2453 if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
2456 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2462 /* Possibly an attributes section. */
2463 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2464 || hdr->sh_type == bed->obj_attrs_section_type)
2466 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2468 _bfd_elf_parse_attributes (abfd, hdr);
2472 /* Check for any processor-specific section types. */
2473 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2476 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2478 if ((hdr->sh_flags & SHF_ALLOC) != 0)
2479 /* FIXME: How to properly handle allocated section reserved
2480 for applications? */
2482 /* xgettext:c-format */
2483 (_("%pB: unknown type [%#x] section `%s'"),
2484 abfd, hdr->sh_type, name);
2487 /* Allow sections reserved for applications. */
2488 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2493 else if (hdr->sh_type >= SHT_LOPROC
2494 && hdr->sh_type <= SHT_HIPROC)
2495 /* FIXME: We should handle this section. */
2497 /* xgettext:c-format */
2498 (_("%pB: unknown type [%#x] section `%s'"),
2499 abfd, hdr->sh_type, name);
2500 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2502 /* Unrecognised OS-specific sections. */
2503 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2504 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2505 required to correctly process the section and the file should
2506 be rejected with an error message. */
2508 /* xgettext:c-format */
2509 (_("%pB: unknown type [%#x] section `%s'"),
2510 abfd, hdr->sh_type, name);
2513 /* Otherwise it should be processed. */
2514 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2519 /* FIXME: We should handle this section. */
2521 /* xgettext:c-format */
2522 (_("%pB: unknown type [%#x] section `%s'"),
2523 abfd, hdr->sh_type, name);
2531 if (sections_being_created && sections_being_created_abfd == abfd)
2532 sections_being_created [shindex] = FALSE;
2533 if (-- nesting == 0)
2535 sections_being_created = NULL;
2536 sections_being_created_abfd = abfd;
2541 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2544 bfd_sym_from_r_symndx (struct sym_cache *cache,
2546 unsigned long r_symndx)
2548 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2550 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2552 Elf_Internal_Shdr *symtab_hdr;
2553 unsigned char esym[sizeof (Elf64_External_Sym)];
2554 Elf_External_Sym_Shndx eshndx;
2556 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2557 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2558 &cache->sym[ent], esym, &eshndx) == NULL)
2561 if (cache->abfd != abfd)
2563 memset (cache->indx, -1, sizeof (cache->indx));
2566 cache->indx[ent] = r_symndx;
2569 return &cache->sym[ent];
2572 /* Given an ELF section number, retrieve the corresponding BFD
2576 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2578 if (sec_index >= elf_numsections (abfd))
2580 return elf_elfsections (abfd)[sec_index]->bfd_section;
2583 static const struct bfd_elf_special_section special_sections_b[] =
2585 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2586 { NULL, 0, 0, 0, 0 }
2589 static const struct bfd_elf_special_section special_sections_c[] =
2591 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2592 { NULL, 0, 0, 0, 0 }
2595 static const struct bfd_elf_special_section special_sections_d[] =
2597 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2598 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2599 /* There are more DWARF sections than these, but they needn't be added here
2600 unless you have to cope with broken compilers that don't emit section
2601 attributes or you want to help the user writing assembler. */
2602 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2603 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2604 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2605 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2606 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2607 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2608 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2609 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2610 { NULL, 0, 0, 0, 0 }
2613 static const struct bfd_elf_special_section special_sections_f[] =
2615 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2616 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2617 { NULL, 0 , 0, 0, 0 }
2620 static const struct bfd_elf_special_section special_sections_g[] =
2622 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2623 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE },
2624 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2625 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2626 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2627 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2628 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2629 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2630 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2631 { NULL, 0, 0, 0, 0 }
2634 static const struct bfd_elf_special_section special_sections_h[] =
2636 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2637 { NULL, 0, 0, 0, 0 }
2640 static const struct bfd_elf_special_section special_sections_i[] =
2642 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2643 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2644 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2645 { NULL, 0, 0, 0, 0 }
2648 static const struct bfd_elf_special_section special_sections_l[] =
2650 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2651 { NULL, 0, 0, 0, 0 }
2654 static const struct bfd_elf_special_section special_sections_n[] =
2656 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2657 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2658 { NULL, 0, 0, 0, 0 }
2661 static const struct bfd_elf_special_section special_sections_p[] =
2663 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2664 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2665 { NULL, 0, 0, 0, 0 }
2668 static const struct bfd_elf_special_section special_sections_r[] =
2670 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2671 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2672 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2673 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2674 { NULL, 0, 0, 0, 0 }
2677 static const struct bfd_elf_special_section special_sections_s[] =
2679 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2680 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2681 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2682 /* See struct bfd_elf_special_section declaration for the semantics of
2683 this special case where .prefix_length != strlen (.prefix). */
2684 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2685 { NULL, 0, 0, 0, 0 }
2688 static const struct bfd_elf_special_section special_sections_t[] =
2690 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2691 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2692 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2693 { NULL, 0, 0, 0, 0 }
2696 static const struct bfd_elf_special_section special_sections_z[] =
2698 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2699 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2700 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2701 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2702 { NULL, 0, 0, 0, 0 }
2705 static const struct bfd_elf_special_section * const special_sections[] =
2707 special_sections_b, /* 'b' */
2708 special_sections_c, /* 'c' */
2709 special_sections_d, /* 'd' */
2711 special_sections_f, /* 'f' */
2712 special_sections_g, /* 'g' */
2713 special_sections_h, /* 'h' */
2714 special_sections_i, /* 'i' */
2717 special_sections_l, /* 'l' */
2719 special_sections_n, /* 'n' */
2721 special_sections_p, /* 'p' */
2723 special_sections_r, /* 'r' */
2724 special_sections_s, /* 's' */
2725 special_sections_t, /* 't' */
2731 special_sections_z /* 'z' */
2734 const struct bfd_elf_special_section *
2735 _bfd_elf_get_special_section (const char *name,
2736 const struct bfd_elf_special_section *spec,
2742 len = strlen (name);
2744 for (i = 0; spec[i].prefix != NULL; i++)
2747 int prefix_len = spec[i].prefix_length;
2749 if (len < prefix_len)
2751 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2754 suffix_len = spec[i].suffix_length;
2755 if (suffix_len <= 0)
2757 if (name[prefix_len] != 0)
2759 if (suffix_len == 0)
2761 if (name[prefix_len] != '.'
2762 && (suffix_len == -2
2763 || (rela && spec[i].type == SHT_REL)))
2769 if (len < prefix_len + suffix_len)
2771 if (memcmp (name + len - suffix_len,
2772 spec[i].prefix + prefix_len,
2782 const struct bfd_elf_special_section *
2783 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2786 const struct bfd_elf_special_section *spec;
2787 const struct elf_backend_data *bed;
2789 /* See if this is one of the special sections. */
2790 if (sec->name == NULL)
2793 bed = get_elf_backend_data (abfd);
2794 spec = bed->special_sections;
2797 spec = _bfd_elf_get_special_section (sec->name,
2798 bed->special_sections,
2804 if (sec->name[0] != '.')
2807 i = sec->name[1] - 'b';
2808 if (i < 0 || i > 'z' - 'b')
2811 spec = special_sections[i];
2816 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2820 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2822 struct bfd_elf_section_data *sdata;
2823 const struct elf_backend_data *bed;
2824 const struct bfd_elf_special_section *ssect;
2826 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2829 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2833 sec->used_by_bfd = sdata;
2836 /* Indicate whether or not this section should use RELA relocations. */
2837 bed = get_elf_backend_data (abfd);
2838 sec->use_rela_p = bed->default_use_rela_p;
2840 /* When we read a file, we don't need to set ELF section type and
2841 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2842 anyway. We will set ELF section type and flags for all linker
2843 created sections. If user specifies BFD section flags, we will
2844 set ELF section type and flags based on BFD section flags in
2845 elf_fake_sections. Special handling for .init_array/.fini_array
2846 output sections since they may contain .ctors/.dtors input
2847 sections. We don't want _bfd_elf_init_private_section_data to
2848 copy ELF section type from .ctors/.dtors input sections. */
2849 if (abfd->direction != read_direction
2850 || (sec->flags & SEC_LINKER_CREATED) != 0)
2852 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2855 || (sec->flags & SEC_LINKER_CREATED) != 0
2856 || ssect->type == SHT_INIT_ARRAY
2857 || ssect->type == SHT_FINI_ARRAY))
2859 elf_section_type (sec) = ssect->type;
2860 elf_section_flags (sec) = ssect->attr;
2864 return _bfd_generic_new_section_hook (abfd, sec);
2867 /* Create a new bfd section from an ELF program header.
2869 Since program segments have no names, we generate a synthetic name
2870 of the form segment<NUM>, where NUM is generally the index in the
2871 program header table. For segments that are split (see below) we
2872 generate the names segment<NUM>a and segment<NUM>b.
2874 Note that some program segments may have a file size that is different than
2875 (less than) the memory size. All this means is that at execution the
2876 system must allocate the amount of memory specified by the memory size,
2877 but only initialize it with the first "file size" bytes read from the
2878 file. This would occur for example, with program segments consisting
2879 of combined data+bss.
2881 To handle the above situation, this routine generates TWO bfd sections
2882 for the single program segment. The first has the length specified by
2883 the file size of the segment, and the second has the length specified
2884 by the difference between the two sizes. In effect, the segment is split
2885 into its initialized and uninitialized parts.
2890 _bfd_elf_make_section_from_phdr (bfd *abfd,
2891 Elf_Internal_Phdr *hdr,
2893 const char *type_name)
2901 split = ((hdr->p_memsz > 0)
2902 && (hdr->p_filesz > 0)
2903 && (hdr->p_memsz > hdr->p_filesz));
2905 if (hdr->p_filesz > 0)
2907 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2908 len = strlen (namebuf) + 1;
2909 name = (char *) bfd_alloc (abfd, len);
2912 memcpy (name, namebuf, len);
2913 newsect = bfd_make_section (abfd, name);
2914 if (newsect == NULL)
2916 newsect->vma = hdr->p_vaddr;
2917 newsect->lma = hdr->p_paddr;
2918 newsect->size = hdr->p_filesz;
2919 newsect->filepos = hdr->p_offset;
2920 newsect->flags |= SEC_HAS_CONTENTS;
2921 newsect->alignment_power = bfd_log2 (hdr->p_align);
2922 if (hdr->p_type == PT_LOAD)
2924 newsect->flags |= SEC_ALLOC;
2925 newsect->flags |= SEC_LOAD;
2926 if (hdr->p_flags & PF_X)
2928 /* FIXME: all we known is that it has execute PERMISSION,
2930 newsect->flags |= SEC_CODE;
2933 if (!(hdr->p_flags & PF_W))
2935 newsect->flags |= SEC_READONLY;
2939 if (hdr->p_memsz > hdr->p_filesz)
2943 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2944 len = strlen (namebuf) + 1;
2945 name = (char *) bfd_alloc (abfd, len);
2948 memcpy (name, namebuf, len);
2949 newsect = bfd_make_section (abfd, name);
2950 if (newsect == NULL)
2952 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2953 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2954 newsect->size = hdr->p_memsz - hdr->p_filesz;
2955 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2956 align = newsect->vma & -newsect->vma;
2957 if (align == 0 || align > hdr->p_align)
2958 align = hdr->p_align;
2959 newsect->alignment_power = bfd_log2 (align);
2960 if (hdr->p_type == PT_LOAD)
2962 /* Hack for gdb. Segments that have not been modified do
2963 not have their contents written to a core file, on the
2964 assumption that a debugger can find the contents in the
2965 executable. We flag this case by setting the fake
2966 section size to zero. Note that "real" bss sections will
2967 always have their contents dumped to the core file. */
2968 if (bfd_get_format (abfd) == bfd_core)
2970 newsect->flags |= SEC_ALLOC;
2971 if (hdr->p_flags & PF_X)
2972 newsect->flags |= SEC_CODE;
2974 if (!(hdr->p_flags & PF_W))
2975 newsect->flags |= SEC_READONLY;
2982 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2984 const struct elf_backend_data *bed;
2986 switch (hdr->p_type)
2989 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2992 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2995 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2998 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
3001 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
3003 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz,
3009 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
3012 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
3014 case PT_GNU_EH_FRAME:
3015 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
3019 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
3022 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
3025 /* Check for any processor-specific program segment types. */
3026 bed = get_elf_backend_data (abfd);
3027 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
3031 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3035 _bfd_elf_single_rel_hdr (asection *sec)
3037 if (elf_section_data (sec)->rel.hdr)
3039 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
3040 return elf_section_data (sec)->rel.hdr;
3043 return elf_section_data (sec)->rela.hdr;
3047 _bfd_elf_set_reloc_sh_name (bfd *abfd,
3048 Elf_Internal_Shdr *rel_hdr,
3049 const char *sec_name,
3050 bfd_boolean use_rela_p)
3052 char *name = (char *) bfd_alloc (abfd,
3053 sizeof ".rela" + strlen (sec_name));
3057 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
3059 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
3061 if (rel_hdr->sh_name == (unsigned int) -1)
3067 /* Allocate and initialize a section-header for a new reloc section,
3068 containing relocations against ASECT. It is stored in RELDATA. If
3069 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3073 _bfd_elf_init_reloc_shdr (bfd *abfd,
3074 struct bfd_elf_section_reloc_data *reldata,
3075 const char *sec_name,
3076 bfd_boolean use_rela_p,
3077 bfd_boolean delay_st_name_p)
3079 Elf_Internal_Shdr *rel_hdr;
3080 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3082 BFD_ASSERT (reldata->hdr == NULL);
3083 rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
3084 reldata->hdr = rel_hdr;
3086 if (delay_st_name_p)
3087 rel_hdr->sh_name = (unsigned int) -1;
3088 else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
3091 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
3092 rel_hdr->sh_entsize = (use_rela_p
3093 ? bed->s->sizeof_rela
3094 : bed->s->sizeof_rel);
3095 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
3096 rel_hdr->sh_flags = 0;
3097 rel_hdr->sh_addr = 0;
3098 rel_hdr->sh_size = 0;
3099 rel_hdr->sh_offset = 0;
3104 /* Return the default section type based on the passed in section flags. */
3107 bfd_elf_get_default_section_type (flagword flags)
3109 if ((flags & SEC_ALLOC) != 0
3110 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3112 return SHT_PROGBITS;
3115 struct fake_section_arg
3117 struct bfd_link_info *link_info;
3121 /* Set up an ELF internal section header for a section. */
3124 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
3126 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
3127 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3128 struct bfd_elf_section_data *esd = elf_section_data (asect);
3129 Elf_Internal_Shdr *this_hdr;
3130 unsigned int sh_type;
3131 const char *name = asect->name;
3132 bfd_boolean delay_st_name_p = FALSE;
3136 /* We already failed; just get out of the bfd_map_over_sections
3141 this_hdr = &esd->this_hdr;
3145 /* ld: compress DWARF debug sections with names: .debug_*. */
3146 if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
3147 && (asect->flags & SEC_DEBUGGING)
3151 /* Set SEC_ELF_COMPRESS to indicate this section should be
3153 asect->flags |= SEC_ELF_COMPRESS;
3155 /* If this section will be compressed, delay adding section
3156 name to section name section after it is compressed in
3157 _bfd_elf_assign_file_positions_for_non_load. */
3158 delay_st_name_p = TRUE;
3161 else if ((asect->flags & SEC_ELF_RENAME))
3163 /* objcopy: rename output DWARF debug section. */
3164 if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
3166 /* When we decompress or compress with SHF_COMPRESSED,
3167 convert section name from .zdebug_* to .debug_* if
3171 char *new_name = convert_zdebug_to_debug (abfd, name);
3172 if (new_name == NULL)
3180 else if (asect->compress_status == COMPRESS_SECTION_DONE)
3182 /* PR binutils/18087: Compression does not always make a
3183 section smaller. So only rename the section when
3184 compression has actually taken place. If input section
3185 name is .zdebug_*, we should never compress it again. */
3186 char *new_name = convert_debug_to_zdebug (abfd, name);
3187 if (new_name == NULL)
3192 BFD_ASSERT (name[1] != 'z');
3197 if (delay_st_name_p)
3198 this_hdr->sh_name = (unsigned int) -1;
3202 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3204 if (this_hdr->sh_name == (unsigned int) -1)
3211 /* Don't clear sh_flags. Assembler may set additional bits. */
3213 if ((asect->flags & SEC_ALLOC) != 0
3214 || asect->user_set_vma)
3215 this_hdr->sh_addr = asect->vma;
3217 this_hdr->sh_addr = 0;
3219 this_hdr->sh_offset = 0;
3220 this_hdr->sh_size = asect->size;
3221 this_hdr->sh_link = 0;
3222 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3223 if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
3226 /* xgettext:c-format */
3227 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3228 abfd, asect->alignment_power, asect);
3232 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
3233 /* The sh_entsize and sh_info fields may have been set already by
3234 copy_private_section_data. */
3236 this_hdr->bfd_section = asect;
3237 this_hdr->contents = NULL;
3239 /* If the section type is unspecified, we set it based on
3241 if ((asect->flags & SEC_GROUP) != 0)
3242 sh_type = SHT_GROUP;
3244 sh_type = bfd_elf_get_default_section_type (asect->flags);
3246 if (this_hdr->sh_type == SHT_NULL)
3247 this_hdr->sh_type = sh_type;
3248 else if (this_hdr->sh_type == SHT_NOBITS
3249 && sh_type == SHT_PROGBITS
3250 && (asect->flags & SEC_ALLOC) != 0)
3252 /* Warn if we are changing a NOBITS section to PROGBITS, but
3253 allow the link to proceed. This can happen when users link
3254 non-bss input sections to bss output sections, or emit data
3255 to a bss output section via a linker script. */
3257 (_("warning: section `%pA' type changed to PROGBITS"), asect);
3258 this_hdr->sh_type = sh_type;
3261 switch (this_hdr->sh_type)
3272 case SHT_INIT_ARRAY:
3273 case SHT_FINI_ARRAY:
3274 case SHT_PREINIT_ARRAY:
3275 this_hdr->sh_entsize = bed->s->arch_size / 8;
3279 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
3283 this_hdr->sh_entsize = bed->s->sizeof_sym;
3287 this_hdr->sh_entsize = bed->s->sizeof_dyn;
3291 if (get_elf_backend_data (abfd)->may_use_rela_p)
3292 this_hdr->sh_entsize = bed->s->sizeof_rela;
3296 if (get_elf_backend_data (abfd)->may_use_rel_p)
3297 this_hdr->sh_entsize = bed->s->sizeof_rel;
3300 case SHT_GNU_versym:
3301 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
3304 case SHT_GNU_verdef:
3305 this_hdr->sh_entsize = 0;
3306 /* objcopy or strip will copy over sh_info, but may not set
3307 cverdefs. The linker will set cverdefs, but sh_info will be
3309 if (this_hdr->sh_info == 0)
3310 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
3312 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
3313 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
3316 case SHT_GNU_verneed:
3317 this_hdr->sh_entsize = 0;
3318 /* objcopy or strip will copy over sh_info, but may not set
3319 cverrefs. The linker will set cverrefs, but sh_info will be
3321 if (this_hdr->sh_info == 0)
3322 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
3324 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
3325 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
3329 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
3333 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
3337 if ((asect->flags & SEC_ALLOC) != 0)
3338 this_hdr->sh_flags |= SHF_ALLOC;
3339 if ((asect->flags & SEC_READONLY) == 0)
3340 this_hdr->sh_flags |= SHF_WRITE;
3341 if ((asect->flags & SEC_CODE) != 0)
3342 this_hdr->sh_flags |= SHF_EXECINSTR;
3343 if ((asect->flags & SEC_MERGE) != 0)
3345 this_hdr->sh_flags |= SHF_MERGE;
3346 this_hdr->sh_entsize = asect->entsize;
3348 if ((asect->flags & SEC_STRINGS) != 0)
3349 this_hdr->sh_flags |= SHF_STRINGS;
3350 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
3351 this_hdr->sh_flags |= SHF_GROUP;
3352 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
3354 this_hdr->sh_flags |= SHF_TLS;
3355 if (asect->size == 0
3356 && (asect->flags & SEC_HAS_CONTENTS) == 0)
3358 struct bfd_link_order *o = asect->map_tail.link_order;
3360 this_hdr->sh_size = 0;
3363 this_hdr->sh_size = o->offset + o->size;
3364 if (this_hdr->sh_size != 0)
3365 this_hdr->sh_type = SHT_NOBITS;
3369 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
3370 this_hdr->sh_flags |= SHF_EXCLUDE;
3372 /* If the section has relocs, set up a section header for the
3373 SHT_REL[A] section. If two relocation sections are required for
3374 this section, it is up to the processor-specific back-end to
3375 create the other. */
3376 if ((asect->flags & SEC_RELOC) != 0)
3378 /* When doing a relocatable link, create both REL and RELA sections if
3381 /* Do the normal setup if we wouldn't create any sections here. */
3382 && esd->rel.count + esd->rela.count > 0
3383 && (bfd_link_relocatable (arg->link_info)
3384 || arg->link_info->emitrelocations))
3386 if (esd->rel.count && esd->rel.hdr == NULL
3387 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name,
3388 FALSE, delay_st_name_p))
3393 if (esd->rela.count && esd->rela.hdr == NULL
3394 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name,
3395 TRUE, delay_st_name_p))
3401 else if (!_bfd_elf_init_reloc_shdr (abfd,
3403 ? &esd->rela : &esd->rel),
3413 /* Check for processor-specific section types. */
3414 sh_type = this_hdr->sh_type;
3415 if (bed->elf_backend_fake_sections
3416 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
3422 if (sh_type == SHT_NOBITS && asect->size != 0)
3424 /* Don't change the header type from NOBITS if we are being
3425 called for objcopy --only-keep-debug. */
3426 this_hdr->sh_type = sh_type;
3430 /* Fill in the contents of a SHT_GROUP section. Called from
3431 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3432 when ELF targets use the generic linker, ld. Called for ld -r
3433 from bfd_elf_final_link. */
3436 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
3438 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
3439 asection *elt, *first;
3443 /* Ignore linker created group section. See elfNN_ia64_object_p in
3445 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
3449 if (elf_section_data (sec)->this_hdr.sh_info == 0)
3451 unsigned long symindx = 0;
3453 /* elf_group_id will have been set up by objcopy and the
3455 if (elf_group_id (sec) != NULL)
3456 symindx = elf_group_id (sec)->udata.i;
3460 /* If called from the assembler, swap_out_syms will have set up
3461 elf_section_syms. */
3462 BFD_ASSERT (elf_section_syms (abfd) != NULL);
3463 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
3465 elf_section_data (sec)->this_hdr.sh_info = symindx;
3467 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
3469 /* The ELF backend linker sets sh_info to -2 when the group
3470 signature symbol is global, and thus the index can't be
3471 set until all local symbols are output. */
3473 struct bfd_elf_section_data *sec_data;
3474 unsigned long symndx;
3475 unsigned long extsymoff;
3476 struct elf_link_hash_entry *h;
3478 /* The point of this little dance to the first SHF_GROUP section
3479 then back to the SHT_GROUP section is that this gets us to
3480 the SHT_GROUP in the input object. */
3481 igroup = elf_sec_group (elf_next_in_group (sec));
3482 sec_data = elf_section_data (igroup);
3483 symndx = sec_data->this_hdr.sh_info;
3485 if (!elf_bad_symtab (igroup->owner))
3487 Elf_Internal_Shdr *symtab_hdr;
3489 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
3490 extsymoff = symtab_hdr->sh_info;
3492 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
3493 while (h->root.type == bfd_link_hash_indirect
3494 || h->root.type == bfd_link_hash_warning)
3495 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3497 elf_section_data (sec)->this_hdr.sh_info = h->indx;
3500 /* The contents won't be allocated for "ld -r" or objcopy. */
3502 if (sec->contents == NULL)
3505 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
3507 /* Arrange for the section to be written out. */
3508 elf_section_data (sec)->this_hdr.contents = sec->contents;
3509 if (sec->contents == NULL)
3516 loc = sec->contents + sec->size;
3518 /* Get the pointer to the first section in the group that gas
3519 squirreled away here. objcopy arranges for this to be set to the
3520 start of the input section group. */
3521 first = elt = elf_next_in_group (sec);
3523 /* First element is a flag word. Rest of section is elf section
3524 indices for all the sections of the group. Write them backwards
3525 just to keep the group in the same order as given in .section
3526 directives, not that it matters. */
3533 s = s->output_section;
3535 && !bfd_is_abs_section (s))
3537 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
3538 struct bfd_elf_section_data *input_elf_sec = elf_section_data (elt);
3540 if (elf_sec->rel.hdr != NULL
3542 || (input_elf_sec->rel.hdr != NULL
3543 && input_elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0))
3545 elf_sec->rel.hdr->sh_flags |= SHF_GROUP;
3547 H_PUT_32 (abfd, elf_sec->rel.idx, loc);
3549 if (elf_sec->rela.hdr != NULL
3551 || (input_elf_sec->rela.hdr != NULL
3552 && input_elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0))
3554 elf_sec->rela.hdr->sh_flags |= SHF_GROUP;
3556 H_PUT_32 (abfd, elf_sec->rela.idx, loc);
3559 H_PUT_32 (abfd, elf_sec->this_idx, loc);
3561 elt = elf_next_in_group (elt);
3567 BFD_ASSERT (loc == sec->contents);
3569 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
3572 /* Given NAME, the name of a relocation section stripped of its
3573 .rel/.rela prefix, return the section in ABFD to which the
3574 relocations apply. */
3577 _bfd_elf_plt_get_reloc_section (bfd *abfd, const char *name)
3579 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3580 section likely apply to .got.plt or .got section. */
3581 if (get_elf_backend_data (abfd)->want_got_plt
3582 && strcmp (name, ".plt") == 0)
3587 sec = bfd_get_section_by_name (abfd, name);
3593 return bfd_get_section_by_name (abfd, name);
3596 /* Return the section to which RELOC_SEC applies. */
3599 elf_get_reloc_section (asection *reloc_sec)
3604 const struct elf_backend_data *bed;
3606 type = elf_section_data (reloc_sec)->this_hdr.sh_type;
3607 if (type != SHT_REL && type != SHT_RELA)
3610 /* We look up the section the relocs apply to by name. */
3611 name = reloc_sec->name;
3612 if (strncmp (name, ".rel", 4) != 0)
3615 if (type == SHT_RELA && *name++ != 'a')
3618 abfd = reloc_sec->owner;
3619 bed = get_elf_backend_data (abfd);
3620 return bed->get_reloc_section (abfd, name);
3623 /* Assign all ELF section numbers. The dummy first section is handled here
3624 too. The link/info pointers for the standard section types are filled
3625 in here too, while we're at it. */
3628 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
3630 struct elf_obj_tdata *t = elf_tdata (abfd);
3632 unsigned int section_number;
3633 Elf_Internal_Shdr **i_shdrp;
3634 struct bfd_elf_section_data *d;
3635 bfd_boolean need_symtab;
3639 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
3641 /* SHT_GROUP sections are in relocatable files only. */
3642 if (link_info == NULL || !link_info->resolve_section_groups)
3644 size_t reloc_count = 0;
3646 /* Put SHT_GROUP sections first. */
3647 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3649 d = elf_section_data (sec);
3651 if (d->this_hdr.sh_type == SHT_GROUP)
3653 if (sec->flags & SEC_LINKER_CREATED)
3655 /* Remove the linker created SHT_GROUP sections. */
3656 bfd_section_list_remove (abfd, sec);
3657 abfd->section_count--;
3660 d->this_idx = section_number++;
3663 /* Count relocations. */
3664 reloc_count += sec->reloc_count;
3667 /* Clear HAS_RELOC if there are no relocations. */
3668 if (reloc_count == 0)
3669 abfd->flags &= ~HAS_RELOC;
3672 for (sec = abfd->sections; sec; sec = sec->next)
3674 d = elf_section_data (sec);
3676 if (d->this_hdr.sh_type != SHT_GROUP)
3677 d->this_idx = section_number++;
3678 if (d->this_hdr.sh_name != (unsigned int) -1)
3679 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
3682 d->rel.idx = section_number++;
3683 if (d->rel.hdr->sh_name != (unsigned int) -1)
3684 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
3691 d->rela.idx = section_number++;
3692 if (d->rela.hdr->sh_name != (unsigned int) -1)
3693 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
3699 need_symtab = (bfd_get_symcount (abfd) > 0
3700 || (link_info == NULL
3701 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3705 elf_onesymtab (abfd) = section_number++;
3706 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
3707 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
3709 elf_section_list * entry;
3711 BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL);
3713 entry = bfd_zalloc (abfd, sizeof * entry);
3714 entry->ndx = section_number++;
3715 elf_symtab_shndx_list (abfd) = entry;
3717 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3718 ".symtab_shndx", FALSE);
3719 if (entry->hdr.sh_name == (unsigned int) -1)
3722 elf_strtab_sec (abfd) = section_number++;
3723 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3726 elf_shstrtab_sec (abfd) = section_number++;
3727 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3728 elf_elfheader (abfd)->e_shstrndx = elf_shstrtab_sec (abfd);
3730 if (section_number >= SHN_LORESERVE)
3732 /* xgettext:c-format */
3733 _bfd_error_handler (_("%pB: too many sections: %u"),
3734 abfd, section_number);
3738 elf_numsections (abfd) = section_number;
3739 elf_elfheader (abfd)->e_shnum = section_number;
3741 /* Set up the list of section header pointers, in agreement with the
3743 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3744 sizeof (Elf_Internal_Shdr *));
3745 if (i_shdrp == NULL)
3748 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3749 sizeof (Elf_Internal_Shdr));
3750 if (i_shdrp[0] == NULL)
3752 bfd_release (abfd, i_shdrp);
3756 elf_elfsections (abfd) = i_shdrp;
3758 i_shdrp[elf_shstrtab_sec (abfd)] = &t->shstrtab_hdr;
3761 i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr;
3762 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3764 elf_section_list * entry = elf_symtab_shndx_list (abfd);
3765 BFD_ASSERT (entry != NULL);
3766 i_shdrp[entry->ndx] = & entry->hdr;
3767 entry->hdr.sh_link = elf_onesymtab (abfd);
3769 i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
3770 t->symtab_hdr.sh_link = elf_strtab_sec (abfd);
3773 for (sec = abfd->sections; sec; sec = sec->next)
3777 d = elf_section_data (sec);
3779 i_shdrp[d->this_idx] = &d->this_hdr;
3780 if (d->rel.idx != 0)
3781 i_shdrp[d->rel.idx] = d->rel.hdr;
3782 if (d->rela.idx != 0)
3783 i_shdrp[d->rela.idx] = d->rela.hdr;
3785 /* Fill in the sh_link and sh_info fields while we're at it. */
3787 /* sh_link of a reloc section is the section index of the symbol
3788 table. sh_info is the section index of the section to which
3789 the relocation entries apply. */
3790 if (d->rel.idx != 0)
3792 d->rel.hdr->sh_link = elf_onesymtab (abfd);
3793 d->rel.hdr->sh_info = d->this_idx;
3794 d->rel.hdr->sh_flags |= SHF_INFO_LINK;
3796 if (d->rela.idx != 0)
3798 d->rela.hdr->sh_link = elf_onesymtab (abfd);
3799 d->rela.hdr->sh_info = d->this_idx;
3800 d->rela.hdr->sh_flags |= SHF_INFO_LINK;
3803 /* We need to set up sh_link for SHF_LINK_ORDER. */
3804 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3806 s = elf_linked_to_section (sec);
3809 /* elf_linked_to_section points to the input section. */
3810 if (link_info != NULL)
3812 /* Check discarded linkonce section. */
3813 if (discarded_section (s))
3817 /* xgettext:c-format */
3818 (_("%pB: sh_link of section `%pA' points to"
3819 " discarded section `%pA' of `%pB'"),
3820 abfd, d->this_hdr.bfd_section,
3822 /* Point to the kept section if it has the same
3823 size as the discarded one. */
3824 kept = _bfd_elf_check_kept_section (s, link_info);
3827 bfd_set_error (bfd_error_bad_value);
3833 s = s->output_section;
3834 BFD_ASSERT (s != NULL);
3838 /* Handle objcopy. */
3839 if (s->output_section == NULL)
3842 /* xgettext:c-format */
3843 (_("%pB: sh_link of section `%pA' points to"
3844 " removed section `%pA' of `%pB'"),
3845 abfd, d->this_hdr.bfd_section, s, s->owner);
3846 bfd_set_error (bfd_error_bad_value);
3849 s = s->output_section;
3851 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3856 The Intel C compiler generates SHT_IA_64_UNWIND with
3857 SHF_LINK_ORDER. But it doesn't set the sh_link or
3858 sh_info fields. Hence we could get the situation
3860 const struct elf_backend_data *bed
3861 = get_elf_backend_data (abfd);
3862 if (bed->link_order_error_handler)
3863 bed->link_order_error_handler
3864 /* xgettext:c-format */
3865 (_("%pB: warning: sh_link not set for section `%pA'"),
3870 switch (d->this_hdr.sh_type)
3874 /* A reloc section which we are treating as a normal BFD
3875 section. sh_link is the section index of the symbol
3876 table. sh_info is the section index of the section to
3877 which the relocation entries apply. We assume that an
3878 allocated reloc section uses the dynamic symbol table.
3879 FIXME: How can we be sure? */
3880 s = bfd_get_section_by_name (abfd, ".dynsym");
3882 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3884 s = elf_get_reloc_section (sec);
3887 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3888 d->this_hdr.sh_flags |= SHF_INFO_LINK;
3893 /* We assume that a section named .stab*str is a stabs
3894 string section. We look for a section with the same name
3895 but without the trailing ``str'', and set its sh_link
3896 field to point to this section. */
3897 if (CONST_STRNEQ (sec->name, ".stab")
3898 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3903 len = strlen (sec->name);
3904 alc = (char *) bfd_malloc (len - 2);
3907 memcpy (alc, sec->name, len - 3);
3908 alc[len - 3] = '\0';
3909 s = bfd_get_section_by_name (abfd, alc);
3913 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3915 /* This is a .stab section. */
3916 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3917 elf_section_data (s)->this_hdr.sh_entsize
3918 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3925 case SHT_GNU_verneed:
3926 case SHT_GNU_verdef:
3927 /* sh_link is the section header index of the string table
3928 used for the dynamic entries, or the symbol table, or the
3930 s = bfd_get_section_by_name (abfd, ".dynstr");
3932 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3935 case SHT_GNU_LIBLIST:
3936 /* sh_link is the section header index of the prelink library
3937 list used for the dynamic entries, or the symbol table, or
3938 the version strings. */
3939 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3940 ? ".dynstr" : ".gnu.libstr");
3942 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3947 case SHT_GNU_versym:
3948 /* sh_link is the section header index of the symbol table
3949 this hash table or version table is for. */
3950 s = bfd_get_section_by_name (abfd, ".dynsym");
3952 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3956 d->this_hdr.sh_link = elf_onesymtab (abfd);
3960 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3961 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3962 debug section name from .debug_* to .zdebug_* if needed. */
3968 sym_is_global (bfd *abfd, asymbol *sym)
3970 /* If the backend has a special mapping, use it. */
3971 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3972 if (bed->elf_backend_sym_is_global)
3973 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3975 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3976 || bfd_is_und_section (bfd_get_section (sym))
3977 || bfd_is_com_section (bfd_get_section (sym)));
3980 /* Filter global symbols of ABFD to include in the import library. All
3981 SYMCOUNT symbols of ABFD can be examined from their pointers in
3982 SYMS. Pointers of symbols to keep should be stored contiguously at
3983 the beginning of that array.
3985 Returns the number of symbols to keep. */
3988 _bfd_elf_filter_global_symbols (bfd *abfd, struct bfd_link_info *info,
3989 asymbol **syms, long symcount)
3991 long src_count, dst_count = 0;
3993 for (src_count = 0; src_count < symcount; src_count++)
3995 asymbol *sym = syms[src_count];
3996 char *name = (char *) bfd_asymbol_name (sym);
3997 struct bfd_link_hash_entry *h;
3999 if (!sym_is_global (abfd, sym))
4002 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
4005 if (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak)
4007 if (h->linker_def || h->ldscript_def)
4010 syms[dst_count++] = sym;
4013 syms[dst_count] = NULL;
4018 /* Don't output section symbols for sections that are not going to be
4019 output, that are duplicates or there is no BFD section. */
4022 ignore_section_sym (bfd *abfd, asymbol *sym)
4024 elf_symbol_type *type_ptr;
4029 if ((sym->flags & BSF_SECTION_SYM) == 0)
4032 if (sym->section == NULL)
4035 type_ptr = elf_symbol_from (abfd, sym);
4036 return ((type_ptr != NULL
4037 && type_ptr->internal_elf_sym.st_shndx != 0
4038 && bfd_is_abs_section (sym->section))
4039 || !(sym->section->owner == abfd
4040 || (sym->section->output_section != NULL
4041 && sym->section->output_section->owner == abfd
4042 && sym->section->output_offset == 0)
4043 || bfd_is_abs_section (sym->section)));
4046 /* Map symbol from it's internal number to the external number, moving
4047 all local symbols to be at the head of the list. */
4050 elf_map_symbols (bfd *abfd, unsigned int *pnum_locals)
4052 unsigned int symcount = bfd_get_symcount (abfd);
4053 asymbol **syms = bfd_get_outsymbols (abfd);
4054 asymbol **sect_syms;
4055 unsigned int num_locals = 0;
4056 unsigned int num_globals = 0;
4057 unsigned int num_locals2 = 0;
4058 unsigned int num_globals2 = 0;
4059 unsigned int max_index = 0;
4065 fprintf (stderr, "elf_map_symbols\n");
4069 for (asect = abfd->sections; asect; asect = asect->next)
4071 if (max_index < asect->index)
4072 max_index = asect->index;
4076 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
4077 if (sect_syms == NULL)
4079 elf_section_syms (abfd) = sect_syms;
4080 elf_num_section_syms (abfd) = max_index;
4082 /* Init sect_syms entries for any section symbols we have already
4083 decided to output. */
4084 for (idx = 0; idx < symcount; idx++)
4086 asymbol *sym = syms[idx];
4088 if ((sym->flags & BSF_SECTION_SYM) != 0
4090 && !ignore_section_sym (abfd, sym)
4091 && !bfd_is_abs_section (sym->section))
4093 asection *sec = sym->section;
4095 if (sec->owner != abfd)
4096 sec = sec->output_section;
4098 sect_syms[sec->index] = syms[idx];
4102 /* Classify all of the symbols. */
4103 for (idx = 0; idx < symcount; idx++)
4105 if (sym_is_global (abfd, syms[idx]))
4107 else if (!ignore_section_sym (abfd, syms[idx]))
4111 /* We will be adding a section symbol for each normal BFD section. Most
4112 sections will already have a section symbol in outsymbols, but
4113 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4114 at least in that case. */
4115 for (asect = abfd->sections; asect; asect = asect->next)
4117 if (sect_syms[asect->index] == NULL)
4119 if (!sym_is_global (abfd, asect->symbol))
4126 /* Now sort the symbols so the local symbols are first. */
4127 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
4128 sizeof (asymbol *));
4130 if (new_syms == NULL)
4133 for (idx = 0; idx < symcount; idx++)
4135 asymbol *sym = syms[idx];
4138 if (sym_is_global (abfd, sym))
4139 i = num_locals + num_globals2++;
4140 else if (!ignore_section_sym (abfd, sym))
4145 sym->udata.i = i + 1;
4147 for (asect = abfd->sections; asect; asect = asect->next)
4149 if (sect_syms[asect->index] == NULL)
4151 asymbol *sym = asect->symbol;
4154 sect_syms[asect->index] = sym;
4155 if (!sym_is_global (abfd, sym))
4158 i = num_locals + num_globals2++;
4160 sym->udata.i = i + 1;
4164 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
4166 *pnum_locals = num_locals;
4170 /* Align to the maximum file alignment that could be required for any
4171 ELF data structure. */
4173 static inline file_ptr
4174 align_file_position (file_ptr off, int align)
4176 return (off + align - 1) & ~(align - 1);
4179 /* Assign a file position to a section, optionally aligning to the
4180 required section alignment. */
4183 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
4187 if (align && i_shdrp->sh_addralign > 1)
4188 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
4189 i_shdrp->sh_offset = offset;
4190 if (i_shdrp->bfd_section != NULL)
4191 i_shdrp->bfd_section->filepos = offset;
4192 if (i_shdrp->sh_type != SHT_NOBITS)
4193 offset += i_shdrp->sh_size;
4197 /* Compute the file positions we are going to put the sections at, and
4198 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4199 is not NULL, this is being called by the ELF backend linker. */
4202 _bfd_elf_compute_section_file_positions (bfd *abfd,
4203 struct bfd_link_info *link_info)
4205 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4206 struct fake_section_arg fsargs;
4208 struct elf_strtab_hash *strtab = NULL;
4209 Elf_Internal_Shdr *shstrtab_hdr;
4210 bfd_boolean need_symtab;
4212 if (abfd->output_has_begun)
4215 /* Do any elf backend specific processing first. */
4216 if (bed->elf_backend_begin_write_processing)
4217 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
4219 if (! prep_headers (abfd))
4222 /* Post process the headers if necessary. */
4223 (*bed->elf_backend_post_process_headers) (abfd, link_info);
4225 fsargs.failed = FALSE;
4226 fsargs.link_info = link_info;
4227 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
4231 if (!assign_section_numbers (abfd, link_info))
4234 /* The backend linker builds symbol table information itself. */
4235 need_symtab = (link_info == NULL
4236 && (bfd_get_symcount (abfd) > 0
4237 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
4241 /* Non-zero if doing a relocatable link. */
4242 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
4244 if (! swap_out_syms (abfd, &strtab, relocatable_p))
4249 if (link_info == NULL)
4251 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
4256 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
4257 /* sh_name was set in prep_headers. */
4258 shstrtab_hdr->sh_type = SHT_STRTAB;
4259 shstrtab_hdr->sh_flags = bed->elf_strtab_flags;
4260 shstrtab_hdr->sh_addr = 0;
4261 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4262 shstrtab_hdr->sh_entsize = 0;
4263 shstrtab_hdr->sh_link = 0;
4264 shstrtab_hdr->sh_info = 0;
4265 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4266 shstrtab_hdr->sh_addralign = 1;
4268 if (!assign_file_positions_except_relocs (abfd, link_info))
4274 Elf_Internal_Shdr *hdr;
4276 off = elf_next_file_pos (abfd);
4278 hdr = & elf_symtab_hdr (abfd);
4279 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4281 if (elf_symtab_shndx_list (abfd) != NULL)
4283 hdr = & elf_symtab_shndx_list (abfd)->hdr;
4284 if (hdr->sh_size != 0)
4285 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4286 /* FIXME: What about other symtab_shndx sections in the list ? */
4289 hdr = &elf_tdata (abfd)->strtab_hdr;
4290 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4292 elf_next_file_pos (abfd) = off;
4294 /* Now that we know where the .strtab section goes, write it
4296 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4297 || ! _bfd_elf_strtab_emit (abfd, strtab))
4299 _bfd_elf_strtab_free (strtab);
4302 abfd->output_has_begun = TRUE;
4307 /* Make an initial estimate of the size of the program header. If we
4308 get the number wrong here, we'll redo section placement. */
4310 static bfd_size_type
4311 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
4315 const struct elf_backend_data *bed;
4317 /* Assume we will need exactly two PT_LOAD segments: one for text
4318 and one for data. */
4321 s = bfd_get_section_by_name (abfd, ".interp");
4322 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4324 /* If we have a loadable interpreter section, we need a
4325 PT_INTERP segment. In this case, assume we also need a
4326 PT_PHDR segment, although that may not be true for all
4331 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4333 /* We need a PT_DYNAMIC segment. */
4337 if (info != NULL && info->relro)
4339 /* We need a PT_GNU_RELRO segment. */
4343 if (elf_eh_frame_hdr (abfd))
4345 /* We need a PT_GNU_EH_FRAME segment. */
4349 if (elf_stack_flags (abfd))
4351 /* We need a PT_GNU_STACK segment. */
4355 for (s = abfd->sections; s != NULL; s = s->next)
4357 if ((s->flags & SEC_LOAD) != 0
4358 && CONST_STRNEQ (s->name, ".note"))
4360 /* We need a PT_NOTE segment. */
4362 /* Try to create just one PT_NOTE segment
4363 for all adjacent loadable .note* sections.
4364 gABI requires that within a PT_NOTE segment
4365 (and also inside of each SHT_NOTE section)
4366 each note is padded to a multiple of 4 size,
4367 so we check whether the sections are correctly
4369 if (s->alignment_power == 2)
4370 while (s->next != NULL
4371 && s->next->alignment_power == 2
4372 && (s->next->flags & SEC_LOAD) != 0
4373 && CONST_STRNEQ (s->next->name, ".note"))
4378 for (s = abfd->sections; s != NULL; s = s->next)
4380 if (s->flags & SEC_THREAD_LOCAL)
4382 /* We need a PT_TLS segment. */
4388 bed = get_elf_backend_data (abfd);
4390 if ((abfd->flags & D_PAGED) != 0)
4392 /* Add a PT_GNU_MBIND segment for each mbind section. */
4393 unsigned int page_align_power = bfd_log2 (bed->commonpagesize);
4394 for (s = abfd->sections; s != NULL; s = s->next)
4395 if (elf_section_flags (s) & SHF_GNU_MBIND)
4397 if (elf_section_data (s)->this_hdr.sh_info
4401 /* xgettext:c-format */
4402 (_("%pB: GNU_MBIN section `%pA' has invalid sh_info field: %d"),
4403 abfd, s, elf_section_data (s)->this_hdr.sh_info);
4406 /* Align mbind section to page size. */
4407 if (s->alignment_power < page_align_power)
4408 s->alignment_power = page_align_power;
4413 /* Let the backend count up any program headers it might need. */
4414 if (bed->elf_backend_additional_program_headers)
4418 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
4424 return segs * bed->s->sizeof_phdr;
4427 /* Find the segment that contains the output_section of section. */
4430 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
4432 struct elf_segment_map *m;
4433 Elf_Internal_Phdr *p;
4435 for (m = elf_seg_map (abfd), p = elf_tdata (abfd)->phdr;
4441 for (i = m->count - 1; i >= 0; i--)
4442 if (m->sections[i] == section)
4449 /* Create a mapping from a set of sections to a program segment. */
4451 static struct elf_segment_map *
4452 make_mapping (bfd *abfd,
4453 asection **sections,
4458 struct elf_segment_map *m;
4463 amt = sizeof (struct elf_segment_map);
4464 amt += (to - from - 1) * sizeof (asection *);
4465 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4469 m->p_type = PT_LOAD;
4470 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
4471 m->sections[i - from] = *hdrpp;
4472 m->count = to - from;
4474 if (from == 0 && phdr)
4476 /* Include the headers in the first PT_LOAD segment. */
4477 m->includes_filehdr = 1;
4478 m->includes_phdrs = 1;
4484 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4487 struct elf_segment_map *
4488 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
4490 struct elf_segment_map *m;
4492 m = (struct elf_segment_map *) bfd_zalloc (abfd,
4493 sizeof (struct elf_segment_map));
4497 m->p_type = PT_DYNAMIC;
4499 m->sections[0] = dynsec;
4504 /* Possibly add or remove segments from the segment map. */
4507 elf_modify_segment_map (bfd *abfd,
4508 struct bfd_link_info *info,
4509 bfd_boolean remove_empty_load)
4511 struct elf_segment_map **m;
4512 const struct elf_backend_data *bed;
4514 /* The placement algorithm assumes that non allocated sections are
4515 not in PT_LOAD segments. We ensure this here by removing such
4516 sections from the segment map. We also remove excluded
4517 sections. Finally, any PT_LOAD segment without sections is
4519 m = &elf_seg_map (abfd);
4522 unsigned int i, new_count;
4524 for (new_count = 0, i = 0; i < (*m)->count; i++)
4526 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
4527 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
4528 || (*m)->p_type != PT_LOAD))
4530 (*m)->sections[new_count] = (*m)->sections[i];
4534 (*m)->count = new_count;
4536 if (remove_empty_load
4537 && (*m)->p_type == PT_LOAD
4539 && !(*m)->includes_phdrs)
4545 bed = get_elf_backend_data (abfd);
4546 if (bed->elf_backend_modify_segment_map != NULL)
4548 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
4555 #define IS_TBSS(s) \
4556 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4558 /* Set up a mapping from BFD sections to program segments. */
4561 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
4564 struct elf_segment_map *m;
4565 asection **sections = NULL;
4566 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4567 bfd_boolean no_user_phdrs;
4569 no_user_phdrs = elf_seg_map (abfd) == NULL;
4572 info->user_phdrs = !no_user_phdrs;
4574 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
4578 struct elf_segment_map *mfirst;
4579 struct elf_segment_map **pm;
4582 unsigned int phdr_index;
4583 bfd_vma maxpagesize;
4585 bfd_boolean phdr_in_segment = TRUE;
4586 bfd_boolean writable;
4587 bfd_boolean executable;
4589 asection *first_tls = NULL;
4590 asection *first_mbind = NULL;
4591 asection *dynsec, *eh_frame_hdr;
4593 bfd_vma addr_mask, wrap_to = 0;
4594 bfd_boolean linker_created_pt_phdr_segment = FALSE;
4596 /* Select the allocated sections, and sort them. */
4598 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
4599 sizeof (asection *));
4600 if (sections == NULL)
4603 /* Calculate top address, avoiding undefined behaviour of shift
4604 left operator when shift count is equal to size of type
4606 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
4607 addr_mask = (addr_mask << 1) + 1;
4610 for (s = abfd->sections; s != NULL; s = s->next)
4612 if ((s->flags & SEC_ALLOC) != 0)
4616 /* A wrapping section potentially clashes with header. */
4617 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
4618 wrap_to = (s->lma + s->size) & addr_mask;
4621 BFD_ASSERT (i <= bfd_count_sections (abfd));
4624 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
4626 /* Build the mapping. */
4631 /* If we have a .interp section, then create a PT_PHDR segment for
4632 the program headers and a PT_INTERP segment for the .interp
4634 s = bfd_get_section_by_name (abfd, ".interp");
4635 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4637 amt = sizeof (struct elf_segment_map);
4638 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4642 m->p_type = PT_PHDR;
4644 m->p_flags_valid = 1;
4645 m->includes_phdrs = 1;
4646 linker_created_pt_phdr_segment = TRUE;
4650 amt = sizeof (struct elf_segment_map);
4651 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4655 m->p_type = PT_INTERP;
4663 /* Look through the sections. We put sections in the same program
4664 segment when the start of the second section can be placed within
4665 a few bytes of the end of the first section. */
4669 maxpagesize = bed->maxpagesize;
4670 /* PR 17512: file: c8455299.
4671 Avoid divide-by-zero errors later on.
4672 FIXME: Should we abort if the maxpagesize is zero ? */
4673 if (maxpagesize == 0)
4677 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
4679 && (dynsec->flags & SEC_LOAD) == 0)
4682 /* Deal with -Ttext or something similar such that the first section
4683 is not adjacent to the program headers. This is an
4684 approximation, since at this point we don't know exactly how many
4685 program headers we will need. */
4688 bfd_size_type phdr_size = elf_program_header_size (abfd);
4690 if (phdr_size == (bfd_size_type) -1)
4691 phdr_size = get_program_header_size (abfd, info);
4692 phdr_size += bed->s->sizeof_ehdr;
4693 if ((abfd->flags & D_PAGED) == 0
4694 || (sections[0]->lma & addr_mask) < phdr_size
4695 || ((sections[0]->lma & addr_mask) % maxpagesize
4696 < phdr_size % maxpagesize)
4697 || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
4699 /* PR 20815: The ELF standard says that a PT_PHDR segment, if
4700 present, must be included as part of the memory image of the
4701 program. Ie it must be part of a PT_LOAD segment as well.
4702 If we have had to create our own PT_PHDR segment, but it is
4703 not going to be covered by the first PT_LOAD segment, then
4704 force the inclusion if we can... */
4705 if ((abfd->flags & D_PAGED) != 0
4706 && linker_created_pt_phdr_segment)
4707 phdr_in_segment = TRUE;
4709 phdr_in_segment = FALSE;
4713 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
4716 bfd_boolean new_segment;
4720 /* See if this section and the last one will fit in the same
4723 if (last_hdr == NULL)
4725 /* If we don't have a segment yet, then we don't need a new
4726 one (we build the last one after this loop). */
4727 new_segment = FALSE;
4729 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
4731 /* If this section has a different relation between the
4732 virtual address and the load address, then we need a new
4736 else if (hdr->lma < last_hdr->lma + last_size
4737 || last_hdr->lma + last_size < last_hdr->lma)
4739 /* If this section has a load address that makes it overlap
4740 the previous section, then we need a new segment. */
4743 else if ((abfd->flags & D_PAGED) != 0
4744 && (((last_hdr->lma + last_size - 1) & -maxpagesize)
4745 == (hdr->lma & -maxpagesize)))
4747 /* If we are demand paged then we can't map two disk
4748 pages onto the same memory page. */
4749 new_segment = FALSE;
4751 /* In the next test we have to be careful when last_hdr->lma is close
4752 to the end of the address space. If the aligned address wraps
4753 around to the start of the address space, then there are no more
4754 pages left in memory and it is OK to assume that the current
4755 section can be included in the current segment. */
4756 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4757 + maxpagesize > last_hdr->lma)
4758 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4759 + maxpagesize <= hdr->lma))
4761 /* If putting this section in this segment would force us to
4762 skip a page in the segment, then we need a new segment. */
4765 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
4766 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
4768 /* We don't want to put a loaded section after a
4769 nonloaded (ie. bss style) section in the same segment
4770 as that will force the non-loaded section to be loaded.
4771 Consider .tbss sections as loaded for this purpose. */
4774 else if ((abfd->flags & D_PAGED) == 0)
4776 /* If the file is not demand paged, which means that we
4777 don't require the sections to be correctly aligned in the
4778 file, then there is no other reason for a new segment. */
4779 new_segment = FALSE;
4781 else if (info != NULL
4782 && info->separate_code
4783 && executable != ((hdr->flags & SEC_CODE) != 0))
4788 && (hdr->flags & SEC_READONLY) == 0)
4790 /* We don't want to put a writable section in a read only
4796 /* Otherwise, we can use the same segment. */
4797 new_segment = FALSE;
4800 /* Allow interested parties a chance to override our decision. */
4801 if (last_hdr != NULL
4803 && info->callbacks->override_segment_assignment != NULL)
4805 = info->callbacks->override_segment_assignment (info, abfd, hdr,
4811 if ((hdr->flags & SEC_READONLY) == 0)
4813 if ((hdr->flags & SEC_CODE) != 0)
4816 /* .tbss sections effectively have zero size. */
4817 last_size = !IS_TBSS (hdr) ? hdr->size : 0;
4821 /* We need a new program segment. We must create a new program
4822 header holding all the sections from phdr_index until hdr. */
4824 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4831 if ((hdr->flags & SEC_READONLY) == 0)
4836 if ((hdr->flags & SEC_CODE) == 0)
4842 /* .tbss sections effectively have zero size. */
4843 last_size = !IS_TBSS (hdr) ? hdr->size : 0;
4845 phdr_in_segment = FALSE;
4848 /* Create a final PT_LOAD program segment, but not if it's just
4850 if (last_hdr != NULL
4851 && (i - phdr_index != 1
4852 || !IS_TBSS (last_hdr)))
4854 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4862 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4865 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4872 /* For each batch of consecutive loadable .note sections,
4873 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4874 because if we link together nonloadable .note sections and
4875 loadable .note sections, we will generate two .note sections
4876 in the output file. FIXME: Using names for section types is
4878 for (s = abfd->sections; s != NULL; s = s->next)
4880 if ((s->flags & SEC_LOAD) != 0
4881 && CONST_STRNEQ (s->name, ".note"))
4886 amt = sizeof (struct elf_segment_map);
4887 if (s->alignment_power == 2)
4888 for (s2 = s; s2->next != NULL; s2 = s2->next)
4890 if (s2->next->alignment_power == 2
4891 && (s2->next->flags & SEC_LOAD) != 0
4892 && CONST_STRNEQ (s2->next->name, ".note")
4893 && align_power (s2->lma + s2->size, 2)
4899 amt += (count - 1) * sizeof (asection *);
4900 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4904 m->p_type = PT_NOTE;
4908 m->sections[m->count - count--] = s;
4909 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4912 m->sections[m->count - 1] = s;
4913 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4917 if (s->flags & SEC_THREAD_LOCAL)
4923 if (first_mbind == NULL
4924 && (elf_section_flags (s) & SHF_GNU_MBIND) != 0)
4928 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4931 amt = sizeof (struct elf_segment_map);
4932 amt += (tls_count - 1) * sizeof (asection *);
4933 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4938 m->count = tls_count;
4939 /* Mandated PF_R. */
4941 m->p_flags_valid = 1;
4943 for (i = 0; i < (unsigned int) tls_count; ++i)
4945 if ((s->flags & SEC_THREAD_LOCAL) == 0)
4948 (_("%pB: TLS sections are not adjacent:"), abfd);
4951 while (i < (unsigned int) tls_count)
4953 if ((s->flags & SEC_THREAD_LOCAL) != 0)
4955 _bfd_error_handler (_(" TLS: %pA"), s);
4959 _bfd_error_handler (_(" non-TLS: %pA"), s);
4962 bfd_set_error (bfd_error_bad_value);
4973 if (first_mbind && (abfd->flags & D_PAGED) != 0)
4974 for (s = first_mbind; s != NULL; s = s->next)
4975 if ((elf_section_flags (s) & SHF_GNU_MBIND) != 0
4976 && (elf_section_data (s)->this_hdr.sh_info
4977 <= PT_GNU_MBIND_NUM))
4979 /* Mandated PF_R. */
4980 unsigned long p_flags = PF_R;
4981 if ((s->flags & SEC_READONLY) == 0)
4983 if ((s->flags & SEC_CODE) != 0)
4986 amt = sizeof (struct elf_segment_map) + sizeof (asection *);
4987 m = bfd_zalloc (abfd, amt);
4991 m->p_type = (PT_GNU_MBIND_LO
4992 + elf_section_data (s)->this_hdr.sh_info);
4994 m->p_flags_valid = 1;
4996 m->p_flags = p_flags;
5002 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5004 eh_frame_hdr = elf_eh_frame_hdr (abfd);
5005 if (eh_frame_hdr != NULL
5006 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
5008 amt = sizeof (struct elf_segment_map);
5009 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5013 m->p_type = PT_GNU_EH_FRAME;
5015 m->sections[0] = eh_frame_hdr->output_section;
5021 if (elf_stack_flags (abfd))
5023 amt = sizeof (struct elf_segment_map);
5024 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5028 m->p_type = PT_GNU_STACK;
5029 m->p_flags = elf_stack_flags (abfd);
5030 m->p_align = bed->stack_align;
5031 m->p_flags_valid = 1;
5032 m->p_align_valid = m->p_align != 0;
5033 if (info->stacksize > 0)
5035 m->p_size = info->stacksize;
5036 m->p_size_valid = 1;
5043 if (info != NULL && info->relro)
5045 for (m = mfirst; m != NULL; m = m->next)
5047 if (m->p_type == PT_LOAD
5049 && m->sections[0]->vma >= info->relro_start
5050 && m->sections[0]->vma < info->relro_end)
5053 while (--i != (unsigned) -1)
5054 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
5055 == (SEC_LOAD | SEC_HAS_CONTENTS))
5058 if (i != (unsigned) -1)
5063 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5066 amt = sizeof (struct elf_segment_map);
5067 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5071 m->p_type = PT_GNU_RELRO;
5078 elf_seg_map (abfd) = mfirst;
5081 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
5084 for (count = 0, m = elf_seg_map (abfd); m != NULL; m = m->next)
5086 elf_program_header_size (abfd) = count * bed->s->sizeof_phdr;
5091 if (sections != NULL)
5096 /* Sort sections by address. */
5099 elf_sort_sections (const void *arg1, const void *arg2)
5101 const asection *sec1 = *(const asection **) arg1;
5102 const asection *sec2 = *(const asection **) arg2;
5103 bfd_size_type size1, size2;
5105 /* Sort by LMA first, since this is the address used to
5106 place the section into a segment. */
5107 if (sec1->lma < sec2->lma)
5109 else if (sec1->lma > sec2->lma)
5112 /* Then sort by VMA. Normally the LMA and the VMA will be
5113 the same, and this will do nothing. */
5114 if (sec1->vma < sec2->vma)
5116 else if (sec1->vma > sec2->vma)
5119 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5121 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5127 /* If the indicies are the same, do not return 0
5128 here, but continue to try the next comparison. */
5129 if (sec1->target_index - sec2->target_index != 0)
5130 return sec1->target_index - sec2->target_index;
5135 else if (TOEND (sec2))
5140 /* Sort by size, to put zero sized sections
5141 before others at the same address. */
5143 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
5144 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
5151 return sec1->target_index - sec2->target_index;
5154 /* Ian Lance Taylor writes:
5156 We shouldn't be using % with a negative signed number. That's just
5157 not good. We have to make sure either that the number is not
5158 negative, or that the number has an unsigned type. When the types
5159 are all the same size they wind up as unsigned. When file_ptr is a
5160 larger signed type, the arithmetic winds up as signed long long,
5163 What we're trying to say here is something like ``increase OFF by
5164 the least amount that will cause it to be equal to the VMA modulo
5166 /* In other words, something like:
5168 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5169 off_offset = off % bed->maxpagesize;
5170 if (vma_offset < off_offset)
5171 adjustment = vma_offset + bed->maxpagesize - off_offset;
5173 adjustment = vma_offset - off_offset;
5175 which can be collapsed into the expression below. */
5178 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
5180 /* PR binutils/16199: Handle an alignment of zero. */
5181 if (maxpagesize == 0)
5183 return ((vma - off) % maxpagesize);
5187 print_segment_map (const struct elf_segment_map *m)
5190 const char *pt = get_segment_type (m->p_type);
5195 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
5196 sprintf (buf, "LOPROC+%7.7x",
5197 (unsigned int) (m->p_type - PT_LOPROC));
5198 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
5199 sprintf (buf, "LOOS+%7.7x",
5200 (unsigned int) (m->p_type - PT_LOOS));
5202 snprintf (buf, sizeof (buf), "%8.8x",
5203 (unsigned int) m->p_type);
5207 fprintf (stderr, "%s:", pt);
5208 for (j = 0; j < m->count; j++)
5209 fprintf (stderr, " %s", m->sections [j]->name);
5215 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
5220 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
5222 buf = bfd_zmalloc (len);
5225 ret = bfd_bwrite (buf, len, abfd) == len;
5230 /* Assign file positions to the sections based on the mapping from
5231 sections to segments. This function also sets up some fields in
5235 assign_file_positions_for_load_sections (bfd *abfd,
5236 struct bfd_link_info *link_info)
5238 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5239 struct elf_segment_map *m;
5240 Elf_Internal_Phdr *phdrs;
5241 Elf_Internal_Phdr *p;
5243 bfd_size_type maxpagesize;
5244 unsigned int pt_load_count = 0;
5247 bfd_vma header_pad = 0;
5249 if (link_info == NULL
5250 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
5254 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5258 header_pad = m->header_size;
5263 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
5264 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
5268 /* PR binutils/12467. */
5269 elf_elfheader (abfd)->e_phoff = 0;
5270 elf_elfheader (abfd)->e_phentsize = 0;
5273 elf_elfheader (abfd)->e_phnum = alloc;
5275 if (elf_program_header_size (abfd) == (bfd_size_type) -1)
5276 elf_program_header_size (abfd) = alloc * bed->s->sizeof_phdr;
5278 BFD_ASSERT (elf_program_header_size (abfd)
5279 >= alloc * bed->s->sizeof_phdr);
5283 elf_next_file_pos (abfd) = bed->s->sizeof_ehdr;
5287 /* We're writing the size in elf_program_header_size (abfd),
5288 see assign_file_positions_except_relocs, so make sure we have
5289 that amount allocated, with trailing space cleared.
5290 The variable alloc contains the computed need, while
5291 elf_program_header_size (abfd) contains the size used for the
5293 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5294 where the layout is forced to according to a larger size in the
5295 last iterations for the testcase ld-elf/header. */
5296 BFD_ASSERT (elf_program_header_size (abfd) % bed->s->sizeof_phdr
5298 phdrs = (Elf_Internal_Phdr *)
5300 (elf_program_header_size (abfd) / bed->s->sizeof_phdr),
5301 sizeof (Elf_Internal_Phdr));
5302 elf_tdata (abfd)->phdr = phdrs;
5307 if ((abfd->flags & D_PAGED) != 0)
5308 maxpagesize = bed->maxpagesize;
5310 off = bed->s->sizeof_ehdr;
5311 off += alloc * bed->s->sizeof_phdr;
5312 if (header_pad < (bfd_vma) off)
5318 for (m = elf_seg_map (abfd), p = phdrs, j = 0;
5320 m = m->next, p++, j++)
5324 bfd_boolean no_contents;
5326 /* If elf_segment_map is not from map_sections_to_segments, the
5327 sections may not be correctly ordered. NOTE: sorting should
5328 not be done to the PT_NOTE section of a corefile, which may
5329 contain several pseudo-sections artificially created by bfd.
5330 Sorting these pseudo-sections breaks things badly. */
5332 && !(elf_elfheader (abfd)->e_type == ET_CORE
5333 && m->p_type == PT_NOTE))
5334 qsort (m->sections, (size_t) m->count, sizeof (asection *),
5337 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5338 number of sections with contents contributing to both p_filesz
5339 and p_memsz, followed by a number of sections with no contents
5340 that just contribute to p_memsz. In this loop, OFF tracks next
5341 available file offset for PT_LOAD and PT_NOTE segments. */
5342 p->p_type = m->p_type;
5343 p->p_flags = m->p_flags;
5348 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
5350 if (m->p_paddr_valid)
5351 p->p_paddr = m->p_paddr;
5352 else if (m->count == 0)
5355 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
5357 if (p->p_type == PT_LOAD
5358 && (abfd->flags & D_PAGED) != 0)
5360 /* p_align in demand paged PT_LOAD segments effectively stores
5361 the maximum page size. When copying an executable with
5362 objcopy, we set m->p_align from the input file. Use this
5363 value for maxpagesize rather than bed->maxpagesize, which
5364 may be different. Note that we use maxpagesize for PT_TLS
5365 segment alignment later in this function, so we are relying
5366 on at least one PT_LOAD segment appearing before a PT_TLS
5368 if (m->p_align_valid)
5369 maxpagesize = m->p_align;
5371 p->p_align = maxpagesize;
5374 else if (m->p_align_valid)
5375 p->p_align = m->p_align;
5376 else if (m->count == 0)
5377 p->p_align = 1 << bed->s->log_file_align;
5381 no_contents = FALSE;
5383 if (p->p_type == PT_LOAD
5386 bfd_size_type align;
5387 unsigned int align_power = 0;
5389 if (m->p_align_valid)
5393 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5395 unsigned int secalign;
5397 secalign = bfd_get_section_alignment (abfd, *secpp);
5398 if (secalign > align_power)
5399 align_power = secalign;
5401 align = (bfd_size_type) 1 << align_power;
5402 if (align < maxpagesize)
5403 align = maxpagesize;
5406 for (i = 0; i < m->count; i++)
5407 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
5408 /* If we aren't making room for this section, then
5409 it must be SHT_NOBITS regardless of what we've
5410 set via struct bfd_elf_special_section. */
5411 elf_section_type (m->sections[i]) = SHT_NOBITS;
5413 /* Find out whether this segment contains any loadable
5416 for (i = 0; i < m->count; i++)
5417 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
5419 no_contents = FALSE;
5423 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
5425 /* Broken hardware and/or kernel require that files do not
5426 map the same page with different permissions on some hppa
5428 if (pt_load_count > 1
5429 && bed->no_page_alias
5430 && (off & (maxpagesize - 1)) != 0
5431 && (off & -maxpagesize) == ((off + off_adjust) & -maxpagesize))
5432 off_adjust += maxpagesize;
5436 /* We shouldn't need to align the segment on disk since
5437 the segment doesn't need file space, but the gABI
5438 arguably requires the alignment and glibc ld.so
5439 checks it. So to comply with the alignment
5440 requirement but not waste file space, we adjust
5441 p_offset for just this segment. (OFF_ADJUST is
5442 subtracted from OFF later.) This may put p_offset
5443 past the end of file, but that shouldn't matter. */
5448 /* Make sure the .dynamic section is the first section in the
5449 PT_DYNAMIC segment. */
5450 else if (p->p_type == PT_DYNAMIC
5452 && strcmp (m->sections[0]->name, ".dynamic") != 0)
5455 (_("%pB: The first section in the PT_DYNAMIC segment"
5456 " is not the .dynamic section"),
5458 bfd_set_error (bfd_error_bad_value);
5461 /* Set the note section type to SHT_NOTE. */
5462 else if (p->p_type == PT_NOTE)
5463 for (i = 0; i < m->count; i++)
5464 elf_section_type (m->sections[i]) = SHT_NOTE;
5470 if (m->includes_filehdr)
5472 if (!m->p_flags_valid)
5474 p->p_filesz = bed->s->sizeof_ehdr;
5475 p->p_memsz = bed->s->sizeof_ehdr;
5478 if (p->p_vaddr < (bfd_vma) off
5479 || (!m->p_paddr_valid
5480 && p->p_paddr < (bfd_vma) off))
5483 (_("%pB: not enough room for program headers,"
5484 " try linking with -N"),
5486 bfd_set_error (bfd_error_bad_value);
5491 if (!m->p_paddr_valid)
5496 if (m->includes_phdrs)
5498 if (!m->p_flags_valid)
5501 if (!m->includes_filehdr)
5503 p->p_offset = bed->s->sizeof_ehdr;
5507 p->p_vaddr -= off - p->p_offset;
5508 if (!m->p_paddr_valid)
5509 p->p_paddr -= off - p->p_offset;
5513 p->p_filesz += alloc * bed->s->sizeof_phdr;
5514 p->p_memsz += alloc * bed->s->sizeof_phdr;
5517 p->p_filesz += header_pad;
5518 p->p_memsz += header_pad;
5522 if (p->p_type == PT_LOAD
5523 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
5525 if (!m->includes_filehdr && !m->includes_phdrs)
5531 adjust = off - (p->p_offset + p->p_filesz);
5533 p->p_filesz += adjust;
5534 p->p_memsz += adjust;
5538 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5539 maps. Set filepos for sections in PT_LOAD segments, and in
5540 core files, for sections in PT_NOTE segments.
5541 assign_file_positions_for_non_load_sections will set filepos
5542 for other sections and update p_filesz for other segments. */
5543 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5546 bfd_size_type align;
5547 Elf_Internal_Shdr *this_hdr;
5550 this_hdr = &elf_section_data (sec)->this_hdr;
5551 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
5553 if ((p->p_type == PT_LOAD
5554 || p->p_type == PT_TLS)
5555 && (this_hdr->sh_type != SHT_NOBITS
5556 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
5557 && ((this_hdr->sh_flags & SHF_TLS) == 0
5558 || p->p_type == PT_TLS))))
5560 bfd_vma p_start = p->p_paddr;
5561 bfd_vma p_end = p_start + p->p_memsz;
5562 bfd_vma s_start = sec->lma;
5563 bfd_vma adjust = s_start - p_end;
5567 || p_end < p_start))
5570 /* xgettext:c-format */
5571 (_("%pB: section %pA lma %#" PRIx64 " adjusted to %#" PRIx64),
5572 abfd, sec, (uint64_t) s_start, (uint64_t) p_end);
5576 p->p_memsz += adjust;
5578 if (this_hdr->sh_type != SHT_NOBITS)
5580 if (p->p_filesz + adjust < p->p_memsz)
5582 /* We have a PROGBITS section following NOBITS ones.
5583 Allocate file space for the NOBITS section(s) and
5585 adjust = p->p_memsz - p->p_filesz;
5586 if (!write_zeros (abfd, off, adjust))
5590 p->p_filesz += adjust;
5594 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
5596 /* The section at i == 0 is the one that actually contains
5600 this_hdr->sh_offset = sec->filepos = off;
5601 off += this_hdr->sh_size;
5602 p->p_filesz = this_hdr->sh_size;
5608 /* The rest are fake sections that shouldn't be written. */
5617 if (p->p_type == PT_LOAD)
5619 this_hdr->sh_offset = sec->filepos = off;
5620 if (this_hdr->sh_type != SHT_NOBITS)
5621 off += this_hdr->sh_size;
5623 else if (this_hdr->sh_type == SHT_NOBITS
5624 && (this_hdr->sh_flags & SHF_TLS) != 0
5625 && this_hdr->sh_offset == 0)
5627 /* This is a .tbss section that didn't get a PT_LOAD.
5628 (See _bfd_elf_map_sections_to_segments "Create a
5629 final PT_LOAD".) Set sh_offset to the value it
5630 would have if we had created a zero p_filesz and
5631 p_memsz PT_LOAD header for the section. This
5632 also makes the PT_TLS header have the same
5634 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
5636 this_hdr->sh_offset = sec->filepos = off + adjust;
5639 if (this_hdr->sh_type != SHT_NOBITS)
5641 p->p_filesz += this_hdr->sh_size;
5642 /* A load section without SHF_ALLOC is something like
5643 a note section in a PT_NOTE segment. These take
5644 file space but are not loaded into memory. */
5645 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5646 p->p_memsz += this_hdr->sh_size;
5648 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5650 if (p->p_type == PT_TLS)
5651 p->p_memsz += this_hdr->sh_size;
5653 /* .tbss is special. It doesn't contribute to p_memsz of
5655 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
5656 p->p_memsz += this_hdr->sh_size;
5659 if (align > p->p_align
5660 && !m->p_align_valid
5661 && (p->p_type != PT_LOAD
5662 || (abfd->flags & D_PAGED) == 0))
5666 if (!m->p_flags_valid)
5669 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
5671 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
5678 /* Check that all sections are in a PT_LOAD segment.
5679 Don't check funky gdb generated core files. */
5680 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
5682 bfd_boolean check_vma = TRUE;
5684 for (i = 1; i < m->count; i++)
5685 if (m->sections[i]->vma == m->sections[i - 1]->vma
5686 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
5687 ->this_hdr), p) != 0
5688 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
5689 ->this_hdr), p) != 0)
5691 /* Looks like we have overlays packed into the segment. */
5696 for (i = 0; i < m->count; i++)
5698 Elf_Internal_Shdr *this_hdr;
5701 sec = m->sections[i];
5702 this_hdr = &(elf_section_data(sec)->this_hdr);
5703 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
5704 && !ELF_TBSS_SPECIAL (this_hdr, p))
5707 /* xgettext:c-format */
5708 (_("%pB: section `%pA' can't be allocated in segment %d"),
5710 print_segment_map (m);
5716 elf_next_file_pos (abfd) = off;
5720 /* Assign file positions for the other sections. */
5723 assign_file_positions_for_non_load_sections (bfd *abfd,
5724 struct bfd_link_info *link_info)
5726 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5727 Elf_Internal_Shdr **i_shdrpp;
5728 Elf_Internal_Shdr **hdrpp, **end_hdrpp;
5729 Elf_Internal_Phdr *phdrs;
5730 Elf_Internal_Phdr *p;
5731 struct elf_segment_map *m;
5732 struct elf_segment_map *hdrs_segment;
5733 bfd_vma filehdr_vaddr, filehdr_paddr;
5734 bfd_vma phdrs_vaddr, phdrs_paddr;
5738 i_shdrpp = elf_elfsections (abfd);
5739 end_hdrpp = i_shdrpp + elf_numsections (abfd);
5740 off = elf_next_file_pos (abfd);
5741 for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
5743 Elf_Internal_Shdr *hdr;
5746 if (hdr->bfd_section != NULL
5747 && (hdr->bfd_section->filepos != 0
5748 || (hdr->sh_type == SHT_NOBITS
5749 && hdr->contents == NULL)))
5750 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5751 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
5753 if (hdr->sh_size != 0)
5755 /* xgettext:c-format */
5756 (_("%pB: warning: allocated section `%s' not in segment"),
5758 (hdr->bfd_section == NULL
5760 : hdr->bfd_section->name));
5761 /* We don't need to page align empty sections. */
5762 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5763 off += vma_page_aligned_bias (hdr->sh_addr, off,
5766 off += vma_page_aligned_bias (hdr->sh_addr, off,
5768 off = _bfd_elf_assign_file_position_for_section (hdr, off,
5771 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5772 && hdr->bfd_section == NULL)
5773 || (hdr->bfd_section != NULL
5774 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5775 /* Compress DWARF debug sections. */
5776 || hdr == i_shdrpp[elf_onesymtab (abfd)]
5777 || (elf_symtab_shndx_list (abfd) != NULL
5778 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
5779 || hdr == i_shdrpp[elf_strtab_sec (abfd)]
5780 || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
5781 hdr->sh_offset = -1;
5783 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5786 /* Now that we have set the section file positions, we can set up
5787 the file positions for the non PT_LOAD segments. */
5791 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
5793 hdrs_segment = NULL;
5794 phdrs = elf_tdata (abfd)->phdr;
5795 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5798 if (p->p_type != PT_LOAD)
5801 if (m->includes_filehdr)
5803 filehdr_vaddr = p->p_vaddr;
5804 filehdr_paddr = p->p_paddr;
5806 if (m->includes_phdrs)
5808 phdrs_vaddr = p->p_vaddr;
5809 phdrs_paddr = p->p_paddr;
5810 if (m->includes_filehdr)
5813 phdrs_vaddr += bed->s->sizeof_ehdr;
5814 phdrs_paddr += bed->s->sizeof_ehdr;
5819 if (hdrs_segment != NULL && link_info != NULL)
5821 /* There is a segment that contains both the file headers and the
5822 program headers, so provide a symbol __ehdr_start pointing there.
5823 A program can use this to examine itself robustly. */
5825 struct elf_link_hash_entry *hash
5826 = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
5827 FALSE, FALSE, TRUE);
5828 /* If the symbol was referenced and not defined, define it. */
5830 && (hash->root.type == bfd_link_hash_new
5831 || hash->root.type == bfd_link_hash_undefined
5832 || hash->root.type == bfd_link_hash_undefweak
5833 || hash->root.type == bfd_link_hash_common))
5836 if (hdrs_segment->count != 0)
5837 /* The segment contains sections, so use the first one. */
5838 s = hdrs_segment->sections[0];
5840 /* Use the first (i.e. lowest-addressed) section in any segment. */
5841 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5850 hash->root.u.def.value = filehdr_vaddr - s->vma;
5851 hash->root.u.def.section = s;
5855 hash->root.u.def.value = filehdr_vaddr;
5856 hash->root.u.def.section = bfd_abs_section_ptr;
5859 hash->root.type = bfd_link_hash_defined;
5860 hash->def_regular = 1;
5865 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5867 if (p->p_type == PT_GNU_RELRO)
5872 if (link_info != NULL)
5874 /* During linking the range of the RELRO segment is passed
5875 in link_info. Note that there may be padding between
5876 relro_start and the first RELRO section. */
5877 start = link_info->relro_start;
5878 end = link_info->relro_end;
5880 else if (m->count != 0)
5882 if (!m->p_size_valid)
5884 start = m->sections[0]->vma;
5885 end = start + m->p_size;
5896 struct elf_segment_map *lm;
5897 const Elf_Internal_Phdr *lp;
5900 /* Find a LOAD segment containing a section in the RELRO
5902 for (lm = elf_seg_map (abfd), lp = phdrs;
5904 lm = lm->next, lp++)
5906 if (lp->p_type == PT_LOAD
5908 && (lm->sections[lm->count - 1]->vma
5909 + (!IS_TBSS (lm->sections[lm->count - 1])
5910 ? lm->sections[lm->count - 1]->size
5912 && lm->sections[0]->vma < end)
5918 /* Find the section starting the RELRO segment. */
5919 for (i = 0; i < lm->count; i++)
5921 asection *s = lm->sections[i];
5930 p->p_vaddr = lm->sections[i]->vma;
5931 p->p_paddr = lm->sections[i]->lma;
5932 p->p_offset = lm->sections[i]->filepos;
5933 p->p_memsz = end - p->p_vaddr;
5934 p->p_filesz = p->p_memsz;
5936 /* The RELRO segment typically ends a few bytes
5937 into .got.plt but other layouts are possible.
5938 In cases where the end does not match any
5939 loaded section (for instance is in file
5940 padding), trim p_filesz back to correspond to
5941 the end of loaded section contents. */
5942 if (p->p_filesz > lp->p_vaddr + lp->p_filesz - p->p_vaddr)
5943 p->p_filesz = lp->p_vaddr + lp->p_filesz - p->p_vaddr;
5945 /* Preserve the alignment and flags if they are
5946 valid. The gold linker generates RW/4 for
5947 the PT_GNU_RELRO section. It is better for
5948 objcopy/strip to honor these attributes
5949 otherwise gdb will choke when using separate
5951 if (!m->p_align_valid)
5953 if (!m->p_flags_valid)
5959 if (link_info != NULL)
5962 memset (p, 0, sizeof *p);
5964 else if (p->p_type == PT_GNU_STACK)
5966 if (m->p_size_valid)
5967 p->p_memsz = m->p_size;
5969 else if (m->count != 0)
5973 if (p->p_type != PT_LOAD
5974 && (p->p_type != PT_NOTE
5975 || bfd_get_format (abfd) != bfd_core))
5977 /* A user specified segment layout may include a PHDR
5978 segment that overlaps with a LOAD segment... */
5979 if (p->p_type == PT_PHDR)
5985 if (m->includes_filehdr || m->includes_phdrs)
5987 /* PR 17512: file: 2195325e. */
5989 (_("%pB: error: non-load segment %d includes file header "
5990 "and/or program header"),
5991 abfd, (int) (p - phdrs));
5996 p->p_offset = m->sections[0]->filepos;
5997 for (i = m->count; i-- != 0;)
5999 asection *sect = m->sections[i];
6000 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
6001 if (hdr->sh_type != SHT_NOBITS)
6003 p->p_filesz = (sect->filepos - m->sections[0]->filepos
6010 else if (m->includes_filehdr)
6012 p->p_vaddr = filehdr_vaddr;
6013 if (! m->p_paddr_valid)
6014 p->p_paddr = filehdr_paddr;
6016 else if (m->includes_phdrs)
6018 p->p_vaddr = phdrs_vaddr;
6019 if (! m->p_paddr_valid)
6020 p->p_paddr = phdrs_paddr;
6024 elf_next_file_pos (abfd) = off;
6029 static elf_section_list *
6030 find_section_in_list (unsigned int i, elf_section_list * list)
6032 for (;list != NULL; list = list->next)
6038 /* Work out the file positions of all the sections. This is called by
6039 _bfd_elf_compute_section_file_positions. All the section sizes and
6040 VMAs must be known before this is called.
6042 Reloc sections come in two flavours: Those processed specially as
6043 "side-channel" data attached to a section to which they apply, and
6044 those that bfd doesn't process as relocations. The latter sort are
6045 stored in a normal bfd section by bfd_section_from_shdr. We don't
6046 consider the former sort here, unless they form part of the loadable
6047 image. Reloc sections not assigned here will be handled later by
6048 assign_file_positions_for_relocs.
6050 We also don't set the positions of the .symtab and .strtab here. */
6053 assign_file_positions_except_relocs (bfd *abfd,
6054 struct bfd_link_info *link_info)
6056 struct elf_obj_tdata *tdata = elf_tdata (abfd);
6057 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6058 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6060 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
6061 && bfd_get_format (abfd) != bfd_core)
6063 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
6064 unsigned int num_sec = elf_numsections (abfd);
6065 Elf_Internal_Shdr **hdrpp;
6069 /* Start after the ELF header. */
6070 off = i_ehdrp->e_ehsize;
6072 /* We are not creating an executable, which means that we are
6073 not creating a program header, and that the actual order of
6074 the sections in the file is unimportant. */
6075 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
6077 Elf_Internal_Shdr *hdr;
6080 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
6081 && hdr->bfd_section == NULL)
6082 || (hdr->bfd_section != NULL
6083 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
6084 /* Compress DWARF debug sections. */
6085 || i == elf_onesymtab (abfd)
6086 || (elf_symtab_shndx_list (abfd) != NULL
6087 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
6088 || i == elf_strtab_sec (abfd)
6089 || i == elf_shstrtab_sec (abfd))
6091 hdr->sh_offset = -1;
6094 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
6097 elf_next_file_pos (abfd) = off;
6103 /* Assign file positions for the loaded sections based on the
6104 assignment of sections to segments. */
6105 if (!assign_file_positions_for_load_sections (abfd, link_info))
6108 /* And for non-load sections. */
6109 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
6112 if (bed->elf_backend_modify_program_headers != NULL)
6114 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
6118 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
6119 if (link_info != NULL && bfd_link_pie (link_info))
6121 unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
6122 Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
6123 Elf_Internal_Phdr *end_segment = &segment[num_segments];
6125 /* Find the lowest p_vaddr in PT_LOAD segments. */
6126 bfd_vma p_vaddr = (bfd_vma) -1;
6127 for (; segment < end_segment; segment++)
6128 if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
6129 p_vaddr = segment->p_vaddr;
6131 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6132 segments is non-zero. */
6134 i_ehdrp->e_type = ET_EXEC;
6137 /* Write out the program headers. */
6138 alloc = elf_elfheader (abfd)->e_phnum;
6142 /* PR ld/20815 - Check that the program header segment, if present, will
6143 be loaded into memory. FIXME: The check below is not sufficient as
6144 really all PT_LOAD segments should be checked before issuing an error
6145 message. Plus the PHDR segment does not have to be the first segment
6146 in the program header table. But this version of the check should
6147 catch all real world use cases.
6149 FIXME: We used to have code here to sort the PT_LOAD segments into
6150 ascending order, as per the ELF spec. But this breaks some programs,
6151 including the Linux kernel. But really either the spec should be
6152 changed or the programs updated. */
6154 && tdata->phdr[0].p_type == PT_PHDR
6155 && (bed->elf_backend_allow_non_load_phdr == NULL
6156 || !bed->elf_backend_allow_non_load_phdr (abfd, tdata->phdr,
6158 && tdata->phdr[1].p_type == PT_LOAD
6159 && (tdata->phdr[1].p_vaddr > tdata->phdr[0].p_vaddr
6160 || (tdata->phdr[1].p_vaddr + tdata->phdr[1].p_memsz
6161 < tdata->phdr[0].p_vaddr + tdata->phdr[0].p_memsz)))
6163 /* The fix for this error is usually to edit the linker script being
6164 used and set up the program headers manually. Either that or
6165 leave room for the headers at the start of the SECTIONS. */
6166 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
6167 " by LOAD segment"),
6172 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
6173 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
6181 prep_headers (bfd *abfd)
6183 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
6184 struct elf_strtab_hash *shstrtab;
6185 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6187 i_ehdrp = elf_elfheader (abfd);
6189 shstrtab = _bfd_elf_strtab_init ();
6190 if (shstrtab == NULL)
6193 elf_shstrtab (abfd) = shstrtab;
6195 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
6196 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
6197 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
6198 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
6200 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
6201 i_ehdrp->e_ident[EI_DATA] =
6202 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
6203 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
6205 if ((abfd->flags & DYNAMIC) != 0)
6206 i_ehdrp->e_type = ET_DYN;
6207 else if ((abfd->flags & EXEC_P) != 0)
6208 i_ehdrp->e_type = ET_EXEC;
6209 else if (bfd_get_format (abfd) == bfd_core)
6210 i_ehdrp->e_type = ET_CORE;
6212 i_ehdrp->e_type = ET_REL;
6214 switch (bfd_get_arch (abfd))
6216 case bfd_arch_unknown:
6217 i_ehdrp->e_machine = EM_NONE;
6220 /* There used to be a long list of cases here, each one setting
6221 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6222 in the corresponding bfd definition. To avoid duplication,
6223 the switch was removed. Machines that need special handling
6224 can generally do it in elf_backend_final_write_processing(),
6225 unless they need the information earlier than the final write.
6226 Such need can generally be supplied by replacing the tests for
6227 e_machine with the conditions used to determine it. */
6229 i_ehdrp->e_machine = bed->elf_machine_code;
6232 i_ehdrp->e_version = bed->s->ev_current;
6233 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
6235 /* No program header, for now. */
6236 i_ehdrp->e_phoff = 0;
6237 i_ehdrp->e_phentsize = 0;
6238 i_ehdrp->e_phnum = 0;
6240 /* Each bfd section is section header entry. */
6241 i_ehdrp->e_entry = bfd_get_start_address (abfd);
6242 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
6244 /* If we're building an executable, we'll need a program header table. */
6245 if (abfd->flags & EXEC_P)
6246 /* It all happens later. */
6250 i_ehdrp->e_phentsize = 0;
6251 i_ehdrp->e_phoff = 0;
6254 elf_tdata (abfd)->symtab_hdr.sh_name =
6255 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
6256 elf_tdata (abfd)->strtab_hdr.sh_name =
6257 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
6258 elf_tdata (abfd)->shstrtab_hdr.sh_name =
6259 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
6260 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
6261 || elf_tdata (abfd)->strtab_hdr.sh_name == (unsigned int) -1
6262 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
6268 /* Assign file positions for all the reloc sections which are not part
6269 of the loadable file image, and the file position of section headers. */
6272 _bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
6275 Elf_Internal_Shdr **shdrpp, **end_shdrpp;
6276 Elf_Internal_Shdr *shdrp;
6277 Elf_Internal_Ehdr *i_ehdrp;
6278 const struct elf_backend_data *bed;
6280 off = elf_next_file_pos (abfd);
6282 shdrpp = elf_elfsections (abfd);
6283 end_shdrpp = shdrpp + elf_numsections (abfd);
6284 for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
6287 if (shdrp->sh_offset == -1)
6289 asection *sec = shdrp->bfd_section;
6290 bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
6291 || shdrp->sh_type == SHT_RELA);
6293 || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
6297 const char *name = sec->name;
6298 struct bfd_elf_section_data *d;
6300 /* Compress DWARF debug sections. */
6301 if (!bfd_compress_section (abfd, sec,
6305 if (sec->compress_status == COMPRESS_SECTION_DONE
6306 && (abfd->flags & BFD_COMPRESS_GABI) == 0)
6308 /* If section is compressed with zlib-gnu, convert
6309 section name from .debug_* to .zdebug_*. */
6311 = convert_debug_to_zdebug (abfd, name);
6312 if (new_name == NULL)
6316 /* Add section name to section name section. */
6317 if (shdrp->sh_name != (unsigned int) -1)
6320 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
6322 d = elf_section_data (sec);
6324 /* Add reloc section name to section name section. */
6326 && !_bfd_elf_set_reloc_sh_name (abfd,
6331 && !_bfd_elf_set_reloc_sh_name (abfd,
6336 /* Update section size and contents. */
6337 shdrp->sh_size = sec->size;
6338 shdrp->contents = sec->contents;
6339 shdrp->bfd_section->contents = NULL;
6341 off = _bfd_elf_assign_file_position_for_section (shdrp,
6348 /* Place section name section after DWARF debug sections have been
6350 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
6351 shdrp = &elf_tdata (abfd)->shstrtab_hdr;
6352 shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
6353 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
6355 /* Place the section headers. */
6356 i_ehdrp = elf_elfheader (abfd);
6357 bed = get_elf_backend_data (abfd);
6358 off = align_file_position (off, 1 << bed->s->log_file_align);
6359 i_ehdrp->e_shoff = off;
6360 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
6361 elf_next_file_pos (abfd) = off;
6367 _bfd_elf_write_object_contents (bfd *abfd)
6369 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6370 Elf_Internal_Shdr **i_shdrp;
6372 unsigned int count, num_sec;
6373 struct elf_obj_tdata *t;
6375 if (! abfd->output_has_begun
6376 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6379 i_shdrp = elf_elfsections (abfd);
6382 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
6386 if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
6389 /* After writing the headers, we need to write the sections too... */
6390 num_sec = elf_numsections (abfd);
6391 for (count = 1; count < num_sec; count++)
6393 i_shdrp[count]->sh_name
6394 = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
6395 i_shdrp[count]->sh_name);
6396 if (bed->elf_backend_section_processing)
6397 if (!(*bed->elf_backend_section_processing) (abfd, i_shdrp[count]))
6399 if (i_shdrp[count]->contents)
6401 bfd_size_type amt = i_shdrp[count]->sh_size;
6403 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
6404 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
6409 /* Write out the section header names. */
6410 t = elf_tdata (abfd);
6411 if (elf_shstrtab (abfd) != NULL
6412 && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
6413 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
6416 if (bed->elf_backend_final_write_processing)
6417 (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
6419 if (!bed->s->write_shdrs_and_ehdr (abfd))
6422 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6423 if (t->o->build_id.after_write_object_contents != NULL)
6424 return (*t->o->build_id.after_write_object_contents) (abfd);
6430 _bfd_elf_write_corefile_contents (bfd *abfd)
6432 /* Hopefully this can be done just like an object file. */
6433 return _bfd_elf_write_object_contents (abfd);
6436 /* Given a section, search the header to find them. */
6439 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
6441 const struct elf_backend_data *bed;
6442 unsigned int sec_index;
6444 if (elf_section_data (asect) != NULL
6445 && elf_section_data (asect)->this_idx != 0)
6446 return elf_section_data (asect)->this_idx;
6448 if (bfd_is_abs_section (asect))
6449 sec_index = SHN_ABS;
6450 else if (bfd_is_com_section (asect))
6451 sec_index = SHN_COMMON;
6452 else if (bfd_is_und_section (asect))
6453 sec_index = SHN_UNDEF;
6455 sec_index = SHN_BAD;
6457 bed = get_elf_backend_data (abfd);
6458 if (bed->elf_backend_section_from_bfd_section)
6460 int retval = sec_index;
6462 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
6466 if (sec_index == SHN_BAD)
6467 bfd_set_error (bfd_error_nonrepresentable_section);
6472 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6476 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
6478 asymbol *asym_ptr = *asym_ptr_ptr;
6480 flagword flags = asym_ptr->flags;
6482 /* When gas creates relocations against local labels, it creates its
6483 own symbol for the section, but does put the symbol into the
6484 symbol chain, so udata is 0. When the linker is generating
6485 relocatable output, this section symbol may be for one of the
6486 input sections rather than the output section. */
6487 if (asym_ptr->udata.i == 0
6488 && (flags & BSF_SECTION_SYM)
6489 && asym_ptr->section)
6494 sec = asym_ptr->section;
6495 if (sec->owner != abfd && sec->output_section != NULL)
6496 sec = sec->output_section;
6497 if (sec->owner == abfd
6498 && (indx = sec->index) < elf_num_section_syms (abfd)
6499 && elf_section_syms (abfd)[indx] != NULL)
6500 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
6503 idx = asym_ptr->udata.i;
6507 /* This case can occur when using --strip-symbol on a symbol
6508 which is used in a relocation entry. */
6510 /* xgettext:c-format */
6511 (_("%pB: symbol `%s' required but not present"),
6512 abfd, bfd_asymbol_name (asym_ptr));
6513 bfd_set_error (bfd_error_no_symbols);
6520 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6521 (long) asym_ptr, asym_ptr->name, idx, flags);
6529 /* Rewrite program header information. */
6532 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
6534 Elf_Internal_Ehdr *iehdr;
6535 struct elf_segment_map *map;
6536 struct elf_segment_map *map_first;
6537 struct elf_segment_map **pointer_to_map;
6538 Elf_Internal_Phdr *segment;
6541 unsigned int num_segments;
6542 bfd_boolean phdr_included = FALSE;
6543 bfd_boolean p_paddr_valid;
6544 bfd_vma maxpagesize;
6545 struct elf_segment_map *phdr_adjust_seg = NULL;
6546 unsigned int phdr_adjust_num = 0;
6547 const struct elf_backend_data *bed;
6549 bed = get_elf_backend_data (ibfd);
6550 iehdr = elf_elfheader (ibfd);
6553 pointer_to_map = &map_first;
6555 num_segments = elf_elfheader (ibfd)->e_phnum;
6556 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
6558 /* Returns the end address of the segment + 1. */
6559 #define SEGMENT_END(segment, start) \
6560 (start + (segment->p_memsz > segment->p_filesz \
6561 ? segment->p_memsz : segment->p_filesz))
6563 #define SECTION_SIZE(section, segment) \
6564 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6565 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6566 ? section->size : 0)
6568 /* Returns TRUE if the given section is contained within
6569 the given segment. VMA addresses are compared. */
6570 #define IS_CONTAINED_BY_VMA(section, segment) \
6571 (section->vma >= segment->p_vaddr \
6572 && (section->vma + SECTION_SIZE (section, segment) \
6573 <= (SEGMENT_END (segment, segment->p_vaddr))))
6575 /* Returns TRUE if the given section is contained within
6576 the given segment. LMA addresses are compared. */
6577 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6578 (section->lma >= base \
6579 && (section->lma + SECTION_SIZE (section, segment) \
6580 <= SEGMENT_END (segment, base)))
6582 /* Handle PT_NOTE segment. */
6583 #define IS_NOTE(p, s) \
6584 (p->p_type == PT_NOTE \
6585 && elf_section_type (s) == SHT_NOTE \
6586 && (bfd_vma) s->filepos >= p->p_offset \
6587 && ((bfd_vma) s->filepos + s->size \
6588 <= p->p_offset + p->p_filesz))
6590 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6592 #define IS_COREFILE_NOTE(p, s) \
6594 && bfd_get_format (ibfd) == bfd_core \
6598 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6599 linker, which generates a PT_INTERP section with p_vaddr and
6600 p_memsz set to 0. */
6601 #define IS_SOLARIS_PT_INTERP(p, s) \
6603 && p->p_paddr == 0 \
6604 && p->p_memsz == 0 \
6605 && p->p_filesz > 0 \
6606 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6608 && (bfd_vma) s->filepos >= p->p_offset \
6609 && ((bfd_vma) s->filepos + s->size \
6610 <= p->p_offset + p->p_filesz))
6612 /* Decide if the given section should be included in the given segment.
6613 A section will be included if:
6614 1. It is within the address space of the segment -- we use the LMA
6615 if that is set for the segment and the VMA otherwise,
6616 2. It is an allocated section or a NOTE section in a PT_NOTE
6618 3. There is an output section associated with it,
6619 4. The section has not already been allocated to a previous segment.
6620 5. PT_GNU_STACK segments do not include any sections.
6621 6. PT_TLS segment includes only SHF_TLS sections.
6622 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6623 8. PT_DYNAMIC should not contain empty sections at the beginning
6624 (with the possible exception of .dynamic). */
6625 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6626 ((((segment->p_paddr \
6627 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6628 : IS_CONTAINED_BY_VMA (section, segment)) \
6629 && (section->flags & SEC_ALLOC) != 0) \
6630 || IS_NOTE (segment, section)) \
6631 && segment->p_type != PT_GNU_STACK \
6632 && (segment->p_type != PT_TLS \
6633 || (section->flags & SEC_THREAD_LOCAL)) \
6634 && (segment->p_type == PT_LOAD \
6635 || segment->p_type == PT_TLS \
6636 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6637 && (segment->p_type != PT_DYNAMIC \
6638 || SECTION_SIZE (section, segment) > 0 \
6639 || (segment->p_paddr \
6640 ? segment->p_paddr != section->lma \
6641 : segment->p_vaddr != section->vma) \
6642 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6644 && (segment->p_type != PT_LOAD || !section->segment_mark))
6646 /* If the output section of a section in the input segment is NULL,
6647 it is removed from the corresponding output segment. */
6648 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6649 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6650 && section->output_section != NULL)
6652 /* Returns TRUE iff seg1 starts after the end of seg2. */
6653 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6654 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6656 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6657 their VMA address ranges and their LMA address ranges overlap.
6658 It is possible to have overlapping VMA ranges without overlapping LMA
6659 ranges. RedBoot images for example can have both .data and .bss mapped
6660 to the same VMA range, but with the .data section mapped to a different
6662 #define SEGMENT_OVERLAPS(seg1, seg2) \
6663 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6664 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6665 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6666 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6668 /* Initialise the segment mark field. */
6669 for (section = ibfd->sections; section != NULL; section = section->next)
6670 section->segment_mark = FALSE;
6672 /* The Solaris linker creates program headers in which all the
6673 p_paddr fields are zero. When we try to objcopy or strip such a
6674 file, we get confused. Check for this case, and if we find it
6675 don't set the p_paddr_valid fields. */
6676 p_paddr_valid = FALSE;
6677 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6680 if (segment->p_paddr != 0)
6682 p_paddr_valid = TRUE;
6686 /* Scan through the segments specified in the program header
6687 of the input BFD. For this first scan we look for overlaps
6688 in the loadable segments. These can be created by weird
6689 parameters to objcopy. Also, fix some solaris weirdness. */
6690 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6695 Elf_Internal_Phdr *segment2;
6697 if (segment->p_type == PT_INTERP)
6698 for (section = ibfd->sections; section; section = section->next)
6699 if (IS_SOLARIS_PT_INTERP (segment, section))
6701 /* Mininal change so that the normal section to segment
6702 assignment code will work. */
6703 segment->p_vaddr = section->vma;
6707 if (segment->p_type != PT_LOAD)
6709 /* Remove PT_GNU_RELRO segment. */
6710 if (segment->p_type == PT_GNU_RELRO)
6711 segment->p_type = PT_NULL;
6715 /* Determine if this segment overlaps any previous segments. */
6716 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
6718 bfd_signed_vma extra_length;
6720 if (segment2->p_type != PT_LOAD
6721 || !SEGMENT_OVERLAPS (segment, segment2))
6724 /* Merge the two segments together. */
6725 if (segment2->p_vaddr < segment->p_vaddr)
6727 /* Extend SEGMENT2 to include SEGMENT and then delete
6729 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
6730 - SEGMENT_END (segment2, segment2->p_vaddr));
6732 if (extra_length > 0)
6734 segment2->p_memsz += extra_length;
6735 segment2->p_filesz += extra_length;
6738 segment->p_type = PT_NULL;
6740 /* Since we have deleted P we must restart the outer loop. */
6742 segment = elf_tdata (ibfd)->phdr;
6747 /* Extend SEGMENT to include SEGMENT2 and then delete
6749 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
6750 - SEGMENT_END (segment, segment->p_vaddr));
6752 if (extra_length > 0)
6754 segment->p_memsz += extra_length;
6755 segment->p_filesz += extra_length;
6758 segment2->p_type = PT_NULL;
6763 /* The second scan attempts to assign sections to segments. */
6764 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6768 unsigned int section_count;
6769 asection **sections;
6770 asection *output_section;
6772 asection *matching_lma;
6773 asection *suggested_lma;
6776 asection *first_section;
6778 if (segment->p_type == PT_NULL)
6781 first_section = NULL;
6782 /* Compute how many sections might be placed into this segment. */
6783 for (section = ibfd->sections, section_count = 0;
6785 section = section->next)
6787 /* Find the first section in the input segment, which may be
6788 removed from the corresponding output segment. */
6789 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6791 if (first_section == NULL)
6792 first_section = section;
6793 if (section->output_section != NULL)
6798 /* Allocate a segment map big enough to contain
6799 all of the sections we have selected. */
6800 amt = sizeof (struct elf_segment_map);
6801 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6802 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6806 /* Initialise the fields of the segment map. Default to
6807 using the physical address of the segment in the input BFD. */
6809 map->p_type = segment->p_type;
6810 map->p_flags = segment->p_flags;
6811 map->p_flags_valid = 1;
6813 /* If the first section in the input segment is removed, there is
6814 no need to preserve segment physical address in the corresponding
6816 if (!first_section || first_section->output_section != NULL)
6818 map->p_paddr = segment->p_paddr;
6819 map->p_paddr_valid = p_paddr_valid;
6822 /* Determine if this segment contains the ELF file header
6823 and if it contains the program headers themselves. */
6824 map->includes_filehdr = (segment->p_offset == 0
6825 && segment->p_filesz >= iehdr->e_ehsize);
6826 map->includes_phdrs = 0;
6828 if (!phdr_included || segment->p_type != PT_LOAD)
6830 map->includes_phdrs =
6831 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6832 && (segment->p_offset + segment->p_filesz
6833 >= ((bfd_vma) iehdr->e_phoff
6834 + iehdr->e_phnum * iehdr->e_phentsize)));
6836 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6837 phdr_included = TRUE;
6840 if (section_count == 0)
6842 /* Special segments, such as the PT_PHDR segment, may contain
6843 no sections, but ordinary, loadable segments should contain
6844 something. They are allowed by the ELF spec however, so only
6845 a warning is produced.
6846 There is however the valid use case of embedded systems which
6847 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6848 flash memory with zeros. No warning is shown for that case. */
6849 if (segment->p_type == PT_LOAD
6850 && (segment->p_filesz > 0 || segment->p_memsz == 0))
6851 /* xgettext:c-format */
6853 (_("%pB: warning: empty loadable segment detected"
6854 " at vaddr=%#" PRIx64 ", is this intentional?"),
6855 ibfd, (uint64_t) segment->p_vaddr);
6858 *pointer_to_map = map;
6859 pointer_to_map = &map->next;
6864 /* Now scan the sections in the input BFD again and attempt
6865 to add their corresponding output sections to the segment map.
6866 The problem here is how to handle an output section which has
6867 been moved (ie had its LMA changed). There are four possibilities:
6869 1. None of the sections have been moved.
6870 In this case we can continue to use the segment LMA from the
6873 2. All of the sections have been moved by the same amount.
6874 In this case we can change the segment's LMA to match the LMA
6875 of the first section.
6877 3. Some of the sections have been moved, others have not.
6878 In this case those sections which have not been moved can be
6879 placed in the current segment which will have to have its size,
6880 and possibly its LMA changed, and a new segment or segments will
6881 have to be created to contain the other sections.
6883 4. The sections have been moved, but not by the same amount.
6884 In this case we can change the segment's LMA to match the LMA
6885 of the first section and we will have to create a new segment
6886 or segments to contain the other sections.
6888 In order to save time, we allocate an array to hold the section
6889 pointers that we are interested in. As these sections get assigned
6890 to a segment, they are removed from this array. */
6892 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
6893 if (sections == NULL)
6896 /* Step One: Scan for segment vs section LMA conflicts.
6897 Also add the sections to the section array allocated above.
6898 Also add the sections to the current segment. In the common
6899 case, where the sections have not been moved, this means that
6900 we have completely filled the segment, and there is nothing
6903 matching_lma = NULL;
6904 suggested_lma = NULL;
6906 for (section = first_section, j = 0;
6908 section = section->next)
6910 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
6912 output_section = section->output_section;
6914 sections[j++] = section;
6916 /* The Solaris native linker always sets p_paddr to 0.
6917 We try to catch that case here, and set it to the
6918 correct value. Note - some backends require that
6919 p_paddr be left as zero. */
6921 && segment->p_vaddr != 0
6922 && !bed->want_p_paddr_set_to_zero
6924 && output_section->lma != 0
6925 && (align_power (segment->p_vaddr
6926 + (map->includes_filehdr
6927 ? iehdr->e_ehsize : 0)
6928 + (map->includes_phdrs
6929 ? iehdr->e_phnum * iehdr->e_phentsize
6931 output_section->alignment_power)
6932 == output_section->vma))
6933 map->p_paddr = segment->p_vaddr;
6935 /* Match up the physical address of the segment with the
6936 LMA address of the output section. */
6937 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
6938 || IS_COREFILE_NOTE (segment, section)
6939 || (bed->want_p_paddr_set_to_zero
6940 && IS_CONTAINED_BY_VMA (output_section, segment)))
6942 if (matching_lma == NULL
6943 || output_section->lma < matching_lma->lma)
6944 matching_lma = output_section;
6946 /* We assume that if the section fits within the segment
6947 then it does not overlap any other section within that
6949 map->sections[isec++] = output_section;
6951 else if (suggested_lma == NULL)
6952 suggested_lma = output_section;
6954 if (j == section_count)
6959 BFD_ASSERT (j == section_count);
6961 /* Step Two: Adjust the physical address of the current segment,
6963 if (isec == section_count)
6965 /* All of the sections fitted within the segment as currently
6966 specified. This is the default case. Add the segment to
6967 the list of built segments and carry on to process the next
6968 program header in the input BFD. */
6969 map->count = section_count;
6970 *pointer_to_map = map;
6971 pointer_to_map = &map->next;
6974 && !bed->want_p_paddr_set_to_zero
6975 && matching_lma->lma != map->p_paddr
6976 && !map->includes_filehdr
6977 && !map->includes_phdrs)
6978 /* There is some padding before the first section in the
6979 segment. So, we must account for that in the output
6981 map->p_vaddr_offset = matching_lma->lma - map->p_paddr;
6988 /* Change the current segment's physical address to match
6989 the LMA of the first section that fitted, or if no
6990 section fitted, the first section. */
6991 if (matching_lma == NULL)
6992 matching_lma = suggested_lma;
6994 map->p_paddr = matching_lma->lma;
6996 /* Offset the segment physical address from the lma
6997 to allow for space taken up by elf headers. */
6998 if (map->includes_phdrs)
7000 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
7002 /* iehdr->e_phnum is just an estimate of the number
7003 of program headers that we will need. Make a note
7004 here of the number we used and the segment we chose
7005 to hold these headers, so that we can adjust the
7006 offset when we know the correct value. */
7007 phdr_adjust_num = iehdr->e_phnum;
7008 phdr_adjust_seg = map;
7011 if (map->includes_filehdr)
7013 bfd_vma align = (bfd_vma) 1 << matching_lma->alignment_power;
7014 map->p_paddr -= iehdr->e_ehsize;
7015 /* We've subtracted off the size of headers from the
7016 first section lma, but there may have been some
7017 alignment padding before that section too. Try to
7018 account for that by adjusting the segment lma down to
7019 the same alignment. */
7020 if (segment->p_align != 0 && segment->p_align < align)
7021 align = segment->p_align;
7022 map->p_paddr &= -align;
7026 /* Step Three: Loop over the sections again, this time assigning
7027 those that fit to the current segment and removing them from the
7028 sections array; but making sure not to leave large gaps. Once all
7029 possible sections have been assigned to the current segment it is
7030 added to the list of built segments and if sections still remain
7031 to be assigned, a new segment is constructed before repeating
7037 suggested_lma = NULL;
7039 /* Fill the current segment with sections that fit. */
7040 for (j = 0; j < section_count; j++)
7042 section = sections[j];
7044 if (section == NULL)
7047 output_section = section->output_section;
7049 BFD_ASSERT (output_section != NULL);
7051 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7052 || IS_COREFILE_NOTE (segment, section))
7054 if (map->count == 0)
7056 /* If the first section in a segment does not start at
7057 the beginning of the segment, then something is
7059 if (align_power (map->p_paddr
7060 + (map->includes_filehdr
7061 ? iehdr->e_ehsize : 0)
7062 + (map->includes_phdrs
7063 ? iehdr->e_phnum * iehdr->e_phentsize
7065 output_section->alignment_power)
7066 != output_section->lma)
7073 prev_sec = map->sections[map->count - 1];
7075 /* If the gap between the end of the previous section
7076 and the start of this section is more than
7077 maxpagesize then we need to start a new segment. */
7078 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
7080 < BFD_ALIGN (output_section->lma, maxpagesize))
7081 || (prev_sec->lma + prev_sec->size
7082 > output_section->lma))
7084 if (suggested_lma == NULL)
7085 suggested_lma = output_section;
7091 map->sections[map->count++] = output_section;
7094 if (segment->p_type == PT_LOAD)
7095 section->segment_mark = TRUE;
7097 else if (suggested_lma == NULL)
7098 suggested_lma = output_section;
7101 BFD_ASSERT (map->count > 0);
7103 /* Add the current segment to the list of built segments. */
7104 *pointer_to_map = map;
7105 pointer_to_map = &map->next;
7107 if (isec < section_count)
7109 /* We still have not allocated all of the sections to
7110 segments. Create a new segment here, initialise it
7111 and carry on looping. */
7112 amt = sizeof (struct elf_segment_map);
7113 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
7114 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7121 /* Initialise the fields of the segment map. Set the physical
7122 physical address to the LMA of the first section that has
7123 not yet been assigned. */
7125 map->p_type = segment->p_type;
7126 map->p_flags = segment->p_flags;
7127 map->p_flags_valid = 1;
7128 map->p_paddr = suggested_lma->lma;
7129 map->p_paddr_valid = p_paddr_valid;
7130 map->includes_filehdr = 0;
7131 map->includes_phdrs = 0;
7134 while (isec < section_count);
7139 elf_seg_map (obfd) = map_first;
7141 /* If we had to estimate the number of program headers that were
7142 going to be needed, then check our estimate now and adjust
7143 the offset if necessary. */
7144 if (phdr_adjust_seg != NULL)
7148 for (count = 0, map = map_first; map != NULL; map = map->next)
7151 if (count > phdr_adjust_num)
7152 phdr_adjust_seg->p_paddr
7153 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
7155 for (map = map_first; map != NULL; map = map->next)
7156 if (map->p_type == PT_PHDR)
7159 = phdr_adjust_seg->includes_filehdr ? iehdr->e_ehsize : 0;
7160 map->p_paddr = phdr_adjust_seg->p_paddr + adjust;
7167 #undef IS_CONTAINED_BY_VMA
7168 #undef IS_CONTAINED_BY_LMA
7170 #undef IS_COREFILE_NOTE
7171 #undef IS_SOLARIS_PT_INTERP
7172 #undef IS_SECTION_IN_INPUT_SEGMENT
7173 #undef INCLUDE_SECTION_IN_SEGMENT
7174 #undef SEGMENT_AFTER_SEGMENT
7175 #undef SEGMENT_OVERLAPS
7179 /* Copy ELF program header information. */
7182 copy_elf_program_header (bfd *ibfd, bfd *obfd)
7184 Elf_Internal_Ehdr *iehdr;
7185 struct elf_segment_map *map;
7186 struct elf_segment_map *map_first;
7187 struct elf_segment_map **pointer_to_map;
7188 Elf_Internal_Phdr *segment;
7190 unsigned int num_segments;
7191 bfd_boolean phdr_included = FALSE;
7192 bfd_boolean p_paddr_valid;
7194 iehdr = elf_elfheader (ibfd);
7197 pointer_to_map = &map_first;
7199 /* If all the segment p_paddr fields are zero, don't set
7200 map->p_paddr_valid. */
7201 p_paddr_valid = FALSE;
7202 num_segments = elf_elfheader (ibfd)->e_phnum;
7203 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7206 if (segment->p_paddr != 0)
7208 p_paddr_valid = TRUE;
7212 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7217 unsigned int section_count;
7219 Elf_Internal_Shdr *this_hdr;
7220 asection *first_section = NULL;
7221 asection *lowest_section;
7223 /* Compute how many sections are in this segment. */
7224 for (section = ibfd->sections, section_count = 0;
7226 section = section->next)
7228 this_hdr = &(elf_section_data(section)->this_hdr);
7229 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7231 if (first_section == NULL)
7232 first_section = section;
7237 /* Allocate a segment map big enough to contain
7238 all of the sections we have selected. */
7239 amt = sizeof (struct elf_segment_map);
7240 if (section_count != 0)
7241 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
7242 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7246 /* Initialize the fields of the output segment map with the
7249 map->p_type = segment->p_type;
7250 map->p_flags = segment->p_flags;
7251 map->p_flags_valid = 1;
7252 map->p_paddr = segment->p_paddr;
7253 map->p_paddr_valid = p_paddr_valid;
7254 map->p_align = segment->p_align;
7255 map->p_align_valid = 1;
7256 map->p_vaddr_offset = 0;
7258 if (map->p_type == PT_GNU_RELRO
7259 || map->p_type == PT_GNU_STACK)
7261 /* The PT_GNU_RELRO segment may contain the first a few
7262 bytes in the .got.plt section even if the whole .got.plt
7263 section isn't in the PT_GNU_RELRO segment. We won't
7264 change the size of the PT_GNU_RELRO segment.
7265 Similarly, PT_GNU_STACK size is significant on uclinux
7267 map->p_size = segment->p_memsz;
7268 map->p_size_valid = 1;
7271 /* Determine if this segment contains the ELF file header
7272 and if it contains the program headers themselves. */
7273 map->includes_filehdr = (segment->p_offset == 0
7274 && segment->p_filesz >= iehdr->e_ehsize);
7276 map->includes_phdrs = 0;
7277 if (! phdr_included || segment->p_type != PT_LOAD)
7279 map->includes_phdrs =
7280 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
7281 && (segment->p_offset + segment->p_filesz
7282 >= ((bfd_vma) iehdr->e_phoff
7283 + iehdr->e_phnum * iehdr->e_phentsize)));
7285 if (segment->p_type == PT_LOAD && map->includes_phdrs)
7286 phdr_included = TRUE;
7289 lowest_section = NULL;
7290 if (section_count != 0)
7292 unsigned int isec = 0;
7294 for (section = first_section;
7296 section = section->next)
7298 this_hdr = &(elf_section_data(section)->this_hdr);
7299 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7301 map->sections[isec++] = section->output_section;
7302 if ((section->flags & SEC_ALLOC) != 0)
7306 if (lowest_section == NULL
7307 || section->lma < lowest_section->lma)
7308 lowest_section = section;
7310 /* Section lmas are set up from PT_LOAD header
7311 p_paddr in _bfd_elf_make_section_from_shdr.
7312 If this header has a p_paddr that disagrees
7313 with the section lma, flag the p_paddr as
7315 if ((section->flags & SEC_LOAD) != 0)
7316 seg_off = this_hdr->sh_offset - segment->p_offset;
7318 seg_off = this_hdr->sh_addr - segment->p_vaddr;
7319 if (section->lma - segment->p_paddr != seg_off)
7320 map->p_paddr_valid = FALSE;
7322 if (isec == section_count)
7328 if (map->includes_filehdr && lowest_section != NULL)
7329 /* We need to keep the space used by the headers fixed. */
7330 map->header_size = lowest_section->vma - segment->p_vaddr;
7332 if (!map->includes_phdrs
7333 && !map->includes_filehdr
7334 && map->p_paddr_valid)
7335 /* There is some other padding before the first section. */
7336 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
7337 - segment->p_paddr);
7339 map->count = section_count;
7340 *pointer_to_map = map;
7341 pointer_to_map = &map->next;
7344 elf_seg_map (obfd) = map_first;
7348 /* Copy private BFD data. This copies or rewrites ELF program header
7352 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7354 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7355 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7358 if (elf_tdata (ibfd)->phdr == NULL)
7361 if (ibfd->xvec == obfd->xvec)
7363 /* Check to see if any sections in the input BFD
7364 covered by ELF program header have changed. */
7365 Elf_Internal_Phdr *segment;
7366 asection *section, *osec;
7367 unsigned int i, num_segments;
7368 Elf_Internal_Shdr *this_hdr;
7369 const struct elf_backend_data *bed;
7371 bed = get_elf_backend_data (ibfd);
7373 /* Regenerate the segment map if p_paddr is set to 0. */
7374 if (bed->want_p_paddr_set_to_zero)
7377 /* Initialize the segment mark field. */
7378 for (section = obfd->sections; section != NULL;
7379 section = section->next)
7380 section->segment_mark = FALSE;
7382 num_segments = elf_elfheader (ibfd)->e_phnum;
7383 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7387 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7388 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7389 which severly confuses things, so always regenerate the segment
7390 map in this case. */
7391 if (segment->p_paddr == 0
7392 && segment->p_memsz == 0
7393 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
7396 for (section = ibfd->sections;
7397 section != NULL; section = section->next)
7399 /* We mark the output section so that we know it comes
7400 from the input BFD. */
7401 osec = section->output_section;
7403 osec->segment_mark = TRUE;
7405 /* Check if this section is covered by the segment. */
7406 this_hdr = &(elf_section_data(section)->this_hdr);
7407 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7409 /* FIXME: Check if its output section is changed or
7410 removed. What else do we need to check? */
7412 || section->flags != osec->flags
7413 || section->lma != osec->lma
7414 || section->vma != osec->vma
7415 || section->size != osec->size
7416 || section->rawsize != osec->rawsize
7417 || section->alignment_power != osec->alignment_power)
7423 /* Check to see if any output section do not come from the
7425 for (section = obfd->sections; section != NULL;
7426 section = section->next)
7428 if (!section->segment_mark)
7431 section->segment_mark = FALSE;
7434 return copy_elf_program_header (ibfd, obfd);
7438 if (ibfd->xvec == obfd->xvec)
7440 /* When rewriting program header, set the output maxpagesize to
7441 the maximum alignment of input PT_LOAD segments. */
7442 Elf_Internal_Phdr *segment;
7444 unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7445 bfd_vma maxpagesize = 0;
7447 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7450 if (segment->p_type == PT_LOAD
7451 && maxpagesize < segment->p_align)
7453 /* PR 17512: file: f17299af. */
7454 if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
7455 /* xgettext:c-format */
7456 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7457 PRIx64 " is too large"),
7458 ibfd, (uint64_t) segment->p_align);
7460 maxpagesize = segment->p_align;
7463 if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7464 bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7467 return rewrite_elf_program_header (ibfd, obfd);
7470 /* Initialize private output section information from input section. */
7473 _bfd_elf_init_private_section_data (bfd *ibfd,
7477 struct bfd_link_info *link_info)
7480 Elf_Internal_Shdr *ihdr, *ohdr;
7481 bfd_boolean final_link = (link_info != NULL
7482 && !bfd_link_relocatable (link_info));
7484 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7485 || obfd->xvec->flavour != bfd_target_elf_flavour)
7488 BFD_ASSERT (elf_section_data (osec) != NULL);
7490 /* For objcopy and relocatable link, don't copy the output ELF
7491 section type from input if the output BFD section flags have been
7492 set to something different. For a final link allow some flags
7493 that the linker clears to differ. */
7494 if (elf_section_type (osec) == SHT_NULL
7495 && (osec->flags == isec->flags
7497 && ((osec->flags ^ isec->flags)
7498 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
7499 elf_section_type (osec) = elf_section_type (isec);
7501 /* FIXME: Is this correct for all OS/PROC specific flags? */
7502 elf_section_flags (osec) |= (elf_section_flags (isec)
7503 & (SHF_MASKOS | SHF_MASKPROC));
7505 /* Copy sh_info from input for mbind section. */
7506 if (elf_section_flags (isec) & SHF_GNU_MBIND)
7507 elf_section_data (osec)->this_hdr.sh_info
7508 = elf_section_data (isec)->this_hdr.sh_info;
7510 /* Set things up for objcopy and relocatable link. The output
7511 SHT_GROUP section will have its elf_next_in_group pointing back
7512 to the input group members. Ignore linker created group section.
7513 See elfNN_ia64_object_p in elfxx-ia64.c. */
7514 if ((link_info == NULL
7515 || !link_info->resolve_section_groups)
7516 && (elf_sec_group (isec) == NULL
7517 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
7519 if (elf_section_flags (isec) & SHF_GROUP)
7520 elf_section_flags (osec) |= SHF_GROUP;
7521 elf_next_in_group (osec) = elf_next_in_group (isec);
7522 elf_section_data (osec)->group = elf_section_data (isec)->group;
7525 /* If not decompress, preserve SHF_COMPRESSED. */
7526 if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
7527 elf_section_flags (osec) |= (elf_section_flags (isec)
7530 ihdr = &elf_section_data (isec)->this_hdr;
7532 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7533 don't use the output section of the linked-to section since it
7534 may be NULL at this point. */
7535 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7537 ohdr = &elf_section_data (osec)->this_hdr;
7538 ohdr->sh_flags |= SHF_LINK_ORDER;
7539 elf_linked_to_section (osec) = elf_linked_to_section (isec);
7542 osec->use_rela_p = isec->use_rela_p;
7547 /* Copy private section information. This copies over the entsize
7548 field, and sometimes the info field. */
7551 _bfd_elf_copy_private_section_data (bfd *ibfd,
7556 Elf_Internal_Shdr *ihdr, *ohdr;
7558 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7559 || obfd->xvec->flavour != bfd_target_elf_flavour)
7562 ihdr = &elf_section_data (isec)->this_hdr;
7563 ohdr = &elf_section_data (osec)->this_hdr;
7565 ohdr->sh_entsize = ihdr->sh_entsize;
7567 if (ihdr->sh_type == SHT_SYMTAB
7568 || ihdr->sh_type == SHT_DYNSYM
7569 || ihdr->sh_type == SHT_GNU_verneed
7570 || ihdr->sh_type == SHT_GNU_verdef)
7571 ohdr->sh_info = ihdr->sh_info;
7573 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7577 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7578 necessary if we are removing either the SHT_GROUP section or any of
7579 the group member sections. DISCARDED is the value that a section's
7580 output_section has if the section will be discarded, NULL when this
7581 function is called from objcopy, bfd_abs_section_ptr when called
7585 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
7589 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
7590 if (elf_section_type (isec) == SHT_GROUP)
7592 asection *first = elf_next_in_group (isec);
7593 asection *s = first;
7594 bfd_size_type removed = 0;
7598 /* If this member section is being output but the
7599 SHT_GROUP section is not, then clear the group info
7600 set up by _bfd_elf_copy_private_section_data. */
7601 if (s->output_section != discarded
7602 && isec->output_section == discarded)
7604 elf_section_flags (s->output_section) &= ~SHF_GROUP;
7605 elf_group_name (s->output_section) = NULL;
7607 /* Conversely, if the member section is not being output
7608 but the SHT_GROUP section is, then adjust its size. */
7609 else if (s->output_section == discarded
7610 && isec->output_section != discarded)
7612 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
7614 if (elf_sec->rel.hdr != NULL
7615 && (elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0)
7617 if (elf_sec->rela.hdr != NULL
7618 && (elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0)
7621 s = elf_next_in_group (s);
7627 if (discarded != NULL)
7629 /* If we've been called for ld -r, then we need to
7630 adjust the input section size. */
7631 if (isec->rawsize == 0)
7632 isec->rawsize = isec->size;
7633 isec->size = isec->rawsize - removed;
7634 if (isec->size <= 4)
7637 isec->flags |= SEC_EXCLUDE;
7642 /* Adjust the output section size when called from
7644 isec->output_section->size -= removed;
7645 if (isec->output_section->size <= 4)
7647 isec->output_section->size = 0;
7648 isec->output_section->flags |= SEC_EXCLUDE;
7657 /* Copy private header information. */
7660 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7662 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7663 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7666 /* Copy over private BFD data if it has not already been copied.
7667 This must be done here, rather than in the copy_private_bfd_data
7668 entry point, because the latter is called after the section
7669 contents have been set, which means that the program headers have
7670 already been worked out. */
7671 if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
7673 if (! copy_private_bfd_data (ibfd, obfd))
7677 return _bfd_elf_fixup_group_sections (ibfd, NULL);
7680 /* Copy private symbol information. If this symbol is in a section
7681 which we did not map into a BFD section, try to map the section
7682 index correctly. We use special macro definitions for the mapped
7683 section indices; these definitions are interpreted by the
7684 swap_out_syms function. */
7686 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7687 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7688 #define MAP_STRTAB (SHN_HIOS + 3)
7689 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7690 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7693 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
7698 elf_symbol_type *isym, *osym;
7700 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7701 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7704 isym = elf_symbol_from (ibfd, isymarg);
7705 osym = elf_symbol_from (obfd, osymarg);
7708 && isym->internal_elf_sym.st_shndx != 0
7710 && bfd_is_abs_section (isym->symbol.section))
7714 shndx = isym->internal_elf_sym.st_shndx;
7715 if (shndx == elf_onesymtab (ibfd))
7716 shndx = MAP_ONESYMTAB;
7717 else if (shndx == elf_dynsymtab (ibfd))
7718 shndx = MAP_DYNSYMTAB;
7719 else if (shndx == elf_strtab_sec (ibfd))
7721 else if (shndx == elf_shstrtab_sec (ibfd))
7722 shndx = MAP_SHSTRTAB;
7723 else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
7724 shndx = MAP_SYM_SHNDX;
7725 osym->internal_elf_sym.st_shndx = shndx;
7731 /* Swap out the symbols. */
7734 swap_out_syms (bfd *abfd,
7735 struct elf_strtab_hash **sttp,
7738 const struct elf_backend_data *bed;
7741 struct elf_strtab_hash *stt;
7742 Elf_Internal_Shdr *symtab_hdr;
7743 Elf_Internal_Shdr *symtab_shndx_hdr;
7744 Elf_Internal_Shdr *symstrtab_hdr;
7745 struct elf_sym_strtab *symstrtab;
7746 bfd_byte *outbound_syms;
7747 bfd_byte *outbound_shndx;
7748 unsigned long outbound_syms_index;
7749 unsigned long outbound_shndx_index;
7751 unsigned int num_locals;
7753 bfd_boolean name_local_sections;
7755 if (!elf_map_symbols (abfd, &num_locals))
7758 /* Dump out the symtabs. */
7759 stt = _bfd_elf_strtab_init ();
7763 bed = get_elf_backend_data (abfd);
7764 symcount = bfd_get_symcount (abfd);
7765 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7766 symtab_hdr->sh_type = SHT_SYMTAB;
7767 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7768 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
7769 symtab_hdr->sh_info = num_locals + 1;
7770 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
7772 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7773 symstrtab_hdr->sh_type = SHT_STRTAB;
7775 /* Allocate buffer to swap out the .strtab section. */
7776 symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1)
7777 * sizeof (*symstrtab));
7778 if (symstrtab == NULL)
7780 _bfd_elf_strtab_free (stt);
7784 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
7785 bed->s->sizeof_sym);
7786 if (outbound_syms == NULL)
7789 _bfd_elf_strtab_free (stt);
7793 symtab_hdr->contents = outbound_syms;
7794 outbound_syms_index = 0;
7796 outbound_shndx = NULL;
7797 outbound_shndx_index = 0;
7799 if (elf_symtab_shndx_list (abfd))
7801 symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7802 if (symtab_shndx_hdr->sh_name != 0)
7804 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7805 outbound_shndx = (bfd_byte *)
7806 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7807 if (outbound_shndx == NULL)
7810 symtab_shndx_hdr->contents = outbound_shndx;
7811 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7812 symtab_shndx_hdr->sh_size = amt;
7813 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7814 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7816 /* FIXME: What about any other headers in the list ? */
7819 /* Now generate the data (for "contents"). */
7821 /* Fill in zeroth symbol and swap it out. */
7822 Elf_Internal_Sym sym;
7828 sym.st_shndx = SHN_UNDEF;
7829 sym.st_target_internal = 0;
7830 symstrtab[0].sym = sym;
7831 symstrtab[0].dest_index = outbound_syms_index;
7832 symstrtab[0].destshndx_index = outbound_shndx_index;
7833 outbound_syms_index++;
7834 if (outbound_shndx != NULL)
7835 outbound_shndx_index++;
7839 = (bed->elf_backend_name_local_section_symbols
7840 && bed->elf_backend_name_local_section_symbols (abfd));
7842 syms = bfd_get_outsymbols (abfd);
7843 for (idx = 0; idx < symcount;)
7845 Elf_Internal_Sym sym;
7846 bfd_vma value = syms[idx]->value;
7847 elf_symbol_type *type_ptr;
7848 flagword flags = syms[idx]->flags;
7851 if (!name_local_sections
7852 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
7854 /* Local section symbols have no name. */
7855 sym.st_name = (unsigned long) -1;
7859 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7860 to get the final offset for st_name. */
7862 = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
7864 if (sym.st_name == (unsigned long) -1)
7868 type_ptr = elf_symbol_from (abfd, syms[idx]);
7870 if ((flags & BSF_SECTION_SYM) == 0
7871 && bfd_is_com_section (syms[idx]->section))
7873 /* ELF common symbols put the alignment into the `value' field,
7874 and the size into the `size' field. This is backwards from
7875 how BFD handles it, so reverse it here. */
7876 sym.st_size = value;
7877 if (type_ptr == NULL
7878 || type_ptr->internal_elf_sym.st_value == 0)
7879 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
7881 sym.st_value = type_ptr->internal_elf_sym.st_value;
7882 sym.st_shndx = _bfd_elf_section_from_bfd_section
7883 (abfd, syms[idx]->section);
7887 asection *sec = syms[idx]->section;
7890 if (sec->output_section)
7892 value += sec->output_offset;
7893 sec = sec->output_section;
7896 /* Don't add in the section vma for relocatable output. */
7897 if (! relocatable_p)
7899 sym.st_value = value;
7900 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
7902 if (bfd_is_abs_section (sec)
7904 && type_ptr->internal_elf_sym.st_shndx != 0)
7906 /* This symbol is in a real ELF section which we did
7907 not create as a BFD section. Undo the mapping done
7908 by copy_private_symbol_data. */
7909 shndx = type_ptr->internal_elf_sym.st_shndx;
7913 shndx = elf_onesymtab (abfd);
7916 shndx = elf_dynsymtab (abfd);
7919 shndx = elf_strtab_sec (abfd);
7922 shndx = elf_shstrtab_sec (abfd);
7925 if (elf_symtab_shndx_list (abfd))
7926 shndx = elf_symtab_shndx_list (abfd)->ndx;
7935 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
7937 if (shndx == SHN_BAD)
7941 /* Writing this would be a hell of a lot easier if
7942 we had some decent documentation on bfd, and
7943 knew what to expect of the library, and what to
7944 demand of applications. For example, it
7945 appears that `objcopy' might not set the
7946 section of a symbol to be a section that is
7947 actually in the output file. */
7948 sec2 = bfd_get_section_by_name (abfd, sec->name);
7950 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
7951 if (shndx == SHN_BAD)
7953 /* xgettext:c-format */
7955 (_("unable to find equivalent output section"
7956 " for symbol '%s' from section '%s'"),
7957 syms[idx]->name ? syms[idx]->name : "<Local sym>",
7959 bfd_set_error (bfd_error_invalid_operation);
7965 sym.st_shndx = shndx;
7968 if ((flags & BSF_THREAD_LOCAL) != 0)
7970 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
7971 type = STT_GNU_IFUNC;
7972 else if ((flags & BSF_FUNCTION) != 0)
7974 else if ((flags & BSF_OBJECT) != 0)
7976 else if ((flags & BSF_RELC) != 0)
7978 else if ((flags & BSF_SRELC) != 0)
7983 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
7986 /* Processor-specific types. */
7987 if (type_ptr != NULL
7988 && bed->elf_backend_get_symbol_type)
7989 type = ((*bed->elf_backend_get_symbol_type)
7990 (&type_ptr->internal_elf_sym, type));
7992 if (flags & BSF_SECTION_SYM)
7994 if (flags & BSF_GLOBAL)
7995 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7997 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
7999 else if (bfd_is_com_section (syms[idx]->section))
8001 if (type != STT_TLS)
8003 if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
8004 type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
8005 ? STT_COMMON : STT_OBJECT);
8007 type = ((flags & BSF_ELF_COMMON) != 0
8008 ? STT_COMMON : STT_OBJECT);
8010 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
8012 else if (bfd_is_und_section (syms[idx]->section))
8013 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
8017 else if (flags & BSF_FILE)
8018 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8021 int bind = STB_LOCAL;
8023 if (flags & BSF_LOCAL)
8025 else if (flags & BSF_GNU_UNIQUE)
8026 bind = STB_GNU_UNIQUE;
8027 else if (flags & BSF_WEAK)
8029 else if (flags & BSF_GLOBAL)
8032 sym.st_info = ELF_ST_INFO (bind, type);
8035 if (type_ptr != NULL)
8037 sym.st_other = type_ptr->internal_elf_sym.st_other;
8038 sym.st_target_internal
8039 = type_ptr->internal_elf_sym.st_target_internal;
8044 sym.st_target_internal = 0;
8048 symstrtab[idx].sym = sym;
8049 symstrtab[idx].dest_index = outbound_syms_index;
8050 symstrtab[idx].destshndx_index = outbound_shndx_index;
8052 outbound_syms_index++;
8053 if (outbound_shndx != NULL)
8054 outbound_shndx_index++;
8057 /* Finalize the .strtab section. */
8058 _bfd_elf_strtab_finalize (stt);
8060 /* Swap out the .strtab section. */
8061 for (idx = 0; idx <= symcount; idx++)
8063 struct elf_sym_strtab *elfsym = &symstrtab[idx];
8064 if (elfsym->sym.st_name == (unsigned long) -1)
8065 elfsym->sym.st_name = 0;
8067 elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
8068 elfsym->sym.st_name);
8069 bed->s->swap_symbol_out (abfd, &elfsym->sym,
8071 + (elfsym->dest_index
8072 * bed->s->sizeof_sym)),
8074 + (elfsym->destshndx_index
8075 * sizeof (Elf_External_Sym_Shndx))));
8080 symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
8081 symstrtab_hdr->sh_type = SHT_STRTAB;
8082 symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
8083 symstrtab_hdr->sh_addr = 0;
8084 symstrtab_hdr->sh_entsize = 0;
8085 symstrtab_hdr->sh_link = 0;
8086 symstrtab_hdr->sh_info = 0;
8087 symstrtab_hdr->sh_addralign = 1;
8092 /* Return the number of bytes required to hold the symtab vector.
8094 Note that we base it on the count plus 1, since we will null terminate
8095 the vector allocated based on this size. However, the ELF symbol table
8096 always has a dummy entry as symbol #0, so it ends up even. */
8099 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
8103 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
8105 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8106 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8108 symtab_size -= sizeof (asymbol *);
8114 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
8118 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
8120 if (elf_dynsymtab (abfd) == 0)
8122 bfd_set_error (bfd_error_invalid_operation);
8126 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8127 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8129 symtab_size -= sizeof (asymbol *);
8135 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
8138 return (asect->reloc_count + 1) * sizeof (arelent *);
8141 /* Canonicalize the relocs. */
8144 _bfd_elf_canonicalize_reloc (bfd *abfd,
8151 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8153 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
8156 tblptr = section->relocation;
8157 for (i = 0; i < section->reloc_count; i++)
8158 *relptr++ = tblptr++;
8162 return section->reloc_count;
8166 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
8168 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8169 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
8172 bfd_get_symcount (abfd) = symcount;
8177 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8178 asymbol **allocation)
8180 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8181 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
8184 bfd_get_dynamic_symcount (abfd) = symcount;
8188 /* Return the size required for the dynamic reloc entries. Any loadable
8189 section that was actually installed in the BFD, and has type SHT_REL
8190 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8191 dynamic reloc section. */
8194 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
8199 if (elf_dynsymtab (abfd) == 0)
8201 bfd_set_error (bfd_error_invalid_operation);
8205 ret = sizeof (arelent *);
8206 for (s = abfd->sections; s != NULL; s = s->next)
8207 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8208 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8209 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8210 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
8211 * sizeof (arelent *));
8216 /* Canonicalize the dynamic relocation entries. Note that we return the
8217 dynamic relocations as a single block, although they are actually
8218 associated with particular sections; the interface, which was
8219 designed for SunOS style shared libraries, expects that there is only
8220 one set of dynamic relocs. Any loadable section that was actually
8221 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8222 dynamic symbol table, is considered to be a dynamic reloc section. */
8225 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8229 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8233 if (elf_dynsymtab (abfd) == 0)
8235 bfd_set_error (bfd_error_invalid_operation);
8239 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8241 for (s = abfd->sections; s != NULL; s = s->next)
8243 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8244 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8245 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8250 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
8252 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
8254 for (i = 0; i < count; i++)
8265 /* Read in the version information. */
8268 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
8270 bfd_byte *contents = NULL;
8271 unsigned int freeidx = 0;
8273 if (elf_dynverref (abfd) != 0)
8275 Elf_Internal_Shdr *hdr;
8276 Elf_External_Verneed *everneed;
8277 Elf_Internal_Verneed *iverneed;
8279 bfd_byte *contents_end;
8281 hdr = &elf_tdata (abfd)->dynverref_hdr;
8283 if (hdr->sh_info == 0
8284 || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
8286 error_return_bad_verref:
8288 (_("%pB: .gnu.version_r invalid entry"), abfd);
8289 bfd_set_error (bfd_error_bad_value);
8290 error_return_verref:
8291 elf_tdata (abfd)->verref = NULL;
8292 elf_tdata (abfd)->cverrefs = 0;
8296 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8297 if (contents == NULL)
8298 goto error_return_verref;
8300 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8301 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8302 goto error_return_verref;
8304 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
8305 bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
8307 if (elf_tdata (abfd)->verref == NULL)
8308 goto error_return_verref;
8310 BFD_ASSERT (sizeof (Elf_External_Verneed)
8311 == sizeof (Elf_External_Vernaux));
8312 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
8313 everneed = (Elf_External_Verneed *) contents;
8314 iverneed = elf_tdata (abfd)->verref;
8315 for (i = 0; i < hdr->sh_info; i++, iverneed++)
8317 Elf_External_Vernaux *evernaux;
8318 Elf_Internal_Vernaux *ivernaux;
8321 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8323 iverneed->vn_bfd = abfd;
8325 iverneed->vn_filename =
8326 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8328 if (iverneed->vn_filename == NULL)
8329 goto error_return_bad_verref;
8331 if (iverneed->vn_cnt == 0)
8332 iverneed->vn_auxptr = NULL;
8335 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
8336 bfd_alloc2 (abfd, iverneed->vn_cnt,
8337 sizeof (Elf_Internal_Vernaux));
8338 if (iverneed->vn_auxptr == NULL)
8339 goto error_return_verref;
8342 if (iverneed->vn_aux
8343 > (size_t) (contents_end - (bfd_byte *) everneed))
8344 goto error_return_bad_verref;
8346 evernaux = ((Elf_External_Vernaux *)
8347 ((bfd_byte *) everneed + iverneed->vn_aux));
8348 ivernaux = iverneed->vn_auxptr;
8349 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8351 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8353 ivernaux->vna_nodename =
8354 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8355 ivernaux->vna_name);
8356 if (ivernaux->vna_nodename == NULL)
8357 goto error_return_bad_verref;
8359 if (ivernaux->vna_other > freeidx)
8360 freeidx = ivernaux->vna_other;
8362 ivernaux->vna_nextptr = NULL;
8363 if (ivernaux->vna_next == 0)
8365 iverneed->vn_cnt = j + 1;
8368 if (j + 1 < iverneed->vn_cnt)
8369 ivernaux->vna_nextptr = ivernaux + 1;
8371 if (ivernaux->vna_next
8372 > (size_t) (contents_end - (bfd_byte *) evernaux))
8373 goto error_return_bad_verref;
8375 evernaux = ((Elf_External_Vernaux *)
8376 ((bfd_byte *) evernaux + ivernaux->vna_next));
8379 iverneed->vn_nextref = NULL;
8380 if (iverneed->vn_next == 0)
8382 if (i + 1 < hdr->sh_info)
8383 iverneed->vn_nextref = iverneed + 1;
8385 if (iverneed->vn_next
8386 > (size_t) (contents_end - (bfd_byte *) everneed))
8387 goto error_return_bad_verref;
8389 everneed = ((Elf_External_Verneed *)
8390 ((bfd_byte *) everneed + iverneed->vn_next));
8392 elf_tdata (abfd)->cverrefs = i;
8398 if (elf_dynverdef (abfd) != 0)
8400 Elf_Internal_Shdr *hdr;
8401 Elf_External_Verdef *everdef;
8402 Elf_Internal_Verdef *iverdef;
8403 Elf_Internal_Verdef *iverdefarr;
8404 Elf_Internal_Verdef iverdefmem;
8406 unsigned int maxidx;
8407 bfd_byte *contents_end_def, *contents_end_aux;
8409 hdr = &elf_tdata (abfd)->dynverdef_hdr;
8411 if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8413 error_return_bad_verdef:
8415 (_("%pB: .gnu.version_d invalid entry"), abfd);
8416 bfd_set_error (bfd_error_bad_value);
8417 error_return_verdef:
8418 elf_tdata (abfd)->verdef = NULL;
8419 elf_tdata (abfd)->cverdefs = 0;
8423 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8424 if (contents == NULL)
8425 goto error_return_verdef;
8426 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8427 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8428 goto error_return_verdef;
8430 BFD_ASSERT (sizeof (Elf_External_Verdef)
8431 >= sizeof (Elf_External_Verdaux));
8432 contents_end_def = contents + hdr->sh_size
8433 - sizeof (Elf_External_Verdef);
8434 contents_end_aux = contents + hdr->sh_size
8435 - sizeof (Elf_External_Verdaux);
8437 /* We know the number of entries in the section but not the maximum
8438 index. Therefore we have to run through all entries and find
8440 everdef = (Elf_External_Verdef *) contents;
8442 for (i = 0; i < hdr->sh_info; ++i)
8444 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8446 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8447 goto error_return_bad_verdef;
8448 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8449 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
8451 if (iverdefmem.vd_next == 0)
8454 if (iverdefmem.vd_next
8455 > (size_t) (contents_end_def - (bfd_byte *) everdef))
8456 goto error_return_bad_verdef;
8458 everdef = ((Elf_External_Verdef *)
8459 ((bfd_byte *) everdef + iverdefmem.vd_next));
8462 if (default_imported_symver)
8464 if (freeidx > maxidx)
8470 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8471 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
8472 if (elf_tdata (abfd)->verdef == NULL)
8473 goto error_return_verdef;
8475 elf_tdata (abfd)->cverdefs = maxidx;
8477 everdef = (Elf_External_Verdef *) contents;
8478 iverdefarr = elf_tdata (abfd)->verdef;
8479 for (i = 0; i < hdr->sh_info; i++)
8481 Elf_External_Verdaux *everdaux;
8482 Elf_Internal_Verdaux *iverdaux;
8485 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8487 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
8488 goto error_return_bad_verdef;
8490 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
8491 memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
8493 iverdef->vd_bfd = abfd;
8495 if (iverdef->vd_cnt == 0)
8496 iverdef->vd_auxptr = NULL;
8499 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
8500 bfd_alloc2 (abfd, iverdef->vd_cnt,
8501 sizeof (Elf_Internal_Verdaux));
8502 if (iverdef->vd_auxptr == NULL)
8503 goto error_return_verdef;
8507 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
8508 goto error_return_bad_verdef;
8510 everdaux = ((Elf_External_Verdaux *)
8511 ((bfd_byte *) everdef + iverdef->vd_aux));
8512 iverdaux = iverdef->vd_auxptr;
8513 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8515 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8517 iverdaux->vda_nodename =
8518 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8519 iverdaux->vda_name);
8520 if (iverdaux->vda_nodename == NULL)
8521 goto error_return_bad_verdef;
8523 iverdaux->vda_nextptr = NULL;
8524 if (iverdaux->vda_next == 0)
8526 iverdef->vd_cnt = j + 1;
8529 if (j + 1 < iverdef->vd_cnt)
8530 iverdaux->vda_nextptr = iverdaux + 1;
8532 if (iverdaux->vda_next
8533 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
8534 goto error_return_bad_verdef;
8536 everdaux = ((Elf_External_Verdaux *)
8537 ((bfd_byte *) everdaux + iverdaux->vda_next));
8540 iverdef->vd_nodename = NULL;
8541 if (iverdef->vd_cnt)
8542 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
8544 iverdef->vd_nextdef = NULL;
8545 if (iverdef->vd_next == 0)
8547 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
8548 iverdef->vd_nextdef = iverdef + 1;
8550 everdef = ((Elf_External_Verdef *)
8551 ((bfd_byte *) everdef + iverdef->vd_next));
8557 else if (default_imported_symver)
8564 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8565 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
8566 if (elf_tdata (abfd)->verdef == NULL)
8569 elf_tdata (abfd)->cverdefs = freeidx;
8572 /* Create a default version based on the soname. */
8573 if (default_imported_symver)
8575 Elf_Internal_Verdef *iverdef;
8576 Elf_Internal_Verdaux *iverdaux;
8578 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
8580 iverdef->vd_version = VER_DEF_CURRENT;
8581 iverdef->vd_flags = 0;
8582 iverdef->vd_ndx = freeidx;
8583 iverdef->vd_cnt = 1;
8585 iverdef->vd_bfd = abfd;
8587 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8588 if (iverdef->vd_nodename == NULL)
8589 goto error_return_verdef;
8590 iverdef->vd_nextdef = NULL;
8591 iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8592 bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
8593 if (iverdef->vd_auxptr == NULL)
8594 goto error_return_verdef;
8596 iverdaux = iverdef->vd_auxptr;
8597 iverdaux->vda_nodename = iverdef->vd_nodename;
8603 if (contents != NULL)
8609 _bfd_elf_make_empty_symbol (bfd *abfd)
8611 elf_symbol_type *newsym;
8613 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof * newsym);
8616 newsym->symbol.the_bfd = abfd;
8617 return &newsym->symbol;
8621 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8625 bfd_symbol_info (symbol, ret);
8628 /* Return whether a symbol name implies a local symbol. Most targets
8629 use this function for the is_local_label_name entry point, but some
8633 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8636 /* Normal local symbols start with ``.L''. */
8637 if (name[0] == '.' && name[1] == 'L')
8640 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8641 DWARF debugging symbols starting with ``..''. */
8642 if (name[0] == '.' && name[1] == '.')
8645 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8646 emitting DWARF debugging output. I suspect this is actually a
8647 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8648 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8649 underscore to be emitted on some ELF targets). For ease of use,
8650 we treat such symbols as local. */
8651 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
8654 /* Treat assembler generated fake symbols, dollar local labels and
8655 forward-backward labels (aka local labels) as locals.
8656 These labels have the form:
8658 L0^A.* (fake symbols)
8660 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8662 Versions which start with .L will have already been matched above,
8663 so we only need to match the rest. */
8664 if (name[0] == 'L' && ISDIGIT (name[1]))
8666 bfd_boolean ret = FALSE;
8670 for (p = name + 2; (c = *p); p++)
8672 if (c == 1 || c == 2)
8674 if (c == 1 && p == name + 2)
8675 /* A fake symbol. */
8678 /* FIXME: We are being paranoid here and treating symbols like
8679 L0^Bfoo as if there were non-local, on the grounds that the
8680 assembler will never generate them. But can any symbol
8681 containing an ASCII value in the range 1-31 ever be anything
8682 other than some kind of local ? */
8699 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8700 asymbol *symbol ATTRIBUTE_UNUSED)
8707 _bfd_elf_set_arch_mach (bfd *abfd,
8708 enum bfd_architecture arch,
8709 unsigned long machine)
8711 /* If this isn't the right architecture for this backend, and this
8712 isn't the generic backend, fail. */
8713 if (arch != get_elf_backend_data (abfd)->arch
8714 && arch != bfd_arch_unknown
8715 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
8718 return bfd_default_set_arch_mach (abfd, arch, machine);
8721 /* Find the nearest line to a particular section and offset,
8722 for error reporting. */
8725 _bfd_elf_find_nearest_line (bfd *abfd,
8729 const char **filename_ptr,
8730 const char **functionname_ptr,
8731 unsigned int *line_ptr,
8732 unsigned int *discriminator_ptr)
8736 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
8737 filename_ptr, functionname_ptr,
8738 line_ptr, discriminator_ptr,
8739 dwarf_debug_sections, 0,
8740 &elf_tdata (abfd)->dwarf2_find_line_info)
8741 || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8742 filename_ptr, functionname_ptr,
8745 if (!*functionname_ptr)
8746 _bfd_elf_find_function (abfd, symbols, section, offset,
8747 *filename_ptr ? NULL : filename_ptr,
8752 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
8753 &found, filename_ptr,
8754 functionname_ptr, line_ptr,
8755 &elf_tdata (abfd)->line_info))
8757 if (found && (*functionname_ptr || *line_ptr))
8760 if (symbols == NULL)
8763 if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8764 filename_ptr, functionname_ptr))
8771 /* Find the line for a symbol. */
8774 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8775 const char **filename_ptr, unsigned int *line_ptr)
8777 return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8778 filename_ptr, NULL, line_ptr, NULL,
8779 dwarf_debug_sections, 0,
8780 &elf_tdata (abfd)->dwarf2_find_line_info);
8783 /* After a call to bfd_find_nearest_line, successive calls to
8784 bfd_find_inliner_info can be used to get source information about
8785 each level of function inlining that terminated at the address
8786 passed to bfd_find_nearest_line. Currently this is only supported
8787 for DWARF2 with appropriate DWARF3 extensions. */
8790 _bfd_elf_find_inliner_info (bfd *abfd,
8791 const char **filename_ptr,
8792 const char **functionname_ptr,
8793 unsigned int *line_ptr)
8796 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8797 functionname_ptr, line_ptr,
8798 & elf_tdata (abfd)->dwarf2_find_line_info);
8803 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
8805 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8806 int ret = bed->s->sizeof_ehdr;
8808 if (!bfd_link_relocatable (info))
8810 bfd_size_type phdr_size = elf_program_header_size (abfd);
8812 if (phdr_size == (bfd_size_type) -1)
8814 struct elf_segment_map *m;
8817 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
8818 phdr_size += bed->s->sizeof_phdr;
8821 phdr_size = get_program_header_size (abfd, info);
8824 elf_program_header_size (abfd) = phdr_size;
8832 _bfd_elf_set_section_contents (bfd *abfd,
8834 const void *location,
8836 bfd_size_type count)
8838 Elf_Internal_Shdr *hdr;
8841 if (! abfd->output_has_begun
8842 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
8848 hdr = &elf_section_data (section)->this_hdr;
8849 if (hdr->sh_offset == (file_ptr) -1)
8851 /* We must compress this section. Write output to the buffer. */
8852 unsigned char *contents = hdr->contents;
8853 if ((offset + count) > hdr->sh_size
8854 || (section->flags & SEC_ELF_COMPRESS) == 0
8855 || contents == NULL)
8857 memcpy (contents + offset, location, count);
8860 pos = hdr->sh_offset + offset;
8861 if (bfd_seek (abfd, pos, SEEK_SET) != 0
8862 || bfd_bwrite (location, count, abfd) != count)
8869 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
8870 arelent *cache_ptr ATTRIBUTE_UNUSED,
8871 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
8877 /* Try to convert a non-ELF reloc into an ELF one. */
8880 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
8882 /* Check whether we really have an ELF howto. */
8884 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
8886 bfd_reloc_code_real_type code;
8887 reloc_howto_type *howto;
8889 /* Alien reloc: Try to determine its type to replace it with an
8890 equivalent ELF reloc. */
8892 if (areloc->howto->pc_relative)
8894 switch (areloc->howto->bitsize)
8897 code = BFD_RELOC_8_PCREL;
8900 code = BFD_RELOC_12_PCREL;
8903 code = BFD_RELOC_16_PCREL;
8906 code = BFD_RELOC_24_PCREL;
8909 code = BFD_RELOC_32_PCREL;
8912 code = BFD_RELOC_64_PCREL;
8918 howto = bfd_reloc_type_lookup (abfd, code);
8920 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
8922 if (howto->pcrel_offset)
8923 areloc->addend += areloc->address;
8925 areloc->addend -= areloc->address; /* addend is unsigned!! */
8930 switch (areloc->howto->bitsize)
8936 code = BFD_RELOC_14;
8939 code = BFD_RELOC_16;
8942 code = BFD_RELOC_26;
8945 code = BFD_RELOC_32;
8948 code = BFD_RELOC_64;
8954 howto = bfd_reloc_type_lookup (abfd, code);
8958 areloc->howto = howto;
8966 /* xgettext:c-format */
8967 _bfd_error_handler (_("%pB: %s unsupported"),
8968 abfd, areloc->howto->name);
8969 bfd_set_error (bfd_error_bad_value);
8974 _bfd_elf_close_and_cleanup (bfd *abfd)
8976 struct elf_obj_tdata *tdata = elf_tdata (abfd);
8977 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
8979 if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
8980 _bfd_elf_strtab_free (elf_shstrtab (abfd));
8981 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
8984 return _bfd_generic_close_and_cleanup (abfd);
8987 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
8988 in the relocation's offset. Thus we cannot allow any sort of sanity
8989 range-checking to interfere. There is nothing else to do in processing
8992 bfd_reloc_status_type
8993 _bfd_elf_rel_vtable_reloc_fn
8994 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
8995 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
8996 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
8997 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
8999 return bfd_reloc_ok;
9002 /* Elf core file support. Much of this only works on native
9003 toolchains, since we rely on knowing the
9004 machine-dependent procfs structure in order to pick
9005 out details about the corefile. */
9007 #ifdef HAVE_SYS_PROCFS_H
9008 /* Needed for new procfs interface on sparc-solaris. */
9009 # define _STRUCTURED_PROC 1
9010 # include <sys/procfs.h>
9013 /* Return a PID that identifies a "thread" for threaded cores, or the
9014 PID of the main process for non-threaded cores. */
9017 elfcore_make_pid (bfd *abfd)
9021 pid = elf_tdata (abfd)->core->lwpid;
9023 pid = elf_tdata (abfd)->core->pid;
9028 /* If there isn't a section called NAME, make one, using
9029 data from SECT. Note, this function will generate a
9030 reference to NAME, so you shouldn't deallocate or
9034 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
9038 if (bfd_get_section_by_name (abfd, name) != NULL)
9041 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
9045 sect2->size = sect->size;
9046 sect2->filepos = sect->filepos;
9047 sect2->alignment_power = sect->alignment_power;
9051 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9052 actually creates up to two pseudosections:
9053 - For the single-threaded case, a section named NAME, unless
9054 such a section already exists.
9055 - For the multi-threaded case, a section named "NAME/PID", where
9056 PID is elfcore_make_pid (abfd).
9057 Both pseudosections have identical contents. */
9059 _bfd_elfcore_make_pseudosection (bfd *abfd,
9065 char *threaded_name;
9069 /* Build the section name. */
9071 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
9072 len = strlen (buf) + 1;
9073 threaded_name = (char *) bfd_alloc (abfd, len);
9074 if (threaded_name == NULL)
9076 memcpy (threaded_name, buf, len);
9078 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9083 sect->filepos = filepos;
9084 sect->alignment_power = 2;
9086 return elfcore_maybe_make_sect (abfd, name, sect);
9089 /* prstatus_t exists on:
9091 linux 2.[01] + glibc
9095 #if defined (HAVE_PRSTATUS_T)
9098 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
9103 if (note->descsz == sizeof (prstatus_t))
9107 size = sizeof (prstat.pr_reg);
9108 offset = offsetof (prstatus_t, pr_reg);
9109 memcpy (&prstat, note->descdata, sizeof (prstat));
9111 /* Do not overwrite the core signal if it
9112 has already been set by another thread. */
9113 if (elf_tdata (abfd)->core->signal == 0)
9114 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9115 if (elf_tdata (abfd)->core->pid == 0)
9116 elf_tdata (abfd)->core->pid = prstat.pr_pid;
9118 /* pr_who exists on:
9121 pr_who doesn't exist on:
9124 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9125 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9127 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9130 #if defined (HAVE_PRSTATUS32_T)
9131 else if (note->descsz == sizeof (prstatus32_t))
9133 /* 64-bit host, 32-bit corefile */
9134 prstatus32_t prstat;
9136 size = sizeof (prstat.pr_reg);
9137 offset = offsetof (prstatus32_t, pr_reg);
9138 memcpy (&prstat, note->descdata, sizeof (prstat));
9140 /* Do not overwrite the core signal if it
9141 has already been set by another thread. */
9142 if (elf_tdata (abfd)->core->signal == 0)
9143 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9144 if (elf_tdata (abfd)->core->pid == 0)
9145 elf_tdata (abfd)->core->pid = prstat.pr_pid;
9147 /* pr_who exists on:
9150 pr_who doesn't exist on:
9153 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9154 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9156 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9159 #endif /* HAVE_PRSTATUS32_T */
9162 /* Fail - we don't know how to handle any other
9163 note size (ie. data object type). */
9167 /* Make a ".reg/999" section and a ".reg" section. */
9168 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9169 size, note->descpos + offset);
9171 #endif /* defined (HAVE_PRSTATUS_T) */
9173 /* Create a pseudosection containing the exact contents of NOTE. */
9175 elfcore_make_note_pseudosection (bfd *abfd,
9177 Elf_Internal_Note *note)
9179 return _bfd_elfcore_make_pseudosection (abfd, name,
9180 note->descsz, note->descpos);
9183 /* There isn't a consistent prfpregset_t across platforms,
9184 but it doesn't matter, because we don't have to pick this
9185 data structure apart. */
9188 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
9190 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9193 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9194 type of NT_PRXFPREG. Just include the whole note's contents
9198 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
9200 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9203 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9204 with a note type of NT_X86_XSTATE. Just include the whole note's
9205 contents literally. */
9208 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9210 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9214 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9216 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9220 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9222 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9226 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9228 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9232 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9234 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9238 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9240 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9244 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9246 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9250 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9252 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9256 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9258 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9262 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9264 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9268 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9270 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9274 elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9276 return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9280 elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9282 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9286 elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9288 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9292 elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9294 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9298 elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9300 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9304 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9306 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9310 elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9312 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9316 elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9318 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9322 elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9324 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9327 #if defined (HAVE_PRPSINFO_T)
9328 typedef prpsinfo_t elfcore_psinfo_t;
9329 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9330 typedef prpsinfo32_t elfcore_psinfo32_t;
9334 #if defined (HAVE_PSINFO_T)
9335 typedef psinfo_t elfcore_psinfo_t;
9336 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9337 typedef psinfo32_t elfcore_psinfo32_t;
9341 /* return a malloc'ed copy of a string at START which is at
9342 most MAX bytes long, possibly without a terminating '\0'.
9343 the copy will always have a terminating '\0'. */
9346 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
9349 char *end = (char *) memchr (start, '\0', max);
9357 dups = (char *) bfd_alloc (abfd, len + 1);
9361 memcpy (dups, start, len);
9367 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9369 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
9371 if (note->descsz == sizeof (elfcore_psinfo_t))
9373 elfcore_psinfo_t psinfo;
9375 memcpy (&psinfo, note->descdata, sizeof (psinfo));
9377 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9378 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9380 elf_tdata (abfd)->core->program
9381 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9382 sizeof (psinfo.pr_fname));
9384 elf_tdata (abfd)->core->command
9385 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9386 sizeof (psinfo.pr_psargs));
9388 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9389 else if (note->descsz == sizeof (elfcore_psinfo32_t))
9391 /* 64-bit host, 32-bit corefile */
9392 elfcore_psinfo32_t psinfo;
9394 memcpy (&psinfo, note->descdata, sizeof (psinfo));
9396 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9397 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9399 elf_tdata (abfd)->core->program
9400 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9401 sizeof (psinfo.pr_fname));
9403 elf_tdata (abfd)->core->command
9404 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9405 sizeof (psinfo.pr_psargs));
9411 /* Fail - we don't know how to handle any other
9412 note size (ie. data object type). */
9416 /* Note that for some reason, a spurious space is tacked
9417 onto the end of the args in some (at least one anyway)
9418 implementations, so strip it off if it exists. */
9421 char *command = elf_tdata (abfd)->core->command;
9422 int n = strlen (command);
9424 if (0 < n && command[n - 1] == ' ')
9425 command[n - 1] = '\0';
9430 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9432 #if defined (HAVE_PSTATUS_T)
9434 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
9436 if (note->descsz == sizeof (pstatus_t)
9437 #if defined (HAVE_PXSTATUS_T)
9438 || note->descsz == sizeof (pxstatus_t)
9444 memcpy (&pstat, note->descdata, sizeof (pstat));
9446 elf_tdata (abfd)->core->pid = pstat.pr_pid;
9448 #if defined (HAVE_PSTATUS32_T)
9449 else if (note->descsz == sizeof (pstatus32_t))
9451 /* 64-bit host, 32-bit corefile */
9454 memcpy (&pstat, note->descdata, sizeof (pstat));
9456 elf_tdata (abfd)->core->pid = pstat.pr_pid;
9459 /* Could grab some more details from the "representative"
9460 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9461 NT_LWPSTATUS note, presumably. */
9465 #endif /* defined (HAVE_PSTATUS_T) */
9467 #if defined (HAVE_LWPSTATUS_T)
9469 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
9471 lwpstatus_t lwpstat;
9477 if (note->descsz != sizeof (lwpstat)
9478 #if defined (HAVE_LWPXSTATUS_T)
9479 && note->descsz != sizeof (lwpxstatus_t)
9484 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9486 elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
9487 /* Do not overwrite the core signal if it has already been set by
9489 if (elf_tdata (abfd)->core->signal == 0)
9490 elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
9492 /* Make a ".reg/999" section. */
9494 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
9495 len = strlen (buf) + 1;
9496 name = bfd_alloc (abfd, len);
9499 memcpy (name, buf, len);
9501 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9505 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9506 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
9507 sect->filepos = note->descpos
9508 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9511 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9512 sect->size = sizeof (lwpstat.pr_reg);
9513 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9516 sect->alignment_power = 2;
9518 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
9521 /* Make a ".reg2/999" section */
9523 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
9524 len = strlen (buf) + 1;
9525 name = bfd_alloc (abfd, len);
9528 memcpy (name, buf, len);
9530 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9534 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9535 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
9536 sect->filepos = note->descpos
9537 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9540 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9541 sect->size = sizeof (lwpstat.pr_fpreg);
9542 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9545 sect->alignment_power = 2;
9547 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
9549 #endif /* defined (HAVE_LWPSTATUS_T) */
9552 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
9559 int is_active_thread;
9562 if (note->descsz < 728)
9565 if (! CONST_STRNEQ (note->namedata, "win32"))
9568 type = bfd_get_32 (abfd, note->descdata);
9572 case 1 /* NOTE_INFO_PROCESS */:
9573 /* FIXME: need to add ->core->command. */
9574 /* process_info.pid */
9575 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
9576 /* process_info.signal */
9577 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
9580 case 2 /* NOTE_INFO_THREAD */:
9581 /* Make a ".reg/999" section. */
9582 /* thread_info.tid */
9583 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
9585 len = strlen (buf) + 1;
9586 name = (char *) bfd_alloc (abfd, len);
9590 memcpy (name, buf, len);
9592 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9596 /* sizeof (thread_info.thread_context) */
9598 /* offsetof (thread_info.thread_context) */
9599 sect->filepos = note->descpos + 12;
9600 sect->alignment_power = 2;
9602 /* thread_info.is_active_thread */
9603 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9605 if (is_active_thread)
9606 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
9610 case 3 /* NOTE_INFO_MODULE */:
9611 /* Make a ".module/xxxxxxxx" section. */
9612 /* module_info.base_address */
9613 base_addr = bfd_get_32 (abfd, note->descdata + 4);
9614 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
9616 len = strlen (buf) + 1;
9617 name = (char *) bfd_alloc (abfd, len);
9621 memcpy (name, buf, len);
9623 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9628 sect->size = note->descsz;
9629 sect->filepos = note->descpos;
9630 sect->alignment_power = 2;
9641 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
9643 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9651 if (bed->elf_backend_grok_prstatus)
9652 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
9654 #if defined (HAVE_PRSTATUS_T)
9655 return elfcore_grok_prstatus (abfd, note);
9660 #if defined (HAVE_PSTATUS_T)
9662 return elfcore_grok_pstatus (abfd, note);
9665 #if defined (HAVE_LWPSTATUS_T)
9667 return elfcore_grok_lwpstatus (abfd, note);
9670 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
9671 return elfcore_grok_prfpreg (abfd, note);
9673 case NT_WIN32PSTATUS:
9674 return elfcore_grok_win32pstatus (abfd, note);
9676 case NT_PRXFPREG: /* Linux SSE extension */
9677 if (note->namesz == 6
9678 && strcmp (note->namedata, "LINUX") == 0)
9679 return elfcore_grok_prxfpreg (abfd, note);
9683 case NT_X86_XSTATE: /* Linux XSAVE extension */
9684 if (note->namesz == 6
9685 && strcmp (note->namedata, "LINUX") == 0)
9686 return elfcore_grok_xstatereg (abfd, note);
9691 if (note->namesz == 6
9692 && strcmp (note->namedata, "LINUX") == 0)
9693 return elfcore_grok_ppc_vmx (abfd, note);
9698 if (note->namesz == 6
9699 && strcmp (note->namedata, "LINUX") == 0)
9700 return elfcore_grok_ppc_vsx (abfd, note);
9704 case NT_S390_HIGH_GPRS:
9705 if (note->namesz == 6
9706 && strcmp (note->namedata, "LINUX") == 0)
9707 return elfcore_grok_s390_high_gprs (abfd, note);
9712 if (note->namesz == 6
9713 && strcmp (note->namedata, "LINUX") == 0)
9714 return elfcore_grok_s390_timer (abfd, note);
9718 case NT_S390_TODCMP:
9719 if (note->namesz == 6
9720 && strcmp (note->namedata, "LINUX") == 0)
9721 return elfcore_grok_s390_todcmp (abfd, note);
9725 case NT_S390_TODPREG:
9726 if (note->namesz == 6
9727 && strcmp (note->namedata, "LINUX") == 0)
9728 return elfcore_grok_s390_todpreg (abfd, note);
9733 if (note->namesz == 6
9734 && strcmp (note->namedata, "LINUX") == 0)
9735 return elfcore_grok_s390_ctrs (abfd, note);
9739 case NT_S390_PREFIX:
9740 if (note->namesz == 6
9741 && strcmp (note->namedata, "LINUX") == 0)
9742 return elfcore_grok_s390_prefix (abfd, note);
9746 case NT_S390_LAST_BREAK:
9747 if (note->namesz == 6
9748 && strcmp (note->namedata, "LINUX") == 0)
9749 return elfcore_grok_s390_last_break (abfd, note);
9753 case NT_S390_SYSTEM_CALL:
9754 if (note->namesz == 6
9755 && strcmp (note->namedata, "LINUX") == 0)
9756 return elfcore_grok_s390_system_call (abfd, note);
9761 if (note->namesz == 6
9762 && strcmp (note->namedata, "LINUX") == 0)
9763 return elfcore_grok_s390_tdb (abfd, note);
9767 case NT_S390_VXRS_LOW:
9768 if (note->namesz == 6
9769 && strcmp (note->namedata, "LINUX") == 0)
9770 return elfcore_grok_s390_vxrs_low (abfd, note);
9774 case NT_S390_VXRS_HIGH:
9775 if (note->namesz == 6
9776 && strcmp (note->namedata, "LINUX") == 0)
9777 return elfcore_grok_s390_vxrs_high (abfd, note);
9782 if (note->namesz == 6
9783 && strcmp (note->namedata, "LINUX") == 0)
9784 return elfcore_grok_s390_gs_cb (abfd, note);
9789 if (note->namesz == 6
9790 && strcmp (note->namedata, "LINUX") == 0)
9791 return elfcore_grok_s390_gs_bc (abfd, note);
9796 if (note->namesz == 6
9797 && strcmp (note->namedata, "LINUX") == 0)
9798 return elfcore_grok_arm_vfp (abfd, note);
9803 if (note->namesz == 6
9804 && strcmp (note->namedata, "LINUX") == 0)
9805 return elfcore_grok_aarch_tls (abfd, note);
9809 case NT_ARM_HW_BREAK:
9810 if (note->namesz == 6
9811 && strcmp (note->namedata, "LINUX") == 0)
9812 return elfcore_grok_aarch_hw_break (abfd, note);
9816 case NT_ARM_HW_WATCH:
9817 if (note->namesz == 6
9818 && strcmp (note->namedata, "LINUX") == 0)
9819 return elfcore_grok_aarch_hw_watch (abfd, note);
9825 if (bed->elf_backend_grok_psinfo)
9826 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
9828 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9829 return elfcore_grok_psinfo (abfd, note);
9836 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9841 sect->size = note->descsz;
9842 sect->filepos = note->descpos;
9843 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9849 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
9853 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
9860 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
9862 struct bfd_build_id* build_id;
9864 if (note->descsz == 0)
9867 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
9868 if (build_id == NULL)
9871 build_id->size = note->descsz;
9872 memcpy (build_id->data, note->descdata, note->descsz);
9873 abfd->build_id = build_id;
9879 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
9886 case NT_GNU_PROPERTY_TYPE_0:
9887 return _bfd_elf_parse_gnu_properties (abfd, note);
9889 case NT_GNU_BUILD_ID:
9890 return elfobj_grok_gnu_build_id (abfd, note);
9895 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
9897 struct sdt_note *cur =
9898 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
9901 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
9902 cur->size = (bfd_size_type) note->descsz;
9903 memcpy (cur->data, note->descdata, note->descsz);
9905 elf_tdata (abfd)->sdt_note_head = cur;
9911 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
9916 return elfobj_grok_stapsdt_note_1 (abfd, note);
9924 elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
9928 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
9931 if (note->descsz < 108)
9936 if (note->descsz < 120)
9944 /* Check for version 1 in pr_version. */
9945 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
9950 /* Skip over pr_psinfosz. */
9951 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
9955 offset += 4; /* Padding before pr_psinfosz. */
9959 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
9960 elf_tdata (abfd)->core->program
9961 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
9964 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
9965 elf_tdata (abfd)->core->command
9966 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
9969 /* Padding before pr_pid. */
9972 /* The pr_pid field was added in version "1a". */
9973 if (note->descsz < offset + 4)
9976 elf_tdata (abfd)->core->pid
9977 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
9983 elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
9989 /* Compute offset of pr_getregsz, skipping over pr_statussz.
9990 Also compute minimum size of this note. */
9991 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
9995 min_size = offset + (4 * 2) + 4 + 4 + 4;
9999 offset = 4 + 4 + 8; /* Includes padding before pr_statussz. */
10000 min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
10007 if (note->descsz < min_size)
10010 /* Check for version 1 in pr_version. */
10011 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10014 /* Extract size of pr_reg from pr_gregsetsz. */
10015 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10016 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10018 size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10023 size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10027 /* Skip over pr_osreldate. */
10030 /* Read signal from pr_cursig. */
10031 if (elf_tdata (abfd)->core->signal == 0)
10032 elf_tdata (abfd)->core->signal
10033 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10036 /* Read TID from pr_pid. */
10037 elf_tdata (abfd)->core->lwpid
10038 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10041 /* Padding before pr_reg. */
10042 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
10045 /* Make sure that there is enough data remaining in the note. */
10046 if ((note->descsz - offset) < size)
10049 /* Make a ".reg/999" section and a ".reg" section. */
10050 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10051 size, note->descpos + offset);
10055 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10057 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10059 switch (note->type)
10062 if (bed->elf_backend_grok_freebsd_prstatus)
10063 if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10065 return elfcore_grok_freebsd_prstatus (abfd, note);
10068 return elfcore_grok_prfpreg (abfd, note);
10071 return elfcore_grok_freebsd_psinfo (abfd, note);
10073 case NT_FREEBSD_THRMISC:
10074 if (note->namesz == 8)
10075 return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10079 case NT_FREEBSD_PROCSTAT_PROC:
10080 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10083 case NT_FREEBSD_PROCSTAT_FILES:
10084 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10087 case NT_FREEBSD_PROCSTAT_VMMAP:
10088 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10091 case NT_FREEBSD_PROCSTAT_AUXV:
10093 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10098 sect->size = note->descsz - 4;
10099 sect->filepos = note->descpos + 4;
10100 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10105 case NT_X86_XSTATE:
10106 if (note->namesz == 8)
10107 return elfcore_grok_xstatereg (abfd, note);
10111 case NT_FREEBSD_PTLWPINFO:
10112 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10116 return elfcore_grok_arm_vfp (abfd, note);
10124 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
10128 cp = strchr (note->namedata, '@');
10131 *lwpidp = atoi(cp + 1);
10138 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10140 if (note->descsz <= 0x7c + 31)
10143 /* Signal number at offset 0x08. */
10144 elf_tdata (abfd)->core->signal
10145 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10147 /* Process ID at offset 0x50. */
10148 elf_tdata (abfd)->core->pid
10149 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10151 /* Command name at 0x7c (max 32 bytes, including nul). */
10152 elf_tdata (abfd)->core->command
10153 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10155 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10160 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
10164 if (elfcore_netbsd_get_lwpid (note, &lwp))
10165 elf_tdata (abfd)->core->lwpid = lwp;
10167 if (note->type == NT_NETBSDCORE_PROCINFO)
10169 /* NetBSD-specific core "procinfo". Note that we expect to
10170 find this note before any of the others, which is fine,
10171 since the kernel writes this note out first when it
10172 creates a core file. */
10174 return elfcore_grok_netbsd_procinfo (abfd, note);
10177 /* As of Jan 2002 there are no other machine-independent notes
10178 defined for NetBSD core files. If the note type is less
10179 than the start of the machine-dependent note types, we don't
10182 if (note->type < NT_NETBSDCORE_FIRSTMACH)
10186 switch (bfd_get_arch (abfd))
10188 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10189 PT_GETFPREGS == mach+2. */
10191 case bfd_arch_alpha:
10192 case bfd_arch_sparc:
10193 switch (note->type)
10195 case NT_NETBSDCORE_FIRSTMACH+0:
10196 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10198 case NT_NETBSDCORE_FIRSTMACH+2:
10199 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10205 /* On all other arch's, PT_GETREGS == mach+1 and
10206 PT_GETFPREGS == mach+3. */
10209 switch (note->type)
10211 case NT_NETBSDCORE_FIRSTMACH+1:
10212 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10214 case NT_NETBSDCORE_FIRSTMACH+3:
10215 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10225 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10227 if (note->descsz <= 0x48 + 31)
10230 /* Signal number at offset 0x08. */
10231 elf_tdata (abfd)->core->signal
10232 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10234 /* Process ID at offset 0x20. */
10235 elf_tdata (abfd)->core->pid
10236 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10238 /* Command name at 0x48 (max 32 bytes, including nul). */
10239 elf_tdata (abfd)->core->command
10240 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10246 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10248 if (note->type == NT_OPENBSD_PROCINFO)
10249 return elfcore_grok_openbsd_procinfo (abfd, note);
10251 if (note->type == NT_OPENBSD_REGS)
10252 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10254 if (note->type == NT_OPENBSD_FPREGS)
10255 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10257 if (note->type == NT_OPENBSD_XFPREGS)
10258 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10260 if (note->type == NT_OPENBSD_AUXV)
10262 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10267 sect->size = note->descsz;
10268 sect->filepos = note->descpos;
10269 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10274 if (note->type == NT_OPENBSD_WCOOKIE)
10276 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10281 sect->size = note->descsz;
10282 sect->filepos = note->descpos;
10283 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10292 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
10294 void *ddata = note->descdata;
10301 if (note->descsz < 16)
10304 /* nto_procfs_status 'pid' field is at offset 0. */
10305 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
10307 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10308 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10310 /* nto_procfs_status 'flags' field is at offset 8. */
10311 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
10313 /* nto_procfs_status 'what' field is at offset 14. */
10314 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10316 elf_tdata (abfd)->core->signal = sig;
10317 elf_tdata (abfd)->core->lwpid = *tid;
10320 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10321 do not come from signals so we make sure we set the current
10322 thread just in case. */
10323 if (flags & 0x00000080)
10324 elf_tdata (abfd)->core->lwpid = *tid;
10326 /* Make a ".qnx_core_status/%d" section. */
10327 sprintf (buf, ".qnx_core_status/%ld", *tid);
10329 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10332 strcpy (name, buf);
10334 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10338 sect->size = note->descsz;
10339 sect->filepos = note->descpos;
10340 sect->alignment_power = 2;
10342 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10346 elfcore_grok_nto_regs (bfd *abfd,
10347 Elf_Internal_Note *note,
10355 /* Make a "(base)/%d" section. */
10356 sprintf (buf, "%s/%ld", base, tid);
10358 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10361 strcpy (name, buf);
10363 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10367 sect->size = note->descsz;
10368 sect->filepos = note->descpos;
10369 sect->alignment_power = 2;
10371 /* This is the current thread. */
10372 if (elf_tdata (abfd)->core->lwpid == tid)
10373 return elfcore_maybe_make_sect (abfd, base, sect);
10378 #define BFD_QNT_CORE_INFO 7
10379 #define BFD_QNT_CORE_STATUS 8
10380 #define BFD_QNT_CORE_GREG 9
10381 #define BFD_QNT_CORE_FPREG 10
10384 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
10386 /* Every GREG section has a STATUS section before it. Store the
10387 tid from the previous call to pass down to the next gregs
10389 static long tid = 1;
10391 switch (note->type)
10393 case BFD_QNT_CORE_INFO:
10394 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10395 case BFD_QNT_CORE_STATUS:
10396 return elfcore_grok_nto_status (abfd, note, &tid);
10397 case BFD_QNT_CORE_GREG:
10398 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10399 case BFD_QNT_CORE_FPREG:
10400 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10407 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10413 /* Use note name as section name. */
10414 len = note->namesz;
10415 name = (char *) bfd_alloc (abfd, len);
10418 memcpy (name, note->namedata, len);
10419 name[len - 1] = '\0';
10421 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10425 sect->size = note->descsz;
10426 sect->filepos = note->descpos;
10427 sect->alignment_power = 1;
10432 /* Function: elfcore_write_note
10435 buffer to hold note, and current size of buffer
10439 size of data for note
10441 Writes note to end of buffer. ELF64 notes are written exactly as
10442 for ELF32, despite the current (as of 2006) ELF gabi specifying
10443 that they ought to have 8-byte namesz and descsz field, and have
10444 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10447 Pointer to realloc'd buffer, *BUFSIZ updated. */
10450 elfcore_write_note (bfd *abfd,
10458 Elf_External_Note *xnp;
10465 namesz = strlen (name) + 1;
10467 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
10469 buf = (char *) realloc (buf, *bufsiz + newspace);
10472 dest = buf + *bufsiz;
10473 *bufsiz += newspace;
10474 xnp = (Elf_External_Note *) dest;
10475 H_PUT_32 (abfd, namesz, xnp->namesz);
10476 H_PUT_32 (abfd, size, xnp->descsz);
10477 H_PUT_32 (abfd, type, xnp->type);
10481 memcpy (dest, name, namesz);
10489 memcpy (dest, input, size);
10499 /* gcc-8 warns (*) on all the strncpy calls in this function about
10500 possible string truncation. The "truncation" is not a bug. We
10501 have an external representation of structs with fields that are not
10502 necessarily NULL terminated and corresponding internal
10503 representation fields that are one larger so that they can always
10504 be NULL terminated.
10505 gcc versions between 4.2 and 4.6 do not allow pragma control of
10506 diagnostics inside functions, giving a hard error if you try to use
10507 the finer control available with later versions.
10508 gcc prior to 4.2 warns about diagnostic push and pop.
10509 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10510 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10511 (*) Depending on your system header files! */
10512 #if GCC_VERSION >= 8000
10513 # pragma GCC diagnostic push
10514 # pragma GCC diagnostic ignored "-Wstringop-truncation"
10517 elfcore_write_prpsinfo (bfd *abfd,
10521 const char *psargs)
10523 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10525 if (bed->elf_backend_write_core_note != NULL)
10528 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10529 NT_PRPSINFO, fname, psargs);
10534 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10535 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10536 if (bed->s->elfclass == ELFCLASS32)
10538 # if defined (HAVE_PSINFO32_T)
10540 int note_type = NT_PSINFO;
10543 int note_type = NT_PRPSINFO;
10546 memset (&data, 0, sizeof (data));
10547 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10548 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10549 return elfcore_write_note (abfd, buf, bufsiz,
10550 "CORE", note_type, &data, sizeof (data));
10555 # if defined (HAVE_PSINFO_T)
10557 int note_type = NT_PSINFO;
10560 int note_type = NT_PRPSINFO;
10563 memset (&data, 0, sizeof (data));
10564 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10565 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10566 return elfcore_write_note (abfd, buf, bufsiz,
10567 "CORE", note_type, &data, sizeof (data));
10569 #endif /* PSINFO_T or PRPSINFO_T */
10574 #if GCC_VERSION >= 8000
10575 # pragma GCC diagnostic pop
10579 elfcore_write_linux_prpsinfo32
10580 (bfd *abfd, char *buf, int *bufsiz,
10581 const struct elf_internal_linux_prpsinfo *prpsinfo)
10583 if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10585 struct elf_external_linux_prpsinfo32_ugid16 data;
10587 swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10588 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10589 &data, sizeof (data));
10593 struct elf_external_linux_prpsinfo32_ugid32 data;
10595 swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10596 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10597 &data, sizeof (data));
10602 elfcore_write_linux_prpsinfo64
10603 (bfd *abfd, char *buf, int *bufsiz,
10604 const struct elf_internal_linux_prpsinfo *prpsinfo)
10606 if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
10608 struct elf_external_linux_prpsinfo64_ugid16 data;
10610 swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
10611 return elfcore_write_note (abfd, buf, bufsiz,
10612 "CORE", NT_PRPSINFO, &data, sizeof (data));
10616 struct elf_external_linux_prpsinfo64_ugid32 data;
10618 swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
10619 return elfcore_write_note (abfd, buf, bufsiz,
10620 "CORE", NT_PRPSINFO, &data, sizeof (data));
10625 elfcore_write_prstatus (bfd *abfd,
10632 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10634 if (bed->elf_backend_write_core_note != NULL)
10637 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10639 pid, cursig, gregs);
10644 #if defined (HAVE_PRSTATUS_T)
10645 #if defined (HAVE_PRSTATUS32_T)
10646 if (bed->s->elfclass == ELFCLASS32)
10648 prstatus32_t prstat;
10650 memset (&prstat, 0, sizeof (prstat));
10651 prstat.pr_pid = pid;
10652 prstat.pr_cursig = cursig;
10653 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10654 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10655 NT_PRSTATUS, &prstat, sizeof (prstat));
10662 memset (&prstat, 0, sizeof (prstat));
10663 prstat.pr_pid = pid;
10664 prstat.pr_cursig = cursig;
10665 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10666 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10667 NT_PRSTATUS, &prstat, sizeof (prstat));
10669 #endif /* HAVE_PRSTATUS_T */
10675 #if defined (HAVE_LWPSTATUS_T)
10677 elfcore_write_lwpstatus (bfd *abfd,
10684 lwpstatus_t lwpstat;
10685 const char *note_name = "CORE";
10687 memset (&lwpstat, 0, sizeof (lwpstat));
10688 lwpstat.pr_lwpid = pid >> 16;
10689 lwpstat.pr_cursig = cursig;
10690 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10691 memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
10692 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10693 #if !defined(gregs)
10694 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
10695 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
10697 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
10698 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
10701 return elfcore_write_note (abfd, buf, bufsiz, note_name,
10702 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
10704 #endif /* HAVE_LWPSTATUS_T */
10706 #if defined (HAVE_PSTATUS_T)
10708 elfcore_write_pstatus (bfd *abfd,
10712 int cursig ATTRIBUTE_UNUSED,
10713 const void *gregs ATTRIBUTE_UNUSED)
10715 const char *note_name = "CORE";
10716 #if defined (HAVE_PSTATUS32_T)
10717 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10719 if (bed->s->elfclass == ELFCLASS32)
10723 memset (&pstat, 0, sizeof (pstat));
10724 pstat.pr_pid = pid & 0xffff;
10725 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10726 NT_PSTATUS, &pstat, sizeof (pstat));
10734 memset (&pstat, 0, sizeof (pstat));
10735 pstat.pr_pid = pid & 0xffff;
10736 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10737 NT_PSTATUS, &pstat, sizeof (pstat));
10741 #endif /* HAVE_PSTATUS_T */
10744 elfcore_write_prfpreg (bfd *abfd,
10747 const void *fpregs,
10750 const char *note_name = "CORE";
10751 return elfcore_write_note (abfd, buf, bufsiz,
10752 note_name, NT_FPREGSET, fpregs, size);
10756 elfcore_write_prxfpreg (bfd *abfd,
10759 const void *xfpregs,
10762 char *note_name = "LINUX";
10763 return elfcore_write_note (abfd, buf, bufsiz,
10764 note_name, NT_PRXFPREG, xfpregs, size);
10768 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
10769 const void *xfpregs, int size)
10772 if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
10773 note_name = "FreeBSD";
10775 note_name = "LINUX";
10776 return elfcore_write_note (abfd, buf, bufsiz,
10777 note_name, NT_X86_XSTATE, xfpregs, size);
10781 elfcore_write_ppc_vmx (bfd *abfd,
10784 const void *ppc_vmx,
10787 char *note_name = "LINUX";
10788 return elfcore_write_note (abfd, buf, bufsiz,
10789 note_name, NT_PPC_VMX, ppc_vmx, size);
10793 elfcore_write_ppc_vsx (bfd *abfd,
10796 const void *ppc_vsx,
10799 char *note_name = "LINUX";
10800 return elfcore_write_note (abfd, buf, bufsiz,
10801 note_name, NT_PPC_VSX, ppc_vsx, size);
10805 elfcore_write_s390_high_gprs (bfd *abfd,
10808 const void *s390_high_gprs,
10811 char *note_name = "LINUX";
10812 return elfcore_write_note (abfd, buf, bufsiz,
10813 note_name, NT_S390_HIGH_GPRS,
10814 s390_high_gprs, size);
10818 elfcore_write_s390_timer (bfd *abfd,
10821 const void *s390_timer,
10824 char *note_name = "LINUX";
10825 return elfcore_write_note (abfd, buf, bufsiz,
10826 note_name, NT_S390_TIMER, s390_timer, size);
10830 elfcore_write_s390_todcmp (bfd *abfd,
10833 const void *s390_todcmp,
10836 char *note_name = "LINUX";
10837 return elfcore_write_note (abfd, buf, bufsiz,
10838 note_name, NT_S390_TODCMP, s390_todcmp, size);
10842 elfcore_write_s390_todpreg (bfd *abfd,
10845 const void *s390_todpreg,
10848 char *note_name = "LINUX";
10849 return elfcore_write_note (abfd, buf, bufsiz,
10850 note_name, NT_S390_TODPREG, s390_todpreg, size);
10854 elfcore_write_s390_ctrs (bfd *abfd,
10857 const void *s390_ctrs,
10860 char *note_name = "LINUX";
10861 return elfcore_write_note (abfd, buf, bufsiz,
10862 note_name, NT_S390_CTRS, s390_ctrs, size);
10866 elfcore_write_s390_prefix (bfd *abfd,
10869 const void *s390_prefix,
10872 char *note_name = "LINUX";
10873 return elfcore_write_note (abfd, buf, bufsiz,
10874 note_name, NT_S390_PREFIX, s390_prefix, size);
10878 elfcore_write_s390_last_break (bfd *abfd,
10881 const void *s390_last_break,
10884 char *note_name = "LINUX";
10885 return elfcore_write_note (abfd, buf, bufsiz,
10886 note_name, NT_S390_LAST_BREAK,
10887 s390_last_break, size);
10891 elfcore_write_s390_system_call (bfd *abfd,
10894 const void *s390_system_call,
10897 char *note_name = "LINUX";
10898 return elfcore_write_note (abfd, buf, bufsiz,
10899 note_name, NT_S390_SYSTEM_CALL,
10900 s390_system_call, size);
10904 elfcore_write_s390_tdb (bfd *abfd,
10907 const void *s390_tdb,
10910 char *note_name = "LINUX";
10911 return elfcore_write_note (abfd, buf, bufsiz,
10912 note_name, NT_S390_TDB, s390_tdb, size);
10916 elfcore_write_s390_vxrs_low (bfd *abfd,
10919 const void *s390_vxrs_low,
10922 char *note_name = "LINUX";
10923 return elfcore_write_note (abfd, buf, bufsiz,
10924 note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
10928 elfcore_write_s390_vxrs_high (bfd *abfd,
10931 const void *s390_vxrs_high,
10934 char *note_name = "LINUX";
10935 return elfcore_write_note (abfd, buf, bufsiz,
10936 note_name, NT_S390_VXRS_HIGH,
10937 s390_vxrs_high, size);
10941 elfcore_write_s390_gs_cb (bfd *abfd,
10944 const void *s390_gs_cb,
10947 char *note_name = "LINUX";
10948 return elfcore_write_note (abfd, buf, bufsiz,
10949 note_name, NT_S390_GS_CB,
10954 elfcore_write_s390_gs_bc (bfd *abfd,
10957 const void *s390_gs_bc,
10960 char *note_name = "LINUX";
10961 return elfcore_write_note (abfd, buf, bufsiz,
10962 note_name, NT_S390_GS_BC,
10967 elfcore_write_arm_vfp (bfd *abfd,
10970 const void *arm_vfp,
10973 char *note_name = "LINUX";
10974 return elfcore_write_note (abfd, buf, bufsiz,
10975 note_name, NT_ARM_VFP, arm_vfp, size);
10979 elfcore_write_aarch_tls (bfd *abfd,
10982 const void *aarch_tls,
10985 char *note_name = "LINUX";
10986 return elfcore_write_note (abfd, buf, bufsiz,
10987 note_name, NT_ARM_TLS, aarch_tls, size);
10991 elfcore_write_aarch_hw_break (bfd *abfd,
10994 const void *aarch_hw_break,
10997 char *note_name = "LINUX";
10998 return elfcore_write_note (abfd, buf, bufsiz,
10999 note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11003 elfcore_write_aarch_hw_watch (bfd *abfd,
11006 const void *aarch_hw_watch,
11009 char *note_name = "LINUX";
11010 return elfcore_write_note (abfd, buf, bufsiz,
11011 note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11015 elfcore_write_register_note (bfd *abfd,
11018 const char *section,
11022 if (strcmp (section, ".reg2") == 0)
11023 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11024 if (strcmp (section, ".reg-xfp") == 0)
11025 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
11026 if (strcmp (section, ".reg-xstate") == 0)
11027 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
11028 if (strcmp (section, ".reg-ppc-vmx") == 0)
11029 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
11030 if (strcmp (section, ".reg-ppc-vsx") == 0)
11031 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
11032 if (strcmp (section, ".reg-s390-high-gprs") == 0)
11033 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
11034 if (strcmp (section, ".reg-s390-timer") == 0)
11035 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11036 if (strcmp (section, ".reg-s390-todcmp") == 0)
11037 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11038 if (strcmp (section, ".reg-s390-todpreg") == 0)
11039 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11040 if (strcmp (section, ".reg-s390-ctrs") == 0)
11041 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11042 if (strcmp (section, ".reg-s390-prefix") == 0)
11043 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
11044 if (strcmp (section, ".reg-s390-last-break") == 0)
11045 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11046 if (strcmp (section, ".reg-s390-system-call") == 0)
11047 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
11048 if (strcmp (section, ".reg-s390-tdb") == 0)
11049 return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
11050 if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11051 return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11052 if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11053 return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
11054 if (strcmp (section, ".reg-s390-gs-cb") == 0)
11055 return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11056 if (strcmp (section, ".reg-s390-gs-bc") == 0)
11057 return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
11058 if (strcmp (section, ".reg-arm-vfp") == 0)
11059 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
11060 if (strcmp (section, ".reg-aarch-tls") == 0)
11061 return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11062 if (strcmp (section, ".reg-aarch-hw-break") == 0)
11063 return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11064 if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11065 return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
11070 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11075 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11076 gABI specifies that PT_NOTE alignment should be aligned to 4
11077 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11078 align is less than 4, we use 4 byte alignment. */
11081 if (align != 4 && align != 8)
11085 while (p < buf + size)
11087 Elf_External_Note *xnp = (Elf_External_Note *) p;
11088 Elf_Internal_Note in;
11090 if (offsetof (Elf_External_Note, name) > buf - p + size)
11093 in.type = H_GET_32 (abfd, xnp->type);
11095 in.namesz = H_GET_32 (abfd, xnp->namesz);
11096 in.namedata = xnp->name;
11097 if (in.namesz > buf - in.namedata + size)
11100 in.descsz = H_GET_32 (abfd, xnp->descsz);
11101 in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
11102 in.descpos = offset + (in.descdata - buf);
11104 && (in.descdata >= buf + size
11105 || in.descsz > buf - in.descdata + size))
11108 switch (bfd_get_format (abfd))
11115 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11118 const char * string;
11120 bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
11124 GROKER_ELEMENT ("", elfcore_grok_note),
11125 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
11126 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11127 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11128 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11129 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
11131 #undef GROKER_ELEMENT
11134 for (i = ARRAY_SIZE (grokers); i--;)
11136 if (in.namesz >= grokers[i].len
11137 && strncmp (in.namedata, grokers[i].string,
11138 grokers[i].len) == 0)
11140 if (! grokers[i].func (abfd, & in))
11149 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11151 if (! elfobj_grok_gnu_note (abfd, &in))
11154 else if (in.namesz == sizeof "stapsdt"
11155 && strcmp (in.namedata, "stapsdt") == 0)
11157 if (! elfobj_grok_stapsdt_note (abfd, &in))
11163 p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
11170 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11175 if (size == 0 || (size + 1) == 0)
11178 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11181 buf = (char *) bfd_malloc (size + 1);
11185 /* PR 17512: file: ec08f814
11186 0-termintate the buffer so that string searches will not overflow. */
11189 if (bfd_bread (buf, size, abfd) != size
11190 || !elf_parse_notes (abfd, buf, size, offset, align))
11200 /* Providing external access to the ELF program header table. */
11202 /* Return an upper bound on the number of bytes required to store a
11203 copy of ABFD's program header table entries. Return -1 if an error
11204 occurs; bfd_get_error will return an appropriate code. */
11207 bfd_get_elf_phdr_upper_bound (bfd *abfd)
11209 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11211 bfd_set_error (bfd_error_wrong_format);
11215 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
11218 /* Copy ABFD's program header table entries to *PHDRS. The entries
11219 will be stored as an array of Elf_Internal_Phdr structures, as
11220 defined in include/elf/internal.h. To find out how large the
11221 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11223 Return the number of program header table entries read, or -1 if an
11224 error occurs; bfd_get_error will return an appropriate code. */
11227 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
11231 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11233 bfd_set_error (bfd_error_wrong_format);
11237 num_phdrs = elf_elfheader (abfd)->e_phnum;
11238 memcpy (phdrs, elf_tdata (abfd)->phdr,
11239 num_phdrs * sizeof (Elf_Internal_Phdr));
11244 enum elf_reloc_type_class
11245 _bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11246 const asection *rel_sec ATTRIBUTE_UNUSED,
11247 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
11249 return reloc_class_normal;
11252 /* For RELA architectures, return the relocation value for a
11253 relocation against a local symbol. */
11256 _bfd_elf_rela_local_sym (bfd *abfd,
11257 Elf_Internal_Sym *sym,
11259 Elf_Internal_Rela *rel)
11261 asection *sec = *psec;
11262 bfd_vma relocation;
11264 relocation = (sec->output_section->vma
11265 + sec->output_offset
11267 if ((sec->flags & SEC_MERGE)
11268 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
11269 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
11272 _bfd_merged_section_offset (abfd, psec,
11273 elf_section_data (sec)->sec_info,
11274 sym->st_value + rel->r_addend);
11277 /* If we have changed the section, and our original section is
11278 marked with SEC_EXCLUDE, it means that the original
11279 SEC_MERGE section has been completely subsumed in some
11280 other SEC_MERGE section. In this case, we need to leave
11281 some info around for --emit-relocs. */
11282 if ((sec->flags & SEC_EXCLUDE) != 0)
11283 sec->kept_section = *psec;
11286 rel->r_addend -= relocation;
11287 rel->r_addend += sec->output_section->vma + sec->output_offset;
11293 _bfd_elf_rel_local_sym (bfd *abfd,
11294 Elf_Internal_Sym *sym,
11298 asection *sec = *psec;
11300 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
11301 return sym->st_value + addend;
11303 return _bfd_merged_section_offset (abfd, psec,
11304 elf_section_data (sec)->sec_info,
11305 sym->st_value + addend);
11308 /* Adjust an address within a section. Given OFFSET within SEC, return
11309 the new offset within the section, based upon changes made to the
11310 section. Returns -1 if the offset is now invalid.
11311 The offset (in abnd out) is in target sized bytes, however big a
11315 _bfd_elf_section_offset (bfd *abfd,
11316 struct bfd_link_info *info,
11320 switch (sec->sec_info_type)
11322 case SEC_INFO_TYPE_STABS:
11323 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11325 case SEC_INFO_TYPE_EH_FRAME:
11326 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
11329 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11331 /* Reverse the offset. */
11332 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11333 bfd_size_type address_size = bed->s->arch_size / 8;
11335 /* address_size and sec->size are in octets. Convert
11336 to bytes before subtracting the original offset. */
11337 offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
11343 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
11344 reconstruct an ELF file by reading the segments out of remote memory
11345 based on the ELF file header at EHDR_VMA and the ELF program headers it
11346 points to. If not null, *LOADBASEP is filled in with the difference
11347 between the VMAs from which the segments were read, and the VMAs the
11348 file headers (and hence BFD's idea of each section's VMA) put them at.
11350 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11351 remote memory at target address VMA into the local buffer at MYADDR; it
11352 should return zero on success or an `errno' code on failure. TEMPL must
11353 be a BFD for an ELF target with the word size and byte order found in
11354 the remote memory. */
11357 bfd_elf_bfd_from_remote_memory
11360 bfd_size_type size,
11361 bfd_vma *loadbasep,
11362 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
11364 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
11365 (templ, ehdr_vma, size, loadbasep, target_read_memory);
11369 _bfd_elf_get_synthetic_symtab (bfd *abfd,
11370 long symcount ATTRIBUTE_UNUSED,
11371 asymbol **syms ATTRIBUTE_UNUSED,
11376 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11379 const char *relplt_name;
11380 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11384 Elf_Internal_Shdr *hdr;
11390 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
11393 if (dynsymcount <= 0)
11396 if (!bed->plt_sym_val)
11399 relplt_name = bed->relplt_name;
11400 if (relplt_name == NULL)
11401 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
11402 relplt = bfd_get_section_by_name (abfd, relplt_name);
11403 if (relplt == NULL)
11406 hdr = &elf_section_data (relplt)->this_hdr;
11407 if (hdr->sh_link != elf_dynsymtab (abfd)
11408 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
11411 plt = bfd_get_section_by_name (abfd, ".plt");
11415 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
11416 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
11419 count = relplt->size / hdr->sh_entsize;
11420 size = count * sizeof (asymbol);
11421 p = relplt->relocation;
11422 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11424 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
11425 if (p->addend != 0)
11428 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
11430 size += sizeof ("+0x") - 1 + 8;
11435 s = *ret = (asymbol *) bfd_malloc (size);
11439 names = (char *) (s + count);
11440 p = relplt->relocation;
11442 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11447 addr = bed->plt_sym_val (i, plt, p);
11448 if (addr == (bfd_vma) -1)
11451 *s = **p->sym_ptr_ptr;
11452 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
11453 we are defining a symbol, ensure one of them is set. */
11454 if ((s->flags & BSF_LOCAL) == 0)
11455 s->flags |= BSF_GLOBAL;
11456 s->flags |= BSF_SYNTHETIC;
11458 s->value = addr - plt->vma;
11461 len = strlen ((*p->sym_ptr_ptr)->name);
11462 memcpy (names, (*p->sym_ptr_ptr)->name, len);
11464 if (p->addend != 0)
11468 memcpy (names, "+0x", sizeof ("+0x") - 1);
11469 names += sizeof ("+0x") - 1;
11470 bfd_sprintf_vma (abfd, buf, p->addend);
11471 for (a = buf; *a == '0'; ++a)
11474 memcpy (names, a, len);
11477 memcpy (names, "@plt", sizeof ("@plt"));
11478 names += sizeof ("@plt");
11485 /* It is only used by x86-64 so far.
11486 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
11487 but current usage would allow all of _bfd_std_section to be zero. */
11488 static const asymbol lcomm_sym
11489 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
11490 asection _bfd_elf_large_com_section
11491 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
11492 "LARGE_COMMON", 0, SEC_IS_COMMON);
11495 _bfd_elf_post_process_headers (bfd * abfd,
11496 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
11498 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
11500 i_ehdrp = elf_elfheader (abfd);
11502 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
11504 /* To make things simpler for the loader on Linux systems we set the
11505 osabi field to ELFOSABI_GNU if the binary contains symbols of
11506 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
11507 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
11508 && elf_tdata (abfd)->has_gnu_symbols)
11509 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
11513 /* Return TRUE for ELF symbol types that represent functions.
11514 This is the default version of this function, which is sufficient for
11515 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
11518 _bfd_elf_is_function_type (unsigned int type)
11520 return (type == STT_FUNC
11521 || type == STT_GNU_IFUNC);
11524 /* If the ELF symbol SYM might be a function in SEC, return the
11525 function size and set *CODE_OFF to the function's entry point,
11526 otherwise return zero. */
11529 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
11532 bfd_size_type size;
11534 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
11535 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
11536 || sym->section != sec)
11539 *code_off = sym->value;
11541 if (!(sym->flags & BSF_SYNTHETIC))
11542 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;