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
);
819 _bfd_elf_link_just_syms (sec
, info
)
821 struct bfd_link_info
*info
;
823 sec
->output_section
= bfd_abs_section_ptr
;
824 sec
->output_offset
= sec
->vma
;
825 if (!is_elf_hash_table (info
))
828 elf_section_data (sec
)->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
831 /* Copy the program header and other data from one object module to
835 _bfd_elf_copy_private_bfd_data (ibfd
, obfd
)
839 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
840 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
843 BFD_ASSERT (!elf_flags_init (obfd
)
844 || (elf_elfheader (obfd
)->e_flags
845 == elf_elfheader (ibfd
)->e_flags
));
847 elf_gp (obfd
) = elf_gp (ibfd
);
848 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
849 elf_flags_init (obfd
) = true;
853 /* Print out the program headers. */
856 _bfd_elf_print_private_bfd_data (abfd
, farg
)
860 FILE *f
= (FILE *) farg
;
861 Elf_Internal_Phdr
*p
;
863 bfd_byte
*dynbuf
= NULL
;
865 p
= elf_tdata (abfd
)->phdr
;
870 fprintf (f
, _("\nProgram Header:\n"));
871 c
= elf_elfheader (abfd
)->e_phnum
;
872 for (i
= 0; i
< c
; i
++, p
++)
879 case PT_NULL
: pt
= "NULL"; break;
880 case PT_LOAD
: pt
= "LOAD"; break;
881 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
882 case PT_INTERP
: pt
= "INTERP"; break;
883 case PT_NOTE
: pt
= "NOTE"; break;
884 case PT_SHLIB
: pt
= "SHLIB"; break;
885 case PT_PHDR
: pt
= "PHDR"; break;
886 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
887 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
889 fprintf (f
, "%8s off 0x", pt
);
890 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
891 fprintf (f
, " vaddr 0x");
892 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
893 fprintf (f
, " paddr 0x");
894 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
895 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
896 fprintf (f
, " filesz 0x");
897 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
898 fprintf (f
, " memsz 0x");
899 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
900 fprintf (f
, " flags %c%c%c",
901 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
902 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
903 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
904 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
905 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
910 s
= bfd_get_section_by_name (abfd
, ".dynamic");
914 unsigned long shlink
;
915 bfd_byte
*extdyn
, *extdynend
;
917 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
919 fprintf (f
, _("\nDynamic Section:\n"));
921 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
924 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
928 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
931 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
933 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
934 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
937 extdynend
= extdyn
+ s
->_raw_size
;
938 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
940 Elf_Internal_Dyn dyn
;
945 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
947 if (dyn
.d_tag
== DT_NULL
)
954 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
958 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
959 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
960 case DT_PLTGOT
: name
= "PLTGOT"; break;
961 case DT_HASH
: name
= "HASH"; break;
962 case DT_STRTAB
: name
= "STRTAB"; break;
963 case DT_SYMTAB
: name
= "SYMTAB"; break;
964 case DT_RELA
: name
= "RELA"; break;
965 case DT_RELASZ
: name
= "RELASZ"; break;
966 case DT_RELAENT
: name
= "RELAENT"; break;
967 case DT_STRSZ
: name
= "STRSZ"; break;
968 case DT_SYMENT
: name
= "SYMENT"; break;
969 case DT_INIT
: name
= "INIT"; break;
970 case DT_FINI
: name
= "FINI"; break;
971 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
972 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
973 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
974 case DT_REL
: name
= "REL"; break;
975 case DT_RELSZ
: name
= "RELSZ"; break;
976 case DT_RELENT
: name
= "RELENT"; break;
977 case DT_PLTREL
: name
= "PLTREL"; break;
978 case DT_DEBUG
: name
= "DEBUG"; break;
979 case DT_TEXTREL
: name
= "TEXTREL"; break;
980 case DT_JMPREL
: name
= "JMPREL"; break;
981 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
982 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
983 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
984 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
985 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
986 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= true; break;
987 case DT_FLAGS
: name
= "FLAGS"; break;
988 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
989 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
990 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
991 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
992 case DT_MOVEENT
: name
= "MOVEENT"; break;
993 case DT_MOVESZ
: name
= "MOVESZ"; break;
994 case DT_FEATURE
: name
= "FEATURE"; break;
995 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
996 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
997 case DT_SYMINENT
: name
= "SYMINENT"; break;
998 case DT_CONFIG
: name
= "CONFIG"; stringp
= true; break;
999 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= true; break;
1000 case DT_AUDIT
: name
= "AUDIT"; stringp
= true; break;
1001 case DT_PLTPAD
: name
= "PLTPAD"; break;
1002 case DT_MOVETAB
: name
= "MOVETAB"; break;
1003 case DT_SYMINFO
: name
= "SYMINFO"; break;
1004 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1005 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1006 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1007 case DT_VERSYM
: name
= "VERSYM"; break;
1008 case DT_VERDEF
: name
= "VERDEF"; break;
1009 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1010 case DT_VERNEED
: name
= "VERNEED"; break;
1011 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1012 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
1013 case DT_USED
: name
= "USED"; break;
1014 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
1017 fprintf (f
, " %-11s ", name
);
1019 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1023 unsigned int tagv
= dyn
.d_un
.d_val
;
1025 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1028 fprintf (f
, "%s", string
);
1037 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1038 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1040 if (! _bfd_elf_slurp_version_tables (abfd
))
1044 if (elf_dynverdef (abfd
) != 0)
1046 Elf_Internal_Verdef
*t
;
1048 fprintf (f
, _("\nVersion definitions:\n"));
1049 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1051 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1052 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1053 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1055 Elf_Internal_Verdaux
*a
;
1058 for (a
= t
->vd_auxptr
->vda_nextptr
;
1061 fprintf (f
, "%s ", a
->vda_nodename
);
1067 if (elf_dynverref (abfd
) != 0)
1069 Elf_Internal_Verneed
*t
;
1071 fprintf (f
, _("\nVersion References:\n"));
1072 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1074 Elf_Internal_Vernaux
*a
;
1076 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1077 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1078 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1079 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1091 /* Display ELF-specific fields of a symbol. */
1094 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
1098 bfd_print_symbol_type how
;
1100 FILE *file
= (FILE *) filep
;
1103 case bfd_print_symbol_name
:
1104 fprintf (file
, "%s", symbol
->name
);
1106 case bfd_print_symbol_more
:
1107 fprintf (file
, "elf ");
1108 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1109 fprintf (file
, " %lx", (long) symbol
->flags
);
1111 case bfd_print_symbol_all
:
1113 const char *section_name
;
1114 const char *name
= NULL
;
1115 struct elf_backend_data
*bed
;
1116 unsigned char st_other
;
1119 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1121 bed
= get_elf_backend_data (abfd
);
1122 if (bed
->elf_backend_print_symbol_all
)
1123 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1127 name
= symbol
->name
;
1128 bfd_print_symbol_vandf (abfd
, (PTR
) file
, symbol
);
1131 fprintf (file
, " %s\t", section_name
);
1132 /* Print the "other" value for a symbol. For common symbols,
1133 we've already printed the size; now print the alignment.
1134 For other symbols, we have no specified alignment, and
1135 we've printed the address; now print the size. */
1136 if (bfd_is_com_section (symbol
->section
))
1137 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1139 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1140 bfd_fprintf_vma (abfd
, file
, val
);
1142 /* If we have version information, print it. */
1143 if (elf_tdata (abfd
)->dynversym_section
!= 0
1144 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1145 || elf_tdata (abfd
)->dynverref_section
!= 0))
1147 unsigned int vernum
;
1148 const char *version_string
;
1150 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1153 version_string
= "";
1154 else if (vernum
== 1)
1155 version_string
= "Base";
1156 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1158 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1161 Elf_Internal_Verneed
*t
;
1163 version_string
= "";
1164 for (t
= elf_tdata (abfd
)->verref
;
1168 Elf_Internal_Vernaux
*a
;
1170 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1172 if (a
->vna_other
== vernum
)
1174 version_string
= a
->vna_nodename
;
1181 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1182 fprintf (file
, " %-11s", version_string
);
1187 fprintf (file
, " (%s)", version_string
);
1188 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1193 /* If the st_other field is not zero, print it. */
1194 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1199 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1200 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1201 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1203 /* Some other non-defined flags are also present, so print
1205 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1208 fprintf (file
, " %s", name
);
1214 /* Create an entry in an ELF linker hash table. */
1216 struct bfd_hash_entry
*
1217 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
1218 struct bfd_hash_entry
*entry
;
1219 struct bfd_hash_table
*table
;
1222 /* Allocate the structure if it has not already been allocated by a
1226 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1231 /* Call the allocation method of the superclass. */
1232 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1235 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1236 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1238 /* Set local fields. */
1242 ret
->dynstr_index
= 0;
1243 ret
->weakdef
= NULL
;
1244 ret
->got
.refcount
= htab
->init_refcount
;
1245 ret
->plt
.refcount
= htab
->init_refcount
;
1246 ret
->linker_section_pointer
= NULL
;
1247 ret
->verinfo
.verdef
= NULL
;
1248 ret
->vtable_entries_used
= NULL
;
1249 ret
->vtable_entries_size
= 0;
1250 ret
->vtable_parent
= NULL
;
1251 ret
->type
= STT_NOTYPE
;
1253 /* Assume that we have been called by a non-ELF symbol reader.
1254 This flag is then reset by the code which reads an ELF input
1255 file. This ensures that a symbol created by a non-ELF symbol
1256 reader will have the flag set correctly. */
1257 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
1263 /* Copy data from an indirect symbol to its direct symbol, hiding the
1264 old indirect symbol. Also used for copying flags to a weakdef. */
1267 _bfd_elf_link_hash_copy_indirect (dir
, ind
)
1268 struct elf_link_hash_entry
*dir
, *ind
;
1272 /* Copy down any references that we may have already seen to the
1273 symbol which just became indirect. */
1275 dir
->elf_link_hash_flags
|=
1276 (ind
->elf_link_hash_flags
1277 & (ELF_LINK_HASH_REF_DYNAMIC
1278 | ELF_LINK_HASH_REF_REGULAR
1279 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1280 | ELF_LINK_NON_GOT_REF
));
1282 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1285 /* Copy over the global and procedure linkage table refcount entries.
1286 These may have been already set up by a check_relocs routine. */
1287 tmp
= dir
->got
.refcount
;
1290 dir
->got
.refcount
= ind
->got
.refcount
;
1291 ind
->got
.refcount
= tmp
;
1294 BFD_ASSERT (ind
->got
.refcount
<= 0);
1296 tmp
= dir
->plt
.refcount
;
1299 dir
->plt
.refcount
= ind
->plt
.refcount
;
1300 ind
->plt
.refcount
= tmp
;
1303 BFD_ASSERT (ind
->plt
.refcount
<= 0);
1305 if (dir
->dynindx
== -1)
1307 dir
->dynindx
= ind
->dynindx
;
1308 dir
->dynstr_index
= ind
->dynstr_index
;
1310 ind
->dynstr_index
= 0;
1313 BFD_ASSERT (ind
->dynindx
== -1);
1317 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
)
1318 struct bfd_link_info
*info
;
1319 struct elf_link_hash_entry
*h
;
1320 boolean force_local
;
1322 h
->plt
.offset
= (bfd_vma
) -1;
1323 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1326 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
1327 if (h
->dynindx
!= -1)
1330 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1336 /* Initialize an ELF linker hash table. */
1339 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
1340 struct elf_link_hash_table
*table
;
1342 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
1343 struct bfd_hash_table
*,
1348 table
->dynamic_sections_created
= false;
1349 table
->dynobj
= NULL
;
1350 table
->init_refcount
= get_elf_backend_data (abfd
)->can_refcount
- 1;
1351 /* The first dynamic symbol is a dummy. */
1352 table
->dynsymcount
= 1;
1353 table
->dynstr
= NULL
;
1354 table
->bucketcount
= 0;
1355 table
->needed
= NULL
;
1356 table
->runpath
= NULL
;
1358 table
->stab_info
= NULL
;
1359 table
->merge_info
= NULL
;
1360 table
->dynlocal
= NULL
;
1361 ret
= _bfd_link_hash_table_init (& table
->root
, abfd
, newfunc
);
1362 table
->root
.type
= bfd_link_elf_hash_table
;
1367 /* Create an ELF linker hash table. */
1369 struct bfd_link_hash_table
*
1370 _bfd_elf_link_hash_table_create (abfd
)
1373 struct elf_link_hash_table
*ret
;
1374 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1376 ret
= (struct elf_link_hash_table
*) bfd_malloc (amt
);
1377 if (ret
== (struct elf_link_hash_table
*) NULL
)
1380 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1389 /* This is a hook for the ELF emulation code in the generic linker to
1390 tell the backend linker what file name to use for the DT_NEEDED
1391 entry for a dynamic object. The generic linker passes name as an
1392 empty string to indicate that no DT_NEEDED entry should be made. */
1395 bfd_elf_set_dt_needed_name (abfd
, name
)
1399 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1400 && bfd_get_format (abfd
) == bfd_object
)
1401 elf_dt_name (abfd
) = name
;
1405 bfd_elf_set_dt_needed_soname (abfd
, name
)
1409 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1410 && bfd_get_format (abfd
) == bfd_object
)
1411 elf_dt_soname (abfd
) = name
;
1414 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1415 the linker ELF emulation code. */
1417 struct bfd_link_needed_list
*
1418 bfd_elf_get_needed_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
)->needed
;
1427 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1428 hook for the linker ELF emulation code. */
1430 struct bfd_link_needed_list
*
1431 bfd_elf_get_runpath_list (abfd
, info
)
1432 bfd
*abfd ATTRIBUTE_UNUSED
;
1433 struct bfd_link_info
*info
;
1435 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1437 return elf_hash_table (info
)->runpath
;
1440 /* Get the name actually used for a dynamic object for a link. This
1441 is the SONAME entry if there is one. Otherwise, it is the string
1442 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1445 bfd_elf_get_dt_soname (abfd
)
1448 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1449 && bfd_get_format (abfd
) == bfd_object
)
1450 return elf_dt_name (abfd
);
1454 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1455 the ELF linker emulation code. */
1458 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
1460 struct bfd_link_needed_list
**pneeded
;
1463 bfd_byte
*dynbuf
= NULL
;
1465 unsigned long shlink
;
1466 bfd_byte
*extdyn
, *extdynend
;
1468 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1472 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1473 || bfd_get_format (abfd
) != bfd_object
)
1476 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1477 if (s
== NULL
|| s
->_raw_size
== 0)
1480 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1484 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1488 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1492 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1494 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1495 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1498 extdynend
= extdyn
+ s
->_raw_size
;
1499 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1501 Elf_Internal_Dyn dyn
;
1503 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1505 if (dyn
.d_tag
== DT_NULL
)
1508 if (dyn
.d_tag
== DT_NEEDED
)
1511 struct bfd_link_needed_list
*l
;
1512 unsigned int tagv
= dyn
.d_un
.d_val
;
1515 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1520 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1541 /* Allocate an ELF string table--force the first byte to be zero. */
1543 struct bfd_strtab_hash
*
1544 _bfd_elf_stringtab_init ()
1546 struct bfd_strtab_hash
*ret
;
1548 ret
= _bfd_stringtab_init ();
1553 loc
= _bfd_stringtab_add (ret
, "", true, false);
1554 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1555 if (loc
== (bfd_size_type
) -1)
1557 _bfd_stringtab_free (ret
);
1564 /* ELF .o/exec file reading */
1566 /* Create a new bfd section from an ELF section header. */
1569 bfd_section_from_shdr (abfd
, shindex
)
1571 unsigned int shindex
;
1573 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1574 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1575 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1578 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1580 switch (hdr
->sh_type
)
1583 /* Inactive section. Throw it away. */
1586 case SHT_PROGBITS
: /* Normal section with contents. */
1587 case SHT_DYNAMIC
: /* Dynamic linking information. */
1588 case SHT_NOBITS
: /* .bss section. */
1589 case SHT_HASH
: /* .hash section. */
1590 case SHT_NOTE
: /* .note section. */
1591 case SHT_INIT_ARRAY
: /* .init_array section. */
1592 case SHT_FINI_ARRAY
: /* .fini_array section. */
1593 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1594 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1596 case SHT_SYMTAB
: /* A symbol table */
1597 if (elf_onesymtab (abfd
) == shindex
)
1600 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1601 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1602 elf_onesymtab (abfd
) = shindex
;
1603 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1604 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1605 abfd
->flags
|= HAS_SYMS
;
1607 /* Sometimes a shared object will map in the symbol table. If
1608 SHF_ALLOC is set, and this is a shared object, then we also
1609 treat this section as a BFD section. We can not base the
1610 decision purely on SHF_ALLOC, because that flag is sometimes
1611 set in a relocateable object file, which would confuse the
1613 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1614 && (abfd
->flags
& DYNAMIC
) != 0
1615 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1620 case SHT_DYNSYM
: /* A dynamic symbol table */
1621 if (elf_dynsymtab (abfd
) == shindex
)
1624 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1625 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1626 elf_dynsymtab (abfd
) = shindex
;
1627 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1628 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1629 abfd
->flags
|= HAS_SYMS
;
1631 /* Besides being a symbol table, we also treat this as a regular
1632 section, so that objcopy can handle it. */
1633 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1635 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1636 if (elf_symtab_shndx (abfd
) == shindex
)
1639 /* Get the associated symbol table. */
1640 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
)
1641 || hdr
->sh_link
!= elf_onesymtab (abfd
))
1644 elf_symtab_shndx (abfd
) = shindex
;
1645 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1646 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1649 case SHT_STRTAB
: /* A string table */
1650 if (hdr
->bfd_section
!= NULL
)
1652 if (ehdr
->e_shstrndx
== shindex
)
1654 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1655 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1659 unsigned int i
, num_sec
;
1661 num_sec
= elf_numsections (abfd
);
1662 for (i
= 1; i
< num_sec
; i
++)
1664 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1665 if (hdr2
->sh_link
== shindex
)
1667 if (! bfd_section_from_shdr (abfd
, i
))
1669 if (elf_onesymtab (abfd
) == i
)
1671 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1672 elf_elfsections (abfd
)[shindex
] =
1673 &elf_tdata (abfd
)->strtab_hdr
;
1676 if (elf_dynsymtab (abfd
) == i
)
1678 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1679 elf_elfsections (abfd
)[shindex
] = hdr
=
1680 &elf_tdata (abfd
)->dynstrtab_hdr
;
1681 /* We also treat this as a regular section, so
1682 that objcopy can handle it. */
1685 #if 0 /* Not handling other string tables specially right now. */
1686 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1687 /* We have a strtab for some random other section. */
1688 newsect
= (asection
*) hdr2
->bfd_section
;
1691 hdr
->bfd_section
= newsect
;
1692 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1694 elf_elfsections (abfd
)[shindex
] = hdr2
;
1700 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1704 /* *These* do a lot of work -- but build no sections! */
1706 asection
*target_sect
;
1707 Elf_Internal_Shdr
*hdr2
;
1708 unsigned int num_sec
= elf_numsections (abfd
);
1710 /* Check for a bogus link to avoid crashing. */
1711 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1712 || hdr
->sh_link
>= num_sec
)
1714 ((*_bfd_error_handler
)
1715 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1716 bfd_archive_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1717 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1720 /* For some incomprehensible reason Oracle distributes
1721 libraries for Solaris in which some of the objects have
1722 bogus sh_link fields. It would be nice if we could just
1723 reject them, but, unfortunately, some people need to use
1724 them. We scan through the section headers; if we find only
1725 one suitable symbol table, we clobber the sh_link to point
1726 to it. I hope this doesn't break anything. */
1727 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1728 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1734 for (scan
= 1; scan
< num_sec
; scan
++)
1736 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1737 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1748 hdr
->sh_link
= found
;
1751 /* Get the symbol table. */
1752 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1753 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1756 /* If this reloc section does not use the main symbol table we
1757 don't treat it as a reloc section. BFD can't adequately
1758 represent such a section, so at least for now, we don't
1759 try. We just present it as a normal section. We also
1760 can't use it as a reloc section if it points to the null
1762 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1763 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1765 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1767 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1768 if (target_sect
== NULL
)
1771 if ((target_sect
->flags
& SEC_RELOC
) == 0
1772 || target_sect
->reloc_count
== 0)
1773 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1777 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1778 amt
= sizeof (*hdr2
);
1779 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
1780 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1783 elf_elfsections (abfd
)[shindex
] = hdr2
;
1784 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1785 target_sect
->flags
|= SEC_RELOC
;
1786 target_sect
->relocation
= NULL
;
1787 target_sect
->rel_filepos
= hdr
->sh_offset
;
1788 /* In the section to which the relocations apply, mark whether
1789 its relocations are of the REL or RELA variety. */
1790 if (hdr
->sh_size
!= 0)
1791 elf_section_data (target_sect
)->use_rela_p
1792 = (hdr
->sh_type
== SHT_RELA
);
1793 abfd
->flags
|= HAS_RELOC
;
1798 case SHT_GNU_verdef
:
1799 elf_dynverdef (abfd
) = shindex
;
1800 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1801 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1804 case SHT_GNU_versym
:
1805 elf_dynversym (abfd
) = shindex
;
1806 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1807 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1810 case SHT_GNU_verneed
:
1811 elf_dynverref (abfd
) = shindex
;
1812 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1813 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1820 /* Make a section for objcopy and relocatable links. */
1821 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1823 if (hdr
->contents
!= NULL
)
1825 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1826 unsigned int n_elt
= hdr
->sh_size
/ 4;
1829 while (--n_elt
!= 0)
1830 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
1831 && elf_next_in_group (s
) != NULL
)
1833 elf_next_in_group (hdr
->bfd_section
) = s
;
1840 /* Check for any processor-specific section types. */
1842 if (bed
->elf_backend_section_from_shdr
)
1843 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1851 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1852 Return SEC for sections that have no elf section, and NULL on error. */
1855 bfd_section_from_r_symndx (abfd
, cache
, sec
, r_symndx
)
1857 struct sym_sec_cache
*cache
;
1859 unsigned long r_symndx
;
1861 unsigned char esym_shndx
[4];
1862 unsigned int isym_shndx
;
1863 Elf_Internal_Shdr
*symtab_hdr
;
1866 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1868 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
1869 return cache
->sec
[ent
];
1871 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1872 pos
= symtab_hdr
->sh_offset
;
1873 if (get_elf_backend_data (abfd
)->s
->sizeof_sym
1874 == sizeof (Elf64_External_Sym
))
1876 pos
+= r_symndx
* sizeof (Elf64_External_Sym
);
1877 pos
+= offsetof (Elf64_External_Sym
, st_shndx
);
1878 amt
= sizeof (((Elf64_External_Sym
*) 0)->st_shndx
);
1882 pos
+= r_symndx
* sizeof (Elf32_External_Sym
);
1883 pos
+= offsetof (Elf32_External_Sym
, st_shndx
);
1884 amt
= sizeof (((Elf32_External_Sym
*) 0)->st_shndx
);
1886 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1887 || bfd_bread ((PTR
) esym_shndx
, amt
, abfd
) != amt
)
1889 isym_shndx
= H_GET_16 (abfd
, esym_shndx
);
1891 if (isym_shndx
== SHN_XINDEX
)
1893 Elf_Internal_Shdr
*shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1894 if (shndx_hdr
->sh_size
!= 0)
1896 pos
= shndx_hdr
->sh_offset
;
1897 pos
+= r_symndx
* sizeof (Elf_External_Sym_Shndx
);
1898 amt
= sizeof (Elf_External_Sym_Shndx
);
1899 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1900 || bfd_bread ((PTR
) esym_shndx
, amt
, abfd
) != amt
)
1902 isym_shndx
= H_GET_32 (abfd
, esym_shndx
);
1906 if (cache
->abfd
!= abfd
)
1908 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1911 cache
->indx
[ent
] = r_symndx
;
1912 cache
->sec
[ent
] = sec
;
1913 if (isym_shndx
< SHN_LORESERVE
|| isym_shndx
> SHN_HIRESERVE
)
1916 s
= bfd_section_from_elf_index (abfd
, isym_shndx
);
1918 cache
->sec
[ent
] = s
;
1920 return cache
->sec
[ent
];
1923 /* Given an ELF section number, retrieve the corresponding BFD
1927 bfd_section_from_elf_index (abfd
, index
)
1931 if (index
>= elf_numsections (abfd
))
1933 return elf_elfsections (abfd
)[index
]->bfd_section
;
1937 _bfd_elf_new_section_hook (abfd
, sec
)
1941 struct bfd_elf_section_data
*sdata
;
1942 bfd_size_type amt
= sizeof (*sdata
);
1944 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, amt
);
1947 sec
->used_by_bfd
= (PTR
) sdata
;
1949 /* Indicate whether or not this section should use RELA relocations. */
1951 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1956 /* Create a new bfd section from an ELF program header.
1958 Since program segments have no names, we generate a synthetic name
1959 of the form segment<NUM>, where NUM is generally the index in the
1960 program header table. For segments that are split (see below) we
1961 generate the names segment<NUM>a and segment<NUM>b.
1963 Note that some program segments may have a file size that is different than
1964 (less than) the memory size. All this means is that at execution the
1965 system must allocate the amount of memory specified by the memory size,
1966 but only initialize it with the first "file size" bytes read from the
1967 file. This would occur for example, with program segments consisting
1968 of combined data+bss.
1970 To handle the above situation, this routine generates TWO bfd sections
1971 for the single program segment. The first has the length specified by
1972 the file size of the segment, and the second has the length specified
1973 by the difference between the two sizes. In effect, the segment is split
1974 into it's initialized and uninitialized parts.
1979 _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
)
1981 Elf_Internal_Phdr
*hdr
;
1983 const char *typename
;
1990 split
= ((hdr
->p_memsz
> 0)
1991 && (hdr
->p_filesz
> 0)
1992 && (hdr
->p_memsz
> hdr
->p_filesz
));
1993 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
1994 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
1997 strcpy (name
, namebuf
);
1998 newsect
= bfd_make_section (abfd
, name
);
1999 if (newsect
== NULL
)
2001 newsect
->vma
= hdr
->p_vaddr
;
2002 newsect
->lma
= hdr
->p_paddr
;
2003 newsect
->_raw_size
= hdr
->p_filesz
;
2004 newsect
->filepos
= hdr
->p_offset
;
2005 newsect
->flags
|= SEC_HAS_CONTENTS
;
2006 if (hdr
->p_type
== PT_LOAD
)
2008 newsect
->flags
|= SEC_ALLOC
;
2009 newsect
->flags
|= SEC_LOAD
;
2010 if (hdr
->p_flags
& PF_X
)
2012 /* FIXME: all we known is that it has execute PERMISSION,
2014 newsect
->flags
|= SEC_CODE
;
2017 if (!(hdr
->p_flags
& PF_W
))
2019 newsect
->flags
|= SEC_READONLY
;
2024 sprintf (namebuf
, "%s%db", typename
, index
);
2025 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
2028 strcpy (name
, namebuf
);
2029 newsect
= bfd_make_section (abfd
, name
);
2030 if (newsect
== NULL
)
2032 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2033 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2034 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
2035 if (hdr
->p_type
== PT_LOAD
)
2037 newsect
->flags
|= SEC_ALLOC
;
2038 if (hdr
->p_flags
& PF_X
)
2039 newsect
->flags
|= SEC_CODE
;
2041 if (!(hdr
->p_flags
& PF_W
))
2042 newsect
->flags
|= SEC_READONLY
;
2049 bfd_section_from_phdr (abfd
, hdr
, index
)
2051 Elf_Internal_Phdr
*hdr
;
2054 struct elf_backend_data
*bed
;
2056 switch (hdr
->p_type
)
2059 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2062 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2065 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2068 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2071 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2073 if (! elfcore_read_notes (abfd
, (file_ptr
) hdr
->p_offset
, hdr
->p_filesz
))
2078 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2081 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2084 /* Check for any processor-specific program segment types.
2085 If no handler for them, default to making "segment" sections. */
2086 bed
= get_elf_backend_data (abfd
);
2087 if (bed
->elf_backend_section_from_phdr
)
2088 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
2090 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
2094 /* Initialize REL_HDR, the section-header for new section, containing
2095 relocations against ASECT. If USE_RELA_P is true, we use RELA
2096 relocations; otherwise, we use REL relocations. */
2099 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
2101 Elf_Internal_Shdr
*rel_hdr
;
2106 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2107 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2109 name
= bfd_alloc (abfd
, amt
);
2112 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2114 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2116 if (rel_hdr
->sh_name
== (unsigned int) -1)
2118 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2119 rel_hdr
->sh_entsize
= (use_rela_p
2120 ? bed
->s
->sizeof_rela
2121 : bed
->s
->sizeof_rel
);
2122 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
2123 rel_hdr
->sh_flags
= 0;
2124 rel_hdr
->sh_addr
= 0;
2125 rel_hdr
->sh_size
= 0;
2126 rel_hdr
->sh_offset
= 0;
2131 /* Set up an ELF internal section header for a section. */
2134 elf_fake_sections (abfd
, asect
, failedptrarg
)
2139 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2140 boolean
*failedptr
= (boolean
*) failedptrarg
;
2141 Elf_Internal_Shdr
*this_hdr
;
2145 /* We already failed; just get out of the bfd_map_over_sections
2150 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2152 this_hdr
->sh_name
= (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2153 asect
->name
, false);
2154 if (this_hdr
->sh_name
== (unsigned long) -1)
2160 this_hdr
->sh_flags
= 0;
2162 if ((asect
->flags
& SEC_ALLOC
) != 0
2163 || asect
->user_set_vma
)
2164 this_hdr
->sh_addr
= asect
->vma
;
2166 this_hdr
->sh_addr
= 0;
2168 this_hdr
->sh_offset
= 0;
2169 this_hdr
->sh_size
= asect
->_raw_size
;
2170 this_hdr
->sh_link
= 0;
2171 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2172 /* The sh_entsize and sh_info fields may have been set already by
2173 copy_private_section_data. */
2175 this_hdr
->bfd_section
= asect
;
2176 this_hdr
->contents
= NULL
;
2178 /* FIXME: This should not be based on section names. */
2179 if (strcmp (asect
->name
, ".dynstr") == 0)
2180 this_hdr
->sh_type
= SHT_STRTAB
;
2181 else if (strcmp (asect
->name
, ".hash") == 0)
2183 this_hdr
->sh_type
= SHT_HASH
;
2184 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2186 else if (strcmp (asect
->name
, ".dynsym") == 0)
2188 this_hdr
->sh_type
= SHT_DYNSYM
;
2189 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2191 else if (strcmp (asect
->name
, ".dynamic") == 0)
2193 this_hdr
->sh_type
= SHT_DYNAMIC
;
2194 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2196 else if (strncmp (asect
->name
, ".rela", 5) == 0
2197 && get_elf_backend_data (abfd
)->may_use_rela_p
)
2199 this_hdr
->sh_type
= SHT_RELA
;
2200 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2202 else if (strncmp (asect
->name
, ".rel", 4) == 0
2203 && get_elf_backend_data (abfd
)->may_use_rel_p
)
2205 this_hdr
->sh_type
= SHT_REL
;
2206 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2208 else if (strcmp (asect
->name
, ".init_array") == 0)
2209 this_hdr
->sh_type
= SHT_INIT_ARRAY
;
2210 else if (strcmp (asect
->name
, ".fini_array") == 0)
2211 this_hdr
->sh_type
= SHT_FINI_ARRAY
;
2212 else if (strcmp (asect
->name
, ".preinit_array") == 0)
2213 this_hdr
->sh_type
= SHT_PREINIT_ARRAY
;
2214 else if (strncmp (asect
->name
, ".note", 5) == 0)
2215 this_hdr
->sh_type
= SHT_NOTE
;
2216 else if (strncmp (asect
->name
, ".stab", 5) == 0
2217 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
2218 this_hdr
->sh_type
= SHT_STRTAB
;
2219 else if (strcmp (asect
->name
, ".gnu.version") == 0)
2221 this_hdr
->sh_type
= SHT_GNU_versym
;
2222 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2224 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
2226 this_hdr
->sh_type
= SHT_GNU_verdef
;
2227 this_hdr
->sh_entsize
= 0;
2228 /* objcopy or strip will copy over sh_info, but may not set
2229 cverdefs. The linker will set cverdefs, but sh_info will be
2231 if (this_hdr
->sh_info
== 0)
2232 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2234 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2235 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2237 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
2239 this_hdr
->sh_type
= SHT_GNU_verneed
;
2240 this_hdr
->sh_entsize
= 0;
2241 /* objcopy or strip will copy over sh_info, but may not set
2242 cverrefs. The linker will set cverrefs, but sh_info will be
2244 if (this_hdr
->sh_info
== 0)
2245 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2247 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2248 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2250 else if ((asect
->flags
& SEC_GROUP
) != 0)
2252 this_hdr
->sh_type
= SHT_GROUP
;
2253 this_hdr
->sh_entsize
= 4;
2255 else if ((asect
->flags
& SEC_ALLOC
) != 0
2256 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2257 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2258 this_hdr
->sh_type
= SHT_NOBITS
;
2260 this_hdr
->sh_type
= SHT_PROGBITS
;
2262 if ((asect
->flags
& SEC_ALLOC
) != 0)
2263 this_hdr
->sh_flags
|= SHF_ALLOC
;
2264 if ((asect
->flags
& SEC_READONLY
) == 0)
2265 this_hdr
->sh_flags
|= SHF_WRITE
;
2266 if ((asect
->flags
& SEC_CODE
) != 0)
2267 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2268 if ((asect
->flags
& SEC_MERGE
) != 0)
2270 this_hdr
->sh_flags
|= SHF_MERGE
;
2271 this_hdr
->sh_entsize
= asect
->entsize
;
2272 if ((asect
->flags
& SEC_STRINGS
) != 0)
2273 this_hdr
->sh_flags
|= SHF_STRINGS
;
2275 if (elf_group_name (asect
) != NULL
)
2276 this_hdr
->sh_flags
|= SHF_GROUP
;
2278 /* Check for processor-specific section types. */
2279 if (bed
->elf_backend_fake_sections
2280 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2283 /* If the section has relocs, set up a section header for the
2284 SHT_REL[A] section. If two relocation sections are required for
2285 this section, it is up to the processor-specific back-end to
2286 create the other. */
2287 if ((asect
->flags
& SEC_RELOC
) != 0
2288 && !_bfd_elf_init_reloc_shdr (abfd
,
2289 &elf_section_data (asect
)->rel_hdr
,
2291 elf_section_data (asect
)->use_rela_p
))
2295 /* Fill in the contents of a SHT_GROUP section. */
2298 set_group_contents (abfd
, sec
, failedptrarg
)
2301 PTR failedptrarg ATTRIBUTE_UNUSED
;
2303 boolean
*failedptr
= (boolean
*) failedptrarg
;
2304 unsigned long symindx
;
2307 struct bfd_link_order
*l
;
2309 if (elf_section_data (sec
)->this_hdr
.sh_type
!= SHT_GROUP
2313 /* If called from the assembler, swap_out_syms will have set up
2314 elf_section_syms; If called for "ld -r", the symbols won't yet
2315 be mapped, so emulate elf_bfd_final_link. */
2316 if (elf_section_syms (abfd
) != NULL
)
2317 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2319 symindx
= elf_section_data (sec
)->this_idx
;
2320 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2322 /* Nor will the contents be allocated for "ld -r". */
2323 if (sec
->contents
== NULL
)
2325 sec
->contents
= bfd_alloc (abfd
, sec
->_raw_size
);
2326 if (sec
->contents
== NULL
)
2333 loc
= sec
->contents
+ sec
->_raw_size
;
2335 /* Get the pointer to the first section in the group that we
2336 squirreled away here. */
2337 elt
= elf_next_in_group (sec
);
2339 /* First element is a flag word. Rest of section is elf section
2340 indices for all the sections of the group. Write them backwards
2341 just to keep the group in the same order as given in .section
2342 directives, not that it matters. */
2346 H_PUT_32 (abfd
, elf_section_data (elt
)->this_idx
, loc
);
2347 elt
= elf_next_in_group (elt
);
2350 /* If this is a relocatable link, then the above did nothing because
2351 SEC is the output section. Look through the input sections
2353 for (l
= sec
->link_order_head
; l
!= NULL
; l
= l
->next
)
2354 if (l
->type
== bfd_indirect_link_order
2355 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2360 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2361 elt
= elf_next_in_group (elt
);
2362 /* During a relocatable link, the lists are circular. */
2364 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2367 H_PUT_32 (abfd
, 0, loc
);
2369 BFD_ASSERT (loc
== sec
->contents
);
2372 /* Assign all ELF section numbers. The dummy first section is handled here
2373 too. The link/info pointers for the standard section types are filled
2374 in here too, while we're at it. */
2377 assign_section_numbers (abfd
)
2380 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2382 unsigned int section_number
, secn
;
2383 Elf_Internal_Shdr
**i_shdrp
;
2388 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2390 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2392 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2394 if (section_number
== SHN_LORESERVE
)
2395 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2396 d
->this_idx
= section_number
++;
2397 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2398 if ((sec
->flags
& SEC_RELOC
) == 0)
2402 if (section_number
== SHN_LORESERVE
)
2403 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2404 d
->rel_idx
= section_number
++;
2405 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2410 if (section_number
== SHN_LORESERVE
)
2411 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2412 d
->rel_idx2
= section_number
++;
2413 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2419 if (section_number
== SHN_LORESERVE
)
2420 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2421 t
->shstrtab_section
= section_number
++;
2422 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2423 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2425 if (bfd_get_symcount (abfd
) > 0)
2427 if (section_number
== SHN_LORESERVE
)
2428 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2429 t
->symtab_section
= section_number
++;
2430 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2431 if (section_number
> SHN_LORESERVE
- 2)
2433 if (section_number
== SHN_LORESERVE
)
2434 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2435 t
->symtab_shndx_section
= section_number
++;
2436 t
->symtab_shndx_hdr
.sh_name
2437 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2438 ".symtab_shndx", false);
2439 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2442 if (section_number
== SHN_LORESERVE
)
2443 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2444 t
->strtab_section
= section_number
++;
2445 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2448 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2449 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2451 elf_numsections (abfd
) = section_number
;
2452 elf_elfheader (abfd
)->e_shnum
= section_number
;
2453 if (section_number
> SHN_LORESERVE
)
2454 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2456 /* Set up the list of section header pointers, in agreement with the
2458 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2459 i_shdrp
= (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
2460 if (i_shdrp
== NULL
)
2463 amt
= sizeof (Elf_Internal_Shdr
);
2464 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
2465 if (i_shdrp
[0] == NULL
)
2467 bfd_release (abfd
, i_shdrp
);
2470 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
2472 elf_elfsections (abfd
) = i_shdrp
;
2474 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2475 if (bfd_get_symcount (abfd
) > 0)
2477 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2478 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2480 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2481 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2483 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2484 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2486 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2488 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2492 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2493 if (d
->rel_idx
!= 0)
2494 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2495 if (d
->rel_idx2
!= 0)
2496 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2498 /* Fill in the sh_link and sh_info fields while we're at it. */
2500 /* sh_link of a reloc section is the section index of the symbol
2501 table. sh_info is the section index of the section to which
2502 the relocation entries apply. */
2503 if (d
->rel_idx
!= 0)
2505 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2506 d
->rel_hdr
.sh_info
= d
->this_idx
;
2508 if (d
->rel_idx2
!= 0)
2510 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2511 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2514 switch (d
->this_hdr
.sh_type
)
2518 /* A reloc section which we are treating as a normal BFD
2519 section. sh_link is the section index of the symbol
2520 table. sh_info is the section index of the section to
2521 which the relocation entries apply. We assume that an
2522 allocated reloc section uses the dynamic symbol table.
2523 FIXME: How can we be sure? */
2524 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2526 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2528 /* We look up the section the relocs apply to by name. */
2530 if (d
->this_hdr
.sh_type
== SHT_REL
)
2534 s
= bfd_get_section_by_name (abfd
, name
);
2536 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2540 /* We assume that a section named .stab*str is a stabs
2541 string section. We look for a section with the same name
2542 but without the trailing ``str'', and set its sh_link
2543 field to point to this section. */
2544 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
2545 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2550 len
= strlen (sec
->name
);
2551 alc
= (char *) bfd_malloc ((bfd_size_type
) len
- 2);
2554 strncpy (alc
, sec
->name
, len
- 3);
2555 alc
[len
- 3] = '\0';
2556 s
= bfd_get_section_by_name (abfd
, alc
);
2560 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2562 /* This is a .stab section. */
2563 elf_section_data (s
)->this_hdr
.sh_entsize
=
2564 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2571 case SHT_GNU_verneed
:
2572 case SHT_GNU_verdef
:
2573 /* sh_link is the section header index of the string table
2574 used for the dynamic entries, or the symbol table, or the
2576 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2578 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2582 case SHT_GNU_versym
:
2583 /* sh_link is the section header index of the symbol table
2584 this hash table or version table is for. */
2585 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2587 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2591 d
->this_hdr
.sh_link
= t
->symtab_section
;
2595 for (secn
= 1; secn
< section_number
; ++secn
)
2596 if (i_shdrp
[secn
] == NULL
)
2597 i_shdrp
[secn
] = i_shdrp
[0];
2599 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
2600 i_shdrp
[secn
]->sh_name
);
2604 /* Map symbol from it's internal number to the external number, moving
2605 all local symbols to be at the head of the list. */
2608 sym_is_global (abfd
, sym
)
2612 /* If the backend has a special mapping, use it. */
2613 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2614 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2617 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2618 || bfd_is_und_section (bfd_get_section (sym
))
2619 || bfd_is_com_section (bfd_get_section (sym
)));
2623 elf_map_symbols (abfd
)
2626 unsigned int symcount
= bfd_get_symcount (abfd
);
2627 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2628 asymbol
**sect_syms
;
2629 unsigned int num_locals
= 0;
2630 unsigned int num_globals
= 0;
2631 unsigned int num_locals2
= 0;
2632 unsigned int num_globals2
= 0;
2640 fprintf (stderr
, "elf_map_symbols\n");
2644 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2646 if (max_index
< asect
->index
)
2647 max_index
= asect
->index
;
2651 amt
= max_index
* sizeof (asymbol
*);
2652 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
2653 if (sect_syms
== NULL
)
2655 elf_section_syms (abfd
) = sect_syms
;
2656 elf_num_section_syms (abfd
) = max_index
;
2658 /* Init sect_syms entries for any section symbols we have already
2659 decided to output. */
2660 for (idx
= 0; idx
< symcount
; idx
++)
2662 asymbol
*sym
= syms
[idx
];
2664 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2671 if (sec
->owner
!= NULL
)
2673 if (sec
->owner
!= abfd
)
2675 if (sec
->output_offset
!= 0)
2678 sec
= sec
->output_section
;
2680 /* Empty sections in the input files may have had a
2681 section symbol created for them. (See the comment
2682 near the end of _bfd_generic_link_output_symbols in
2683 linker.c). If the linker script discards such
2684 sections then we will reach this point. Since we know
2685 that we cannot avoid this case, we detect it and skip
2686 the abort and the assignment to the sect_syms array.
2687 To reproduce this particular case try running the
2688 linker testsuite test ld-scripts/weak.exp for an ELF
2689 port that uses the generic linker. */
2690 if (sec
->owner
== NULL
)
2693 BFD_ASSERT (sec
->owner
== abfd
);
2695 sect_syms
[sec
->index
] = syms
[idx
];
2700 /* Classify all of the symbols. */
2701 for (idx
= 0; idx
< symcount
; idx
++)
2703 if (!sym_is_global (abfd
, syms
[idx
]))
2709 /* We will be adding a section symbol for each BFD section. Most normal
2710 sections will already have a section symbol in outsymbols, but
2711 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2712 at least in that case. */
2713 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2715 if (sect_syms
[asect
->index
] == NULL
)
2717 if (!sym_is_global (abfd
, asect
->symbol
))
2724 /* Now sort the symbols so the local symbols are first. */
2725 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
2726 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
2728 if (new_syms
== NULL
)
2731 for (idx
= 0; idx
< symcount
; idx
++)
2733 asymbol
*sym
= syms
[idx
];
2736 if (!sym_is_global (abfd
, sym
))
2739 i
= num_locals
+ num_globals2
++;
2741 sym
->udata
.i
= i
+ 1;
2743 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2745 if (sect_syms
[asect
->index
] == NULL
)
2747 asymbol
*sym
= asect
->symbol
;
2750 sect_syms
[asect
->index
] = sym
;
2751 if (!sym_is_global (abfd
, sym
))
2754 i
= num_locals
+ num_globals2
++;
2756 sym
->udata
.i
= i
+ 1;
2760 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
2762 elf_num_locals (abfd
) = num_locals
;
2763 elf_num_globals (abfd
) = num_globals
;
2767 /* Align to the maximum file alignment that could be required for any
2768 ELF data structure. */
2770 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
2771 static INLINE file_ptr
2772 align_file_position (off
, align
)
2776 return (off
+ align
- 1) & ~(align
- 1);
2779 /* Assign a file position to a section, optionally aligning to the
2780 required section alignment. */
2783 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
2784 Elf_Internal_Shdr
*i_shdrp
;
2792 al
= i_shdrp
->sh_addralign
;
2794 offset
= BFD_ALIGN (offset
, al
);
2796 i_shdrp
->sh_offset
= offset
;
2797 if (i_shdrp
->bfd_section
!= NULL
)
2798 i_shdrp
->bfd_section
->filepos
= offset
;
2799 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2800 offset
+= i_shdrp
->sh_size
;
2804 /* Compute the file positions we are going to put the sections at, and
2805 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2806 is not NULL, this is being called by the ELF backend linker. */
2809 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2811 struct bfd_link_info
*link_info
;
2813 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2815 struct bfd_strtab_hash
*strtab
;
2816 Elf_Internal_Shdr
*shstrtab_hdr
;
2818 if (abfd
->output_has_begun
)
2821 /* Do any elf backend specific processing first. */
2822 if (bed
->elf_backend_begin_write_processing
)
2823 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2825 if (! prep_headers (abfd
))
2828 /* Post process the headers if necessary. */
2829 if (bed
->elf_backend_post_process_headers
)
2830 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2833 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2837 if (!assign_section_numbers (abfd
))
2840 /* The backend linker builds symbol table information itself. */
2841 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2843 /* Non-zero if doing a relocatable link. */
2844 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2846 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2850 if (link_info
== NULL
|| link_info
->relocateable
)
2852 bfd_map_over_sections (abfd
, set_group_contents
, &failed
);
2857 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2858 /* sh_name was set in prep_headers. */
2859 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2860 shstrtab_hdr
->sh_flags
= 0;
2861 shstrtab_hdr
->sh_addr
= 0;
2862 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2863 shstrtab_hdr
->sh_entsize
= 0;
2864 shstrtab_hdr
->sh_link
= 0;
2865 shstrtab_hdr
->sh_info
= 0;
2866 /* sh_offset is set in assign_file_positions_except_relocs. */
2867 shstrtab_hdr
->sh_addralign
= 1;
2869 if (!assign_file_positions_except_relocs (abfd
))
2872 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2875 Elf_Internal_Shdr
*hdr
;
2877 off
= elf_tdata (abfd
)->next_file_pos
;
2879 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2880 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2882 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2883 if (hdr
->sh_size
!= 0)
2884 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2886 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2887 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2889 elf_tdata (abfd
)->next_file_pos
= off
;
2891 /* Now that we know where the .strtab section goes, write it
2893 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2894 || ! _bfd_stringtab_emit (abfd
, strtab
))
2896 _bfd_stringtab_free (strtab
);
2899 abfd
->output_has_begun
= true;
2904 /* Create a mapping from a set of sections to a program segment. */
2906 static INLINE
struct elf_segment_map
*
2907 make_mapping (abfd
, sections
, from
, to
, phdr
)
2909 asection
**sections
;
2914 struct elf_segment_map
*m
;
2919 amt
= sizeof (struct elf_segment_map
);
2920 amt
+= (to
- from
- 1) * sizeof (asection
*);
2921 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2925 m
->p_type
= PT_LOAD
;
2926 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2927 m
->sections
[i
- from
] = *hdrpp
;
2928 m
->count
= to
- from
;
2930 if (from
== 0 && phdr
)
2932 /* Include the headers in the first PT_LOAD segment. */
2933 m
->includes_filehdr
= 1;
2934 m
->includes_phdrs
= 1;
2940 /* Set up a mapping from BFD sections to program segments. */
2943 map_sections_to_segments (abfd
)
2946 asection
**sections
= NULL
;
2950 struct elf_segment_map
*mfirst
;
2951 struct elf_segment_map
**pm
;
2952 struct elf_segment_map
*m
;
2954 unsigned int phdr_index
;
2955 bfd_vma maxpagesize
;
2957 boolean phdr_in_segment
= true;
2959 asection
*dynsec
, *eh_frame_hdr
;
2962 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2965 if (bfd_count_sections (abfd
) == 0)
2968 /* Select the allocated sections, and sort them. */
2970 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
2971 sections
= (asection
**) bfd_malloc (amt
);
2972 if (sections
== NULL
)
2976 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2978 if ((s
->flags
& SEC_ALLOC
) != 0)
2984 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2987 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2989 /* Build the mapping. */
2994 /* If we have a .interp section, then create a PT_PHDR segment for
2995 the program headers and a PT_INTERP segment for the .interp
2997 s
= bfd_get_section_by_name (abfd
, ".interp");
2998 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3000 amt
= sizeof (struct elf_segment_map
);
3001 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3005 m
->p_type
= PT_PHDR
;
3006 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3007 m
->p_flags
= PF_R
| PF_X
;
3008 m
->p_flags_valid
= 1;
3009 m
->includes_phdrs
= 1;
3014 amt
= sizeof (struct elf_segment_map
);
3015 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3019 m
->p_type
= PT_INTERP
;
3027 /* Look through the sections. We put sections in the same program
3028 segment when the start of the second section can be placed within
3029 a few bytes of the end of the first section. */
3032 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3034 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3036 && (dynsec
->flags
& SEC_LOAD
) == 0)
3039 /* Deal with -Ttext or something similar such that the first section
3040 is not adjacent to the program headers. This is an
3041 approximation, since at this point we don't know exactly how many
3042 program headers we will need. */
3045 bfd_size_type phdr_size
;
3047 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3049 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3050 if ((abfd
->flags
& D_PAGED
) == 0
3051 || sections
[0]->lma
< phdr_size
3052 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3053 phdr_in_segment
= false;
3056 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3059 boolean new_segment
;
3063 /* See if this section and the last one will fit in the same
3066 if (last_hdr
== NULL
)
3068 /* If we don't have a segment yet, then we don't need a new
3069 one (we build the last one after this loop). */
3070 new_segment
= false;
3072 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3074 /* If this section has a different relation between the
3075 virtual address and the load address, then we need a new
3079 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3080 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3082 /* If putting this section in this segment would force us to
3083 skip a page in the segment, then we need a new segment. */
3086 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
3087 && (hdr
->flags
& SEC_LOAD
) != 0)
3089 /* We don't want to put a loadable section after a
3090 nonloadable section in the same segment. */
3093 else if ((abfd
->flags
& D_PAGED
) == 0)
3095 /* If the file is not demand paged, which means that we
3096 don't require the sections to be correctly aligned in the
3097 file, then there is no other reason for a new segment. */
3098 new_segment
= false;
3101 && (hdr
->flags
& SEC_READONLY
) == 0
3102 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3105 /* We don't want to put a writable section in a read only
3106 segment, unless they are on the same page in memory
3107 anyhow. We already know that the last section does not
3108 bring us past the current section on the page, so the
3109 only case in which the new section is not on the same
3110 page as the previous section is when the previous section
3111 ends precisely on a page boundary. */
3116 /* Otherwise, we can use the same segment. */
3117 new_segment
= false;
3122 if ((hdr
->flags
& SEC_READONLY
) == 0)
3128 /* We need a new program segment. We must create a new program
3129 header holding all the sections from phdr_index until hdr. */
3131 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3138 if ((hdr
->flags
& SEC_READONLY
) == 0)
3145 phdr_in_segment
= false;
3148 /* Create a final PT_LOAD program segment. */
3149 if (last_hdr
!= NULL
)
3151 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3159 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3162 amt
= sizeof (struct elf_segment_map
);
3163 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3167 m
->p_type
= PT_DYNAMIC
;
3169 m
->sections
[0] = dynsec
;
3175 /* For each loadable .note section, add a PT_NOTE segment. We don't
3176 use bfd_get_section_by_name, because if we link together
3177 nonloadable .note sections and loadable .note sections, we will
3178 generate two .note sections in the output file. FIXME: Using
3179 names for section types is bogus anyhow. */
3180 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3182 if ((s
->flags
& SEC_LOAD
) != 0
3183 && strncmp (s
->name
, ".note", 5) == 0)
3185 amt
= sizeof (struct elf_segment_map
);
3186 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3190 m
->p_type
= PT_NOTE
;
3199 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3201 eh_frame_hdr
= NULL
;
3202 if (elf_tdata (abfd
)->eh_frame_hdr
)
3203 eh_frame_hdr
= bfd_get_section_by_name (abfd
, ".eh_frame_hdr");
3204 if (eh_frame_hdr
!= NULL
&& (eh_frame_hdr
->flags
& SEC_LOAD
))
3206 amt
= sizeof (struct elf_segment_map
);
3207 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3211 m
->p_type
= PT_GNU_EH_FRAME
;
3213 m
->sections
[0] = eh_frame_hdr
;
3222 elf_tdata (abfd
)->segment_map
= mfirst
;
3226 if (sections
!= NULL
)
3231 /* Sort sections by address. */
3234 elf_sort_sections (arg1
, arg2
)
3238 const asection
*sec1
= *(const asection
**) arg1
;
3239 const asection
*sec2
= *(const asection
**) arg2
;
3241 /* Sort by LMA first, since this is the address used to
3242 place the section into a segment. */
3243 if (sec1
->lma
< sec2
->lma
)
3245 else if (sec1
->lma
> sec2
->lma
)
3248 /* Then sort by VMA. Normally the LMA and the VMA will be
3249 the same, and this will do nothing. */
3250 if (sec1
->vma
< sec2
->vma
)
3252 else if (sec1
->vma
> sec2
->vma
)
3255 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3257 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3263 /* If the indicies are the same, do not return 0
3264 here, but continue to try the next comparison. */
3265 if (sec1
->target_index
- sec2
->target_index
!= 0)
3266 return sec1
->target_index
- sec2
->target_index
;
3271 else if (TOEND (sec2
))
3276 /* Sort by size, to put zero sized sections
3277 before others at the same address. */
3279 if (sec1
->_raw_size
< sec2
->_raw_size
)
3281 if (sec1
->_raw_size
> sec2
->_raw_size
)
3284 return sec1
->target_index
- sec2
->target_index
;
3287 /* Assign file positions to the sections based on the mapping from
3288 sections to segments. This function also sets up some fields in
3289 the file header, and writes out the program headers. */
3292 assign_file_positions_for_segments (abfd
)
3295 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3297 struct elf_segment_map
*m
;
3299 Elf_Internal_Phdr
*phdrs
;
3301 bfd_vma filehdr_vaddr
, filehdr_paddr
;
3302 bfd_vma phdrs_vaddr
, phdrs_paddr
;
3303 Elf_Internal_Phdr
*p
;
3306 if (elf_tdata (abfd
)->segment_map
== NULL
)
3308 if (! map_sections_to_segments (abfd
))
3312 if (bed
->elf_backend_modify_segment_map
)
3314 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
3319 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3322 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
3323 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
3324 elf_elfheader (abfd
)->e_phnum
= count
;
3329 /* If we already counted the number of program segments, make sure
3330 that we allocated enough space. This happens when SIZEOF_HEADERS
3331 is used in a linker script. */
3332 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
3333 if (alloc
!= 0 && count
> alloc
)
3335 ((*_bfd_error_handler
)
3336 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3337 bfd_get_filename (abfd
), alloc
, count
));
3338 bfd_set_error (bfd_error_bad_value
);
3345 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
3346 phdrs
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
3350 off
= bed
->s
->sizeof_ehdr
;
3351 off
+= alloc
* bed
->s
->sizeof_phdr
;
3358 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3365 /* If elf_segment_map is not from map_sections_to_segments, the
3366 sections may not be correctly ordered. NOTE: sorting should
3367 not be done to the PT_NOTE section of a corefile, which may
3368 contain several pseudo-sections artificially created by bfd.
3369 Sorting these pseudo-sections breaks things badly. */
3371 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
3372 && m
->p_type
== PT_NOTE
))
3373 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
3376 p
->p_type
= m
->p_type
;
3377 p
->p_flags
= m
->p_flags
;
3379 if (p
->p_type
== PT_LOAD
3381 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
3383 if ((abfd
->flags
& D_PAGED
) != 0)
3384 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
3387 bfd_size_type align
;
3390 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3392 bfd_size_type secalign
;
3394 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
3395 if (secalign
> align
)
3399 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
3406 p
->p_vaddr
= m
->sections
[0]->vma
;
3408 if (m
->p_paddr_valid
)
3409 p
->p_paddr
= m
->p_paddr
;
3410 else if (m
->count
== 0)
3413 p
->p_paddr
= m
->sections
[0]->lma
;
3415 if (p
->p_type
== PT_LOAD
3416 && (abfd
->flags
& D_PAGED
) != 0)
3417 p
->p_align
= bed
->maxpagesize
;
3418 else if (m
->count
== 0)
3419 p
->p_align
= bed
->s
->file_align
;
3427 if (m
->includes_filehdr
)
3429 if (! m
->p_flags_valid
)
3432 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3433 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3436 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3438 if (p
->p_vaddr
< (bfd_vma
) off
)
3440 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
3441 bfd_get_filename (abfd
));
3442 bfd_set_error (bfd_error_bad_value
);
3447 if (! m
->p_paddr_valid
)
3450 if (p
->p_type
== PT_LOAD
)
3452 filehdr_vaddr
= p
->p_vaddr
;
3453 filehdr_paddr
= p
->p_paddr
;
3457 if (m
->includes_phdrs
)
3459 if (! m
->p_flags_valid
)
3462 if (m
->includes_filehdr
)
3464 if (p
->p_type
== PT_LOAD
)
3466 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3467 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3472 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3476 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3477 p
->p_vaddr
-= off
- p
->p_offset
;
3478 if (! m
->p_paddr_valid
)
3479 p
->p_paddr
-= off
- p
->p_offset
;
3482 if (p
->p_type
== PT_LOAD
)
3484 phdrs_vaddr
= p
->p_vaddr
;
3485 phdrs_paddr
= p
->p_paddr
;
3488 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3491 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3492 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3495 if (p
->p_type
== PT_LOAD
3496 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3498 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3504 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3505 p
->p_filesz
+= adjust
;
3506 p
->p_memsz
+= adjust
;
3512 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3516 bfd_size_type align
;
3520 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3522 /* The section may have artificial alignment forced by a
3523 link script. Notice this case by the gap between the
3524 cumulative phdr lma and the section's lma. */
3525 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3527 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3529 p
->p_memsz
+= adjust
;
3532 if ((flags
& SEC_LOAD
) != 0)
3533 p
->p_filesz
+= adjust
;
3536 if (p
->p_type
== PT_LOAD
)
3538 bfd_signed_vma adjust
;
3540 if ((flags
& SEC_LOAD
) != 0)
3542 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3546 else if ((flags
& SEC_ALLOC
) != 0)
3548 /* The section VMA must equal the file position
3549 modulo the page size. FIXME: I'm not sure if
3550 this adjustment is really necessary. We used to
3551 not have the SEC_LOAD case just above, and then
3552 this was necessary, but now I'm not sure. */
3553 if ((abfd
->flags
& D_PAGED
) != 0)
3554 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
3556 adjust
= (sec
->vma
- voff
) % align
;
3565 (* _bfd_error_handler
) (_("\
3566 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3567 bfd_section_name (abfd
, sec
),
3572 p
->p_memsz
+= adjust
;
3575 if ((flags
& SEC_LOAD
) != 0)
3576 p
->p_filesz
+= adjust
;
3581 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3582 used in a linker script we may have a section with
3583 SEC_LOAD clear but which is supposed to have
3585 if ((flags
& SEC_LOAD
) != 0
3586 || (flags
& SEC_HAS_CONTENTS
) != 0)
3587 off
+= sec
->_raw_size
;
3589 if ((flags
& SEC_ALLOC
) != 0)
3590 voff
+= sec
->_raw_size
;
3593 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
3595 /* The actual "note" segment has i == 0.
3596 This is the one that actually contains everything. */
3600 p
->p_filesz
= sec
->_raw_size
;
3601 off
+= sec
->_raw_size
;
3606 /* Fake sections -- don't need to be written. */
3609 flags
= sec
->flags
= 0;
3616 p
->p_memsz
+= sec
->_raw_size
;
3618 if ((flags
& SEC_LOAD
) != 0)
3619 p
->p_filesz
+= sec
->_raw_size
;
3621 if (align
> p
->p_align
3622 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
3626 if (! m
->p_flags_valid
)
3629 if ((flags
& SEC_CODE
) != 0)
3631 if ((flags
& SEC_READONLY
) == 0)
3637 /* Now that we have set the section file positions, we can set up
3638 the file positions for the non PT_LOAD segments. */
3639 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3643 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
3645 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
3646 p
->p_offset
= m
->sections
[0]->filepos
;
3650 if (m
->includes_filehdr
)
3652 p
->p_vaddr
= filehdr_vaddr
;
3653 if (! m
->p_paddr_valid
)
3654 p
->p_paddr
= filehdr_paddr
;
3656 else if (m
->includes_phdrs
)
3658 p
->p_vaddr
= phdrs_vaddr
;
3659 if (! m
->p_paddr_valid
)
3660 p
->p_paddr
= phdrs_paddr
;
3665 /* Clear out any program headers we allocated but did not use. */
3666 for (; count
< alloc
; count
++, p
++)
3668 memset (p
, 0, sizeof *p
);
3669 p
->p_type
= PT_NULL
;
3672 elf_tdata (abfd
)->phdr
= phdrs
;
3674 elf_tdata (abfd
)->next_file_pos
= off
;
3676 /* Write out the program headers. */
3677 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
3678 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
3684 /* Get the size of the program header.
3686 If this is called by the linker before any of the section VMA's are set, it
3687 can't calculate the correct value for a strange memory layout. This only
3688 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3689 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3690 data segment (exclusive of .interp and .dynamic).
3692 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3693 will be two segments. */
3695 static bfd_size_type
3696 get_program_header_size (abfd
)
3701 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3703 /* We can't return a different result each time we're called. */
3704 if (elf_tdata (abfd
)->program_header_size
!= 0)
3705 return elf_tdata (abfd
)->program_header_size
;
3707 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3709 struct elf_segment_map
*m
;
3712 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3714 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3715 return elf_tdata (abfd
)->program_header_size
;
3718 /* Assume we will need exactly two PT_LOAD segments: one for text
3719 and one for data. */
3722 s
= bfd_get_section_by_name (abfd
, ".interp");
3723 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3725 /* If we have a loadable interpreter section, we need a
3726 PT_INTERP segment. In this case, assume we also need a
3727 PT_PHDR segment, although that may not be true for all
3732 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3734 /* We need a PT_DYNAMIC segment. */
3738 if (elf_tdata (abfd
)->eh_frame_hdr
3739 && bfd_get_section_by_name (abfd
, ".eh_frame_hdr") != NULL
)
3741 /* We need a PT_GNU_EH_FRAME segment. */
3745 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3747 if ((s
->flags
& SEC_LOAD
) != 0
3748 && strncmp (s
->name
, ".note", 5) == 0)
3750 /* We need a PT_NOTE segment. */
3755 /* Let the backend count up any program headers it might need. */
3756 if (bed
->elf_backend_additional_program_headers
)
3760 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
3766 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3767 return elf_tdata (abfd
)->program_header_size
;
3770 /* Work out the file positions of all the sections. This is called by
3771 _bfd_elf_compute_section_file_positions. All the section sizes and
3772 VMAs must be known before this is called.
3774 We do not consider reloc sections at this point, unless they form
3775 part of the loadable image. Reloc sections are assigned file
3776 positions in assign_file_positions_for_relocs, which is called by
3777 write_object_contents and final_link.
3779 We also don't set the positions of the .symtab and .strtab here. */
3782 assign_file_positions_except_relocs (abfd
)
3785 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
3786 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
3787 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
3788 unsigned int num_sec
= elf_numsections (abfd
);
3790 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3792 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3793 && bfd_get_format (abfd
) != bfd_core
)
3795 Elf_Internal_Shdr
**hdrpp
;
3798 /* Start after the ELF header. */
3799 off
= i_ehdrp
->e_ehsize
;
3801 /* We are not creating an executable, which means that we are
3802 not creating a program header, and that the actual order of
3803 the sections in the file is unimportant. */
3804 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
3806 Elf_Internal_Shdr
*hdr
;
3809 if (hdr
->sh_type
== SHT_REL
3810 || hdr
->sh_type
== SHT_RELA
3811 || i
== tdata
->symtab_section
3812 || i
== tdata
->symtab_shndx_section
3813 || i
== tdata
->strtab_section
)
3815 hdr
->sh_offset
= -1;
3818 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3820 if (i
== SHN_LORESERVE
- 1)
3822 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3823 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3830 Elf_Internal_Shdr
**hdrpp
;
3832 /* Assign file positions for the loaded sections based on the
3833 assignment of sections to segments. */
3834 if (! assign_file_positions_for_segments (abfd
))
3837 /* Assign file positions for the other sections. */
3839 off
= elf_tdata (abfd
)->next_file_pos
;
3840 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
3842 Elf_Internal_Shdr
*hdr
;
3845 if (hdr
->bfd_section
!= NULL
3846 && hdr
->bfd_section
->filepos
!= 0)
3847 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
3848 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3850 ((*_bfd_error_handler
)
3851 (_("%s: warning: allocated section `%s' not in segment"),
3852 bfd_get_filename (abfd
),
3853 (hdr
->bfd_section
== NULL
3855 : hdr
->bfd_section
->name
)));
3856 if ((abfd
->flags
& D_PAGED
) != 0)
3857 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3859 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3860 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3863 else if (hdr
->sh_type
== SHT_REL
3864 || hdr
->sh_type
== SHT_RELA
3865 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3866 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
3867 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3868 hdr
->sh_offset
= -1;
3870 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3872 if (i
== SHN_LORESERVE
- 1)
3874 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3875 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3880 /* Place the section headers. */
3881 off
= align_file_position (off
, bed
->s
->file_align
);
3882 i_ehdrp
->e_shoff
= off
;
3883 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3885 elf_tdata (abfd
)->next_file_pos
= off
;
3894 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3895 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3896 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3897 struct elf_strtab_hash
*shstrtab
;
3898 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3900 i_ehdrp
= elf_elfheader (abfd
);
3901 i_shdrp
= elf_elfsections (abfd
);
3903 shstrtab
= _bfd_elf_strtab_init ();
3904 if (shstrtab
== NULL
)
3907 elf_shstrtab (abfd
) = shstrtab
;
3909 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3910 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3911 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3912 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3914 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3915 i_ehdrp
->e_ident
[EI_DATA
] =
3916 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3917 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3919 if ((abfd
->flags
& DYNAMIC
) != 0)
3920 i_ehdrp
->e_type
= ET_DYN
;
3921 else if ((abfd
->flags
& EXEC_P
) != 0)
3922 i_ehdrp
->e_type
= ET_EXEC
;
3923 else if (bfd_get_format (abfd
) == bfd_core
)
3924 i_ehdrp
->e_type
= ET_CORE
;
3926 i_ehdrp
->e_type
= ET_REL
;
3928 switch (bfd_get_arch (abfd
))
3930 case bfd_arch_unknown
:
3931 i_ehdrp
->e_machine
= EM_NONE
;
3934 /* There used to be a long list of cases here, each one setting
3935 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
3936 in the corresponding bfd definition. To avoid duplication,
3937 the switch was removed. Machines that need special handling
3938 can generally do it in elf_backend_final_write_processing(),
3939 unless they need the information earlier than the final write.
3940 Such need can generally be supplied by replacing the tests for
3941 e_machine with the conditions used to determine it. */
3943 if (get_elf_backend_data (abfd
) != NULL
)
3944 i_ehdrp
->e_machine
= get_elf_backend_data (abfd
)->elf_machine_code
;
3946 i_ehdrp
->e_machine
= EM_NONE
;
3949 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3950 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3952 /* No program header, for now. */
3953 i_ehdrp
->e_phoff
= 0;
3954 i_ehdrp
->e_phentsize
= 0;
3955 i_ehdrp
->e_phnum
= 0;
3957 /* Each bfd section is section header entry. */
3958 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3959 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3961 /* If we're building an executable, we'll need a program header table. */
3962 if (abfd
->flags
& EXEC_P
)
3964 /* It all happens later. */
3966 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3968 /* elf_build_phdrs() returns a (NULL-terminated) array of
3969 Elf_Internal_Phdrs. */
3970 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3971 i_ehdrp
->e_phoff
= outbase
;
3972 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3977 i_ehdrp
->e_phentsize
= 0;
3979 i_ehdrp
->e_phoff
= 0;
3982 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3983 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
3984 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3985 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
3986 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3987 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
3988 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3989 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3990 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3996 /* Assign file positions for all the reloc sections which are not part
3997 of the loadable file image. */
4000 _bfd_elf_assign_file_positions_for_relocs (abfd
)
4004 unsigned int i
, num_sec
;
4005 Elf_Internal_Shdr
**shdrpp
;
4007 off
= elf_tdata (abfd
)->next_file_pos
;
4009 num_sec
= elf_numsections (abfd
);
4010 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4012 Elf_Internal_Shdr
*shdrp
;
4015 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4016 && shdrp
->sh_offset
== -1)
4017 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
4020 elf_tdata (abfd
)->next_file_pos
= off
;
4024 _bfd_elf_write_object_contents (abfd
)
4027 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4028 Elf_Internal_Ehdr
*i_ehdrp
;
4029 Elf_Internal_Shdr
**i_shdrp
;
4031 unsigned int count
, num_sec
;
4033 if (! abfd
->output_has_begun
4034 && ! _bfd_elf_compute_section_file_positions
4035 (abfd
, (struct bfd_link_info
*) NULL
))
4038 i_shdrp
= elf_elfsections (abfd
);
4039 i_ehdrp
= elf_elfheader (abfd
);
4042 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4046 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4048 /* After writing the headers, we need to write the sections too... */
4049 num_sec
= elf_numsections (abfd
);
4050 for (count
= 1; count
< num_sec
; count
++)
4052 if (bed
->elf_backend_section_processing
)
4053 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4054 if (i_shdrp
[count
]->contents
)
4056 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4058 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4059 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4062 if (count
== SHN_LORESERVE
- 1)
4063 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4066 /* Write out the section header names. */
4067 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4068 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4071 if (bed
->elf_backend_final_write_processing
)
4072 (*bed
->elf_backend_final_write_processing
) (abfd
,
4073 elf_tdata (abfd
)->linker
);
4075 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4079 _bfd_elf_write_corefile_contents (abfd
)
4082 /* Hopefully this can be done just like an object file. */
4083 return _bfd_elf_write_object_contents (abfd
);
4086 /* Given a section, search the header to find them. */
4089 _bfd_elf_section_from_bfd_section (abfd
, asect
)
4093 struct elf_backend_data
*bed
;
4096 if (elf_section_data (asect
) != NULL
4097 && elf_section_data (asect
)->this_idx
!= 0)
4098 return elf_section_data (asect
)->this_idx
;
4100 if (bfd_is_abs_section (asect
))
4102 else if (bfd_is_com_section (asect
))
4104 else if (bfd_is_und_section (asect
))
4108 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4109 int maxindex
= elf_numsections (abfd
);
4111 for (index
= 1; index
< maxindex
; index
++)
4113 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4115 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4121 bed
= get_elf_backend_data (abfd
);
4122 if (bed
->elf_backend_section_from_bfd_section
)
4126 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4131 bfd_set_error (bfd_error_nonrepresentable_section
);
4136 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4140 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
4142 asymbol
**asym_ptr_ptr
;
4144 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4146 flagword flags
= asym_ptr
->flags
;
4148 /* When gas creates relocations against local labels, it creates its
4149 own symbol for the section, but does put the symbol into the
4150 symbol chain, so udata is 0. When the linker is generating
4151 relocatable output, this section symbol may be for one of the
4152 input sections rather than the output section. */
4153 if (asym_ptr
->udata
.i
== 0
4154 && (flags
& BSF_SECTION_SYM
)
4155 && asym_ptr
->section
)
4159 if (asym_ptr
->section
->output_section
!= NULL
)
4160 indx
= asym_ptr
->section
->output_section
->index
;
4162 indx
= asym_ptr
->section
->index
;
4163 if (indx
< elf_num_section_syms (abfd
)
4164 && elf_section_syms (abfd
)[indx
] != NULL
)
4165 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4168 idx
= asym_ptr
->udata
.i
;
4172 /* This case can occur when using --strip-symbol on a symbol
4173 which is used in a relocation entry. */
4174 (*_bfd_error_handler
)
4175 (_("%s: symbol `%s' required but not present"),
4176 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4177 bfd_set_error (bfd_error_no_symbols
);
4184 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4185 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4186 elf_symbol_flags (flags
));
4194 /* Copy private BFD data. This copies any program header information. */
4197 copy_private_bfd_data (ibfd
, obfd
)
4201 Elf_Internal_Ehdr
* iehdr
;
4202 struct elf_segment_map
* map
;
4203 struct elf_segment_map
* map_first
;
4204 struct elf_segment_map
** pointer_to_map
;
4205 Elf_Internal_Phdr
* segment
;
4208 unsigned int num_segments
;
4209 boolean phdr_included
= false;
4210 bfd_vma maxpagesize
;
4211 struct elf_segment_map
* phdr_adjust_seg
= NULL
;
4212 unsigned int phdr_adjust_num
= 0;
4214 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4215 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4218 if (elf_tdata (ibfd
)->phdr
== NULL
)
4221 iehdr
= elf_elfheader (ibfd
);
4224 pointer_to_map
= &map_first
;
4226 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4227 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4229 /* Returns the end address of the segment + 1. */
4230 #define SEGMENT_END(segment, start) \
4231 (start + (segment->p_memsz > segment->p_filesz \
4232 ? segment->p_memsz : segment->p_filesz))
4234 /* Returns true if the given section is contained within
4235 the given segment. VMA addresses are compared. */
4236 #define IS_CONTAINED_BY_VMA(section, segment) \
4237 (section->vma >= segment->p_vaddr \
4238 && (section->vma + section->_raw_size) \
4239 <= (SEGMENT_END (segment, segment->p_vaddr)))
4241 /* Returns true if the given section is contained within
4242 the given segment. LMA addresses are compared. */
4243 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4244 (section->lma >= base \
4245 && (section->lma + section->_raw_size) \
4246 <= SEGMENT_END (segment, base))
4248 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4249 #define IS_COREFILE_NOTE(p, s) \
4250 (p->p_type == PT_NOTE \
4251 && bfd_get_format (ibfd) == bfd_core \
4252 && s->vma == 0 && s->lma == 0 \
4253 && (bfd_vma) s->filepos >= p->p_offset \
4254 && (bfd_vma) s->filepos + s->_raw_size \
4255 <= p->p_offset + p->p_filesz)
4257 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4258 linker, which generates a PT_INTERP section with p_vaddr and
4259 p_memsz set to 0. */
4260 #define IS_SOLARIS_PT_INTERP(p, s) \
4262 && p->p_filesz > 0 \
4263 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4264 && s->_raw_size > 0 \
4265 && (bfd_vma) s->filepos >= p->p_offset \
4266 && ((bfd_vma) s->filepos + s->_raw_size \
4267 <= p->p_offset + p->p_filesz))
4269 /* Decide if the given section should be included in the given segment.
4270 A section will be included if:
4271 1. It is within the address space of the segment -- we use the LMA
4272 if that is set for the segment and the VMA otherwise,
4273 2. It is an allocated segment,
4274 3. There is an output section associated with it,
4275 4. The section has not already been allocated to a previous segment. */
4276 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
4277 (((((segment->p_paddr \
4278 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4279 : IS_CONTAINED_BY_VMA (section, segment)) \
4280 || IS_SOLARIS_PT_INTERP (segment, section)) \
4281 && (section->flags & SEC_ALLOC) != 0) \
4282 || IS_COREFILE_NOTE (segment, section)) \
4283 && section->output_section != NULL \
4284 && section->segment_mark == false)
4286 /* Returns true iff seg1 starts after the end of seg2. */
4287 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4288 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4290 /* Returns true iff seg1 and seg2 overlap. */
4291 #define SEGMENT_OVERLAPS(seg1, seg2) \
4292 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4294 /* Initialise the segment mark field. */
4295 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4296 section
->segment_mark
= false;
4298 /* Scan through the segments specified in the program header
4299 of the input BFD. For this first scan we look for overlaps
4300 in the loadable segments. These can be created by weird
4301 parameters to objcopy. */
4302 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4307 Elf_Internal_Phdr
*segment2
;
4309 if (segment
->p_type
!= PT_LOAD
)
4312 /* Determine if this segment overlaps any previous segments. */
4313 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4315 bfd_signed_vma extra_length
;
4317 if (segment2
->p_type
!= PT_LOAD
4318 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4321 /* Merge the two segments together. */
4322 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4324 /* Extend SEGMENT2 to include SEGMENT and then delete
4327 SEGMENT_END (segment
, segment
->p_vaddr
)
4328 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4330 if (extra_length
> 0)
4332 segment2
->p_memsz
+= extra_length
;
4333 segment2
->p_filesz
+= extra_length
;
4336 segment
->p_type
= PT_NULL
;
4338 /* Since we have deleted P we must restart the outer loop. */
4340 segment
= elf_tdata (ibfd
)->phdr
;
4345 /* Extend SEGMENT to include SEGMENT2 and then delete
4348 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4349 - SEGMENT_END (segment
, segment
->p_vaddr
);
4351 if (extra_length
> 0)
4353 segment
->p_memsz
+= extra_length
;
4354 segment
->p_filesz
+= extra_length
;
4357 segment2
->p_type
= PT_NULL
;
4362 /* The second scan attempts to assign sections to segments. */
4363 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4367 unsigned int section_count
;
4368 asection
** sections
;
4369 asection
* output_section
;
4371 bfd_vma matching_lma
;
4372 bfd_vma suggested_lma
;
4376 if (segment
->p_type
== PT_NULL
)
4379 /* Compute how many sections might be placed into this segment. */
4381 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4382 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
))
4385 /* Allocate a segment map big enough to contain all of the
4386 sections we have selected. */
4387 amt
= sizeof (struct elf_segment_map
);
4388 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4389 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4393 /* Initialise the fields of the segment map. Default to
4394 using the physical address of the segment in the input BFD. */
4396 map
->p_type
= segment
->p_type
;
4397 map
->p_flags
= segment
->p_flags
;
4398 map
->p_flags_valid
= 1;
4399 map
->p_paddr
= segment
->p_paddr
;
4400 map
->p_paddr_valid
= 1;
4402 /* Determine if this segment contains the ELF file header
4403 and if it contains the program headers themselves. */
4404 map
->includes_filehdr
= (segment
->p_offset
== 0
4405 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4407 map
->includes_phdrs
= 0;
4409 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4411 map
->includes_phdrs
=
4412 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4413 && (segment
->p_offset
+ segment
->p_filesz
4414 >= ((bfd_vma
) iehdr
->e_phoff
4415 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4417 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4418 phdr_included
= true;
4421 if (section_count
== 0)
4423 /* Special segments, such as the PT_PHDR segment, may contain
4424 no sections, but ordinary, loadable segments should contain
4426 if (segment
->p_type
== PT_LOAD
)
4428 (_("%s: warning: Empty loadable segment detected\n"),
4429 bfd_archive_filename (ibfd
));
4432 *pointer_to_map
= map
;
4433 pointer_to_map
= &map
->next
;
4438 /* Now scan the sections in the input BFD again and attempt
4439 to add their corresponding output sections to the segment map.
4440 The problem here is how to handle an output section which has
4441 been moved (ie had its LMA changed). There are four possibilities:
4443 1. None of the sections have been moved.
4444 In this case we can continue to use the segment LMA from the
4447 2. All of the sections have been moved by the same amount.
4448 In this case we can change the segment's LMA to match the LMA
4449 of the first section.
4451 3. Some of the sections have been moved, others have not.
4452 In this case those sections which have not been moved can be
4453 placed in the current segment which will have to have its size,
4454 and possibly its LMA changed, and a new segment or segments will
4455 have to be created to contain the other sections.
4457 4. The sections have been moved, but not be the same amount.
4458 In this case we can change the segment's LMA to match the LMA
4459 of the first section and we will have to create a new segment
4460 or segments to contain the other sections.
4462 In order to save time, we allocate an array to hold the section
4463 pointers that we are interested in. As these sections get assigned
4464 to a segment, they are removed from this array. */
4466 amt
= (bfd_size_type
) section_count
* sizeof (asection
*);
4467 sections
= (asection
**) bfd_malloc (amt
);
4468 if (sections
== NULL
)
4471 /* Step One: Scan for segment vs section LMA conflicts.
4472 Also add the sections to the section array allocated above.
4473 Also add the sections to the current segment. In the common
4474 case, where the sections have not been moved, this means that
4475 we have completely filled the segment, and there is nothing
4481 for (j
= 0, section
= ibfd
->sections
;
4483 section
= section
->next
)
4485 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
))
4487 output_section
= section
->output_section
;
4489 sections
[j
++] = section
;
4491 /* The Solaris native linker always sets p_paddr to 0.
4492 We try to catch that case here, and set it to the
4494 if (segment
->p_paddr
== 0
4495 && segment
->p_vaddr
!= 0
4497 && output_section
->lma
!= 0
4498 && (output_section
->vma
== (segment
->p_vaddr
4499 + (map
->includes_filehdr
4502 + (map
->includes_phdrs
4504 * iehdr
->e_phentsize
)
4506 map
->p_paddr
= segment
->p_vaddr
;
4508 /* Match up the physical address of the segment with the
4509 LMA address of the output section. */
4510 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4511 || IS_COREFILE_NOTE (segment
, section
))
4513 if (matching_lma
== 0)
4514 matching_lma
= output_section
->lma
;
4516 /* We assume that if the section fits within the segment
4517 then it does not overlap any other section within that
4519 map
->sections
[isec
++] = output_section
;
4521 else if (suggested_lma
== 0)
4522 suggested_lma
= output_section
->lma
;
4526 BFD_ASSERT (j
== section_count
);
4528 /* Step Two: Adjust the physical address of the current segment,
4530 if (isec
== section_count
)
4532 /* All of the sections fitted within the segment as currently
4533 specified. This is the default case. Add the segment to
4534 the list of built segments and carry on to process the next
4535 program header in the input BFD. */
4536 map
->count
= section_count
;
4537 *pointer_to_map
= map
;
4538 pointer_to_map
= &map
->next
;
4545 if (matching_lma
!= 0)
4547 /* At least one section fits inside the current segment.
4548 Keep it, but modify its physical address to match the
4549 LMA of the first section that fitted. */
4550 map
->p_paddr
= matching_lma
;
4554 /* None of the sections fitted inside the current segment.
4555 Change the current segment's physical address to match
4556 the LMA of the first section. */
4557 map
->p_paddr
= suggested_lma
;
4560 /* Offset the segment physical address from the lma
4561 to allow for space taken up by elf headers. */
4562 if (map
->includes_filehdr
)
4563 map
->p_paddr
-= iehdr
->e_ehsize
;
4565 if (map
->includes_phdrs
)
4567 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
4569 /* iehdr->e_phnum is just an estimate of the number
4570 of program headers that we will need. Make a note
4571 here of the number we used and the segment we chose
4572 to hold these headers, so that we can adjust the
4573 offset when we know the correct value. */
4574 phdr_adjust_num
= iehdr
->e_phnum
;
4575 phdr_adjust_seg
= map
;
4579 /* Step Three: Loop over the sections again, this time assigning
4580 those that fit to the current segment and remvoing them from the
4581 sections array; but making sure not to leave large gaps. Once all
4582 possible sections have been assigned to the current segment it is
4583 added to the list of built segments and if sections still remain
4584 to be assigned, a new segment is constructed before repeating
4592 /* Fill the current segment with sections that fit. */
4593 for (j
= 0; j
< section_count
; j
++)
4595 section
= sections
[j
];
4597 if (section
== NULL
)
4600 output_section
= section
->output_section
;
4602 BFD_ASSERT (output_section
!= NULL
);
4604 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4605 || IS_COREFILE_NOTE (segment
, section
))
4607 if (map
->count
== 0)
4609 /* If the first section in a segment does not start at
4610 the beginning of the segment, then something is
4612 if (output_section
->lma
!=
4614 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
4615 + (map
->includes_phdrs
4616 ? iehdr
->e_phnum
* iehdr
->e_phentsize
4622 asection
* prev_sec
;
4624 prev_sec
= map
->sections
[map
->count
- 1];
4626 /* If the gap between the end of the previous section
4627 and the start of this section is more than
4628 maxpagesize then we need to start a new segment. */
4629 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
,
4631 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
4632 || ((prev_sec
->lma
+ prev_sec
->_raw_size
)
4633 > output_section
->lma
))
4635 if (suggested_lma
== 0)
4636 suggested_lma
= output_section
->lma
;
4642 map
->sections
[map
->count
++] = output_section
;
4645 section
->segment_mark
= true;
4647 else if (suggested_lma
== 0)
4648 suggested_lma
= output_section
->lma
;
4651 BFD_ASSERT (map
->count
> 0);
4653 /* Add the current segment to the list of built segments. */
4654 *pointer_to_map
= map
;
4655 pointer_to_map
= &map
->next
;
4657 if (isec
< section_count
)
4659 /* We still have not allocated all of the sections to
4660 segments. Create a new segment here, initialise it
4661 and carry on looping. */
4662 amt
= sizeof (struct elf_segment_map
);
4663 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4664 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4668 /* Initialise the fields of the segment map. Set the physical
4669 physical address to the LMA of the first section that has
4670 not yet been assigned. */
4672 map
->p_type
= segment
->p_type
;
4673 map
->p_flags
= segment
->p_flags
;
4674 map
->p_flags_valid
= 1;
4675 map
->p_paddr
= suggested_lma
;
4676 map
->p_paddr_valid
= 1;
4677 map
->includes_filehdr
= 0;
4678 map
->includes_phdrs
= 0;
4681 while (isec
< section_count
);
4686 /* The Solaris linker creates program headers in which all the
4687 p_paddr fields are zero. When we try to objcopy or strip such a
4688 file, we get confused. Check for this case, and if we find it
4689 reset the p_paddr_valid fields. */
4690 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
4691 if (map
->p_paddr
!= 0)
4695 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
4696 map
->p_paddr_valid
= 0;
4699 elf_tdata (obfd
)->segment_map
= map_first
;
4701 /* If we had to estimate the number of program headers that were
4702 going to be needed, then check our estimate now and adjust
4703 the offset if necessary. */
4704 if (phdr_adjust_seg
!= NULL
)
4708 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
4711 if (count
> phdr_adjust_num
)
4712 phdr_adjust_seg
->p_paddr
4713 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
4717 /* Final Step: Sort the segments into ascending order of physical
4719 if (map_first
!= NULL
)
4721 struct elf_segment_map
*prev
;
4724 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
4726 /* Yes I know - its a bubble sort.... */
4727 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
4729 /* Swap map and map->next. */
4730 prev
->next
= map
->next
;
4731 map
->next
= map
->next
->next
;
4732 prev
->next
->next
= map
;
4742 #undef IS_CONTAINED_BY_VMA
4743 #undef IS_CONTAINED_BY_LMA
4744 #undef IS_COREFILE_NOTE
4745 #undef IS_SOLARIS_PT_INTERP
4746 #undef INCLUDE_SECTION_IN_SEGMENT
4747 #undef SEGMENT_AFTER_SEGMENT
4748 #undef SEGMENT_OVERLAPS
4752 /* Copy private section information. This copies over the entsize
4753 field, and sometimes the info field. */
4756 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
4762 Elf_Internal_Shdr
*ihdr
, *ohdr
;
4764 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
4765 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
4768 /* Copy over private BFD data if it has not already been copied.
4769 This must be done here, rather than in the copy_private_bfd_data
4770 entry point, because the latter is called after the section
4771 contents have been set, which means that the program headers have
4772 already been worked out. */
4773 if (elf_tdata (obfd
)->segment_map
== NULL
4774 && elf_tdata (ibfd
)->phdr
!= NULL
)
4778 /* Only set up the segments if there are no more SEC_ALLOC
4779 sections. FIXME: This won't do the right thing if objcopy is
4780 used to remove the last SEC_ALLOC section, since objcopy
4781 won't call this routine in that case. */
4782 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
4783 if ((s
->flags
& SEC_ALLOC
) != 0)
4787 if (! copy_private_bfd_data (ibfd
, obfd
))
4792 ihdr
= &elf_section_data (isec
)->this_hdr
;
4793 ohdr
= &elf_section_data (osec
)->this_hdr
;
4795 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
4797 if (ihdr
->sh_type
== SHT_SYMTAB
4798 || ihdr
->sh_type
== SHT_DYNSYM
4799 || ihdr
->sh_type
== SHT_GNU_verneed
4800 || ihdr
->sh_type
== SHT_GNU_verdef
)
4801 ohdr
->sh_info
= ihdr
->sh_info
;
4803 elf_section_data (osec
)->use_rela_p
4804 = elf_section_data (isec
)->use_rela_p
;
4809 /* Copy private symbol information. If this symbol is in a section
4810 which we did not map into a BFD section, try to map the section
4811 index correctly. We use special macro definitions for the mapped
4812 section indices; these definitions are interpreted by the
4813 swap_out_syms function. */
4815 #define MAP_ONESYMTAB (SHN_HIOS + 1)
4816 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
4817 #define MAP_STRTAB (SHN_HIOS + 3)
4818 #define MAP_SHSTRTAB (SHN_HIOS + 4)
4819 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
4822 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
4828 elf_symbol_type
*isym
, *osym
;
4830 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4831 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4834 isym
= elf_symbol_from (ibfd
, isymarg
);
4835 osym
= elf_symbol_from (obfd
, osymarg
);
4839 && bfd_is_abs_section (isym
->symbol
.section
))
4843 shndx
= isym
->internal_elf_sym
.st_shndx
;
4844 if (shndx
== elf_onesymtab (ibfd
))
4845 shndx
= MAP_ONESYMTAB
;
4846 else if (shndx
== elf_dynsymtab (ibfd
))
4847 shndx
= MAP_DYNSYMTAB
;
4848 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
4850 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
4851 shndx
= MAP_SHSTRTAB
;
4852 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
4853 shndx
= MAP_SYM_SHNDX
;
4854 osym
->internal_elf_sym
.st_shndx
= shndx
;
4860 /* Swap out the symbols. */
4863 swap_out_syms (abfd
, sttp
, relocatable_p
)
4865 struct bfd_strtab_hash
**sttp
;
4868 struct elf_backend_data
*bed
;
4871 struct bfd_strtab_hash
*stt
;
4872 Elf_Internal_Shdr
*symtab_hdr
;
4873 Elf_Internal_Shdr
*symtab_shndx_hdr
;
4874 Elf_Internal_Shdr
*symstrtab_hdr
;
4875 char *outbound_syms
;
4876 char *outbound_shndx
;
4880 if (!elf_map_symbols (abfd
))
4883 /* Dump out the symtabs. */
4884 stt
= _bfd_elf_stringtab_init ();
4888 bed
= get_elf_backend_data (abfd
);
4889 symcount
= bfd_get_symcount (abfd
);
4890 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4891 symtab_hdr
->sh_type
= SHT_SYMTAB
;
4892 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
4893 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
4894 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
4895 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
4897 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4898 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4900 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
4901 outbound_syms
= bfd_alloc (abfd
, amt
);
4902 if (outbound_syms
== NULL
)
4904 symtab_hdr
->contents
= (PTR
) outbound_syms
;
4906 outbound_shndx
= NULL
;
4907 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
4908 if (symtab_shndx_hdr
->sh_name
!= 0)
4910 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
4911 outbound_shndx
= bfd_alloc (abfd
, amt
);
4912 if (outbound_shndx
== NULL
)
4914 memset (outbound_shndx
, 0, (unsigned long) amt
);
4915 symtab_shndx_hdr
->contents
= outbound_shndx
;
4916 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
4917 symtab_shndx_hdr
->sh_size
= amt
;
4918 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
4919 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
4922 /* now generate the data (for "contents") */
4924 /* Fill in zeroth symbol and swap it out. */
4925 Elf_Internal_Sym sym
;
4931 sym
.st_shndx
= SHN_UNDEF
;
4932 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
4933 outbound_syms
+= bed
->s
->sizeof_sym
;
4934 if (outbound_shndx
!= NULL
)
4935 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
4938 syms
= bfd_get_outsymbols (abfd
);
4939 for (idx
= 0; idx
< symcount
; idx
++)
4941 Elf_Internal_Sym sym
;
4942 bfd_vma value
= syms
[idx
]->value
;
4943 elf_symbol_type
*type_ptr
;
4944 flagword flags
= syms
[idx
]->flags
;
4947 if ((flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
4949 /* Local section symbols have no name. */
4954 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
4957 if (sym
.st_name
== (unsigned long) -1)
4961 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
4963 if ((flags
& BSF_SECTION_SYM
) == 0
4964 && bfd_is_com_section (syms
[idx
]->section
))
4966 /* ELF common symbols put the alignment into the `value' field,
4967 and the size into the `size' field. This is backwards from
4968 how BFD handles it, so reverse it here. */
4969 sym
.st_size
= value
;
4970 if (type_ptr
== NULL
4971 || type_ptr
->internal_elf_sym
.st_value
== 0)
4972 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
4974 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
4975 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
4976 (abfd
, syms
[idx
]->section
);
4980 asection
*sec
= syms
[idx
]->section
;
4983 if (sec
->output_section
)
4985 value
+= sec
->output_offset
;
4986 sec
= sec
->output_section
;
4988 /* Don't add in the section vma for relocatable output. */
4989 if (! relocatable_p
)
4991 sym
.st_value
= value
;
4992 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4994 if (bfd_is_abs_section (sec
)
4996 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4998 /* This symbol is in a real ELF section which we did
4999 not create as a BFD section. Undo the mapping done
5000 by copy_private_symbol_data. */
5001 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
5005 shndx
= elf_onesymtab (abfd
);
5008 shndx
= elf_dynsymtab (abfd
);
5011 shndx
= elf_tdata (abfd
)->strtab_section
;
5014 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5017 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5025 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5031 /* Writing this would be a hell of a lot easier if
5032 we had some decent documentation on bfd, and
5033 knew what to expect of the library, and what to
5034 demand of applications. For example, it
5035 appears that `objcopy' might not set the
5036 section of a symbol to be a section that is
5037 actually in the output file. */
5038 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5039 BFD_ASSERT (sec2
!= 0);
5040 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5041 BFD_ASSERT (shndx
!= -1);
5045 sym
.st_shndx
= shndx
;
5048 if ((flags
& BSF_FUNCTION
) != 0)
5050 else if ((flags
& BSF_OBJECT
) != 0)
5055 /* Processor-specific types */
5056 if (type_ptr
!= NULL
5057 && bed
->elf_backend_get_symbol_type
)
5058 type
= ((*bed
->elf_backend_get_symbol_type
)
5059 (&type_ptr
->internal_elf_sym
, type
));
5061 if (flags
& BSF_SECTION_SYM
)
5063 if (flags
& BSF_GLOBAL
)
5064 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5066 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5068 else if (bfd_is_com_section (syms
[idx
]->section
))
5069 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5070 else if (bfd_is_und_section (syms
[idx
]->section
))
5071 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5075 else if (flags
& BSF_FILE
)
5076 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5079 int bind
= STB_LOCAL
;
5081 if (flags
& BSF_LOCAL
)
5083 else if (flags
& BSF_WEAK
)
5085 else if (flags
& BSF_GLOBAL
)
5088 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5091 if (type_ptr
!= NULL
)
5092 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5096 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5097 outbound_syms
+= bed
->s
->sizeof_sym
;
5098 if (outbound_shndx
!= NULL
)
5099 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5103 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5104 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5106 symstrtab_hdr
->sh_flags
= 0;
5107 symstrtab_hdr
->sh_addr
= 0;
5108 symstrtab_hdr
->sh_entsize
= 0;
5109 symstrtab_hdr
->sh_link
= 0;
5110 symstrtab_hdr
->sh_info
= 0;
5111 symstrtab_hdr
->sh_addralign
= 1;
5116 /* Return the number of bytes required to hold the symtab vector.
5118 Note that we base it on the count plus 1, since we will null terminate
5119 the vector allocated based on this size. However, the ELF symbol table
5120 always has a dummy entry as symbol #0, so it ends up even. */
5123 _bfd_elf_get_symtab_upper_bound (abfd
)
5128 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5130 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5131 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5133 symtab_size
-= sizeof (asymbol
*);
5139 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
5144 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5146 if (elf_dynsymtab (abfd
) == 0)
5148 bfd_set_error (bfd_error_invalid_operation
);
5152 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5153 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5155 symtab_size
-= sizeof (asymbol
*);
5161 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
5162 bfd
*abfd ATTRIBUTE_UNUSED
;
5165 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5168 /* Canonicalize the relocs. */
5171 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5179 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5181 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
5184 tblptr
= section
->relocation
;
5185 for (i
= 0; i
< section
->reloc_count
; i
++)
5186 *relptr
++ = tblptr
++;
5190 return section
->reloc_count
;
5194 _bfd_elf_get_symtab (abfd
, alocation
)
5196 asymbol
**alocation
;
5198 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5199 long symcount
= bed
->s
->slurp_symbol_table (abfd
, alocation
, false);
5202 bfd_get_symcount (abfd
) = symcount
;
5207 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
5209 asymbol
**alocation
;
5211 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5212 return bed
->s
->slurp_symbol_table (abfd
, alocation
, true);
5215 /* Return the size required for the dynamic reloc entries. Any
5216 section that was actually installed in the BFD, and has type
5217 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5218 considered to be a dynamic reloc section. */
5221 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
5227 if (elf_dynsymtab (abfd
) == 0)
5229 bfd_set_error (bfd_error_invalid_operation
);
5233 ret
= sizeof (arelent
*);
5234 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5235 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5236 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5237 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5238 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5239 * sizeof (arelent
*));
5244 /* Canonicalize the dynamic relocation entries. Note that we return
5245 the dynamic relocations as a single block, although they are
5246 actually associated with particular sections; the interface, which
5247 was designed for SunOS style shared libraries, expects that there
5248 is only one set of dynamic relocs. Any section that was actually
5249 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5250 the dynamic symbol table, is considered to be a dynamic reloc
5254 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
5259 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
5263 if (elf_dynsymtab (abfd
) == 0)
5265 bfd_set_error (bfd_error_invalid_operation
);
5269 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5271 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5273 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5274 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5275 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5280 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
5282 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5284 for (i
= 0; i
< count
; i
++)
5295 /* Read in the version information. */
5298 _bfd_elf_slurp_version_tables (abfd
)
5301 bfd_byte
*contents
= NULL
;
5304 if (elf_dynverdef (abfd
) != 0)
5306 Elf_Internal_Shdr
*hdr
;
5307 Elf_External_Verdef
*everdef
;
5308 Elf_Internal_Verdef
*iverdef
;
5309 Elf_Internal_Verdef
*iverdefarr
;
5310 Elf_Internal_Verdef iverdefmem
;
5312 unsigned int maxidx
;
5314 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5316 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5317 if (contents
== NULL
)
5319 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5320 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5323 /* We know the number of entries in the section but not the maximum
5324 index. Therefore we have to run through all entries and find
5326 everdef
= (Elf_External_Verdef
*) contents
;
5328 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5330 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5332 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5333 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5335 everdef
= ((Elf_External_Verdef
*)
5336 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5339 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5340 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
5341 if (elf_tdata (abfd
)->verdef
== NULL
)
5344 elf_tdata (abfd
)->cverdefs
= maxidx
;
5346 everdef
= (Elf_External_Verdef
*) contents
;
5347 iverdefarr
= elf_tdata (abfd
)->verdef
;
5348 for (i
= 0; i
< hdr
->sh_info
; i
++)
5350 Elf_External_Verdaux
*everdaux
;
5351 Elf_Internal_Verdaux
*iverdaux
;
5354 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5356 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5357 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5359 iverdef
->vd_bfd
= abfd
;
5361 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5362 iverdef
->vd_auxptr
= (Elf_Internal_Verdaux
*) bfd_alloc (abfd
, amt
);
5363 if (iverdef
->vd_auxptr
== NULL
)
5366 everdaux
= ((Elf_External_Verdaux
*)
5367 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5368 iverdaux
= iverdef
->vd_auxptr
;
5369 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5371 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5373 iverdaux
->vda_nodename
=
5374 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5375 iverdaux
->vda_name
);
5376 if (iverdaux
->vda_nodename
== NULL
)
5379 if (j
+ 1 < iverdef
->vd_cnt
)
5380 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5382 iverdaux
->vda_nextptr
= NULL
;
5384 everdaux
= ((Elf_External_Verdaux
*)
5385 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5388 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5390 if (i
+ 1 < hdr
->sh_info
)
5391 iverdef
->vd_nextdef
= iverdef
+ 1;
5393 iverdef
->vd_nextdef
= NULL
;
5395 everdef
= ((Elf_External_Verdef
*)
5396 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5403 if (elf_dynverref (abfd
) != 0)
5405 Elf_Internal_Shdr
*hdr
;
5406 Elf_External_Verneed
*everneed
;
5407 Elf_Internal_Verneed
*iverneed
;
5410 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5412 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5413 elf_tdata (abfd
)->verref
=
5414 (Elf_Internal_Verneed
*) bfd_zalloc (abfd
, amt
);
5415 if (elf_tdata (abfd
)->verref
== NULL
)
5418 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5420 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5421 if (contents
== NULL
)
5423 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5424 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5427 everneed
= (Elf_External_Verneed
*) contents
;
5428 iverneed
= elf_tdata (abfd
)->verref
;
5429 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
5431 Elf_External_Vernaux
*evernaux
;
5432 Elf_Internal_Vernaux
*ivernaux
;
5435 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
5437 iverneed
->vn_bfd
= abfd
;
5439 iverneed
->vn_filename
=
5440 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5442 if (iverneed
->vn_filename
== NULL
)
5445 amt
= iverneed
->vn_cnt
;
5446 amt
*= sizeof (Elf_Internal_Vernaux
);
5447 iverneed
->vn_auxptr
= (Elf_Internal_Vernaux
*) bfd_alloc (abfd
, amt
);
5449 evernaux
= ((Elf_External_Vernaux
*)
5450 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
5451 ivernaux
= iverneed
->vn_auxptr
;
5452 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
5454 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
5456 ivernaux
->vna_nodename
=
5457 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5458 ivernaux
->vna_name
);
5459 if (ivernaux
->vna_nodename
== NULL
)
5462 if (j
+ 1 < iverneed
->vn_cnt
)
5463 ivernaux
->vna_nextptr
= ivernaux
+ 1;
5465 ivernaux
->vna_nextptr
= NULL
;
5467 evernaux
= ((Elf_External_Vernaux
*)
5468 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
5471 if (i
+ 1 < hdr
->sh_info
)
5472 iverneed
->vn_nextref
= iverneed
+ 1;
5474 iverneed
->vn_nextref
= NULL
;
5476 everneed
= ((Elf_External_Verneed
*)
5477 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
5487 if (contents
== NULL
)
5493 _bfd_elf_make_empty_symbol (abfd
)
5496 elf_symbol_type
*newsym
;
5497 bfd_size_type amt
= sizeof (elf_symbol_type
);
5499 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
5504 newsym
->symbol
.the_bfd
= abfd
;
5505 return &newsym
->symbol
;
5510 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
5511 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5515 bfd_symbol_info (symbol
, ret
);
5518 /* Return whether a symbol name implies a local symbol. Most targets
5519 use this function for the is_local_label_name entry point, but some
5523 _bfd_elf_is_local_label_name (abfd
, name
)
5524 bfd
*abfd ATTRIBUTE_UNUSED
;
5527 /* Normal local symbols start with ``.L''. */
5528 if (name
[0] == '.' && name
[1] == 'L')
5531 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5532 DWARF debugging symbols starting with ``..''. */
5533 if (name
[0] == '.' && name
[1] == '.')
5536 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5537 emitting DWARF debugging output. I suspect this is actually a
5538 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5539 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5540 underscore to be emitted on some ELF targets). For ease of use,
5541 we treat such symbols as local. */
5542 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
5549 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
5550 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5551 asymbol
*symbol ATTRIBUTE_UNUSED
;
5558 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
5560 enum bfd_architecture arch
;
5561 unsigned long machine
;
5563 /* If this isn't the right architecture for this backend, and this
5564 isn't the generic backend, fail. */
5565 if (arch
!= get_elf_backend_data (abfd
)->arch
5566 && arch
!= bfd_arch_unknown
5567 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
5570 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5573 /* Find the function to a particular section and offset,
5574 for error reporting. */
5577 elf_find_function (abfd
, section
, symbols
, offset
,
5578 filename_ptr
, functionname_ptr
)
5579 bfd
*abfd ATTRIBUTE_UNUSED
;
5583 const char **filename_ptr
;
5584 const char **functionname_ptr
;
5586 const char *filename
;
5595 for (p
= symbols
; *p
!= NULL
; p
++)
5599 q
= (elf_symbol_type
*) *p
;
5601 if (bfd_get_section (&q
->symbol
) != section
)
5604 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
5609 filename
= bfd_asymbol_name (&q
->symbol
);
5613 if (q
->symbol
.section
== section
5614 && q
->symbol
.value
>= low_func
5615 && q
->symbol
.value
<= offset
)
5617 func
= (asymbol
*) q
;
5618 low_func
= q
->symbol
.value
;
5628 *filename_ptr
= filename
;
5629 if (functionname_ptr
)
5630 *functionname_ptr
= bfd_asymbol_name (func
);
5635 /* Find the nearest line to a particular section and offset,
5636 for error reporting. */
5639 _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
5640 filename_ptr
, functionname_ptr
, line_ptr
)
5645 const char **filename_ptr
;
5646 const char **functionname_ptr
;
5647 unsigned int *line_ptr
;
5651 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
5652 filename_ptr
, functionname_ptr
,
5655 if (!*functionname_ptr
)
5656 elf_find_function (abfd
, section
, symbols
, offset
,
5657 *filename_ptr
? NULL
: filename_ptr
,
5663 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
5664 filename_ptr
, functionname_ptr
,
5666 &elf_tdata (abfd
)->dwarf2_find_line_info
))
5668 if (!*functionname_ptr
)
5669 elf_find_function (abfd
, section
, symbols
, offset
,
5670 *filename_ptr
? NULL
: filename_ptr
,
5676 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
5677 &found
, filename_ptr
,
5678 functionname_ptr
, line_ptr
,
5679 &elf_tdata (abfd
)->line_info
))
5684 if (symbols
== NULL
)
5687 if (! elf_find_function (abfd
, section
, symbols
, offset
,
5688 filename_ptr
, functionname_ptr
))
5696 _bfd_elf_sizeof_headers (abfd
, reloc
)
5702 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
5704 ret
+= get_program_header_size (abfd
);
5709 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
5714 bfd_size_type count
;
5716 Elf_Internal_Shdr
*hdr
;
5719 if (! abfd
->output_has_begun
5720 && ! _bfd_elf_compute_section_file_positions
5721 (abfd
, (struct bfd_link_info
*) NULL
))
5724 hdr
= &elf_section_data (section
)->this_hdr
;
5725 pos
= hdr
->sh_offset
+ offset
;
5726 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
5727 || bfd_bwrite (location
, count
, abfd
) != count
)
5734 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
5735 bfd
*abfd ATTRIBUTE_UNUSED
;
5736 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
5737 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
5744 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
5747 Elf_Internal_Rel
*dst
;
5753 /* Try to convert a non-ELF reloc into an ELF one. */
5756 _bfd_elf_validate_reloc (abfd
, areloc
)
5760 /* Check whether we really have an ELF howto. */
5762 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
5764 bfd_reloc_code_real_type code
;
5765 reloc_howto_type
*howto
;
5767 /* Alien reloc: Try to determine its type to replace it with an
5768 equivalent ELF reloc. */
5770 if (areloc
->howto
->pc_relative
)
5772 switch (areloc
->howto
->bitsize
)
5775 code
= BFD_RELOC_8_PCREL
;
5778 code
= BFD_RELOC_12_PCREL
;
5781 code
= BFD_RELOC_16_PCREL
;
5784 code
= BFD_RELOC_24_PCREL
;
5787 code
= BFD_RELOC_32_PCREL
;
5790 code
= BFD_RELOC_64_PCREL
;
5796 howto
= bfd_reloc_type_lookup (abfd
, code
);
5798 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
5800 if (howto
->pcrel_offset
)
5801 areloc
->addend
+= areloc
->address
;
5803 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
5808 switch (areloc
->howto
->bitsize
)
5814 code
= BFD_RELOC_14
;
5817 code
= BFD_RELOC_16
;
5820 code
= BFD_RELOC_26
;
5823 code
= BFD_RELOC_32
;
5826 code
= BFD_RELOC_64
;
5832 howto
= bfd_reloc_type_lookup (abfd
, code
);
5836 areloc
->howto
= howto
;
5844 (*_bfd_error_handler
)
5845 (_("%s: unsupported relocation type %s"),
5846 bfd_archive_filename (abfd
), areloc
->howto
->name
);
5847 bfd_set_error (bfd_error_bad_value
);
5852 _bfd_elf_close_and_cleanup (abfd
)
5855 if (bfd_get_format (abfd
) == bfd_object
)
5857 if (elf_shstrtab (abfd
) != NULL
)
5858 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
5861 return _bfd_generic_close_and_cleanup (abfd
);
5864 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5865 in the relocation's offset. Thus we cannot allow any sort of sanity
5866 range-checking to interfere. There is nothing else to do in processing
5869 bfd_reloc_status_type
5870 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
5871 bfd
*abfd ATTRIBUTE_UNUSED
;
5872 arelent
*re ATTRIBUTE_UNUSED
;
5873 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
5874 PTR data ATTRIBUTE_UNUSED
;
5875 asection
*is ATTRIBUTE_UNUSED
;
5876 bfd
*obfd ATTRIBUTE_UNUSED
;
5877 char **errmsg ATTRIBUTE_UNUSED
;
5879 return bfd_reloc_ok
;
5882 /* Elf core file support. Much of this only works on native
5883 toolchains, since we rely on knowing the
5884 machine-dependent procfs structure in order to pick
5885 out details about the corefile. */
5887 #ifdef HAVE_SYS_PROCFS_H
5888 # include <sys/procfs.h>
5891 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5894 elfcore_make_pid (abfd
)
5897 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
5898 + (elf_tdata (abfd
)->core_pid
));
5901 /* If there isn't a section called NAME, make one, using
5902 data from SECT. Note, this function will generate a
5903 reference to NAME, so you shouldn't deallocate or
5907 elfcore_maybe_make_sect (abfd
, name
, sect
)
5914 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
5917 sect2
= bfd_make_section (abfd
, name
);
5921 sect2
->_raw_size
= sect
->_raw_size
;
5922 sect2
->filepos
= sect
->filepos
;
5923 sect2
->flags
= sect
->flags
;
5924 sect2
->alignment_power
= sect
->alignment_power
;
5928 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
5929 actually creates up to two pseudosections:
5930 - For the single-threaded case, a section named NAME, unless
5931 such a section already exists.
5932 - For the multi-threaded case, a section named "NAME/PID", where
5933 PID is elfcore_make_pid (abfd).
5934 Both pseudosections have identical contents. */
5936 _bfd_elfcore_make_pseudosection (abfd
, name
, size
, filepos
)
5943 char *threaded_name
;
5946 /* Build the section name. */
5948 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
5949 threaded_name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
5950 if (threaded_name
== NULL
)
5952 strcpy (threaded_name
, buf
);
5954 sect
= bfd_make_section (abfd
, threaded_name
);
5957 sect
->_raw_size
= size
;
5958 sect
->filepos
= filepos
;
5959 sect
->flags
= SEC_HAS_CONTENTS
;
5960 sect
->alignment_power
= 2;
5962 return elfcore_maybe_make_sect (abfd
, name
, sect
);
5965 /* prstatus_t exists on:
5967 linux 2.[01] + glibc
5971 #if defined (HAVE_PRSTATUS_T)
5972 static boolean elfcore_grok_prstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
5975 elfcore_grok_prstatus (abfd
, note
)
5977 Elf_Internal_Note
*note
;
5982 if (note
->descsz
== sizeof (prstatus_t
))
5986 raw_size
= sizeof (prstat
.pr_reg
);
5987 offset
= offsetof (prstatus_t
, pr_reg
);
5988 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5990 /* Do not overwrite the core signal if it
5991 has already been set by another thread. */
5992 if (elf_tdata (abfd
)->core_signal
== 0)
5993 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5994 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5996 /* pr_who exists on:
5999 pr_who doesn't exist on:
6002 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6003 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6006 #if defined (HAVE_PRSTATUS32_T)
6007 else if (note
->descsz
== sizeof (prstatus32_t
))
6009 /* 64-bit host, 32-bit corefile */
6010 prstatus32_t prstat
;
6012 raw_size
= sizeof (prstat
.pr_reg
);
6013 offset
= offsetof (prstatus32_t
, pr_reg
);
6014 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6016 /* Do not overwrite the core signal if it
6017 has already been set by another thread. */
6018 if (elf_tdata (abfd
)->core_signal
== 0)
6019 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6020 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6022 /* pr_who exists on:
6025 pr_who doesn't exist on:
6028 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6029 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6032 #endif /* HAVE_PRSTATUS32_T */
6035 /* Fail - we don't know how to handle any other
6036 note size (ie. data object type). */
6040 /* Make a ".reg/999" section and a ".reg" section. */
6041 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6042 raw_size
, note
->descpos
+ offset
);
6044 #endif /* defined (HAVE_PRSTATUS_T) */
6046 /* Create a pseudosection containing the exact contents of NOTE. */
6048 elfcore_make_note_pseudosection (abfd
, name
, note
)
6051 Elf_Internal_Note
*note
;
6053 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6054 note
->descsz
, note
->descpos
);
6057 /* There isn't a consistent prfpregset_t across platforms,
6058 but it doesn't matter, because we don't have to pick this
6059 data structure apart. */
6062 elfcore_grok_prfpreg (abfd
, note
)
6064 Elf_Internal_Note
*note
;
6066 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6069 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6070 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6074 elfcore_grok_prxfpreg (abfd
, note
)
6076 Elf_Internal_Note
*note
;
6078 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6081 #if defined (HAVE_PRPSINFO_T)
6082 typedef prpsinfo_t elfcore_psinfo_t
;
6083 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6084 typedef prpsinfo32_t elfcore_psinfo32_t
;
6088 #if defined (HAVE_PSINFO_T)
6089 typedef psinfo_t elfcore_psinfo_t
;
6090 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6091 typedef psinfo32_t elfcore_psinfo32_t
;
6095 /* return a malloc'ed copy of a string at START which is at
6096 most MAX bytes long, possibly without a terminating '\0'.
6097 the copy will always have a terminating '\0'. */
6100 _bfd_elfcore_strndup (abfd
, start
, max
)
6106 char *end
= memchr (start
, '\0', max
);
6114 dups
= bfd_alloc (abfd
, (bfd_size_type
) len
+ 1);
6118 memcpy (dups
, start
, len
);
6124 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6125 static boolean elfcore_grok_psinfo
PARAMS ((bfd
*, Elf_Internal_Note
*));
6128 elfcore_grok_psinfo (abfd
, note
)
6130 Elf_Internal_Note
*note
;
6132 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6134 elfcore_psinfo_t psinfo
;
6136 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6138 elf_tdata (abfd
)->core_program
6139 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6140 sizeof (psinfo
.pr_fname
));
6142 elf_tdata (abfd
)->core_command
6143 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6144 sizeof (psinfo
.pr_psargs
));
6146 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6147 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6149 /* 64-bit host, 32-bit corefile */
6150 elfcore_psinfo32_t psinfo
;
6152 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6154 elf_tdata (abfd
)->core_program
6155 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6156 sizeof (psinfo
.pr_fname
));
6158 elf_tdata (abfd
)->core_command
6159 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6160 sizeof (psinfo
.pr_psargs
));
6166 /* Fail - we don't know how to handle any other
6167 note size (ie. data object type). */
6171 /* Note that for some reason, a spurious space is tacked
6172 onto the end of the args in some (at least one anyway)
6173 implementations, so strip it off if it exists. */
6176 char *command
= elf_tdata (abfd
)->core_command
;
6177 int n
= strlen (command
);
6179 if (0 < n
&& command
[n
- 1] == ' ')
6180 command
[n
- 1] = '\0';
6185 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6187 #if defined (HAVE_PSTATUS_T)
6188 static boolean elfcore_grok_pstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
6191 elfcore_grok_pstatus (abfd
, note
)
6193 Elf_Internal_Note
*note
;
6195 if (note
->descsz
== sizeof (pstatus_t
)
6196 #if defined (HAVE_PXSTATUS_T)
6197 || note
->descsz
== sizeof (pxstatus_t
)
6203 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6205 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6207 #if defined (HAVE_PSTATUS32_T)
6208 else if (note
->descsz
== sizeof (pstatus32_t
))
6210 /* 64-bit host, 32-bit corefile */
6213 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6215 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6218 /* Could grab some more details from the "representative"
6219 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6220 NT_LWPSTATUS note, presumably. */
6224 #endif /* defined (HAVE_PSTATUS_T) */
6226 #if defined (HAVE_LWPSTATUS_T)
6227 static boolean elfcore_grok_lwpstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
6230 elfcore_grok_lwpstatus (abfd
, note
)
6232 Elf_Internal_Note
*note
;
6234 lwpstatus_t lwpstat
;
6239 if (note
->descsz
!= sizeof (lwpstat
)
6240 #if defined (HAVE_LWPXSTATUS_T)
6241 && note
->descsz
!= sizeof (lwpxstatus_t
)
6246 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6248 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6249 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6251 /* Make a ".reg/999" section. */
6253 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6254 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6259 sect
= bfd_make_section (abfd
, name
);
6263 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6264 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6265 sect
->filepos
= note
->descpos
6266 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6269 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6270 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
6271 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6274 sect
->flags
= SEC_HAS_CONTENTS
;
6275 sect
->alignment_power
= 2;
6277 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6280 /* Make a ".reg2/999" section */
6282 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6283 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6288 sect
= bfd_make_section (abfd
, name
);
6292 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6293 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6294 sect
->filepos
= note
->descpos
6295 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6298 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6299 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
6300 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6303 sect
->flags
= SEC_HAS_CONTENTS
;
6304 sect
->alignment_power
= 2;
6306 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6308 #endif /* defined (HAVE_LWPSTATUS_T) */
6310 #if defined (HAVE_WIN32_PSTATUS_T)
6312 elfcore_grok_win32pstatus (abfd
, note
)
6314 Elf_Internal_Note
*note
;
6319 win32_pstatus_t pstatus
;
6321 if (note
->descsz
< sizeof (pstatus
))
6324 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6326 switch (pstatus
.data_type
)
6328 case NOTE_INFO_PROCESS
:
6329 /* FIXME: need to add ->core_command. */
6330 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6331 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6334 case NOTE_INFO_THREAD
:
6335 /* Make a ".reg/999" section. */
6336 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6338 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6344 sect
= bfd_make_section (abfd
, name
);
6348 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6349 sect
->filepos
= (note
->descpos
6350 + offsetof (struct win32_pstatus
,
6351 data
.thread_info
.thread_context
));
6352 sect
->flags
= SEC_HAS_CONTENTS
;
6353 sect
->alignment_power
= 2;
6355 if (pstatus
.data
.thread_info
.is_active_thread
)
6356 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6360 case NOTE_INFO_MODULE
:
6361 /* Make a ".module/xxxxxxxx" section. */
6362 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6364 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6370 sect
= bfd_make_section (abfd
, name
);
6375 sect
->_raw_size
= note
->descsz
;
6376 sect
->filepos
= note
->descpos
;
6377 sect
->flags
= SEC_HAS_CONTENTS
;
6378 sect
->alignment_power
= 2;
6387 #endif /* HAVE_WIN32_PSTATUS_T */
6390 elfcore_grok_note (abfd
, note
)
6392 Elf_Internal_Note
*note
;
6394 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6402 if (bed
->elf_backend_grok_prstatus
)
6403 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6405 #if defined (HAVE_PRSTATUS_T)
6406 return elfcore_grok_prstatus (abfd
, note
);
6411 #if defined (HAVE_PSTATUS_T)
6413 return elfcore_grok_pstatus (abfd
, note
);
6416 #if defined (HAVE_LWPSTATUS_T)
6418 return elfcore_grok_lwpstatus (abfd
, note
);
6421 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6422 return elfcore_grok_prfpreg (abfd
, note
);
6424 #if defined (HAVE_WIN32_PSTATUS_T)
6425 case NT_WIN32PSTATUS
:
6426 return elfcore_grok_win32pstatus (abfd
, note
);
6429 case NT_PRXFPREG
: /* Linux SSE extension */
6430 if (note
->namesz
== 5
6431 && ! strcmp (note
->namedata
, "LINUX"))
6432 return elfcore_grok_prxfpreg (abfd
, note
);
6438 if (bed
->elf_backend_grok_psinfo
)
6439 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6441 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6442 return elfcore_grok_psinfo (abfd
, note
);
6450 elfcore_netbsd_get_lwpid (note
, lwpidp
)
6451 Elf_Internal_Note
*note
;
6456 cp
= strchr (note
->namedata
, '@');
6459 *lwpidp
= atoi(cp
+ 1);
6466 elfcore_grok_netbsd_procinfo (abfd
, note
)
6468 Elf_Internal_Note
*note
;
6471 /* Signal number at offset 0x08. */
6472 elf_tdata (abfd
)->core_signal
6473 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
6475 /* Process ID at offset 0x50. */
6476 elf_tdata (abfd
)->core_pid
6477 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
6479 /* Command name at 0x7c (max 32 bytes, including nul). */
6480 elf_tdata (abfd
)->core_command
6481 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
6487 elfcore_grok_netbsd_note (abfd
, note
)
6489 Elf_Internal_Note
*note
;
6493 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
6494 elf_tdata (abfd
)->core_lwpid
= lwp
;
6496 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
6498 /* NetBSD-specific core "procinfo". Note that we expect to
6499 find this note before any of the others, which is fine,
6500 since the kernel writes this note out first when it
6501 creates a core file. */
6503 return elfcore_grok_netbsd_procinfo (abfd
, note
);
6506 /* As of Jan 2002 there are no other machine-independent notes
6507 defined for NetBSD core files. If the note type is less
6508 than the start of the machine-dependent note types, we don't
6511 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
6515 switch (bfd_get_arch (abfd
))
6517 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6518 PT_GETFPREGS == mach+2. */
6520 case bfd_arch_alpha
:
6521 case bfd_arch_sparc
:
6524 case NT_NETBSDCORE_FIRSTMACH
+0:
6525 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6527 case NT_NETBSDCORE_FIRSTMACH
+2:
6528 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6534 /* On all other arch's, PT_GETREGS == mach+1 and
6535 PT_GETFPREGS == mach+3. */
6540 case NT_NETBSDCORE_FIRSTMACH
+1:
6541 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6543 case NT_NETBSDCORE_FIRSTMACH
+3:
6544 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6553 /* Function: elfcore_write_note
6560 size of data for note
6563 End of buffer containing note. */
6566 elfcore_write_note (abfd
, buf
, bufsiz
, name
, type
, input
, size
)
6575 Elf_External_Note
*xnp
;
6576 int namesz
= strlen (name
);
6577 int newspace
= BFD_ALIGN (sizeof (Elf_External_Note
) + size
+ namesz
- 1, 4);
6580 p
= realloc (buf
, *bufsiz
+ newspace
);
6582 *bufsiz
+= newspace
;
6583 xnp
= (Elf_External_Note
*) dest
;
6584 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
6585 H_PUT_32 (abfd
, size
, xnp
->descsz
);
6586 H_PUT_32 (abfd
, type
, xnp
->type
);
6587 strcpy (xnp
->name
, name
);
6588 memcpy (xnp
->name
+ BFD_ALIGN (namesz
, 4), input
, size
);
6592 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6594 elfcore_write_prpsinfo (abfd
, buf
, bufsiz
, fname
, psargs
)
6602 char *note_name
= "CORE";
6604 #if defined (HAVE_PSINFO_T)
6606 note_type
= NT_PSINFO
;
6609 note_type
= NT_PRPSINFO
;
6612 memset (&data
, 0, sizeof (data
));
6613 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
6614 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
6615 return elfcore_write_note (abfd
, buf
, bufsiz
,
6616 note_name
, note_type
, &data
, sizeof (data
));
6618 #endif /* PSINFO_T or PRPSINFO_T */
6620 #if defined (HAVE_PRSTATUS_T)
6622 elfcore_write_prstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6631 char *note_name
= "CORE";
6633 memset (&prstat
, 0, sizeof (prstat
));
6634 prstat
.pr_pid
= pid
;
6635 prstat
.pr_cursig
= cursig
;
6636 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
6637 return elfcore_write_note (abfd
, buf
, bufsiz
,
6638 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
6640 #endif /* HAVE_PRSTATUS_T */
6642 #if defined (HAVE_LWPSTATUS_T)
6644 elfcore_write_lwpstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6652 lwpstatus_t lwpstat
;
6653 char *note_name
= "CORE";
6655 memset (&lwpstat
, 0, sizeof (lwpstat
));
6656 lwpstat
.pr_lwpid
= pid
>> 16;
6657 lwpstat
.pr_cursig
= cursig
;
6658 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6659 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
6660 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6662 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
6663 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
6665 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
6666 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
6669 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
6670 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
6672 #endif /* HAVE_LWPSTATUS_T */
6674 #if defined (HAVE_PSTATUS_T)
6676 elfcore_write_pstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6685 char *note_name
= "CORE";
6687 memset (&pstat
, 0, sizeof (pstat
));
6688 pstat
.pr_pid
= pid
& 0xffff;
6689 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
6690 NT_PSTATUS
, &pstat
, sizeof (pstat
));
6693 #endif /* HAVE_PSTATUS_T */
6696 elfcore_write_prfpreg (abfd
, buf
, bufsiz
, fpregs
, size
)
6703 char *note_name
= "CORE";
6704 return elfcore_write_note (abfd
, buf
, bufsiz
,
6705 note_name
, NT_FPREGSET
, fpregs
, size
);
6709 elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, xfpregs
, size
)
6716 char *note_name
= "LINUX";
6717 return elfcore_write_note (abfd
, buf
, bufsiz
,
6718 note_name
, NT_PRXFPREG
, xfpregs
, size
);
6722 elfcore_read_notes (abfd
, offset
, size
)
6733 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
6736 buf
= bfd_malloc (size
);
6740 if (bfd_bread (buf
, size
, abfd
) != size
)
6748 while (p
< buf
+ size
)
6750 /* FIXME: bad alignment assumption. */
6751 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
6752 Elf_Internal_Note in
;
6754 in
.type
= H_GET_32 (abfd
, xnp
->type
);
6756 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
6757 in
.namedata
= xnp
->name
;
6759 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
6760 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
6761 in
.descpos
= offset
+ (in
.descdata
- buf
);
6763 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
6765 if (! elfcore_grok_netbsd_note (abfd
, &in
))
6770 if (! elfcore_grok_note (abfd
, &in
))
6774 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
6781 /* Providing external access to the ELF program header table. */
6783 /* Return an upper bound on the number of bytes required to store a
6784 copy of ABFD's program header table entries. Return -1 if an error
6785 occurs; bfd_get_error will return an appropriate code. */
6788 bfd_get_elf_phdr_upper_bound (abfd
)
6791 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6793 bfd_set_error (bfd_error_wrong_format
);
6797 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
6800 /* Copy ABFD's program header table entries to *PHDRS. The entries
6801 will be stored as an array of Elf_Internal_Phdr structures, as
6802 defined in include/elf/internal.h. To find out how large the
6803 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
6805 Return the number of program header table entries read, or -1 if an
6806 error occurs; bfd_get_error will return an appropriate code. */
6809 bfd_get_elf_phdrs (abfd
, phdrs
)
6815 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6817 bfd_set_error (bfd_error_wrong_format
);
6821 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
6822 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
6823 num_phdrs
* sizeof (Elf_Internal_Phdr
));
6829 _bfd_elf_sprintf_vma (abfd
, buf
, value
)
6830 bfd
*abfd ATTRIBUTE_UNUSED
;
6835 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
6837 i_ehdrp
= elf_elfheader (abfd
);
6838 if (i_ehdrp
== NULL
)
6839 sprintf_vma (buf
, value
);
6842 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
6844 #if BFD_HOST_64BIT_LONG
6845 sprintf (buf
, "%016lx", value
);
6847 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
6848 _bfd_int64_low (value
));
6852 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
6855 sprintf_vma (buf
, value
);
6860 _bfd_elf_fprintf_vma (abfd
, stream
, value
)
6861 bfd
*abfd ATTRIBUTE_UNUSED
;
6866 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
6868 i_ehdrp
= elf_elfheader (abfd
);
6869 if (i_ehdrp
== NULL
)
6870 fprintf_vma ((FILE *) stream
, value
);
6873 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
6875 #if BFD_HOST_64BIT_LONG
6876 fprintf ((FILE *) stream
, "%016lx", value
);
6878 fprintf ((FILE *) stream
, "%08lx%08lx",
6879 _bfd_int64_high (value
), _bfd_int64_low (value
));
6883 fprintf ((FILE *) stream
, "%08lx",
6884 (unsigned long) (value
& 0xffffffff));
6887 fprintf_vma ((FILE *) stream
, value
);
6891 enum elf_reloc_type_class
6892 _bfd_elf_reloc_type_class (rela
)
6893 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
;
6895 return reloc_class_normal
;
6898 /* For RELA architectures, return what the relocation value for
6899 relocation against a local symbol. */
6902 _bfd_elf_rela_local_sym (abfd
, sym
, sec
, rel
)
6904 Elf_Internal_Sym
*sym
;
6906 Elf_Internal_Rela
*rel
;
6910 relocation
= (sec
->output_section
->vma
6911 + sec
->output_offset
6913 if ((sec
->flags
& SEC_MERGE
)
6914 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
6915 && elf_section_data (sec
)->sec_info_type
== ELF_INFO_TYPE_MERGE
)
6921 _bfd_merged_section_offset (abfd
, &msec
,
6922 elf_section_data (sec
)->sec_info
,
6923 sym
->st_value
+ rel
->r_addend
,
6926 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
6932 _bfd_elf_rel_local_sym (abfd
, sym
, psec
, addend
)
6934 Elf_Internal_Sym
*sym
;
6938 asection
*sec
= *psec
;
6940 if (elf_section_data (sec
)->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
6941 return sym
->st_value
+ addend
;
6943 return _bfd_merged_section_offset (abfd
, psec
,
6944 elf_section_data (sec
)->sec_info
,
6945 sym
->st_value
+ addend
, (bfd_vma
) 0);
6949 _bfd_elf_section_offset (abfd
, info
, sec
, offset
)
6951 struct bfd_link_info
*info
;
6955 struct bfd_elf_section_data
*sec_data
;
6957 sec_data
= elf_section_data (sec
);
6958 switch (sec_data
->sec_info_type
)
6960 case ELF_INFO_TYPE_STABS
:
6961 return _bfd_stab_section_offset
6962 (abfd
, &elf_hash_table (info
)->merge_info
, sec
, &sec_data
->sec_info
,
6964 case ELF_INFO_TYPE_EH_FRAME
:
6965 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);