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 && !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 bfd_vma matching_lma;
6773 bfd_vma suggested_lma;
6776 asection *first_section;
6777 bfd_boolean first_matching_lma;
6778 bfd_boolean first_suggested_lma;
6780 if (segment->p_type == PT_NULL)
6783 first_section = NULL;
6784 /* Compute how many sections might be placed into this segment. */
6785 for (section = ibfd->sections, section_count = 0;
6787 section = section->next)
6789 /* Find the first section in the input segment, which may be
6790 removed from the corresponding output segment. */
6791 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6793 if (first_section == NULL)
6794 first_section = section;
6795 if (section->output_section != NULL)
6800 /* Allocate a segment map big enough to contain
6801 all of the sections we have selected. */
6802 amt = sizeof (struct elf_segment_map);
6803 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6804 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6808 /* Initialise the fields of the segment map. Default to
6809 using the physical address of the segment in the input BFD. */
6811 map->p_type = segment->p_type;
6812 map->p_flags = segment->p_flags;
6813 map->p_flags_valid = 1;
6815 /* If the first section in the input segment is removed, there is
6816 no need to preserve segment physical address in the corresponding
6818 if (!first_section || first_section->output_section != NULL)
6820 map->p_paddr = segment->p_paddr;
6821 map->p_paddr_valid = p_paddr_valid;
6824 /* Determine if this segment contains the ELF file header
6825 and if it contains the program headers themselves. */
6826 map->includes_filehdr = (segment->p_offset == 0
6827 && segment->p_filesz >= iehdr->e_ehsize);
6828 map->includes_phdrs = 0;
6830 if (!phdr_included || segment->p_type != PT_LOAD)
6832 map->includes_phdrs =
6833 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6834 && (segment->p_offset + segment->p_filesz
6835 >= ((bfd_vma) iehdr->e_phoff
6836 + iehdr->e_phnum * iehdr->e_phentsize)));
6838 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6839 phdr_included = TRUE;
6842 if (section_count == 0)
6844 /* Special segments, such as the PT_PHDR segment, may contain
6845 no sections, but ordinary, loadable segments should contain
6846 something. They are allowed by the ELF spec however, so only
6847 a warning is produced.
6848 There is however the valid use case of embedded systems which
6849 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6850 flash memory with zeros. No warning is shown for that case. */
6851 if (segment->p_type == PT_LOAD
6852 && (segment->p_filesz > 0 || segment->p_memsz == 0))
6853 /* xgettext:c-format */
6855 (_("%pB: warning: empty loadable segment detected"
6856 " at vaddr=%#" PRIx64 ", is this intentional?"),
6857 ibfd, (uint64_t) segment->p_vaddr);
6860 *pointer_to_map = map;
6861 pointer_to_map = &map->next;
6866 /* Now scan the sections in the input BFD again and attempt
6867 to add their corresponding output sections to the segment map.
6868 The problem here is how to handle an output section which has
6869 been moved (ie had its LMA changed). There are four possibilities:
6871 1. None of the sections have been moved.
6872 In this case we can continue to use the segment LMA from the
6875 2. All of the sections have been moved by the same amount.
6876 In this case we can change the segment's LMA to match the LMA
6877 of the first section.
6879 3. Some of the sections have been moved, others have not.
6880 In this case those sections which have not been moved can be
6881 placed in the current segment which will have to have its size,
6882 and possibly its LMA changed, and a new segment or segments will
6883 have to be created to contain the other sections.
6885 4. The sections have been moved, but not by the same amount.
6886 In this case we can change the segment's LMA to match the LMA
6887 of the first section and we will have to create a new segment
6888 or segments to contain the other sections.
6890 In order to save time, we allocate an array to hold the section
6891 pointers that we are interested in. As these sections get assigned
6892 to a segment, they are removed from this array. */
6894 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
6895 if (sections == NULL)
6898 /* Step One: Scan for segment vs section LMA conflicts.
6899 Also add the sections to the section array allocated above.
6900 Also add the sections to the current segment. In the common
6901 case, where the sections have not been moved, this means that
6902 we have completely filled the segment, and there is nothing
6907 first_matching_lma = TRUE;
6908 first_suggested_lma = TRUE;
6910 for (section = first_section, j = 0;
6912 section = section->next)
6914 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
6916 output_section = section->output_section;
6918 sections[j++] = section;
6920 /* The Solaris native linker always sets p_paddr to 0.
6921 We try to catch that case here, and set it to the
6922 correct value. Note - some backends require that
6923 p_paddr be left as zero. */
6925 && segment->p_vaddr != 0
6926 && !bed->want_p_paddr_set_to_zero
6928 && output_section->lma != 0
6929 && output_section->vma == (segment->p_vaddr
6930 + (map->includes_filehdr
6933 + (map->includes_phdrs
6935 * iehdr->e_phentsize)
6937 map->p_paddr = segment->p_vaddr;
6939 /* Match up the physical address of the segment with the
6940 LMA address of the output section. */
6941 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
6942 || IS_COREFILE_NOTE (segment, section)
6943 || (bed->want_p_paddr_set_to_zero
6944 && IS_CONTAINED_BY_VMA (output_section, segment)))
6946 if (first_matching_lma || output_section->lma < matching_lma)
6948 matching_lma = output_section->lma;
6949 first_matching_lma = FALSE;
6952 /* We assume that if the section fits within the segment
6953 then it does not overlap any other section within that
6955 map->sections[isec++] = output_section;
6957 else if (first_suggested_lma)
6959 suggested_lma = output_section->lma;
6960 first_suggested_lma = FALSE;
6963 if (j == section_count)
6968 BFD_ASSERT (j == section_count);
6970 /* Step Two: Adjust the physical address of the current segment,
6972 if (isec == section_count)
6974 /* All of the sections fitted within the segment as currently
6975 specified. This is the default case. Add the segment to
6976 the list of built segments and carry on to process the next
6977 program header in the input BFD. */
6978 map->count = section_count;
6979 *pointer_to_map = map;
6980 pointer_to_map = &map->next;
6983 && !bed->want_p_paddr_set_to_zero
6984 && matching_lma != map->p_paddr
6985 && !map->includes_filehdr
6986 && !map->includes_phdrs)
6987 /* There is some padding before the first section in the
6988 segment. So, we must account for that in the output
6990 map->p_vaddr_offset = matching_lma - map->p_paddr;
6997 if (!first_matching_lma)
6999 /* At least one section fits inside the current segment.
7000 Keep it, but modify its physical address to match the
7001 LMA of the first section that fitted. */
7002 map->p_paddr = matching_lma;
7006 /* None of the sections fitted inside the current segment.
7007 Change the current segment's physical address to match
7008 the LMA of the first section. */
7009 map->p_paddr = suggested_lma;
7012 /* Offset the segment physical address from the lma
7013 to allow for space taken up by elf headers. */
7014 if (map->includes_filehdr)
7016 if (map->p_paddr >= iehdr->e_ehsize)
7017 map->p_paddr -= iehdr->e_ehsize;
7020 map->includes_filehdr = FALSE;
7021 map->includes_phdrs = FALSE;
7025 if (map->includes_phdrs)
7027 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
7029 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
7031 /* iehdr->e_phnum is just an estimate of the number
7032 of program headers that we will need. Make a note
7033 here of the number we used and the segment we chose
7034 to hold these headers, so that we can adjust the
7035 offset when we know the correct value. */
7036 phdr_adjust_num = iehdr->e_phnum;
7037 phdr_adjust_seg = map;
7040 map->includes_phdrs = FALSE;
7044 /* Step Three: Loop over the sections again, this time assigning
7045 those that fit to the current segment and removing them from the
7046 sections array; but making sure not to leave large gaps. Once all
7047 possible sections have been assigned to the current segment it is
7048 added to the list of built segments and if sections still remain
7049 to be assigned, a new segment is constructed before repeating
7056 first_suggested_lma = TRUE;
7058 /* Fill the current segment with sections that fit. */
7059 for (j = 0; j < section_count; j++)
7061 section = sections[j];
7063 if (section == NULL)
7066 output_section = section->output_section;
7068 BFD_ASSERT (output_section != NULL);
7070 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7071 || IS_COREFILE_NOTE (segment, section))
7073 if (map->count == 0)
7075 /* If the first section in a segment does not start at
7076 the beginning of the segment, then something is
7078 if (output_section->lma
7080 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
7081 + (map->includes_phdrs
7082 ? iehdr->e_phnum * iehdr->e_phentsize
7090 prev_sec = map->sections[map->count - 1];
7092 /* If the gap between the end of the previous section
7093 and the start of this section is more than
7094 maxpagesize then we need to start a new segment. */
7095 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
7097 < BFD_ALIGN (output_section->lma, maxpagesize))
7098 || (prev_sec->lma + prev_sec->size
7099 > output_section->lma))
7101 if (first_suggested_lma)
7103 suggested_lma = output_section->lma;
7104 first_suggested_lma = FALSE;
7111 map->sections[map->count++] = output_section;
7114 section->segment_mark = TRUE;
7116 else if (first_suggested_lma)
7118 suggested_lma = output_section->lma;
7119 first_suggested_lma = FALSE;
7123 BFD_ASSERT (map->count > 0);
7125 /* Add the current segment to the list of built segments. */
7126 *pointer_to_map = map;
7127 pointer_to_map = &map->next;
7129 if (isec < section_count)
7131 /* We still have not allocated all of the sections to
7132 segments. Create a new segment here, initialise it
7133 and carry on looping. */
7134 amt = sizeof (struct elf_segment_map);
7135 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
7136 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7143 /* Initialise the fields of the segment map. Set the physical
7144 physical address to the LMA of the first section that has
7145 not yet been assigned. */
7147 map->p_type = segment->p_type;
7148 map->p_flags = segment->p_flags;
7149 map->p_flags_valid = 1;
7150 map->p_paddr = suggested_lma;
7151 map->p_paddr_valid = p_paddr_valid;
7152 map->includes_filehdr = 0;
7153 map->includes_phdrs = 0;
7156 while (isec < section_count);
7161 elf_seg_map (obfd) = map_first;
7163 /* If we had to estimate the number of program headers that were
7164 going to be needed, then check our estimate now and adjust
7165 the offset if necessary. */
7166 if (phdr_adjust_seg != NULL)
7170 for (count = 0, map = map_first; map != NULL; map = map->next)
7173 if (count > phdr_adjust_num)
7174 phdr_adjust_seg->p_paddr
7175 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
7180 #undef IS_CONTAINED_BY_VMA
7181 #undef IS_CONTAINED_BY_LMA
7183 #undef IS_COREFILE_NOTE
7184 #undef IS_SOLARIS_PT_INTERP
7185 #undef IS_SECTION_IN_INPUT_SEGMENT
7186 #undef INCLUDE_SECTION_IN_SEGMENT
7187 #undef SEGMENT_AFTER_SEGMENT
7188 #undef SEGMENT_OVERLAPS
7192 /* Copy ELF program header information. */
7195 copy_elf_program_header (bfd *ibfd, bfd *obfd)
7197 Elf_Internal_Ehdr *iehdr;
7198 struct elf_segment_map *map;
7199 struct elf_segment_map *map_first;
7200 struct elf_segment_map **pointer_to_map;
7201 Elf_Internal_Phdr *segment;
7203 unsigned int num_segments;
7204 bfd_boolean phdr_included = FALSE;
7205 bfd_boolean p_paddr_valid;
7207 iehdr = elf_elfheader (ibfd);
7210 pointer_to_map = &map_first;
7212 /* If all the segment p_paddr fields are zero, don't set
7213 map->p_paddr_valid. */
7214 p_paddr_valid = FALSE;
7215 num_segments = elf_elfheader (ibfd)->e_phnum;
7216 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7219 if (segment->p_paddr != 0)
7221 p_paddr_valid = TRUE;
7225 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7230 unsigned int section_count;
7232 Elf_Internal_Shdr *this_hdr;
7233 asection *first_section = NULL;
7234 asection *lowest_section;
7236 /* Compute how many sections are in this segment. */
7237 for (section = ibfd->sections, section_count = 0;
7239 section = section->next)
7241 this_hdr = &(elf_section_data(section)->this_hdr);
7242 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7244 if (first_section == NULL)
7245 first_section = section;
7250 /* Allocate a segment map big enough to contain
7251 all of the sections we have selected. */
7252 amt = sizeof (struct elf_segment_map);
7253 if (section_count != 0)
7254 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
7255 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7259 /* Initialize the fields of the output segment map with the
7262 map->p_type = segment->p_type;
7263 map->p_flags = segment->p_flags;
7264 map->p_flags_valid = 1;
7265 map->p_paddr = segment->p_paddr;
7266 map->p_paddr_valid = p_paddr_valid;
7267 map->p_align = segment->p_align;
7268 map->p_align_valid = 1;
7269 map->p_vaddr_offset = 0;
7271 if (map->p_type == PT_GNU_RELRO
7272 || map->p_type == PT_GNU_STACK)
7274 /* The PT_GNU_RELRO segment may contain the first a few
7275 bytes in the .got.plt section even if the whole .got.plt
7276 section isn't in the PT_GNU_RELRO segment. We won't
7277 change the size of the PT_GNU_RELRO segment.
7278 Similarly, PT_GNU_STACK size is significant on uclinux
7280 map->p_size = segment->p_memsz;
7281 map->p_size_valid = 1;
7284 /* Determine if this segment contains the ELF file header
7285 and if it contains the program headers themselves. */
7286 map->includes_filehdr = (segment->p_offset == 0
7287 && segment->p_filesz >= iehdr->e_ehsize);
7289 map->includes_phdrs = 0;
7290 if (! phdr_included || segment->p_type != PT_LOAD)
7292 map->includes_phdrs =
7293 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
7294 && (segment->p_offset + segment->p_filesz
7295 >= ((bfd_vma) iehdr->e_phoff
7296 + iehdr->e_phnum * iehdr->e_phentsize)));
7298 if (segment->p_type == PT_LOAD && map->includes_phdrs)
7299 phdr_included = TRUE;
7302 lowest_section = NULL;
7303 if (section_count != 0)
7305 unsigned int isec = 0;
7307 for (section = first_section;
7309 section = section->next)
7311 this_hdr = &(elf_section_data(section)->this_hdr);
7312 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7314 map->sections[isec++] = section->output_section;
7315 if ((section->flags & SEC_ALLOC) != 0)
7319 if (lowest_section == NULL
7320 || section->lma < lowest_section->lma)
7321 lowest_section = section;
7323 /* Section lmas are set up from PT_LOAD header
7324 p_paddr in _bfd_elf_make_section_from_shdr.
7325 If this header has a p_paddr that disagrees
7326 with the section lma, flag the p_paddr as
7328 if ((section->flags & SEC_LOAD) != 0)
7329 seg_off = this_hdr->sh_offset - segment->p_offset;
7331 seg_off = this_hdr->sh_addr - segment->p_vaddr;
7332 if (section->lma - segment->p_paddr != seg_off)
7333 map->p_paddr_valid = FALSE;
7335 if (isec == section_count)
7341 if (map->includes_filehdr && lowest_section != NULL)
7342 /* We need to keep the space used by the headers fixed. */
7343 map->header_size = lowest_section->vma - segment->p_vaddr;
7345 if (!map->includes_phdrs
7346 && !map->includes_filehdr
7347 && map->p_paddr_valid)
7348 /* There is some other padding before the first section. */
7349 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
7350 - segment->p_paddr);
7352 map->count = section_count;
7353 *pointer_to_map = map;
7354 pointer_to_map = &map->next;
7357 elf_seg_map (obfd) = map_first;
7361 /* Copy private BFD data. This copies or rewrites ELF program header
7365 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7367 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7368 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7371 if (elf_tdata (ibfd)->phdr == NULL)
7374 if (ibfd->xvec == obfd->xvec)
7376 /* Check to see if any sections in the input BFD
7377 covered by ELF program header have changed. */
7378 Elf_Internal_Phdr *segment;
7379 asection *section, *osec;
7380 unsigned int i, num_segments;
7381 Elf_Internal_Shdr *this_hdr;
7382 const struct elf_backend_data *bed;
7384 bed = get_elf_backend_data (ibfd);
7386 /* Regenerate the segment map if p_paddr is set to 0. */
7387 if (bed->want_p_paddr_set_to_zero)
7390 /* Initialize the segment mark field. */
7391 for (section = obfd->sections; section != NULL;
7392 section = section->next)
7393 section->segment_mark = FALSE;
7395 num_segments = elf_elfheader (ibfd)->e_phnum;
7396 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7400 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7401 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7402 which severly confuses things, so always regenerate the segment
7403 map in this case. */
7404 if (segment->p_paddr == 0
7405 && segment->p_memsz == 0
7406 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
7409 for (section = ibfd->sections;
7410 section != NULL; section = section->next)
7412 /* We mark the output section so that we know it comes
7413 from the input BFD. */
7414 osec = section->output_section;
7416 osec->segment_mark = TRUE;
7418 /* Check if this section is covered by the segment. */
7419 this_hdr = &(elf_section_data(section)->this_hdr);
7420 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7422 /* FIXME: Check if its output section is changed or
7423 removed. What else do we need to check? */
7425 || section->flags != osec->flags
7426 || section->lma != osec->lma
7427 || section->vma != osec->vma
7428 || section->size != osec->size
7429 || section->rawsize != osec->rawsize
7430 || section->alignment_power != osec->alignment_power)
7436 /* Check to see if any output section do not come from the
7438 for (section = obfd->sections; section != NULL;
7439 section = section->next)
7441 if (!section->segment_mark)
7444 section->segment_mark = FALSE;
7447 return copy_elf_program_header (ibfd, obfd);
7451 if (ibfd->xvec == obfd->xvec)
7453 /* When rewriting program header, set the output maxpagesize to
7454 the maximum alignment of input PT_LOAD segments. */
7455 Elf_Internal_Phdr *segment;
7457 unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7458 bfd_vma maxpagesize = 0;
7460 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7463 if (segment->p_type == PT_LOAD
7464 && maxpagesize < segment->p_align)
7466 /* PR 17512: file: f17299af. */
7467 if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
7468 /* xgettext:c-format */
7469 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7470 PRIx64 " is too large"),
7471 ibfd, (uint64_t) segment->p_align);
7473 maxpagesize = segment->p_align;
7476 if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7477 bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7480 return rewrite_elf_program_header (ibfd, obfd);
7483 /* Initialize private output section information from input section. */
7486 _bfd_elf_init_private_section_data (bfd *ibfd,
7490 struct bfd_link_info *link_info)
7493 Elf_Internal_Shdr *ihdr, *ohdr;
7494 bfd_boolean final_link = (link_info != NULL
7495 && !bfd_link_relocatable (link_info));
7497 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7498 || obfd->xvec->flavour != bfd_target_elf_flavour)
7501 BFD_ASSERT (elf_section_data (osec) != NULL);
7503 /* For objcopy and relocatable link, don't copy the output ELF
7504 section type from input if the output BFD section flags have been
7505 set to something different. For a final link allow some flags
7506 that the linker clears to differ. */
7507 if (elf_section_type (osec) == SHT_NULL
7508 && (osec->flags == isec->flags
7510 && ((osec->flags ^ isec->flags)
7511 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
7512 elf_section_type (osec) = elf_section_type (isec);
7514 /* FIXME: Is this correct for all OS/PROC specific flags? */
7515 elf_section_flags (osec) |= (elf_section_flags (isec)
7516 & (SHF_MASKOS | SHF_MASKPROC));
7518 /* Copy sh_info from input for mbind section. */
7519 if (elf_section_flags (isec) & SHF_GNU_MBIND)
7520 elf_section_data (osec)->this_hdr.sh_info
7521 = elf_section_data (isec)->this_hdr.sh_info;
7523 /* Set things up for objcopy and relocatable link. The output
7524 SHT_GROUP section will have its elf_next_in_group pointing back
7525 to the input group members. Ignore linker created group section.
7526 See elfNN_ia64_object_p in elfxx-ia64.c. */
7527 if ((link_info == NULL
7528 || !link_info->resolve_section_groups)
7529 && (elf_sec_group (isec) == NULL
7530 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
7532 if (elf_section_flags (isec) & SHF_GROUP)
7533 elf_section_flags (osec) |= SHF_GROUP;
7534 elf_next_in_group (osec) = elf_next_in_group (isec);
7535 elf_section_data (osec)->group = elf_section_data (isec)->group;
7538 /* If not decompress, preserve SHF_COMPRESSED. */
7539 if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
7540 elf_section_flags (osec) |= (elf_section_flags (isec)
7543 ihdr = &elf_section_data (isec)->this_hdr;
7545 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7546 don't use the output section of the linked-to section since it
7547 may be NULL at this point. */
7548 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7550 ohdr = &elf_section_data (osec)->this_hdr;
7551 ohdr->sh_flags |= SHF_LINK_ORDER;
7552 elf_linked_to_section (osec) = elf_linked_to_section (isec);
7555 osec->use_rela_p = isec->use_rela_p;
7560 /* Copy private section information. This copies over the entsize
7561 field, and sometimes the info field. */
7564 _bfd_elf_copy_private_section_data (bfd *ibfd,
7569 Elf_Internal_Shdr *ihdr, *ohdr;
7571 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7572 || obfd->xvec->flavour != bfd_target_elf_flavour)
7575 ihdr = &elf_section_data (isec)->this_hdr;
7576 ohdr = &elf_section_data (osec)->this_hdr;
7578 ohdr->sh_entsize = ihdr->sh_entsize;
7580 if (ihdr->sh_type == SHT_SYMTAB
7581 || ihdr->sh_type == SHT_DYNSYM
7582 || ihdr->sh_type == SHT_GNU_verneed
7583 || ihdr->sh_type == SHT_GNU_verdef)
7584 ohdr->sh_info = ihdr->sh_info;
7586 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7590 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7591 necessary if we are removing either the SHT_GROUP section or any of
7592 the group member sections. DISCARDED is the value that a section's
7593 output_section has if the section will be discarded, NULL when this
7594 function is called from objcopy, bfd_abs_section_ptr when called
7598 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
7602 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
7603 if (elf_section_type (isec) == SHT_GROUP)
7605 asection *first = elf_next_in_group (isec);
7606 asection *s = first;
7607 bfd_size_type removed = 0;
7611 /* If this member section is being output but the
7612 SHT_GROUP section is not, then clear the group info
7613 set up by _bfd_elf_copy_private_section_data. */
7614 if (s->output_section != discarded
7615 && isec->output_section == discarded)
7617 elf_section_flags (s->output_section) &= ~SHF_GROUP;
7618 elf_group_name (s->output_section) = NULL;
7620 /* Conversely, if the member section is not being output
7621 but the SHT_GROUP section is, then adjust its size. */
7622 else if (s->output_section == discarded
7623 && isec->output_section != discarded)
7625 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
7627 if (elf_sec->rel.hdr != NULL
7628 && (elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0)
7630 if (elf_sec->rela.hdr != NULL
7631 && (elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0)
7634 s = elf_next_in_group (s);
7640 if (discarded != NULL)
7642 /* If we've been called for ld -r, then we need to
7643 adjust the input section size. */
7644 if (isec->rawsize == 0)
7645 isec->rawsize = isec->size;
7646 isec->size = isec->rawsize - removed;
7647 if (isec->size <= 4)
7650 isec->flags |= SEC_EXCLUDE;
7655 /* Adjust the output section size when called from
7657 isec->output_section->size -= removed;
7658 if (isec->output_section->size <= 4)
7660 isec->output_section->size = 0;
7661 isec->output_section->flags |= SEC_EXCLUDE;
7670 /* Copy private header information. */
7673 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7675 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7676 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7679 /* Copy over private BFD data if it has not already been copied.
7680 This must be done here, rather than in the copy_private_bfd_data
7681 entry point, because the latter is called after the section
7682 contents have been set, which means that the program headers have
7683 already been worked out. */
7684 if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
7686 if (! copy_private_bfd_data (ibfd, obfd))
7690 return _bfd_elf_fixup_group_sections (ibfd, NULL);
7693 /* Copy private symbol information. If this symbol is in a section
7694 which we did not map into a BFD section, try to map the section
7695 index correctly. We use special macro definitions for the mapped
7696 section indices; these definitions are interpreted by the
7697 swap_out_syms function. */
7699 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7700 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7701 #define MAP_STRTAB (SHN_HIOS + 3)
7702 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7703 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7706 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
7711 elf_symbol_type *isym, *osym;
7713 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7714 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7717 isym = elf_symbol_from (ibfd, isymarg);
7718 osym = elf_symbol_from (obfd, osymarg);
7721 && isym->internal_elf_sym.st_shndx != 0
7723 && bfd_is_abs_section (isym->symbol.section))
7727 shndx = isym->internal_elf_sym.st_shndx;
7728 if (shndx == elf_onesymtab (ibfd))
7729 shndx = MAP_ONESYMTAB;
7730 else if (shndx == elf_dynsymtab (ibfd))
7731 shndx = MAP_DYNSYMTAB;
7732 else if (shndx == elf_strtab_sec (ibfd))
7734 else if (shndx == elf_shstrtab_sec (ibfd))
7735 shndx = MAP_SHSTRTAB;
7736 else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
7737 shndx = MAP_SYM_SHNDX;
7738 osym->internal_elf_sym.st_shndx = shndx;
7744 /* Swap out the symbols. */
7747 swap_out_syms (bfd *abfd,
7748 struct elf_strtab_hash **sttp,
7751 const struct elf_backend_data *bed;
7754 struct elf_strtab_hash *stt;
7755 Elf_Internal_Shdr *symtab_hdr;
7756 Elf_Internal_Shdr *symtab_shndx_hdr;
7757 Elf_Internal_Shdr *symstrtab_hdr;
7758 struct elf_sym_strtab *symstrtab;
7759 bfd_byte *outbound_syms;
7760 bfd_byte *outbound_shndx;
7761 unsigned long outbound_syms_index;
7762 unsigned long outbound_shndx_index;
7764 unsigned int num_locals;
7766 bfd_boolean name_local_sections;
7768 if (!elf_map_symbols (abfd, &num_locals))
7771 /* Dump out the symtabs. */
7772 stt = _bfd_elf_strtab_init ();
7776 bed = get_elf_backend_data (abfd);
7777 symcount = bfd_get_symcount (abfd);
7778 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7779 symtab_hdr->sh_type = SHT_SYMTAB;
7780 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7781 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
7782 symtab_hdr->sh_info = num_locals + 1;
7783 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
7785 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7786 symstrtab_hdr->sh_type = SHT_STRTAB;
7788 /* Allocate buffer to swap out the .strtab section. */
7789 symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1)
7790 * sizeof (*symstrtab));
7791 if (symstrtab == NULL)
7793 _bfd_elf_strtab_free (stt);
7797 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
7798 bed->s->sizeof_sym);
7799 if (outbound_syms == NULL)
7802 _bfd_elf_strtab_free (stt);
7806 symtab_hdr->contents = outbound_syms;
7807 outbound_syms_index = 0;
7809 outbound_shndx = NULL;
7810 outbound_shndx_index = 0;
7812 if (elf_symtab_shndx_list (abfd))
7814 symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7815 if (symtab_shndx_hdr->sh_name != 0)
7817 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7818 outbound_shndx = (bfd_byte *)
7819 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7820 if (outbound_shndx == NULL)
7823 symtab_shndx_hdr->contents = outbound_shndx;
7824 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7825 symtab_shndx_hdr->sh_size = amt;
7826 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7827 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7829 /* FIXME: What about any other headers in the list ? */
7832 /* Now generate the data (for "contents"). */
7834 /* Fill in zeroth symbol and swap it out. */
7835 Elf_Internal_Sym sym;
7841 sym.st_shndx = SHN_UNDEF;
7842 sym.st_target_internal = 0;
7843 symstrtab[0].sym = sym;
7844 symstrtab[0].dest_index = outbound_syms_index;
7845 symstrtab[0].destshndx_index = outbound_shndx_index;
7846 outbound_syms_index++;
7847 if (outbound_shndx != NULL)
7848 outbound_shndx_index++;
7852 = (bed->elf_backend_name_local_section_symbols
7853 && bed->elf_backend_name_local_section_symbols (abfd));
7855 syms = bfd_get_outsymbols (abfd);
7856 for (idx = 0; idx < symcount;)
7858 Elf_Internal_Sym sym;
7859 bfd_vma value = syms[idx]->value;
7860 elf_symbol_type *type_ptr;
7861 flagword flags = syms[idx]->flags;
7864 if (!name_local_sections
7865 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
7867 /* Local section symbols have no name. */
7868 sym.st_name = (unsigned long) -1;
7872 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7873 to get the final offset for st_name. */
7875 = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
7877 if (sym.st_name == (unsigned long) -1)
7881 type_ptr = elf_symbol_from (abfd, syms[idx]);
7883 if ((flags & BSF_SECTION_SYM) == 0
7884 && bfd_is_com_section (syms[idx]->section))
7886 /* ELF common symbols put the alignment into the `value' field,
7887 and the size into the `size' field. This is backwards from
7888 how BFD handles it, so reverse it here. */
7889 sym.st_size = value;
7890 if (type_ptr == NULL
7891 || type_ptr->internal_elf_sym.st_value == 0)
7892 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
7894 sym.st_value = type_ptr->internal_elf_sym.st_value;
7895 sym.st_shndx = _bfd_elf_section_from_bfd_section
7896 (abfd, syms[idx]->section);
7900 asection *sec = syms[idx]->section;
7903 if (sec->output_section)
7905 value += sec->output_offset;
7906 sec = sec->output_section;
7909 /* Don't add in the section vma for relocatable output. */
7910 if (! relocatable_p)
7912 sym.st_value = value;
7913 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
7915 if (bfd_is_abs_section (sec)
7917 && type_ptr->internal_elf_sym.st_shndx != 0)
7919 /* This symbol is in a real ELF section which we did
7920 not create as a BFD section. Undo the mapping done
7921 by copy_private_symbol_data. */
7922 shndx = type_ptr->internal_elf_sym.st_shndx;
7926 shndx = elf_onesymtab (abfd);
7929 shndx = elf_dynsymtab (abfd);
7932 shndx = elf_strtab_sec (abfd);
7935 shndx = elf_shstrtab_sec (abfd);
7938 if (elf_symtab_shndx_list (abfd))
7939 shndx = elf_symtab_shndx_list (abfd)->ndx;
7948 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
7950 if (shndx == SHN_BAD)
7954 /* Writing this would be a hell of a lot easier if
7955 we had some decent documentation on bfd, and
7956 knew what to expect of the library, and what to
7957 demand of applications. For example, it
7958 appears that `objcopy' might not set the
7959 section of a symbol to be a section that is
7960 actually in the output file. */
7961 sec2 = bfd_get_section_by_name (abfd, sec->name);
7963 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
7964 if (shndx == SHN_BAD)
7966 /* xgettext:c-format */
7968 (_("unable to find equivalent output section"
7969 " for symbol '%s' from section '%s'"),
7970 syms[idx]->name ? syms[idx]->name : "<Local sym>",
7972 bfd_set_error (bfd_error_invalid_operation);
7978 sym.st_shndx = shndx;
7981 if ((flags & BSF_THREAD_LOCAL) != 0)
7983 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
7984 type = STT_GNU_IFUNC;
7985 else if ((flags & BSF_FUNCTION) != 0)
7987 else if ((flags & BSF_OBJECT) != 0)
7989 else if ((flags & BSF_RELC) != 0)
7991 else if ((flags & BSF_SRELC) != 0)
7996 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
7999 /* Processor-specific types. */
8000 if (type_ptr != NULL
8001 && bed->elf_backend_get_symbol_type)
8002 type = ((*bed->elf_backend_get_symbol_type)
8003 (&type_ptr->internal_elf_sym, type));
8005 if (flags & BSF_SECTION_SYM)
8007 if (flags & BSF_GLOBAL)
8008 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8010 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
8012 else if (bfd_is_com_section (syms[idx]->section))
8014 if (type != STT_TLS)
8016 if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
8017 type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
8018 ? STT_COMMON : STT_OBJECT);
8020 type = ((flags & BSF_ELF_COMMON) != 0
8021 ? STT_COMMON : STT_OBJECT);
8023 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
8025 else if (bfd_is_und_section (syms[idx]->section))
8026 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
8030 else if (flags & BSF_FILE)
8031 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8034 int bind = STB_LOCAL;
8036 if (flags & BSF_LOCAL)
8038 else if (flags & BSF_GNU_UNIQUE)
8039 bind = STB_GNU_UNIQUE;
8040 else if (flags & BSF_WEAK)
8042 else if (flags & BSF_GLOBAL)
8045 sym.st_info = ELF_ST_INFO (bind, type);
8048 if (type_ptr != NULL)
8050 sym.st_other = type_ptr->internal_elf_sym.st_other;
8051 sym.st_target_internal
8052 = type_ptr->internal_elf_sym.st_target_internal;
8057 sym.st_target_internal = 0;
8061 symstrtab[idx].sym = sym;
8062 symstrtab[idx].dest_index = outbound_syms_index;
8063 symstrtab[idx].destshndx_index = outbound_shndx_index;
8065 outbound_syms_index++;
8066 if (outbound_shndx != NULL)
8067 outbound_shndx_index++;
8070 /* Finalize the .strtab section. */
8071 _bfd_elf_strtab_finalize (stt);
8073 /* Swap out the .strtab section. */
8074 for (idx = 0; idx <= symcount; idx++)
8076 struct elf_sym_strtab *elfsym = &symstrtab[idx];
8077 if (elfsym->sym.st_name == (unsigned long) -1)
8078 elfsym->sym.st_name = 0;
8080 elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
8081 elfsym->sym.st_name);
8082 bed->s->swap_symbol_out (abfd, &elfsym->sym,
8084 + (elfsym->dest_index
8085 * bed->s->sizeof_sym)),
8087 + (elfsym->destshndx_index
8088 * sizeof (Elf_External_Sym_Shndx))));
8093 symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
8094 symstrtab_hdr->sh_type = SHT_STRTAB;
8095 symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
8096 symstrtab_hdr->sh_addr = 0;
8097 symstrtab_hdr->sh_entsize = 0;
8098 symstrtab_hdr->sh_link = 0;
8099 symstrtab_hdr->sh_info = 0;
8100 symstrtab_hdr->sh_addralign = 1;
8105 /* Return the number of bytes required to hold the symtab vector.
8107 Note that we base it on the count plus 1, since we will null terminate
8108 the vector allocated based on this size. However, the ELF symbol table
8109 always has a dummy entry as symbol #0, so it ends up even. */
8112 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
8116 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
8118 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8119 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8121 symtab_size -= sizeof (asymbol *);
8127 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
8131 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
8133 if (elf_dynsymtab (abfd) == 0)
8135 bfd_set_error (bfd_error_invalid_operation);
8139 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8140 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8142 symtab_size -= sizeof (asymbol *);
8148 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
8151 return (asect->reloc_count + 1) * sizeof (arelent *);
8154 /* Canonicalize the relocs. */
8157 _bfd_elf_canonicalize_reloc (bfd *abfd,
8164 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8166 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
8169 tblptr = section->relocation;
8170 for (i = 0; i < section->reloc_count; i++)
8171 *relptr++ = tblptr++;
8175 return section->reloc_count;
8179 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
8181 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8182 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
8185 bfd_get_symcount (abfd) = symcount;
8190 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8191 asymbol **allocation)
8193 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8194 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
8197 bfd_get_dynamic_symcount (abfd) = symcount;
8201 /* Return the size required for the dynamic reloc entries. Any loadable
8202 section that was actually installed in the BFD, and has type SHT_REL
8203 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8204 dynamic reloc section. */
8207 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
8212 if (elf_dynsymtab (abfd) == 0)
8214 bfd_set_error (bfd_error_invalid_operation);
8218 ret = sizeof (arelent *);
8219 for (s = abfd->sections; s != NULL; s = s->next)
8220 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8221 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8222 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8223 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
8224 * sizeof (arelent *));
8229 /* Canonicalize the dynamic relocation entries. Note that we return the
8230 dynamic relocations as a single block, although they are actually
8231 associated with particular sections; the interface, which was
8232 designed for SunOS style shared libraries, expects that there is only
8233 one set of dynamic relocs. Any loadable section that was actually
8234 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8235 dynamic symbol table, is considered to be a dynamic reloc section. */
8238 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8242 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8246 if (elf_dynsymtab (abfd) == 0)
8248 bfd_set_error (bfd_error_invalid_operation);
8252 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8254 for (s = abfd->sections; s != NULL; s = s->next)
8256 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8257 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8258 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8263 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
8265 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
8267 for (i = 0; i < count; i++)
8278 /* Read in the version information. */
8281 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
8283 bfd_byte *contents = NULL;
8284 unsigned int freeidx = 0;
8286 if (elf_dynverref (abfd) != 0)
8288 Elf_Internal_Shdr *hdr;
8289 Elf_External_Verneed *everneed;
8290 Elf_Internal_Verneed *iverneed;
8292 bfd_byte *contents_end;
8294 hdr = &elf_tdata (abfd)->dynverref_hdr;
8296 if (hdr->sh_info == 0
8297 || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
8299 error_return_bad_verref:
8301 (_("%pB: .gnu.version_r invalid entry"), abfd);
8302 bfd_set_error (bfd_error_bad_value);
8303 error_return_verref:
8304 elf_tdata (abfd)->verref = NULL;
8305 elf_tdata (abfd)->cverrefs = 0;
8309 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8310 if (contents == NULL)
8311 goto error_return_verref;
8313 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8314 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8315 goto error_return_verref;
8317 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
8318 bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
8320 if (elf_tdata (abfd)->verref == NULL)
8321 goto error_return_verref;
8323 BFD_ASSERT (sizeof (Elf_External_Verneed)
8324 == sizeof (Elf_External_Vernaux));
8325 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
8326 everneed = (Elf_External_Verneed *) contents;
8327 iverneed = elf_tdata (abfd)->verref;
8328 for (i = 0; i < hdr->sh_info; i++, iverneed++)
8330 Elf_External_Vernaux *evernaux;
8331 Elf_Internal_Vernaux *ivernaux;
8334 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8336 iverneed->vn_bfd = abfd;
8338 iverneed->vn_filename =
8339 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8341 if (iverneed->vn_filename == NULL)
8342 goto error_return_bad_verref;
8344 if (iverneed->vn_cnt == 0)
8345 iverneed->vn_auxptr = NULL;
8348 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
8349 bfd_alloc2 (abfd, iverneed->vn_cnt,
8350 sizeof (Elf_Internal_Vernaux));
8351 if (iverneed->vn_auxptr == NULL)
8352 goto error_return_verref;
8355 if (iverneed->vn_aux
8356 > (size_t) (contents_end - (bfd_byte *) everneed))
8357 goto error_return_bad_verref;
8359 evernaux = ((Elf_External_Vernaux *)
8360 ((bfd_byte *) everneed + iverneed->vn_aux));
8361 ivernaux = iverneed->vn_auxptr;
8362 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8364 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8366 ivernaux->vna_nodename =
8367 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8368 ivernaux->vna_name);
8369 if (ivernaux->vna_nodename == NULL)
8370 goto error_return_bad_verref;
8372 if (ivernaux->vna_other > freeidx)
8373 freeidx = ivernaux->vna_other;
8375 ivernaux->vna_nextptr = NULL;
8376 if (ivernaux->vna_next == 0)
8378 iverneed->vn_cnt = j + 1;
8381 if (j + 1 < iverneed->vn_cnt)
8382 ivernaux->vna_nextptr = ivernaux + 1;
8384 if (ivernaux->vna_next
8385 > (size_t) (contents_end - (bfd_byte *) evernaux))
8386 goto error_return_bad_verref;
8388 evernaux = ((Elf_External_Vernaux *)
8389 ((bfd_byte *) evernaux + ivernaux->vna_next));
8392 iverneed->vn_nextref = NULL;
8393 if (iverneed->vn_next == 0)
8395 if (i + 1 < hdr->sh_info)
8396 iverneed->vn_nextref = iverneed + 1;
8398 if (iverneed->vn_next
8399 > (size_t) (contents_end - (bfd_byte *) everneed))
8400 goto error_return_bad_verref;
8402 everneed = ((Elf_External_Verneed *)
8403 ((bfd_byte *) everneed + iverneed->vn_next));
8405 elf_tdata (abfd)->cverrefs = i;
8411 if (elf_dynverdef (abfd) != 0)
8413 Elf_Internal_Shdr *hdr;
8414 Elf_External_Verdef *everdef;
8415 Elf_Internal_Verdef *iverdef;
8416 Elf_Internal_Verdef *iverdefarr;
8417 Elf_Internal_Verdef iverdefmem;
8419 unsigned int maxidx;
8420 bfd_byte *contents_end_def, *contents_end_aux;
8422 hdr = &elf_tdata (abfd)->dynverdef_hdr;
8424 if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8426 error_return_bad_verdef:
8428 (_("%pB: .gnu.version_d invalid entry"), abfd);
8429 bfd_set_error (bfd_error_bad_value);
8430 error_return_verdef:
8431 elf_tdata (abfd)->verdef = NULL;
8432 elf_tdata (abfd)->cverdefs = 0;
8436 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8437 if (contents == NULL)
8438 goto error_return_verdef;
8439 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8440 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8441 goto error_return_verdef;
8443 BFD_ASSERT (sizeof (Elf_External_Verdef)
8444 >= sizeof (Elf_External_Verdaux));
8445 contents_end_def = contents + hdr->sh_size
8446 - sizeof (Elf_External_Verdef);
8447 contents_end_aux = contents + hdr->sh_size
8448 - sizeof (Elf_External_Verdaux);
8450 /* We know the number of entries in the section but not the maximum
8451 index. Therefore we have to run through all entries and find
8453 everdef = (Elf_External_Verdef *) contents;
8455 for (i = 0; i < hdr->sh_info; ++i)
8457 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8459 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8460 goto error_return_bad_verdef;
8461 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8462 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
8464 if (iverdefmem.vd_next == 0)
8467 if (iverdefmem.vd_next
8468 > (size_t) (contents_end_def - (bfd_byte *) everdef))
8469 goto error_return_bad_verdef;
8471 everdef = ((Elf_External_Verdef *)
8472 ((bfd_byte *) everdef + iverdefmem.vd_next));
8475 if (default_imported_symver)
8477 if (freeidx > maxidx)
8483 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8484 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
8485 if (elf_tdata (abfd)->verdef == NULL)
8486 goto error_return_verdef;
8488 elf_tdata (abfd)->cverdefs = maxidx;
8490 everdef = (Elf_External_Verdef *) contents;
8491 iverdefarr = elf_tdata (abfd)->verdef;
8492 for (i = 0; i < hdr->sh_info; i++)
8494 Elf_External_Verdaux *everdaux;
8495 Elf_Internal_Verdaux *iverdaux;
8498 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8500 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
8501 goto error_return_bad_verdef;
8503 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
8504 memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
8506 iverdef->vd_bfd = abfd;
8508 if (iverdef->vd_cnt == 0)
8509 iverdef->vd_auxptr = NULL;
8512 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
8513 bfd_alloc2 (abfd, iverdef->vd_cnt,
8514 sizeof (Elf_Internal_Verdaux));
8515 if (iverdef->vd_auxptr == NULL)
8516 goto error_return_verdef;
8520 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
8521 goto error_return_bad_verdef;
8523 everdaux = ((Elf_External_Verdaux *)
8524 ((bfd_byte *) everdef + iverdef->vd_aux));
8525 iverdaux = iverdef->vd_auxptr;
8526 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8528 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8530 iverdaux->vda_nodename =
8531 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8532 iverdaux->vda_name);
8533 if (iverdaux->vda_nodename == NULL)
8534 goto error_return_bad_verdef;
8536 iverdaux->vda_nextptr = NULL;
8537 if (iverdaux->vda_next == 0)
8539 iverdef->vd_cnt = j + 1;
8542 if (j + 1 < iverdef->vd_cnt)
8543 iverdaux->vda_nextptr = iverdaux + 1;
8545 if (iverdaux->vda_next
8546 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
8547 goto error_return_bad_verdef;
8549 everdaux = ((Elf_External_Verdaux *)
8550 ((bfd_byte *) everdaux + iverdaux->vda_next));
8553 iverdef->vd_nodename = NULL;
8554 if (iverdef->vd_cnt)
8555 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
8557 iverdef->vd_nextdef = NULL;
8558 if (iverdef->vd_next == 0)
8560 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
8561 iverdef->vd_nextdef = iverdef + 1;
8563 everdef = ((Elf_External_Verdef *)
8564 ((bfd_byte *) everdef + iverdef->vd_next));
8570 else if (default_imported_symver)
8577 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8578 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
8579 if (elf_tdata (abfd)->verdef == NULL)
8582 elf_tdata (abfd)->cverdefs = freeidx;
8585 /* Create a default version based on the soname. */
8586 if (default_imported_symver)
8588 Elf_Internal_Verdef *iverdef;
8589 Elf_Internal_Verdaux *iverdaux;
8591 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
8593 iverdef->vd_version = VER_DEF_CURRENT;
8594 iverdef->vd_flags = 0;
8595 iverdef->vd_ndx = freeidx;
8596 iverdef->vd_cnt = 1;
8598 iverdef->vd_bfd = abfd;
8600 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8601 if (iverdef->vd_nodename == NULL)
8602 goto error_return_verdef;
8603 iverdef->vd_nextdef = NULL;
8604 iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8605 bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
8606 if (iverdef->vd_auxptr == NULL)
8607 goto error_return_verdef;
8609 iverdaux = iverdef->vd_auxptr;
8610 iverdaux->vda_nodename = iverdef->vd_nodename;
8616 if (contents != NULL)
8622 _bfd_elf_make_empty_symbol (bfd *abfd)
8624 elf_symbol_type *newsym;
8626 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof * newsym);
8629 newsym->symbol.the_bfd = abfd;
8630 return &newsym->symbol;
8634 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8638 bfd_symbol_info (symbol, ret);
8641 /* Return whether a symbol name implies a local symbol. Most targets
8642 use this function for the is_local_label_name entry point, but some
8646 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8649 /* Normal local symbols start with ``.L''. */
8650 if (name[0] == '.' && name[1] == 'L')
8653 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8654 DWARF debugging symbols starting with ``..''. */
8655 if (name[0] == '.' && name[1] == '.')
8658 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8659 emitting DWARF debugging output. I suspect this is actually a
8660 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8661 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8662 underscore to be emitted on some ELF targets). For ease of use,
8663 we treat such symbols as local. */
8664 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
8667 /* Treat assembler generated fake symbols, dollar local labels and
8668 forward-backward labels (aka local labels) as locals.
8669 These labels have the form:
8671 L0^A.* (fake symbols)
8673 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8675 Versions which start with .L will have already been matched above,
8676 so we only need to match the rest. */
8677 if (name[0] == 'L' && ISDIGIT (name[1]))
8679 bfd_boolean ret = FALSE;
8683 for (p = name + 2; (c = *p); p++)
8685 if (c == 1 || c == 2)
8687 if (c == 1 && p == name + 2)
8688 /* A fake symbol. */
8691 /* FIXME: We are being paranoid here and treating symbols like
8692 L0^Bfoo as if there were non-local, on the grounds that the
8693 assembler will never generate them. But can any symbol
8694 containing an ASCII value in the range 1-31 ever be anything
8695 other than some kind of local ? */
8712 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8713 asymbol *symbol ATTRIBUTE_UNUSED)
8720 _bfd_elf_set_arch_mach (bfd *abfd,
8721 enum bfd_architecture arch,
8722 unsigned long machine)
8724 /* If this isn't the right architecture for this backend, and this
8725 isn't the generic backend, fail. */
8726 if (arch != get_elf_backend_data (abfd)->arch
8727 && arch != bfd_arch_unknown
8728 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
8731 return bfd_default_set_arch_mach (abfd, arch, machine);
8734 /* Find the nearest line to a particular section and offset,
8735 for error reporting. */
8738 _bfd_elf_find_nearest_line (bfd *abfd,
8742 const char **filename_ptr,
8743 const char **functionname_ptr,
8744 unsigned int *line_ptr,
8745 unsigned int *discriminator_ptr)
8749 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
8750 filename_ptr, functionname_ptr,
8751 line_ptr, discriminator_ptr,
8752 dwarf_debug_sections, 0,
8753 &elf_tdata (abfd)->dwarf2_find_line_info)
8754 || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8755 filename_ptr, functionname_ptr,
8758 if (!*functionname_ptr)
8759 _bfd_elf_find_function (abfd, symbols, section, offset,
8760 *filename_ptr ? NULL : filename_ptr,
8765 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
8766 &found, filename_ptr,
8767 functionname_ptr, line_ptr,
8768 &elf_tdata (abfd)->line_info))
8770 if (found && (*functionname_ptr || *line_ptr))
8773 if (symbols == NULL)
8776 if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8777 filename_ptr, functionname_ptr))
8784 /* Find the line for a symbol. */
8787 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8788 const char **filename_ptr, unsigned int *line_ptr)
8790 return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8791 filename_ptr, NULL, line_ptr, NULL,
8792 dwarf_debug_sections, 0,
8793 &elf_tdata (abfd)->dwarf2_find_line_info);
8796 /* After a call to bfd_find_nearest_line, successive calls to
8797 bfd_find_inliner_info can be used to get source information about
8798 each level of function inlining that terminated at the address
8799 passed to bfd_find_nearest_line. Currently this is only supported
8800 for DWARF2 with appropriate DWARF3 extensions. */
8803 _bfd_elf_find_inliner_info (bfd *abfd,
8804 const char **filename_ptr,
8805 const char **functionname_ptr,
8806 unsigned int *line_ptr)
8809 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8810 functionname_ptr, line_ptr,
8811 & elf_tdata (abfd)->dwarf2_find_line_info);
8816 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
8818 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8819 int ret = bed->s->sizeof_ehdr;
8821 if (!bfd_link_relocatable (info))
8823 bfd_size_type phdr_size = elf_program_header_size (abfd);
8825 if (phdr_size == (bfd_size_type) -1)
8827 struct elf_segment_map *m;
8830 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
8831 phdr_size += bed->s->sizeof_phdr;
8834 phdr_size = get_program_header_size (abfd, info);
8837 elf_program_header_size (abfd) = phdr_size;
8845 _bfd_elf_set_section_contents (bfd *abfd,
8847 const void *location,
8849 bfd_size_type count)
8851 Elf_Internal_Shdr *hdr;
8854 if (! abfd->output_has_begun
8855 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
8861 hdr = &elf_section_data (section)->this_hdr;
8862 if (hdr->sh_offset == (file_ptr) -1)
8864 /* We must compress this section. Write output to the buffer. */
8865 unsigned char *contents = hdr->contents;
8866 if ((offset + count) > hdr->sh_size
8867 || (section->flags & SEC_ELF_COMPRESS) == 0
8868 || contents == NULL)
8870 memcpy (contents + offset, location, count);
8873 pos = hdr->sh_offset + offset;
8874 if (bfd_seek (abfd, pos, SEEK_SET) != 0
8875 || bfd_bwrite (location, count, abfd) != count)
8882 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
8883 arelent *cache_ptr ATTRIBUTE_UNUSED,
8884 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
8890 /* Try to convert a non-ELF reloc into an ELF one. */
8893 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
8895 /* Check whether we really have an ELF howto. */
8897 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
8899 bfd_reloc_code_real_type code;
8900 reloc_howto_type *howto;
8902 /* Alien reloc: Try to determine its type to replace it with an
8903 equivalent ELF reloc. */
8905 if (areloc->howto->pc_relative)
8907 switch (areloc->howto->bitsize)
8910 code = BFD_RELOC_8_PCREL;
8913 code = BFD_RELOC_12_PCREL;
8916 code = BFD_RELOC_16_PCREL;
8919 code = BFD_RELOC_24_PCREL;
8922 code = BFD_RELOC_32_PCREL;
8925 code = BFD_RELOC_64_PCREL;
8931 howto = bfd_reloc_type_lookup (abfd, code);
8933 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
8935 if (howto->pcrel_offset)
8936 areloc->addend += areloc->address;
8938 areloc->addend -= areloc->address; /* addend is unsigned!! */
8943 switch (areloc->howto->bitsize)
8949 code = BFD_RELOC_14;
8952 code = BFD_RELOC_16;
8955 code = BFD_RELOC_26;
8958 code = BFD_RELOC_32;
8961 code = BFD_RELOC_64;
8967 howto = bfd_reloc_type_lookup (abfd, code);
8971 areloc->howto = howto;
8979 /* xgettext:c-format */
8980 _bfd_error_handler (_("%pB: %s unsupported"),
8981 abfd, areloc->howto->name);
8982 bfd_set_error (bfd_error_bad_value);
8987 _bfd_elf_close_and_cleanup (bfd *abfd)
8989 struct elf_obj_tdata *tdata = elf_tdata (abfd);
8990 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
8992 if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
8993 _bfd_elf_strtab_free (elf_shstrtab (abfd));
8994 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
8997 return _bfd_generic_close_and_cleanup (abfd);
9000 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9001 in the relocation's offset. Thus we cannot allow any sort of sanity
9002 range-checking to interfere. There is nothing else to do in processing
9005 bfd_reloc_status_type
9006 _bfd_elf_rel_vtable_reloc_fn
9007 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
9008 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
9009 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
9010 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
9012 return bfd_reloc_ok;
9015 /* Elf core file support. Much of this only works on native
9016 toolchains, since we rely on knowing the
9017 machine-dependent procfs structure in order to pick
9018 out details about the corefile. */
9020 #ifdef HAVE_SYS_PROCFS_H
9021 /* Needed for new procfs interface on sparc-solaris. */
9022 # define _STRUCTURED_PROC 1
9023 # include <sys/procfs.h>
9026 /* Return a PID that identifies a "thread" for threaded cores, or the
9027 PID of the main process for non-threaded cores. */
9030 elfcore_make_pid (bfd *abfd)
9034 pid = elf_tdata (abfd)->core->lwpid;
9036 pid = elf_tdata (abfd)->core->pid;
9041 /* If there isn't a section called NAME, make one, using
9042 data from SECT. Note, this function will generate a
9043 reference to NAME, so you shouldn't deallocate or
9047 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
9051 if (bfd_get_section_by_name (abfd, name) != NULL)
9054 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
9058 sect2->size = sect->size;
9059 sect2->filepos = sect->filepos;
9060 sect2->alignment_power = sect->alignment_power;
9064 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9065 actually creates up to two pseudosections:
9066 - For the single-threaded case, a section named NAME, unless
9067 such a section already exists.
9068 - For the multi-threaded case, a section named "NAME/PID", where
9069 PID is elfcore_make_pid (abfd).
9070 Both pseudosections have identical contents. */
9072 _bfd_elfcore_make_pseudosection (bfd *abfd,
9078 char *threaded_name;
9082 /* Build the section name. */
9084 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
9085 len = strlen (buf) + 1;
9086 threaded_name = (char *) bfd_alloc (abfd, len);
9087 if (threaded_name == NULL)
9089 memcpy (threaded_name, buf, len);
9091 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9096 sect->filepos = filepos;
9097 sect->alignment_power = 2;
9099 return elfcore_maybe_make_sect (abfd, name, sect);
9102 /* prstatus_t exists on:
9104 linux 2.[01] + glibc
9108 #if defined (HAVE_PRSTATUS_T)
9111 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
9116 if (note->descsz == sizeof (prstatus_t))
9120 size = sizeof (prstat.pr_reg);
9121 offset = offsetof (prstatus_t, pr_reg);
9122 memcpy (&prstat, note->descdata, sizeof (prstat));
9124 /* Do not overwrite the core signal if it
9125 has already been set by another thread. */
9126 if (elf_tdata (abfd)->core->signal == 0)
9127 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9128 if (elf_tdata (abfd)->core->pid == 0)
9129 elf_tdata (abfd)->core->pid = prstat.pr_pid;
9131 /* pr_who exists on:
9134 pr_who doesn't exist on:
9137 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9138 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9140 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9143 #if defined (HAVE_PRSTATUS32_T)
9144 else if (note->descsz == sizeof (prstatus32_t))
9146 /* 64-bit host, 32-bit corefile */
9147 prstatus32_t prstat;
9149 size = sizeof (prstat.pr_reg);
9150 offset = offsetof (prstatus32_t, pr_reg);
9151 memcpy (&prstat, note->descdata, sizeof (prstat));
9153 /* Do not overwrite the core signal if it
9154 has already been set by another thread. */
9155 if (elf_tdata (abfd)->core->signal == 0)
9156 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9157 if (elf_tdata (abfd)->core->pid == 0)
9158 elf_tdata (abfd)->core->pid = prstat.pr_pid;
9160 /* pr_who exists on:
9163 pr_who doesn't exist on:
9166 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9167 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9169 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9172 #endif /* HAVE_PRSTATUS32_T */
9175 /* Fail - we don't know how to handle any other
9176 note size (ie. data object type). */
9180 /* Make a ".reg/999" section and a ".reg" section. */
9181 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9182 size, note->descpos + offset);
9184 #endif /* defined (HAVE_PRSTATUS_T) */
9186 /* Create a pseudosection containing the exact contents of NOTE. */
9188 elfcore_make_note_pseudosection (bfd *abfd,
9190 Elf_Internal_Note *note)
9192 return _bfd_elfcore_make_pseudosection (abfd, name,
9193 note->descsz, note->descpos);
9196 /* There isn't a consistent prfpregset_t across platforms,
9197 but it doesn't matter, because we don't have to pick this
9198 data structure apart. */
9201 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
9203 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9206 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9207 type of NT_PRXFPREG. Just include the whole note's contents
9211 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
9213 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9216 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9217 with a note type of NT_X86_XSTATE. Just include the whole note's
9218 contents literally. */
9221 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9223 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9227 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9229 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9233 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9235 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9239 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9241 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9245 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9247 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9251 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9253 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9257 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9259 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9263 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9265 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9269 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9271 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9275 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9277 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9281 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9283 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9287 elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9289 return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9293 elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9295 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9299 elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9301 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9305 elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9307 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9311 elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9313 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9317 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9319 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9323 elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9325 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9329 elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9331 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9335 elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9337 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9340 #if defined (HAVE_PRPSINFO_T)
9341 typedef prpsinfo_t elfcore_psinfo_t;
9342 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9343 typedef prpsinfo32_t elfcore_psinfo32_t;
9347 #if defined (HAVE_PSINFO_T)
9348 typedef psinfo_t elfcore_psinfo_t;
9349 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9350 typedef psinfo32_t elfcore_psinfo32_t;
9354 /* return a malloc'ed copy of a string at START which is at
9355 most MAX bytes long, possibly without a terminating '\0'.
9356 the copy will always have a terminating '\0'. */
9359 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
9362 char *end = (char *) memchr (start, '\0', max);
9370 dups = (char *) bfd_alloc (abfd, len + 1);
9374 memcpy (dups, start, len);
9380 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9382 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
9384 if (note->descsz == sizeof (elfcore_psinfo_t))
9386 elfcore_psinfo_t psinfo;
9388 memcpy (&psinfo, note->descdata, sizeof (psinfo));
9390 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9391 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9393 elf_tdata (abfd)->core->program
9394 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9395 sizeof (psinfo.pr_fname));
9397 elf_tdata (abfd)->core->command
9398 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9399 sizeof (psinfo.pr_psargs));
9401 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9402 else if (note->descsz == sizeof (elfcore_psinfo32_t))
9404 /* 64-bit host, 32-bit corefile */
9405 elfcore_psinfo32_t psinfo;
9407 memcpy (&psinfo, note->descdata, sizeof (psinfo));
9409 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9410 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9412 elf_tdata (abfd)->core->program
9413 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9414 sizeof (psinfo.pr_fname));
9416 elf_tdata (abfd)->core->command
9417 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9418 sizeof (psinfo.pr_psargs));
9424 /* Fail - we don't know how to handle any other
9425 note size (ie. data object type). */
9429 /* Note that for some reason, a spurious space is tacked
9430 onto the end of the args in some (at least one anyway)
9431 implementations, so strip it off if it exists. */
9434 char *command = elf_tdata (abfd)->core->command;
9435 int n = strlen (command);
9437 if (0 < n && command[n - 1] == ' ')
9438 command[n - 1] = '\0';
9443 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9445 #if defined (HAVE_PSTATUS_T)
9447 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
9449 if (note->descsz == sizeof (pstatus_t)
9450 #if defined (HAVE_PXSTATUS_T)
9451 || note->descsz == sizeof (pxstatus_t)
9457 memcpy (&pstat, note->descdata, sizeof (pstat));
9459 elf_tdata (abfd)->core->pid = pstat.pr_pid;
9461 #if defined (HAVE_PSTATUS32_T)
9462 else if (note->descsz == sizeof (pstatus32_t))
9464 /* 64-bit host, 32-bit corefile */
9467 memcpy (&pstat, note->descdata, sizeof (pstat));
9469 elf_tdata (abfd)->core->pid = pstat.pr_pid;
9472 /* Could grab some more details from the "representative"
9473 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9474 NT_LWPSTATUS note, presumably. */
9478 #endif /* defined (HAVE_PSTATUS_T) */
9480 #if defined (HAVE_LWPSTATUS_T)
9482 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
9484 lwpstatus_t lwpstat;
9490 if (note->descsz != sizeof (lwpstat)
9491 #if defined (HAVE_LWPXSTATUS_T)
9492 && note->descsz != sizeof (lwpxstatus_t)
9497 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9499 elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
9500 /* Do not overwrite the core signal if it has already been set by
9502 if (elf_tdata (abfd)->core->signal == 0)
9503 elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
9505 /* Make a ".reg/999" section. */
9507 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
9508 len = strlen (buf) + 1;
9509 name = bfd_alloc (abfd, len);
9512 memcpy (name, buf, len);
9514 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9518 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9519 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
9520 sect->filepos = note->descpos
9521 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9524 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9525 sect->size = sizeof (lwpstat.pr_reg);
9526 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9529 sect->alignment_power = 2;
9531 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
9534 /* Make a ".reg2/999" section */
9536 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
9537 len = strlen (buf) + 1;
9538 name = bfd_alloc (abfd, len);
9541 memcpy (name, buf, len);
9543 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9547 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9548 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
9549 sect->filepos = note->descpos
9550 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9553 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9554 sect->size = sizeof (lwpstat.pr_fpreg);
9555 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9558 sect->alignment_power = 2;
9560 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
9562 #endif /* defined (HAVE_LWPSTATUS_T) */
9565 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
9572 int is_active_thread;
9575 if (note->descsz < 728)
9578 if (! CONST_STRNEQ (note->namedata, "win32"))
9581 type = bfd_get_32 (abfd, note->descdata);
9585 case 1 /* NOTE_INFO_PROCESS */:
9586 /* FIXME: need to add ->core->command. */
9587 /* process_info.pid */
9588 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
9589 /* process_info.signal */
9590 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
9593 case 2 /* NOTE_INFO_THREAD */:
9594 /* Make a ".reg/999" section. */
9595 /* thread_info.tid */
9596 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
9598 len = strlen (buf) + 1;
9599 name = (char *) bfd_alloc (abfd, len);
9603 memcpy (name, buf, len);
9605 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9609 /* sizeof (thread_info.thread_context) */
9611 /* offsetof (thread_info.thread_context) */
9612 sect->filepos = note->descpos + 12;
9613 sect->alignment_power = 2;
9615 /* thread_info.is_active_thread */
9616 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9618 if (is_active_thread)
9619 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
9623 case 3 /* NOTE_INFO_MODULE */:
9624 /* Make a ".module/xxxxxxxx" section. */
9625 /* module_info.base_address */
9626 base_addr = bfd_get_32 (abfd, note->descdata + 4);
9627 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
9629 len = strlen (buf) + 1;
9630 name = (char *) bfd_alloc (abfd, len);
9634 memcpy (name, buf, len);
9636 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9641 sect->size = note->descsz;
9642 sect->filepos = note->descpos;
9643 sect->alignment_power = 2;
9654 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
9656 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9664 if (bed->elf_backend_grok_prstatus)
9665 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
9667 #if defined (HAVE_PRSTATUS_T)
9668 return elfcore_grok_prstatus (abfd, note);
9673 #if defined (HAVE_PSTATUS_T)
9675 return elfcore_grok_pstatus (abfd, note);
9678 #if defined (HAVE_LWPSTATUS_T)
9680 return elfcore_grok_lwpstatus (abfd, note);
9683 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
9684 return elfcore_grok_prfpreg (abfd, note);
9686 case NT_WIN32PSTATUS:
9687 return elfcore_grok_win32pstatus (abfd, note);
9689 case NT_PRXFPREG: /* Linux SSE extension */
9690 if (note->namesz == 6
9691 && strcmp (note->namedata, "LINUX") == 0)
9692 return elfcore_grok_prxfpreg (abfd, note);
9696 case NT_X86_XSTATE: /* Linux XSAVE extension */
9697 if (note->namesz == 6
9698 && strcmp (note->namedata, "LINUX") == 0)
9699 return elfcore_grok_xstatereg (abfd, note);
9704 if (note->namesz == 6
9705 && strcmp (note->namedata, "LINUX") == 0)
9706 return elfcore_grok_ppc_vmx (abfd, note);
9711 if (note->namesz == 6
9712 && strcmp (note->namedata, "LINUX") == 0)
9713 return elfcore_grok_ppc_vsx (abfd, note);
9717 case NT_S390_HIGH_GPRS:
9718 if (note->namesz == 6
9719 && strcmp (note->namedata, "LINUX") == 0)
9720 return elfcore_grok_s390_high_gprs (abfd, note);
9725 if (note->namesz == 6
9726 && strcmp (note->namedata, "LINUX") == 0)
9727 return elfcore_grok_s390_timer (abfd, note);
9731 case NT_S390_TODCMP:
9732 if (note->namesz == 6
9733 && strcmp (note->namedata, "LINUX") == 0)
9734 return elfcore_grok_s390_todcmp (abfd, note);
9738 case NT_S390_TODPREG:
9739 if (note->namesz == 6
9740 && strcmp (note->namedata, "LINUX") == 0)
9741 return elfcore_grok_s390_todpreg (abfd, note);
9746 if (note->namesz == 6
9747 && strcmp (note->namedata, "LINUX") == 0)
9748 return elfcore_grok_s390_ctrs (abfd, note);
9752 case NT_S390_PREFIX:
9753 if (note->namesz == 6
9754 && strcmp (note->namedata, "LINUX") == 0)
9755 return elfcore_grok_s390_prefix (abfd, note);
9759 case NT_S390_LAST_BREAK:
9760 if (note->namesz == 6
9761 && strcmp (note->namedata, "LINUX") == 0)
9762 return elfcore_grok_s390_last_break (abfd, note);
9766 case NT_S390_SYSTEM_CALL:
9767 if (note->namesz == 6
9768 && strcmp (note->namedata, "LINUX") == 0)
9769 return elfcore_grok_s390_system_call (abfd, note);
9774 if (note->namesz == 6
9775 && strcmp (note->namedata, "LINUX") == 0)
9776 return elfcore_grok_s390_tdb (abfd, note);
9780 case NT_S390_VXRS_LOW:
9781 if (note->namesz == 6
9782 && strcmp (note->namedata, "LINUX") == 0)
9783 return elfcore_grok_s390_vxrs_low (abfd, note);
9787 case NT_S390_VXRS_HIGH:
9788 if (note->namesz == 6
9789 && strcmp (note->namedata, "LINUX") == 0)
9790 return elfcore_grok_s390_vxrs_high (abfd, note);
9795 if (note->namesz == 6
9796 && strcmp (note->namedata, "LINUX") == 0)
9797 return elfcore_grok_s390_gs_cb (abfd, note);
9802 if (note->namesz == 6
9803 && strcmp (note->namedata, "LINUX") == 0)
9804 return elfcore_grok_s390_gs_bc (abfd, note);
9809 if (note->namesz == 6
9810 && strcmp (note->namedata, "LINUX") == 0)
9811 return elfcore_grok_arm_vfp (abfd, note);
9816 if (note->namesz == 6
9817 && strcmp (note->namedata, "LINUX") == 0)
9818 return elfcore_grok_aarch_tls (abfd, note);
9822 case NT_ARM_HW_BREAK:
9823 if (note->namesz == 6
9824 && strcmp (note->namedata, "LINUX") == 0)
9825 return elfcore_grok_aarch_hw_break (abfd, note);
9829 case NT_ARM_HW_WATCH:
9830 if (note->namesz == 6
9831 && strcmp (note->namedata, "LINUX") == 0)
9832 return elfcore_grok_aarch_hw_watch (abfd, note);
9838 if (bed->elf_backend_grok_psinfo)
9839 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
9841 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9842 return elfcore_grok_psinfo (abfd, note);
9849 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9854 sect->size = note->descsz;
9855 sect->filepos = note->descpos;
9856 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9862 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
9866 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
9873 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
9875 struct bfd_build_id* build_id;
9877 if (note->descsz == 0)
9880 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
9881 if (build_id == NULL)
9884 build_id->size = note->descsz;
9885 memcpy (build_id->data, note->descdata, note->descsz);
9886 abfd->build_id = build_id;
9892 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
9899 case NT_GNU_PROPERTY_TYPE_0:
9900 return _bfd_elf_parse_gnu_properties (abfd, note);
9902 case NT_GNU_BUILD_ID:
9903 return elfobj_grok_gnu_build_id (abfd, note);
9908 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
9910 struct sdt_note *cur =
9911 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
9914 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
9915 cur->size = (bfd_size_type) note->descsz;
9916 memcpy (cur->data, note->descdata, note->descsz);
9918 elf_tdata (abfd)->sdt_note_head = cur;
9924 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
9929 return elfobj_grok_stapsdt_note_1 (abfd, note);
9937 elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
9941 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
9944 if (note->descsz < 108)
9949 if (note->descsz < 120)
9957 /* Check for version 1 in pr_version. */
9958 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
9963 /* Skip over pr_psinfosz. */
9964 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
9968 offset += 4; /* Padding before pr_psinfosz. */
9972 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
9973 elf_tdata (abfd)->core->program
9974 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
9977 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
9978 elf_tdata (abfd)->core->command
9979 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
9982 /* Padding before pr_pid. */
9985 /* The pr_pid field was added in version "1a". */
9986 if (note->descsz < offset + 4)
9989 elf_tdata (abfd)->core->pid
9990 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
9996 elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
10002 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10003 Also compute minimum size of this note. */
10004 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10008 min_size = offset + (4 * 2) + 4 + 4 + 4;
10012 offset = 4 + 4 + 8; /* Includes padding before pr_statussz. */
10013 min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
10020 if (note->descsz < min_size)
10023 /* Check for version 1 in pr_version. */
10024 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10027 /* Extract size of pr_reg from pr_gregsetsz. */
10028 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10029 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10031 size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10036 size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10040 /* Skip over pr_osreldate. */
10043 /* Read signal from pr_cursig. */
10044 if (elf_tdata (abfd)->core->signal == 0)
10045 elf_tdata (abfd)->core->signal
10046 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10049 /* Read TID from pr_pid. */
10050 elf_tdata (abfd)->core->lwpid
10051 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10054 /* Padding before pr_reg. */
10055 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
10058 /* Make sure that there is enough data remaining in the note. */
10059 if ((note->descsz - offset) < size)
10062 /* Make a ".reg/999" section and a ".reg" section. */
10063 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10064 size, note->descpos + offset);
10068 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10070 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10072 switch (note->type)
10075 if (bed->elf_backend_grok_freebsd_prstatus)
10076 if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10078 return elfcore_grok_freebsd_prstatus (abfd, note);
10081 return elfcore_grok_prfpreg (abfd, note);
10084 return elfcore_grok_freebsd_psinfo (abfd, note);
10086 case NT_FREEBSD_THRMISC:
10087 if (note->namesz == 8)
10088 return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10092 case NT_FREEBSD_PROCSTAT_PROC:
10093 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10096 case NT_FREEBSD_PROCSTAT_FILES:
10097 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10100 case NT_FREEBSD_PROCSTAT_VMMAP:
10101 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10104 case NT_FREEBSD_PROCSTAT_AUXV:
10106 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10111 sect->size = note->descsz - 4;
10112 sect->filepos = note->descpos + 4;
10113 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10118 case NT_X86_XSTATE:
10119 if (note->namesz == 8)
10120 return elfcore_grok_xstatereg (abfd, note);
10124 case NT_FREEBSD_PTLWPINFO:
10125 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10129 return elfcore_grok_arm_vfp (abfd, note);
10137 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
10141 cp = strchr (note->namedata, '@');
10144 *lwpidp = atoi(cp + 1);
10151 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10153 if (note->descsz <= 0x7c + 31)
10156 /* Signal number at offset 0x08. */
10157 elf_tdata (abfd)->core->signal
10158 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10160 /* Process ID at offset 0x50. */
10161 elf_tdata (abfd)->core->pid
10162 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10164 /* Command name at 0x7c (max 32 bytes, including nul). */
10165 elf_tdata (abfd)->core->command
10166 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10168 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10173 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
10177 if (elfcore_netbsd_get_lwpid (note, &lwp))
10178 elf_tdata (abfd)->core->lwpid = lwp;
10180 if (note->type == NT_NETBSDCORE_PROCINFO)
10182 /* NetBSD-specific core "procinfo". Note that we expect to
10183 find this note before any of the others, which is fine,
10184 since the kernel writes this note out first when it
10185 creates a core file. */
10187 return elfcore_grok_netbsd_procinfo (abfd, note);
10190 /* As of Jan 2002 there are no other machine-independent notes
10191 defined for NetBSD core files. If the note type is less
10192 than the start of the machine-dependent note types, we don't
10195 if (note->type < NT_NETBSDCORE_FIRSTMACH)
10199 switch (bfd_get_arch (abfd))
10201 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10202 PT_GETFPREGS == mach+2. */
10204 case bfd_arch_alpha:
10205 case bfd_arch_sparc:
10206 switch (note->type)
10208 case NT_NETBSDCORE_FIRSTMACH+0:
10209 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10211 case NT_NETBSDCORE_FIRSTMACH+2:
10212 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10218 /* On all other arch's, PT_GETREGS == mach+1 and
10219 PT_GETFPREGS == mach+3. */
10222 switch (note->type)
10224 case NT_NETBSDCORE_FIRSTMACH+1:
10225 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10227 case NT_NETBSDCORE_FIRSTMACH+3:
10228 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10238 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10240 if (note->descsz <= 0x48 + 31)
10243 /* Signal number at offset 0x08. */
10244 elf_tdata (abfd)->core->signal
10245 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10247 /* Process ID at offset 0x20. */
10248 elf_tdata (abfd)->core->pid
10249 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10251 /* Command name at 0x48 (max 32 bytes, including nul). */
10252 elf_tdata (abfd)->core->command
10253 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10259 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10261 if (note->type == NT_OPENBSD_PROCINFO)
10262 return elfcore_grok_openbsd_procinfo (abfd, note);
10264 if (note->type == NT_OPENBSD_REGS)
10265 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10267 if (note->type == NT_OPENBSD_FPREGS)
10268 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10270 if (note->type == NT_OPENBSD_XFPREGS)
10271 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10273 if (note->type == NT_OPENBSD_AUXV)
10275 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10280 sect->size = note->descsz;
10281 sect->filepos = note->descpos;
10282 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10287 if (note->type == NT_OPENBSD_WCOOKIE)
10289 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10294 sect->size = note->descsz;
10295 sect->filepos = note->descpos;
10296 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10305 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
10307 void *ddata = note->descdata;
10314 if (note->descsz < 16)
10317 /* nto_procfs_status 'pid' field is at offset 0. */
10318 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
10320 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10321 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10323 /* nto_procfs_status 'flags' field is at offset 8. */
10324 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
10326 /* nto_procfs_status 'what' field is at offset 14. */
10327 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10329 elf_tdata (abfd)->core->signal = sig;
10330 elf_tdata (abfd)->core->lwpid = *tid;
10333 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10334 do not come from signals so we make sure we set the current
10335 thread just in case. */
10336 if (flags & 0x00000080)
10337 elf_tdata (abfd)->core->lwpid = *tid;
10339 /* Make a ".qnx_core_status/%d" section. */
10340 sprintf (buf, ".qnx_core_status/%ld", *tid);
10342 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10345 strcpy (name, buf);
10347 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10351 sect->size = note->descsz;
10352 sect->filepos = note->descpos;
10353 sect->alignment_power = 2;
10355 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10359 elfcore_grok_nto_regs (bfd *abfd,
10360 Elf_Internal_Note *note,
10368 /* Make a "(base)/%d" section. */
10369 sprintf (buf, "%s/%ld", base, tid);
10371 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10374 strcpy (name, buf);
10376 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10380 sect->size = note->descsz;
10381 sect->filepos = note->descpos;
10382 sect->alignment_power = 2;
10384 /* This is the current thread. */
10385 if (elf_tdata (abfd)->core->lwpid == tid)
10386 return elfcore_maybe_make_sect (abfd, base, sect);
10391 #define BFD_QNT_CORE_INFO 7
10392 #define BFD_QNT_CORE_STATUS 8
10393 #define BFD_QNT_CORE_GREG 9
10394 #define BFD_QNT_CORE_FPREG 10
10397 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
10399 /* Every GREG section has a STATUS section before it. Store the
10400 tid from the previous call to pass down to the next gregs
10402 static long tid = 1;
10404 switch (note->type)
10406 case BFD_QNT_CORE_INFO:
10407 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10408 case BFD_QNT_CORE_STATUS:
10409 return elfcore_grok_nto_status (abfd, note, &tid);
10410 case BFD_QNT_CORE_GREG:
10411 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10412 case BFD_QNT_CORE_FPREG:
10413 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10420 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10426 /* Use note name as section name. */
10427 len = note->namesz;
10428 name = (char *) bfd_alloc (abfd, len);
10431 memcpy (name, note->namedata, len);
10432 name[len - 1] = '\0';
10434 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10438 sect->size = note->descsz;
10439 sect->filepos = note->descpos;
10440 sect->alignment_power = 1;
10445 /* Function: elfcore_write_note
10448 buffer to hold note, and current size of buffer
10452 size of data for note
10454 Writes note to end of buffer. ELF64 notes are written exactly as
10455 for ELF32, despite the current (as of 2006) ELF gabi specifying
10456 that they ought to have 8-byte namesz and descsz field, and have
10457 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10460 Pointer to realloc'd buffer, *BUFSIZ updated. */
10463 elfcore_write_note (bfd *abfd,
10471 Elf_External_Note *xnp;
10478 namesz = strlen (name) + 1;
10480 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
10482 buf = (char *) realloc (buf, *bufsiz + newspace);
10485 dest = buf + *bufsiz;
10486 *bufsiz += newspace;
10487 xnp = (Elf_External_Note *) dest;
10488 H_PUT_32 (abfd, namesz, xnp->namesz);
10489 H_PUT_32 (abfd, size, xnp->descsz);
10490 H_PUT_32 (abfd, type, xnp->type);
10494 memcpy (dest, name, namesz);
10502 memcpy (dest, input, size);
10512 /* gcc-8 warns (*) on all the strncpy calls in this function about
10513 possible string truncation. The "truncation" is not a bug. We
10514 have an external representation of structs with fields that are not
10515 necessarily NULL terminated and corresponding internal
10516 representation fields that are one larger so that they can always
10517 be NULL terminated.
10518 gcc versions between 4.2 and 4.6 do not allow pragma control of
10519 diagnostics inside functions, giving a hard error if you try to use
10520 the finer control available with later versions.
10521 gcc prior to 4.2 warns about diagnostic push and pop.
10522 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10523 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10524 (*) Depending on your system header files! */
10525 #if GCC_VERSION >= 8000
10526 # pragma GCC diagnostic push
10527 # pragma GCC diagnostic ignored "-Wstringop-truncation"
10530 elfcore_write_prpsinfo (bfd *abfd,
10534 const char *psargs)
10536 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10538 if (bed->elf_backend_write_core_note != NULL)
10541 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10542 NT_PRPSINFO, fname, psargs);
10547 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10548 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10549 if (bed->s->elfclass == ELFCLASS32)
10551 # if defined (HAVE_PSINFO32_T)
10553 int note_type = NT_PSINFO;
10556 int note_type = NT_PRPSINFO;
10559 memset (&data, 0, sizeof (data));
10560 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10561 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10562 return elfcore_write_note (abfd, buf, bufsiz,
10563 "CORE", note_type, &data, sizeof (data));
10568 # if defined (HAVE_PSINFO_T)
10570 int note_type = NT_PSINFO;
10573 int note_type = NT_PRPSINFO;
10576 memset (&data, 0, sizeof (data));
10577 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10578 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10579 return elfcore_write_note (abfd, buf, bufsiz,
10580 "CORE", note_type, &data, sizeof (data));
10582 #endif /* PSINFO_T or PRPSINFO_T */
10587 #if GCC_VERSION >= 8000
10588 # pragma GCC diagnostic pop
10592 elfcore_write_linux_prpsinfo32
10593 (bfd *abfd, char *buf, int *bufsiz,
10594 const struct elf_internal_linux_prpsinfo *prpsinfo)
10596 if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10598 struct elf_external_linux_prpsinfo32_ugid16 data;
10600 swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10601 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10602 &data, sizeof (data));
10606 struct elf_external_linux_prpsinfo32_ugid32 data;
10608 swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10609 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10610 &data, sizeof (data));
10615 elfcore_write_linux_prpsinfo64
10616 (bfd *abfd, char *buf, int *bufsiz,
10617 const struct elf_internal_linux_prpsinfo *prpsinfo)
10619 if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
10621 struct elf_external_linux_prpsinfo64_ugid16 data;
10623 swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
10624 return elfcore_write_note (abfd, buf, bufsiz,
10625 "CORE", NT_PRPSINFO, &data, sizeof (data));
10629 struct elf_external_linux_prpsinfo64_ugid32 data;
10631 swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
10632 return elfcore_write_note (abfd, buf, bufsiz,
10633 "CORE", NT_PRPSINFO, &data, sizeof (data));
10638 elfcore_write_prstatus (bfd *abfd,
10645 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10647 if (bed->elf_backend_write_core_note != NULL)
10650 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10652 pid, cursig, gregs);
10657 #if defined (HAVE_PRSTATUS_T)
10658 #if defined (HAVE_PRSTATUS32_T)
10659 if (bed->s->elfclass == ELFCLASS32)
10661 prstatus32_t prstat;
10663 memset (&prstat, 0, sizeof (prstat));
10664 prstat.pr_pid = pid;
10665 prstat.pr_cursig = cursig;
10666 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10667 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10668 NT_PRSTATUS, &prstat, sizeof (prstat));
10675 memset (&prstat, 0, sizeof (prstat));
10676 prstat.pr_pid = pid;
10677 prstat.pr_cursig = cursig;
10678 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10679 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10680 NT_PRSTATUS, &prstat, sizeof (prstat));
10682 #endif /* HAVE_PRSTATUS_T */
10688 #if defined (HAVE_LWPSTATUS_T)
10690 elfcore_write_lwpstatus (bfd *abfd,
10697 lwpstatus_t lwpstat;
10698 const char *note_name = "CORE";
10700 memset (&lwpstat, 0, sizeof (lwpstat));
10701 lwpstat.pr_lwpid = pid >> 16;
10702 lwpstat.pr_cursig = cursig;
10703 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10704 memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
10705 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10706 #if !defined(gregs)
10707 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
10708 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
10710 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
10711 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
10714 return elfcore_write_note (abfd, buf, bufsiz, note_name,
10715 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
10717 #endif /* HAVE_LWPSTATUS_T */
10719 #if defined (HAVE_PSTATUS_T)
10721 elfcore_write_pstatus (bfd *abfd,
10725 int cursig ATTRIBUTE_UNUSED,
10726 const void *gregs ATTRIBUTE_UNUSED)
10728 const char *note_name = "CORE";
10729 #if defined (HAVE_PSTATUS32_T)
10730 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10732 if (bed->s->elfclass == ELFCLASS32)
10736 memset (&pstat, 0, sizeof (pstat));
10737 pstat.pr_pid = pid & 0xffff;
10738 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10739 NT_PSTATUS, &pstat, sizeof (pstat));
10747 memset (&pstat, 0, sizeof (pstat));
10748 pstat.pr_pid = pid & 0xffff;
10749 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10750 NT_PSTATUS, &pstat, sizeof (pstat));
10754 #endif /* HAVE_PSTATUS_T */
10757 elfcore_write_prfpreg (bfd *abfd,
10760 const void *fpregs,
10763 const char *note_name = "CORE";
10764 return elfcore_write_note (abfd, buf, bufsiz,
10765 note_name, NT_FPREGSET, fpregs, size);
10769 elfcore_write_prxfpreg (bfd *abfd,
10772 const void *xfpregs,
10775 char *note_name = "LINUX";
10776 return elfcore_write_note (abfd, buf, bufsiz,
10777 note_name, NT_PRXFPREG, xfpregs, size);
10781 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
10782 const void *xfpregs, int size)
10785 if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
10786 note_name = "FreeBSD";
10788 note_name = "LINUX";
10789 return elfcore_write_note (abfd, buf, bufsiz,
10790 note_name, NT_X86_XSTATE, xfpregs, size);
10794 elfcore_write_ppc_vmx (bfd *abfd,
10797 const void *ppc_vmx,
10800 char *note_name = "LINUX";
10801 return elfcore_write_note (abfd, buf, bufsiz,
10802 note_name, NT_PPC_VMX, ppc_vmx, size);
10806 elfcore_write_ppc_vsx (bfd *abfd,
10809 const void *ppc_vsx,
10812 char *note_name = "LINUX";
10813 return elfcore_write_note (abfd, buf, bufsiz,
10814 note_name, NT_PPC_VSX, ppc_vsx, size);
10818 elfcore_write_s390_high_gprs (bfd *abfd,
10821 const void *s390_high_gprs,
10824 char *note_name = "LINUX";
10825 return elfcore_write_note (abfd, buf, bufsiz,
10826 note_name, NT_S390_HIGH_GPRS,
10827 s390_high_gprs, size);
10831 elfcore_write_s390_timer (bfd *abfd,
10834 const void *s390_timer,
10837 char *note_name = "LINUX";
10838 return elfcore_write_note (abfd, buf, bufsiz,
10839 note_name, NT_S390_TIMER, s390_timer, size);
10843 elfcore_write_s390_todcmp (bfd *abfd,
10846 const void *s390_todcmp,
10849 char *note_name = "LINUX";
10850 return elfcore_write_note (abfd, buf, bufsiz,
10851 note_name, NT_S390_TODCMP, s390_todcmp, size);
10855 elfcore_write_s390_todpreg (bfd *abfd,
10858 const void *s390_todpreg,
10861 char *note_name = "LINUX";
10862 return elfcore_write_note (abfd, buf, bufsiz,
10863 note_name, NT_S390_TODPREG, s390_todpreg, size);
10867 elfcore_write_s390_ctrs (bfd *abfd,
10870 const void *s390_ctrs,
10873 char *note_name = "LINUX";
10874 return elfcore_write_note (abfd, buf, bufsiz,
10875 note_name, NT_S390_CTRS, s390_ctrs, size);
10879 elfcore_write_s390_prefix (bfd *abfd,
10882 const void *s390_prefix,
10885 char *note_name = "LINUX";
10886 return elfcore_write_note (abfd, buf, bufsiz,
10887 note_name, NT_S390_PREFIX, s390_prefix, size);
10891 elfcore_write_s390_last_break (bfd *abfd,
10894 const void *s390_last_break,
10897 char *note_name = "LINUX";
10898 return elfcore_write_note (abfd, buf, bufsiz,
10899 note_name, NT_S390_LAST_BREAK,
10900 s390_last_break, size);
10904 elfcore_write_s390_system_call (bfd *abfd,
10907 const void *s390_system_call,
10910 char *note_name = "LINUX";
10911 return elfcore_write_note (abfd, buf, bufsiz,
10912 note_name, NT_S390_SYSTEM_CALL,
10913 s390_system_call, size);
10917 elfcore_write_s390_tdb (bfd *abfd,
10920 const void *s390_tdb,
10923 char *note_name = "LINUX";
10924 return elfcore_write_note (abfd, buf, bufsiz,
10925 note_name, NT_S390_TDB, s390_tdb, size);
10929 elfcore_write_s390_vxrs_low (bfd *abfd,
10932 const void *s390_vxrs_low,
10935 char *note_name = "LINUX";
10936 return elfcore_write_note (abfd, buf, bufsiz,
10937 note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
10941 elfcore_write_s390_vxrs_high (bfd *abfd,
10944 const void *s390_vxrs_high,
10947 char *note_name = "LINUX";
10948 return elfcore_write_note (abfd, buf, bufsiz,
10949 note_name, NT_S390_VXRS_HIGH,
10950 s390_vxrs_high, size);
10954 elfcore_write_s390_gs_cb (bfd *abfd,
10957 const void *s390_gs_cb,
10960 char *note_name = "LINUX";
10961 return elfcore_write_note (abfd, buf, bufsiz,
10962 note_name, NT_S390_GS_CB,
10967 elfcore_write_s390_gs_bc (bfd *abfd,
10970 const void *s390_gs_bc,
10973 char *note_name = "LINUX";
10974 return elfcore_write_note (abfd, buf, bufsiz,
10975 note_name, NT_S390_GS_BC,
10980 elfcore_write_arm_vfp (bfd *abfd,
10983 const void *arm_vfp,
10986 char *note_name = "LINUX";
10987 return elfcore_write_note (abfd, buf, bufsiz,
10988 note_name, NT_ARM_VFP, arm_vfp, size);
10992 elfcore_write_aarch_tls (bfd *abfd,
10995 const void *aarch_tls,
10998 char *note_name = "LINUX";
10999 return elfcore_write_note (abfd, buf, bufsiz,
11000 note_name, NT_ARM_TLS, aarch_tls, size);
11004 elfcore_write_aarch_hw_break (bfd *abfd,
11007 const void *aarch_hw_break,
11010 char *note_name = "LINUX";
11011 return elfcore_write_note (abfd, buf, bufsiz,
11012 note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11016 elfcore_write_aarch_hw_watch (bfd *abfd,
11019 const void *aarch_hw_watch,
11022 char *note_name = "LINUX";
11023 return elfcore_write_note (abfd, buf, bufsiz,
11024 note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11028 elfcore_write_register_note (bfd *abfd,
11031 const char *section,
11035 if (strcmp (section, ".reg2") == 0)
11036 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11037 if (strcmp (section, ".reg-xfp") == 0)
11038 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
11039 if (strcmp (section, ".reg-xstate") == 0)
11040 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
11041 if (strcmp (section, ".reg-ppc-vmx") == 0)
11042 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
11043 if (strcmp (section, ".reg-ppc-vsx") == 0)
11044 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
11045 if (strcmp (section, ".reg-s390-high-gprs") == 0)
11046 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
11047 if (strcmp (section, ".reg-s390-timer") == 0)
11048 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11049 if (strcmp (section, ".reg-s390-todcmp") == 0)
11050 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11051 if (strcmp (section, ".reg-s390-todpreg") == 0)
11052 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11053 if (strcmp (section, ".reg-s390-ctrs") == 0)
11054 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11055 if (strcmp (section, ".reg-s390-prefix") == 0)
11056 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
11057 if (strcmp (section, ".reg-s390-last-break") == 0)
11058 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11059 if (strcmp (section, ".reg-s390-system-call") == 0)
11060 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
11061 if (strcmp (section, ".reg-s390-tdb") == 0)
11062 return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
11063 if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11064 return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11065 if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11066 return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
11067 if (strcmp (section, ".reg-s390-gs-cb") == 0)
11068 return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11069 if (strcmp (section, ".reg-s390-gs-bc") == 0)
11070 return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
11071 if (strcmp (section, ".reg-arm-vfp") == 0)
11072 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
11073 if (strcmp (section, ".reg-aarch-tls") == 0)
11074 return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11075 if (strcmp (section, ".reg-aarch-hw-break") == 0)
11076 return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11077 if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11078 return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
11083 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11088 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11089 gABI specifies that PT_NOTE alignment should be aligned to 4
11090 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11091 align is less than 4, we use 4 byte alignment. */
11094 if (align != 4 && align != 8)
11098 while (p < buf + size)
11100 Elf_External_Note *xnp = (Elf_External_Note *) p;
11101 Elf_Internal_Note in;
11103 if (offsetof (Elf_External_Note, name) > buf - p + size)
11106 in.type = H_GET_32 (abfd, xnp->type);
11108 in.namesz = H_GET_32 (abfd, xnp->namesz);
11109 in.namedata = xnp->name;
11110 if (in.namesz > buf - in.namedata + size)
11113 in.descsz = H_GET_32 (abfd, xnp->descsz);
11114 in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
11115 in.descpos = offset + (in.descdata - buf);
11117 && (in.descdata >= buf + size
11118 || in.descsz > buf - in.descdata + size))
11121 switch (bfd_get_format (abfd))
11128 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11131 const char * string;
11133 bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
11137 GROKER_ELEMENT ("", elfcore_grok_note),
11138 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
11139 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11140 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11141 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11142 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
11144 #undef GROKER_ELEMENT
11147 for (i = ARRAY_SIZE (grokers); i--;)
11149 if (in.namesz >= grokers[i].len
11150 && strncmp (in.namedata, grokers[i].string,
11151 grokers[i].len) == 0)
11153 if (! grokers[i].func (abfd, & in))
11162 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11164 if (! elfobj_grok_gnu_note (abfd, &in))
11167 else if (in.namesz == sizeof "stapsdt"
11168 && strcmp (in.namedata, "stapsdt") == 0)
11170 if (! elfobj_grok_stapsdt_note (abfd, &in))
11176 p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
11183 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11188 if (size == 0 || (size + 1) == 0)
11191 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11194 buf = (char *) bfd_malloc (size + 1);
11198 /* PR 17512: file: ec08f814
11199 0-termintate the buffer so that string searches will not overflow. */
11202 if (bfd_bread (buf, size, abfd) != size
11203 || !elf_parse_notes (abfd, buf, size, offset, align))
11213 /* Providing external access to the ELF program header table. */
11215 /* Return an upper bound on the number of bytes required to store a
11216 copy of ABFD's program header table entries. Return -1 if an error
11217 occurs; bfd_get_error will return an appropriate code. */
11220 bfd_get_elf_phdr_upper_bound (bfd *abfd)
11222 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11224 bfd_set_error (bfd_error_wrong_format);
11228 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
11231 /* Copy ABFD's program header table entries to *PHDRS. The entries
11232 will be stored as an array of Elf_Internal_Phdr structures, as
11233 defined in include/elf/internal.h. To find out how large the
11234 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11236 Return the number of program header table entries read, or -1 if an
11237 error occurs; bfd_get_error will return an appropriate code. */
11240 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
11244 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11246 bfd_set_error (bfd_error_wrong_format);
11250 num_phdrs = elf_elfheader (abfd)->e_phnum;
11251 memcpy (phdrs, elf_tdata (abfd)->phdr,
11252 num_phdrs * sizeof (Elf_Internal_Phdr));
11257 enum elf_reloc_type_class
11258 _bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11259 const asection *rel_sec ATTRIBUTE_UNUSED,
11260 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
11262 return reloc_class_normal;
11265 /* For RELA architectures, return the relocation value for a
11266 relocation against a local symbol. */
11269 _bfd_elf_rela_local_sym (bfd *abfd,
11270 Elf_Internal_Sym *sym,
11272 Elf_Internal_Rela *rel)
11274 asection *sec = *psec;
11275 bfd_vma relocation;
11277 relocation = (sec->output_section->vma
11278 + sec->output_offset
11280 if ((sec->flags & SEC_MERGE)
11281 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
11282 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
11285 _bfd_merged_section_offset (abfd, psec,
11286 elf_section_data (sec)->sec_info,
11287 sym->st_value + rel->r_addend);
11290 /* If we have changed the section, and our original section is
11291 marked with SEC_EXCLUDE, it means that the original
11292 SEC_MERGE section has been completely subsumed in some
11293 other SEC_MERGE section. In this case, we need to leave
11294 some info around for --emit-relocs. */
11295 if ((sec->flags & SEC_EXCLUDE) != 0)
11296 sec->kept_section = *psec;
11299 rel->r_addend -= relocation;
11300 rel->r_addend += sec->output_section->vma + sec->output_offset;
11306 _bfd_elf_rel_local_sym (bfd *abfd,
11307 Elf_Internal_Sym *sym,
11311 asection *sec = *psec;
11313 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
11314 return sym->st_value + addend;
11316 return _bfd_merged_section_offset (abfd, psec,
11317 elf_section_data (sec)->sec_info,
11318 sym->st_value + addend);
11321 /* Adjust an address within a section. Given OFFSET within SEC, return
11322 the new offset within the section, based upon changes made to the
11323 section. Returns -1 if the offset is now invalid.
11324 The offset (in abnd out) is in target sized bytes, however big a
11328 _bfd_elf_section_offset (bfd *abfd,
11329 struct bfd_link_info *info,
11333 switch (sec->sec_info_type)
11335 case SEC_INFO_TYPE_STABS:
11336 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11338 case SEC_INFO_TYPE_EH_FRAME:
11339 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
11342 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11344 /* Reverse the offset. */
11345 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11346 bfd_size_type address_size = bed->s->arch_size / 8;
11348 /* address_size and sec->size are in octets. Convert
11349 to bytes before subtracting the original offset. */
11350 offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
11356 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
11357 reconstruct an ELF file by reading the segments out of remote memory
11358 based on the ELF file header at EHDR_VMA and the ELF program headers it
11359 points to. If not null, *LOADBASEP is filled in with the difference
11360 between the VMAs from which the segments were read, and the VMAs the
11361 file headers (and hence BFD's idea of each section's VMA) put them at.
11363 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11364 remote memory at target address VMA into the local buffer at MYADDR; it
11365 should return zero on success or an `errno' code on failure. TEMPL must
11366 be a BFD for an ELF target with the word size and byte order found in
11367 the remote memory. */
11370 bfd_elf_bfd_from_remote_memory
11373 bfd_size_type size,
11374 bfd_vma *loadbasep,
11375 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
11377 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
11378 (templ, ehdr_vma, size, loadbasep, target_read_memory);
11382 _bfd_elf_get_synthetic_symtab (bfd *abfd,
11383 long symcount ATTRIBUTE_UNUSED,
11384 asymbol **syms ATTRIBUTE_UNUSED,
11389 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11392 const char *relplt_name;
11393 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11397 Elf_Internal_Shdr *hdr;
11403 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
11406 if (dynsymcount <= 0)
11409 if (!bed->plt_sym_val)
11412 relplt_name = bed->relplt_name;
11413 if (relplt_name == NULL)
11414 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
11415 relplt = bfd_get_section_by_name (abfd, relplt_name);
11416 if (relplt == NULL)
11419 hdr = &elf_section_data (relplt)->this_hdr;
11420 if (hdr->sh_link != elf_dynsymtab (abfd)
11421 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
11424 plt = bfd_get_section_by_name (abfd, ".plt");
11428 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
11429 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
11432 count = relplt->size / hdr->sh_entsize;
11433 size = count * sizeof (asymbol);
11434 p = relplt->relocation;
11435 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11437 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
11438 if (p->addend != 0)
11441 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
11443 size += sizeof ("+0x") - 1 + 8;
11448 s = *ret = (asymbol *) bfd_malloc (size);
11452 names = (char *) (s + count);
11453 p = relplt->relocation;
11455 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11460 addr = bed->plt_sym_val (i, plt, p);
11461 if (addr == (bfd_vma) -1)
11464 *s = **p->sym_ptr_ptr;
11465 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
11466 we are defining a symbol, ensure one of them is set. */
11467 if ((s->flags & BSF_LOCAL) == 0)
11468 s->flags |= BSF_GLOBAL;
11469 s->flags |= BSF_SYNTHETIC;
11471 s->value = addr - plt->vma;
11474 len = strlen ((*p->sym_ptr_ptr)->name);
11475 memcpy (names, (*p->sym_ptr_ptr)->name, len);
11477 if (p->addend != 0)
11481 memcpy (names, "+0x", sizeof ("+0x") - 1);
11482 names += sizeof ("+0x") - 1;
11483 bfd_sprintf_vma (abfd, buf, p->addend);
11484 for (a = buf; *a == '0'; ++a)
11487 memcpy (names, a, len);
11490 memcpy (names, "@plt", sizeof ("@plt"));
11491 names += sizeof ("@plt");
11498 /* It is only used by x86-64 so far.
11499 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
11500 but current usage would allow all of _bfd_std_section to be zero. */
11501 static const asymbol lcomm_sym
11502 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
11503 asection _bfd_elf_large_com_section
11504 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
11505 "LARGE_COMMON", 0, SEC_IS_COMMON);
11508 _bfd_elf_post_process_headers (bfd * abfd,
11509 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
11511 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
11513 i_ehdrp = elf_elfheader (abfd);
11515 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
11517 /* To make things simpler for the loader on Linux systems we set the
11518 osabi field to ELFOSABI_GNU if the binary contains symbols of
11519 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
11520 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
11521 && elf_tdata (abfd)->has_gnu_symbols)
11522 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
11526 /* Return TRUE for ELF symbol types that represent functions.
11527 This is the default version of this function, which is sufficient for
11528 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
11531 _bfd_elf_is_function_type (unsigned int type)
11533 return (type == STT_FUNC
11534 || type == STT_GNU_IFUNC);
11537 /* If the ELF symbol SYM might be a function in SEC, return the
11538 function size and set *CODE_OFF to the function's entry point,
11539 otherwise return zero. */
11542 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
11545 bfd_size_type size;
11547 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
11548 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
11549 || sym->section != sec)
11552 *code_off = sym->value;
11554 if (!(sym->flags & BSF_SYNTHETIC))
11555 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;