1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 BFD support for ELF formats is being worked on.
27 Currently, the best supported back ends are for sparc and i386
28 (running svr4 or Solaris 2).
30 Documentation of the internals of the support code still needs
31 to be written. The code is changing quickly enough that we
35 /* For sparc64-cross-sparc32. */
43 #include "libiberty.h"
45 static INLINE struct elf_segment_map *make_mapping
46 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
47 static boolean map_sections_to_segments PARAMS ((bfd *));
48 static int elf_sort_sections PARAMS ((const PTR, const PTR));
49 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
50 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
51 static boolean prep_headers PARAMS ((bfd *));
52 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
53 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
54 static char *elf_read PARAMS ((bfd *, file_ptr, bfd_size_type));
55 static boolean setup_group PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
56 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
57 static void set_group_contents PARAMS ((bfd *, asection *, PTR));
58 static boolean assign_section_numbers PARAMS ((bfd *));
59 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
60 static boolean elf_map_symbols PARAMS ((bfd *));
61 static bfd_size_type get_program_header_size PARAMS ((bfd *));
62 static boolean elfcore_read_notes PARAMS ((bfd *, file_ptr, bfd_size_type));
63 static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
64 bfd_vma, const char **,
66 static int elfcore_make_pid PARAMS ((bfd *));
67 static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
68 static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
69 Elf_Internal_Note *));
70 static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
71 static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
72 static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
74 /* Swap version information in and out. The version information is
75 currently size independent. If that ever changes, this code will
76 need to move into elfcode.h. */
78 /* Swap in a Verdef structure. */
81 _bfd_elf_swap_verdef_in (abfd, src, dst)
83 const Elf_External_Verdef *src;
84 Elf_Internal_Verdef *dst;
86 dst->vd_version = H_GET_16 (abfd, src->vd_version);
87 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
88 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
89 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
90 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
91 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
92 dst->vd_next = H_GET_32 (abfd, src->vd_next);
95 /* Swap out a Verdef structure. */
98 _bfd_elf_swap_verdef_out (abfd, src, dst)
100 const Elf_Internal_Verdef *src;
101 Elf_External_Verdef *dst;
103 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
104 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
105 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
106 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
107 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
108 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
109 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
112 /* Swap in a Verdaux structure. */
115 _bfd_elf_swap_verdaux_in (abfd, src, dst)
117 const Elf_External_Verdaux *src;
118 Elf_Internal_Verdaux *dst;
120 dst->vda_name = H_GET_32 (abfd, src->vda_name);
121 dst->vda_next = H_GET_32 (abfd, src->vda_next);
124 /* Swap out a Verdaux structure. */
127 _bfd_elf_swap_verdaux_out (abfd, src, dst)
129 const Elf_Internal_Verdaux *src;
130 Elf_External_Verdaux *dst;
132 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
133 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
136 /* Swap in a Verneed structure. */
139 _bfd_elf_swap_verneed_in (abfd, src, dst)
141 const Elf_External_Verneed *src;
142 Elf_Internal_Verneed *dst;
144 dst->vn_version = H_GET_16 (abfd, src->vn_version);
145 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
146 dst->vn_file = H_GET_32 (abfd, src->vn_file);
147 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
148 dst->vn_next = H_GET_32 (abfd, src->vn_next);
151 /* Swap out a Verneed structure. */
154 _bfd_elf_swap_verneed_out (abfd, src, dst)
156 const Elf_Internal_Verneed *src;
157 Elf_External_Verneed *dst;
159 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
160 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
161 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
162 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
163 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
166 /* Swap in a Vernaux structure. */
169 _bfd_elf_swap_vernaux_in (abfd, src, dst)
171 const Elf_External_Vernaux *src;
172 Elf_Internal_Vernaux *dst;
174 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
175 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
176 dst->vna_other = H_GET_16 (abfd, src->vna_other);
177 dst->vna_name = H_GET_32 (abfd, src->vna_name);
178 dst->vna_next = H_GET_32 (abfd, src->vna_next);
181 /* Swap out a Vernaux structure. */
184 _bfd_elf_swap_vernaux_out (abfd, src, dst)
186 const Elf_Internal_Vernaux *src;
187 Elf_External_Vernaux *dst;
189 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
190 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
191 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
192 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
193 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
196 /* Swap in a Versym structure. */
199 _bfd_elf_swap_versym_in (abfd, src, dst)
201 const Elf_External_Versym *src;
202 Elf_Internal_Versym *dst;
204 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
207 /* Swap out a Versym structure. */
210 _bfd_elf_swap_versym_out (abfd, src, dst)
212 const Elf_Internal_Versym *src;
213 Elf_External_Versym *dst;
215 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
218 /* Standard ELF hash function. Do not change this function; you will
219 cause invalid hash tables to be generated. */
222 bfd_elf_hash (namearg)
225 const unsigned char *name = (const unsigned char *) namearg;
230 while ((ch = *name++) != '\0')
233 if ((g = (h & 0xf0000000)) != 0)
236 /* The ELF ABI says `h &= ~g', but this is equivalent in
237 this case and on some machines one insn instead of two. */
244 /* Read a specified number of bytes at a specified offset in an ELF
245 file, into a newly allocated buffer, and return a pointer to the
249 elf_read (abfd, offset, size)
256 if ((buf = bfd_alloc (abfd, size)) == NULL)
258 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
260 if (bfd_bread ((PTR) buf, size, abfd) != size)
262 if (bfd_get_error () != bfd_error_system_call)
263 bfd_set_error (bfd_error_file_truncated);
270 bfd_elf_mkobject (abfd)
273 /* This just does initialization. */
274 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
275 bfd_size_type amt = sizeof (struct elf_obj_tdata);
276 elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
277 if (elf_tdata (abfd) == 0)
279 /* Since everything is done at close time, do we need any
286 bfd_elf_mkcorefile (abfd)
289 /* I think this can be done just like an object file. */
290 return bfd_elf_mkobject (abfd);
294 bfd_elf_get_str_section (abfd, shindex)
296 unsigned int shindex;
298 Elf_Internal_Shdr **i_shdrp;
299 char *shstrtab = NULL;
301 bfd_size_type shstrtabsize;
303 i_shdrp = elf_elfsections (abfd);
304 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
307 shstrtab = (char *) i_shdrp[shindex]->contents;
308 if (shstrtab == NULL)
310 /* No cached one, attempt to read, and cache what we read. */
311 offset = i_shdrp[shindex]->sh_offset;
312 shstrtabsize = i_shdrp[shindex]->sh_size;
313 shstrtab = elf_read (abfd, offset, shstrtabsize);
314 i_shdrp[shindex]->contents = (PTR) shstrtab;
320 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
322 unsigned int shindex;
323 unsigned int strindex;
325 Elf_Internal_Shdr *hdr;
330 hdr = elf_elfsections (abfd)[shindex];
332 if (hdr->contents == NULL
333 && bfd_elf_get_str_section (abfd, shindex) == NULL)
336 if (strindex >= hdr->sh_size)
338 (*_bfd_error_handler)
339 (_("%s: invalid string offset %u >= %lu for section `%s'"),
340 bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
341 ((shindex == elf_elfheader(abfd)->e_shstrndx
342 && strindex == hdr->sh_name)
344 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
348 return ((char *) hdr->contents) + strindex;
351 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
352 sections. The first element is the flags, the rest are section
355 typedef union elf_internal_group {
356 Elf_Internal_Shdr *shdr;
358 } Elf_Internal_Group;
360 /* Set next_in_group list pointer, and group name for NEWSECT. */
363 setup_group (abfd, hdr, newsect)
365 Elf_Internal_Shdr *hdr;
368 unsigned int num_group = elf_tdata (abfd)->num_group;
370 /* If num_group is zero, read in all SHT_GROUP sections. The count
371 is set to -1 if there are no SHT_GROUP sections. */
374 unsigned int i, shnum;
376 /* First count the number of groups. If we have a SHT_GROUP
377 section with just a flag word (ie. sh_size is 4), ignore it. */
378 shnum = elf_elfheader (abfd)->e_shnum;
380 for (i = 0; i < shnum; i++)
382 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
383 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
388 num_group = (unsigned) -1;
389 elf_tdata (abfd)->num_group = num_group;
393 /* We keep a list of elf section headers for group sections,
394 so we can find them quickly. */
395 bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
396 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
397 if (elf_tdata (abfd)->group_sect_ptr == NULL)
401 for (i = 0; i < shnum; i++)
403 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
404 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
407 Elf_Internal_Group *dest;
409 /* Add to list of sections. */
410 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
413 /* Read the raw contents. */
414 BFD_ASSERT (sizeof (*dest) >= 4);
415 amt = shdr->sh_size * sizeof (*dest) / 4;
416 shdr->contents = bfd_alloc (abfd, amt);
417 if (shdr->contents == NULL
418 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
419 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
423 /* Translate raw contents, a flag word followed by an
424 array of elf section indices all in target byte order,
425 to the flag word followed by an array of elf section
427 src = shdr->contents + shdr->sh_size;
428 dest = (Elf_Internal_Group *) (shdr->contents + amt);
435 idx = H_GET_32 (abfd, src);
436 if (src == shdr->contents)
443 ((*_bfd_error_handler)
444 (_("%s: invalid SHT_GROUP entry"),
445 bfd_archive_filename (abfd)));
448 dest->shdr = elf_elfsections (abfd)[idx];
455 if (num_group != (unsigned) -1)
459 for (i = 0; i < num_group; i++)
461 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
462 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
463 unsigned int n_elt = shdr->sh_size / 4;
465 /* Look through this group's sections to see if current
466 section is a member. */
468 if ((++idx)->shdr == hdr)
472 /* We are a member of this group. Go looking through
473 other members to see if any others are linked via
475 idx = (Elf_Internal_Group *) shdr->contents;
476 n_elt = shdr->sh_size / 4;
478 if ((s = (++idx)->shdr->bfd_section) != NULL
479 && elf_next_in_group (s) != NULL)
483 /* Snarf the group name from other member, and
484 insert current section in circular list. */
485 elf_group_name (newsect) = elf_group_name (s);
486 elf_next_in_group (newsect) = elf_next_in_group (s);
487 elf_next_in_group (s) = newsect;
491 struct elf_backend_data *bed;
493 unsigned char ename[4];
497 /* Humbug. Get the name from the group signature
498 symbol. Why isn't the signature just a string?
499 Fortunately, the name index is at the same
500 place in the external symbol for both 32 and 64
502 bed = get_elf_backend_data (abfd);
503 pos = elf_tdata (abfd)->symtab_hdr.sh_offset;
504 pos += shdr->sh_info * bed->s->sizeof_sym;
505 if (bfd_seek (abfd, pos, SEEK_SET) != 0
506 || bfd_bread (ename, (bfd_size_type) 4, abfd) != 4)
508 iname = H_GET_32 (abfd, ename);
509 gname = elf_string_from_elf_strtab (abfd, iname);
510 elf_group_name (newsect) = gname;
512 /* Start a circular list with one element. */
513 elf_next_in_group (newsect) = newsect;
515 if (shdr->bfd_section != NULL)
516 elf_next_in_group (shdr->bfd_section) = newsect;
523 if (elf_group_name (newsect) == NULL)
525 (*_bfd_error_handler) (_("%s: no group info for section %s"),
526 bfd_archive_filename (abfd), newsect->name);
531 /* Make a BFD section from an ELF section. We store a pointer to the
532 BFD section in the bfd_section field of the header. */
535 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
537 Elf_Internal_Shdr *hdr;
542 struct elf_backend_data *bed;
544 if (hdr->bfd_section != NULL)
546 BFD_ASSERT (strcmp (name,
547 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
551 newsect = bfd_make_section_anyway (abfd, name);
555 newsect->filepos = hdr->sh_offset;
557 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
558 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
559 || ! bfd_set_section_alignment (abfd, newsect,
560 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
563 flags = SEC_NO_FLAGS;
564 if (hdr->sh_type != SHT_NOBITS)
565 flags |= SEC_HAS_CONTENTS;
566 if (hdr->sh_type == SHT_GROUP)
567 flags |= SEC_GROUP | SEC_EXCLUDE;
568 if ((hdr->sh_flags & SHF_ALLOC) != 0)
571 if (hdr->sh_type != SHT_NOBITS)
574 if ((hdr->sh_flags & SHF_WRITE) == 0)
575 flags |= SEC_READONLY;
576 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
578 else if ((flags & SEC_LOAD) != 0)
580 if ((hdr->sh_flags & SHF_MERGE) != 0)
583 newsect->entsize = hdr->sh_entsize;
584 if ((hdr->sh_flags & SHF_STRINGS) != 0)
585 flags |= SEC_STRINGS;
587 if (hdr->sh_flags & SHF_GROUP)
588 if (!setup_group (abfd, hdr, newsect))
591 /* The debugging sections appear to be recognized only by name, not
594 static const char *debug_sec_names [] =
603 for (i = ARRAY_SIZE (debug_sec_names); i--;)
604 if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
608 flags |= SEC_DEBUGGING;
611 /* As a GNU extension, if the name begins with .gnu.linkonce, we
612 only link a single copy of the section. This is used to support
613 g++. g++ will emit each template expansion in its own section.
614 The symbols will be defined as weak, so that multiple definitions
615 are permitted. The GNU linker extension is to actually discard
616 all but one of the sections. */
617 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
618 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
620 bed = get_elf_backend_data (abfd);
621 if (bed->elf_backend_section_flags)
622 if (! bed->elf_backend_section_flags (&flags, hdr))
625 if (! bfd_set_section_flags (abfd, newsect, flags))
628 if ((flags & SEC_ALLOC) != 0)
630 Elf_Internal_Phdr *phdr;
633 /* Look through the phdrs to see if we need to adjust the lma.
634 If all the p_paddr fields are zero, we ignore them, since
635 some ELF linkers produce such output. */
636 phdr = elf_tdata (abfd)->phdr;
637 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
639 if (phdr->p_paddr != 0)
642 if (i < elf_elfheader (abfd)->e_phnum)
644 phdr = elf_tdata (abfd)->phdr;
645 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
647 /* This section is part of this segment if its file
648 offset plus size lies within the segment's memory
649 span and, if the section is loaded, the extent of the
650 loaded data lies within the extent of the segment.
651 If the p_paddr field is not set, we don't alter the
653 if (phdr->p_type == PT_LOAD
655 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
656 && (hdr->sh_offset + hdr->sh_size
657 <= phdr->p_offset + phdr->p_memsz)
658 && ((flags & SEC_LOAD) == 0
659 || (phdr->p_offset + phdr->p_filesz
660 >= hdr->sh_offset + hdr->sh_size)))
662 /* We used to do a relative adjustment here, but
663 that doesn't work if the segment is packed with
664 code from multiple VMAs. Instead we calculate
665 the LMA absoultely, based on the LMA of the
666 segment (it is assumed that the segment will
667 contain sections with contiguous LMAs, even if
668 the VMAs are not). */
669 newsect->lma = phdr->p_paddr
670 + hdr->sh_offset - phdr->p_offset;
677 hdr->bfd_section = newsect;
678 elf_section_data (newsect)->this_hdr = *hdr;
688 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
691 Helper functions for GDB to locate the string tables.
692 Since BFD hides string tables from callers, GDB needs to use an
693 internal hook to find them. Sun's .stabstr, in particular,
694 isn't even pointed to by the .stab section, so ordinary
695 mechanisms wouldn't work to find it, even if we had some.
698 struct elf_internal_shdr *
699 bfd_elf_find_section (abfd, name)
703 Elf_Internal_Shdr **i_shdrp;
708 i_shdrp = elf_elfsections (abfd);
711 shstrtab = bfd_elf_get_str_section
712 (abfd, elf_elfheader (abfd)->e_shstrndx);
713 if (shstrtab != NULL)
715 max = elf_elfheader (abfd)->e_shnum;
716 for (i = 1; i < max; i++)
717 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
724 const char *const bfd_elf_section_type_names[] = {
725 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
726 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
727 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
730 /* ELF relocs are against symbols. If we are producing relocateable
731 output, and the reloc is against an external symbol, and nothing
732 has given us any additional addend, the resulting reloc will also
733 be against the same symbol. In such a case, we don't want to
734 change anything about the way the reloc is handled, since it will
735 all be done at final link time. Rather than put special case code
736 into bfd_perform_relocation, all the reloc types use this howto
737 function. It just short circuits the reloc if producing
738 relocateable output against an external symbol. */
740 bfd_reloc_status_type
741 bfd_elf_generic_reloc (abfd,
748 bfd *abfd ATTRIBUTE_UNUSED;
749 arelent *reloc_entry;
751 PTR data ATTRIBUTE_UNUSED;
752 asection *input_section;
754 char **error_message ATTRIBUTE_UNUSED;
756 if (output_bfd != (bfd *) NULL
757 && (symbol->flags & BSF_SECTION_SYM) == 0
758 && (! reloc_entry->howto->partial_inplace
759 || reloc_entry->addend == 0))
761 reloc_entry->address += input_section->output_offset;
765 return bfd_reloc_continue;
768 /* Finish SHF_MERGE section merging. */
771 _bfd_elf_merge_sections (abfd, info)
773 struct bfd_link_info *info;
775 if (!is_elf_hash_table (info))
777 if (elf_hash_table (info)->merge_info)
778 _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info);
782 /* Print out the program headers. */
785 _bfd_elf_print_private_bfd_data (abfd, farg)
789 FILE *f = (FILE *) farg;
790 Elf_Internal_Phdr *p;
792 bfd_byte *dynbuf = NULL;
794 p = elf_tdata (abfd)->phdr;
799 fprintf (f, _("\nProgram Header:\n"));
800 c = elf_elfheader (abfd)->e_phnum;
801 for (i = 0; i < c; i++, p++)
808 case PT_NULL: pt = "NULL"; break;
809 case PT_LOAD: pt = "LOAD"; break;
810 case PT_DYNAMIC: pt = "DYNAMIC"; break;
811 case PT_INTERP: pt = "INTERP"; break;
812 case PT_NOTE: pt = "NOTE"; break;
813 case PT_SHLIB: pt = "SHLIB"; break;
814 case PT_PHDR: pt = "PHDR"; break;
815 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
816 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
818 fprintf (f, "%8s off 0x", pt);
819 bfd_fprintf_vma (abfd, f, p->p_offset);
820 fprintf (f, " vaddr 0x");
821 bfd_fprintf_vma (abfd, f, p->p_vaddr);
822 fprintf (f, " paddr 0x");
823 bfd_fprintf_vma (abfd, f, p->p_paddr);
824 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
825 fprintf (f, " filesz 0x");
826 bfd_fprintf_vma (abfd, f, p->p_filesz);
827 fprintf (f, " memsz 0x");
828 bfd_fprintf_vma (abfd, f, p->p_memsz);
829 fprintf (f, " flags %c%c%c",
830 (p->p_flags & PF_R) != 0 ? 'r' : '-',
831 (p->p_flags & PF_W) != 0 ? 'w' : '-',
832 (p->p_flags & PF_X) != 0 ? 'x' : '-');
833 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
834 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
839 s = bfd_get_section_by_name (abfd, ".dynamic");
843 unsigned long shlink;
844 bfd_byte *extdyn, *extdynend;
846 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
848 fprintf (f, _("\nDynamic Section:\n"));
850 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
853 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
857 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
860 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
862 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
863 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
866 extdynend = extdyn + s->_raw_size;
867 for (; extdyn < extdynend; extdyn += extdynsize)
869 Elf_Internal_Dyn dyn;
874 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
876 if (dyn.d_tag == DT_NULL)
883 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
887 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
888 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
889 case DT_PLTGOT: name = "PLTGOT"; break;
890 case DT_HASH: name = "HASH"; break;
891 case DT_STRTAB: name = "STRTAB"; break;
892 case DT_SYMTAB: name = "SYMTAB"; break;
893 case DT_RELA: name = "RELA"; break;
894 case DT_RELASZ: name = "RELASZ"; break;
895 case DT_RELAENT: name = "RELAENT"; break;
896 case DT_STRSZ: name = "STRSZ"; break;
897 case DT_SYMENT: name = "SYMENT"; break;
898 case DT_INIT: name = "INIT"; break;
899 case DT_FINI: name = "FINI"; break;
900 case DT_SONAME: name = "SONAME"; stringp = true; break;
901 case DT_RPATH: name = "RPATH"; stringp = true; break;
902 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
903 case DT_REL: name = "REL"; break;
904 case DT_RELSZ: name = "RELSZ"; break;
905 case DT_RELENT: name = "RELENT"; break;
906 case DT_PLTREL: name = "PLTREL"; break;
907 case DT_DEBUG: name = "DEBUG"; break;
908 case DT_TEXTREL: name = "TEXTREL"; break;
909 case DT_JMPREL: name = "JMPREL"; break;
910 case DT_BIND_NOW: name = "BIND_NOW"; break;
911 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
912 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
913 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
914 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
915 case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
916 case DT_FLAGS: name = "FLAGS"; break;
917 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
918 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
919 case DT_CHECKSUM: name = "CHECKSUM"; break;
920 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
921 case DT_MOVEENT: name = "MOVEENT"; break;
922 case DT_MOVESZ: name = "MOVESZ"; break;
923 case DT_FEATURE: name = "FEATURE"; break;
924 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
925 case DT_SYMINSZ: name = "SYMINSZ"; break;
926 case DT_SYMINENT: name = "SYMINENT"; break;
927 case DT_CONFIG: name = "CONFIG"; stringp = true; break;
928 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
929 case DT_AUDIT: name = "AUDIT"; stringp = true; break;
930 case DT_PLTPAD: name = "PLTPAD"; break;
931 case DT_MOVETAB: name = "MOVETAB"; break;
932 case DT_SYMINFO: name = "SYMINFO"; break;
933 case DT_RELACOUNT: name = "RELACOUNT"; break;
934 case DT_RELCOUNT: name = "RELCOUNT"; break;
935 case DT_FLAGS_1: name = "FLAGS_1"; break;
936 case DT_VERSYM: name = "VERSYM"; break;
937 case DT_VERDEF: name = "VERDEF"; break;
938 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
939 case DT_VERNEED: name = "VERNEED"; break;
940 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
941 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
942 case DT_USED: name = "USED"; break;
943 case DT_FILTER: name = "FILTER"; stringp = true; break;
946 fprintf (f, " %-11s ", name);
948 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
952 unsigned int tagv = dyn.d_un.d_val;
954 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
957 fprintf (f, "%s", string);
966 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
967 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
969 if (! _bfd_elf_slurp_version_tables (abfd))
973 if (elf_dynverdef (abfd) != 0)
975 Elf_Internal_Verdef *t;
977 fprintf (f, _("\nVersion definitions:\n"));
978 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
980 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
981 t->vd_flags, t->vd_hash, t->vd_nodename);
982 if (t->vd_auxptr->vda_nextptr != NULL)
984 Elf_Internal_Verdaux *a;
987 for (a = t->vd_auxptr->vda_nextptr;
990 fprintf (f, "%s ", a->vda_nodename);
996 if (elf_dynverref (abfd) != 0)
998 Elf_Internal_Verneed *t;
1000 fprintf (f, _("\nVersion References:\n"));
1001 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1003 Elf_Internal_Vernaux *a;
1005 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1006 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1007 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1008 a->vna_flags, a->vna_other, a->vna_nodename);
1020 /* Display ELF-specific fields of a symbol. */
1023 bfd_elf_print_symbol (abfd, filep, symbol, how)
1027 bfd_print_symbol_type how;
1029 FILE *file = (FILE *) filep;
1032 case bfd_print_symbol_name:
1033 fprintf (file, "%s", symbol->name);
1035 case bfd_print_symbol_more:
1036 fprintf (file, "elf ");
1037 bfd_fprintf_vma (abfd, file, symbol->value);
1038 fprintf (file, " %lx", (long) symbol->flags);
1040 case bfd_print_symbol_all:
1042 const char *section_name;
1043 const char *name = NULL;
1044 struct elf_backend_data *bed;
1045 unsigned char st_other;
1048 section_name = symbol->section ? symbol->section->name : "(*none*)";
1050 bed = get_elf_backend_data (abfd);
1051 if (bed->elf_backend_print_symbol_all)
1052 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1056 name = symbol->name;
1057 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
1060 fprintf (file, " %s\t", section_name);
1061 /* Print the "other" value for a symbol. For common symbols,
1062 we've already printed the size; now print the alignment.
1063 For other symbols, we have no specified alignment, and
1064 we've printed the address; now print the size. */
1065 if (bfd_is_com_section (symbol->section))
1066 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1068 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1069 bfd_fprintf_vma (abfd, file, val);
1071 /* If we have version information, print it. */
1072 if (elf_tdata (abfd)->dynversym_section != 0
1073 && (elf_tdata (abfd)->dynverdef_section != 0
1074 || elf_tdata (abfd)->dynverref_section != 0))
1076 unsigned int vernum;
1077 const char *version_string;
1079 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1082 version_string = "";
1083 else if (vernum == 1)
1084 version_string = "Base";
1085 else if (vernum <= elf_tdata (abfd)->cverdefs)
1087 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1090 Elf_Internal_Verneed *t;
1092 version_string = "";
1093 for (t = elf_tdata (abfd)->verref;
1097 Elf_Internal_Vernaux *a;
1099 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1101 if (a->vna_other == vernum)
1103 version_string = a->vna_nodename;
1110 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1111 fprintf (file, " %-11s", version_string);
1116 fprintf (file, " (%s)", version_string);
1117 for (i = 10 - strlen (version_string); i > 0; --i)
1122 /* If the st_other field is not zero, print it. */
1123 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1128 case STV_INTERNAL: fprintf (file, " .internal"); break;
1129 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1130 case STV_PROTECTED: fprintf (file, " .protected"); break;
1132 /* Some other non-defined flags are also present, so print
1134 fprintf (file, " 0x%02x", (unsigned int) st_other);
1137 fprintf (file, " %s", name);
1143 /* Create an entry in an ELF linker hash table. */
1145 struct bfd_hash_entry *
1146 _bfd_elf_link_hash_newfunc (entry, table, string)
1147 struct bfd_hash_entry *entry;
1148 struct bfd_hash_table *table;
1151 /* Allocate the structure if it has not already been allocated by a
1155 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1160 /* Call the allocation method of the superclass. */
1161 entry = _bfd_link_hash_newfunc (entry, table, string);
1164 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1165 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1167 /* Set local fields. */
1171 ret->dynstr_index = 0;
1172 ret->weakdef = NULL;
1173 ret->got.refcount = htab->init_refcount;
1174 ret->plt.refcount = htab->init_refcount;
1175 ret->linker_section_pointer = NULL;
1176 ret->verinfo.verdef = NULL;
1177 ret->vtable_entries_used = NULL;
1178 ret->vtable_entries_size = 0;
1179 ret->vtable_parent = NULL;
1180 ret->type = STT_NOTYPE;
1182 /* Assume that we have been called by a non-ELF symbol reader.
1183 This flag is then reset by the code which reads an ELF input
1184 file. This ensures that a symbol created by a non-ELF symbol
1185 reader will have the flag set correctly. */
1186 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1192 /* Copy data from an indirect symbol to its direct symbol, hiding the
1193 old indirect symbol. Also used for copying flags to a weakdef. */
1196 _bfd_elf_link_hash_copy_indirect (dir, ind)
1197 struct elf_link_hash_entry *dir, *ind;
1201 /* Copy down any references that we may have already seen to the
1202 symbol which just became indirect. */
1204 dir->elf_link_hash_flags |=
1205 (ind->elf_link_hash_flags
1206 & (ELF_LINK_HASH_REF_DYNAMIC
1207 | ELF_LINK_HASH_REF_REGULAR
1208 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1209 | ELF_LINK_NON_GOT_REF));
1211 if (ind->root.type != bfd_link_hash_indirect)
1214 /* Copy over the global and procedure linkage table refcount entries.
1215 These may have been already set up by a check_relocs routine. */
1216 tmp = dir->got.refcount;
1219 dir->got.refcount = ind->got.refcount;
1220 ind->got.refcount = tmp;
1223 BFD_ASSERT (ind->got.refcount <= 0);
1225 tmp = dir->plt.refcount;
1228 dir->plt.refcount = ind->plt.refcount;
1229 ind->plt.refcount = tmp;
1232 BFD_ASSERT (ind->plt.refcount <= 0);
1234 if (dir->dynindx == -1)
1236 dir->dynindx = ind->dynindx;
1237 dir->dynstr_index = ind->dynstr_index;
1239 ind->dynstr_index = 0;
1242 BFD_ASSERT (ind->dynindx == -1);
1246 _bfd_elf_link_hash_hide_symbol (info, h)
1247 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1248 struct elf_link_hash_entry *h;
1250 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1251 h->plt.offset = (bfd_vma) -1;
1252 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
1256 /* Initialize an ELF linker hash table. */
1259 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
1260 struct elf_link_hash_table *table;
1262 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1263 struct bfd_hash_table *,
1268 table->dynamic_sections_created = false;
1269 table->dynobj = NULL;
1270 table->init_refcount = get_elf_backend_data (abfd)->can_refcount - 1;
1271 /* The first dynamic symbol is a dummy. */
1272 table->dynsymcount = 1;
1273 table->dynstr = NULL;
1274 table->bucketcount = 0;
1275 table->needed = NULL;
1276 table->runpath = NULL;
1278 table->stab_info = NULL;
1279 table->merge_info = NULL;
1280 table->dynlocal = NULL;
1281 ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
1282 table->root.type = bfd_link_elf_hash_table;
1287 /* Create an ELF linker hash table. */
1289 struct bfd_link_hash_table *
1290 _bfd_elf_link_hash_table_create (abfd)
1293 struct elf_link_hash_table *ret;
1294 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1296 ret = (struct elf_link_hash_table *) bfd_alloc (abfd, amt);
1297 if (ret == (struct elf_link_hash_table *) NULL)
1300 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1302 bfd_release (abfd, ret);
1309 /* This is a hook for the ELF emulation code in the generic linker to
1310 tell the backend linker what file name to use for the DT_NEEDED
1311 entry for a dynamic object. The generic linker passes name as an
1312 empty string to indicate that no DT_NEEDED entry should be made. */
1315 bfd_elf_set_dt_needed_name (abfd, name)
1319 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1320 && bfd_get_format (abfd) == bfd_object)
1321 elf_dt_name (abfd) = name;
1325 bfd_elf_set_dt_needed_soname (abfd, name)
1329 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1330 && bfd_get_format (abfd) == bfd_object)
1331 elf_dt_soname (abfd) = name;
1334 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1335 the linker ELF emulation code. */
1337 struct bfd_link_needed_list *
1338 bfd_elf_get_needed_list (abfd, info)
1339 bfd *abfd ATTRIBUTE_UNUSED;
1340 struct bfd_link_info *info;
1342 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1344 return elf_hash_table (info)->needed;
1347 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1348 hook for the linker ELF emulation code. */
1350 struct bfd_link_needed_list *
1351 bfd_elf_get_runpath_list (abfd, info)
1352 bfd *abfd ATTRIBUTE_UNUSED;
1353 struct bfd_link_info *info;
1355 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1357 return elf_hash_table (info)->runpath;
1360 /* Get the name actually used for a dynamic object for a link. This
1361 is the SONAME entry if there is one. Otherwise, it is the string
1362 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1365 bfd_elf_get_dt_soname (abfd)
1368 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1369 && bfd_get_format (abfd) == bfd_object)
1370 return elf_dt_name (abfd);
1374 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1375 the ELF linker emulation code. */
1378 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1380 struct bfd_link_needed_list **pneeded;
1383 bfd_byte *dynbuf = NULL;
1385 unsigned long shlink;
1386 bfd_byte *extdyn, *extdynend;
1388 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1392 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1393 || bfd_get_format (abfd) != bfd_object)
1396 s = bfd_get_section_by_name (abfd, ".dynamic");
1397 if (s == NULL || s->_raw_size == 0)
1400 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1404 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1408 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1412 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1414 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1415 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1418 extdynend = extdyn + s->_raw_size;
1419 for (; extdyn < extdynend; extdyn += extdynsize)
1421 Elf_Internal_Dyn dyn;
1423 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1425 if (dyn.d_tag == DT_NULL)
1428 if (dyn.d_tag == DT_NEEDED)
1431 struct bfd_link_needed_list *l;
1432 unsigned int tagv = dyn.d_un.d_val;
1435 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1440 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1461 /* Allocate an ELF string table--force the first byte to be zero. */
1463 struct bfd_strtab_hash *
1464 _bfd_elf_stringtab_init ()
1466 struct bfd_strtab_hash *ret;
1468 ret = _bfd_stringtab_init ();
1473 loc = _bfd_stringtab_add (ret, "", true, false);
1474 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1475 if (loc == (bfd_size_type) -1)
1477 _bfd_stringtab_free (ret);
1484 /* ELF .o/exec file reading */
1486 /* Create a new bfd section from an ELF section header. */
1489 bfd_section_from_shdr (abfd, shindex)
1491 unsigned int shindex;
1493 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1494 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1495 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1498 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1500 switch (hdr->sh_type)
1503 /* Inactive section. Throw it away. */
1506 case SHT_PROGBITS: /* Normal section with contents. */
1507 case SHT_DYNAMIC: /* Dynamic linking information. */
1508 case SHT_NOBITS: /* .bss section. */
1509 case SHT_HASH: /* .hash section. */
1510 case SHT_NOTE: /* .note section. */
1511 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1513 case SHT_SYMTAB: /* A symbol table */
1514 if (elf_onesymtab (abfd) == shindex)
1517 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1518 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1519 elf_onesymtab (abfd) = shindex;
1520 elf_tdata (abfd)->symtab_hdr = *hdr;
1521 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1522 abfd->flags |= HAS_SYMS;
1524 /* Sometimes a shared object will map in the symbol table. If
1525 SHF_ALLOC is set, and this is a shared object, then we also
1526 treat this section as a BFD section. We can not base the
1527 decision purely on SHF_ALLOC, because that flag is sometimes
1528 set in a relocateable object file, which would confuse the
1530 if ((hdr->sh_flags & SHF_ALLOC) != 0
1531 && (abfd->flags & DYNAMIC) != 0
1532 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1537 case SHT_DYNSYM: /* A dynamic symbol table */
1538 if (elf_dynsymtab (abfd) == shindex)
1541 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1542 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1543 elf_dynsymtab (abfd) = shindex;
1544 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1545 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1546 abfd->flags |= HAS_SYMS;
1548 /* Besides being a symbol table, we also treat this as a regular
1549 section, so that objcopy can handle it. */
1550 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1552 case SHT_STRTAB: /* A string table */
1553 if (hdr->bfd_section != NULL)
1555 if (ehdr->e_shstrndx == shindex)
1557 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1558 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1564 for (i = 1; i < ehdr->e_shnum; i++)
1566 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1567 if (hdr2->sh_link == shindex)
1569 if (! bfd_section_from_shdr (abfd, i))
1571 if (elf_onesymtab (abfd) == i)
1573 elf_tdata (abfd)->strtab_hdr = *hdr;
1574 elf_elfsections (abfd)[shindex] =
1575 &elf_tdata (abfd)->strtab_hdr;
1578 if (elf_dynsymtab (abfd) == i)
1580 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1581 elf_elfsections (abfd)[shindex] = hdr =
1582 &elf_tdata (abfd)->dynstrtab_hdr;
1583 /* We also treat this as a regular section, so
1584 that objcopy can handle it. */
1587 #if 0 /* Not handling other string tables specially right now. */
1588 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1589 /* We have a strtab for some random other section. */
1590 newsect = (asection *) hdr2->bfd_section;
1593 hdr->bfd_section = newsect;
1594 hdr2 = &elf_section_data (newsect)->str_hdr;
1596 elf_elfsections (abfd)[shindex] = hdr2;
1602 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1606 /* *These* do a lot of work -- but build no sections! */
1608 asection *target_sect;
1609 Elf_Internal_Shdr *hdr2;
1611 /* Check for a bogus link to avoid crashing. */
1612 if (hdr->sh_link >= ehdr->e_shnum)
1614 ((*_bfd_error_handler)
1615 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1616 bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1617 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1620 /* For some incomprehensible reason Oracle distributes
1621 libraries for Solaris in which some of the objects have
1622 bogus sh_link fields. It would be nice if we could just
1623 reject them, but, unfortunately, some people need to use
1624 them. We scan through the section headers; if we find only
1625 one suitable symbol table, we clobber the sh_link to point
1626 to it. I hope this doesn't break anything. */
1627 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1628 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1634 for (scan = 1; scan < ehdr->e_shnum; scan++)
1636 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1637 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1648 hdr->sh_link = found;
1651 /* Get the symbol table. */
1652 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1653 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1656 /* If this reloc section does not use the main symbol table we
1657 don't treat it as a reloc section. BFD can't adequately
1658 represent such a section, so at least for now, we don't
1659 try. We just present it as a normal section. We also
1660 can't use it as a reloc section if it points to the null
1662 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1663 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1665 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1667 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1668 if (target_sect == NULL)
1671 if ((target_sect->flags & SEC_RELOC) == 0
1672 || target_sect->reloc_count == 0)
1673 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1677 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1678 amt = sizeof (*hdr2);
1679 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1680 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1683 elf_elfsections (abfd)[shindex] = hdr2;
1684 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1685 target_sect->flags |= SEC_RELOC;
1686 target_sect->relocation = NULL;
1687 target_sect->rel_filepos = hdr->sh_offset;
1688 /* In the section to which the relocations apply, mark whether
1689 its relocations are of the REL or RELA variety. */
1690 if (hdr->sh_size != 0)
1691 elf_section_data (target_sect)->use_rela_p
1692 = (hdr->sh_type == SHT_RELA);
1693 abfd->flags |= HAS_RELOC;
1698 case SHT_GNU_verdef:
1699 elf_dynverdef (abfd) = shindex;
1700 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1701 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1704 case SHT_GNU_versym:
1705 elf_dynversym (abfd) = shindex;
1706 elf_tdata (abfd)->dynversym_hdr = *hdr;
1707 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1710 case SHT_GNU_verneed:
1711 elf_dynverref (abfd) = shindex;
1712 elf_tdata (abfd)->dynverref_hdr = *hdr;
1713 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1720 /* Make a section for objcopy and relocatable links. */
1721 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
1723 if (hdr->contents != NULL)
1725 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1726 unsigned int n_elt = hdr->sh_size / 4;
1729 while (--n_elt != 0)
1730 if ((s = (++idx)->shdr->bfd_section) != NULL
1731 && elf_next_in_group (s) != NULL)
1733 elf_next_in_group (hdr->bfd_section) = s;
1740 /* Check for any processor-specific section types. */
1742 if (bed->elf_backend_section_from_shdr)
1743 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1751 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1752 Return SEC for sections that have no elf section, and NULL on error. */
1755 bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
1757 struct sym_sec_cache *cache;
1759 unsigned long r_symndx;
1761 unsigned char esym_shndx[2];
1762 unsigned int isym_shndx;
1763 Elf_Internal_Shdr *symtab_hdr;
1766 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1768 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
1769 return cache->sec[ent];
1771 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1772 pos = symtab_hdr->sh_offset;
1773 if (get_elf_backend_data (abfd)->s->sizeof_sym
1774 == sizeof (Elf64_External_Sym))
1776 pos += r_symndx * sizeof (Elf64_External_Sym);
1777 pos += offsetof (Elf64_External_Sym, st_shndx);
1781 pos += r_symndx * sizeof (Elf32_External_Sym);
1782 pos += offsetof (Elf32_External_Sym, st_shndx);
1784 amt = sizeof (esym_shndx);
1785 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1786 || bfd_bread ((PTR) esym_shndx, amt, abfd) != amt)
1788 isym_shndx = H_GET_16 (abfd, esym_shndx);
1790 if (cache->abfd != abfd)
1792 memset (cache->indx, -1, sizeof (cache->indx));
1795 cache->indx[ent] = r_symndx;
1796 cache->sec[ent] = sec;
1797 if (isym_shndx > 0 && isym_shndx < SHN_LORESERVE)
1800 s = bfd_section_from_elf_index (abfd, isym_shndx);
1802 cache->sec[ent] = s;
1804 return cache->sec[ent];
1807 /* Given an ELF section number, retrieve the corresponding BFD
1811 bfd_section_from_elf_index (abfd, index)
1815 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1816 if (index >= elf_elfheader (abfd)->e_shnum)
1818 return elf_elfsections (abfd)[index]->bfd_section;
1822 _bfd_elf_new_section_hook (abfd, sec)
1826 struct bfd_elf_section_data *sdata;
1827 bfd_size_type amt = sizeof (*sdata);
1829 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
1832 sec->used_by_bfd = (PTR) sdata;
1834 /* Indicate whether or not this section should use RELA relocations. */
1836 = get_elf_backend_data (abfd)->default_use_rela_p;
1841 /* Create a new bfd section from an ELF program header.
1843 Since program segments have no names, we generate a synthetic name
1844 of the form segment<NUM>, where NUM is generally the index in the
1845 program header table. For segments that are split (see below) we
1846 generate the names segment<NUM>a and segment<NUM>b.
1848 Note that some program segments may have a file size that is different than
1849 (less than) the memory size. All this means is that at execution the
1850 system must allocate the amount of memory specified by the memory size,
1851 but only initialize it with the first "file size" bytes read from the
1852 file. This would occur for example, with program segments consisting
1853 of combined data+bss.
1855 To handle the above situation, this routine generates TWO bfd sections
1856 for the single program segment. The first has the length specified by
1857 the file size of the segment, and the second has the length specified
1858 by the difference between the two sizes. In effect, the segment is split
1859 into it's initialized and uninitialized parts.
1864 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1866 Elf_Internal_Phdr *hdr;
1868 const char *typename;
1875 split = ((hdr->p_memsz > 0)
1876 && (hdr->p_filesz > 0)
1877 && (hdr->p_memsz > hdr->p_filesz));
1878 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1879 name = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
1882 strcpy (name, namebuf);
1883 newsect = bfd_make_section (abfd, name);
1884 if (newsect == NULL)
1886 newsect->vma = hdr->p_vaddr;
1887 newsect->lma = hdr->p_paddr;
1888 newsect->_raw_size = hdr->p_filesz;
1889 newsect->filepos = hdr->p_offset;
1890 newsect->flags |= SEC_HAS_CONTENTS;
1891 if (hdr->p_type == PT_LOAD)
1893 newsect->flags |= SEC_ALLOC;
1894 newsect->flags |= SEC_LOAD;
1895 if (hdr->p_flags & PF_X)
1897 /* FIXME: all we known is that it has execute PERMISSION,
1899 newsect->flags |= SEC_CODE;
1902 if (!(hdr->p_flags & PF_W))
1904 newsect->flags |= SEC_READONLY;
1909 sprintf (namebuf, "%s%db", typename, index);
1910 name = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
1913 strcpy (name, namebuf);
1914 newsect = bfd_make_section (abfd, name);
1915 if (newsect == NULL)
1917 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1918 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1919 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1920 if (hdr->p_type == PT_LOAD)
1922 newsect->flags |= SEC_ALLOC;
1923 if (hdr->p_flags & PF_X)
1924 newsect->flags |= SEC_CODE;
1926 if (!(hdr->p_flags & PF_W))
1927 newsect->flags |= SEC_READONLY;
1934 bfd_section_from_phdr (abfd, hdr, index)
1936 Elf_Internal_Phdr *hdr;
1939 struct elf_backend_data *bed;
1941 switch (hdr->p_type)
1944 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
1947 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
1950 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
1953 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
1956 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
1958 if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
1963 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
1966 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
1969 /* Check for any processor-specific program segment types.
1970 If no handler for them, default to making "segment" sections. */
1971 bed = get_elf_backend_data (abfd);
1972 if (bed->elf_backend_section_from_phdr)
1973 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
1975 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
1979 /* Initialize REL_HDR, the section-header for new section, containing
1980 relocations against ASECT. If USE_RELA_P is true, we use RELA
1981 relocations; otherwise, we use REL relocations. */
1984 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
1986 Elf_Internal_Shdr *rel_hdr;
1991 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1992 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
1994 name = bfd_alloc (abfd, amt);
1997 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1999 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2001 if (rel_hdr->sh_name == (unsigned int) -1)
2003 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2004 rel_hdr->sh_entsize = (use_rela_p
2005 ? bed->s->sizeof_rela
2006 : bed->s->sizeof_rel);
2007 rel_hdr->sh_addralign = bed->s->file_align;
2008 rel_hdr->sh_flags = 0;
2009 rel_hdr->sh_addr = 0;
2010 rel_hdr->sh_size = 0;
2011 rel_hdr->sh_offset = 0;
2016 /* Set up an ELF internal section header for a section. */
2019 elf_fake_sections (abfd, asect, failedptrarg)
2024 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2025 boolean *failedptr = (boolean *) failedptrarg;
2026 Elf_Internal_Shdr *this_hdr;
2030 /* We already failed; just get out of the bfd_map_over_sections
2035 this_hdr = &elf_section_data (asect)->this_hdr;
2037 this_hdr->sh_name = (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2038 asect->name, false);
2039 if (this_hdr->sh_name == (unsigned long) -1)
2045 this_hdr->sh_flags = 0;
2047 if ((asect->flags & SEC_ALLOC) != 0
2048 || asect->user_set_vma)
2049 this_hdr->sh_addr = asect->vma;
2051 this_hdr->sh_addr = 0;
2053 this_hdr->sh_offset = 0;
2054 this_hdr->sh_size = asect->_raw_size;
2055 this_hdr->sh_link = 0;
2056 this_hdr->sh_addralign = 1 << asect->alignment_power;
2057 /* The sh_entsize and sh_info fields may have been set already by
2058 copy_private_section_data. */
2060 this_hdr->bfd_section = asect;
2061 this_hdr->contents = NULL;
2063 /* FIXME: This should not be based on section names. */
2064 if (strcmp (asect->name, ".dynstr") == 0)
2065 this_hdr->sh_type = SHT_STRTAB;
2066 else if (strcmp (asect->name, ".hash") == 0)
2068 this_hdr->sh_type = SHT_HASH;
2069 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2071 else if (strcmp (asect->name, ".dynsym") == 0)
2073 this_hdr->sh_type = SHT_DYNSYM;
2074 this_hdr->sh_entsize = bed->s->sizeof_sym;
2076 else if (strcmp (asect->name, ".dynamic") == 0)
2078 this_hdr->sh_type = SHT_DYNAMIC;
2079 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2081 else if (strncmp (asect->name, ".rela", 5) == 0
2082 && get_elf_backend_data (abfd)->may_use_rela_p)
2084 this_hdr->sh_type = SHT_RELA;
2085 this_hdr->sh_entsize = bed->s->sizeof_rela;
2087 else if (strncmp (asect->name, ".rel", 4) == 0
2088 && get_elf_backend_data (abfd)->may_use_rel_p)
2090 this_hdr->sh_type = SHT_REL;
2091 this_hdr->sh_entsize = bed->s->sizeof_rel;
2093 else if (strncmp (asect->name, ".note", 5) == 0)
2094 this_hdr->sh_type = SHT_NOTE;
2095 else if (strncmp (asect->name, ".stab", 5) == 0
2096 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
2097 this_hdr->sh_type = SHT_STRTAB;
2098 else if (strcmp (asect->name, ".gnu.version") == 0)
2100 this_hdr->sh_type = SHT_GNU_versym;
2101 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2103 else if (strcmp (asect->name, ".gnu.version_d") == 0)
2105 this_hdr->sh_type = SHT_GNU_verdef;
2106 this_hdr->sh_entsize = 0;
2107 /* objcopy or strip will copy over sh_info, but may not set
2108 cverdefs. The linker will set cverdefs, but sh_info will be
2110 if (this_hdr->sh_info == 0)
2111 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2113 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2114 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2116 else if (strcmp (asect->name, ".gnu.version_r") == 0)
2118 this_hdr->sh_type = SHT_GNU_verneed;
2119 this_hdr->sh_entsize = 0;
2120 /* objcopy or strip will copy over sh_info, but may not set
2121 cverrefs. The linker will set cverrefs, but sh_info will be
2123 if (this_hdr->sh_info == 0)
2124 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2126 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2127 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2129 else if ((asect->flags & SEC_GROUP) != 0)
2131 this_hdr->sh_type = SHT_GROUP;
2132 this_hdr->sh_entsize = 4;
2134 else if ((asect->flags & SEC_ALLOC) != 0
2135 && ((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0))
2136 this_hdr->sh_type = SHT_NOBITS;
2138 this_hdr->sh_type = SHT_PROGBITS;
2140 if ((asect->flags & SEC_ALLOC) != 0)
2141 this_hdr->sh_flags |= SHF_ALLOC;
2142 if ((asect->flags & SEC_READONLY) == 0)
2143 this_hdr->sh_flags |= SHF_WRITE;
2144 if ((asect->flags & SEC_CODE) != 0)
2145 this_hdr->sh_flags |= SHF_EXECINSTR;
2146 if ((asect->flags & SEC_MERGE) != 0)
2148 this_hdr->sh_flags |= SHF_MERGE;
2149 this_hdr->sh_entsize = asect->entsize;
2150 if ((asect->flags & SEC_STRINGS) != 0)
2151 this_hdr->sh_flags |= SHF_STRINGS;
2153 if (elf_group_name (asect) != NULL)
2154 this_hdr->sh_flags |= SHF_GROUP;
2156 /* Check for processor-specific section types. */
2157 if (bed->elf_backend_fake_sections)
2158 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
2160 /* If the section has relocs, set up a section header for the
2161 SHT_REL[A] section. If two relocation sections are required for
2162 this section, it is up to the processor-specific back-end to
2163 create the other. */
2164 if ((asect->flags & SEC_RELOC) != 0
2165 && !_bfd_elf_init_reloc_shdr (abfd,
2166 &elf_section_data (asect)->rel_hdr,
2168 elf_section_data (asect)->use_rela_p))
2172 /* Fill in the contents of a SHT_GROUP section. */
2175 set_group_contents (abfd, sec, failedptrarg)
2178 PTR failedptrarg ATTRIBUTE_UNUSED;
2180 boolean *failedptr = (boolean *) failedptrarg;
2181 unsigned long symindx;
2184 struct bfd_link_order *l;
2186 if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2190 /* If called from the assembler, swap_out_syms will have set up
2191 elf_section_syms; If called for "ld -r", the symbols won't yet
2192 be mapped, so emulate elf_bfd_final_link. */
2193 if (elf_section_syms (abfd) != NULL)
2194 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2196 symindx = elf_section_data (sec)->this_idx;
2197 elf_section_data (sec)->this_hdr.sh_info = symindx;
2199 /* Nor will the contents be allocated for "ld -r". */
2200 if (sec->contents == NULL)
2202 sec->contents = bfd_alloc (abfd, sec->_raw_size);
2203 if (sec->contents == NULL)
2210 loc = sec->contents + sec->_raw_size;
2212 /* Get the pointer to the first section in the group that we
2213 squirreled away here. */
2214 elt = elf_next_in_group (sec);
2216 /* First element is a flag word. Rest of section is elf section
2217 indices for all the sections of the group. Write them backwards
2218 just to keep the group in the same order as given in .section
2219 directives, not that it matters. */
2223 H_PUT_32 (abfd, elf_section_data (elt)->this_idx, loc);
2224 elt = elf_next_in_group (elt);
2227 /* If this is a relocatable link, then the above did nothing because
2228 SEC is the output section. Look through the input sections
2230 for (l = sec->link_order_head; l != NULL; l = l->next)
2231 if (l->type == bfd_indirect_link_order
2232 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2237 elf_section_data (elt->output_section)->this_idx, loc);
2238 elt = elf_next_in_group (elt);
2239 /* During a relocatable link, the lists are circular. */
2241 while (elt != elf_next_in_group (l->u.indirect.section));
2244 H_PUT_32 (abfd, 0, loc);
2246 BFD_ASSERT (loc == sec->contents);
2249 /* Assign all ELF section numbers. The dummy first section is handled here
2250 too. The link/info pointers for the standard section types are filled
2251 in here too, while we're at it. */
2254 assign_section_numbers (abfd)
2257 struct elf_obj_tdata *t = elf_tdata (abfd);
2259 unsigned int section_number, secn;
2260 Elf_Internal_Shdr **i_shdrp;
2265 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2267 for (sec = abfd->sections; sec; sec = sec->next)
2269 struct bfd_elf_section_data *d = elf_section_data (sec);
2271 d->this_idx = section_number++;
2272 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2273 if ((sec->flags & SEC_RELOC) == 0)
2277 d->rel_idx = section_number++;
2278 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2283 d->rel_idx2 = section_number++;
2284 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2290 t->shstrtab_section = section_number++;
2291 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2292 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2294 if (bfd_get_symcount (abfd) > 0)
2296 t->symtab_section = section_number++;
2297 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2298 t->strtab_section = section_number++;
2299 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2302 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2303 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2304 elf_elfheader (abfd)->e_shnum = section_number;
2306 /* Set up the list of section header pointers, in agreement with the
2308 amt = section_number * sizeof (Elf_Internal_Shdr *);
2309 i_shdrp = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
2310 if (i_shdrp == NULL)
2313 amt = sizeof (Elf_Internal_Shdr);
2314 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
2315 if (i_shdrp[0] == NULL)
2317 bfd_release (abfd, i_shdrp);
2320 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
2322 elf_elfsections (abfd) = i_shdrp;
2324 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2325 if (bfd_get_symcount (abfd) > 0)
2327 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2328 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2329 t->symtab_hdr.sh_link = t->strtab_section;
2331 for (sec = abfd->sections; sec; sec = sec->next)
2333 struct bfd_elf_section_data *d = elf_section_data (sec);
2337 i_shdrp[d->this_idx] = &d->this_hdr;
2338 if (d->rel_idx != 0)
2339 i_shdrp[d->rel_idx] = &d->rel_hdr;
2340 if (d->rel_idx2 != 0)
2341 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2343 /* Fill in the sh_link and sh_info fields while we're at it. */
2345 /* sh_link of a reloc section is the section index of the symbol
2346 table. sh_info is the section index of the section to which
2347 the relocation entries apply. */
2348 if (d->rel_idx != 0)
2350 d->rel_hdr.sh_link = t->symtab_section;
2351 d->rel_hdr.sh_info = d->this_idx;
2353 if (d->rel_idx2 != 0)
2355 d->rel_hdr2->sh_link = t->symtab_section;
2356 d->rel_hdr2->sh_info = d->this_idx;
2359 switch (d->this_hdr.sh_type)
2363 /* A reloc section which we are treating as a normal BFD
2364 section. sh_link is the section index of the symbol
2365 table. sh_info is the section index of the section to
2366 which the relocation entries apply. We assume that an
2367 allocated reloc section uses the dynamic symbol table.
2368 FIXME: How can we be sure? */
2369 s = bfd_get_section_by_name (abfd, ".dynsym");
2371 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2373 /* We look up the section the relocs apply to by name. */
2375 if (d->this_hdr.sh_type == SHT_REL)
2379 s = bfd_get_section_by_name (abfd, name);
2381 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2385 /* We assume that a section named .stab*str is a stabs
2386 string section. We look for a section with the same name
2387 but without the trailing ``str'', and set its sh_link
2388 field to point to this section. */
2389 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2390 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2395 len = strlen (sec->name);
2396 alc = (char *) bfd_malloc ((bfd_size_type) len - 2);
2399 strncpy (alc, sec->name, len - 3);
2400 alc[len - 3] = '\0';
2401 s = bfd_get_section_by_name (abfd, alc);
2405 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2407 /* This is a .stab section. */
2408 elf_section_data (s)->this_hdr.sh_entsize =
2409 4 + 2 * bfd_get_arch_size (abfd) / 8;
2416 case SHT_GNU_verneed:
2417 case SHT_GNU_verdef:
2418 /* sh_link is the section header index of the string table
2419 used for the dynamic entries, or the symbol table, or the
2421 s = bfd_get_section_by_name (abfd, ".dynstr");
2423 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2427 case SHT_GNU_versym:
2428 /* sh_link is the section header index of the symbol table
2429 this hash table or version table is for. */
2430 s = bfd_get_section_by_name (abfd, ".dynsym");
2432 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2436 d->this_hdr.sh_link = t->symtab_section;
2440 for (secn = 1; secn < section_number; ++secn)
2441 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2442 i_shdrp[secn]->sh_name);
2447 /* Map symbol from it's internal number to the external number, moving
2448 all local symbols to be at the head of the list. */
2451 sym_is_global (abfd, sym)
2455 /* If the backend has a special mapping, use it. */
2456 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2457 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2460 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2461 || bfd_is_und_section (bfd_get_section (sym))
2462 || bfd_is_com_section (bfd_get_section (sym)));
2466 elf_map_symbols (abfd)
2469 unsigned int symcount = bfd_get_symcount (abfd);
2470 asymbol **syms = bfd_get_outsymbols (abfd);
2471 asymbol **sect_syms;
2472 unsigned int num_locals = 0;
2473 unsigned int num_globals = 0;
2474 unsigned int num_locals2 = 0;
2475 unsigned int num_globals2 = 0;
2483 fprintf (stderr, "elf_map_symbols\n");
2487 for (asect = abfd->sections; asect; asect = asect->next)
2489 if (max_index < asect->index)
2490 max_index = asect->index;
2494 amt = max_index * sizeof (asymbol *);
2495 sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
2496 if (sect_syms == NULL)
2498 elf_section_syms (abfd) = sect_syms;
2499 elf_num_section_syms (abfd) = max_index;
2501 /* Init sect_syms entries for any section symbols we have already
2502 decided to output. */
2503 for (idx = 0; idx < symcount; idx++)
2505 asymbol *sym = syms[idx];
2507 if ((sym->flags & BSF_SECTION_SYM) != 0
2514 if (sec->owner != NULL)
2516 if (sec->owner != abfd)
2518 if (sec->output_offset != 0)
2521 sec = sec->output_section;
2523 /* Empty sections in the input files may have had a
2524 section symbol created for them. (See the comment
2525 near the end of _bfd_generic_link_output_symbols in
2526 linker.c). If the linker script discards such
2527 sections then we will reach this point. Since we know
2528 that we cannot avoid this case, we detect it and skip
2529 the abort and the assignment to the sect_syms array.
2530 To reproduce this particular case try running the
2531 linker testsuite test ld-scripts/weak.exp for an ELF
2532 port that uses the generic linker. */
2533 if (sec->owner == NULL)
2536 BFD_ASSERT (sec->owner == abfd);
2538 sect_syms[sec->index] = syms[idx];
2543 /* Classify all of the symbols. */
2544 for (idx = 0; idx < symcount; idx++)
2546 if (!sym_is_global (abfd, syms[idx]))
2552 /* We will be adding a section symbol for each BFD section. Most normal
2553 sections will already have a section symbol in outsymbols, but
2554 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2555 at least in that case. */
2556 for (asect = abfd->sections; asect; asect = asect->next)
2558 if (sect_syms[asect->index] == NULL)
2560 if (!sym_is_global (abfd, asect->symbol))
2567 /* Now sort the symbols so the local symbols are first. */
2568 amt = (num_locals + num_globals) * sizeof (asymbol *);
2569 new_syms = (asymbol **) bfd_alloc (abfd, amt);
2571 if (new_syms == NULL)
2574 for (idx = 0; idx < symcount; idx++)
2576 asymbol *sym = syms[idx];
2579 if (!sym_is_global (abfd, sym))
2582 i = num_locals + num_globals2++;
2584 sym->udata.i = i + 1;
2586 for (asect = abfd->sections; asect; asect = asect->next)
2588 if (sect_syms[asect->index] == NULL)
2590 asymbol *sym = asect->symbol;
2593 sect_syms[asect->index] = sym;
2594 if (!sym_is_global (abfd, sym))
2597 i = num_locals + num_globals2++;
2599 sym->udata.i = i + 1;
2603 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2605 elf_num_locals (abfd) = num_locals;
2606 elf_num_globals (abfd) = num_globals;
2610 /* Align to the maximum file alignment that could be required for any
2611 ELF data structure. */
2613 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2614 static INLINE file_ptr
2615 align_file_position (off, align)
2619 return (off + align - 1) & ~(align - 1);
2622 /* Assign a file position to a section, optionally aligning to the
2623 required section alignment. */
2626 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2627 Elf_Internal_Shdr *i_shdrp;
2635 al = i_shdrp->sh_addralign;
2637 offset = BFD_ALIGN (offset, al);
2639 i_shdrp->sh_offset = offset;
2640 if (i_shdrp->bfd_section != NULL)
2641 i_shdrp->bfd_section->filepos = offset;
2642 if (i_shdrp->sh_type != SHT_NOBITS)
2643 offset += i_shdrp->sh_size;
2647 /* Compute the file positions we are going to put the sections at, and
2648 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2649 is not NULL, this is being called by the ELF backend linker. */
2652 _bfd_elf_compute_section_file_positions (abfd, link_info)
2654 struct bfd_link_info *link_info;
2656 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2658 struct bfd_strtab_hash *strtab;
2659 Elf_Internal_Shdr *shstrtab_hdr;
2661 if (abfd->output_has_begun)
2664 /* Do any elf backend specific processing first. */
2665 if (bed->elf_backend_begin_write_processing)
2666 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2668 if (! prep_headers (abfd))
2671 /* Post process the headers if necessary. */
2672 if (bed->elf_backend_post_process_headers)
2673 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2676 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2680 if (!assign_section_numbers (abfd))
2683 /* The backend linker builds symbol table information itself. */
2684 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2686 /* Non-zero if doing a relocatable link. */
2687 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2689 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2693 if (link_info == NULL || link_info->relocateable)
2695 bfd_map_over_sections (abfd, set_group_contents, &failed);
2700 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2701 /* sh_name was set in prep_headers. */
2702 shstrtab_hdr->sh_type = SHT_STRTAB;
2703 shstrtab_hdr->sh_flags = 0;
2704 shstrtab_hdr->sh_addr = 0;
2705 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2706 shstrtab_hdr->sh_entsize = 0;
2707 shstrtab_hdr->sh_link = 0;
2708 shstrtab_hdr->sh_info = 0;
2709 /* sh_offset is set in assign_file_positions_except_relocs. */
2710 shstrtab_hdr->sh_addralign = 1;
2712 if (!assign_file_positions_except_relocs (abfd))
2715 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2718 Elf_Internal_Shdr *hdr;
2720 off = elf_tdata (abfd)->next_file_pos;
2722 hdr = &elf_tdata (abfd)->symtab_hdr;
2723 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2725 hdr = &elf_tdata (abfd)->strtab_hdr;
2726 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2728 elf_tdata (abfd)->next_file_pos = off;
2730 /* Now that we know where the .strtab section goes, write it
2732 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2733 || ! _bfd_stringtab_emit (abfd, strtab))
2735 _bfd_stringtab_free (strtab);
2738 abfd->output_has_begun = true;
2743 /* Create a mapping from a set of sections to a program segment. */
2745 static INLINE struct elf_segment_map *
2746 make_mapping (abfd, sections, from, to, phdr)
2748 asection **sections;
2753 struct elf_segment_map *m;
2758 amt = sizeof (struct elf_segment_map);
2759 amt += (to - from - 1) * sizeof (asection *);
2760 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2764 m->p_type = PT_LOAD;
2765 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2766 m->sections[i - from] = *hdrpp;
2767 m->count = to - from;
2769 if (from == 0 && phdr)
2771 /* Include the headers in the first PT_LOAD segment. */
2772 m->includes_filehdr = 1;
2773 m->includes_phdrs = 1;
2779 /* Set up a mapping from BFD sections to program segments. */
2782 map_sections_to_segments (abfd)
2785 asection **sections = NULL;
2789 struct elf_segment_map *mfirst;
2790 struct elf_segment_map **pm;
2791 struct elf_segment_map *m;
2793 unsigned int phdr_index;
2794 bfd_vma maxpagesize;
2796 boolean phdr_in_segment = true;
2798 asection *dynsec, *eh_frame_hdr;
2801 if (elf_tdata (abfd)->segment_map != NULL)
2804 if (bfd_count_sections (abfd) == 0)
2807 /* Select the allocated sections, and sort them. */
2809 amt = bfd_count_sections (abfd) * sizeof (asection *);
2810 sections = (asection **) bfd_malloc (amt);
2811 if (sections == NULL)
2815 for (s = abfd->sections; s != NULL; s = s->next)
2817 if ((s->flags & SEC_ALLOC) != 0)
2823 BFD_ASSERT (i <= bfd_count_sections (abfd));
2826 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2828 /* Build the mapping. */
2833 /* If we have a .interp section, then create a PT_PHDR segment for
2834 the program headers and a PT_INTERP segment for the .interp
2836 s = bfd_get_section_by_name (abfd, ".interp");
2837 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2839 amt = sizeof (struct elf_segment_map);
2840 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2844 m->p_type = PT_PHDR;
2845 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2846 m->p_flags = PF_R | PF_X;
2847 m->p_flags_valid = 1;
2848 m->includes_phdrs = 1;
2853 amt = sizeof (struct elf_segment_map);
2854 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2858 m->p_type = PT_INTERP;
2866 /* Look through the sections. We put sections in the same program
2867 segment when the start of the second section can be placed within
2868 a few bytes of the end of the first section. */
2871 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2873 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2875 && (dynsec->flags & SEC_LOAD) == 0)
2878 /* Deal with -Ttext or something similar such that the first section
2879 is not adjacent to the program headers. This is an
2880 approximation, since at this point we don't know exactly how many
2881 program headers we will need. */
2884 bfd_size_type phdr_size;
2886 phdr_size = elf_tdata (abfd)->program_header_size;
2888 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2889 if ((abfd->flags & D_PAGED) == 0
2890 || sections[0]->lma < phdr_size
2891 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2892 phdr_in_segment = false;
2895 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2898 boolean new_segment;
2902 /* See if this section and the last one will fit in the same
2905 if (last_hdr == NULL)
2907 /* If we don't have a segment yet, then we don't need a new
2908 one (we build the last one after this loop). */
2909 new_segment = false;
2911 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2913 /* If this section has a different relation between the
2914 virtual address and the load address, then we need a new
2918 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2919 < BFD_ALIGN (hdr->lma, maxpagesize))
2921 /* If putting this section in this segment would force us to
2922 skip a page in the segment, then we need a new segment. */
2925 else if ((last_hdr->flags & SEC_LOAD) == 0
2926 && (hdr->flags & SEC_LOAD) != 0)
2928 /* We don't want to put a loadable section after a
2929 nonloadable section in the same segment. */
2932 else if ((abfd->flags & D_PAGED) == 0)
2934 /* If the file is not demand paged, which means that we
2935 don't require the sections to be correctly aligned in the
2936 file, then there is no other reason for a new segment. */
2937 new_segment = false;
2940 && (hdr->flags & SEC_READONLY) == 0
2941 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2944 /* We don't want to put a writable section in a read only
2945 segment, unless they are on the same page in memory
2946 anyhow. We already know that the last section does not
2947 bring us past the current section on the page, so the
2948 only case in which the new section is not on the same
2949 page as the previous section is when the previous section
2950 ends precisely on a page boundary. */
2955 /* Otherwise, we can use the same segment. */
2956 new_segment = false;
2961 if ((hdr->flags & SEC_READONLY) == 0)
2967 /* We need a new program segment. We must create a new program
2968 header holding all the sections from phdr_index until hdr. */
2970 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2977 if ((hdr->flags & SEC_READONLY) == 0)
2984 phdr_in_segment = false;
2987 /* Create a final PT_LOAD program segment. */
2988 if (last_hdr != NULL)
2990 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2998 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3001 amt = sizeof (struct elf_segment_map);
3002 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3006 m->p_type = PT_DYNAMIC;
3008 m->sections[0] = dynsec;
3014 /* For each loadable .note section, add a PT_NOTE segment. We don't
3015 use bfd_get_section_by_name, because if we link together
3016 nonloadable .note sections and loadable .note sections, we will
3017 generate two .note sections in the output file. FIXME: Using
3018 names for section types is bogus anyhow. */
3019 for (s = abfd->sections; s != NULL; s = s->next)
3021 if ((s->flags & SEC_LOAD) != 0
3022 && strncmp (s->name, ".note", 5) == 0)
3024 amt = sizeof (struct elf_segment_map);
3025 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3029 m->p_type = PT_NOTE;
3038 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3040 eh_frame_hdr = bfd_get_section_by_name (abfd, ".eh_frame_hdr");
3041 if (eh_frame_hdr != NULL && (eh_frame_hdr->flags & SEC_LOAD))
3043 amt = sizeof (struct elf_segment_map);
3044 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3048 m->p_type = PT_GNU_EH_FRAME;
3050 m->sections[0] = eh_frame_hdr;
3059 elf_tdata (abfd)->segment_map = mfirst;
3063 if (sections != NULL)
3068 /* Sort sections by address. */
3071 elf_sort_sections (arg1, arg2)
3075 const asection *sec1 = *(const asection **) arg1;
3076 const asection *sec2 = *(const asection **) arg2;
3078 /* Sort by LMA first, since this is the address used to
3079 place the section into a segment. */
3080 if (sec1->lma < sec2->lma)
3082 else if (sec1->lma > sec2->lma)
3085 /* Then sort by VMA. Normally the LMA and the VMA will be
3086 the same, and this will do nothing. */
3087 if (sec1->vma < sec2->vma)
3089 else if (sec1->vma > sec2->vma)
3092 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3094 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3100 /* If the indicies are the same, do not return 0
3101 here, but continue to try the next comparison. */
3102 if (sec1->target_index - sec2->target_index != 0)
3103 return sec1->target_index - sec2->target_index;
3108 else if (TOEND (sec2))
3113 /* Sort by size, to put zero sized sections
3114 before others at the same address. */
3116 if (sec1->_raw_size < sec2->_raw_size)
3118 if (sec1->_raw_size > sec2->_raw_size)
3121 return sec1->target_index - sec2->target_index;
3124 /* Assign file positions to the sections based on the mapping from
3125 sections to segments. This function also sets up some fields in
3126 the file header, and writes out the program headers. */
3129 assign_file_positions_for_segments (abfd)
3132 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3134 struct elf_segment_map *m;
3136 Elf_Internal_Phdr *phdrs;
3138 bfd_vma filehdr_vaddr, filehdr_paddr;
3139 bfd_vma phdrs_vaddr, phdrs_paddr;
3140 Elf_Internal_Phdr *p;
3143 if (elf_tdata (abfd)->segment_map == NULL)
3145 if (! map_sections_to_segments (abfd))
3149 if (bed->elf_backend_modify_segment_map)
3151 if (! (*bed->elf_backend_modify_segment_map) (abfd))
3156 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3159 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3160 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3161 elf_elfheader (abfd)->e_phnum = count;
3166 /* If we already counted the number of program segments, make sure
3167 that we allocated enough space. This happens when SIZEOF_HEADERS
3168 is used in a linker script. */
3169 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3170 if (alloc != 0 && count > alloc)
3172 ((*_bfd_error_handler)
3173 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3174 bfd_get_filename (abfd), alloc, count));
3175 bfd_set_error (bfd_error_bad_value);
3182 amt = alloc * sizeof (Elf_Internal_Phdr);
3183 phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
3187 off = bed->s->sizeof_ehdr;
3188 off += alloc * bed->s->sizeof_phdr;
3195 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3202 /* If elf_segment_map is not from map_sections_to_segments, the
3203 sections may not be correctly ordered. */
3205 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3208 p->p_type = m->p_type;
3209 p->p_flags = m->p_flags;
3211 if (p->p_type == PT_LOAD
3213 && (m->sections[0]->flags & SEC_ALLOC) != 0)
3215 if ((abfd->flags & D_PAGED) != 0)
3216 off += (m->sections[0]->vma - off) % bed->maxpagesize;
3219 bfd_size_type align;
3222 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3224 bfd_size_type secalign;
3226 secalign = bfd_get_section_alignment (abfd, *secpp);
3227 if (secalign > align)
3231 off += (m->sections[0]->vma - off) % (1 << align);
3238 p->p_vaddr = m->sections[0]->vma;
3240 if (m->p_paddr_valid)
3241 p->p_paddr = m->p_paddr;
3242 else if (m->count == 0)
3245 p->p_paddr = m->sections[0]->lma;
3247 if (p->p_type == PT_LOAD
3248 && (abfd->flags & D_PAGED) != 0)
3249 p->p_align = bed->maxpagesize;
3250 else if (m->count == 0)
3251 p->p_align = bed->s->file_align;
3259 if (m->includes_filehdr)
3261 if (! m->p_flags_valid)
3264 p->p_filesz = bed->s->sizeof_ehdr;
3265 p->p_memsz = bed->s->sizeof_ehdr;
3268 BFD_ASSERT (p->p_type == PT_LOAD);
3270 if (p->p_vaddr < (bfd_vma) off)
3272 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
3273 bfd_get_filename (abfd));
3274 bfd_set_error (bfd_error_bad_value);
3279 if (! m->p_paddr_valid)
3282 if (p->p_type == PT_LOAD)
3284 filehdr_vaddr = p->p_vaddr;
3285 filehdr_paddr = p->p_paddr;
3289 if (m->includes_phdrs)
3291 if (! m->p_flags_valid)
3294 if (m->includes_filehdr)
3296 if (p->p_type == PT_LOAD)
3298 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3299 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3304 p->p_offset = bed->s->sizeof_ehdr;
3308 BFD_ASSERT (p->p_type == PT_LOAD);
3309 p->p_vaddr -= off - p->p_offset;
3310 if (! m->p_paddr_valid)
3311 p->p_paddr -= off - p->p_offset;
3314 if (p->p_type == PT_LOAD)
3316 phdrs_vaddr = p->p_vaddr;
3317 phdrs_paddr = p->p_paddr;
3320 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3323 p->p_filesz += alloc * bed->s->sizeof_phdr;
3324 p->p_memsz += alloc * bed->s->sizeof_phdr;
3327 if (p->p_type == PT_LOAD
3328 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3330 if (! m->includes_filehdr && ! m->includes_phdrs)
3336 adjust = off - (p->p_offset + p->p_filesz);
3337 p->p_filesz += adjust;
3338 p->p_memsz += adjust;
3344 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3348 bfd_size_type align;
3352 align = 1 << bfd_get_section_alignment (abfd, sec);
3354 /* The section may have artificial alignment forced by a
3355 link script. Notice this case by the gap between the
3356 cumulative phdr lma and the section's lma. */
3357 if (p->p_paddr + p->p_memsz < sec->lma)
3359 bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3361 p->p_memsz += adjust;
3364 if ((flags & SEC_LOAD) != 0)
3365 p->p_filesz += adjust;
3368 if (p->p_type == PT_LOAD)
3370 bfd_signed_vma adjust;
3372 if ((flags & SEC_LOAD) != 0)
3374 adjust = sec->lma - (p->p_paddr + p->p_memsz);
3378 else if ((flags & SEC_ALLOC) != 0)
3380 /* The section VMA must equal the file position
3381 modulo the page size. FIXME: I'm not sure if
3382 this adjustment is really necessary. We used to
3383 not have the SEC_LOAD case just above, and then
3384 this was necessary, but now I'm not sure. */
3385 if ((abfd->flags & D_PAGED) != 0)
3386 adjust = (sec->vma - voff) % bed->maxpagesize;
3388 adjust = (sec->vma - voff) % align;
3397 (* _bfd_error_handler) (_("\
3398 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3399 bfd_section_name (abfd, sec),
3404 p->p_memsz += adjust;
3407 if ((flags & SEC_LOAD) != 0)
3408 p->p_filesz += adjust;
3413 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3414 used in a linker script we may have a section with
3415 SEC_LOAD clear but which is supposed to have
3417 if ((flags & SEC_LOAD) != 0
3418 || (flags & SEC_HAS_CONTENTS) != 0)
3419 off += sec->_raw_size;
3421 if ((flags & SEC_ALLOC) != 0)
3422 voff += sec->_raw_size;
3425 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3427 /* The actual "note" segment has i == 0.
3428 This is the one that actually contains everything. */
3432 p->p_filesz = sec->_raw_size;
3433 off += sec->_raw_size;
3438 /* Fake sections -- don't need to be written. */
3441 flags = sec->flags = 0;
3448 p->p_memsz += sec->_raw_size;
3450 if ((flags & SEC_LOAD) != 0)
3451 p->p_filesz += sec->_raw_size;
3453 if (align > p->p_align
3454 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3458 if (! m->p_flags_valid)
3461 if ((flags & SEC_CODE) != 0)
3463 if ((flags & SEC_READONLY) == 0)
3469 /* Now that we have set the section file positions, we can set up
3470 the file positions for the non PT_LOAD segments. */
3471 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3475 if (p->p_type != PT_LOAD && m->count > 0)
3477 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3478 p->p_offset = m->sections[0]->filepos;
3482 if (m->includes_filehdr)
3484 p->p_vaddr = filehdr_vaddr;
3485 if (! m->p_paddr_valid)
3486 p->p_paddr = filehdr_paddr;
3488 else if (m->includes_phdrs)
3490 p->p_vaddr = phdrs_vaddr;
3491 if (! m->p_paddr_valid)
3492 p->p_paddr = phdrs_paddr;
3497 /* Clear out any program headers we allocated but did not use. */
3498 for (; count < alloc; count++, p++)
3500 memset (p, 0, sizeof *p);
3501 p->p_type = PT_NULL;
3504 elf_tdata (abfd)->phdr = phdrs;
3506 elf_tdata (abfd)->next_file_pos = off;
3508 /* Write out the program headers. */
3509 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
3510 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3516 /* Get the size of the program header.
3518 If this is called by the linker before any of the section VMA's are set, it
3519 can't calculate the correct value for a strange memory layout. This only
3520 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3521 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3522 data segment (exclusive of .interp and .dynamic).
3524 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3525 will be two segments. */
3527 static bfd_size_type
3528 get_program_header_size (abfd)
3533 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3535 /* We can't return a different result each time we're called. */
3536 if (elf_tdata (abfd)->program_header_size != 0)
3537 return elf_tdata (abfd)->program_header_size;
3539 if (elf_tdata (abfd)->segment_map != NULL)
3541 struct elf_segment_map *m;
3544 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3546 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3547 return elf_tdata (abfd)->program_header_size;
3550 /* Assume we will need exactly two PT_LOAD segments: one for text
3551 and one for data. */
3554 s = bfd_get_section_by_name (abfd, ".interp");
3555 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3557 /* If we have a loadable interpreter section, we need a
3558 PT_INTERP segment. In this case, assume we also need a
3559 PT_PHDR segment, although that may not be true for all
3564 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3566 /* We need a PT_DYNAMIC segment. */
3570 if (elf_tdata (abfd)->eh_frame_hdr
3571 && bfd_get_section_by_name (abfd, ".eh_frame_hdr") != NULL)
3573 /* We need a PT_GNU_EH_FRAME segment. */
3577 for (s = abfd->sections; s != NULL; s = s->next)
3579 if ((s->flags & SEC_LOAD) != 0
3580 && strncmp (s->name, ".note", 5) == 0)
3582 /* We need a PT_NOTE segment. */
3587 /* Let the backend count up any program headers it might need. */
3588 if (bed->elf_backend_additional_program_headers)
3592 a = (*bed->elf_backend_additional_program_headers) (abfd);
3598 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3599 return elf_tdata (abfd)->program_header_size;
3602 /* Work out the file positions of all the sections. This is called by
3603 _bfd_elf_compute_section_file_positions. All the section sizes and
3604 VMAs must be known before this is called.
3606 We do not consider reloc sections at this point, unless they form
3607 part of the loadable image. Reloc sections are assigned file
3608 positions in assign_file_positions_for_relocs, which is called by
3609 write_object_contents and final_link.
3611 We also don't set the positions of the .symtab and .strtab here. */
3614 assign_file_positions_except_relocs (abfd)
3617 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3618 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3619 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3621 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3623 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3624 && bfd_get_format (abfd) != bfd_core)
3626 Elf_Internal_Shdr **hdrpp;
3629 /* Start after the ELF header. */
3630 off = i_ehdrp->e_ehsize;
3632 /* We are not creating an executable, which means that we are
3633 not creating a program header, and that the actual order of
3634 the sections in the file is unimportant. */
3635 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3637 Elf_Internal_Shdr *hdr;
3640 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
3642 hdr->sh_offset = -1;
3645 if (i == tdata->symtab_section
3646 || i == tdata->strtab_section)
3648 hdr->sh_offset = -1;
3652 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3658 Elf_Internal_Shdr **hdrpp;
3660 /* Assign file positions for the loaded sections based on the
3661 assignment of sections to segments. */
3662 if (! assign_file_positions_for_segments (abfd))
3665 /* Assign file positions for the other sections. */
3667 off = elf_tdata (abfd)->next_file_pos;
3668 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3670 Elf_Internal_Shdr *hdr;
3673 if (hdr->bfd_section != NULL
3674 && hdr->bfd_section->filepos != 0)
3675 hdr->sh_offset = hdr->bfd_section->filepos;
3676 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3678 ((*_bfd_error_handler)
3679 (_("%s: warning: allocated section `%s' not in segment"),
3680 bfd_get_filename (abfd),
3681 (hdr->bfd_section == NULL
3683 : hdr->bfd_section->name)));
3684 if ((abfd->flags & D_PAGED) != 0)
3685 off += (hdr->sh_addr - off) % bed->maxpagesize;
3687 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3688 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3691 else if (hdr->sh_type == SHT_REL
3692 || hdr->sh_type == SHT_RELA
3693 || hdr == i_shdrpp[tdata->symtab_section]
3694 || hdr == i_shdrpp[tdata->strtab_section])
3695 hdr->sh_offset = -1;
3697 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3701 /* Place the section headers. */
3702 off = align_file_position (off, bed->s->file_align);
3703 i_ehdrp->e_shoff = off;
3704 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3706 elf_tdata (abfd)->next_file_pos = off;
3715 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3716 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3717 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3719 struct elf_strtab_hash *shstrtab;
3720 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3722 i_ehdrp = elf_elfheader (abfd);
3723 i_shdrp = elf_elfsections (abfd);
3725 shstrtab = _bfd_elf_strtab_init ();
3726 if (shstrtab == NULL)
3729 elf_shstrtab (abfd) = shstrtab;
3731 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3732 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3733 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3734 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3736 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3737 i_ehdrp->e_ident[EI_DATA] =
3738 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3739 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3741 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
3742 i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3744 for (count = EI_PAD; count < EI_NIDENT; count++)
3745 i_ehdrp->e_ident[count] = 0;
3747 if ((abfd->flags & DYNAMIC) != 0)
3748 i_ehdrp->e_type = ET_DYN;
3749 else if ((abfd->flags & EXEC_P) != 0)
3750 i_ehdrp->e_type = ET_EXEC;
3751 else if (bfd_get_format (abfd) == bfd_core)
3752 i_ehdrp->e_type = ET_CORE;
3754 i_ehdrp->e_type = ET_REL;
3756 switch (bfd_get_arch (abfd))
3758 case bfd_arch_unknown:
3759 i_ehdrp->e_machine = EM_NONE;
3762 /* There used to be a long list of cases here, each one setting
3763 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
3764 in the corresponding bfd definition. To avoid duplication,
3765 the switch was removed. Machines that need special handling
3766 can generally do it in elf_backend_final_write_processing(),
3767 unless they need the information earlier than the final write.
3768 Such need can generally be supplied by replacing the tests for
3769 e_machine with the conditions used to determine it. */
3771 if (get_elf_backend_data (abfd) != NULL)
3772 i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
3774 i_ehdrp->e_machine = EM_NONE;
3777 i_ehdrp->e_version = bed->s->ev_current;
3778 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3780 /* No program header, for now. */
3781 i_ehdrp->e_phoff = 0;
3782 i_ehdrp->e_phentsize = 0;
3783 i_ehdrp->e_phnum = 0;
3785 /* Each bfd section is section header entry. */
3786 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3787 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3789 /* If we're building an executable, we'll need a program header table. */
3790 if (abfd->flags & EXEC_P)
3792 /* It all happens later. */
3794 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3796 /* elf_build_phdrs() returns a (NULL-terminated) array of
3797 Elf_Internal_Phdrs. */
3798 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3799 i_ehdrp->e_phoff = outbase;
3800 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3805 i_ehdrp->e_phentsize = 0;
3807 i_ehdrp->e_phoff = 0;
3810 elf_tdata (abfd)->symtab_hdr.sh_name =
3811 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", false);
3812 elf_tdata (abfd)->strtab_hdr.sh_name =
3813 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", false);
3814 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3815 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", false);
3816 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3817 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3818 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3824 /* Assign file positions for all the reloc sections which are not part
3825 of the loadable file image. */
3828 _bfd_elf_assign_file_positions_for_relocs (abfd)
3833 Elf_Internal_Shdr **shdrpp;
3835 off = elf_tdata (abfd)->next_file_pos;
3837 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3838 i < elf_elfheader (abfd)->e_shnum;
3841 Elf_Internal_Shdr *shdrp;
3844 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3845 && shdrp->sh_offset == -1)
3846 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3849 elf_tdata (abfd)->next_file_pos = off;
3853 _bfd_elf_write_object_contents (abfd)
3856 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3857 Elf_Internal_Ehdr *i_ehdrp;
3858 Elf_Internal_Shdr **i_shdrp;
3862 if (! abfd->output_has_begun
3863 && ! _bfd_elf_compute_section_file_positions
3864 (abfd, (struct bfd_link_info *) NULL))
3867 i_shdrp = elf_elfsections (abfd);
3868 i_ehdrp = elf_elfheader (abfd);
3871 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3875 _bfd_elf_assign_file_positions_for_relocs (abfd);
3877 /* After writing the headers, we need to write the sections too... */
3878 for (count = 1; count < i_ehdrp->e_shnum; count++)
3880 if (bed->elf_backend_section_processing)
3881 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3882 if (i_shdrp[count]->contents)
3884 bfd_size_type amt = i_shdrp[count]->sh_size;
3886 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3887 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
3892 /* Write out the section header names. */
3893 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3894 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
3897 if (bed->elf_backend_final_write_processing)
3898 (*bed->elf_backend_final_write_processing) (abfd,
3899 elf_tdata (abfd)->linker);
3901 return bed->s->write_shdrs_and_ehdr (abfd);
3905 _bfd_elf_write_corefile_contents (abfd)
3908 /* Hopefully this can be done just like an object file. */
3909 return _bfd_elf_write_object_contents (abfd);
3912 /* Given a section, search the header to find them. */
3915 _bfd_elf_section_from_bfd_section (abfd, asect)
3919 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3920 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3922 Elf_Internal_Shdr *hdr;
3923 int maxindex = elf_elfheader (abfd)->e_shnum;
3925 for (index = 0; index < maxindex; index++)
3927 hdr = i_shdrp[index];
3928 if (hdr->bfd_section == asect)
3932 if (bed->elf_backend_section_from_bfd_section)
3934 for (index = 0; index < maxindex; index++)
3938 hdr = i_shdrp[index];
3940 if ((*bed->elf_backend_section_from_bfd_section)
3941 (abfd, hdr, asect, &retval))
3946 if (bfd_is_abs_section (asect))
3948 if (bfd_is_com_section (asect))
3950 if (bfd_is_und_section (asect))
3953 bfd_set_error (bfd_error_nonrepresentable_section);
3958 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3962 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3964 asymbol **asym_ptr_ptr;
3966 asymbol *asym_ptr = *asym_ptr_ptr;
3968 flagword flags = asym_ptr->flags;
3970 /* When gas creates relocations against local labels, it creates its
3971 own symbol for the section, but does put the symbol into the
3972 symbol chain, so udata is 0. When the linker is generating
3973 relocatable output, this section symbol may be for one of the
3974 input sections rather than the output section. */
3975 if (asym_ptr->udata.i == 0
3976 && (flags & BSF_SECTION_SYM)
3977 && asym_ptr->section)
3981 if (asym_ptr->section->output_section != NULL)
3982 indx = asym_ptr->section->output_section->index;
3984 indx = asym_ptr->section->index;
3985 if (indx < elf_num_section_syms (abfd)
3986 && elf_section_syms (abfd)[indx] != NULL)
3987 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3990 idx = asym_ptr->udata.i;
3994 /* This case can occur when using --strip-symbol on a symbol
3995 which is used in a relocation entry. */
3996 (*_bfd_error_handler)
3997 (_("%s: symbol `%s' required but not present"),
3998 bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
3999 bfd_set_error (bfd_error_no_symbols);
4006 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
4007 (long) asym_ptr, asym_ptr->name, idx, flags,
4008 elf_symbol_flags (flags));
4016 /* Copy private BFD data. This copies any program header information. */
4019 copy_private_bfd_data (ibfd, obfd)
4023 Elf_Internal_Ehdr * iehdr;
4024 struct elf_segment_map * map;
4025 struct elf_segment_map * map_first;
4026 struct elf_segment_map ** pointer_to_map;
4027 Elf_Internal_Phdr * segment;
4030 unsigned int num_segments;
4031 boolean phdr_included = false;
4032 bfd_vma maxpagesize;
4033 struct elf_segment_map * phdr_adjust_seg = NULL;
4034 unsigned int phdr_adjust_num = 0;
4036 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4037 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4040 if (elf_tdata (ibfd)->phdr == NULL)
4043 iehdr = elf_elfheader (ibfd);
4046 pointer_to_map = &map_first;
4048 num_segments = elf_elfheader (ibfd)->e_phnum;
4049 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4051 /* Returns the end address of the segment + 1. */
4052 #define SEGMENT_END(segment, start) \
4053 (start + (segment->p_memsz > segment->p_filesz \
4054 ? segment->p_memsz : segment->p_filesz))
4056 /* Returns true if the given section is contained within
4057 the given segment. VMA addresses are compared. */
4058 #define IS_CONTAINED_BY_VMA(section, segment) \
4059 (section->vma >= segment->p_vaddr \
4060 && (section->vma + section->_raw_size) \
4061 <= (SEGMENT_END (segment, segment->p_vaddr)))
4063 /* Returns true if the given section is contained within
4064 the given segment. LMA addresses are compared. */
4065 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4066 (section->lma >= base \
4067 && (section->lma + section->_raw_size) \
4068 <= SEGMENT_END (segment, base))
4070 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4071 #define IS_COREFILE_NOTE(p, s) \
4072 (p->p_type == PT_NOTE \
4073 && bfd_get_format (ibfd) == bfd_core \
4074 && s->vma == 0 && s->lma == 0 \
4075 && (bfd_vma) s->filepos >= p->p_offset \
4076 && (bfd_vma) s->filepos + s->_raw_size \
4077 <= p->p_offset + p->p_filesz)
4079 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4080 linker, which generates a PT_INTERP section with p_vaddr and
4081 p_memsz set to 0. */
4082 #define IS_SOLARIS_PT_INTERP(p, s) \
4084 && p->p_filesz > 0 \
4085 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4086 && s->_raw_size > 0 \
4087 && (bfd_vma) s->filepos >= p->p_offset \
4088 && ((bfd_vma) s->filepos + s->_raw_size \
4089 <= p->p_offset + p->p_filesz))
4091 /* Decide if the given section should be included in the given segment.
4092 A section will be included if:
4093 1. It is within the address space of the segment -- we use the LMA
4094 if that is set for the segment and the VMA otherwise,
4095 2. It is an allocated segment,
4096 3. There is an output section associated with it,
4097 4. The section has not already been allocated to a previous segment. */
4098 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
4099 (((((segment->p_paddr \
4100 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4101 : IS_CONTAINED_BY_VMA (section, segment)) \
4102 || IS_SOLARIS_PT_INTERP (segment, section)) \
4103 && (section->flags & SEC_ALLOC) != 0) \
4104 || IS_COREFILE_NOTE (segment, section)) \
4105 && section->output_section != NULL \
4106 && section->segment_mark == false)
4108 /* Returns true iff seg1 starts after the end of seg2. */
4109 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4110 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4112 /* Returns true iff seg1 and seg2 overlap. */
4113 #define SEGMENT_OVERLAPS(seg1, seg2) \
4114 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4116 /* Initialise the segment mark field. */
4117 for (section = ibfd->sections; section != NULL; section = section->next)
4118 section->segment_mark = false;
4120 /* Scan through the segments specified in the program header
4121 of the input BFD. For this first scan we look for overlaps
4122 in the loadable segments. These can be created by wierd
4123 parameters to objcopy. */
4124 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4129 Elf_Internal_Phdr *segment2;
4131 if (segment->p_type != PT_LOAD)
4134 /* Determine if this segment overlaps any previous segments. */
4135 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4137 bfd_signed_vma extra_length;
4139 if (segment2->p_type != PT_LOAD
4140 || ! SEGMENT_OVERLAPS (segment, segment2))
4143 /* Merge the two segments together. */
4144 if (segment2->p_vaddr < segment->p_vaddr)
4146 /* Extend SEGMENT2 to include SEGMENT and then delete
4149 SEGMENT_END (segment, segment->p_vaddr)
4150 - SEGMENT_END (segment2, segment2->p_vaddr);
4152 if (extra_length > 0)
4154 segment2->p_memsz += extra_length;
4155 segment2->p_filesz += extra_length;
4158 segment->p_type = PT_NULL;
4160 /* Since we have deleted P we must restart the outer loop. */
4162 segment = elf_tdata (ibfd)->phdr;
4167 /* Extend SEGMENT to include SEGMENT2 and then delete
4170 SEGMENT_END (segment2, segment2->p_vaddr)
4171 - SEGMENT_END (segment, segment->p_vaddr);
4173 if (extra_length > 0)
4175 segment->p_memsz += extra_length;
4176 segment->p_filesz += extra_length;
4179 segment2->p_type = PT_NULL;
4184 /* The second scan attempts to assign sections to segments. */
4185 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4189 unsigned int section_count;
4190 asection ** sections;
4191 asection * output_section;
4193 bfd_vma matching_lma;
4194 bfd_vma suggested_lma;
4198 if (segment->p_type == PT_NULL)
4201 /* Compute how many sections might be placed into this segment. */
4203 for (section = ibfd->sections; section != NULL; section = section->next)
4204 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
4207 /* Allocate a segment map big enough to contain all of the
4208 sections we have selected. */
4209 amt = sizeof (struct elf_segment_map);
4210 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4211 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4215 /* Initialise the fields of the segment map. Default to
4216 using the physical address of the segment in the input BFD. */
4218 map->p_type = segment->p_type;
4219 map->p_flags = segment->p_flags;
4220 map->p_flags_valid = 1;
4221 map->p_paddr = segment->p_paddr;
4222 map->p_paddr_valid = 1;
4224 /* Determine if this segment contains the ELF file header
4225 and if it contains the program headers themselves. */
4226 map->includes_filehdr = (segment->p_offset == 0
4227 && segment->p_filesz >= iehdr->e_ehsize);
4229 map->includes_phdrs = 0;
4231 if (! phdr_included || segment->p_type != PT_LOAD)
4233 map->includes_phdrs =
4234 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4235 && (segment->p_offset + segment->p_filesz
4236 >= ((bfd_vma) iehdr->e_phoff
4237 + iehdr->e_phnum * iehdr->e_phentsize)));
4239 if (segment->p_type == PT_LOAD && map->includes_phdrs)
4240 phdr_included = true;
4243 if (section_count == 0)
4245 /* Special segments, such as the PT_PHDR segment, may contain
4246 no sections, but ordinary, loadable segments should contain
4248 if (segment->p_type == PT_LOAD)
4250 (_("%s: warning: Empty loadable segment detected\n"),
4251 bfd_archive_filename (ibfd));
4254 *pointer_to_map = map;
4255 pointer_to_map = &map->next;
4260 /* Now scan the sections in the input BFD again and attempt
4261 to add their corresponding output sections to the segment map.
4262 The problem here is how to handle an output section which has
4263 been moved (ie had its LMA changed). There are four possibilities:
4265 1. None of the sections have been moved.
4266 In this case we can continue to use the segment LMA from the
4269 2. All of the sections have been moved by the same amount.
4270 In this case we can change the segment's LMA to match the LMA
4271 of the first section.
4273 3. Some of the sections have been moved, others have not.
4274 In this case those sections which have not been moved can be
4275 placed in the current segment which will have to have its size,
4276 and possibly its LMA changed, and a new segment or segments will
4277 have to be created to contain the other sections.
4279 4. The sections have been moved, but not be the same amount.
4280 In this case we can change the segment's LMA to match the LMA
4281 of the first section and we will have to create a new segment
4282 or segments to contain the other sections.
4284 In order to save time, we allocate an array to hold the section
4285 pointers that we are interested in. As these sections get assigned
4286 to a segment, they are removed from this array. */
4288 amt = (bfd_size_type) section_count * sizeof (asection *);
4289 sections = (asection **) bfd_malloc (amt);
4290 if (sections == NULL)
4293 /* Step One: Scan for segment vs section LMA conflicts.
4294 Also add the sections to the section array allocated above.
4295 Also add the sections to the current segment. In the common
4296 case, where the sections have not been moved, this means that
4297 we have completely filled the segment, and there is nothing
4303 for (j = 0, section = ibfd->sections;
4305 section = section->next)
4307 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
4309 output_section = section->output_section;
4311 sections[j ++] = section;
4313 /* The Solaris native linker always sets p_paddr to 0.
4314 We try to catch that case here, and set it to the
4316 if (segment->p_paddr == 0
4317 && segment->p_vaddr != 0
4319 && output_section->lma != 0
4320 && (output_section->vma == (segment->p_vaddr
4321 + (map->includes_filehdr
4324 + (map->includes_phdrs
4326 * iehdr->e_phentsize)
4328 map->p_paddr = segment->p_vaddr;
4330 /* Match up the physical address of the segment with the
4331 LMA address of the output section. */
4332 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4333 || IS_COREFILE_NOTE (segment, section))
4335 if (matching_lma == 0)
4336 matching_lma = output_section->lma;
4338 /* We assume that if the section fits within the segment
4339 then it does not overlap any other section within that
4341 map->sections[isec ++] = output_section;
4343 else if (suggested_lma == 0)
4344 suggested_lma = output_section->lma;
4348 BFD_ASSERT (j == section_count);
4350 /* Step Two: Adjust the physical address of the current segment,
4352 if (isec == section_count)
4354 /* All of the sections fitted within the segment as currently
4355 specified. This is the default case. Add the segment to
4356 the list of built segments and carry on to process the next
4357 program header in the input BFD. */
4358 map->count = section_count;
4359 *pointer_to_map = map;
4360 pointer_to_map = &map->next;
4367 if (matching_lma != 0)
4369 /* At least one section fits inside the current segment.
4370 Keep it, but modify its physical address to match the
4371 LMA of the first section that fitted. */
4372 map->p_paddr = matching_lma;
4376 /* None of the sections fitted inside the current segment.
4377 Change the current segment's physical address to match
4378 the LMA of the first section. */
4379 map->p_paddr = suggested_lma;
4382 /* Offset the segment physical address from the lma
4383 to allow for space taken up by elf headers. */
4384 if (map->includes_filehdr)
4385 map->p_paddr -= iehdr->e_ehsize;
4387 if (map->includes_phdrs)
4389 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4391 /* iehdr->e_phnum is just an estimate of the number
4392 of program headers that we will need. Make a note
4393 here of the number we used and the segment we chose
4394 to hold these headers, so that we can adjust the
4395 offset when we know the correct value. */
4396 phdr_adjust_num = iehdr->e_phnum;
4397 phdr_adjust_seg = map;
4401 /* Step Three: Loop over the sections again, this time assigning
4402 those that fit to the current segment and remvoing them from the
4403 sections array; but making sure not to leave large gaps. Once all
4404 possible sections have been assigned to the current segment it is
4405 added to the list of built segments and if sections still remain
4406 to be assigned, a new segment is constructed before repeating
4414 /* Fill the current segment with sections that fit. */
4415 for (j = 0; j < section_count; j++)
4417 section = sections[j];
4419 if (section == NULL)
4422 output_section = section->output_section;
4424 BFD_ASSERT (output_section != NULL);
4426 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4427 || IS_COREFILE_NOTE (segment, section))
4429 if (map->count == 0)
4431 /* If the first section in a segment does not start at
4432 the beginning of the segment, then something is
4434 if (output_section->lma !=
4436 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4437 + (map->includes_phdrs
4438 ? iehdr->e_phnum * iehdr->e_phentsize
4444 asection * prev_sec;
4446 prev_sec = map->sections[map->count - 1];
4448 /* If the gap between the end of the previous section
4449 and the start of this section is more than
4450 maxpagesize then we need to start a new segment. */
4451 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
4453 < BFD_ALIGN (output_section->lma, maxpagesize))
4454 || ((prev_sec->lma + prev_sec->_raw_size)
4455 > output_section->lma))
4457 if (suggested_lma == 0)
4458 suggested_lma = output_section->lma;
4464 map->sections[map->count++] = output_section;
4467 section->segment_mark = true;
4469 else if (suggested_lma == 0)
4470 suggested_lma = output_section->lma;
4473 BFD_ASSERT (map->count > 0);
4475 /* Add the current segment to the list of built segments. */
4476 *pointer_to_map = map;
4477 pointer_to_map = &map->next;
4479 if (isec < section_count)
4481 /* We still have not allocated all of the sections to
4482 segments. Create a new segment here, initialise it
4483 and carry on looping. */
4484 amt = sizeof (struct elf_segment_map);
4485 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4486 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4490 /* Initialise the fields of the segment map. Set the physical
4491 physical address to the LMA of the first section that has
4492 not yet been assigned. */
4494 map->p_type = segment->p_type;
4495 map->p_flags = segment->p_flags;
4496 map->p_flags_valid = 1;
4497 map->p_paddr = suggested_lma;
4498 map->p_paddr_valid = 1;
4499 map->includes_filehdr = 0;
4500 map->includes_phdrs = 0;
4503 while (isec < section_count);
4508 /* The Solaris linker creates program headers in which all the
4509 p_paddr fields are zero. When we try to objcopy or strip such a
4510 file, we get confused. Check for this case, and if we find it
4511 reset the p_paddr_valid fields. */
4512 for (map = map_first; map != NULL; map = map->next)
4513 if (map->p_paddr != 0)
4517 for (map = map_first; map != NULL; map = map->next)
4518 map->p_paddr_valid = 0;
4521 elf_tdata (obfd)->segment_map = map_first;
4523 /* If we had to estimate the number of program headers that were
4524 going to be needed, then check our estimate know and adjust
4525 the offset if necessary. */
4526 if (phdr_adjust_seg != NULL)
4530 for (count = 0, map = map_first; map != NULL; map = map->next)
4533 if (count > phdr_adjust_num)
4534 phdr_adjust_seg->p_paddr
4535 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
4539 /* Final Step: Sort the segments into ascending order of physical
4541 if (map_first != NULL)
4543 struct elf_segment_map *prev;
4546 for (map = map_first->next; map != NULL; prev = map, map = map->next)
4548 /* Yes I know - its a bubble sort.... */
4549 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
4551 /* Swap map and map->next. */
4552 prev->next = map->next;
4553 map->next = map->next->next;
4554 prev->next->next = map;
4564 #undef IS_CONTAINED_BY_VMA
4565 #undef IS_CONTAINED_BY_LMA
4566 #undef IS_COREFILE_NOTE
4567 #undef IS_SOLARIS_PT_INTERP
4568 #undef INCLUDE_SECTION_IN_SEGMENT
4569 #undef SEGMENT_AFTER_SEGMENT
4570 #undef SEGMENT_OVERLAPS
4574 /* Copy private section information. This copies over the entsize
4575 field, and sometimes the info field. */
4578 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
4584 Elf_Internal_Shdr *ihdr, *ohdr;
4586 if (ibfd->xvec->flavour != bfd_target_elf_flavour
4587 || obfd->xvec->flavour != bfd_target_elf_flavour)
4590 /* Copy over private BFD data if it has not already been copied.
4591 This must be done here, rather than in the copy_private_bfd_data
4592 entry point, because the latter is called after the section
4593 contents have been set, which means that the program headers have
4594 already been worked out. */
4595 if (elf_tdata (obfd)->segment_map == NULL
4596 && elf_tdata (ibfd)->phdr != NULL)
4600 /* Only set up the segments if there are no more SEC_ALLOC
4601 sections. FIXME: This won't do the right thing if objcopy is
4602 used to remove the last SEC_ALLOC section, since objcopy
4603 won't call this routine in that case. */
4604 for (s = isec->next; s != NULL; s = s->next)
4605 if ((s->flags & SEC_ALLOC) != 0)
4609 if (! copy_private_bfd_data (ibfd, obfd))
4614 ihdr = &elf_section_data (isec)->this_hdr;
4615 ohdr = &elf_section_data (osec)->this_hdr;
4617 ohdr->sh_entsize = ihdr->sh_entsize;
4619 if (ihdr->sh_type == SHT_SYMTAB
4620 || ihdr->sh_type == SHT_DYNSYM
4621 || ihdr->sh_type == SHT_GNU_verneed
4622 || ihdr->sh_type == SHT_GNU_verdef)
4623 ohdr->sh_info = ihdr->sh_info;
4625 elf_section_data (osec)->use_rela_p
4626 = elf_section_data (isec)->use_rela_p;
4631 /* Copy private symbol information. If this symbol is in a section
4632 which we did not map into a BFD section, try to map the section
4633 index correctly. We use special macro definitions for the mapped
4634 section indices; these definitions are interpreted by the
4635 swap_out_syms function. */
4637 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
4638 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
4639 #define MAP_STRTAB (SHN_LORESERVE - 3)
4640 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
4643 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
4649 elf_symbol_type *isym, *osym;
4651 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4652 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4655 isym = elf_symbol_from (ibfd, isymarg);
4656 osym = elf_symbol_from (obfd, osymarg);
4660 && bfd_is_abs_section (isym->symbol.section))
4664 shndx = isym->internal_elf_sym.st_shndx;
4665 if (shndx == elf_onesymtab (ibfd))
4666 shndx = MAP_ONESYMTAB;
4667 else if (shndx == elf_dynsymtab (ibfd))
4668 shndx = MAP_DYNSYMTAB;
4669 else if (shndx == elf_tdata (ibfd)->strtab_section)
4671 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
4672 shndx = MAP_SHSTRTAB;
4673 osym->internal_elf_sym.st_shndx = shndx;
4679 /* Swap out the symbols. */
4682 swap_out_syms (abfd, sttp, relocatable_p)
4684 struct bfd_strtab_hash **sttp;
4687 struct elf_backend_data *bed;
4690 struct bfd_strtab_hash *stt;
4691 Elf_Internal_Shdr *symtab_hdr;
4692 Elf_Internal_Shdr *symstrtab_hdr;
4693 char *outbound_syms;
4697 if (!elf_map_symbols (abfd))
4700 /* Dump out the symtabs. */
4701 stt = _bfd_elf_stringtab_init ();
4705 bed = get_elf_backend_data (abfd);
4706 symcount = bfd_get_symcount (abfd);
4707 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4708 symtab_hdr->sh_type = SHT_SYMTAB;
4709 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4710 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4711 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4712 symtab_hdr->sh_addralign = bed->s->file_align;
4714 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4715 symstrtab_hdr->sh_type = SHT_STRTAB;
4717 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
4718 outbound_syms = bfd_alloc (abfd, amt);
4719 if (outbound_syms == NULL)
4721 symtab_hdr->contents = (PTR) outbound_syms;
4723 /* now generate the data (for "contents") */
4725 /* Fill in zeroth symbol and swap it out. */
4726 Elf_Internal_Sym sym;
4732 sym.st_shndx = SHN_UNDEF;
4733 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4734 outbound_syms += bed->s->sizeof_sym;
4737 syms = bfd_get_outsymbols (abfd);
4738 for (idx = 0; idx < symcount; idx++)
4740 Elf_Internal_Sym sym;
4741 bfd_vma value = syms[idx]->value;
4742 elf_symbol_type *type_ptr;
4743 flagword flags = syms[idx]->flags;
4746 if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
4748 /* Local section symbols have no name. */
4753 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4756 if (sym.st_name == (unsigned long) -1)
4760 type_ptr = elf_symbol_from (abfd, syms[idx]);
4762 if ((flags & BSF_SECTION_SYM) == 0
4763 && bfd_is_com_section (syms[idx]->section))
4765 /* ELF common symbols put the alignment into the `value' field,
4766 and the size into the `size' field. This is backwards from
4767 how BFD handles it, so reverse it here. */
4768 sym.st_size = value;
4769 if (type_ptr == NULL
4770 || type_ptr->internal_elf_sym.st_value == 0)
4771 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4773 sym.st_value = type_ptr->internal_elf_sym.st_value;
4774 sym.st_shndx = _bfd_elf_section_from_bfd_section
4775 (abfd, syms[idx]->section);
4779 asection *sec = syms[idx]->section;
4782 if (sec->output_section)
4784 value += sec->output_offset;
4785 sec = sec->output_section;
4787 /* Don't add in the section vma for relocatable output. */
4788 if (! relocatable_p)
4790 sym.st_value = value;
4791 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4793 if (bfd_is_abs_section (sec)
4795 && type_ptr->internal_elf_sym.st_shndx != 0)
4797 /* This symbol is in a real ELF section which we did
4798 not create as a BFD section. Undo the mapping done
4799 by copy_private_symbol_data. */
4800 shndx = type_ptr->internal_elf_sym.st_shndx;
4804 shndx = elf_onesymtab (abfd);
4807 shndx = elf_dynsymtab (abfd);
4810 shndx = elf_tdata (abfd)->strtab_section;
4813 shndx = elf_tdata (abfd)->shstrtab_section;
4821 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4827 /* Writing this would be a hell of a lot easier if
4828 we had some decent documentation on bfd, and
4829 knew what to expect of the library, and what to
4830 demand of applications. For example, it
4831 appears that `objcopy' might not set the
4832 section of a symbol to be a section that is
4833 actually in the output file. */
4834 sec2 = bfd_get_section_by_name (abfd, sec->name);
4835 BFD_ASSERT (sec2 != 0);
4836 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4837 BFD_ASSERT (shndx != -1);
4841 sym.st_shndx = shndx;
4844 if ((flags & BSF_FUNCTION) != 0)
4846 else if ((flags & BSF_OBJECT) != 0)
4851 /* Processor-specific types */
4852 if (type_ptr != NULL
4853 && bed->elf_backend_get_symbol_type)
4854 type = ((*bed->elf_backend_get_symbol_type)
4855 (&type_ptr->internal_elf_sym, type));
4857 if (flags & BSF_SECTION_SYM)
4859 if (flags & BSF_GLOBAL)
4860 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
4862 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4864 else if (bfd_is_com_section (syms[idx]->section))
4865 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4866 else if (bfd_is_und_section (syms[idx]->section))
4867 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4871 else if (flags & BSF_FILE)
4872 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4875 int bind = STB_LOCAL;
4877 if (flags & BSF_LOCAL)
4879 else if (flags & BSF_WEAK)
4881 else if (flags & BSF_GLOBAL)
4884 sym.st_info = ELF_ST_INFO (bind, type);
4887 if (type_ptr != NULL)
4888 sym.st_other = type_ptr->internal_elf_sym.st_other;
4892 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4893 outbound_syms += bed->s->sizeof_sym;
4897 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4898 symstrtab_hdr->sh_type = SHT_STRTAB;
4900 symstrtab_hdr->sh_flags = 0;
4901 symstrtab_hdr->sh_addr = 0;
4902 symstrtab_hdr->sh_entsize = 0;
4903 symstrtab_hdr->sh_link = 0;
4904 symstrtab_hdr->sh_info = 0;
4905 symstrtab_hdr->sh_addralign = 1;
4910 /* Return the number of bytes required to hold the symtab vector.
4912 Note that we base it on the count plus 1, since we will null terminate
4913 the vector allocated based on this size. However, the ELF symbol table
4914 always has a dummy entry as symbol #0, so it ends up even. */
4917 _bfd_elf_get_symtab_upper_bound (abfd)
4922 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4924 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4925 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4931 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4936 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4938 if (elf_dynsymtab (abfd) == 0)
4940 bfd_set_error (bfd_error_invalid_operation);
4944 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4945 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4951 _bfd_elf_get_reloc_upper_bound (abfd, asect)
4952 bfd *abfd ATTRIBUTE_UNUSED;
4955 return (asect->reloc_count + 1) * sizeof (arelent *);
4958 /* Canonicalize the relocs. */
4961 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4969 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4971 if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
4974 tblptr = section->relocation;
4975 for (i = 0; i < section->reloc_count; i++)
4976 *relptr++ = tblptr++;
4980 return section->reloc_count;
4984 _bfd_elf_get_symtab (abfd, alocation)
4986 asymbol **alocation;
4988 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4989 long symcount = bed->s->slurp_symbol_table (abfd, alocation, false);
4992 bfd_get_symcount (abfd) = symcount;
4997 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4999 asymbol **alocation;
5001 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5002 return bed->s->slurp_symbol_table (abfd, alocation, true);
5005 /* Return the size required for the dynamic reloc entries. Any
5006 section that was actually installed in the BFD, and has type
5007 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5008 considered to be a dynamic reloc section. */
5011 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
5017 if (elf_dynsymtab (abfd) == 0)
5019 bfd_set_error (bfd_error_invalid_operation);
5023 ret = sizeof (arelent *);
5024 for (s = abfd->sections; s != NULL; s = s->next)
5025 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5026 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5027 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5028 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5029 * sizeof (arelent *));
5034 /* Canonicalize the dynamic relocation entries. Note that we return
5035 the dynamic relocations as a single block, although they are
5036 actually associated with particular sections; the interface, which
5037 was designed for SunOS style shared libraries, expects that there
5038 is only one set of dynamic relocs. Any section that was actually
5039 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5040 the dynamic symbol table, is considered to be a dynamic reloc
5044 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
5049 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
5053 if (elf_dynsymtab (abfd) == 0)
5055 bfd_set_error (bfd_error_invalid_operation);
5059 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5061 for (s = abfd->sections; s != NULL; s = s->next)
5063 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5064 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5065 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5070 if (! (*slurp_relocs) (abfd, s, syms, true))
5072 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5074 for (i = 0; i < count; i++)
5085 /* Read in the version information. */
5088 _bfd_elf_slurp_version_tables (abfd)
5091 bfd_byte *contents = NULL;
5094 if (elf_dynverdef (abfd) != 0)
5096 Elf_Internal_Shdr *hdr;
5097 Elf_External_Verdef *everdef;
5098 Elf_Internal_Verdef *iverdef;
5099 Elf_Internal_Verdef *iverdefarr;
5100 Elf_Internal_Verdef iverdefmem;
5102 unsigned int maxidx;
5104 hdr = &elf_tdata (abfd)->dynverdef_hdr;
5106 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5107 if (contents == NULL)
5109 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5110 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5113 /* We know the number of entries in the section but not the maximum
5114 index. Therefore we have to run through all entries and find
5116 everdef = (Elf_External_Verdef *) contents;
5118 for (i = 0; i < hdr->sh_info; ++i)
5120 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5122 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5123 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5125 everdef = ((Elf_External_Verdef *)
5126 ((bfd_byte *) everdef + iverdefmem.vd_next));
5129 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5130 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
5131 if (elf_tdata (abfd)->verdef == NULL)
5134 elf_tdata (abfd)->cverdefs = maxidx;
5136 everdef = (Elf_External_Verdef *) contents;
5137 iverdefarr = elf_tdata (abfd)->verdef;
5138 for (i = 0; i < hdr->sh_info; i++)
5140 Elf_External_Verdaux *everdaux;
5141 Elf_Internal_Verdaux *iverdaux;
5144 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5146 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5147 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5149 iverdef->vd_bfd = abfd;
5151 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5152 iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
5153 if (iverdef->vd_auxptr == NULL)
5156 everdaux = ((Elf_External_Verdaux *)
5157 ((bfd_byte *) everdef + iverdef->vd_aux));
5158 iverdaux = iverdef->vd_auxptr;
5159 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5161 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5163 iverdaux->vda_nodename =
5164 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5165 iverdaux->vda_name);
5166 if (iverdaux->vda_nodename == NULL)
5169 if (j + 1 < iverdef->vd_cnt)
5170 iverdaux->vda_nextptr = iverdaux + 1;
5172 iverdaux->vda_nextptr = NULL;
5174 everdaux = ((Elf_External_Verdaux *)
5175 ((bfd_byte *) everdaux + iverdaux->vda_next));
5178 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5180 if (i + 1 < hdr->sh_info)
5181 iverdef->vd_nextdef = iverdef + 1;
5183 iverdef->vd_nextdef = NULL;
5185 everdef = ((Elf_External_Verdef *)
5186 ((bfd_byte *) everdef + iverdef->vd_next));
5193 if (elf_dynverref (abfd) != 0)
5195 Elf_Internal_Shdr *hdr;
5196 Elf_External_Verneed *everneed;
5197 Elf_Internal_Verneed *iverneed;
5200 hdr = &elf_tdata (abfd)->dynverref_hdr;
5202 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5203 elf_tdata (abfd)->verref =
5204 (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
5205 if (elf_tdata (abfd)->verref == NULL)
5208 elf_tdata (abfd)->cverrefs = hdr->sh_info;
5210 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5211 if (contents == NULL)
5213 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5214 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5217 everneed = (Elf_External_Verneed *) contents;
5218 iverneed = elf_tdata (abfd)->verref;
5219 for (i = 0; i < hdr->sh_info; i++, iverneed++)
5221 Elf_External_Vernaux *evernaux;
5222 Elf_Internal_Vernaux *ivernaux;
5225 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5227 iverneed->vn_bfd = abfd;
5229 iverneed->vn_filename =
5230 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5232 if (iverneed->vn_filename == NULL)
5235 amt = iverneed->vn_cnt;
5236 amt *= sizeof (Elf_Internal_Vernaux);
5237 iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
5239 evernaux = ((Elf_External_Vernaux *)
5240 ((bfd_byte *) everneed + iverneed->vn_aux));
5241 ivernaux = iverneed->vn_auxptr;
5242 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5244 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5246 ivernaux->vna_nodename =
5247 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5248 ivernaux->vna_name);
5249 if (ivernaux->vna_nodename == NULL)
5252 if (j + 1 < iverneed->vn_cnt)
5253 ivernaux->vna_nextptr = ivernaux + 1;
5255 ivernaux->vna_nextptr = NULL;
5257 evernaux = ((Elf_External_Vernaux *)
5258 ((bfd_byte *) evernaux + ivernaux->vna_next));
5261 if (i + 1 < hdr->sh_info)
5262 iverneed->vn_nextref = iverneed + 1;
5264 iverneed->vn_nextref = NULL;
5266 everneed = ((Elf_External_Verneed *)
5267 ((bfd_byte *) everneed + iverneed->vn_next));
5277 if (contents == NULL)
5283 _bfd_elf_make_empty_symbol (abfd)
5286 elf_symbol_type *newsym;
5287 bfd_size_type amt = sizeof (elf_symbol_type);
5289 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
5294 newsym->symbol.the_bfd = abfd;
5295 return &newsym->symbol;
5300 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
5301 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5305 bfd_symbol_info (symbol, ret);
5308 /* Return whether a symbol name implies a local symbol. Most targets
5309 use this function for the is_local_label_name entry point, but some
5313 _bfd_elf_is_local_label_name (abfd, name)
5314 bfd *abfd ATTRIBUTE_UNUSED;
5317 /* Normal local symbols start with ``.L''. */
5318 if (name[0] == '.' && name[1] == 'L')
5321 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5322 DWARF debugging symbols starting with ``..''. */
5323 if (name[0] == '.' && name[1] == '.')
5326 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5327 emitting DWARF debugging output. I suspect this is actually a
5328 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5329 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5330 underscore to be emitted on some ELF targets). For ease of use,
5331 we treat such symbols as local. */
5332 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5339 _bfd_elf_get_lineno (ignore_abfd, symbol)
5340 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5341 asymbol *symbol ATTRIBUTE_UNUSED;
5348 _bfd_elf_set_arch_mach (abfd, arch, machine)
5350 enum bfd_architecture arch;
5351 unsigned long machine;
5353 /* If this isn't the right architecture for this backend, and this
5354 isn't the generic backend, fail. */
5355 if (arch != get_elf_backend_data (abfd)->arch
5356 && arch != bfd_arch_unknown
5357 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5360 return bfd_default_set_arch_mach (abfd, arch, machine);
5363 /* Find the function to a particular section and offset,
5364 for error reporting. */
5367 elf_find_function (abfd, section, symbols, offset,
5368 filename_ptr, functionname_ptr)
5369 bfd *abfd ATTRIBUTE_UNUSED;
5373 const char **filename_ptr;
5374 const char **functionname_ptr;
5376 const char *filename;
5385 for (p = symbols; *p != NULL; p++)
5389 q = (elf_symbol_type *) *p;
5391 if (bfd_get_section (&q->symbol) != section)
5394 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5399 filename = bfd_asymbol_name (&q->symbol);
5403 if (q->symbol.section == section
5404 && q->symbol.value >= low_func
5405 && q->symbol.value <= offset)
5407 func = (asymbol *) q;
5408 low_func = q->symbol.value;
5418 *filename_ptr = filename;
5419 if (functionname_ptr)
5420 *functionname_ptr = bfd_asymbol_name (func);
5425 /* Find the nearest line to a particular section and offset,
5426 for error reporting. */
5429 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
5430 filename_ptr, functionname_ptr, line_ptr)
5435 const char **filename_ptr;
5436 const char **functionname_ptr;
5437 unsigned int *line_ptr;
5441 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
5442 filename_ptr, functionname_ptr,
5445 if (!*functionname_ptr)
5446 elf_find_function (abfd, section, symbols, offset,
5447 *filename_ptr ? NULL : filename_ptr,
5453 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
5454 filename_ptr, functionname_ptr,
5456 &elf_tdata (abfd)->dwarf2_find_line_info))
5458 if (!*functionname_ptr)
5459 elf_find_function (abfd, section, symbols, offset,
5460 *filename_ptr ? NULL : filename_ptr,
5466 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
5467 &found, filename_ptr,
5468 functionname_ptr, line_ptr,
5469 &elf_tdata (abfd)->line_info))
5474 if (symbols == NULL)
5477 if (! elf_find_function (abfd, section, symbols, offset,
5478 filename_ptr, functionname_ptr))
5486 _bfd_elf_sizeof_headers (abfd, reloc)
5492 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
5494 ret += get_program_header_size (abfd);
5499 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
5504 bfd_size_type count;
5506 Elf_Internal_Shdr *hdr;
5509 if (! abfd->output_has_begun
5510 && ! _bfd_elf_compute_section_file_positions
5511 (abfd, (struct bfd_link_info *) NULL))
5514 hdr = &elf_section_data (section)->this_hdr;
5515 pos = hdr->sh_offset + offset;
5516 if (bfd_seek (abfd, pos, SEEK_SET) != 0
5517 || bfd_bwrite (location, count, abfd) != count)
5524 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
5525 bfd *abfd ATTRIBUTE_UNUSED;
5526 arelent *cache_ptr ATTRIBUTE_UNUSED;
5527 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
5534 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
5537 Elf_Internal_Rel *dst;
5543 /* Try to convert a non-ELF reloc into an ELF one. */
5546 _bfd_elf_validate_reloc (abfd, areloc)
5550 /* Check whether we really have an ELF howto. */
5552 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
5554 bfd_reloc_code_real_type code;
5555 reloc_howto_type *howto;
5557 /* Alien reloc: Try to determine its type to replace it with an
5558 equivalent ELF reloc. */
5560 if (areloc->howto->pc_relative)
5562 switch (areloc->howto->bitsize)
5565 code = BFD_RELOC_8_PCREL;
5568 code = BFD_RELOC_12_PCREL;
5571 code = BFD_RELOC_16_PCREL;
5574 code = BFD_RELOC_24_PCREL;
5577 code = BFD_RELOC_32_PCREL;
5580 code = BFD_RELOC_64_PCREL;
5586 howto = bfd_reloc_type_lookup (abfd, code);
5588 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
5590 if (howto->pcrel_offset)
5591 areloc->addend += areloc->address;
5593 areloc->addend -= areloc->address; /* addend is unsigned!! */
5598 switch (areloc->howto->bitsize)
5604 code = BFD_RELOC_14;
5607 code = BFD_RELOC_16;
5610 code = BFD_RELOC_26;
5613 code = BFD_RELOC_32;
5616 code = BFD_RELOC_64;
5622 howto = bfd_reloc_type_lookup (abfd, code);
5626 areloc->howto = howto;
5634 (*_bfd_error_handler)
5635 (_("%s: unsupported relocation type %s"),
5636 bfd_archive_filename (abfd), areloc->howto->name);
5637 bfd_set_error (bfd_error_bad_value);
5642 _bfd_elf_close_and_cleanup (abfd)
5645 if (bfd_get_format (abfd) == bfd_object)
5647 if (elf_shstrtab (abfd) != NULL)
5648 _bfd_elf_strtab_free (elf_shstrtab (abfd));
5651 return _bfd_generic_close_and_cleanup (abfd);
5654 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5655 in the relocation's offset. Thus we cannot allow any sort of sanity
5656 range-checking to interfere. There is nothing else to do in processing
5659 bfd_reloc_status_type
5660 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
5661 bfd *abfd ATTRIBUTE_UNUSED;
5662 arelent *re ATTRIBUTE_UNUSED;
5663 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
5664 PTR data ATTRIBUTE_UNUSED;
5665 asection *is ATTRIBUTE_UNUSED;
5666 bfd *obfd ATTRIBUTE_UNUSED;
5667 char **errmsg ATTRIBUTE_UNUSED;
5669 return bfd_reloc_ok;
5672 /* Elf core file support. Much of this only works on native
5673 toolchains, since we rely on knowing the
5674 machine-dependent procfs structure in order to pick
5675 out details about the corefile. */
5677 #ifdef HAVE_SYS_PROCFS_H
5678 # include <sys/procfs.h>
5681 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5684 elfcore_make_pid (abfd)
5687 return ((elf_tdata (abfd)->core_lwpid << 16)
5688 + (elf_tdata (abfd)->core_pid));
5691 /* If there isn't a section called NAME, make one, using
5692 data from SECT. Note, this function will generate a
5693 reference to NAME, so you shouldn't deallocate or
5697 elfcore_maybe_make_sect (abfd, name, sect)
5704 if (bfd_get_section_by_name (abfd, name) != NULL)
5707 sect2 = bfd_make_section (abfd, name);
5711 sect2->_raw_size = sect->_raw_size;
5712 sect2->filepos = sect->filepos;
5713 sect2->flags = sect->flags;
5714 sect2->alignment_power = sect->alignment_power;
5718 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
5719 actually creates up to two pseudosections:
5720 - For the single-threaded case, a section named NAME, unless
5721 such a section already exists.
5722 - For the multi-threaded case, a section named "NAME/PID", where
5723 PID is elfcore_make_pid (abfd).
5724 Both pseudosections have identical contents. */
5726 _bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
5733 char *threaded_name;
5736 /* Build the section name. */
5738 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5739 threaded_name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
5740 if (threaded_name == NULL)
5742 strcpy (threaded_name, buf);
5744 sect = bfd_make_section (abfd, threaded_name);
5747 sect->_raw_size = size;
5748 sect->filepos = filepos;
5749 sect->flags = SEC_HAS_CONTENTS;
5750 sect->alignment_power = 2;
5752 return elfcore_maybe_make_sect (abfd, name, sect);
5755 /* prstatus_t exists on:
5757 linux 2.[01] + glibc
5761 #if defined (HAVE_PRSTATUS_T)
5762 static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
5765 elfcore_grok_prstatus (abfd, note)
5767 Elf_Internal_Note *note;
5772 if (note->descsz == sizeof (prstatus_t))
5776 raw_size = sizeof (prstat.pr_reg);
5777 offset = offsetof (prstatus_t, pr_reg);
5778 memcpy (&prstat, note->descdata, sizeof (prstat));
5780 /* Do not overwrite the core signal if it
5781 has already been set by another thread. */
5782 if (elf_tdata (abfd)->core_signal == 0)
5783 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5784 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5786 /* pr_who exists on:
5789 pr_who doesn't exist on:
5792 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5793 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5796 #if defined (HAVE_PRSTATUS32_T)
5797 else if (note->descsz == sizeof (prstatus32_t))
5799 /* 64-bit host, 32-bit corefile */
5800 prstatus32_t prstat;
5802 raw_size = sizeof (prstat.pr_reg);
5803 offset = offsetof (prstatus32_t, pr_reg);
5804 memcpy (&prstat, note->descdata, sizeof (prstat));
5806 /* Do not overwrite the core signal if it
5807 has already been set by another thread. */
5808 if (elf_tdata (abfd)->core_signal == 0)
5809 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5810 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5812 /* pr_who exists on:
5815 pr_who doesn't exist on:
5818 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
5819 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5822 #endif /* HAVE_PRSTATUS32_T */
5825 /* Fail - we don't know how to handle any other
5826 note size (ie. data object type). */
5830 /* Make a ".reg/999" section and a ".reg" section. */
5831 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5832 raw_size, note->descpos + offset);
5834 #endif /* defined (HAVE_PRSTATUS_T) */
5836 /* Create a pseudosection containing the exact contents of NOTE. */
5838 elfcore_make_note_pseudosection (abfd, name, note)
5841 Elf_Internal_Note *note;
5843 return _bfd_elfcore_make_pseudosection (abfd, name,
5844 note->descsz, note->descpos);
5847 /* There isn't a consistent prfpregset_t across platforms,
5848 but it doesn't matter, because we don't have to pick this
5849 data structure apart. */
5852 elfcore_grok_prfpreg (abfd, note)
5854 Elf_Internal_Note *note;
5856 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
5859 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5860 type of 5 (NT_PRXFPREG). Just include the whole note's contents
5864 elfcore_grok_prxfpreg (abfd, note)
5866 Elf_Internal_Note *note;
5868 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
5871 #if defined (HAVE_PRPSINFO_T)
5872 typedef prpsinfo_t elfcore_psinfo_t;
5873 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
5874 typedef prpsinfo32_t elfcore_psinfo32_t;
5878 #if defined (HAVE_PSINFO_T)
5879 typedef psinfo_t elfcore_psinfo_t;
5880 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
5881 typedef psinfo32_t elfcore_psinfo32_t;
5885 /* return a malloc'ed copy of a string at START which is at
5886 most MAX bytes long, possibly without a terminating '\0'.
5887 the copy will always have a terminating '\0'. */
5890 _bfd_elfcore_strndup (abfd, start, max)
5896 char *end = memchr (start, '\0', max);
5904 dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
5908 memcpy (dups, start, len);
5914 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5915 static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
5918 elfcore_grok_psinfo (abfd, note)
5920 Elf_Internal_Note *note;
5922 if (note->descsz == sizeof (elfcore_psinfo_t))
5924 elfcore_psinfo_t psinfo;
5926 memcpy (&psinfo, note->descdata, sizeof (psinfo));
5928 elf_tdata (abfd)->core_program
5929 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
5930 sizeof (psinfo.pr_fname));
5932 elf_tdata (abfd)->core_command
5933 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
5934 sizeof (psinfo.pr_psargs));
5936 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
5937 else if (note->descsz == sizeof (elfcore_psinfo32_t))
5939 /* 64-bit host, 32-bit corefile */
5940 elfcore_psinfo32_t psinfo;
5942 memcpy (&psinfo, note->descdata, sizeof (psinfo));
5944 elf_tdata (abfd)->core_program
5945 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
5946 sizeof (psinfo.pr_fname));
5948 elf_tdata (abfd)->core_command
5949 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
5950 sizeof (psinfo.pr_psargs));
5956 /* Fail - we don't know how to handle any other
5957 note size (ie. data object type). */
5961 /* Note that for some reason, a spurious space is tacked
5962 onto the end of the args in some (at least one anyway)
5963 implementations, so strip it off if it exists. */
5966 char *command = elf_tdata (abfd)->core_command;
5967 int n = strlen (command);
5969 if (0 < n && command[n - 1] == ' ')
5970 command[n - 1] = '\0';
5975 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5977 #if defined (HAVE_PSTATUS_T)
5979 elfcore_grok_pstatus (abfd, note)
5981 Elf_Internal_Note *note;
5983 if (note->descsz == sizeof (pstatus_t)
5984 #if defined (HAVE_PXSTATUS_T)
5985 || note->descsz == sizeof (pxstatus_t)
5991 memcpy (&pstat, note->descdata, sizeof (pstat));
5993 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5995 #if defined (HAVE_PSTATUS32_T)
5996 else if (note->descsz == sizeof (pstatus32_t))
5998 /* 64-bit host, 32-bit corefile */
6001 memcpy (&pstat, note->descdata, sizeof (pstat));
6003 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6006 /* Could grab some more details from the "representative"
6007 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6008 NT_LWPSTATUS note, presumably. */
6012 #endif /* defined (HAVE_PSTATUS_T) */
6014 #if defined (HAVE_LWPSTATUS_T)
6016 elfcore_grok_lwpstatus (abfd, note)
6018 Elf_Internal_Note *note;
6020 lwpstatus_t lwpstat;
6025 if (note->descsz != sizeof (lwpstat)
6026 #if defined (HAVE_LWPXSTATUS_T)
6027 && note->descsz != sizeof (lwpxstatus_t)
6032 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6034 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6035 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6037 /* Make a ".reg/999" section. */
6039 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6040 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6045 sect = bfd_make_section (abfd, name);
6049 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6050 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6051 sect->filepos = note->descpos
6052 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6055 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6056 sect->_raw_size = sizeof (lwpstat.pr_reg);
6057 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6060 sect->flags = SEC_HAS_CONTENTS;
6061 sect->alignment_power = 2;
6063 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6066 /* Make a ".reg2/999" section */
6068 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6069 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6074 sect = bfd_make_section (abfd, name);
6078 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6079 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6080 sect->filepos = note->descpos
6081 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6084 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6085 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6086 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6089 sect->flags = SEC_HAS_CONTENTS;
6090 sect->alignment_power = 2;
6092 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6094 #endif /* defined (HAVE_LWPSTATUS_T) */
6096 #if defined (HAVE_WIN32_PSTATUS_T)
6098 elfcore_grok_win32pstatus (abfd, note)
6100 Elf_Internal_Note *note;
6105 win32_pstatus_t pstatus;
6107 if (note->descsz < sizeof (pstatus))
6110 memcpy (&pstatus, note->descdata, note->descsz);
6112 switch (pstatus.data_type)
6114 case NOTE_INFO_PROCESS:
6115 /* FIXME: need to add ->core_command. */
6116 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6117 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6120 case NOTE_INFO_THREAD:
6121 /* Make a ".reg/999" section. */
6122 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6124 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6130 sect = bfd_make_section (abfd, name);
6134 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6135 sect->filepos = (note->descpos
6136 + offsetof (struct win32_pstatus,
6137 data.thread_info.thread_context));
6138 sect->flags = SEC_HAS_CONTENTS;
6139 sect->alignment_power = 2;
6141 if (pstatus.data.thread_info.is_active_thread)
6142 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6146 case NOTE_INFO_MODULE:
6147 /* Make a ".module/xxxxxxxx" section. */
6148 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6150 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6156 sect = bfd_make_section (abfd, name);
6161 sect->_raw_size = note->descsz;
6162 sect->filepos = note->descpos;
6163 sect->flags = SEC_HAS_CONTENTS;
6164 sect->alignment_power = 2;
6173 #endif /* HAVE_WIN32_PSTATUS_T */
6176 elfcore_grok_note (abfd, note)
6178 Elf_Internal_Note *note;
6180 struct elf_backend_data *bed = get_elf_backend_data (abfd);
6188 if (bed->elf_backend_grok_prstatus)
6189 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6191 #if defined (HAVE_PRSTATUS_T)
6192 return elfcore_grok_prstatus (abfd, note);
6197 #if defined (HAVE_PSTATUS_T)
6199 return elfcore_grok_pstatus (abfd, note);
6202 #if defined (HAVE_LWPSTATUS_T)
6204 return elfcore_grok_lwpstatus (abfd, note);
6207 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
6208 return elfcore_grok_prfpreg (abfd, note);
6210 #if defined (HAVE_WIN32_PSTATUS_T)
6211 case NT_WIN32PSTATUS:
6212 return elfcore_grok_win32pstatus (abfd, note);
6215 case NT_PRXFPREG: /* Linux SSE extension */
6216 if (note->namesz == 5
6217 && ! strcmp (note->namedata, "LINUX"))
6218 return elfcore_grok_prxfpreg (abfd, note);
6224 if (bed->elf_backend_grok_psinfo)
6225 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6227 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6228 return elfcore_grok_psinfo (abfd, note);
6236 elfcore_read_notes (abfd, offset, size)
6247 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
6250 buf = bfd_malloc (size);
6254 if (bfd_bread (buf, size, abfd) != size)
6262 while (p < buf + size)
6264 /* FIXME: bad alignment assumption. */
6265 Elf_External_Note *xnp = (Elf_External_Note *) p;
6266 Elf_Internal_Note in;
6268 in.type = H_GET_32 (abfd, xnp->type);
6270 in.namesz = H_GET_32 (abfd, xnp->namesz);
6271 in.namedata = xnp->name;
6273 in.descsz = H_GET_32 (abfd, xnp->descsz);
6274 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
6275 in.descpos = offset + (in.descdata - buf);
6277 if (! elfcore_grok_note (abfd, &in))
6280 p = in.descdata + BFD_ALIGN (in.descsz, 4);
6287 /* Providing external access to the ELF program header table. */
6289 /* Return an upper bound on the number of bytes required to store a
6290 copy of ABFD's program header table entries. Return -1 if an error
6291 occurs; bfd_get_error will return an appropriate code. */
6294 bfd_get_elf_phdr_upper_bound (abfd)
6297 if (abfd->xvec->flavour != bfd_target_elf_flavour)
6299 bfd_set_error (bfd_error_wrong_format);
6303 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
6306 /* Copy ABFD's program header table entries to *PHDRS. The entries
6307 will be stored as an array of Elf_Internal_Phdr structures, as
6308 defined in include/elf/internal.h. To find out how large the
6309 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
6311 Return the number of program header table entries read, or -1 if an
6312 error occurs; bfd_get_error will return an appropriate code. */
6315 bfd_get_elf_phdrs (abfd, phdrs)
6321 if (abfd->xvec->flavour != bfd_target_elf_flavour)
6323 bfd_set_error (bfd_error_wrong_format);
6327 num_phdrs = elf_elfheader (abfd)->e_phnum;
6328 memcpy (phdrs, elf_tdata (abfd)->phdr,
6329 num_phdrs * sizeof (Elf_Internal_Phdr));
6335 _bfd_elf_sprintf_vma (abfd, buf, value)
6336 bfd *abfd ATTRIBUTE_UNUSED;
6341 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
6343 i_ehdrp = elf_elfheader (abfd);
6344 if (i_ehdrp == NULL)
6345 sprintf_vma (buf, value);
6348 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6350 #if BFD_HOST_64BIT_LONG
6351 sprintf (buf, "%016lx", value);
6353 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
6354 _bfd_int64_low (value));
6358 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
6361 sprintf_vma (buf, value);
6366 _bfd_elf_fprintf_vma (abfd, stream, value)
6367 bfd *abfd ATTRIBUTE_UNUSED;
6372 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
6374 i_ehdrp = elf_elfheader (abfd);
6375 if (i_ehdrp == NULL)
6376 fprintf_vma ((FILE *) stream, value);
6379 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6381 #if BFD_HOST_64BIT_LONG
6382 fprintf ((FILE *) stream, "%016lx", value);
6384 fprintf ((FILE *) stream, "%08lx%08lx",
6385 _bfd_int64_high (value), _bfd_int64_low (value));
6389 fprintf ((FILE *) stream, "%08lx",
6390 (unsigned long) (value & 0xffffffff));
6393 fprintf_vma ((FILE *) stream, value);
6397 enum elf_reloc_type_class
6398 _bfd_elf_reloc_type_class (rela)
6399 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
6401 return reloc_class_normal;
6404 /* For RELA architectures, return what the relocation value for
6405 relocation against a local symbol. */
6408 _bfd_elf_rela_local_sym (abfd, sym, sec, rel)
6410 Elf_Internal_Sym *sym;
6412 Elf_Internal_Rela *rel;
6416 relocation = (sec->output_section->vma
6417 + sec->output_offset
6419 if ((sec->flags & SEC_MERGE)
6420 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
6421 && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
6427 _bfd_merged_section_offset (abfd, &msec,
6428 elf_section_data (sec)->sec_info,
6429 sym->st_value + rel->r_addend,
6432 rel->r_addend += msec->output_section->vma + msec->output_offset;
6438 _bfd_elf_rel_local_sym (abfd, sym, psec, addend)
6440 Elf_Internal_Sym *sym;
6444 asection *sec = *psec;
6446 if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE)
6447 return sym->st_value + addend;
6449 return _bfd_merged_section_offset (abfd, psec,
6450 elf_section_data (sec)->sec_info,
6451 sym->st_value + addend, (bfd_vma) 0);
6455 _bfd_elf_section_offset (abfd, info, sec, offset)
6457 struct bfd_link_info *info;
6461 struct bfd_elf_section_data *sec_data;
6463 sec_data = elf_section_data (sec);
6464 switch (sec_data->sec_info_type)
6466 case ELF_INFO_TYPE_STABS:
6467 return _bfd_stab_section_offset
6468 (abfd, &elf_hash_table (info)->merge_info, sec, &sec_data->sec_info,
6470 case ELF_INFO_TYPE_EH_FRAME:
6471 return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);