1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
31 haven't bothered yet. */
33 /* For sparc64-cross-sparc32. */
41 #include "libiberty.h"
43 static INLINE
struct elf_segment_map
*make_mapping
44 PARAMS ((bfd
*, asection
**, unsigned int, unsigned int, boolean
));
45 static boolean map_sections_to_segments
PARAMS ((bfd
*));
46 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
47 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
48 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
49 static boolean prep_headers
PARAMS ((bfd
*));
50 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**, int));
51 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
52 static char *elf_read
PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
53 static boolean setup_group
PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
54 static void merge_sections_remove_hook
PARAMS ((bfd
*, asection
*));
55 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
56 static void set_group_contents
PARAMS ((bfd
*, asection
*, PTR
));
57 static boolean assign_section_numbers
PARAMS ((bfd
*));
58 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
59 static boolean elf_map_symbols
PARAMS ((bfd
*));
60 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
61 static boolean elfcore_read_notes
PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
62 static boolean elf_find_function
PARAMS ((bfd
*, asection
*, asymbol
**,
63 bfd_vma
, const char **,
65 static int elfcore_make_pid
PARAMS ((bfd
*));
66 static boolean elfcore_maybe_make_sect
PARAMS ((bfd
*, char *, asection
*));
67 static boolean elfcore_make_note_pseudosection
PARAMS ((bfd
*, char *,
68 Elf_Internal_Note
*));
69 static boolean elfcore_grok_prfpreg
PARAMS ((bfd
*, Elf_Internal_Note
*));
70 static boolean elfcore_grok_prxfpreg
PARAMS ((bfd
*, Elf_Internal_Note
*));
71 static boolean elfcore_grok_note
PARAMS ((bfd
*, Elf_Internal_Note
*));
73 static boolean elfcore_netbsd_get_lwpid
PARAMS ((Elf_Internal_Note
*, int *));
74 static boolean elfcore_grok_netbsd_procinfo
PARAMS ((bfd
*,
75 Elf_Internal_Note
*));
76 static boolean elfcore_grok_netbsd_note
PARAMS ((bfd
*, Elf_Internal_Note
*));
78 /* Swap version information in and out. The version information is
79 currently size independent. If that ever changes, this code will
80 need to move into elfcode.h. */
82 /* Swap in a Verdef structure. */
85 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
87 const Elf_External_Verdef
*src
;
88 Elf_Internal_Verdef
*dst
;
90 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
91 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
92 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
93 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
94 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
95 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
96 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
99 /* Swap out a Verdef structure. */
102 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
104 const Elf_Internal_Verdef
*src
;
105 Elf_External_Verdef
*dst
;
107 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
108 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
109 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
110 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
111 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
112 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
113 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
116 /* Swap in a Verdaux structure. */
119 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
121 const Elf_External_Verdaux
*src
;
122 Elf_Internal_Verdaux
*dst
;
124 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
125 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
128 /* Swap out a Verdaux structure. */
131 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
133 const Elf_Internal_Verdaux
*src
;
134 Elf_External_Verdaux
*dst
;
136 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
137 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
140 /* Swap in a Verneed structure. */
143 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
145 const Elf_External_Verneed
*src
;
146 Elf_Internal_Verneed
*dst
;
148 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
149 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
150 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
151 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
152 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
155 /* Swap out a Verneed structure. */
158 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
160 const Elf_Internal_Verneed
*src
;
161 Elf_External_Verneed
*dst
;
163 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
164 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
165 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
166 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
167 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
170 /* Swap in a Vernaux structure. */
173 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
175 const Elf_External_Vernaux
*src
;
176 Elf_Internal_Vernaux
*dst
;
178 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
179 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
180 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
181 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
182 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
185 /* Swap out a Vernaux structure. */
188 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
190 const Elf_Internal_Vernaux
*src
;
191 Elf_External_Vernaux
*dst
;
193 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
194 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
195 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
196 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
197 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
200 /* Swap in a Versym structure. */
203 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
205 const Elf_External_Versym
*src
;
206 Elf_Internal_Versym
*dst
;
208 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
211 /* Swap out a Versym structure. */
214 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
216 const Elf_Internal_Versym
*src
;
217 Elf_External_Versym
*dst
;
219 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
222 /* Standard ELF hash function. Do not change this function; you will
223 cause invalid hash tables to be generated. */
226 bfd_elf_hash (namearg
)
229 const unsigned char *name
= (const unsigned char *) namearg
;
234 while ((ch
= *name
++) != '\0')
237 if ((g
= (h
& 0xf0000000)) != 0)
240 /* The ELF ABI says `h &= ~g', but this is equivalent in
241 this case and on some machines one insn instead of two. */
248 /* Read a specified number of bytes at a specified offset in an ELF
249 file, into a newly allocated buffer, and return a pointer to the
253 elf_read (abfd
, offset
, size
)
260 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
262 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
264 if (bfd_bread ((PTR
) buf
, size
, abfd
) != size
)
266 if (bfd_get_error () != bfd_error_system_call
)
267 bfd_set_error (bfd_error_file_truncated
);
274 bfd_elf_mkobject (abfd
)
277 /* This just does initialization. */
278 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
279 bfd_size_type amt
= sizeof (struct elf_obj_tdata
);
280 elf_tdata (abfd
) = (struct elf_obj_tdata
*) bfd_zalloc (abfd
, amt
);
281 if (elf_tdata (abfd
) == 0)
283 /* Since everything is done at close time, do we need any
290 bfd_elf_mkcorefile (abfd
)
293 /* I think this can be done just like an object file. */
294 return bfd_elf_mkobject (abfd
);
298 bfd_elf_get_str_section (abfd
, shindex
)
300 unsigned int shindex
;
302 Elf_Internal_Shdr
**i_shdrp
;
303 char *shstrtab
= NULL
;
305 bfd_size_type shstrtabsize
;
307 i_shdrp
= elf_elfsections (abfd
);
308 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
311 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
312 if (shstrtab
== NULL
)
314 /* No cached one, attempt to read, and cache what we read. */
315 offset
= i_shdrp
[shindex
]->sh_offset
;
316 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
317 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
318 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
324 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
326 unsigned int shindex
;
327 unsigned int strindex
;
329 Elf_Internal_Shdr
*hdr
;
334 hdr
= elf_elfsections (abfd
)[shindex
];
336 if (hdr
->contents
== NULL
337 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
340 if (strindex
>= hdr
->sh_size
)
342 (*_bfd_error_handler
)
343 (_("%s: invalid string offset %u >= %lu for section `%s'"),
344 bfd_archive_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
345 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
346 && strindex
== hdr
->sh_name
)
348 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
352 return ((char *) hdr
->contents
) + strindex
;
355 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
356 sections. The first element is the flags, the rest are section
359 typedef union elf_internal_group
{
360 Elf_Internal_Shdr
*shdr
;
362 } Elf_Internal_Group
;
364 /* Set next_in_group list pointer, and group name for NEWSECT. */
367 setup_group (abfd
, hdr
, newsect
)
369 Elf_Internal_Shdr
*hdr
;
372 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
374 /* If num_group is zero, read in all SHT_GROUP sections. The count
375 is set to -1 if there are no SHT_GROUP sections. */
378 unsigned int i
, shnum
;
380 /* First count the number of groups. If we have a SHT_GROUP
381 section with just a flag word (ie. sh_size is 4), ignore it. */
382 shnum
= elf_numsections (abfd
);
384 for (i
= 0; i
< shnum
; i
++)
386 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
387 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
392 num_group
= (unsigned) -1;
393 elf_tdata (abfd
)->num_group
= num_group
;
397 /* We keep a list of elf section headers for group sections,
398 so we can find them quickly. */
399 bfd_size_type amt
= num_group
* sizeof (Elf_Internal_Shdr
*);
400 elf_tdata (abfd
)->group_sect_ptr
= bfd_alloc (abfd
, amt
);
401 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
405 for (i
= 0; i
< shnum
; i
++)
407 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
408 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
411 Elf_Internal_Group
*dest
;
413 /* Add to list of sections. */
414 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
417 /* Read the raw contents. */
418 BFD_ASSERT (sizeof (*dest
) >= 4);
419 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
420 shdr
->contents
= bfd_alloc (abfd
, amt
);
421 if (shdr
->contents
== NULL
422 || bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
423 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
427 /* Translate raw contents, a flag word followed by an
428 array of elf section indices all in target byte order,
429 to the flag word followed by an array of elf section
431 src
= shdr
->contents
+ shdr
->sh_size
;
432 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
439 idx
= H_GET_32 (abfd
, src
);
440 if (src
== shdr
->contents
)
447 ((*_bfd_error_handler
)
448 (_("%s: invalid SHT_GROUP entry"),
449 bfd_archive_filename (abfd
)));
452 dest
->shdr
= elf_elfsections (abfd
)[idx
];
459 if (num_group
!= (unsigned) -1)
463 for (i
= 0; i
< num_group
; i
++)
465 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
466 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
467 unsigned int n_elt
= shdr
->sh_size
/ 4;
469 /* Look through this group's sections to see if current
470 section is a member. */
472 if ((++idx
)->shdr
== hdr
)
476 /* We are a member of this group. Go looking through
477 other members to see if any others are linked via
479 idx
= (Elf_Internal_Group
*) shdr
->contents
;
480 n_elt
= shdr
->sh_size
/ 4;
482 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
483 && elf_next_in_group (s
) != NULL
)
487 /* Snarf the group name from other member, and
488 insert current section in circular list. */
489 elf_group_name (newsect
) = elf_group_name (s
);
490 elf_next_in_group (newsect
) = elf_next_in_group (s
);
491 elf_next_in_group (s
) = newsect
;
495 struct elf_backend_data
*bed
;
497 unsigned char ename
[4];
501 /* Humbug. Get the name from the group signature
502 symbol. Why isn't the signature just a string?
503 Fortunately, the name index is at the same
504 place in the external symbol for both 32 and 64
506 bed
= get_elf_backend_data (abfd
);
507 pos
= elf_tdata (abfd
)->symtab_hdr
.sh_offset
;
508 pos
+= shdr
->sh_info
* bed
->s
->sizeof_sym
;
509 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
510 || bfd_bread (ename
, (bfd_size_type
) 4, abfd
) != 4)
512 iname
= H_GET_32 (abfd
, ename
);
513 gname
= elf_string_from_elf_strtab (abfd
, iname
);
514 elf_group_name (newsect
) = gname
;
516 /* Start a circular list with one element. */
517 elf_next_in_group (newsect
) = newsect
;
519 if (shdr
->bfd_section
!= NULL
)
520 elf_next_in_group (shdr
->bfd_section
) = newsect
;
527 if (elf_group_name (newsect
) == NULL
)
529 (*_bfd_error_handler
) (_("%s: no group info for section %s"),
530 bfd_archive_filename (abfd
), newsect
->name
);
535 /* Make a BFD section from an ELF section. We store a pointer to the
536 BFD section in the bfd_section field of the header. */
539 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
541 Elf_Internal_Shdr
*hdr
;
546 struct elf_backend_data
*bed
;
548 if (hdr
->bfd_section
!= NULL
)
550 BFD_ASSERT (strcmp (name
,
551 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
555 newsect
= bfd_make_section_anyway (abfd
, name
);
559 newsect
->filepos
= hdr
->sh_offset
;
561 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
562 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
563 || ! bfd_set_section_alignment (abfd
, newsect
,
564 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
567 flags
= SEC_NO_FLAGS
;
568 if (hdr
->sh_type
!= SHT_NOBITS
)
569 flags
|= SEC_HAS_CONTENTS
;
570 if (hdr
->sh_type
== SHT_GROUP
)
571 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
572 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
575 if (hdr
->sh_type
!= SHT_NOBITS
)
578 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
579 flags
|= SEC_READONLY
;
580 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
582 else if ((flags
& SEC_LOAD
) != 0)
584 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
587 newsect
->entsize
= hdr
->sh_entsize
;
588 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
589 flags
|= SEC_STRINGS
;
591 if (hdr
->sh_flags
& SHF_GROUP
)
592 if (!setup_group (abfd
, hdr
, newsect
))
595 /* The debugging sections appear to be recognized only by name, not
598 static const char *debug_sec_names
[] =
607 for (i
= ARRAY_SIZE (debug_sec_names
); i
--;)
608 if (strncmp (name
, debug_sec_names
[i
], strlen (debug_sec_names
[i
])) == 0)
612 flags
|= SEC_DEBUGGING
;
615 /* As a GNU extension, if the name begins with .gnu.linkonce, we
616 only link a single copy of the section. This is used to support
617 g++. g++ will emit each template expansion in its own section.
618 The symbols will be defined as weak, so that multiple definitions
619 are permitted. The GNU linker extension is to actually discard
620 all but one of the sections. */
621 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
622 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
624 bed
= get_elf_backend_data (abfd
);
625 if (bed
->elf_backend_section_flags
)
626 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
629 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
632 if ((flags
& SEC_ALLOC
) != 0)
634 Elf_Internal_Phdr
*phdr
;
637 /* Look through the phdrs to see if we need to adjust the lma.
638 If all the p_paddr fields are zero, we ignore them, since
639 some ELF linkers produce such output. */
640 phdr
= elf_tdata (abfd
)->phdr
;
641 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
643 if (phdr
->p_paddr
!= 0)
646 if (i
< elf_elfheader (abfd
)->e_phnum
)
648 phdr
= elf_tdata (abfd
)->phdr
;
649 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
651 /* This section is part of this segment if its file
652 offset plus size lies within the segment's memory
653 span and, if the section is loaded, the extent of the
654 loaded data lies within the extent of the segment.
656 Note - we used to check the p_paddr field as well, and
657 refuse to set the LMA if it was 0. This is wrong
658 though, as a perfectly valid initialised segment can
659 have a p_paddr of zero. Some architectures, eg ARM,
660 place special significance on the address 0 and
661 executables need to be able to have a segment which
662 covers this address. */
663 if (phdr
->p_type
== PT_LOAD
664 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
665 && (hdr
->sh_offset
+ hdr
->sh_size
666 <= phdr
->p_offset
+ phdr
->p_memsz
)
667 && ((flags
& SEC_LOAD
) == 0
668 || (hdr
->sh_offset
+ hdr
->sh_size
669 <= phdr
->p_offset
+ phdr
->p_filesz
)))
671 if ((flags
& SEC_LOAD
) == 0)
672 newsect
->lma
= (phdr
->p_paddr
673 + hdr
->sh_addr
- phdr
->p_vaddr
);
675 /* We used to use the same adjustment for SEC_LOAD
676 sections, but that doesn't work if the segment
677 is packed with code from multiple VMAs.
678 Instead we calculate the section LMA based on
679 the segment LMA. It is assumed that the
680 segment will contain sections with contiguous
681 LMAs, even if the VMAs are not. */
682 newsect
->lma
= (phdr
->p_paddr
683 + hdr
->sh_offset
- phdr
->p_offset
);
685 /* With contiguous segments, we can't tell from file
686 offsets whether a section with zero size should
687 be placed at the end of one segment or the
688 beginning of the next. Decide based on vaddr. */
689 if (hdr
->sh_addr
>= phdr
->p_vaddr
690 && (hdr
->sh_addr
+ hdr
->sh_size
691 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
698 hdr
->bfd_section
= newsect
;
699 elf_section_data (newsect
)->this_hdr
= *hdr
;
709 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
712 Helper functions for GDB to locate the string tables.
713 Since BFD hides string tables from callers, GDB needs to use an
714 internal hook to find them. Sun's .stabstr, in particular,
715 isn't even pointed to by the .stab section, so ordinary
716 mechanisms wouldn't work to find it, even if we had some.
719 struct elf_internal_shdr
*
720 bfd_elf_find_section (abfd
, name
)
724 Elf_Internal_Shdr
**i_shdrp
;
729 i_shdrp
= elf_elfsections (abfd
);
732 shstrtab
= bfd_elf_get_str_section (abfd
,
733 elf_elfheader (abfd
)->e_shstrndx
);
734 if (shstrtab
!= NULL
)
736 max
= elf_numsections (abfd
);
737 for (i
= 1; i
< max
; i
++)
738 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
745 const char *const bfd_elf_section_type_names
[] = {
746 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
747 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
748 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
751 /* ELF relocs are against symbols. If we are producing relocateable
752 output, and the reloc is against an external symbol, and nothing
753 has given us any additional addend, the resulting reloc will also
754 be against the same symbol. In such a case, we don't want to
755 change anything about the way the reloc is handled, since it will
756 all be done at final link time. Rather than put special case code
757 into bfd_perform_relocation, all the reloc types use this howto
758 function. It just short circuits the reloc if producing
759 relocateable output against an external symbol. */
761 bfd_reloc_status_type
762 bfd_elf_generic_reloc (abfd
,
769 bfd
*abfd ATTRIBUTE_UNUSED
;
770 arelent
*reloc_entry
;
772 PTR data ATTRIBUTE_UNUSED
;
773 asection
*input_section
;
775 char **error_message ATTRIBUTE_UNUSED
;
777 if (output_bfd
!= (bfd
*) NULL
778 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
779 && (! reloc_entry
->howto
->partial_inplace
780 || reloc_entry
->addend
== 0))
782 reloc_entry
->address
+= input_section
->output_offset
;
786 return bfd_reloc_continue
;
789 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
792 merge_sections_remove_hook (abfd
, sec
)
793 bfd
*abfd ATTRIBUTE_UNUSED
;
796 struct bfd_elf_section_data
*sec_data
;
798 sec_data
= elf_section_data (sec
);
799 BFD_ASSERT (sec_data
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
800 sec_data
->sec_info_type
= ELF_INFO_TYPE_NONE
;
803 /* Finish SHF_MERGE section merging. */
806 _bfd_elf_merge_sections (abfd
, info
)
808 struct bfd_link_info
*info
;
810 if (!is_elf_hash_table (info
))
812 if (elf_hash_table (info
)->merge_info
)
813 _bfd_merge_sections (abfd
, elf_hash_table (info
)->merge_info
,
814 merge_sections_remove_hook
);
818 /* Copy the program header and other data from one object module to
822 _bfd_elf_copy_private_bfd_data (ibfd
, obfd
)
826 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
827 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
830 BFD_ASSERT (!elf_flags_init (obfd
)
831 || (elf_elfheader (obfd
)->e_flags
832 == elf_elfheader (ibfd
)->e_flags
));
834 elf_gp (obfd
) = elf_gp (ibfd
);
835 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
836 elf_flags_init (obfd
) = true;
840 /* Print out the program headers. */
843 _bfd_elf_print_private_bfd_data (abfd
, farg
)
847 FILE *f
= (FILE *) farg
;
848 Elf_Internal_Phdr
*p
;
850 bfd_byte
*dynbuf
= NULL
;
852 p
= elf_tdata (abfd
)->phdr
;
857 fprintf (f
, _("\nProgram Header:\n"));
858 c
= elf_elfheader (abfd
)->e_phnum
;
859 for (i
= 0; i
< c
; i
++, p
++)
866 case PT_NULL
: pt
= "NULL"; break;
867 case PT_LOAD
: pt
= "LOAD"; break;
868 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
869 case PT_INTERP
: pt
= "INTERP"; break;
870 case PT_NOTE
: pt
= "NOTE"; break;
871 case PT_SHLIB
: pt
= "SHLIB"; break;
872 case PT_PHDR
: pt
= "PHDR"; break;
873 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
874 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
876 fprintf (f
, "%8s off 0x", pt
);
877 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
878 fprintf (f
, " vaddr 0x");
879 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
880 fprintf (f
, " paddr 0x");
881 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
882 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
883 fprintf (f
, " filesz 0x");
884 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
885 fprintf (f
, " memsz 0x");
886 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
887 fprintf (f
, " flags %c%c%c",
888 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
889 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
890 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
891 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
892 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
897 s
= bfd_get_section_by_name (abfd
, ".dynamic");
901 unsigned long shlink
;
902 bfd_byte
*extdyn
, *extdynend
;
904 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
906 fprintf (f
, _("\nDynamic Section:\n"));
908 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
911 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
915 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
918 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
920 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
921 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
924 extdynend
= extdyn
+ s
->_raw_size
;
925 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
927 Elf_Internal_Dyn dyn
;
932 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
934 if (dyn
.d_tag
== DT_NULL
)
941 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
945 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
946 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
947 case DT_PLTGOT
: name
= "PLTGOT"; break;
948 case DT_HASH
: name
= "HASH"; break;
949 case DT_STRTAB
: name
= "STRTAB"; break;
950 case DT_SYMTAB
: name
= "SYMTAB"; break;
951 case DT_RELA
: name
= "RELA"; break;
952 case DT_RELASZ
: name
= "RELASZ"; break;
953 case DT_RELAENT
: name
= "RELAENT"; break;
954 case DT_STRSZ
: name
= "STRSZ"; break;
955 case DT_SYMENT
: name
= "SYMENT"; break;
956 case DT_INIT
: name
= "INIT"; break;
957 case DT_FINI
: name
= "FINI"; break;
958 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
959 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
960 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
961 case DT_REL
: name
= "REL"; break;
962 case DT_RELSZ
: name
= "RELSZ"; break;
963 case DT_RELENT
: name
= "RELENT"; break;
964 case DT_PLTREL
: name
= "PLTREL"; break;
965 case DT_DEBUG
: name
= "DEBUG"; break;
966 case DT_TEXTREL
: name
= "TEXTREL"; break;
967 case DT_JMPREL
: name
= "JMPREL"; break;
968 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
969 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
970 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
971 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
972 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
973 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= true; break;
974 case DT_FLAGS
: name
= "FLAGS"; break;
975 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
976 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
977 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
978 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
979 case DT_MOVEENT
: name
= "MOVEENT"; break;
980 case DT_MOVESZ
: name
= "MOVESZ"; break;
981 case DT_FEATURE
: name
= "FEATURE"; break;
982 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
983 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
984 case DT_SYMINENT
: name
= "SYMINENT"; break;
985 case DT_CONFIG
: name
= "CONFIG"; stringp
= true; break;
986 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= true; break;
987 case DT_AUDIT
: name
= "AUDIT"; stringp
= true; break;
988 case DT_PLTPAD
: name
= "PLTPAD"; break;
989 case DT_MOVETAB
: name
= "MOVETAB"; break;
990 case DT_SYMINFO
: name
= "SYMINFO"; break;
991 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
992 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
993 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
994 case DT_VERSYM
: name
= "VERSYM"; break;
995 case DT_VERDEF
: name
= "VERDEF"; break;
996 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
997 case DT_VERNEED
: name
= "VERNEED"; break;
998 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
999 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
1000 case DT_USED
: name
= "USED"; break;
1001 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
1004 fprintf (f
, " %-11s ", name
);
1006 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1010 unsigned int tagv
= dyn
.d_un
.d_val
;
1012 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1015 fprintf (f
, "%s", string
);
1024 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1025 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1027 if (! _bfd_elf_slurp_version_tables (abfd
))
1031 if (elf_dynverdef (abfd
) != 0)
1033 Elf_Internal_Verdef
*t
;
1035 fprintf (f
, _("\nVersion definitions:\n"));
1036 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1038 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1039 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1040 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1042 Elf_Internal_Verdaux
*a
;
1045 for (a
= t
->vd_auxptr
->vda_nextptr
;
1048 fprintf (f
, "%s ", a
->vda_nodename
);
1054 if (elf_dynverref (abfd
) != 0)
1056 Elf_Internal_Verneed
*t
;
1058 fprintf (f
, _("\nVersion References:\n"));
1059 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1061 Elf_Internal_Vernaux
*a
;
1063 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1064 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1065 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1066 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1078 /* Display ELF-specific fields of a symbol. */
1081 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
1085 bfd_print_symbol_type how
;
1087 FILE *file
= (FILE *) filep
;
1090 case bfd_print_symbol_name
:
1091 fprintf (file
, "%s", symbol
->name
);
1093 case bfd_print_symbol_more
:
1094 fprintf (file
, "elf ");
1095 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1096 fprintf (file
, " %lx", (long) symbol
->flags
);
1098 case bfd_print_symbol_all
:
1100 const char *section_name
;
1101 const char *name
= NULL
;
1102 struct elf_backend_data
*bed
;
1103 unsigned char st_other
;
1106 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1108 bed
= get_elf_backend_data (abfd
);
1109 if (bed
->elf_backend_print_symbol_all
)
1110 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1114 name
= symbol
->name
;
1115 bfd_print_symbol_vandf (abfd
, (PTR
) file
, symbol
);
1118 fprintf (file
, " %s\t", section_name
);
1119 /* Print the "other" value for a symbol. For common symbols,
1120 we've already printed the size; now print the alignment.
1121 For other symbols, we have no specified alignment, and
1122 we've printed the address; now print the size. */
1123 if (bfd_is_com_section (symbol
->section
))
1124 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1126 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1127 bfd_fprintf_vma (abfd
, file
, val
);
1129 /* If we have version information, print it. */
1130 if (elf_tdata (abfd
)->dynversym_section
!= 0
1131 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1132 || elf_tdata (abfd
)->dynverref_section
!= 0))
1134 unsigned int vernum
;
1135 const char *version_string
;
1137 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1140 version_string
= "";
1141 else if (vernum
== 1)
1142 version_string
= "Base";
1143 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1145 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1148 Elf_Internal_Verneed
*t
;
1150 version_string
= "";
1151 for (t
= elf_tdata (abfd
)->verref
;
1155 Elf_Internal_Vernaux
*a
;
1157 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1159 if (a
->vna_other
== vernum
)
1161 version_string
= a
->vna_nodename
;
1168 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1169 fprintf (file
, " %-11s", version_string
);
1174 fprintf (file
, " (%s)", version_string
);
1175 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1180 /* If the st_other field is not zero, print it. */
1181 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1186 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1187 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1188 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1190 /* Some other non-defined flags are also present, so print
1192 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1195 fprintf (file
, " %s", name
);
1201 /* Create an entry in an ELF linker hash table. */
1203 struct bfd_hash_entry
*
1204 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
1205 struct bfd_hash_entry
*entry
;
1206 struct bfd_hash_table
*table
;
1209 /* Allocate the structure if it has not already been allocated by a
1213 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1218 /* Call the allocation method of the superclass. */
1219 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1222 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1223 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1225 /* Set local fields. */
1229 ret
->dynstr_index
= 0;
1230 ret
->weakdef
= NULL
;
1231 ret
->got
.refcount
= htab
->init_refcount
;
1232 ret
->plt
.refcount
= htab
->init_refcount
;
1233 ret
->linker_section_pointer
= NULL
;
1234 ret
->verinfo
.verdef
= NULL
;
1235 ret
->vtable_entries_used
= NULL
;
1236 ret
->vtable_entries_size
= 0;
1237 ret
->vtable_parent
= NULL
;
1238 ret
->type
= STT_NOTYPE
;
1240 /* Assume that we have been called by a non-ELF symbol reader.
1241 This flag is then reset by the code which reads an ELF input
1242 file. This ensures that a symbol created by a non-ELF symbol
1243 reader will have the flag set correctly. */
1244 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
1250 /* Copy data from an indirect symbol to its direct symbol, hiding the
1251 old indirect symbol. Also used for copying flags to a weakdef. */
1254 _bfd_elf_link_hash_copy_indirect (dir
, ind
)
1255 struct elf_link_hash_entry
*dir
, *ind
;
1259 /* Copy down any references that we may have already seen to the
1260 symbol which just became indirect. */
1262 dir
->elf_link_hash_flags
|=
1263 (ind
->elf_link_hash_flags
1264 & (ELF_LINK_HASH_REF_DYNAMIC
1265 | ELF_LINK_HASH_REF_REGULAR
1266 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1267 | ELF_LINK_NON_GOT_REF
));
1269 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1272 /* Copy over the global and procedure linkage table refcount entries.
1273 These may have been already set up by a check_relocs routine. */
1274 tmp
= dir
->got
.refcount
;
1277 dir
->got
.refcount
= ind
->got
.refcount
;
1278 ind
->got
.refcount
= tmp
;
1281 BFD_ASSERT (ind
->got
.refcount
<= 0);
1283 tmp
= dir
->plt
.refcount
;
1286 dir
->plt
.refcount
= ind
->plt
.refcount
;
1287 ind
->plt
.refcount
= tmp
;
1290 BFD_ASSERT (ind
->plt
.refcount
<= 0);
1292 if (dir
->dynindx
== -1)
1294 dir
->dynindx
= ind
->dynindx
;
1295 dir
->dynstr_index
= ind
->dynstr_index
;
1297 ind
->dynstr_index
= 0;
1300 BFD_ASSERT (ind
->dynindx
== -1);
1304 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
)
1305 struct bfd_link_info
*info
;
1306 struct elf_link_hash_entry
*h
;
1307 boolean force_local
;
1309 h
->plt
.offset
= (bfd_vma
) -1;
1310 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1313 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
1314 if (h
->dynindx
!= -1)
1317 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1323 /* Initialize an ELF linker hash table. */
1326 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
1327 struct elf_link_hash_table
*table
;
1329 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
1330 struct bfd_hash_table
*,
1335 table
->dynamic_sections_created
= false;
1336 table
->dynobj
= NULL
;
1337 table
->init_refcount
= get_elf_backend_data (abfd
)->can_refcount
- 1;
1338 /* The first dynamic symbol is a dummy. */
1339 table
->dynsymcount
= 1;
1340 table
->dynstr
= NULL
;
1341 table
->bucketcount
= 0;
1342 table
->needed
= NULL
;
1343 table
->runpath
= NULL
;
1345 table
->stab_info
= NULL
;
1346 table
->merge_info
= NULL
;
1347 table
->dynlocal
= NULL
;
1348 ret
= _bfd_link_hash_table_init (& table
->root
, abfd
, newfunc
);
1349 table
->root
.type
= bfd_link_elf_hash_table
;
1354 /* Create an ELF linker hash table. */
1356 struct bfd_link_hash_table
*
1357 _bfd_elf_link_hash_table_create (abfd
)
1360 struct elf_link_hash_table
*ret
;
1361 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1363 ret
= (struct elf_link_hash_table
*) bfd_malloc (amt
);
1364 if (ret
== (struct elf_link_hash_table
*) NULL
)
1367 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1376 /* This is a hook for the ELF emulation code in the generic linker to
1377 tell the backend linker what file name to use for the DT_NEEDED
1378 entry for a dynamic object. The generic linker passes name as an
1379 empty string to indicate that no DT_NEEDED entry should be made. */
1382 bfd_elf_set_dt_needed_name (abfd
, name
)
1386 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1387 && bfd_get_format (abfd
) == bfd_object
)
1388 elf_dt_name (abfd
) = name
;
1392 bfd_elf_set_dt_needed_soname (abfd
, name
)
1396 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1397 && bfd_get_format (abfd
) == bfd_object
)
1398 elf_dt_soname (abfd
) = name
;
1401 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1402 the linker ELF emulation code. */
1404 struct bfd_link_needed_list
*
1405 bfd_elf_get_needed_list (abfd
, info
)
1406 bfd
*abfd ATTRIBUTE_UNUSED
;
1407 struct bfd_link_info
*info
;
1409 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1411 return elf_hash_table (info
)->needed
;
1414 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1415 hook for the linker ELF emulation code. */
1417 struct bfd_link_needed_list
*
1418 bfd_elf_get_runpath_list (abfd
, info
)
1419 bfd
*abfd ATTRIBUTE_UNUSED
;
1420 struct bfd_link_info
*info
;
1422 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1424 return elf_hash_table (info
)->runpath
;
1427 /* Get the name actually used for a dynamic object for a link. This
1428 is the SONAME entry if there is one. Otherwise, it is the string
1429 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1432 bfd_elf_get_dt_soname (abfd
)
1435 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1436 && bfd_get_format (abfd
) == bfd_object
)
1437 return elf_dt_name (abfd
);
1441 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1442 the ELF linker emulation code. */
1445 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
1447 struct bfd_link_needed_list
**pneeded
;
1450 bfd_byte
*dynbuf
= NULL
;
1452 unsigned long shlink
;
1453 bfd_byte
*extdyn
, *extdynend
;
1455 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1459 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1460 || bfd_get_format (abfd
) != bfd_object
)
1463 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1464 if (s
== NULL
|| s
->_raw_size
== 0)
1467 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1471 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1475 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1479 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1481 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1482 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1485 extdynend
= extdyn
+ s
->_raw_size
;
1486 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1488 Elf_Internal_Dyn dyn
;
1490 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1492 if (dyn
.d_tag
== DT_NULL
)
1495 if (dyn
.d_tag
== DT_NEEDED
)
1498 struct bfd_link_needed_list
*l
;
1499 unsigned int tagv
= dyn
.d_un
.d_val
;
1502 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1507 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1528 /* Allocate an ELF string table--force the first byte to be zero. */
1530 struct bfd_strtab_hash
*
1531 _bfd_elf_stringtab_init ()
1533 struct bfd_strtab_hash
*ret
;
1535 ret
= _bfd_stringtab_init ();
1540 loc
= _bfd_stringtab_add (ret
, "", true, false);
1541 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1542 if (loc
== (bfd_size_type
) -1)
1544 _bfd_stringtab_free (ret
);
1551 /* ELF .o/exec file reading */
1553 /* Create a new bfd section from an ELF section header. */
1556 bfd_section_from_shdr (abfd
, shindex
)
1558 unsigned int shindex
;
1560 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1561 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1562 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1565 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1567 switch (hdr
->sh_type
)
1570 /* Inactive section. Throw it away. */
1573 case SHT_PROGBITS
: /* Normal section with contents. */
1574 case SHT_DYNAMIC
: /* Dynamic linking information. */
1575 case SHT_NOBITS
: /* .bss section. */
1576 case SHT_HASH
: /* .hash section. */
1577 case SHT_NOTE
: /* .note section. */
1578 case SHT_INIT_ARRAY
: /* .init_array section. */
1579 case SHT_FINI_ARRAY
: /* .fini_array section. */
1580 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1581 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1583 case SHT_SYMTAB
: /* A symbol table */
1584 if (elf_onesymtab (abfd
) == shindex
)
1587 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1588 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1589 elf_onesymtab (abfd
) = shindex
;
1590 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1591 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1592 abfd
->flags
|= HAS_SYMS
;
1594 /* Sometimes a shared object will map in the symbol table. If
1595 SHF_ALLOC is set, and this is a shared object, then we also
1596 treat this section as a BFD section. We can not base the
1597 decision purely on SHF_ALLOC, because that flag is sometimes
1598 set in a relocateable object file, which would confuse the
1600 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1601 && (abfd
->flags
& DYNAMIC
) != 0
1602 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1607 case SHT_DYNSYM
: /* A dynamic symbol table */
1608 if (elf_dynsymtab (abfd
) == shindex
)
1611 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1612 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1613 elf_dynsymtab (abfd
) = shindex
;
1614 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1615 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1616 abfd
->flags
|= HAS_SYMS
;
1618 /* Besides being a symbol table, we also treat this as a regular
1619 section, so that objcopy can handle it. */
1620 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1622 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1623 if (elf_symtab_shndx (abfd
) == shindex
)
1626 /* Get the associated symbol table. */
1627 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
)
1628 || hdr
->sh_link
!= elf_onesymtab (abfd
))
1631 elf_symtab_shndx (abfd
) = shindex
;
1632 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1633 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1636 case SHT_STRTAB
: /* A string table */
1637 if (hdr
->bfd_section
!= NULL
)
1639 if (ehdr
->e_shstrndx
== shindex
)
1641 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1642 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1646 unsigned int i
, num_sec
;
1648 num_sec
= elf_numsections (abfd
);
1649 for (i
= 1; i
< num_sec
; i
++)
1651 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1652 if (hdr2
->sh_link
== shindex
)
1654 if (! bfd_section_from_shdr (abfd
, i
))
1656 if (elf_onesymtab (abfd
) == i
)
1658 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1659 elf_elfsections (abfd
)[shindex
] =
1660 &elf_tdata (abfd
)->strtab_hdr
;
1663 if (elf_dynsymtab (abfd
) == i
)
1665 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1666 elf_elfsections (abfd
)[shindex
] = hdr
=
1667 &elf_tdata (abfd
)->dynstrtab_hdr
;
1668 /* We also treat this as a regular section, so
1669 that objcopy can handle it. */
1672 #if 0 /* Not handling other string tables specially right now. */
1673 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1674 /* We have a strtab for some random other section. */
1675 newsect
= (asection
*) hdr2
->bfd_section
;
1678 hdr
->bfd_section
= newsect
;
1679 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1681 elf_elfsections (abfd
)[shindex
] = hdr2
;
1687 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1691 /* *These* do a lot of work -- but build no sections! */
1693 asection
*target_sect
;
1694 Elf_Internal_Shdr
*hdr2
;
1695 unsigned int num_sec
= elf_numsections (abfd
);
1697 /* Check for a bogus link to avoid crashing. */
1698 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1699 || hdr
->sh_link
>= num_sec
)
1701 ((*_bfd_error_handler
)
1702 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1703 bfd_archive_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1704 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1707 /* For some incomprehensible reason Oracle distributes
1708 libraries for Solaris in which some of the objects have
1709 bogus sh_link fields. It would be nice if we could just
1710 reject them, but, unfortunately, some people need to use
1711 them. We scan through the section headers; if we find only
1712 one suitable symbol table, we clobber the sh_link to point
1713 to it. I hope this doesn't break anything. */
1714 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1715 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1721 for (scan
= 1; scan
< num_sec
; scan
++)
1723 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1724 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1735 hdr
->sh_link
= found
;
1738 /* Get the symbol table. */
1739 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1740 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1743 /* If this reloc section does not use the main symbol table we
1744 don't treat it as a reloc section. BFD can't adequately
1745 represent such a section, so at least for now, we don't
1746 try. We just present it as a normal section. We also
1747 can't use it as a reloc section if it points to the null
1749 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1750 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1752 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1754 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1755 if (target_sect
== NULL
)
1758 if ((target_sect
->flags
& SEC_RELOC
) == 0
1759 || target_sect
->reloc_count
== 0)
1760 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1764 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1765 amt
= sizeof (*hdr2
);
1766 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
1767 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1770 elf_elfsections (abfd
)[shindex
] = hdr2
;
1771 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1772 target_sect
->flags
|= SEC_RELOC
;
1773 target_sect
->relocation
= NULL
;
1774 target_sect
->rel_filepos
= hdr
->sh_offset
;
1775 /* In the section to which the relocations apply, mark whether
1776 its relocations are of the REL or RELA variety. */
1777 if (hdr
->sh_size
!= 0)
1778 elf_section_data (target_sect
)->use_rela_p
1779 = (hdr
->sh_type
== SHT_RELA
);
1780 abfd
->flags
|= HAS_RELOC
;
1785 case SHT_GNU_verdef
:
1786 elf_dynverdef (abfd
) = shindex
;
1787 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1788 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1791 case SHT_GNU_versym
:
1792 elf_dynversym (abfd
) = shindex
;
1793 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1794 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1797 case SHT_GNU_verneed
:
1798 elf_dynverref (abfd
) = shindex
;
1799 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1800 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1807 /* Make a section for objcopy and relocatable links. */
1808 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1810 if (hdr
->contents
!= NULL
)
1812 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1813 unsigned int n_elt
= hdr
->sh_size
/ 4;
1816 while (--n_elt
!= 0)
1817 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
1818 && elf_next_in_group (s
) != NULL
)
1820 elf_next_in_group (hdr
->bfd_section
) = s
;
1827 /* Check for any processor-specific section types. */
1829 if (bed
->elf_backend_section_from_shdr
)
1830 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1838 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1839 Return SEC for sections that have no elf section, and NULL on error. */
1842 bfd_section_from_r_symndx (abfd
, cache
, sec
, r_symndx
)
1844 struct sym_sec_cache
*cache
;
1846 unsigned long r_symndx
;
1848 unsigned char esym_shndx
[4];
1849 unsigned int isym_shndx
;
1850 Elf_Internal_Shdr
*symtab_hdr
;
1853 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1855 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
1856 return cache
->sec
[ent
];
1858 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1859 pos
= symtab_hdr
->sh_offset
;
1860 if (get_elf_backend_data (abfd
)->s
->sizeof_sym
1861 == sizeof (Elf64_External_Sym
))
1863 pos
+= r_symndx
* sizeof (Elf64_External_Sym
);
1864 pos
+= offsetof (Elf64_External_Sym
, st_shndx
);
1865 amt
= sizeof (((Elf64_External_Sym
*) 0)->st_shndx
);
1869 pos
+= r_symndx
* sizeof (Elf32_External_Sym
);
1870 pos
+= offsetof (Elf32_External_Sym
, st_shndx
);
1871 amt
= sizeof (((Elf32_External_Sym
*) 0)->st_shndx
);
1873 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1874 || bfd_bread ((PTR
) esym_shndx
, amt
, abfd
) != amt
)
1876 isym_shndx
= H_GET_16 (abfd
, esym_shndx
);
1878 if (isym_shndx
== SHN_XINDEX
)
1880 Elf_Internal_Shdr
*shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1881 if (shndx_hdr
->sh_size
!= 0)
1883 pos
= shndx_hdr
->sh_offset
;
1884 pos
+= r_symndx
* sizeof (Elf_External_Sym_Shndx
);
1885 amt
= sizeof (Elf_External_Sym_Shndx
);
1886 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1887 || bfd_bread ((PTR
) esym_shndx
, amt
, abfd
) != amt
)
1889 isym_shndx
= H_GET_32 (abfd
, esym_shndx
);
1893 if (cache
->abfd
!= abfd
)
1895 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1898 cache
->indx
[ent
] = r_symndx
;
1899 cache
->sec
[ent
] = sec
;
1900 if (isym_shndx
< SHN_LORESERVE
|| isym_shndx
> SHN_HIRESERVE
)
1903 s
= bfd_section_from_elf_index (abfd
, isym_shndx
);
1905 cache
->sec
[ent
] = s
;
1907 return cache
->sec
[ent
];
1910 /* Given an ELF section number, retrieve the corresponding BFD
1914 bfd_section_from_elf_index (abfd
, index
)
1918 if (index
>= elf_numsections (abfd
))
1920 return elf_elfsections (abfd
)[index
]->bfd_section
;
1924 _bfd_elf_new_section_hook (abfd
, sec
)
1928 struct bfd_elf_section_data
*sdata
;
1929 bfd_size_type amt
= sizeof (*sdata
);
1931 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, amt
);
1934 sec
->used_by_bfd
= (PTR
) sdata
;
1936 /* Indicate whether or not this section should use RELA relocations. */
1938 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1943 /* Create a new bfd section from an ELF program header.
1945 Since program segments have no names, we generate a synthetic name
1946 of the form segment<NUM>, where NUM is generally the index in the
1947 program header table. For segments that are split (see below) we
1948 generate the names segment<NUM>a and segment<NUM>b.
1950 Note that some program segments may have a file size that is different than
1951 (less than) the memory size. All this means is that at execution the
1952 system must allocate the amount of memory specified by the memory size,
1953 but only initialize it with the first "file size" bytes read from the
1954 file. This would occur for example, with program segments consisting
1955 of combined data+bss.
1957 To handle the above situation, this routine generates TWO bfd sections
1958 for the single program segment. The first has the length specified by
1959 the file size of the segment, and the second has the length specified
1960 by the difference between the two sizes. In effect, the segment is split
1961 into it's initialized and uninitialized parts.
1966 _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
)
1968 Elf_Internal_Phdr
*hdr
;
1970 const char *typename
;
1977 split
= ((hdr
->p_memsz
> 0)
1978 && (hdr
->p_filesz
> 0)
1979 && (hdr
->p_memsz
> hdr
->p_filesz
));
1980 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
1981 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
1984 strcpy (name
, namebuf
);
1985 newsect
= bfd_make_section (abfd
, name
);
1986 if (newsect
== NULL
)
1988 newsect
->vma
= hdr
->p_vaddr
;
1989 newsect
->lma
= hdr
->p_paddr
;
1990 newsect
->_raw_size
= hdr
->p_filesz
;
1991 newsect
->filepos
= hdr
->p_offset
;
1992 newsect
->flags
|= SEC_HAS_CONTENTS
;
1993 if (hdr
->p_type
== PT_LOAD
)
1995 newsect
->flags
|= SEC_ALLOC
;
1996 newsect
->flags
|= SEC_LOAD
;
1997 if (hdr
->p_flags
& PF_X
)
1999 /* FIXME: all we known is that it has execute PERMISSION,
2001 newsect
->flags
|= SEC_CODE
;
2004 if (!(hdr
->p_flags
& PF_W
))
2006 newsect
->flags
|= SEC_READONLY
;
2011 sprintf (namebuf
, "%s%db", typename
, index
);
2012 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
2015 strcpy (name
, namebuf
);
2016 newsect
= bfd_make_section (abfd
, name
);
2017 if (newsect
== NULL
)
2019 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2020 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2021 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
2022 if (hdr
->p_type
== PT_LOAD
)
2024 newsect
->flags
|= SEC_ALLOC
;
2025 if (hdr
->p_flags
& PF_X
)
2026 newsect
->flags
|= SEC_CODE
;
2028 if (!(hdr
->p_flags
& PF_W
))
2029 newsect
->flags
|= SEC_READONLY
;
2036 bfd_section_from_phdr (abfd
, hdr
, index
)
2038 Elf_Internal_Phdr
*hdr
;
2041 struct elf_backend_data
*bed
;
2043 switch (hdr
->p_type
)
2046 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2049 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2052 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2055 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2058 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2060 if (! elfcore_read_notes (abfd
, (file_ptr
) hdr
->p_offset
, hdr
->p_filesz
))
2065 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2068 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2071 /* Check for any processor-specific program segment types.
2072 If no handler for them, default to making "segment" sections. */
2073 bed
= get_elf_backend_data (abfd
);
2074 if (bed
->elf_backend_section_from_phdr
)
2075 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
2077 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
2081 /* Initialize REL_HDR, the section-header for new section, containing
2082 relocations against ASECT. If USE_RELA_P is true, we use RELA
2083 relocations; otherwise, we use REL relocations. */
2086 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
2088 Elf_Internal_Shdr
*rel_hdr
;
2093 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2094 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2096 name
= bfd_alloc (abfd
, amt
);
2099 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2101 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2103 if (rel_hdr
->sh_name
== (unsigned int) -1)
2105 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2106 rel_hdr
->sh_entsize
= (use_rela_p
2107 ? bed
->s
->sizeof_rela
2108 : bed
->s
->sizeof_rel
);
2109 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
2110 rel_hdr
->sh_flags
= 0;
2111 rel_hdr
->sh_addr
= 0;
2112 rel_hdr
->sh_size
= 0;
2113 rel_hdr
->sh_offset
= 0;
2118 /* Set up an ELF internal section header for a section. */
2121 elf_fake_sections (abfd
, asect
, failedptrarg
)
2126 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2127 boolean
*failedptr
= (boolean
*) failedptrarg
;
2128 Elf_Internal_Shdr
*this_hdr
;
2132 /* We already failed; just get out of the bfd_map_over_sections
2137 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2139 this_hdr
->sh_name
= (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2140 asect
->name
, false);
2141 if (this_hdr
->sh_name
== (unsigned long) -1)
2147 this_hdr
->sh_flags
= 0;
2149 if ((asect
->flags
& SEC_ALLOC
) != 0
2150 || asect
->user_set_vma
)
2151 this_hdr
->sh_addr
= asect
->vma
;
2153 this_hdr
->sh_addr
= 0;
2155 this_hdr
->sh_offset
= 0;
2156 this_hdr
->sh_size
= asect
->_raw_size
;
2157 this_hdr
->sh_link
= 0;
2158 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2159 /* The sh_entsize and sh_info fields may have been set already by
2160 copy_private_section_data. */
2162 this_hdr
->bfd_section
= asect
;
2163 this_hdr
->contents
= NULL
;
2165 /* FIXME: This should not be based on section names. */
2166 if (strcmp (asect
->name
, ".dynstr") == 0)
2167 this_hdr
->sh_type
= SHT_STRTAB
;
2168 else if (strcmp (asect
->name
, ".hash") == 0)
2170 this_hdr
->sh_type
= SHT_HASH
;
2171 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2173 else if (strcmp (asect
->name
, ".dynsym") == 0)
2175 this_hdr
->sh_type
= SHT_DYNSYM
;
2176 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2178 else if (strcmp (asect
->name
, ".dynamic") == 0)
2180 this_hdr
->sh_type
= SHT_DYNAMIC
;
2181 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2183 else if (strncmp (asect
->name
, ".rela", 5) == 0
2184 && get_elf_backend_data (abfd
)->may_use_rela_p
)
2186 this_hdr
->sh_type
= SHT_RELA
;
2187 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2189 else if (strncmp (asect
->name
, ".rel", 4) == 0
2190 && get_elf_backend_data (abfd
)->may_use_rel_p
)
2192 this_hdr
->sh_type
= SHT_REL
;
2193 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2195 else if (strcmp (asect
->name
, ".init_array") == 0)
2196 this_hdr
->sh_type
= SHT_INIT_ARRAY
;
2197 else if (strcmp (asect
->name
, ".fini_array") == 0)
2198 this_hdr
->sh_type
= SHT_FINI_ARRAY
;
2199 else if (strcmp (asect
->name
, ".preinit_array") == 0)
2200 this_hdr
->sh_type
= SHT_PREINIT_ARRAY
;
2201 else if (strncmp (asect
->name
, ".note", 5) == 0)
2202 this_hdr
->sh_type
= SHT_NOTE
;
2203 else if (strncmp (asect
->name
, ".stab", 5) == 0
2204 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
2205 this_hdr
->sh_type
= SHT_STRTAB
;
2206 else if (strcmp (asect
->name
, ".gnu.version") == 0)
2208 this_hdr
->sh_type
= SHT_GNU_versym
;
2209 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2211 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
2213 this_hdr
->sh_type
= SHT_GNU_verdef
;
2214 this_hdr
->sh_entsize
= 0;
2215 /* objcopy or strip will copy over sh_info, but may not set
2216 cverdefs. The linker will set cverdefs, but sh_info will be
2218 if (this_hdr
->sh_info
== 0)
2219 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2221 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2222 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2224 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
2226 this_hdr
->sh_type
= SHT_GNU_verneed
;
2227 this_hdr
->sh_entsize
= 0;
2228 /* objcopy or strip will copy over sh_info, but may not set
2229 cverrefs. The linker will set cverrefs, but sh_info will be
2231 if (this_hdr
->sh_info
== 0)
2232 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2234 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2235 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2237 else if ((asect
->flags
& SEC_GROUP
) != 0)
2239 this_hdr
->sh_type
= SHT_GROUP
;
2240 this_hdr
->sh_entsize
= 4;
2242 else if ((asect
->flags
& SEC_ALLOC
) != 0
2243 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2244 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2245 this_hdr
->sh_type
= SHT_NOBITS
;
2247 this_hdr
->sh_type
= SHT_PROGBITS
;
2249 if ((asect
->flags
& SEC_ALLOC
) != 0)
2250 this_hdr
->sh_flags
|= SHF_ALLOC
;
2251 if ((asect
->flags
& SEC_READONLY
) == 0)
2252 this_hdr
->sh_flags
|= SHF_WRITE
;
2253 if ((asect
->flags
& SEC_CODE
) != 0)
2254 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2255 if ((asect
->flags
& SEC_MERGE
) != 0)
2257 this_hdr
->sh_flags
|= SHF_MERGE
;
2258 this_hdr
->sh_entsize
= asect
->entsize
;
2259 if ((asect
->flags
& SEC_STRINGS
) != 0)
2260 this_hdr
->sh_flags
|= SHF_STRINGS
;
2262 if (elf_group_name (asect
) != NULL
)
2263 this_hdr
->sh_flags
|= SHF_GROUP
;
2265 /* Check for processor-specific section types. */
2266 if (bed
->elf_backend_fake_sections
2267 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2270 /* If the section has relocs, set up a section header for the
2271 SHT_REL[A] section. If two relocation sections are required for
2272 this section, it is up to the processor-specific back-end to
2273 create the other. */
2274 if ((asect
->flags
& SEC_RELOC
) != 0
2275 && !_bfd_elf_init_reloc_shdr (abfd
,
2276 &elf_section_data (asect
)->rel_hdr
,
2278 elf_section_data (asect
)->use_rela_p
))
2282 /* Fill in the contents of a SHT_GROUP section. */
2285 set_group_contents (abfd
, sec
, failedptrarg
)
2288 PTR failedptrarg ATTRIBUTE_UNUSED
;
2290 boolean
*failedptr
= (boolean
*) failedptrarg
;
2291 unsigned long symindx
;
2294 struct bfd_link_order
*l
;
2296 if (elf_section_data (sec
)->this_hdr
.sh_type
!= SHT_GROUP
2300 /* If called from the assembler, swap_out_syms will have set up
2301 elf_section_syms; If called for "ld -r", the symbols won't yet
2302 be mapped, so emulate elf_bfd_final_link. */
2303 if (elf_section_syms (abfd
) != NULL
)
2304 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2306 symindx
= elf_section_data (sec
)->this_idx
;
2307 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2309 /* Nor will the contents be allocated for "ld -r". */
2310 if (sec
->contents
== NULL
)
2312 sec
->contents
= bfd_alloc (abfd
, sec
->_raw_size
);
2313 if (sec
->contents
== NULL
)
2320 loc
= sec
->contents
+ sec
->_raw_size
;
2322 /* Get the pointer to the first section in the group that we
2323 squirreled away here. */
2324 elt
= elf_next_in_group (sec
);
2326 /* First element is a flag word. Rest of section is elf section
2327 indices for all the sections of the group. Write them backwards
2328 just to keep the group in the same order as given in .section
2329 directives, not that it matters. */
2333 H_PUT_32 (abfd
, elf_section_data (elt
)->this_idx
, loc
);
2334 elt
= elf_next_in_group (elt
);
2337 /* If this is a relocatable link, then the above did nothing because
2338 SEC is the output section. Look through the input sections
2340 for (l
= sec
->link_order_head
; l
!= NULL
; l
= l
->next
)
2341 if (l
->type
== bfd_indirect_link_order
2342 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2347 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2348 elt
= elf_next_in_group (elt
);
2349 /* During a relocatable link, the lists are circular. */
2351 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2354 H_PUT_32 (abfd
, 0, loc
);
2356 BFD_ASSERT (loc
== sec
->contents
);
2359 /* Assign all ELF section numbers. The dummy first section is handled here
2360 too. The link/info pointers for the standard section types are filled
2361 in here too, while we're at it. */
2364 assign_section_numbers (abfd
)
2367 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2369 unsigned int section_number
, secn
;
2370 Elf_Internal_Shdr
**i_shdrp
;
2375 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2377 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2379 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2381 if (section_number
== SHN_LORESERVE
)
2382 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2383 d
->this_idx
= section_number
++;
2384 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2385 if ((sec
->flags
& SEC_RELOC
) == 0)
2389 if (section_number
== SHN_LORESERVE
)
2390 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2391 d
->rel_idx
= section_number
++;
2392 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2397 if (section_number
== SHN_LORESERVE
)
2398 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2399 d
->rel_idx2
= section_number
++;
2400 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2406 if (section_number
== SHN_LORESERVE
)
2407 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2408 t
->shstrtab_section
= section_number
++;
2409 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2410 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2412 if (bfd_get_symcount (abfd
) > 0)
2414 if (section_number
== SHN_LORESERVE
)
2415 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2416 t
->symtab_section
= section_number
++;
2417 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2418 if (section_number
> SHN_LORESERVE
- 2)
2420 if (section_number
== SHN_LORESERVE
)
2421 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2422 t
->symtab_shndx_section
= section_number
++;
2423 t
->symtab_shndx_hdr
.sh_name
2424 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2425 ".symtab_shndx", false);
2426 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2429 if (section_number
== SHN_LORESERVE
)
2430 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2431 t
->strtab_section
= section_number
++;
2432 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2435 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2436 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2438 elf_numsections (abfd
) = section_number
;
2439 elf_elfheader (abfd
)->e_shnum
= section_number
;
2440 if (section_number
> SHN_LORESERVE
)
2441 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2443 /* Set up the list of section header pointers, in agreement with the
2445 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2446 i_shdrp
= (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
2447 if (i_shdrp
== NULL
)
2450 amt
= sizeof (Elf_Internal_Shdr
);
2451 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
2452 if (i_shdrp
[0] == NULL
)
2454 bfd_release (abfd
, i_shdrp
);
2457 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
2459 elf_elfsections (abfd
) = i_shdrp
;
2461 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2462 if (bfd_get_symcount (abfd
) > 0)
2464 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2465 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2467 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2468 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2470 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2471 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2473 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2475 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2479 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2480 if (d
->rel_idx
!= 0)
2481 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2482 if (d
->rel_idx2
!= 0)
2483 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2485 /* Fill in the sh_link and sh_info fields while we're at it. */
2487 /* sh_link of a reloc section is the section index of the symbol
2488 table. sh_info is the section index of the section to which
2489 the relocation entries apply. */
2490 if (d
->rel_idx
!= 0)
2492 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2493 d
->rel_hdr
.sh_info
= d
->this_idx
;
2495 if (d
->rel_idx2
!= 0)
2497 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2498 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2501 switch (d
->this_hdr
.sh_type
)
2505 /* A reloc section which we are treating as a normal BFD
2506 section. sh_link is the section index of the symbol
2507 table. sh_info is the section index of the section to
2508 which the relocation entries apply. We assume that an
2509 allocated reloc section uses the dynamic symbol table.
2510 FIXME: How can we be sure? */
2511 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2513 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2515 /* We look up the section the relocs apply to by name. */
2517 if (d
->this_hdr
.sh_type
== SHT_REL
)
2521 s
= bfd_get_section_by_name (abfd
, name
);
2523 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2527 /* We assume that a section named .stab*str is a stabs
2528 string section. We look for a section with the same name
2529 but without the trailing ``str'', and set its sh_link
2530 field to point to this section. */
2531 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
2532 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2537 len
= strlen (sec
->name
);
2538 alc
= (char *) bfd_malloc ((bfd_size_type
) len
- 2);
2541 strncpy (alc
, sec
->name
, len
- 3);
2542 alc
[len
- 3] = '\0';
2543 s
= bfd_get_section_by_name (abfd
, alc
);
2547 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2549 /* This is a .stab section. */
2550 elf_section_data (s
)->this_hdr
.sh_entsize
=
2551 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2558 case SHT_GNU_verneed
:
2559 case SHT_GNU_verdef
:
2560 /* sh_link is the section header index of the string table
2561 used for the dynamic entries, or the symbol table, or the
2563 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2565 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2569 case SHT_GNU_versym
:
2570 /* sh_link is the section header index of the symbol table
2571 this hash table or version table is for. */
2572 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2574 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2578 d
->this_hdr
.sh_link
= t
->symtab_section
;
2582 for (secn
= 1; secn
< section_number
; ++secn
)
2583 if (i_shdrp
[secn
] == NULL
)
2584 i_shdrp
[secn
] = i_shdrp
[0];
2586 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
2587 i_shdrp
[secn
]->sh_name
);
2591 /* Map symbol from it's internal number to the external number, moving
2592 all local symbols to be at the head of the list. */
2595 sym_is_global (abfd
, sym
)
2599 /* If the backend has a special mapping, use it. */
2600 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2601 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2604 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2605 || bfd_is_und_section (bfd_get_section (sym
))
2606 || bfd_is_com_section (bfd_get_section (sym
)));
2610 elf_map_symbols (abfd
)
2613 unsigned int symcount
= bfd_get_symcount (abfd
);
2614 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2615 asymbol
**sect_syms
;
2616 unsigned int num_locals
= 0;
2617 unsigned int num_globals
= 0;
2618 unsigned int num_locals2
= 0;
2619 unsigned int num_globals2
= 0;
2627 fprintf (stderr
, "elf_map_symbols\n");
2631 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2633 if (max_index
< asect
->index
)
2634 max_index
= asect
->index
;
2638 amt
= max_index
* sizeof (asymbol
*);
2639 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
2640 if (sect_syms
== NULL
)
2642 elf_section_syms (abfd
) = sect_syms
;
2643 elf_num_section_syms (abfd
) = max_index
;
2645 /* Init sect_syms entries for any section symbols we have already
2646 decided to output. */
2647 for (idx
= 0; idx
< symcount
; idx
++)
2649 asymbol
*sym
= syms
[idx
];
2651 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2658 if (sec
->owner
!= NULL
)
2660 if (sec
->owner
!= abfd
)
2662 if (sec
->output_offset
!= 0)
2665 sec
= sec
->output_section
;
2667 /* Empty sections in the input files may have had a
2668 section symbol created for them. (See the comment
2669 near the end of _bfd_generic_link_output_symbols in
2670 linker.c). If the linker script discards such
2671 sections then we will reach this point. Since we know
2672 that we cannot avoid this case, we detect it and skip
2673 the abort and the assignment to the sect_syms array.
2674 To reproduce this particular case try running the
2675 linker testsuite test ld-scripts/weak.exp for an ELF
2676 port that uses the generic linker. */
2677 if (sec
->owner
== NULL
)
2680 BFD_ASSERT (sec
->owner
== abfd
);
2682 sect_syms
[sec
->index
] = syms
[idx
];
2687 /* Classify all of the symbols. */
2688 for (idx
= 0; idx
< symcount
; idx
++)
2690 if (!sym_is_global (abfd
, syms
[idx
]))
2696 /* We will be adding a section symbol for each BFD section. Most normal
2697 sections will already have a section symbol in outsymbols, but
2698 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2699 at least in that case. */
2700 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2702 if (sect_syms
[asect
->index
] == NULL
)
2704 if (!sym_is_global (abfd
, asect
->symbol
))
2711 /* Now sort the symbols so the local symbols are first. */
2712 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
2713 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
2715 if (new_syms
== NULL
)
2718 for (idx
= 0; idx
< symcount
; idx
++)
2720 asymbol
*sym
= syms
[idx
];
2723 if (!sym_is_global (abfd
, sym
))
2726 i
= num_locals
+ num_globals2
++;
2728 sym
->udata
.i
= i
+ 1;
2730 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2732 if (sect_syms
[asect
->index
] == NULL
)
2734 asymbol
*sym
= asect
->symbol
;
2737 sect_syms
[asect
->index
] = sym
;
2738 if (!sym_is_global (abfd
, sym
))
2741 i
= num_locals
+ num_globals2
++;
2743 sym
->udata
.i
= i
+ 1;
2747 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
2749 elf_num_locals (abfd
) = num_locals
;
2750 elf_num_globals (abfd
) = num_globals
;
2754 /* Align to the maximum file alignment that could be required for any
2755 ELF data structure. */
2757 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
2758 static INLINE file_ptr
2759 align_file_position (off
, align
)
2763 return (off
+ align
- 1) & ~(align
- 1);
2766 /* Assign a file position to a section, optionally aligning to the
2767 required section alignment. */
2770 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
2771 Elf_Internal_Shdr
*i_shdrp
;
2779 al
= i_shdrp
->sh_addralign
;
2781 offset
= BFD_ALIGN (offset
, al
);
2783 i_shdrp
->sh_offset
= offset
;
2784 if (i_shdrp
->bfd_section
!= NULL
)
2785 i_shdrp
->bfd_section
->filepos
= offset
;
2786 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2787 offset
+= i_shdrp
->sh_size
;
2791 /* Compute the file positions we are going to put the sections at, and
2792 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2793 is not NULL, this is being called by the ELF backend linker. */
2796 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2798 struct bfd_link_info
*link_info
;
2800 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2802 struct bfd_strtab_hash
*strtab
;
2803 Elf_Internal_Shdr
*shstrtab_hdr
;
2805 if (abfd
->output_has_begun
)
2808 /* Do any elf backend specific processing first. */
2809 if (bed
->elf_backend_begin_write_processing
)
2810 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2812 if (! prep_headers (abfd
))
2815 /* Post process the headers if necessary. */
2816 if (bed
->elf_backend_post_process_headers
)
2817 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2820 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2824 if (!assign_section_numbers (abfd
))
2827 /* The backend linker builds symbol table information itself. */
2828 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2830 /* Non-zero if doing a relocatable link. */
2831 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2833 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2837 if (link_info
== NULL
|| link_info
->relocateable
)
2839 bfd_map_over_sections (abfd
, set_group_contents
, &failed
);
2844 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2845 /* sh_name was set in prep_headers. */
2846 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2847 shstrtab_hdr
->sh_flags
= 0;
2848 shstrtab_hdr
->sh_addr
= 0;
2849 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2850 shstrtab_hdr
->sh_entsize
= 0;
2851 shstrtab_hdr
->sh_link
= 0;
2852 shstrtab_hdr
->sh_info
= 0;
2853 /* sh_offset is set in assign_file_positions_except_relocs. */
2854 shstrtab_hdr
->sh_addralign
= 1;
2856 if (!assign_file_positions_except_relocs (abfd
))
2859 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2862 Elf_Internal_Shdr
*hdr
;
2864 off
= elf_tdata (abfd
)->next_file_pos
;
2866 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2867 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2869 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2870 if (hdr
->sh_size
!= 0)
2871 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2873 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2874 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2876 elf_tdata (abfd
)->next_file_pos
= off
;
2878 /* Now that we know where the .strtab section goes, write it
2880 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2881 || ! _bfd_stringtab_emit (abfd
, strtab
))
2883 _bfd_stringtab_free (strtab
);
2886 abfd
->output_has_begun
= true;
2891 /* Create a mapping from a set of sections to a program segment. */
2893 static INLINE
struct elf_segment_map
*
2894 make_mapping (abfd
, sections
, from
, to
, phdr
)
2896 asection
**sections
;
2901 struct elf_segment_map
*m
;
2906 amt
= sizeof (struct elf_segment_map
);
2907 amt
+= (to
- from
- 1) * sizeof (asection
*);
2908 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2912 m
->p_type
= PT_LOAD
;
2913 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2914 m
->sections
[i
- from
] = *hdrpp
;
2915 m
->count
= to
- from
;
2917 if (from
== 0 && phdr
)
2919 /* Include the headers in the first PT_LOAD segment. */
2920 m
->includes_filehdr
= 1;
2921 m
->includes_phdrs
= 1;
2927 /* Set up a mapping from BFD sections to program segments. */
2930 map_sections_to_segments (abfd
)
2933 asection
**sections
= NULL
;
2937 struct elf_segment_map
*mfirst
;
2938 struct elf_segment_map
**pm
;
2939 struct elf_segment_map
*m
;
2941 unsigned int phdr_index
;
2942 bfd_vma maxpagesize
;
2944 boolean phdr_in_segment
= true;
2946 asection
*dynsec
, *eh_frame_hdr
;
2949 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2952 if (bfd_count_sections (abfd
) == 0)
2955 /* Select the allocated sections, and sort them. */
2957 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
2958 sections
= (asection
**) bfd_malloc (amt
);
2959 if (sections
== NULL
)
2963 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2965 if ((s
->flags
& SEC_ALLOC
) != 0)
2971 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2974 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2976 /* Build the mapping. */
2981 /* If we have a .interp section, then create a PT_PHDR segment for
2982 the program headers and a PT_INTERP segment for the .interp
2984 s
= bfd_get_section_by_name (abfd
, ".interp");
2985 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2987 amt
= sizeof (struct elf_segment_map
);
2988 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2992 m
->p_type
= PT_PHDR
;
2993 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2994 m
->p_flags
= PF_R
| PF_X
;
2995 m
->p_flags_valid
= 1;
2996 m
->includes_phdrs
= 1;
3001 amt
= sizeof (struct elf_segment_map
);
3002 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3006 m
->p_type
= PT_INTERP
;
3014 /* Look through the sections. We put sections in the same program
3015 segment when the start of the second section can be placed within
3016 a few bytes of the end of the first section. */
3019 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3021 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3023 && (dynsec
->flags
& SEC_LOAD
) == 0)
3026 /* Deal with -Ttext or something similar such that the first section
3027 is not adjacent to the program headers. This is an
3028 approximation, since at this point we don't know exactly how many
3029 program headers we will need. */
3032 bfd_size_type phdr_size
;
3034 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3036 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3037 if ((abfd
->flags
& D_PAGED
) == 0
3038 || sections
[0]->lma
< phdr_size
3039 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3040 phdr_in_segment
= false;
3043 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3046 boolean new_segment
;
3050 /* See if this section and the last one will fit in the same
3053 if (last_hdr
== NULL
)
3055 /* If we don't have a segment yet, then we don't need a new
3056 one (we build the last one after this loop). */
3057 new_segment
= false;
3059 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3061 /* If this section has a different relation between the
3062 virtual address and the load address, then we need a new
3066 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3067 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3069 /* If putting this section in this segment would force us to
3070 skip a page in the segment, then we need a new segment. */
3073 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
3074 && (hdr
->flags
& SEC_LOAD
) != 0)
3076 /* We don't want to put a loadable section after a
3077 nonloadable section in the same segment. */
3080 else if ((abfd
->flags
& D_PAGED
) == 0)
3082 /* If the file is not demand paged, which means that we
3083 don't require the sections to be correctly aligned in the
3084 file, then there is no other reason for a new segment. */
3085 new_segment
= false;
3088 && (hdr
->flags
& SEC_READONLY
) == 0
3089 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3092 /* We don't want to put a writable section in a read only
3093 segment, unless they are on the same page in memory
3094 anyhow. We already know that the last section does not
3095 bring us past the current section on the page, so the
3096 only case in which the new section is not on the same
3097 page as the previous section is when the previous section
3098 ends precisely on a page boundary. */
3103 /* Otherwise, we can use the same segment. */
3104 new_segment
= false;
3109 if ((hdr
->flags
& SEC_READONLY
) == 0)
3115 /* We need a new program segment. We must create a new program
3116 header holding all the sections from phdr_index until hdr. */
3118 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3125 if ((hdr
->flags
& SEC_READONLY
) == 0)
3132 phdr_in_segment
= false;
3135 /* Create a final PT_LOAD program segment. */
3136 if (last_hdr
!= NULL
)
3138 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3146 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3149 amt
= sizeof (struct elf_segment_map
);
3150 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3154 m
->p_type
= PT_DYNAMIC
;
3156 m
->sections
[0] = dynsec
;
3162 /* For each loadable .note section, add a PT_NOTE segment. We don't
3163 use bfd_get_section_by_name, because if we link together
3164 nonloadable .note sections and loadable .note sections, we will
3165 generate two .note sections in the output file. FIXME: Using
3166 names for section types is bogus anyhow. */
3167 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3169 if ((s
->flags
& SEC_LOAD
) != 0
3170 && strncmp (s
->name
, ".note", 5) == 0)
3172 amt
= sizeof (struct elf_segment_map
);
3173 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3177 m
->p_type
= PT_NOTE
;
3186 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3188 eh_frame_hdr
= NULL
;
3189 if (elf_tdata (abfd
)->eh_frame_hdr
)
3190 eh_frame_hdr
= bfd_get_section_by_name (abfd
, ".eh_frame_hdr");
3191 if (eh_frame_hdr
!= NULL
&& (eh_frame_hdr
->flags
& SEC_LOAD
))
3193 amt
= sizeof (struct elf_segment_map
);
3194 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3198 m
->p_type
= PT_GNU_EH_FRAME
;
3200 m
->sections
[0] = eh_frame_hdr
;
3209 elf_tdata (abfd
)->segment_map
= mfirst
;
3213 if (sections
!= NULL
)
3218 /* Sort sections by address. */
3221 elf_sort_sections (arg1
, arg2
)
3225 const asection
*sec1
= *(const asection
**) arg1
;
3226 const asection
*sec2
= *(const asection
**) arg2
;
3228 /* Sort by LMA first, since this is the address used to
3229 place the section into a segment. */
3230 if (sec1
->lma
< sec2
->lma
)
3232 else if (sec1
->lma
> sec2
->lma
)
3235 /* Then sort by VMA. Normally the LMA and the VMA will be
3236 the same, and this will do nothing. */
3237 if (sec1
->vma
< sec2
->vma
)
3239 else if (sec1
->vma
> sec2
->vma
)
3242 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3244 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3250 /* If the indicies are the same, do not return 0
3251 here, but continue to try the next comparison. */
3252 if (sec1
->target_index
- sec2
->target_index
!= 0)
3253 return sec1
->target_index
- sec2
->target_index
;
3258 else if (TOEND (sec2
))
3263 /* Sort by size, to put zero sized sections
3264 before others at the same address. */
3266 if (sec1
->_raw_size
< sec2
->_raw_size
)
3268 if (sec1
->_raw_size
> sec2
->_raw_size
)
3271 return sec1
->target_index
- sec2
->target_index
;
3274 /* Assign file positions to the sections based on the mapping from
3275 sections to segments. This function also sets up some fields in
3276 the file header, and writes out the program headers. */
3279 assign_file_positions_for_segments (abfd
)
3282 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3284 struct elf_segment_map
*m
;
3286 Elf_Internal_Phdr
*phdrs
;
3288 bfd_vma filehdr_vaddr
, filehdr_paddr
;
3289 bfd_vma phdrs_vaddr
, phdrs_paddr
;
3290 Elf_Internal_Phdr
*p
;
3293 if (elf_tdata (abfd
)->segment_map
== NULL
)
3295 if (! map_sections_to_segments (abfd
))
3299 if (bed
->elf_backend_modify_segment_map
)
3301 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
3306 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3309 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
3310 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
3311 elf_elfheader (abfd
)->e_phnum
= count
;
3316 /* If we already counted the number of program segments, make sure
3317 that we allocated enough space. This happens when SIZEOF_HEADERS
3318 is used in a linker script. */
3319 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
3320 if (alloc
!= 0 && count
> alloc
)
3322 ((*_bfd_error_handler
)
3323 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3324 bfd_get_filename (abfd
), alloc
, count
));
3325 bfd_set_error (bfd_error_bad_value
);
3332 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
3333 phdrs
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
3337 off
= bed
->s
->sizeof_ehdr
;
3338 off
+= alloc
* bed
->s
->sizeof_phdr
;
3345 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3352 /* If elf_segment_map is not from map_sections_to_segments, the
3353 sections may not be correctly ordered. NOTE: sorting should
3354 not be done to the PT_NOTE section of a corefile, which may
3355 contain several pseudo-sections artificially created by bfd.
3356 Sorting these pseudo-sections breaks things badly. */
3358 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
3359 && m
->p_type
== PT_NOTE
))
3360 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
3363 p
->p_type
= m
->p_type
;
3364 p
->p_flags
= m
->p_flags
;
3366 if (p
->p_type
== PT_LOAD
3368 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
3370 if ((abfd
->flags
& D_PAGED
) != 0)
3371 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
3374 bfd_size_type align
;
3377 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3379 bfd_size_type secalign
;
3381 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
3382 if (secalign
> align
)
3386 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
3393 p
->p_vaddr
= m
->sections
[0]->vma
;
3395 if (m
->p_paddr_valid
)
3396 p
->p_paddr
= m
->p_paddr
;
3397 else if (m
->count
== 0)
3400 p
->p_paddr
= m
->sections
[0]->lma
;
3402 if (p
->p_type
== PT_LOAD
3403 && (abfd
->flags
& D_PAGED
) != 0)
3404 p
->p_align
= bed
->maxpagesize
;
3405 else if (m
->count
== 0)
3406 p
->p_align
= bed
->s
->file_align
;
3414 if (m
->includes_filehdr
)
3416 if (! m
->p_flags_valid
)
3419 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3420 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3423 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3425 if (p
->p_vaddr
< (bfd_vma
) off
)
3427 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
3428 bfd_get_filename (abfd
));
3429 bfd_set_error (bfd_error_bad_value
);
3434 if (! m
->p_paddr_valid
)
3437 if (p
->p_type
== PT_LOAD
)
3439 filehdr_vaddr
= p
->p_vaddr
;
3440 filehdr_paddr
= p
->p_paddr
;
3444 if (m
->includes_phdrs
)
3446 if (! m
->p_flags_valid
)
3449 if (m
->includes_filehdr
)
3451 if (p
->p_type
== PT_LOAD
)
3453 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3454 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3459 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3463 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3464 p
->p_vaddr
-= off
- p
->p_offset
;
3465 if (! m
->p_paddr_valid
)
3466 p
->p_paddr
-= off
- p
->p_offset
;
3469 if (p
->p_type
== PT_LOAD
)
3471 phdrs_vaddr
= p
->p_vaddr
;
3472 phdrs_paddr
= p
->p_paddr
;
3475 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3478 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3479 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3482 if (p
->p_type
== PT_LOAD
3483 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3485 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3491 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3492 p
->p_filesz
+= adjust
;
3493 p
->p_memsz
+= adjust
;
3499 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3503 bfd_size_type align
;
3507 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3509 /* The section may have artificial alignment forced by a
3510 link script. Notice this case by the gap between the
3511 cumulative phdr lma and the section's lma. */
3512 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3514 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3516 p
->p_memsz
+= adjust
;
3519 if ((flags
& SEC_LOAD
) != 0)
3520 p
->p_filesz
+= adjust
;
3523 if (p
->p_type
== PT_LOAD
)
3525 bfd_signed_vma adjust
;
3527 if ((flags
& SEC_LOAD
) != 0)
3529 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3533 else if ((flags
& SEC_ALLOC
) != 0)
3535 /* The section VMA must equal the file position
3536 modulo the page size. FIXME: I'm not sure if
3537 this adjustment is really necessary. We used to
3538 not have the SEC_LOAD case just above, and then
3539 this was necessary, but now I'm not sure. */
3540 if ((abfd
->flags
& D_PAGED
) != 0)
3541 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
3543 adjust
= (sec
->vma
- voff
) % align
;
3552 (* _bfd_error_handler
) (_("\
3553 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3554 bfd_section_name (abfd
, sec
),
3559 p
->p_memsz
+= adjust
;
3562 if ((flags
& SEC_LOAD
) != 0)
3563 p
->p_filesz
+= adjust
;
3568 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3569 used in a linker script we may have a section with
3570 SEC_LOAD clear but which is supposed to have
3572 if ((flags
& SEC_LOAD
) != 0
3573 || (flags
& SEC_HAS_CONTENTS
) != 0)
3574 off
+= sec
->_raw_size
;
3576 if ((flags
& SEC_ALLOC
) != 0)
3577 voff
+= sec
->_raw_size
;
3580 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
3582 /* The actual "note" segment has i == 0.
3583 This is the one that actually contains everything. */
3587 p
->p_filesz
= sec
->_raw_size
;
3588 off
+= sec
->_raw_size
;
3593 /* Fake sections -- don't need to be written. */
3596 flags
= sec
->flags
= 0;
3603 p
->p_memsz
+= sec
->_raw_size
;
3605 if ((flags
& SEC_LOAD
) != 0)
3606 p
->p_filesz
+= sec
->_raw_size
;
3608 if (align
> p
->p_align
3609 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
3613 if (! m
->p_flags_valid
)
3616 if ((flags
& SEC_CODE
) != 0)
3618 if ((flags
& SEC_READONLY
) == 0)
3624 /* Now that we have set the section file positions, we can set up
3625 the file positions for the non PT_LOAD segments. */
3626 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3630 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
3632 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
3633 p
->p_offset
= m
->sections
[0]->filepos
;
3637 if (m
->includes_filehdr
)
3639 p
->p_vaddr
= filehdr_vaddr
;
3640 if (! m
->p_paddr_valid
)
3641 p
->p_paddr
= filehdr_paddr
;
3643 else if (m
->includes_phdrs
)
3645 p
->p_vaddr
= phdrs_vaddr
;
3646 if (! m
->p_paddr_valid
)
3647 p
->p_paddr
= phdrs_paddr
;
3652 /* Clear out any program headers we allocated but did not use. */
3653 for (; count
< alloc
; count
++, p
++)
3655 memset (p
, 0, sizeof *p
);
3656 p
->p_type
= PT_NULL
;
3659 elf_tdata (abfd
)->phdr
= phdrs
;
3661 elf_tdata (abfd
)->next_file_pos
= off
;
3663 /* Write out the program headers. */
3664 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
3665 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
3671 /* Get the size of the program header.
3673 If this is called by the linker before any of the section VMA's are set, it
3674 can't calculate the correct value for a strange memory layout. This only
3675 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3676 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3677 data segment (exclusive of .interp and .dynamic).
3679 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3680 will be two segments. */
3682 static bfd_size_type
3683 get_program_header_size (abfd
)
3688 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3690 /* We can't return a different result each time we're called. */
3691 if (elf_tdata (abfd
)->program_header_size
!= 0)
3692 return elf_tdata (abfd
)->program_header_size
;
3694 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3696 struct elf_segment_map
*m
;
3699 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3701 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3702 return elf_tdata (abfd
)->program_header_size
;
3705 /* Assume we will need exactly two PT_LOAD segments: one for text
3706 and one for data. */
3709 s
= bfd_get_section_by_name (abfd
, ".interp");
3710 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3712 /* If we have a loadable interpreter section, we need a
3713 PT_INTERP segment. In this case, assume we also need a
3714 PT_PHDR segment, although that may not be true for all
3719 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3721 /* We need a PT_DYNAMIC segment. */
3725 if (elf_tdata (abfd
)->eh_frame_hdr
3726 && bfd_get_section_by_name (abfd
, ".eh_frame_hdr") != NULL
)
3728 /* We need a PT_GNU_EH_FRAME segment. */
3732 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3734 if ((s
->flags
& SEC_LOAD
) != 0
3735 && strncmp (s
->name
, ".note", 5) == 0)
3737 /* We need a PT_NOTE segment. */
3742 /* Let the backend count up any program headers it might need. */
3743 if (bed
->elf_backend_additional_program_headers
)
3747 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
3753 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3754 return elf_tdata (abfd
)->program_header_size
;
3757 /* Work out the file positions of all the sections. This is called by
3758 _bfd_elf_compute_section_file_positions. All the section sizes and
3759 VMAs must be known before this is called.
3761 We do not consider reloc sections at this point, unless they form
3762 part of the loadable image. Reloc sections are assigned file
3763 positions in assign_file_positions_for_relocs, which is called by
3764 write_object_contents and final_link.
3766 We also don't set the positions of the .symtab and .strtab here. */
3769 assign_file_positions_except_relocs (abfd
)
3772 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
3773 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
3774 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
3775 unsigned int num_sec
= elf_numsections (abfd
);
3777 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3779 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3780 && bfd_get_format (abfd
) != bfd_core
)
3782 Elf_Internal_Shdr
**hdrpp
;
3785 /* Start after the ELF header. */
3786 off
= i_ehdrp
->e_ehsize
;
3788 /* We are not creating an executable, which means that we are
3789 not creating a program header, and that the actual order of
3790 the sections in the file is unimportant. */
3791 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
3793 Elf_Internal_Shdr
*hdr
;
3796 if (hdr
->sh_type
== SHT_REL
3797 || hdr
->sh_type
== SHT_RELA
3798 || i
== tdata
->symtab_section
3799 || i
== tdata
->symtab_shndx_section
3800 || i
== tdata
->strtab_section
)
3802 hdr
->sh_offset
= -1;
3805 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3807 if (i
== SHN_LORESERVE
- 1)
3809 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3810 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3817 Elf_Internal_Shdr
**hdrpp
;
3819 /* Assign file positions for the loaded sections based on the
3820 assignment of sections to segments. */
3821 if (! assign_file_positions_for_segments (abfd
))
3824 /* Assign file positions for the other sections. */
3826 off
= elf_tdata (abfd
)->next_file_pos
;
3827 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
3829 Elf_Internal_Shdr
*hdr
;
3832 if (hdr
->bfd_section
!= NULL
3833 && hdr
->bfd_section
->filepos
!= 0)
3834 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
3835 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3837 ((*_bfd_error_handler
)
3838 (_("%s: warning: allocated section `%s' not in segment"),
3839 bfd_get_filename (abfd
),
3840 (hdr
->bfd_section
== NULL
3842 : hdr
->bfd_section
->name
)));
3843 if ((abfd
->flags
& D_PAGED
) != 0)
3844 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3846 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3847 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3850 else if (hdr
->sh_type
== SHT_REL
3851 || hdr
->sh_type
== SHT_RELA
3852 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3853 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
3854 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3855 hdr
->sh_offset
= -1;
3857 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3859 if (i
== SHN_LORESERVE
- 1)
3861 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3862 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3867 /* Place the section headers. */
3868 off
= align_file_position (off
, bed
->s
->file_align
);
3869 i_ehdrp
->e_shoff
= off
;
3870 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3872 elf_tdata (abfd
)->next_file_pos
= off
;
3881 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3882 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3883 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3884 struct elf_strtab_hash
*shstrtab
;
3885 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3887 i_ehdrp
= elf_elfheader (abfd
);
3888 i_shdrp
= elf_elfsections (abfd
);
3890 shstrtab
= _bfd_elf_strtab_init ();
3891 if (shstrtab
== NULL
)
3894 elf_shstrtab (abfd
) = shstrtab
;
3896 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3897 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3898 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3899 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3901 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3902 i_ehdrp
->e_ident
[EI_DATA
] =
3903 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3904 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3906 if ((abfd
->flags
& DYNAMIC
) != 0)
3907 i_ehdrp
->e_type
= ET_DYN
;
3908 else if ((abfd
->flags
& EXEC_P
) != 0)
3909 i_ehdrp
->e_type
= ET_EXEC
;
3910 else if (bfd_get_format (abfd
) == bfd_core
)
3911 i_ehdrp
->e_type
= ET_CORE
;
3913 i_ehdrp
->e_type
= ET_REL
;
3915 switch (bfd_get_arch (abfd
))
3917 case bfd_arch_unknown
:
3918 i_ehdrp
->e_machine
= EM_NONE
;
3921 /* There used to be a long list of cases here, each one setting
3922 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
3923 in the corresponding bfd definition. To avoid duplication,
3924 the switch was removed. Machines that need special handling
3925 can generally do it in elf_backend_final_write_processing(),
3926 unless they need the information earlier than the final write.
3927 Such need can generally be supplied by replacing the tests for
3928 e_machine with the conditions used to determine it. */
3930 if (get_elf_backend_data (abfd
) != NULL
)
3931 i_ehdrp
->e_machine
= get_elf_backend_data (abfd
)->elf_machine_code
;
3933 i_ehdrp
->e_machine
= EM_NONE
;
3936 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3937 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3939 /* No program header, for now. */
3940 i_ehdrp
->e_phoff
= 0;
3941 i_ehdrp
->e_phentsize
= 0;
3942 i_ehdrp
->e_phnum
= 0;
3944 /* Each bfd section is section header entry. */
3945 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3946 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3948 /* If we're building an executable, we'll need a program header table. */
3949 if (abfd
->flags
& EXEC_P
)
3951 /* It all happens later. */
3953 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3955 /* elf_build_phdrs() returns a (NULL-terminated) array of
3956 Elf_Internal_Phdrs. */
3957 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3958 i_ehdrp
->e_phoff
= outbase
;
3959 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3964 i_ehdrp
->e_phentsize
= 0;
3966 i_ehdrp
->e_phoff
= 0;
3969 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3970 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
3971 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3972 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
3973 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3974 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
3975 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3976 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3977 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3983 /* Assign file positions for all the reloc sections which are not part
3984 of the loadable file image. */
3987 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3991 unsigned int i
, num_sec
;
3992 Elf_Internal_Shdr
**shdrpp
;
3994 off
= elf_tdata (abfd
)->next_file_pos
;
3996 num_sec
= elf_numsections (abfd
);
3997 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
3999 Elf_Internal_Shdr
*shdrp
;
4002 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4003 && shdrp
->sh_offset
== -1)
4004 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
4007 elf_tdata (abfd
)->next_file_pos
= off
;
4011 _bfd_elf_write_object_contents (abfd
)
4014 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4015 Elf_Internal_Ehdr
*i_ehdrp
;
4016 Elf_Internal_Shdr
**i_shdrp
;
4018 unsigned int count
, num_sec
;
4020 if (! abfd
->output_has_begun
4021 && ! _bfd_elf_compute_section_file_positions
4022 (abfd
, (struct bfd_link_info
*) NULL
))
4025 i_shdrp
= elf_elfsections (abfd
);
4026 i_ehdrp
= elf_elfheader (abfd
);
4029 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4033 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4035 /* After writing the headers, we need to write the sections too... */
4036 num_sec
= elf_numsections (abfd
);
4037 for (count
= 1; count
< num_sec
; count
++)
4039 if (bed
->elf_backend_section_processing
)
4040 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4041 if (i_shdrp
[count
]->contents
)
4043 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4045 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4046 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4049 if (count
== SHN_LORESERVE
- 1)
4050 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4053 /* Write out the section header names. */
4054 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4055 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4058 if (bed
->elf_backend_final_write_processing
)
4059 (*bed
->elf_backend_final_write_processing
) (abfd
,
4060 elf_tdata (abfd
)->linker
);
4062 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4066 _bfd_elf_write_corefile_contents (abfd
)
4069 /* Hopefully this can be done just like an object file. */
4070 return _bfd_elf_write_object_contents (abfd
);
4073 /* Given a section, search the header to find them. */
4076 _bfd_elf_section_from_bfd_section (abfd
, asect
)
4080 struct elf_backend_data
*bed
;
4083 if (elf_section_data (asect
) != NULL
4084 && elf_section_data (asect
)->this_idx
!= 0)
4085 return elf_section_data (asect
)->this_idx
;
4087 if (bfd_is_abs_section (asect
))
4089 else if (bfd_is_com_section (asect
))
4091 else if (bfd_is_und_section (asect
))
4095 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4096 int maxindex
= elf_numsections (abfd
);
4098 for (index
= 1; index
< maxindex
; index
++)
4100 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4102 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4108 bed
= get_elf_backend_data (abfd
);
4109 if (bed
->elf_backend_section_from_bfd_section
)
4113 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4118 bfd_set_error (bfd_error_nonrepresentable_section
);
4123 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4127 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
4129 asymbol
**asym_ptr_ptr
;
4131 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4133 flagword flags
= asym_ptr
->flags
;
4135 /* When gas creates relocations against local labels, it creates its
4136 own symbol for the section, but does put the symbol into the
4137 symbol chain, so udata is 0. When the linker is generating
4138 relocatable output, this section symbol may be for one of the
4139 input sections rather than the output section. */
4140 if (asym_ptr
->udata
.i
== 0
4141 && (flags
& BSF_SECTION_SYM
)
4142 && asym_ptr
->section
)
4146 if (asym_ptr
->section
->output_section
!= NULL
)
4147 indx
= asym_ptr
->section
->output_section
->index
;
4149 indx
= asym_ptr
->section
->index
;
4150 if (indx
< elf_num_section_syms (abfd
)
4151 && elf_section_syms (abfd
)[indx
] != NULL
)
4152 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4155 idx
= asym_ptr
->udata
.i
;
4159 /* This case can occur when using --strip-symbol on a symbol
4160 which is used in a relocation entry. */
4161 (*_bfd_error_handler
)
4162 (_("%s: symbol `%s' required but not present"),
4163 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4164 bfd_set_error (bfd_error_no_symbols
);
4171 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4172 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4173 elf_symbol_flags (flags
));
4181 /* Copy private BFD data. This copies any program header information. */
4184 copy_private_bfd_data (ibfd
, obfd
)
4188 Elf_Internal_Ehdr
* iehdr
;
4189 struct elf_segment_map
* map
;
4190 struct elf_segment_map
* map_first
;
4191 struct elf_segment_map
** pointer_to_map
;
4192 Elf_Internal_Phdr
* segment
;
4195 unsigned int num_segments
;
4196 boolean phdr_included
= false;
4197 bfd_vma maxpagesize
;
4198 struct elf_segment_map
* phdr_adjust_seg
= NULL
;
4199 unsigned int phdr_adjust_num
= 0;
4201 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4202 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4205 if (elf_tdata (ibfd
)->phdr
== NULL
)
4208 iehdr
= elf_elfheader (ibfd
);
4211 pointer_to_map
= &map_first
;
4213 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4214 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4216 /* Returns the end address of the segment + 1. */
4217 #define SEGMENT_END(segment, start) \
4218 (start + (segment->p_memsz > segment->p_filesz \
4219 ? segment->p_memsz : segment->p_filesz))
4221 /* Returns true if the given section is contained within
4222 the given segment. VMA addresses are compared. */
4223 #define IS_CONTAINED_BY_VMA(section, segment) \
4224 (section->vma >= segment->p_vaddr \
4225 && (section->vma + section->_raw_size) \
4226 <= (SEGMENT_END (segment, segment->p_vaddr)))
4228 /* Returns true if the given section is contained within
4229 the given segment. LMA addresses are compared. */
4230 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4231 (section->lma >= base \
4232 && (section->lma + section->_raw_size) \
4233 <= SEGMENT_END (segment, base))
4235 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4236 #define IS_COREFILE_NOTE(p, s) \
4237 (p->p_type == PT_NOTE \
4238 && bfd_get_format (ibfd) == bfd_core \
4239 && s->vma == 0 && s->lma == 0 \
4240 && (bfd_vma) s->filepos >= p->p_offset \
4241 && (bfd_vma) s->filepos + s->_raw_size \
4242 <= p->p_offset + p->p_filesz)
4244 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4245 linker, which generates a PT_INTERP section with p_vaddr and
4246 p_memsz set to 0. */
4247 #define IS_SOLARIS_PT_INTERP(p, s) \
4249 && p->p_filesz > 0 \
4250 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4251 && s->_raw_size > 0 \
4252 && (bfd_vma) s->filepos >= p->p_offset \
4253 && ((bfd_vma) s->filepos + s->_raw_size \
4254 <= p->p_offset + p->p_filesz))
4256 /* Decide if the given section should be included in the given segment.
4257 A section will be included if:
4258 1. It is within the address space of the segment -- we use the LMA
4259 if that is set for the segment and the VMA otherwise,
4260 2. It is an allocated segment,
4261 3. There is an output section associated with it,
4262 4. The section has not already been allocated to a previous segment. */
4263 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
4264 (((((segment->p_paddr \
4265 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4266 : IS_CONTAINED_BY_VMA (section, segment)) \
4267 || IS_SOLARIS_PT_INTERP (segment, section)) \
4268 && (section->flags & SEC_ALLOC) != 0) \
4269 || IS_COREFILE_NOTE (segment, section)) \
4270 && section->output_section != NULL \
4271 && section->segment_mark == false)
4273 /* Returns true iff seg1 starts after the end of seg2. */
4274 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4275 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4277 /* Returns true iff seg1 and seg2 overlap. */
4278 #define SEGMENT_OVERLAPS(seg1, seg2) \
4279 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4281 /* Initialise the segment mark field. */
4282 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4283 section
->segment_mark
= false;
4285 /* Scan through the segments specified in the program header
4286 of the input BFD. For this first scan we look for overlaps
4287 in the loadable segments. These can be created by weird
4288 parameters to objcopy. */
4289 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4294 Elf_Internal_Phdr
*segment2
;
4296 if (segment
->p_type
!= PT_LOAD
)
4299 /* Determine if this segment overlaps any previous segments. */
4300 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4302 bfd_signed_vma extra_length
;
4304 if (segment2
->p_type
!= PT_LOAD
4305 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4308 /* Merge the two segments together. */
4309 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4311 /* Extend SEGMENT2 to include SEGMENT and then delete
4314 SEGMENT_END (segment
, segment
->p_vaddr
)
4315 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4317 if (extra_length
> 0)
4319 segment2
->p_memsz
+= extra_length
;
4320 segment2
->p_filesz
+= extra_length
;
4323 segment
->p_type
= PT_NULL
;
4325 /* Since we have deleted P we must restart the outer loop. */
4327 segment
= elf_tdata (ibfd
)->phdr
;
4332 /* Extend SEGMENT to include SEGMENT2 and then delete
4335 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4336 - SEGMENT_END (segment
, segment
->p_vaddr
);
4338 if (extra_length
> 0)
4340 segment
->p_memsz
+= extra_length
;
4341 segment
->p_filesz
+= extra_length
;
4344 segment2
->p_type
= PT_NULL
;
4349 /* The second scan attempts to assign sections to segments. */
4350 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4354 unsigned int section_count
;
4355 asection
** sections
;
4356 asection
* output_section
;
4358 bfd_vma matching_lma
;
4359 bfd_vma suggested_lma
;
4363 if (segment
->p_type
== PT_NULL
)
4366 /* Compute how many sections might be placed into this segment. */
4368 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4369 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
))
4372 /* Allocate a segment map big enough to contain all of the
4373 sections we have selected. */
4374 amt
= sizeof (struct elf_segment_map
);
4375 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4376 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4380 /* Initialise the fields of the segment map. Default to
4381 using the physical address of the segment in the input BFD. */
4383 map
->p_type
= segment
->p_type
;
4384 map
->p_flags
= segment
->p_flags
;
4385 map
->p_flags_valid
= 1;
4386 map
->p_paddr
= segment
->p_paddr
;
4387 map
->p_paddr_valid
= 1;
4389 /* Determine if this segment contains the ELF file header
4390 and if it contains the program headers themselves. */
4391 map
->includes_filehdr
= (segment
->p_offset
== 0
4392 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4394 map
->includes_phdrs
= 0;
4396 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4398 map
->includes_phdrs
=
4399 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4400 && (segment
->p_offset
+ segment
->p_filesz
4401 >= ((bfd_vma
) iehdr
->e_phoff
4402 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4404 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4405 phdr_included
= true;
4408 if (section_count
== 0)
4410 /* Special segments, such as the PT_PHDR segment, may contain
4411 no sections, but ordinary, loadable segments should contain
4413 if (segment
->p_type
== PT_LOAD
)
4415 (_("%s: warning: Empty loadable segment detected\n"),
4416 bfd_archive_filename (ibfd
));
4419 *pointer_to_map
= map
;
4420 pointer_to_map
= &map
->next
;
4425 /* Now scan the sections in the input BFD again and attempt
4426 to add their corresponding output sections to the segment map.
4427 The problem here is how to handle an output section which has
4428 been moved (ie had its LMA changed). There are four possibilities:
4430 1. None of the sections have been moved.
4431 In this case we can continue to use the segment LMA from the
4434 2. All of the sections have been moved by the same amount.
4435 In this case we can change the segment's LMA to match the LMA
4436 of the first section.
4438 3. Some of the sections have been moved, others have not.
4439 In this case those sections which have not been moved can be
4440 placed in the current segment which will have to have its size,
4441 and possibly its LMA changed, and a new segment or segments will
4442 have to be created to contain the other sections.
4444 4. The sections have been moved, but not be the same amount.
4445 In this case we can change the segment's LMA to match the LMA
4446 of the first section and we will have to create a new segment
4447 or segments to contain the other sections.
4449 In order to save time, we allocate an array to hold the section
4450 pointers that we are interested in. As these sections get assigned
4451 to a segment, they are removed from this array. */
4453 amt
= (bfd_size_type
) section_count
* sizeof (asection
*);
4454 sections
= (asection
**) bfd_malloc (amt
);
4455 if (sections
== NULL
)
4458 /* Step One: Scan for segment vs section LMA conflicts.
4459 Also add the sections to the section array allocated above.
4460 Also add the sections to the current segment. In the common
4461 case, where the sections have not been moved, this means that
4462 we have completely filled the segment, and there is nothing
4468 for (j
= 0, section
= ibfd
->sections
;
4470 section
= section
->next
)
4472 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
))
4474 output_section
= section
->output_section
;
4476 sections
[j
++] = section
;
4478 /* The Solaris native linker always sets p_paddr to 0.
4479 We try to catch that case here, and set it to the
4481 if (segment
->p_paddr
== 0
4482 && segment
->p_vaddr
!= 0
4484 && output_section
->lma
!= 0
4485 && (output_section
->vma
== (segment
->p_vaddr
4486 + (map
->includes_filehdr
4489 + (map
->includes_phdrs
4491 * iehdr
->e_phentsize
)
4493 map
->p_paddr
= segment
->p_vaddr
;
4495 /* Match up the physical address of the segment with the
4496 LMA address of the output section. */
4497 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4498 || IS_COREFILE_NOTE (segment
, section
))
4500 if (matching_lma
== 0)
4501 matching_lma
= output_section
->lma
;
4503 /* We assume that if the section fits within the segment
4504 then it does not overlap any other section within that
4506 map
->sections
[isec
++] = output_section
;
4508 else if (suggested_lma
== 0)
4509 suggested_lma
= output_section
->lma
;
4513 BFD_ASSERT (j
== section_count
);
4515 /* Step Two: Adjust the physical address of the current segment,
4517 if (isec
== section_count
)
4519 /* All of the sections fitted within the segment as currently
4520 specified. This is the default case. Add the segment to
4521 the list of built segments and carry on to process the next
4522 program header in the input BFD. */
4523 map
->count
= section_count
;
4524 *pointer_to_map
= map
;
4525 pointer_to_map
= &map
->next
;
4532 if (matching_lma
!= 0)
4534 /* At least one section fits inside the current segment.
4535 Keep it, but modify its physical address to match the
4536 LMA of the first section that fitted. */
4537 map
->p_paddr
= matching_lma
;
4541 /* None of the sections fitted inside the current segment.
4542 Change the current segment's physical address to match
4543 the LMA of the first section. */
4544 map
->p_paddr
= suggested_lma
;
4547 /* Offset the segment physical address from the lma
4548 to allow for space taken up by elf headers. */
4549 if (map
->includes_filehdr
)
4550 map
->p_paddr
-= iehdr
->e_ehsize
;
4552 if (map
->includes_phdrs
)
4554 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
4556 /* iehdr->e_phnum is just an estimate of the number
4557 of program headers that we will need. Make a note
4558 here of the number we used and the segment we chose
4559 to hold these headers, so that we can adjust the
4560 offset when we know the correct value. */
4561 phdr_adjust_num
= iehdr
->e_phnum
;
4562 phdr_adjust_seg
= map
;
4566 /* Step Three: Loop over the sections again, this time assigning
4567 those that fit to the current segment and remvoing them from the
4568 sections array; but making sure not to leave large gaps. Once all
4569 possible sections have been assigned to the current segment it is
4570 added to the list of built segments and if sections still remain
4571 to be assigned, a new segment is constructed before repeating
4579 /* Fill the current segment with sections that fit. */
4580 for (j
= 0; j
< section_count
; j
++)
4582 section
= sections
[j
];
4584 if (section
== NULL
)
4587 output_section
= section
->output_section
;
4589 BFD_ASSERT (output_section
!= NULL
);
4591 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4592 || IS_COREFILE_NOTE (segment
, section
))
4594 if (map
->count
== 0)
4596 /* If the first section in a segment does not start at
4597 the beginning of the segment, then something is
4599 if (output_section
->lma
!=
4601 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
4602 + (map
->includes_phdrs
4603 ? iehdr
->e_phnum
* iehdr
->e_phentsize
4609 asection
* prev_sec
;
4611 prev_sec
= map
->sections
[map
->count
- 1];
4613 /* If the gap between the end of the previous section
4614 and the start of this section is more than
4615 maxpagesize then we need to start a new segment. */
4616 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
,
4618 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
4619 || ((prev_sec
->lma
+ prev_sec
->_raw_size
)
4620 > output_section
->lma
))
4622 if (suggested_lma
== 0)
4623 suggested_lma
= output_section
->lma
;
4629 map
->sections
[map
->count
++] = output_section
;
4632 section
->segment_mark
= true;
4634 else if (suggested_lma
== 0)
4635 suggested_lma
= output_section
->lma
;
4638 BFD_ASSERT (map
->count
> 0);
4640 /* Add the current segment to the list of built segments. */
4641 *pointer_to_map
= map
;
4642 pointer_to_map
= &map
->next
;
4644 if (isec
< section_count
)
4646 /* We still have not allocated all of the sections to
4647 segments. Create a new segment here, initialise it
4648 and carry on looping. */
4649 amt
= sizeof (struct elf_segment_map
);
4650 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4651 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4655 /* Initialise the fields of the segment map. Set the physical
4656 physical address to the LMA of the first section that has
4657 not yet been assigned. */
4659 map
->p_type
= segment
->p_type
;
4660 map
->p_flags
= segment
->p_flags
;
4661 map
->p_flags_valid
= 1;
4662 map
->p_paddr
= suggested_lma
;
4663 map
->p_paddr_valid
= 1;
4664 map
->includes_filehdr
= 0;
4665 map
->includes_phdrs
= 0;
4668 while (isec
< section_count
);
4673 /* The Solaris linker creates program headers in which all the
4674 p_paddr fields are zero. When we try to objcopy or strip such a
4675 file, we get confused. Check for this case, and if we find it
4676 reset the p_paddr_valid fields. */
4677 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
4678 if (map
->p_paddr
!= 0)
4682 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
4683 map
->p_paddr_valid
= 0;
4686 elf_tdata (obfd
)->segment_map
= map_first
;
4688 /* If we had to estimate the number of program headers that were
4689 going to be needed, then check our estimate now and adjust
4690 the offset if necessary. */
4691 if (phdr_adjust_seg
!= NULL
)
4695 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
4698 if (count
> phdr_adjust_num
)
4699 phdr_adjust_seg
->p_paddr
4700 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
4704 /* Final Step: Sort the segments into ascending order of physical
4706 if (map_first
!= NULL
)
4708 struct elf_segment_map
*prev
;
4711 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
4713 /* Yes I know - its a bubble sort.... */
4714 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
4716 /* Swap map and map->next. */
4717 prev
->next
= map
->next
;
4718 map
->next
= map
->next
->next
;
4719 prev
->next
->next
= map
;
4729 #undef IS_CONTAINED_BY_VMA
4730 #undef IS_CONTAINED_BY_LMA
4731 #undef IS_COREFILE_NOTE
4732 #undef IS_SOLARIS_PT_INTERP
4733 #undef INCLUDE_SECTION_IN_SEGMENT
4734 #undef SEGMENT_AFTER_SEGMENT
4735 #undef SEGMENT_OVERLAPS
4739 /* Copy private section information. This copies over the entsize
4740 field, and sometimes the info field. */
4743 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
4749 Elf_Internal_Shdr
*ihdr
, *ohdr
;
4751 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
4752 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
4755 /* Copy over private BFD data if it has not already been copied.
4756 This must be done here, rather than in the copy_private_bfd_data
4757 entry point, because the latter is called after the section
4758 contents have been set, which means that the program headers have
4759 already been worked out. */
4760 if (elf_tdata (obfd
)->segment_map
== NULL
4761 && elf_tdata (ibfd
)->phdr
!= NULL
)
4765 /* Only set up the segments if there are no more SEC_ALLOC
4766 sections. FIXME: This won't do the right thing if objcopy is
4767 used to remove the last SEC_ALLOC section, since objcopy
4768 won't call this routine in that case. */
4769 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
4770 if ((s
->flags
& SEC_ALLOC
) != 0)
4774 if (! copy_private_bfd_data (ibfd
, obfd
))
4779 ihdr
= &elf_section_data (isec
)->this_hdr
;
4780 ohdr
= &elf_section_data (osec
)->this_hdr
;
4782 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
4784 if (ihdr
->sh_type
== SHT_SYMTAB
4785 || ihdr
->sh_type
== SHT_DYNSYM
4786 || ihdr
->sh_type
== SHT_GNU_verneed
4787 || ihdr
->sh_type
== SHT_GNU_verdef
)
4788 ohdr
->sh_info
= ihdr
->sh_info
;
4790 elf_section_data (osec
)->use_rela_p
4791 = elf_section_data (isec
)->use_rela_p
;
4796 /* Copy private symbol information. If this symbol is in a section
4797 which we did not map into a BFD section, try to map the section
4798 index correctly. We use special macro definitions for the mapped
4799 section indices; these definitions are interpreted by the
4800 swap_out_syms function. */
4802 #define MAP_ONESYMTAB (SHN_HIOS + 1)
4803 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
4804 #define MAP_STRTAB (SHN_HIOS + 3)
4805 #define MAP_SHSTRTAB (SHN_HIOS + 4)
4806 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
4809 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
4815 elf_symbol_type
*isym
, *osym
;
4817 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4818 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4821 isym
= elf_symbol_from (ibfd
, isymarg
);
4822 osym
= elf_symbol_from (obfd
, osymarg
);
4826 && bfd_is_abs_section (isym
->symbol
.section
))
4830 shndx
= isym
->internal_elf_sym
.st_shndx
;
4831 if (shndx
== elf_onesymtab (ibfd
))
4832 shndx
= MAP_ONESYMTAB
;
4833 else if (shndx
== elf_dynsymtab (ibfd
))
4834 shndx
= MAP_DYNSYMTAB
;
4835 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
4837 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
4838 shndx
= MAP_SHSTRTAB
;
4839 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
4840 shndx
= MAP_SYM_SHNDX
;
4841 osym
->internal_elf_sym
.st_shndx
= shndx
;
4847 /* Swap out the symbols. */
4850 swap_out_syms (abfd
, sttp
, relocatable_p
)
4852 struct bfd_strtab_hash
**sttp
;
4855 struct elf_backend_data
*bed
;
4858 struct bfd_strtab_hash
*stt
;
4859 Elf_Internal_Shdr
*symtab_hdr
;
4860 Elf_Internal_Shdr
*symtab_shndx_hdr
;
4861 Elf_Internal_Shdr
*symstrtab_hdr
;
4862 char *outbound_syms
;
4863 char *outbound_shndx
;
4867 if (!elf_map_symbols (abfd
))
4870 /* Dump out the symtabs. */
4871 stt
= _bfd_elf_stringtab_init ();
4875 bed
= get_elf_backend_data (abfd
);
4876 symcount
= bfd_get_symcount (abfd
);
4877 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4878 symtab_hdr
->sh_type
= SHT_SYMTAB
;
4879 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
4880 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
4881 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
4882 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
4884 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4885 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4887 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
4888 outbound_syms
= bfd_alloc (abfd
, amt
);
4889 if (outbound_syms
== NULL
)
4891 symtab_hdr
->contents
= (PTR
) outbound_syms
;
4893 outbound_shndx
= NULL
;
4894 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
4895 if (symtab_shndx_hdr
->sh_name
!= 0)
4897 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
4898 outbound_shndx
= bfd_alloc (abfd
, amt
);
4899 if (outbound_shndx
== NULL
)
4901 memset (outbound_shndx
, 0, (unsigned long) amt
);
4902 symtab_shndx_hdr
->contents
= outbound_shndx
;
4903 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
4904 symtab_shndx_hdr
->sh_size
= amt
;
4905 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
4906 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
4909 /* now generate the data (for "contents") */
4911 /* Fill in zeroth symbol and swap it out. */
4912 Elf_Internal_Sym sym
;
4918 sym
.st_shndx
= SHN_UNDEF
;
4919 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
4920 outbound_syms
+= bed
->s
->sizeof_sym
;
4921 if (outbound_shndx
!= NULL
)
4922 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
4925 syms
= bfd_get_outsymbols (abfd
);
4926 for (idx
= 0; idx
< symcount
; idx
++)
4928 Elf_Internal_Sym sym
;
4929 bfd_vma value
= syms
[idx
]->value
;
4930 elf_symbol_type
*type_ptr
;
4931 flagword flags
= syms
[idx
]->flags
;
4934 if ((flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
4936 /* Local section symbols have no name. */
4941 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
4944 if (sym
.st_name
== (unsigned long) -1)
4948 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
4950 if ((flags
& BSF_SECTION_SYM
) == 0
4951 && bfd_is_com_section (syms
[idx
]->section
))
4953 /* ELF common symbols put the alignment into the `value' field,
4954 and the size into the `size' field. This is backwards from
4955 how BFD handles it, so reverse it here. */
4956 sym
.st_size
= value
;
4957 if (type_ptr
== NULL
4958 || type_ptr
->internal_elf_sym
.st_value
== 0)
4959 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
4961 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
4962 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
4963 (abfd
, syms
[idx
]->section
);
4967 asection
*sec
= syms
[idx
]->section
;
4970 if (sec
->output_section
)
4972 value
+= sec
->output_offset
;
4973 sec
= sec
->output_section
;
4975 /* Don't add in the section vma for relocatable output. */
4976 if (! relocatable_p
)
4978 sym
.st_value
= value
;
4979 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4981 if (bfd_is_abs_section (sec
)
4983 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4985 /* This symbol is in a real ELF section which we did
4986 not create as a BFD section. Undo the mapping done
4987 by copy_private_symbol_data. */
4988 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
4992 shndx
= elf_onesymtab (abfd
);
4995 shndx
= elf_dynsymtab (abfd
);
4998 shndx
= elf_tdata (abfd
)->strtab_section
;
5001 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5004 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5012 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5018 /* Writing this would be a hell of a lot easier if
5019 we had some decent documentation on bfd, and
5020 knew what to expect of the library, and what to
5021 demand of applications. For example, it
5022 appears that `objcopy' might not set the
5023 section of a symbol to be a section that is
5024 actually in the output file. */
5025 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5026 BFD_ASSERT (sec2
!= 0);
5027 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5028 BFD_ASSERT (shndx
!= -1);
5032 sym
.st_shndx
= shndx
;
5035 if ((flags
& BSF_FUNCTION
) != 0)
5037 else if ((flags
& BSF_OBJECT
) != 0)
5042 /* Processor-specific types */
5043 if (type_ptr
!= NULL
5044 && bed
->elf_backend_get_symbol_type
)
5045 type
= ((*bed
->elf_backend_get_symbol_type
)
5046 (&type_ptr
->internal_elf_sym
, type
));
5048 if (flags
& BSF_SECTION_SYM
)
5050 if (flags
& BSF_GLOBAL
)
5051 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5053 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5055 else if (bfd_is_com_section (syms
[idx
]->section
))
5056 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5057 else if (bfd_is_und_section (syms
[idx
]->section
))
5058 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5062 else if (flags
& BSF_FILE
)
5063 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5066 int bind
= STB_LOCAL
;
5068 if (flags
& BSF_LOCAL
)
5070 else if (flags
& BSF_WEAK
)
5072 else if (flags
& BSF_GLOBAL
)
5075 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5078 if (type_ptr
!= NULL
)
5079 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5083 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5084 outbound_syms
+= bed
->s
->sizeof_sym
;
5085 if (outbound_shndx
!= NULL
)
5086 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5090 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5091 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5093 symstrtab_hdr
->sh_flags
= 0;
5094 symstrtab_hdr
->sh_addr
= 0;
5095 symstrtab_hdr
->sh_entsize
= 0;
5096 symstrtab_hdr
->sh_link
= 0;
5097 symstrtab_hdr
->sh_info
= 0;
5098 symstrtab_hdr
->sh_addralign
= 1;
5103 /* Return the number of bytes required to hold the symtab vector.
5105 Note that we base it on the count plus 1, since we will null terminate
5106 the vector allocated based on this size. However, the ELF symbol table
5107 always has a dummy entry as symbol #0, so it ends up even. */
5110 _bfd_elf_get_symtab_upper_bound (abfd
)
5115 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5117 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5118 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5120 symtab_size
-= sizeof (asymbol
*);
5126 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
5131 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5133 if (elf_dynsymtab (abfd
) == 0)
5135 bfd_set_error (bfd_error_invalid_operation
);
5139 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5140 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5142 symtab_size
-= sizeof (asymbol
*);
5148 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
5149 bfd
*abfd ATTRIBUTE_UNUSED
;
5152 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5155 /* Canonicalize the relocs. */
5158 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5166 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5168 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
5171 tblptr
= section
->relocation
;
5172 for (i
= 0; i
< section
->reloc_count
; i
++)
5173 *relptr
++ = tblptr
++;
5177 return section
->reloc_count
;
5181 _bfd_elf_get_symtab (abfd
, alocation
)
5183 asymbol
**alocation
;
5185 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5186 long symcount
= bed
->s
->slurp_symbol_table (abfd
, alocation
, false);
5189 bfd_get_symcount (abfd
) = symcount
;
5194 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
5196 asymbol
**alocation
;
5198 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5199 return bed
->s
->slurp_symbol_table (abfd
, alocation
, true);
5202 /* Return the size required for the dynamic reloc entries. Any
5203 section that was actually installed in the BFD, and has type
5204 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5205 considered to be a dynamic reloc section. */
5208 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
5214 if (elf_dynsymtab (abfd
) == 0)
5216 bfd_set_error (bfd_error_invalid_operation
);
5220 ret
= sizeof (arelent
*);
5221 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5222 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5223 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5224 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5225 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5226 * sizeof (arelent
*));
5231 /* Canonicalize the dynamic relocation entries. Note that we return
5232 the dynamic relocations as a single block, although they are
5233 actually associated with particular sections; the interface, which
5234 was designed for SunOS style shared libraries, expects that there
5235 is only one set of dynamic relocs. Any section that was actually
5236 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5237 the dynamic symbol table, is considered to be a dynamic reloc
5241 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
5246 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
5250 if (elf_dynsymtab (abfd
) == 0)
5252 bfd_set_error (bfd_error_invalid_operation
);
5256 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5258 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5260 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5261 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5262 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5267 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
5269 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5271 for (i
= 0; i
< count
; i
++)
5282 /* Read in the version information. */
5285 _bfd_elf_slurp_version_tables (abfd
)
5288 bfd_byte
*contents
= NULL
;
5291 if (elf_dynverdef (abfd
) != 0)
5293 Elf_Internal_Shdr
*hdr
;
5294 Elf_External_Verdef
*everdef
;
5295 Elf_Internal_Verdef
*iverdef
;
5296 Elf_Internal_Verdef
*iverdefarr
;
5297 Elf_Internal_Verdef iverdefmem
;
5299 unsigned int maxidx
;
5301 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5303 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5304 if (contents
== NULL
)
5306 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5307 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5310 /* We know the number of entries in the section but not the maximum
5311 index. Therefore we have to run through all entries and find
5313 everdef
= (Elf_External_Verdef
*) contents
;
5315 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5317 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5319 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5320 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5322 everdef
= ((Elf_External_Verdef
*)
5323 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5326 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5327 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
5328 if (elf_tdata (abfd
)->verdef
== NULL
)
5331 elf_tdata (abfd
)->cverdefs
= maxidx
;
5333 everdef
= (Elf_External_Verdef
*) contents
;
5334 iverdefarr
= elf_tdata (abfd
)->verdef
;
5335 for (i
= 0; i
< hdr
->sh_info
; i
++)
5337 Elf_External_Verdaux
*everdaux
;
5338 Elf_Internal_Verdaux
*iverdaux
;
5341 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5343 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5344 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5346 iverdef
->vd_bfd
= abfd
;
5348 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5349 iverdef
->vd_auxptr
= (Elf_Internal_Verdaux
*) bfd_alloc (abfd
, amt
);
5350 if (iverdef
->vd_auxptr
== NULL
)
5353 everdaux
= ((Elf_External_Verdaux
*)
5354 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5355 iverdaux
= iverdef
->vd_auxptr
;
5356 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5358 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5360 iverdaux
->vda_nodename
=
5361 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5362 iverdaux
->vda_name
);
5363 if (iverdaux
->vda_nodename
== NULL
)
5366 if (j
+ 1 < iverdef
->vd_cnt
)
5367 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5369 iverdaux
->vda_nextptr
= NULL
;
5371 everdaux
= ((Elf_External_Verdaux
*)
5372 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5375 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5377 if (i
+ 1 < hdr
->sh_info
)
5378 iverdef
->vd_nextdef
= iverdef
+ 1;
5380 iverdef
->vd_nextdef
= NULL
;
5382 everdef
= ((Elf_External_Verdef
*)
5383 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5390 if (elf_dynverref (abfd
) != 0)
5392 Elf_Internal_Shdr
*hdr
;
5393 Elf_External_Verneed
*everneed
;
5394 Elf_Internal_Verneed
*iverneed
;
5397 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5399 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5400 elf_tdata (abfd
)->verref
=
5401 (Elf_Internal_Verneed
*) bfd_zalloc (abfd
, amt
);
5402 if (elf_tdata (abfd
)->verref
== NULL
)
5405 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5407 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5408 if (contents
== NULL
)
5410 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5411 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5414 everneed
= (Elf_External_Verneed
*) contents
;
5415 iverneed
= elf_tdata (abfd
)->verref
;
5416 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
5418 Elf_External_Vernaux
*evernaux
;
5419 Elf_Internal_Vernaux
*ivernaux
;
5422 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
5424 iverneed
->vn_bfd
= abfd
;
5426 iverneed
->vn_filename
=
5427 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5429 if (iverneed
->vn_filename
== NULL
)
5432 amt
= iverneed
->vn_cnt
;
5433 amt
*= sizeof (Elf_Internal_Vernaux
);
5434 iverneed
->vn_auxptr
= (Elf_Internal_Vernaux
*) bfd_alloc (abfd
, amt
);
5436 evernaux
= ((Elf_External_Vernaux
*)
5437 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
5438 ivernaux
= iverneed
->vn_auxptr
;
5439 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
5441 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
5443 ivernaux
->vna_nodename
=
5444 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5445 ivernaux
->vna_name
);
5446 if (ivernaux
->vna_nodename
== NULL
)
5449 if (j
+ 1 < iverneed
->vn_cnt
)
5450 ivernaux
->vna_nextptr
= ivernaux
+ 1;
5452 ivernaux
->vna_nextptr
= NULL
;
5454 evernaux
= ((Elf_External_Vernaux
*)
5455 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
5458 if (i
+ 1 < hdr
->sh_info
)
5459 iverneed
->vn_nextref
= iverneed
+ 1;
5461 iverneed
->vn_nextref
= NULL
;
5463 everneed
= ((Elf_External_Verneed
*)
5464 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
5474 if (contents
== NULL
)
5480 _bfd_elf_make_empty_symbol (abfd
)
5483 elf_symbol_type
*newsym
;
5484 bfd_size_type amt
= sizeof (elf_symbol_type
);
5486 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
5491 newsym
->symbol
.the_bfd
= abfd
;
5492 return &newsym
->symbol
;
5497 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
5498 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5502 bfd_symbol_info (symbol
, ret
);
5505 /* Return whether a symbol name implies a local symbol. Most targets
5506 use this function for the is_local_label_name entry point, but some
5510 _bfd_elf_is_local_label_name (abfd
, name
)
5511 bfd
*abfd ATTRIBUTE_UNUSED
;
5514 /* Normal local symbols start with ``.L''. */
5515 if (name
[0] == '.' && name
[1] == 'L')
5518 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5519 DWARF debugging symbols starting with ``..''. */
5520 if (name
[0] == '.' && name
[1] == '.')
5523 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5524 emitting DWARF debugging output. I suspect this is actually a
5525 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5526 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5527 underscore to be emitted on some ELF targets). For ease of use,
5528 we treat such symbols as local. */
5529 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
5536 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
5537 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5538 asymbol
*symbol ATTRIBUTE_UNUSED
;
5545 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
5547 enum bfd_architecture arch
;
5548 unsigned long machine
;
5550 /* If this isn't the right architecture for this backend, and this
5551 isn't the generic backend, fail. */
5552 if (arch
!= get_elf_backend_data (abfd
)->arch
5553 && arch
!= bfd_arch_unknown
5554 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
5557 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5560 /* Find the function to a particular section and offset,
5561 for error reporting. */
5564 elf_find_function (abfd
, section
, symbols
, offset
,
5565 filename_ptr
, functionname_ptr
)
5566 bfd
*abfd ATTRIBUTE_UNUSED
;
5570 const char **filename_ptr
;
5571 const char **functionname_ptr
;
5573 const char *filename
;
5582 for (p
= symbols
; *p
!= NULL
; p
++)
5586 q
= (elf_symbol_type
*) *p
;
5588 if (bfd_get_section (&q
->symbol
) != section
)
5591 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
5596 filename
= bfd_asymbol_name (&q
->symbol
);
5600 if (q
->symbol
.section
== section
5601 && q
->symbol
.value
>= low_func
5602 && q
->symbol
.value
<= offset
)
5604 func
= (asymbol
*) q
;
5605 low_func
= q
->symbol
.value
;
5615 *filename_ptr
= filename
;
5616 if (functionname_ptr
)
5617 *functionname_ptr
= bfd_asymbol_name (func
);
5622 /* Find the nearest line to a particular section and offset,
5623 for error reporting. */
5626 _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
5627 filename_ptr
, functionname_ptr
, line_ptr
)
5632 const char **filename_ptr
;
5633 const char **functionname_ptr
;
5634 unsigned int *line_ptr
;
5638 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
5639 filename_ptr
, functionname_ptr
,
5642 if (!*functionname_ptr
)
5643 elf_find_function (abfd
, section
, symbols
, offset
,
5644 *filename_ptr
? NULL
: filename_ptr
,
5650 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
5651 filename_ptr
, functionname_ptr
,
5653 &elf_tdata (abfd
)->dwarf2_find_line_info
))
5655 if (!*functionname_ptr
)
5656 elf_find_function (abfd
, section
, symbols
, offset
,
5657 *filename_ptr
? NULL
: filename_ptr
,
5663 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
5664 &found
, filename_ptr
,
5665 functionname_ptr
, line_ptr
,
5666 &elf_tdata (abfd
)->line_info
))
5671 if (symbols
== NULL
)
5674 if (! elf_find_function (abfd
, section
, symbols
, offset
,
5675 filename_ptr
, functionname_ptr
))
5683 _bfd_elf_sizeof_headers (abfd
, reloc
)
5689 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
5691 ret
+= get_program_header_size (abfd
);
5696 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
5701 bfd_size_type count
;
5703 Elf_Internal_Shdr
*hdr
;
5706 if (! abfd
->output_has_begun
5707 && ! _bfd_elf_compute_section_file_positions
5708 (abfd
, (struct bfd_link_info
*) NULL
))
5711 hdr
= &elf_section_data (section
)->this_hdr
;
5712 pos
= hdr
->sh_offset
+ offset
;
5713 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
5714 || bfd_bwrite (location
, count
, abfd
) != count
)
5721 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
5722 bfd
*abfd ATTRIBUTE_UNUSED
;
5723 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
5724 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
5731 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
5734 Elf_Internal_Rel
*dst
;
5740 /* Try to convert a non-ELF reloc into an ELF one. */
5743 _bfd_elf_validate_reloc (abfd
, areloc
)
5747 /* Check whether we really have an ELF howto. */
5749 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
5751 bfd_reloc_code_real_type code
;
5752 reloc_howto_type
*howto
;
5754 /* Alien reloc: Try to determine its type to replace it with an
5755 equivalent ELF reloc. */
5757 if (areloc
->howto
->pc_relative
)
5759 switch (areloc
->howto
->bitsize
)
5762 code
= BFD_RELOC_8_PCREL
;
5765 code
= BFD_RELOC_12_PCREL
;
5768 code
= BFD_RELOC_16_PCREL
;
5771 code
= BFD_RELOC_24_PCREL
;
5774 code
= BFD_RELOC_32_PCREL
;
5777 code
= BFD_RELOC_64_PCREL
;
5783 howto
= bfd_reloc_type_lookup (abfd
, code
);
5785 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
5787 if (howto
->pcrel_offset
)
5788 areloc
->addend
+= areloc
->address
;
5790 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
5795 switch (areloc
->howto
->bitsize
)
5801 code
= BFD_RELOC_14
;
5804 code
= BFD_RELOC_16
;
5807 code
= BFD_RELOC_26
;
5810 code
= BFD_RELOC_32
;
5813 code
= BFD_RELOC_64
;
5819 howto
= bfd_reloc_type_lookup (abfd
, code
);
5823 areloc
->howto
= howto
;
5831 (*_bfd_error_handler
)
5832 (_("%s: unsupported relocation type %s"),
5833 bfd_archive_filename (abfd
), areloc
->howto
->name
);
5834 bfd_set_error (bfd_error_bad_value
);
5839 _bfd_elf_close_and_cleanup (abfd
)
5842 if (bfd_get_format (abfd
) == bfd_object
)
5844 if (elf_shstrtab (abfd
) != NULL
)
5845 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
5848 return _bfd_generic_close_and_cleanup (abfd
);
5851 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5852 in the relocation's offset. Thus we cannot allow any sort of sanity
5853 range-checking to interfere. There is nothing else to do in processing
5856 bfd_reloc_status_type
5857 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
5858 bfd
*abfd ATTRIBUTE_UNUSED
;
5859 arelent
*re ATTRIBUTE_UNUSED
;
5860 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
5861 PTR data ATTRIBUTE_UNUSED
;
5862 asection
*is ATTRIBUTE_UNUSED
;
5863 bfd
*obfd ATTRIBUTE_UNUSED
;
5864 char **errmsg ATTRIBUTE_UNUSED
;
5866 return bfd_reloc_ok
;
5869 /* Elf core file support. Much of this only works on native
5870 toolchains, since we rely on knowing the
5871 machine-dependent procfs structure in order to pick
5872 out details about the corefile. */
5874 #ifdef HAVE_SYS_PROCFS_H
5875 # include <sys/procfs.h>
5878 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5881 elfcore_make_pid (abfd
)
5884 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
5885 + (elf_tdata (abfd
)->core_pid
));
5888 /* If there isn't a section called NAME, make one, using
5889 data from SECT. Note, this function will generate a
5890 reference to NAME, so you shouldn't deallocate or
5894 elfcore_maybe_make_sect (abfd
, name
, sect
)
5901 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
5904 sect2
= bfd_make_section (abfd
, name
);
5908 sect2
->_raw_size
= sect
->_raw_size
;
5909 sect2
->filepos
= sect
->filepos
;
5910 sect2
->flags
= sect
->flags
;
5911 sect2
->alignment_power
= sect
->alignment_power
;
5915 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
5916 actually creates up to two pseudosections:
5917 - For the single-threaded case, a section named NAME, unless
5918 such a section already exists.
5919 - For the multi-threaded case, a section named "NAME/PID", where
5920 PID is elfcore_make_pid (abfd).
5921 Both pseudosections have identical contents. */
5923 _bfd_elfcore_make_pseudosection (abfd
, name
, size
, filepos
)
5930 char *threaded_name
;
5933 /* Build the section name. */
5935 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
5936 threaded_name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
5937 if (threaded_name
== NULL
)
5939 strcpy (threaded_name
, buf
);
5941 sect
= bfd_make_section (abfd
, threaded_name
);
5944 sect
->_raw_size
= size
;
5945 sect
->filepos
= filepos
;
5946 sect
->flags
= SEC_HAS_CONTENTS
;
5947 sect
->alignment_power
= 2;
5949 return elfcore_maybe_make_sect (abfd
, name
, sect
);
5952 /* prstatus_t exists on:
5954 linux 2.[01] + glibc
5958 #if defined (HAVE_PRSTATUS_T)
5959 static boolean elfcore_grok_prstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
5962 elfcore_grok_prstatus (abfd
, note
)
5964 Elf_Internal_Note
*note
;
5969 if (note
->descsz
== sizeof (prstatus_t
))
5973 raw_size
= sizeof (prstat
.pr_reg
);
5974 offset
= offsetof (prstatus_t
, pr_reg
);
5975 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5977 /* Do not overwrite the core signal if it
5978 has already been set by another thread. */
5979 if (elf_tdata (abfd
)->core_signal
== 0)
5980 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5981 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5983 /* pr_who exists on:
5986 pr_who doesn't exist on:
5989 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5990 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
5993 #if defined (HAVE_PRSTATUS32_T)
5994 else if (note
->descsz
== sizeof (prstatus32_t
))
5996 /* 64-bit host, 32-bit corefile */
5997 prstatus32_t prstat
;
5999 raw_size
= sizeof (prstat
.pr_reg
);
6000 offset
= offsetof (prstatus32_t
, pr_reg
);
6001 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6003 /* Do not overwrite the core signal if it
6004 has already been set by another thread. */
6005 if (elf_tdata (abfd
)->core_signal
== 0)
6006 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6007 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6009 /* pr_who exists on:
6012 pr_who doesn't exist on:
6015 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6016 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6019 #endif /* HAVE_PRSTATUS32_T */
6022 /* Fail - we don't know how to handle any other
6023 note size (ie. data object type). */
6027 /* Make a ".reg/999" section and a ".reg" section. */
6028 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6029 raw_size
, note
->descpos
+ offset
);
6031 #endif /* defined (HAVE_PRSTATUS_T) */
6033 /* Create a pseudosection containing the exact contents of NOTE. */
6035 elfcore_make_note_pseudosection (abfd
, name
, note
)
6038 Elf_Internal_Note
*note
;
6040 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6041 note
->descsz
, note
->descpos
);
6044 /* There isn't a consistent prfpregset_t across platforms,
6045 but it doesn't matter, because we don't have to pick this
6046 data structure apart. */
6049 elfcore_grok_prfpreg (abfd
, note
)
6051 Elf_Internal_Note
*note
;
6053 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6056 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6057 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6061 elfcore_grok_prxfpreg (abfd
, note
)
6063 Elf_Internal_Note
*note
;
6065 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6068 #if defined (HAVE_PRPSINFO_T)
6069 typedef prpsinfo_t elfcore_psinfo_t
;
6070 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6071 typedef prpsinfo32_t elfcore_psinfo32_t
;
6075 #if defined (HAVE_PSINFO_T)
6076 typedef psinfo_t elfcore_psinfo_t
;
6077 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6078 typedef psinfo32_t elfcore_psinfo32_t
;
6082 /* return a malloc'ed copy of a string at START which is at
6083 most MAX bytes long, possibly without a terminating '\0'.
6084 the copy will always have a terminating '\0'. */
6087 _bfd_elfcore_strndup (abfd
, start
, max
)
6093 char *end
= memchr (start
, '\0', max
);
6101 dups
= bfd_alloc (abfd
, (bfd_size_type
) len
+ 1);
6105 memcpy (dups
, start
, len
);
6111 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6112 static boolean elfcore_grok_psinfo
PARAMS ((bfd
*, Elf_Internal_Note
*));
6115 elfcore_grok_psinfo (abfd
, note
)
6117 Elf_Internal_Note
*note
;
6119 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6121 elfcore_psinfo_t psinfo
;
6123 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6125 elf_tdata (abfd
)->core_program
6126 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6127 sizeof (psinfo
.pr_fname
));
6129 elf_tdata (abfd
)->core_command
6130 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6131 sizeof (psinfo
.pr_psargs
));
6133 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6134 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6136 /* 64-bit host, 32-bit corefile */
6137 elfcore_psinfo32_t psinfo
;
6139 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6141 elf_tdata (abfd
)->core_program
6142 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6143 sizeof (psinfo
.pr_fname
));
6145 elf_tdata (abfd
)->core_command
6146 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6147 sizeof (psinfo
.pr_psargs
));
6153 /* Fail - we don't know how to handle any other
6154 note size (ie. data object type). */
6158 /* Note that for some reason, a spurious space is tacked
6159 onto the end of the args in some (at least one anyway)
6160 implementations, so strip it off if it exists. */
6163 char *command
= elf_tdata (abfd
)->core_command
;
6164 int n
= strlen (command
);
6166 if (0 < n
&& command
[n
- 1] == ' ')
6167 command
[n
- 1] = '\0';
6172 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6174 #if defined (HAVE_PSTATUS_T)
6175 static boolean elfcore_grok_pstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
6178 elfcore_grok_pstatus (abfd
, note
)
6180 Elf_Internal_Note
*note
;
6182 if (note
->descsz
== sizeof (pstatus_t
)
6183 #if defined (HAVE_PXSTATUS_T)
6184 || note
->descsz
== sizeof (pxstatus_t
)
6190 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6192 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6194 #if defined (HAVE_PSTATUS32_T)
6195 else if (note
->descsz
== sizeof (pstatus32_t
))
6197 /* 64-bit host, 32-bit corefile */
6200 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6202 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6205 /* Could grab some more details from the "representative"
6206 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6207 NT_LWPSTATUS note, presumably. */
6211 #endif /* defined (HAVE_PSTATUS_T) */
6213 #if defined (HAVE_LWPSTATUS_T)
6214 static boolean elfcore_grok_lwpstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
6217 elfcore_grok_lwpstatus (abfd
, note
)
6219 Elf_Internal_Note
*note
;
6221 lwpstatus_t lwpstat
;
6226 if (note
->descsz
!= sizeof (lwpstat
)
6227 #if defined (HAVE_LWPXSTATUS_T)
6228 && note
->descsz
!= sizeof (lwpxstatus_t
)
6233 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6235 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6236 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6238 /* Make a ".reg/999" section. */
6240 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6241 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6246 sect
= bfd_make_section (abfd
, name
);
6250 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6251 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6252 sect
->filepos
= note
->descpos
6253 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6256 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6257 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
6258 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6261 sect
->flags
= SEC_HAS_CONTENTS
;
6262 sect
->alignment_power
= 2;
6264 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6267 /* Make a ".reg2/999" section */
6269 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6270 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6275 sect
= bfd_make_section (abfd
, name
);
6279 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6280 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6281 sect
->filepos
= note
->descpos
6282 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6285 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6286 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
6287 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6290 sect
->flags
= SEC_HAS_CONTENTS
;
6291 sect
->alignment_power
= 2;
6293 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6295 #endif /* defined (HAVE_LWPSTATUS_T) */
6297 #if defined (HAVE_WIN32_PSTATUS_T)
6299 elfcore_grok_win32pstatus (abfd
, note
)
6301 Elf_Internal_Note
*note
;
6306 win32_pstatus_t pstatus
;
6308 if (note
->descsz
< sizeof (pstatus
))
6311 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6313 switch (pstatus
.data_type
)
6315 case NOTE_INFO_PROCESS
:
6316 /* FIXME: need to add ->core_command. */
6317 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6318 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6321 case NOTE_INFO_THREAD
:
6322 /* Make a ".reg/999" section. */
6323 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6325 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6331 sect
= bfd_make_section (abfd
, name
);
6335 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6336 sect
->filepos
= (note
->descpos
6337 + offsetof (struct win32_pstatus
,
6338 data
.thread_info
.thread_context
));
6339 sect
->flags
= SEC_HAS_CONTENTS
;
6340 sect
->alignment_power
= 2;
6342 if (pstatus
.data
.thread_info
.is_active_thread
)
6343 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6347 case NOTE_INFO_MODULE
:
6348 /* Make a ".module/xxxxxxxx" section. */
6349 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6351 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6357 sect
= bfd_make_section (abfd
, name
);
6362 sect
->_raw_size
= note
->descsz
;
6363 sect
->filepos
= note
->descpos
;
6364 sect
->flags
= SEC_HAS_CONTENTS
;
6365 sect
->alignment_power
= 2;
6374 #endif /* HAVE_WIN32_PSTATUS_T */
6377 elfcore_grok_note (abfd
, note
)
6379 Elf_Internal_Note
*note
;
6381 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6389 if (bed
->elf_backend_grok_prstatus
)
6390 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6392 #if defined (HAVE_PRSTATUS_T)
6393 return elfcore_grok_prstatus (abfd
, note
);
6398 #if defined (HAVE_PSTATUS_T)
6400 return elfcore_grok_pstatus (abfd
, note
);
6403 #if defined (HAVE_LWPSTATUS_T)
6405 return elfcore_grok_lwpstatus (abfd
, note
);
6408 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6409 return elfcore_grok_prfpreg (abfd
, note
);
6411 #if defined (HAVE_WIN32_PSTATUS_T)
6412 case NT_WIN32PSTATUS
:
6413 return elfcore_grok_win32pstatus (abfd
, note
);
6416 case NT_PRXFPREG
: /* Linux SSE extension */
6417 if (note
->namesz
== 5
6418 && ! strcmp (note
->namedata
, "LINUX"))
6419 return elfcore_grok_prxfpreg (abfd
, note
);
6425 if (bed
->elf_backend_grok_psinfo
)
6426 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6428 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6429 return elfcore_grok_psinfo (abfd
, note
);
6437 elfcore_netbsd_get_lwpid (note
, lwpidp
)
6438 Elf_Internal_Note
*note
;
6443 cp
= strchr (note
->namedata
, '@');
6446 *lwpidp
= atoi(cp
+ 1);
6453 elfcore_grok_netbsd_procinfo (abfd
, note
)
6455 Elf_Internal_Note
*note
;
6458 /* Signal number at offset 0x08. */
6459 elf_tdata (abfd
)->core_signal
6460 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
6462 /* Process ID at offset 0x50. */
6463 elf_tdata (abfd
)->core_pid
6464 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
6466 /* Command name at 0x7c (max 32 bytes, including nul). */
6467 elf_tdata (abfd
)->core_command
6468 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
6474 elfcore_grok_netbsd_note (abfd
, note
)
6476 Elf_Internal_Note
*note
;
6480 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
6481 elf_tdata (abfd
)->core_lwpid
= lwp
;
6483 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
6485 /* NetBSD-specific core "procinfo". Note that we expect to
6486 find this note before any of the others, which is fine,
6487 since the kernel writes this note out first when it
6488 creates a core file. */
6490 return elfcore_grok_netbsd_procinfo (abfd
, note
);
6493 /* As of Jan 2002 there are no other machine-independent notes
6494 defined for NetBSD core files. If the note type is less
6495 than the start of the machine-dependent note types, we don't
6498 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
6502 switch (bfd_get_arch (abfd
))
6504 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6505 PT_GETFPREGS == mach+2. */
6507 case bfd_arch_alpha
:
6508 case bfd_arch_sparc
:
6511 case NT_NETBSDCORE_FIRSTMACH
+0:
6512 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6514 case NT_NETBSDCORE_FIRSTMACH
+2:
6515 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6521 /* On all other arch's, PT_GETREGS == mach+1 and
6522 PT_GETFPREGS == mach+3. */
6527 case NT_NETBSDCORE_FIRSTMACH
+1:
6528 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6530 case NT_NETBSDCORE_FIRSTMACH
+3:
6531 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6540 /* Function: elfcore_write_note
6547 size of data for note
6550 End of buffer containing note. */
6553 elfcore_write_note (abfd
, buf
, bufsiz
, name
, type
, input
, size
)
6562 Elf_External_Note
*xnp
;
6563 int namesz
= strlen (name
);
6564 int newspace
= BFD_ALIGN (sizeof (Elf_External_Note
) + size
+ namesz
- 1, 4);
6567 p
= realloc (buf
, *bufsiz
+ newspace
);
6569 *bufsiz
+= newspace
;
6570 xnp
= (Elf_External_Note
*) dest
;
6571 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
6572 H_PUT_32 (abfd
, size
, xnp
->descsz
);
6573 H_PUT_32 (abfd
, type
, xnp
->type
);
6574 strcpy (xnp
->name
, name
);
6575 memcpy (xnp
->name
+ BFD_ALIGN (namesz
, 4), input
, size
);
6579 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6581 elfcore_write_prpsinfo (abfd
, buf
, bufsiz
, fname
, psargs
)
6589 char *note_name
= "CORE";
6591 #if defined (HAVE_PSINFO_T)
6593 note_type
= NT_PSINFO
;
6596 note_type
= NT_PRPSINFO
;
6599 memset (&data
, 0, sizeof (data
));
6600 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
6601 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
6602 return elfcore_write_note (abfd
, buf
, bufsiz
,
6603 note_name
, note_type
, &data
, sizeof (data
));
6605 #endif /* PSINFO_T or PRPSINFO_T */
6607 #if defined (HAVE_PRSTATUS_T)
6609 elfcore_write_prstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6618 char *note_name
= "CORE";
6620 memset (&prstat
, 0, sizeof (prstat
));
6621 prstat
.pr_pid
= pid
;
6622 prstat
.pr_cursig
= cursig
;
6623 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
6624 return elfcore_write_note (abfd
, buf
, bufsiz
,
6625 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
6627 #endif /* HAVE_PRSTATUS_T */
6629 #if defined (HAVE_LWPSTATUS_T)
6631 elfcore_write_lwpstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6639 lwpstatus_t lwpstat
;
6640 char *note_name
= "CORE";
6642 memset (&lwpstat
, 0, sizeof (lwpstat
));
6643 lwpstat
.pr_lwpid
= pid
>> 16;
6644 lwpstat
.pr_cursig
= cursig
;
6645 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6646 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
6647 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6649 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
6650 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
6652 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
6653 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
6656 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
6657 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
6659 #endif /* HAVE_LWPSTATUS_T */
6661 #if defined (HAVE_PSTATUS_T)
6663 elfcore_write_pstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6672 char *note_name
= "CORE";
6674 memset (&pstat
, 0, sizeof (pstat
));
6675 pstat
.pr_pid
= pid
& 0xffff;
6676 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
6677 NT_PSTATUS
, &pstat
, sizeof (pstat
));
6680 #endif /* HAVE_PSTATUS_T */
6683 elfcore_write_prfpreg (abfd
, buf
, bufsiz
, fpregs
, size
)
6690 char *note_name
= "CORE";
6691 return elfcore_write_note (abfd
, buf
, bufsiz
,
6692 note_name
, NT_FPREGSET
, fpregs
, size
);
6696 elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, xfpregs
, size
)
6703 char *note_name
= "LINUX";
6704 return elfcore_write_note (abfd
, buf
, bufsiz
,
6705 note_name
, NT_PRXFPREG
, xfpregs
, size
);
6709 elfcore_read_notes (abfd
, offset
, size
)
6720 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
6723 buf
= bfd_malloc (size
);
6727 if (bfd_bread (buf
, size
, abfd
) != size
)
6735 while (p
< buf
+ size
)
6737 /* FIXME: bad alignment assumption. */
6738 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
6739 Elf_Internal_Note in
;
6741 in
.type
= H_GET_32 (abfd
, xnp
->type
);
6743 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
6744 in
.namedata
= xnp
->name
;
6746 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
6747 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
6748 in
.descpos
= offset
+ (in
.descdata
- buf
);
6750 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
6752 if (! elfcore_grok_netbsd_note (abfd
, &in
))
6757 if (! elfcore_grok_note (abfd
, &in
))
6761 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
6768 /* Providing external access to the ELF program header table. */
6770 /* Return an upper bound on the number of bytes required to store a
6771 copy of ABFD's program header table entries. Return -1 if an error
6772 occurs; bfd_get_error will return an appropriate code. */
6775 bfd_get_elf_phdr_upper_bound (abfd
)
6778 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6780 bfd_set_error (bfd_error_wrong_format
);
6784 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
6787 /* Copy ABFD's program header table entries to *PHDRS. The entries
6788 will be stored as an array of Elf_Internal_Phdr structures, as
6789 defined in include/elf/internal.h. To find out how large the
6790 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
6792 Return the number of program header table entries read, or -1 if an
6793 error occurs; bfd_get_error will return an appropriate code. */
6796 bfd_get_elf_phdrs (abfd
, phdrs
)
6802 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6804 bfd_set_error (bfd_error_wrong_format
);
6808 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
6809 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
6810 num_phdrs
* sizeof (Elf_Internal_Phdr
));
6816 _bfd_elf_sprintf_vma (abfd
, buf
, value
)
6817 bfd
*abfd ATTRIBUTE_UNUSED
;
6822 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
6824 i_ehdrp
= elf_elfheader (abfd
);
6825 if (i_ehdrp
== NULL
)
6826 sprintf_vma (buf
, value
);
6829 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
6831 #if BFD_HOST_64BIT_LONG
6832 sprintf (buf
, "%016lx", value
);
6834 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
6835 _bfd_int64_low (value
));
6839 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
6842 sprintf_vma (buf
, value
);
6847 _bfd_elf_fprintf_vma (abfd
, stream
, value
)
6848 bfd
*abfd ATTRIBUTE_UNUSED
;
6853 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
6855 i_ehdrp
= elf_elfheader (abfd
);
6856 if (i_ehdrp
== NULL
)
6857 fprintf_vma ((FILE *) stream
, value
);
6860 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
6862 #if BFD_HOST_64BIT_LONG
6863 fprintf ((FILE *) stream
, "%016lx", value
);
6865 fprintf ((FILE *) stream
, "%08lx%08lx",
6866 _bfd_int64_high (value
), _bfd_int64_low (value
));
6870 fprintf ((FILE *) stream
, "%08lx",
6871 (unsigned long) (value
& 0xffffffff));
6874 fprintf_vma ((FILE *) stream
, value
);
6878 enum elf_reloc_type_class
6879 _bfd_elf_reloc_type_class (rela
)
6880 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
;
6882 return reloc_class_normal
;
6885 /* For RELA architectures, return what the relocation value for
6886 relocation against a local symbol. */
6889 _bfd_elf_rela_local_sym (abfd
, sym
, sec
, rel
)
6891 Elf_Internal_Sym
*sym
;
6893 Elf_Internal_Rela
*rel
;
6897 relocation
= (sec
->output_section
->vma
6898 + sec
->output_offset
6900 if ((sec
->flags
& SEC_MERGE
)
6901 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
6902 && elf_section_data (sec
)->sec_info_type
== ELF_INFO_TYPE_MERGE
)
6908 _bfd_merged_section_offset (abfd
, &msec
,
6909 elf_section_data (sec
)->sec_info
,
6910 sym
->st_value
+ rel
->r_addend
,
6913 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
6919 _bfd_elf_rel_local_sym (abfd
, sym
, psec
, addend
)
6921 Elf_Internal_Sym
*sym
;
6925 asection
*sec
= *psec
;
6927 if (elf_section_data (sec
)->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
6928 return sym
->st_value
+ addend
;
6930 return _bfd_merged_section_offset (abfd
, psec
,
6931 elf_section_data (sec
)->sec_info
,
6932 sym
->st_value
+ addend
, (bfd_vma
) 0);
6936 _bfd_elf_section_offset (abfd
, info
, sec
, offset
)
6938 struct bfd_link_info
*info
;
6942 struct bfd_elf_section_data
*sec_data
;
6944 sec_data
= elf_section_data (sec
);
6945 switch (sec_data
->sec_info_type
)
6947 case ELF_INFO_TYPE_STABS
:
6948 return _bfd_stab_section_offset
6949 (abfd
, &elf_hash_table (info
)->merge_info
, sec
, &sec_data
->sec_info
,
6951 case ELF_INFO_TYPE_EH_FRAME
:
6952 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);