1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
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. */
22 /* $FreeBSD: src/contrib/binutils/bfd/elf.c,v 1.3.6.6 2002/09/01 23:43:36 obrien Exp $ */
23 /* $DragonFly: src/contrib/binutils/bfd/Attic/elf.c,v 1.2 2003/06/17 04:23:58 dillon Exp $ */
30 BFD support for ELF formats is being worked on.
31 Currently, the best supported back ends are for sparc and i386
32 (running svr4 or Solaris 2).
34 Documentation of the internals of the support code still needs
35 to be written. The code is changing quickly enough that we
36 haven't bothered yet. */
38 /* For sparc64-cross-sparc32. */
46 #include "libiberty.h"
48 static INLINE struct elf_segment_map *make_mapping
49 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
50 static boolean map_sections_to_segments PARAMS ((bfd *));
51 static int elf_sort_sections PARAMS ((const PTR, const PTR));
52 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
53 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
54 static boolean prep_headers PARAMS ((bfd *));
55 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
56 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
57 static char *elf_read PARAMS ((bfd *, file_ptr, bfd_size_type));
58 static boolean setup_group PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
59 static void merge_sections_remove_hook PARAMS ((bfd *, asection *));
60 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
61 static void set_group_contents PARAMS ((bfd *, asection *, PTR));
62 static boolean assign_section_numbers PARAMS ((bfd *));
63 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
64 static boolean elf_map_symbols PARAMS ((bfd *));
65 static bfd_size_type get_program_header_size PARAMS ((bfd *));
66 static boolean elfcore_read_notes PARAMS ((bfd *, file_ptr, bfd_size_type));
67 static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
68 bfd_vma, const char **,
70 static int elfcore_make_pid PARAMS ((bfd *));
71 static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
72 static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
73 Elf_Internal_Note *));
74 static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
75 static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
76 static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
78 static boolean elfcore_netbsd_get_lwpid PARAMS ((Elf_Internal_Note *, int *));
79 static boolean elfcore_grok_netbsd_procinfo PARAMS ((bfd *,
80 Elf_Internal_Note *));
81 static boolean elfcore_grok_netbsd_note PARAMS ((bfd *, Elf_Internal_Note *));
83 /* Swap version information in and out. The version information is
84 currently size independent. If that ever changes, this code will
85 need to move into elfcode.h. */
87 /* Swap in a Verdef structure. */
90 _bfd_elf_swap_verdef_in (abfd, src, dst)
92 const Elf_External_Verdef *src;
93 Elf_Internal_Verdef *dst;
95 dst->vd_version = H_GET_16 (abfd, src->vd_version);
96 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
97 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
98 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
99 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
100 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
101 dst->vd_next = H_GET_32 (abfd, src->vd_next);
104 /* Swap out a Verdef structure. */
107 _bfd_elf_swap_verdef_out (abfd, src, dst)
109 const Elf_Internal_Verdef *src;
110 Elf_External_Verdef *dst;
112 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
113 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
114 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
115 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
116 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
117 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
118 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
121 /* Swap in a Verdaux structure. */
124 _bfd_elf_swap_verdaux_in (abfd, src, dst)
126 const Elf_External_Verdaux *src;
127 Elf_Internal_Verdaux *dst;
129 dst->vda_name = H_GET_32 (abfd, src->vda_name);
130 dst->vda_next = H_GET_32 (abfd, src->vda_next);
133 /* Swap out a Verdaux structure. */
136 _bfd_elf_swap_verdaux_out (abfd, src, dst)
138 const Elf_Internal_Verdaux *src;
139 Elf_External_Verdaux *dst;
141 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
142 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
145 /* Swap in a Verneed structure. */
148 _bfd_elf_swap_verneed_in (abfd, src, dst)
150 const Elf_External_Verneed *src;
151 Elf_Internal_Verneed *dst;
153 dst->vn_version = H_GET_16 (abfd, src->vn_version);
154 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
155 dst->vn_file = H_GET_32 (abfd, src->vn_file);
156 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
157 dst->vn_next = H_GET_32 (abfd, src->vn_next);
160 /* Swap out a Verneed structure. */
163 _bfd_elf_swap_verneed_out (abfd, src, dst)
165 const Elf_Internal_Verneed *src;
166 Elf_External_Verneed *dst;
168 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
169 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
170 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
171 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
172 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
175 /* Swap in a Vernaux structure. */
178 _bfd_elf_swap_vernaux_in (abfd, src, dst)
180 const Elf_External_Vernaux *src;
181 Elf_Internal_Vernaux *dst;
183 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
184 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
185 dst->vna_other = H_GET_16 (abfd, src->vna_other);
186 dst->vna_name = H_GET_32 (abfd, src->vna_name);
187 dst->vna_next = H_GET_32 (abfd, src->vna_next);
190 /* Swap out a Vernaux structure. */
193 _bfd_elf_swap_vernaux_out (abfd, src, dst)
195 const Elf_Internal_Vernaux *src;
196 Elf_External_Vernaux *dst;
198 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
199 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
200 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
201 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
202 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
205 /* Swap in a Versym structure. */
208 _bfd_elf_swap_versym_in (abfd, src, dst)
210 const Elf_External_Versym *src;
211 Elf_Internal_Versym *dst;
213 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
216 /* Swap out a Versym structure. */
219 _bfd_elf_swap_versym_out (abfd, src, dst)
221 const Elf_Internal_Versym *src;
222 Elf_External_Versym *dst;
224 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
227 /* Standard ELF hash function. Do not change this function; you will
228 cause invalid hash tables to be generated. */
231 bfd_elf_hash (namearg)
234 const unsigned char *name = (const unsigned char *) namearg;
239 while ((ch = *name++) != '\0')
242 if ((g = (h & 0xf0000000)) != 0)
245 /* The ELF ABI says `h &= ~g', but this is equivalent in
246 this case and on some machines one insn instead of two. */
253 /* Read a specified number of bytes at a specified offset in an ELF
254 file, into a newly allocated buffer, and return a pointer to the
258 elf_read (abfd, offset, size)
265 if ((buf = bfd_alloc (abfd, size)) == NULL)
267 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
269 if (bfd_bread ((PTR) buf, size, abfd) != size)
271 if (bfd_get_error () != bfd_error_system_call)
272 bfd_set_error (bfd_error_file_truncated);
279 bfd_elf_mkobject (abfd)
282 /* This just does initialization. */
283 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
284 bfd_size_type amt = sizeof (struct elf_obj_tdata);
285 elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
286 if (elf_tdata (abfd) == 0)
288 /* Since everything is done at close time, do we need any
295 bfd_elf_mkcorefile (abfd)
298 /* I think this can be done just like an object file. */
299 return bfd_elf_mkobject (abfd);
303 bfd_elf_get_str_section (abfd, shindex)
305 unsigned int shindex;
307 Elf_Internal_Shdr **i_shdrp;
308 char *shstrtab = NULL;
310 bfd_size_type shstrtabsize;
312 i_shdrp = elf_elfsections (abfd);
313 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
316 shstrtab = (char *) i_shdrp[shindex]->contents;
317 if (shstrtab == NULL)
319 /* No cached one, attempt to read, and cache what we read. */
320 offset = i_shdrp[shindex]->sh_offset;
321 shstrtabsize = i_shdrp[shindex]->sh_size;
322 shstrtab = elf_read (abfd, offset, shstrtabsize);
323 i_shdrp[shindex]->contents = (PTR) shstrtab;
329 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
331 unsigned int shindex;
332 unsigned int strindex;
334 Elf_Internal_Shdr *hdr;
339 hdr = elf_elfsections (abfd)[shindex];
341 if (hdr->contents == NULL
342 && bfd_elf_get_str_section (abfd, shindex) == NULL)
345 if (strindex >= hdr->sh_size)
347 (*_bfd_error_handler)
348 (_("%s: invalid string offset %u >= %lu for section `%s'"),
349 bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
350 ((shindex == elf_elfheader(abfd)->e_shstrndx
351 && strindex == hdr->sh_name)
353 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
357 return ((char *) hdr->contents) + strindex;
360 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
361 sections. The first element is the flags, the rest are section
364 typedef union elf_internal_group {
365 Elf_Internal_Shdr *shdr;
367 } Elf_Internal_Group;
369 /* Set next_in_group list pointer, and group name for NEWSECT. */
372 setup_group (abfd, hdr, newsect)
374 Elf_Internal_Shdr *hdr;
377 unsigned int num_group = elf_tdata (abfd)->num_group;
379 /* If num_group is zero, read in all SHT_GROUP sections. The count
380 is set to -1 if there are no SHT_GROUP sections. */
383 unsigned int i, shnum;
385 /* First count the number of groups. If we have a SHT_GROUP
386 section with just a flag word (ie. sh_size is 4), ignore it. */
387 shnum = elf_numsections (abfd);
389 for (i = 0; i < shnum; i++)
391 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
392 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
397 num_group = (unsigned) -1;
398 elf_tdata (abfd)->num_group = num_group;
402 /* We keep a list of elf section headers for group sections,
403 so we can find them quickly. */
404 bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
405 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
406 if (elf_tdata (abfd)->group_sect_ptr == NULL)
410 for (i = 0; i < shnum; i++)
412 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
413 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
416 Elf_Internal_Group *dest;
418 /* Add to list of sections. */
419 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
422 /* Read the raw contents. */
423 BFD_ASSERT (sizeof (*dest) >= 4);
424 amt = shdr->sh_size * sizeof (*dest) / 4;
425 shdr->contents = bfd_alloc (abfd, amt);
426 if (shdr->contents == NULL
427 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
428 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
432 /* Translate raw contents, a flag word followed by an
433 array of elf section indices all in target byte order,
434 to the flag word followed by an array of elf section
436 src = shdr->contents + shdr->sh_size;
437 dest = (Elf_Internal_Group *) (shdr->contents + amt);
444 idx = H_GET_32 (abfd, src);
445 if (src == shdr->contents)
452 ((*_bfd_error_handler)
453 (_("%s: invalid SHT_GROUP entry"),
454 bfd_archive_filename (abfd)));
457 dest->shdr = elf_elfsections (abfd)[idx];
464 if (num_group != (unsigned) -1)
468 for (i = 0; i < num_group; i++)
470 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
471 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
472 unsigned int n_elt = shdr->sh_size / 4;
474 /* Look through this group's sections to see if current
475 section is a member. */
477 if ((++idx)->shdr == hdr)
481 /* We are a member of this group. Go looking through
482 other members to see if any others are linked via
484 idx = (Elf_Internal_Group *) shdr->contents;
485 n_elt = shdr->sh_size / 4;
487 if ((s = (++idx)->shdr->bfd_section) != NULL
488 && elf_next_in_group (s) != NULL)
492 /* Snarf the group name from other member, and
493 insert current section in circular list. */
494 elf_group_name (newsect) = elf_group_name (s);
495 elf_next_in_group (newsect) = elf_next_in_group (s);
496 elf_next_in_group (s) = newsect;
500 struct elf_backend_data *bed;
502 unsigned char ename[4];
506 /* Humbug. Get the name from the group signature
507 symbol. Why isn't the signature just a string?
508 Fortunately, the name index is at the same
509 place in the external symbol for both 32 and 64
511 bed = get_elf_backend_data (abfd);
512 pos = elf_tdata (abfd)->symtab_hdr.sh_offset;
513 pos += shdr->sh_info * bed->s->sizeof_sym;
514 if (bfd_seek (abfd, pos, SEEK_SET) != 0
515 || bfd_bread (ename, (bfd_size_type) 4, abfd) != 4)
517 iname = H_GET_32 (abfd, ename);
518 gname = elf_string_from_elf_strtab (abfd, iname);
519 elf_group_name (newsect) = gname;
521 /* Start a circular list with one element. */
522 elf_next_in_group (newsect) = newsect;
524 if (shdr->bfd_section != NULL)
525 elf_next_in_group (shdr->bfd_section) = newsect;
532 if (elf_group_name (newsect) == NULL)
534 (*_bfd_error_handler) (_("%s: no group info for section %s"),
535 bfd_archive_filename (abfd), newsect->name);
540 /* Make a BFD section from an ELF section. We store a pointer to the
541 BFD section in the bfd_section field of the header. */
544 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
546 Elf_Internal_Shdr *hdr;
551 struct elf_backend_data *bed;
553 if (hdr->bfd_section != NULL)
555 BFD_ASSERT (strcmp (name,
556 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
560 newsect = bfd_make_section_anyway (abfd, name);
564 newsect->filepos = hdr->sh_offset;
566 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
567 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
568 || ! bfd_set_section_alignment (abfd, newsect,
569 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
572 flags = SEC_NO_FLAGS;
573 if (hdr->sh_type != SHT_NOBITS)
574 flags |= SEC_HAS_CONTENTS;
575 if (hdr->sh_type == SHT_GROUP)
576 flags |= SEC_GROUP | SEC_EXCLUDE;
577 if ((hdr->sh_flags & SHF_ALLOC) != 0)
580 if (hdr->sh_type != SHT_NOBITS)
583 if ((hdr->sh_flags & SHF_WRITE) == 0)
584 flags |= SEC_READONLY;
585 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
587 else if ((flags & SEC_LOAD) != 0)
589 if ((hdr->sh_flags & SHF_MERGE) != 0)
592 newsect->entsize = hdr->sh_entsize;
593 if ((hdr->sh_flags & SHF_STRINGS) != 0)
594 flags |= SEC_STRINGS;
596 if (hdr->sh_flags & SHF_GROUP)
597 if (!setup_group (abfd, hdr, newsect))
600 /* The debugging sections appear to be recognized only by name, not
603 static const char *debug_sec_names [] =
612 for (i = ARRAY_SIZE (debug_sec_names); i--;)
613 if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
617 flags |= SEC_DEBUGGING;
620 /* As a GNU extension, if the name begins with .gnu.linkonce, we
621 only link a single copy of the section. This is used to support
622 g++. g++ will emit each template expansion in its own section.
623 The symbols will be defined as weak, so that multiple definitions
624 are permitted. The GNU linker extension is to actually discard
625 all but one of the sections. */
626 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
627 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
629 bed = get_elf_backend_data (abfd);
630 if (bed->elf_backend_section_flags)
631 if (! bed->elf_backend_section_flags (&flags, hdr))
634 if (! bfd_set_section_flags (abfd, newsect, flags))
637 if ((flags & SEC_ALLOC) != 0)
639 Elf_Internal_Phdr *phdr;
642 /* Look through the phdrs to see if we need to adjust the lma.
643 If all the p_paddr fields are zero, we ignore them, since
644 some ELF linkers produce such output. */
645 phdr = elf_tdata (abfd)->phdr;
646 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
648 if (phdr->p_paddr != 0)
651 if (i < elf_elfheader (abfd)->e_phnum)
653 phdr = elf_tdata (abfd)->phdr;
654 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
656 /* This section is part of this segment if its file
657 offset plus size lies within the segment's memory
658 span and, if the section is loaded, the extent of the
659 loaded data lies within the extent of the segment.
661 Note - we used to check the p_paddr field as well, and
662 refuse to set the LMA if it was 0. This is wrong
663 though, as a perfectly valid initialised segment can
664 have a p_paddr of zero. Some architectures, eg ARM,
665 place special significance on the address 0 and
666 executables need to be able to have a segment which
667 covers this address. */
668 if (phdr->p_type == PT_LOAD
669 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
670 && (hdr->sh_offset + hdr->sh_size
671 <= phdr->p_offset + phdr->p_memsz)
672 && ((flags & SEC_LOAD) == 0
673 || (hdr->sh_offset + hdr->sh_size
674 <= phdr->p_offset + phdr->p_filesz)))
676 if ((flags & SEC_LOAD) == 0)
677 newsect->lma = (phdr->p_paddr
678 + hdr->sh_addr - phdr->p_vaddr);
680 /* We used to use the same adjustment for SEC_LOAD
681 sections, but that doesn't work if the segment
682 is packed with code from multiple VMAs.
683 Instead we calculate the section LMA based on
684 the segment LMA. It is assumed that the
685 segment will contain sections with contiguous
686 LMAs, even if the VMAs are not. */
687 newsect->lma = (phdr->p_paddr
688 + hdr->sh_offset - phdr->p_offset);
690 /* With contiguous segments, we can't tell from file
691 offsets whether a section with zero size should
692 be placed at the end of one segment or the
693 beginning of the next. Decide based on vaddr. */
694 if (hdr->sh_addr >= phdr->p_vaddr
695 && (hdr->sh_addr + hdr->sh_size
696 <= phdr->p_vaddr + phdr->p_memsz))
703 hdr->bfd_section = newsect;
704 elf_section_data (newsect)->this_hdr = *hdr;
714 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
717 Helper functions for GDB to locate the string tables.
718 Since BFD hides string tables from callers, GDB needs to use an
719 internal hook to find them. Sun's .stabstr, in particular,
720 isn't even pointed to by the .stab section, so ordinary
721 mechanisms wouldn't work to find it, even if we had some.
724 struct elf_internal_shdr *
725 bfd_elf_find_section (abfd, name)
729 Elf_Internal_Shdr **i_shdrp;
734 i_shdrp = elf_elfsections (abfd);
737 shstrtab = bfd_elf_get_str_section (abfd,
738 elf_elfheader (abfd)->e_shstrndx);
739 if (shstrtab != NULL)
741 max = elf_numsections (abfd);
742 for (i = 1; i < max; i++)
743 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
750 const char *const bfd_elf_section_type_names[] = {
751 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
752 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
753 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
756 /* ELF relocs are against symbols. If we are producing relocateable
757 output, and the reloc is against an external symbol, and nothing
758 has given us any additional addend, the resulting reloc will also
759 be against the same symbol. In such a case, we don't want to
760 change anything about the way the reloc is handled, since it will
761 all be done at final link time. Rather than put special case code
762 into bfd_perform_relocation, all the reloc types use this howto
763 function. It just short circuits the reloc if producing
764 relocateable output against an external symbol. */
766 bfd_reloc_status_type
767 bfd_elf_generic_reloc (abfd,
774 bfd *abfd ATTRIBUTE_UNUSED;
775 arelent *reloc_entry;
777 PTR data ATTRIBUTE_UNUSED;
778 asection *input_section;
780 char **error_message ATTRIBUTE_UNUSED;
782 if (output_bfd != (bfd *) NULL
783 && (symbol->flags & BSF_SECTION_SYM) == 0
784 && (! reloc_entry->howto->partial_inplace
785 || reloc_entry->addend == 0))
787 reloc_entry->address += input_section->output_offset;
791 return bfd_reloc_continue;
794 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
797 merge_sections_remove_hook (abfd, sec)
798 bfd *abfd ATTRIBUTE_UNUSED;
801 struct bfd_elf_section_data *sec_data;
803 sec_data = elf_section_data (sec);
804 BFD_ASSERT (sec_data->sec_info_type == ELF_INFO_TYPE_MERGE);
805 sec_data->sec_info_type = ELF_INFO_TYPE_NONE;
808 /* Finish SHF_MERGE section merging. */
811 _bfd_elf_merge_sections (abfd, info)
813 struct bfd_link_info *info;
815 if (!is_elf_hash_table (info))
817 if (elf_hash_table (info)->merge_info)
818 _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
819 merge_sections_remove_hook);
823 /* Copy the program header and other data from one object module to
827 _bfd_elf_copy_private_bfd_data (ibfd, obfd)
831 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
832 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
835 BFD_ASSERT (!elf_flags_init (obfd)
836 || (elf_elfheader (obfd)->e_flags
837 == elf_elfheader (ibfd)->e_flags));
839 elf_gp (obfd) = elf_gp (ibfd);
840 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
841 elf_flags_init (obfd) = true;
845 /* Print out the program headers. */
848 _bfd_elf_print_private_bfd_data (abfd, farg)
852 FILE *f = (FILE *) farg;
853 Elf_Internal_Phdr *p;
855 bfd_byte *dynbuf = NULL;
857 p = elf_tdata (abfd)->phdr;
862 fprintf (f, _("\nProgram Header:\n"));
863 c = elf_elfheader (abfd)->e_phnum;
864 for (i = 0; i < c; i++, p++)
871 case PT_NULL: pt = "NULL"; break;
872 case PT_LOAD: pt = "LOAD"; break;
873 case PT_DYNAMIC: pt = "DYNAMIC"; break;
874 case PT_INTERP: pt = "INTERP"; break;
875 case PT_NOTE: pt = "NOTE"; break;
876 case PT_SHLIB: pt = "SHLIB"; break;
877 case PT_PHDR: pt = "PHDR"; break;
878 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
879 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
881 fprintf (f, "%8s off 0x", pt);
882 bfd_fprintf_vma (abfd, f, p->p_offset);
883 fprintf (f, " vaddr 0x");
884 bfd_fprintf_vma (abfd, f, p->p_vaddr);
885 fprintf (f, " paddr 0x");
886 bfd_fprintf_vma (abfd, f, p->p_paddr);
887 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
888 fprintf (f, " filesz 0x");
889 bfd_fprintf_vma (abfd, f, p->p_filesz);
890 fprintf (f, " memsz 0x");
891 bfd_fprintf_vma (abfd, f, p->p_memsz);
892 fprintf (f, " flags %c%c%c",
893 (p->p_flags & PF_R) != 0 ? 'r' : '-',
894 (p->p_flags & PF_W) != 0 ? 'w' : '-',
895 (p->p_flags & PF_X) != 0 ? 'x' : '-');
896 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
897 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
902 s = bfd_get_section_by_name (abfd, ".dynamic");
906 unsigned long shlink;
907 bfd_byte *extdyn, *extdynend;
909 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
911 fprintf (f, _("\nDynamic Section:\n"));
913 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
916 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
920 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
923 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
925 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
926 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
929 extdynend = extdyn + s->_raw_size;
930 for (; extdyn < extdynend; extdyn += extdynsize)
932 Elf_Internal_Dyn dyn;
937 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
939 if (dyn.d_tag == DT_NULL)
946 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
950 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
951 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
952 case DT_PLTGOT: name = "PLTGOT"; break;
953 case DT_HASH: name = "HASH"; break;
954 case DT_STRTAB: name = "STRTAB"; break;
955 case DT_SYMTAB: name = "SYMTAB"; break;
956 case DT_RELA: name = "RELA"; break;
957 case DT_RELASZ: name = "RELASZ"; break;
958 case DT_RELAENT: name = "RELAENT"; break;
959 case DT_STRSZ: name = "STRSZ"; break;
960 case DT_SYMENT: name = "SYMENT"; break;
961 case DT_INIT: name = "INIT"; break;
962 case DT_FINI: name = "FINI"; break;
963 case DT_SONAME: name = "SONAME"; stringp = true; break;
964 case DT_RPATH: name = "RPATH"; stringp = true; break;
965 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
966 case DT_REL: name = "REL"; break;
967 case DT_RELSZ: name = "RELSZ"; break;
968 case DT_RELENT: name = "RELENT"; break;
969 case DT_PLTREL: name = "PLTREL"; break;
970 case DT_DEBUG: name = "DEBUG"; break;
971 case DT_TEXTREL: name = "TEXTREL"; break;
972 case DT_JMPREL: name = "JMPREL"; break;
973 case DT_BIND_NOW: name = "BIND_NOW"; break;
974 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
975 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
976 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
977 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
978 case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
979 case DT_FLAGS: name = "FLAGS"; break;
980 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
981 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
982 case DT_CHECKSUM: name = "CHECKSUM"; break;
983 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
984 case DT_MOVEENT: name = "MOVEENT"; break;
985 case DT_MOVESZ: name = "MOVESZ"; break;
986 case DT_FEATURE: name = "FEATURE"; break;
987 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
988 case DT_SYMINSZ: name = "SYMINSZ"; break;
989 case DT_SYMINENT: name = "SYMINENT"; break;
990 case DT_CONFIG: name = "CONFIG"; stringp = true; break;
991 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
992 case DT_AUDIT: name = "AUDIT"; stringp = true; break;
993 case DT_PLTPAD: name = "PLTPAD"; break;
994 case DT_MOVETAB: name = "MOVETAB"; break;
995 case DT_SYMINFO: name = "SYMINFO"; break;
996 case DT_RELACOUNT: name = "RELACOUNT"; break;
997 case DT_RELCOUNT: name = "RELCOUNT"; break;
998 case DT_FLAGS_1: name = "FLAGS_1"; break;
999 case DT_VERSYM: name = "VERSYM"; break;
1000 case DT_VERDEF: name = "VERDEF"; break;
1001 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1002 case DT_VERNEED: name = "VERNEED"; break;
1003 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1004 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
1005 case DT_USED: name = "USED"; break;
1006 case DT_FILTER: name = "FILTER"; stringp = true; break;
1009 fprintf (f, " %-11s ", name);
1011 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1015 unsigned int tagv = dyn.d_un.d_val;
1017 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1020 fprintf (f, "%s", string);
1029 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1030 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1032 if (! _bfd_elf_slurp_version_tables (abfd))
1036 if (elf_dynverdef (abfd) != 0)
1038 Elf_Internal_Verdef *t;
1040 fprintf (f, _("\nVersion definitions:\n"));
1041 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1043 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1044 t->vd_flags, t->vd_hash, t->vd_nodename);
1045 if (t->vd_auxptr->vda_nextptr != NULL)
1047 Elf_Internal_Verdaux *a;
1050 for (a = t->vd_auxptr->vda_nextptr;
1053 fprintf (f, "%s ", a->vda_nodename);
1059 if (elf_dynverref (abfd) != 0)
1061 Elf_Internal_Verneed *t;
1063 fprintf (f, _("\nVersion References:\n"));
1064 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1066 Elf_Internal_Vernaux *a;
1068 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1069 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1070 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1071 a->vna_flags, a->vna_other, a->vna_nodename);
1083 /* Display ELF-specific fields of a symbol. */
1086 bfd_elf_print_symbol (abfd, filep, symbol, how)
1090 bfd_print_symbol_type how;
1092 FILE *file = (FILE *) filep;
1095 case bfd_print_symbol_name:
1096 fprintf (file, "%s", symbol->name);
1098 case bfd_print_symbol_more:
1099 fprintf (file, "elf ");
1100 bfd_fprintf_vma (abfd, file, symbol->value);
1101 fprintf (file, " %lx", (long) symbol->flags);
1103 case bfd_print_symbol_all:
1105 const char *section_name;
1106 const char *name = NULL;
1107 struct elf_backend_data *bed;
1108 unsigned char st_other;
1111 section_name = symbol->section ? symbol->section->name : "(*none*)";
1113 bed = get_elf_backend_data (abfd);
1114 if (bed->elf_backend_print_symbol_all)
1115 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1119 name = symbol->name;
1120 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
1123 fprintf (file, " %s\t", section_name);
1124 /* Print the "other" value for a symbol. For common symbols,
1125 we've already printed the size; now print the alignment.
1126 For other symbols, we have no specified alignment, and
1127 we've printed the address; now print the size. */
1128 if (bfd_is_com_section (symbol->section))
1129 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1131 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1132 bfd_fprintf_vma (abfd, file, val);
1134 /* If we have version information, print it. */
1135 if (elf_tdata (abfd)->dynversym_section != 0
1136 && (elf_tdata (abfd)->dynverdef_section != 0
1137 || elf_tdata (abfd)->dynverref_section != 0))
1139 unsigned int vernum;
1140 const char *version_string;
1142 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1145 version_string = "";
1146 else if (vernum == 1)
1147 version_string = "Base";
1148 else if (vernum <= elf_tdata (abfd)->cverdefs)
1150 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1153 Elf_Internal_Verneed *t;
1155 version_string = "";
1156 for (t = elf_tdata (abfd)->verref;
1160 Elf_Internal_Vernaux *a;
1162 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1164 if (a->vna_other == vernum)
1166 version_string = a->vna_nodename;
1173 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1174 fprintf (file, " %-11s", version_string);
1179 fprintf (file, " (%s)", version_string);
1180 for (i = 10 - strlen (version_string); i > 0; --i)
1185 /* If the st_other field is not zero, print it. */
1186 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1191 case STV_INTERNAL: fprintf (file, " .internal"); break;
1192 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1193 case STV_PROTECTED: fprintf (file, " .protected"); break;
1195 /* Some other non-defined flags are also present, so print
1197 fprintf (file, " 0x%02x", (unsigned int) st_other);
1200 fprintf (file, " %s", name);
1206 /* Create an entry in an ELF linker hash table. */
1208 struct bfd_hash_entry *
1209 _bfd_elf_link_hash_newfunc (entry, table, string)
1210 struct bfd_hash_entry *entry;
1211 struct bfd_hash_table *table;
1214 /* Allocate the structure if it has not already been allocated by a
1218 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1223 /* Call the allocation method of the superclass. */
1224 entry = _bfd_link_hash_newfunc (entry, table, string);
1227 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1228 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1230 /* Set local fields. */
1234 ret->dynstr_index = 0;
1235 ret->weakdef = NULL;
1236 ret->got.refcount = htab->init_refcount;
1237 ret->plt.refcount = htab->init_refcount;
1238 ret->linker_section_pointer = NULL;
1239 ret->verinfo.verdef = NULL;
1240 ret->vtable_entries_used = NULL;
1241 ret->vtable_entries_size = 0;
1242 ret->vtable_parent = NULL;
1243 ret->type = STT_NOTYPE;
1245 /* Assume that we have been called by a non-ELF symbol reader.
1246 This flag is then reset by the code which reads an ELF input
1247 file. This ensures that a symbol created by a non-ELF symbol
1248 reader will have the flag set correctly. */
1249 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1255 /* Copy data from an indirect symbol to its direct symbol, hiding the
1256 old indirect symbol. Also used for copying flags to a weakdef. */
1259 _bfd_elf_link_hash_copy_indirect (dir, ind)
1260 struct elf_link_hash_entry *dir, *ind;
1264 /* Copy down any references that we may have already seen to the
1265 symbol which just became indirect. */
1267 dir->elf_link_hash_flags |=
1268 (ind->elf_link_hash_flags
1269 & (ELF_LINK_HASH_REF_DYNAMIC
1270 | ELF_LINK_HASH_REF_REGULAR
1271 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1272 | ELF_LINK_NON_GOT_REF));
1274 if (ind->root.type != bfd_link_hash_indirect)
1277 /* Copy over the global and procedure linkage table refcount entries.
1278 These may have been already set up by a check_relocs routine. */
1279 tmp = dir->got.refcount;
1282 dir->got.refcount = ind->got.refcount;
1283 ind->got.refcount = tmp;
1286 BFD_ASSERT (ind->got.refcount <= 0);
1288 tmp = dir->plt.refcount;
1291 dir->plt.refcount = ind->plt.refcount;
1292 ind->plt.refcount = tmp;
1295 BFD_ASSERT (ind->plt.refcount <= 0);
1297 if (dir->dynindx == -1)
1299 dir->dynindx = ind->dynindx;
1300 dir->dynstr_index = ind->dynstr_index;
1302 ind->dynstr_index = 0;
1305 BFD_ASSERT (ind->dynindx == -1);
1309 _bfd_elf_link_hash_hide_symbol (info, h, force_local)
1310 struct bfd_link_info *info;
1311 struct elf_link_hash_entry *h;
1312 boolean force_local;
1314 h->plt.offset = (bfd_vma) -1;
1315 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1318 h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
1319 if (h->dynindx != -1)
1322 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1328 /* Initialize an ELF linker hash table. */
1331 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
1332 struct elf_link_hash_table *table;
1334 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1335 struct bfd_hash_table *,
1340 table->dynamic_sections_created = false;
1341 table->dynobj = NULL;
1342 table->init_refcount = get_elf_backend_data (abfd)->can_refcount - 1;
1343 /* The first dynamic symbol is a dummy. */
1344 table->dynsymcount = 1;
1345 table->dynstr = NULL;
1346 table->bucketcount = 0;
1347 table->needed = NULL;
1348 table->runpath = NULL;
1350 table->stab_info = NULL;
1351 table->merge_info = NULL;
1352 table->dynlocal = NULL;
1353 ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
1354 table->root.type = bfd_link_elf_hash_table;
1359 /* Create an ELF linker hash table. */
1361 struct bfd_link_hash_table *
1362 _bfd_elf_link_hash_table_create (abfd)
1365 struct elf_link_hash_table *ret;
1366 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1368 ret = (struct elf_link_hash_table *) bfd_alloc (abfd, amt);
1369 if (ret == (struct elf_link_hash_table *) NULL)
1372 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1374 bfd_release (abfd, ret);
1381 /* This is a hook for the ELF emulation code in the generic linker to
1382 tell the backend linker what file name to use for the DT_NEEDED
1383 entry for a dynamic object. The generic linker passes name as an
1384 empty string to indicate that no DT_NEEDED entry should be made. */
1387 bfd_elf_set_dt_needed_name (abfd, name)
1391 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1392 && bfd_get_format (abfd) == bfd_object)
1393 elf_dt_name (abfd) = name;
1397 bfd_elf_set_dt_needed_soname (abfd, name)
1401 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1402 && bfd_get_format (abfd) == bfd_object)
1403 elf_dt_soname (abfd) = name;
1406 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1407 the linker ELF emulation code. */
1409 struct bfd_link_needed_list *
1410 bfd_elf_get_needed_list (abfd, info)
1411 bfd *abfd ATTRIBUTE_UNUSED;
1412 struct bfd_link_info *info;
1414 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1416 return elf_hash_table (info)->needed;
1419 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1420 hook for the linker ELF emulation code. */
1422 struct bfd_link_needed_list *
1423 bfd_elf_get_runpath_list (abfd, info)
1424 bfd *abfd ATTRIBUTE_UNUSED;
1425 struct bfd_link_info *info;
1427 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1429 return elf_hash_table (info)->runpath;
1432 /* Get the name actually used for a dynamic object for a link. This
1433 is the SONAME entry if there is one. Otherwise, it is the string
1434 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1437 bfd_elf_get_dt_soname (abfd)
1440 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1441 && bfd_get_format (abfd) == bfd_object)
1442 return elf_dt_name (abfd);
1446 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1447 the ELF linker emulation code. */
1450 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1452 struct bfd_link_needed_list **pneeded;
1455 bfd_byte *dynbuf = NULL;
1457 unsigned long shlink;
1458 bfd_byte *extdyn, *extdynend;
1460 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1464 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1465 || bfd_get_format (abfd) != bfd_object)
1468 s = bfd_get_section_by_name (abfd, ".dynamic");
1469 if (s == NULL || s->_raw_size == 0)
1472 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1476 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1480 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1484 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1486 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1487 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1490 extdynend = extdyn + s->_raw_size;
1491 for (; extdyn < extdynend; extdyn += extdynsize)
1493 Elf_Internal_Dyn dyn;
1495 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1497 if (dyn.d_tag == DT_NULL)
1500 if (dyn.d_tag == DT_NEEDED)
1503 struct bfd_link_needed_list *l;
1504 unsigned int tagv = dyn.d_un.d_val;
1507 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1512 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1533 /* Allocate an ELF string table--force the first byte to be zero. */
1535 struct bfd_strtab_hash *
1536 _bfd_elf_stringtab_init ()
1538 struct bfd_strtab_hash *ret;
1540 ret = _bfd_stringtab_init ();
1545 loc = _bfd_stringtab_add (ret, "", true, false);
1546 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1547 if (loc == (bfd_size_type) -1)
1549 _bfd_stringtab_free (ret);
1556 /* ELF .o/exec file reading */
1558 /* Create a new bfd section from an ELF section header. */
1561 bfd_section_from_shdr (abfd, shindex)
1563 unsigned int shindex;
1565 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1566 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1567 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1570 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1572 switch (hdr->sh_type)
1575 /* Inactive section. Throw it away. */
1578 case SHT_PROGBITS: /* Normal section with contents. */
1579 case SHT_DYNAMIC: /* Dynamic linking information. */
1580 case SHT_NOBITS: /* .bss section. */
1581 case SHT_HASH: /* .hash section. */
1582 case SHT_NOTE: /* .note section. */
1583 case SHT_INIT_ARRAY: /* .init_array section. */
1584 case SHT_FINI_ARRAY: /* .fini_array section. */
1585 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1586 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1588 case SHT_SYMTAB: /* A symbol table */
1589 if (elf_onesymtab (abfd) == shindex)
1592 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1593 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1594 elf_onesymtab (abfd) = shindex;
1595 elf_tdata (abfd)->symtab_hdr = *hdr;
1596 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1597 abfd->flags |= HAS_SYMS;
1599 /* Sometimes a shared object will map in the symbol table. If
1600 SHF_ALLOC is set, and this is a shared object, then we also
1601 treat this section as a BFD section. We can not base the
1602 decision purely on SHF_ALLOC, because that flag is sometimes
1603 set in a relocateable object file, which would confuse the
1605 if ((hdr->sh_flags & SHF_ALLOC) != 0
1606 && (abfd->flags & DYNAMIC) != 0
1607 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1612 case SHT_DYNSYM: /* A dynamic symbol table */
1613 if (elf_dynsymtab (abfd) == shindex)
1616 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1617 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1618 elf_dynsymtab (abfd) = shindex;
1619 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1620 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1621 abfd->flags |= HAS_SYMS;
1623 /* Besides being a symbol table, we also treat this as a regular
1624 section, so that objcopy can handle it. */
1625 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1627 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1628 if (elf_symtab_shndx (abfd) == shindex)
1631 /* Get the associated symbol table. */
1632 if (! bfd_section_from_shdr (abfd, hdr->sh_link)
1633 || hdr->sh_link != elf_onesymtab (abfd))
1636 elf_symtab_shndx (abfd) = shindex;
1637 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1638 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1641 case SHT_STRTAB: /* A string table */
1642 if (hdr->bfd_section != NULL)
1644 if (ehdr->e_shstrndx == shindex)
1646 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1647 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1651 unsigned int i, num_sec;
1653 num_sec = elf_numsections (abfd);
1654 for (i = 1; i < num_sec; i++)
1656 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1657 if (hdr2->sh_link == shindex)
1659 if (! bfd_section_from_shdr (abfd, i))
1661 if (elf_onesymtab (abfd) == i)
1663 elf_tdata (abfd)->strtab_hdr = *hdr;
1664 elf_elfsections (abfd)[shindex] =
1665 &elf_tdata (abfd)->strtab_hdr;
1668 if (elf_dynsymtab (abfd) == i)
1670 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1671 elf_elfsections (abfd)[shindex] = hdr =
1672 &elf_tdata (abfd)->dynstrtab_hdr;
1673 /* We also treat this as a regular section, so
1674 that objcopy can handle it. */
1677 #if 0 /* Not handling other string tables specially right now. */
1678 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1679 /* We have a strtab for some random other section. */
1680 newsect = (asection *) hdr2->bfd_section;
1683 hdr->bfd_section = newsect;
1684 hdr2 = &elf_section_data (newsect)->str_hdr;
1686 elf_elfsections (abfd)[shindex] = hdr2;
1692 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1696 /* *These* do a lot of work -- but build no sections! */
1698 asection *target_sect;
1699 Elf_Internal_Shdr *hdr2;
1700 unsigned int num_sec = elf_numsections (abfd);
1702 /* Check for a bogus link to avoid crashing. */
1703 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1704 || hdr->sh_link >= num_sec)
1706 ((*_bfd_error_handler)
1707 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1708 bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1709 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1712 /* For some incomprehensible reason Oracle distributes
1713 libraries for Solaris in which some of the objects have
1714 bogus sh_link fields. It would be nice if we could just
1715 reject them, but, unfortunately, some people need to use
1716 them. We scan through the section headers; if we find only
1717 one suitable symbol table, we clobber the sh_link to point
1718 to it. I hope this doesn't break anything. */
1719 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1720 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1726 for (scan = 1; scan < num_sec; scan++)
1728 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1729 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1740 hdr->sh_link = found;
1743 /* Get the symbol table. */
1744 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1745 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1748 /* If this reloc section does not use the main symbol table we
1749 don't treat it as a reloc section. BFD can't adequately
1750 represent such a section, so at least for now, we don't
1751 try. We just present it as a normal section. We also
1752 can't use it as a reloc section if it points to the null
1754 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1755 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1757 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1759 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1760 if (target_sect == NULL)
1763 if ((target_sect->flags & SEC_RELOC) == 0
1764 || target_sect->reloc_count == 0)
1765 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1769 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1770 amt = sizeof (*hdr2);
1771 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1772 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1775 elf_elfsections (abfd)[shindex] = hdr2;
1776 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1777 target_sect->flags |= SEC_RELOC;
1778 target_sect->relocation = NULL;
1779 target_sect->rel_filepos = hdr->sh_offset;
1780 /* In the section to which the relocations apply, mark whether
1781 its relocations are of the REL or RELA variety. */
1782 if (hdr->sh_size != 0)
1783 elf_section_data (target_sect)->use_rela_p
1784 = (hdr->sh_type == SHT_RELA);
1785 abfd->flags |= HAS_RELOC;
1790 case SHT_GNU_verdef:
1791 elf_dynverdef (abfd) = shindex;
1792 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1793 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1796 case SHT_GNU_versym:
1797 elf_dynversym (abfd) = shindex;
1798 elf_tdata (abfd)->dynversym_hdr = *hdr;
1799 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1802 case SHT_GNU_verneed:
1803 elf_dynverref (abfd) = shindex;
1804 elf_tdata (abfd)->dynverref_hdr = *hdr;
1805 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1812 /* Make a section for objcopy and relocatable links. */
1813 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
1815 if (hdr->contents != NULL)
1817 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1818 unsigned int n_elt = hdr->sh_size / 4;
1821 while (--n_elt != 0)
1822 if ((s = (++idx)->shdr->bfd_section) != NULL
1823 && elf_next_in_group (s) != NULL)
1825 elf_next_in_group (hdr->bfd_section) = s;
1832 /* Check for any processor-specific section types. */
1834 if (bed->elf_backend_section_from_shdr)
1835 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1843 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1844 Return SEC for sections that have no elf section, and NULL on error. */
1847 bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
1849 struct sym_sec_cache *cache;
1851 unsigned long r_symndx;
1853 unsigned char esym_shndx[4];
1854 unsigned int isym_shndx;
1855 Elf_Internal_Shdr *symtab_hdr;
1858 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1860 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
1861 return cache->sec[ent];
1863 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1864 pos = symtab_hdr->sh_offset;
1865 if (get_elf_backend_data (abfd)->s->sizeof_sym
1866 == sizeof (Elf64_External_Sym))
1868 pos += r_symndx * sizeof (Elf64_External_Sym);
1869 pos += offsetof (Elf64_External_Sym, st_shndx);
1870 amt = sizeof (((Elf64_External_Sym *) 0)->st_shndx);
1874 pos += r_symndx * sizeof (Elf32_External_Sym);
1875 pos += offsetof (Elf32_External_Sym, st_shndx);
1876 amt = sizeof (((Elf32_External_Sym *) 0)->st_shndx);
1878 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1879 || bfd_bread ((PTR) esym_shndx, amt, abfd) != amt)
1881 isym_shndx = H_GET_16 (abfd, esym_shndx);
1883 if (isym_shndx == SHN_XINDEX)
1885 Elf_Internal_Shdr *shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1886 if (shndx_hdr->sh_size != 0)
1888 pos = shndx_hdr->sh_offset;
1889 pos += r_symndx * sizeof (Elf_External_Sym_Shndx);
1890 amt = sizeof (Elf_External_Sym_Shndx);
1891 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1892 || bfd_bread ((PTR) esym_shndx, amt, abfd) != amt)
1894 isym_shndx = H_GET_32 (abfd, esym_shndx);
1898 if (cache->abfd != abfd)
1900 memset (cache->indx, -1, sizeof (cache->indx));
1903 cache->indx[ent] = r_symndx;
1904 cache->sec[ent] = sec;
1905 if (isym_shndx < SHN_LORESERVE || isym_shndx > SHN_HIRESERVE)
1908 s = bfd_section_from_elf_index (abfd, isym_shndx);
1910 cache->sec[ent] = s;
1912 return cache->sec[ent];
1915 /* Given an ELF section number, retrieve the corresponding BFD
1919 bfd_section_from_elf_index (abfd, index)
1923 if (index >= elf_numsections (abfd))
1925 return elf_elfsections (abfd)[index]->bfd_section;
1929 _bfd_elf_new_section_hook (abfd, sec)
1933 struct bfd_elf_section_data *sdata;
1934 bfd_size_type amt = sizeof (*sdata);
1936 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
1939 sec->used_by_bfd = (PTR) sdata;
1941 /* Indicate whether or not this section should use RELA relocations. */
1943 = get_elf_backend_data (abfd)->default_use_rela_p;
1948 /* Create a new bfd section from an ELF program header.
1950 Since program segments have no names, we generate a synthetic name
1951 of the form segment<NUM>, where NUM is generally the index in the
1952 program header table. For segments that are split (see below) we
1953 generate the names segment<NUM>a and segment<NUM>b.
1955 Note that some program segments may have a file size that is different than
1956 (less than) the memory size. All this means is that at execution the
1957 system must allocate the amount of memory specified by the memory size,
1958 but only initialize it with the first "file size" bytes read from the
1959 file. This would occur for example, with program segments consisting
1960 of combined data+bss.
1962 To handle the above situation, this routine generates TWO bfd sections
1963 for the single program segment. The first has the length specified by
1964 the file size of the segment, and the second has the length specified
1965 by the difference between the two sizes. In effect, the segment is split
1966 into it's initialized and uninitialized parts.
1971 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1973 Elf_Internal_Phdr *hdr;
1975 const char *typename;
1982 split = ((hdr->p_memsz > 0)
1983 && (hdr->p_filesz > 0)
1984 && (hdr->p_memsz > hdr->p_filesz));
1985 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1986 name = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
1989 strcpy (name, namebuf);
1990 newsect = bfd_make_section (abfd, name);
1991 if (newsect == NULL)
1993 newsect->vma = hdr->p_vaddr;
1994 newsect->lma = hdr->p_paddr;
1995 newsect->_raw_size = hdr->p_filesz;
1996 newsect->filepos = hdr->p_offset;
1997 newsect->flags |= SEC_HAS_CONTENTS;
1998 if (hdr->p_type == PT_LOAD)
2000 newsect->flags |= SEC_ALLOC;
2001 newsect->flags |= SEC_LOAD;
2002 if (hdr->p_flags & PF_X)
2004 /* FIXME: all we known is that it has execute PERMISSION,
2006 newsect->flags |= SEC_CODE;
2009 if (!(hdr->p_flags & PF_W))
2011 newsect->flags |= SEC_READONLY;
2016 sprintf (namebuf, "%s%db", typename, index);
2017 name = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
2020 strcpy (name, namebuf);
2021 newsect = bfd_make_section (abfd, name);
2022 if (newsect == NULL)
2024 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2025 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2026 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
2027 if (hdr->p_type == PT_LOAD)
2029 newsect->flags |= SEC_ALLOC;
2030 if (hdr->p_flags & PF_X)
2031 newsect->flags |= SEC_CODE;
2033 if (!(hdr->p_flags & PF_W))
2034 newsect->flags |= SEC_READONLY;
2041 bfd_section_from_phdr (abfd, hdr, index)
2043 Elf_Internal_Phdr *hdr;
2046 struct elf_backend_data *bed;
2048 switch (hdr->p_type)
2051 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2054 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2057 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2060 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2063 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2065 if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
2070 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2073 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2076 /* Check for any processor-specific program segment types.
2077 If no handler for them, default to making "segment" sections. */
2078 bed = get_elf_backend_data (abfd);
2079 if (bed->elf_backend_section_from_phdr)
2080 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2082 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2086 /* Initialize REL_HDR, the section-header for new section, containing
2087 relocations against ASECT. If USE_RELA_P is true, we use RELA
2088 relocations; otherwise, we use REL relocations. */
2091 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
2093 Elf_Internal_Shdr *rel_hdr;
2098 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2099 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2101 name = bfd_alloc (abfd, amt);
2104 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2106 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2108 if (rel_hdr->sh_name == (unsigned int) -1)
2110 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2111 rel_hdr->sh_entsize = (use_rela_p
2112 ? bed->s->sizeof_rela
2113 : bed->s->sizeof_rel);
2114 rel_hdr->sh_addralign = bed->s->file_align;
2115 rel_hdr->sh_flags = 0;
2116 rel_hdr->sh_addr = 0;
2117 rel_hdr->sh_size = 0;
2118 rel_hdr->sh_offset = 0;
2123 /* Set up an ELF internal section header for a section. */
2126 elf_fake_sections (abfd, asect, failedptrarg)
2131 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2132 boolean *failedptr = (boolean *) failedptrarg;
2133 Elf_Internal_Shdr *this_hdr;
2137 /* We already failed; just get out of the bfd_map_over_sections
2142 this_hdr = &elf_section_data (asect)->this_hdr;
2144 this_hdr->sh_name = (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2145 asect->name, false);
2146 if (this_hdr->sh_name == (unsigned long) -1)
2152 this_hdr->sh_flags = 0;
2154 if ((asect->flags & SEC_ALLOC) != 0
2155 || asect->user_set_vma)
2156 this_hdr->sh_addr = asect->vma;
2158 this_hdr->sh_addr = 0;
2160 this_hdr->sh_offset = 0;
2161 this_hdr->sh_size = asect->_raw_size;
2162 this_hdr->sh_link = 0;
2163 this_hdr->sh_addralign = 1 << asect->alignment_power;
2164 /* The sh_entsize and sh_info fields may have been set already by
2165 copy_private_section_data. */
2167 this_hdr->bfd_section = asect;
2168 this_hdr->contents = NULL;
2170 /* FIXME: This should not be based on section names. */
2171 if (strcmp (asect->name, ".dynstr") == 0)
2172 this_hdr->sh_type = SHT_STRTAB;
2173 else if (strcmp (asect->name, ".hash") == 0)
2175 this_hdr->sh_type = SHT_HASH;
2176 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2178 else if (strcmp (asect->name, ".dynsym") == 0)
2180 this_hdr->sh_type = SHT_DYNSYM;
2181 this_hdr->sh_entsize = bed->s->sizeof_sym;
2183 else if (strcmp (asect->name, ".dynamic") == 0)
2185 this_hdr->sh_type = SHT_DYNAMIC;
2186 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2188 else if (strncmp (asect->name, ".rela", 5) == 0
2189 && get_elf_backend_data (abfd)->may_use_rela_p)
2191 this_hdr->sh_type = SHT_RELA;
2192 this_hdr->sh_entsize = bed->s->sizeof_rela;
2194 else if (strncmp (asect->name, ".rel", 4) == 0
2195 && get_elf_backend_data (abfd)->may_use_rel_p)
2197 this_hdr->sh_type = SHT_REL;
2198 this_hdr->sh_entsize = bed->s->sizeof_rel;
2200 else if (strcmp (asect->name, ".init_array") == 0)
2201 this_hdr->sh_type = SHT_INIT_ARRAY;
2202 else if (strcmp (asect->name, ".fini_array") == 0)
2203 this_hdr->sh_type = SHT_FINI_ARRAY;
2204 else if (strcmp (asect->name, ".preinit_array") == 0)
2205 this_hdr->sh_type = SHT_PREINIT_ARRAY;
2206 else if (strncmp (asect->name, ".note", 5) == 0)
2207 this_hdr->sh_type = SHT_NOTE;
2208 else if (strncmp (asect->name, ".stab", 5) == 0
2209 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
2210 this_hdr->sh_type = SHT_STRTAB;
2211 else if (strcmp (asect->name, ".gnu.version") == 0)
2213 this_hdr->sh_type = SHT_GNU_versym;
2214 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2216 else if (strcmp (asect->name, ".gnu.version_d") == 0)
2218 this_hdr->sh_type = SHT_GNU_verdef;
2219 this_hdr->sh_entsize = 0;
2220 /* objcopy or strip will copy over sh_info, but may not set
2221 cverdefs. The linker will set cverdefs, but sh_info will be
2223 if (this_hdr->sh_info == 0)
2224 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2226 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2227 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2229 else if (strcmp (asect->name, ".gnu.version_r") == 0)
2231 this_hdr->sh_type = SHT_GNU_verneed;
2232 this_hdr->sh_entsize = 0;
2233 /* objcopy or strip will copy over sh_info, but may not set
2234 cverrefs. The linker will set cverrefs, but sh_info will be
2236 if (this_hdr->sh_info == 0)
2237 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2239 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2240 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2242 else if ((asect->flags & SEC_GROUP) != 0)
2244 this_hdr->sh_type = SHT_GROUP;
2245 this_hdr->sh_entsize = 4;
2247 else if ((asect->flags & SEC_ALLOC) != 0
2248 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2249 || (asect->flags & SEC_NEVER_LOAD) != 0))
2250 this_hdr->sh_type = SHT_NOBITS;
2252 this_hdr->sh_type = SHT_PROGBITS;
2254 if ((asect->flags & SEC_ALLOC) != 0)
2255 this_hdr->sh_flags |= SHF_ALLOC;
2256 if ((asect->flags & SEC_READONLY) == 0)
2257 this_hdr->sh_flags |= SHF_WRITE;
2258 if ((asect->flags & SEC_CODE) != 0)
2259 this_hdr->sh_flags |= SHF_EXECINSTR;
2260 if ((asect->flags & SEC_MERGE) != 0)
2262 this_hdr->sh_flags |= SHF_MERGE;
2263 this_hdr->sh_entsize = asect->entsize;
2264 if ((asect->flags & SEC_STRINGS) != 0)
2265 this_hdr->sh_flags |= SHF_STRINGS;
2267 if (elf_group_name (asect) != NULL)
2268 this_hdr->sh_flags |= SHF_GROUP;
2270 /* Check for processor-specific section types. */
2271 if (bed->elf_backend_fake_sections
2272 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2275 /* If the section has relocs, set up a section header for the
2276 SHT_REL[A] section. If two relocation sections are required for
2277 this section, it is up to the processor-specific back-end to
2278 create the other. */
2279 if ((asect->flags & SEC_RELOC) != 0
2280 && !_bfd_elf_init_reloc_shdr (abfd,
2281 &elf_section_data (asect)->rel_hdr,
2283 elf_section_data (asect)->use_rela_p))
2287 /* Fill in the contents of a SHT_GROUP section. */
2290 set_group_contents (abfd, sec, failedptrarg)
2293 PTR failedptrarg ATTRIBUTE_UNUSED;
2295 boolean *failedptr = (boolean *) failedptrarg;
2296 unsigned long symindx;
2299 struct bfd_link_order *l;
2301 if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2305 /* If called from the assembler, swap_out_syms will have set up
2306 elf_section_syms; If called for "ld -r", the symbols won't yet
2307 be mapped, so emulate elf_bfd_final_link. */
2308 if (elf_section_syms (abfd) != NULL)
2309 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2311 symindx = elf_section_data (sec)->this_idx;
2312 elf_section_data (sec)->this_hdr.sh_info = symindx;
2314 /* Nor will the contents be allocated for "ld -r". */
2315 if (sec->contents == NULL)
2317 sec->contents = bfd_alloc (abfd, sec->_raw_size);
2318 if (sec->contents == NULL)
2325 loc = sec->contents + sec->_raw_size;
2327 /* Get the pointer to the first section in the group that we
2328 squirreled away here. */
2329 elt = elf_next_in_group (sec);
2331 /* First element is a flag word. Rest of section is elf section
2332 indices for all the sections of the group. Write them backwards
2333 just to keep the group in the same order as given in .section
2334 directives, not that it matters. */
2338 H_PUT_32 (abfd, elf_section_data (elt)->this_idx, loc);
2339 elt = elf_next_in_group (elt);
2342 /* If this is a relocatable link, then the above did nothing because
2343 SEC is the output section. Look through the input sections
2345 for (l = sec->link_order_head; l != NULL; l = l->next)
2346 if (l->type == bfd_indirect_link_order
2347 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2352 elf_section_data (elt->output_section)->this_idx, loc);
2353 elt = elf_next_in_group (elt);
2354 /* During a relocatable link, the lists are circular. */
2356 while (elt != elf_next_in_group (l->u.indirect.section));
2359 H_PUT_32 (abfd, 0, loc);
2361 BFD_ASSERT (loc == sec->contents);
2364 /* Assign all ELF section numbers. The dummy first section is handled here
2365 too. The link/info pointers for the standard section types are filled
2366 in here too, while we're at it. */
2369 assign_section_numbers (abfd)
2372 struct elf_obj_tdata *t = elf_tdata (abfd);
2374 unsigned int section_number, secn;
2375 Elf_Internal_Shdr **i_shdrp;
2380 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2382 for (sec = abfd->sections; sec; sec = sec->next)
2384 struct bfd_elf_section_data *d = elf_section_data (sec);
2386 if (section_number == SHN_LORESERVE)
2387 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2388 d->this_idx = section_number++;
2389 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2390 if ((sec->flags & SEC_RELOC) == 0)
2394 if (section_number == SHN_LORESERVE)
2395 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2396 d->rel_idx = section_number++;
2397 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2402 if (section_number == SHN_LORESERVE)
2403 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2404 d->rel_idx2 = section_number++;
2405 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2411 if (section_number == SHN_LORESERVE)
2412 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2413 t->shstrtab_section = section_number++;
2414 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2415 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2417 if (bfd_get_symcount (abfd) > 0)
2419 if (section_number == SHN_LORESERVE)
2420 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2421 t->symtab_section = section_number++;
2422 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2423 if (section_number > SHN_LORESERVE - 2)
2425 if (section_number == SHN_LORESERVE)
2426 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2427 t->symtab_shndx_section = section_number++;
2428 t->symtab_shndx_hdr.sh_name
2429 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2430 ".symtab_shndx", false);
2431 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2434 if (section_number == SHN_LORESERVE)
2435 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2436 t->strtab_section = section_number++;
2437 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2440 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2441 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2443 elf_numsections (abfd) = section_number;
2444 elf_elfheader (abfd)->e_shnum = section_number;
2445 if (section_number > SHN_LORESERVE)
2446 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2448 /* Set up the list of section header pointers, in agreement with the
2450 amt = section_number * sizeof (Elf_Internal_Shdr *);
2451 i_shdrp = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
2452 if (i_shdrp == NULL)
2455 amt = sizeof (Elf_Internal_Shdr);
2456 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
2457 if (i_shdrp[0] == NULL)
2459 bfd_release (abfd, i_shdrp);
2462 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
2464 elf_elfsections (abfd) = i_shdrp;
2466 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2467 if (bfd_get_symcount (abfd) > 0)
2469 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2470 if (elf_numsections (abfd) > SHN_LORESERVE)
2472 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2473 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2475 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2476 t->symtab_hdr.sh_link = t->strtab_section;
2478 for (sec = abfd->sections; sec; sec = sec->next)
2480 struct bfd_elf_section_data *d = elf_section_data (sec);
2484 i_shdrp[d->this_idx] = &d->this_hdr;
2485 if (d->rel_idx != 0)
2486 i_shdrp[d->rel_idx] = &d->rel_hdr;
2487 if (d->rel_idx2 != 0)
2488 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2490 /* Fill in the sh_link and sh_info fields while we're at it. */
2492 /* sh_link of a reloc section is the section index of the symbol
2493 table. sh_info is the section index of the section to which
2494 the relocation entries apply. */
2495 if (d->rel_idx != 0)
2497 d->rel_hdr.sh_link = t->symtab_section;
2498 d->rel_hdr.sh_info = d->this_idx;
2500 if (d->rel_idx2 != 0)
2502 d->rel_hdr2->sh_link = t->symtab_section;
2503 d->rel_hdr2->sh_info = d->this_idx;
2506 switch (d->this_hdr.sh_type)
2510 /* A reloc section which we are treating as a normal BFD
2511 section. sh_link is the section index of the symbol
2512 table. sh_info is the section index of the section to
2513 which the relocation entries apply. We assume that an
2514 allocated reloc section uses the dynamic symbol table.
2515 FIXME: How can we be sure? */
2516 s = bfd_get_section_by_name (abfd, ".dynsym");
2518 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2520 /* We look up the section the relocs apply to by name. */
2522 if (d->this_hdr.sh_type == SHT_REL)
2526 s = bfd_get_section_by_name (abfd, name);
2528 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2532 /* We assume that a section named .stab*str is a stabs
2533 string section. We look for a section with the same name
2534 but without the trailing ``str'', and set its sh_link
2535 field to point to this section. */
2536 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2537 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2542 len = strlen (sec->name);
2543 alc = (char *) bfd_malloc ((bfd_size_type) len - 2);
2546 strncpy (alc, sec->name, len - 3);
2547 alc[len - 3] = '\0';
2548 s = bfd_get_section_by_name (abfd, alc);
2552 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2554 /* This is a .stab section. */
2555 elf_section_data (s)->this_hdr.sh_entsize =
2556 4 + 2 * bfd_get_arch_size (abfd) / 8;
2563 case SHT_GNU_verneed:
2564 case SHT_GNU_verdef:
2565 /* sh_link is the section header index of the string table
2566 used for the dynamic entries, or the symbol table, or the
2568 s = bfd_get_section_by_name (abfd, ".dynstr");
2570 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2574 case SHT_GNU_versym:
2575 /* sh_link is the section header index of the symbol table
2576 this hash table or version table is for. */
2577 s = bfd_get_section_by_name (abfd, ".dynsym");
2579 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2583 d->this_hdr.sh_link = t->symtab_section;
2587 for (secn = 1; secn < section_number; ++secn)
2588 if (i_shdrp[secn] == NULL)
2589 i_shdrp[secn] = i_shdrp[0];
2591 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2592 i_shdrp[secn]->sh_name);
2596 /* Map symbol from it's internal number to the external number, moving
2597 all local symbols to be at the head of the list. */
2600 sym_is_global (abfd, sym)
2604 /* If the backend has a special mapping, use it. */
2605 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2606 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2609 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2610 || bfd_is_und_section (bfd_get_section (sym))
2611 || bfd_is_com_section (bfd_get_section (sym)));
2615 elf_map_symbols (abfd)
2618 unsigned int symcount = bfd_get_symcount (abfd);
2619 asymbol **syms = bfd_get_outsymbols (abfd);
2620 asymbol **sect_syms;
2621 unsigned int num_locals = 0;
2622 unsigned int num_globals = 0;
2623 unsigned int num_locals2 = 0;
2624 unsigned int num_globals2 = 0;
2632 fprintf (stderr, "elf_map_symbols\n");
2636 for (asect = abfd->sections; asect; asect = asect->next)
2638 if (max_index < asect->index)
2639 max_index = asect->index;
2643 amt = max_index * sizeof (asymbol *);
2644 sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
2645 if (sect_syms == NULL)
2647 elf_section_syms (abfd) = sect_syms;
2648 elf_num_section_syms (abfd) = max_index;
2650 /* Init sect_syms entries for any section symbols we have already
2651 decided to output. */
2652 for (idx = 0; idx < symcount; idx++)
2654 asymbol *sym = syms[idx];
2656 if ((sym->flags & BSF_SECTION_SYM) != 0
2663 if (sec->owner != NULL)
2665 if (sec->owner != abfd)
2667 if (sec->output_offset != 0)
2670 sec = sec->output_section;
2672 /* Empty sections in the input files may have had a
2673 section symbol created for them. (See the comment
2674 near the end of _bfd_generic_link_output_symbols in
2675 linker.c). If the linker script discards such
2676 sections then we will reach this point. Since we know
2677 that we cannot avoid this case, we detect it and skip
2678 the abort and the assignment to the sect_syms array.
2679 To reproduce this particular case try running the
2680 linker testsuite test ld-scripts/weak.exp for an ELF
2681 port that uses the generic linker. */
2682 if (sec->owner == NULL)
2685 BFD_ASSERT (sec->owner == abfd);
2687 sect_syms[sec->index] = syms[idx];
2692 /* Classify all of the symbols. */
2693 for (idx = 0; idx < symcount; idx++)
2695 if (!sym_is_global (abfd, syms[idx]))
2701 /* We will be adding a section symbol for each BFD section. Most normal
2702 sections will already have a section symbol in outsymbols, but
2703 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2704 at least in that case. */
2705 for (asect = abfd->sections; asect; asect = asect->next)
2707 if (sect_syms[asect->index] == NULL)
2709 if (!sym_is_global (abfd, asect->symbol))
2716 /* Now sort the symbols so the local symbols are first. */
2717 amt = (num_locals + num_globals) * sizeof (asymbol *);
2718 new_syms = (asymbol **) bfd_alloc (abfd, amt);
2720 if (new_syms == NULL)
2723 for (idx = 0; idx < symcount; idx++)
2725 asymbol *sym = syms[idx];
2728 if (!sym_is_global (abfd, sym))
2731 i = num_locals + num_globals2++;
2733 sym->udata.i = i + 1;
2735 for (asect = abfd->sections; asect; asect = asect->next)
2737 if (sect_syms[asect->index] == NULL)
2739 asymbol *sym = asect->symbol;
2742 sect_syms[asect->index] = sym;
2743 if (!sym_is_global (abfd, sym))
2746 i = num_locals + num_globals2++;
2748 sym->udata.i = i + 1;
2752 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2754 elf_num_locals (abfd) = num_locals;
2755 elf_num_globals (abfd) = num_globals;
2759 /* Align to the maximum file alignment that could be required for any
2760 ELF data structure. */
2762 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2763 static INLINE file_ptr
2764 align_file_position (off, align)
2768 return (off + align - 1) & ~(align - 1);
2771 /* Assign a file position to a section, optionally aligning to the
2772 required section alignment. */
2775 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2776 Elf_Internal_Shdr *i_shdrp;
2784 al = i_shdrp->sh_addralign;
2786 offset = BFD_ALIGN (offset, al);
2788 i_shdrp->sh_offset = offset;
2789 if (i_shdrp->bfd_section != NULL)
2790 i_shdrp->bfd_section->filepos = offset;
2791 if (i_shdrp->sh_type != SHT_NOBITS)
2792 offset += i_shdrp->sh_size;
2796 /* Compute the file positions we are going to put the sections at, and
2797 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2798 is not NULL, this is being called by the ELF backend linker. */
2801 _bfd_elf_compute_section_file_positions (abfd, link_info)
2803 struct bfd_link_info *link_info;
2805 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2807 struct bfd_strtab_hash *strtab;
2808 Elf_Internal_Shdr *shstrtab_hdr;
2810 if (abfd->output_has_begun)
2813 /* Do any elf backend specific processing first. */
2814 if (bed->elf_backend_begin_write_processing)
2815 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2817 if (! prep_headers (abfd))
2820 /* Post process the headers if necessary. */
2821 if (bed->elf_backend_post_process_headers)
2822 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2825 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2829 if (!assign_section_numbers (abfd))
2832 /* The backend linker builds symbol table information itself. */
2833 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2835 /* Non-zero if doing a relocatable link. */
2836 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2838 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2842 if (link_info == NULL || link_info->relocateable)
2844 bfd_map_over_sections (abfd, set_group_contents, &failed);
2849 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2850 /* sh_name was set in prep_headers. */
2851 shstrtab_hdr->sh_type = SHT_STRTAB;
2852 shstrtab_hdr->sh_flags = 0;
2853 shstrtab_hdr->sh_addr = 0;
2854 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2855 shstrtab_hdr->sh_entsize = 0;
2856 shstrtab_hdr->sh_link = 0;
2857 shstrtab_hdr->sh_info = 0;
2858 /* sh_offset is set in assign_file_positions_except_relocs. */
2859 shstrtab_hdr->sh_addralign = 1;
2861 if (!assign_file_positions_except_relocs (abfd))
2864 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2867 Elf_Internal_Shdr *hdr;
2869 off = elf_tdata (abfd)->next_file_pos;
2871 hdr = &elf_tdata (abfd)->symtab_hdr;
2872 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2874 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2875 if (hdr->sh_size != 0)
2876 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2878 hdr = &elf_tdata (abfd)->strtab_hdr;
2879 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2881 elf_tdata (abfd)->next_file_pos = off;
2883 /* Now that we know where the .strtab section goes, write it
2885 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2886 || ! _bfd_stringtab_emit (abfd, strtab))
2888 _bfd_stringtab_free (strtab);
2891 abfd->output_has_begun = true;
2896 /* Create a mapping from a set of sections to a program segment. */
2898 static INLINE struct elf_segment_map *
2899 make_mapping (abfd, sections, from, to, phdr)
2901 asection **sections;
2906 struct elf_segment_map *m;
2911 amt = sizeof (struct elf_segment_map);
2912 amt += (to - from - 1) * sizeof (asection *);
2913 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2917 m->p_type = PT_LOAD;
2918 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2919 m->sections[i - from] = *hdrpp;
2920 m->count = to - from;
2922 if (from == 0 && phdr)
2924 /* Include the headers in the first PT_LOAD segment. */
2925 m->includes_filehdr = 1;
2926 m->includes_phdrs = 1;
2932 /* Set up a mapping from BFD sections to program segments. */
2935 map_sections_to_segments (abfd)
2938 asection **sections = NULL;
2942 struct elf_segment_map *mfirst;
2943 struct elf_segment_map **pm;
2944 struct elf_segment_map *m;
2946 unsigned int phdr_index;
2947 bfd_vma maxpagesize;
2949 boolean phdr_in_segment = true;
2951 asection *dynsec, *eh_frame_hdr;
2954 if (elf_tdata (abfd)->segment_map != NULL)
2957 if (bfd_count_sections (abfd) == 0)
2960 /* Select the allocated sections, and sort them. */
2962 amt = bfd_count_sections (abfd) * sizeof (asection *);
2963 sections = (asection **) bfd_malloc (amt);
2964 if (sections == NULL)
2968 for (s = abfd->sections; s != NULL; s = s->next)
2970 if ((s->flags & SEC_ALLOC) != 0)
2976 BFD_ASSERT (i <= bfd_count_sections (abfd));
2979 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2981 /* Build the mapping. */
2986 /* If we have a .interp section, then create a PT_PHDR segment for
2987 the program headers and a PT_INTERP segment for the .interp
2989 s = bfd_get_section_by_name (abfd, ".interp");
2990 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2992 amt = sizeof (struct elf_segment_map);
2993 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2997 m->p_type = PT_PHDR;
2998 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2999 m->p_flags = PF_R | PF_X;
3000 m->p_flags_valid = 1;
3001 m->includes_phdrs = 1;
3006 amt = sizeof (struct elf_segment_map);
3007 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3011 m->p_type = PT_INTERP;
3019 /* Look through the sections. We put sections in the same program
3020 segment when the start of the second section can be placed within
3021 a few bytes of the end of the first section. */
3024 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3026 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3028 && (dynsec->flags & SEC_LOAD) == 0)
3031 /* Deal with -Ttext or something similar such that the first section
3032 is not adjacent to the program headers. This is an
3033 approximation, since at this point we don't know exactly how many
3034 program headers we will need. */
3037 bfd_size_type phdr_size;
3039 phdr_size = elf_tdata (abfd)->program_header_size;
3041 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3042 if ((abfd->flags & D_PAGED) == 0
3043 || sections[0]->lma < phdr_size
3044 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3045 phdr_in_segment = false;
3048 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3051 boolean new_segment;
3055 /* See if this section and the last one will fit in the same
3058 if (last_hdr == NULL)
3060 /* If we don't have a segment yet, then we don't need a new
3061 one (we build the last one after this loop). */
3062 new_segment = false;
3064 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3066 /* If this section has a different relation between the
3067 virtual address and the load address, then we need a new
3071 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3072 < BFD_ALIGN (hdr->lma, maxpagesize))
3074 /* If putting this section in this segment would force us to
3075 skip a page in the segment, then we need a new segment. */
3078 else if ((last_hdr->flags & SEC_LOAD) == 0
3079 && (hdr->flags & SEC_LOAD) != 0)
3081 /* We don't want to put a loadable section after a
3082 nonloadable section in the same segment. */
3085 else if ((abfd->flags & D_PAGED) == 0)
3087 /* If the file is not demand paged, which means that we
3088 don't require the sections to be correctly aligned in the
3089 file, then there is no other reason for a new segment. */
3090 new_segment = false;
3093 && (hdr->flags & SEC_READONLY) == 0
3094 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3097 /* We don't want to put a writable section in a read only
3098 segment, unless they are on the same page in memory
3099 anyhow. We already know that the last section does not
3100 bring us past the current section on the page, so the
3101 only case in which the new section is not on the same
3102 page as the previous section is when the previous section
3103 ends precisely on a page boundary. */
3108 /* Otherwise, we can use the same segment. */
3109 new_segment = false;
3114 if ((hdr->flags & SEC_READONLY) == 0)
3120 /* We need a new program segment. We must create a new program
3121 header holding all the sections from phdr_index until hdr. */
3123 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3130 if ((hdr->flags & SEC_READONLY) == 0)
3137 phdr_in_segment = false;
3140 /* Create a final PT_LOAD program segment. */
3141 if (last_hdr != NULL)
3143 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3151 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3154 amt = sizeof (struct elf_segment_map);
3155 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3159 m->p_type = PT_DYNAMIC;
3161 m->sections[0] = dynsec;
3167 /* For each loadable .note section, add a PT_NOTE segment. We don't
3168 use bfd_get_section_by_name, because if we link together
3169 nonloadable .note sections and loadable .note sections, we will
3170 generate two .note sections in the output file. FIXME: Using
3171 names for section types is bogus anyhow. */
3172 for (s = abfd->sections; s != NULL; s = s->next)
3174 if ((s->flags & SEC_LOAD) != 0
3175 && strncmp (s->name, ".note", 5) == 0)
3177 amt = sizeof (struct elf_segment_map);
3178 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3182 m->p_type = PT_NOTE;
3191 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3193 eh_frame_hdr = NULL;
3194 if (elf_tdata (abfd)->eh_frame_hdr)
3195 eh_frame_hdr = bfd_get_section_by_name (abfd, ".eh_frame_hdr");
3196 if (eh_frame_hdr != NULL && (eh_frame_hdr->flags & SEC_LOAD))
3198 amt = sizeof (struct elf_segment_map);
3199 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3203 m->p_type = PT_GNU_EH_FRAME;
3205 m->sections[0] = eh_frame_hdr;
3214 elf_tdata (abfd)->segment_map = mfirst;
3218 if (sections != NULL)
3223 /* Sort sections by address. */
3226 elf_sort_sections (arg1, arg2)
3230 const asection *sec1 = *(const asection **) arg1;
3231 const asection *sec2 = *(const asection **) arg2;
3233 /* Sort by LMA first, since this is the address used to
3234 place the section into a segment. */
3235 if (sec1->lma < sec2->lma)
3237 else if (sec1->lma > sec2->lma)
3240 /* Then sort by VMA. Normally the LMA and the VMA will be
3241 the same, and this will do nothing. */
3242 if (sec1->vma < sec2->vma)
3244 else if (sec1->vma > sec2->vma)
3247 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3249 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3255 /* If the indicies are the same, do not return 0
3256 here, but continue to try the next comparison. */
3257 if (sec1->target_index - sec2->target_index != 0)
3258 return sec1->target_index - sec2->target_index;
3263 else if (TOEND (sec2))
3268 /* Sort by size, to put zero sized sections
3269 before others at the same address. */
3271 if (sec1->_raw_size < sec2->_raw_size)
3273 if (sec1->_raw_size > sec2->_raw_size)
3276 return sec1->target_index - sec2->target_index;
3279 /* Assign file positions to the sections based on the mapping from
3280 sections to segments. This function also sets up some fields in
3281 the file header, and writes out the program headers. */
3284 assign_file_positions_for_segments (abfd)
3287 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3289 struct elf_segment_map *m;
3291 Elf_Internal_Phdr *phdrs;
3293 bfd_vma filehdr_vaddr, filehdr_paddr;
3294 bfd_vma phdrs_vaddr, phdrs_paddr;
3295 Elf_Internal_Phdr *p;
3298 if (elf_tdata (abfd)->segment_map == NULL)
3300 if (! map_sections_to_segments (abfd))
3304 if (bed->elf_backend_modify_segment_map)
3306 if (! (*bed->elf_backend_modify_segment_map) (abfd))
3311 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3314 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3315 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3316 elf_elfheader (abfd)->e_phnum = count;
3321 /* If we already counted the number of program segments, make sure
3322 that we allocated enough space. This happens when SIZEOF_HEADERS
3323 is used in a linker script. */
3324 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3325 if (alloc != 0 && count > alloc)
3327 ((*_bfd_error_handler)
3328 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3329 bfd_get_filename (abfd), alloc, count));
3330 bfd_set_error (bfd_error_bad_value);
3337 amt = alloc * sizeof (Elf_Internal_Phdr);
3338 phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
3342 off = bed->s->sizeof_ehdr;
3343 off += alloc * bed->s->sizeof_phdr;
3350 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3357 /* If elf_segment_map is not from map_sections_to_segments, the
3358 sections may not be correctly ordered. NOTE: sorting should
3359 not be done to the PT_NOTE section of a corefile, which may
3360 contain several pseudo-sections artificially created by bfd.
3361 Sorting these pseudo-sections breaks things badly. */
3363 && !(elf_elfheader (abfd)->e_type == ET_CORE
3364 && m->p_type == PT_NOTE))
3365 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3368 p->p_type = m->p_type;
3369 p->p_flags = m->p_flags;
3371 if (p->p_type == PT_LOAD
3373 && (m->sections[0]->flags & SEC_ALLOC) != 0)
3375 if ((abfd->flags & D_PAGED) != 0)
3376 off += (m->sections[0]->vma - off) % bed->maxpagesize;
3379 bfd_size_type align;
3382 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3384 bfd_size_type secalign;
3386 secalign = bfd_get_section_alignment (abfd, *secpp);
3387 if (secalign > align)
3391 off += (m->sections[0]->vma - off) % (1 << align);
3398 p->p_vaddr = m->sections[0]->vma;
3400 if (m->p_paddr_valid)
3401 p->p_paddr = m->p_paddr;
3402 else if (m->count == 0)
3405 p->p_paddr = m->sections[0]->lma;
3407 if (p->p_type == PT_LOAD
3408 && (abfd->flags & D_PAGED) != 0)
3409 p->p_align = bed->maxpagesize;
3410 else if (m->count == 0)
3411 p->p_align = bed->s->file_align;
3419 if (m->includes_filehdr)
3421 if (! m->p_flags_valid)
3424 p->p_filesz = bed->s->sizeof_ehdr;
3425 p->p_memsz = bed->s->sizeof_ehdr;
3428 BFD_ASSERT (p->p_type == PT_LOAD);
3430 if (p->p_vaddr < (bfd_vma) off)
3432 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
3433 bfd_get_filename (abfd));
3434 bfd_set_error (bfd_error_bad_value);
3439 if (! m->p_paddr_valid)
3442 if (p->p_type == PT_LOAD)
3444 filehdr_vaddr = p->p_vaddr;
3445 filehdr_paddr = p->p_paddr;
3449 if (m->includes_phdrs)
3451 if (! m->p_flags_valid)
3454 if (m->includes_filehdr)
3456 if (p->p_type == PT_LOAD)
3458 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3459 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3464 p->p_offset = bed->s->sizeof_ehdr;
3468 BFD_ASSERT (p->p_type == PT_LOAD);
3469 p->p_vaddr -= off - p->p_offset;
3470 if (! m->p_paddr_valid)
3471 p->p_paddr -= off - p->p_offset;
3474 if (p->p_type == PT_LOAD)
3476 phdrs_vaddr = p->p_vaddr;
3477 phdrs_paddr = p->p_paddr;
3480 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3483 p->p_filesz += alloc * bed->s->sizeof_phdr;
3484 p->p_memsz += alloc * bed->s->sizeof_phdr;
3487 if (p->p_type == PT_LOAD
3488 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3490 if (! m->includes_filehdr && ! m->includes_phdrs)
3496 adjust = off - (p->p_offset + p->p_filesz);
3497 p->p_filesz += adjust;
3498 p->p_memsz += adjust;
3504 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3508 bfd_size_type align;
3512 align = 1 << bfd_get_section_alignment (abfd, sec);
3514 /* The section may have artificial alignment forced by a
3515 link script. Notice this case by the gap between the
3516 cumulative phdr lma and the section's lma. */
3517 if (p->p_paddr + p->p_memsz < sec->lma)
3519 bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3521 p->p_memsz += adjust;
3524 if ((flags & SEC_LOAD) != 0)
3525 p->p_filesz += adjust;
3528 if (p->p_type == PT_LOAD)
3530 bfd_signed_vma adjust;
3532 if ((flags & SEC_LOAD) != 0)
3534 adjust = sec->lma - (p->p_paddr + p->p_memsz);
3538 else if ((flags & SEC_ALLOC) != 0)
3540 /* The section VMA must equal the file position
3541 modulo the page size. FIXME: I'm not sure if
3542 this adjustment is really necessary. We used to
3543 not have the SEC_LOAD case just above, and then
3544 this was necessary, but now I'm not sure. */
3545 if ((abfd->flags & D_PAGED) != 0)
3546 adjust = (sec->vma - voff) % bed->maxpagesize;
3548 adjust = (sec->vma - voff) % align;
3557 (* _bfd_error_handler) (_("\
3558 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3559 bfd_section_name (abfd, sec),
3564 p->p_memsz += adjust;
3567 if ((flags & SEC_LOAD) != 0)
3568 p->p_filesz += adjust;
3573 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3574 used in a linker script we may have a section with
3575 SEC_LOAD clear but which is supposed to have
3577 if ((flags & SEC_LOAD) != 0
3578 || (flags & SEC_HAS_CONTENTS) != 0)
3579 off += sec->_raw_size;
3581 if ((flags & SEC_ALLOC) != 0)
3582 voff += sec->_raw_size;
3585 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3587 /* The actual "note" segment has i == 0.
3588 This is the one that actually contains everything. */
3592 p->p_filesz = sec->_raw_size;
3593 off += sec->_raw_size;
3598 /* Fake sections -- don't need to be written. */
3601 flags = sec->flags = 0;
3608 p->p_memsz += sec->_raw_size;
3610 if ((flags & SEC_LOAD) != 0)
3611 p->p_filesz += sec->_raw_size;
3613 if (align > p->p_align
3614 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3618 if (! m->p_flags_valid)
3621 if ((flags & SEC_CODE) != 0)
3623 if ((flags & SEC_READONLY) == 0)
3629 /* Now that we have set the section file positions, we can set up
3630 the file positions for the non PT_LOAD segments. */
3631 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3635 if (p->p_type != PT_LOAD && m->count > 0)
3637 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3638 p->p_offset = m->sections[0]->filepos;
3642 if (m->includes_filehdr)
3644 p->p_vaddr = filehdr_vaddr;
3645 if (! m->p_paddr_valid)
3646 p->p_paddr = filehdr_paddr;
3648 else if (m->includes_phdrs)
3650 p->p_vaddr = phdrs_vaddr;
3651 if (! m->p_paddr_valid)
3652 p->p_paddr = phdrs_paddr;
3657 /* Clear out any program headers we allocated but did not use. */
3658 for (; count < alloc; count++, p++)
3660 memset (p, 0, sizeof *p);
3661 p->p_type = PT_NULL;
3664 elf_tdata (abfd)->phdr = phdrs;
3666 elf_tdata (abfd)->next_file_pos = off;
3668 /* Write out the program headers. */
3669 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
3670 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3676 /* Get the size of the program header.
3678 If this is called by the linker before any of the section VMA's are set, it
3679 can't calculate the correct value for a strange memory layout. This only
3680 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3681 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3682 data segment (exclusive of .interp and .dynamic).
3684 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3685 will be two segments. */
3687 static bfd_size_type
3688 get_program_header_size (abfd)
3693 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3695 /* We can't return a different result each time we're called. */
3696 if (elf_tdata (abfd)->program_header_size != 0)
3697 return elf_tdata (abfd)->program_header_size;
3699 if (elf_tdata (abfd)->segment_map != NULL)
3701 struct elf_segment_map *m;
3704 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3706 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3707 return elf_tdata (abfd)->program_header_size;
3710 /* Assume we will need exactly two PT_LOAD segments: one for text
3711 and one for data. */
3714 s = bfd_get_section_by_name (abfd, ".interp");
3715 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3717 /* If we have a loadable interpreter section, we need a
3718 PT_INTERP segment. In this case, assume we also need a
3719 PT_PHDR segment, although that may not be true for all
3724 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3726 /* We need a PT_DYNAMIC segment. */
3730 if (elf_tdata (abfd)->eh_frame_hdr
3731 && bfd_get_section_by_name (abfd, ".eh_frame_hdr") != NULL)
3733 /* We need a PT_GNU_EH_FRAME segment. */
3737 for (s = abfd->sections; s != NULL; s = s->next)
3739 if ((s->flags & SEC_LOAD) != 0
3740 && strncmp (s->name, ".note", 5) == 0)
3742 /* We need a PT_NOTE segment. */
3747 /* Let the backend count up any program headers it might need. */
3748 if (bed->elf_backend_additional_program_headers)
3752 a = (*bed->elf_backend_additional_program_headers) (abfd);
3758 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3759 return elf_tdata (abfd)->program_header_size;
3762 /* Work out the file positions of all the sections. This is called by
3763 _bfd_elf_compute_section_file_positions. All the section sizes and
3764 VMAs must be known before this is called.
3766 We do not consider reloc sections at this point, unless they form
3767 part of the loadable image. Reloc sections are assigned file
3768 positions in assign_file_positions_for_relocs, which is called by
3769 write_object_contents and final_link.
3771 We also don't set the positions of the .symtab and .strtab here. */
3774 assign_file_positions_except_relocs (abfd)
3777 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3778 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3779 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3780 unsigned int num_sec = elf_numsections (abfd);
3782 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3784 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3785 && bfd_get_format (abfd) != bfd_core)
3787 Elf_Internal_Shdr **hdrpp;
3790 /* Start after the ELF header. */
3791 off = i_ehdrp->e_ehsize;
3793 /* We are not creating an executable, which means that we are
3794 not creating a program header, and that the actual order of
3795 the sections in the file is unimportant. */
3796 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
3798 Elf_Internal_Shdr *hdr;
3801 if (hdr->sh_type == SHT_REL
3802 || hdr->sh_type == SHT_RELA
3803 || i == tdata->symtab_section
3804 || i == tdata->symtab_shndx_section
3805 || i == tdata->strtab_section)
3807 hdr->sh_offset = -1;
3810 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3812 if (i == SHN_LORESERVE - 1)
3814 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3815 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3822 Elf_Internal_Shdr **hdrpp;
3824 /* Assign file positions for the loaded sections based on the
3825 assignment of sections to segments. */
3826 if (! assign_file_positions_for_segments (abfd))
3829 /* Assign file positions for the other sections. */
3831 off = elf_tdata (abfd)->next_file_pos;
3832 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
3834 Elf_Internal_Shdr *hdr;
3837 if (hdr->bfd_section != NULL
3838 && hdr->bfd_section->filepos != 0)
3839 hdr->sh_offset = hdr->bfd_section->filepos;
3840 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3842 ((*_bfd_error_handler)
3843 (_("%s: warning: allocated section `%s' not in segment"),
3844 bfd_get_filename (abfd),
3845 (hdr->bfd_section == NULL
3847 : hdr->bfd_section->name)));
3848 if ((abfd->flags & D_PAGED) != 0)
3849 off += (hdr->sh_addr - off) % bed->maxpagesize;
3851 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3852 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3855 else if (hdr->sh_type == SHT_REL
3856 || hdr->sh_type == SHT_RELA
3857 || hdr == i_shdrpp[tdata->symtab_section]
3858 || hdr == i_shdrpp[tdata->symtab_shndx_section]
3859 || hdr == i_shdrpp[tdata->strtab_section])
3860 hdr->sh_offset = -1;
3862 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3864 if (i == SHN_LORESERVE - 1)
3866 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3867 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3872 /* Place the section headers. */
3873 off = align_file_position (off, bed->s->file_align);
3874 i_ehdrp->e_shoff = off;
3875 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3877 elf_tdata (abfd)->next_file_pos = off;
3886 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3887 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3888 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3889 struct elf_strtab_hash *shstrtab;
3890 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3892 i_ehdrp = elf_elfheader (abfd);
3893 i_shdrp = elf_elfsections (abfd);
3895 shstrtab = _bfd_elf_strtab_init ();
3896 if (shstrtab == NULL)
3899 elf_shstrtab (abfd) = shstrtab;
3901 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3902 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3903 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3904 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3906 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3907 i_ehdrp->e_ident[EI_DATA] =
3908 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3909 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3911 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3912 #ifdef WANT_OLD_BRANDELF_METHOD
3913 #define _OLD_EI_BRAND_OFFSET 8
3914 #define _OLD_BRANDING "FreeBSD"
3915 strncpy((char *) &i_ehdrp->e_ident[_OLD_EI_BRAND_OFFSET], _OLD_BRANDING,
3916 EI_NIDENT-_OLD_EI_BRAND_OFFSET);
3919 if ((abfd->flags & DYNAMIC) != 0)
3920 i_ehdrp->e_type = ET_DYN;
3921 else if ((abfd->flags & EXEC_P) != 0)
3922 i_ehdrp->e_type = ET_EXEC;
3923 else if (bfd_get_format (abfd) == bfd_core)
3924 i_ehdrp->e_type = ET_CORE;
3926 i_ehdrp->e_type = ET_REL;
3928 switch (bfd_get_arch (abfd))
3930 case bfd_arch_unknown:
3931 i_ehdrp->e_machine = EM_NONE;
3934 /* There used to be a long list of cases here, each one setting
3935 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
3936 in the corresponding bfd definition. To avoid duplication,
3937 the switch was removed. Machines that need special handling
3938 can generally do it in elf_backend_final_write_processing(),
3939 unless they need the information earlier than the final write.
3940 Such need can generally be supplied by replacing the tests for
3941 e_machine with the conditions used to determine it. */
3943 if (get_elf_backend_data (abfd) != NULL)
3944 i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
3946 i_ehdrp->e_machine = EM_NONE;
3949 i_ehdrp->e_version = bed->s->ev_current;
3950 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3952 /* No program header, for now. */
3953 i_ehdrp->e_phoff = 0;
3954 i_ehdrp->e_phentsize = 0;
3955 i_ehdrp->e_phnum = 0;
3957 /* Each bfd section is section header entry. */
3958 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3959 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3961 /* If we're building an executable, we'll need a program header table. */
3962 if (abfd->flags & EXEC_P)
3964 /* It all happens later. */
3966 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3968 /* elf_build_phdrs() returns a (NULL-terminated) array of
3969 Elf_Internal_Phdrs. */
3970 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3971 i_ehdrp->e_phoff = outbase;
3972 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3977 i_ehdrp->e_phentsize = 0;
3979 i_ehdrp->e_phoff = 0;
3982 elf_tdata (abfd)->symtab_hdr.sh_name =
3983 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", false);
3984 elf_tdata (abfd)->strtab_hdr.sh_name =
3985 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", false);
3986 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3987 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", false);
3988 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3989 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3990 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3996 /* Assign file positions for all the reloc sections which are not part
3997 of the loadable file image. */
4000 _bfd_elf_assign_file_positions_for_relocs (abfd)
4004 unsigned int i, num_sec;
4005 Elf_Internal_Shdr **shdrpp;
4007 off = elf_tdata (abfd)->next_file_pos;
4009 num_sec = elf_numsections (abfd);
4010 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4012 Elf_Internal_Shdr *shdrp;
4015 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4016 && shdrp->sh_offset == -1)
4017 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
4020 elf_tdata (abfd)->next_file_pos = off;
4024 _bfd_elf_write_object_contents (abfd)
4027 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4028 Elf_Internal_Ehdr *i_ehdrp;
4029 Elf_Internal_Shdr **i_shdrp;
4031 unsigned int count, num_sec;
4033 if (! abfd->output_has_begun
4034 && ! _bfd_elf_compute_section_file_positions
4035 (abfd, (struct bfd_link_info *) NULL))
4038 i_shdrp = elf_elfsections (abfd);
4039 i_ehdrp = elf_elfheader (abfd);
4042 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4046 _bfd_elf_assign_file_positions_for_relocs (abfd);
4048 /* After writing the headers, we need to write the sections too... */
4049 num_sec = elf_numsections (abfd);
4050 for (count = 1; count < num_sec; count++)
4052 if (bed->elf_backend_section_processing)
4053 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4054 if (i_shdrp[count]->contents)
4056 bfd_size_type amt = i_shdrp[count]->sh_size;
4058 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4059 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4062 if (count == SHN_LORESERVE - 1)
4063 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4066 /* Write out the section header names. */
4067 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4068 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4071 if (bed->elf_backend_final_write_processing)
4072 (*bed->elf_backend_final_write_processing) (abfd,
4073 elf_tdata (abfd)->linker);
4075 return bed->s->write_shdrs_and_ehdr (abfd);
4079 _bfd_elf_write_corefile_contents (abfd)
4082 /* Hopefully this can be done just like an object file. */
4083 return _bfd_elf_write_object_contents (abfd);
4086 /* Given a section, search the header to find them. */
4089 _bfd_elf_section_from_bfd_section (abfd, asect)
4093 struct elf_backend_data *bed;
4096 if (elf_section_data (asect) != NULL
4097 && elf_section_data (asect)->this_idx != 0)
4098 return elf_section_data (asect)->this_idx;
4100 if (bfd_is_abs_section (asect))
4102 else if (bfd_is_com_section (asect))
4104 else if (bfd_is_und_section (asect))
4108 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4109 int maxindex = elf_numsections (abfd);
4111 for (index = 1; index < maxindex; index++)
4113 Elf_Internal_Shdr *hdr = i_shdrp[index];
4115 if (hdr != NULL && hdr->bfd_section == asect)
4121 bed = get_elf_backend_data (abfd);
4122 if (bed->elf_backend_section_from_bfd_section)
4126 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4131 bfd_set_error (bfd_error_nonrepresentable_section);
4136 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4140 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
4142 asymbol **asym_ptr_ptr;
4144 asymbol *asym_ptr = *asym_ptr_ptr;
4146 flagword flags = asym_ptr->flags;
4148 /* When gas creates relocations against local labels, it creates its
4149 own symbol for the section, but does put the symbol into the
4150 symbol chain, so udata is 0. When the linker is generating
4151 relocatable output, this section symbol may be for one of the
4152 input sections rather than the output section. */
4153 if (asym_ptr->udata.i == 0
4154 && (flags & BSF_SECTION_SYM)
4155 && asym_ptr->section)
4159 if (asym_ptr->section->output_section != NULL)
4160 indx = asym_ptr->section->output_section->index;
4162 indx = asym_ptr->section->index;
4163 if (indx < elf_num_section_syms (abfd)
4164 && elf_section_syms (abfd)[indx] != NULL)
4165 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4168 idx = asym_ptr->udata.i;
4172 /* This case can occur when using --strip-symbol on a symbol
4173 which is used in a relocation entry. */
4174 (*_bfd_error_handler)
4175 (_("%s: symbol `%s' required but not present"),
4176 bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
4177 bfd_set_error (bfd_error_no_symbols);
4184 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4185 (long) asym_ptr, asym_ptr->name, idx, flags,
4186 elf_symbol_flags (flags));
4194 /* Copy private BFD data. This copies any program header information. */
4197 copy_private_bfd_data (ibfd, obfd)
4201 Elf_Internal_Ehdr * iehdr;
4202 struct elf_segment_map * map;
4203 struct elf_segment_map * map_first;
4204 struct elf_segment_map ** pointer_to_map;
4205 Elf_Internal_Phdr * segment;
4208 unsigned int num_segments;
4209 boolean phdr_included = false;
4210 bfd_vma maxpagesize;
4211 struct elf_segment_map * phdr_adjust_seg = NULL;
4212 unsigned int phdr_adjust_num = 0;
4214 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4215 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4218 if (elf_tdata (ibfd)->phdr == NULL)
4221 iehdr = elf_elfheader (ibfd);
4224 pointer_to_map = &map_first;
4226 num_segments = elf_elfheader (ibfd)->e_phnum;
4227 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4229 /* Returns the end address of the segment + 1. */
4230 #define SEGMENT_END(segment, start) \
4231 (start + (segment->p_memsz > segment->p_filesz \
4232 ? segment->p_memsz : segment->p_filesz))
4234 /* Returns true if the given section is contained within
4235 the given segment. VMA addresses are compared. */
4236 #define IS_CONTAINED_BY_VMA(section, segment) \
4237 (section->vma >= segment->p_vaddr \
4238 && (section->vma + section->_raw_size) \
4239 <= (SEGMENT_END (segment, segment->p_vaddr)))
4241 /* Returns true if the given section is contained within
4242 the given segment. LMA addresses are compared. */
4243 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4244 (section->lma >= base \
4245 && (section->lma + section->_raw_size) \
4246 <= SEGMENT_END (segment, base))
4248 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4249 #define IS_COREFILE_NOTE(p, s) \
4250 (p->p_type == PT_NOTE \
4251 && bfd_get_format (ibfd) == bfd_core \
4252 && s->vma == 0 && s->lma == 0 \
4253 && (bfd_vma) s->filepos >= p->p_offset \
4254 && (bfd_vma) s->filepos + s->_raw_size \
4255 <= p->p_offset + p->p_filesz)
4257 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4258 linker, which generates a PT_INTERP section with p_vaddr and
4259 p_memsz set to 0. */
4260 #define IS_SOLARIS_PT_INTERP(p, s) \
4262 && p->p_filesz > 0 \
4263 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4264 && s->_raw_size > 0 \
4265 && (bfd_vma) s->filepos >= p->p_offset \
4266 && ((bfd_vma) s->filepos + s->_raw_size \
4267 <= p->p_offset + p->p_filesz))
4269 /* Decide if the given section should be included in the given segment.
4270 A section will be included if:
4271 1. It is within the address space of the segment -- we use the LMA
4272 if that is set for the segment and the VMA otherwise,
4273 2. It is an allocated segment,
4274 3. There is an output section associated with it,
4275 4. The section has not already been allocated to a previous segment. */
4276 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
4277 (((((segment->p_paddr \
4278 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4279 : IS_CONTAINED_BY_VMA (section, segment)) \
4280 || IS_SOLARIS_PT_INTERP (segment, section)) \
4281 && (section->flags & SEC_ALLOC) != 0) \
4282 || IS_COREFILE_NOTE (segment, section)) \
4283 && section->output_section != NULL \
4284 && section->segment_mark == false)
4286 /* Returns true iff seg1 starts after the end of seg2. */
4287 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4288 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4290 /* Returns true iff seg1 and seg2 overlap. */
4291 #define SEGMENT_OVERLAPS(seg1, seg2) \
4292 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4294 /* Initialise the segment mark field. */
4295 for (section = ibfd->sections; section != NULL; section = section->next)
4296 section->segment_mark = false;
4298 /* Scan through the segments specified in the program header
4299 of the input BFD. For this first scan we look for overlaps
4300 in the loadable segments. These can be created by weird
4301 parameters to objcopy. */
4302 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4307 Elf_Internal_Phdr *segment2;
4309 if (segment->p_type != PT_LOAD)
4312 /* Determine if this segment overlaps any previous segments. */
4313 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4315 bfd_signed_vma extra_length;
4317 if (segment2->p_type != PT_LOAD
4318 || ! SEGMENT_OVERLAPS (segment, segment2))
4321 /* Merge the two segments together. */
4322 if (segment2->p_vaddr < segment->p_vaddr)
4324 /* Extend SEGMENT2 to include SEGMENT and then delete
4327 SEGMENT_END (segment, segment->p_vaddr)
4328 - SEGMENT_END (segment2, segment2->p_vaddr);
4330 if (extra_length > 0)
4332 segment2->p_memsz += extra_length;
4333 segment2->p_filesz += extra_length;
4336 segment->p_type = PT_NULL;
4338 /* Since we have deleted P we must restart the outer loop. */
4340 segment = elf_tdata (ibfd)->phdr;
4345 /* Extend SEGMENT to include SEGMENT2 and then delete
4348 SEGMENT_END (segment2, segment2->p_vaddr)
4349 - SEGMENT_END (segment, segment->p_vaddr);
4351 if (extra_length > 0)
4353 segment->p_memsz += extra_length;
4354 segment->p_filesz += extra_length;
4357 segment2->p_type = PT_NULL;
4362 /* The second scan attempts to assign sections to segments. */
4363 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4367 unsigned int section_count;
4368 asection ** sections;
4369 asection * output_section;
4371 bfd_vma matching_lma;
4372 bfd_vma suggested_lma;
4376 if (segment->p_type == PT_NULL)
4379 /* Compute how many sections might be placed into this segment. */
4381 for (section = ibfd->sections; section != NULL; section = section->next)
4382 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
4385 /* Allocate a segment map big enough to contain all of the
4386 sections we have selected. */
4387 amt = sizeof (struct elf_segment_map);
4388 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4389 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4393 /* Initialise the fields of the segment map. Default to
4394 using the physical address of the segment in the input BFD. */
4396 map->p_type = segment->p_type;
4397 map->p_flags = segment->p_flags;
4398 map->p_flags_valid = 1;
4399 map->p_paddr = segment->p_paddr;
4400 map->p_paddr_valid = 1;
4402 /* Determine if this segment contains the ELF file header
4403 and if it contains the program headers themselves. */
4404 map->includes_filehdr = (segment->p_offset == 0
4405 && segment->p_filesz >= iehdr->e_ehsize);
4407 map->includes_phdrs = 0;
4409 if (! phdr_included || segment->p_type != PT_LOAD)
4411 map->includes_phdrs =
4412 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4413 && (segment->p_offset + segment->p_filesz
4414 >= ((bfd_vma) iehdr->e_phoff
4415 + iehdr->e_phnum * iehdr->e_phentsize)));
4417 if (segment->p_type == PT_LOAD && map->includes_phdrs)
4418 phdr_included = true;
4421 if (section_count == 0)
4423 /* Special segments, such as the PT_PHDR segment, may contain
4424 no sections, but ordinary, loadable segments should contain
4426 if (segment->p_type == PT_LOAD)
4428 (_("%s: warning: Empty loadable segment detected\n"),
4429 bfd_archive_filename (ibfd));
4432 *pointer_to_map = map;
4433 pointer_to_map = &map->next;
4438 /* Now scan the sections in the input BFD again and attempt
4439 to add their corresponding output sections to the segment map.
4440 The problem here is how to handle an output section which has
4441 been moved (ie had its LMA changed). There are four possibilities:
4443 1. None of the sections have been moved.
4444 In this case we can continue to use the segment LMA from the
4447 2. All of the sections have been moved by the same amount.
4448 In this case we can change the segment's LMA to match the LMA
4449 of the first section.
4451 3. Some of the sections have been moved, others have not.
4452 In this case those sections which have not been moved can be
4453 placed in the current segment which will have to have its size,
4454 and possibly its LMA changed, and a new segment or segments will
4455 have to be created to contain the other sections.
4457 4. The sections have been moved, but not be the same amount.
4458 In this case we can change the segment's LMA to match the LMA
4459 of the first section and we will have to create a new segment
4460 or segments to contain the other sections.
4462 In order to save time, we allocate an array to hold the section
4463 pointers that we are interested in. As these sections get assigned
4464 to a segment, they are removed from this array. */
4466 amt = (bfd_size_type) section_count * sizeof (asection *);
4467 sections = (asection **) bfd_malloc (amt);
4468 if (sections == NULL)
4471 /* Step One: Scan for segment vs section LMA conflicts.
4472 Also add the sections to the section array allocated above.
4473 Also add the sections to the current segment. In the common
4474 case, where the sections have not been moved, this means that
4475 we have completely filled the segment, and there is nothing
4481 for (j = 0, section = ibfd->sections;
4483 section = section->next)
4485 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
4487 output_section = section->output_section;
4489 sections[j ++] = section;
4491 /* The Solaris native linker always sets p_paddr to 0.
4492 We try to catch that case here, and set it to the
4494 if (segment->p_paddr == 0
4495 && segment->p_vaddr != 0
4497 && output_section->lma != 0
4498 && (output_section->vma == (segment->p_vaddr
4499 + (map->includes_filehdr
4502 + (map->includes_phdrs
4504 * iehdr->e_phentsize)
4506 map->p_paddr = segment->p_vaddr;
4508 /* Match up the physical address of the segment with the
4509 LMA address of the output section. */
4510 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4511 || IS_COREFILE_NOTE (segment, section))
4513 if (matching_lma == 0)
4514 matching_lma = output_section->lma;
4516 /* We assume that if the section fits within the segment
4517 then it does not overlap any other section within that
4519 map->sections[isec ++] = output_section;
4521 else if (suggested_lma == 0)
4522 suggested_lma = output_section->lma;
4526 BFD_ASSERT (j == section_count);
4528 /* Step Two: Adjust the physical address of the current segment,
4530 if (isec == section_count)
4532 /* All of the sections fitted within the segment as currently
4533 specified. This is the default case. Add the segment to
4534 the list of built segments and carry on to process the next
4535 program header in the input BFD. */
4536 map->count = section_count;
4537 *pointer_to_map = map;
4538 pointer_to_map = &map->next;
4545 if (matching_lma != 0)
4547 /* At least one section fits inside the current segment.
4548 Keep it, but modify its physical address to match the
4549 LMA of the first section that fitted. */
4550 map->p_paddr = matching_lma;
4554 /* None of the sections fitted inside the current segment.
4555 Change the current segment's physical address to match
4556 the LMA of the first section. */
4557 map->p_paddr = suggested_lma;
4560 /* Offset the segment physical address from the lma
4561 to allow for space taken up by elf headers. */
4562 if (map->includes_filehdr)
4563 map->p_paddr -= iehdr->e_ehsize;
4565 if (map->includes_phdrs)
4567 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4569 /* iehdr->e_phnum is just an estimate of the number
4570 of program headers that we will need. Make a note
4571 here of the number we used and the segment we chose
4572 to hold these headers, so that we can adjust the
4573 offset when we know the correct value. */
4574 phdr_adjust_num = iehdr->e_phnum;
4575 phdr_adjust_seg = map;
4579 /* Step Three: Loop over the sections again, this time assigning
4580 those that fit to the current segment and remvoing them from the
4581 sections array; but making sure not to leave large gaps. Once all
4582 possible sections have been assigned to the current segment it is
4583 added to the list of built segments and if sections still remain
4584 to be assigned, a new segment is constructed before repeating
4592 /* Fill the current segment with sections that fit. */
4593 for (j = 0; j < section_count; j++)
4595 section = sections[j];
4597 if (section == NULL)
4600 output_section = section->output_section;
4602 BFD_ASSERT (output_section != NULL);
4604 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4605 || IS_COREFILE_NOTE (segment, section))
4607 if (map->count == 0)
4609 /* If the first section in a segment does not start at
4610 the beginning of the segment, then something is
4612 if (output_section->lma !=
4614 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4615 + (map->includes_phdrs
4616 ? iehdr->e_phnum * iehdr->e_phentsize
4622 asection * prev_sec;
4624 prev_sec = map->sections[map->count - 1];
4626 /* If the gap between the end of the previous section
4627 and the start of this section is more than
4628 maxpagesize then we need to start a new segment. */
4629 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
4631 < BFD_ALIGN (output_section->lma, maxpagesize))
4632 || ((prev_sec->lma + prev_sec->_raw_size)
4633 > output_section->lma))
4635 if (suggested_lma == 0)
4636 suggested_lma = output_section->lma;
4642 map->sections[map->count++] = output_section;
4645 section->segment_mark = true;
4647 else if (suggested_lma == 0)
4648 suggested_lma = output_section->lma;
4651 BFD_ASSERT (map->count > 0);
4653 /* Add the current segment to the list of built segments. */
4654 *pointer_to_map = map;
4655 pointer_to_map = &map->next;
4657 if (isec < section_count)
4659 /* We still have not allocated all of the sections to
4660 segments. Create a new segment here, initialise it
4661 and carry on looping. */
4662 amt = sizeof (struct elf_segment_map);
4663 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4664 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4668 /* Initialise the fields of the segment map. Set the physical
4669 physical address to the LMA of the first section that has
4670 not yet been assigned. */
4672 map->p_type = segment->p_type;
4673 map->p_flags = segment->p_flags;
4674 map->p_flags_valid = 1;
4675 map->p_paddr = suggested_lma;
4676 map->p_paddr_valid = 1;
4677 map->includes_filehdr = 0;
4678 map->includes_phdrs = 0;
4681 while (isec < section_count);
4686 /* The Solaris linker creates program headers in which all the
4687 p_paddr fields are zero. When we try to objcopy or strip such a
4688 file, we get confused. Check for this case, and if we find it
4689 reset the p_paddr_valid fields. */
4690 for (map = map_first; map != NULL; map = map->next)
4691 if (map->p_paddr != 0)
4695 for (map = map_first; map != NULL; map = map->next)
4696 map->p_paddr_valid = 0;
4699 elf_tdata (obfd)->segment_map = map_first;
4701 /* If we had to estimate the number of program headers that were
4702 going to be needed, then check our estimate now and adjust
4703 the offset if necessary. */
4704 if (phdr_adjust_seg != NULL)
4708 for (count = 0, map = map_first; map != NULL; map = map->next)
4711 if (count > phdr_adjust_num)
4712 phdr_adjust_seg->p_paddr
4713 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
4717 /* Final Step: Sort the segments into ascending order of physical
4719 if (map_first != NULL)
4721 struct elf_segment_map *prev;
4724 for (map = map_first->next; map != NULL; prev = map, map = map->next)
4726 /* Yes I know - its a bubble sort.... */
4727 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
4729 /* Swap map and map->next. */
4730 prev->next = map->next;
4731 map->next = map->next->next;
4732 prev->next->next = map;
4742 #undef IS_CONTAINED_BY_VMA
4743 #undef IS_CONTAINED_BY_LMA
4744 #undef IS_COREFILE_NOTE
4745 #undef IS_SOLARIS_PT_INTERP
4746 #undef INCLUDE_SECTION_IN_SEGMENT
4747 #undef SEGMENT_AFTER_SEGMENT
4748 #undef SEGMENT_OVERLAPS
4752 /* Copy private section information. This copies over the entsize
4753 field, and sometimes the info field. */
4756 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
4762 Elf_Internal_Shdr *ihdr, *ohdr;
4764 if (ibfd->xvec->flavour != bfd_target_elf_flavour
4765 || obfd->xvec->flavour != bfd_target_elf_flavour)
4768 /* Copy over private BFD data if it has not already been copied.
4769 This must be done here, rather than in the copy_private_bfd_data
4770 entry point, because the latter is called after the section
4771 contents have been set, which means that the program headers have
4772 already been worked out. */
4773 if (elf_tdata (obfd)->segment_map == NULL
4774 && elf_tdata (ibfd)->phdr != NULL)
4778 /* Only set up the segments if there are no more SEC_ALLOC
4779 sections. FIXME: This won't do the right thing if objcopy is
4780 used to remove the last SEC_ALLOC section, since objcopy
4781 won't call this routine in that case. */
4782 for (s = isec->next; s != NULL; s = s->next)
4783 if ((s->flags & SEC_ALLOC) != 0)
4787 if (! copy_private_bfd_data (ibfd, obfd))
4792 ihdr = &elf_section_data (isec)->this_hdr;
4793 ohdr = &elf_section_data (osec)->this_hdr;
4795 ohdr->sh_entsize = ihdr->sh_entsize;
4797 if (ihdr->sh_type == SHT_SYMTAB
4798 || ihdr->sh_type == SHT_DYNSYM
4799 || ihdr->sh_type == SHT_GNU_verneed
4800 || ihdr->sh_type == SHT_GNU_verdef)
4801 ohdr->sh_info = ihdr->sh_info;
4803 elf_section_data (osec)->use_rela_p
4804 = elf_section_data (isec)->use_rela_p;
4809 /* Copy private symbol information. If this symbol is in a section
4810 which we did not map into a BFD section, try to map the section
4811 index correctly. We use special macro definitions for the mapped
4812 section indices; these definitions are interpreted by the
4813 swap_out_syms function. */
4815 #define MAP_ONESYMTAB (SHN_HIOS + 1)
4816 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
4817 #define MAP_STRTAB (SHN_HIOS + 3)
4818 #define MAP_SHSTRTAB (SHN_HIOS + 4)
4819 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
4822 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
4828 elf_symbol_type *isym, *osym;
4830 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4831 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4834 isym = elf_symbol_from (ibfd, isymarg);
4835 osym = elf_symbol_from (obfd, osymarg);
4839 && bfd_is_abs_section (isym->symbol.section))
4843 shndx = isym->internal_elf_sym.st_shndx;
4844 if (shndx == elf_onesymtab (ibfd))
4845 shndx = MAP_ONESYMTAB;
4846 else if (shndx == elf_dynsymtab (ibfd))
4847 shndx = MAP_DYNSYMTAB;
4848 else if (shndx == elf_tdata (ibfd)->strtab_section)
4850 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
4851 shndx = MAP_SHSTRTAB;
4852 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
4853 shndx = MAP_SYM_SHNDX;
4854 osym->internal_elf_sym.st_shndx = shndx;
4860 /* Swap out the symbols. */
4863 swap_out_syms (abfd, sttp, relocatable_p)
4865 struct bfd_strtab_hash **sttp;
4868 struct elf_backend_data *bed;
4871 struct bfd_strtab_hash *stt;
4872 Elf_Internal_Shdr *symtab_hdr;
4873 Elf_Internal_Shdr *symtab_shndx_hdr;
4874 Elf_Internal_Shdr *symstrtab_hdr;
4875 char *outbound_syms;
4876 char *outbound_shndx;
4880 if (!elf_map_symbols (abfd))
4883 /* Dump out the symtabs. */
4884 stt = _bfd_elf_stringtab_init ();
4888 bed = get_elf_backend_data (abfd);
4889 symcount = bfd_get_symcount (abfd);
4890 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4891 symtab_hdr->sh_type = SHT_SYMTAB;
4892 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4893 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4894 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4895 symtab_hdr->sh_addralign = bed->s->file_align;
4897 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4898 symstrtab_hdr->sh_type = SHT_STRTAB;
4900 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
4901 outbound_syms = bfd_alloc (abfd, amt);
4902 if (outbound_syms == NULL)
4904 symtab_hdr->contents = (PTR) outbound_syms;
4906 outbound_shndx = NULL;
4907 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
4908 if (symtab_shndx_hdr->sh_name != 0)
4910 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
4911 outbound_shndx = bfd_alloc (abfd, amt);
4912 if (outbound_shndx == NULL)
4914 memset (outbound_shndx, 0, (unsigned long) amt);
4915 symtab_shndx_hdr->contents = outbound_shndx;
4916 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
4917 symtab_shndx_hdr->sh_size = amt;
4918 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
4919 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
4922 /* now generate the data (for "contents") */
4924 /* Fill in zeroth symbol and swap it out. */
4925 Elf_Internal_Sym sym;
4931 sym.st_shndx = SHN_UNDEF;
4932 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
4933 outbound_syms += bed->s->sizeof_sym;
4934 if (outbound_shndx != NULL)
4935 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
4938 syms = bfd_get_outsymbols (abfd);
4939 for (idx = 0; idx < symcount; idx++)
4941 Elf_Internal_Sym sym;
4942 bfd_vma value = syms[idx]->value;
4943 elf_symbol_type *type_ptr;
4944 flagword flags = syms[idx]->flags;
4947 if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
4949 /* Local section symbols have no name. */
4954 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4957 if (sym.st_name == (unsigned long) -1)
4961 type_ptr = elf_symbol_from (abfd, syms[idx]);
4963 if ((flags & BSF_SECTION_SYM) == 0
4964 && bfd_is_com_section (syms[idx]->section))
4966 /* ELF common symbols put the alignment into the `value' field,
4967 and the size into the `size' field. This is backwards from
4968 how BFD handles it, so reverse it here. */
4969 sym.st_size = value;
4970 if (type_ptr == NULL
4971 || type_ptr->internal_elf_sym.st_value == 0)
4972 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4974 sym.st_value = type_ptr->internal_elf_sym.st_value;
4975 sym.st_shndx = _bfd_elf_section_from_bfd_section
4976 (abfd, syms[idx]->section);
4980 asection *sec = syms[idx]->section;
4983 if (sec->output_section)
4985 value += sec->output_offset;
4986 sec = sec->output_section;
4988 /* Don't add in the section vma for relocatable output. */
4989 if (! relocatable_p)
4991 sym.st_value = value;
4992 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4994 if (bfd_is_abs_section (sec)
4996 && type_ptr->internal_elf_sym.st_shndx != 0)
4998 /* This symbol is in a real ELF section which we did
4999 not create as a BFD section. Undo the mapping done
5000 by copy_private_symbol_data. */
5001 shndx = type_ptr->internal_elf_sym.st_shndx;
5005 shndx = elf_onesymtab (abfd);
5008 shndx = elf_dynsymtab (abfd);
5011 shndx = elf_tdata (abfd)->strtab_section;
5014 shndx = elf_tdata (abfd)->shstrtab_section;
5017 shndx = elf_tdata (abfd)->symtab_shndx_section;
5025 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5031 /* Writing this would be a hell of a lot easier if
5032 we had some decent documentation on bfd, and
5033 knew what to expect of the library, and what to
5034 demand of applications. For example, it
5035 appears that `objcopy' might not set the
5036 section of a symbol to be a section that is
5037 actually in the output file. */
5038 sec2 = bfd_get_section_by_name (abfd, sec->name);
5039 BFD_ASSERT (sec2 != 0);
5040 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5041 BFD_ASSERT (shndx != -1);
5045 sym.st_shndx = shndx;
5048 if ((flags & BSF_FUNCTION) != 0)
5050 else if ((flags & BSF_OBJECT) != 0)
5055 /* Processor-specific types */
5056 if (type_ptr != NULL
5057 && bed->elf_backend_get_symbol_type)
5058 type = ((*bed->elf_backend_get_symbol_type)
5059 (&type_ptr->internal_elf_sym, type));
5061 if (flags & BSF_SECTION_SYM)
5063 if (flags & BSF_GLOBAL)
5064 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5066 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5068 else if (bfd_is_com_section (syms[idx]->section))
5069 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5070 else if (bfd_is_und_section (syms[idx]->section))
5071 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5075 else if (flags & BSF_FILE)
5076 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5079 int bind = STB_LOCAL;
5081 if (flags & BSF_LOCAL)
5083 else if (flags & BSF_WEAK)
5085 else if (flags & BSF_GLOBAL)
5088 sym.st_info = ELF_ST_INFO (bind, type);
5091 if (type_ptr != NULL)
5092 sym.st_other = type_ptr->internal_elf_sym.st_other;
5096 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5097 outbound_syms += bed->s->sizeof_sym;
5098 if (outbound_shndx != NULL)
5099 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5103 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5104 symstrtab_hdr->sh_type = SHT_STRTAB;
5106 symstrtab_hdr->sh_flags = 0;
5107 symstrtab_hdr->sh_addr = 0;
5108 symstrtab_hdr->sh_entsize = 0;
5109 symstrtab_hdr->sh_link = 0;
5110 symstrtab_hdr->sh_info = 0;
5111 symstrtab_hdr->sh_addralign = 1;
5116 /* Return the number of bytes required to hold the symtab vector.
5118 Note that we base it on the count plus 1, since we will null terminate
5119 the vector allocated based on this size. However, the ELF symbol table
5120 always has a dummy entry as symbol #0, so it ends up even. */
5123 _bfd_elf_get_symtab_upper_bound (abfd)
5128 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5130 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5131 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5133 symtab_size -= sizeof (asymbol *);
5139 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
5144 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5146 if (elf_dynsymtab (abfd) == 0)
5148 bfd_set_error (bfd_error_invalid_operation);
5152 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5153 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5155 symtab_size -= sizeof (asymbol *);
5161 _bfd_elf_get_reloc_upper_bound (abfd, asect)
5162 bfd *abfd ATTRIBUTE_UNUSED;
5165 return (asect->reloc_count + 1) * sizeof (arelent *);
5168 /* Canonicalize the relocs. */
5171 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
5179 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5181 if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
5184 tblptr = section->relocation;
5185 for (i = 0; i < section->reloc_count; i++)
5186 *relptr++ = tblptr++;
5190 return section->reloc_count;
5194 _bfd_elf_get_symtab (abfd, alocation)
5196 asymbol **alocation;
5198 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5199 long symcount = bed->s->slurp_symbol_table (abfd, alocation, false);
5202 bfd_get_symcount (abfd) = symcount;
5207 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
5209 asymbol **alocation;
5211 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5212 return bed->s->slurp_symbol_table (abfd, alocation, true);
5215 /* Return the size required for the dynamic reloc entries. Any
5216 section that was actually installed in the BFD, and has type
5217 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5218 considered to be a dynamic reloc section. */
5221 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
5227 if (elf_dynsymtab (abfd) == 0)
5229 bfd_set_error (bfd_error_invalid_operation);
5233 ret = sizeof (arelent *);
5234 for (s = abfd->sections; s != NULL; s = s->next)
5235 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5236 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5237 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5238 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5239 * sizeof (arelent *));
5244 /* Canonicalize the dynamic relocation entries. Note that we return
5245 the dynamic relocations as a single block, although they are
5246 actually associated with particular sections; the interface, which
5247 was designed for SunOS style shared libraries, expects that there
5248 is only one set of dynamic relocs. Any section that was actually
5249 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5250 the dynamic symbol table, is considered to be a dynamic reloc
5254 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
5259 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
5263 if (elf_dynsymtab (abfd) == 0)
5265 bfd_set_error (bfd_error_invalid_operation);
5269 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5271 for (s = abfd->sections; s != NULL; s = s->next)
5273 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5274 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5275 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5280 if (! (*slurp_relocs) (abfd, s, syms, true))
5282 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5284 for (i = 0; i < count; i++)
5295 /* Read in the version information. */
5298 _bfd_elf_slurp_version_tables (abfd)
5301 bfd_byte *contents = NULL;
5304 if (elf_dynverdef (abfd) != 0)
5306 Elf_Internal_Shdr *hdr;
5307 Elf_External_Verdef *everdef;
5308 Elf_Internal_Verdef *iverdef;
5309 Elf_Internal_Verdef *iverdefarr;
5310 Elf_Internal_Verdef iverdefmem;
5312 unsigned int maxidx;
5314 hdr = &elf_tdata (abfd)->dynverdef_hdr;
5316 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5317 if (contents == NULL)
5319 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5320 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5323 /* We know the number of entries in the section but not the maximum
5324 index. Therefore we have to run through all entries and find
5326 everdef = (Elf_External_Verdef *) contents;
5328 for (i = 0; i < hdr->sh_info; ++i)
5330 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5332 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5333 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5335 everdef = ((Elf_External_Verdef *)
5336 ((bfd_byte *) everdef + iverdefmem.vd_next));
5339 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5340 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
5341 if (elf_tdata (abfd)->verdef == NULL)
5344 elf_tdata (abfd)->cverdefs = maxidx;
5346 everdef = (Elf_External_Verdef *) contents;
5347 iverdefarr = elf_tdata (abfd)->verdef;
5348 for (i = 0; i < hdr->sh_info; i++)
5350 Elf_External_Verdaux *everdaux;
5351 Elf_Internal_Verdaux *iverdaux;
5354 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5356 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5357 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5359 iverdef->vd_bfd = abfd;
5361 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5362 iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
5363 if (iverdef->vd_auxptr == NULL)
5366 everdaux = ((Elf_External_Verdaux *)
5367 ((bfd_byte *) everdef + iverdef->vd_aux));
5368 iverdaux = iverdef->vd_auxptr;
5369 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5371 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5373 iverdaux->vda_nodename =
5374 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5375 iverdaux->vda_name);
5376 if (iverdaux->vda_nodename == NULL)
5379 if (j + 1 < iverdef->vd_cnt)
5380 iverdaux->vda_nextptr = iverdaux + 1;
5382 iverdaux->vda_nextptr = NULL;
5384 everdaux = ((Elf_External_Verdaux *)
5385 ((bfd_byte *) everdaux + iverdaux->vda_next));
5388 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5390 if (i + 1 < hdr->sh_info)
5391 iverdef->vd_nextdef = iverdef + 1;
5393 iverdef->vd_nextdef = NULL;
5395 everdef = ((Elf_External_Verdef *)
5396 ((bfd_byte *) everdef + iverdef->vd_next));
5403 if (elf_dynverref (abfd) != 0)
5405 Elf_Internal_Shdr *hdr;
5406 Elf_External_Verneed *everneed;
5407 Elf_Internal_Verneed *iverneed;
5410 hdr = &elf_tdata (abfd)->dynverref_hdr;
5412 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5413 elf_tdata (abfd)->verref =
5414 (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
5415 if (elf_tdata (abfd)->verref == NULL)
5418 elf_tdata (abfd)->cverrefs = hdr->sh_info;
5420 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5421 if (contents == NULL)
5423 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5424 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5427 everneed = (Elf_External_Verneed *) contents;
5428 iverneed = elf_tdata (abfd)->verref;
5429 for (i = 0; i < hdr->sh_info; i++, iverneed++)
5431 Elf_External_Vernaux *evernaux;
5432 Elf_Internal_Vernaux *ivernaux;
5435 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5437 iverneed->vn_bfd = abfd;
5439 iverneed->vn_filename =
5440 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5442 if (iverneed->vn_filename == NULL)
5445 amt = iverneed->vn_cnt;
5446 amt *= sizeof (Elf_Internal_Vernaux);
5447 iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
5449 evernaux = ((Elf_External_Vernaux *)
5450 ((bfd_byte *) everneed + iverneed->vn_aux));
5451 ivernaux = iverneed->vn_auxptr;
5452 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5454 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5456 ivernaux->vna_nodename =
5457 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5458 ivernaux->vna_name);
5459 if (ivernaux->vna_nodename == NULL)
5462 if (j + 1 < iverneed->vn_cnt)
5463 ivernaux->vna_nextptr = ivernaux + 1;
5465 ivernaux->vna_nextptr = NULL;
5467 evernaux = ((Elf_External_Vernaux *)
5468 ((bfd_byte *) evernaux + ivernaux->vna_next));
5471 if (i + 1 < hdr->sh_info)
5472 iverneed->vn_nextref = iverneed + 1;
5474 iverneed->vn_nextref = NULL;
5476 everneed = ((Elf_External_Verneed *)
5477 ((bfd_byte *) everneed + iverneed->vn_next));
5487 if (contents == NULL)
5493 _bfd_elf_make_empty_symbol (abfd)
5496 elf_symbol_type *newsym;
5497 bfd_size_type amt = sizeof (elf_symbol_type);
5499 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
5504 newsym->symbol.the_bfd = abfd;
5505 return &newsym->symbol;
5510 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
5511 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5515 bfd_symbol_info (symbol, ret);
5518 /* Return whether a symbol name implies a local symbol. Most targets
5519 use this function for the is_local_label_name entry point, but some
5523 _bfd_elf_is_local_label_name (abfd, name)
5524 bfd *abfd ATTRIBUTE_UNUSED;
5527 /* Normal local symbols start with ``.L''. */
5528 if (name[0] == '.' && name[1] == 'L')
5531 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5532 DWARF debugging symbols starting with ``..''. */
5533 if (name[0] == '.' && name[1] == '.')
5536 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5537 emitting DWARF debugging output. I suspect this is actually a
5538 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5539 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5540 underscore to be emitted on some ELF targets). For ease of use,
5541 we treat such symbols as local. */
5542 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5549 _bfd_elf_get_lineno (ignore_abfd, symbol)
5550 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5551 asymbol *symbol ATTRIBUTE_UNUSED;
5558 _bfd_elf_set_arch_mach (abfd, arch, machine)
5560 enum bfd_architecture arch;
5561 unsigned long machine;
5563 /* If this isn't the right architecture for this backend, and this
5564 isn't the generic backend, fail. */
5565 if (arch != get_elf_backend_data (abfd)->arch
5566 && arch != bfd_arch_unknown
5567 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5570 return bfd_default_set_arch_mach (abfd, arch, machine);
5573 /* Find the function to a particular section and offset,
5574 for error reporting. */
5577 elf_find_function (abfd, section, symbols, offset,
5578 filename_ptr, functionname_ptr)
5579 bfd *abfd ATTRIBUTE_UNUSED;
5583 const char **filename_ptr;
5584 const char **functionname_ptr;
5586 const char *filename;
5595 for (p = symbols; *p != NULL; p++)
5599 q = (elf_symbol_type *) *p;
5601 if (bfd_get_section (&q->symbol) != section)
5604 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5609 filename = bfd_asymbol_name (&q->symbol);
5613 if (q->symbol.section == section
5614 && q->symbol.value >= low_func
5615 && q->symbol.value <= offset)
5617 func = (asymbol *) q;
5618 low_func = q->symbol.value;
5628 *filename_ptr = filename;
5629 if (functionname_ptr)
5630 *functionname_ptr = bfd_asymbol_name (func);
5635 /* Find the nearest line to a particular section and offset,
5636 for error reporting. */
5639 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
5640 filename_ptr, functionname_ptr, line_ptr)
5645 const char **filename_ptr;
5646 const char **functionname_ptr;
5647 unsigned int *line_ptr;
5651 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
5652 filename_ptr, functionname_ptr,
5655 if (!*functionname_ptr)
5656 elf_find_function (abfd, section, symbols, offset,
5657 *filename_ptr ? NULL : filename_ptr,
5663 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
5664 filename_ptr, functionname_ptr,
5666 &elf_tdata (abfd)->dwarf2_find_line_info))
5668 if (!*functionname_ptr)
5669 elf_find_function (abfd, section, symbols, offset,
5670 *filename_ptr ? NULL : filename_ptr,
5676 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
5677 &found, filename_ptr,
5678 functionname_ptr, line_ptr,
5679 &elf_tdata (abfd)->line_info))
5684 if (symbols == NULL)
5687 if (! elf_find_function (abfd, section, symbols, offset,
5688 filename_ptr, functionname_ptr))
5696 _bfd_elf_sizeof_headers (abfd, reloc)
5702 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
5704 ret += get_program_header_size (abfd);
5709 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
5714 bfd_size_type count;
5716 Elf_Internal_Shdr *hdr;
5719 if (! abfd->output_has_begun
5720 && ! _bfd_elf_compute_section_file_positions
5721 (abfd, (struct bfd_link_info *) NULL))
5724 hdr = &elf_section_data (section)->this_hdr;
5725 pos = hdr->sh_offset + offset;
5726 if (bfd_seek (abfd, pos, SEEK_SET) != 0
5727 || bfd_bwrite (location, count, abfd) != count)
5734 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
5735 bfd *abfd ATTRIBUTE_UNUSED;
5736 arelent *cache_ptr ATTRIBUTE_UNUSED;
5737 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
5744 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
5747 Elf_Internal_Rel *dst;
5753 /* Try to convert a non-ELF reloc into an ELF one. */
5756 _bfd_elf_validate_reloc (abfd, areloc)
5760 /* Check whether we really have an ELF howto. */
5762 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
5764 bfd_reloc_code_real_type code;
5765 reloc_howto_type *howto;
5767 /* Alien reloc: Try to determine its type to replace it with an
5768 equivalent ELF reloc. */
5770 if (areloc->howto->pc_relative)
5772 switch (areloc->howto->bitsize)
5775 code = BFD_RELOC_8_PCREL;
5778 code = BFD_RELOC_12_PCREL;
5781 code = BFD_RELOC_16_PCREL;
5784 code = BFD_RELOC_24_PCREL;
5787 code = BFD_RELOC_32_PCREL;
5790 code = BFD_RELOC_64_PCREL;
5796 howto = bfd_reloc_type_lookup (abfd, code);
5798 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
5800 if (howto->pcrel_offset)
5801 areloc->addend += areloc->address;
5803 areloc->addend -= areloc->address; /* addend is unsigned!! */
5808 switch (areloc->howto->bitsize)
5814 code = BFD_RELOC_14;
5817 code = BFD_RELOC_16;
5820 code = BFD_RELOC_26;
5823 code = BFD_RELOC_32;
5826 code = BFD_RELOC_64;
5832 howto = bfd_reloc_type_lookup (abfd, code);
5836 areloc->howto = howto;
5844 (*_bfd_error_handler)
5845 (_("%s: unsupported relocation type %s"),
5846 bfd_archive_filename (abfd), areloc->howto->name);
5847 bfd_set_error (bfd_error_bad_value);
5852 _bfd_elf_close_and_cleanup (abfd)
5855 if (bfd_get_format (abfd) == bfd_object)
5857 if (elf_shstrtab (abfd) != NULL)
5858 _bfd_elf_strtab_free (elf_shstrtab (abfd));
5861 return _bfd_generic_close_and_cleanup (abfd);
5864 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5865 in the relocation's offset. Thus we cannot allow any sort of sanity
5866 range-checking to interfere. There is nothing else to do in processing
5869 bfd_reloc_status_type
5870 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
5871 bfd *abfd ATTRIBUTE_UNUSED;
5872 arelent *re ATTRIBUTE_UNUSED;
5873 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
5874 PTR data ATTRIBUTE_UNUSED;
5875 asection *is ATTRIBUTE_UNUSED;
5876 bfd *obfd ATTRIBUTE_UNUSED;
5877 char **errmsg ATTRIBUTE_UNUSED;
5879 return bfd_reloc_ok;
5882 /* Elf core file support. Much of this only works on native
5883 toolchains, since we rely on knowing the
5884 machine-dependent procfs structure in order to pick
5885 out details about the corefile. */
5887 #ifdef HAVE_SYS_PROCFS_H
5888 # include <sys/procfs.h>
5891 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5894 elfcore_make_pid (abfd)
5897 return ((elf_tdata (abfd)->core_lwpid << 16)
5898 + (elf_tdata (abfd)->core_pid));
5901 /* If there isn't a section called NAME, make one, using
5902 data from SECT. Note, this function will generate a
5903 reference to NAME, so you shouldn't deallocate or
5907 elfcore_maybe_make_sect (abfd, name, sect)
5914 if (bfd_get_section_by_name (abfd, name) != NULL)
5917 sect2 = bfd_make_section (abfd, name);
5921 sect2->_raw_size = sect->_raw_size;
5922 sect2->filepos = sect->filepos;
5923 sect2->flags = sect->flags;
5924 sect2->alignment_power = sect->alignment_power;
5928 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
5929 actually creates up to two pseudosections:
5930 - For the single-threaded case, a section named NAME, unless
5931 such a section already exists.
5932 - For the multi-threaded case, a section named "NAME/PID", where
5933 PID is elfcore_make_pid (abfd).
5934 Both pseudosections have identical contents. */
5936 _bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
5943 char *threaded_name;
5946 /* Build the section name. */
5948 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5949 threaded_name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
5950 if (threaded_name == NULL)
5952 strcpy (threaded_name, buf);
5954 sect = bfd_make_section (abfd, threaded_name);
5957 sect->_raw_size = size;
5958 sect->filepos = filepos;
5959 sect->flags = SEC_HAS_CONTENTS;
5960 sect->alignment_power = 2;
5962 return elfcore_maybe_make_sect (abfd, name, sect);
5965 /* prstatus_t exists on:
5967 linux 2.[01] + glibc
5971 #if defined (HAVE_PRSTATUS_T)
5972 static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
5975 elfcore_grok_prstatus (abfd, note)
5977 Elf_Internal_Note *note;
5982 if (note->descsz == sizeof (prstatus_t))
5986 raw_size = sizeof (prstat.pr_reg);
5987 offset = offsetof (prstatus_t, pr_reg);
5988 memcpy (&prstat, note->descdata, sizeof (prstat));
5990 /* Do not overwrite the core signal if it
5991 has already been set by another thread. */
5992 if (elf_tdata (abfd)->core_signal == 0)
5993 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5994 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5996 /* pr_who exists on:
5999 pr_who doesn't exist on:
6002 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6003 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6006 #if defined (HAVE_PRSTATUS32_T)
6007 else if (note->descsz == sizeof (prstatus32_t))
6009 /* 64-bit host, 32-bit corefile */
6010 prstatus32_t prstat;
6012 raw_size = sizeof (prstat.pr_reg);
6013 offset = offsetof (prstatus32_t, pr_reg);
6014 memcpy (&prstat, note->descdata, sizeof (prstat));
6016 /* Do not overwrite the core signal if it
6017 has already been set by another thread. */
6018 if (elf_tdata (abfd)->core_signal == 0)
6019 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6020 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6022 /* pr_who exists on:
6025 pr_who doesn't exist on:
6028 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6029 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6032 #endif /* HAVE_PRSTATUS32_T */
6035 /* Fail - we don't know how to handle any other
6036 note size (ie. data object type). */
6040 /* Make a ".reg/999" section and a ".reg" section. */
6041 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6042 raw_size, note->descpos + offset);
6044 #endif /* defined (HAVE_PRSTATUS_T) */
6046 /* Create a pseudosection containing the exact contents of NOTE. */
6048 elfcore_make_note_pseudosection (abfd, name, note)
6051 Elf_Internal_Note *note;
6053 return _bfd_elfcore_make_pseudosection (abfd, name,
6054 note->descsz, note->descpos);
6057 /* There isn't a consistent prfpregset_t across platforms,
6058 but it doesn't matter, because we don't have to pick this
6059 data structure apart. */
6062 elfcore_grok_prfpreg (abfd, note)
6064 Elf_Internal_Note *note;
6066 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6069 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6070 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6074 elfcore_grok_prxfpreg (abfd, note)
6076 Elf_Internal_Note *note;
6078 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6081 #if defined (HAVE_PRPSINFO_T)
6082 typedef prpsinfo_t elfcore_psinfo_t;
6083 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6084 typedef prpsinfo32_t elfcore_psinfo32_t;
6088 #if defined (HAVE_PSINFO_T)
6089 typedef psinfo_t elfcore_psinfo_t;
6090 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6091 typedef psinfo32_t elfcore_psinfo32_t;
6095 /* return a malloc'ed copy of a string at START which is at
6096 most MAX bytes long, possibly without a terminating '\0'.
6097 the copy will always have a terminating '\0'. */
6100 _bfd_elfcore_strndup (abfd, start, max)
6106 char *end = memchr (start, '\0', max);
6114 dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
6118 memcpy (dups, start, len);
6124 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6125 static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
6128 elfcore_grok_psinfo (abfd, note)
6130 Elf_Internal_Note *note;
6132 if (note->descsz == sizeof (elfcore_psinfo_t))
6134 elfcore_psinfo_t psinfo;
6136 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6138 elf_tdata (abfd)->core_program
6139 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6140 sizeof (psinfo.pr_fname));
6142 elf_tdata (abfd)->core_command
6143 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6144 sizeof (psinfo.pr_psargs));
6146 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6147 else if (note->descsz == sizeof (elfcore_psinfo32_t))
6149 /* 64-bit host, 32-bit corefile */
6150 elfcore_psinfo32_t psinfo;
6152 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6154 elf_tdata (abfd)->core_program
6155 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6156 sizeof (psinfo.pr_fname));
6158 elf_tdata (abfd)->core_command
6159 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6160 sizeof (psinfo.pr_psargs));
6166 /* Fail - we don't know how to handle any other
6167 note size (ie. data object type). */
6171 /* Note that for some reason, a spurious space is tacked
6172 onto the end of the args in some (at least one anyway)
6173 implementations, so strip it off if it exists. */
6176 char *command = elf_tdata (abfd)->core_command;
6177 int n = strlen (command);
6179 if (0 < n && command[n - 1] == ' ')
6180 command[n - 1] = '\0';
6185 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6187 #if defined (HAVE_PSTATUS_T)
6188 static boolean elfcore_grok_pstatus PARAMS ((bfd *, Elf_Internal_Note *));
6191 elfcore_grok_pstatus (abfd, note)
6193 Elf_Internal_Note *note;
6195 if (note->descsz == sizeof (pstatus_t)
6196 #if defined (HAVE_PXSTATUS_T)
6197 || note->descsz == sizeof (pxstatus_t)
6203 memcpy (&pstat, note->descdata, sizeof (pstat));
6205 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6207 #if defined (HAVE_PSTATUS32_T)
6208 else if (note->descsz == sizeof (pstatus32_t))
6210 /* 64-bit host, 32-bit corefile */
6213 memcpy (&pstat, note->descdata, sizeof (pstat));
6215 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6218 /* Could grab some more details from the "representative"
6219 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6220 NT_LWPSTATUS note, presumably. */
6224 #endif /* defined (HAVE_PSTATUS_T) */
6226 #if defined (HAVE_LWPSTATUS_T)
6227 static boolean elfcore_grok_lwpstatus PARAMS ((bfd *, Elf_Internal_Note *));
6230 elfcore_grok_lwpstatus (abfd, note)
6232 Elf_Internal_Note *note;
6234 lwpstatus_t lwpstat;
6239 if (note->descsz != sizeof (lwpstat)
6240 #if defined (HAVE_LWPXSTATUS_T)
6241 && note->descsz != sizeof (lwpxstatus_t)
6246 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6248 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6249 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6251 /* Make a ".reg/999" section. */
6253 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6254 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6259 sect = bfd_make_section (abfd, name);
6263 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6264 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6265 sect->filepos = note->descpos
6266 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6269 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6270 sect->_raw_size = sizeof (lwpstat.pr_reg);
6271 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6274 sect->flags = SEC_HAS_CONTENTS;
6275 sect->alignment_power = 2;
6277 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6280 /* Make a ".reg2/999" section */
6282 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6283 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6288 sect = bfd_make_section (abfd, name);
6292 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6293 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6294 sect->filepos = note->descpos
6295 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6298 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6299 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6300 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6303 sect->flags = SEC_HAS_CONTENTS;
6304 sect->alignment_power = 2;
6306 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6308 #endif /* defined (HAVE_LWPSTATUS_T) */
6310 #if defined (HAVE_WIN32_PSTATUS_T)
6312 elfcore_grok_win32pstatus (abfd, note)
6314 Elf_Internal_Note *note;
6319 win32_pstatus_t pstatus;
6321 if (note->descsz < sizeof (pstatus))
6324 memcpy (&pstatus, note->descdata, sizeof (pstatus));
6326 switch (pstatus.data_type)
6328 case NOTE_INFO_PROCESS:
6329 /* FIXME: need to add ->core_command. */
6330 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6331 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6334 case NOTE_INFO_THREAD:
6335 /* Make a ".reg/999" section. */
6336 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6338 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6344 sect = bfd_make_section (abfd, name);
6348 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6349 sect->filepos = (note->descpos
6350 + offsetof (struct win32_pstatus,
6351 data.thread_info.thread_context));
6352 sect->flags = SEC_HAS_CONTENTS;
6353 sect->alignment_power = 2;
6355 if (pstatus.data.thread_info.is_active_thread)
6356 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6360 case NOTE_INFO_MODULE:
6361 /* Make a ".module/xxxxxxxx" section. */
6362 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6364 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6370 sect = bfd_make_section (abfd, name);
6375 sect->_raw_size = note->descsz;
6376 sect->filepos = note->descpos;
6377 sect->flags = SEC_HAS_CONTENTS;
6378 sect->alignment_power = 2;
6387 #endif /* HAVE_WIN32_PSTATUS_T */
6390 elfcore_grok_note (abfd, note)
6392 Elf_Internal_Note *note;
6394 struct elf_backend_data *bed = get_elf_backend_data (abfd);
6402 if (bed->elf_backend_grok_prstatus)
6403 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6405 #if defined (HAVE_PRSTATUS_T)
6406 return elfcore_grok_prstatus (abfd, note);
6411 #if defined (HAVE_PSTATUS_T)
6413 return elfcore_grok_pstatus (abfd, note);
6416 #if defined (HAVE_LWPSTATUS_T)
6418 return elfcore_grok_lwpstatus (abfd, note);
6421 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
6422 return elfcore_grok_prfpreg (abfd, note);
6424 #if defined (HAVE_WIN32_PSTATUS_T)
6425 case NT_WIN32PSTATUS:
6426 return elfcore_grok_win32pstatus (abfd, note);
6429 case NT_PRXFPREG: /* Linux SSE extension */
6430 if (note->namesz == 5
6431 && ! strcmp (note->namedata, "LINUX"))
6432 return elfcore_grok_prxfpreg (abfd, note);
6438 if (bed->elf_backend_grok_psinfo)
6439 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6441 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6442 return elfcore_grok_psinfo (abfd, note);
6450 elfcore_netbsd_get_lwpid (note, lwpidp)
6451 Elf_Internal_Note *note;
6456 cp = strchr (note->namedata, '@');
6459 *lwpidp = atoi(cp + 1);
6466 elfcore_grok_netbsd_procinfo (abfd, note)
6468 Elf_Internal_Note *note;
6471 /* Signal number at offset 0x08. */
6472 elf_tdata (abfd)->core_signal
6473 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
6475 /* Process ID at offset 0x50. */
6476 elf_tdata (abfd)->core_pid
6477 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
6479 /* Command name at 0x7c (max 32 bytes, including nul). */
6480 elf_tdata (abfd)->core_command
6481 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
6487 elfcore_grok_netbsd_note (abfd, note)
6489 Elf_Internal_Note *note;
6493 if (elfcore_netbsd_get_lwpid (note, &lwp))
6494 elf_tdata (abfd)->core_lwpid = lwp;
6496 if (note->type == NT_NETBSDCORE_PROCINFO)
6498 /* NetBSD-specific core "procinfo". Note that we expect to
6499 find this note before any of the others, which is fine,
6500 since the kernel writes this note out first when it
6501 creates a core file. */
6503 return elfcore_grok_netbsd_procinfo (abfd, note);
6506 /* As of Jan 2002 there are no other machine-independent notes
6507 defined for NetBSD core files. If the note type is less
6508 than the start of the machine-dependent note types, we don't
6511 if (note->type < NT_NETBSDCORE_FIRSTMACH)
6515 switch (bfd_get_arch (abfd))
6517 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6518 PT_GETFPREGS == mach+2. */
6520 case bfd_arch_alpha:
6521 case bfd_arch_sparc:
6524 case NT_NETBSDCORE_FIRSTMACH+0:
6525 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6527 case NT_NETBSDCORE_FIRSTMACH+2:
6528 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6534 /* On all other arch's, PT_GETREGS == mach+1 and
6535 PT_GETFPREGS == mach+3. */
6540 case NT_NETBSDCORE_FIRSTMACH+1:
6541 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6543 case NT_NETBSDCORE_FIRSTMACH+3:
6544 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6553 /* Function: elfcore_write_note
6560 size of data for note
6563 End of buffer containing note. */
6566 elfcore_write_note (abfd, buf, bufsiz, name, type, input, size)
6575 Elf_External_Note *xnp;
6576 int namesz = strlen (name);
6577 int newspace = BFD_ALIGN (sizeof (Elf_External_Note) + size + namesz - 1, 4);
6580 p = realloc (buf, *bufsiz + newspace);
6582 *bufsiz += newspace;
6583 xnp = (Elf_External_Note *) dest;
6584 H_PUT_32 (abfd, namesz, xnp->namesz);
6585 H_PUT_32 (abfd, size, xnp->descsz);
6586 H_PUT_32 (abfd, type, xnp->type);
6587 strcpy (xnp->name, name);
6588 memcpy (xnp->name + BFD_ALIGN (namesz, 4), input, size);
6592 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6594 elfcore_write_prpsinfo (abfd, buf, bufsiz, fname, psargs)
6602 char *note_name = "CORE";
6604 #if defined (HAVE_PSINFO_T)
6606 note_type = NT_PSINFO;
6609 note_type = NT_PRPSINFO;
6612 memset (&data, 0, sizeof (data));
6613 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
6614 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
6615 return elfcore_write_note (abfd, buf, bufsiz,
6616 note_name, note_type, &data, sizeof (data));
6618 #endif /* PSINFO_T or PRPSINFO_T */
6620 #if defined (HAVE_PRSTATUS_T)
6622 elfcore_write_prstatus (abfd, buf, bufsiz, pid, cursig, gregs)
6631 char *note_name = "CORE";
6633 memset (&prstat, 0, sizeof (prstat));
6634 prstat.pr_pid = pid;
6635 prstat.pr_cursig = cursig;
6636 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
6637 return elfcore_write_note (abfd, buf, bufsiz,
6638 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
6640 #endif /* HAVE_PRSTATUS_T */
6642 #if defined (HAVE_LWPSTATUS_T)
6644 elfcore_write_lwpstatus (abfd, buf, bufsiz, pid, cursig, gregs)
6652 lwpstatus_t lwpstat;
6653 char *note_name = "CORE";
6655 memset (&lwpstat, 0, sizeof (lwpstat));
6656 lwpstat.pr_lwpid = pid >> 16;
6657 lwpstat.pr_cursig = cursig;
6658 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6659 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
6660 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6662 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
6663 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
6665 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
6666 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
6669 return elfcore_write_note (abfd, buf, bufsiz, note_name,
6670 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
6672 #endif /* HAVE_LWPSTATUS_T */
6674 #if defined (HAVE_PSTATUS_T)
6676 elfcore_write_pstatus (abfd, buf, bufsiz, pid, cursig, gregs)
6685 char *note_name = "CORE";
6687 memset (&pstat, 0, sizeof (pstat));
6688 pstat.pr_pid = pid & 0xffff;
6689 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
6690 NT_PSTATUS, &pstat, sizeof (pstat));
6693 #endif /* HAVE_PSTATUS_T */
6696 elfcore_write_prfpreg (abfd, buf, bufsiz, fpregs, size)
6703 char *note_name = "CORE";
6704 return elfcore_write_note (abfd, buf, bufsiz,
6705 note_name, NT_FPREGSET, fpregs, size);
6709 elfcore_write_prxfpreg (abfd, buf, bufsiz, xfpregs, size)
6716 char *note_name = "LINUX";
6717 return elfcore_write_note (abfd, buf, bufsiz,
6718 note_name, NT_PRXFPREG, xfpregs, size);
6722 elfcore_read_notes (abfd, offset, size)
6733 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
6736 buf = bfd_malloc (size);
6740 if (bfd_bread (buf, size, abfd) != size)
6748 while (p < buf + size)
6750 /* FIXME: bad alignment assumption. */
6751 Elf_External_Note *xnp = (Elf_External_Note *) p;
6752 Elf_Internal_Note in;
6754 in.type = H_GET_32 (abfd, xnp->type);
6756 in.namesz = H_GET_32 (abfd, xnp->namesz);
6757 in.namedata = xnp->name;
6759 in.descsz = H_GET_32 (abfd, xnp->descsz);
6760 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
6761 in.descpos = offset + (in.descdata - buf);
6763 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
6765 if (! elfcore_grok_netbsd_note (abfd, &in))
6770 if (! elfcore_grok_note (abfd, &in))
6774 p = in.descdata + BFD_ALIGN (in.descsz, 4);
6781 /* Providing external access to the ELF program header table. */
6783 /* Return an upper bound on the number of bytes required to store a
6784 copy of ABFD's program header table entries. Return -1 if an error
6785 occurs; bfd_get_error will return an appropriate code. */
6788 bfd_get_elf_phdr_upper_bound (abfd)
6791 if (abfd->xvec->flavour != bfd_target_elf_flavour)
6793 bfd_set_error (bfd_error_wrong_format);
6797 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
6800 /* Copy ABFD's program header table entries to *PHDRS. The entries
6801 will be stored as an array of Elf_Internal_Phdr structures, as
6802 defined in include/elf/internal.h. To find out how large the
6803 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
6805 Return the number of program header table entries read, or -1 if an
6806 error occurs; bfd_get_error will return an appropriate code. */
6809 bfd_get_elf_phdrs (abfd, phdrs)
6815 if (abfd->xvec->flavour != bfd_target_elf_flavour)
6817 bfd_set_error (bfd_error_wrong_format);
6821 num_phdrs = elf_elfheader (abfd)->e_phnum;
6822 memcpy (phdrs, elf_tdata (abfd)->phdr,
6823 num_phdrs * sizeof (Elf_Internal_Phdr));
6829 _bfd_elf_sprintf_vma (abfd, buf, value)
6830 bfd *abfd ATTRIBUTE_UNUSED;
6835 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
6837 i_ehdrp = elf_elfheader (abfd);
6838 if (i_ehdrp == NULL)
6839 sprintf_vma (buf, value);
6842 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6844 #if BFD_HOST_64BIT_LONG
6845 sprintf (buf, "%016lx", value);
6847 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
6848 _bfd_int64_low (value));
6852 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
6855 sprintf_vma (buf, value);
6860 _bfd_elf_fprintf_vma (abfd, stream, value)
6861 bfd *abfd ATTRIBUTE_UNUSED;
6866 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
6868 i_ehdrp = elf_elfheader (abfd);
6869 if (i_ehdrp == NULL)
6870 fprintf_vma ((FILE *) stream, value);
6873 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6875 #if BFD_HOST_64BIT_LONG
6876 fprintf ((FILE *) stream, "%016lx", value);
6878 fprintf ((FILE *) stream, "%08lx%08lx",
6879 _bfd_int64_high (value), _bfd_int64_low (value));
6883 fprintf ((FILE *) stream, "%08lx",
6884 (unsigned long) (value & 0xffffffff));
6887 fprintf_vma ((FILE *) stream, value);
6891 enum elf_reloc_type_class
6892 _bfd_elf_reloc_type_class (rela)
6893 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
6895 return reloc_class_normal;
6898 /* For RELA architectures, return what the relocation value for
6899 relocation against a local symbol. */
6902 _bfd_elf_rela_local_sym (abfd, sym, sec, rel)
6904 Elf_Internal_Sym *sym;
6906 Elf_Internal_Rela *rel;
6910 relocation = (sec->output_section->vma
6911 + sec->output_offset
6913 if ((sec->flags & SEC_MERGE)
6914 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
6915 && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
6921 _bfd_merged_section_offset (abfd, &msec,
6922 elf_section_data (sec)->sec_info,
6923 sym->st_value + rel->r_addend,
6926 rel->r_addend += msec->output_section->vma + msec->output_offset;
6932 _bfd_elf_rel_local_sym (abfd, sym, psec, addend)
6934 Elf_Internal_Sym *sym;
6938 asection *sec = *psec;
6940 if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE)
6941 return sym->st_value + addend;
6943 return _bfd_merged_section_offset (abfd, psec,
6944 elf_section_data (sec)->sec_info,
6945 sym->st_value + addend, (bfd_vma) 0);
6949 _bfd_elf_section_offset (abfd, info, sec, offset)
6951 struct bfd_link_info *info;
6955 struct bfd_elf_section_data *sec_data;
6957 sec_data = elf_section_data (sec);
6958 switch (sec_data->sec_info_type)
6960 case ELF_INFO_TYPE_STABS:
6961 return _bfd_stab_section_offset
6962 (abfd, &elf_hash_table (info)->merge_info, sec, &sec_data->sec_info,
6964 case ELF_INFO_TYPE_EH_FRAME:
6965 return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);