1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 BFD support for ELF formats is being worked on.
27 Currently, the best supported back ends are for sparc and i386
28 (running svr4 or Solaris 2).
30 Documentation of the internals of the support code still needs
31 to be written. The code is changing quickly enough that we
35 /* For sparc64-cross-sparc32. */
43 #include "libiberty.h"
45 static INLINE struct elf_segment_map *make_mapping
46 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
47 static boolean map_sections_to_segments PARAMS ((bfd *));
48 static int elf_sort_sections PARAMS ((const PTR, const PTR));
49 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
50 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
51 static boolean prep_headers PARAMS ((bfd *));
52 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
53 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
54 static char *elf_read PARAMS ((bfd *, file_ptr, bfd_size_type));
55 static boolean setup_group PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
56 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
57 static void set_group_contents PARAMS ((bfd *, asection *, PTR));
58 static boolean assign_section_numbers PARAMS ((bfd *));
59 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
60 static boolean elf_map_symbols PARAMS ((bfd *));
61 static bfd_size_type get_program_header_size PARAMS ((bfd *));
62 static boolean elfcore_read_notes PARAMS ((bfd *, file_ptr, bfd_size_type));
63 static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
64 bfd_vma, const char **,
66 static int elfcore_make_pid PARAMS ((bfd *));
67 static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
68 static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
69 Elf_Internal_Note *));
70 static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
71 static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
72 static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
74 static boolean elfcore_netbsd_get_lwpid PARAMS ((Elf_Internal_Note *, int *));
75 static boolean elfcore_grok_netbsd_procinfo PARAMS ((bfd *,
76 Elf_Internal_Note *));
77 static boolean elfcore_grok_netbsd_note PARAMS ((bfd *, Elf_Internal_Note *));
79 /* Swap version information in and out. The version information is
80 currently size independent. If that ever changes, this code will
81 need to move into elfcode.h. */
83 /* Swap in a Verdef structure. */
86 _bfd_elf_swap_verdef_in (abfd, src, dst)
88 const Elf_External_Verdef *src;
89 Elf_Internal_Verdef *dst;
91 dst->vd_version = H_GET_16 (abfd, src->vd_version);
92 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
93 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
94 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
95 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
96 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
97 dst->vd_next = H_GET_32 (abfd, src->vd_next);
100 /* Swap out a Verdef structure. */
103 _bfd_elf_swap_verdef_out (abfd, src, dst)
105 const Elf_Internal_Verdef *src;
106 Elf_External_Verdef *dst;
108 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
109 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
110 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
111 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
112 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
113 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
114 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
117 /* Swap in a Verdaux structure. */
120 _bfd_elf_swap_verdaux_in (abfd, src, dst)
122 const Elf_External_Verdaux *src;
123 Elf_Internal_Verdaux *dst;
125 dst->vda_name = H_GET_32 (abfd, src->vda_name);
126 dst->vda_next = H_GET_32 (abfd, src->vda_next);
129 /* Swap out a Verdaux structure. */
132 _bfd_elf_swap_verdaux_out (abfd, src, dst)
134 const Elf_Internal_Verdaux *src;
135 Elf_External_Verdaux *dst;
137 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
138 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
141 /* Swap in a Verneed structure. */
144 _bfd_elf_swap_verneed_in (abfd, src, dst)
146 const Elf_External_Verneed *src;
147 Elf_Internal_Verneed *dst;
149 dst->vn_version = H_GET_16 (abfd, src->vn_version);
150 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
151 dst->vn_file = H_GET_32 (abfd, src->vn_file);
152 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
153 dst->vn_next = H_GET_32 (abfd, src->vn_next);
156 /* Swap out a Verneed structure. */
159 _bfd_elf_swap_verneed_out (abfd, src, dst)
161 const Elf_Internal_Verneed *src;
162 Elf_External_Verneed *dst;
164 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
165 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
166 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
167 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
168 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
171 /* Swap in a Vernaux structure. */
174 _bfd_elf_swap_vernaux_in (abfd, src, dst)
176 const Elf_External_Vernaux *src;
177 Elf_Internal_Vernaux *dst;
179 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
180 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
181 dst->vna_other = H_GET_16 (abfd, src->vna_other);
182 dst->vna_name = H_GET_32 (abfd, src->vna_name);
183 dst->vna_next = H_GET_32 (abfd, src->vna_next);
186 /* Swap out a Vernaux structure. */
189 _bfd_elf_swap_vernaux_out (abfd, src, dst)
191 const Elf_Internal_Vernaux *src;
192 Elf_External_Vernaux *dst;
194 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
195 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
196 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
197 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
198 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
201 /* Swap in a Versym structure. */
204 _bfd_elf_swap_versym_in (abfd, src, dst)
206 const Elf_External_Versym *src;
207 Elf_Internal_Versym *dst;
209 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
212 /* Swap out a Versym structure. */
215 _bfd_elf_swap_versym_out (abfd, src, dst)
217 const Elf_Internal_Versym *src;
218 Elf_External_Versym *dst;
220 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
223 /* Standard ELF hash function. Do not change this function; you will
224 cause invalid hash tables to be generated. */
227 bfd_elf_hash (namearg)
230 const unsigned char *name = (const unsigned char *) namearg;
235 while ((ch = *name++) != '\0')
238 if ((g = (h & 0xf0000000)) != 0)
241 /* The ELF ABI says `h &= ~g', but this is equivalent in
242 this case and on some machines one insn instead of two. */
249 /* Read a specified number of bytes at a specified offset in an ELF
250 file, into a newly allocated buffer, and return a pointer to the
254 elf_read (abfd, offset, size)
261 if ((buf = bfd_alloc (abfd, size)) == NULL)
263 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
265 if (bfd_bread ((PTR) buf, size, abfd) != size)
267 if (bfd_get_error () != bfd_error_system_call)
268 bfd_set_error (bfd_error_file_truncated);
275 bfd_elf_mkobject (abfd)
278 /* This just does initialization. */
279 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
280 bfd_size_type amt = sizeof (struct elf_obj_tdata);
281 elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
282 if (elf_tdata (abfd) == 0)
284 /* Since everything is done at close time, do we need any
291 bfd_elf_mkcorefile (abfd)
294 /* I think this can be done just like an object file. */
295 return bfd_elf_mkobject (abfd);
299 bfd_elf_get_str_section (abfd, shindex)
301 unsigned int shindex;
303 Elf_Internal_Shdr **i_shdrp;
304 char *shstrtab = NULL;
306 bfd_size_type shstrtabsize;
308 i_shdrp = elf_elfsections (abfd);
309 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
312 shstrtab = (char *) i_shdrp[shindex]->contents;
313 if (shstrtab == NULL)
315 /* No cached one, attempt to read, and cache what we read. */
316 offset = i_shdrp[shindex]->sh_offset;
317 shstrtabsize = i_shdrp[shindex]->sh_size;
318 shstrtab = elf_read (abfd, offset, shstrtabsize);
319 i_shdrp[shindex]->contents = (PTR) shstrtab;
325 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
327 unsigned int shindex;
328 unsigned int strindex;
330 Elf_Internal_Shdr *hdr;
335 hdr = elf_elfsections (abfd)[shindex];
337 if (hdr->contents == NULL
338 && bfd_elf_get_str_section (abfd, shindex) == NULL)
341 if (strindex >= hdr->sh_size)
343 (*_bfd_error_handler)
344 (_("%s: invalid string offset %u >= %lu for section `%s'"),
345 bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
346 ((shindex == elf_elfheader(abfd)->e_shstrndx
347 && strindex == hdr->sh_name)
349 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
353 return ((char *) hdr->contents) + strindex;
356 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
357 sections. The first element is the flags, the rest are section
360 typedef union elf_internal_group {
361 Elf_Internal_Shdr *shdr;
363 } Elf_Internal_Group;
365 /* Set next_in_group list pointer, and group name for NEWSECT. */
368 setup_group (abfd, hdr, newsect)
370 Elf_Internal_Shdr *hdr;
373 unsigned int num_group = elf_tdata (abfd)->num_group;
375 /* If num_group is zero, read in all SHT_GROUP sections. The count
376 is set to -1 if there are no SHT_GROUP sections. */
379 unsigned int i, shnum;
381 /* First count the number of groups. If we have a SHT_GROUP
382 section with just a flag word (ie. sh_size is 4), ignore it. */
383 shnum = elf_numsections (abfd);
385 for (i = 0; i < shnum; i++)
387 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
388 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
393 num_group = (unsigned) -1;
394 elf_tdata (abfd)->num_group = num_group;
398 /* We keep a list of elf section headers for group sections,
399 so we can find them quickly. */
400 bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
401 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
402 if (elf_tdata (abfd)->group_sect_ptr == NULL)
406 for (i = 0; i < shnum; i++)
408 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
409 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
412 Elf_Internal_Group *dest;
414 /* Add to list of sections. */
415 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
418 /* Read the raw contents. */
419 BFD_ASSERT (sizeof (*dest) >= 4);
420 amt = shdr->sh_size * sizeof (*dest) / 4;
421 shdr->contents = bfd_alloc (abfd, amt);
422 if (shdr->contents == NULL
423 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
424 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
428 /* Translate raw contents, a flag word followed by an
429 array of elf section indices all in target byte order,
430 to the flag word followed by an array of elf section
432 src = shdr->contents + shdr->sh_size;
433 dest = (Elf_Internal_Group *) (shdr->contents + amt);
440 idx = H_GET_32 (abfd, src);
441 if (src == shdr->contents)
448 ((*_bfd_error_handler)
449 (_("%s: invalid SHT_GROUP entry"),
450 bfd_archive_filename (abfd)));
453 dest->shdr = elf_elfsections (abfd)[idx];
460 if (num_group != (unsigned) -1)
464 for (i = 0; i < num_group; i++)
466 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
467 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
468 unsigned int n_elt = shdr->sh_size / 4;
470 /* Look through this group's sections to see if current
471 section is a member. */
473 if ((++idx)->shdr == hdr)
477 /* We are a member of this group. Go looking through
478 other members to see if any others are linked via
480 idx = (Elf_Internal_Group *) shdr->contents;
481 n_elt = shdr->sh_size / 4;
483 if ((s = (++idx)->shdr->bfd_section) != NULL
484 && elf_next_in_group (s) != NULL)
488 /* Snarf the group name from other member, and
489 insert current section in circular list. */
490 elf_group_name (newsect) = elf_group_name (s);
491 elf_next_in_group (newsect) = elf_next_in_group (s);
492 elf_next_in_group (s) = newsect;
496 struct elf_backend_data *bed;
498 unsigned char ename[4];
502 /* Humbug. Get the name from the group signature
503 symbol. Why isn't the signature just a string?
504 Fortunately, the name index is at the same
505 place in the external symbol for both 32 and 64
507 bed = get_elf_backend_data (abfd);
508 pos = elf_tdata (abfd)->symtab_hdr.sh_offset;
509 pos += shdr->sh_info * bed->s->sizeof_sym;
510 if (bfd_seek (abfd, pos, SEEK_SET) != 0
511 || bfd_bread (ename, (bfd_size_type) 4, abfd) != 4)
513 iname = H_GET_32 (abfd, ename);
514 gname = elf_string_from_elf_strtab (abfd, iname);
515 elf_group_name (newsect) = gname;
517 /* Start a circular list with one element. */
518 elf_next_in_group (newsect) = newsect;
520 if (shdr->bfd_section != NULL)
521 elf_next_in_group (shdr->bfd_section) = newsect;
528 if (elf_group_name (newsect) == NULL)
530 (*_bfd_error_handler) (_("%s: no group info for section %s"),
531 bfd_archive_filename (abfd), newsect->name);
536 /* Make a BFD section from an ELF section. We store a pointer to the
537 BFD section in the bfd_section field of the header. */
540 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
542 Elf_Internal_Shdr *hdr;
547 struct elf_backend_data *bed;
549 if (hdr->bfd_section != NULL)
551 BFD_ASSERT (strcmp (name,
552 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
556 newsect = bfd_make_section_anyway (abfd, name);
560 newsect->filepos = hdr->sh_offset;
562 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
563 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
564 || ! bfd_set_section_alignment (abfd, newsect,
565 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
568 flags = SEC_NO_FLAGS;
569 if (hdr->sh_type != SHT_NOBITS)
570 flags |= SEC_HAS_CONTENTS;
571 if (hdr->sh_type == SHT_GROUP)
572 flags |= SEC_GROUP | SEC_EXCLUDE;
573 if ((hdr->sh_flags & SHF_ALLOC) != 0)
576 if (hdr->sh_type != SHT_NOBITS)
579 if ((hdr->sh_flags & SHF_WRITE) == 0)
580 flags |= SEC_READONLY;
581 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
583 else if ((flags & SEC_LOAD) != 0)
585 if ((hdr->sh_flags & SHF_MERGE) != 0)
588 newsect->entsize = hdr->sh_entsize;
589 if ((hdr->sh_flags & SHF_STRINGS) != 0)
590 flags |= SEC_STRINGS;
592 if (hdr->sh_flags & SHF_GROUP)
593 if (!setup_group (abfd, hdr, newsect))
596 /* The debugging sections appear to be recognized only by name, not
599 static const char *debug_sec_names [] =
608 for (i = ARRAY_SIZE (debug_sec_names); i--;)
609 if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
613 flags |= SEC_DEBUGGING;
616 /* As a GNU extension, if the name begins with .gnu.linkonce, we
617 only link a single copy of the section. This is used to support
618 g++. g++ will emit each template expansion in its own section.
619 The symbols will be defined as weak, so that multiple definitions
620 are permitted. The GNU linker extension is to actually discard
621 all but one of the sections. */
622 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
623 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
625 bed = get_elf_backend_data (abfd);
626 if (bed->elf_backend_section_flags)
627 if (! bed->elf_backend_section_flags (&flags, hdr))
630 if (! bfd_set_section_flags (abfd, newsect, flags))
633 if ((flags & SEC_ALLOC) != 0)
635 Elf_Internal_Phdr *phdr;
638 /* Look through the phdrs to see if we need to adjust the lma.
639 If all the p_paddr fields are zero, we ignore them, since
640 some ELF linkers produce such output. */
641 phdr = elf_tdata (abfd)->phdr;
642 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
644 if (phdr->p_paddr != 0)
647 if (i < elf_elfheader (abfd)->e_phnum)
649 phdr = elf_tdata (abfd)->phdr;
650 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
652 /* This section is part of this segment if its file
653 offset plus size lies within the segment's memory
654 span and, if the section is loaded, the extent of the
655 loaded data lies within the extent of the segment.
656 If the p_paddr field is not set, we don't alter the
658 if (phdr->p_type == PT_LOAD
660 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
661 && (hdr->sh_offset + hdr->sh_size
662 <= phdr->p_offset + phdr->p_memsz)
663 && ((flags & SEC_LOAD) == 0
664 || (phdr->p_offset + phdr->p_filesz
665 >= hdr->sh_offset + hdr->sh_size)))
667 /* We used to do a relative adjustment here, but
668 that doesn't work if the segment is packed with
669 code from multiple VMAs. Instead we calculate
670 the LMA absoultely, based on the LMA of the
671 segment (it is assumed that the segment will
672 contain sections with contiguous LMAs, even if
673 the VMAs are not). */
674 newsect->lma = phdr->p_paddr
675 + hdr->sh_offset - phdr->p_offset;
682 hdr->bfd_section = newsect;
683 elf_section_data (newsect)->this_hdr = *hdr;
693 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
696 Helper functions for GDB to locate the string tables.
697 Since BFD hides string tables from callers, GDB needs to use an
698 internal hook to find them. Sun's .stabstr, in particular,
699 isn't even pointed to by the .stab section, so ordinary
700 mechanisms wouldn't work to find it, even if we had some.
703 struct elf_internal_shdr *
704 bfd_elf_find_section (abfd, name)
708 Elf_Internal_Shdr **i_shdrp;
713 i_shdrp = elf_elfsections (abfd);
716 shstrtab = bfd_elf_get_str_section (abfd,
717 elf_elfheader (abfd)->e_shstrndx);
718 if (shstrtab != NULL)
720 max = elf_numsections (abfd);
721 for (i = 1; i < max; i++)
722 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
729 const char *const bfd_elf_section_type_names[] = {
730 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
731 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
732 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
735 /* ELF relocs are against symbols. If we are producing relocateable
736 output, and the reloc is against an external symbol, and nothing
737 has given us any additional addend, the resulting reloc will also
738 be against the same symbol. In such a case, we don't want to
739 change anything about the way the reloc is handled, since it will
740 all be done at final link time. Rather than put special case code
741 into bfd_perform_relocation, all the reloc types use this howto
742 function. It just short circuits the reloc if producing
743 relocateable output against an external symbol. */
745 bfd_reloc_status_type
746 bfd_elf_generic_reloc (abfd,
753 bfd *abfd ATTRIBUTE_UNUSED;
754 arelent *reloc_entry;
756 PTR data ATTRIBUTE_UNUSED;
757 asection *input_section;
759 char **error_message ATTRIBUTE_UNUSED;
761 if (output_bfd != (bfd *) NULL
762 && (symbol->flags & BSF_SECTION_SYM) == 0
763 && (! reloc_entry->howto->partial_inplace
764 || reloc_entry->addend == 0))
766 reloc_entry->address += input_section->output_offset;
770 return bfd_reloc_continue;
773 /* Finish SHF_MERGE section merging. */
776 _bfd_elf_merge_sections (abfd, info)
778 struct bfd_link_info *info;
780 if (!is_elf_hash_table (info))
782 if (elf_hash_table (info)->merge_info)
783 _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info);
787 /* Print out the program headers. */
790 _bfd_elf_copy_private_bfd_data (ibfd, obfd)
794 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
795 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
798 BFD_ASSERT (!elf_flags_init (obfd)
799 || (elf_elfheader (obfd)->e_flags
800 == elf_elfheader (ibfd)->e_flags));
802 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
803 elf_flags_init (obfd) = true;
808 _bfd_elf_print_private_bfd_data (abfd, farg)
812 FILE *f = (FILE *) farg;
813 Elf_Internal_Phdr *p;
815 bfd_byte *dynbuf = NULL;
817 p = elf_tdata (abfd)->phdr;
822 fprintf (f, _("\nProgram Header:\n"));
823 c = elf_elfheader (abfd)->e_phnum;
824 for (i = 0; i < c; i++, p++)
831 case PT_NULL: pt = "NULL"; break;
832 case PT_LOAD: pt = "LOAD"; break;
833 case PT_DYNAMIC: pt = "DYNAMIC"; break;
834 case PT_INTERP: pt = "INTERP"; break;
835 case PT_NOTE: pt = "NOTE"; break;
836 case PT_SHLIB: pt = "SHLIB"; break;
837 case PT_PHDR: pt = "PHDR"; break;
838 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
839 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
841 fprintf (f, "%8s off 0x", pt);
842 bfd_fprintf_vma (abfd, f, p->p_offset);
843 fprintf (f, " vaddr 0x");
844 bfd_fprintf_vma (abfd, f, p->p_vaddr);
845 fprintf (f, " paddr 0x");
846 bfd_fprintf_vma (abfd, f, p->p_paddr);
847 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
848 fprintf (f, " filesz 0x");
849 bfd_fprintf_vma (abfd, f, p->p_filesz);
850 fprintf (f, " memsz 0x");
851 bfd_fprintf_vma (abfd, f, p->p_memsz);
852 fprintf (f, " flags %c%c%c",
853 (p->p_flags & PF_R) != 0 ? 'r' : '-',
854 (p->p_flags & PF_W) != 0 ? 'w' : '-',
855 (p->p_flags & PF_X) != 0 ? 'x' : '-');
856 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
857 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
862 s = bfd_get_section_by_name (abfd, ".dynamic");
866 unsigned long shlink;
867 bfd_byte *extdyn, *extdynend;
869 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
871 fprintf (f, _("\nDynamic Section:\n"));
873 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
876 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
880 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
883 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
885 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
886 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
889 extdynend = extdyn + s->_raw_size;
890 for (; extdyn < extdynend; extdyn += extdynsize)
892 Elf_Internal_Dyn dyn;
897 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
899 if (dyn.d_tag == DT_NULL)
906 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
910 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
911 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
912 case DT_PLTGOT: name = "PLTGOT"; break;
913 case DT_HASH: name = "HASH"; break;
914 case DT_STRTAB: name = "STRTAB"; break;
915 case DT_SYMTAB: name = "SYMTAB"; break;
916 case DT_RELA: name = "RELA"; break;
917 case DT_RELASZ: name = "RELASZ"; break;
918 case DT_RELAENT: name = "RELAENT"; break;
919 case DT_STRSZ: name = "STRSZ"; break;
920 case DT_SYMENT: name = "SYMENT"; break;
921 case DT_INIT: name = "INIT"; break;
922 case DT_FINI: name = "FINI"; break;
923 case DT_SONAME: name = "SONAME"; stringp = true; break;
924 case DT_RPATH: name = "RPATH"; stringp = true; break;
925 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
926 case DT_REL: name = "REL"; break;
927 case DT_RELSZ: name = "RELSZ"; break;
928 case DT_RELENT: name = "RELENT"; break;
929 case DT_PLTREL: name = "PLTREL"; break;
930 case DT_DEBUG: name = "DEBUG"; break;
931 case DT_TEXTREL: name = "TEXTREL"; break;
932 case DT_JMPREL: name = "JMPREL"; break;
933 case DT_BIND_NOW: name = "BIND_NOW"; break;
934 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
935 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
936 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
937 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
938 case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
939 case DT_FLAGS: name = "FLAGS"; break;
940 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
941 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
942 case DT_CHECKSUM: name = "CHECKSUM"; break;
943 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
944 case DT_MOVEENT: name = "MOVEENT"; break;
945 case DT_MOVESZ: name = "MOVESZ"; break;
946 case DT_FEATURE: name = "FEATURE"; break;
947 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
948 case DT_SYMINSZ: name = "SYMINSZ"; break;
949 case DT_SYMINENT: name = "SYMINENT"; break;
950 case DT_CONFIG: name = "CONFIG"; stringp = true; break;
951 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
952 case DT_AUDIT: name = "AUDIT"; stringp = true; break;
953 case DT_PLTPAD: name = "PLTPAD"; break;
954 case DT_MOVETAB: name = "MOVETAB"; break;
955 case DT_SYMINFO: name = "SYMINFO"; break;
956 case DT_RELACOUNT: name = "RELACOUNT"; break;
957 case DT_RELCOUNT: name = "RELCOUNT"; break;
958 case DT_FLAGS_1: name = "FLAGS_1"; break;
959 case DT_VERSYM: name = "VERSYM"; break;
960 case DT_VERDEF: name = "VERDEF"; break;
961 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
962 case DT_VERNEED: name = "VERNEED"; break;
963 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
964 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
965 case DT_USED: name = "USED"; break;
966 case DT_FILTER: name = "FILTER"; stringp = true; break;
969 fprintf (f, " %-11s ", name);
971 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
975 unsigned int tagv = dyn.d_un.d_val;
977 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
980 fprintf (f, "%s", string);
989 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
990 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
992 if (! _bfd_elf_slurp_version_tables (abfd))
996 if (elf_dynverdef (abfd) != 0)
998 Elf_Internal_Verdef *t;
1000 fprintf (f, _("\nVersion definitions:\n"));
1001 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1003 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1004 t->vd_flags, t->vd_hash, t->vd_nodename);
1005 if (t->vd_auxptr->vda_nextptr != NULL)
1007 Elf_Internal_Verdaux *a;
1010 for (a = t->vd_auxptr->vda_nextptr;
1013 fprintf (f, "%s ", a->vda_nodename);
1019 if (elf_dynverref (abfd) != 0)
1021 Elf_Internal_Verneed *t;
1023 fprintf (f, _("\nVersion References:\n"));
1024 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1026 Elf_Internal_Vernaux *a;
1028 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1029 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1030 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1031 a->vna_flags, a->vna_other, a->vna_nodename);
1043 /* Display ELF-specific fields of a symbol. */
1046 bfd_elf_print_symbol (abfd, filep, symbol, how)
1050 bfd_print_symbol_type how;
1052 FILE *file = (FILE *) filep;
1055 case bfd_print_symbol_name:
1056 fprintf (file, "%s", symbol->name);
1058 case bfd_print_symbol_more:
1059 fprintf (file, "elf ");
1060 bfd_fprintf_vma (abfd, file, symbol->value);
1061 fprintf (file, " %lx", (long) symbol->flags);
1063 case bfd_print_symbol_all:
1065 const char *section_name;
1066 const char *name = NULL;
1067 struct elf_backend_data *bed;
1068 unsigned char st_other;
1071 section_name = symbol->section ? symbol->section->name : "(*none*)";
1073 bed = get_elf_backend_data (abfd);
1074 if (bed->elf_backend_print_symbol_all)
1075 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1079 name = symbol->name;
1080 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
1083 fprintf (file, " %s\t", section_name);
1084 /* Print the "other" value for a symbol. For common symbols,
1085 we've already printed the size; now print the alignment.
1086 For other symbols, we have no specified alignment, and
1087 we've printed the address; now print the size. */
1088 if (bfd_is_com_section (symbol->section))
1089 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1091 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1092 bfd_fprintf_vma (abfd, file, val);
1094 /* If we have version information, print it. */
1095 if (elf_tdata (abfd)->dynversym_section != 0
1096 && (elf_tdata (abfd)->dynverdef_section != 0
1097 || elf_tdata (abfd)->dynverref_section != 0))
1099 unsigned int vernum;
1100 const char *version_string;
1102 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1105 version_string = "";
1106 else if (vernum == 1)
1107 version_string = "Base";
1108 else if (vernum <= elf_tdata (abfd)->cverdefs)
1110 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1113 Elf_Internal_Verneed *t;
1115 version_string = "";
1116 for (t = elf_tdata (abfd)->verref;
1120 Elf_Internal_Vernaux *a;
1122 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1124 if (a->vna_other == vernum)
1126 version_string = a->vna_nodename;
1133 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1134 fprintf (file, " %-11s", version_string);
1139 fprintf (file, " (%s)", version_string);
1140 for (i = 10 - strlen (version_string); i > 0; --i)
1145 /* If the st_other field is not zero, print it. */
1146 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1151 case STV_INTERNAL: fprintf (file, " .internal"); break;
1152 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1153 case STV_PROTECTED: fprintf (file, " .protected"); break;
1155 /* Some other non-defined flags are also present, so print
1157 fprintf (file, " 0x%02x", (unsigned int) st_other);
1160 fprintf (file, " %s", name);
1166 /* Create an entry in an ELF linker hash table. */
1168 struct bfd_hash_entry *
1169 _bfd_elf_link_hash_newfunc (entry, table, string)
1170 struct bfd_hash_entry *entry;
1171 struct bfd_hash_table *table;
1174 /* Allocate the structure if it has not already been allocated by a
1178 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1183 /* Call the allocation method of the superclass. */
1184 entry = _bfd_link_hash_newfunc (entry, table, string);
1187 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1188 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1190 /* Set local fields. */
1194 ret->dynstr_index = 0;
1195 ret->weakdef = NULL;
1196 ret->got.refcount = htab->init_refcount;
1197 ret->plt.refcount = htab->init_refcount;
1198 ret->linker_section_pointer = NULL;
1199 ret->verinfo.verdef = NULL;
1200 ret->vtable_entries_used = NULL;
1201 ret->vtable_entries_size = 0;
1202 ret->vtable_parent = NULL;
1203 ret->type = STT_NOTYPE;
1205 /* Assume that we have been called by a non-ELF symbol reader.
1206 This flag is then reset by the code which reads an ELF input
1207 file. This ensures that a symbol created by a non-ELF symbol
1208 reader will have the flag set correctly. */
1209 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1215 /* Copy data from an indirect symbol to its direct symbol, hiding the
1216 old indirect symbol. Also used for copying flags to a weakdef. */
1219 _bfd_elf_link_hash_copy_indirect (dir, ind)
1220 struct elf_link_hash_entry *dir, *ind;
1224 /* Copy down any references that we may have already seen to the
1225 symbol which just became indirect. */
1227 dir->elf_link_hash_flags |=
1228 (ind->elf_link_hash_flags
1229 & (ELF_LINK_HASH_REF_DYNAMIC
1230 | ELF_LINK_HASH_REF_REGULAR
1231 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1232 | ELF_LINK_NON_GOT_REF));
1234 if (ind->root.type != bfd_link_hash_indirect)
1237 /* Copy over the global and procedure linkage table refcount entries.
1238 These may have been already set up by a check_relocs routine. */
1239 tmp = dir->got.refcount;
1242 dir->got.refcount = ind->got.refcount;
1243 ind->got.refcount = tmp;
1246 BFD_ASSERT (ind->got.refcount <= 0);
1248 tmp = dir->plt.refcount;
1251 dir->plt.refcount = ind->plt.refcount;
1252 ind->plt.refcount = tmp;
1255 BFD_ASSERT (ind->plt.refcount <= 0);
1257 if (dir->dynindx == -1)
1259 dir->dynindx = ind->dynindx;
1260 dir->dynstr_index = ind->dynstr_index;
1262 ind->dynstr_index = 0;
1265 BFD_ASSERT (ind->dynindx == -1);
1269 _bfd_elf_link_hash_hide_symbol (info, h)
1270 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1271 struct elf_link_hash_entry *h;
1273 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1274 h->plt.offset = (bfd_vma) -1;
1275 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
1279 /* Initialize an ELF linker hash table. */
1282 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
1283 struct elf_link_hash_table *table;
1285 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1286 struct bfd_hash_table *,
1291 table->dynamic_sections_created = false;
1292 table->dynobj = NULL;
1293 table->init_refcount = get_elf_backend_data (abfd)->can_refcount - 1;
1294 /* The first dynamic symbol is a dummy. */
1295 table->dynsymcount = 1;
1296 table->dynstr = NULL;
1297 table->bucketcount = 0;
1298 table->needed = NULL;
1299 table->runpath = NULL;
1301 table->stab_info = NULL;
1302 table->merge_info = NULL;
1303 table->dynlocal = NULL;
1304 ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
1305 table->root.type = bfd_link_elf_hash_table;
1310 /* Create an ELF linker hash table. */
1312 struct bfd_link_hash_table *
1313 _bfd_elf_link_hash_table_create (abfd)
1316 struct elf_link_hash_table *ret;
1317 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1319 ret = (struct elf_link_hash_table *) bfd_alloc (abfd, amt);
1320 if (ret == (struct elf_link_hash_table *) NULL)
1323 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1325 bfd_release (abfd, ret);
1332 /* This is a hook for the ELF emulation code in the generic linker to
1333 tell the backend linker what file name to use for the DT_NEEDED
1334 entry for a dynamic object. The generic linker passes name as an
1335 empty string to indicate that no DT_NEEDED entry should be made. */
1338 bfd_elf_set_dt_needed_name (abfd, name)
1342 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1343 && bfd_get_format (abfd) == bfd_object)
1344 elf_dt_name (abfd) = name;
1348 bfd_elf_set_dt_needed_soname (abfd, name)
1352 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1353 && bfd_get_format (abfd) == bfd_object)
1354 elf_dt_soname (abfd) = name;
1357 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1358 the linker ELF emulation code. */
1360 struct bfd_link_needed_list *
1361 bfd_elf_get_needed_list (abfd, info)
1362 bfd *abfd ATTRIBUTE_UNUSED;
1363 struct bfd_link_info *info;
1365 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1367 return elf_hash_table (info)->needed;
1370 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1371 hook for the linker ELF emulation code. */
1373 struct bfd_link_needed_list *
1374 bfd_elf_get_runpath_list (abfd, info)
1375 bfd *abfd ATTRIBUTE_UNUSED;
1376 struct bfd_link_info *info;
1378 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1380 return elf_hash_table (info)->runpath;
1383 /* Get the name actually used for a dynamic object for a link. This
1384 is the SONAME entry if there is one. Otherwise, it is the string
1385 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1388 bfd_elf_get_dt_soname (abfd)
1391 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1392 && bfd_get_format (abfd) == bfd_object)
1393 return elf_dt_name (abfd);
1397 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1398 the ELF linker emulation code. */
1401 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1403 struct bfd_link_needed_list **pneeded;
1406 bfd_byte *dynbuf = NULL;
1408 unsigned long shlink;
1409 bfd_byte *extdyn, *extdynend;
1411 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1415 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1416 || bfd_get_format (abfd) != bfd_object)
1419 s = bfd_get_section_by_name (abfd, ".dynamic");
1420 if (s == NULL || s->_raw_size == 0)
1423 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1427 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1431 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1435 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1437 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1438 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1441 extdynend = extdyn + s->_raw_size;
1442 for (; extdyn < extdynend; extdyn += extdynsize)
1444 Elf_Internal_Dyn dyn;
1446 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1448 if (dyn.d_tag == DT_NULL)
1451 if (dyn.d_tag == DT_NEEDED)
1454 struct bfd_link_needed_list *l;
1455 unsigned int tagv = dyn.d_un.d_val;
1458 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1463 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1484 /* Allocate an ELF string table--force the first byte to be zero. */
1486 struct bfd_strtab_hash *
1487 _bfd_elf_stringtab_init ()
1489 struct bfd_strtab_hash *ret;
1491 ret = _bfd_stringtab_init ();
1496 loc = _bfd_stringtab_add (ret, "", true, false);
1497 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1498 if (loc == (bfd_size_type) -1)
1500 _bfd_stringtab_free (ret);
1507 /* ELF .o/exec file reading */
1509 /* Create a new bfd section from an ELF section header. */
1512 bfd_section_from_shdr (abfd, shindex)
1514 unsigned int shindex;
1516 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1517 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1518 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1521 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1523 switch (hdr->sh_type)
1526 /* Inactive section. Throw it away. */
1529 case SHT_PROGBITS: /* Normal section with contents. */
1530 case SHT_DYNAMIC: /* Dynamic linking information. */
1531 case SHT_NOBITS: /* .bss section. */
1532 case SHT_HASH: /* .hash section. */
1533 case SHT_NOTE: /* .note section. */
1534 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1536 case SHT_SYMTAB: /* A symbol table */
1537 if (elf_onesymtab (abfd) == shindex)
1540 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1541 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1542 elf_onesymtab (abfd) = shindex;
1543 elf_tdata (abfd)->symtab_hdr = *hdr;
1544 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1545 abfd->flags |= HAS_SYMS;
1547 /* Sometimes a shared object will map in the symbol table. If
1548 SHF_ALLOC is set, and this is a shared object, then we also
1549 treat this section as a BFD section. We can not base the
1550 decision purely on SHF_ALLOC, because that flag is sometimes
1551 set in a relocateable object file, which would confuse the
1553 if ((hdr->sh_flags & SHF_ALLOC) != 0
1554 && (abfd->flags & DYNAMIC) != 0
1555 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1560 case SHT_DYNSYM: /* A dynamic symbol table */
1561 if (elf_dynsymtab (abfd) == shindex)
1564 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1565 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1566 elf_dynsymtab (abfd) = shindex;
1567 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1568 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1569 abfd->flags |= HAS_SYMS;
1571 /* Besides being a symbol table, we also treat this as a regular
1572 section, so that objcopy can handle it. */
1573 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1575 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1576 if (elf_symtab_shndx (abfd) == shindex)
1579 /* Get the associated symbol table. */
1580 if (! bfd_section_from_shdr (abfd, hdr->sh_link)
1581 || hdr->sh_link != elf_onesymtab (abfd))
1584 elf_symtab_shndx (abfd) = shindex;
1585 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1586 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1589 case SHT_STRTAB: /* A string table */
1590 if (hdr->bfd_section != NULL)
1592 if (ehdr->e_shstrndx == shindex)
1594 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1595 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1599 unsigned int i, num_sec;
1601 num_sec = elf_numsections (abfd);
1602 for (i = 1; i < num_sec; i++)
1604 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1605 if (hdr2->sh_link == shindex)
1607 if (! bfd_section_from_shdr (abfd, i))
1609 if (elf_onesymtab (abfd) == i)
1611 elf_tdata (abfd)->strtab_hdr = *hdr;
1612 elf_elfsections (abfd)[shindex] =
1613 &elf_tdata (abfd)->strtab_hdr;
1616 if (elf_dynsymtab (abfd) == i)
1618 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1619 elf_elfsections (abfd)[shindex] = hdr =
1620 &elf_tdata (abfd)->dynstrtab_hdr;
1621 /* We also treat this as a regular section, so
1622 that objcopy can handle it. */
1625 #if 0 /* Not handling other string tables specially right now. */
1626 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1627 /* We have a strtab for some random other section. */
1628 newsect = (asection *) hdr2->bfd_section;
1631 hdr->bfd_section = newsect;
1632 hdr2 = &elf_section_data (newsect)->str_hdr;
1634 elf_elfsections (abfd)[shindex] = hdr2;
1640 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1644 /* *These* do a lot of work -- but build no sections! */
1646 asection *target_sect;
1647 Elf_Internal_Shdr *hdr2;
1648 unsigned int num_sec = elf_numsections (abfd);
1650 /* Check for a bogus link to avoid crashing. */
1651 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1652 || hdr->sh_link >= num_sec)
1654 ((*_bfd_error_handler)
1655 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1656 bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1657 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1660 /* For some incomprehensible reason Oracle distributes
1661 libraries for Solaris in which some of the objects have
1662 bogus sh_link fields. It would be nice if we could just
1663 reject them, but, unfortunately, some people need to use
1664 them. We scan through the section headers; if we find only
1665 one suitable symbol table, we clobber the sh_link to point
1666 to it. I hope this doesn't break anything. */
1667 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1668 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1674 for (scan = 1; scan < num_sec; scan++)
1676 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1677 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1688 hdr->sh_link = found;
1691 /* Get the symbol table. */
1692 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1693 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1696 /* If this reloc section does not use the main symbol table we
1697 don't treat it as a reloc section. BFD can't adequately
1698 represent such a section, so at least for now, we don't
1699 try. We just present it as a normal section. We also
1700 can't use it as a reloc section if it points to the null
1702 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1703 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1705 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1707 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1708 if (target_sect == NULL)
1711 if ((target_sect->flags & SEC_RELOC) == 0
1712 || target_sect->reloc_count == 0)
1713 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1717 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1718 amt = sizeof (*hdr2);
1719 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1720 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1723 elf_elfsections (abfd)[shindex] = hdr2;
1724 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1725 target_sect->flags |= SEC_RELOC;
1726 target_sect->relocation = NULL;
1727 target_sect->rel_filepos = hdr->sh_offset;
1728 /* In the section to which the relocations apply, mark whether
1729 its relocations are of the REL or RELA variety. */
1730 if (hdr->sh_size != 0)
1731 elf_section_data (target_sect)->use_rela_p
1732 = (hdr->sh_type == SHT_RELA);
1733 abfd->flags |= HAS_RELOC;
1738 case SHT_GNU_verdef:
1739 elf_dynverdef (abfd) = shindex;
1740 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1741 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1744 case SHT_GNU_versym:
1745 elf_dynversym (abfd) = shindex;
1746 elf_tdata (abfd)->dynversym_hdr = *hdr;
1747 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1750 case SHT_GNU_verneed:
1751 elf_dynverref (abfd) = shindex;
1752 elf_tdata (abfd)->dynverref_hdr = *hdr;
1753 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1760 /* Make a section for objcopy and relocatable links. */
1761 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
1763 if (hdr->contents != NULL)
1765 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1766 unsigned int n_elt = hdr->sh_size / 4;
1769 while (--n_elt != 0)
1770 if ((s = (++idx)->shdr->bfd_section) != NULL
1771 && elf_next_in_group (s) != NULL)
1773 elf_next_in_group (hdr->bfd_section) = s;
1780 /* Check for any processor-specific section types. */
1782 if (bed->elf_backend_section_from_shdr)
1783 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1791 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1792 Return SEC for sections that have no elf section, and NULL on error. */
1795 bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
1797 struct sym_sec_cache *cache;
1799 unsigned long r_symndx;
1801 unsigned char esym_shndx[4];
1802 unsigned int isym_shndx;
1803 Elf_Internal_Shdr *symtab_hdr;
1806 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1808 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
1809 return cache->sec[ent];
1811 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1812 pos = symtab_hdr->sh_offset;
1813 if (get_elf_backend_data (abfd)->s->sizeof_sym
1814 == sizeof (Elf64_External_Sym))
1816 pos += r_symndx * sizeof (Elf64_External_Sym);
1817 pos += offsetof (Elf64_External_Sym, st_shndx);
1818 amt = sizeof (((Elf64_External_Sym *) 0)->st_shndx);
1822 pos += r_symndx * sizeof (Elf32_External_Sym);
1823 pos += offsetof (Elf32_External_Sym, st_shndx);
1824 amt = sizeof (((Elf32_External_Sym *) 0)->st_shndx);
1826 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1827 || bfd_bread ((PTR) esym_shndx, amt, abfd) != amt)
1829 isym_shndx = H_GET_16 (abfd, esym_shndx);
1831 if (isym_shndx == SHN_XINDEX)
1833 Elf_Internal_Shdr *shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1834 if (shndx_hdr->sh_size != 0)
1836 pos = shndx_hdr->sh_offset;
1837 pos += r_symndx * sizeof (Elf_External_Sym_Shndx);
1838 amt = sizeof (Elf_External_Sym_Shndx);
1839 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1840 || bfd_bread ((PTR) esym_shndx, amt, abfd) != amt)
1842 isym_shndx = H_GET_32 (abfd, esym_shndx);
1846 if (cache->abfd != abfd)
1848 memset (cache->indx, -1, sizeof (cache->indx));
1851 cache->indx[ent] = r_symndx;
1852 cache->sec[ent] = sec;
1853 if (isym_shndx < SHN_LORESERVE || isym_shndx > SHN_HIRESERVE)
1856 s = bfd_section_from_elf_index (abfd, isym_shndx);
1858 cache->sec[ent] = s;
1860 return cache->sec[ent];
1863 /* Given an ELF section number, retrieve the corresponding BFD
1867 bfd_section_from_elf_index (abfd, index)
1871 if (index >= elf_numsections (abfd))
1873 return elf_elfsections (abfd)[index]->bfd_section;
1877 _bfd_elf_new_section_hook (abfd, sec)
1881 struct bfd_elf_section_data *sdata;
1882 bfd_size_type amt = sizeof (*sdata);
1884 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
1887 sec->used_by_bfd = (PTR) sdata;
1889 /* Indicate whether or not this section should use RELA relocations. */
1891 = get_elf_backend_data (abfd)->default_use_rela_p;
1896 /* Create a new bfd section from an ELF program header.
1898 Since program segments have no names, we generate a synthetic name
1899 of the form segment<NUM>, where NUM is generally the index in the
1900 program header table. For segments that are split (see below) we
1901 generate the names segment<NUM>a and segment<NUM>b.
1903 Note that some program segments may have a file size that is different than
1904 (less than) the memory size. All this means is that at execution the
1905 system must allocate the amount of memory specified by the memory size,
1906 but only initialize it with the first "file size" bytes read from the
1907 file. This would occur for example, with program segments consisting
1908 of combined data+bss.
1910 To handle the above situation, this routine generates TWO bfd sections
1911 for the single program segment. The first has the length specified by
1912 the file size of the segment, and the second has the length specified
1913 by the difference between the two sizes. In effect, the segment is split
1914 into it's initialized and uninitialized parts.
1919 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1921 Elf_Internal_Phdr *hdr;
1923 const char *typename;
1930 split = ((hdr->p_memsz > 0)
1931 && (hdr->p_filesz > 0)
1932 && (hdr->p_memsz > hdr->p_filesz));
1933 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1934 name = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
1937 strcpy (name, namebuf);
1938 newsect = bfd_make_section (abfd, name);
1939 if (newsect == NULL)
1941 newsect->vma = hdr->p_vaddr;
1942 newsect->lma = hdr->p_paddr;
1943 newsect->_raw_size = hdr->p_filesz;
1944 newsect->filepos = hdr->p_offset;
1945 newsect->flags |= SEC_HAS_CONTENTS;
1946 if (hdr->p_type == PT_LOAD)
1948 newsect->flags |= SEC_ALLOC;
1949 newsect->flags |= SEC_LOAD;
1950 if (hdr->p_flags & PF_X)
1952 /* FIXME: all we known is that it has execute PERMISSION,
1954 newsect->flags |= SEC_CODE;
1957 if (!(hdr->p_flags & PF_W))
1959 newsect->flags |= SEC_READONLY;
1964 sprintf (namebuf, "%s%db", typename, index);
1965 name = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1);
1968 strcpy (name, namebuf);
1969 newsect = bfd_make_section (abfd, name);
1970 if (newsect == NULL)
1972 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1973 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1974 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1975 if (hdr->p_type == PT_LOAD)
1977 newsect->flags |= SEC_ALLOC;
1978 if (hdr->p_flags & PF_X)
1979 newsect->flags |= SEC_CODE;
1981 if (!(hdr->p_flags & PF_W))
1982 newsect->flags |= SEC_READONLY;
1989 bfd_section_from_phdr (abfd, hdr, index)
1991 Elf_Internal_Phdr *hdr;
1994 struct elf_backend_data *bed;
1996 switch (hdr->p_type)
1999 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2002 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2005 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2008 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2011 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2013 if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
2018 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2021 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2024 /* Check for any processor-specific program segment types.
2025 If no handler for them, default to making "segment" sections. */
2026 bed = get_elf_backend_data (abfd);
2027 if (bed->elf_backend_section_from_phdr)
2028 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2030 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2034 /* Initialize REL_HDR, the section-header for new section, containing
2035 relocations against ASECT. If USE_RELA_P is true, we use RELA
2036 relocations; otherwise, we use REL relocations. */
2039 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
2041 Elf_Internal_Shdr *rel_hdr;
2046 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2047 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2049 name = bfd_alloc (abfd, amt);
2052 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2054 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2056 if (rel_hdr->sh_name == (unsigned int) -1)
2058 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2059 rel_hdr->sh_entsize = (use_rela_p
2060 ? bed->s->sizeof_rela
2061 : bed->s->sizeof_rel);
2062 rel_hdr->sh_addralign = bed->s->file_align;
2063 rel_hdr->sh_flags = 0;
2064 rel_hdr->sh_addr = 0;
2065 rel_hdr->sh_size = 0;
2066 rel_hdr->sh_offset = 0;
2071 /* Set up an ELF internal section header for a section. */
2074 elf_fake_sections (abfd, asect, failedptrarg)
2079 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2080 boolean *failedptr = (boolean *) failedptrarg;
2081 Elf_Internal_Shdr *this_hdr;
2085 /* We already failed; just get out of the bfd_map_over_sections
2090 this_hdr = &elf_section_data (asect)->this_hdr;
2092 this_hdr->sh_name = (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2093 asect->name, false);
2094 if (this_hdr->sh_name == (unsigned long) -1)
2100 this_hdr->sh_flags = 0;
2102 if ((asect->flags & SEC_ALLOC) != 0
2103 || asect->user_set_vma)
2104 this_hdr->sh_addr = asect->vma;
2106 this_hdr->sh_addr = 0;
2108 this_hdr->sh_offset = 0;
2109 this_hdr->sh_size = asect->_raw_size;
2110 this_hdr->sh_link = 0;
2111 this_hdr->sh_addralign = 1 << asect->alignment_power;
2112 /* The sh_entsize and sh_info fields may have been set already by
2113 copy_private_section_data. */
2115 this_hdr->bfd_section = asect;
2116 this_hdr->contents = NULL;
2118 /* FIXME: This should not be based on section names. */
2119 if (strcmp (asect->name, ".dynstr") == 0)
2120 this_hdr->sh_type = SHT_STRTAB;
2121 else if (strcmp (asect->name, ".hash") == 0)
2123 this_hdr->sh_type = SHT_HASH;
2124 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2126 else if (strcmp (asect->name, ".dynsym") == 0)
2128 this_hdr->sh_type = SHT_DYNSYM;
2129 this_hdr->sh_entsize = bed->s->sizeof_sym;
2131 else if (strcmp (asect->name, ".dynamic") == 0)
2133 this_hdr->sh_type = SHT_DYNAMIC;
2134 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2136 else if (strncmp (asect->name, ".rela", 5) == 0
2137 && get_elf_backend_data (abfd)->may_use_rela_p)
2139 this_hdr->sh_type = SHT_RELA;
2140 this_hdr->sh_entsize = bed->s->sizeof_rela;
2142 else if (strncmp (asect->name, ".rel", 4) == 0
2143 && get_elf_backend_data (abfd)->may_use_rel_p)
2145 this_hdr->sh_type = SHT_REL;
2146 this_hdr->sh_entsize = bed->s->sizeof_rel;
2148 else if (strncmp (asect->name, ".note", 5) == 0)
2149 this_hdr->sh_type = SHT_NOTE;
2150 else if (strncmp (asect->name, ".stab", 5) == 0
2151 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
2152 this_hdr->sh_type = SHT_STRTAB;
2153 else if (strcmp (asect->name, ".gnu.version") == 0)
2155 this_hdr->sh_type = SHT_GNU_versym;
2156 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2158 else if (strcmp (asect->name, ".gnu.version_d") == 0)
2160 this_hdr->sh_type = SHT_GNU_verdef;
2161 this_hdr->sh_entsize = 0;
2162 /* objcopy or strip will copy over sh_info, but may not set
2163 cverdefs. The linker will set cverdefs, but sh_info will be
2165 if (this_hdr->sh_info == 0)
2166 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2168 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2169 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2171 else if (strcmp (asect->name, ".gnu.version_r") == 0)
2173 this_hdr->sh_type = SHT_GNU_verneed;
2174 this_hdr->sh_entsize = 0;
2175 /* objcopy or strip will copy over sh_info, but may not set
2176 cverrefs. The linker will set cverrefs, but sh_info will be
2178 if (this_hdr->sh_info == 0)
2179 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2181 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2182 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2184 else if ((asect->flags & SEC_GROUP) != 0)
2186 this_hdr->sh_type = SHT_GROUP;
2187 this_hdr->sh_entsize = 4;
2189 else if ((asect->flags & SEC_ALLOC) != 0
2190 && ((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0))
2191 this_hdr->sh_type = SHT_NOBITS;
2193 this_hdr->sh_type = SHT_PROGBITS;
2195 if ((asect->flags & SEC_ALLOC) != 0)
2196 this_hdr->sh_flags |= SHF_ALLOC;
2197 if ((asect->flags & SEC_READONLY) == 0)
2198 this_hdr->sh_flags |= SHF_WRITE;
2199 if ((asect->flags & SEC_CODE) != 0)
2200 this_hdr->sh_flags |= SHF_EXECINSTR;
2201 if ((asect->flags & SEC_MERGE) != 0)
2203 this_hdr->sh_flags |= SHF_MERGE;
2204 this_hdr->sh_entsize = asect->entsize;
2205 if ((asect->flags & SEC_STRINGS) != 0)
2206 this_hdr->sh_flags |= SHF_STRINGS;
2208 if (elf_group_name (asect) != NULL)
2209 this_hdr->sh_flags |= SHF_GROUP;
2211 /* Check for processor-specific section types. */
2212 if (bed->elf_backend_fake_sections)
2213 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
2215 /* If the section has relocs, set up a section header for the
2216 SHT_REL[A] section. If two relocation sections are required for
2217 this section, it is up to the processor-specific back-end to
2218 create the other. */
2219 if ((asect->flags & SEC_RELOC) != 0
2220 && !_bfd_elf_init_reloc_shdr (abfd,
2221 &elf_section_data (asect)->rel_hdr,
2223 elf_section_data (asect)->use_rela_p))
2227 /* Fill in the contents of a SHT_GROUP section. */
2230 set_group_contents (abfd, sec, failedptrarg)
2233 PTR failedptrarg ATTRIBUTE_UNUSED;
2235 boolean *failedptr = (boolean *) failedptrarg;
2236 unsigned long symindx;
2239 struct bfd_link_order *l;
2241 if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2245 /* If called from the assembler, swap_out_syms will have set up
2246 elf_section_syms; If called for "ld -r", the symbols won't yet
2247 be mapped, so emulate elf_bfd_final_link. */
2248 if (elf_section_syms (abfd) != NULL)
2249 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2251 symindx = elf_section_data (sec)->this_idx;
2252 elf_section_data (sec)->this_hdr.sh_info = symindx;
2254 /* Nor will the contents be allocated for "ld -r". */
2255 if (sec->contents == NULL)
2257 sec->contents = bfd_alloc (abfd, sec->_raw_size);
2258 if (sec->contents == NULL)
2265 loc = sec->contents + sec->_raw_size;
2267 /* Get the pointer to the first section in the group that we
2268 squirreled away here. */
2269 elt = elf_next_in_group (sec);
2271 /* First element is a flag word. Rest of section is elf section
2272 indices for all the sections of the group. Write them backwards
2273 just to keep the group in the same order as given in .section
2274 directives, not that it matters. */
2278 H_PUT_32 (abfd, elf_section_data (elt)->this_idx, loc);
2279 elt = elf_next_in_group (elt);
2282 /* If this is a relocatable link, then the above did nothing because
2283 SEC is the output section. Look through the input sections
2285 for (l = sec->link_order_head; l != NULL; l = l->next)
2286 if (l->type == bfd_indirect_link_order
2287 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2292 elf_section_data (elt->output_section)->this_idx, loc);
2293 elt = elf_next_in_group (elt);
2294 /* During a relocatable link, the lists are circular. */
2296 while (elt != elf_next_in_group (l->u.indirect.section));
2299 H_PUT_32 (abfd, 0, loc);
2301 BFD_ASSERT (loc == sec->contents);
2304 /* Assign all ELF section numbers. The dummy first section is handled here
2305 too. The link/info pointers for the standard section types are filled
2306 in here too, while we're at it. */
2309 assign_section_numbers (abfd)
2312 struct elf_obj_tdata *t = elf_tdata (abfd);
2314 unsigned int section_number, secn;
2315 Elf_Internal_Shdr **i_shdrp;
2320 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2322 for (sec = abfd->sections; sec; sec = sec->next)
2324 struct bfd_elf_section_data *d = elf_section_data (sec);
2326 if (section_number == SHN_LORESERVE)
2327 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2328 d->this_idx = section_number++;
2329 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2330 if ((sec->flags & SEC_RELOC) == 0)
2334 if (section_number == SHN_LORESERVE)
2335 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2336 d->rel_idx = section_number++;
2337 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2342 if (section_number == SHN_LORESERVE)
2343 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2344 d->rel_idx2 = section_number++;
2345 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2351 if (section_number == SHN_LORESERVE)
2352 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2353 t->shstrtab_section = section_number++;
2354 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2355 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2357 if (bfd_get_symcount (abfd) > 0)
2359 if (section_number == SHN_LORESERVE)
2360 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2361 t->symtab_section = section_number++;
2362 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2363 if (section_number > SHN_LORESERVE - 2)
2365 if (section_number == SHN_LORESERVE)
2366 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2367 t->symtab_shndx_section = section_number++;
2368 t->symtab_shndx_hdr.sh_name
2369 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2370 ".symtab_shndx", false);
2371 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2374 if (section_number == SHN_LORESERVE)
2375 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2376 t->strtab_section = section_number++;
2377 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2380 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2381 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2383 elf_numsections (abfd) = section_number;
2384 elf_elfheader (abfd)->e_shnum = section_number;
2385 if (section_number > SHN_LORESERVE)
2386 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2388 /* Set up the list of section header pointers, in agreement with the
2390 amt = section_number * sizeof (Elf_Internal_Shdr *);
2391 i_shdrp = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
2392 if (i_shdrp == NULL)
2395 amt = sizeof (Elf_Internal_Shdr);
2396 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
2397 if (i_shdrp[0] == NULL)
2399 bfd_release (abfd, i_shdrp);
2402 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
2404 elf_elfsections (abfd) = i_shdrp;
2406 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2407 if (bfd_get_symcount (abfd) > 0)
2409 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2410 if (elf_numsections (abfd) > SHN_LORESERVE)
2412 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2413 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2415 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2416 t->symtab_hdr.sh_link = t->strtab_section;
2418 for (sec = abfd->sections; sec; sec = sec->next)
2420 struct bfd_elf_section_data *d = elf_section_data (sec);
2424 i_shdrp[d->this_idx] = &d->this_hdr;
2425 if (d->rel_idx != 0)
2426 i_shdrp[d->rel_idx] = &d->rel_hdr;
2427 if (d->rel_idx2 != 0)
2428 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2430 /* Fill in the sh_link and sh_info fields while we're at it. */
2432 /* sh_link of a reloc section is the section index of the symbol
2433 table. sh_info is the section index of the section to which
2434 the relocation entries apply. */
2435 if (d->rel_idx != 0)
2437 d->rel_hdr.sh_link = t->symtab_section;
2438 d->rel_hdr.sh_info = d->this_idx;
2440 if (d->rel_idx2 != 0)
2442 d->rel_hdr2->sh_link = t->symtab_section;
2443 d->rel_hdr2->sh_info = d->this_idx;
2446 switch (d->this_hdr.sh_type)
2450 /* A reloc section which we are treating as a normal BFD
2451 section. sh_link is the section index of the symbol
2452 table. sh_info is the section index of the section to
2453 which the relocation entries apply. We assume that an
2454 allocated reloc section uses the dynamic symbol table.
2455 FIXME: How can we be sure? */
2456 s = bfd_get_section_by_name (abfd, ".dynsym");
2458 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2460 /* We look up the section the relocs apply to by name. */
2462 if (d->this_hdr.sh_type == SHT_REL)
2466 s = bfd_get_section_by_name (abfd, name);
2468 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2472 /* We assume that a section named .stab*str is a stabs
2473 string section. We look for a section with the same name
2474 but without the trailing ``str'', and set its sh_link
2475 field to point to this section. */
2476 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2477 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2482 len = strlen (sec->name);
2483 alc = (char *) bfd_malloc ((bfd_size_type) len - 2);
2486 strncpy (alc, sec->name, len - 3);
2487 alc[len - 3] = '\0';
2488 s = bfd_get_section_by_name (abfd, alc);
2492 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2494 /* This is a .stab section. */
2495 elf_section_data (s)->this_hdr.sh_entsize =
2496 4 + 2 * bfd_get_arch_size (abfd) / 8;
2503 case SHT_GNU_verneed:
2504 case SHT_GNU_verdef:
2505 /* sh_link is the section header index of the string table
2506 used for the dynamic entries, or the symbol table, or the
2508 s = bfd_get_section_by_name (abfd, ".dynstr");
2510 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2514 case SHT_GNU_versym:
2515 /* sh_link is the section header index of the symbol table
2516 this hash table or version table is for. */
2517 s = bfd_get_section_by_name (abfd, ".dynsym");
2519 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2523 d->this_hdr.sh_link = t->symtab_section;
2527 for (secn = 1; secn < section_number; ++secn)
2528 if (i_shdrp[secn] == NULL)
2529 i_shdrp[secn] = i_shdrp[0];
2531 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2532 i_shdrp[secn]->sh_name);
2536 /* Map symbol from it's internal number to the external number, moving
2537 all local symbols to be at the head of the list. */
2540 sym_is_global (abfd, sym)
2544 /* If the backend has a special mapping, use it. */
2545 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2546 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2549 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2550 || bfd_is_und_section (bfd_get_section (sym))
2551 || bfd_is_com_section (bfd_get_section (sym)));
2555 elf_map_symbols (abfd)
2558 unsigned int symcount = bfd_get_symcount (abfd);
2559 asymbol **syms = bfd_get_outsymbols (abfd);
2560 asymbol **sect_syms;
2561 unsigned int num_locals = 0;
2562 unsigned int num_globals = 0;
2563 unsigned int num_locals2 = 0;
2564 unsigned int num_globals2 = 0;
2572 fprintf (stderr, "elf_map_symbols\n");
2576 for (asect = abfd->sections; asect; asect = asect->next)
2578 if (max_index < asect->index)
2579 max_index = asect->index;
2583 amt = max_index * sizeof (asymbol *);
2584 sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
2585 if (sect_syms == NULL)
2587 elf_section_syms (abfd) = sect_syms;
2588 elf_num_section_syms (abfd) = max_index;
2590 /* Init sect_syms entries for any section symbols we have already
2591 decided to output. */
2592 for (idx = 0; idx < symcount; idx++)
2594 asymbol *sym = syms[idx];
2596 if ((sym->flags & BSF_SECTION_SYM) != 0
2603 if (sec->owner != NULL)
2605 if (sec->owner != abfd)
2607 if (sec->output_offset != 0)
2610 sec = sec->output_section;
2612 /* Empty sections in the input files may have had a
2613 section symbol created for them. (See the comment
2614 near the end of _bfd_generic_link_output_symbols in
2615 linker.c). If the linker script discards such
2616 sections then we will reach this point. Since we know
2617 that we cannot avoid this case, we detect it and skip
2618 the abort and the assignment to the sect_syms array.
2619 To reproduce this particular case try running the
2620 linker testsuite test ld-scripts/weak.exp for an ELF
2621 port that uses the generic linker. */
2622 if (sec->owner == NULL)
2625 BFD_ASSERT (sec->owner == abfd);
2627 sect_syms[sec->index] = syms[idx];
2632 /* Classify all of the symbols. */
2633 for (idx = 0; idx < symcount; idx++)
2635 if (!sym_is_global (abfd, syms[idx]))
2641 /* We will be adding a section symbol for each BFD section. Most normal
2642 sections will already have a section symbol in outsymbols, but
2643 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2644 at least in that case. */
2645 for (asect = abfd->sections; asect; asect = asect->next)
2647 if (sect_syms[asect->index] == NULL)
2649 if (!sym_is_global (abfd, asect->symbol))
2656 /* Now sort the symbols so the local symbols are first. */
2657 amt = (num_locals + num_globals) * sizeof (asymbol *);
2658 new_syms = (asymbol **) bfd_alloc (abfd, amt);
2660 if (new_syms == NULL)
2663 for (idx = 0; idx < symcount; idx++)
2665 asymbol *sym = syms[idx];
2668 if (!sym_is_global (abfd, sym))
2671 i = num_locals + num_globals2++;
2673 sym->udata.i = i + 1;
2675 for (asect = abfd->sections; asect; asect = asect->next)
2677 if (sect_syms[asect->index] == NULL)
2679 asymbol *sym = asect->symbol;
2682 sect_syms[asect->index] = sym;
2683 if (!sym_is_global (abfd, sym))
2686 i = num_locals + num_globals2++;
2688 sym->udata.i = i + 1;
2692 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2694 elf_num_locals (abfd) = num_locals;
2695 elf_num_globals (abfd) = num_globals;
2699 /* Align to the maximum file alignment that could be required for any
2700 ELF data structure. */
2702 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2703 static INLINE file_ptr
2704 align_file_position (off, align)
2708 return (off + align - 1) & ~(align - 1);
2711 /* Assign a file position to a section, optionally aligning to the
2712 required section alignment. */
2715 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2716 Elf_Internal_Shdr *i_shdrp;
2724 al = i_shdrp->sh_addralign;
2726 offset = BFD_ALIGN (offset, al);
2728 i_shdrp->sh_offset = offset;
2729 if (i_shdrp->bfd_section != NULL)
2730 i_shdrp->bfd_section->filepos = offset;
2731 if (i_shdrp->sh_type != SHT_NOBITS)
2732 offset += i_shdrp->sh_size;
2736 /* Compute the file positions we are going to put the sections at, and
2737 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2738 is not NULL, this is being called by the ELF backend linker. */
2741 _bfd_elf_compute_section_file_positions (abfd, link_info)
2743 struct bfd_link_info *link_info;
2745 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2747 struct bfd_strtab_hash *strtab;
2748 Elf_Internal_Shdr *shstrtab_hdr;
2750 if (abfd->output_has_begun)
2753 /* Do any elf backend specific processing first. */
2754 if (bed->elf_backend_begin_write_processing)
2755 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2757 if (! prep_headers (abfd))
2760 /* Post process the headers if necessary. */
2761 if (bed->elf_backend_post_process_headers)
2762 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2765 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2769 if (!assign_section_numbers (abfd))
2772 /* The backend linker builds symbol table information itself. */
2773 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2775 /* Non-zero if doing a relocatable link. */
2776 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2778 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2782 if (link_info == NULL || link_info->relocateable)
2784 bfd_map_over_sections (abfd, set_group_contents, &failed);
2789 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2790 /* sh_name was set in prep_headers. */
2791 shstrtab_hdr->sh_type = SHT_STRTAB;
2792 shstrtab_hdr->sh_flags = 0;
2793 shstrtab_hdr->sh_addr = 0;
2794 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2795 shstrtab_hdr->sh_entsize = 0;
2796 shstrtab_hdr->sh_link = 0;
2797 shstrtab_hdr->sh_info = 0;
2798 /* sh_offset is set in assign_file_positions_except_relocs. */
2799 shstrtab_hdr->sh_addralign = 1;
2801 if (!assign_file_positions_except_relocs (abfd))
2804 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2807 Elf_Internal_Shdr *hdr;
2809 off = elf_tdata (abfd)->next_file_pos;
2811 hdr = &elf_tdata (abfd)->symtab_hdr;
2812 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2814 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2815 if (hdr->sh_size != 0)
2816 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2818 hdr = &elf_tdata (abfd)->strtab_hdr;
2819 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2821 elf_tdata (abfd)->next_file_pos = off;
2823 /* Now that we know where the .strtab section goes, write it
2825 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2826 || ! _bfd_stringtab_emit (abfd, strtab))
2828 _bfd_stringtab_free (strtab);
2831 abfd->output_has_begun = true;
2836 /* Create a mapping from a set of sections to a program segment. */
2838 static INLINE struct elf_segment_map *
2839 make_mapping (abfd, sections, from, to, phdr)
2841 asection **sections;
2846 struct elf_segment_map *m;
2851 amt = sizeof (struct elf_segment_map);
2852 amt += (to - from - 1) * sizeof (asection *);
2853 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2857 m->p_type = PT_LOAD;
2858 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2859 m->sections[i - from] = *hdrpp;
2860 m->count = to - from;
2862 if (from == 0 && phdr)
2864 /* Include the headers in the first PT_LOAD segment. */
2865 m->includes_filehdr = 1;
2866 m->includes_phdrs = 1;
2872 /* Set up a mapping from BFD sections to program segments. */
2875 map_sections_to_segments (abfd)
2878 asection **sections = NULL;
2882 struct elf_segment_map *mfirst;
2883 struct elf_segment_map **pm;
2884 struct elf_segment_map *m;
2886 unsigned int phdr_index;
2887 bfd_vma maxpagesize;
2889 boolean phdr_in_segment = true;
2891 asection *dynsec, *eh_frame_hdr;
2894 if (elf_tdata (abfd)->segment_map != NULL)
2897 if (bfd_count_sections (abfd) == 0)
2900 /* Select the allocated sections, and sort them. */
2902 amt = bfd_count_sections (abfd) * sizeof (asection *);
2903 sections = (asection **) bfd_malloc (amt);
2904 if (sections == NULL)
2908 for (s = abfd->sections; s != NULL; s = s->next)
2910 if ((s->flags & SEC_ALLOC) != 0)
2916 BFD_ASSERT (i <= bfd_count_sections (abfd));
2919 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2921 /* Build the mapping. */
2926 /* If we have a .interp section, then create a PT_PHDR segment for
2927 the program headers and a PT_INTERP segment for the .interp
2929 s = bfd_get_section_by_name (abfd, ".interp");
2930 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2932 amt = sizeof (struct elf_segment_map);
2933 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2937 m->p_type = PT_PHDR;
2938 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2939 m->p_flags = PF_R | PF_X;
2940 m->p_flags_valid = 1;
2941 m->includes_phdrs = 1;
2946 amt = sizeof (struct elf_segment_map);
2947 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
2951 m->p_type = PT_INTERP;
2959 /* Look through the sections. We put sections in the same program
2960 segment when the start of the second section can be placed within
2961 a few bytes of the end of the first section. */
2964 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2966 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2968 && (dynsec->flags & SEC_LOAD) == 0)
2971 /* Deal with -Ttext or something similar such that the first section
2972 is not adjacent to the program headers. This is an
2973 approximation, since at this point we don't know exactly how many
2974 program headers we will need. */
2977 bfd_size_type phdr_size;
2979 phdr_size = elf_tdata (abfd)->program_header_size;
2981 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2982 if ((abfd->flags & D_PAGED) == 0
2983 || sections[0]->lma < phdr_size
2984 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2985 phdr_in_segment = false;
2988 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2991 boolean new_segment;
2995 /* See if this section and the last one will fit in the same
2998 if (last_hdr == NULL)
3000 /* If we don't have a segment yet, then we don't need a new
3001 one (we build the last one after this loop). */
3002 new_segment = false;
3004 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3006 /* If this section has a different relation between the
3007 virtual address and the load address, then we need a new
3011 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3012 < BFD_ALIGN (hdr->lma, maxpagesize))
3014 /* If putting this section in this segment would force us to
3015 skip a page in the segment, then we need a new segment. */
3018 else if ((last_hdr->flags & SEC_LOAD) == 0
3019 && (hdr->flags & SEC_LOAD) != 0)
3021 /* We don't want to put a loadable section after a
3022 nonloadable section in the same segment. */
3025 else if ((abfd->flags & D_PAGED) == 0)
3027 /* If the file is not demand paged, which means that we
3028 don't require the sections to be correctly aligned in the
3029 file, then there is no other reason for a new segment. */
3030 new_segment = false;
3033 && (hdr->flags & SEC_READONLY) == 0
3034 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3037 /* We don't want to put a writable section in a read only
3038 segment, unless they are on the same page in memory
3039 anyhow. We already know that the last section does not
3040 bring us past the current section on the page, so the
3041 only case in which the new section is not on the same
3042 page as the previous section is when the previous section
3043 ends precisely on a page boundary. */
3048 /* Otherwise, we can use the same segment. */
3049 new_segment = false;
3054 if ((hdr->flags & SEC_READONLY) == 0)
3060 /* We need a new program segment. We must create a new program
3061 header holding all the sections from phdr_index until hdr. */
3063 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3070 if ((hdr->flags & SEC_READONLY) == 0)
3077 phdr_in_segment = false;
3080 /* Create a final PT_LOAD program segment. */
3081 if (last_hdr != NULL)
3083 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3091 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3094 amt = sizeof (struct elf_segment_map);
3095 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3099 m->p_type = PT_DYNAMIC;
3101 m->sections[0] = dynsec;
3107 /* For each loadable .note section, add a PT_NOTE segment. We don't
3108 use bfd_get_section_by_name, because if we link together
3109 nonloadable .note sections and loadable .note sections, we will
3110 generate two .note sections in the output file. FIXME: Using
3111 names for section types is bogus anyhow. */
3112 for (s = abfd->sections; s != NULL; s = s->next)
3114 if ((s->flags & SEC_LOAD) != 0
3115 && strncmp (s->name, ".note", 5) == 0)
3117 amt = sizeof (struct elf_segment_map);
3118 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3122 m->p_type = PT_NOTE;
3131 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3133 eh_frame_hdr = NULL;
3134 if (elf_tdata (abfd)->eh_frame_hdr)
3135 eh_frame_hdr = bfd_get_section_by_name (abfd, ".eh_frame_hdr");
3136 if (eh_frame_hdr != NULL && (eh_frame_hdr->flags & SEC_LOAD))
3138 amt = sizeof (struct elf_segment_map);
3139 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3143 m->p_type = PT_GNU_EH_FRAME;
3145 m->sections[0] = eh_frame_hdr;
3154 elf_tdata (abfd)->segment_map = mfirst;
3158 if (sections != NULL)
3163 /* Sort sections by address. */
3166 elf_sort_sections (arg1, arg2)
3170 const asection *sec1 = *(const asection **) arg1;
3171 const asection *sec2 = *(const asection **) arg2;
3173 /* Sort by LMA first, since this is the address used to
3174 place the section into a segment. */
3175 if (sec1->lma < sec2->lma)
3177 else if (sec1->lma > sec2->lma)
3180 /* Then sort by VMA. Normally the LMA and the VMA will be
3181 the same, and this will do nothing. */
3182 if (sec1->vma < sec2->vma)
3184 else if (sec1->vma > sec2->vma)
3187 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3189 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3195 /* If the indicies are the same, do not return 0
3196 here, but continue to try the next comparison. */
3197 if (sec1->target_index - sec2->target_index != 0)
3198 return sec1->target_index - sec2->target_index;
3203 else if (TOEND (sec2))
3208 /* Sort by size, to put zero sized sections
3209 before others at the same address. */
3211 if (sec1->_raw_size < sec2->_raw_size)
3213 if (sec1->_raw_size > sec2->_raw_size)
3216 return sec1->target_index - sec2->target_index;
3219 /* Assign file positions to the sections based on the mapping from
3220 sections to segments. This function also sets up some fields in
3221 the file header, and writes out the program headers. */
3224 assign_file_positions_for_segments (abfd)
3227 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3229 struct elf_segment_map *m;
3231 Elf_Internal_Phdr *phdrs;
3233 bfd_vma filehdr_vaddr, filehdr_paddr;
3234 bfd_vma phdrs_vaddr, phdrs_paddr;
3235 Elf_Internal_Phdr *p;
3238 if (elf_tdata (abfd)->segment_map == NULL)
3240 if (! map_sections_to_segments (abfd))
3244 if (bed->elf_backend_modify_segment_map)
3246 if (! (*bed->elf_backend_modify_segment_map) (abfd))
3251 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3254 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3255 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3256 elf_elfheader (abfd)->e_phnum = count;
3261 /* If we already counted the number of program segments, make sure
3262 that we allocated enough space. This happens when SIZEOF_HEADERS
3263 is used in a linker script. */
3264 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3265 if (alloc != 0 && count > alloc)
3267 ((*_bfd_error_handler)
3268 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3269 bfd_get_filename (abfd), alloc, count));
3270 bfd_set_error (bfd_error_bad_value);
3277 amt = alloc * sizeof (Elf_Internal_Phdr);
3278 phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
3282 off = bed->s->sizeof_ehdr;
3283 off += alloc * bed->s->sizeof_phdr;
3290 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3297 /* If elf_segment_map is not from map_sections_to_segments, the
3298 sections may not be correctly ordered. */
3300 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3303 p->p_type = m->p_type;
3304 p->p_flags = m->p_flags;
3306 if (p->p_type == PT_LOAD
3308 && (m->sections[0]->flags & SEC_ALLOC) != 0)
3310 if ((abfd->flags & D_PAGED) != 0)
3311 off += (m->sections[0]->vma - off) % bed->maxpagesize;
3314 bfd_size_type align;
3317 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3319 bfd_size_type secalign;
3321 secalign = bfd_get_section_alignment (abfd, *secpp);
3322 if (secalign > align)
3326 off += (m->sections[0]->vma - off) % (1 << align);
3333 p->p_vaddr = m->sections[0]->vma;
3335 if (m->p_paddr_valid)
3336 p->p_paddr = m->p_paddr;
3337 else if (m->count == 0)
3340 p->p_paddr = m->sections[0]->lma;
3342 if (p->p_type == PT_LOAD
3343 && (abfd->flags & D_PAGED) != 0)
3344 p->p_align = bed->maxpagesize;
3345 else if (m->count == 0)
3346 p->p_align = bed->s->file_align;
3354 if (m->includes_filehdr)
3356 if (! m->p_flags_valid)
3359 p->p_filesz = bed->s->sizeof_ehdr;
3360 p->p_memsz = bed->s->sizeof_ehdr;
3363 BFD_ASSERT (p->p_type == PT_LOAD);
3365 if (p->p_vaddr < (bfd_vma) off)
3367 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
3368 bfd_get_filename (abfd));
3369 bfd_set_error (bfd_error_bad_value);
3374 if (! m->p_paddr_valid)
3377 if (p->p_type == PT_LOAD)
3379 filehdr_vaddr = p->p_vaddr;
3380 filehdr_paddr = p->p_paddr;
3384 if (m->includes_phdrs)
3386 if (! m->p_flags_valid)
3389 if (m->includes_filehdr)
3391 if (p->p_type == PT_LOAD)
3393 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3394 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3399 p->p_offset = bed->s->sizeof_ehdr;
3403 BFD_ASSERT (p->p_type == PT_LOAD);
3404 p->p_vaddr -= off - p->p_offset;
3405 if (! m->p_paddr_valid)
3406 p->p_paddr -= off - p->p_offset;
3409 if (p->p_type == PT_LOAD)
3411 phdrs_vaddr = p->p_vaddr;
3412 phdrs_paddr = p->p_paddr;
3415 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3418 p->p_filesz += alloc * bed->s->sizeof_phdr;
3419 p->p_memsz += alloc * bed->s->sizeof_phdr;
3422 if (p->p_type == PT_LOAD
3423 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3425 if (! m->includes_filehdr && ! m->includes_phdrs)
3431 adjust = off - (p->p_offset + p->p_filesz);
3432 p->p_filesz += adjust;
3433 p->p_memsz += adjust;
3439 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3443 bfd_size_type align;
3447 align = 1 << bfd_get_section_alignment (abfd, sec);
3449 /* The section may have artificial alignment forced by a
3450 link script. Notice this case by the gap between the
3451 cumulative phdr lma and the section's lma. */
3452 if (p->p_paddr + p->p_memsz < sec->lma)
3454 bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3456 p->p_memsz += adjust;
3459 if ((flags & SEC_LOAD) != 0)
3460 p->p_filesz += adjust;
3463 if (p->p_type == PT_LOAD)
3465 bfd_signed_vma adjust;
3467 if ((flags & SEC_LOAD) != 0)
3469 adjust = sec->lma - (p->p_paddr + p->p_memsz);
3473 else if ((flags & SEC_ALLOC) != 0)
3475 /* The section VMA must equal the file position
3476 modulo the page size. FIXME: I'm not sure if
3477 this adjustment is really necessary. We used to
3478 not have the SEC_LOAD case just above, and then
3479 this was necessary, but now I'm not sure. */
3480 if ((abfd->flags & D_PAGED) != 0)
3481 adjust = (sec->vma - voff) % bed->maxpagesize;
3483 adjust = (sec->vma - voff) % align;
3492 (* _bfd_error_handler) (_("\
3493 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3494 bfd_section_name (abfd, sec),
3499 p->p_memsz += adjust;
3502 if ((flags & SEC_LOAD) != 0)
3503 p->p_filesz += adjust;
3508 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3509 used in a linker script we may have a section with
3510 SEC_LOAD clear but which is supposed to have
3512 if ((flags & SEC_LOAD) != 0
3513 || (flags & SEC_HAS_CONTENTS) != 0)
3514 off += sec->_raw_size;
3516 if ((flags & SEC_ALLOC) != 0)
3517 voff += sec->_raw_size;
3520 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3522 /* The actual "note" segment has i == 0.
3523 This is the one that actually contains everything. */
3527 p->p_filesz = sec->_raw_size;
3528 off += sec->_raw_size;
3533 /* Fake sections -- don't need to be written. */
3536 flags = sec->flags = 0;
3543 p->p_memsz += sec->_raw_size;
3545 if ((flags & SEC_LOAD) != 0)
3546 p->p_filesz += sec->_raw_size;
3548 if (align > p->p_align
3549 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3553 if (! m->p_flags_valid)
3556 if ((flags & SEC_CODE) != 0)
3558 if ((flags & SEC_READONLY) == 0)
3564 /* Now that we have set the section file positions, we can set up
3565 the file positions for the non PT_LOAD segments. */
3566 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3570 if (p->p_type != PT_LOAD && m->count > 0)
3572 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3573 p->p_offset = m->sections[0]->filepos;
3577 if (m->includes_filehdr)
3579 p->p_vaddr = filehdr_vaddr;
3580 if (! m->p_paddr_valid)
3581 p->p_paddr = filehdr_paddr;
3583 else if (m->includes_phdrs)
3585 p->p_vaddr = phdrs_vaddr;
3586 if (! m->p_paddr_valid)
3587 p->p_paddr = phdrs_paddr;
3592 /* Clear out any program headers we allocated but did not use. */
3593 for (; count < alloc; count++, p++)
3595 memset (p, 0, sizeof *p);
3596 p->p_type = PT_NULL;
3599 elf_tdata (abfd)->phdr = phdrs;
3601 elf_tdata (abfd)->next_file_pos = off;
3603 /* Write out the program headers. */
3604 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
3605 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3611 /* Get the size of the program header.
3613 If this is called by the linker before any of the section VMA's are set, it
3614 can't calculate the correct value for a strange memory layout. This only
3615 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3616 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3617 data segment (exclusive of .interp and .dynamic).
3619 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3620 will be two segments. */
3622 static bfd_size_type
3623 get_program_header_size (abfd)
3628 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3630 /* We can't return a different result each time we're called. */
3631 if (elf_tdata (abfd)->program_header_size != 0)
3632 return elf_tdata (abfd)->program_header_size;
3634 if (elf_tdata (abfd)->segment_map != NULL)
3636 struct elf_segment_map *m;
3639 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3641 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3642 return elf_tdata (abfd)->program_header_size;
3645 /* Assume we will need exactly two PT_LOAD segments: one for text
3646 and one for data. */
3649 s = bfd_get_section_by_name (abfd, ".interp");
3650 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3652 /* If we have a loadable interpreter section, we need a
3653 PT_INTERP segment. In this case, assume we also need a
3654 PT_PHDR segment, although that may not be true for all
3659 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3661 /* We need a PT_DYNAMIC segment. */
3665 if (elf_tdata (abfd)->eh_frame_hdr
3666 && bfd_get_section_by_name (abfd, ".eh_frame_hdr") != NULL)
3668 /* We need a PT_GNU_EH_FRAME segment. */
3672 for (s = abfd->sections; s != NULL; s = s->next)
3674 if ((s->flags & SEC_LOAD) != 0
3675 && strncmp (s->name, ".note", 5) == 0)
3677 /* We need a PT_NOTE segment. */
3682 /* Let the backend count up any program headers it might need. */
3683 if (bed->elf_backend_additional_program_headers)
3687 a = (*bed->elf_backend_additional_program_headers) (abfd);
3693 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3694 return elf_tdata (abfd)->program_header_size;
3697 /* Work out the file positions of all the sections. This is called by
3698 _bfd_elf_compute_section_file_positions. All the section sizes and
3699 VMAs must be known before this is called.
3701 We do not consider reloc sections at this point, unless they form
3702 part of the loadable image. Reloc sections are assigned file
3703 positions in assign_file_positions_for_relocs, which is called by
3704 write_object_contents and final_link.
3706 We also don't set the positions of the .symtab and .strtab here. */
3709 assign_file_positions_except_relocs (abfd)
3712 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3713 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3714 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3715 unsigned int num_sec = elf_numsections (abfd);
3717 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3719 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3720 && bfd_get_format (abfd) != bfd_core)
3722 Elf_Internal_Shdr **hdrpp;
3725 /* Start after the ELF header. */
3726 off = i_ehdrp->e_ehsize;
3728 /* We are not creating an executable, which means that we are
3729 not creating a program header, and that the actual order of
3730 the sections in the file is unimportant. */
3731 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
3733 Elf_Internal_Shdr *hdr;
3736 if (hdr->sh_type == SHT_REL
3737 || hdr->sh_type == SHT_RELA
3738 || i == tdata->symtab_section
3739 || i == tdata->symtab_shndx_section
3740 || i == tdata->strtab_section)
3742 hdr->sh_offset = -1;
3745 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3747 if (i == SHN_LORESERVE - 1)
3749 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3750 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3757 Elf_Internal_Shdr **hdrpp;
3759 /* Assign file positions for the loaded sections based on the
3760 assignment of sections to segments. */
3761 if (! assign_file_positions_for_segments (abfd))
3764 /* Assign file positions for the other sections. */
3766 off = elf_tdata (abfd)->next_file_pos;
3767 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
3769 Elf_Internal_Shdr *hdr;
3772 if (hdr->bfd_section != NULL
3773 && hdr->bfd_section->filepos != 0)
3774 hdr->sh_offset = hdr->bfd_section->filepos;
3775 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3777 ((*_bfd_error_handler)
3778 (_("%s: warning: allocated section `%s' not in segment"),
3779 bfd_get_filename (abfd),
3780 (hdr->bfd_section == NULL
3782 : hdr->bfd_section->name)));
3783 if ((abfd->flags & D_PAGED) != 0)
3784 off += (hdr->sh_addr - off) % bed->maxpagesize;
3786 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3787 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3790 else if (hdr->sh_type == SHT_REL
3791 || hdr->sh_type == SHT_RELA
3792 || hdr == i_shdrpp[tdata->symtab_section]
3793 || hdr == i_shdrpp[tdata->symtab_shndx_section]
3794 || hdr == i_shdrpp[tdata->strtab_section])
3795 hdr->sh_offset = -1;
3797 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3799 if (i == SHN_LORESERVE - 1)
3801 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3802 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3807 /* Place the section headers. */
3808 off = align_file_position (off, bed->s->file_align);
3809 i_ehdrp->e_shoff = off;
3810 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3812 elf_tdata (abfd)->next_file_pos = off;
3821 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3822 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3823 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3825 struct elf_strtab_hash *shstrtab;
3826 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3828 i_ehdrp = elf_elfheader (abfd);
3829 i_shdrp = elf_elfsections (abfd);
3831 shstrtab = _bfd_elf_strtab_init ();
3832 if (shstrtab == NULL)
3835 elf_shstrtab (abfd) = shstrtab;
3837 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3838 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3839 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3840 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3842 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3843 i_ehdrp->e_ident[EI_DATA] =
3844 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3845 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3847 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
3848 i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3850 for (count = EI_PAD; count < EI_NIDENT; count++)
3851 i_ehdrp->e_ident[count] = 0;
3853 if ((abfd->flags & DYNAMIC) != 0)
3854 i_ehdrp->e_type = ET_DYN;
3855 else if ((abfd->flags & EXEC_P) != 0)
3856 i_ehdrp->e_type = ET_EXEC;
3857 else if (bfd_get_format (abfd) == bfd_core)
3858 i_ehdrp->e_type = ET_CORE;
3860 i_ehdrp->e_type = ET_REL;
3862 switch (bfd_get_arch (abfd))
3864 case bfd_arch_unknown:
3865 i_ehdrp->e_machine = EM_NONE;
3868 /* There used to be a long list of cases here, each one setting
3869 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
3870 in the corresponding bfd definition. To avoid duplication,
3871 the switch was removed. Machines that need special handling
3872 can generally do it in elf_backend_final_write_processing(),
3873 unless they need the information earlier than the final write.
3874 Such need can generally be supplied by replacing the tests for
3875 e_machine with the conditions used to determine it. */
3877 if (get_elf_backend_data (abfd) != NULL)
3878 i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
3880 i_ehdrp->e_machine = EM_NONE;
3883 i_ehdrp->e_version = bed->s->ev_current;
3884 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3886 /* No program header, for now. */
3887 i_ehdrp->e_phoff = 0;
3888 i_ehdrp->e_phentsize = 0;
3889 i_ehdrp->e_phnum = 0;
3891 /* Each bfd section is section header entry. */
3892 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3893 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3895 /* If we're building an executable, we'll need a program header table. */
3896 if (abfd->flags & EXEC_P)
3898 /* It all happens later. */
3900 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3902 /* elf_build_phdrs() returns a (NULL-terminated) array of
3903 Elf_Internal_Phdrs. */
3904 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3905 i_ehdrp->e_phoff = outbase;
3906 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3911 i_ehdrp->e_phentsize = 0;
3913 i_ehdrp->e_phoff = 0;
3916 elf_tdata (abfd)->symtab_hdr.sh_name =
3917 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", false);
3918 elf_tdata (abfd)->strtab_hdr.sh_name =
3919 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", false);
3920 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3921 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", false);
3922 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3923 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3924 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3930 /* Assign file positions for all the reloc sections which are not part
3931 of the loadable file image. */
3934 _bfd_elf_assign_file_positions_for_relocs (abfd)
3938 unsigned int i, num_sec;
3939 Elf_Internal_Shdr **shdrpp;
3941 off = elf_tdata (abfd)->next_file_pos;
3943 num_sec = elf_numsections (abfd);
3944 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
3946 Elf_Internal_Shdr *shdrp;
3949 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3950 && shdrp->sh_offset == -1)
3951 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3954 elf_tdata (abfd)->next_file_pos = off;
3958 _bfd_elf_write_object_contents (abfd)
3961 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3962 Elf_Internal_Ehdr *i_ehdrp;
3963 Elf_Internal_Shdr **i_shdrp;
3965 unsigned int count, num_sec;
3967 if (! abfd->output_has_begun
3968 && ! _bfd_elf_compute_section_file_positions
3969 (abfd, (struct bfd_link_info *) NULL))
3972 i_shdrp = elf_elfsections (abfd);
3973 i_ehdrp = elf_elfheader (abfd);
3976 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3980 _bfd_elf_assign_file_positions_for_relocs (abfd);
3982 /* After writing the headers, we need to write the sections too... */
3983 num_sec = elf_numsections (abfd);
3984 for (count = 1; count < num_sec; count++)
3986 if (bed->elf_backend_section_processing)
3987 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3988 if (i_shdrp[count]->contents)
3990 bfd_size_type amt = i_shdrp[count]->sh_size;
3992 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3993 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
3996 if (count == SHN_LORESERVE - 1)
3997 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4000 /* Write out the section header names. */
4001 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4002 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4005 if (bed->elf_backend_final_write_processing)
4006 (*bed->elf_backend_final_write_processing) (abfd,
4007 elf_tdata (abfd)->linker);
4009 return bed->s->write_shdrs_and_ehdr (abfd);
4013 _bfd_elf_write_corefile_contents (abfd)
4016 /* Hopefully this can be done just like an object file. */
4017 return _bfd_elf_write_object_contents (abfd);
4020 /* Given a section, search the header to find them. */
4023 _bfd_elf_section_from_bfd_section (abfd, asect)
4027 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4028 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4030 Elf_Internal_Shdr *hdr;
4031 int maxindex = elf_numsections (abfd);
4033 if (elf_section_data (asect) != NULL
4034 && elf_section_data (asect)->this_idx != 0)
4035 return elf_section_data (asect)->this_idx;
4037 if (bfd_is_abs_section (asect))
4039 if (bfd_is_com_section (asect))
4041 if (bfd_is_und_section (asect))
4044 for (index = 1; index < maxindex; index++)
4046 hdr = i_shdrp[index];
4047 if (hdr != NULL && hdr->bfd_section == asect)
4051 if (bed->elf_backend_section_from_bfd_section)
4053 for (index = 0; index < maxindex; index++)
4057 hdr = i_shdrp[index];
4062 if ((*bed->elf_backend_section_from_bfd_section)
4063 (abfd, hdr, asect, &retval))
4068 bfd_set_error (bfd_error_nonrepresentable_section);
4073 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4077 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
4079 asymbol **asym_ptr_ptr;
4081 asymbol *asym_ptr = *asym_ptr_ptr;
4083 flagword flags = asym_ptr->flags;
4085 /* When gas creates relocations against local labels, it creates its
4086 own symbol for the section, but does put the symbol into the
4087 symbol chain, so udata is 0. When the linker is generating
4088 relocatable output, this section symbol may be for one of the
4089 input sections rather than the output section. */
4090 if (asym_ptr->udata.i == 0
4091 && (flags & BSF_SECTION_SYM)
4092 && asym_ptr->section)
4096 if (asym_ptr->section->output_section != NULL)
4097 indx = asym_ptr->section->output_section->index;
4099 indx = asym_ptr->section->index;
4100 if (indx < elf_num_section_syms (abfd)
4101 && elf_section_syms (abfd)[indx] != NULL)
4102 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4105 idx = asym_ptr->udata.i;
4109 /* This case can occur when using --strip-symbol on a symbol
4110 which is used in a relocation entry. */
4111 (*_bfd_error_handler)
4112 (_("%s: symbol `%s' required but not present"),
4113 bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
4114 bfd_set_error (bfd_error_no_symbols);
4121 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
4122 (long) asym_ptr, asym_ptr->name, idx, flags,
4123 elf_symbol_flags (flags));
4131 /* Copy private BFD data. This copies any program header information. */
4134 copy_private_bfd_data (ibfd, obfd)
4138 Elf_Internal_Ehdr * iehdr;
4139 struct elf_segment_map * map;
4140 struct elf_segment_map * map_first;
4141 struct elf_segment_map ** pointer_to_map;
4142 Elf_Internal_Phdr * segment;
4145 unsigned int num_segments;
4146 boolean phdr_included = false;
4147 bfd_vma maxpagesize;
4148 struct elf_segment_map * phdr_adjust_seg = NULL;
4149 unsigned int phdr_adjust_num = 0;
4151 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4152 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4155 if (elf_tdata (ibfd)->phdr == NULL)
4158 iehdr = elf_elfheader (ibfd);
4161 pointer_to_map = &map_first;
4163 num_segments = elf_elfheader (ibfd)->e_phnum;
4164 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4166 /* Returns the end address of the segment + 1. */
4167 #define SEGMENT_END(segment, start) \
4168 (start + (segment->p_memsz > segment->p_filesz \
4169 ? segment->p_memsz : segment->p_filesz))
4171 /* Returns true if the given section is contained within
4172 the given segment. VMA addresses are compared. */
4173 #define IS_CONTAINED_BY_VMA(section, segment) \
4174 (section->vma >= segment->p_vaddr \
4175 && (section->vma + section->_raw_size) \
4176 <= (SEGMENT_END (segment, segment->p_vaddr)))
4178 /* Returns true if the given section is contained within
4179 the given segment. LMA addresses are compared. */
4180 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4181 (section->lma >= base \
4182 && (section->lma + section->_raw_size) \
4183 <= SEGMENT_END (segment, base))
4185 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4186 #define IS_COREFILE_NOTE(p, s) \
4187 (p->p_type == PT_NOTE \
4188 && bfd_get_format (ibfd) == bfd_core \
4189 && s->vma == 0 && s->lma == 0 \
4190 && (bfd_vma) s->filepos >= p->p_offset \
4191 && (bfd_vma) s->filepos + s->_raw_size \
4192 <= p->p_offset + p->p_filesz)
4194 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4195 linker, which generates a PT_INTERP section with p_vaddr and
4196 p_memsz set to 0. */
4197 #define IS_SOLARIS_PT_INTERP(p, s) \
4199 && p->p_filesz > 0 \
4200 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4201 && s->_raw_size > 0 \
4202 && (bfd_vma) s->filepos >= p->p_offset \
4203 && ((bfd_vma) s->filepos + s->_raw_size \
4204 <= p->p_offset + p->p_filesz))
4206 /* Decide if the given section should be included in the given segment.
4207 A section will be included if:
4208 1. It is within the address space of the segment -- we use the LMA
4209 if that is set for the segment and the VMA otherwise,
4210 2. It is an allocated segment,
4211 3. There is an output section associated with it,
4212 4. The section has not already been allocated to a previous segment. */
4213 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
4214 (((((segment->p_paddr \
4215 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4216 : IS_CONTAINED_BY_VMA (section, segment)) \
4217 || IS_SOLARIS_PT_INTERP (segment, section)) \
4218 && (section->flags & SEC_ALLOC) != 0) \
4219 || IS_COREFILE_NOTE (segment, section)) \
4220 && section->output_section != NULL \
4221 && section->segment_mark == false)
4223 /* Returns true iff seg1 starts after the end of seg2. */
4224 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4225 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4227 /* Returns true iff seg1 and seg2 overlap. */
4228 #define SEGMENT_OVERLAPS(seg1, seg2) \
4229 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4231 /* Initialise the segment mark field. */
4232 for (section = ibfd->sections; section != NULL; section = section->next)
4233 section->segment_mark = false;
4235 /* Scan through the segments specified in the program header
4236 of the input BFD. For this first scan we look for overlaps
4237 in the loadable segments. These can be created by weird
4238 parameters to objcopy. */
4239 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4244 Elf_Internal_Phdr *segment2;
4246 if (segment->p_type != PT_LOAD)
4249 /* Determine if this segment overlaps any previous segments. */
4250 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4252 bfd_signed_vma extra_length;
4254 if (segment2->p_type != PT_LOAD
4255 || ! SEGMENT_OVERLAPS (segment, segment2))
4258 /* Merge the two segments together. */
4259 if (segment2->p_vaddr < segment->p_vaddr)
4261 /* Extend SEGMENT2 to include SEGMENT and then delete
4264 SEGMENT_END (segment, segment->p_vaddr)
4265 - SEGMENT_END (segment2, segment2->p_vaddr);
4267 if (extra_length > 0)
4269 segment2->p_memsz += extra_length;
4270 segment2->p_filesz += extra_length;
4273 segment->p_type = PT_NULL;
4275 /* Since we have deleted P we must restart the outer loop. */
4277 segment = elf_tdata (ibfd)->phdr;
4282 /* Extend SEGMENT to include SEGMENT2 and then delete
4285 SEGMENT_END (segment2, segment2->p_vaddr)
4286 - SEGMENT_END (segment, segment->p_vaddr);
4288 if (extra_length > 0)
4290 segment->p_memsz += extra_length;
4291 segment->p_filesz += extra_length;
4294 segment2->p_type = PT_NULL;
4299 /* The second scan attempts to assign sections to segments. */
4300 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4304 unsigned int section_count;
4305 asection ** sections;
4306 asection * output_section;
4308 bfd_vma matching_lma;
4309 bfd_vma suggested_lma;
4313 if (segment->p_type == PT_NULL)
4316 /* Compute how many sections might be placed into this segment. */
4318 for (section = ibfd->sections; section != NULL; section = section->next)
4319 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
4322 /* Allocate a segment map big enough to contain all of the
4323 sections we have selected. */
4324 amt = sizeof (struct elf_segment_map);
4325 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4326 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4330 /* Initialise the fields of the segment map. Default to
4331 using the physical address of the segment in the input BFD. */
4333 map->p_type = segment->p_type;
4334 map->p_flags = segment->p_flags;
4335 map->p_flags_valid = 1;
4336 map->p_paddr = segment->p_paddr;
4337 map->p_paddr_valid = 1;
4339 /* Determine if this segment contains the ELF file header
4340 and if it contains the program headers themselves. */
4341 map->includes_filehdr = (segment->p_offset == 0
4342 && segment->p_filesz >= iehdr->e_ehsize);
4344 map->includes_phdrs = 0;
4346 if (! phdr_included || segment->p_type != PT_LOAD)
4348 map->includes_phdrs =
4349 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4350 && (segment->p_offset + segment->p_filesz
4351 >= ((bfd_vma) iehdr->e_phoff
4352 + iehdr->e_phnum * iehdr->e_phentsize)));
4354 if (segment->p_type == PT_LOAD && map->includes_phdrs)
4355 phdr_included = true;
4358 if (section_count == 0)
4360 /* Special segments, such as the PT_PHDR segment, may contain
4361 no sections, but ordinary, loadable segments should contain
4363 if (segment->p_type == PT_LOAD)
4365 (_("%s: warning: Empty loadable segment detected\n"),
4366 bfd_archive_filename (ibfd));
4369 *pointer_to_map = map;
4370 pointer_to_map = &map->next;
4375 /* Now scan the sections in the input BFD again and attempt
4376 to add their corresponding output sections to the segment map.
4377 The problem here is how to handle an output section which has
4378 been moved (ie had its LMA changed). There are four possibilities:
4380 1. None of the sections have been moved.
4381 In this case we can continue to use the segment LMA from the
4384 2. All of the sections have been moved by the same amount.
4385 In this case we can change the segment's LMA to match the LMA
4386 of the first section.
4388 3. Some of the sections have been moved, others have not.
4389 In this case those sections which have not been moved can be
4390 placed in the current segment which will have to have its size,
4391 and possibly its LMA changed, and a new segment or segments will
4392 have to be created to contain the other sections.
4394 4. The sections have been moved, but not be the same amount.
4395 In this case we can change the segment's LMA to match the LMA
4396 of the first section and we will have to create a new segment
4397 or segments to contain the other sections.
4399 In order to save time, we allocate an array to hold the section
4400 pointers that we are interested in. As these sections get assigned
4401 to a segment, they are removed from this array. */
4403 amt = (bfd_size_type) section_count * sizeof (asection *);
4404 sections = (asection **) bfd_malloc (amt);
4405 if (sections == NULL)
4408 /* Step One: Scan for segment vs section LMA conflicts.
4409 Also add the sections to the section array allocated above.
4410 Also add the sections to the current segment. In the common
4411 case, where the sections have not been moved, this means that
4412 we have completely filled the segment, and there is nothing
4418 for (j = 0, section = ibfd->sections;
4420 section = section->next)
4422 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
4424 output_section = section->output_section;
4426 sections[j ++] = section;
4428 /* The Solaris native linker always sets p_paddr to 0.
4429 We try to catch that case here, and set it to the
4431 if (segment->p_paddr == 0
4432 && segment->p_vaddr != 0
4434 && output_section->lma != 0
4435 && (output_section->vma == (segment->p_vaddr
4436 + (map->includes_filehdr
4439 + (map->includes_phdrs
4441 * iehdr->e_phentsize)
4443 map->p_paddr = segment->p_vaddr;
4445 /* Match up the physical address of the segment with the
4446 LMA address of the output section. */
4447 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4448 || IS_COREFILE_NOTE (segment, section))
4450 if (matching_lma == 0)
4451 matching_lma = output_section->lma;
4453 /* We assume that if the section fits within the segment
4454 then it does not overlap any other section within that
4456 map->sections[isec ++] = output_section;
4458 else if (suggested_lma == 0)
4459 suggested_lma = output_section->lma;
4463 BFD_ASSERT (j == section_count);
4465 /* Step Two: Adjust the physical address of the current segment,
4467 if (isec == section_count)
4469 /* All of the sections fitted within the segment as currently
4470 specified. This is the default case. Add the segment to
4471 the list of built segments and carry on to process the next
4472 program header in the input BFD. */
4473 map->count = section_count;
4474 *pointer_to_map = map;
4475 pointer_to_map = &map->next;
4482 if (matching_lma != 0)
4484 /* At least one section fits inside the current segment.
4485 Keep it, but modify its physical address to match the
4486 LMA of the first section that fitted. */
4487 map->p_paddr = matching_lma;
4491 /* None of the sections fitted inside the current segment.
4492 Change the current segment's physical address to match
4493 the LMA of the first section. */
4494 map->p_paddr = suggested_lma;
4497 /* Offset the segment physical address from the lma
4498 to allow for space taken up by elf headers. */
4499 if (map->includes_filehdr)
4500 map->p_paddr -= iehdr->e_ehsize;
4502 if (map->includes_phdrs)
4504 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4506 /* iehdr->e_phnum is just an estimate of the number
4507 of program headers that we will need. Make a note
4508 here of the number we used and the segment we chose
4509 to hold these headers, so that we can adjust the
4510 offset when we know the correct value. */
4511 phdr_adjust_num = iehdr->e_phnum;
4512 phdr_adjust_seg = map;
4516 /* Step Three: Loop over the sections again, this time assigning
4517 those that fit to the current segment and remvoing them from the
4518 sections array; but making sure not to leave large gaps. Once all
4519 possible sections have been assigned to the current segment it is
4520 added to the list of built segments and if sections still remain
4521 to be assigned, a new segment is constructed before repeating
4529 /* Fill the current segment with sections that fit. */
4530 for (j = 0; j < section_count; j++)
4532 section = sections[j];
4534 if (section == NULL)
4537 output_section = section->output_section;
4539 BFD_ASSERT (output_section != NULL);
4541 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4542 || IS_COREFILE_NOTE (segment, section))
4544 if (map->count == 0)
4546 /* If the first section in a segment does not start at
4547 the beginning of the segment, then something is
4549 if (output_section->lma !=
4551 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4552 + (map->includes_phdrs
4553 ? iehdr->e_phnum * iehdr->e_phentsize
4559 asection * prev_sec;
4561 prev_sec = map->sections[map->count - 1];
4563 /* If the gap between the end of the previous section
4564 and the start of this section is more than
4565 maxpagesize then we need to start a new segment. */
4566 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
4568 < BFD_ALIGN (output_section->lma, maxpagesize))
4569 || ((prev_sec->lma + prev_sec->_raw_size)
4570 > output_section->lma))
4572 if (suggested_lma == 0)
4573 suggested_lma = output_section->lma;
4579 map->sections[map->count++] = output_section;
4582 section->segment_mark = true;
4584 else if (suggested_lma == 0)
4585 suggested_lma = output_section->lma;
4588 BFD_ASSERT (map->count > 0);
4590 /* Add the current segment to the list of built segments. */
4591 *pointer_to_map = map;
4592 pointer_to_map = &map->next;
4594 if (isec < section_count)
4596 /* We still have not allocated all of the sections to
4597 segments. Create a new segment here, initialise it
4598 and carry on looping. */
4599 amt = sizeof (struct elf_segment_map);
4600 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4601 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4605 /* Initialise the fields of the segment map. Set the physical
4606 physical address to the LMA of the first section that has
4607 not yet been assigned. */
4609 map->p_type = segment->p_type;
4610 map->p_flags = segment->p_flags;
4611 map->p_flags_valid = 1;
4612 map->p_paddr = suggested_lma;
4613 map->p_paddr_valid = 1;
4614 map->includes_filehdr = 0;
4615 map->includes_phdrs = 0;
4618 while (isec < section_count);
4623 /* The Solaris linker creates program headers in which all the
4624 p_paddr fields are zero. When we try to objcopy or strip such a
4625 file, we get confused. Check for this case, and if we find it
4626 reset the p_paddr_valid fields. */
4627 for (map = map_first; map != NULL; map = map->next)
4628 if (map->p_paddr != 0)
4632 for (map = map_first; map != NULL; map = map->next)
4633 map->p_paddr_valid = 0;
4636 elf_tdata (obfd)->segment_map = map_first;
4638 /* If we had to estimate the number of program headers that were
4639 going to be needed, then check our estimate now and adjust
4640 the offset if necessary. */
4641 if (phdr_adjust_seg != NULL)
4645 for (count = 0, map = map_first; map != NULL; map = map->next)
4648 if (count > phdr_adjust_num)
4649 phdr_adjust_seg->p_paddr
4650 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
4654 /* Final Step: Sort the segments into ascending order of physical
4656 if (map_first != NULL)
4658 struct elf_segment_map *prev;
4661 for (map = map_first->next; map != NULL; prev = map, map = map->next)
4663 /* Yes I know - its a bubble sort.... */
4664 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
4666 /* Swap map and map->next. */
4667 prev->next = map->next;
4668 map->next = map->next->next;
4669 prev->next->next = map;
4679 #undef IS_CONTAINED_BY_VMA
4680 #undef IS_CONTAINED_BY_LMA
4681 #undef IS_COREFILE_NOTE
4682 #undef IS_SOLARIS_PT_INTERP
4683 #undef INCLUDE_SECTION_IN_SEGMENT
4684 #undef SEGMENT_AFTER_SEGMENT
4685 #undef SEGMENT_OVERLAPS
4689 /* Copy private section information. This copies over the entsize
4690 field, and sometimes the info field. */
4693 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
4699 Elf_Internal_Shdr *ihdr, *ohdr;
4701 if (ibfd->xvec->flavour != bfd_target_elf_flavour
4702 || obfd->xvec->flavour != bfd_target_elf_flavour)
4705 /* Copy over private BFD data if it has not already been copied.
4706 This must be done here, rather than in the copy_private_bfd_data
4707 entry point, because the latter is called after the section
4708 contents have been set, which means that the program headers have
4709 already been worked out. */
4710 if (elf_tdata (obfd)->segment_map == NULL
4711 && elf_tdata (ibfd)->phdr != NULL)
4715 /* Only set up the segments if there are no more SEC_ALLOC
4716 sections. FIXME: This won't do the right thing if objcopy is
4717 used to remove the last SEC_ALLOC section, since objcopy
4718 won't call this routine in that case. */
4719 for (s = isec->next; s != NULL; s = s->next)
4720 if ((s->flags & SEC_ALLOC) != 0)
4724 if (! copy_private_bfd_data (ibfd, obfd))
4729 ihdr = &elf_section_data (isec)->this_hdr;
4730 ohdr = &elf_section_data (osec)->this_hdr;
4732 ohdr->sh_entsize = ihdr->sh_entsize;
4734 if (ihdr->sh_type == SHT_SYMTAB
4735 || ihdr->sh_type == SHT_DYNSYM
4736 || ihdr->sh_type == SHT_GNU_verneed
4737 || ihdr->sh_type == SHT_GNU_verdef)
4738 ohdr->sh_info = ihdr->sh_info;
4740 elf_section_data (osec)->use_rela_p
4741 = elf_section_data (isec)->use_rela_p;
4746 /* Copy private symbol information. If this symbol is in a section
4747 which we did not map into a BFD section, try to map the section
4748 index correctly. We use special macro definitions for the mapped
4749 section indices; these definitions are interpreted by the
4750 swap_out_syms function. */
4752 #define MAP_ONESYMTAB (SHN_HIOS + 1)
4753 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
4754 #define MAP_STRTAB (SHN_HIOS + 3)
4755 #define MAP_SHSTRTAB (SHN_HIOS + 4)
4756 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
4759 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
4765 elf_symbol_type *isym, *osym;
4767 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4768 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4771 isym = elf_symbol_from (ibfd, isymarg);
4772 osym = elf_symbol_from (obfd, osymarg);
4776 && bfd_is_abs_section (isym->symbol.section))
4780 shndx = isym->internal_elf_sym.st_shndx;
4781 if (shndx == elf_onesymtab (ibfd))
4782 shndx = MAP_ONESYMTAB;
4783 else if (shndx == elf_dynsymtab (ibfd))
4784 shndx = MAP_DYNSYMTAB;
4785 else if (shndx == elf_tdata (ibfd)->strtab_section)
4787 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
4788 shndx = MAP_SHSTRTAB;
4789 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
4790 shndx = MAP_SYM_SHNDX;
4791 osym->internal_elf_sym.st_shndx = shndx;
4797 /* Swap out the symbols. */
4800 swap_out_syms (abfd, sttp, relocatable_p)
4802 struct bfd_strtab_hash **sttp;
4805 struct elf_backend_data *bed;
4808 struct bfd_strtab_hash *stt;
4809 Elf_Internal_Shdr *symtab_hdr;
4810 Elf_Internal_Shdr *symtab_shndx_hdr;
4811 Elf_Internal_Shdr *symstrtab_hdr;
4812 char *outbound_syms;
4813 char *outbound_shndx;
4817 if (!elf_map_symbols (abfd))
4820 /* Dump out the symtabs. */
4821 stt = _bfd_elf_stringtab_init ();
4825 bed = get_elf_backend_data (abfd);
4826 symcount = bfd_get_symcount (abfd);
4827 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4828 symtab_hdr->sh_type = SHT_SYMTAB;
4829 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4830 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4831 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4832 symtab_hdr->sh_addralign = bed->s->file_align;
4834 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4835 symstrtab_hdr->sh_type = SHT_STRTAB;
4837 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
4838 outbound_syms = bfd_alloc (abfd, amt);
4839 if (outbound_syms == NULL)
4841 symtab_hdr->contents = (PTR) outbound_syms;
4843 outbound_shndx = NULL;
4844 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
4845 if (symtab_shndx_hdr->sh_name != 0)
4847 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
4848 outbound_shndx = bfd_alloc (abfd, amt);
4849 if (outbound_shndx == NULL)
4851 memset (outbound_shndx, 0, (unsigned long) amt);
4852 symtab_shndx_hdr->contents = outbound_shndx;
4853 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
4854 symtab_shndx_hdr->sh_size = amt;
4855 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
4856 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
4859 /* now generate the data (for "contents") */
4861 /* Fill in zeroth symbol and swap it out. */
4862 Elf_Internal_Sym sym;
4868 sym.st_shndx = SHN_UNDEF;
4869 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
4870 outbound_syms += bed->s->sizeof_sym;
4871 if (outbound_shndx != NULL)
4872 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
4875 syms = bfd_get_outsymbols (abfd);
4876 for (idx = 0; idx < symcount; idx++)
4878 Elf_Internal_Sym sym;
4879 bfd_vma value = syms[idx]->value;
4880 elf_symbol_type *type_ptr;
4881 flagword flags = syms[idx]->flags;
4884 if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
4886 /* Local section symbols have no name. */
4891 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4894 if (sym.st_name == (unsigned long) -1)
4898 type_ptr = elf_symbol_from (abfd, syms[idx]);
4900 if ((flags & BSF_SECTION_SYM) == 0
4901 && bfd_is_com_section (syms[idx]->section))
4903 /* ELF common symbols put the alignment into the `value' field,
4904 and the size into the `size' field. This is backwards from
4905 how BFD handles it, so reverse it here. */
4906 sym.st_size = value;
4907 if (type_ptr == NULL
4908 || type_ptr->internal_elf_sym.st_value == 0)
4909 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4911 sym.st_value = type_ptr->internal_elf_sym.st_value;
4912 sym.st_shndx = _bfd_elf_section_from_bfd_section
4913 (abfd, syms[idx]->section);
4917 asection *sec = syms[idx]->section;
4920 if (sec->output_section)
4922 value += sec->output_offset;
4923 sec = sec->output_section;
4925 /* Don't add in the section vma for relocatable output. */
4926 if (! relocatable_p)
4928 sym.st_value = value;
4929 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4931 if (bfd_is_abs_section (sec)
4933 && type_ptr->internal_elf_sym.st_shndx != 0)
4935 /* This symbol is in a real ELF section which we did
4936 not create as a BFD section. Undo the mapping done
4937 by copy_private_symbol_data. */
4938 shndx = type_ptr->internal_elf_sym.st_shndx;
4942 shndx = elf_onesymtab (abfd);
4945 shndx = elf_dynsymtab (abfd);
4948 shndx = elf_tdata (abfd)->strtab_section;
4951 shndx = elf_tdata (abfd)->shstrtab_section;
4954 shndx = elf_tdata (abfd)->symtab_shndx_section;
4962 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4968 /* Writing this would be a hell of a lot easier if
4969 we had some decent documentation on bfd, and
4970 knew what to expect of the library, and what to
4971 demand of applications. For example, it
4972 appears that `objcopy' might not set the
4973 section of a symbol to be a section that is
4974 actually in the output file. */
4975 sec2 = bfd_get_section_by_name (abfd, sec->name);
4976 BFD_ASSERT (sec2 != 0);
4977 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4978 BFD_ASSERT (shndx != -1);
4982 sym.st_shndx = shndx;
4985 if ((flags & BSF_FUNCTION) != 0)
4987 else if ((flags & BSF_OBJECT) != 0)
4992 /* Processor-specific types */
4993 if (type_ptr != NULL
4994 && bed->elf_backend_get_symbol_type)
4995 type = ((*bed->elf_backend_get_symbol_type)
4996 (&type_ptr->internal_elf_sym, type));
4998 if (flags & BSF_SECTION_SYM)
5000 if (flags & BSF_GLOBAL)
5001 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5003 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5005 else if (bfd_is_com_section (syms[idx]->section))
5006 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5007 else if (bfd_is_und_section (syms[idx]->section))
5008 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5012 else if (flags & BSF_FILE)
5013 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5016 int bind = STB_LOCAL;
5018 if (flags & BSF_LOCAL)
5020 else if (flags & BSF_WEAK)
5022 else if (flags & BSF_GLOBAL)
5025 sym.st_info = ELF_ST_INFO (bind, type);
5028 if (type_ptr != NULL)
5029 sym.st_other = type_ptr->internal_elf_sym.st_other;
5033 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5034 outbound_syms += bed->s->sizeof_sym;
5035 if (outbound_shndx != NULL)
5036 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5040 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5041 symstrtab_hdr->sh_type = SHT_STRTAB;
5043 symstrtab_hdr->sh_flags = 0;
5044 symstrtab_hdr->sh_addr = 0;
5045 symstrtab_hdr->sh_entsize = 0;
5046 symstrtab_hdr->sh_link = 0;
5047 symstrtab_hdr->sh_info = 0;
5048 symstrtab_hdr->sh_addralign = 1;
5053 /* Return the number of bytes required to hold the symtab vector.
5055 Note that we base it on the count plus 1, since we will null terminate
5056 the vector allocated based on this size. However, the ELF symbol table
5057 always has a dummy entry as symbol #0, so it ends up even. */
5060 _bfd_elf_get_symtab_upper_bound (abfd)
5065 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5067 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5068 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
5074 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
5079 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5081 if (elf_dynsymtab (abfd) == 0)
5083 bfd_set_error (bfd_error_invalid_operation);
5087 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5088 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
5094 _bfd_elf_get_reloc_upper_bound (abfd, asect)
5095 bfd *abfd ATTRIBUTE_UNUSED;
5098 return (asect->reloc_count + 1) * sizeof (arelent *);
5101 /* Canonicalize the relocs. */
5104 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
5112 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5114 if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
5117 tblptr = section->relocation;
5118 for (i = 0; i < section->reloc_count; i++)
5119 *relptr++ = tblptr++;
5123 return section->reloc_count;
5127 _bfd_elf_get_symtab (abfd, alocation)
5129 asymbol **alocation;
5131 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5132 long symcount = bed->s->slurp_symbol_table (abfd, alocation, false);
5135 bfd_get_symcount (abfd) = symcount;
5140 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
5142 asymbol **alocation;
5144 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5145 return bed->s->slurp_symbol_table (abfd, alocation, true);
5148 /* Return the size required for the dynamic reloc entries. Any
5149 section that was actually installed in the BFD, and has type
5150 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5151 considered to be a dynamic reloc section. */
5154 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
5160 if (elf_dynsymtab (abfd) == 0)
5162 bfd_set_error (bfd_error_invalid_operation);
5166 ret = sizeof (arelent *);
5167 for (s = abfd->sections; s != NULL; s = s->next)
5168 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5169 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5170 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5171 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5172 * sizeof (arelent *));
5177 /* Canonicalize the dynamic relocation entries. Note that we return
5178 the dynamic relocations as a single block, although they are
5179 actually associated with particular sections; the interface, which
5180 was designed for SunOS style shared libraries, expects that there
5181 is only one set of dynamic relocs. Any section that was actually
5182 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5183 the dynamic symbol table, is considered to be a dynamic reloc
5187 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
5192 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
5196 if (elf_dynsymtab (abfd) == 0)
5198 bfd_set_error (bfd_error_invalid_operation);
5202 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5204 for (s = abfd->sections; s != NULL; s = s->next)
5206 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5207 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5208 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5213 if (! (*slurp_relocs) (abfd, s, syms, true))
5215 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5217 for (i = 0; i < count; i++)
5228 /* Read in the version information. */
5231 _bfd_elf_slurp_version_tables (abfd)
5234 bfd_byte *contents = NULL;
5237 if (elf_dynverdef (abfd) != 0)
5239 Elf_Internal_Shdr *hdr;
5240 Elf_External_Verdef *everdef;
5241 Elf_Internal_Verdef *iverdef;
5242 Elf_Internal_Verdef *iverdefarr;
5243 Elf_Internal_Verdef iverdefmem;
5245 unsigned int maxidx;
5247 hdr = &elf_tdata (abfd)->dynverdef_hdr;
5249 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5250 if (contents == NULL)
5252 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5253 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5256 /* We know the number of entries in the section but not the maximum
5257 index. Therefore we have to run through all entries and find
5259 everdef = (Elf_External_Verdef *) contents;
5261 for (i = 0; i < hdr->sh_info; ++i)
5263 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5265 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5266 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5268 everdef = ((Elf_External_Verdef *)
5269 ((bfd_byte *) everdef + iverdefmem.vd_next));
5272 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5273 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
5274 if (elf_tdata (abfd)->verdef == NULL)
5277 elf_tdata (abfd)->cverdefs = maxidx;
5279 everdef = (Elf_External_Verdef *) contents;
5280 iverdefarr = elf_tdata (abfd)->verdef;
5281 for (i = 0; i < hdr->sh_info; i++)
5283 Elf_External_Verdaux *everdaux;
5284 Elf_Internal_Verdaux *iverdaux;
5287 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5289 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5290 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5292 iverdef->vd_bfd = abfd;
5294 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5295 iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
5296 if (iverdef->vd_auxptr == NULL)
5299 everdaux = ((Elf_External_Verdaux *)
5300 ((bfd_byte *) everdef + iverdef->vd_aux));
5301 iverdaux = iverdef->vd_auxptr;
5302 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5304 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5306 iverdaux->vda_nodename =
5307 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5308 iverdaux->vda_name);
5309 if (iverdaux->vda_nodename == NULL)
5312 if (j + 1 < iverdef->vd_cnt)
5313 iverdaux->vda_nextptr = iverdaux + 1;
5315 iverdaux->vda_nextptr = NULL;
5317 everdaux = ((Elf_External_Verdaux *)
5318 ((bfd_byte *) everdaux + iverdaux->vda_next));
5321 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5323 if (i + 1 < hdr->sh_info)
5324 iverdef->vd_nextdef = iverdef + 1;
5326 iverdef->vd_nextdef = NULL;
5328 everdef = ((Elf_External_Verdef *)
5329 ((bfd_byte *) everdef + iverdef->vd_next));
5336 if (elf_dynverref (abfd) != 0)
5338 Elf_Internal_Shdr *hdr;
5339 Elf_External_Verneed *everneed;
5340 Elf_Internal_Verneed *iverneed;
5343 hdr = &elf_tdata (abfd)->dynverref_hdr;
5345 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5346 elf_tdata (abfd)->verref =
5347 (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
5348 if (elf_tdata (abfd)->verref == NULL)
5351 elf_tdata (abfd)->cverrefs = hdr->sh_info;
5353 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5354 if (contents == NULL)
5356 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5357 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5360 everneed = (Elf_External_Verneed *) contents;
5361 iverneed = elf_tdata (abfd)->verref;
5362 for (i = 0; i < hdr->sh_info; i++, iverneed++)
5364 Elf_External_Vernaux *evernaux;
5365 Elf_Internal_Vernaux *ivernaux;
5368 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5370 iverneed->vn_bfd = abfd;
5372 iverneed->vn_filename =
5373 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5375 if (iverneed->vn_filename == NULL)
5378 amt = iverneed->vn_cnt;
5379 amt *= sizeof (Elf_Internal_Vernaux);
5380 iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
5382 evernaux = ((Elf_External_Vernaux *)
5383 ((bfd_byte *) everneed + iverneed->vn_aux));
5384 ivernaux = iverneed->vn_auxptr;
5385 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5387 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5389 ivernaux->vna_nodename =
5390 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5391 ivernaux->vna_name);
5392 if (ivernaux->vna_nodename == NULL)
5395 if (j + 1 < iverneed->vn_cnt)
5396 ivernaux->vna_nextptr = ivernaux + 1;
5398 ivernaux->vna_nextptr = NULL;
5400 evernaux = ((Elf_External_Vernaux *)
5401 ((bfd_byte *) evernaux + ivernaux->vna_next));
5404 if (i + 1 < hdr->sh_info)
5405 iverneed->vn_nextref = iverneed + 1;
5407 iverneed->vn_nextref = NULL;
5409 everneed = ((Elf_External_Verneed *)
5410 ((bfd_byte *) everneed + iverneed->vn_next));
5420 if (contents == NULL)
5426 _bfd_elf_make_empty_symbol (abfd)
5429 elf_symbol_type *newsym;
5430 bfd_size_type amt = sizeof (elf_symbol_type);
5432 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
5437 newsym->symbol.the_bfd = abfd;
5438 return &newsym->symbol;
5443 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
5444 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5448 bfd_symbol_info (symbol, ret);
5451 /* Return whether a symbol name implies a local symbol. Most targets
5452 use this function for the is_local_label_name entry point, but some
5456 _bfd_elf_is_local_label_name (abfd, name)
5457 bfd *abfd ATTRIBUTE_UNUSED;
5460 /* Normal local symbols start with ``.L''. */
5461 if (name[0] == '.' && name[1] == 'L')
5464 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5465 DWARF debugging symbols starting with ``..''. */
5466 if (name[0] == '.' && name[1] == '.')
5469 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5470 emitting DWARF debugging output. I suspect this is actually a
5471 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5472 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5473 underscore to be emitted on some ELF targets). For ease of use,
5474 we treat such symbols as local. */
5475 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5482 _bfd_elf_get_lineno (ignore_abfd, symbol)
5483 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5484 asymbol *symbol ATTRIBUTE_UNUSED;
5491 _bfd_elf_set_arch_mach (abfd, arch, machine)
5493 enum bfd_architecture arch;
5494 unsigned long machine;
5496 /* If this isn't the right architecture for this backend, and this
5497 isn't the generic backend, fail. */
5498 if (arch != get_elf_backend_data (abfd)->arch
5499 && arch != bfd_arch_unknown
5500 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5503 return bfd_default_set_arch_mach (abfd, arch, machine);
5506 /* Find the function to a particular section and offset,
5507 for error reporting. */
5510 elf_find_function (abfd, section, symbols, offset,
5511 filename_ptr, functionname_ptr)
5512 bfd *abfd ATTRIBUTE_UNUSED;
5516 const char **filename_ptr;
5517 const char **functionname_ptr;
5519 const char *filename;
5528 for (p = symbols; *p != NULL; p++)
5532 q = (elf_symbol_type *) *p;
5534 if (bfd_get_section (&q->symbol) != section)
5537 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5542 filename = bfd_asymbol_name (&q->symbol);
5546 if (q->symbol.section == section
5547 && q->symbol.value >= low_func
5548 && q->symbol.value <= offset)
5550 func = (asymbol *) q;
5551 low_func = q->symbol.value;
5561 *filename_ptr = filename;
5562 if (functionname_ptr)
5563 *functionname_ptr = bfd_asymbol_name (func);
5568 /* Find the nearest line to a particular section and offset,
5569 for error reporting. */
5572 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
5573 filename_ptr, functionname_ptr, line_ptr)
5578 const char **filename_ptr;
5579 const char **functionname_ptr;
5580 unsigned int *line_ptr;
5584 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
5585 filename_ptr, functionname_ptr,
5588 if (!*functionname_ptr)
5589 elf_find_function (abfd, section, symbols, offset,
5590 *filename_ptr ? NULL : filename_ptr,
5596 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
5597 filename_ptr, functionname_ptr,
5599 &elf_tdata (abfd)->dwarf2_find_line_info))
5601 if (!*functionname_ptr)
5602 elf_find_function (abfd, section, symbols, offset,
5603 *filename_ptr ? NULL : filename_ptr,
5609 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
5610 &found, filename_ptr,
5611 functionname_ptr, line_ptr,
5612 &elf_tdata (abfd)->line_info))
5617 if (symbols == NULL)
5620 if (! elf_find_function (abfd, section, symbols, offset,
5621 filename_ptr, functionname_ptr))
5629 _bfd_elf_sizeof_headers (abfd, reloc)
5635 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
5637 ret += get_program_header_size (abfd);
5642 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
5647 bfd_size_type count;
5649 Elf_Internal_Shdr *hdr;
5652 if (! abfd->output_has_begun
5653 && ! _bfd_elf_compute_section_file_positions
5654 (abfd, (struct bfd_link_info *) NULL))
5657 hdr = &elf_section_data (section)->this_hdr;
5658 pos = hdr->sh_offset + offset;
5659 if (bfd_seek (abfd, pos, SEEK_SET) != 0
5660 || bfd_bwrite (location, count, abfd) != count)
5667 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
5668 bfd *abfd ATTRIBUTE_UNUSED;
5669 arelent *cache_ptr ATTRIBUTE_UNUSED;
5670 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
5677 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
5680 Elf_Internal_Rel *dst;
5686 /* Try to convert a non-ELF reloc into an ELF one. */
5689 _bfd_elf_validate_reloc (abfd, areloc)
5693 /* Check whether we really have an ELF howto. */
5695 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
5697 bfd_reloc_code_real_type code;
5698 reloc_howto_type *howto;
5700 /* Alien reloc: Try to determine its type to replace it with an
5701 equivalent ELF reloc. */
5703 if (areloc->howto->pc_relative)
5705 switch (areloc->howto->bitsize)
5708 code = BFD_RELOC_8_PCREL;
5711 code = BFD_RELOC_12_PCREL;
5714 code = BFD_RELOC_16_PCREL;
5717 code = BFD_RELOC_24_PCREL;
5720 code = BFD_RELOC_32_PCREL;
5723 code = BFD_RELOC_64_PCREL;
5729 howto = bfd_reloc_type_lookup (abfd, code);
5731 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
5733 if (howto->pcrel_offset)
5734 areloc->addend += areloc->address;
5736 areloc->addend -= areloc->address; /* addend is unsigned!! */
5741 switch (areloc->howto->bitsize)
5747 code = BFD_RELOC_14;
5750 code = BFD_RELOC_16;
5753 code = BFD_RELOC_26;
5756 code = BFD_RELOC_32;
5759 code = BFD_RELOC_64;
5765 howto = bfd_reloc_type_lookup (abfd, code);
5769 areloc->howto = howto;
5777 (*_bfd_error_handler)
5778 (_("%s: unsupported relocation type %s"),
5779 bfd_archive_filename (abfd), areloc->howto->name);
5780 bfd_set_error (bfd_error_bad_value);
5785 _bfd_elf_close_and_cleanup (abfd)
5788 if (bfd_get_format (abfd) == bfd_object)
5790 if (elf_shstrtab (abfd) != NULL)
5791 _bfd_elf_strtab_free (elf_shstrtab (abfd));
5794 return _bfd_generic_close_and_cleanup (abfd);
5797 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5798 in the relocation's offset. Thus we cannot allow any sort of sanity
5799 range-checking to interfere. There is nothing else to do in processing
5802 bfd_reloc_status_type
5803 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
5804 bfd *abfd ATTRIBUTE_UNUSED;
5805 arelent *re ATTRIBUTE_UNUSED;
5806 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
5807 PTR data ATTRIBUTE_UNUSED;
5808 asection *is ATTRIBUTE_UNUSED;
5809 bfd *obfd ATTRIBUTE_UNUSED;
5810 char **errmsg ATTRIBUTE_UNUSED;
5812 return bfd_reloc_ok;
5815 /* Elf core file support. Much of this only works on native
5816 toolchains, since we rely on knowing the
5817 machine-dependent procfs structure in order to pick
5818 out details about the corefile. */
5820 #ifdef HAVE_SYS_PROCFS_H
5821 # include <sys/procfs.h>
5824 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5827 elfcore_make_pid (abfd)
5830 return ((elf_tdata (abfd)->core_lwpid << 16)
5831 + (elf_tdata (abfd)->core_pid));
5834 /* If there isn't a section called NAME, make one, using
5835 data from SECT. Note, this function will generate a
5836 reference to NAME, so you shouldn't deallocate or
5840 elfcore_maybe_make_sect (abfd, name, sect)
5847 if (bfd_get_section_by_name (abfd, name) != NULL)
5850 sect2 = bfd_make_section (abfd, name);
5854 sect2->_raw_size = sect->_raw_size;
5855 sect2->filepos = sect->filepos;
5856 sect2->flags = sect->flags;
5857 sect2->alignment_power = sect->alignment_power;
5861 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
5862 actually creates up to two pseudosections:
5863 - For the single-threaded case, a section named NAME, unless
5864 such a section already exists.
5865 - For the multi-threaded case, a section named "NAME/PID", where
5866 PID is elfcore_make_pid (abfd).
5867 Both pseudosections have identical contents. */
5869 _bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
5876 char *threaded_name;
5879 /* Build the section name. */
5881 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5882 threaded_name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
5883 if (threaded_name == NULL)
5885 strcpy (threaded_name, buf);
5887 sect = bfd_make_section (abfd, threaded_name);
5890 sect->_raw_size = size;
5891 sect->filepos = filepos;
5892 sect->flags = SEC_HAS_CONTENTS;
5893 sect->alignment_power = 2;
5895 return elfcore_maybe_make_sect (abfd, name, sect);
5898 /* prstatus_t exists on:
5900 linux 2.[01] + glibc
5904 #if defined (HAVE_PRSTATUS_T)
5905 static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
5908 elfcore_grok_prstatus (abfd, note)
5910 Elf_Internal_Note *note;
5915 if (note->descsz == sizeof (prstatus_t))
5919 raw_size = sizeof (prstat.pr_reg);
5920 offset = offsetof (prstatus_t, pr_reg);
5921 memcpy (&prstat, note->descdata, sizeof (prstat));
5923 /* Do not overwrite the core signal if it
5924 has already been set by another thread. */
5925 if (elf_tdata (abfd)->core_signal == 0)
5926 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5927 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5929 /* pr_who exists on:
5932 pr_who doesn't exist on:
5935 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5936 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5939 #if defined (HAVE_PRSTATUS32_T)
5940 else if (note->descsz == sizeof (prstatus32_t))
5942 /* 64-bit host, 32-bit corefile */
5943 prstatus32_t prstat;
5945 raw_size = sizeof (prstat.pr_reg);
5946 offset = offsetof (prstatus32_t, pr_reg);
5947 memcpy (&prstat, note->descdata, sizeof (prstat));
5949 /* Do not overwrite the core signal if it
5950 has already been set by another thread. */
5951 if (elf_tdata (abfd)->core_signal == 0)
5952 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5953 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5955 /* pr_who exists on:
5958 pr_who doesn't exist on:
5961 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
5962 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5965 #endif /* HAVE_PRSTATUS32_T */
5968 /* Fail - we don't know how to handle any other
5969 note size (ie. data object type). */
5973 /* Make a ".reg/999" section and a ".reg" section. */
5974 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5975 raw_size, note->descpos + offset);
5977 #endif /* defined (HAVE_PRSTATUS_T) */
5979 /* Create a pseudosection containing the exact contents of NOTE. */
5981 elfcore_make_note_pseudosection (abfd, name, note)
5984 Elf_Internal_Note *note;
5986 return _bfd_elfcore_make_pseudosection (abfd, name,
5987 note->descsz, note->descpos);
5990 /* There isn't a consistent prfpregset_t across platforms,
5991 but it doesn't matter, because we don't have to pick this
5992 data structure apart. */
5995 elfcore_grok_prfpreg (abfd, note)
5997 Elf_Internal_Note *note;
5999 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6002 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6003 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6007 elfcore_grok_prxfpreg (abfd, note)
6009 Elf_Internal_Note *note;
6011 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6014 #if defined (HAVE_PRPSINFO_T)
6015 typedef prpsinfo_t elfcore_psinfo_t;
6016 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6017 typedef prpsinfo32_t elfcore_psinfo32_t;
6021 #if defined (HAVE_PSINFO_T)
6022 typedef psinfo_t elfcore_psinfo_t;
6023 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6024 typedef psinfo32_t elfcore_psinfo32_t;
6028 /* return a malloc'ed copy of a string at START which is at
6029 most MAX bytes long, possibly without a terminating '\0'.
6030 the copy will always have a terminating '\0'. */
6033 _bfd_elfcore_strndup (abfd, start, max)
6039 char *end = memchr (start, '\0', max);
6047 dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
6051 memcpy (dups, start, len);
6057 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6058 static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
6061 elfcore_grok_psinfo (abfd, note)
6063 Elf_Internal_Note *note;
6065 if (note->descsz == sizeof (elfcore_psinfo_t))
6067 elfcore_psinfo_t psinfo;
6069 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6071 elf_tdata (abfd)->core_program
6072 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6073 sizeof (psinfo.pr_fname));
6075 elf_tdata (abfd)->core_command
6076 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6077 sizeof (psinfo.pr_psargs));
6079 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6080 else if (note->descsz == sizeof (elfcore_psinfo32_t))
6082 /* 64-bit host, 32-bit corefile */
6083 elfcore_psinfo32_t psinfo;
6085 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6087 elf_tdata (abfd)->core_program
6088 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6089 sizeof (psinfo.pr_fname));
6091 elf_tdata (abfd)->core_command
6092 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6093 sizeof (psinfo.pr_psargs));
6099 /* Fail - we don't know how to handle any other
6100 note size (ie. data object type). */
6104 /* Note that for some reason, a spurious space is tacked
6105 onto the end of the args in some (at least one anyway)
6106 implementations, so strip it off if it exists. */
6109 char *command = elf_tdata (abfd)->core_command;
6110 int n = strlen (command);
6112 if (0 < n && command[n - 1] == ' ')
6113 command[n - 1] = '\0';
6118 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6120 #if defined (HAVE_PSTATUS_T)
6122 elfcore_grok_pstatus (abfd, note)
6124 Elf_Internal_Note *note;
6126 if (note->descsz == sizeof (pstatus_t)
6127 #if defined (HAVE_PXSTATUS_T)
6128 || note->descsz == sizeof (pxstatus_t)
6134 memcpy (&pstat, note->descdata, sizeof (pstat));
6136 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6138 #if defined (HAVE_PSTATUS32_T)
6139 else if (note->descsz == sizeof (pstatus32_t))
6141 /* 64-bit host, 32-bit corefile */
6144 memcpy (&pstat, note->descdata, sizeof (pstat));
6146 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6149 /* Could grab some more details from the "representative"
6150 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6151 NT_LWPSTATUS note, presumably. */
6155 #endif /* defined (HAVE_PSTATUS_T) */
6157 #if defined (HAVE_LWPSTATUS_T)
6159 elfcore_grok_lwpstatus (abfd, note)
6161 Elf_Internal_Note *note;
6163 lwpstatus_t lwpstat;
6168 if (note->descsz != sizeof (lwpstat)
6169 #if defined (HAVE_LWPXSTATUS_T)
6170 && note->descsz != sizeof (lwpxstatus_t)
6175 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6177 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6178 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6180 /* Make a ".reg/999" section. */
6182 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6183 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6188 sect = bfd_make_section (abfd, name);
6192 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6193 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6194 sect->filepos = note->descpos
6195 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6198 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6199 sect->_raw_size = sizeof (lwpstat.pr_reg);
6200 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6203 sect->flags = SEC_HAS_CONTENTS;
6204 sect->alignment_power = 2;
6206 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6209 /* Make a ".reg2/999" section */
6211 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6212 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6217 sect = bfd_make_section (abfd, name);
6221 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6222 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6223 sect->filepos = note->descpos
6224 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6227 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6228 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6229 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6232 sect->flags = SEC_HAS_CONTENTS;
6233 sect->alignment_power = 2;
6235 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6237 #endif /* defined (HAVE_LWPSTATUS_T) */
6239 #if defined (HAVE_WIN32_PSTATUS_T)
6241 elfcore_grok_win32pstatus (abfd, note)
6243 Elf_Internal_Note *note;
6248 win32_pstatus_t pstatus;
6250 if (note->descsz < sizeof (pstatus))
6253 memcpy (&pstatus, note->descdata, note->descsz);
6255 switch (pstatus.data_type)
6257 case NOTE_INFO_PROCESS:
6258 /* FIXME: need to add ->core_command. */
6259 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6260 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6263 case NOTE_INFO_THREAD:
6264 /* Make a ".reg/999" section. */
6265 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6267 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6273 sect = bfd_make_section (abfd, name);
6277 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6278 sect->filepos = (note->descpos
6279 + offsetof (struct win32_pstatus,
6280 data.thread_info.thread_context));
6281 sect->flags = SEC_HAS_CONTENTS;
6282 sect->alignment_power = 2;
6284 if (pstatus.data.thread_info.is_active_thread)
6285 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6289 case NOTE_INFO_MODULE:
6290 /* Make a ".module/xxxxxxxx" section. */
6291 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6293 name = bfd_alloc (abfd, (bfd_size_type) strlen (buf) + 1);
6299 sect = bfd_make_section (abfd, name);
6304 sect->_raw_size = note->descsz;
6305 sect->filepos = note->descpos;
6306 sect->flags = SEC_HAS_CONTENTS;
6307 sect->alignment_power = 2;
6316 #endif /* HAVE_WIN32_PSTATUS_T */
6319 elfcore_grok_note (abfd, note)
6321 Elf_Internal_Note *note;
6323 struct elf_backend_data *bed = get_elf_backend_data (abfd);
6331 if (bed->elf_backend_grok_prstatus)
6332 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6334 #if defined (HAVE_PRSTATUS_T)
6335 return elfcore_grok_prstatus (abfd, note);
6340 #if defined (HAVE_PSTATUS_T)
6342 return elfcore_grok_pstatus (abfd, note);
6345 #if defined (HAVE_LWPSTATUS_T)
6347 return elfcore_grok_lwpstatus (abfd, note);
6350 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
6351 return elfcore_grok_prfpreg (abfd, note);
6353 #if defined (HAVE_WIN32_PSTATUS_T)
6354 case NT_WIN32PSTATUS:
6355 return elfcore_grok_win32pstatus (abfd, note);
6358 case NT_PRXFPREG: /* Linux SSE extension */
6359 if (note->namesz == 5
6360 && ! strcmp (note->namedata, "LINUX"))
6361 return elfcore_grok_prxfpreg (abfd, note);
6367 if (bed->elf_backend_grok_psinfo)
6368 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6370 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6371 return elfcore_grok_psinfo (abfd, note);
6379 elfcore_netbsd_get_lwpid (note, lwpidp)
6380 Elf_Internal_Note *note;
6385 cp = strchr (note->namedata, '@');
6395 elfcore_grok_netbsd_procinfo (abfd, note)
6397 Elf_Internal_Note *note;
6400 /* Signal number at offset 0x08. */
6401 elf_tdata (abfd)->core_signal
6402 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
6404 /* Process ID at offset 0x50. */
6405 elf_tdata (abfd)->core_pid
6406 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
6408 /* Command name at 0x7c (max 32 bytes, including nul). */
6409 elf_tdata (abfd)->core_command
6410 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
6416 elfcore_grok_netbsd_note (abfd, note)
6418 Elf_Internal_Note *note;
6422 if (elfcore_netbsd_get_lwpid (note, &lwp))
6423 elf_tdata (abfd)->core_lwpid = lwp;
6425 if (note->type == 1)
6427 /* NetBSD-specific core "procinfo". Note that we expect to
6428 find this note before any of the others, which is fine,
6429 since the kernel writes this note out first when it
6430 creates a core file. */
6432 return elfcore_grok_netbsd_procinfo (abfd, note);
6435 /* There are not currently any other machine-independent notes defined
6436 for NetBSD ELF core files. If the note type is less than the start
6437 of the machine-dependent note types, we don't understand it. */
6439 if (note->type < 32)
6443 switch (bfd_get_arch (abfd))
6445 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6446 PT_GETFPREGS == mach+2. */
6448 case bfd_arch_alpha:
6449 case bfd_arch_sparc:
6453 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6456 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6462 /* On all other arch's, PT_GETREGS == mach+1 and
6463 PT_GETFPREGS == mach+3. */
6469 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6472 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6482 elfcore_read_notes (abfd, offset, size)
6493 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
6496 buf = bfd_malloc (size);
6500 if (bfd_bread (buf, size, abfd) != size)
6508 while (p < buf + size)
6510 /* FIXME: bad alignment assumption. */
6511 Elf_External_Note *xnp = (Elf_External_Note *) p;
6512 Elf_Internal_Note in;
6514 in.type = H_GET_32 (abfd, xnp->type);
6516 in.namesz = H_GET_32 (abfd, xnp->namesz);
6517 in.namedata = xnp->name;
6519 in.descsz = H_GET_32 (abfd, xnp->descsz);
6520 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
6521 in.descpos = offset + (in.descdata - buf);
6523 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
6525 if (! elfcore_grok_netbsd_note (abfd, &in))
6530 if (! elfcore_grok_note (abfd, &in))
6534 p = in.descdata + BFD_ALIGN (in.descsz, 4);
6541 /* Providing external access to the ELF program header table. */
6543 /* Return an upper bound on the number of bytes required to store a
6544 copy of ABFD's program header table entries. Return -1 if an error
6545 occurs; bfd_get_error will return an appropriate code. */
6548 bfd_get_elf_phdr_upper_bound (abfd)
6551 if (abfd->xvec->flavour != bfd_target_elf_flavour)
6553 bfd_set_error (bfd_error_wrong_format);
6557 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
6560 /* Copy ABFD's program header table entries to *PHDRS. The entries
6561 will be stored as an array of Elf_Internal_Phdr structures, as
6562 defined in include/elf/internal.h. To find out how large the
6563 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
6565 Return the number of program header table entries read, or -1 if an
6566 error occurs; bfd_get_error will return an appropriate code. */
6569 bfd_get_elf_phdrs (abfd, phdrs)
6575 if (abfd->xvec->flavour != bfd_target_elf_flavour)
6577 bfd_set_error (bfd_error_wrong_format);
6581 num_phdrs = elf_elfheader (abfd)->e_phnum;
6582 memcpy (phdrs, elf_tdata (abfd)->phdr,
6583 num_phdrs * sizeof (Elf_Internal_Phdr));
6589 _bfd_elf_sprintf_vma (abfd, buf, value)
6590 bfd *abfd ATTRIBUTE_UNUSED;
6595 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
6597 i_ehdrp = elf_elfheader (abfd);
6598 if (i_ehdrp == NULL)
6599 sprintf_vma (buf, value);
6602 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6604 #if BFD_HOST_64BIT_LONG
6605 sprintf (buf, "%016lx", value);
6607 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
6608 _bfd_int64_low (value));
6612 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
6615 sprintf_vma (buf, value);
6620 _bfd_elf_fprintf_vma (abfd, stream, value)
6621 bfd *abfd ATTRIBUTE_UNUSED;
6626 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
6628 i_ehdrp = elf_elfheader (abfd);
6629 if (i_ehdrp == NULL)
6630 fprintf_vma ((FILE *) stream, value);
6633 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6635 #if BFD_HOST_64BIT_LONG
6636 fprintf ((FILE *) stream, "%016lx", value);
6638 fprintf ((FILE *) stream, "%08lx%08lx",
6639 _bfd_int64_high (value), _bfd_int64_low (value));
6643 fprintf ((FILE *) stream, "%08lx",
6644 (unsigned long) (value & 0xffffffff));
6647 fprintf_vma ((FILE *) stream, value);
6651 enum elf_reloc_type_class
6652 _bfd_elf_reloc_type_class (rela)
6653 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
6655 return reloc_class_normal;
6658 /* For RELA architectures, return what the relocation value for
6659 relocation against a local symbol. */
6662 _bfd_elf_rela_local_sym (abfd, sym, sec, rel)
6664 Elf_Internal_Sym *sym;
6666 Elf_Internal_Rela *rel;
6670 relocation = (sec->output_section->vma
6671 + sec->output_offset
6673 if ((sec->flags & SEC_MERGE)
6674 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
6675 && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
6681 _bfd_merged_section_offset (abfd, &msec,
6682 elf_section_data (sec)->sec_info,
6683 sym->st_value + rel->r_addend,
6686 rel->r_addend += msec->output_section->vma + msec->output_offset;
6692 _bfd_elf_rel_local_sym (abfd, sym, psec, addend)
6694 Elf_Internal_Sym *sym;
6698 asection *sec = *psec;
6700 if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE)
6701 return sym->st_value + addend;
6703 return _bfd_merged_section_offset (abfd, psec,
6704 elf_section_data (sec)->sec_info,
6705 sym->st_value + addend, (bfd_vma) 0);
6709 _bfd_elf_section_offset (abfd, info, sec, offset)
6711 struct bfd_link_info *info;
6715 struct bfd_elf_section_data *sec_data;
6717 sec_data = elf_section_data (sec);
6718 switch (sec_data->sec_info_type)
6720 case ELF_INFO_TYPE_STABS:
6721 return _bfd_stab_section_offset
6722 (abfd, &elf_hash_table (info)->merge_info, sec, &sec_data->sec_info,
6724 case ELF_INFO_TYPE_EH_FRAME:
6725 return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);