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,
632 num_group * sizeof (Elf_Internal_Shdr *));
635 for (i = 0; i < shnum; i++)
637 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
639 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
642 Elf_Internal_Group *dest;
644 /* Make sure the group section has a BFD section
646 if (!bfd_section_from_shdr (abfd, i))
649 /* Add to list of sections. */
650 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
653 /* Read the raw contents. */
654 BFD_ASSERT (sizeof (*dest) >= 4);
655 amt = shdr->sh_size * sizeof (*dest) / 4;
656 shdr->contents = (unsigned char *)
657 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
658 /* PR binutils/4110: Handle corrupt group headers. */
659 if (shdr->contents == NULL)
662 /* xgettext:c-format */
663 (_("%pB: corrupt size field in group section"
664 " header: %#" PRIx64),
665 abfd, (uint64_t) shdr->sh_size);
666 bfd_set_error (bfd_error_bad_value);
671 memset (shdr->contents, 0, amt);
673 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
674 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
678 /* xgettext:c-format */
679 (_("%pB: invalid size field in group section"
680 " header: %#" PRIx64 ""),
681 abfd, (uint64_t) shdr->sh_size);
682 bfd_set_error (bfd_error_bad_value);
684 /* PR 17510: If the group contents are even
685 partially corrupt, do not allow any of the
686 contents to be used. */
687 memset (shdr->contents, 0, amt);
691 /* Translate raw contents, a flag word followed by an
692 array of elf section indices all in target byte order,
693 to the flag word followed by an array of elf section
695 src = shdr->contents + shdr->sh_size;
696 dest = (Elf_Internal_Group *) (shdr->contents + amt);
704 idx = H_GET_32 (abfd, src);
705 if (src == shdr->contents)
708 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
709 shdr->bfd_section->flags
710 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
715 dest->shdr = elf_elfsections (abfd)[idx];
716 /* PR binutils/23199: All sections in a
717 section group should be marked with
718 SHF_GROUP. But some tools generate
719 broken objects without SHF_GROUP. Fix
721 dest->shdr->sh_flags |= SHF_GROUP;
724 || dest->shdr->sh_type == SHT_GROUP)
727 (_("%pB: invalid entry in SHT_GROUP section [%u]"),
735 /* PR 17510: Corrupt binaries might contain invalid groups. */
736 if (num_group != (unsigned) elf_tdata (abfd)->num_group)
738 elf_tdata (abfd)->num_group = num_group;
740 /* If all groups are invalid then fail. */
743 elf_tdata (abfd)->group_sect_ptr = NULL;
744 elf_tdata (abfd)->num_group = num_group = -1;
746 (_("%pB: no valid group sections found"), abfd);
747 bfd_set_error (bfd_error_bad_value);
753 if (num_group != (unsigned) -1)
755 unsigned int search_offset = elf_tdata (abfd)->group_search_offset;
758 for (j = 0; j < num_group; j++)
760 /* Begin search from previous found group. */
761 unsigned i = (j + search_offset) % num_group;
763 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
764 Elf_Internal_Group *idx;
770 idx = (Elf_Internal_Group *) shdr->contents;
771 if (idx == NULL || shdr->sh_size < 4)
773 /* See PR 21957 for a reproducer. */
774 /* xgettext:c-format */
775 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
776 abfd, shdr->bfd_section);
777 elf_tdata (abfd)->group_sect_ptr[i] = NULL;
778 bfd_set_error (bfd_error_bad_value);
781 n_elt = shdr->sh_size / 4;
783 /* Look through this group's sections to see if current
784 section is a member. */
786 if ((++idx)->shdr == hdr)
790 /* We are a member of this group. Go looking through
791 other members to see if any others are linked via
793 idx = (Elf_Internal_Group *) shdr->contents;
794 n_elt = shdr->sh_size / 4;
796 if ((++idx)->shdr != NULL
797 && (s = idx->shdr->bfd_section) != NULL
798 && elf_next_in_group (s) != NULL)
802 /* Snarf the group name from other member, and
803 insert current section in circular list. */
804 elf_group_name (newsect) = elf_group_name (s);
805 elf_next_in_group (newsect) = elf_next_in_group (s);
806 elf_next_in_group (s) = newsect;
812 gname = group_signature (abfd, shdr);
815 elf_group_name (newsect) = gname;
817 /* Start a circular list with one element. */
818 elf_next_in_group (newsect) = newsect;
821 /* If the group section has been created, point to the
823 if (shdr->bfd_section != NULL)
824 elf_next_in_group (shdr->bfd_section) = newsect;
826 elf_tdata (abfd)->group_search_offset = i;
833 if (elf_group_name (newsect) == NULL)
835 /* xgettext:c-format */
836 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
844 _bfd_elf_setup_sections (bfd *abfd)
847 unsigned int num_group = elf_tdata (abfd)->num_group;
848 bfd_boolean result = TRUE;
851 /* Process SHF_LINK_ORDER. */
852 for (s = abfd->sections; s != NULL; s = s->next)
854 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
855 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
857 unsigned int elfsec = this_hdr->sh_link;
858 /* FIXME: The old Intel compiler and old strip/objcopy may
859 not set the sh_link or sh_info fields. Hence we could
860 get the situation where elfsec is 0. */
863 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
864 if (bed->link_order_error_handler)
865 bed->link_order_error_handler
866 /* xgettext:c-format */
867 (_("%pB: warning: sh_link not set for section `%pA'"),
872 asection *linksec = NULL;
874 if (elfsec < elf_numsections (abfd))
876 this_hdr = elf_elfsections (abfd)[elfsec];
877 linksec = this_hdr->bfd_section;
881 Some strip/objcopy may leave an incorrect value in
882 sh_link. We don't want to proceed. */
886 /* xgettext:c-format */
887 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
888 s->owner, elfsec, s);
892 elf_linked_to_section (s) = linksec;
895 else if (this_hdr->sh_type == SHT_GROUP
896 && elf_next_in_group (s) == NULL)
899 /* xgettext:c-format */
900 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
901 abfd, elf_section_data (s)->this_idx);
906 /* Process section groups. */
907 if (num_group == (unsigned) -1)
910 for (i = 0; i < num_group; i++)
912 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
913 Elf_Internal_Group *idx;
916 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
917 if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
920 /* xgettext:c-format */
921 (_("%pB: section group entry number %u is corrupt"),
927 idx = (Elf_Internal_Group *) shdr->contents;
928 n_elt = shdr->sh_size / 4;
934 if (idx->shdr == NULL)
936 else if (idx->shdr->bfd_section)
937 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
938 else if (idx->shdr->sh_type != SHT_RELA
939 && idx->shdr->sh_type != SHT_REL)
941 /* There are some unknown sections in the group. */
943 /* xgettext:c-format */
944 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
947 bfd_elf_string_from_elf_section (abfd,
948 (elf_elfheader (abfd)
961 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
963 return elf_next_in_group (sec) != NULL;
967 convert_debug_to_zdebug (bfd *abfd, const char *name)
969 unsigned int len = strlen (name);
970 char *new_name = bfd_alloc (abfd, len + 2);
971 if (new_name == NULL)
975 memcpy (new_name + 2, name + 1, len);
980 convert_zdebug_to_debug (bfd *abfd, const char *name)
982 unsigned int len = strlen (name);
983 char *new_name = bfd_alloc (abfd, len);
984 if (new_name == NULL)
987 memcpy (new_name + 1, name + 2, len - 1);
991 /* Make a BFD section from an ELF section. We store a pointer to the
992 BFD section in the bfd_section field of the header. */
995 _bfd_elf_make_section_from_shdr (bfd *abfd,
996 Elf_Internal_Shdr *hdr,
1002 const struct elf_backend_data *bed;
1004 if (hdr->bfd_section != NULL)
1007 newsect = bfd_make_section_anyway (abfd, name);
1008 if (newsect == NULL)
1011 hdr->bfd_section = newsect;
1012 elf_section_data (newsect)->this_hdr = *hdr;
1013 elf_section_data (newsect)->this_idx = shindex;
1015 /* Always use the real type/flags. */
1016 elf_section_type (newsect) = hdr->sh_type;
1017 elf_section_flags (newsect) = hdr->sh_flags;
1019 newsect->filepos = hdr->sh_offset;
1021 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
1022 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
1023 || ! bfd_set_section_alignment (abfd, newsect,
1024 bfd_log2 (hdr->sh_addralign)))
1027 flags = SEC_NO_FLAGS;
1028 if (hdr->sh_type != SHT_NOBITS)
1029 flags |= SEC_HAS_CONTENTS;
1030 if (hdr->sh_type == SHT_GROUP)
1032 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1035 if (hdr->sh_type != SHT_NOBITS)
1038 if ((hdr->sh_flags & SHF_WRITE) == 0)
1039 flags |= SEC_READONLY;
1040 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
1042 else if ((flags & SEC_LOAD) != 0)
1044 if ((hdr->sh_flags & SHF_MERGE) != 0)
1047 newsect->entsize = hdr->sh_entsize;
1049 if ((hdr->sh_flags & SHF_STRINGS) != 0)
1050 flags |= SEC_STRINGS;
1051 if (hdr->sh_flags & SHF_GROUP)
1052 if (!setup_group (abfd, hdr, newsect))
1054 if ((hdr->sh_flags & SHF_TLS) != 0)
1055 flags |= SEC_THREAD_LOCAL;
1056 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
1057 flags |= SEC_EXCLUDE;
1059 if ((flags & SEC_ALLOC) == 0)
1061 /* The debugging sections appear to be recognized only by name,
1062 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1063 if (name [0] == '.')
1068 p = ".debug", n = 6;
1069 else if (name[1] == 'g' && name[2] == 'n')
1070 p = ".gnu.linkonce.wi.", n = 17;
1071 else if (name[1] == 'g' && name[2] == 'd')
1072 p = ".gdb_index", n = 11; /* yes we really do mean 11. */
1073 else if (name[1] == 'l')
1075 else if (name[1] == 's')
1077 else if (name[1] == 'z')
1078 p = ".zdebug", n = 7;
1081 if (p != NULL && strncmp (name, p, n) == 0)
1082 flags |= SEC_DEBUGGING;
1086 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1087 only link a single copy of the section. This is used to support
1088 g++. g++ will emit each template expansion in its own section.
1089 The symbols will be defined as weak, so that multiple definitions
1090 are permitted. The GNU linker extension is to actually discard
1091 all but one of the sections. */
1092 if (CONST_STRNEQ (name, ".gnu.linkonce")
1093 && elf_next_in_group (newsect) == NULL)
1094 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1096 bed = get_elf_backend_data (abfd);
1097 if (bed->elf_backend_section_flags)
1098 if (! bed->elf_backend_section_flags (&flags, hdr))
1101 if (! bfd_set_section_flags (abfd, newsect, flags))
1104 /* We do not parse the PT_NOTE segments as we are interested even in the
1105 separate debug info files which may have the segments offsets corrupted.
1106 PT_NOTEs from the core files are currently not parsed using BFD. */
1107 if (hdr->sh_type == SHT_NOTE)
1111 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
1114 elf_parse_notes (abfd, (char *) contents, hdr->sh_size,
1115 hdr->sh_offset, hdr->sh_addralign);
1119 if ((flags & SEC_ALLOC) != 0)
1121 Elf_Internal_Phdr *phdr;
1122 unsigned int i, nload;
1124 /* Some ELF linkers produce binaries with all the program header
1125 p_paddr fields zero. If we have such a binary with more than
1126 one PT_LOAD header, then leave the section lma equal to vma
1127 so that we don't create sections with overlapping lma. */
1128 phdr = elf_tdata (abfd)->phdr;
1129 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1130 if (phdr->p_paddr != 0)
1132 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
1134 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
1137 phdr = elf_tdata (abfd)->phdr;
1138 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1140 if (((phdr->p_type == PT_LOAD
1141 && (hdr->sh_flags & SHF_TLS) == 0)
1142 || phdr->p_type == PT_TLS)
1143 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
1145 if ((flags & SEC_LOAD) == 0)
1146 newsect->lma = (phdr->p_paddr
1147 + hdr->sh_addr - phdr->p_vaddr);
1149 /* We used to use the same adjustment for SEC_LOAD
1150 sections, but that doesn't work if the segment
1151 is packed with code from multiple VMAs.
1152 Instead we calculate the section LMA based on
1153 the segment LMA. It is assumed that the
1154 segment will contain sections with contiguous
1155 LMAs, even if the VMAs are not. */
1156 newsect->lma = (phdr->p_paddr
1157 + hdr->sh_offset - phdr->p_offset);
1159 /* With contiguous segments, we can't tell from file
1160 offsets whether a section with zero size should
1161 be placed at the end of one segment or the
1162 beginning of the next. Decide based on vaddr. */
1163 if (hdr->sh_addr >= phdr->p_vaddr
1164 && (hdr->sh_addr + hdr->sh_size
1165 <= phdr->p_vaddr + phdr->p_memsz))
1171 /* Compress/decompress DWARF debug sections with names: .debug_* and
1172 .zdebug_*, after the section flags is set. */
1173 if ((flags & SEC_DEBUGGING)
1174 && ((name[1] == 'd' && name[6] == '_')
1175 || (name[1] == 'z' && name[7] == '_')))
1177 enum { nothing, compress, decompress } action = nothing;
1178 int compression_header_size;
1179 bfd_size_type uncompressed_size;
1180 bfd_boolean compressed
1181 = bfd_is_section_compressed_with_header (abfd, newsect,
1182 &compression_header_size,
1183 &uncompressed_size);
1187 /* Compressed section. Check if we should decompress. */
1188 if ((abfd->flags & BFD_DECOMPRESS))
1189 action = decompress;
1192 /* Compress the uncompressed section or convert from/to .zdebug*
1193 section. Check if we should compress. */
1194 if (action == nothing)
1196 if (newsect->size != 0
1197 && (abfd->flags & BFD_COMPRESS)
1198 && compression_header_size >= 0
1199 && uncompressed_size > 0
1201 || ((compression_header_size > 0)
1202 != ((abfd->flags & BFD_COMPRESS_GABI) != 0))))
1208 if (action == compress)
1210 if (!bfd_init_section_compress_status (abfd, newsect))
1213 /* xgettext:c-format */
1214 (_("%pB: unable to initialize compress status for section %s"),
1221 if (!bfd_init_section_decompress_status (abfd, newsect))
1224 /* xgettext:c-format */
1225 (_("%pB: unable to initialize decompress status for section %s"),
1231 if (abfd->is_linker_input)
1234 && (action == decompress
1235 || (action == compress
1236 && (abfd->flags & BFD_COMPRESS_GABI) != 0)))
1238 /* Convert section name from .zdebug_* to .debug_* so
1239 that linker will consider this section as a debug
1241 char *new_name = convert_zdebug_to_debug (abfd, name);
1242 if (new_name == NULL)
1244 bfd_rename_section (abfd, newsect, new_name);
1248 /* For objdump, don't rename the section. For objcopy, delay
1249 section rename to elf_fake_sections. */
1250 newsect->flags |= SEC_ELF_RENAME;
1256 const char *const bfd_elf_section_type_names[] =
1258 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1259 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1260 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1263 /* ELF relocs are against symbols. If we are producing relocatable
1264 output, and the reloc is against an external symbol, and nothing
1265 has given us any additional addend, the resulting reloc will also
1266 be against the same symbol. In such a case, we don't want to
1267 change anything about the way the reloc is handled, since it will
1268 all be done at final link time. Rather than put special case code
1269 into bfd_perform_relocation, all the reloc types use this howto
1270 function. It just short circuits the reloc if producing
1271 relocatable output against an external symbol. */
1273 bfd_reloc_status_type
1274 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1275 arelent *reloc_entry,
1277 void *data ATTRIBUTE_UNUSED,
1278 asection *input_section,
1280 char **error_message ATTRIBUTE_UNUSED)
1282 if (output_bfd != NULL
1283 && (symbol->flags & BSF_SECTION_SYM) == 0
1284 && (! reloc_entry->howto->partial_inplace
1285 || reloc_entry->addend == 0))
1287 reloc_entry->address += input_section->output_offset;
1288 return bfd_reloc_ok;
1291 return bfd_reloc_continue;
1294 /* Returns TRUE if section A matches section B.
1295 Names, addresses and links may be different, but everything else
1296 should be the same. */
1299 section_match (const Elf_Internal_Shdr * a,
1300 const Elf_Internal_Shdr * b)
1302 if (a->sh_type != b->sh_type
1303 || ((a->sh_flags ^ b->sh_flags) & ~SHF_INFO_LINK) != 0
1304 || a->sh_addralign != b->sh_addralign
1305 || a->sh_entsize != b->sh_entsize)
1307 if (a->sh_type == SHT_SYMTAB
1308 || a->sh_type == SHT_STRTAB)
1310 return a->sh_size == b->sh_size;
1313 /* Find a section in OBFD that has the same characteristics
1314 as IHEADER. Return the index of this section or SHN_UNDEF if
1315 none can be found. Check's section HINT first, as this is likely
1316 to be the correct section. */
1319 find_link (const bfd *obfd, const Elf_Internal_Shdr *iheader,
1320 const unsigned int hint)
1322 Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd);
1325 BFD_ASSERT (iheader != NULL);
1327 /* See PR 20922 for a reproducer of the NULL test. */
1328 if (hint < elf_numsections (obfd)
1329 && oheaders[hint] != NULL
1330 && section_match (oheaders[hint], iheader))
1333 for (i = 1; i < elf_numsections (obfd); i++)
1335 Elf_Internal_Shdr * oheader = oheaders[i];
1337 if (oheader == NULL)
1339 if (section_match (oheader, iheader))
1340 /* FIXME: Do we care if there is a potential for
1341 multiple matches ? */
1348 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1349 Processor specific section, based upon a matching input section.
1350 Returns TRUE upon success, FALSE otherwise. */
1353 copy_special_section_fields (const bfd *ibfd,
1355 const Elf_Internal_Shdr *iheader,
1356 Elf_Internal_Shdr *oheader,
1357 const unsigned int secnum)
1359 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
1360 const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1361 bfd_boolean changed = FALSE;
1362 unsigned int sh_link;
1364 if (oheader->sh_type == SHT_NOBITS)
1366 /* This is a feature for objcopy --only-keep-debug:
1367 When a section's type is changed to NOBITS, we preserve
1368 the sh_link and sh_info fields so that they can be
1369 matched up with the original.
1371 Note: Strictly speaking these assignments are wrong.
1372 The sh_link and sh_info fields should point to the
1373 relevent sections in the output BFD, which may not be in
1374 the same location as they were in the input BFD. But
1375 the whole point of this action is to preserve the
1376 original values of the sh_link and sh_info fields, so
1377 that they can be matched up with the section headers in
1378 the original file. So strictly speaking we may be
1379 creating an invalid ELF file, but it is only for a file
1380 that just contains debug info and only for sections
1381 without any contents. */
1382 if (oheader->sh_link == 0)
1383 oheader->sh_link = iheader->sh_link;
1384 if (oheader->sh_info == 0)
1385 oheader->sh_info = iheader->sh_info;
1389 /* Allow the target a chance to decide how these fields should be set. */
1390 if (bed->elf_backend_copy_special_section_fields != NULL
1391 && bed->elf_backend_copy_special_section_fields
1392 (ibfd, obfd, iheader, oheader))
1395 /* We have an iheader which might match oheader, and which has non-zero
1396 sh_info and/or sh_link fields. Attempt to follow those links and find
1397 the section in the output bfd which corresponds to the linked section
1398 in the input bfd. */
1399 if (iheader->sh_link != SHN_UNDEF)
1401 /* See PR 20931 for a reproducer. */
1402 if (iheader->sh_link >= elf_numsections (ibfd))
1405 /* xgettext:c-format */
1406 (_("%pB: invalid sh_link field (%d) in section number %d"),
1407 ibfd, iheader->sh_link, secnum);
1411 sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link);
1412 if (sh_link != SHN_UNDEF)
1414 oheader->sh_link = sh_link;
1418 /* FIXME: Should we install iheader->sh_link
1419 if we could not find a match ? */
1421 /* xgettext:c-format */
1422 (_("%pB: failed to find link section for section %d"), obfd, secnum);
1425 if (iheader->sh_info)
1427 /* The sh_info field can hold arbitrary information, but if the
1428 SHF_LINK_INFO flag is set then it should be interpreted as a
1430 if (iheader->sh_flags & SHF_INFO_LINK)
1432 sh_link = find_link (obfd, iheaders[iheader->sh_info],
1434 if (sh_link != SHN_UNDEF)
1435 oheader->sh_flags |= SHF_INFO_LINK;
1438 /* No idea what it means - just copy it. */
1439 sh_link = iheader->sh_info;
1441 if (sh_link != SHN_UNDEF)
1443 oheader->sh_info = sh_link;
1448 /* xgettext:c-format */
1449 (_("%pB: failed to find info section for section %d"), obfd, secnum);
1455 /* Copy the program header and other data from one object module to
1459 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1461 const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1462 Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
1463 const struct elf_backend_data *bed;
1466 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1467 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1470 if (!elf_flags_init (obfd))
1472 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1473 elf_flags_init (obfd) = TRUE;
1476 elf_gp (obfd) = elf_gp (ibfd);
1478 /* Also copy the EI_OSABI field. */
1479 elf_elfheader (obfd)->e_ident[EI_OSABI] =
1480 elf_elfheader (ibfd)->e_ident[EI_OSABI];
1482 /* If set, copy the EI_ABIVERSION field. */
1483 if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION])
1484 elf_elfheader (obfd)->e_ident[EI_ABIVERSION]
1485 = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION];
1487 /* Copy object attributes. */
1488 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1490 if (iheaders == NULL || oheaders == NULL)
1493 bed = get_elf_backend_data (obfd);
1495 /* Possibly copy other fields in the section header. */
1496 for (i = 1; i < elf_numsections (obfd); i++)
1499 Elf_Internal_Shdr * oheader = oheaders[i];
1501 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1502 because of a special case need for generating separate debug info
1503 files. See below for more details. */
1505 || (oheader->sh_type != SHT_NOBITS
1506 && oheader->sh_type < SHT_LOOS))
1509 /* Ignore empty sections, and sections whose
1510 fields have already been initialised. */
1511 if (oheader->sh_size == 0
1512 || (oheader->sh_info != 0 && oheader->sh_link != 0))
1515 /* Scan for the matching section in the input bfd.
1516 First we try for a direct mapping between the input and output sections. */
1517 for (j = 1; j < elf_numsections (ibfd); j++)
1519 const Elf_Internal_Shdr * iheader = iheaders[j];
1521 if (iheader == NULL)
1524 if (oheader->bfd_section != NULL
1525 && iheader->bfd_section != NULL
1526 && iheader->bfd_section->output_section != NULL
1527 && iheader->bfd_section->output_section == oheader->bfd_section)
1529 /* We have found a connection from the input section to the
1530 output section. Attempt to copy the header fields. If
1531 this fails then do not try any further sections - there
1532 should only be a one-to-one mapping between input and output. */
1533 if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1534 j = elf_numsections (ibfd);
1539 if (j < elf_numsections (ibfd))
1542 /* That failed. So try to deduce the corresponding input section.
1543 Unfortunately we cannot compare names as the output string table
1544 is empty, so instead we check size, address and type. */
1545 for (j = 1; j < elf_numsections (ibfd); j++)
1547 const Elf_Internal_Shdr * iheader = iheaders[j];
1549 if (iheader == NULL)
1552 /* Try matching fields in the input section's header.
1553 Since --only-keep-debug turns all non-debug sections into
1554 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1556 if ((oheader->sh_type == SHT_NOBITS
1557 || iheader->sh_type == oheader->sh_type)
1558 && (iheader->sh_flags & ~ SHF_INFO_LINK)
1559 == (oheader->sh_flags & ~ SHF_INFO_LINK)
1560 && iheader->sh_addralign == oheader->sh_addralign
1561 && iheader->sh_entsize == oheader->sh_entsize
1562 && iheader->sh_size == oheader->sh_size
1563 && iheader->sh_addr == oheader->sh_addr
1564 && (iheader->sh_info != oheader->sh_info
1565 || iheader->sh_link != oheader->sh_link))
1567 if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1572 if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS)
1574 /* Final attempt. Call the backend copy function
1575 with a NULL input section. */
1576 if (bed->elf_backend_copy_special_section_fields != NULL)
1577 bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
1585 get_segment_type (unsigned int p_type)
1590 case PT_NULL: pt = "NULL"; break;
1591 case PT_LOAD: pt = "LOAD"; break;
1592 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1593 case PT_INTERP: pt = "INTERP"; break;
1594 case PT_NOTE: pt = "NOTE"; break;
1595 case PT_SHLIB: pt = "SHLIB"; break;
1596 case PT_PHDR: pt = "PHDR"; break;
1597 case PT_TLS: pt = "TLS"; break;
1598 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1599 case PT_GNU_STACK: pt = "STACK"; break;
1600 case PT_GNU_RELRO: pt = "RELRO"; break;
1601 default: pt = NULL; break;
1606 /* Print out the program headers. */
1609 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1611 FILE *f = (FILE *) farg;
1612 Elf_Internal_Phdr *p;
1614 bfd_byte *dynbuf = NULL;
1616 p = elf_tdata (abfd)->phdr;
1621 fprintf (f, _("\nProgram Header:\n"));
1622 c = elf_elfheader (abfd)->e_phnum;
1623 for (i = 0; i < c; i++, p++)
1625 const char *pt = get_segment_type (p->p_type);
1630 sprintf (buf, "0x%lx", p->p_type);
1633 fprintf (f, "%8s off 0x", pt);
1634 bfd_fprintf_vma (abfd, f, p->p_offset);
1635 fprintf (f, " vaddr 0x");
1636 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1637 fprintf (f, " paddr 0x");
1638 bfd_fprintf_vma (abfd, f, p->p_paddr);
1639 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1640 fprintf (f, " filesz 0x");
1641 bfd_fprintf_vma (abfd, f, p->p_filesz);
1642 fprintf (f, " memsz 0x");
1643 bfd_fprintf_vma (abfd, f, p->p_memsz);
1644 fprintf (f, " flags %c%c%c",
1645 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1646 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1647 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1648 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1649 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1654 s = bfd_get_section_by_name (abfd, ".dynamic");
1657 unsigned int elfsec;
1658 unsigned long shlink;
1659 bfd_byte *extdyn, *extdynend;
1661 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1663 fprintf (f, _("\nDynamic Section:\n"));
1665 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1668 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1669 if (elfsec == SHN_BAD)
1671 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1673 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1674 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1677 /* PR 17512: file: 6f427532. */
1678 if (s->size < extdynsize)
1680 extdynend = extdyn + s->size;
1681 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1683 for (; extdyn <= (extdynend - extdynsize); extdyn += extdynsize)
1685 Elf_Internal_Dyn dyn;
1686 const char *name = "";
1688 bfd_boolean stringp;
1689 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1691 (*swap_dyn_in) (abfd, extdyn, &dyn);
1693 if (dyn.d_tag == DT_NULL)
1700 if (bed->elf_backend_get_target_dtag)
1701 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1703 if (!strcmp (name, ""))
1705 sprintf (ab, "%#" BFD_VMA_FMT "x", dyn.d_tag);
1710 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1711 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1712 case DT_PLTGOT: name = "PLTGOT"; break;
1713 case DT_HASH: name = "HASH"; break;
1714 case DT_STRTAB: name = "STRTAB"; break;
1715 case DT_SYMTAB: name = "SYMTAB"; break;
1716 case DT_RELA: name = "RELA"; break;
1717 case DT_RELASZ: name = "RELASZ"; break;
1718 case DT_RELAENT: name = "RELAENT"; break;
1719 case DT_STRSZ: name = "STRSZ"; break;
1720 case DT_SYMENT: name = "SYMENT"; break;
1721 case DT_INIT: name = "INIT"; break;
1722 case DT_FINI: name = "FINI"; break;
1723 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1724 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1725 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1726 case DT_REL: name = "REL"; break;
1727 case DT_RELSZ: name = "RELSZ"; break;
1728 case DT_RELENT: name = "RELENT"; break;
1729 case DT_PLTREL: name = "PLTREL"; break;
1730 case DT_DEBUG: name = "DEBUG"; break;
1731 case DT_TEXTREL: name = "TEXTREL"; break;
1732 case DT_JMPREL: name = "JMPREL"; break;
1733 case DT_BIND_NOW: name = "BIND_NOW"; break;
1734 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1735 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1736 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1737 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1738 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1739 case DT_FLAGS: name = "FLAGS"; break;
1740 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1741 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1742 case DT_CHECKSUM: name = "CHECKSUM"; break;
1743 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1744 case DT_MOVEENT: name = "MOVEENT"; break;
1745 case DT_MOVESZ: name = "MOVESZ"; break;
1746 case DT_FEATURE: name = "FEATURE"; break;
1747 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1748 case DT_SYMINSZ: name = "SYMINSZ"; break;
1749 case DT_SYMINENT: name = "SYMINENT"; break;
1750 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1751 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1752 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1753 case DT_PLTPAD: name = "PLTPAD"; break;
1754 case DT_MOVETAB: name = "MOVETAB"; break;
1755 case DT_SYMINFO: name = "SYMINFO"; break;
1756 case DT_RELACOUNT: name = "RELACOUNT"; break;
1757 case DT_RELCOUNT: name = "RELCOUNT"; break;
1758 case DT_FLAGS_1: name = "FLAGS_1"; break;
1759 case DT_VERSYM: name = "VERSYM"; break;
1760 case DT_VERDEF: name = "VERDEF"; break;
1761 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1762 case DT_VERNEED: name = "VERNEED"; break;
1763 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1764 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1765 case DT_USED: name = "USED"; break;
1766 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1767 case DT_GNU_HASH: name = "GNU_HASH"; break;
1770 fprintf (f, " %-20s ", name);
1774 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1779 unsigned int tagv = dyn.d_un.d_val;
1781 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1784 fprintf (f, "%s", string);
1793 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1794 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1796 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1800 if (elf_dynverdef (abfd) != 0)
1802 Elf_Internal_Verdef *t;
1804 fprintf (f, _("\nVersion definitions:\n"));
1805 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1807 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1808 t->vd_flags, t->vd_hash,
1809 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1810 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1812 Elf_Internal_Verdaux *a;
1815 for (a = t->vd_auxptr->vda_nextptr;
1819 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1825 if (elf_dynverref (abfd) != 0)
1827 Elf_Internal_Verneed *t;
1829 fprintf (f, _("\nVersion References:\n"));
1830 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1832 Elf_Internal_Vernaux *a;
1834 fprintf (f, _(" required from %s:\n"),
1835 t->vn_filename ? t->vn_filename : "<corrupt>");
1836 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1837 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1838 a->vna_flags, a->vna_other,
1839 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1851 /* Get version string. */
1854 _bfd_elf_get_symbol_version_string (bfd *abfd, asymbol *symbol,
1855 bfd_boolean *hidden)
1857 const char *version_string = NULL;
1858 if (elf_dynversym (abfd) != 0
1859 && (elf_dynverdef (abfd) != 0 || elf_dynverref (abfd) != 0))
1861 unsigned int vernum = ((elf_symbol_type *) symbol)->version;
1863 *hidden = (vernum & VERSYM_HIDDEN) != 0;
1864 vernum &= VERSYM_VERSION;
1867 version_string = "";
1868 else if (vernum == 1
1869 && (vernum > elf_tdata (abfd)->cverdefs
1870 || (elf_tdata (abfd)->verdef[0].vd_flags
1872 version_string = "Base";
1873 else if (vernum <= elf_tdata (abfd)->cverdefs)
1875 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1878 Elf_Internal_Verneed *t;
1880 version_string = _("<corrupt>");
1881 for (t = elf_tdata (abfd)->verref;
1885 Elf_Internal_Vernaux *a;
1887 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1889 if (a->vna_other == vernum)
1891 version_string = a->vna_nodename;
1898 return version_string;
1901 /* Display ELF-specific fields of a symbol. */
1904 bfd_elf_print_symbol (bfd *abfd,
1907 bfd_print_symbol_type how)
1909 FILE *file = (FILE *) filep;
1912 case bfd_print_symbol_name:
1913 fprintf (file, "%s", symbol->name);
1915 case bfd_print_symbol_more:
1916 fprintf (file, "elf ");
1917 bfd_fprintf_vma (abfd, file, symbol->value);
1918 fprintf (file, " %x", symbol->flags);
1920 case bfd_print_symbol_all:
1922 const char *section_name;
1923 const char *name = NULL;
1924 const struct elf_backend_data *bed;
1925 unsigned char st_other;
1927 const char *version_string;
1930 section_name = symbol->section ? symbol->section->name : "(*none*)";
1932 bed = get_elf_backend_data (abfd);
1933 if (bed->elf_backend_print_symbol_all)
1934 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1938 name = symbol->name;
1939 bfd_print_symbol_vandf (abfd, file, symbol);
1942 fprintf (file, " %s\t", section_name);
1943 /* Print the "other" value for a symbol. For common symbols,
1944 we've already printed the size; now print the alignment.
1945 For other symbols, we have no specified alignment, and
1946 we've printed the address; now print the size. */
1947 if (symbol->section && bfd_is_com_section (symbol->section))
1948 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1950 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1951 bfd_fprintf_vma (abfd, file, val);
1953 /* If we have version information, print it. */
1954 version_string = _bfd_elf_get_symbol_version_string (abfd,
1960 fprintf (file, " %-11s", version_string);
1965 fprintf (file, " (%s)", version_string);
1966 for (i = 10 - strlen (version_string); i > 0; --i)
1971 /* If the st_other field is not zero, print it. */
1972 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1977 case STV_INTERNAL: fprintf (file, " .internal"); break;
1978 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1979 case STV_PROTECTED: fprintf (file, " .protected"); break;
1981 /* Some other non-defined flags are also present, so print
1983 fprintf (file, " 0x%02x", (unsigned int) st_other);
1986 fprintf (file, " %s", name);
1992 /* ELF .o/exec file reading */
1994 /* Create a new bfd section from an ELF section header. */
1997 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1999 Elf_Internal_Shdr *hdr;
2000 Elf_Internal_Ehdr *ehdr;
2001 const struct elf_backend_data *bed;
2003 bfd_boolean ret = TRUE;
2004 static bfd_boolean * sections_being_created = NULL;
2005 static bfd * sections_being_created_abfd = NULL;
2006 static unsigned int nesting = 0;
2008 if (shindex >= elf_numsections (abfd))
2013 /* PR17512: A corrupt ELF binary might contain a recursive group of
2014 sections, with each the string indices pointing to the next in the
2015 loop. Detect this here, by refusing to load a section that we are
2016 already in the process of loading. We only trigger this test if
2017 we have nested at least three sections deep as normal ELF binaries
2018 can expect to recurse at least once.
2020 FIXME: It would be better if this array was attached to the bfd,
2021 rather than being held in a static pointer. */
2023 if (sections_being_created_abfd != abfd)
2024 sections_being_created = NULL;
2025 if (sections_being_created == NULL)
2027 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
2028 sections_being_created = (bfd_boolean *)
2029 bfd_zalloc (abfd, elf_numsections (abfd) * sizeof (bfd_boolean));
2030 sections_being_created_abfd = abfd;
2032 if (sections_being_created [shindex])
2035 (_("%pB: warning: loop in section dependencies detected"), abfd);
2038 sections_being_created [shindex] = TRUE;
2041 hdr = elf_elfsections (abfd)[shindex];
2042 ehdr = elf_elfheader (abfd);
2043 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
2048 bed = get_elf_backend_data (abfd);
2049 switch (hdr->sh_type)
2052 /* Inactive section. Throw it away. */
2055 case SHT_PROGBITS: /* Normal section with contents. */
2056 case SHT_NOBITS: /* .bss section. */
2057 case SHT_HASH: /* .hash section. */
2058 case SHT_NOTE: /* .note section. */
2059 case SHT_INIT_ARRAY: /* .init_array section. */
2060 case SHT_FINI_ARRAY: /* .fini_array section. */
2061 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
2062 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
2063 case SHT_GNU_HASH: /* .gnu.hash section. */
2064 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2067 case SHT_DYNAMIC: /* Dynamic linking information. */
2068 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2071 if (hdr->sh_link > elf_numsections (abfd))
2073 /* PR 10478: Accept Solaris binaries with a sh_link
2074 field set to SHN_BEFORE or SHN_AFTER. */
2075 switch (bfd_get_arch (abfd))
2078 case bfd_arch_sparc:
2079 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
2080 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
2082 /* Otherwise fall through. */
2087 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
2089 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
2091 Elf_Internal_Shdr *dynsymhdr;
2093 /* The shared libraries distributed with hpux11 have a bogus
2094 sh_link field for the ".dynamic" section. Find the
2095 string table for the ".dynsym" section instead. */
2096 if (elf_dynsymtab (abfd) != 0)
2098 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
2099 hdr->sh_link = dynsymhdr->sh_link;
2103 unsigned int i, num_sec;
2105 num_sec = elf_numsections (abfd);
2106 for (i = 1; i < num_sec; i++)
2108 dynsymhdr = elf_elfsections (abfd)[i];
2109 if (dynsymhdr->sh_type == SHT_DYNSYM)
2111 hdr->sh_link = dynsymhdr->sh_link;
2119 case SHT_SYMTAB: /* A symbol table. */
2120 if (elf_onesymtab (abfd) == shindex)
2123 if (hdr->sh_entsize != bed->s->sizeof_sym)
2126 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2128 if (hdr->sh_size != 0)
2130 /* Some assemblers erroneously set sh_info to one with a
2131 zero sh_size. ld sees this as a global symbol count
2132 of (unsigned) -1. Fix it here. */
2137 /* PR 18854: A binary might contain more than one symbol table.
2138 Unusual, but possible. Warn, but continue. */
2139 if (elf_onesymtab (abfd) != 0)
2142 /* xgettext:c-format */
2143 (_("%pB: warning: multiple symbol tables detected"
2144 " - ignoring the table in section %u"),
2148 elf_onesymtab (abfd) = shindex;
2149 elf_symtab_hdr (abfd) = *hdr;
2150 elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
2151 abfd->flags |= HAS_SYMS;
2153 /* Sometimes a shared object will map in the symbol table. If
2154 SHF_ALLOC is set, and this is a shared object, then we also
2155 treat this section as a BFD section. We can not base the
2156 decision purely on SHF_ALLOC, because that flag is sometimes
2157 set in a relocatable object file, which would confuse the
2159 if ((hdr->sh_flags & SHF_ALLOC) != 0
2160 && (abfd->flags & DYNAMIC) != 0
2161 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2165 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2166 can't read symbols without that section loaded as well. It
2167 is most likely specified by the next section header. */
2169 elf_section_list * entry;
2170 unsigned int i, num_sec;
2172 for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2173 if (entry->hdr.sh_link == shindex)
2176 num_sec = elf_numsections (abfd);
2177 for (i = shindex + 1; i < num_sec; i++)
2179 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2181 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2182 && hdr2->sh_link == shindex)
2187 for (i = 1; i < shindex; i++)
2189 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2191 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2192 && hdr2->sh_link == shindex)
2197 ret = bfd_section_from_shdr (abfd, i);
2198 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2202 case SHT_DYNSYM: /* A dynamic symbol table. */
2203 if (elf_dynsymtab (abfd) == shindex)
2206 if (hdr->sh_entsize != bed->s->sizeof_sym)
2209 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2211 if (hdr->sh_size != 0)
2214 /* Some linkers erroneously set sh_info to one with a
2215 zero sh_size. ld sees this as a global symbol count
2216 of (unsigned) -1. Fix it here. */
2221 /* PR 18854: A binary might contain more than one dynamic symbol table.
2222 Unusual, but possible. Warn, but continue. */
2223 if (elf_dynsymtab (abfd) != 0)
2226 /* xgettext:c-format */
2227 (_("%pB: warning: multiple dynamic symbol tables detected"
2228 " - ignoring the table in section %u"),
2232 elf_dynsymtab (abfd) = shindex;
2233 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
2234 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2235 abfd->flags |= HAS_SYMS;
2237 /* Besides being a symbol table, we also treat this as a regular
2238 section, so that objcopy can handle it. */
2239 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2242 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections. */
2244 elf_section_list * entry;
2246 for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2247 if (entry->ndx == shindex)
2250 entry = bfd_alloc (abfd, sizeof * entry);
2253 entry->ndx = shindex;
2255 entry->next = elf_symtab_shndx_list (abfd);
2256 elf_symtab_shndx_list (abfd) = entry;
2257 elf_elfsections (abfd)[shindex] = & entry->hdr;
2261 case SHT_STRTAB: /* A string table. */
2262 if (hdr->bfd_section != NULL)
2265 if (ehdr->e_shstrndx == shindex)
2267 elf_tdata (abfd)->shstrtab_hdr = *hdr;
2268 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
2272 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
2275 elf_tdata (abfd)->strtab_hdr = *hdr;
2276 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
2280 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2283 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2284 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2285 elf_elfsections (abfd)[shindex] = hdr;
2286 /* We also treat this as a regular section, so that objcopy
2288 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2293 /* If the string table isn't one of the above, then treat it as a
2294 regular section. We need to scan all the headers to be sure,
2295 just in case this strtab section appeared before the above. */
2296 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2298 unsigned int i, num_sec;
2300 num_sec = elf_numsections (abfd);
2301 for (i = 1; i < num_sec; i++)
2303 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2304 if (hdr2->sh_link == shindex)
2306 /* Prevent endless recursion on broken objects. */
2309 if (! bfd_section_from_shdr (abfd, i))
2311 if (elf_onesymtab (abfd) == i)
2313 if (elf_dynsymtab (abfd) == i)
2314 goto dynsymtab_strtab;
2318 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2323 /* *These* do a lot of work -- but build no sections! */
2325 asection *target_sect;
2326 Elf_Internal_Shdr *hdr2, **p_hdr;
2327 unsigned int num_sec = elf_numsections (abfd);
2328 struct bfd_elf_section_data *esdt;
2331 != (bfd_size_type) (hdr->sh_type == SHT_REL
2332 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
2335 /* Check for a bogus link to avoid crashing. */
2336 if (hdr->sh_link >= num_sec)
2339 /* xgettext:c-format */
2340 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2341 abfd, hdr->sh_link, name, shindex);
2342 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2347 /* For some incomprehensible reason Oracle distributes
2348 libraries for Solaris in which some of the objects have
2349 bogus sh_link fields. It would be nice if we could just
2350 reject them, but, unfortunately, some people need to use
2351 them. We scan through the section headers; if we find only
2352 one suitable symbol table, we clobber the sh_link to point
2353 to it. I hope this doesn't break anything.
2355 Don't do it on executable nor shared library. */
2356 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
2357 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2358 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2364 for (scan = 1; scan < num_sec; scan++)
2366 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2367 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2378 hdr->sh_link = found;
2381 /* Get the symbol table. */
2382 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2383 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2384 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2387 /* If this is an alloc section in an executable or shared
2388 library, or the reloc section does not use the main symbol
2389 table we don't treat it as a reloc section. BFD can't
2390 adequately represent such a section, so at least for now,
2391 we don't try. We just present it as a normal section. We
2392 also can't use it as a reloc section if it points to the
2393 null section, an invalid section, another reloc section, or
2394 its sh_link points to the null section. */
2395 if (((abfd->flags & (DYNAMIC | EXEC_P)) != 0
2396 && (hdr->sh_flags & SHF_ALLOC) != 0)
2397 || hdr->sh_link == SHN_UNDEF
2398 || hdr->sh_link != elf_onesymtab (abfd)
2399 || hdr->sh_info == SHN_UNDEF
2400 || hdr->sh_info >= num_sec
2401 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2402 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2404 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2409 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2412 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2413 if (target_sect == NULL)
2416 esdt = elf_section_data (target_sect);
2417 if (hdr->sh_type == SHT_RELA)
2418 p_hdr = &esdt->rela.hdr;
2420 p_hdr = &esdt->rel.hdr;
2422 /* PR 17512: file: 0b4f81b7. */
2425 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
2430 elf_elfsections (abfd)[shindex] = hdr2;
2431 target_sect->reloc_count += (NUM_SHDR_ENTRIES (hdr)
2432 * bed->s->int_rels_per_ext_rel);
2433 target_sect->flags |= SEC_RELOC;
2434 target_sect->relocation = NULL;
2435 target_sect->rel_filepos = hdr->sh_offset;
2436 /* In the section to which the relocations apply, mark whether
2437 its relocations are of the REL or RELA variety. */
2438 if (hdr->sh_size != 0)
2440 if (hdr->sh_type == SHT_RELA)
2441 target_sect->use_rela_p = 1;
2443 abfd->flags |= HAS_RELOC;
2447 case SHT_GNU_verdef:
2448 elf_dynverdef (abfd) = shindex;
2449 elf_tdata (abfd)->dynverdef_hdr = *hdr;
2450 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2453 case SHT_GNU_versym:
2454 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2457 elf_dynversym (abfd) = shindex;
2458 elf_tdata (abfd)->dynversym_hdr = *hdr;
2459 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2462 case SHT_GNU_verneed:
2463 elf_dynverref (abfd) = shindex;
2464 elf_tdata (abfd)->dynverref_hdr = *hdr;
2465 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2472 if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
2475 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2481 /* Possibly an attributes section. */
2482 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2483 || hdr->sh_type == bed->obj_attrs_section_type)
2485 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2487 _bfd_elf_parse_attributes (abfd, hdr);
2491 /* Check for any processor-specific section types. */
2492 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2495 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2497 if ((hdr->sh_flags & SHF_ALLOC) != 0)
2498 /* FIXME: How to properly handle allocated section reserved
2499 for applications? */
2501 /* xgettext:c-format */
2502 (_("%pB: unknown type [%#x] section `%s'"),
2503 abfd, hdr->sh_type, name);
2506 /* Allow sections reserved for applications. */
2507 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2512 else if (hdr->sh_type >= SHT_LOPROC
2513 && hdr->sh_type <= SHT_HIPROC)
2514 /* FIXME: We should handle this section. */
2516 /* xgettext:c-format */
2517 (_("%pB: unknown type [%#x] section `%s'"),
2518 abfd, hdr->sh_type, name);
2519 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2521 /* Unrecognised OS-specific sections. */
2522 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2523 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2524 required to correctly process the section and the file should
2525 be rejected with an error message. */
2527 /* xgettext:c-format */
2528 (_("%pB: unknown type [%#x] section `%s'"),
2529 abfd, hdr->sh_type, name);
2532 /* Otherwise it should be processed. */
2533 ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2538 /* FIXME: We should handle this section. */
2540 /* xgettext:c-format */
2541 (_("%pB: unknown type [%#x] section `%s'"),
2542 abfd, hdr->sh_type, name);
2550 if (sections_being_created && sections_being_created_abfd == abfd)
2551 sections_being_created [shindex] = FALSE;
2552 if (-- nesting == 0)
2554 sections_being_created = NULL;
2555 sections_being_created_abfd = abfd;
2560 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2563 bfd_sym_from_r_symndx (struct sym_cache *cache,
2565 unsigned long r_symndx)
2567 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2569 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2571 Elf_Internal_Shdr *symtab_hdr;
2572 unsigned char esym[sizeof (Elf64_External_Sym)];
2573 Elf_External_Sym_Shndx eshndx;
2575 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2576 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2577 &cache->sym[ent], esym, &eshndx) == NULL)
2580 if (cache->abfd != abfd)
2582 memset (cache->indx, -1, sizeof (cache->indx));
2585 cache->indx[ent] = r_symndx;
2588 return &cache->sym[ent];
2591 /* Given an ELF section number, retrieve the corresponding BFD
2595 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2597 if (sec_index >= elf_numsections (abfd))
2599 return elf_elfsections (abfd)[sec_index]->bfd_section;
2602 static const struct bfd_elf_special_section special_sections_b[] =
2604 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2605 { NULL, 0, 0, 0, 0 }
2608 static const struct bfd_elf_special_section special_sections_c[] =
2610 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2611 { NULL, 0, 0, 0, 0 }
2614 static const struct bfd_elf_special_section special_sections_d[] =
2616 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2617 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2618 /* There are more DWARF sections than these, but they needn't be added here
2619 unless you have to cope with broken compilers that don't emit section
2620 attributes or you want to help the user writing assembler. */
2621 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2622 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2623 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2624 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2625 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2626 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2627 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2628 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2629 { NULL, 0, 0, 0, 0 }
2632 static const struct bfd_elf_special_section special_sections_f[] =
2634 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2635 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2636 { NULL, 0 , 0, 0, 0 }
2639 static const struct bfd_elf_special_section special_sections_g[] =
2641 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2642 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE },
2643 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2644 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2645 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2646 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2647 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2648 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2649 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2650 { NULL, 0, 0, 0, 0 }
2653 static const struct bfd_elf_special_section special_sections_h[] =
2655 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2656 { NULL, 0, 0, 0, 0 }
2659 static const struct bfd_elf_special_section special_sections_i[] =
2661 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2662 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2663 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2664 { NULL, 0, 0, 0, 0 }
2667 static const struct bfd_elf_special_section special_sections_l[] =
2669 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2670 { NULL, 0, 0, 0, 0 }
2673 static const struct bfd_elf_special_section special_sections_n[] =
2675 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2676 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2677 { NULL, 0, 0, 0, 0 }
2680 static const struct bfd_elf_special_section special_sections_p[] =
2682 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2683 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2684 { NULL, 0, 0, 0, 0 }
2687 static const struct bfd_elf_special_section special_sections_r[] =
2689 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2690 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2691 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2692 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2693 { NULL, 0, 0, 0, 0 }
2696 static const struct bfd_elf_special_section special_sections_s[] =
2698 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2699 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2700 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2701 /* See struct bfd_elf_special_section declaration for the semantics of
2702 this special case where .prefix_length != strlen (.prefix). */
2703 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2704 { NULL, 0, 0, 0, 0 }
2707 static const struct bfd_elf_special_section special_sections_t[] =
2709 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2710 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2711 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2712 { NULL, 0, 0, 0, 0 }
2715 static const struct bfd_elf_special_section special_sections_z[] =
2717 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2718 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2719 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2720 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2721 { NULL, 0, 0, 0, 0 }
2724 static const struct bfd_elf_special_section * const special_sections[] =
2726 special_sections_b, /* 'b' */
2727 special_sections_c, /* 'c' */
2728 special_sections_d, /* 'd' */
2730 special_sections_f, /* 'f' */
2731 special_sections_g, /* 'g' */
2732 special_sections_h, /* 'h' */
2733 special_sections_i, /* 'i' */
2736 special_sections_l, /* 'l' */
2738 special_sections_n, /* 'n' */
2740 special_sections_p, /* 'p' */
2742 special_sections_r, /* 'r' */
2743 special_sections_s, /* 's' */
2744 special_sections_t, /* 't' */
2750 special_sections_z /* 'z' */
2753 const struct bfd_elf_special_section *
2754 _bfd_elf_get_special_section (const char *name,
2755 const struct bfd_elf_special_section *spec,
2761 len = strlen (name);
2763 for (i = 0; spec[i].prefix != NULL; i++)
2766 int prefix_len = spec[i].prefix_length;
2768 if (len < prefix_len)
2770 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2773 suffix_len = spec[i].suffix_length;
2774 if (suffix_len <= 0)
2776 if (name[prefix_len] != 0)
2778 if (suffix_len == 0)
2780 if (name[prefix_len] != '.'
2781 && (suffix_len == -2
2782 || (rela && spec[i].type == SHT_REL)))
2788 if (len < prefix_len + suffix_len)
2790 if (memcmp (name + len - suffix_len,
2791 spec[i].prefix + prefix_len,
2801 const struct bfd_elf_special_section *
2802 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2805 const struct bfd_elf_special_section *spec;
2806 const struct elf_backend_data *bed;
2808 /* See if this is one of the special sections. */
2809 if (sec->name == NULL)
2812 bed = get_elf_backend_data (abfd);
2813 spec = bed->special_sections;
2816 spec = _bfd_elf_get_special_section (sec->name,
2817 bed->special_sections,
2823 if (sec->name[0] != '.')
2826 i = sec->name[1] - 'b';
2827 if (i < 0 || i > 'z' - 'b')
2830 spec = special_sections[i];
2835 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2839 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2841 struct bfd_elf_section_data *sdata;
2842 const struct elf_backend_data *bed;
2843 const struct bfd_elf_special_section *ssect;
2845 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2848 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2852 sec->used_by_bfd = sdata;
2855 /* Indicate whether or not this section should use RELA relocations. */
2856 bed = get_elf_backend_data (abfd);
2857 sec->use_rela_p = bed->default_use_rela_p;
2859 /* When we read a file, we don't need to set ELF section type and
2860 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2861 anyway. We will set ELF section type and flags for all linker
2862 created sections. If user specifies BFD section flags, we will
2863 set ELF section type and flags based on BFD section flags in
2864 elf_fake_sections. Special handling for .init_array/.fini_array
2865 output sections since they may contain .ctors/.dtors input
2866 sections. We don't want _bfd_elf_init_private_section_data to
2867 copy ELF section type from .ctors/.dtors input sections. */
2868 if (abfd->direction != read_direction
2869 || (sec->flags & SEC_LINKER_CREATED) != 0)
2871 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2874 || (sec->flags & SEC_LINKER_CREATED) != 0
2875 || ssect->type == SHT_INIT_ARRAY
2876 || ssect->type == SHT_FINI_ARRAY))
2878 elf_section_type (sec) = ssect->type;
2879 elf_section_flags (sec) = ssect->attr;
2883 return _bfd_generic_new_section_hook (abfd, sec);
2886 /* Create a new bfd section from an ELF program header.
2888 Since program segments have no names, we generate a synthetic name
2889 of the form segment<NUM>, where NUM is generally the index in the
2890 program header table. For segments that are split (see below) we
2891 generate the names segment<NUM>a and segment<NUM>b.
2893 Note that some program segments may have a file size that is different than
2894 (less than) the memory size. All this means is that at execution the
2895 system must allocate the amount of memory specified by the memory size,
2896 but only initialize it with the first "file size" bytes read from the
2897 file. This would occur for example, with program segments consisting
2898 of combined data+bss.
2900 To handle the above situation, this routine generates TWO bfd sections
2901 for the single program segment. The first has the length specified by
2902 the file size of the segment, and the second has the length specified
2903 by the difference between the two sizes. In effect, the segment is split
2904 into its initialized and uninitialized parts.
2909 _bfd_elf_make_section_from_phdr (bfd *abfd,
2910 Elf_Internal_Phdr *hdr,
2912 const char *type_name)
2920 split = ((hdr->p_memsz > 0)
2921 && (hdr->p_filesz > 0)
2922 && (hdr->p_memsz > hdr->p_filesz));
2924 if (hdr->p_filesz > 0)
2926 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2927 len = strlen (namebuf) + 1;
2928 name = (char *) bfd_alloc (abfd, len);
2931 memcpy (name, namebuf, len);
2932 newsect = bfd_make_section (abfd, name);
2933 if (newsect == NULL)
2935 newsect->vma = hdr->p_vaddr;
2936 newsect->lma = hdr->p_paddr;
2937 newsect->size = hdr->p_filesz;
2938 newsect->filepos = hdr->p_offset;
2939 newsect->flags |= SEC_HAS_CONTENTS;
2940 newsect->alignment_power = bfd_log2 (hdr->p_align);
2941 if (hdr->p_type == PT_LOAD)
2943 newsect->flags |= SEC_ALLOC;
2944 newsect->flags |= SEC_LOAD;
2945 if (hdr->p_flags & PF_X)
2947 /* FIXME: all we known is that it has execute PERMISSION,
2949 newsect->flags |= SEC_CODE;
2952 if (!(hdr->p_flags & PF_W))
2954 newsect->flags |= SEC_READONLY;
2958 if (hdr->p_memsz > hdr->p_filesz)
2962 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2963 len = strlen (namebuf) + 1;
2964 name = (char *) bfd_alloc (abfd, len);
2967 memcpy (name, namebuf, len);
2968 newsect = bfd_make_section (abfd, name);
2969 if (newsect == NULL)
2971 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2972 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2973 newsect->size = hdr->p_memsz - hdr->p_filesz;
2974 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2975 align = newsect->vma & -newsect->vma;
2976 if (align == 0 || align > hdr->p_align)
2977 align = hdr->p_align;
2978 newsect->alignment_power = bfd_log2 (align);
2979 if (hdr->p_type == PT_LOAD)
2981 /* Hack for gdb. Segments that have not been modified do
2982 not have their contents written to a core file, on the
2983 assumption that a debugger can find the contents in the
2984 executable. We flag this case by setting the fake
2985 section size to zero. Note that "real" bss sections will
2986 always have their contents dumped to the core file. */
2987 if (bfd_get_format (abfd) == bfd_core)
2989 newsect->flags |= SEC_ALLOC;
2990 if (hdr->p_flags & PF_X)
2991 newsect->flags |= SEC_CODE;
2993 if (!(hdr->p_flags & PF_W))
2994 newsect->flags |= SEC_READONLY;
3001 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
3003 const struct elf_backend_data *bed;
3005 switch (hdr->p_type)
3008 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
3011 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
3014 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
3017 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
3020 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
3022 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz,
3028 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
3031 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
3033 case PT_GNU_EH_FRAME:
3034 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
3038 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
3041 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
3044 /* Check for any processor-specific program segment types. */
3045 bed = get_elf_backend_data (abfd);
3046 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
3050 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3054 _bfd_elf_single_rel_hdr (asection *sec)
3056 if (elf_section_data (sec)->rel.hdr)
3058 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
3059 return elf_section_data (sec)->rel.hdr;
3062 return elf_section_data (sec)->rela.hdr;
3066 _bfd_elf_set_reloc_sh_name (bfd *abfd,
3067 Elf_Internal_Shdr *rel_hdr,
3068 const char *sec_name,
3069 bfd_boolean use_rela_p)
3071 char *name = (char *) bfd_alloc (abfd,
3072 sizeof ".rela" + strlen (sec_name));
3076 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
3078 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
3080 if (rel_hdr->sh_name == (unsigned int) -1)
3086 /* Allocate and initialize a section-header for a new reloc section,
3087 containing relocations against ASECT. It is stored in RELDATA. If
3088 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3092 _bfd_elf_init_reloc_shdr (bfd *abfd,
3093 struct bfd_elf_section_reloc_data *reldata,
3094 const char *sec_name,
3095 bfd_boolean use_rela_p,
3096 bfd_boolean delay_st_name_p)
3098 Elf_Internal_Shdr *rel_hdr;
3099 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3101 BFD_ASSERT (reldata->hdr == NULL);
3102 rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
3103 reldata->hdr = rel_hdr;
3105 if (delay_st_name_p)
3106 rel_hdr->sh_name = (unsigned int) -1;
3107 else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
3110 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
3111 rel_hdr->sh_entsize = (use_rela_p
3112 ? bed->s->sizeof_rela
3113 : bed->s->sizeof_rel);
3114 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
3115 rel_hdr->sh_flags = 0;
3116 rel_hdr->sh_addr = 0;
3117 rel_hdr->sh_size = 0;
3118 rel_hdr->sh_offset = 0;
3123 /* Return the default section type based on the passed in section flags. */
3126 bfd_elf_get_default_section_type (flagword flags)
3128 if ((flags & SEC_ALLOC) != 0
3129 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3131 return SHT_PROGBITS;
3134 struct fake_section_arg
3136 struct bfd_link_info *link_info;
3140 /* Set up an ELF internal section header for a section. */
3143 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
3145 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
3146 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3147 struct bfd_elf_section_data *esd = elf_section_data (asect);
3148 Elf_Internal_Shdr *this_hdr;
3149 unsigned int sh_type;
3150 const char *name = asect->name;
3151 bfd_boolean delay_st_name_p = FALSE;
3155 /* We already failed; just get out of the bfd_map_over_sections
3160 this_hdr = &esd->this_hdr;
3164 /* ld: compress DWARF debug sections with names: .debug_*. */
3165 if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
3166 && (asect->flags & SEC_DEBUGGING)
3170 /* Set SEC_ELF_COMPRESS to indicate this section should be
3172 asect->flags |= SEC_ELF_COMPRESS;
3174 /* If this section will be compressed, delay adding section
3175 name to section name section after it is compressed in
3176 _bfd_elf_assign_file_positions_for_non_load. */
3177 delay_st_name_p = TRUE;
3180 else if ((asect->flags & SEC_ELF_RENAME))
3182 /* objcopy: rename output DWARF debug section. */
3183 if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
3185 /* When we decompress or compress with SHF_COMPRESSED,
3186 convert section name from .zdebug_* to .debug_* if
3190 char *new_name = convert_zdebug_to_debug (abfd, name);
3191 if (new_name == NULL)
3199 else if (asect->compress_status == COMPRESS_SECTION_DONE)
3201 /* PR binutils/18087: Compression does not always make a
3202 section smaller. So only rename the section when
3203 compression has actually taken place. If input section
3204 name is .zdebug_*, we should never compress it again. */
3205 char *new_name = convert_debug_to_zdebug (abfd, name);
3206 if (new_name == NULL)
3211 BFD_ASSERT (name[1] != 'z');
3216 if (delay_st_name_p)
3217 this_hdr->sh_name = (unsigned int) -1;
3221 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3223 if (this_hdr->sh_name == (unsigned int) -1)
3230 /* Don't clear sh_flags. Assembler may set additional bits. */
3232 if ((asect->flags & SEC_ALLOC) != 0
3233 || asect->user_set_vma)
3234 this_hdr->sh_addr = asect->vma;
3236 this_hdr->sh_addr = 0;
3238 this_hdr->sh_offset = 0;
3239 this_hdr->sh_size = asect->size;
3240 this_hdr->sh_link = 0;
3241 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3242 if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
3245 /* xgettext:c-format */
3246 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3247 abfd, asect->alignment_power, asect);
3251 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
3252 /* The sh_entsize and sh_info fields may have been set already by
3253 copy_private_section_data. */
3255 this_hdr->bfd_section = asect;
3256 this_hdr->contents = NULL;
3258 /* If the section type is unspecified, we set it based on
3260 if ((asect->flags & SEC_GROUP) != 0)
3261 sh_type = SHT_GROUP;
3263 sh_type = bfd_elf_get_default_section_type (asect->flags);
3265 if (this_hdr->sh_type == SHT_NULL)
3266 this_hdr->sh_type = sh_type;
3267 else if (this_hdr->sh_type == SHT_NOBITS
3268 && sh_type == SHT_PROGBITS
3269 && (asect->flags & SEC_ALLOC) != 0)
3271 /* Warn if we are changing a NOBITS section to PROGBITS, but
3272 allow the link to proceed. This can happen when users link
3273 non-bss input sections to bss output sections, or emit data
3274 to a bss output section via a linker script. */
3276 (_("warning: section `%pA' type changed to PROGBITS"), asect);
3277 this_hdr->sh_type = sh_type;
3280 switch (this_hdr->sh_type)
3291 case SHT_INIT_ARRAY:
3292 case SHT_FINI_ARRAY:
3293 case SHT_PREINIT_ARRAY:
3294 this_hdr->sh_entsize = bed->s->arch_size / 8;
3298 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
3302 this_hdr->sh_entsize = bed->s->sizeof_sym;
3306 this_hdr->sh_entsize = bed->s->sizeof_dyn;
3310 if (get_elf_backend_data (abfd)->may_use_rela_p)
3311 this_hdr->sh_entsize = bed->s->sizeof_rela;
3315 if (get_elf_backend_data (abfd)->may_use_rel_p)
3316 this_hdr->sh_entsize = bed->s->sizeof_rel;
3319 case SHT_GNU_versym:
3320 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
3323 case SHT_GNU_verdef:
3324 this_hdr->sh_entsize = 0;
3325 /* objcopy or strip will copy over sh_info, but may not set
3326 cverdefs. The linker will set cverdefs, but sh_info will be
3328 if (this_hdr->sh_info == 0)
3329 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
3331 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
3332 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
3335 case SHT_GNU_verneed:
3336 this_hdr->sh_entsize = 0;
3337 /* objcopy or strip will copy over sh_info, but may not set
3338 cverrefs. The linker will set cverrefs, but sh_info will be
3340 if (this_hdr->sh_info == 0)
3341 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
3343 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
3344 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
3348 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
3352 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
3356 if ((asect->flags & SEC_ALLOC) != 0)
3357 this_hdr->sh_flags |= SHF_ALLOC;
3358 if ((asect->flags & SEC_READONLY) == 0)
3359 this_hdr->sh_flags |= SHF_WRITE;
3360 if ((asect->flags & SEC_CODE) != 0)
3361 this_hdr->sh_flags |= SHF_EXECINSTR;
3362 if ((asect->flags & SEC_MERGE) != 0)
3364 this_hdr->sh_flags |= SHF_MERGE;
3365 this_hdr->sh_entsize = asect->entsize;
3367 if ((asect->flags & SEC_STRINGS) != 0)
3368 this_hdr->sh_flags |= SHF_STRINGS;
3369 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
3370 this_hdr->sh_flags |= SHF_GROUP;
3371 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
3373 this_hdr->sh_flags |= SHF_TLS;
3374 if (asect->size == 0
3375 && (asect->flags & SEC_HAS_CONTENTS) == 0)
3377 struct bfd_link_order *o = asect->map_tail.link_order;
3379 this_hdr->sh_size = 0;
3382 this_hdr->sh_size = o->offset + o->size;
3383 if (this_hdr->sh_size != 0)
3384 this_hdr->sh_type = SHT_NOBITS;
3388 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
3389 this_hdr->sh_flags |= SHF_EXCLUDE;
3391 /* If the section has relocs, set up a section header for the
3392 SHT_REL[A] section. If two relocation sections are required for
3393 this section, it is up to the processor-specific back-end to
3394 create the other. */
3395 if ((asect->flags & SEC_RELOC) != 0)
3397 /* When doing a relocatable link, create both REL and RELA sections if
3400 /* Do the normal setup if we wouldn't create any sections here. */
3401 && esd->rel.count + esd->rela.count > 0
3402 && (bfd_link_relocatable (arg->link_info)
3403 || arg->link_info->emitrelocations))
3405 if (esd->rel.count && esd->rel.hdr == NULL
3406 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name,
3407 FALSE, delay_st_name_p))
3412 if (esd->rela.count && esd->rela.hdr == NULL
3413 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name,
3414 TRUE, delay_st_name_p))
3420 else if (!_bfd_elf_init_reloc_shdr (abfd,
3422 ? &esd->rela : &esd->rel),
3432 /* Check for processor-specific section types. */
3433 sh_type = this_hdr->sh_type;
3434 if (bed->elf_backend_fake_sections
3435 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
3441 if (sh_type == SHT_NOBITS && asect->size != 0)
3443 /* Don't change the header type from NOBITS if we are being
3444 called for objcopy --only-keep-debug. */
3445 this_hdr->sh_type = sh_type;
3449 /* Fill in the contents of a SHT_GROUP section. Called from
3450 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3451 when ELF targets use the generic linker, ld. Called for ld -r
3452 from bfd_elf_final_link. */
3455 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
3457 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
3458 asection *elt, *first;
3462 /* Ignore linker created group section. See elfNN_ia64_object_p in
3464 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
3468 if (elf_section_data (sec)->this_hdr.sh_info == 0)
3470 unsigned long symindx = 0;
3472 /* elf_group_id will have been set up by objcopy and the
3474 if (elf_group_id (sec) != NULL)
3475 symindx = elf_group_id (sec)->udata.i;
3479 /* If called from the assembler, swap_out_syms will have set up
3480 elf_section_syms. */
3481 BFD_ASSERT (elf_section_syms (abfd) != NULL);
3482 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
3484 elf_section_data (sec)->this_hdr.sh_info = symindx;
3486 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
3488 /* The ELF backend linker sets sh_info to -2 when the group
3489 signature symbol is global, and thus the index can't be
3490 set until all local symbols are output. */
3492 struct bfd_elf_section_data *sec_data;
3493 unsigned long symndx;
3494 unsigned long extsymoff;
3495 struct elf_link_hash_entry *h;
3497 /* The point of this little dance to the first SHF_GROUP section
3498 then back to the SHT_GROUP section is that this gets us to
3499 the SHT_GROUP in the input object. */
3500 igroup = elf_sec_group (elf_next_in_group (sec));
3501 sec_data = elf_section_data (igroup);
3502 symndx = sec_data->this_hdr.sh_info;
3504 if (!elf_bad_symtab (igroup->owner))
3506 Elf_Internal_Shdr *symtab_hdr;
3508 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
3509 extsymoff = symtab_hdr->sh_info;
3511 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
3512 while (h->root.type == bfd_link_hash_indirect
3513 || h->root.type == bfd_link_hash_warning)
3514 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3516 elf_section_data (sec)->this_hdr.sh_info = h->indx;
3519 /* The contents won't be allocated for "ld -r" or objcopy. */
3521 if (sec->contents == NULL)
3524 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
3526 /* Arrange for the section to be written out. */
3527 elf_section_data (sec)->this_hdr.contents = sec->contents;
3528 if (sec->contents == NULL)
3535 loc = sec->contents + sec->size;
3537 /* Get the pointer to the first section in the group that gas
3538 squirreled away here. objcopy arranges for this to be set to the
3539 start of the input section group. */
3540 first = elt = elf_next_in_group (sec);
3542 /* First element is a flag word. Rest of section is elf section
3543 indices for all the sections of the group. Write them backwards
3544 just to keep the group in the same order as given in .section
3545 directives, not that it matters. */
3552 s = s->output_section;
3554 && !bfd_is_abs_section (s))
3556 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
3557 struct bfd_elf_section_data *input_elf_sec = elf_section_data (elt);
3559 if (elf_sec->rel.hdr != NULL
3561 || (input_elf_sec->rel.hdr != NULL
3562 && input_elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0))
3564 elf_sec->rel.hdr->sh_flags |= SHF_GROUP;
3566 H_PUT_32 (abfd, elf_sec->rel.idx, loc);
3568 if (elf_sec->rela.hdr != NULL
3570 || (input_elf_sec->rela.hdr != NULL
3571 && input_elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0))
3573 elf_sec->rela.hdr->sh_flags |= SHF_GROUP;
3575 H_PUT_32 (abfd, elf_sec->rela.idx, loc);
3578 H_PUT_32 (abfd, elf_sec->this_idx, loc);
3580 elt = elf_next_in_group (elt);
3586 BFD_ASSERT (loc == sec->contents);
3588 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
3591 /* Given NAME, the name of a relocation section stripped of its
3592 .rel/.rela prefix, return the section in ABFD to which the
3593 relocations apply. */
3596 _bfd_elf_plt_get_reloc_section (bfd *abfd, const char *name)
3598 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3599 section likely apply to .got.plt or .got section. */
3600 if (get_elf_backend_data (abfd)->want_got_plt
3601 && strcmp (name, ".plt") == 0)
3606 sec = bfd_get_section_by_name (abfd, name);
3612 return bfd_get_section_by_name (abfd, name);
3615 /* Return the section to which RELOC_SEC applies. */
3618 elf_get_reloc_section (asection *reloc_sec)
3623 const struct elf_backend_data *bed;
3625 type = elf_section_data (reloc_sec)->this_hdr.sh_type;
3626 if (type != SHT_REL && type != SHT_RELA)
3629 /* We look up the section the relocs apply to by name. */
3630 name = reloc_sec->name;
3631 if (strncmp (name, ".rel", 4) != 0)
3634 if (type == SHT_RELA && *name++ != 'a')
3637 abfd = reloc_sec->owner;
3638 bed = get_elf_backend_data (abfd);
3639 return bed->get_reloc_section (abfd, name);
3642 /* Assign all ELF section numbers. The dummy first section is handled here
3643 too. The link/info pointers for the standard section types are filled
3644 in here too, while we're at it. */
3647 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
3649 struct elf_obj_tdata *t = elf_tdata (abfd);
3651 unsigned int section_number;
3652 Elf_Internal_Shdr **i_shdrp;
3653 struct bfd_elf_section_data *d;
3654 bfd_boolean need_symtab;
3658 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
3660 /* SHT_GROUP sections are in relocatable files only. */
3661 if (link_info == NULL || !link_info->resolve_section_groups)
3663 size_t reloc_count = 0;
3665 /* Put SHT_GROUP sections first. */
3666 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3668 d = elf_section_data (sec);
3670 if (d->this_hdr.sh_type == SHT_GROUP)
3672 if (sec->flags & SEC_LINKER_CREATED)
3674 /* Remove the linker created SHT_GROUP sections. */
3675 bfd_section_list_remove (abfd, sec);
3676 abfd->section_count--;
3679 d->this_idx = section_number++;
3682 /* Count relocations. */
3683 reloc_count += sec->reloc_count;
3686 /* Clear HAS_RELOC if there are no relocations. */
3687 if (reloc_count == 0)
3688 abfd->flags &= ~HAS_RELOC;
3691 for (sec = abfd->sections; sec; sec = sec->next)
3693 d = elf_section_data (sec);
3695 if (d->this_hdr.sh_type != SHT_GROUP)
3696 d->this_idx = section_number++;
3697 if (d->this_hdr.sh_name != (unsigned int) -1)
3698 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
3701 d->rel.idx = section_number++;
3702 if (d->rel.hdr->sh_name != (unsigned int) -1)
3703 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
3710 d->rela.idx = section_number++;
3711 if (d->rela.hdr->sh_name != (unsigned int) -1)
3712 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
3718 need_symtab = (bfd_get_symcount (abfd) > 0
3719 || (link_info == NULL
3720 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3724 elf_onesymtab (abfd) = section_number++;
3725 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
3726 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
3728 elf_section_list * entry;
3730 BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL);
3732 entry = bfd_zalloc (abfd, sizeof * entry);
3733 entry->ndx = section_number++;
3734 elf_symtab_shndx_list (abfd) = entry;
3736 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3737 ".symtab_shndx", FALSE);
3738 if (entry->hdr.sh_name == (unsigned int) -1)
3741 elf_strtab_sec (abfd) = section_number++;
3742 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3745 elf_shstrtab_sec (abfd) = section_number++;
3746 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3747 elf_elfheader (abfd)->e_shstrndx = elf_shstrtab_sec (abfd);
3749 if (section_number >= SHN_LORESERVE)
3751 /* xgettext:c-format */
3752 _bfd_error_handler (_("%pB: too many sections: %u"),
3753 abfd, section_number);
3757 elf_numsections (abfd) = section_number;
3758 elf_elfheader (abfd)->e_shnum = section_number;
3760 /* Set up the list of section header pointers, in agreement with the
3762 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3763 sizeof (Elf_Internal_Shdr *));
3764 if (i_shdrp == NULL)
3767 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3768 sizeof (Elf_Internal_Shdr));
3769 if (i_shdrp[0] == NULL)
3771 bfd_release (abfd, i_shdrp);
3775 elf_elfsections (abfd) = i_shdrp;
3777 i_shdrp[elf_shstrtab_sec (abfd)] = &t->shstrtab_hdr;
3780 i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr;
3781 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3783 elf_section_list * entry = elf_symtab_shndx_list (abfd);
3784 BFD_ASSERT (entry != NULL);
3785 i_shdrp[entry->ndx] = & entry->hdr;
3786 entry->hdr.sh_link = elf_onesymtab (abfd);
3788 i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
3789 t->symtab_hdr.sh_link = elf_strtab_sec (abfd);
3792 for (sec = abfd->sections; sec; sec = sec->next)
3796 d = elf_section_data (sec);
3798 i_shdrp[d->this_idx] = &d->this_hdr;
3799 if (d->rel.idx != 0)
3800 i_shdrp[d->rel.idx] = d->rel.hdr;
3801 if (d->rela.idx != 0)
3802 i_shdrp[d->rela.idx] = d->rela.hdr;
3804 /* Fill in the sh_link and sh_info fields while we're at it. */
3806 /* sh_link of a reloc section is the section index of the symbol
3807 table. sh_info is the section index of the section to which
3808 the relocation entries apply. */
3809 if (d->rel.idx != 0)
3811 d->rel.hdr->sh_link = elf_onesymtab (abfd);
3812 d->rel.hdr->sh_info = d->this_idx;
3813 d->rel.hdr->sh_flags |= SHF_INFO_LINK;
3815 if (d->rela.idx != 0)
3817 d->rela.hdr->sh_link = elf_onesymtab (abfd);
3818 d->rela.hdr->sh_info = d->this_idx;
3819 d->rela.hdr->sh_flags |= SHF_INFO_LINK;
3822 /* We need to set up sh_link for SHF_LINK_ORDER. */
3823 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3825 s = elf_linked_to_section (sec);
3828 /* elf_linked_to_section points to the input section. */
3829 if (link_info != NULL)
3831 /* Check discarded linkonce section. */
3832 if (discarded_section (s))
3836 /* xgettext:c-format */
3837 (_("%pB: sh_link of section `%pA' points to"
3838 " discarded section `%pA' of `%pB'"),
3839 abfd, d->this_hdr.bfd_section,
3841 /* Point to the kept section if it has the same
3842 size as the discarded one. */
3843 kept = _bfd_elf_check_kept_section (s, link_info);
3846 bfd_set_error (bfd_error_bad_value);
3852 s = s->output_section;
3853 BFD_ASSERT (s != NULL);
3857 /* Handle objcopy. */
3858 if (s->output_section == NULL)
3861 /* xgettext:c-format */
3862 (_("%pB: sh_link of section `%pA' points to"
3863 " removed section `%pA' of `%pB'"),
3864 abfd, d->this_hdr.bfd_section, s, s->owner);
3865 bfd_set_error (bfd_error_bad_value);
3868 s = s->output_section;
3870 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3875 The Intel C compiler generates SHT_IA_64_UNWIND with
3876 SHF_LINK_ORDER. But it doesn't set the sh_link or
3877 sh_info fields. Hence we could get the situation
3879 const struct elf_backend_data *bed
3880 = get_elf_backend_data (abfd);
3881 if (bed->link_order_error_handler)
3882 bed->link_order_error_handler
3883 /* xgettext:c-format */
3884 (_("%pB: warning: sh_link not set for section `%pA'"),
3889 switch (d->this_hdr.sh_type)
3893 /* A reloc section which we are treating as a normal BFD
3894 section. sh_link is the section index of the symbol
3895 table. sh_info is the section index of the section to
3896 which the relocation entries apply. We assume that an
3897 allocated reloc section uses the dynamic symbol table.
3898 FIXME: How can we be sure? */
3899 s = bfd_get_section_by_name (abfd, ".dynsym");
3901 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3903 s = elf_get_reloc_section (sec);
3906 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3907 d->this_hdr.sh_flags |= SHF_INFO_LINK;
3912 /* We assume that a section named .stab*str is a stabs
3913 string section. We look for a section with the same name
3914 but without the trailing ``str'', and set its sh_link
3915 field to point to this section. */
3916 if (CONST_STRNEQ (sec->name, ".stab")
3917 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3922 len = strlen (sec->name);
3923 alc = (char *) bfd_malloc (len - 2);
3926 memcpy (alc, sec->name, len - 3);
3927 alc[len - 3] = '\0';
3928 s = bfd_get_section_by_name (abfd, alc);
3932 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3934 /* This is a .stab section. */
3935 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3936 elf_section_data (s)->this_hdr.sh_entsize
3937 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3944 case SHT_GNU_verneed:
3945 case SHT_GNU_verdef:
3946 /* sh_link is the section header index of the string table
3947 used for the dynamic entries, or the symbol table, or the
3949 s = bfd_get_section_by_name (abfd, ".dynstr");
3951 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3954 case SHT_GNU_LIBLIST:
3955 /* sh_link is the section header index of the prelink library
3956 list used for the dynamic entries, or the symbol table, or
3957 the version strings. */
3958 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3959 ? ".dynstr" : ".gnu.libstr");
3961 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3966 case SHT_GNU_versym:
3967 /* sh_link is the section header index of the symbol table
3968 this hash table or version table is for. */
3969 s = bfd_get_section_by_name (abfd, ".dynsym");
3971 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3975 d->this_hdr.sh_link = elf_onesymtab (abfd);
3979 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3980 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3981 debug section name from .debug_* to .zdebug_* if needed. */
3987 sym_is_global (bfd *abfd, asymbol *sym)
3989 /* If the backend has a special mapping, use it. */
3990 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3991 if (bed->elf_backend_sym_is_global)
3992 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3994 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3995 || bfd_is_und_section (bfd_get_section (sym))
3996 || bfd_is_com_section (bfd_get_section (sym)));
3999 /* Filter global symbols of ABFD to include in the import library. All
4000 SYMCOUNT symbols of ABFD can be examined from their pointers in
4001 SYMS. Pointers of symbols to keep should be stored contiguously at
4002 the beginning of that array.
4004 Returns the number of symbols to keep. */
4007 _bfd_elf_filter_global_symbols (bfd *abfd, struct bfd_link_info *info,
4008 asymbol **syms, long symcount)
4010 long src_count, dst_count = 0;
4012 for (src_count = 0; src_count < symcount; src_count++)
4014 asymbol *sym = syms[src_count];
4015 char *name = (char *) bfd_asymbol_name (sym);
4016 struct bfd_link_hash_entry *h;
4018 if (!sym_is_global (abfd, sym))
4021 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
4024 if (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak)
4026 if (h->linker_def || h->ldscript_def)
4029 syms[dst_count++] = sym;
4032 syms[dst_count] = NULL;
4037 /* Don't output section symbols for sections that are not going to be
4038 output, that are duplicates or there is no BFD section. */
4041 ignore_section_sym (bfd *abfd, asymbol *sym)
4043 elf_symbol_type *type_ptr;
4048 if ((sym->flags & BSF_SECTION_SYM) == 0)
4051 if (sym->section == NULL)
4054 type_ptr = elf_symbol_from (abfd, sym);
4055 return ((type_ptr != NULL
4056 && type_ptr->internal_elf_sym.st_shndx != 0
4057 && bfd_is_abs_section (sym->section))
4058 || !(sym->section->owner == abfd
4059 || (sym->section->output_section != NULL
4060 && sym->section->output_section->owner == abfd
4061 && sym->section->output_offset == 0)
4062 || bfd_is_abs_section (sym->section)));
4065 /* Map symbol from it's internal number to the external number, moving
4066 all local symbols to be at the head of the list. */
4069 elf_map_symbols (bfd *abfd, unsigned int *pnum_locals)
4071 unsigned int symcount = bfd_get_symcount (abfd);
4072 asymbol **syms = bfd_get_outsymbols (abfd);
4073 asymbol **sect_syms;
4074 unsigned int num_locals = 0;
4075 unsigned int num_globals = 0;
4076 unsigned int num_locals2 = 0;
4077 unsigned int num_globals2 = 0;
4078 unsigned int max_index = 0;
4084 fprintf (stderr, "elf_map_symbols\n");
4088 for (asect = abfd->sections; asect; asect = asect->next)
4090 if (max_index < asect->index)
4091 max_index = asect->index;
4095 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
4096 if (sect_syms == NULL)
4098 elf_section_syms (abfd) = sect_syms;
4099 elf_num_section_syms (abfd) = max_index;
4101 /* Init sect_syms entries for any section symbols we have already
4102 decided to output. */
4103 for (idx = 0; idx < symcount; idx++)
4105 asymbol *sym = syms[idx];
4107 if ((sym->flags & BSF_SECTION_SYM) != 0
4109 && !ignore_section_sym (abfd, sym)
4110 && !bfd_is_abs_section (sym->section))
4112 asection *sec = sym->section;
4114 if (sec->owner != abfd)
4115 sec = sec->output_section;
4117 sect_syms[sec->index] = syms[idx];
4121 /* Classify all of the symbols. */
4122 for (idx = 0; idx < symcount; idx++)
4124 if (sym_is_global (abfd, syms[idx]))
4126 else if (!ignore_section_sym (abfd, syms[idx]))
4130 /* We will be adding a section symbol for each normal BFD section. Most
4131 sections will already have a section symbol in outsymbols, but
4132 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4133 at least in that case. */
4134 for (asect = abfd->sections; asect; asect = asect->next)
4136 if (sect_syms[asect->index] == NULL)
4138 if (!sym_is_global (abfd, asect->symbol))
4145 /* Now sort the symbols so the local symbols are first. */
4146 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
4147 sizeof (asymbol *));
4149 if (new_syms == NULL)
4152 for (idx = 0; idx < symcount; idx++)
4154 asymbol *sym = syms[idx];
4157 if (sym_is_global (abfd, sym))
4158 i = num_locals + num_globals2++;
4159 else if (!ignore_section_sym (abfd, sym))
4164 sym->udata.i = i + 1;
4166 for (asect = abfd->sections; asect; asect = asect->next)
4168 if (sect_syms[asect->index] == NULL)
4170 asymbol *sym = asect->symbol;
4173 sect_syms[asect->index] = sym;
4174 if (!sym_is_global (abfd, sym))
4177 i = num_locals + num_globals2++;
4179 sym->udata.i = i + 1;
4183 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
4185 *pnum_locals = num_locals;
4189 /* Align to the maximum file alignment that could be required for any
4190 ELF data structure. */
4192 static inline file_ptr
4193 align_file_position (file_ptr off, int align)
4195 return (off + align - 1) & ~(align - 1);
4198 /* Assign a file position to a section, optionally aligning to the
4199 required section alignment. */
4202 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
4206 if (align && i_shdrp->sh_addralign > 1)
4207 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
4208 i_shdrp->sh_offset = offset;
4209 if (i_shdrp->bfd_section != NULL)
4210 i_shdrp->bfd_section->filepos = offset;
4211 if (i_shdrp->sh_type != SHT_NOBITS)
4212 offset += i_shdrp->sh_size;
4216 /* Compute the file positions we are going to put the sections at, and
4217 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4218 is not NULL, this is being called by the ELF backend linker. */
4221 _bfd_elf_compute_section_file_positions (bfd *abfd,
4222 struct bfd_link_info *link_info)
4224 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4225 struct fake_section_arg fsargs;
4227 struct elf_strtab_hash *strtab = NULL;
4228 Elf_Internal_Shdr *shstrtab_hdr;
4229 bfd_boolean need_symtab;
4231 if (abfd->output_has_begun)
4234 /* Do any elf backend specific processing first. */
4235 if (bed->elf_backend_begin_write_processing)
4236 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
4238 if (! prep_headers (abfd))
4241 /* Post process the headers if necessary. */
4242 (*bed->elf_backend_post_process_headers) (abfd, link_info);
4244 fsargs.failed = FALSE;
4245 fsargs.link_info = link_info;
4246 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
4250 if (!assign_section_numbers (abfd, link_info))
4253 /* The backend linker builds symbol table information itself. */
4254 need_symtab = (link_info == NULL
4255 && (bfd_get_symcount (abfd) > 0
4256 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
4260 /* Non-zero if doing a relocatable link. */
4261 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
4263 if (! swap_out_syms (abfd, &strtab, relocatable_p))
4268 if (link_info == NULL)
4270 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
4275 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
4276 /* sh_name was set in prep_headers. */
4277 shstrtab_hdr->sh_type = SHT_STRTAB;
4278 shstrtab_hdr->sh_flags = bed->elf_strtab_flags;
4279 shstrtab_hdr->sh_addr = 0;
4280 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4281 shstrtab_hdr->sh_entsize = 0;
4282 shstrtab_hdr->sh_link = 0;
4283 shstrtab_hdr->sh_info = 0;
4284 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4285 shstrtab_hdr->sh_addralign = 1;
4287 if (!assign_file_positions_except_relocs (abfd, link_info))
4293 Elf_Internal_Shdr *hdr;
4295 off = elf_next_file_pos (abfd);
4297 hdr = & elf_symtab_hdr (abfd);
4298 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4300 if (elf_symtab_shndx_list (abfd) != NULL)
4302 hdr = & elf_symtab_shndx_list (abfd)->hdr;
4303 if (hdr->sh_size != 0)
4304 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4305 /* FIXME: What about other symtab_shndx sections in the list ? */
4308 hdr = &elf_tdata (abfd)->strtab_hdr;
4309 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4311 elf_next_file_pos (abfd) = off;
4313 /* Now that we know where the .strtab section goes, write it
4315 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4316 || ! _bfd_elf_strtab_emit (abfd, strtab))
4318 _bfd_elf_strtab_free (strtab);
4321 abfd->output_has_begun = TRUE;
4326 /* Make an initial estimate of the size of the program header. If we
4327 get the number wrong here, we'll redo section placement. */
4329 static bfd_size_type
4330 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
4334 const struct elf_backend_data *bed;
4336 /* Assume we will need exactly two PT_LOAD segments: one for text
4337 and one for data. */
4340 s = bfd_get_section_by_name (abfd, ".interp");
4341 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->size != 0)
4343 /* If we have a loadable interpreter section, we need a
4344 PT_INTERP segment. In this case, assume we also need a
4345 PT_PHDR segment, although that may not be true for all
4350 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4352 /* We need a PT_DYNAMIC segment. */
4356 if (info != NULL && info->relro)
4358 /* We need a PT_GNU_RELRO segment. */
4362 if (elf_eh_frame_hdr (abfd))
4364 /* We need a PT_GNU_EH_FRAME segment. */
4368 if (elf_stack_flags (abfd))
4370 /* We need a PT_GNU_STACK segment. */
4374 for (s = abfd->sections; s != NULL; s = s->next)
4376 if ((s->flags & SEC_LOAD) != 0
4377 && elf_section_type (s) == SHT_NOTE)
4379 unsigned int alignment_power;
4380 /* We need a PT_NOTE segment. */
4382 /* Try to create just one PT_NOTE segment for all adjacent
4383 loadable SHT_NOTE sections. gABI requires that within a
4384 PT_NOTE segment (and also inside of each SHT_NOTE section)
4385 each note should have the same alignment. So we check
4386 whether the sections are correctly aligned. */
4387 alignment_power = s->alignment_power;
4388 while (s->next != NULL
4389 && s->next->alignment_power == alignment_power
4390 && (s->next->flags & SEC_LOAD) != 0
4391 && elf_section_type (s->next) == SHT_NOTE)
4396 for (s = abfd->sections; s != NULL; s = s->next)
4398 if (s->flags & SEC_THREAD_LOCAL)
4400 /* We need a PT_TLS segment. */
4406 bed = get_elf_backend_data (abfd);
4408 if ((abfd->flags & D_PAGED) != 0)
4410 /* Add a PT_GNU_MBIND segment for each mbind section. */
4411 unsigned int page_align_power = bfd_log2 (bed->commonpagesize);
4412 for (s = abfd->sections; s != NULL; s = s->next)
4413 if (elf_section_flags (s) & SHF_GNU_MBIND)
4415 if (elf_section_data (s)->this_hdr.sh_info
4419 /* xgettext:c-format */
4420 (_("%pB: GNU_MBIN section `%pA' has invalid sh_info field: %d"),
4421 abfd, s, elf_section_data (s)->this_hdr.sh_info);
4424 /* Align mbind section to page size. */
4425 if (s->alignment_power < page_align_power)
4426 s->alignment_power = page_align_power;
4431 /* Let the backend count up any program headers it might need. */
4432 if (bed->elf_backend_additional_program_headers)
4436 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
4442 return segs * bed->s->sizeof_phdr;
4445 /* Find the segment that contains the output_section of section. */
4448 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
4450 struct elf_segment_map *m;
4451 Elf_Internal_Phdr *p;
4453 for (m = elf_seg_map (abfd), p = elf_tdata (abfd)->phdr;
4459 for (i = m->count - 1; i >= 0; i--)
4460 if (m->sections[i] == section)
4467 /* Create a mapping from a set of sections to a program segment. */
4469 static struct elf_segment_map *
4470 make_mapping (bfd *abfd,
4471 asection **sections,
4476 struct elf_segment_map *m;
4481 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4482 amt += (to - from) * sizeof (asection *);
4483 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4487 m->p_type = PT_LOAD;
4488 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
4489 m->sections[i - from] = *hdrpp;
4490 m->count = to - from;
4492 if (from == 0 && phdr)
4494 /* Include the headers in the first PT_LOAD segment. */
4495 m->includes_filehdr = 1;
4496 m->includes_phdrs = 1;
4502 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4505 struct elf_segment_map *
4506 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
4508 struct elf_segment_map *m;
4510 m = (struct elf_segment_map *) bfd_zalloc (abfd,
4511 sizeof (struct elf_segment_map));
4515 m->p_type = PT_DYNAMIC;
4517 m->sections[0] = dynsec;
4522 /* Possibly add or remove segments from the segment map. */
4525 elf_modify_segment_map (bfd *abfd,
4526 struct bfd_link_info *info,
4527 bfd_boolean remove_empty_load)
4529 struct elf_segment_map **m;
4530 const struct elf_backend_data *bed;
4532 /* The placement algorithm assumes that non allocated sections are
4533 not in PT_LOAD segments. We ensure this here by removing such
4534 sections from the segment map. We also remove excluded
4535 sections. Finally, any PT_LOAD segment without sections is
4537 m = &elf_seg_map (abfd);
4540 unsigned int i, new_count;
4542 for (new_count = 0, i = 0; i < (*m)->count; i++)
4544 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
4545 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
4546 || (*m)->p_type != PT_LOAD))
4548 (*m)->sections[new_count] = (*m)->sections[i];
4552 (*m)->count = new_count;
4554 if (remove_empty_load
4555 && (*m)->p_type == PT_LOAD
4557 && !(*m)->includes_phdrs)
4563 bed = get_elf_backend_data (abfd);
4564 if (bed->elf_backend_modify_segment_map != NULL)
4566 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
4573 #define IS_TBSS(s) \
4574 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4576 /* Set up a mapping from BFD sections to program segments. */
4579 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
4582 struct elf_segment_map *m;
4583 asection **sections = NULL;
4584 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4585 bfd_boolean no_user_phdrs;
4587 no_user_phdrs = elf_seg_map (abfd) == NULL;
4590 info->user_phdrs = !no_user_phdrs;
4592 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
4596 struct elf_segment_map *mfirst;
4597 struct elf_segment_map **pm;
4600 unsigned int hdr_index;
4601 bfd_vma maxpagesize;
4603 bfd_boolean phdr_in_segment;
4604 bfd_boolean writable;
4605 bfd_boolean executable;
4607 asection *first_tls = NULL;
4608 asection *first_mbind = NULL;
4609 asection *dynsec, *eh_frame_hdr;
4611 bfd_vma addr_mask, wrap_to = 0;
4612 bfd_size_type phdr_size;
4614 /* Select the allocated sections, and sort them. */
4616 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
4617 sizeof (asection *));
4618 if (sections == NULL)
4621 /* Calculate top address, avoiding undefined behaviour of shift
4622 left operator when shift count is equal to size of type
4624 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
4625 addr_mask = (addr_mask << 1) + 1;
4628 for (s = abfd->sections; s != NULL; s = s->next)
4630 if ((s->flags & SEC_ALLOC) != 0)
4634 /* A wrapping section potentially clashes with header. */
4635 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
4636 wrap_to = (s->lma + s->size) & addr_mask;
4639 BFD_ASSERT (i <= bfd_count_sections (abfd));
4642 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
4644 phdr_size = elf_program_header_size (abfd);
4645 if (phdr_size == (bfd_size_type) -1)
4646 phdr_size = get_program_header_size (abfd, info);
4647 phdr_size += bed->s->sizeof_ehdr;
4648 maxpagesize = bed->maxpagesize;
4649 if (maxpagesize == 0)
4651 phdr_in_segment = info != NULL && info->load_phdrs;
4653 && (((sections[0]->lma & addr_mask) & (maxpagesize - 1))
4654 >= (phdr_size & (maxpagesize - 1))))
4655 /* For compatibility with old scripts that may not be using
4656 SIZEOF_HEADERS, add headers when it looks like space has
4657 been left for them. */
4658 phdr_in_segment = TRUE;
4660 /* Build the mapping. */
4664 /* If we have a .interp section, then create a PT_PHDR segment for
4665 the program headers and a PT_INTERP segment for the .interp
4667 s = bfd_get_section_by_name (abfd, ".interp");
4668 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->size != 0)
4670 amt = sizeof (struct elf_segment_map);
4671 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4675 m->p_type = PT_PHDR;
4677 m->p_flags_valid = 1;
4678 m->includes_phdrs = 1;
4679 phdr_in_segment = TRUE;
4683 amt = sizeof (struct elf_segment_map);
4684 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4688 m->p_type = PT_INTERP;
4696 /* Look through the sections. We put sections in the same program
4697 segment when the start of the second section can be placed within
4698 a few bytes of the end of the first section. */
4704 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
4706 && (dynsec->flags & SEC_LOAD) == 0)
4709 if ((abfd->flags & D_PAGED) == 0)
4710 phdr_in_segment = FALSE;
4712 /* Deal with -Ttext or something similar such that the first section
4713 is not adjacent to the program headers. This is an
4714 approximation, since at this point we don't know exactly how many
4715 program headers we will need. */
4716 if (phdr_in_segment && count > 0)
4719 bfd_boolean separate_phdr = FALSE;
4721 phdr_lma = (sections[0]->lma - phdr_size) & addr_mask & -maxpagesize;
4723 && info->separate_code
4724 && (sections[0]->flags & SEC_CODE) != 0)
4726 /* If data sections should be separate from code and
4727 thus not executable, and the first section is
4728 executable then put the file and program headers in
4729 their own PT_LOAD. */
4730 separate_phdr = TRUE;
4731 if ((((phdr_lma + phdr_size - 1) & addr_mask & -maxpagesize)
4732 == (sections[0]->lma & addr_mask & -maxpagesize)))
4734 /* The file and program headers are currently on the
4735 same page as the first section. Put them on the
4736 previous page if we can. */
4737 if (phdr_lma >= maxpagesize)
4738 phdr_lma -= maxpagesize;
4740 separate_phdr = FALSE;
4743 if ((sections[0]->lma & addr_mask) < phdr_lma
4744 || (sections[0]->lma & addr_mask) < phdr_size)
4745 /* If file and program headers would be placed at the end
4746 of memory then it's probably better to omit them. */
4747 phdr_in_segment = FALSE;
4748 else if (phdr_lma < wrap_to)
4749 /* If a section wraps around to where we'll be placing
4750 file and program headers, then the headers will be
4752 phdr_in_segment = FALSE;
4753 else if (separate_phdr)
4755 m = make_mapping (abfd, sections, 0, 0, phdr_in_segment);
4758 m->p_paddr = phdr_lma;
4760 = (sections[0]->vma - phdr_size) & addr_mask & -maxpagesize;
4761 m->p_paddr_valid = 1;
4764 phdr_in_segment = FALSE;
4768 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
4771 bfd_boolean new_segment;
4775 /* See if this section and the last one will fit in the same
4778 if (last_hdr == NULL)
4780 /* If we don't have a segment yet, then we don't need a new
4781 one (we build the last one after this loop). */
4782 new_segment = FALSE;
4784 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
4786 /* If this section has a different relation between the
4787 virtual address and the load address, then we need a new
4791 else if (hdr->lma < last_hdr->lma + last_size
4792 || last_hdr->lma + last_size < last_hdr->lma)
4794 /* If this section has a load address that makes it overlap
4795 the previous section, then we need a new segment. */
4798 else if ((abfd->flags & D_PAGED) != 0
4799 && (((last_hdr->lma + last_size - 1) & -maxpagesize)
4800 == (hdr->lma & -maxpagesize)))
4802 /* If we are demand paged then we can't map two disk
4803 pages onto the same memory page. */
4804 new_segment = FALSE;
4806 /* In the next test we have to be careful when last_hdr->lma is close
4807 to the end of the address space. If the aligned address wraps
4808 around to the start of the address space, then there are no more
4809 pages left in memory and it is OK to assume that the current
4810 section can be included in the current segment. */
4811 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4812 + maxpagesize > last_hdr->lma)
4813 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
4814 + maxpagesize <= hdr->lma))
4816 /* If putting this section in this segment would force us to
4817 skip a page in the segment, then we need a new segment. */
4820 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
4821 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
4823 /* We don't want to put a loaded section after a
4824 nonloaded (ie. bss style) section in the same segment
4825 as that will force the non-loaded section to be loaded.
4826 Consider .tbss sections as loaded for this purpose. */
4829 else if ((abfd->flags & D_PAGED) == 0)
4831 /* If the file is not demand paged, which means that we
4832 don't require the sections to be correctly aligned in the
4833 file, then there is no other reason for a new segment. */
4834 new_segment = FALSE;
4836 else if (info != NULL
4837 && info->separate_code
4838 && executable != ((hdr->flags & SEC_CODE) != 0))
4843 && (hdr->flags & SEC_READONLY) == 0)
4845 /* We don't want to put a writable section in a read only
4851 /* Otherwise, we can use the same segment. */
4852 new_segment = FALSE;
4855 /* Allow interested parties a chance to override our decision. */
4856 if (last_hdr != NULL
4858 && info->callbacks->override_segment_assignment != NULL)
4860 = info->callbacks->override_segment_assignment (info, abfd, hdr,
4866 if ((hdr->flags & SEC_READONLY) == 0)
4868 if ((hdr->flags & SEC_CODE) != 0)
4871 /* .tbss sections effectively have zero size. */
4872 last_size = !IS_TBSS (hdr) ? hdr->size : 0;
4876 /* We need a new program segment. We must create a new program
4877 header holding all the sections from hdr_index until hdr. */
4879 m = make_mapping (abfd, sections, hdr_index, i, phdr_in_segment);
4886 if ((hdr->flags & SEC_READONLY) == 0)
4891 if ((hdr->flags & SEC_CODE) == 0)
4897 /* .tbss sections effectively have zero size. */
4898 last_size = !IS_TBSS (hdr) ? hdr->size : 0;
4900 phdr_in_segment = FALSE;
4903 /* Create a final PT_LOAD program segment, but not if it's just
4905 if (last_hdr != NULL
4906 && (i - hdr_index != 1
4907 || !IS_TBSS (last_hdr)))
4909 m = make_mapping (abfd, sections, hdr_index, i, phdr_in_segment);
4917 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4920 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4927 /* For each batch of consecutive loadable SHT_NOTE sections,
4928 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4929 because if we link together nonloadable .note sections and
4930 loadable .note sections, we will generate two .note sections
4931 in the output file. */
4932 for (s = abfd->sections; s != NULL; s = s->next)
4934 if ((s->flags & SEC_LOAD) != 0
4935 && elf_section_type (s) == SHT_NOTE)
4938 unsigned int alignment_power = s->alignment_power;
4941 for (s2 = s; s2->next != NULL; s2 = s2->next)
4943 if (s2->next->alignment_power == alignment_power
4944 && (s2->next->flags & SEC_LOAD) != 0
4945 && elf_section_type (s2->next) == SHT_NOTE
4946 && align_power (s2->lma + s2->size,
4953 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4954 amt += count * sizeof (asection *);
4955 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4959 m->p_type = PT_NOTE;
4963 m->sections[m->count - count--] = s;
4964 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4967 m->sections[m->count - 1] = s;
4968 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4972 if (s->flags & SEC_THREAD_LOCAL)
4978 if (first_mbind == NULL
4979 && (elf_section_flags (s) & SHF_GNU_MBIND) != 0)
4983 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4986 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
4987 amt += tls_count * sizeof (asection *);
4988 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4993 m->count = tls_count;
4994 /* Mandated PF_R. */
4996 m->p_flags_valid = 1;
4998 for (i = 0; i < (unsigned int) tls_count; ++i)
5000 if ((s->flags & SEC_THREAD_LOCAL) == 0)
5003 (_("%pB: TLS sections are not adjacent:"), abfd);
5006 while (i < (unsigned int) tls_count)
5008 if ((s->flags & SEC_THREAD_LOCAL) != 0)
5010 _bfd_error_handler (_(" TLS: %pA"), s);
5014 _bfd_error_handler (_(" non-TLS: %pA"), s);
5017 bfd_set_error (bfd_error_bad_value);
5028 if (first_mbind && (abfd->flags & D_PAGED) != 0)
5029 for (s = first_mbind; s != NULL; s = s->next)
5030 if ((elf_section_flags (s) & SHF_GNU_MBIND) != 0
5031 && (elf_section_data (s)->this_hdr.sh_info
5032 <= PT_GNU_MBIND_NUM))
5034 /* Mandated PF_R. */
5035 unsigned long p_flags = PF_R;
5036 if ((s->flags & SEC_READONLY) == 0)
5038 if ((s->flags & SEC_CODE) != 0)
5041 amt = sizeof (struct elf_segment_map) + sizeof (asection *);
5042 m = bfd_zalloc (abfd, amt);
5046 m->p_type = (PT_GNU_MBIND_LO
5047 + elf_section_data (s)->this_hdr.sh_info);
5049 m->p_flags_valid = 1;
5051 m->p_flags = p_flags;
5057 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5059 eh_frame_hdr = elf_eh_frame_hdr (abfd);
5060 if (eh_frame_hdr != NULL
5061 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
5063 amt = sizeof (struct elf_segment_map);
5064 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5068 m->p_type = PT_GNU_EH_FRAME;
5070 m->sections[0] = eh_frame_hdr->output_section;
5076 if (elf_stack_flags (abfd))
5078 amt = sizeof (struct elf_segment_map);
5079 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5083 m->p_type = PT_GNU_STACK;
5084 m->p_flags = elf_stack_flags (abfd);
5085 m->p_align = bed->stack_align;
5086 m->p_flags_valid = 1;
5087 m->p_align_valid = m->p_align != 0;
5088 if (info->stacksize > 0)
5090 m->p_size = info->stacksize;
5091 m->p_size_valid = 1;
5098 if (info != NULL && info->relro)
5100 for (m = mfirst; m != NULL; m = m->next)
5102 if (m->p_type == PT_LOAD
5104 && m->sections[0]->vma >= info->relro_start
5105 && m->sections[0]->vma < info->relro_end)
5108 while (--i != (unsigned) -1)
5109 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
5110 == (SEC_LOAD | SEC_HAS_CONTENTS))
5113 if (i != (unsigned) -1)
5118 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5121 amt = sizeof (struct elf_segment_map);
5122 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
5126 m->p_type = PT_GNU_RELRO;
5133 elf_seg_map (abfd) = mfirst;
5136 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
5139 for (count = 0, m = elf_seg_map (abfd); m != NULL; m = m->next)
5141 elf_program_header_size (abfd) = count * bed->s->sizeof_phdr;
5146 if (sections != NULL)
5151 /* Sort sections by address. */
5154 elf_sort_sections (const void *arg1, const void *arg2)
5156 const asection *sec1 = *(const asection **) arg1;
5157 const asection *sec2 = *(const asection **) arg2;
5158 bfd_size_type size1, size2;
5160 /* Sort by LMA first, since this is the address used to
5161 place the section into a segment. */
5162 if (sec1->lma < sec2->lma)
5164 else if (sec1->lma > sec2->lma)
5167 /* Then sort by VMA. Normally the LMA and the VMA will be
5168 the same, and this will do nothing. */
5169 if (sec1->vma < sec2->vma)
5171 else if (sec1->vma > sec2->vma)
5174 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5176 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5182 /* If the indices are the same, do not return 0
5183 here, but continue to try the next comparison. */
5184 if (sec1->target_index - sec2->target_index != 0)
5185 return sec1->target_index - sec2->target_index;
5190 else if (TOEND (sec2))
5195 /* Sort by size, to put zero sized sections
5196 before others at the same address. */
5198 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
5199 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
5206 return sec1->target_index - sec2->target_index;
5209 /* Ian Lance Taylor writes:
5211 We shouldn't be using % with a negative signed number. That's just
5212 not good. We have to make sure either that the number is not
5213 negative, or that the number has an unsigned type. When the types
5214 are all the same size they wind up as unsigned. When file_ptr is a
5215 larger signed type, the arithmetic winds up as signed long long,
5218 What we're trying to say here is something like ``increase OFF by
5219 the least amount that will cause it to be equal to the VMA modulo
5221 /* In other words, something like:
5223 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5224 off_offset = off % bed->maxpagesize;
5225 if (vma_offset < off_offset)
5226 adjustment = vma_offset + bed->maxpagesize - off_offset;
5228 adjustment = vma_offset - off_offset;
5230 which can be collapsed into the expression below. */
5233 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
5235 /* PR binutils/16199: Handle an alignment of zero. */
5236 if (maxpagesize == 0)
5238 return ((vma - off) % maxpagesize);
5242 print_segment_map (const struct elf_segment_map *m)
5245 const char *pt = get_segment_type (m->p_type);
5250 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
5251 sprintf (buf, "LOPROC+%7.7x",
5252 (unsigned int) (m->p_type - PT_LOPROC));
5253 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
5254 sprintf (buf, "LOOS+%7.7x",
5255 (unsigned int) (m->p_type - PT_LOOS));
5257 snprintf (buf, sizeof (buf), "%8.8x",
5258 (unsigned int) m->p_type);
5262 fprintf (stderr, "%s:", pt);
5263 for (j = 0; j < m->count; j++)
5264 fprintf (stderr, " %s", m->sections [j]->name);
5270 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
5275 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
5277 buf = bfd_zmalloc (len);
5280 ret = bfd_bwrite (buf, len, abfd) == len;
5285 /* Assign file positions to the sections based on the mapping from
5286 sections to segments. This function also sets up some fields in
5290 assign_file_positions_for_load_sections (bfd *abfd,
5291 struct bfd_link_info *link_info)
5293 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5294 struct elf_segment_map *m;
5295 Elf_Internal_Phdr *phdrs;
5296 Elf_Internal_Phdr *p;
5298 bfd_size_type maxpagesize;
5299 unsigned int pt_load_count = 0;
5302 bfd_vma header_pad = 0;
5304 if (link_info == NULL
5305 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
5309 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5313 header_pad = m->header_size;
5318 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
5319 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
5323 /* PR binutils/12467. */
5324 elf_elfheader (abfd)->e_phoff = 0;
5325 elf_elfheader (abfd)->e_phentsize = 0;
5328 elf_elfheader (abfd)->e_phnum = alloc;
5330 if (elf_program_header_size (abfd) == (bfd_size_type) -1)
5331 elf_program_header_size (abfd) = alloc * bed->s->sizeof_phdr;
5333 BFD_ASSERT (elf_program_header_size (abfd)
5334 >= alloc * bed->s->sizeof_phdr);
5338 elf_next_file_pos (abfd) = bed->s->sizeof_ehdr;
5342 /* We're writing the size in elf_program_header_size (abfd),
5343 see assign_file_positions_except_relocs, so make sure we have
5344 that amount allocated, with trailing space cleared.
5345 The variable alloc contains the computed need, while
5346 elf_program_header_size (abfd) contains the size used for the
5348 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5349 where the layout is forced to according to a larger size in the
5350 last iterations for the testcase ld-elf/header. */
5351 BFD_ASSERT (elf_program_header_size (abfd) % bed->s->sizeof_phdr
5353 phdrs = (Elf_Internal_Phdr *)
5355 (elf_program_header_size (abfd) / bed->s->sizeof_phdr),
5356 sizeof (Elf_Internal_Phdr));
5357 elf_tdata (abfd)->phdr = phdrs;
5362 if ((abfd->flags & D_PAGED) != 0)
5363 maxpagesize = bed->maxpagesize;
5365 off = bed->s->sizeof_ehdr;
5366 off += alloc * bed->s->sizeof_phdr;
5367 if (header_pad < (bfd_vma) off)
5373 for (m = elf_seg_map (abfd), p = phdrs, j = 0;
5375 m = m->next, p++, j++)
5379 bfd_boolean no_contents;
5381 /* If elf_segment_map is not from map_sections_to_segments, the
5382 sections may not be correctly ordered. NOTE: sorting should
5383 not be done to the PT_NOTE section of a corefile, which may
5384 contain several pseudo-sections artificially created by bfd.
5385 Sorting these pseudo-sections breaks things badly. */
5387 && !(elf_elfheader (abfd)->e_type == ET_CORE
5388 && m->p_type == PT_NOTE))
5389 qsort (m->sections, (size_t) m->count, sizeof (asection *),
5392 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5393 number of sections with contents contributing to both p_filesz
5394 and p_memsz, followed by a number of sections with no contents
5395 that just contribute to p_memsz. In this loop, OFF tracks next
5396 available file offset for PT_LOAD and PT_NOTE segments. */
5397 p->p_type = m->p_type;
5398 p->p_flags = m->p_flags;
5401 p->p_vaddr = m->p_vaddr_offset;
5403 p->p_vaddr = m->sections[0]->vma + m->p_vaddr_offset;
5405 if (m->p_paddr_valid)
5406 p->p_paddr = m->p_paddr;
5407 else if (m->count == 0)
5410 p->p_paddr = m->sections[0]->lma + m->p_vaddr_offset;
5412 if (p->p_type == PT_LOAD
5413 && (abfd->flags & D_PAGED) != 0)
5415 /* p_align in demand paged PT_LOAD segments effectively stores
5416 the maximum page size. When copying an executable with
5417 objcopy, we set m->p_align from the input file. Use this
5418 value for maxpagesize rather than bed->maxpagesize, which
5419 may be different. Note that we use maxpagesize for PT_TLS
5420 segment alignment later in this function, so we are relying
5421 on at least one PT_LOAD segment appearing before a PT_TLS
5423 if (m->p_align_valid)
5424 maxpagesize = m->p_align;
5426 p->p_align = maxpagesize;
5429 else if (m->p_align_valid)
5430 p->p_align = m->p_align;
5431 else if (m->count == 0)
5432 p->p_align = 1 << bed->s->log_file_align;
5436 no_contents = FALSE;
5438 if (p->p_type == PT_LOAD
5441 bfd_size_type align;
5442 unsigned int align_power = 0;
5444 if (m->p_align_valid)
5448 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5450 unsigned int secalign;
5452 secalign = bfd_get_section_alignment (abfd, *secpp);
5453 if (secalign > align_power)
5454 align_power = secalign;
5456 align = (bfd_size_type) 1 << align_power;
5457 if (align < maxpagesize)
5458 align = maxpagesize;
5461 for (i = 0; i < m->count; i++)
5462 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
5463 /* If we aren't making room for this section, then
5464 it must be SHT_NOBITS regardless of what we've
5465 set via struct bfd_elf_special_section. */
5466 elf_section_type (m->sections[i]) = SHT_NOBITS;
5468 /* Find out whether this segment contains any loadable
5471 for (i = 0; i < m->count; i++)
5472 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
5474 no_contents = FALSE;
5478 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
5480 /* Broken hardware and/or kernel require that files do not
5481 map the same page with different permissions on some hppa
5483 if (pt_load_count > 1
5484 && bed->no_page_alias
5485 && (off & (maxpagesize - 1)) != 0
5486 && (off & -maxpagesize) == ((off + off_adjust) & -maxpagesize))
5487 off_adjust += maxpagesize;
5491 /* We shouldn't need to align the segment on disk since
5492 the segment doesn't need file space, but the gABI
5493 arguably requires the alignment and glibc ld.so
5494 checks it. So to comply with the alignment
5495 requirement but not waste file space, we adjust
5496 p_offset for just this segment. (OFF_ADJUST is
5497 subtracted from OFF later.) This may put p_offset
5498 past the end of file, but that shouldn't matter. */
5503 /* Make sure the .dynamic section is the first section in the
5504 PT_DYNAMIC segment. */
5505 else if (p->p_type == PT_DYNAMIC
5507 && strcmp (m->sections[0]->name, ".dynamic") != 0)
5510 (_("%pB: The first section in the PT_DYNAMIC segment"
5511 " is not the .dynamic section"),
5513 bfd_set_error (bfd_error_bad_value);
5516 /* Set the note section type to SHT_NOTE. */
5517 else if (p->p_type == PT_NOTE)
5518 for (i = 0; i < m->count; i++)
5519 elf_section_type (m->sections[i]) = SHT_NOTE;
5525 if (m->includes_filehdr)
5527 if (!m->p_flags_valid)
5529 p->p_filesz = bed->s->sizeof_ehdr;
5530 p->p_memsz = bed->s->sizeof_ehdr;
5533 if (p->p_vaddr < (bfd_vma) off
5534 || (!m->p_paddr_valid
5535 && p->p_paddr < (bfd_vma) off))
5538 (_("%pB: not enough room for program headers,"
5539 " try linking with -N"),
5541 bfd_set_error (bfd_error_bad_value);
5546 if (!m->p_paddr_valid)
5551 if (m->includes_phdrs)
5553 if (!m->p_flags_valid)
5556 if (!m->includes_filehdr)
5558 p->p_offset = bed->s->sizeof_ehdr;
5562 p->p_vaddr -= off - p->p_offset;
5563 if (!m->p_paddr_valid)
5564 p->p_paddr -= off - p->p_offset;
5568 p->p_filesz += alloc * bed->s->sizeof_phdr;
5569 p->p_memsz += alloc * bed->s->sizeof_phdr;
5572 p->p_filesz += header_pad;
5573 p->p_memsz += header_pad;
5577 if (p->p_type == PT_LOAD
5578 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
5580 if (!m->includes_filehdr && !m->includes_phdrs)
5586 adjust = off - (p->p_offset + p->p_filesz);
5588 p->p_filesz += adjust;
5589 p->p_memsz += adjust;
5593 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5594 maps. Set filepos for sections in PT_LOAD segments, and in
5595 core files, for sections in PT_NOTE segments.
5596 assign_file_positions_for_non_load_sections will set filepos
5597 for other sections and update p_filesz for other segments. */
5598 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5601 bfd_size_type align;
5602 Elf_Internal_Shdr *this_hdr;
5605 this_hdr = &elf_section_data (sec)->this_hdr;
5606 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
5608 if ((p->p_type == PT_LOAD
5609 || p->p_type == PT_TLS)
5610 && (this_hdr->sh_type != SHT_NOBITS
5611 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
5612 && ((this_hdr->sh_flags & SHF_TLS) == 0
5613 || p->p_type == PT_TLS))))
5615 bfd_vma p_start = p->p_paddr;
5616 bfd_vma p_end = p_start + p->p_memsz;
5617 bfd_vma s_start = sec->lma;
5618 bfd_vma adjust = s_start - p_end;
5622 || p_end < p_start))
5625 /* xgettext:c-format */
5626 (_("%pB: section %pA lma %#" PRIx64 " adjusted to %#" PRIx64),
5627 abfd, sec, (uint64_t) s_start, (uint64_t) p_end);
5631 p->p_memsz += adjust;
5633 if (this_hdr->sh_type != SHT_NOBITS)
5635 if (p->p_filesz + adjust < p->p_memsz)
5637 /* We have a PROGBITS section following NOBITS ones.
5638 Allocate file space for the NOBITS section(s) and
5640 adjust = p->p_memsz - p->p_filesz;
5641 if (!write_zeros (abfd, off, adjust))
5645 p->p_filesz += adjust;
5649 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
5651 /* The section at i == 0 is the one that actually contains
5655 this_hdr->sh_offset = sec->filepos = off;
5656 off += this_hdr->sh_size;
5657 p->p_filesz = this_hdr->sh_size;
5663 /* The rest are fake sections that shouldn't be written. */
5672 if (p->p_type == PT_LOAD)
5674 this_hdr->sh_offset = sec->filepos = off;
5675 if (this_hdr->sh_type != SHT_NOBITS)
5676 off += this_hdr->sh_size;
5678 else if (this_hdr->sh_type == SHT_NOBITS
5679 && (this_hdr->sh_flags & SHF_TLS) != 0
5680 && this_hdr->sh_offset == 0)
5682 /* This is a .tbss section that didn't get a PT_LOAD.
5683 (See _bfd_elf_map_sections_to_segments "Create a
5684 final PT_LOAD".) Set sh_offset to the value it
5685 would have if we had created a zero p_filesz and
5686 p_memsz PT_LOAD header for the section. This
5687 also makes the PT_TLS header have the same
5689 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
5691 this_hdr->sh_offset = sec->filepos = off + adjust;
5694 if (this_hdr->sh_type != SHT_NOBITS)
5696 p->p_filesz += this_hdr->sh_size;
5697 /* A load section without SHF_ALLOC is something like
5698 a note section in a PT_NOTE segment. These take
5699 file space but are not loaded into memory. */
5700 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5701 p->p_memsz += this_hdr->sh_size;
5703 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5705 if (p->p_type == PT_TLS)
5706 p->p_memsz += this_hdr->sh_size;
5708 /* .tbss is special. It doesn't contribute to p_memsz of
5710 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
5711 p->p_memsz += this_hdr->sh_size;
5714 if (align > p->p_align
5715 && !m->p_align_valid
5716 && (p->p_type != PT_LOAD
5717 || (abfd->flags & D_PAGED) == 0))
5721 if (!m->p_flags_valid)
5724 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
5726 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
5733 /* Check that all sections are in a PT_LOAD segment.
5734 Don't check funky gdb generated core files. */
5735 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
5737 bfd_boolean check_vma = TRUE;
5739 for (i = 1; i < m->count; i++)
5740 if (m->sections[i]->vma == m->sections[i - 1]->vma
5741 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
5742 ->this_hdr), p) != 0
5743 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
5744 ->this_hdr), p) != 0)
5746 /* Looks like we have overlays packed into the segment. */
5751 for (i = 0; i < m->count; i++)
5753 Elf_Internal_Shdr *this_hdr;
5756 sec = m->sections[i];
5757 this_hdr = &(elf_section_data(sec)->this_hdr);
5758 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
5759 && !ELF_TBSS_SPECIAL (this_hdr, p))
5762 /* xgettext:c-format */
5763 (_("%pB: section `%pA' can't be allocated in segment %d"),
5765 print_segment_map (m);
5771 elf_next_file_pos (abfd) = off;
5775 /* Assign file positions for the other sections. */
5778 assign_file_positions_for_non_load_sections (bfd *abfd,
5779 struct bfd_link_info *link_info)
5781 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5782 Elf_Internal_Shdr **i_shdrpp;
5783 Elf_Internal_Shdr **hdrpp, **end_hdrpp;
5784 Elf_Internal_Phdr *phdrs;
5785 Elf_Internal_Phdr *p;
5786 struct elf_segment_map *m;
5787 struct elf_segment_map *hdrs_segment;
5788 bfd_vma filehdr_vaddr, filehdr_paddr;
5789 bfd_vma phdrs_vaddr, phdrs_paddr;
5793 i_shdrpp = elf_elfsections (abfd);
5794 end_hdrpp = i_shdrpp + elf_numsections (abfd);
5795 off = elf_next_file_pos (abfd);
5796 for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
5798 Elf_Internal_Shdr *hdr;
5801 if (hdr->bfd_section != NULL
5802 && (hdr->bfd_section->filepos != 0
5803 || (hdr->sh_type == SHT_NOBITS
5804 && hdr->contents == NULL)))
5805 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5806 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
5808 if (hdr->sh_size != 0)
5810 /* xgettext:c-format */
5811 (_("%pB: warning: allocated section `%s' not in segment"),
5813 (hdr->bfd_section == NULL
5815 : hdr->bfd_section->name));
5816 /* We don't need to page align empty sections. */
5817 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5818 off += vma_page_aligned_bias (hdr->sh_addr, off,
5821 off += vma_page_aligned_bias (hdr->sh_addr, off,
5823 off = _bfd_elf_assign_file_position_for_section (hdr, off,
5826 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5827 && hdr->bfd_section == NULL)
5828 || (hdr->bfd_section != NULL
5829 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5830 /* Compress DWARF debug sections. */
5831 || hdr == i_shdrpp[elf_onesymtab (abfd)]
5832 || (elf_symtab_shndx_list (abfd) != NULL
5833 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
5834 || hdr == i_shdrpp[elf_strtab_sec (abfd)]
5835 || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
5836 hdr->sh_offset = -1;
5838 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5841 /* Now that we have set the section file positions, we can set up
5842 the file positions for the non PT_LOAD segments. */
5846 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
5848 hdrs_segment = NULL;
5849 phdrs = elf_tdata (abfd)->phdr;
5850 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5853 if (p->p_type != PT_LOAD)
5856 if (m->includes_filehdr)
5858 filehdr_vaddr = p->p_vaddr;
5859 filehdr_paddr = p->p_paddr;
5861 if (m->includes_phdrs)
5863 phdrs_vaddr = p->p_vaddr;
5864 phdrs_paddr = p->p_paddr;
5865 if (m->includes_filehdr)
5868 phdrs_vaddr += bed->s->sizeof_ehdr;
5869 phdrs_paddr += bed->s->sizeof_ehdr;
5874 if (hdrs_segment != NULL && link_info != NULL)
5876 /* There is a segment that contains both the file headers and the
5877 program headers, so provide a symbol __ehdr_start pointing there.
5878 A program can use this to examine itself robustly. */
5880 struct elf_link_hash_entry *hash
5881 = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
5882 FALSE, FALSE, TRUE);
5883 /* If the symbol was referenced and not defined, define it. */
5885 && (hash->root.type == bfd_link_hash_new
5886 || hash->root.type == bfd_link_hash_undefined
5887 || hash->root.type == bfd_link_hash_undefweak
5888 || hash->root.type == bfd_link_hash_common))
5891 if (hdrs_segment->count != 0)
5892 /* The segment contains sections, so use the first one. */
5893 s = hdrs_segment->sections[0];
5895 /* Use the first (i.e. lowest-addressed) section in any segment. */
5896 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5905 hash->root.u.def.value = filehdr_vaddr - s->vma;
5906 hash->root.u.def.section = s;
5910 hash->root.u.def.value = filehdr_vaddr;
5911 hash->root.u.def.section = bfd_abs_section_ptr;
5914 hash->root.type = bfd_link_hash_defined;
5915 hash->def_regular = 1;
5920 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5922 if (p->p_type == PT_GNU_RELRO)
5927 if (link_info != NULL)
5929 /* During linking the range of the RELRO segment is passed
5930 in link_info. Note that there may be padding between
5931 relro_start and the first RELRO section. */
5932 start = link_info->relro_start;
5933 end = link_info->relro_end;
5935 else if (m->count != 0)
5937 if (!m->p_size_valid)
5939 start = m->sections[0]->vma;
5940 end = start + m->p_size;
5951 struct elf_segment_map *lm;
5952 const Elf_Internal_Phdr *lp;
5955 /* Find a LOAD segment containing a section in the RELRO
5957 for (lm = elf_seg_map (abfd), lp = phdrs;
5959 lm = lm->next, lp++)
5961 if (lp->p_type == PT_LOAD
5963 && (lm->sections[lm->count - 1]->vma
5964 + (!IS_TBSS (lm->sections[lm->count - 1])
5965 ? lm->sections[lm->count - 1]->size
5967 && lm->sections[0]->vma < end)
5973 /* Find the section starting the RELRO segment. */
5974 for (i = 0; i < lm->count; i++)
5976 asection *s = lm->sections[i];
5985 p->p_vaddr = lm->sections[i]->vma;
5986 p->p_paddr = lm->sections[i]->lma;
5987 p->p_offset = lm->sections[i]->filepos;
5988 p->p_memsz = end - p->p_vaddr;
5989 p->p_filesz = p->p_memsz;
5991 /* The RELRO segment typically ends a few bytes
5992 into .got.plt but other layouts are possible.
5993 In cases where the end does not match any
5994 loaded section (for instance is in file
5995 padding), trim p_filesz back to correspond to
5996 the end of loaded section contents. */
5997 if (p->p_filesz > lp->p_vaddr + lp->p_filesz - p->p_vaddr)
5998 p->p_filesz = lp->p_vaddr + lp->p_filesz - p->p_vaddr;
6000 /* Preserve the alignment and flags if they are
6001 valid. The gold linker generates RW/4 for
6002 the PT_GNU_RELRO section. It is better for
6003 objcopy/strip to honor these attributes
6004 otherwise gdb will choke when using separate
6006 if (!m->p_align_valid)
6008 if (!m->p_flags_valid)
6014 if (link_info != NULL)
6017 memset (p, 0, sizeof *p);
6019 else if (p->p_type == PT_GNU_STACK)
6021 if (m->p_size_valid)
6022 p->p_memsz = m->p_size;
6024 else if (m->count != 0)
6028 if (p->p_type != PT_LOAD
6029 && (p->p_type != PT_NOTE
6030 || bfd_get_format (abfd) != bfd_core))
6032 /* A user specified segment layout may include a PHDR
6033 segment that overlaps with a LOAD segment... */
6034 if (p->p_type == PT_PHDR)
6040 if (m->includes_filehdr || m->includes_phdrs)
6042 /* PR 17512: file: 2195325e. */
6044 (_("%pB: error: non-load segment %d includes file header "
6045 "and/or program header"),
6046 abfd, (int) (p - phdrs));
6051 p->p_offset = m->sections[0]->filepos;
6052 for (i = m->count; i-- != 0;)
6054 asection *sect = m->sections[i];
6055 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
6056 if (hdr->sh_type != SHT_NOBITS)
6058 p->p_filesz = (sect->filepos - m->sections[0]->filepos
6065 else if (m->includes_filehdr)
6067 p->p_vaddr = filehdr_vaddr;
6068 if (! m->p_paddr_valid)
6069 p->p_paddr = filehdr_paddr;
6071 else if (m->includes_phdrs)
6073 p->p_vaddr = phdrs_vaddr;
6074 if (! m->p_paddr_valid)
6075 p->p_paddr = phdrs_paddr;
6079 elf_next_file_pos (abfd) = off;
6084 static elf_section_list *
6085 find_section_in_list (unsigned int i, elf_section_list * list)
6087 for (;list != NULL; list = list->next)
6093 /* Work out the file positions of all the sections. This is called by
6094 _bfd_elf_compute_section_file_positions. All the section sizes and
6095 VMAs must be known before this is called.
6097 Reloc sections come in two flavours: Those processed specially as
6098 "side-channel" data attached to a section to which they apply, and
6099 those that bfd doesn't process as relocations. The latter sort are
6100 stored in a normal bfd section by bfd_section_from_shdr. We don't
6101 consider the former sort here, unless they form part of the loadable
6102 image. Reloc sections not assigned here will be handled later by
6103 assign_file_positions_for_relocs.
6105 We also don't set the positions of the .symtab and .strtab here. */
6108 assign_file_positions_except_relocs (bfd *abfd,
6109 struct bfd_link_info *link_info)
6111 struct elf_obj_tdata *tdata = elf_tdata (abfd);
6112 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6113 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6115 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
6116 && bfd_get_format (abfd) != bfd_core)
6118 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
6119 unsigned int num_sec = elf_numsections (abfd);
6120 Elf_Internal_Shdr **hdrpp;
6124 /* Start after the ELF header. */
6125 off = i_ehdrp->e_ehsize;
6127 /* We are not creating an executable, which means that we are
6128 not creating a program header, and that the actual order of
6129 the sections in the file is unimportant. */
6130 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
6132 Elf_Internal_Shdr *hdr;
6135 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
6136 && hdr->bfd_section == NULL)
6137 || (hdr->bfd_section != NULL
6138 && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
6139 /* Compress DWARF debug sections. */
6140 || i == elf_onesymtab (abfd)
6141 || (elf_symtab_shndx_list (abfd) != NULL
6142 && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
6143 || i == elf_strtab_sec (abfd)
6144 || i == elf_shstrtab_sec (abfd))
6146 hdr->sh_offset = -1;
6149 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
6152 elf_next_file_pos (abfd) = off;
6158 /* Assign file positions for the loaded sections based on the
6159 assignment of sections to segments. */
6160 if (!assign_file_positions_for_load_sections (abfd, link_info))
6163 /* And for non-load sections. */
6164 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
6167 if (bed->elf_backend_modify_program_headers != NULL)
6169 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
6173 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
6174 if (link_info != NULL && bfd_link_pie (link_info))
6176 unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
6177 Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
6178 Elf_Internal_Phdr *end_segment = &segment[num_segments];
6180 /* Find the lowest p_vaddr in PT_LOAD segments. */
6181 bfd_vma p_vaddr = (bfd_vma) -1;
6182 for (; segment < end_segment; segment++)
6183 if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
6184 p_vaddr = segment->p_vaddr;
6186 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6187 segments is non-zero. */
6189 i_ehdrp->e_type = ET_EXEC;
6192 /* Write out the program headers. */
6193 alloc = elf_elfheader (abfd)->e_phnum;
6197 /* PR ld/20815 - Check that the program header segment, if present, will
6198 be loaded into memory. FIXME: The check below is not sufficient as
6199 really all PT_LOAD segments should be checked before issuing an error
6200 message. Plus the PHDR segment does not have to be the first segment
6201 in the program header table. But this version of the check should
6202 catch all real world use cases.
6204 FIXME: We used to have code here to sort the PT_LOAD segments into
6205 ascending order, as per the ELF spec. But this breaks some programs,
6206 including the Linux kernel. But really either the spec should be
6207 changed or the programs updated. */
6209 && tdata->phdr[0].p_type == PT_PHDR
6210 && (bed->elf_backend_allow_non_load_phdr == NULL
6211 || !bed->elf_backend_allow_non_load_phdr (abfd, tdata->phdr,
6213 && tdata->phdr[1].p_type == PT_LOAD
6214 && (tdata->phdr[1].p_vaddr > tdata->phdr[0].p_vaddr
6215 || (tdata->phdr[1].p_vaddr + tdata->phdr[1].p_memsz
6216 < tdata->phdr[0].p_vaddr + tdata->phdr[0].p_memsz)))
6218 /* The fix for this error is usually to edit the linker script being
6219 used and set up the program headers manually. Either that or
6220 leave room for the headers at the start of the SECTIONS. */
6221 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
6222 " by LOAD segment"),
6227 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
6228 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
6236 prep_headers (bfd *abfd)
6238 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
6239 struct elf_strtab_hash *shstrtab;
6240 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6242 i_ehdrp = elf_elfheader (abfd);
6244 shstrtab = _bfd_elf_strtab_init ();
6245 if (shstrtab == NULL)
6248 elf_shstrtab (abfd) = shstrtab;
6250 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
6251 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
6252 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
6253 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
6255 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
6256 i_ehdrp->e_ident[EI_DATA] =
6257 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
6258 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
6260 if ((abfd->flags & DYNAMIC) != 0)
6261 i_ehdrp->e_type = ET_DYN;
6262 else if ((abfd->flags & EXEC_P) != 0)
6263 i_ehdrp->e_type = ET_EXEC;
6264 else if (bfd_get_format (abfd) == bfd_core)
6265 i_ehdrp->e_type = ET_CORE;
6267 i_ehdrp->e_type = ET_REL;
6269 switch (bfd_get_arch (abfd))
6271 case bfd_arch_unknown:
6272 i_ehdrp->e_machine = EM_NONE;
6275 /* There used to be a long list of cases here, each one setting
6276 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6277 in the corresponding bfd definition. To avoid duplication,
6278 the switch was removed. Machines that need special handling
6279 can generally do it in elf_backend_final_write_processing(),
6280 unless they need the information earlier than the final write.
6281 Such need can generally be supplied by replacing the tests for
6282 e_machine with the conditions used to determine it. */
6284 i_ehdrp->e_machine = bed->elf_machine_code;
6287 i_ehdrp->e_version = bed->s->ev_current;
6288 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
6290 /* No program header, for now. */
6291 i_ehdrp->e_phoff = 0;
6292 i_ehdrp->e_phentsize = 0;
6293 i_ehdrp->e_phnum = 0;
6295 /* Each bfd section is section header entry. */
6296 i_ehdrp->e_entry = bfd_get_start_address (abfd);
6297 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
6299 /* If we're building an executable, we'll need a program header table. */
6300 if (abfd->flags & EXEC_P)
6301 /* It all happens later. */
6305 i_ehdrp->e_phentsize = 0;
6306 i_ehdrp->e_phoff = 0;
6309 elf_tdata (abfd)->symtab_hdr.sh_name =
6310 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
6311 elf_tdata (abfd)->strtab_hdr.sh_name =
6312 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
6313 elf_tdata (abfd)->shstrtab_hdr.sh_name =
6314 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
6315 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
6316 || elf_tdata (abfd)->strtab_hdr.sh_name == (unsigned int) -1
6317 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
6323 /* Assign file positions for all the reloc sections which are not part
6324 of the loadable file image, and the file position of section headers. */
6327 _bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
6330 Elf_Internal_Shdr **shdrpp, **end_shdrpp;
6331 Elf_Internal_Shdr *shdrp;
6332 Elf_Internal_Ehdr *i_ehdrp;
6333 const struct elf_backend_data *bed;
6335 off = elf_next_file_pos (abfd);
6337 shdrpp = elf_elfsections (abfd);
6338 end_shdrpp = shdrpp + elf_numsections (abfd);
6339 for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
6342 if (shdrp->sh_offset == -1)
6344 asection *sec = shdrp->bfd_section;
6345 bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
6346 || shdrp->sh_type == SHT_RELA);
6348 || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
6352 const char *name = sec->name;
6353 struct bfd_elf_section_data *d;
6355 /* Compress DWARF debug sections. */
6356 if (!bfd_compress_section (abfd, sec,
6360 if (sec->compress_status == COMPRESS_SECTION_DONE
6361 && (abfd->flags & BFD_COMPRESS_GABI) == 0)
6363 /* If section is compressed with zlib-gnu, convert
6364 section name from .debug_* to .zdebug_*. */
6366 = convert_debug_to_zdebug (abfd, name);
6367 if (new_name == NULL)
6371 /* Add section name to section name section. */
6372 if (shdrp->sh_name != (unsigned int) -1)
6375 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
6377 d = elf_section_data (sec);
6379 /* Add reloc section name to section name section. */
6381 && !_bfd_elf_set_reloc_sh_name (abfd,
6386 && !_bfd_elf_set_reloc_sh_name (abfd,
6391 /* Update section size and contents. */
6392 shdrp->sh_size = sec->size;
6393 shdrp->contents = sec->contents;
6394 shdrp->bfd_section->contents = NULL;
6396 off = _bfd_elf_assign_file_position_for_section (shdrp,
6403 /* Place section name section after DWARF debug sections have been
6405 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
6406 shdrp = &elf_tdata (abfd)->shstrtab_hdr;
6407 shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
6408 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
6410 /* Place the section headers. */
6411 i_ehdrp = elf_elfheader (abfd);
6412 bed = get_elf_backend_data (abfd);
6413 off = align_file_position (off, 1 << bed->s->log_file_align);
6414 i_ehdrp->e_shoff = off;
6415 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
6416 elf_next_file_pos (abfd) = off;
6422 _bfd_elf_write_object_contents (bfd *abfd)
6424 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6425 Elf_Internal_Shdr **i_shdrp;
6427 unsigned int count, num_sec;
6428 struct elf_obj_tdata *t;
6430 if (! abfd->output_has_begun
6431 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6433 /* Do not rewrite ELF data when the BFD has been opened for update.
6434 abfd->output_has_begun was set to TRUE on opening, so creation of new
6435 sections, and modification of existing section sizes was restricted.
6436 This means the ELF header, program headers and section headers can't have
6438 If the contents of any sections has been modified, then those changes have
6439 already been written to the BFD. */
6440 else if (abfd->direction == both_direction)
6442 BFD_ASSERT (abfd->output_has_begun);
6446 i_shdrp = elf_elfsections (abfd);
6449 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
6453 if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
6456 /* After writing the headers, we need to write the sections too... */
6457 num_sec = elf_numsections (abfd);
6458 for (count = 1; count < num_sec; count++)
6460 i_shdrp[count]->sh_name
6461 = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
6462 i_shdrp[count]->sh_name);
6463 if (bed->elf_backend_section_processing)
6464 if (!(*bed->elf_backend_section_processing) (abfd, i_shdrp[count]))
6466 if (i_shdrp[count]->contents)
6468 bfd_size_type amt = i_shdrp[count]->sh_size;
6470 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
6471 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
6476 /* Write out the section header names. */
6477 t = elf_tdata (abfd);
6478 if (elf_shstrtab (abfd) != NULL
6479 && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
6480 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
6483 if (bed->elf_backend_final_write_processing)
6484 (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
6486 if (!bed->s->write_shdrs_and_ehdr (abfd))
6489 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6490 if (t->o->build_id.after_write_object_contents != NULL)
6491 return (*t->o->build_id.after_write_object_contents) (abfd);
6497 _bfd_elf_write_corefile_contents (bfd *abfd)
6499 /* Hopefully this can be done just like an object file. */
6500 return _bfd_elf_write_object_contents (abfd);
6503 /* Given a section, search the header to find them. */
6506 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
6508 const struct elf_backend_data *bed;
6509 unsigned int sec_index;
6511 if (elf_section_data (asect) != NULL
6512 && elf_section_data (asect)->this_idx != 0)
6513 return elf_section_data (asect)->this_idx;
6515 if (bfd_is_abs_section (asect))
6516 sec_index = SHN_ABS;
6517 else if (bfd_is_com_section (asect))
6518 sec_index = SHN_COMMON;
6519 else if (bfd_is_und_section (asect))
6520 sec_index = SHN_UNDEF;
6522 sec_index = SHN_BAD;
6524 bed = get_elf_backend_data (abfd);
6525 if (bed->elf_backend_section_from_bfd_section)
6527 int retval = sec_index;
6529 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
6533 if (sec_index == SHN_BAD)
6534 bfd_set_error (bfd_error_nonrepresentable_section);
6539 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6543 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
6545 asymbol *asym_ptr = *asym_ptr_ptr;
6547 flagword flags = asym_ptr->flags;
6549 /* When gas creates relocations against local labels, it creates its
6550 own symbol for the section, but does put the symbol into the
6551 symbol chain, so udata is 0. When the linker is generating
6552 relocatable output, this section symbol may be for one of the
6553 input sections rather than the output section. */
6554 if (asym_ptr->udata.i == 0
6555 && (flags & BSF_SECTION_SYM)
6556 && asym_ptr->section)
6561 sec = asym_ptr->section;
6562 if (sec->owner != abfd && sec->output_section != NULL)
6563 sec = sec->output_section;
6564 if (sec->owner == abfd
6565 && (indx = sec->index) < elf_num_section_syms (abfd)
6566 && elf_section_syms (abfd)[indx] != NULL)
6567 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
6570 idx = asym_ptr->udata.i;
6574 /* This case can occur when using --strip-symbol on a symbol
6575 which is used in a relocation entry. */
6577 /* xgettext:c-format */
6578 (_("%pB: symbol `%s' required but not present"),
6579 abfd, bfd_asymbol_name (asym_ptr));
6580 bfd_set_error (bfd_error_no_symbols);
6587 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6588 (long) asym_ptr, asym_ptr->name, idx, flags);
6596 /* Rewrite program header information. */
6599 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
6601 Elf_Internal_Ehdr *iehdr;
6602 struct elf_segment_map *map;
6603 struct elf_segment_map *map_first;
6604 struct elf_segment_map **pointer_to_map;
6605 Elf_Internal_Phdr *segment;
6608 unsigned int num_segments;
6609 bfd_boolean phdr_included = FALSE;
6610 bfd_boolean p_paddr_valid;
6611 bfd_vma maxpagesize;
6612 struct elf_segment_map *phdr_adjust_seg = NULL;
6613 unsigned int phdr_adjust_num = 0;
6614 const struct elf_backend_data *bed;
6616 bed = get_elf_backend_data (ibfd);
6617 iehdr = elf_elfheader (ibfd);
6620 pointer_to_map = &map_first;
6622 num_segments = elf_elfheader (ibfd)->e_phnum;
6623 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
6625 /* Returns the end address of the segment + 1. */
6626 #define SEGMENT_END(segment, start) \
6627 (start + (segment->p_memsz > segment->p_filesz \
6628 ? segment->p_memsz : segment->p_filesz))
6630 #define SECTION_SIZE(section, segment) \
6631 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6632 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6633 ? section->size : 0)
6635 /* Returns TRUE if the given section is contained within
6636 the given segment. VMA addresses are compared. */
6637 #define IS_CONTAINED_BY_VMA(section, segment) \
6638 (section->vma >= segment->p_vaddr \
6639 && (section->vma + SECTION_SIZE (section, segment) \
6640 <= (SEGMENT_END (segment, segment->p_vaddr))))
6642 /* Returns TRUE if the given section is contained within
6643 the given segment. LMA addresses are compared. */
6644 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6645 (section->lma >= base \
6646 && (section->lma + SECTION_SIZE (section, segment) \
6647 <= SEGMENT_END (segment, base)))
6649 /* Handle PT_NOTE segment. */
6650 #define IS_NOTE(p, s) \
6651 (p->p_type == PT_NOTE \
6652 && elf_section_type (s) == SHT_NOTE \
6653 && (bfd_vma) s->filepos >= p->p_offset \
6654 && ((bfd_vma) s->filepos + s->size \
6655 <= p->p_offset + p->p_filesz))
6657 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6659 #define IS_COREFILE_NOTE(p, s) \
6661 && bfd_get_format (ibfd) == bfd_core \
6665 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6666 linker, which generates a PT_INTERP section with p_vaddr and
6667 p_memsz set to 0. */
6668 #define IS_SOLARIS_PT_INTERP(p, s) \
6670 && p->p_paddr == 0 \
6671 && p->p_memsz == 0 \
6672 && p->p_filesz > 0 \
6673 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6675 && (bfd_vma) s->filepos >= p->p_offset \
6676 && ((bfd_vma) s->filepos + s->size \
6677 <= p->p_offset + p->p_filesz))
6679 /* Decide if the given section should be included in the given segment.
6680 A section will be included if:
6681 1. It is within the address space of the segment -- we use the LMA
6682 if that is set for the segment and the VMA otherwise,
6683 2. It is an allocated section or a NOTE section in a PT_NOTE
6685 3. There is an output section associated with it,
6686 4. The section has not already been allocated to a previous segment.
6687 5. PT_GNU_STACK segments do not include any sections.
6688 6. PT_TLS segment includes only SHF_TLS sections.
6689 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6690 8. PT_DYNAMIC should not contain empty sections at the beginning
6691 (with the possible exception of .dynamic). */
6692 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6693 ((((segment->p_paddr \
6694 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6695 : IS_CONTAINED_BY_VMA (section, segment)) \
6696 && (section->flags & SEC_ALLOC) != 0) \
6697 || IS_NOTE (segment, section)) \
6698 && segment->p_type != PT_GNU_STACK \
6699 && (segment->p_type != PT_TLS \
6700 || (section->flags & SEC_THREAD_LOCAL)) \
6701 && (segment->p_type == PT_LOAD \
6702 || segment->p_type == PT_TLS \
6703 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6704 && (segment->p_type != PT_DYNAMIC \
6705 || SECTION_SIZE (section, segment) > 0 \
6706 || (segment->p_paddr \
6707 ? segment->p_paddr != section->lma \
6708 : segment->p_vaddr != section->vma) \
6709 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6711 && (segment->p_type != PT_LOAD || !section->segment_mark))
6713 /* If the output section of a section in the input segment is NULL,
6714 it is removed from the corresponding output segment. */
6715 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6716 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6717 && section->output_section != NULL)
6719 /* Returns TRUE iff seg1 starts after the end of seg2. */
6720 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6721 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6723 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6724 their VMA address ranges and their LMA address ranges overlap.
6725 It is possible to have overlapping VMA ranges without overlapping LMA
6726 ranges. RedBoot images for example can have both .data and .bss mapped
6727 to the same VMA range, but with the .data section mapped to a different
6729 #define SEGMENT_OVERLAPS(seg1, seg2) \
6730 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6731 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6732 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6733 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6735 /* Initialise the segment mark field. */
6736 for (section = ibfd->sections; section != NULL; section = section->next)
6737 section->segment_mark = FALSE;
6739 /* The Solaris linker creates program headers in which all the
6740 p_paddr fields are zero. When we try to objcopy or strip such a
6741 file, we get confused. Check for this case, and if we find it
6742 don't set the p_paddr_valid fields. */
6743 p_paddr_valid = FALSE;
6744 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6747 if (segment->p_paddr != 0)
6749 p_paddr_valid = TRUE;
6753 /* Scan through the segments specified in the program header
6754 of the input BFD. For this first scan we look for overlaps
6755 in the loadable segments. These can be created by weird
6756 parameters to objcopy. Also, fix some solaris weirdness. */
6757 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6762 Elf_Internal_Phdr *segment2;
6764 if (segment->p_type == PT_INTERP)
6765 for (section = ibfd->sections; section; section = section->next)
6766 if (IS_SOLARIS_PT_INTERP (segment, section))
6768 /* Mininal change so that the normal section to segment
6769 assignment code will work. */
6770 segment->p_vaddr = section->vma;
6774 if (segment->p_type != PT_LOAD)
6776 /* Remove PT_GNU_RELRO segment. */
6777 if (segment->p_type == PT_GNU_RELRO)
6778 segment->p_type = PT_NULL;
6782 /* Determine if this segment overlaps any previous segments. */
6783 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
6785 bfd_signed_vma extra_length;
6787 if (segment2->p_type != PT_LOAD
6788 || !SEGMENT_OVERLAPS (segment, segment2))
6791 /* Merge the two segments together. */
6792 if (segment2->p_vaddr < segment->p_vaddr)
6794 /* Extend SEGMENT2 to include SEGMENT and then delete
6796 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
6797 - SEGMENT_END (segment2, segment2->p_vaddr));
6799 if (extra_length > 0)
6801 segment2->p_memsz += extra_length;
6802 segment2->p_filesz += extra_length;
6805 segment->p_type = PT_NULL;
6807 /* Since we have deleted P we must restart the outer loop. */
6809 segment = elf_tdata (ibfd)->phdr;
6814 /* Extend SEGMENT to include SEGMENT2 and then delete
6816 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
6817 - SEGMENT_END (segment, segment->p_vaddr));
6819 if (extra_length > 0)
6821 segment->p_memsz += extra_length;
6822 segment->p_filesz += extra_length;
6825 segment2->p_type = PT_NULL;
6830 /* The second scan attempts to assign sections to segments. */
6831 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6835 unsigned int section_count;
6836 asection **sections;
6837 asection *output_section;
6839 asection *matching_lma;
6840 asection *suggested_lma;
6843 asection *first_section;
6845 if (segment->p_type == PT_NULL)
6848 first_section = NULL;
6849 /* Compute how many sections might be placed into this segment. */
6850 for (section = ibfd->sections, section_count = 0;
6852 section = section->next)
6854 /* Find the first section in the input segment, which may be
6855 removed from the corresponding output segment. */
6856 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6858 if (first_section == NULL)
6859 first_section = section;
6860 if (section->output_section != NULL)
6865 /* Allocate a segment map big enough to contain
6866 all of the sections we have selected. */
6867 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
6868 amt += (bfd_size_type) section_count * sizeof (asection *);
6869 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6873 /* Initialise the fields of the segment map. Default to
6874 using the physical address of the segment in the input BFD. */
6876 map->p_type = segment->p_type;
6877 map->p_flags = segment->p_flags;
6878 map->p_flags_valid = 1;
6880 /* If the first section in the input segment is removed, there is
6881 no need to preserve segment physical address in the corresponding
6883 if (!first_section || first_section->output_section != NULL)
6885 map->p_paddr = segment->p_paddr;
6886 map->p_paddr_valid = p_paddr_valid;
6889 /* Determine if this segment contains the ELF file header
6890 and if it contains the program headers themselves. */
6891 map->includes_filehdr = (segment->p_offset == 0
6892 && segment->p_filesz >= iehdr->e_ehsize);
6893 map->includes_phdrs = 0;
6895 if (!phdr_included || segment->p_type != PT_LOAD)
6897 map->includes_phdrs =
6898 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6899 && (segment->p_offset + segment->p_filesz
6900 >= ((bfd_vma) iehdr->e_phoff
6901 + iehdr->e_phnum * iehdr->e_phentsize)));
6903 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6904 phdr_included = TRUE;
6907 if (section_count == 0)
6909 /* Special segments, such as the PT_PHDR segment, may contain
6910 no sections, but ordinary, loadable segments should contain
6911 something. They are allowed by the ELF spec however, so only
6912 a warning is produced.
6913 There is however the valid use case of embedded systems which
6914 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6915 flash memory with zeros. No warning is shown for that case. */
6916 if (segment->p_type == PT_LOAD
6917 && (segment->p_filesz > 0 || segment->p_memsz == 0))
6918 /* xgettext:c-format */
6920 (_("%pB: warning: empty loadable segment detected"
6921 " at vaddr=%#" PRIx64 ", is this intentional?"),
6922 ibfd, (uint64_t) segment->p_vaddr);
6924 map->p_vaddr_offset = segment->p_vaddr;
6926 *pointer_to_map = map;
6927 pointer_to_map = &map->next;
6932 /* Now scan the sections in the input BFD again and attempt
6933 to add their corresponding output sections to the segment map.
6934 The problem here is how to handle an output section which has
6935 been moved (ie had its LMA changed). There are four possibilities:
6937 1. None of the sections have been moved.
6938 In this case we can continue to use the segment LMA from the
6941 2. All of the sections have been moved by the same amount.
6942 In this case we can change the segment's LMA to match the LMA
6943 of the first section.
6945 3. Some of the sections have been moved, others have not.
6946 In this case those sections which have not been moved can be
6947 placed in the current segment which will have to have its size,
6948 and possibly its LMA changed, and a new segment or segments will
6949 have to be created to contain the other sections.
6951 4. The sections have been moved, but not by the same amount.
6952 In this case we can change the segment's LMA to match the LMA
6953 of the first section and we will have to create a new segment
6954 or segments to contain the other sections.
6956 In order to save time, we allocate an array to hold the section
6957 pointers that we are interested in. As these sections get assigned
6958 to a segment, they are removed from this array. */
6960 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
6961 if (sections == NULL)
6964 /* Step One: Scan for segment vs section LMA conflicts.
6965 Also add the sections to the section array allocated above.
6966 Also add the sections to the current segment. In the common
6967 case, where the sections have not been moved, this means that
6968 we have completely filled the segment, and there is nothing
6971 matching_lma = NULL;
6972 suggested_lma = NULL;
6974 for (section = first_section, j = 0;
6976 section = section->next)
6978 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
6980 output_section = section->output_section;
6982 sections[j++] = section;
6984 /* The Solaris native linker always sets p_paddr to 0.
6985 We try to catch that case here, and set it to the
6986 correct value. Note - some backends require that
6987 p_paddr be left as zero. */
6989 && segment->p_vaddr != 0
6990 && !bed->want_p_paddr_set_to_zero
6992 && output_section->lma != 0
6993 && (align_power (segment->p_vaddr
6994 + (map->includes_filehdr
6995 ? iehdr->e_ehsize : 0)
6996 + (map->includes_phdrs
6997 ? iehdr->e_phnum * iehdr->e_phentsize
6999 output_section->alignment_power)
7000 == output_section->vma))
7001 map->p_paddr = segment->p_vaddr;
7003 /* Match up the physical address of the segment with the
7004 LMA address of the output section. */
7005 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7006 || IS_COREFILE_NOTE (segment, section)
7007 || (bed->want_p_paddr_set_to_zero
7008 && IS_CONTAINED_BY_VMA (output_section, segment)))
7010 if (matching_lma == NULL
7011 || output_section->lma < matching_lma->lma)
7012 matching_lma = output_section;
7014 /* We assume that if the section fits within the segment
7015 then it does not overlap any other section within that
7017 map->sections[isec++] = output_section;
7019 else if (suggested_lma == NULL)
7020 suggested_lma = output_section;
7022 if (j == section_count)
7027 BFD_ASSERT (j == section_count);
7029 /* Step Two: Adjust the physical address of the current segment,
7031 if (isec == section_count)
7033 /* All of the sections fitted within the segment as currently
7034 specified. This is the default case. Add the segment to
7035 the list of built segments and carry on to process the next
7036 program header in the input BFD. */
7037 map->count = section_count;
7038 *pointer_to_map = map;
7039 pointer_to_map = &map->next;
7042 && !bed->want_p_paddr_set_to_zero
7043 && matching_lma->lma != map->p_paddr
7044 && !map->includes_filehdr
7045 && !map->includes_phdrs)
7046 /* There is some padding before the first section in the
7047 segment. So, we must account for that in the output
7049 map->p_vaddr_offset = map->p_paddr - matching_lma->lma;
7056 /* Change the current segment's physical address to match
7057 the LMA of the first section that fitted, or if no
7058 section fitted, the first section. */
7059 if (matching_lma == NULL)
7060 matching_lma = suggested_lma;
7062 map->p_paddr = matching_lma->lma;
7064 /* Offset the segment physical address from the lma
7065 to allow for space taken up by elf headers. */
7066 if (map->includes_phdrs)
7068 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
7070 /* iehdr->e_phnum is just an estimate of the number
7071 of program headers that we will need. Make a note
7072 here of the number we used and the segment we chose
7073 to hold these headers, so that we can adjust the
7074 offset when we know the correct value. */
7075 phdr_adjust_num = iehdr->e_phnum;
7076 phdr_adjust_seg = map;
7079 if (map->includes_filehdr)
7081 bfd_vma align = (bfd_vma) 1 << matching_lma->alignment_power;
7082 map->p_paddr -= iehdr->e_ehsize;
7083 /* We've subtracted off the size of headers from the
7084 first section lma, but there may have been some
7085 alignment padding before that section too. Try to
7086 account for that by adjusting the segment lma down to
7087 the same alignment. */
7088 if (segment->p_align != 0 && segment->p_align < align)
7089 align = segment->p_align;
7090 map->p_paddr &= -align;
7094 /* Step Three: Loop over the sections again, this time assigning
7095 those that fit to the current segment and removing them from the
7096 sections array; but making sure not to leave large gaps. Once all
7097 possible sections have been assigned to the current segment it is
7098 added to the list of built segments and if sections still remain
7099 to be assigned, a new segment is constructed before repeating
7105 suggested_lma = NULL;
7107 /* Fill the current segment with sections that fit. */
7108 for (j = 0; j < section_count; j++)
7110 section = sections[j];
7112 if (section == NULL)
7115 output_section = section->output_section;
7117 BFD_ASSERT (output_section != NULL);
7119 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
7120 || IS_COREFILE_NOTE (segment, section))
7122 if (map->count == 0)
7124 /* If the first section in a segment does not start at
7125 the beginning of the segment, then something is
7127 if (align_power (map->p_paddr
7128 + (map->includes_filehdr
7129 ? iehdr->e_ehsize : 0)
7130 + (map->includes_phdrs
7131 ? iehdr->e_phnum * iehdr->e_phentsize
7133 output_section->alignment_power)
7134 != output_section->lma)
7141 prev_sec = map->sections[map->count - 1];
7143 /* If the gap between the end of the previous section
7144 and the start of this section is more than
7145 maxpagesize then we need to start a new segment. */
7146 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
7148 < BFD_ALIGN (output_section->lma, maxpagesize))
7149 || (prev_sec->lma + prev_sec->size
7150 > output_section->lma))
7152 if (suggested_lma == NULL)
7153 suggested_lma = output_section;
7159 map->sections[map->count++] = output_section;
7162 if (segment->p_type == PT_LOAD)
7163 section->segment_mark = TRUE;
7165 else if (suggested_lma == NULL)
7166 suggested_lma = output_section;
7169 BFD_ASSERT (map->count > 0);
7171 /* Add the current segment to the list of built segments. */
7172 *pointer_to_map = map;
7173 pointer_to_map = &map->next;
7175 if (isec < section_count)
7177 /* We still have not allocated all of the sections to
7178 segments. Create a new segment here, initialise it
7179 and carry on looping. */
7180 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7181 amt += (bfd_size_type) section_count * sizeof (asection *);
7182 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7189 /* Initialise the fields of the segment map. Set the physical
7190 physical address to the LMA of the first section that has
7191 not yet been assigned. */
7193 map->p_type = segment->p_type;
7194 map->p_flags = segment->p_flags;
7195 map->p_flags_valid = 1;
7196 map->p_paddr = suggested_lma->lma;
7197 map->p_paddr_valid = p_paddr_valid;
7198 map->includes_filehdr = 0;
7199 map->includes_phdrs = 0;
7202 while (isec < section_count);
7207 elf_seg_map (obfd) = map_first;
7209 /* If we had to estimate the number of program headers that were
7210 going to be needed, then check our estimate now and adjust
7211 the offset if necessary. */
7212 if (phdr_adjust_seg != NULL)
7216 for (count = 0, map = map_first; map != NULL; map = map->next)
7219 if (count > phdr_adjust_num)
7220 phdr_adjust_seg->p_paddr
7221 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
7223 for (map = map_first; map != NULL; map = map->next)
7224 if (map->p_type == PT_PHDR)
7227 = phdr_adjust_seg->includes_filehdr ? iehdr->e_ehsize : 0;
7228 map->p_paddr = phdr_adjust_seg->p_paddr + adjust;
7235 #undef IS_CONTAINED_BY_VMA
7236 #undef IS_CONTAINED_BY_LMA
7238 #undef IS_COREFILE_NOTE
7239 #undef IS_SOLARIS_PT_INTERP
7240 #undef IS_SECTION_IN_INPUT_SEGMENT
7241 #undef INCLUDE_SECTION_IN_SEGMENT
7242 #undef SEGMENT_AFTER_SEGMENT
7243 #undef SEGMENT_OVERLAPS
7247 /* Copy ELF program header information. */
7250 copy_elf_program_header (bfd *ibfd, bfd *obfd)
7252 Elf_Internal_Ehdr *iehdr;
7253 struct elf_segment_map *map;
7254 struct elf_segment_map *map_first;
7255 struct elf_segment_map **pointer_to_map;
7256 Elf_Internal_Phdr *segment;
7258 unsigned int num_segments;
7259 bfd_boolean phdr_included = FALSE;
7260 bfd_boolean p_paddr_valid;
7262 iehdr = elf_elfheader (ibfd);
7265 pointer_to_map = &map_first;
7267 /* If all the segment p_paddr fields are zero, don't set
7268 map->p_paddr_valid. */
7269 p_paddr_valid = FALSE;
7270 num_segments = elf_elfheader (ibfd)->e_phnum;
7271 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7274 if (segment->p_paddr != 0)
7276 p_paddr_valid = TRUE;
7280 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7285 unsigned int section_count;
7287 Elf_Internal_Shdr *this_hdr;
7288 asection *first_section = NULL;
7289 asection *lowest_section;
7290 bfd_boolean no_contents = TRUE;
7292 /* Compute how many sections are in this segment. */
7293 for (section = ibfd->sections, section_count = 0;
7295 section = section->next)
7297 this_hdr = &(elf_section_data(section)->this_hdr);
7298 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7300 if (first_section == NULL)
7301 first_section = section;
7302 if (elf_section_type (section) != SHT_NOBITS)
7303 no_contents = FALSE;
7308 /* Allocate a segment map big enough to contain
7309 all of the sections we have selected. */
7310 amt = sizeof (struct elf_segment_map) - sizeof (asection *);
7311 amt += (bfd_size_type) section_count * sizeof (asection *);
7312 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
7316 /* Initialize the fields of the output segment map with the
7319 map->p_type = segment->p_type;
7320 map->p_flags = segment->p_flags;
7321 map->p_flags_valid = 1;
7322 map->p_paddr = segment->p_paddr;
7323 map->p_paddr_valid = p_paddr_valid;
7324 map->p_align = segment->p_align;
7325 map->p_align_valid = 1;
7326 map->p_vaddr_offset = 0;
7328 if (map->p_type == PT_GNU_RELRO
7329 || map->p_type == PT_GNU_STACK)
7331 /* The PT_GNU_RELRO segment may contain the first a few
7332 bytes in the .got.plt section even if the whole .got.plt
7333 section isn't in the PT_GNU_RELRO segment. We won't
7334 change the size of the PT_GNU_RELRO segment.
7335 Similarly, PT_GNU_STACK size is significant on uclinux
7337 map->p_size = segment->p_memsz;
7338 map->p_size_valid = 1;
7341 /* Determine if this segment contains the ELF file header
7342 and if it contains the program headers themselves. */
7343 map->includes_filehdr = (segment->p_offset == 0
7344 && segment->p_filesz >= iehdr->e_ehsize);
7346 map->includes_phdrs = 0;
7347 if (! phdr_included || segment->p_type != PT_LOAD)
7349 map->includes_phdrs =
7350 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
7351 && (segment->p_offset + segment->p_filesz
7352 >= ((bfd_vma) iehdr->e_phoff
7353 + iehdr->e_phnum * iehdr->e_phentsize)));
7355 if (segment->p_type == PT_LOAD && map->includes_phdrs)
7356 phdr_included = TRUE;
7359 lowest_section = NULL;
7360 if (section_count != 0)
7362 unsigned int isec = 0;
7364 for (section = first_section;
7366 section = section->next)
7368 this_hdr = &(elf_section_data(section)->this_hdr);
7369 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7371 map->sections[isec++] = section->output_section;
7372 if ((section->flags & SEC_ALLOC) != 0)
7376 if (lowest_section == NULL
7377 || section->lma < lowest_section->lma)
7378 lowest_section = section;
7380 /* Section lmas are set up from PT_LOAD header
7381 p_paddr in _bfd_elf_make_section_from_shdr.
7382 If this header has a p_paddr that disagrees
7383 with the section lma, flag the p_paddr as
7385 if ((section->flags & SEC_LOAD) != 0)
7386 seg_off = this_hdr->sh_offset - segment->p_offset;
7388 seg_off = this_hdr->sh_addr - segment->p_vaddr;
7389 if (section->lma - segment->p_paddr != seg_off)
7390 map->p_paddr_valid = FALSE;
7392 if (isec == section_count)
7398 if (map->includes_filehdr && lowest_section != NULL)
7400 /* Try to keep the space used by the headers plus any
7401 padding fixed. If there are sections with file contents
7402 in this segment then the lowest sh_offset is the best
7403 guess. Otherwise the segment only has file contents for
7404 the headers, and p_filesz is the best guess. */
7406 map->header_size = segment->p_filesz;
7408 map->header_size = lowest_section->filepos;
7411 if (section_count == 0)
7412 map->p_vaddr_offset = segment->p_vaddr;
7413 else if (!map->includes_phdrs
7414 && !map->includes_filehdr
7415 && map->p_paddr_valid)
7416 /* Account for padding before the first section. */
7417 map->p_vaddr_offset = (segment->p_paddr
7418 - (lowest_section ? lowest_section->lma : 0));
7420 map->count = section_count;
7421 *pointer_to_map = map;
7422 pointer_to_map = &map->next;
7425 elf_seg_map (obfd) = map_first;
7429 /* Copy private BFD data. This copies or rewrites ELF program header
7433 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7435 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7436 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7439 if (elf_tdata (ibfd)->phdr == NULL)
7442 if (ibfd->xvec == obfd->xvec)
7444 /* Check to see if any sections in the input BFD
7445 covered by ELF program header have changed. */
7446 Elf_Internal_Phdr *segment;
7447 asection *section, *osec;
7448 unsigned int i, num_segments;
7449 Elf_Internal_Shdr *this_hdr;
7450 const struct elf_backend_data *bed;
7452 bed = get_elf_backend_data (ibfd);
7454 /* Regenerate the segment map if p_paddr is set to 0. */
7455 if (bed->want_p_paddr_set_to_zero)
7458 /* Initialize the segment mark field. */
7459 for (section = obfd->sections; section != NULL;
7460 section = section->next)
7461 section->segment_mark = FALSE;
7463 num_segments = elf_elfheader (ibfd)->e_phnum;
7464 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7468 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7469 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7470 which severly confuses things, so always regenerate the segment
7471 map in this case. */
7472 if (segment->p_paddr == 0
7473 && segment->p_memsz == 0
7474 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
7477 for (section = ibfd->sections;
7478 section != NULL; section = section->next)
7480 /* We mark the output section so that we know it comes
7481 from the input BFD. */
7482 osec = section->output_section;
7484 osec->segment_mark = TRUE;
7486 /* Check if this section is covered by the segment. */
7487 this_hdr = &(elf_section_data(section)->this_hdr);
7488 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7490 /* FIXME: Check if its output section is changed or
7491 removed. What else do we need to check? */
7493 || section->flags != osec->flags
7494 || section->lma != osec->lma
7495 || section->vma != osec->vma
7496 || section->size != osec->size
7497 || section->rawsize != osec->rawsize
7498 || section->alignment_power != osec->alignment_power)
7504 /* Check to see if any output section do not come from the
7506 for (section = obfd->sections; section != NULL;
7507 section = section->next)
7509 if (!section->segment_mark)
7512 section->segment_mark = FALSE;
7515 return copy_elf_program_header (ibfd, obfd);
7519 if (ibfd->xvec == obfd->xvec)
7521 /* When rewriting program header, set the output maxpagesize to
7522 the maximum alignment of input PT_LOAD segments. */
7523 Elf_Internal_Phdr *segment;
7525 unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7526 bfd_vma maxpagesize = 0;
7528 for (i = 0, segment = elf_tdata (ibfd)->phdr;
7531 if (segment->p_type == PT_LOAD
7532 && maxpagesize < segment->p_align)
7534 /* PR 17512: file: f17299af. */
7535 if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
7536 /* xgettext:c-format */
7537 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7538 PRIx64 " is too large"),
7539 ibfd, (uint64_t) segment->p_align);
7541 maxpagesize = segment->p_align;
7544 if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7545 bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7548 return rewrite_elf_program_header (ibfd, obfd);
7551 /* Initialize private output section information from input section. */
7554 _bfd_elf_init_private_section_data (bfd *ibfd,
7558 struct bfd_link_info *link_info)
7561 Elf_Internal_Shdr *ihdr, *ohdr;
7562 bfd_boolean final_link = (link_info != NULL
7563 && !bfd_link_relocatable (link_info));
7565 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7566 || obfd->xvec->flavour != bfd_target_elf_flavour)
7569 BFD_ASSERT (elf_section_data (osec) != NULL);
7571 /* For objcopy and relocatable link, don't copy the output ELF
7572 section type from input if the output BFD section flags have been
7573 set to something different. For a final link allow some flags
7574 that the linker clears to differ. */
7575 if (elf_section_type (osec) == SHT_NULL
7576 && (osec->flags == isec->flags
7578 && ((osec->flags ^ isec->flags)
7579 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
7580 elf_section_type (osec) = elf_section_type (isec);
7582 /* FIXME: Is this correct for all OS/PROC specific flags? */
7583 elf_section_flags (osec) |= (elf_section_flags (isec)
7584 & (SHF_MASKOS | SHF_MASKPROC));
7586 /* Copy sh_info from input for mbind section. */
7587 if (elf_section_flags (isec) & SHF_GNU_MBIND)
7588 elf_section_data (osec)->this_hdr.sh_info
7589 = elf_section_data (isec)->this_hdr.sh_info;
7591 /* Set things up for objcopy and relocatable link. The output
7592 SHT_GROUP section will have its elf_next_in_group pointing back
7593 to the input group members. Ignore linker created group section.
7594 See elfNN_ia64_object_p in elfxx-ia64.c. */
7595 if ((link_info == NULL
7596 || !link_info->resolve_section_groups)
7597 && (elf_sec_group (isec) == NULL
7598 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
7600 if (elf_section_flags (isec) & SHF_GROUP)
7601 elf_section_flags (osec) |= SHF_GROUP;
7602 elf_next_in_group (osec) = elf_next_in_group (isec);
7603 elf_section_data (osec)->group = elf_section_data (isec)->group;
7606 /* If not decompress, preserve SHF_COMPRESSED. */
7607 if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
7608 elf_section_flags (osec) |= (elf_section_flags (isec)
7611 ihdr = &elf_section_data (isec)->this_hdr;
7613 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7614 don't use the output section of the linked-to section since it
7615 may be NULL at this point. */
7616 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7618 ohdr = &elf_section_data (osec)->this_hdr;
7619 ohdr->sh_flags |= SHF_LINK_ORDER;
7620 elf_linked_to_section (osec) = elf_linked_to_section (isec);
7623 osec->use_rela_p = isec->use_rela_p;
7628 /* Copy private section information. This copies over the entsize
7629 field, and sometimes the info field. */
7632 _bfd_elf_copy_private_section_data (bfd *ibfd,
7637 Elf_Internal_Shdr *ihdr, *ohdr;
7639 if (ibfd->xvec->flavour != bfd_target_elf_flavour
7640 || obfd->xvec->flavour != bfd_target_elf_flavour)
7643 ihdr = &elf_section_data (isec)->this_hdr;
7644 ohdr = &elf_section_data (osec)->this_hdr;
7646 ohdr->sh_entsize = ihdr->sh_entsize;
7648 if (ihdr->sh_type == SHT_SYMTAB
7649 || ihdr->sh_type == SHT_DYNSYM
7650 || ihdr->sh_type == SHT_GNU_verneed
7651 || ihdr->sh_type == SHT_GNU_verdef)
7652 ohdr->sh_info = ihdr->sh_info;
7654 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7658 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7659 necessary if we are removing either the SHT_GROUP section or any of
7660 the group member sections. DISCARDED is the value that a section's
7661 output_section has if the section will be discarded, NULL when this
7662 function is called from objcopy, bfd_abs_section_ptr when called
7666 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
7670 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
7671 if (elf_section_type (isec) == SHT_GROUP)
7673 asection *first = elf_next_in_group (isec);
7674 asection *s = first;
7675 bfd_size_type removed = 0;
7679 /* If this member section is being output but the
7680 SHT_GROUP section is not, then clear the group info
7681 set up by _bfd_elf_copy_private_section_data. */
7682 if (s->output_section != discarded
7683 && isec->output_section == discarded)
7685 elf_section_flags (s->output_section) &= ~SHF_GROUP;
7686 elf_group_name (s->output_section) = NULL;
7688 /* Conversely, if the member section is not being output
7689 but the SHT_GROUP section is, then adjust its size. */
7690 else if (s->output_section == discarded
7691 && isec->output_section != discarded)
7693 struct bfd_elf_section_data *elf_sec = elf_section_data (s);
7695 if (elf_sec->rel.hdr != NULL
7696 && (elf_sec->rel.hdr->sh_flags & SHF_GROUP) != 0)
7698 if (elf_sec->rela.hdr != NULL
7699 && (elf_sec->rela.hdr->sh_flags & SHF_GROUP) != 0)
7702 s = elf_next_in_group (s);
7708 if (discarded != NULL)
7710 /* If we've been called for ld -r, then we need to
7711 adjust the input section size. */
7712 if (isec->rawsize == 0)
7713 isec->rawsize = isec->size;
7714 isec->size = isec->rawsize - removed;
7715 if (isec->size <= 4)
7718 isec->flags |= SEC_EXCLUDE;
7723 /* Adjust the output section size when called from
7725 isec->output_section->size -= removed;
7726 if (isec->output_section->size <= 4)
7728 isec->output_section->size = 0;
7729 isec->output_section->flags |= SEC_EXCLUDE;
7738 /* Copy private header information. */
7741 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7743 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7744 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7747 /* Copy over private BFD data if it has not already been copied.
7748 This must be done here, rather than in the copy_private_bfd_data
7749 entry point, because the latter is called after the section
7750 contents have been set, which means that the program headers have
7751 already been worked out. */
7752 if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
7754 if (! copy_private_bfd_data (ibfd, obfd))
7758 return _bfd_elf_fixup_group_sections (ibfd, NULL);
7761 /* Copy private symbol information. If this symbol is in a section
7762 which we did not map into a BFD section, try to map the section
7763 index correctly. We use special macro definitions for the mapped
7764 section indices; these definitions are interpreted by the
7765 swap_out_syms function. */
7767 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7768 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7769 #define MAP_STRTAB (SHN_HIOS + 3)
7770 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7771 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7774 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
7779 elf_symbol_type *isym, *osym;
7781 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7782 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7785 isym = elf_symbol_from (ibfd, isymarg);
7786 osym = elf_symbol_from (obfd, osymarg);
7789 && isym->internal_elf_sym.st_shndx != 0
7791 && bfd_is_abs_section (isym->symbol.section))
7795 shndx = isym->internal_elf_sym.st_shndx;
7796 if (shndx == elf_onesymtab (ibfd))
7797 shndx = MAP_ONESYMTAB;
7798 else if (shndx == elf_dynsymtab (ibfd))
7799 shndx = MAP_DYNSYMTAB;
7800 else if (shndx == elf_strtab_sec (ibfd))
7802 else if (shndx == elf_shstrtab_sec (ibfd))
7803 shndx = MAP_SHSTRTAB;
7804 else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
7805 shndx = MAP_SYM_SHNDX;
7806 osym->internal_elf_sym.st_shndx = shndx;
7812 /* Swap out the symbols. */
7815 swap_out_syms (bfd *abfd,
7816 struct elf_strtab_hash **sttp,
7819 const struct elf_backend_data *bed;
7822 struct elf_strtab_hash *stt;
7823 Elf_Internal_Shdr *symtab_hdr;
7824 Elf_Internal_Shdr *symtab_shndx_hdr;
7825 Elf_Internal_Shdr *symstrtab_hdr;
7826 struct elf_sym_strtab *symstrtab;
7827 bfd_byte *outbound_syms;
7828 bfd_byte *outbound_shndx;
7829 unsigned long outbound_syms_index;
7830 unsigned long outbound_shndx_index;
7832 unsigned int num_locals;
7834 bfd_boolean name_local_sections;
7836 if (!elf_map_symbols (abfd, &num_locals))
7839 /* Dump out the symtabs. */
7840 stt = _bfd_elf_strtab_init ();
7844 bed = get_elf_backend_data (abfd);
7845 symcount = bfd_get_symcount (abfd);
7846 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7847 symtab_hdr->sh_type = SHT_SYMTAB;
7848 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7849 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
7850 symtab_hdr->sh_info = num_locals + 1;
7851 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
7853 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7854 symstrtab_hdr->sh_type = SHT_STRTAB;
7856 /* Allocate buffer to swap out the .strtab section. */
7857 symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1)
7858 * sizeof (*symstrtab));
7859 if (symstrtab == NULL)
7861 _bfd_elf_strtab_free (stt);
7865 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
7866 bed->s->sizeof_sym);
7867 if (outbound_syms == NULL)
7870 _bfd_elf_strtab_free (stt);
7874 symtab_hdr->contents = outbound_syms;
7875 outbound_syms_index = 0;
7877 outbound_shndx = NULL;
7878 outbound_shndx_index = 0;
7880 if (elf_symtab_shndx_list (abfd))
7882 symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7883 if (symtab_shndx_hdr->sh_name != 0)
7885 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7886 outbound_shndx = (bfd_byte *)
7887 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7888 if (outbound_shndx == NULL)
7891 symtab_shndx_hdr->contents = outbound_shndx;
7892 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7893 symtab_shndx_hdr->sh_size = amt;
7894 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7895 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7897 /* FIXME: What about any other headers in the list ? */
7900 /* Now generate the data (for "contents"). */
7902 /* Fill in zeroth symbol and swap it out. */
7903 Elf_Internal_Sym sym;
7909 sym.st_shndx = SHN_UNDEF;
7910 sym.st_target_internal = 0;
7911 symstrtab[0].sym = sym;
7912 symstrtab[0].dest_index = outbound_syms_index;
7913 symstrtab[0].destshndx_index = outbound_shndx_index;
7914 outbound_syms_index++;
7915 if (outbound_shndx != NULL)
7916 outbound_shndx_index++;
7920 = (bed->elf_backend_name_local_section_symbols
7921 && bed->elf_backend_name_local_section_symbols (abfd));
7923 syms = bfd_get_outsymbols (abfd);
7924 for (idx = 0; idx < symcount;)
7926 Elf_Internal_Sym sym;
7927 bfd_vma value = syms[idx]->value;
7928 elf_symbol_type *type_ptr;
7929 flagword flags = syms[idx]->flags;
7932 if (!name_local_sections
7933 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
7935 /* Local section symbols have no name. */
7936 sym.st_name = (unsigned long) -1;
7940 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7941 to get the final offset for st_name. */
7943 = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
7945 if (sym.st_name == (unsigned long) -1)
7949 type_ptr = elf_symbol_from (abfd, syms[idx]);
7951 if ((flags & BSF_SECTION_SYM) == 0
7952 && bfd_is_com_section (syms[idx]->section))
7954 /* ELF common symbols put the alignment into the `value' field,
7955 and the size into the `size' field. This is backwards from
7956 how BFD handles it, so reverse it here. */
7957 sym.st_size = value;
7958 if (type_ptr == NULL
7959 || type_ptr->internal_elf_sym.st_value == 0)
7960 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
7962 sym.st_value = type_ptr->internal_elf_sym.st_value;
7963 sym.st_shndx = _bfd_elf_section_from_bfd_section
7964 (abfd, syms[idx]->section);
7968 asection *sec = syms[idx]->section;
7971 if (sec->output_section)
7973 value += sec->output_offset;
7974 sec = sec->output_section;
7977 /* Don't add in the section vma for relocatable output. */
7978 if (! relocatable_p)
7980 sym.st_value = value;
7981 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
7983 if (bfd_is_abs_section (sec)
7985 && type_ptr->internal_elf_sym.st_shndx != 0)
7987 /* This symbol is in a real ELF section which we did
7988 not create as a BFD section. Undo the mapping done
7989 by copy_private_symbol_data. */
7990 shndx = type_ptr->internal_elf_sym.st_shndx;
7994 shndx = elf_onesymtab (abfd);
7997 shndx = elf_dynsymtab (abfd);
8000 shndx = elf_strtab_sec (abfd);
8003 shndx = elf_shstrtab_sec (abfd);
8006 if (elf_symtab_shndx_list (abfd))
8007 shndx = elf_symtab_shndx_list (abfd)->ndx;
8016 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8018 if (shndx == SHN_BAD)
8022 /* Writing this would be a hell of a lot easier if
8023 we had some decent documentation on bfd, and
8024 knew what to expect of the library, and what to
8025 demand of applications. For example, it
8026 appears that `objcopy' might not set the
8027 section of a symbol to be a section that is
8028 actually in the output file. */
8029 sec2 = bfd_get_section_by_name (abfd, sec->name);
8031 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
8032 if (shndx == SHN_BAD)
8034 /* xgettext:c-format */
8036 (_("unable to find equivalent output section"
8037 " for symbol '%s' from section '%s'"),
8038 syms[idx]->name ? syms[idx]->name : "<Local sym>",
8040 bfd_set_error (bfd_error_invalid_operation);
8046 sym.st_shndx = shndx;
8049 if ((flags & BSF_THREAD_LOCAL) != 0)
8051 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
8052 type = STT_GNU_IFUNC;
8053 else if ((flags & BSF_FUNCTION) != 0)
8055 else if ((flags & BSF_OBJECT) != 0)
8057 else if ((flags & BSF_RELC) != 0)
8059 else if ((flags & BSF_SRELC) != 0)
8064 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
8067 /* Processor-specific types. */
8068 if (type_ptr != NULL
8069 && bed->elf_backend_get_symbol_type)
8070 type = ((*bed->elf_backend_get_symbol_type)
8071 (&type_ptr->internal_elf_sym, type));
8073 if (flags & BSF_SECTION_SYM)
8075 if (flags & BSF_GLOBAL)
8076 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8078 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
8080 else if (bfd_is_com_section (syms[idx]->section))
8082 if (type != STT_TLS)
8084 if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
8085 type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
8086 ? STT_COMMON : STT_OBJECT);
8088 type = ((flags & BSF_ELF_COMMON) != 0
8089 ? STT_COMMON : STT_OBJECT);
8091 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
8093 else if (bfd_is_und_section (syms[idx]->section))
8094 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
8098 else if (flags & BSF_FILE)
8099 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
8102 int bind = STB_LOCAL;
8104 if (flags & BSF_LOCAL)
8106 else if (flags & BSF_GNU_UNIQUE)
8107 bind = STB_GNU_UNIQUE;
8108 else if (flags & BSF_WEAK)
8110 else if (flags & BSF_GLOBAL)
8113 sym.st_info = ELF_ST_INFO (bind, type);
8116 if (type_ptr != NULL)
8118 sym.st_other = type_ptr->internal_elf_sym.st_other;
8119 sym.st_target_internal
8120 = type_ptr->internal_elf_sym.st_target_internal;
8125 sym.st_target_internal = 0;
8129 symstrtab[idx].sym = sym;
8130 symstrtab[idx].dest_index = outbound_syms_index;
8131 symstrtab[idx].destshndx_index = outbound_shndx_index;
8133 outbound_syms_index++;
8134 if (outbound_shndx != NULL)
8135 outbound_shndx_index++;
8138 /* Finalize the .strtab section. */
8139 _bfd_elf_strtab_finalize (stt);
8141 /* Swap out the .strtab section. */
8142 for (idx = 0; idx <= symcount; idx++)
8144 struct elf_sym_strtab *elfsym = &symstrtab[idx];
8145 if (elfsym->sym.st_name == (unsigned long) -1)
8146 elfsym->sym.st_name = 0;
8148 elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
8149 elfsym->sym.st_name);
8150 bed->s->swap_symbol_out (abfd, &elfsym->sym,
8152 + (elfsym->dest_index
8153 * bed->s->sizeof_sym)),
8155 + (elfsym->destshndx_index
8156 * sizeof (Elf_External_Sym_Shndx))));
8161 symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
8162 symstrtab_hdr->sh_type = SHT_STRTAB;
8163 symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
8164 symstrtab_hdr->sh_addr = 0;
8165 symstrtab_hdr->sh_entsize = 0;
8166 symstrtab_hdr->sh_link = 0;
8167 symstrtab_hdr->sh_info = 0;
8168 symstrtab_hdr->sh_addralign = 1;
8173 /* Return the number of bytes required to hold the symtab vector.
8175 Note that we base it on the count plus 1, since we will null terminate
8176 the vector allocated based on this size. However, the ELF symbol table
8177 always has a dummy entry as symbol #0, so it ends up even. */
8180 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
8184 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
8186 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8187 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8189 symtab_size -= sizeof (asymbol *);
8195 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
8199 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
8201 if (elf_dynsymtab (abfd) == 0)
8203 bfd_set_error (bfd_error_invalid_operation);
8207 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
8208 symtab_size = (symcount + 1) * (sizeof (asymbol *));
8210 symtab_size -= sizeof (asymbol *);
8216 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
8219 return (asect->reloc_count + 1) * sizeof (arelent *);
8222 /* Canonicalize the relocs. */
8225 _bfd_elf_canonicalize_reloc (bfd *abfd,
8232 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8234 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
8237 tblptr = section->relocation;
8238 for (i = 0; i < section->reloc_count; i++)
8239 *relptr++ = tblptr++;
8243 return section->reloc_count;
8247 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
8249 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8250 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
8253 bfd_get_symcount (abfd) = symcount;
8258 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
8259 asymbol **allocation)
8261 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8262 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
8265 bfd_get_dynamic_symcount (abfd) = symcount;
8269 /* Return the size required for the dynamic reloc entries. Any loadable
8270 section that was actually installed in the BFD, and has type SHT_REL
8271 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8272 dynamic reloc section. */
8275 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
8280 if (elf_dynsymtab (abfd) == 0)
8282 bfd_set_error (bfd_error_invalid_operation);
8286 ret = sizeof (arelent *);
8287 for (s = abfd->sections; s != NULL; s = s->next)
8288 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8289 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8290 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8291 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
8292 * sizeof (arelent *));
8297 /* Canonicalize the dynamic relocation entries. Note that we return the
8298 dynamic relocations as a single block, although they are actually
8299 associated with particular sections; the interface, which was
8300 designed for SunOS style shared libraries, expects that there is only
8301 one set of dynamic relocs. Any loadable section that was actually
8302 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8303 dynamic symbol table, is considered to be a dynamic reloc section. */
8306 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
8310 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8314 if (elf_dynsymtab (abfd) == 0)
8316 bfd_set_error (bfd_error_invalid_operation);
8320 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8322 for (s = abfd->sections; s != NULL; s = s->next)
8324 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
8325 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
8326 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
8331 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
8333 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
8335 for (i = 0; i < count; i++)
8346 /* Read in the version information. */
8349 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
8351 bfd_byte *contents = NULL;
8352 unsigned int freeidx = 0;
8354 if (elf_dynverref (abfd) != 0)
8356 Elf_Internal_Shdr *hdr;
8357 Elf_External_Verneed *everneed;
8358 Elf_Internal_Verneed *iverneed;
8360 bfd_byte *contents_end;
8362 hdr = &elf_tdata (abfd)->dynverref_hdr;
8364 if (hdr->sh_info == 0
8365 || hdr->sh_info > hdr->sh_size / sizeof (Elf_External_Verneed))
8367 error_return_bad_verref:
8369 (_("%pB: .gnu.version_r invalid entry"), abfd);
8370 bfd_set_error (bfd_error_bad_value);
8371 error_return_verref:
8372 elf_tdata (abfd)->verref = NULL;
8373 elf_tdata (abfd)->cverrefs = 0;
8377 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8378 if (contents == NULL)
8379 goto error_return_verref;
8381 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8382 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8383 goto error_return_verref;
8385 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
8386 bfd_alloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
8388 if (elf_tdata (abfd)->verref == NULL)
8389 goto error_return_verref;
8391 BFD_ASSERT (sizeof (Elf_External_Verneed)
8392 == sizeof (Elf_External_Vernaux));
8393 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
8394 everneed = (Elf_External_Verneed *) contents;
8395 iverneed = elf_tdata (abfd)->verref;
8396 for (i = 0; i < hdr->sh_info; i++, iverneed++)
8398 Elf_External_Vernaux *evernaux;
8399 Elf_Internal_Vernaux *ivernaux;
8402 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
8404 iverneed->vn_bfd = abfd;
8406 iverneed->vn_filename =
8407 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8409 if (iverneed->vn_filename == NULL)
8410 goto error_return_bad_verref;
8412 if (iverneed->vn_cnt == 0)
8413 iverneed->vn_auxptr = NULL;
8416 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
8417 bfd_alloc2 (abfd, iverneed->vn_cnt,
8418 sizeof (Elf_Internal_Vernaux));
8419 if (iverneed->vn_auxptr == NULL)
8420 goto error_return_verref;
8423 if (iverneed->vn_aux
8424 > (size_t) (contents_end - (bfd_byte *) everneed))
8425 goto error_return_bad_verref;
8427 evernaux = ((Elf_External_Vernaux *)
8428 ((bfd_byte *) everneed + iverneed->vn_aux));
8429 ivernaux = iverneed->vn_auxptr;
8430 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8432 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8434 ivernaux->vna_nodename =
8435 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8436 ivernaux->vna_name);
8437 if (ivernaux->vna_nodename == NULL)
8438 goto error_return_bad_verref;
8440 if (ivernaux->vna_other > freeidx)
8441 freeidx = ivernaux->vna_other;
8443 ivernaux->vna_nextptr = NULL;
8444 if (ivernaux->vna_next == 0)
8446 iverneed->vn_cnt = j + 1;
8449 if (j + 1 < iverneed->vn_cnt)
8450 ivernaux->vna_nextptr = ivernaux + 1;
8452 if (ivernaux->vna_next
8453 > (size_t) (contents_end - (bfd_byte *) evernaux))
8454 goto error_return_bad_verref;
8456 evernaux = ((Elf_External_Vernaux *)
8457 ((bfd_byte *) evernaux + ivernaux->vna_next));
8460 iverneed->vn_nextref = NULL;
8461 if (iverneed->vn_next == 0)
8463 if (i + 1 < hdr->sh_info)
8464 iverneed->vn_nextref = iverneed + 1;
8466 if (iverneed->vn_next
8467 > (size_t) (contents_end - (bfd_byte *) everneed))
8468 goto error_return_bad_verref;
8470 everneed = ((Elf_External_Verneed *)
8471 ((bfd_byte *) everneed + iverneed->vn_next));
8473 elf_tdata (abfd)->cverrefs = i;
8479 if (elf_dynverdef (abfd) != 0)
8481 Elf_Internal_Shdr *hdr;
8482 Elf_External_Verdef *everdef;
8483 Elf_Internal_Verdef *iverdef;
8484 Elf_Internal_Verdef *iverdefarr;
8485 Elf_Internal_Verdef iverdefmem;
8487 unsigned int maxidx;
8488 bfd_byte *contents_end_def, *contents_end_aux;
8490 hdr = &elf_tdata (abfd)->dynverdef_hdr;
8492 if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8494 error_return_bad_verdef:
8496 (_("%pB: .gnu.version_d invalid entry"), abfd);
8497 bfd_set_error (bfd_error_bad_value);
8498 error_return_verdef:
8499 elf_tdata (abfd)->verdef = NULL;
8500 elf_tdata (abfd)->cverdefs = 0;
8504 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8505 if (contents == NULL)
8506 goto error_return_verdef;
8507 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8508 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8509 goto error_return_verdef;
8511 BFD_ASSERT (sizeof (Elf_External_Verdef)
8512 >= sizeof (Elf_External_Verdaux));
8513 contents_end_def = contents + hdr->sh_size
8514 - sizeof (Elf_External_Verdef);
8515 contents_end_aux = contents + hdr->sh_size
8516 - sizeof (Elf_External_Verdaux);
8518 /* We know the number of entries in the section but not the maximum
8519 index. Therefore we have to run through all entries and find
8521 everdef = (Elf_External_Verdef *) contents;
8523 for (i = 0; i < hdr->sh_info; ++i)
8525 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8527 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8528 goto error_return_bad_verdef;
8529 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8530 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
8532 if (iverdefmem.vd_next == 0)
8535 if (iverdefmem.vd_next
8536 > (size_t) (contents_end_def - (bfd_byte *) everdef))
8537 goto error_return_bad_verdef;
8539 everdef = ((Elf_External_Verdef *)
8540 ((bfd_byte *) everdef + iverdefmem.vd_next));
8543 if (default_imported_symver)
8545 if (freeidx > maxidx)
8551 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8552 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
8553 if (elf_tdata (abfd)->verdef == NULL)
8554 goto error_return_verdef;
8556 elf_tdata (abfd)->cverdefs = maxidx;
8558 everdef = (Elf_External_Verdef *) contents;
8559 iverdefarr = elf_tdata (abfd)->verdef;
8560 for (i = 0; i < hdr->sh_info; i++)
8562 Elf_External_Verdaux *everdaux;
8563 Elf_Internal_Verdaux *iverdaux;
8566 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8568 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
8569 goto error_return_bad_verdef;
8571 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
8572 memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
8574 iverdef->vd_bfd = abfd;
8576 if (iverdef->vd_cnt == 0)
8577 iverdef->vd_auxptr = NULL;
8580 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
8581 bfd_alloc2 (abfd, iverdef->vd_cnt,
8582 sizeof (Elf_Internal_Verdaux));
8583 if (iverdef->vd_auxptr == NULL)
8584 goto error_return_verdef;
8588 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
8589 goto error_return_bad_verdef;
8591 everdaux = ((Elf_External_Verdaux *)
8592 ((bfd_byte *) everdef + iverdef->vd_aux));
8593 iverdaux = iverdef->vd_auxptr;
8594 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8596 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8598 iverdaux->vda_nodename =
8599 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8600 iverdaux->vda_name);
8601 if (iverdaux->vda_nodename == NULL)
8602 goto error_return_bad_verdef;
8604 iverdaux->vda_nextptr = NULL;
8605 if (iverdaux->vda_next == 0)
8607 iverdef->vd_cnt = j + 1;
8610 if (j + 1 < iverdef->vd_cnt)
8611 iverdaux->vda_nextptr = iverdaux + 1;
8613 if (iverdaux->vda_next
8614 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
8615 goto error_return_bad_verdef;
8617 everdaux = ((Elf_External_Verdaux *)
8618 ((bfd_byte *) everdaux + iverdaux->vda_next));
8621 iverdef->vd_nodename = NULL;
8622 if (iverdef->vd_cnt)
8623 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
8625 iverdef->vd_nextdef = NULL;
8626 if (iverdef->vd_next == 0)
8628 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
8629 iverdef->vd_nextdef = iverdef + 1;
8631 everdef = ((Elf_External_Verdef *)
8632 ((bfd_byte *) everdef + iverdef->vd_next));
8638 else if (default_imported_symver)
8645 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8646 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
8647 if (elf_tdata (abfd)->verdef == NULL)
8650 elf_tdata (abfd)->cverdefs = freeidx;
8653 /* Create a default version based on the soname. */
8654 if (default_imported_symver)
8656 Elf_Internal_Verdef *iverdef;
8657 Elf_Internal_Verdaux *iverdaux;
8659 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
8661 iverdef->vd_version = VER_DEF_CURRENT;
8662 iverdef->vd_flags = 0;
8663 iverdef->vd_ndx = freeidx;
8664 iverdef->vd_cnt = 1;
8666 iverdef->vd_bfd = abfd;
8668 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8669 if (iverdef->vd_nodename == NULL)
8670 goto error_return_verdef;
8671 iverdef->vd_nextdef = NULL;
8672 iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8673 bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
8674 if (iverdef->vd_auxptr == NULL)
8675 goto error_return_verdef;
8677 iverdaux = iverdef->vd_auxptr;
8678 iverdaux->vda_nodename = iverdef->vd_nodename;
8684 if (contents != NULL)
8690 _bfd_elf_make_empty_symbol (bfd *abfd)
8692 elf_symbol_type *newsym;
8694 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof * newsym);
8697 newsym->symbol.the_bfd = abfd;
8698 return &newsym->symbol;
8702 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8706 bfd_symbol_info (symbol, ret);
8709 /* Return whether a symbol name implies a local symbol. Most targets
8710 use this function for the is_local_label_name entry point, but some
8714 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8717 /* Normal local symbols start with ``.L''. */
8718 if (name[0] == '.' && name[1] == 'L')
8721 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8722 DWARF debugging symbols starting with ``..''. */
8723 if (name[0] == '.' && name[1] == '.')
8726 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8727 emitting DWARF debugging output. I suspect this is actually a
8728 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8729 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8730 underscore to be emitted on some ELF targets). For ease of use,
8731 we treat such symbols as local. */
8732 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
8735 /* Treat assembler generated fake symbols, dollar local labels and
8736 forward-backward labels (aka local labels) as locals.
8737 These labels have the form:
8739 L0^A.* (fake symbols)
8741 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8743 Versions which start with .L will have already been matched above,
8744 so we only need to match the rest. */
8745 if (name[0] == 'L' && ISDIGIT (name[1]))
8747 bfd_boolean ret = FALSE;
8751 for (p = name + 2; (c = *p); p++)
8753 if (c == 1 || c == 2)
8755 if (c == 1 && p == name + 2)
8756 /* A fake symbol. */
8759 /* FIXME: We are being paranoid here and treating symbols like
8760 L0^Bfoo as if there were non-local, on the grounds that the
8761 assembler will never generate them. But can any symbol
8762 containing an ASCII value in the range 1-31 ever be anything
8763 other than some kind of local ? */
8780 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8781 asymbol *symbol ATTRIBUTE_UNUSED)
8788 _bfd_elf_set_arch_mach (bfd *abfd,
8789 enum bfd_architecture arch,
8790 unsigned long machine)
8792 /* If this isn't the right architecture for this backend, and this
8793 isn't the generic backend, fail. */
8794 if (arch != get_elf_backend_data (abfd)->arch
8795 && arch != bfd_arch_unknown
8796 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
8799 return bfd_default_set_arch_mach (abfd, arch, machine);
8802 /* Find the nearest line to a particular section and offset,
8803 for error reporting. */
8806 _bfd_elf_find_nearest_line (bfd *abfd,
8810 const char **filename_ptr,
8811 const char **functionname_ptr,
8812 unsigned int *line_ptr,
8813 unsigned int *discriminator_ptr)
8817 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
8818 filename_ptr, functionname_ptr,
8819 line_ptr, discriminator_ptr,
8820 dwarf_debug_sections, 0,
8821 &elf_tdata (abfd)->dwarf2_find_line_info)
8822 || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8823 filename_ptr, functionname_ptr,
8826 if (!*functionname_ptr)
8827 _bfd_elf_find_function (abfd, symbols, section, offset,
8828 *filename_ptr ? NULL : filename_ptr,
8833 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
8834 &found, filename_ptr,
8835 functionname_ptr, line_ptr,
8836 &elf_tdata (abfd)->line_info))
8838 if (found && (*functionname_ptr || *line_ptr))
8841 if (symbols == NULL)
8844 if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8845 filename_ptr, functionname_ptr))
8852 /* Find the line for a symbol. */
8855 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8856 const char **filename_ptr, unsigned int *line_ptr)
8858 return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8859 filename_ptr, NULL, line_ptr, NULL,
8860 dwarf_debug_sections, 0,
8861 &elf_tdata (abfd)->dwarf2_find_line_info);
8864 /* After a call to bfd_find_nearest_line, successive calls to
8865 bfd_find_inliner_info can be used to get source information about
8866 each level of function inlining that terminated at the address
8867 passed to bfd_find_nearest_line. Currently this is only supported
8868 for DWARF2 with appropriate DWARF3 extensions. */
8871 _bfd_elf_find_inliner_info (bfd *abfd,
8872 const char **filename_ptr,
8873 const char **functionname_ptr,
8874 unsigned int *line_ptr)
8877 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8878 functionname_ptr, line_ptr,
8879 & elf_tdata (abfd)->dwarf2_find_line_info);
8884 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
8886 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8887 int ret = bed->s->sizeof_ehdr;
8889 if (!bfd_link_relocatable (info))
8891 bfd_size_type phdr_size = elf_program_header_size (abfd);
8893 if (phdr_size == (bfd_size_type) -1)
8895 struct elf_segment_map *m;
8898 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
8899 phdr_size += bed->s->sizeof_phdr;
8902 phdr_size = get_program_header_size (abfd, info);
8905 elf_program_header_size (abfd) = phdr_size;
8913 _bfd_elf_set_section_contents (bfd *abfd,
8915 const void *location,
8917 bfd_size_type count)
8919 Elf_Internal_Shdr *hdr;
8922 if (! abfd->output_has_begun
8923 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
8929 hdr = &elf_section_data (section)->this_hdr;
8930 if (hdr->sh_offset == (file_ptr) -1)
8932 /* We must compress this section. Write output to the buffer. */
8933 unsigned char *contents = hdr->contents;
8934 if ((offset + count) > hdr->sh_size
8935 || (section->flags & SEC_ELF_COMPRESS) == 0
8936 || contents == NULL)
8938 memcpy (contents + offset, location, count);
8941 pos = hdr->sh_offset + offset;
8942 if (bfd_seek (abfd, pos, SEEK_SET) != 0
8943 || bfd_bwrite (location, count, abfd) != count)
8950 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
8951 arelent *cache_ptr ATTRIBUTE_UNUSED,
8952 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
8958 /* Try to convert a non-ELF reloc into an ELF one. */
8961 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
8963 /* Check whether we really have an ELF howto. */
8965 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
8967 bfd_reloc_code_real_type code;
8968 reloc_howto_type *howto;
8970 /* Alien reloc: Try to determine its type to replace it with an
8971 equivalent ELF reloc. */
8973 if (areloc->howto->pc_relative)
8975 switch (areloc->howto->bitsize)
8978 code = BFD_RELOC_8_PCREL;
8981 code = BFD_RELOC_12_PCREL;
8984 code = BFD_RELOC_16_PCREL;
8987 code = BFD_RELOC_24_PCREL;
8990 code = BFD_RELOC_32_PCREL;
8993 code = BFD_RELOC_64_PCREL;
8999 howto = bfd_reloc_type_lookup (abfd, code);
9001 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
9003 if (howto->pcrel_offset)
9004 areloc->addend += areloc->address;
9006 areloc->addend -= areloc->address; /* addend is unsigned!! */
9011 switch (areloc->howto->bitsize)
9017 code = BFD_RELOC_14;
9020 code = BFD_RELOC_16;
9023 code = BFD_RELOC_26;
9026 code = BFD_RELOC_32;
9029 code = BFD_RELOC_64;
9035 howto = bfd_reloc_type_lookup (abfd, code);
9039 areloc->howto = howto;
9047 /* xgettext:c-format */
9048 _bfd_error_handler (_("%pB: %s unsupported"),
9049 abfd, areloc->howto->name);
9050 bfd_set_error (bfd_error_bad_value);
9055 _bfd_elf_close_and_cleanup (bfd *abfd)
9057 struct elf_obj_tdata *tdata = elf_tdata (abfd);
9058 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
9060 if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
9061 _bfd_elf_strtab_free (elf_shstrtab (abfd));
9062 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
9065 return _bfd_generic_close_and_cleanup (abfd);
9068 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9069 in the relocation's offset. Thus we cannot allow any sort of sanity
9070 range-checking to interfere. There is nothing else to do in processing
9073 bfd_reloc_status_type
9074 _bfd_elf_rel_vtable_reloc_fn
9075 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
9076 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
9077 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
9078 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
9080 return bfd_reloc_ok;
9083 /* Elf core file support. Much of this only works on native
9084 toolchains, since we rely on knowing the
9085 machine-dependent procfs structure in order to pick
9086 out details about the corefile. */
9088 #ifdef HAVE_SYS_PROCFS_H
9089 /* Needed for new procfs interface on sparc-solaris. */
9090 # define _STRUCTURED_PROC 1
9091 # include <sys/procfs.h>
9094 /* Return a PID that identifies a "thread" for threaded cores, or the
9095 PID of the main process for non-threaded cores. */
9098 elfcore_make_pid (bfd *abfd)
9102 pid = elf_tdata (abfd)->core->lwpid;
9104 pid = elf_tdata (abfd)->core->pid;
9109 /* If there isn't a section called NAME, make one, using
9110 data from SECT. Note, this function will generate a
9111 reference to NAME, so you shouldn't deallocate or
9115 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
9119 if (bfd_get_section_by_name (abfd, name) != NULL)
9122 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
9126 sect2->size = sect->size;
9127 sect2->filepos = sect->filepos;
9128 sect2->alignment_power = sect->alignment_power;
9132 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9133 actually creates up to two pseudosections:
9134 - For the single-threaded case, a section named NAME, unless
9135 such a section already exists.
9136 - For the multi-threaded case, a section named "NAME/PID", where
9137 PID is elfcore_make_pid (abfd).
9138 Both pseudosections have identical contents. */
9140 _bfd_elfcore_make_pseudosection (bfd *abfd,
9146 char *threaded_name;
9150 /* Build the section name. */
9152 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
9153 len = strlen (buf) + 1;
9154 threaded_name = (char *) bfd_alloc (abfd, len);
9155 if (threaded_name == NULL)
9157 memcpy (threaded_name, buf, len);
9159 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
9164 sect->filepos = filepos;
9165 sect->alignment_power = 2;
9167 return elfcore_maybe_make_sect (abfd, name, sect);
9170 /* prstatus_t exists on:
9172 linux 2.[01] + glibc
9176 #if defined (HAVE_PRSTATUS_T)
9179 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
9184 if (note->descsz == sizeof (prstatus_t))
9188 size = sizeof (prstat.pr_reg);
9189 offset = offsetof (prstatus_t, pr_reg);
9190 memcpy (&prstat, note->descdata, sizeof (prstat));
9192 /* Do not overwrite the core signal if it
9193 has already been set by another thread. */
9194 if (elf_tdata (abfd)->core->signal == 0)
9195 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9196 if (elf_tdata (abfd)->core->pid == 0)
9197 elf_tdata (abfd)->core->pid = prstat.pr_pid;
9199 /* pr_who exists on:
9202 pr_who doesn't exist on:
9205 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9206 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9208 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9211 #if defined (HAVE_PRSTATUS32_T)
9212 else if (note->descsz == sizeof (prstatus32_t))
9214 /* 64-bit host, 32-bit corefile */
9215 prstatus32_t prstat;
9217 size = sizeof (prstat.pr_reg);
9218 offset = offsetof (prstatus32_t, pr_reg);
9219 memcpy (&prstat, note->descdata, sizeof (prstat));
9221 /* Do not overwrite the core signal if it
9222 has already been set by another thread. */
9223 if (elf_tdata (abfd)->core->signal == 0)
9224 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
9225 if (elf_tdata (abfd)->core->pid == 0)
9226 elf_tdata (abfd)->core->pid = prstat.pr_pid;
9228 /* pr_who exists on:
9231 pr_who doesn't exist on:
9234 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9235 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
9237 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
9240 #endif /* HAVE_PRSTATUS32_T */
9243 /* Fail - we don't know how to handle any other
9244 note size (ie. data object type). */
9248 /* Make a ".reg/999" section and a ".reg" section. */
9249 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9250 size, note->descpos + offset);
9252 #endif /* defined (HAVE_PRSTATUS_T) */
9254 /* Create a pseudosection containing the exact contents of NOTE. */
9256 elfcore_make_note_pseudosection (bfd *abfd,
9258 Elf_Internal_Note *note)
9260 return _bfd_elfcore_make_pseudosection (abfd, name,
9261 note->descsz, note->descpos);
9264 /* There isn't a consistent prfpregset_t across platforms,
9265 but it doesn't matter, because we don't have to pick this
9266 data structure apart. */
9269 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
9271 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9274 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9275 type of NT_PRXFPREG. Just include the whole note's contents
9279 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
9281 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9284 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9285 with a note type of NT_X86_XSTATE. Just include the whole note's
9286 contents literally. */
9289 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
9291 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
9295 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
9297 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
9301 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
9303 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
9307 elfcore_grok_ppc_tar (bfd *abfd, Elf_Internal_Note *note)
9309 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tar", note);
9313 elfcore_grok_ppc_ppr (bfd *abfd, Elf_Internal_Note *note)
9315 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ppr", note);
9319 elfcore_grok_ppc_dscr (bfd *abfd, Elf_Internal_Note *note)
9321 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-dscr", note);
9325 elfcore_grok_ppc_ebb (bfd *abfd, Elf_Internal_Note *note)
9327 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-ebb", note);
9331 elfcore_grok_ppc_pmu (bfd *abfd, Elf_Internal_Note *note)
9333 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-pmu", note);
9337 elfcore_grok_ppc_tm_cgpr (bfd *abfd, Elf_Internal_Note *note)
9339 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cgpr", note);
9343 elfcore_grok_ppc_tm_cfpr (bfd *abfd, Elf_Internal_Note *note)
9345 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cfpr", note);
9349 elfcore_grok_ppc_tm_cvmx (bfd *abfd, Elf_Internal_Note *note)
9351 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvmx", note);
9355 elfcore_grok_ppc_tm_cvsx (bfd *abfd, Elf_Internal_Note *note)
9357 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cvsx", note);
9361 elfcore_grok_ppc_tm_spr (bfd *abfd, Elf_Internal_Note *note)
9363 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-spr", note);
9367 elfcore_grok_ppc_tm_ctar (bfd *abfd, Elf_Internal_Note *note)
9369 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-ctar", note);
9373 elfcore_grok_ppc_tm_cppr (bfd *abfd, Elf_Internal_Note *note)
9375 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cppr", note);
9379 elfcore_grok_ppc_tm_cdscr (bfd *abfd, Elf_Internal_Note *note)
9381 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-tm-cdscr", note);
9385 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
9387 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
9391 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
9393 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
9397 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
9399 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
9403 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
9405 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
9409 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
9411 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
9415 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
9417 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
9421 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
9423 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
9427 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
9429 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
9433 elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
9435 return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
9439 elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
9441 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
9445 elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
9447 return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
9451 elfcore_grok_s390_gs_cb (bfd *abfd, Elf_Internal_Note *note)
9453 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-cb", note);
9457 elfcore_grok_s390_gs_bc (bfd *abfd, Elf_Internal_Note *note)
9459 return elfcore_make_note_pseudosection (abfd, ".reg-s390-gs-bc", note);
9463 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
9465 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
9469 elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
9471 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
9475 elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
9477 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
9481 elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
9483 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
9487 elfcore_grok_aarch_sve (bfd *abfd, Elf_Internal_Note *note)
9489 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-sve", note);
9492 #if defined (HAVE_PRPSINFO_T)
9493 typedef prpsinfo_t elfcore_psinfo_t;
9494 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9495 typedef prpsinfo32_t elfcore_psinfo32_t;
9499 #if defined (HAVE_PSINFO_T)
9500 typedef psinfo_t elfcore_psinfo_t;
9501 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9502 typedef psinfo32_t elfcore_psinfo32_t;
9506 /* return a malloc'ed copy of a string at START which is at
9507 most MAX bytes long, possibly without a terminating '\0'.
9508 the copy will always have a terminating '\0'. */
9511 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
9514 char *end = (char *) memchr (start, '\0', max);
9522 dups = (char *) bfd_alloc (abfd, len + 1);
9526 memcpy (dups, start, len);
9532 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9534 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
9536 if (note->descsz == sizeof (elfcore_psinfo_t))
9538 elfcore_psinfo_t psinfo;
9540 memcpy (&psinfo, note->descdata, sizeof (psinfo));
9542 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9543 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9545 elf_tdata (abfd)->core->program
9546 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9547 sizeof (psinfo.pr_fname));
9549 elf_tdata (abfd)->core->command
9550 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9551 sizeof (psinfo.pr_psargs));
9553 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9554 else if (note->descsz == sizeof (elfcore_psinfo32_t))
9556 /* 64-bit host, 32-bit corefile */
9557 elfcore_psinfo32_t psinfo;
9559 memcpy (&psinfo, note->descdata, sizeof (psinfo));
9561 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9562 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9564 elf_tdata (abfd)->core->program
9565 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9566 sizeof (psinfo.pr_fname));
9568 elf_tdata (abfd)->core->command
9569 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9570 sizeof (psinfo.pr_psargs));
9576 /* Fail - we don't know how to handle any other
9577 note size (ie. data object type). */
9581 /* Note that for some reason, a spurious space is tacked
9582 onto the end of the args in some (at least one anyway)
9583 implementations, so strip it off if it exists. */
9586 char *command = elf_tdata (abfd)->core->command;
9587 int n = strlen (command);
9589 if (0 < n && command[n - 1] == ' ')
9590 command[n - 1] = '\0';
9595 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9597 #if defined (HAVE_PSTATUS_T)
9599 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
9601 if (note->descsz == sizeof (pstatus_t)
9602 #if defined (HAVE_PXSTATUS_T)
9603 || note->descsz == sizeof (pxstatus_t)
9609 memcpy (&pstat, note->descdata, sizeof (pstat));
9611 elf_tdata (abfd)->core->pid = pstat.pr_pid;
9613 #if defined (HAVE_PSTATUS32_T)
9614 else if (note->descsz == sizeof (pstatus32_t))
9616 /* 64-bit host, 32-bit corefile */
9619 memcpy (&pstat, note->descdata, sizeof (pstat));
9621 elf_tdata (abfd)->core->pid = pstat.pr_pid;
9624 /* Could grab some more details from the "representative"
9625 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9626 NT_LWPSTATUS note, presumably. */
9630 #endif /* defined (HAVE_PSTATUS_T) */
9632 #if defined (HAVE_LWPSTATUS_T)
9634 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
9636 lwpstatus_t lwpstat;
9642 if (note->descsz != sizeof (lwpstat)
9643 #if defined (HAVE_LWPXSTATUS_T)
9644 && note->descsz != sizeof (lwpxstatus_t)
9649 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9651 elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
9652 /* Do not overwrite the core signal if it has already been set by
9654 if (elf_tdata (abfd)->core->signal == 0)
9655 elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
9657 /* Make a ".reg/999" section. */
9659 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
9660 len = strlen (buf) + 1;
9661 name = bfd_alloc (abfd, len);
9664 memcpy (name, buf, len);
9666 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9670 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9671 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
9672 sect->filepos = note->descpos
9673 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9676 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9677 sect->size = sizeof (lwpstat.pr_reg);
9678 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9681 sect->alignment_power = 2;
9683 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
9686 /* Make a ".reg2/999" section */
9688 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
9689 len = strlen (buf) + 1;
9690 name = bfd_alloc (abfd, len);
9693 memcpy (name, buf, len);
9695 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9699 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9700 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
9701 sect->filepos = note->descpos
9702 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9705 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9706 sect->size = sizeof (lwpstat.pr_fpreg);
9707 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9710 sect->alignment_power = 2;
9712 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
9714 #endif /* defined (HAVE_LWPSTATUS_T) */
9717 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
9724 int is_active_thread;
9727 if (note->descsz < 728)
9730 if (! CONST_STRNEQ (note->namedata, "win32"))
9733 type = bfd_get_32 (abfd, note->descdata);
9737 case 1 /* NOTE_INFO_PROCESS */:
9738 /* FIXME: need to add ->core->command. */
9739 /* process_info.pid */
9740 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
9741 /* process_info.signal */
9742 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
9745 case 2 /* NOTE_INFO_THREAD */:
9746 /* Make a ".reg/999" section. */
9747 /* thread_info.tid */
9748 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
9750 len = strlen (buf) + 1;
9751 name = (char *) bfd_alloc (abfd, len);
9755 memcpy (name, buf, len);
9757 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9761 /* sizeof (thread_info.thread_context) */
9763 /* offsetof (thread_info.thread_context) */
9764 sect->filepos = note->descpos + 12;
9765 sect->alignment_power = 2;
9767 /* thread_info.is_active_thread */
9768 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9770 if (is_active_thread)
9771 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
9775 case 3 /* NOTE_INFO_MODULE */:
9776 /* Make a ".module/xxxxxxxx" section. */
9777 /* module_info.base_address */
9778 base_addr = bfd_get_32 (abfd, note->descdata + 4);
9779 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
9781 len = strlen (buf) + 1;
9782 name = (char *) bfd_alloc (abfd, len);
9786 memcpy (name, buf, len);
9788 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9793 sect->size = note->descsz;
9794 sect->filepos = note->descpos;
9795 sect->alignment_power = 2;
9806 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
9808 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9816 if (bed->elf_backend_grok_prstatus)
9817 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
9819 #if defined (HAVE_PRSTATUS_T)
9820 return elfcore_grok_prstatus (abfd, note);
9825 #if defined (HAVE_PSTATUS_T)
9827 return elfcore_grok_pstatus (abfd, note);
9830 #if defined (HAVE_LWPSTATUS_T)
9832 return elfcore_grok_lwpstatus (abfd, note);
9835 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
9836 return elfcore_grok_prfpreg (abfd, note);
9838 case NT_WIN32PSTATUS:
9839 return elfcore_grok_win32pstatus (abfd, note);
9841 case NT_PRXFPREG: /* Linux SSE extension */
9842 if (note->namesz == 6
9843 && strcmp (note->namedata, "LINUX") == 0)
9844 return elfcore_grok_prxfpreg (abfd, note);
9848 case NT_X86_XSTATE: /* Linux XSAVE extension */
9849 if (note->namesz == 6
9850 && strcmp (note->namedata, "LINUX") == 0)
9851 return elfcore_grok_xstatereg (abfd, note);
9856 if (note->namesz == 6
9857 && strcmp (note->namedata, "LINUX") == 0)
9858 return elfcore_grok_ppc_vmx (abfd, note);
9863 if (note->namesz == 6
9864 && strcmp (note->namedata, "LINUX") == 0)
9865 return elfcore_grok_ppc_vsx (abfd, note);
9870 if (note->namesz == 6
9871 && strcmp (note->namedata, "LINUX") == 0)
9872 return elfcore_grok_ppc_tar (abfd, note);
9877 if (note->namesz == 6
9878 && strcmp (note->namedata, "LINUX") == 0)
9879 return elfcore_grok_ppc_ppr (abfd, note);
9884 if (note->namesz == 6
9885 && strcmp (note->namedata, "LINUX") == 0)
9886 return elfcore_grok_ppc_dscr (abfd, note);
9891 if (note->namesz == 6
9892 && strcmp (note->namedata, "LINUX") == 0)
9893 return elfcore_grok_ppc_ebb (abfd, note);
9898 if (note->namesz == 6
9899 && strcmp (note->namedata, "LINUX") == 0)
9900 return elfcore_grok_ppc_pmu (abfd, note);
9904 case NT_PPC_TM_CGPR:
9905 if (note->namesz == 6
9906 && strcmp (note->namedata, "LINUX") == 0)
9907 return elfcore_grok_ppc_tm_cgpr (abfd, note);
9911 case NT_PPC_TM_CFPR:
9912 if (note->namesz == 6
9913 && strcmp (note->namedata, "LINUX") == 0)
9914 return elfcore_grok_ppc_tm_cfpr (abfd, note);
9918 case NT_PPC_TM_CVMX:
9919 if (note->namesz == 6
9920 && strcmp (note->namedata, "LINUX") == 0)
9921 return elfcore_grok_ppc_tm_cvmx (abfd, note);
9925 case NT_PPC_TM_CVSX:
9926 if (note->namesz == 6
9927 && strcmp (note->namedata, "LINUX") == 0)
9928 return elfcore_grok_ppc_tm_cvsx (abfd, note);
9933 if (note->namesz == 6
9934 && strcmp (note->namedata, "LINUX") == 0)
9935 return elfcore_grok_ppc_tm_spr (abfd, note);
9939 case NT_PPC_TM_CTAR:
9940 if (note->namesz == 6
9941 && strcmp (note->namedata, "LINUX") == 0)
9942 return elfcore_grok_ppc_tm_ctar (abfd, note);
9946 case NT_PPC_TM_CPPR:
9947 if (note->namesz == 6
9948 && strcmp (note->namedata, "LINUX") == 0)
9949 return elfcore_grok_ppc_tm_cppr (abfd, note);
9953 case NT_PPC_TM_CDSCR:
9954 if (note->namesz == 6
9955 && strcmp (note->namedata, "LINUX") == 0)
9956 return elfcore_grok_ppc_tm_cdscr (abfd, note);
9960 case NT_S390_HIGH_GPRS:
9961 if (note->namesz == 6
9962 && strcmp (note->namedata, "LINUX") == 0)
9963 return elfcore_grok_s390_high_gprs (abfd, note);
9968 if (note->namesz == 6
9969 && strcmp (note->namedata, "LINUX") == 0)
9970 return elfcore_grok_s390_timer (abfd, note);
9974 case NT_S390_TODCMP:
9975 if (note->namesz == 6
9976 && strcmp (note->namedata, "LINUX") == 0)
9977 return elfcore_grok_s390_todcmp (abfd, note);
9981 case NT_S390_TODPREG:
9982 if (note->namesz == 6
9983 && strcmp (note->namedata, "LINUX") == 0)
9984 return elfcore_grok_s390_todpreg (abfd, note);
9989 if (note->namesz == 6
9990 && strcmp (note->namedata, "LINUX") == 0)
9991 return elfcore_grok_s390_ctrs (abfd, note);
9995 case NT_S390_PREFIX:
9996 if (note->namesz == 6
9997 && strcmp (note->namedata, "LINUX") == 0)
9998 return elfcore_grok_s390_prefix (abfd, note);
10002 case NT_S390_LAST_BREAK:
10003 if (note->namesz == 6
10004 && strcmp (note->namedata, "LINUX") == 0)
10005 return elfcore_grok_s390_last_break (abfd, note);
10009 case NT_S390_SYSTEM_CALL:
10010 if (note->namesz == 6
10011 && strcmp (note->namedata, "LINUX") == 0)
10012 return elfcore_grok_s390_system_call (abfd, note);
10017 if (note->namesz == 6
10018 && strcmp (note->namedata, "LINUX") == 0)
10019 return elfcore_grok_s390_tdb (abfd, note);
10023 case NT_S390_VXRS_LOW:
10024 if (note->namesz == 6
10025 && strcmp (note->namedata, "LINUX") == 0)
10026 return elfcore_grok_s390_vxrs_low (abfd, note);
10030 case NT_S390_VXRS_HIGH:
10031 if (note->namesz == 6
10032 && strcmp (note->namedata, "LINUX") == 0)
10033 return elfcore_grok_s390_vxrs_high (abfd, note);
10037 case NT_S390_GS_CB:
10038 if (note->namesz == 6
10039 && strcmp (note->namedata, "LINUX") == 0)
10040 return elfcore_grok_s390_gs_cb (abfd, note);
10044 case NT_S390_GS_BC:
10045 if (note->namesz == 6
10046 && strcmp (note->namedata, "LINUX") == 0)
10047 return elfcore_grok_s390_gs_bc (abfd, note);
10052 if (note->namesz == 6
10053 && strcmp (note->namedata, "LINUX") == 0)
10054 return elfcore_grok_arm_vfp (abfd, note);
10059 if (note->namesz == 6
10060 && strcmp (note->namedata, "LINUX") == 0)
10061 return elfcore_grok_aarch_tls (abfd, note);
10065 case NT_ARM_HW_BREAK:
10066 if (note->namesz == 6
10067 && strcmp (note->namedata, "LINUX") == 0)
10068 return elfcore_grok_aarch_hw_break (abfd, note);
10072 case NT_ARM_HW_WATCH:
10073 if (note->namesz == 6
10074 && strcmp (note->namedata, "LINUX") == 0)
10075 return elfcore_grok_aarch_hw_watch (abfd, note);
10080 if (note->namesz == 6
10081 && strcmp (note->namedata, "LINUX") == 0)
10082 return elfcore_grok_aarch_sve (abfd, note);
10088 if (bed->elf_backend_grok_psinfo)
10089 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
10091 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10092 return elfcore_grok_psinfo (abfd, note);
10099 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10104 sect->size = note->descsz;
10105 sect->filepos = note->descpos;
10106 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10112 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
10116 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
10123 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
10125 struct bfd_build_id* build_id;
10127 if (note->descsz == 0)
10130 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
10131 if (build_id == NULL)
10134 build_id->size = note->descsz;
10135 memcpy (build_id->data, note->descdata, note->descsz);
10136 abfd->build_id = build_id;
10142 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
10144 switch (note->type)
10149 case NT_GNU_PROPERTY_TYPE_0:
10150 return _bfd_elf_parse_gnu_properties (abfd, note);
10152 case NT_GNU_BUILD_ID:
10153 return elfobj_grok_gnu_build_id (abfd, note);
10158 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
10160 struct sdt_note *cur =
10161 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
10164 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
10165 cur->size = (bfd_size_type) note->descsz;
10166 memcpy (cur->data, note->descdata, note->descsz);
10168 elf_tdata (abfd)->sdt_note_head = cur;
10174 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
10176 switch (note->type)
10179 return elfobj_grok_stapsdt_note_1 (abfd, note);
10187 elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
10191 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10194 if (note->descsz < 108)
10199 if (note->descsz < 120)
10207 /* Check for version 1 in pr_version. */
10208 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10213 /* Skip over pr_psinfosz. */
10214 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10218 offset += 4; /* Padding before pr_psinfosz. */
10222 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10223 elf_tdata (abfd)->core->program
10224 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
10227 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10228 elf_tdata (abfd)->core->command
10229 = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
10232 /* Padding before pr_pid. */
10235 /* The pr_pid field was added in version "1a". */
10236 if (note->descsz < offset + 4)
10239 elf_tdata (abfd)->core->pid
10240 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10246 elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
10252 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10253 Also compute minimum size of this note. */
10254 switch (elf_elfheader (abfd)->e_ident[EI_CLASS])
10258 min_size = offset + (4 * 2) + 4 + 4 + 4;
10262 offset = 4 + 4 + 8; /* Includes padding before pr_statussz. */
10263 min_size = offset + (8 * 2) + 4 + 4 + 4 + 4;
10270 if (note->descsz < min_size)
10273 /* Check for version 1 in pr_version. */
10274 if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
10277 /* Extract size of pr_reg from pr_gregsetsz. */
10278 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10279 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS32)
10281 size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10286 size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
10290 /* Skip over pr_osreldate. */
10293 /* Read signal from pr_cursig. */
10294 if (elf_tdata (abfd)->core->signal == 0)
10295 elf_tdata (abfd)->core->signal
10296 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10299 /* Read TID from pr_pid. */
10300 elf_tdata (abfd)->core->lwpid
10301 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
10304 /* Padding before pr_reg. */
10305 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
10308 /* Make sure that there is enough data remaining in the note. */
10309 if ((note->descsz - offset) < size)
10312 /* Make a ".reg/999" section and a ".reg" section. */
10313 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
10314 size, note->descpos + offset);
10318 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
10320 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10322 switch (note->type)
10325 if (bed->elf_backend_grok_freebsd_prstatus)
10326 if ((*bed->elf_backend_grok_freebsd_prstatus) (abfd, note))
10328 return elfcore_grok_freebsd_prstatus (abfd, note);
10331 return elfcore_grok_prfpreg (abfd, note);
10334 return elfcore_grok_freebsd_psinfo (abfd, note);
10336 case NT_FREEBSD_THRMISC:
10337 if (note->namesz == 8)
10338 return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
10342 case NT_FREEBSD_PROCSTAT_PROC:
10343 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.proc",
10346 case NT_FREEBSD_PROCSTAT_FILES:
10347 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.files",
10350 case NT_FREEBSD_PROCSTAT_VMMAP:
10351 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.vmmap",
10354 case NT_FREEBSD_PROCSTAT_AUXV:
10356 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10361 sect->size = note->descsz - 4;
10362 sect->filepos = note->descpos + 4;
10363 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10368 case NT_X86_XSTATE:
10369 if (note->namesz == 8)
10370 return elfcore_grok_xstatereg (abfd, note);
10374 case NT_FREEBSD_PTLWPINFO:
10375 return elfcore_make_note_pseudosection (abfd, ".note.freebsdcore.lwpinfo",
10379 return elfcore_grok_arm_vfp (abfd, note);
10387 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
10391 cp = strchr (note->namedata, '@');
10394 *lwpidp = atoi(cp + 1);
10401 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10403 if (note->descsz <= 0x7c + 31)
10406 /* Signal number at offset 0x08. */
10407 elf_tdata (abfd)->core->signal
10408 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10410 /* Process ID at offset 0x50. */
10411 elf_tdata (abfd)->core->pid
10412 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
10414 /* Command name at 0x7c (max 32 bytes, including nul). */
10415 elf_tdata (abfd)->core->command
10416 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
10418 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
10423 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
10427 if (elfcore_netbsd_get_lwpid (note, &lwp))
10428 elf_tdata (abfd)->core->lwpid = lwp;
10430 if (note->type == NT_NETBSDCORE_PROCINFO)
10432 /* NetBSD-specific core "procinfo". Note that we expect to
10433 find this note before any of the others, which is fine,
10434 since the kernel writes this note out first when it
10435 creates a core file. */
10437 return elfcore_grok_netbsd_procinfo (abfd, note);
10440 /* As of Jan 2002 there are no other machine-independent notes
10441 defined for NetBSD core files. If the note type is less
10442 than the start of the machine-dependent note types, we don't
10445 if (note->type < NT_NETBSDCORE_FIRSTMACH)
10449 switch (bfd_get_arch (abfd))
10451 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10452 PT_GETFPREGS == mach+2. */
10454 case bfd_arch_alpha:
10455 case bfd_arch_sparc:
10456 switch (note->type)
10458 case NT_NETBSDCORE_FIRSTMACH+0:
10459 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10461 case NT_NETBSDCORE_FIRSTMACH+2:
10462 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10468 /* On all other arch's, PT_GETREGS == mach+1 and
10469 PT_GETFPREGS == mach+3. */
10472 switch (note->type)
10474 case NT_NETBSDCORE_FIRSTMACH+1:
10475 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10477 case NT_NETBSDCORE_FIRSTMACH+3:
10478 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10488 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
10490 if (note->descsz <= 0x48 + 31)
10493 /* Signal number at offset 0x08. */
10494 elf_tdata (abfd)->core->signal
10495 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
10497 /* Process ID at offset 0x20. */
10498 elf_tdata (abfd)->core->pid
10499 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
10501 /* Command name at 0x48 (max 32 bytes, including nul). */
10502 elf_tdata (abfd)->core->command
10503 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
10509 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
10511 if (note->type == NT_OPENBSD_PROCINFO)
10512 return elfcore_grok_openbsd_procinfo (abfd, note);
10514 if (note->type == NT_OPENBSD_REGS)
10515 return elfcore_make_note_pseudosection (abfd, ".reg", note);
10517 if (note->type == NT_OPENBSD_FPREGS)
10518 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
10520 if (note->type == NT_OPENBSD_XFPREGS)
10521 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
10523 if (note->type == NT_OPENBSD_AUXV)
10525 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
10530 sect->size = note->descsz;
10531 sect->filepos = note->descpos;
10532 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10537 if (note->type == NT_OPENBSD_WCOOKIE)
10539 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
10544 sect->size = note->descsz;
10545 sect->filepos = note->descpos;
10546 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
10555 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
10557 void *ddata = note->descdata;
10564 if (note->descsz < 16)
10567 /* nto_procfs_status 'pid' field is at offset 0. */
10568 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
10570 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10571 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
10573 /* nto_procfs_status 'flags' field is at offset 8. */
10574 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
10576 /* nto_procfs_status 'what' field is at offset 14. */
10577 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
10579 elf_tdata (abfd)->core->signal = sig;
10580 elf_tdata (abfd)->core->lwpid = *tid;
10583 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10584 do not come from signals so we make sure we set the current
10585 thread just in case. */
10586 if (flags & 0x00000080)
10587 elf_tdata (abfd)->core->lwpid = *tid;
10589 /* Make a ".qnx_core_status/%d" section. */
10590 sprintf (buf, ".qnx_core_status/%ld", *tid);
10592 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10595 strcpy (name, buf);
10597 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10601 sect->size = note->descsz;
10602 sect->filepos = note->descpos;
10603 sect->alignment_power = 2;
10605 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
10609 elfcore_grok_nto_regs (bfd *abfd,
10610 Elf_Internal_Note *note,
10618 /* Make a "(base)/%d" section. */
10619 sprintf (buf, "%s/%ld", base, tid);
10621 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
10624 strcpy (name, buf);
10626 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10630 sect->size = note->descsz;
10631 sect->filepos = note->descpos;
10632 sect->alignment_power = 2;
10634 /* This is the current thread. */
10635 if (elf_tdata (abfd)->core->lwpid == tid)
10636 return elfcore_maybe_make_sect (abfd, base, sect);
10641 #define BFD_QNT_CORE_INFO 7
10642 #define BFD_QNT_CORE_STATUS 8
10643 #define BFD_QNT_CORE_GREG 9
10644 #define BFD_QNT_CORE_FPREG 10
10647 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
10649 /* Every GREG section has a STATUS section before it. Store the
10650 tid from the previous call to pass down to the next gregs
10652 static long tid = 1;
10654 switch (note->type)
10656 case BFD_QNT_CORE_INFO:
10657 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
10658 case BFD_QNT_CORE_STATUS:
10659 return elfcore_grok_nto_status (abfd, note, &tid);
10660 case BFD_QNT_CORE_GREG:
10661 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
10662 case BFD_QNT_CORE_FPREG:
10663 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
10670 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
10676 /* Use note name as section name. */
10677 len = note->namesz;
10678 name = (char *) bfd_alloc (abfd, len);
10681 memcpy (name, note->namedata, len);
10682 name[len - 1] = '\0';
10684 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
10688 sect->size = note->descsz;
10689 sect->filepos = note->descpos;
10690 sect->alignment_power = 1;
10695 /* Function: elfcore_write_note
10698 buffer to hold note, and current size of buffer
10702 size of data for note
10704 Writes note to end of buffer. ELF64 notes are written exactly as
10705 for ELF32, despite the current (as of 2006) ELF gabi specifying
10706 that they ought to have 8-byte namesz and descsz field, and have
10707 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10710 Pointer to realloc'd buffer, *BUFSIZ updated. */
10713 elfcore_write_note (bfd *abfd,
10721 Elf_External_Note *xnp;
10728 namesz = strlen (name) + 1;
10730 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
10732 buf = (char *) realloc (buf, *bufsiz + newspace);
10735 dest = buf + *bufsiz;
10736 *bufsiz += newspace;
10737 xnp = (Elf_External_Note *) dest;
10738 H_PUT_32 (abfd, namesz, xnp->namesz);
10739 H_PUT_32 (abfd, size, xnp->descsz);
10740 H_PUT_32 (abfd, type, xnp->type);
10744 memcpy (dest, name, namesz);
10752 memcpy (dest, input, size);
10762 /* gcc-8 warns (*) on all the strncpy calls in this function about
10763 possible string truncation. The "truncation" is not a bug. We
10764 have an external representation of structs with fields that are not
10765 necessarily NULL terminated and corresponding internal
10766 representation fields that are one larger so that they can always
10767 be NULL terminated.
10768 gcc versions between 4.2 and 4.6 do not allow pragma control of
10769 diagnostics inside functions, giving a hard error if you try to use
10770 the finer control available with later versions.
10771 gcc prior to 4.2 warns about diagnostic push and pop.
10772 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10773 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10774 (*) Depending on your system header files! */
10775 #if GCC_VERSION >= 8000
10776 # pragma GCC diagnostic push
10777 # pragma GCC diagnostic ignored "-Wstringop-truncation"
10780 elfcore_write_prpsinfo (bfd *abfd,
10784 const char *psargs)
10786 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10788 if (bed->elf_backend_write_core_note != NULL)
10791 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10792 NT_PRPSINFO, fname, psargs);
10797 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10798 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10799 if (bed->s->elfclass == ELFCLASS32)
10801 # if defined (HAVE_PSINFO32_T)
10803 int note_type = NT_PSINFO;
10806 int note_type = NT_PRPSINFO;
10809 memset (&data, 0, sizeof (data));
10810 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10811 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10812 return elfcore_write_note (abfd, buf, bufsiz,
10813 "CORE", note_type, &data, sizeof (data));
10818 # if defined (HAVE_PSINFO_T)
10820 int note_type = NT_PSINFO;
10823 int note_type = NT_PRPSINFO;
10826 memset (&data, 0, sizeof (data));
10827 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10828 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10829 return elfcore_write_note (abfd, buf, bufsiz,
10830 "CORE", note_type, &data, sizeof (data));
10832 #endif /* PSINFO_T or PRPSINFO_T */
10837 #if GCC_VERSION >= 8000
10838 # pragma GCC diagnostic pop
10842 elfcore_write_linux_prpsinfo32
10843 (bfd *abfd, char *buf, int *bufsiz,
10844 const struct elf_internal_linux_prpsinfo *prpsinfo)
10846 if (get_elf_backend_data (abfd)->linux_prpsinfo32_ugid16)
10848 struct elf_external_linux_prpsinfo32_ugid16 data;
10850 swap_linux_prpsinfo32_ugid16_out (abfd, prpsinfo, &data);
10851 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10852 &data, sizeof (data));
10856 struct elf_external_linux_prpsinfo32_ugid32 data;
10858 swap_linux_prpsinfo32_ugid32_out (abfd, prpsinfo, &data);
10859 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10860 &data, sizeof (data));
10865 elfcore_write_linux_prpsinfo64
10866 (bfd *abfd, char *buf, int *bufsiz,
10867 const struct elf_internal_linux_prpsinfo *prpsinfo)
10869 if (get_elf_backend_data (abfd)->linux_prpsinfo64_ugid16)
10871 struct elf_external_linux_prpsinfo64_ugid16 data;
10873 swap_linux_prpsinfo64_ugid16_out (abfd, prpsinfo, &data);
10874 return elfcore_write_note (abfd, buf, bufsiz,
10875 "CORE", NT_PRPSINFO, &data, sizeof (data));
10879 struct elf_external_linux_prpsinfo64_ugid32 data;
10881 swap_linux_prpsinfo64_ugid32_out (abfd, prpsinfo, &data);
10882 return elfcore_write_note (abfd, buf, bufsiz,
10883 "CORE", NT_PRPSINFO, &data, sizeof (data));
10888 elfcore_write_prstatus (bfd *abfd,
10895 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10897 if (bed->elf_backend_write_core_note != NULL)
10900 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10902 pid, cursig, gregs);
10907 #if defined (HAVE_PRSTATUS_T)
10908 #if defined (HAVE_PRSTATUS32_T)
10909 if (bed->s->elfclass == ELFCLASS32)
10911 prstatus32_t prstat;
10913 memset (&prstat, 0, sizeof (prstat));
10914 prstat.pr_pid = pid;
10915 prstat.pr_cursig = cursig;
10916 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10917 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10918 NT_PRSTATUS, &prstat, sizeof (prstat));
10925 memset (&prstat, 0, sizeof (prstat));
10926 prstat.pr_pid = pid;
10927 prstat.pr_cursig = cursig;
10928 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10929 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10930 NT_PRSTATUS, &prstat, sizeof (prstat));
10932 #endif /* HAVE_PRSTATUS_T */
10938 #if defined (HAVE_LWPSTATUS_T)
10940 elfcore_write_lwpstatus (bfd *abfd,
10947 lwpstatus_t lwpstat;
10948 const char *note_name = "CORE";
10950 memset (&lwpstat, 0, sizeof (lwpstat));
10951 lwpstat.pr_lwpid = pid >> 16;
10952 lwpstat.pr_cursig = cursig;
10953 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10954 memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
10955 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10956 #if !defined(gregs)
10957 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
10958 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
10960 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
10961 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
10964 return elfcore_write_note (abfd, buf, bufsiz, note_name,
10965 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
10967 #endif /* HAVE_LWPSTATUS_T */
10969 #if defined (HAVE_PSTATUS_T)
10971 elfcore_write_pstatus (bfd *abfd,
10975 int cursig ATTRIBUTE_UNUSED,
10976 const void *gregs ATTRIBUTE_UNUSED)
10978 const char *note_name = "CORE";
10979 #if defined (HAVE_PSTATUS32_T)
10980 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10982 if (bed->s->elfclass == ELFCLASS32)
10986 memset (&pstat, 0, sizeof (pstat));
10987 pstat.pr_pid = pid & 0xffff;
10988 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10989 NT_PSTATUS, &pstat, sizeof (pstat));
10997 memset (&pstat, 0, sizeof (pstat));
10998 pstat.pr_pid = pid & 0xffff;
10999 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
11000 NT_PSTATUS, &pstat, sizeof (pstat));
11004 #endif /* HAVE_PSTATUS_T */
11007 elfcore_write_prfpreg (bfd *abfd,
11010 const void *fpregs,
11013 const char *note_name = "CORE";
11014 return elfcore_write_note (abfd, buf, bufsiz,
11015 note_name, NT_FPREGSET, fpregs, size);
11019 elfcore_write_prxfpreg (bfd *abfd,
11022 const void *xfpregs,
11025 char *note_name = "LINUX";
11026 return elfcore_write_note (abfd, buf, bufsiz,
11027 note_name, NT_PRXFPREG, xfpregs, size);
11031 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
11032 const void *xfpregs, int size)
11035 if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
11036 note_name = "FreeBSD";
11038 note_name = "LINUX";
11039 return elfcore_write_note (abfd, buf, bufsiz,
11040 note_name, NT_X86_XSTATE, xfpregs, size);
11044 elfcore_write_ppc_vmx (bfd *abfd,
11047 const void *ppc_vmx,
11050 char *note_name = "LINUX";
11051 return elfcore_write_note (abfd, buf, bufsiz,
11052 note_name, NT_PPC_VMX, ppc_vmx, size);
11056 elfcore_write_ppc_vsx (bfd *abfd,
11059 const void *ppc_vsx,
11062 char *note_name = "LINUX";
11063 return elfcore_write_note (abfd, buf, bufsiz,
11064 note_name, NT_PPC_VSX, ppc_vsx, size);
11068 elfcore_write_ppc_tar (bfd *abfd,
11071 const void *ppc_tar,
11074 char *note_name = "LINUX";
11075 return elfcore_write_note (abfd, buf, bufsiz,
11076 note_name, NT_PPC_TAR, ppc_tar, size);
11080 elfcore_write_ppc_ppr (bfd *abfd,
11083 const void *ppc_ppr,
11086 char *note_name = "LINUX";
11087 return elfcore_write_note (abfd, buf, bufsiz,
11088 note_name, NT_PPC_PPR, ppc_ppr, size);
11092 elfcore_write_ppc_dscr (bfd *abfd,
11095 const void *ppc_dscr,
11098 char *note_name = "LINUX";
11099 return elfcore_write_note (abfd, buf, bufsiz,
11100 note_name, NT_PPC_DSCR, ppc_dscr, size);
11104 elfcore_write_ppc_ebb (bfd *abfd,
11107 const void *ppc_ebb,
11110 char *note_name = "LINUX";
11111 return elfcore_write_note (abfd, buf, bufsiz,
11112 note_name, NT_PPC_EBB, ppc_ebb, size);
11116 elfcore_write_ppc_pmu (bfd *abfd,
11119 const void *ppc_pmu,
11122 char *note_name = "LINUX";
11123 return elfcore_write_note (abfd, buf, bufsiz,
11124 note_name, NT_PPC_PMU, ppc_pmu, size);
11128 elfcore_write_ppc_tm_cgpr (bfd *abfd,
11131 const void *ppc_tm_cgpr,
11134 char *note_name = "LINUX";
11135 return elfcore_write_note (abfd, buf, bufsiz,
11136 note_name, NT_PPC_TM_CGPR, ppc_tm_cgpr, size);
11140 elfcore_write_ppc_tm_cfpr (bfd *abfd,
11143 const void *ppc_tm_cfpr,
11146 char *note_name = "LINUX";
11147 return elfcore_write_note (abfd, buf, bufsiz,
11148 note_name, NT_PPC_TM_CFPR, ppc_tm_cfpr, size);
11152 elfcore_write_ppc_tm_cvmx (bfd *abfd,
11155 const void *ppc_tm_cvmx,
11158 char *note_name = "LINUX";
11159 return elfcore_write_note (abfd, buf, bufsiz,
11160 note_name, NT_PPC_TM_CVMX, ppc_tm_cvmx, size);
11164 elfcore_write_ppc_tm_cvsx (bfd *abfd,
11167 const void *ppc_tm_cvsx,
11170 char *note_name = "LINUX";
11171 return elfcore_write_note (abfd, buf, bufsiz,
11172 note_name, NT_PPC_TM_CVSX, ppc_tm_cvsx, size);
11176 elfcore_write_ppc_tm_spr (bfd *abfd,
11179 const void *ppc_tm_spr,
11182 char *note_name = "LINUX";
11183 return elfcore_write_note (abfd, buf, bufsiz,
11184 note_name, NT_PPC_TM_SPR, ppc_tm_spr, size);
11188 elfcore_write_ppc_tm_ctar (bfd *abfd,
11191 const void *ppc_tm_ctar,
11194 char *note_name = "LINUX";
11195 return elfcore_write_note (abfd, buf, bufsiz,
11196 note_name, NT_PPC_TM_CTAR, ppc_tm_ctar, size);
11200 elfcore_write_ppc_tm_cppr (bfd *abfd,
11203 const void *ppc_tm_cppr,
11206 char *note_name = "LINUX";
11207 return elfcore_write_note (abfd, buf, bufsiz,
11208 note_name, NT_PPC_TM_CPPR, ppc_tm_cppr, size);
11212 elfcore_write_ppc_tm_cdscr (bfd *abfd,
11215 const void *ppc_tm_cdscr,
11218 char *note_name = "LINUX";
11219 return elfcore_write_note (abfd, buf, bufsiz,
11220 note_name, NT_PPC_TM_CDSCR, ppc_tm_cdscr, size);
11224 elfcore_write_s390_high_gprs (bfd *abfd,
11227 const void *s390_high_gprs,
11230 char *note_name = "LINUX";
11231 return elfcore_write_note (abfd, buf, bufsiz,
11232 note_name, NT_S390_HIGH_GPRS,
11233 s390_high_gprs, size);
11237 elfcore_write_s390_timer (bfd *abfd,
11240 const void *s390_timer,
11243 char *note_name = "LINUX";
11244 return elfcore_write_note (abfd, buf, bufsiz,
11245 note_name, NT_S390_TIMER, s390_timer, size);
11249 elfcore_write_s390_todcmp (bfd *abfd,
11252 const void *s390_todcmp,
11255 char *note_name = "LINUX";
11256 return elfcore_write_note (abfd, buf, bufsiz,
11257 note_name, NT_S390_TODCMP, s390_todcmp, size);
11261 elfcore_write_s390_todpreg (bfd *abfd,
11264 const void *s390_todpreg,
11267 char *note_name = "LINUX";
11268 return elfcore_write_note (abfd, buf, bufsiz,
11269 note_name, NT_S390_TODPREG, s390_todpreg, size);
11273 elfcore_write_s390_ctrs (bfd *abfd,
11276 const void *s390_ctrs,
11279 char *note_name = "LINUX";
11280 return elfcore_write_note (abfd, buf, bufsiz,
11281 note_name, NT_S390_CTRS, s390_ctrs, size);
11285 elfcore_write_s390_prefix (bfd *abfd,
11288 const void *s390_prefix,
11291 char *note_name = "LINUX";
11292 return elfcore_write_note (abfd, buf, bufsiz,
11293 note_name, NT_S390_PREFIX, s390_prefix, size);
11297 elfcore_write_s390_last_break (bfd *abfd,
11300 const void *s390_last_break,
11303 char *note_name = "LINUX";
11304 return elfcore_write_note (abfd, buf, bufsiz,
11305 note_name, NT_S390_LAST_BREAK,
11306 s390_last_break, size);
11310 elfcore_write_s390_system_call (bfd *abfd,
11313 const void *s390_system_call,
11316 char *note_name = "LINUX";
11317 return elfcore_write_note (abfd, buf, bufsiz,
11318 note_name, NT_S390_SYSTEM_CALL,
11319 s390_system_call, size);
11323 elfcore_write_s390_tdb (bfd *abfd,
11326 const void *s390_tdb,
11329 char *note_name = "LINUX";
11330 return elfcore_write_note (abfd, buf, bufsiz,
11331 note_name, NT_S390_TDB, s390_tdb, size);
11335 elfcore_write_s390_vxrs_low (bfd *abfd,
11338 const void *s390_vxrs_low,
11341 char *note_name = "LINUX";
11342 return elfcore_write_note (abfd, buf, bufsiz,
11343 note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
11347 elfcore_write_s390_vxrs_high (bfd *abfd,
11350 const void *s390_vxrs_high,
11353 char *note_name = "LINUX";
11354 return elfcore_write_note (abfd, buf, bufsiz,
11355 note_name, NT_S390_VXRS_HIGH,
11356 s390_vxrs_high, size);
11360 elfcore_write_s390_gs_cb (bfd *abfd,
11363 const void *s390_gs_cb,
11366 char *note_name = "LINUX";
11367 return elfcore_write_note (abfd, buf, bufsiz,
11368 note_name, NT_S390_GS_CB,
11373 elfcore_write_s390_gs_bc (bfd *abfd,
11376 const void *s390_gs_bc,
11379 char *note_name = "LINUX";
11380 return elfcore_write_note (abfd, buf, bufsiz,
11381 note_name, NT_S390_GS_BC,
11386 elfcore_write_arm_vfp (bfd *abfd,
11389 const void *arm_vfp,
11392 char *note_name = "LINUX";
11393 return elfcore_write_note (abfd, buf, bufsiz,
11394 note_name, NT_ARM_VFP, arm_vfp, size);
11398 elfcore_write_aarch_tls (bfd *abfd,
11401 const void *aarch_tls,
11404 char *note_name = "LINUX";
11405 return elfcore_write_note (abfd, buf, bufsiz,
11406 note_name, NT_ARM_TLS, aarch_tls, size);
11410 elfcore_write_aarch_hw_break (bfd *abfd,
11413 const void *aarch_hw_break,
11416 char *note_name = "LINUX";
11417 return elfcore_write_note (abfd, buf, bufsiz,
11418 note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
11422 elfcore_write_aarch_hw_watch (bfd *abfd,
11425 const void *aarch_hw_watch,
11428 char *note_name = "LINUX";
11429 return elfcore_write_note (abfd, buf, bufsiz,
11430 note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
11434 elfcore_write_aarch_sve (bfd *abfd,
11437 const void *aarch_sve,
11440 char *note_name = "LINUX";
11441 return elfcore_write_note (abfd, buf, bufsiz,
11442 note_name, NT_ARM_SVE, aarch_sve, size);
11446 elfcore_write_register_note (bfd *abfd,
11449 const char *section,
11453 if (strcmp (section, ".reg2") == 0)
11454 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
11455 if (strcmp (section, ".reg-xfp") == 0)
11456 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
11457 if (strcmp (section, ".reg-xstate") == 0)
11458 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
11459 if (strcmp (section, ".reg-ppc-vmx") == 0)
11460 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
11461 if (strcmp (section, ".reg-ppc-vsx") == 0)
11462 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
11463 if (strcmp (section, ".reg-ppc-tar") == 0)
11464 return elfcore_write_ppc_tar (abfd, buf, bufsiz, data, size);
11465 if (strcmp (section, ".reg-ppc-ppr") == 0)
11466 return elfcore_write_ppc_ppr (abfd, buf, bufsiz, data, size);
11467 if (strcmp (section, ".reg-ppc-dscr") == 0)
11468 return elfcore_write_ppc_dscr (abfd, buf, bufsiz, data, size);
11469 if (strcmp (section, ".reg-ppc-ebb") == 0)
11470 return elfcore_write_ppc_ebb (abfd, buf, bufsiz, data, size);
11471 if (strcmp (section, ".reg-ppc-pmu") == 0)
11472 return elfcore_write_ppc_pmu (abfd, buf, bufsiz, data, size);
11473 if (strcmp (section, ".reg-ppc-tm-cgpr") == 0)
11474 return elfcore_write_ppc_tm_cgpr (abfd, buf, bufsiz, data, size);
11475 if (strcmp (section, ".reg-ppc-tm-cfpr") == 0)
11476 return elfcore_write_ppc_tm_cfpr (abfd, buf, bufsiz, data, size);
11477 if (strcmp (section, ".reg-ppc-tm-cvmx") == 0)
11478 return elfcore_write_ppc_tm_cvmx (abfd, buf, bufsiz, data, size);
11479 if (strcmp (section, ".reg-ppc-tm-cvsx") == 0)
11480 return elfcore_write_ppc_tm_cvsx (abfd, buf, bufsiz, data, size);
11481 if (strcmp (section, ".reg-ppc-tm-spr") == 0)
11482 return elfcore_write_ppc_tm_spr (abfd, buf, bufsiz, data, size);
11483 if (strcmp (section, ".reg-ppc-tm-ctar") == 0)
11484 return elfcore_write_ppc_tm_ctar (abfd, buf, bufsiz, data, size);
11485 if (strcmp (section, ".reg-ppc-tm-cppr") == 0)
11486 return elfcore_write_ppc_tm_cppr (abfd, buf, bufsiz, data, size);
11487 if (strcmp (section, ".reg-ppc-tm-cdscr") == 0)
11488 return elfcore_write_ppc_tm_cdscr (abfd, buf, bufsiz, data, size);
11489 if (strcmp (section, ".reg-s390-high-gprs") == 0)
11490 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
11491 if (strcmp (section, ".reg-s390-timer") == 0)
11492 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
11493 if (strcmp (section, ".reg-s390-todcmp") == 0)
11494 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
11495 if (strcmp (section, ".reg-s390-todpreg") == 0)
11496 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
11497 if (strcmp (section, ".reg-s390-ctrs") == 0)
11498 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
11499 if (strcmp (section, ".reg-s390-prefix") == 0)
11500 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
11501 if (strcmp (section, ".reg-s390-last-break") == 0)
11502 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
11503 if (strcmp (section, ".reg-s390-system-call") == 0)
11504 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
11505 if (strcmp (section, ".reg-s390-tdb") == 0)
11506 return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
11507 if (strcmp (section, ".reg-s390-vxrs-low") == 0)
11508 return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
11509 if (strcmp (section, ".reg-s390-vxrs-high") == 0)
11510 return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
11511 if (strcmp (section, ".reg-s390-gs-cb") == 0)
11512 return elfcore_write_s390_gs_cb (abfd, buf, bufsiz, data, size);
11513 if (strcmp (section, ".reg-s390-gs-bc") == 0)
11514 return elfcore_write_s390_gs_bc (abfd, buf, bufsiz, data, size);
11515 if (strcmp (section, ".reg-arm-vfp") == 0)
11516 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
11517 if (strcmp (section, ".reg-aarch-tls") == 0)
11518 return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
11519 if (strcmp (section, ".reg-aarch-hw-break") == 0)
11520 return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
11521 if (strcmp (section, ".reg-aarch-hw-watch") == 0)
11522 return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
11523 if (strcmp (section, ".reg-aarch-sve") == 0)
11524 return elfcore_write_aarch_sve (abfd, buf, bufsiz, data, size);
11529 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset,
11534 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11535 gABI specifies that PT_NOTE alignment should be aligned to 4
11536 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11537 align is less than 4, we use 4 byte alignment. */
11540 if (align != 4 && align != 8)
11544 while (p < buf + size)
11546 Elf_External_Note *xnp = (Elf_External_Note *) p;
11547 Elf_Internal_Note in;
11549 if (offsetof (Elf_External_Note, name) > buf - p + size)
11552 in.type = H_GET_32 (abfd, xnp->type);
11554 in.namesz = H_GET_32 (abfd, xnp->namesz);
11555 in.namedata = xnp->name;
11556 if (in.namesz > buf - in.namedata + size)
11559 in.descsz = H_GET_32 (abfd, xnp->descsz);
11560 in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align);
11561 in.descpos = offset + (in.descdata - buf);
11563 && (in.descdata >= buf + size
11564 || in.descsz > buf - in.descdata + size))
11567 switch (bfd_get_format (abfd))
11574 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11577 const char * string;
11579 bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
11583 GROKER_ELEMENT ("", elfcore_grok_note),
11584 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
11585 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
11586 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
11587 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
11588 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
11590 #undef GROKER_ELEMENT
11593 for (i = ARRAY_SIZE (grokers); i--;)
11595 if (in.namesz >= grokers[i].len
11596 && strncmp (in.namedata, grokers[i].string,
11597 grokers[i].len) == 0)
11599 if (! grokers[i].func (abfd, & in))
11608 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
11610 if (! elfobj_grok_gnu_note (abfd, &in))
11613 else if (in.namesz == sizeof "stapsdt"
11614 && strcmp (in.namedata, "stapsdt") == 0)
11616 if (! elfobj_grok_stapsdt_note (abfd, &in))
11622 p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align);
11629 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size,
11634 if (size == 0 || (size + 1) == 0)
11637 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
11640 buf = (char *) bfd_malloc (size + 1);
11644 /* PR 17512: file: ec08f814
11645 0-termintate the buffer so that string searches will not overflow. */
11648 if (bfd_bread (buf, size, abfd) != size
11649 || !elf_parse_notes (abfd, buf, size, offset, align))
11659 /* Providing external access to the ELF program header table. */
11661 /* Return an upper bound on the number of bytes required to store a
11662 copy of ABFD's program header table entries. Return -1 if an error
11663 occurs; bfd_get_error will return an appropriate code. */
11666 bfd_get_elf_phdr_upper_bound (bfd *abfd)
11668 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11670 bfd_set_error (bfd_error_wrong_format);
11674 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
11677 /* Copy ABFD's program header table entries to *PHDRS. The entries
11678 will be stored as an array of Elf_Internal_Phdr structures, as
11679 defined in include/elf/internal.h. To find out how large the
11680 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11682 Return the number of program header table entries read, or -1 if an
11683 error occurs; bfd_get_error will return an appropriate code. */
11686 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
11690 if (abfd->xvec->flavour != bfd_target_elf_flavour)
11692 bfd_set_error (bfd_error_wrong_format);
11696 num_phdrs = elf_elfheader (abfd)->e_phnum;
11697 if (num_phdrs != 0)
11698 memcpy (phdrs, elf_tdata (abfd)->phdr,
11699 num_phdrs * sizeof (Elf_Internal_Phdr));
11704 enum elf_reloc_type_class
11705 _bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
11706 const asection *rel_sec ATTRIBUTE_UNUSED,
11707 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
11709 return reloc_class_normal;
11712 /* For RELA architectures, return the relocation value for a
11713 relocation against a local symbol. */
11716 _bfd_elf_rela_local_sym (bfd *abfd,
11717 Elf_Internal_Sym *sym,
11719 Elf_Internal_Rela *rel)
11721 asection *sec = *psec;
11722 bfd_vma relocation;
11724 relocation = (sec->output_section->vma
11725 + sec->output_offset
11727 if ((sec->flags & SEC_MERGE)
11728 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
11729 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
11732 _bfd_merged_section_offset (abfd, psec,
11733 elf_section_data (sec)->sec_info,
11734 sym->st_value + rel->r_addend);
11737 /* If we have changed the section, and our original section is
11738 marked with SEC_EXCLUDE, it means that the original
11739 SEC_MERGE section has been completely subsumed in some
11740 other SEC_MERGE section. In this case, we need to leave
11741 some info around for --emit-relocs. */
11742 if ((sec->flags & SEC_EXCLUDE) != 0)
11743 sec->kept_section = *psec;
11746 rel->r_addend -= relocation;
11747 rel->r_addend += sec->output_section->vma + sec->output_offset;
11753 _bfd_elf_rel_local_sym (bfd *abfd,
11754 Elf_Internal_Sym *sym,
11758 asection *sec = *psec;
11760 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
11761 return sym->st_value + addend;
11763 return _bfd_merged_section_offset (abfd, psec,
11764 elf_section_data (sec)->sec_info,
11765 sym->st_value + addend);
11768 /* Adjust an address within a section. Given OFFSET within SEC, return
11769 the new offset within the section, based upon changes made to the
11770 section. Returns -1 if the offset is now invalid.
11771 The offset (in abnd out) is in target sized bytes, however big a
11775 _bfd_elf_section_offset (bfd *abfd,
11776 struct bfd_link_info *info,
11780 switch (sec->sec_info_type)
11782 case SEC_INFO_TYPE_STABS:
11783 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
11785 case SEC_INFO_TYPE_EH_FRAME:
11786 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
11789 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
11791 /* Reverse the offset. */
11792 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11793 bfd_size_type address_size = bed->s->arch_size / 8;
11795 /* address_size and sec->size are in octets. Convert
11796 to bytes before subtracting the original offset. */
11797 offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
11803 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
11804 reconstruct an ELF file by reading the segments out of remote memory
11805 based on the ELF file header at EHDR_VMA and the ELF program headers it
11806 points to. If not null, *LOADBASEP is filled in with the difference
11807 between the VMAs from which the segments were read, and the VMAs the
11808 file headers (and hence BFD's idea of each section's VMA) put them at.
11810 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11811 remote memory at target address VMA into the local buffer at MYADDR; it
11812 should return zero on success or an `errno' code on failure. TEMPL must
11813 be a BFD for an ELF target with the word size and byte order found in
11814 the remote memory. */
11817 bfd_elf_bfd_from_remote_memory
11820 bfd_size_type size,
11821 bfd_vma *loadbasep,
11822 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
11824 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
11825 (templ, ehdr_vma, size, loadbasep, target_read_memory);
11829 _bfd_elf_get_synthetic_symtab (bfd *abfd,
11830 long symcount ATTRIBUTE_UNUSED,
11831 asymbol **syms ATTRIBUTE_UNUSED,
11836 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11839 const char *relplt_name;
11840 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
11844 Elf_Internal_Shdr *hdr;
11850 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
11853 if (dynsymcount <= 0)
11856 if (!bed->plt_sym_val)
11859 relplt_name = bed->relplt_name;
11860 if (relplt_name == NULL)
11861 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
11862 relplt = bfd_get_section_by_name (abfd, relplt_name);
11863 if (relplt == NULL)
11866 hdr = &elf_section_data (relplt)->this_hdr;
11867 if (hdr->sh_link != elf_dynsymtab (abfd)
11868 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
11871 plt = bfd_get_section_by_name (abfd, ".plt");
11875 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
11876 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
11879 count = relplt->size / hdr->sh_entsize;
11880 size = count * sizeof (asymbol);
11881 p = relplt->relocation;
11882 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11884 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
11885 if (p->addend != 0)
11888 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
11890 size += sizeof ("+0x") - 1 + 8;
11895 s = *ret = (asymbol *) bfd_malloc (size);
11899 names = (char *) (s + count);
11900 p = relplt->relocation;
11902 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
11907 addr = bed->plt_sym_val (i, plt, p);
11908 if (addr == (bfd_vma) -1)
11911 *s = **p->sym_ptr_ptr;
11912 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
11913 we are defining a symbol, ensure one of them is set. */
11914 if ((s->flags & BSF_LOCAL) == 0)
11915 s->flags |= BSF_GLOBAL;
11916 s->flags |= BSF_SYNTHETIC;
11918 s->value = addr - plt->vma;
11921 len = strlen ((*p->sym_ptr_ptr)->name);
11922 memcpy (names, (*p->sym_ptr_ptr)->name, len);
11924 if (p->addend != 0)
11928 memcpy (names, "+0x", sizeof ("+0x") - 1);
11929 names += sizeof ("+0x") - 1;
11930 bfd_sprintf_vma (abfd, buf, p->addend);
11931 for (a = buf; *a == '0'; ++a)
11934 memcpy (names, a, len);
11937 memcpy (names, "@plt", sizeof ("@plt"));
11938 names += sizeof ("@plt");
11945 /* It is only used by x86-64 so far.
11946 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
11947 but current usage would allow all of _bfd_std_section to be zero. */
11948 static const asymbol lcomm_sym
11949 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section);
11950 asection _bfd_elf_large_com_section
11951 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, &lcomm_sym,
11952 "LARGE_COMMON", 0, SEC_IS_COMMON);
11955 _bfd_elf_post_process_headers (bfd * abfd,
11956 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
11958 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
11960 i_ehdrp = elf_elfheader (abfd);
11962 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
11964 /* To make things simpler for the loader on Linux systems we set the
11965 osabi field to ELFOSABI_GNU if the binary contains symbols of
11966 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
11967 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
11968 && elf_tdata (abfd)->has_gnu_symbols)
11969 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
11973 /* Return TRUE for ELF symbol types that represent functions.
11974 This is the default version of this function, which is sufficient for
11975 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
11978 _bfd_elf_is_function_type (unsigned int type)
11980 return (type == STT_FUNC
11981 || type == STT_GNU_IFUNC);
11984 /* If the ELF symbol SYM might be a function in SEC, return the
11985 function size and set *CODE_OFF to the function's entry point,
11986 otherwise return zero. */
11989 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
11992 bfd_size_type size;
11994 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
11995 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
11996 || sym->section != sec)
11999 *code_off = sym->value;
12001 if (!(sym->flags & BSF_SYNTHETIC))
12002 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;