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 || (phdr
->p_offset
+ phdr
->p_filesz
669 >= hdr
->sh_offset
+ hdr
->sh_size
)))
671 if ((flags
& SEC_LOAD
) == 0)
672 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
674 /* We used to use the same adjustment for SEC_LOAD
675 sections, but that doesn't work if the segment
676 is packed with code from multiple VMAs.
677 Instead we calculate the section LMA based on
678 the segment LMA. It is assumed that the
679 segment will contain sections with contiguous
680 LMAs, even if the VMAs are not. */
681 newsect
->lma
= (phdr
->p_paddr
682 + hdr
->sh_offset
- phdr
->p_offset
);
689 hdr
->bfd_section
= newsect
;
690 elf_section_data (newsect
)->this_hdr
= *hdr
;
700 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
703 Helper functions for GDB to locate the string tables.
704 Since BFD hides string tables from callers, GDB needs to use an
705 internal hook to find them. Sun's .stabstr, in particular,
706 isn't even pointed to by the .stab section, so ordinary
707 mechanisms wouldn't work to find it, even if we had some.
710 struct elf_internal_shdr
*
711 bfd_elf_find_section (abfd
, name
)
715 Elf_Internal_Shdr
**i_shdrp
;
720 i_shdrp
= elf_elfsections (abfd
);
723 shstrtab
= bfd_elf_get_str_section (abfd
,
724 elf_elfheader (abfd
)->e_shstrndx
);
725 if (shstrtab
!= NULL
)
727 max
= elf_numsections (abfd
);
728 for (i
= 1; i
< max
; i
++)
729 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
736 const char *const bfd_elf_section_type_names
[] = {
737 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
738 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
739 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
742 /* ELF relocs are against symbols. If we are producing relocateable
743 output, and the reloc is against an external symbol, and nothing
744 has given us any additional addend, the resulting reloc will also
745 be against the same symbol. In such a case, we don't want to
746 change anything about the way the reloc is handled, since it will
747 all be done at final link time. Rather than put special case code
748 into bfd_perform_relocation, all the reloc types use this howto
749 function. It just short circuits the reloc if producing
750 relocateable output against an external symbol. */
752 bfd_reloc_status_type
753 bfd_elf_generic_reloc (abfd
,
760 bfd
*abfd ATTRIBUTE_UNUSED
;
761 arelent
*reloc_entry
;
763 PTR data ATTRIBUTE_UNUSED
;
764 asection
*input_section
;
766 char **error_message ATTRIBUTE_UNUSED
;
768 if (output_bfd
!= (bfd
*) NULL
769 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
770 && (! reloc_entry
->howto
->partial_inplace
771 || reloc_entry
->addend
== 0))
773 reloc_entry
->address
+= input_section
->output_offset
;
777 return bfd_reloc_continue
;
780 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
783 merge_sections_remove_hook (abfd
, sec
)
784 bfd
*abfd ATTRIBUTE_UNUSED
;
787 struct bfd_elf_section_data
*sec_data
;
789 sec_data
= elf_section_data (sec
);
790 BFD_ASSERT (sec_data
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
791 sec_data
->sec_info_type
= ELF_INFO_TYPE_NONE
;
794 /* Finish SHF_MERGE section merging. */
797 _bfd_elf_merge_sections (abfd
, info
)
799 struct bfd_link_info
*info
;
801 if (!is_elf_hash_table (info
))
803 if (elf_hash_table (info
)->merge_info
)
804 _bfd_merge_sections (abfd
, elf_hash_table (info
)->merge_info
,
805 merge_sections_remove_hook
);
809 /* Copy the program header and other data from one object module to
813 _bfd_elf_copy_private_bfd_data (ibfd
, obfd
)
817 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
818 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
821 BFD_ASSERT (!elf_flags_init (obfd
)
822 || (elf_elfheader (obfd
)->e_flags
823 == elf_elfheader (ibfd
)->e_flags
));
825 elf_gp (obfd
) = elf_gp (ibfd
);
826 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
827 elf_flags_init (obfd
) = true;
831 /* Print out the program headers. */
834 _bfd_elf_print_private_bfd_data (abfd
, farg
)
838 FILE *f
= (FILE *) farg
;
839 Elf_Internal_Phdr
*p
;
841 bfd_byte
*dynbuf
= NULL
;
843 p
= elf_tdata (abfd
)->phdr
;
848 fprintf (f
, _("\nProgram Header:\n"));
849 c
= elf_elfheader (abfd
)->e_phnum
;
850 for (i
= 0; i
< c
; i
++, p
++)
857 case PT_NULL
: pt
= "NULL"; break;
858 case PT_LOAD
: pt
= "LOAD"; break;
859 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
860 case PT_INTERP
: pt
= "INTERP"; break;
861 case PT_NOTE
: pt
= "NOTE"; break;
862 case PT_SHLIB
: pt
= "SHLIB"; break;
863 case PT_PHDR
: pt
= "PHDR"; break;
864 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
865 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
867 fprintf (f
, "%8s off 0x", pt
);
868 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
869 fprintf (f
, " vaddr 0x");
870 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
871 fprintf (f
, " paddr 0x");
872 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
873 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
874 fprintf (f
, " filesz 0x");
875 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
876 fprintf (f
, " memsz 0x");
877 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
878 fprintf (f
, " flags %c%c%c",
879 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
880 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
881 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
882 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
883 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
888 s
= bfd_get_section_by_name (abfd
, ".dynamic");
892 unsigned long shlink
;
893 bfd_byte
*extdyn
, *extdynend
;
895 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
897 fprintf (f
, _("\nDynamic Section:\n"));
899 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
902 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
906 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
909 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
911 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
912 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
915 extdynend
= extdyn
+ s
->_raw_size
;
916 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
918 Elf_Internal_Dyn dyn
;
923 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
925 if (dyn
.d_tag
== DT_NULL
)
932 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
936 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
937 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
938 case DT_PLTGOT
: name
= "PLTGOT"; break;
939 case DT_HASH
: name
= "HASH"; break;
940 case DT_STRTAB
: name
= "STRTAB"; break;
941 case DT_SYMTAB
: name
= "SYMTAB"; break;
942 case DT_RELA
: name
= "RELA"; break;
943 case DT_RELASZ
: name
= "RELASZ"; break;
944 case DT_RELAENT
: name
= "RELAENT"; break;
945 case DT_STRSZ
: name
= "STRSZ"; break;
946 case DT_SYMENT
: name
= "SYMENT"; break;
947 case DT_INIT
: name
= "INIT"; break;
948 case DT_FINI
: name
= "FINI"; break;
949 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
950 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
951 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
952 case DT_REL
: name
= "REL"; break;
953 case DT_RELSZ
: name
= "RELSZ"; break;
954 case DT_RELENT
: name
= "RELENT"; break;
955 case DT_PLTREL
: name
= "PLTREL"; break;
956 case DT_DEBUG
: name
= "DEBUG"; break;
957 case DT_TEXTREL
: name
= "TEXTREL"; break;
958 case DT_JMPREL
: name
= "JMPREL"; break;
959 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
960 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
961 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
962 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
963 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
964 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= true; break;
965 case DT_FLAGS
: name
= "FLAGS"; break;
966 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
967 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
968 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
969 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
970 case DT_MOVEENT
: name
= "MOVEENT"; break;
971 case DT_MOVESZ
: name
= "MOVESZ"; break;
972 case DT_FEATURE
: name
= "FEATURE"; break;
973 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
974 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
975 case DT_SYMINENT
: name
= "SYMINENT"; break;
976 case DT_CONFIG
: name
= "CONFIG"; stringp
= true; break;
977 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= true; break;
978 case DT_AUDIT
: name
= "AUDIT"; stringp
= true; break;
979 case DT_PLTPAD
: name
= "PLTPAD"; break;
980 case DT_MOVETAB
: name
= "MOVETAB"; break;
981 case DT_SYMINFO
: name
= "SYMINFO"; break;
982 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
983 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
984 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
985 case DT_VERSYM
: name
= "VERSYM"; break;
986 case DT_VERDEF
: name
= "VERDEF"; break;
987 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
988 case DT_VERNEED
: name
= "VERNEED"; break;
989 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
990 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
991 case DT_USED
: name
= "USED"; break;
992 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
995 fprintf (f
, " %-11s ", name
);
997 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1001 unsigned int tagv
= dyn
.d_un
.d_val
;
1003 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1006 fprintf (f
, "%s", string
);
1015 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1016 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1018 if (! _bfd_elf_slurp_version_tables (abfd
))
1022 if (elf_dynverdef (abfd
) != 0)
1024 Elf_Internal_Verdef
*t
;
1026 fprintf (f
, _("\nVersion definitions:\n"));
1027 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1029 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1030 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1031 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1033 Elf_Internal_Verdaux
*a
;
1036 for (a
= t
->vd_auxptr
->vda_nextptr
;
1039 fprintf (f
, "%s ", a
->vda_nodename
);
1045 if (elf_dynverref (abfd
) != 0)
1047 Elf_Internal_Verneed
*t
;
1049 fprintf (f
, _("\nVersion References:\n"));
1050 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1052 Elf_Internal_Vernaux
*a
;
1054 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1055 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1056 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1057 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1069 /* Display ELF-specific fields of a symbol. */
1072 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
1076 bfd_print_symbol_type how
;
1078 FILE *file
= (FILE *) filep
;
1081 case bfd_print_symbol_name
:
1082 fprintf (file
, "%s", symbol
->name
);
1084 case bfd_print_symbol_more
:
1085 fprintf (file
, "elf ");
1086 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1087 fprintf (file
, " %lx", (long) symbol
->flags
);
1089 case bfd_print_symbol_all
:
1091 const char *section_name
;
1092 const char *name
= NULL
;
1093 struct elf_backend_data
*bed
;
1094 unsigned char st_other
;
1097 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1099 bed
= get_elf_backend_data (abfd
);
1100 if (bed
->elf_backend_print_symbol_all
)
1101 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1105 name
= symbol
->name
;
1106 bfd_print_symbol_vandf (abfd
, (PTR
) file
, symbol
);
1109 fprintf (file
, " %s\t", section_name
);
1110 /* Print the "other" value for a symbol. For common symbols,
1111 we've already printed the size; now print the alignment.
1112 For other symbols, we have no specified alignment, and
1113 we've printed the address; now print the size. */
1114 if (bfd_is_com_section (symbol
->section
))
1115 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1117 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1118 bfd_fprintf_vma (abfd
, file
, val
);
1120 /* If we have version information, print it. */
1121 if (elf_tdata (abfd
)->dynversym_section
!= 0
1122 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1123 || elf_tdata (abfd
)->dynverref_section
!= 0))
1125 unsigned int vernum
;
1126 const char *version_string
;
1128 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1131 version_string
= "";
1132 else if (vernum
== 1)
1133 version_string
= "Base";
1134 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1136 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1139 Elf_Internal_Verneed
*t
;
1141 version_string
= "";
1142 for (t
= elf_tdata (abfd
)->verref
;
1146 Elf_Internal_Vernaux
*a
;
1148 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1150 if (a
->vna_other
== vernum
)
1152 version_string
= a
->vna_nodename
;
1159 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1160 fprintf (file
, " %-11s", version_string
);
1165 fprintf (file
, " (%s)", version_string
);
1166 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1171 /* If the st_other field is not zero, print it. */
1172 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1177 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1178 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1179 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1181 /* Some other non-defined flags are also present, so print
1183 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1186 fprintf (file
, " %s", name
);
1192 /* Create an entry in an ELF linker hash table. */
1194 struct bfd_hash_entry
*
1195 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
1196 struct bfd_hash_entry
*entry
;
1197 struct bfd_hash_table
*table
;
1200 /* Allocate the structure if it has not already been allocated by a
1204 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1209 /* Call the allocation method of the superclass. */
1210 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1213 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1214 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1216 /* Set local fields. */
1220 ret
->dynstr_index
= 0;
1221 ret
->weakdef
= NULL
;
1222 ret
->got
.refcount
= htab
->init_refcount
;
1223 ret
->plt
.refcount
= htab
->init_refcount
;
1224 ret
->linker_section_pointer
= NULL
;
1225 ret
->verinfo
.verdef
= NULL
;
1226 ret
->vtable_entries_used
= NULL
;
1227 ret
->vtable_entries_size
= 0;
1228 ret
->vtable_parent
= NULL
;
1229 ret
->type
= STT_NOTYPE
;
1231 /* Assume that we have been called by a non-ELF symbol reader.
1232 This flag is then reset by the code which reads an ELF input
1233 file. This ensures that a symbol created by a non-ELF symbol
1234 reader will have the flag set correctly. */
1235 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
1241 /* Copy data from an indirect symbol to its direct symbol, hiding the
1242 old indirect symbol. Also used for copying flags to a weakdef. */
1245 _bfd_elf_link_hash_copy_indirect (dir
, ind
)
1246 struct elf_link_hash_entry
*dir
, *ind
;
1250 /* Copy down any references that we may have already seen to the
1251 symbol which just became indirect. */
1253 dir
->elf_link_hash_flags
|=
1254 (ind
->elf_link_hash_flags
1255 & (ELF_LINK_HASH_REF_DYNAMIC
1256 | ELF_LINK_HASH_REF_REGULAR
1257 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1258 | ELF_LINK_NON_GOT_REF
));
1260 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1263 /* Copy over the global and procedure linkage table refcount entries.
1264 These may have been already set up by a check_relocs routine. */
1265 tmp
= dir
->got
.refcount
;
1268 dir
->got
.refcount
= ind
->got
.refcount
;
1269 ind
->got
.refcount
= tmp
;
1272 BFD_ASSERT (ind
->got
.refcount
<= 0);
1274 tmp
= dir
->plt
.refcount
;
1277 dir
->plt
.refcount
= ind
->plt
.refcount
;
1278 ind
->plt
.refcount
= tmp
;
1281 BFD_ASSERT (ind
->plt
.refcount
<= 0);
1283 if (dir
->dynindx
== -1)
1285 dir
->dynindx
= ind
->dynindx
;
1286 dir
->dynstr_index
= ind
->dynstr_index
;
1288 ind
->dynstr_index
= 0;
1291 BFD_ASSERT (ind
->dynindx
== -1);
1295 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
)
1296 struct bfd_link_info
*info
;
1297 struct elf_link_hash_entry
*h
;
1298 boolean force_local
;
1300 h
->plt
.offset
= (bfd_vma
) -1;
1301 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1304 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
1305 if (h
->dynindx
!= -1)
1308 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1314 /* Initialize an ELF linker hash table. */
1317 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
1318 struct elf_link_hash_table
*table
;
1320 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
1321 struct bfd_hash_table
*,
1326 table
->dynamic_sections_created
= false;
1327 table
->dynobj
= NULL
;
1328 table
->init_refcount
= get_elf_backend_data (abfd
)->can_refcount
- 1;
1329 /* The first dynamic symbol is a dummy. */
1330 table
->dynsymcount
= 1;
1331 table
->dynstr
= NULL
;
1332 table
->bucketcount
= 0;
1333 table
->needed
= NULL
;
1334 table
->runpath
= NULL
;
1336 table
->stab_info
= NULL
;
1337 table
->merge_info
= NULL
;
1338 table
->dynlocal
= NULL
;
1339 ret
= _bfd_link_hash_table_init (& table
->root
, abfd
, newfunc
);
1340 table
->root
.type
= bfd_link_elf_hash_table
;
1345 /* Create an ELF linker hash table. */
1347 struct bfd_link_hash_table
*
1348 _bfd_elf_link_hash_table_create (abfd
)
1351 struct elf_link_hash_table
*ret
;
1352 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1354 ret
= (struct elf_link_hash_table
*) bfd_alloc (abfd
, amt
);
1355 if (ret
== (struct elf_link_hash_table
*) NULL
)
1358 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1360 bfd_release (abfd
, ret
);
1367 /* This is a hook for the ELF emulation code in the generic linker to
1368 tell the backend linker what file name to use for the DT_NEEDED
1369 entry for a dynamic object. The generic linker passes name as an
1370 empty string to indicate that no DT_NEEDED entry should be made. */
1373 bfd_elf_set_dt_needed_name (abfd
, name
)
1377 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1378 && bfd_get_format (abfd
) == bfd_object
)
1379 elf_dt_name (abfd
) = name
;
1383 bfd_elf_set_dt_needed_soname (abfd
, name
)
1387 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1388 && bfd_get_format (abfd
) == bfd_object
)
1389 elf_dt_soname (abfd
) = name
;
1392 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1393 the linker ELF emulation code. */
1395 struct bfd_link_needed_list
*
1396 bfd_elf_get_needed_list (abfd
, info
)
1397 bfd
*abfd ATTRIBUTE_UNUSED
;
1398 struct bfd_link_info
*info
;
1400 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1402 return elf_hash_table (info
)->needed
;
1405 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1406 hook for the linker ELF emulation code. */
1408 struct bfd_link_needed_list
*
1409 bfd_elf_get_runpath_list (abfd
, info
)
1410 bfd
*abfd ATTRIBUTE_UNUSED
;
1411 struct bfd_link_info
*info
;
1413 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1415 return elf_hash_table (info
)->runpath
;
1418 /* Get the name actually used for a dynamic object for a link. This
1419 is the SONAME entry if there is one. Otherwise, it is the string
1420 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1423 bfd_elf_get_dt_soname (abfd
)
1426 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1427 && bfd_get_format (abfd
) == bfd_object
)
1428 return elf_dt_name (abfd
);
1432 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1433 the ELF linker emulation code. */
1436 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
1438 struct bfd_link_needed_list
**pneeded
;
1441 bfd_byte
*dynbuf
= NULL
;
1443 unsigned long shlink
;
1444 bfd_byte
*extdyn
, *extdynend
;
1446 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1450 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1451 || bfd_get_format (abfd
) != bfd_object
)
1454 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1455 if (s
== NULL
|| s
->_raw_size
== 0)
1458 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1462 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1466 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1470 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1472 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1473 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1476 extdynend
= extdyn
+ s
->_raw_size
;
1477 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1479 Elf_Internal_Dyn dyn
;
1481 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1483 if (dyn
.d_tag
== DT_NULL
)
1486 if (dyn
.d_tag
== DT_NEEDED
)
1489 struct bfd_link_needed_list
*l
;
1490 unsigned int tagv
= dyn
.d_un
.d_val
;
1493 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1498 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1519 /* Allocate an ELF string table--force the first byte to be zero. */
1521 struct bfd_strtab_hash
*
1522 _bfd_elf_stringtab_init ()
1524 struct bfd_strtab_hash
*ret
;
1526 ret
= _bfd_stringtab_init ();
1531 loc
= _bfd_stringtab_add (ret
, "", true, false);
1532 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1533 if (loc
== (bfd_size_type
) -1)
1535 _bfd_stringtab_free (ret
);
1542 /* ELF .o/exec file reading */
1544 /* Create a new bfd section from an ELF section header. */
1547 bfd_section_from_shdr (abfd
, shindex
)
1549 unsigned int shindex
;
1551 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1552 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1553 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1556 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1558 switch (hdr
->sh_type
)
1561 /* Inactive section. Throw it away. */
1564 case SHT_PROGBITS
: /* Normal section with contents. */
1565 case SHT_DYNAMIC
: /* Dynamic linking information. */
1566 case SHT_NOBITS
: /* .bss section. */
1567 case SHT_HASH
: /* .hash section. */
1568 case SHT_NOTE
: /* .note section. */
1569 case SHT_INIT_ARRAY
: /* .init_array section. */
1570 case SHT_FINI_ARRAY
: /* .fini_array section. */
1571 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1572 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1574 case SHT_SYMTAB
: /* A symbol table */
1575 if (elf_onesymtab (abfd
) == shindex
)
1578 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1579 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1580 elf_onesymtab (abfd
) = shindex
;
1581 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1582 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1583 abfd
->flags
|= HAS_SYMS
;
1585 /* Sometimes a shared object will map in the symbol table. If
1586 SHF_ALLOC is set, and this is a shared object, then we also
1587 treat this section as a BFD section. We can not base the
1588 decision purely on SHF_ALLOC, because that flag is sometimes
1589 set in a relocateable object file, which would confuse the
1591 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1592 && (abfd
->flags
& DYNAMIC
) != 0
1593 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1598 case SHT_DYNSYM
: /* A dynamic symbol table */
1599 if (elf_dynsymtab (abfd
) == shindex
)
1602 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1603 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1604 elf_dynsymtab (abfd
) = shindex
;
1605 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1606 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1607 abfd
->flags
|= HAS_SYMS
;
1609 /* Besides being a symbol table, we also treat this as a regular
1610 section, so that objcopy can handle it. */
1611 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1613 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1614 if (elf_symtab_shndx (abfd
) == shindex
)
1617 /* Get the associated symbol table. */
1618 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
)
1619 || hdr
->sh_link
!= elf_onesymtab (abfd
))
1622 elf_symtab_shndx (abfd
) = shindex
;
1623 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1624 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1627 case SHT_STRTAB
: /* A string table */
1628 if (hdr
->bfd_section
!= NULL
)
1630 if (ehdr
->e_shstrndx
== shindex
)
1632 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1633 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1637 unsigned int i
, num_sec
;
1639 num_sec
= elf_numsections (abfd
);
1640 for (i
= 1; i
< num_sec
; i
++)
1642 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1643 if (hdr2
->sh_link
== shindex
)
1645 if (! bfd_section_from_shdr (abfd
, i
))
1647 if (elf_onesymtab (abfd
) == i
)
1649 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1650 elf_elfsections (abfd
)[shindex
] =
1651 &elf_tdata (abfd
)->strtab_hdr
;
1654 if (elf_dynsymtab (abfd
) == i
)
1656 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1657 elf_elfsections (abfd
)[shindex
] = hdr
=
1658 &elf_tdata (abfd
)->dynstrtab_hdr
;
1659 /* We also treat this as a regular section, so
1660 that objcopy can handle it. */
1663 #if 0 /* Not handling other string tables specially right now. */
1664 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1665 /* We have a strtab for some random other section. */
1666 newsect
= (asection
*) hdr2
->bfd_section
;
1669 hdr
->bfd_section
= newsect
;
1670 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1672 elf_elfsections (abfd
)[shindex
] = hdr2
;
1678 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1682 /* *These* do a lot of work -- but build no sections! */
1684 asection
*target_sect
;
1685 Elf_Internal_Shdr
*hdr2
;
1686 unsigned int num_sec
= elf_numsections (abfd
);
1688 /* Check for a bogus link to avoid crashing. */
1689 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1690 || hdr
->sh_link
>= num_sec
)
1692 ((*_bfd_error_handler
)
1693 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1694 bfd_archive_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1695 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1698 /* For some incomprehensible reason Oracle distributes
1699 libraries for Solaris in which some of the objects have
1700 bogus sh_link fields. It would be nice if we could just
1701 reject them, but, unfortunately, some people need to use
1702 them. We scan through the section headers; if we find only
1703 one suitable symbol table, we clobber the sh_link to point
1704 to it. I hope this doesn't break anything. */
1705 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1706 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1712 for (scan
= 1; scan
< num_sec
; scan
++)
1714 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1715 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1726 hdr
->sh_link
= found
;
1729 /* Get the symbol table. */
1730 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1731 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1734 /* If this reloc section does not use the main symbol table we
1735 don't treat it as a reloc section. BFD can't adequately
1736 represent such a section, so at least for now, we don't
1737 try. We just present it as a normal section. We also
1738 can't use it as a reloc section if it points to the null
1740 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1741 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1743 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1745 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1746 if (target_sect
== NULL
)
1749 if ((target_sect
->flags
& SEC_RELOC
) == 0
1750 || target_sect
->reloc_count
== 0)
1751 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1755 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1756 amt
= sizeof (*hdr2
);
1757 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
1758 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1761 elf_elfsections (abfd
)[shindex
] = hdr2
;
1762 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1763 target_sect
->flags
|= SEC_RELOC
;
1764 target_sect
->relocation
= NULL
;
1765 target_sect
->rel_filepos
= hdr
->sh_offset
;
1766 /* In the section to which the relocations apply, mark whether
1767 its relocations are of the REL or RELA variety. */
1768 if (hdr
->sh_size
!= 0)
1769 elf_section_data (target_sect
)->use_rela_p
1770 = (hdr
->sh_type
== SHT_RELA
);
1771 abfd
->flags
|= HAS_RELOC
;
1776 case SHT_GNU_verdef
:
1777 elf_dynverdef (abfd
) = shindex
;
1778 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1779 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1782 case SHT_GNU_versym
:
1783 elf_dynversym (abfd
) = shindex
;
1784 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1785 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1788 case SHT_GNU_verneed
:
1789 elf_dynverref (abfd
) = shindex
;
1790 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1791 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1798 /* Make a section for objcopy and relocatable links. */
1799 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1801 if (hdr
->contents
!= NULL
)
1803 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1804 unsigned int n_elt
= hdr
->sh_size
/ 4;
1807 while (--n_elt
!= 0)
1808 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
1809 && elf_next_in_group (s
) != NULL
)
1811 elf_next_in_group (hdr
->bfd_section
) = s
;
1818 /* Check for any processor-specific section types. */
1820 if (bed
->elf_backend_section_from_shdr
)
1821 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1829 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1830 Return SEC for sections that have no elf section, and NULL on error. */
1833 bfd_section_from_r_symndx (abfd
, cache
, sec
, r_symndx
)
1835 struct sym_sec_cache
*cache
;
1837 unsigned long r_symndx
;
1839 unsigned char esym_shndx
[4];
1840 unsigned int isym_shndx
;
1841 Elf_Internal_Shdr
*symtab_hdr
;
1844 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1846 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
1847 return cache
->sec
[ent
];
1849 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1850 pos
= symtab_hdr
->sh_offset
;
1851 if (get_elf_backend_data (abfd
)->s
->sizeof_sym
1852 == sizeof (Elf64_External_Sym
))
1854 pos
+= r_symndx
* sizeof (Elf64_External_Sym
);
1855 pos
+= offsetof (Elf64_External_Sym
, st_shndx
);
1856 amt
= sizeof (((Elf64_External_Sym
*) 0)->st_shndx
);
1860 pos
+= r_symndx
* sizeof (Elf32_External_Sym
);
1861 pos
+= offsetof (Elf32_External_Sym
, st_shndx
);
1862 amt
= sizeof (((Elf32_External_Sym
*) 0)->st_shndx
);
1864 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1865 || bfd_bread ((PTR
) esym_shndx
, amt
, abfd
) != amt
)
1867 isym_shndx
= H_GET_16 (abfd
, esym_shndx
);
1869 if (isym_shndx
== SHN_XINDEX
)
1871 Elf_Internal_Shdr
*shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1872 if (shndx_hdr
->sh_size
!= 0)
1874 pos
= shndx_hdr
->sh_offset
;
1875 pos
+= r_symndx
* sizeof (Elf_External_Sym_Shndx
);
1876 amt
= sizeof (Elf_External_Sym_Shndx
);
1877 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1878 || bfd_bread ((PTR
) esym_shndx
, amt
, abfd
) != amt
)
1880 isym_shndx
= H_GET_32 (abfd
, esym_shndx
);
1884 if (cache
->abfd
!= abfd
)
1886 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1889 cache
->indx
[ent
] = r_symndx
;
1890 cache
->sec
[ent
] = sec
;
1891 if (isym_shndx
< SHN_LORESERVE
|| isym_shndx
> SHN_HIRESERVE
)
1894 s
= bfd_section_from_elf_index (abfd
, isym_shndx
);
1896 cache
->sec
[ent
] = s
;
1898 return cache
->sec
[ent
];
1901 /* Given an ELF section number, retrieve the corresponding BFD
1905 bfd_section_from_elf_index (abfd
, index
)
1909 if (index
>= elf_numsections (abfd
))
1911 return elf_elfsections (abfd
)[index
]->bfd_section
;
1915 _bfd_elf_new_section_hook (abfd
, sec
)
1919 struct bfd_elf_section_data
*sdata
;
1920 bfd_size_type amt
= sizeof (*sdata
);
1922 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, amt
);
1925 sec
->used_by_bfd
= (PTR
) sdata
;
1927 /* Indicate whether or not this section should use RELA relocations. */
1929 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1934 /* Create a new bfd section from an ELF program header.
1936 Since program segments have no names, we generate a synthetic name
1937 of the form segment<NUM>, where NUM is generally the index in the
1938 program header table. For segments that are split (see below) we
1939 generate the names segment<NUM>a and segment<NUM>b.
1941 Note that some program segments may have a file size that is different than
1942 (less than) the memory size. All this means is that at execution the
1943 system must allocate the amount of memory specified by the memory size,
1944 but only initialize it with the first "file size" bytes read from the
1945 file. This would occur for example, with program segments consisting
1946 of combined data+bss.
1948 To handle the above situation, this routine generates TWO bfd sections
1949 for the single program segment. The first has the length specified by
1950 the file size of the segment, and the second has the length specified
1951 by the difference between the two sizes. In effect, the segment is split
1952 into it's initialized and uninitialized parts.
1957 _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
)
1959 Elf_Internal_Phdr
*hdr
;
1961 const char *typename
;
1968 split
= ((hdr
->p_memsz
> 0)
1969 && (hdr
->p_filesz
> 0)
1970 && (hdr
->p_memsz
> hdr
->p_filesz
));
1971 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
1972 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
1975 strcpy (name
, namebuf
);
1976 newsect
= bfd_make_section (abfd
, name
);
1977 if (newsect
== NULL
)
1979 newsect
->vma
= hdr
->p_vaddr
;
1980 newsect
->lma
= hdr
->p_paddr
;
1981 newsect
->_raw_size
= hdr
->p_filesz
;
1982 newsect
->filepos
= hdr
->p_offset
;
1983 newsect
->flags
|= SEC_HAS_CONTENTS
;
1984 if (hdr
->p_type
== PT_LOAD
)
1986 newsect
->flags
|= SEC_ALLOC
;
1987 newsect
->flags
|= SEC_LOAD
;
1988 if (hdr
->p_flags
& PF_X
)
1990 /* FIXME: all we known is that it has execute PERMISSION,
1992 newsect
->flags
|= SEC_CODE
;
1995 if (!(hdr
->p_flags
& PF_W
))
1997 newsect
->flags
|= SEC_READONLY
;
2002 sprintf (namebuf
, "%s%db", typename
, index
);
2003 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (namebuf
) + 1);
2006 strcpy (name
, namebuf
);
2007 newsect
= bfd_make_section (abfd
, name
);
2008 if (newsect
== NULL
)
2010 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2011 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2012 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
2013 if (hdr
->p_type
== PT_LOAD
)
2015 newsect
->flags
|= SEC_ALLOC
;
2016 if (hdr
->p_flags
& PF_X
)
2017 newsect
->flags
|= SEC_CODE
;
2019 if (!(hdr
->p_flags
& PF_W
))
2020 newsect
->flags
|= SEC_READONLY
;
2027 bfd_section_from_phdr (abfd
, hdr
, index
)
2029 Elf_Internal_Phdr
*hdr
;
2032 struct elf_backend_data
*bed
;
2034 switch (hdr
->p_type
)
2037 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2040 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2043 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2046 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2049 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2051 if (! elfcore_read_notes (abfd
, (file_ptr
) hdr
->p_offset
, hdr
->p_filesz
))
2056 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2059 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2062 /* Check for any processor-specific program segment types.
2063 If no handler for them, default to making "segment" sections. */
2064 bed
= get_elf_backend_data (abfd
);
2065 if (bed
->elf_backend_section_from_phdr
)
2066 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
2068 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
2072 /* Initialize REL_HDR, the section-header for new section, containing
2073 relocations against ASECT. If USE_RELA_P is true, we use RELA
2074 relocations; otherwise, we use REL relocations. */
2077 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
2079 Elf_Internal_Shdr
*rel_hdr
;
2084 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2085 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2087 name
= bfd_alloc (abfd
, amt
);
2090 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2092 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2094 if (rel_hdr
->sh_name
== (unsigned int) -1)
2096 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2097 rel_hdr
->sh_entsize
= (use_rela_p
2098 ? bed
->s
->sizeof_rela
2099 : bed
->s
->sizeof_rel
);
2100 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
2101 rel_hdr
->sh_flags
= 0;
2102 rel_hdr
->sh_addr
= 0;
2103 rel_hdr
->sh_size
= 0;
2104 rel_hdr
->sh_offset
= 0;
2109 /* Set up an ELF internal section header for a section. */
2112 elf_fake_sections (abfd
, asect
, failedptrarg
)
2117 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2118 boolean
*failedptr
= (boolean
*) failedptrarg
;
2119 Elf_Internal_Shdr
*this_hdr
;
2123 /* We already failed; just get out of the bfd_map_over_sections
2128 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2130 this_hdr
->sh_name
= (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2131 asect
->name
, false);
2132 if (this_hdr
->sh_name
== (unsigned long) -1)
2138 this_hdr
->sh_flags
= 0;
2140 if ((asect
->flags
& SEC_ALLOC
) != 0
2141 || asect
->user_set_vma
)
2142 this_hdr
->sh_addr
= asect
->vma
;
2144 this_hdr
->sh_addr
= 0;
2146 this_hdr
->sh_offset
= 0;
2147 this_hdr
->sh_size
= asect
->_raw_size
;
2148 this_hdr
->sh_link
= 0;
2149 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2150 /* The sh_entsize and sh_info fields may have been set already by
2151 copy_private_section_data. */
2153 this_hdr
->bfd_section
= asect
;
2154 this_hdr
->contents
= NULL
;
2156 /* FIXME: This should not be based on section names. */
2157 if (strcmp (asect
->name
, ".dynstr") == 0)
2158 this_hdr
->sh_type
= SHT_STRTAB
;
2159 else if (strcmp (asect
->name
, ".hash") == 0)
2161 this_hdr
->sh_type
= SHT_HASH
;
2162 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2164 else if (strcmp (asect
->name
, ".dynsym") == 0)
2166 this_hdr
->sh_type
= SHT_DYNSYM
;
2167 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2169 else if (strcmp (asect
->name
, ".dynamic") == 0)
2171 this_hdr
->sh_type
= SHT_DYNAMIC
;
2172 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2174 else if (strncmp (asect
->name
, ".rela", 5) == 0
2175 && get_elf_backend_data (abfd
)->may_use_rela_p
)
2177 this_hdr
->sh_type
= SHT_RELA
;
2178 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2180 else if (strncmp (asect
->name
, ".rel", 4) == 0
2181 && get_elf_backend_data (abfd
)->may_use_rel_p
)
2183 this_hdr
->sh_type
= SHT_REL
;
2184 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2186 else if (strcmp (asect
->name
, ".init_array") == 0)
2187 this_hdr
->sh_type
= SHT_INIT_ARRAY
;
2188 else if (strcmp (asect
->name
, ".fini_array") == 0)
2189 this_hdr
->sh_type
= SHT_FINI_ARRAY
;
2190 else if (strcmp (asect
->name
, ".preinit_array") == 0)
2191 this_hdr
->sh_type
= SHT_PREINIT_ARRAY
;
2192 else if (strncmp (asect
->name
, ".note", 5) == 0)
2193 this_hdr
->sh_type
= SHT_NOTE
;
2194 else if (strncmp (asect
->name
, ".stab", 5) == 0
2195 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
2196 this_hdr
->sh_type
= SHT_STRTAB
;
2197 else if (strcmp (asect
->name
, ".gnu.version") == 0)
2199 this_hdr
->sh_type
= SHT_GNU_versym
;
2200 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2202 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
2204 this_hdr
->sh_type
= SHT_GNU_verdef
;
2205 this_hdr
->sh_entsize
= 0;
2206 /* objcopy or strip will copy over sh_info, but may not set
2207 cverdefs. The linker will set cverdefs, but sh_info will be
2209 if (this_hdr
->sh_info
== 0)
2210 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2212 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2213 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2215 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
2217 this_hdr
->sh_type
= SHT_GNU_verneed
;
2218 this_hdr
->sh_entsize
= 0;
2219 /* objcopy or strip will copy over sh_info, but may not set
2220 cverrefs. The linker will set cverrefs, but sh_info will be
2222 if (this_hdr
->sh_info
== 0)
2223 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2225 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2226 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2228 else if ((asect
->flags
& SEC_GROUP
) != 0)
2230 this_hdr
->sh_type
= SHT_GROUP
;
2231 this_hdr
->sh_entsize
= 4;
2233 else if ((asect
->flags
& SEC_ALLOC
) != 0
2234 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2235 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2236 this_hdr
->sh_type
= SHT_NOBITS
;
2238 this_hdr
->sh_type
= SHT_PROGBITS
;
2240 if ((asect
->flags
& SEC_ALLOC
) != 0)
2241 this_hdr
->sh_flags
|= SHF_ALLOC
;
2242 if ((asect
->flags
& SEC_READONLY
) == 0)
2243 this_hdr
->sh_flags
|= SHF_WRITE
;
2244 if ((asect
->flags
& SEC_CODE
) != 0)
2245 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2246 if ((asect
->flags
& SEC_MERGE
) != 0)
2248 this_hdr
->sh_flags
|= SHF_MERGE
;
2249 this_hdr
->sh_entsize
= asect
->entsize
;
2250 if ((asect
->flags
& SEC_STRINGS
) != 0)
2251 this_hdr
->sh_flags
|= SHF_STRINGS
;
2253 if (elf_group_name (asect
) != NULL
)
2254 this_hdr
->sh_flags
|= SHF_GROUP
;
2256 /* Check for processor-specific section types. */
2257 if (bed
->elf_backend_fake_sections
2258 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2261 /* If the section has relocs, set up a section header for the
2262 SHT_REL[A] section. If two relocation sections are required for
2263 this section, it is up to the processor-specific back-end to
2264 create the other. */
2265 if ((asect
->flags
& SEC_RELOC
) != 0
2266 && !_bfd_elf_init_reloc_shdr (abfd
,
2267 &elf_section_data (asect
)->rel_hdr
,
2269 elf_section_data (asect
)->use_rela_p
))
2273 /* Fill in the contents of a SHT_GROUP section. */
2276 set_group_contents (abfd
, sec
, failedptrarg
)
2279 PTR failedptrarg ATTRIBUTE_UNUSED
;
2281 boolean
*failedptr
= (boolean
*) failedptrarg
;
2282 unsigned long symindx
;
2285 struct bfd_link_order
*l
;
2287 if (elf_section_data (sec
)->this_hdr
.sh_type
!= SHT_GROUP
2291 /* If called from the assembler, swap_out_syms will have set up
2292 elf_section_syms; If called for "ld -r", the symbols won't yet
2293 be mapped, so emulate elf_bfd_final_link. */
2294 if (elf_section_syms (abfd
) != NULL
)
2295 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2297 symindx
= elf_section_data (sec
)->this_idx
;
2298 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2300 /* Nor will the contents be allocated for "ld -r". */
2301 if (sec
->contents
== NULL
)
2303 sec
->contents
= bfd_alloc (abfd
, sec
->_raw_size
);
2304 if (sec
->contents
== NULL
)
2311 loc
= sec
->contents
+ sec
->_raw_size
;
2313 /* Get the pointer to the first section in the group that we
2314 squirreled away here. */
2315 elt
= elf_next_in_group (sec
);
2317 /* First element is a flag word. Rest of section is elf section
2318 indices for all the sections of the group. Write them backwards
2319 just to keep the group in the same order as given in .section
2320 directives, not that it matters. */
2324 H_PUT_32 (abfd
, elf_section_data (elt
)->this_idx
, loc
);
2325 elt
= elf_next_in_group (elt
);
2328 /* If this is a relocatable link, then the above did nothing because
2329 SEC is the output section. Look through the input sections
2331 for (l
= sec
->link_order_head
; l
!= NULL
; l
= l
->next
)
2332 if (l
->type
== bfd_indirect_link_order
2333 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2338 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2339 elt
= elf_next_in_group (elt
);
2340 /* During a relocatable link, the lists are circular. */
2342 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2345 H_PUT_32 (abfd
, 0, loc
);
2347 BFD_ASSERT (loc
== sec
->contents
);
2350 /* Assign all ELF section numbers. The dummy first section is handled here
2351 too. The link/info pointers for the standard section types are filled
2352 in here too, while we're at it. */
2355 assign_section_numbers (abfd
)
2358 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2360 unsigned int section_number
, secn
;
2361 Elf_Internal_Shdr
**i_shdrp
;
2366 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2368 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2370 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2372 if (section_number
== SHN_LORESERVE
)
2373 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2374 d
->this_idx
= section_number
++;
2375 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2376 if ((sec
->flags
& SEC_RELOC
) == 0)
2380 if (section_number
== SHN_LORESERVE
)
2381 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2382 d
->rel_idx
= section_number
++;
2383 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2388 if (section_number
== SHN_LORESERVE
)
2389 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2390 d
->rel_idx2
= section_number
++;
2391 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2397 if (section_number
== SHN_LORESERVE
)
2398 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2399 t
->shstrtab_section
= section_number
++;
2400 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2401 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2403 if (bfd_get_symcount (abfd
) > 0)
2405 if (section_number
== SHN_LORESERVE
)
2406 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2407 t
->symtab_section
= section_number
++;
2408 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2409 if (section_number
> SHN_LORESERVE
- 2)
2411 if (section_number
== SHN_LORESERVE
)
2412 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2413 t
->symtab_shndx_section
= section_number
++;
2414 t
->symtab_shndx_hdr
.sh_name
2415 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2416 ".symtab_shndx", false);
2417 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2420 if (section_number
== SHN_LORESERVE
)
2421 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2422 t
->strtab_section
= section_number
++;
2423 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2426 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2427 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2429 elf_numsections (abfd
) = section_number
;
2430 elf_elfheader (abfd
)->e_shnum
= section_number
;
2431 if (section_number
> SHN_LORESERVE
)
2432 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2434 /* Set up the list of section header pointers, in agreement with the
2436 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2437 i_shdrp
= (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
2438 if (i_shdrp
== NULL
)
2441 amt
= sizeof (Elf_Internal_Shdr
);
2442 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
2443 if (i_shdrp
[0] == NULL
)
2445 bfd_release (abfd
, i_shdrp
);
2448 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
2450 elf_elfsections (abfd
) = i_shdrp
;
2452 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2453 if (bfd_get_symcount (abfd
) > 0)
2455 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2456 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2458 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2459 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2461 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2462 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2464 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2466 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2470 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2471 if (d
->rel_idx
!= 0)
2472 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2473 if (d
->rel_idx2
!= 0)
2474 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2476 /* Fill in the sh_link and sh_info fields while we're at it. */
2478 /* sh_link of a reloc section is the section index of the symbol
2479 table. sh_info is the section index of the section to which
2480 the relocation entries apply. */
2481 if (d
->rel_idx
!= 0)
2483 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2484 d
->rel_hdr
.sh_info
= d
->this_idx
;
2486 if (d
->rel_idx2
!= 0)
2488 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2489 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2492 switch (d
->this_hdr
.sh_type
)
2496 /* A reloc section which we are treating as a normal BFD
2497 section. sh_link is the section index of the symbol
2498 table. sh_info is the section index of the section to
2499 which the relocation entries apply. We assume that an
2500 allocated reloc section uses the dynamic symbol table.
2501 FIXME: How can we be sure? */
2502 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2504 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2506 /* We look up the section the relocs apply to by name. */
2508 if (d
->this_hdr
.sh_type
== SHT_REL
)
2512 s
= bfd_get_section_by_name (abfd
, name
);
2514 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2518 /* We assume that a section named .stab*str is a stabs
2519 string section. We look for a section with the same name
2520 but without the trailing ``str'', and set its sh_link
2521 field to point to this section. */
2522 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
2523 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2528 len
= strlen (sec
->name
);
2529 alc
= (char *) bfd_malloc ((bfd_size_type
) len
- 2);
2532 strncpy (alc
, sec
->name
, len
- 3);
2533 alc
[len
- 3] = '\0';
2534 s
= bfd_get_section_by_name (abfd
, alc
);
2538 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2540 /* This is a .stab section. */
2541 elf_section_data (s
)->this_hdr
.sh_entsize
=
2542 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2549 case SHT_GNU_verneed
:
2550 case SHT_GNU_verdef
:
2551 /* sh_link is the section header index of the string table
2552 used for the dynamic entries, or the symbol table, or the
2554 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2556 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2560 case SHT_GNU_versym
:
2561 /* sh_link is the section header index of the symbol table
2562 this hash table or version table is for. */
2563 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2565 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2569 d
->this_hdr
.sh_link
= t
->symtab_section
;
2573 for (secn
= 1; secn
< section_number
; ++secn
)
2574 if (i_shdrp
[secn
] == NULL
)
2575 i_shdrp
[secn
] = i_shdrp
[0];
2577 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
2578 i_shdrp
[secn
]->sh_name
);
2582 /* Map symbol from it's internal number to the external number, moving
2583 all local symbols to be at the head of the list. */
2586 sym_is_global (abfd
, sym
)
2590 /* If the backend has a special mapping, use it. */
2591 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2592 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2595 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2596 || bfd_is_und_section (bfd_get_section (sym
))
2597 || bfd_is_com_section (bfd_get_section (sym
)));
2601 elf_map_symbols (abfd
)
2604 unsigned int symcount
= bfd_get_symcount (abfd
);
2605 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2606 asymbol
**sect_syms
;
2607 unsigned int num_locals
= 0;
2608 unsigned int num_globals
= 0;
2609 unsigned int num_locals2
= 0;
2610 unsigned int num_globals2
= 0;
2618 fprintf (stderr
, "elf_map_symbols\n");
2622 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2624 if (max_index
< asect
->index
)
2625 max_index
= asect
->index
;
2629 amt
= max_index
* sizeof (asymbol
*);
2630 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
2631 if (sect_syms
== NULL
)
2633 elf_section_syms (abfd
) = sect_syms
;
2634 elf_num_section_syms (abfd
) = max_index
;
2636 /* Init sect_syms entries for any section symbols we have already
2637 decided to output. */
2638 for (idx
= 0; idx
< symcount
; idx
++)
2640 asymbol
*sym
= syms
[idx
];
2642 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2649 if (sec
->owner
!= NULL
)
2651 if (sec
->owner
!= abfd
)
2653 if (sec
->output_offset
!= 0)
2656 sec
= sec
->output_section
;
2658 /* Empty sections in the input files may have had a
2659 section symbol created for them. (See the comment
2660 near the end of _bfd_generic_link_output_symbols in
2661 linker.c). If the linker script discards such
2662 sections then we will reach this point. Since we know
2663 that we cannot avoid this case, we detect it and skip
2664 the abort and the assignment to the sect_syms array.
2665 To reproduce this particular case try running the
2666 linker testsuite test ld-scripts/weak.exp for an ELF
2667 port that uses the generic linker. */
2668 if (sec
->owner
== NULL
)
2671 BFD_ASSERT (sec
->owner
== abfd
);
2673 sect_syms
[sec
->index
] = syms
[idx
];
2678 /* Classify all of the symbols. */
2679 for (idx
= 0; idx
< symcount
; idx
++)
2681 if (!sym_is_global (abfd
, syms
[idx
]))
2687 /* We will be adding a section symbol for each BFD section. Most normal
2688 sections will already have a section symbol in outsymbols, but
2689 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2690 at least in that case. */
2691 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2693 if (sect_syms
[asect
->index
] == NULL
)
2695 if (!sym_is_global (abfd
, asect
->symbol
))
2702 /* Now sort the symbols so the local symbols are first. */
2703 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
2704 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
2706 if (new_syms
== NULL
)
2709 for (idx
= 0; idx
< symcount
; idx
++)
2711 asymbol
*sym
= syms
[idx
];
2714 if (!sym_is_global (abfd
, sym
))
2717 i
= num_locals
+ num_globals2
++;
2719 sym
->udata
.i
= i
+ 1;
2721 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2723 if (sect_syms
[asect
->index
] == NULL
)
2725 asymbol
*sym
= asect
->symbol
;
2728 sect_syms
[asect
->index
] = sym
;
2729 if (!sym_is_global (abfd
, sym
))
2732 i
= num_locals
+ num_globals2
++;
2734 sym
->udata
.i
= i
+ 1;
2738 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
2740 elf_num_locals (abfd
) = num_locals
;
2741 elf_num_globals (abfd
) = num_globals
;
2745 /* Align to the maximum file alignment that could be required for any
2746 ELF data structure. */
2748 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
2749 static INLINE file_ptr
2750 align_file_position (off
, align
)
2754 return (off
+ align
- 1) & ~(align
- 1);
2757 /* Assign a file position to a section, optionally aligning to the
2758 required section alignment. */
2761 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
2762 Elf_Internal_Shdr
*i_shdrp
;
2770 al
= i_shdrp
->sh_addralign
;
2772 offset
= BFD_ALIGN (offset
, al
);
2774 i_shdrp
->sh_offset
= offset
;
2775 if (i_shdrp
->bfd_section
!= NULL
)
2776 i_shdrp
->bfd_section
->filepos
= offset
;
2777 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2778 offset
+= i_shdrp
->sh_size
;
2782 /* Compute the file positions we are going to put the sections at, and
2783 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2784 is not NULL, this is being called by the ELF backend linker. */
2787 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2789 struct bfd_link_info
*link_info
;
2791 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2793 struct bfd_strtab_hash
*strtab
;
2794 Elf_Internal_Shdr
*shstrtab_hdr
;
2796 if (abfd
->output_has_begun
)
2799 /* Do any elf backend specific processing first. */
2800 if (bed
->elf_backend_begin_write_processing
)
2801 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2803 if (! prep_headers (abfd
))
2806 /* Post process the headers if necessary. */
2807 if (bed
->elf_backend_post_process_headers
)
2808 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2811 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2815 if (!assign_section_numbers (abfd
))
2818 /* The backend linker builds symbol table information itself. */
2819 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2821 /* Non-zero if doing a relocatable link. */
2822 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2824 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2828 if (link_info
== NULL
|| link_info
->relocateable
)
2830 bfd_map_over_sections (abfd
, set_group_contents
, &failed
);
2835 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2836 /* sh_name was set in prep_headers. */
2837 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2838 shstrtab_hdr
->sh_flags
= 0;
2839 shstrtab_hdr
->sh_addr
= 0;
2840 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2841 shstrtab_hdr
->sh_entsize
= 0;
2842 shstrtab_hdr
->sh_link
= 0;
2843 shstrtab_hdr
->sh_info
= 0;
2844 /* sh_offset is set in assign_file_positions_except_relocs. */
2845 shstrtab_hdr
->sh_addralign
= 1;
2847 if (!assign_file_positions_except_relocs (abfd
))
2850 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2853 Elf_Internal_Shdr
*hdr
;
2855 off
= elf_tdata (abfd
)->next_file_pos
;
2857 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2858 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2860 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2861 if (hdr
->sh_size
!= 0)
2862 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2864 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2865 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2867 elf_tdata (abfd
)->next_file_pos
= off
;
2869 /* Now that we know where the .strtab section goes, write it
2871 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2872 || ! _bfd_stringtab_emit (abfd
, strtab
))
2874 _bfd_stringtab_free (strtab
);
2877 abfd
->output_has_begun
= true;
2882 /* Create a mapping from a set of sections to a program segment. */
2884 static INLINE
struct elf_segment_map
*
2885 make_mapping (abfd
, sections
, from
, to
, phdr
)
2887 asection
**sections
;
2892 struct elf_segment_map
*m
;
2897 amt
= sizeof (struct elf_segment_map
);
2898 amt
+= (to
- from
- 1) * sizeof (asection
*);
2899 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2903 m
->p_type
= PT_LOAD
;
2904 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2905 m
->sections
[i
- from
] = *hdrpp
;
2906 m
->count
= to
- from
;
2908 if (from
== 0 && phdr
)
2910 /* Include the headers in the first PT_LOAD segment. */
2911 m
->includes_filehdr
= 1;
2912 m
->includes_phdrs
= 1;
2918 /* Set up a mapping from BFD sections to program segments. */
2921 map_sections_to_segments (abfd
)
2924 asection
**sections
= NULL
;
2928 struct elf_segment_map
*mfirst
;
2929 struct elf_segment_map
**pm
;
2930 struct elf_segment_map
*m
;
2932 unsigned int phdr_index
;
2933 bfd_vma maxpagesize
;
2935 boolean phdr_in_segment
= true;
2937 asection
*dynsec
, *eh_frame_hdr
;
2940 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2943 if (bfd_count_sections (abfd
) == 0)
2946 /* Select the allocated sections, and sort them. */
2948 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
2949 sections
= (asection
**) bfd_malloc (amt
);
2950 if (sections
== NULL
)
2954 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2956 if ((s
->flags
& SEC_ALLOC
) != 0)
2962 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2965 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2967 /* Build the mapping. */
2972 /* If we have a .interp section, then create a PT_PHDR segment for
2973 the program headers and a PT_INTERP segment for the .interp
2975 s
= bfd_get_section_by_name (abfd
, ".interp");
2976 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2978 amt
= sizeof (struct elf_segment_map
);
2979 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2983 m
->p_type
= PT_PHDR
;
2984 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2985 m
->p_flags
= PF_R
| PF_X
;
2986 m
->p_flags_valid
= 1;
2987 m
->includes_phdrs
= 1;
2992 amt
= sizeof (struct elf_segment_map
);
2993 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2997 m
->p_type
= PT_INTERP
;
3005 /* Look through the sections. We put sections in the same program
3006 segment when the start of the second section can be placed within
3007 a few bytes of the end of the first section. */
3010 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3012 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3014 && (dynsec
->flags
& SEC_LOAD
) == 0)
3017 /* Deal with -Ttext or something similar such that the first section
3018 is not adjacent to the program headers. This is an
3019 approximation, since at this point we don't know exactly how many
3020 program headers we will need. */
3023 bfd_size_type phdr_size
;
3025 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3027 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3028 if ((abfd
->flags
& D_PAGED
) == 0
3029 || sections
[0]->lma
< phdr_size
3030 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3031 phdr_in_segment
= false;
3034 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3037 boolean new_segment
;
3041 /* See if this section and the last one will fit in the same
3044 if (last_hdr
== NULL
)
3046 /* If we don't have a segment yet, then we don't need a new
3047 one (we build the last one after this loop). */
3048 new_segment
= false;
3050 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3052 /* If this section has a different relation between the
3053 virtual address and the load address, then we need a new
3057 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3058 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3060 /* If putting this section in this segment would force us to
3061 skip a page in the segment, then we need a new segment. */
3064 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
3065 && (hdr
->flags
& SEC_LOAD
) != 0)
3067 /* We don't want to put a loadable section after a
3068 nonloadable section in the same segment. */
3071 else if ((abfd
->flags
& D_PAGED
) == 0)
3073 /* If the file is not demand paged, which means that we
3074 don't require the sections to be correctly aligned in the
3075 file, then there is no other reason for a new segment. */
3076 new_segment
= false;
3079 && (hdr
->flags
& SEC_READONLY
) == 0
3080 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3083 /* We don't want to put a writable section in a read only
3084 segment, unless they are on the same page in memory
3085 anyhow. We already know that the last section does not
3086 bring us past the current section on the page, so the
3087 only case in which the new section is not on the same
3088 page as the previous section is when the previous section
3089 ends precisely on a page boundary. */
3094 /* Otherwise, we can use the same segment. */
3095 new_segment
= false;
3100 if ((hdr
->flags
& SEC_READONLY
) == 0)
3106 /* We need a new program segment. We must create a new program
3107 header holding all the sections from phdr_index until hdr. */
3109 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3116 if ((hdr
->flags
& SEC_READONLY
) == 0)
3123 phdr_in_segment
= false;
3126 /* Create a final PT_LOAD program segment. */
3127 if (last_hdr
!= NULL
)
3129 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3137 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3140 amt
= sizeof (struct elf_segment_map
);
3141 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3145 m
->p_type
= PT_DYNAMIC
;
3147 m
->sections
[0] = dynsec
;
3153 /* For each loadable .note section, add a PT_NOTE segment. We don't
3154 use bfd_get_section_by_name, because if we link together
3155 nonloadable .note sections and loadable .note sections, we will
3156 generate two .note sections in the output file. FIXME: Using
3157 names for section types is bogus anyhow. */
3158 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3160 if ((s
->flags
& SEC_LOAD
) != 0
3161 && strncmp (s
->name
, ".note", 5) == 0)
3163 amt
= sizeof (struct elf_segment_map
);
3164 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3168 m
->p_type
= PT_NOTE
;
3177 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3179 eh_frame_hdr
= NULL
;
3180 if (elf_tdata (abfd
)->eh_frame_hdr
)
3181 eh_frame_hdr
= bfd_get_section_by_name (abfd
, ".eh_frame_hdr");
3182 if (eh_frame_hdr
!= NULL
&& (eh_frame_hdr
->flags
& SEC_LOAD
))
3184 amt
= sizeof (struct elf_segment_map
);
3185 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3189 m
->p_type
= PT_GNU_EH_FRAME
;
3191 m
->sections
[0] = eh_frame_hdr
;
3200 elf_tdata (abfd
)->segment_map
= mfirst
;
3204 if (sections
!= NULL
)
3209 /* Sort sections by address. */
3212 elf_sort_sections (arg1
, arg2
)
3216 const asection
*sec1
= *(const asection
**) arg1
;
3217 const asection
*sec2
= *(const asection
**) arg2
;
3219 /* Sort by LMA first, since this is the address used to
3220 place the section into a segment. */
3221 if (sec1
->lma
< sec2
->lma
)
3223 else if (sec1
->lma
> sec2
->lma
)
3226 /* Then sort by VMA. Normally the LMA and the VMA will be
3227 the same, and this will do nothing. */
3228 if (sec1
->vma
< sec2
->vma
)
3230 else if (sec1
->vma
> sec2
->vma
)
3233 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3235 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3241 /* If the indicies are the same, do not return 0
3242 here, but continue to try the next comparison. */
3243 if (sec1
->target_index
- sec2
->target_index
!= 0)
3244 return sec1
->target_index
- sec2
->target_index
;
3249 else if (TOEND (sec2
))
3254 /* Sort by size, to put zero sized sections
3255 before others at the same address. */
3257 if (sec1
->_raw_size
< sec2
->_raw_size
)
3259 if (sec1
->_raw_size
> sec2
->_raw_size
)
3262 return sec1
->target_index
- sec2
->target_index
;
3265 /* Assign file positions to the sections based on the mapping from
3266 sections to segments. This function also sets up some fields in
3267 the file header, and writes out the program headers. */
3270 assign_file_positions_for_segments (abfd
)
3273 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3275 struct elf_segment_map
*m
;
3277 Elf_Internal_Phdr
*phdrs
;
3279 bfd_vma filehdr_vaddr
, filehdr_paddr
;
3280 bfd_vma phdrs_vaddr
, phdrs_paddr
;
3281 Elf_Internal_Phdr
*p
;
3284 if (elf_tdata (abfd
)->segment_map
== NULL
)
3286 if (! map_sections_to_segments (abfd
))
3290 if (bed
->elf_backend_modify_segment_map
)
3292 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
3297 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3300 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
3301 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
3302 elf_elfheader (abfd
)->e_phnum
= count
;
3307 /* If we already counted the number of program segments, make sure
3308 that we allocated enough space. This happens when SIZEOF_HEADERS
3309 is used in a linker script. */
3310 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
3311 if (alloc
!= 0 && count
> alloc
)
3313 ((*_bfd_error_handler
)
3314 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3315 bfd_get_filename (abfd
), alloc
, count
));
3316 bfd_set_error (bfd_error_bad_value
);
3323 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
3324 phdrs
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
3328 off
= bed
->s
->sizeof_ehdr
;
3329 off
+= alloc
* bed
->s
->sizeof_phdr
;
3336 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3343 /* If elf_segment_map is not from map_sections_to_segments, the
3344 sections may not be correctly ordered. NOTE: sorting should
3345 not be done to the PT_NOTE section of a corefile, which may
3346 contain several pseudo-sections artificially created by bfd.
3347 Sorting these pseudo-sections breaks things badly. */
3349 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
3350 && m
->p_type
== PT_NOTE
))
3351 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
3354 p
->p_type
= m
->p_type
;
3355 p
->p_flags
= m
->p_flags
;
3357 if (p
->p_type
== PT_LOAD
3359 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
3361 if ((abfd
->flags
& D_PAGED
) != 0)
3362 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
3365 bfd_size_type align
;
3368 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3370 bfd_size_type secalign
;
3372 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
3373 if (secalign
> align
)
3377 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
3384 p
->p_vaddr
= m
->sections
[0]->vma
;
3386 if (m
->p_paddr_valid
)
3387 p
->p_paddr
= m
->p_paddr
;
3388 else if (m
->count
== 0)
3391 p
->p_paddr
= m
->sections
[0]->lma
;
3393 if (p
->p_type
== PT_LOAD
3394 && (abfd
->flags
& D_PAGED
) != 0)
3395 p
->p_align
= bed
->maxpagesize
;
3396 else if (m
->count
== 0)
3397 p
->p_align
= bed
->s
->file_align
;
3405 if (m
->includes_filehdr
)
3407 if (! m
->p_flags_valid
)
3410 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3411 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3414 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3416 if (p
->p_vaddr
< (bfd_vma
) off
)
3418 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
3419 bfd_get_filename (abfd
));
3420 bfd_set_error (bfd_error_bad_value
);
3425 if (! m
->p_paddr_valid
)
3428 if (p
->p_type
== PT_LOAD
)
3430 filehdr_vaddr
= p
->p_vaddr
;
3431 filehdr_paddr
= p
->p_paddr
;
3435 if (m
->includes_phdrs
)
3437 if (! m
->p_flags_valid
)
3440 if (m
->includes_filehdr
)
3442 if (p
->p_type
== PT_LOAD
)
3444 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3445 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3450 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3454 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3455 p
->p_vaddr
-= off
- p
->p_offset
;
3456 if (! m
->p_paddr_valid
)
3457 p
->p_paddr
-= off
- p
->p_offset
;
3460 if (p
->p_type
== PT_LOAD
)
3462 phdrs_vaddr
= p
->p_vaddr
;
3463 phdrs_paddr
= p
->p_paddr
;
3466 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3469 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3470 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3473 if (p
->p_type
== PT_LOAD
3474 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3476 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3482 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3483 p
->p_filesz
+= adjust
;
3484 p
->p_memsz
+= adjust
;
3490 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3494 bfd_size_type align
;
3498 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3500 /* The section may have artificial alignment forced by a
3501 link script. Notice this case by the gap between the
3502 cumulative phdr lma and the section's lma. */
3503 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3505 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3507 p
->p_memsz
+= adjust
;
3510 if ((flags
& SEC_LOAD
) != 0)
3511 p
->p_filesz
+= adjust
;
3514 if (p
->p_type
== PT_LOAD
)
3516 bfd_signed_vma adjust
;
3518 if ((flags
& SEC_LOAD
) != 0)
3520 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3524 else if ((flags
& SEC_ALLOC
) != 0)
3526 /* The section VMA must equal the file position
3527 modulo the page size. FIXME: I'm not sure if
3528 this adjustment is really necessary. We used to
3529 not have the SEC_LOAD case just above, and then
3530 this was necessary, but now I'm not sure. */
3531 if ((abfd
->flags
& D_PAGED
) != 0)
3532 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
3534 adjust
= (sec
->vma
- voff
) % align
;
3543 (* _bfd_error_handler
) (_("\
3544 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3545 bfd_section_name (abfd
, sec
),
3550 p
->p_memsz
+= adjust
;
3553 if ((flags
& SEC_LOAD
) != 0)
3554 p
->p_filesz
+= adjust
;
3559 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3560 used in a linker script we may have a section with
3561 SEC_LOAD clear but which is supposed to have
3563 if ((flags
& SEC_LOAD
) != 0
3564 || (flags
& SEC_HAS_CONTENTS
) != 0)
3565 off
+= sec
->_raw_size
;
3567 if ((flags
& SEC_ALLOC
) != 0)
3568 voff
+= sec
->_raw_size
;
3571 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
3573 /* The actual "note" segment has i == 0.
3574 This is the one that actually contains everything. */
3578 p
->p_filesz
= sec
->_raw_size
;
3579 off
+= sec
->_raw_size
;
3584 /* Fake sections -- don't need to be written. */
3587 flags
= sec
->flags
= 0;
3594 p
->p_memsz
+= sec
->_raw_size
;
3596 if ((flags
& SEC_LOAD
) != 0)
3597 p
->p_filesz
+= sec
->_raw_size
;
3599 if (align
> p
->p_align
3600 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
3604 if (! m
->p_flags_valid
)
3607 if ((flags
& SEC_CODE
) != 0)
3609 if ((flags
& SEC_READONLY
) == 0)
3615 /* Now that we have set the section file positions, we can set up
3616 the file positions for the non PT_LOAD segments. */
3617 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3621 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
3623 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
3624 p
->p_offset
= m
->sections
[0]->filepos
;
3628 if (m
->includes_filehdr
)
3630 p
->p_vaddr
= filehdr_vaddr
;
3631 if (! m
->p_paddr_valid
)
3632 p
->p_paddr
= filehdr_paddr
;
3634 else if (m
->includes_phdrs
)
3636 p
->p_vaddr
= phdrs_vaddr
;
3637 if (! m
->p_paddr_valid
)
3638 p
->p_paddr
= phdrs_paddr
;
3643 /* Clear out any program headers we allocated but did not use. */
3644 for (; count
< alloc
; count
++, p
++)
3646 memset (p
, 0, sizeof *p
);
3647 p
->p_type
= PT_NULL
;
3650 elf_tdata (abfd
)->phdr
= phdrs
;
3652 elf_tdata (abfd
)->next_file_pos
= off
;
3654 /* Write out the program headers. */
3655 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
3656 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
3662 /* Get the size of the program header.
3664 If this is called by the linker before any of the section VMA's are set, it
3665 can't calculate the correct value for a strange memory layout. This only
3666 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3667 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3668 data segment (exclusive of .interp and .dynamic).
3670 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3671 will be two segments. */
3673 static bfd_size_type
3674 get_program_header_size (abfd
)
3679 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3681 /* We can't return a different result each time we're called. */
3682 if (elf_tdata (abfd
)->program_header_size
!= 0)
3683 return elf_tdata (abfd
)->program_header_size
;
3685 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3687 struct elf_segment_map
*m
;
3690 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3692 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3693 return elf_tdata (abfd
)->program_header_size
;
3696 /* Assume we will need exactly two PT_LOAD segments: one for text
3697 and one for data. */
3700 s
= bfd_get_section_by_name (abfd
, ".interp");
3701 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3703 /* If we have a loadable interpreter section, we need a
3704 PT_INTERP segment. In this case, assume we also need a
3705 PT_PHDR segment, although that may not be true for all
3710 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3712 /* We need a PT_DYNAMIC segment. */
3716 if (elf_tdata (abfd
)->eh_frame_hdr
3717 && bfd_get_section_by_name (abfd
, ".eh_frame_hdr") != NULL
)
3719 /* We need a PT_GNU_EH_FRAME segment. */
3723 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3725 if ((s
->flags
& SEC_LOAD
) != 0
3726 && strncmp (s
->name
, ".note", 5) == 0)
3728 /* We need a PT_NOTE segment. */
3733 /* Let the backend count up any program headers it might need. */
3734 if (bed
->elf_backend_additional_program_headers
)
3738 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
3744 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
3745 return elf_tdata (abfd
)->program_header_size
;
3748 /* Work out the file positions of all the sections. This is called by
3749 _bfd_elf_compute_section_file_positions. All the section sizes and
3750 VMAs must be known before this is called.
3752 We do not consider reloc sections at this point, unless they form
3753 part of the loadable image. Reloc sections are assigned file
3754 positions in assign_file_positions_for_relocs, which is called by
3755 write_object_contents and final_link.
3757 We also don't set the positions of the .symtab and .strtab here. */
3760 assign_file_positions_except_relocs (abfd
)
3763 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
3764 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
3765 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
3766 unsigned int num_sec
= elf_numsections (abfd
);
3768 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3770 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
3771 && bfd_get_format (abfd
) != bfd_core
)
3773 Elf_Internal_Shdr
**hdrpp
;
3776 /* Start after the ELF header. */
3777 off
= i_ehdrp
->e_ehsize
;
3779 /* We are not creating an executable, which means that we are
3780 not creating a program header, and that the actual order of
3781 the sections in the file is unimportant. */
3782 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
3784 Elf_Internal_Shdr
*hdr
;
3787 if (hdr
->sh_type
== SHT_REL
3788 || hdr
->sh_type
== SHT_RELA
3789 || i
== tdata
->symtab_section
3790 || i
== tdata
->symtab_shndx_section
3791 || i
== tdata
->strtab_section
)
3793 hdr
->sh_offset
= -1;
3796 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3798 if (i
== SHN_LORESERVE
- 1)
3800 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3801 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3808 Elf_Internal_Shdr
**hdrpp
;
3810 /* Assign file positions for the loaded sections based on the
3811 assignment of sections to segments. */
3812 if (! assign_file_positions_for_segments (abfd
))
3815 /* Assign file positions for the other sections. */
3817 off
= elf_tdata (abfd
)->next_file_pos
;
3818 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
3820 Elf_Internal_Shdr
*hdr
;
3823 if (hdr
->bfd_section
!= NULL
3824 && hdr
->bfd_section
->filepos
!= 0)
3825 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
3826 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3828 ((*_bfd_error_handler
)
3829 (_("%s: warning: allocated section `%s' not in segment"),
3830 bfd_get_filename (abfd
),
3831 (hdr
->bfd_section
== NULL
3833 : hdr
->bfd_section
->name
)));
3834 if ((abfd
->flags
& D_PAGED
) != 0)
3835 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3837 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3838 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3841 else if (hdr
->sh_type
== SHT_REL
3842 || hdr
->sh_type
== SHT_RELA
3843 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3844 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
3845 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3846 hdr
->sh_offset
= -1;
3848 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3850 if (i
== SHN_LORESERVE
- 1)
3852 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3853 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3858 /* Place the section headers. */
3859 off
= align_file_position (off
, bed
->s
->file_align
);
3860 i_ehdrp
->e_shoff
= off
;
3861 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3863 elf_tdata (abfd
)->next_file_pos
= off
;
3872 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3873 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3874 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3876 struct elf_strtab_hash
*shstrtab
;
3877 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3879 i_ehdrp
= elf_elfheader (abfd
);
3880 i_shdrp
= elf_elfsections (abfd
);
3882 shstrtab
= _bfd_elf_strtab_init ();
3883 if (shstrtab
== NULL
)
3886 elf_shstrtab (abfd
) = shstrtab
;
3888 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3889 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3890 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3891 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3893 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3894 i_ehdrp
->e_ident
[EI_DATA
] =
3895 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3896 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3898 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_NONE
;
3899 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 0;
3901 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
3902 i_ehdrp
->e_ident
[count
] = 0;
3904 if ((abfd
->flags
& DYNAMIC
) != 0)
3905 i_ehdrp
->e_type
= ET_DYN
;
3906 else if ((abfd
->flags
& EXEC_P
) != 0)
3907 i_ehdrp
->e_type
= ET_EXEC
;
3908 else if (bfd_get_format (abfd
) == bfd_core
)
3909 i_ehdrp
->e_type
= ET_CORE
;
3911 i_ehdrp
->e_type
= ET_REL
;
3913 switch (bfd_get_arch (abfd
))
3915 case bfd_arch_unknown
:
3916 i_ehdrp
->e_machine
= EM_NONE
;
3919 /* There used to be a long list of cases here, each one setting
3920 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
3921 in the corresponding bfd definition. To avoid duplication,
3922 the switch was removed. Machines that need special handling
3923 can generally do it in elf_backend_final_write_processing(),
3924 unless they need the information earlier than the final write.
3925 Such need can generally be supplied by replacing the tests for
3926 e_machine with the conditions used to determine it. */
3928 if (get_elf_backend_data (abfd
) != NULL
)
3929 i_ehdrp
->e_machine
= get_elf_backend_data (abfd
)->elf_machine_code
;
3931 i_ehdrp
->e_machine
= EM_NONE
;
3934 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3935 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3937 /* No program header, for now. */
3938 i_ehdrp
->e_phoff
= 0;
3939 i_ehdrp
->e_phentsize
= 0;
3940 i_ehdrp
->e_phnum
= 0;
3942 /* Each bfd section is section header entry. */
3943 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3944 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3946 /* If we're building an executable, we'll need a program header table. */
3947 if (abfd
->flags
& EXEC_P
)
3949 /* It all happens later. */
3951 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3953 /* elf_build_phdrs() returns a (NULL-terminated) array of
3954 Elf_Internal_Phdrs. */
3955 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3956 i_ehdrp
->e_phoff
= outbase
;
3957 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3962 i_ehdrp
->e_phentsize
= 0;
3964 i_ehdrp
->e_phoff
= 0;
3967 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3968 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
3969 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3970 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
3971 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3972 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
3973 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3974 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3975 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3981 /* Assign file positions for all the reloc sections which are not part
3982 of the loadable file image. */
3985 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3989 unsigned int i
, num_sec
;
3990 Elf_Internal_Shdr
**shdrpp
;
3992 off
= elf_tdata (abfd
)->next_file_pos
;
3994 num_sec
= elf_numsections (abfd
);
3995 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
3997 Elf_Internal_Shdr
*shdrp
;
4000 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4001 && shdrp
->sh_offset
== -1)
4002 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
4005 elf_tdata (abfd
)->next_file_pos
= off
;
4009 _bfd_elf_write_object_contents (abfd
)
4012 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4013 Elf_Internal_Ehdr
*i_ehdrp
;
4014 Elf_Internal_Shdr
**i_shdrp
;
4016 unsigned int count
, num_sec
;
4018 if (! abfd
->output_has_begun
4019 && ! _bfd_elf_compute_section_file_positions
4020 (abfd
, (struct bfd_link_info
*) NULL
))
4023 i_shdrp
= elf_elfsections (abfd
);
4024 i_ehdrp
= elf_elfheader (abfd
);
4027 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4031 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4033 /* After writing the headers, we need to write the sections too... */
4034 num_sec
= elf_numsections (abfd
);
4035 for (count
= 1; count
< num_sec
; count
++)
4037 if (bed
->elf_backend_section_processing
)
4038 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4039 if (i_shdrp
[count
]->contents
)
4041 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4043 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4044 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4047 if (count
== SHN_LORESERVE
- 1)
4048 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4051 /* Write out the section header names. */
4052 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4053 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4056 if (bed
->elf_backend_final_write_processing
)
4057 (*bed
->elf_backend_final_write_processing
) (abfd
,
4058 elf_tdata (abfd
)->linker
);
4060 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4064 _bfd_elf_write_corefile_contents (abfd
)
4067 /* Hopefully this can be done just like an object file. */
4068 return _bfd_elf_write_object_contents (abfd
);
4071 /* Given a section, search the header to find them. */
4074 _bfd_elf_section_from_bfd_section (abfd
, asect
)
4078 struct elf_backend_data
*bed
;
4081 if (elf_section_data (asect
) != NULL
4082 && elf_section_data (asect
)->this_idx
!= 0)
4083 return elf_section_data (asect
)->this_idx
;
4085 if (bfd_is_abs_section (asect
))
4087 else if (bfd_is_com_section (asect
))
4089 else if (bfd_is_und_section (asect
))
4093 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4094 int maxindex
= elf_numsections (abfd
);
4096 for (index
= 1; index
< maxindex
; index
++)
4098 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4100 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4106 bed
= get_elf_backend_data (abfd
);
4107 if (bed
->elf_backend_section_from_bfd_section
)
4111 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4116 bfd_set_error (bfd_error_nonrepresentable_section
);
4121 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4125 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
4127 asymbol
**asym_ptr_ptr
;
4129 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4131 flagword flags
= asym_ptr
->flags
;
4133 /* When gas creates relocations against local labels, it creates its
4134 own symbol for the section, but does put the symbol into the
4135 symbol chain, so udata is 0. When the linker is generating
4136 relocatable output, this section symbol may be for one of the
4137 input sections rather than the output section. */
4138 if (asym_ptr
->udata
.i
== 0
4139 && (flags
& BSF_SECTION_SYM
)
4140 && asym_ptr
->section
)
4144 if (asym_ptr
->section
->output_section
!= NULL
)
4145 indx
= asym_ptr
->section
->output_section
->index
;
4147 indx
= asym_ptr
->section
->index
;
4148 if (indx
< elf_num_section_syms (abfd
)
4149 && elf_section_syms (abfd
)[indx
] != NULL
)
4150 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4153 idx
= asym_ptr
->udata
.i
;
4157 /* This case can occur when using --strip-symbol on a symbol
4158 which is used in a relocation entry. */
4159 (*_bfd_error_handler
)
4160 (_("%s: symbol `%s' required but not present"),
4161 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4162 bfd_set_error (bfd_error_no_symbols
);
4169 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4170 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4171 elf_symbol_flags (flags
));
4179 /* Copy private BFD data. This copies any program header information. */
4182 copy_private_bfd_data (ibfd
, obfd
)
4186 Elf_Internal_Ehdr
* iehdr
;
4187 struct elf_segment_map
* map
;
4188 struct elf_segment_map
* map_first
;
4189 struct elf_segment_map
** pointer_to_map
;
4190 Elf_Internal_Phdr
* segment
;
4193 unsigned int num_segments
;
4194 boolean phdr_included
= false;
4195 bfd_vma maxpagesize
;
4196 struct elf_segment_map
* phdr_adjust_seg
= NULL
;
4197 unsigned int phdr_adjust_num
= 0;
4199 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4200 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4203 if (elf_tdata (ibfd
)->phdr
== NULL
)
4206 iehdr
= elf_elfheader (ibfd
);
4209 pointer_to_map
= &map_first
;
4211 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4212 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4214 /* Returns the end address of the segment + 1. */
4215 #define SEGMENT_END(segment, start) \
4216 (start + (segment->p_memsz > segment->p_filesz \
4217 ? segment->p_memsz : segment->p_filesz))
4219 /* Returns true if the given section is contained within
4220 the given segment. VMA addresses are compared. */
4221 #define IS_CONTAINED_BY_VMA(section, segment) \
4222 (section->vma >= segment->p_vaddr \
4223 && (section->vma + section->_raw_size) \
4224 <= (SEGMENT_END (segment, segment->p_vaddr)))
4226 /* Returns true if the given section is contained within
4227 the given segment. LMA addresses are compared. */
4228 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4229 (section->lma >= base \
4230 && (section->lma + section->_raw_size) \
4231 <= SEGMENT_END (segment, base))
4233 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4234 #define IS_COREFILE_NOTE(p, s) \
4235 (p->p_type == PT_NOTE \
4236 && bfd_get_format (ibfd) == bfd_core \
4237 && s->vma == 0 && s->lma == 0 \
4238 && (bfd_vma) s->filepos >= p->p_offset \
4239 && (bfd_vma) s->filepos + s->_raw_size \
4240 <= p->p_offset + p->p_filesz)
4242 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4243 linker, which generates a PT_INTERP section with p_vaddr and
4244 p_memsz set to 0. */
4245 #define IS_SOLARIS_PT_INTERP(p, s) \
4247 && p->p_filesz > 0 \
4248 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4249 && s->_raw_size > 0 \
4250 && (bfd_vma) s->filepos >= p->p_offset \
4251 && ((bfd_vma) s->filepos + s->_raw_size \
4252 <= p->p_offset + p->p_filesz))
4254 /* Decide if the given section should be included in the given segment.
4255 A section will be included if:
4256 1. It is within the address space of the segment -- we use the LMA
4257 if that is set for the segment and the VMA otherwise,
4258 2. It is an allocated segment,
4259 3. There is an output section associated with it,
4260 4. The section has not already been allocated to a previous segment. */
4261 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
4262 (((((segment->p_paddr \
4263 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4264 : IS_CONTAINED_BY_VMA (section, segment)) \
4265 || IS_SOLARIS_PT_INTERP (segment, section)) \
4266 && (section->flags & SEC_ALLOC) != 0) \
4267 || IS_COREFILE_NOTE (segment, section)) \
4268 && section->output_section != NULL \
4269 && section->segment_mark == false)
4271 /* Returns true iff seg1 starts after the end of seg2. */
4272 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4273 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4275 /* Returns true iff seg1 and seg2 overlap. */
4276 #define SEGMENT_OVERLAPS(seg1, seg2) \
4277 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4279 /* Initialise the segment mark field. */
4280 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4281 section
->segment_mark
= false;
4283 /* Scan through the segments specified in the program header
4284 of the input BFD. For this first scan we look for overlaps
4285 in the loadable segments. These can be created by weird
4286 parameters to objcopy. */
4287 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4292 Elf_Internal_Phdr
*segment2
;
4294 if (segment
->p_type
!= PT_LOAD
)
4297 /* Determine if this segment overlaps any previous segments. */
4298 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4300 bfd_signed_vma extra_length
;
4302 if (segment2
->p_type
!= PT_LOAD
4303 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4306 /* Merge the two segments together. */
4307 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4309 /* Extend SEGMENT2 to include SEGMENT and then delete
4312 SEGMENT_END (segment
, segment
->p_vaddr
)
4313 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4315 if (extra_length
> 0)
4317 segment2
->p_memsz
+= extra_length
;
4318 segment2
->p_filesz
+= extra_length
;
4321 segment
->p_type
= PT_NULL
;
4323 /* Since we have deleted P we must restart the outer loop. */
4325 segment
= elf_tdata (ibfd
)->phdr
;
4330 /* Extend SEGMENT to include SEGMENT2 and then delete
4333 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4334 - SEGMENT_END (segment
, segment
->p_vaddr
);
4336 if (extra_length
> 0)
4338 segment
->p_memsz
+= extra_length
;
4339 segment
->p_filesz
+= extra_length
;
4342 segment2
->p_type
= PT_NULL
;
4347 /* The second scan attempts to assign sections to segments. */
4348 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4352 unsigned int section_count
;
4353 asection
** sections
;
4354 asection
* output_section
;
4356 bfd_vma matching_lma
;
4357 bfd_vma suggested_lma
;
4361 if (segment
->p_type
== PT_NULL
)
4364 /* Compute how many sections might be placed into this segment. */
4366 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4367 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
))
4370 /* Allocate a segment map big enough to contain all of the
4371 sections we have selected. */
4372 amt
= sizeof (struct elf_segment_map
);
4373 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4374 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4378 /* Initialise the fields of the segment map. Default to
4379 using the physical address of the segment in the input BFD. */
4381 map
->p_type
= segment
->p_type
;
4382 map
->p_flags
= segment
->p_flags
;
4383 map
->p_flags_valid
= 1;
4384 map
->p_paddr
= segment
->p_paddr
;
4385 map
->p_paddr_valid
= 1;
4387 /* Determine if this segment contains the ELF file header
4388 and if it contains the program headers themselves. */
4389 map
->includes_filehdr
= (segment
->p_offset
== 0
4390 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4392 map
->includes_phdrs
= 0;
4394 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4396 map
->includes_phdrs
=
4397 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4398 && (segment
->p_offset
+ segment
->p_filesz
4399 >= ((bfd_vma
) iehdr
->e_phoff
4400 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4402 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4403 phdr_included
= true;
4406 if (section_count
== 0)
4408 /* Special segments, such as the PT_PHDR segment, may contain
4409 no sections, but ordinary, loadable segments should contain
4411 if (segment
->p_type
== PT_LOAD
)
4413 (_("%s: warning: Empty loadable segment detected\n"),
4414 bfd_archive_filename (ibfd
));
4417 *pointer_to_map
= map
;
4418 pointer_to_map
= &map
->next
;
4423 /* Now scan the sections in the input BFD again and attempt
4424 to add their corresponding output sections to the segment map.
4425 The problem here is how to handle an output section which has
4426 been moved (ie had its LMA changed). There are four possibilities:
4428 1. None of the sections have been moved.
4429 In this case we can continue to use the segment LMA from the
4432 2. All of the sections have been moved by the same amount.
4433 In this case we can change the segment's LMA to match the LMA
4434 of the first section.
4436 3. Some of the sections have been moved, others have not.
4437 In this case those sections which have not been moved can be
4438 placed in the current segment which will have to have its size,
4439 and possibly its LMA changed, and a new segment or segments will
4440 have to be created to contain the other sections.
4442 4. The sections have been moved, but not be the same amount.
4443 In this case we can change the segment's LMA to match the LMA
4444 of the first section and we will have to create a new segment
4445 or segments to contain the other sections.
4447 In order to save time, we allocate an array to hold the section
4448 pointers that we are interested in. As these sections get assigned
4449 to a segment, they are removed from this array. */
4451 amt
= (bfd_size_type
) section_count
* sizeof (asection
*);
4452 sections
= (asection
**) bfd_malloc (amt
);
4453 if (sections
== NULL
)
4456 /* Step One: Scan for segment vs section LMA conflicts.
4457 Also add the sections to the section array allocated above.
4458 Also add the sections to the current segment. In the common
4459 case, where the sections have not been moved, this means that
4460 we have completely filled the segment, and there is nothing
4466 for (j
= 0, section
= ibfd
->sections
;
4468 section
= section
->next
)
4470 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
))
4472 output_section
= section
->output_section
;
4474 sections
[j
++] = section
;
4476 /* The Solaris native linker always sets p_paddr to 0.
4477 We try to catch that case here, and set it to the
4479 if (segment
->p_paddr
== 0
4480 && segment
->p_vaddr
!= 0
4482 && output_section
->lma
!= 0
4483 && (output_section
->vma
== (segment
->p_vaddr
4484 + (map
->includes_filehdr
4487 + (map
->includes_phdrs
4489 * iehdr
->e_phentsize
)
4491 map
->p_paddr
= segment
->p_vaddr
;
4493 /* Match up the physical address of the segment with the
4494 LMA address of the output section. */
4495 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4496 || IS_COREFILE_NOTE (segment
, section
))
4498 if (matching_lma
== 0)
4499 matching_lma
= output_section
->lma
;
4501 /* We assume that if the section fits within the segment
4502 then it does not overlap any other section within that
4504 map
->sections
[isec
++] = output_section
;
4506 else if (suggested_lma
== 0)
4507 suggested_lma
= output_section
->lma
;
4511 BFD_ASSERT (j
== section_count
);
4513 /* Step Two: Adjust the physical address of the current segment,
4515 if (isec
== section_count
)
4517 /* All of the sections fitted within the segment as currently
4518 specified. This is the default case. Add the segment to
4519 the list of built segments and carry on to process the next
4520 program header in the input BFD. */
4521 map
->count
= section_count
;
4522 *pointer_to_map
= map
;
4523 pointer_to_map
= &map
->next
;
4530 if (matching_lma
!= 0)
4532 /* At least one section fits inside the current segment.
4533 Keep it, but modify its physical address to match the
4534 LMA of the first section that fitted. */
4535 map
->p_paddr
= matching_lma
;
4539 /* None of the sections fitted inside the current segment.
4540 Change the current segment's physical address to match
4541 the LMA of the first section. */
4542 map
->p_paddr
= suggested_lma
;
4545 /* Offset the segment physical address from the lma
4546 to allow for space taken up by elf headers. */
4547 if (map
->includes_filehdr
)
4548 map
->p_paddr
-= iehdr
->e_ehsize
;
4550 if (map
->includes_phdrs
)
4552 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
4554 /* iehdr->e_phnum is just an estimate of the number
4555 of program headers that we will need. Make a note
4556 here of the number we used and the segment we chose
4557 to hold these headers, so that we can adjust the
4558 offset when we know the correct value. */
4559 phdr_adjust_num
= iehdr
->e_phnum
;
4560 phdr_adjust_seg
= map
;
4564 /* Step Three: Loop over the sections again, this time assigning
4565 those that fit to the current segment and remvoing them from the
4566 sections array; but making sure not to leave large gaps. Once all
4567 possible sections have been assigned to the current segment it is
4568 added to the list of built segments and if sections still remain
4569 to be assigned, a new segment is constructed before repeating
4577 /* Fill the current segment with sections that fit. */
4578 for (j
= 0; j
< section_count
; j
++)
4580 section
= sections
[j
];
4582 if (section
== NULL
)
4585 output_section
= section
->output_section
;
4587 BFD_ASSERT (output_section
!= NULL
);
4589 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4590 || IS_COREFILE_NOTE (segment
, section
))
4592 if (map
->count
== 0)
4594 /* If the first section in a segment does not start at
4595 the beginning of the segment, then something is
4597 if (output_section
->lma
!=
4599 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
4600 + (map
->includes_phdrs
4601 ? iehdr
->e_phnum
* iehdr
->e_phentsize
4607 asection
* prev_sec
;
4609 prev_sec
= map
->sections
[map
->count
- 1];
4611 /* If the gap between the end of the previous section
4612 and the start of this section is more than
4613 maxpagesize then we need to start a new segment. */
4614 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
,
4616 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
4617 || ((prev_sec
->lma
+ prev_sec
->_raw_size
)
4618 > output_section
->lma
))
4620 if (suggested_lma
== 0)
4621 suggested_lma
= output_section
->lma
;
4627 map
->sections
[map
->count
++] = output_section
;
4630 section
->segment_mark
= true;
4632 else if (suggested_lma
== 0)
4633 suggested_lma
= output_section
->lma
;
4636 BFD_ASSERT (map
->count
> 0);
4638 /* Add the current segment to the list of built segments. */
4639 *pointer_to_map
= map
;
4640 pointer_to_map
= &map
->next
;
4642 if (isec
< section_count
)
4644 /* We still have not allocated all of the sections to
4645 segments. Create a new segment here, initialise it
4646 and carry on looping. */
4647 amt
= sizeof (struct elf_segment_map
);
4648 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4649 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4653 /* Initialise the fields of the segment map. Set the physical
4654 physical address to the LMA of the first section that has
4655 not yet been assigned. */
4657 map
->p_type
= segment
->p_type
;
4658 map
->p_flags
= segment
->p_flags
;
4659 map
->p_flags_valid
= 1;
4660 map
->p_paddr
= suggested_lma
;
4661 map
->p_paddr_valid
= 1;
4662 map
->includes_filehdr
= 0;
4663 map
->includes_phdrs
= 0;
4666 while (isec
< section_count
);
4671 /* The Solaris linker creates program headers in which all the
4672 p_paddr fields are zero. When we try to objcopy or strip such a
4673 file, we get confused. Check for this case, and if we find it
4674 reset the p_paddr_valid fields. */
4675 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
4676 if (map
->p_paddr
!= 0)
4680 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
4681 map
->p_paddr_valid
= 0;
4684 elf_tdata (obfd
)->segment_map
= map_first
;
4686 /* If we had to estimate the number of program headers that were
4687 going to be needed, then check our estimate now and adjust
4688 the offset if necessary. */
4689 if (phdr_adjust_seg
!= NULL
)
4693 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
4696 if (count
> phdr_adjust_num
)
4697 phdr_adjust_seg
->p_paddr
4698 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
4702 /* Final Step: Sort the segments into ascending order of physical
4704 if (map_first
!= NULL
)
4706 struct elf_segment_map
*prev
;
4709 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
4711 /* Yes I know - its a bubble sort.... */
4712 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
4714 /* Swap map and map->next. */
4715 prev
->next
= map
->next
;
4716 map
->next
= map
->next
->next
;
4717 prev
->next
->next
= map
;
4727 #undef IS_CONTAINED_BY_VMA
4728 #undef IS_CONTAINED_BY_LMA
4729 #undef IS_COREFILE_NOTE
4730 #undef IS_SOLARIS_PT_INTERP
4731 #undef INCLUDE_SECTION_IN_SEGMENT
4732 #undef SEGMENT_AFTER_SEGMENT
4733 #undef SEGMENT_OVERLAPS
4737 /* Copy private section information. This copies over the entsize
4738 field, and sometimes the info field. */
4741 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
4747 Elf_Internal_Shdr
*ihdr
, *ohdr
;
4749 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
4750 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
4753 /* Copy over private BFD data if it has not already been copied.
4754 This must be done here, rather than in the copy_private_bfd_data
4755 entry point, because the latter is called after the section
4756 contents have been set, which means that the program headers have
4757 already been worked out. */
4758 if (elf_tdata (obfd
)->segment_map
== NULL
4759 && elf_tdata (ibfd
)->phdr
!= NULL
)
4763 /* Only set up the segments if there are no more SEC_ALLOC
4764 sections. FIXME: This won't do the right thing if objcopy is
4765 used to remove the last SEC_ALLOC section, since objcopy
4766 won't call this routine in that case. */
4767 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
4768 if ((s
->flags
& SEC_ALLOC
) != 0)
4772 if (! copy_private_bfd_data (ibfd
, obfd
))
4777 ihdr
= &elf_section_data (isec
)->this_hdr
;
4778 ohdr
= &elf_section_data (osec
)->this_hdr
;
4780 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
4782 if (ihdr
->sh_type
== SHT_SYMTAB
4783 || ihdr
->sh_type
== SHT_DYNSYM
4784 || ihdr
->sh_type
== SHT_GNU_verneed
4785 || ihdr
->sh_type
== SHT_GNU_verdef
)
4786 ohdr
->sh_info
= ihdr
->sh_info
;
4788 elf_section_data (osec
)->use_rela_p
4789 = elf_section_data (isec
)->use_rela_p
;
4794 /* Copy private symbol information. If this symbol is in a section
4795 which we did not map into a BFD section, try to map the section
4796 index correctly. We use special macro definitions for the mapped
4797 section indices; these definitions are interpreted by the
4798 swap_out_syms function. */
4800 #define MAP_ONESYMTAB (SHN_HIOS + 1)
4801 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
4802 #define MAP_STRTAB (SHN_HIOS + 3)
4803 #define MAP_SHSTRTAB (SHN_HIOS + 4)
4804 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
4807 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
4813 elf_symbol_type
*isym
, *osym
;
4815 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4816 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4819 isym
= elf_symbol_from (ibfd
, isymarg
);
4820 osym
= elf_symbol_from (obfd
, osymarg
);
4824 && bfd_is_abs_section (isym
->symbol
.section
))
4828 shndx
= isym
->internal_elf_sym
.st_shndx
;
4829 if (shndx
== elf_onesymtab (ibfd
))
4830 shndx
= MAP_ONESYMTAB
;
4831 else if (shndx
== elf_dynsymtab (ibfd
))
4832 shndx
= MAP_DYNSYMTAB
;
4833 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
4835 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
4836 shndx
= MAP_SHSTRTAB
;
4837 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
4838 shndx
= MAP_SYM_SHNDX
;
4839 osym
->internal_elf_sym
.st_shndx
= shndx
;
4845 /* Swap out the symbols. */
4848 swap_out_syms (abfd
, sttp
, relocatable_p
)
4850 struct bfd_strtab_hash
**sttp
;
4853 struct elf_backend_data
*bed
;
4856 struct bfd_strtab_hash
*stt
;
4857 Elf_Internal_Shdr
*symtab_hdr
;
4858 Elf_Internal_Shdr
*symtab_shndx_hdr
;
4859 Elf_Internal_Shdr
*symstrtab_hdr
;
4860 char *outbound_syms
;
4861 char *outbound_shndx
;
4865 if (!elf_map_symbols (abfd
))
4868 /* Dump out the symtabs. */
4869 stt
= _bfd_elf_stringtab_init ();
4873 bed
= get_elf_backend_data (abfd
);
4874 symcount
= bfd_get_symcount (abfd
);
4875 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4876 symtab_hdr
->sh_type
= SHT_SYMTAB
;
4877 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
4878 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
4879 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
4880 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
4882 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4883 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4885 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
4886 outbound_syms
= bfd_alloc (abfd
, amt
);
4887 if (outbound_syms
== NULL
)
4889 symtab_hdr
->contents
= (PTR
) outbound_syms
;
4891 outbound_shndx
= NULL
;
4892 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
4893 if (symtab_shndx_hdr
->sh_name
!= 0)
4895 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
4896 outbound_shndx
= bfd_alloc (abfd
, amt
);
4897 if (outbound_shndx
== NULL
)
4899 memset (outbound_shndx
, 0, (unsigned long) amt
);
4900 symtab_shndx_hdr
->contents
= outbound_shndx
;
4901 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
4902 symtab_shndx_hdr
->sh_size
= amt
;
4903 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
4904 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
4907 /* now generate the data (for "contents") */
4909 /* Fill in zeroth symbol and swap it out. */
4910 Elf_Internal_Sym sym
;
4916 sym
.st_shndx
= SHN_UNDEF
;
4917 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
4918 outbound_syms
+= bed
->s
->sizeof_sym
;
4919 if (outbound_shndx
!= NULL
)
4920 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
4923 syms
= bfd_get_outsymbols (abfd
);
4924 for (idx
= 0; idx
< symcount
; idx
++)
4926 Elf_Internal_Sym sym
;
4927 bfd_vma value
= syms
[idx
]->value
;
4928 elf_symbol_type
*type_ptr
;
4929 flagword flags
= syms
[idx
]->flags
;
4932 if ((flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
4934 /* Local section symbols have no name. */
4939 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
4942 if (sym
.st_name
== (unsigned long) -1)
4946 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
4948 if ((flags
& BSF_SECTION_SYM
) == 0
4949 && bfd_is_com_section (syms
[idx
]->section
))
4951 /* ELF common symbols put the alignment into the `value' field,
4952 and the size into the `size' field. This is backwards from
4953 how BFD handles it, so reverse it here. */
4954 sym
.st_size
= value
;
4955 if (type_ptr
== NULL
4956 || type_ptr
->internal_elf_sym
.st_value
== 0)
4957 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
4959 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
4960 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
4961 (abfd
, syms
[idx
]->section
);
4965 asection
*sec
= syms
[idx
]->section
;
4968 if (sec
->output_section
)
4970 value
+= sec
->output_offset
;
4971 sec
= sec
->output_section
;
4973 /* Don't add in the section vma for relocatable output. */
4974 if (! relocatable_p
)
4976 sym
.st_value
= value
;
4977 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4979 if (bfd_is_abs_section (sec
)
4981 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4983 /* This symbol is in a real ELF section which we did
4984 not create as a BFD section. Undo the mapping done
4985 by copy_private_symbol_data. */
4986 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
4990 shndx
= elf_onesymtab (abfd
);
4993 shndx
= elf_dynsymtab (abfd
);
4996 shndx
= elf_tdata (abfd
)->strtab_section
;
4999 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5002 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5010 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5016 /* Writing this would be a hell of a lot easier if
5017 we had some decent documentation on bfd, and
5018 knew what to expect of the library, and what to
5019 demand of applications. For example, it
5020 appears that `objcopy' might not set the
5021 section of a symbol to be a section that is
5022 actually in the output file. */
5023 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5024 BFD_ASSERT (sec2
!= 0);
5025 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5026 BFD_ASSERT (shndx
!= -1);
5030 sym
.st_shndx
= shndx
;
5033 if ((flags
& BSF_FUNCTION
) != 0)
5035 else if ((flags
& BSF_OBJECT
) != 0)
5040 /* Processor-specific types */
5041 if (type_ptr
!= NULL
5042 && bed
->elf_backend_get_symbol_type
)
5043 type
= ((*bed
->elf_backend_get_symbol_type
)
5044 (&type_ptr
->internal_elf_sym
, type
));
5046 if (flags
& BSF_SECTION_SYM
)
5048 if (flags
& BSF_GLOBAL
)
5049 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5051 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5053 else if (bfd_is_com_section (syms
[idx
]->section
))
5054 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5055 else if (bfd_is_und_section (syms
[idx
]->section
))
5056 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5060 else if (flags
& BSF_FILE
)
5061 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5064 int bind
= STB_LOCAL
;
5066 if (flags
& BSF_LOCAL
)
5068 else if (flags
& BSF_WEAK
)
5070 else if (flags
& BSF_GLOBAL
)
5073 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5076 if (type_ptr
!= NULL
)
5077 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5081 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5082 outbound_syms
+= bed
->s
->sizeof_sym
;
5083 if (outbound_shndx
!= NULL
)
5084 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5088 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5089 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5091 symstrtab_hdr
->sh_flags
= 0;
5092 symstrtab_hdr
->sh_addr
= 0;
5093 symstrtab_hdr
->sh_entsize
= 0;
5094 symstrtab_hdr
->sh_link
= 0;
5095 symstrtab_hdr
->sh_info
= 0;
5096 symstrtab_hdr
->sh_addralign
= 1;
5101 /* Return the number of bytes required to hold the symtab vector.
5103 Note that we base it on the count plus 1, since we will null terminate
5104 the vector allocated based on this size. However, the ELF symbol table
5105 always has a dummy entry as symbol #0, so it ends up even. */
5108 _bfd_elf_get_symtab_upper_bound (abfd
)
5113 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5115 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5116 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5118 symtab_size
-= sizeof (asymbol
*);
5124 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
5129 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5131 if (elf_dynsymtab (abfd
) == 0)
5133 bfd_set_error (bfd_error_invalid_operation
);
5137 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5138 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5140 symtab_size
-= sizeof (asymbol
*);
5146 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
5147 bfd
*abfd ATTRIBUTE_UNUSED
;
5150 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5153 /* Canonicalize the relocs. */
5156 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5164 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5166 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
5169 tblptr
= section
->relocation
;
5170 for (i
= 0; i
< section
->reloc_count
; i
++)
5171 *relptr
++ = tblptr
++;
5175 return section
->reloc_count
;
5179 _bfd_elf_get_symtab (abfd
, alocation
)
5181 asymbol
**alocation
;
5183 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5184 long symcount
= bed
->s
->slurp_symbol_table (abfd
, alocation
, false);
5187 bfd_get_symcount (abfd
) = symcount
;
5192 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
5194 asymbol
**alocation
;
5196 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5197 return bed
->s
->slurp_symbol_table (abfd
, alocation
, true);
5200 /* Return the size required for the dynamic reloc entries. Any
5201 section that was actually installed in the BFD, and has type
5202 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5203 considered to be a dynamic reloc section. */
5206 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
5212 if (elf_dynsymtab (abfd
) == 0)
5214 bfd_set_error (bfd_error_invalid_operation
);
5218 ret
= sizeof (arelent
*);
5219 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5220 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5221 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5222 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5223 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5224 * sizeof (arelent
*));
5229 /* Canonicalize the dynamic relocation entries. Note that we return
5230 the dynamic relocations as a single block, although they are
5231 actually associated with particular sections; the interface, which
5232 was designed for SunOS style shared libraries, expects that there
5233 is only one set of dynamic relocs. Any section that was actually
5234 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5235 the dynamic symbol table, is considered to be a dynamic reloc
5239 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
5244 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
5248 if (elf_dynsymtab (abfd
) == 0)
5250 bfd_set_error (bfd_error_invalid_operation
);
5254 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5256 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5258 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5259 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5260 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5265 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
5267 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5269 for (i
= 0; i
< count
; i
++)
5280 /* Read in the version information. */
5283 _bfd_elf_slurp_version_tables (abfd
)
5286 bfd_byte
*contents
= NULL
;
5289 if (elf_dynverdef (abfd
) != 0)
5291 Elf_Internal_Shdr
*hdr
;
5292 Elf_External_Verdef
*everdef
;
5293 Elf_Internal_Verdef
*iverdef
;
5294 Elf_Internal_Verdef
*iverdefarr
;
5295 Elf_Internal_Verdef iverdefmem
;
5297 unsigned int maxidx
;
5299 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5301 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5302 if (contents
== NULL
)
5304 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5305 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5308 /* We know the number of entries in the section but not the maximum
5309 index. Therefore we have to run through all entries and find
5311 everdef
= (Elf_External_Verdef
*) contents
;
5313 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5315 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5317 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5318 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5320 everdef
= ((Elf_External_Verdef
*)
5321 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5324 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5325 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
5326 if (elf_tdata (abfd
)->verdef
== NULL
)
5329 elf_tdata (abfd
)->cverdefs
= maxidx
;
5331 everdef
= (Elf_External_Verdef
*) contents
;
5332 iverdefarr
= elf_tdata (abfd
)->verdef
;
5333 for (i
= 0; i
< hdr
->sh_info
; i
++)
5335 Elf_External_Verdaux
*everdaux
;
5336 Elf_Internal_Verdaux
*iverdaux
;
5339 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5341 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5342 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5344 iverdef
->vd_bfd
= abfd
;
5346 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5347 iverdef
->vd_auxptr
= (Elf_Internal_Verdaux
*) bfd_alloc (abfd
, amt
);
5348 if (iverdef
->vd_auxptr
== NULL
)
5351 everdaux
= ((Elf_External_Verdaux
*)
5352 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5353 iverdaux
= iverdef
->vd_auxptr
;
5354 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5356 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5358 iverdaux
->vda_nodename
=
5359 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5360 iverdaux
->vda_name
);
5361 if (iverdaux
->vda_nodename
== NULL
)
5364 if (j
+ 1 < iverdef
->vd_cnt
)
5365 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5367 iverdaux
->vda_nextptr
= NULL
;
5369 everdaux
= ((Elf_External_Verdaux
*)
5370 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5373 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5375 if (i
+ 1 < hdr
->sh_info
)
5376 iverdef
->vd_nextdef
= iverdef
+ 1;
5378 iverdef
->vd_nextdef
= NULL
;
5380 everdef
= ((Elf_External_Verdef
*)
5381 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5388 if (elf_dynverref (abfd
) != 0)
5390 Elf_Internal_Shdr
*hdr
;
5391 Elf_External_Verneed
*everneed
;
5392 Elf_Internal_Verneed
*iverneed
;
5395 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5397 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5398 elf_tdata (abfd
)->verref
=
5399 (Elf_Internal_Verneed
*) bfd_zalloc (abfd
, amt
);
5400 if (elf_tdata (abfd
)->verref
== NULL
)
5403 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5405 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5406 if (contents
== NULL
)
5408 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5409 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5412 everneed
= (Elf_External_Verneed
*) contents
;
5413 iverneed
= elf_tdata (abfd
)->verref
;
5414 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
5416 Elf_External_Vernaux
*evernaux
;
5417 Elf_Internal_Vernaux
*ivernaux
;
5420 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
5422 iverneed
->vn_bfd
= abfd
;
5424 iverneed
->vn_filename
=
5425 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5427 if (iverneed
->vn_filename
== NULL
)
5430 amt
= iverneed
->vn_cnt
;
5431 amt
*= sizeof (Elf_Internal_Vernaux
);
5432 iverneed
->vn_auxptr
= (Elf_Internal_Vernaux
*) bfd_alloc (abfd
, amt
);
5434 evernaux
= ((Elf_External_Vernaux
*)
5435 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
5436 ivernaux
= iverneed
->vn_auxptr
;
5437 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
5439 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
5441 ivernaux
->vna_nodename
=
5442 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5443 ivernaux
->vna_name
);
5444 if (ivernaux
->vna_nodename
== NULL
)
5447 if (j
+ 1 < iverneed
->vn_cnt
)
5448 ivernaux
->vna_nextptr
= ivernaux
+ 1;
5450 ivernaux
->vna_nextptr
= NULL
;
5452 evernaux
= ((Elf_External_Vernaux
*)
5453 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
5456 if (i
+ 1 < hdr
->sh_info
)
5457 iverneed
->vn_nextref
= iverneed
+ 1;
5459 iverneed
->vn_nextref
= NULL
;
5461 everneed
= ((Elf_External_Verneed
*)
5462 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
5472 if (contents
== NULL
)
5478 _bfd_elf_make_empty_symbol (abfd
)
5481 elf_symbol_type
*newsym
;
5482 bfd_size_type amt
= sizeof (elf_symbol_type
);
5484 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
5489 newsym
->symbol
.the_bfd
= abfd
;
5490 return &newsym
->symbol
;
5495 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
5496 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5500 bfd_symbol_info (symbol
, ret
);
5503 /* Return whether a symbol name implies a local symbol. Most targets
5504 use this function for the is_local_label_name entry point, but some
5508 _bfd_elf_is_local_label_name (abfd
, name
)
5509 bfd
*abfd ATTRIBUTE_UNUSED
;
5512 /* Normal local symbols start with ``.L''. */
5513 if (name
[0] == '.' && name
[1] == 'L')
5516 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5517 DWARF debugging symbols starting with ``..''. */
5518 if (name
[0] == '.' && name
[1] == '.')
5521 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5522 emitting DWARF debugging output. I suspect this is actually a
5523 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5524 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5525 underscore to be emitted on some ELF targets). For ease of use,
5526 we treat such symbols as local. */
5527 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
5534 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
5535 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5536 asymbol
*symbol ATTRIBUTE_UNUSED
;
5543 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
5545 enum bfd_architecture arch
;
5546 unsigned long machine
;
5548 /* If this isn't the right architecture for this backend, and this
5549 isn't the generic backend, fail. */
5550 if (arch
!= get_elf_backend_data (abfd
)->arch
5551 && arch
!= bfd_arch_unknown
5552 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
5555 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5558 /* Find the function to a particular section and offset,
5559 for error reporting. */
5562 elf_find_function (abfd
, section
, symbols
, offset
,
5563 filename_ptr
, functionname_ptr
)
5564 bfd
*abfd ATTRIBUTE_UNUSED
;
5568 const char **filename_ptr
;
5569 const char **functionname_ptr
;
5571 const char *filename
;
5580 for (p
= symbols
; *p
!= NULL
; p
++)
5584 q
= (elf_symbol_type
*) *p
;
5586 if (bfd_get_section (&q
->symbol
) != section
)
5589 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
5594 filename
= bfd_asymbol_name (&q
->symbol
);
5598 if (q
->symbol
.section
== section
5599 && q
->symbol
.value
>= low_func
5600 && q
->symbol
.value
<= offset
)
5602 func
= (asymbol
*) q
;
5603 low_func
= q
->symbol
.value
;
5613 *filename_ptr
= filename
;
5614 if (functionname_ptr
)
5615 *functionname_ptr
= bfd_asymbol_name (func
);
5620 /* Find the nearest line to a particular section and offset,
5621 for error reporting. */
5624 _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
5625 filename_ptr
, functionname_ptr
, line_ptr
)
5630 const char **filename_ptr
;
5631 const char **functionname_ptr
;
5632 unsigned int *line_ptr
;
5636 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
5637 filename_ptr
, functionname_ptr
,
5640 if (!*functionname_ptr
)
5641 elf_find_function (abfd
, section
, symbols
, offset
,
5642 *filename_ptr
? NULL
: filename_ptr
,
5648 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
5649 filename_ptr
, functionname_ptr
,
5651 &elf_tdata (abfd
)->dwarf2_find_line_info
))
5653 if (!*functionname_ptr
)
5654 elf_find_function (abfd
, section
, symbols
, offset
,
5655 *filename_ptr
? NULL
: filename_ptr
,
5661 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
5662 &found
, filename_ptr
,
5663 functionname_ptr
, line_ptr
,
5664 &elf_tdata (abfd
)->line_info
))
5669 if (symbols
== NULL
)
5672 if (! elf_find_function (abfd
, section
, symbols
, offset
,
5673 filename_ptr
, functionname_ptr
))
5681 _bfd_elf_sizeof_headers (abfd
, reloc
)
5687 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
5689 ret
+= get_program_header_size (abfd
);
5694 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
5699 bfd_size_type count
;
5701 Elf_Internal_Shdr
*hdr
;
5704 if (! abfd
->output_has_begun
5705 && ! _bfd_elf_compute_section_file_positions
5706 (abfd
, (struct bfd_link_info
*) NULL
))
5709 hdr
= &elf_section_data (section
)->this_hdr
;
5710 pos
= hdr
->sh_offset
+ offset
;
5711 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
5712 || bfd_bwrite (location
, count
, abfd
) != count
)
5719 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
5720 bfd
*abfd ATTRIBUTE_UNUSED
;
5721 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
5722 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
5729 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
5732 Elf_Internal_Rel
*dst
;
5738 /* Try to convert a non-ELF reloc into an ELF one. */
5741 _bfd_elf_validate_reloc (abfd
, areloc
)
5745 /* Check whether we really have an ELF howto. */
5747 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
5749 bfd_reloc_code_real_type code
;
5750 reloc_howto_type
*howto
;
5752 /* Alien reloc: Try to determine its type to replace it with an
5753 equivalent ELF reloc. */
5755 if (areloc
->howto
->pc_relative
)
5757 switch (areloc
->howto
->bitsize
)
5760 code
= BFD_RELOC_8_PCREL
;
5763 code
= BFD_RELOC_12_PCREL
;
5766 code
= BFD_RELOC_16_PCREL
;
5769 code
= BFD_RELOC_24_PCREL
;
5772 code
= BFD_RELOC_32_PCREL
;
5775 code
= BFD_RELOC_64_PCREL
;
5781 howto
= bfd_reloc_type_lookup (abfd
, code
);
5783 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
5785 if (howto
->pcrel_offset
)
5786 areloc
->addend
+= areloc
->address
;
5788 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
5793 switch (areloc
->howto
->bitsize
)
5799 code
= BFD_RELOC_14
;
5802 code
= BFD_RELOC_16
;
5805 code
= BFD_RELOC_26
;
5808 code
= BFD_RELOC_32
;
5811 code
= BFD_RELOC_64
;
5817 howto
= bfd_reloc_type_lookup (abfd
, code
);
5821 areloc
->howto
= howto
;
5829 (*_bfd_error_handler
)
5830 (_("%s: unsupported relocation type %s"),
5831 bfd_archive_filename (abfd
), areloc
->howto
->name
);
5832 bfd_set_error (bfd_error_bad_value
);
5837 _bfd_elf_close_and_cleanup (abfd
)
5840 if (bfd_get_format (abfd
) == bfd_object
)
5842 if (elf_shstrtab (abfd
) != NULL
)
5843 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
5846 return _bfd_generic_close_and_cleanup (abfd
);
5849 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5850 in the relocation's offset. Thus we cannot allow any sort of sanity
5851 range-checking to interfere. There is nothing else to do in processing
5854 bfd_reloc_status_type
5855 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
5856 bfd
*abfd ATTRIBUTE_UNUSED
;
5857 arelent
*re ATTRIBUTE_UNUSED
;
5858 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
5859 PTR data ATTRIBUTE_UNUSED
;
5860 asection
*is ATTRIBUTE_UNUSED
;
5861 bfd
*obfd ATTRIBUTE_UNUSED
;
5862 char **errmsg ATTRIBUTE_UNUSED
;
5864 return bfd_reloc_ok
;
5867 /* Elf core file support. Much of this only works on native
5868 toolchains, since we rely on knowing the
5869 machine-dependent procfs structure in order to pick
5870 out details about the corefile. */
5872 #ifdef HAVE_SYS_PROCFS_H
5873 # include <sys/procfs.h>
5876 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5879 elfcore_make_pid (abfd
)
5882 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
5883 + (elf_tdata (abfd
)->core_pid
));
5886 /* If there isn't a section called NAME, make one, using
5887 data from SECT. Note, this function will generate a
5888 reference to NAME, so you shouldn't deallocate or
5892 elfcore_maybe_make_sect (abfd
, name
, sect
)
5899 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
5902 sect2
= bfd_make_section (abfd
, name
);
5906 sect2
->_raw_size
= sect
->_raw_size
;
5907 sect2
->filepos
= sect
->filepos
;
5908 sect2
->flags
= sect
->flags
;
5909 sect2
->alignment_power
= sect
->alignment_power
;
5913 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
5914 actually creates up to two pseudosections:
5915 - For the single-threaded case, a section named NAME, unless
5916 such a section already exists.
5917 - For the multi-threaded case, a section named "NAME/PID", where
5918 PID is elfcore_make_pid (abfd).
5919 Both pseudosections have identical contents. */
5921 _bfd_elfcore_make_pseudosection (abfd
, name
, size
, filepos
)
5928 char *threaded_name
;
5931 /* Build the section name. */
5933 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
5934 threaded_name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
5935 if (threaded_name
== NULL
)
5937 strcpy (threaded_name
, buf
);
5939 sect
= bfd_make_section (abfd
, threaded_name
);
5942 sect
->_raw_size
= size
;
5943 sect
->filepos
= filepos
;
5944 sect
->flags
= SEC_HAS_CONTENTS
;
5945 sect
->alignment_power
= 2;
5947 return elfcore_maybe_make_sect (abfd
, name
, sect
);
5950 /* prstatus_t exists on:
5952 linux 2.[01] + glibc
5956 #if defined (HAVE_PRSTATUS_T)
5957 static boolean elfcore_grok_prstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
5960 elfcore_grok_prstatus (abfd
, note
)
5962 Elf_Internal_Note
*note
;
5967 if (note
->descsz
== sizeof (prstatus_t
))
5971 raw_size
= sizeof (prstat
.pr_reg
);
5972 offset
= offsetof (prstatus_t
, pr_reg
);
5973 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
5975 /* Do not overwrite the core signal if it
5976 has already been set by another thread. */
5977 if (elf_tdata (abfd
)->core_signal
== 0)
5978 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
5979 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
5981 /* pr_who exists on:
5984 pr_who doesn't exist on:
5987 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5988 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
5991 #if defined (HAVE_PRSTATUS32_T)
5992 else if (note
->descsz
== sizeof (prstatus32_t
))
5994 /* 64-bit host, 32-bit corefile */
5995 prstatus32_t prstat
;
5997 raw_size
= sizeof (prstat
.pr_reg
);
5998 offset
= offsetof (prstatus32_t
, pr_reg
);
5999 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6001 /* Do not overwrite the core signal if it
6002 has already been set by another thread. */
6003 if (elf_tdata (abfd
)->core_signal
== 0)
6004 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6005 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6007 /* pr_who exists on:
6010 pr_who doesn't exist on:
6013 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6014 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6017 #endif /* HAVE_PRSTATUS32_T */
6020 /* Fail - we don't know how to handle any other
6021 note size (ie. data object type). */
6025 /* Make a ".reg/999" section and a ".reg" section. */
6026 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6027 raw_size
, note
->descpos
+ offset
);
6029 #endif /* defined (HAVE_PRSTATUS_T) */
6031 /* Create a pseudosection containing the exact contents of NOTE. */
6033 elfcore_make_note_pseudosection (abfd
, name
, note
)
6036 Elf_Internal_Note
*note
;
6038 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6039 note
->descsz
, note
->descpos
);
6042 /* There isn't a consistent prfpregset_t across platforms,
6043 but it doesn't matter, because we don't have to pick this
6044 data structure apart. */
6047 elfcore_grok_prfpreg (abfd
, note
)
6049 Elf_Internal_Note
*note
;
6051 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6054 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6055 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6059 elfcore_grok_prxfpreg (abfd
, note
)
6061 Elf_Internal_Note
*note
;
6063 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6066 #if defined (HAVE_PRPSINFO_T)
6067 typedef prpsinfo_t elfcore_psinfo_t
;
6068 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6069 typedef prpsinfo32_t elfcore_psinfo32_t
;
6073 #if defined (HAVE_PSINFO_T)
6074 typedef psinfo_t elfcore_psinfo_t
;
6075 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6076 typedef psinfo32_t elfcore_psinfo32_t
;
6080 /* return a malloc'ed copy of a string at START which is at
6081 most MAX bytes long, possibly without a terminating '\0'.
6082 the copy will always have a terminating '\0'. */
6085 _bfd_elfcore_strndup (abfd
, start
, max
)
6091 char *end
= memchr (start
, '\0', max
);
6099 dups
= bfd_alloc (abfd
, (bfd_size_type
) len
+ 1);
6103 memcpy (dups
, start
, len
);
6109 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6110 static boolean elfcore_grok_psinfo
PARAMS ((bfd
*, Elf_Internal_Note
*));
6113 elfcore_grok_psinfo (abfd
, note
)
6115 Elf_Internal_Note
*note
;
6117 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6119 elfcore_psinfo_t psinfo
;
6121 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6123 elf_tdata (abfd
)->core_program
6124 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6125 sizeof (psinfo
.pr_fname
));
6127 elf_tdata (abfd
)->core_command
6128 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6129 sizeof (psinfo
.pr_psargs
));
6131 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6132 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6134 /* 64-bit host, 32-bit corefile */
6135 elfcore_psinfo32_t psinfo
;
6137 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6139 elf_tdata (abfd
)->core_program
6140 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6141 sizeof (psinfo
.pr_fname
));
6143 elf_tdata (abfd
)->core_command
6144 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6145 sizeof (psinfo
.pr_psargs
));
6151 /* Fail - we don't know how to handle any other
6152 note size (ie. data object type). */
6156 /* Note that for some reason, a spurious space is tacked
6157 onto the end of the args in some (at least one anyway)
6158 implementations, so strip it off if it exists. */
6161 char *command
= elf_tdata (abfd
)->core_command
;
6162 int n
= strlen (command
);
6164 if (0 < n
&& command
[n
- 1] == ' ')
6165 command
[n
- 1] = '\0';
6170 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6172 #if defined (HAVE_PSTATUS_T)
6173 static boolean elfcore_grok_pstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
6176 elfcore_grok_pstatus (abfd
, note
)
6178 Elf_Internal_Note
*note
;
6180 if (note
->descsz
== sizeof (pstatus_t
)
6181 #if defined (HAVE_PXSTATUS_T)
6182 || note
->descsz
== sizeof (pxstatus_t
)
6188 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6190 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6192 #if defined (HAVE_PSTATUS32_T)
6193 else if (note
->descsz
== sizeof (pstatus32_t
))
6195 /* 64-bit host, 32-bit corefile */
6198 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6200 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6203 /* Could grab some more details from the "representative"
6204 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6205 NT_LWPSTATUS note, presumably. */
6209 #endif /* defined (HAVE_PSTATUS_T) */
6211 #if defined (HAVE_LWPSTATUS_T)
6212 static boolean elfcore_grok_lwpstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
6215 elfcore_grok_lwpstatus (abfd
, note
)
6217 Elf_Internal_Note
*note
;
6219 lwpstatus_t lwpstat
;
6224 if (note
->descsz
!= sizeof (lwpstat
)
6225 #if defined (HAVE_LWPXSTATUS_T)
6226 && note
->descsz
!= sizeof (lwpxstatus_t
)
6231 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6233 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6234 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6236 /* Make a ".reg/999" section. */
6238 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6239 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6244 sect
= bfd_make_section (abfd
, name
);
6248 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6249 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6250 sect
->filepos
= note
->descpos
6251 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6254 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6255 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
6256 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6259 sect
->flags
= SEC_HAS_CONTENTS
;
6260 sect
->alignment_power
= 2;
6262 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6265 /* Make a ".reg2/999" section */
6267 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6268 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6273 sect
= bfd_make_section (abfd
, name
);
6277 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6278 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6279 sect
->filepos
= note
->descpos
6280 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6283 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6284 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
6285 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6288 sect
->flags
= SEC_HAS_CONTENTS
;
6289 sect
->alignment_power
= 2;
6291 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6293 #endif /* defined (HAVE_LWPSTATUS_T) */
6295 #if defined (HAVE_WIN32_PSTATUS_T)
6297 elfcore_grok_win32pstatus (abfd
, note
)
6299 Elf_Internal_Note
*note
;
6304 win32_pstatus_t pstatus
;
6306 if (note
->descsz
< sizeof (pstatus
))
6309 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6311 switch (pstatus
.data_type
)
6313 case NOTE_INFO_PROCESS
:
6314 /* FIXME: need to add ->core_command. */
6315 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6316 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6319 case NOTE_INFO_THREAD
:
6320 /* Make a ".reg/999" section. */
6321 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6323 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6329 sect
= bfd_make_section (abfd
, name
);
6333 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6334 sect
->filepos
= (note
->descpos
6335 + offsetof (struct win32_pstatus
,
6336 data
.thread_info
.thread_context
));
6337 sect
->flags
= SEC_HAS_CONTENTS
;
6338 sect
->alignment_power
= 2;
6340 if (pstatus
.data
.thread_info
.is_active_thread
)
6341 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6345 case NOTE_INFO_MODULE
:
6346 /* Make a ".module/xxxxxxxx" section. */
6347 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6349 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (buf
) + 1);
6355 sect
= bfd_make_section (abfd
, name
);
6360 sect
->_raw_size
= note
->descsz
;
6361 sect
->filepos
= note
->descpos
;
6362 sect
->flags
= SEC_HAS_CONTENTS
;
6363 sect
->alignment_power
= 2;
6372 #endif /* HAVE_WIN32_PSTATUS_T */
6375 elfcore_grok_note (abfd
, note
)
6377 Elf_Internal_Note
*note
;
6379 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6387 if (bed
->elf_backend_grok_prstatus
)
6388 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6390 #if defined (HAVE_PRSTATUS_T)
6391 return elfcore_grok_prstatus (abfd
, note
);
6396 #if defined (HAVE_PSTATUS_T)
6398 return elfcore_grok_pstatus (abfd
, note
);
6401 #if defined (HAVE_LWPSTATUS_T)
6403 return elfcore_grok_lwpstatus (abfd
, note
);
6406 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6407 return elfcore_grok_prfpreg (abfd
, note
);
6409 #if defined (HAVE_WIN32_PSTATUS_T)
6410 case NT_WIN32PSTATUS
:
6411 return elfcore_grok_win32pstatus (abfd
, note
);
6414 case NT_PRXFPREG
: /* Linux SSE extension */
6415 if (note
->namesz
== 5
6416 && ! strcmp (note
->namedata
, "LINUX"))
6417 return elfcore_grok_prxfpreg (abfd
, note
);
6423 if (bed
->elf_backend_grok_psinfo
)
6424 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6426 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6427 return elfcore_grok_psinfo (abfd
, note
);
6435 elfcore_netbsd_get_lwpid (note
, lwpidp
)
6436 Elf_Internal_Note
*note
;
6441 cp
= strchr (note
->namedata
, '@');
6451 elfcore_grok_netbsd_procinfo (abfd
, note
)
6453 Elf_Internal_Note
*note
;
6456 /* Signal number at offset 0x08. */
6457 elf_tdata (abfd
)->core_signal
6458 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
6460 /* Process ID at offset 0x50. */
6461 elf_tdata (abfd
)->core_pid
6462 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
6464 /* Command name at 0x7c (max 32 bytes, including nul). */
6465 elf_tdata (abfd
)->core_command
6466 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
6472 elfcore_grok_netbsd_note (abfd
, note
)
6474 Elf_Internal_Note
*note
;
6478 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
6479 elf_tdata (abfd
)->core_lwpid
= lwp
;
6481 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
6483 /* NetBSD-specific core "procinfo". Note that we expect to
6484 find this note before any of the others, which is fine,
6485 since the kernel writes this note out first when it
6486 creates a core file. */
6488 return elfcore_grok_netbsd_procinfo (abfd
, note
);
6491 /* As of Jan 2002 there are no other machine-independent notes
6492 defined for NetBSD core files. If the note type is less
6493 than the start of the machine-dependent note types, we don't
6496 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
6500 switch (bfd_get_arch (abfd
))
6502 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6503 PT_GETFPREGS == mach+2. */
6505 case bfd_arch_alpha
:
6506 case bfd_arch_sparc
:
6509 case NT_NETBSDCORE_FIRSTMACH
+0:
6510 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6512 case NT_NETBSDCORE_FIRSTMACH
+2:
6513 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6519 /* On all other arch's, PT_GETREGS == mach+1 and
6520 PT_GETFPREGS == mach+3. */
6525 case NT_NETBSDCORE_FIRSTMACH
+1:
6526 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6528 case NT_NETBSDCORE_FIRSTMACH
+3:
6529 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6538 /* Function: elfcore_write_note
6545 size of data for note
6548 End of buffer containing note. */
6551 elfcore_write_note (abfd
, buf
, bufsiz
, name
, type
, input
, size
)
6560 Elf_External_Note
*xnp
;
6561 int namesz
= strlen (name
);
6562 int newspace
= BFD_ALIGN (sizeof (Elf_External_Note
) + size
+ namesz
- 1, 4);
6565 p
= realloc (buf
, *bufsiz
+ newspace
);
6567 *bufsiz
+= newspace
;
6568 xnp
= (Elf_External_Note
*) dest
;
6569 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
6570 H_PUT_32 (abfd
, size
, xnp
->descsz
);
6571 H_PUT_32 (abfd
, type
, xnp
->type
);
6572 strcpy (xnp
->name
, name
);
6573 memcpy (xnp
->name
+ BFD_ALIGN (namesz
, 4), input
, size
);
6577 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6579 elfcore_write_prpsinfo (abfd
, buf
, bufsiz
, fname
, psargs
)
6587 char *note_name
= "CORE";
6589 #if defined (HAVE_PSINFO_T)
6591 note_type
= NT_PSINFO
;
6594 note_type
= NT_PRPSINFO
;
6597 memset (&data
, 0, sizeof (data
));
6598 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
6599 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
6600 return elfcore_write_note (abfd
, buf
, bufsiz
,
6601 note_name
, note_type
, &data
, sizeof (data
));
6603 #endif /* PSINFO_T or PRPSINFO_T */
6605 #if defined (HAVE_PRSTATUS_T)
6607 elfcore_write_prstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6616 char *note_name
= "CORE";
6618 memset (&prstat
, 0, sizeof (prstat
));
6619 prstat
.pr_pid
= pid
;
6620 prstat
.pr_cursig
= cursig
;
6621 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
6622 return elfcore_write_note (abfd
, buf
, bufsiz
,
6623 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
6625 #endif /* HAVE_PRSTATUS_T */
6627 #if defined (HAVE_LWPSTATUS_T)
6629 elfcore_write_lwpstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6637 lwpstatus_t lwpstat
;
6638 char *note_name
= "CORE";
6640 memset (&lwpstat
, 0, sizeof (lwpstat
));
6641 lwpstat
.pr_lwpid
= pid
>> 16;
6642 lwpstat
.pr_cursig
= cursig
;
6643 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6644 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
6645 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6647 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
6648 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
6650 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
6651 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
6654 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
6655 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
6657 #endif /* HAVE_LWPSTATUS_T */
6659 #if defined (HAVE_PSTATUS_T)
6661 elfcore_write_pstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
6670 char *note_name
= "CORE";
6672 memset (&pstat
, 0, sizeof (pstat
));
6673 pstat
.pr_pid
= pid
& 0xffff;
6674 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
6675 NT_PSTATUS
, &pstat
, sizeof (pstat
));
6678 #endif /* HAVE_PSTATUS_T */
6681 elfcore_write_prfpreg (abfd
, buf
, bufsiz
, fpregs
, size
)
6688 char *note_name
= "CORE";
6689 return elfcore_write_note (abfd
, buf
, bufsiz
,
6690 note_name
, NT_FPREGSET
, fpregs
, size
);
6694 elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, xfpregs
, size
)
6701 char *note_name
= "LINUX";
6702 return elfcore_write_note (abfd
, buf
, bufsiz
,
6703 note_name
, NT_PRXFPREG
, xfpregs
, size
);
6707 elfcore_read_notes (abfd
, offset
, size
)
6718 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
6721 buf
= bfd_malloc (size
);
6725 if (bfd_bread (buf
, size
, abfd
) != size
)
6733 while (p
< buf
+ size
)
6735 /* FIXME: bad alignment assumption. */
6736 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
6737 Elf_Internal_Note in
;
6739 in
.type
= H_GET_32 (abfd
, xnp
->type
);
6741 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
6742 in
.namedata
= xnp
->name
;
6744 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
6745 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
6746 in
.descpos
= offset
+ (in
.descdata
- buf
);
6748 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
6750 if (! elfcore_grok_netbsd_note (abfd
, &in
))
6755 if (! elfcore_grok_note (abfd
, &in
))
6759 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
6766 /* Providing external access to the ELF program header table. */
6768 /* Return an upper bound on the number of bytes required to store a
6769 copy of ABFD's program header table entries. Return -1 if an error
6770 occurs; bfd_get_error will return an appropriate code. */
6773 bfd_get_elf_phdr_upper_bound (abfd
)
6776 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6778 bfd_set_error (bfd_error_wrong_format
);
6782 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
6785 /* Copy ABFD's program header table entries to *PHDRS. The entries
6786 will be stored as an array of Elf_Internal_Phdr structures, as
6787 defined in include/elf/internal.h. To find out how large the
6788 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
6790 Return the number of program header table entries read, or -1 if an
6791 error occurs; bfd_get_error will return an appropriate code. */
6794 bfd_get_elf_phdrs (abfd
, phdrs
)
6800 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6802 bfd_set_error (bfd_error_wrong_format
);
6806 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
6807 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
6808 num_phdrs
* sizeof (Elf_Internal_Phdr
));
6814 _bfd_elf_sprintf_vma (abfd
, buf
, value
)
6815 bfd
*abfd ATTRIBUTE_UNUSED
;
6820 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
6822 i_ehdrp
= elf_elfheader (abfd
);
6823 if (i_ehdrp
== NULL
)
6824 sprintf_vma (buf
, value
);
6827 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
6829 #if BFD_HOST_64BIT_LONG
6830 sprintf (buf
, "%016lx", value
);
6832 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
6833 _bfd_int64_low (value
));
6837 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
6840 sprintf_vma (buf
, value
);
6845 _bfd_elf_fprintf_vma (abfd
, stream
, value
)
6846 bfd
*abfd ATTRIBUTE_UNUSED
;
6851 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
6853 i_ehdrp
= elf_elfheader (abfd
);
6854 if (i_ehdrp
== NULL
)
6855 fprintf_vma ((FILE *) stream
, value
);
6858 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
6860 #if BFD_HOST_64BIT_LONG
6861 fprintf ((FILE *) stream
, "%016lx", value
);
6863 fprintf ((FILE *) stream
, "%08lx%08lx",
6864 _bfd_int64_high (value
), _bfd_int64_low (value
));
6868 fprintf ((FILE *) stream
, "%08lx",
6869 (unsigned long) (value
& 0xffffffff));
6872 fprintf_vma ((FILE *) stream
, value
);
6876 enum elf_reloc_type_class
6877 _bfd_elf_reloc_type_class (rela
)
6878 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
;
6880 return reloc_class_normal
;
6883 /* For RELA architectures, return what the relocation value for
6884 relocation against a local symbol. */
6887 _bfd_elf_rela_local_sym (abfd
, sym
, sec
, rel
)
6889 Elf_Internal_Sym
*sym
;
6891 Elf_Internal_Rela
*rel
;
6895 relocation
= (sec
->output_section
->vma
6896 + sec
->output_offset
6898 if ((sec
->flags
& SEC_MERGE
)
6899 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
6900 && elf_section_data (sec
)->sec_info_type
== ELF_INFO_TYPE_MERGE
)
6906 _bfd_merged_section_offset (abfd
, &msec
,
6907 elf_section_data (sec
)->sec_info
,
6908 sym
->st_value
+ rel
->r_addend
,
6911 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
6917 _bfd_elf_rel_local_sym (abfd
, sym
, psec
, addend
)
6919 Elf_Internal_Sym
*sym
;
6923 asection
*sec
= *psec
;
6925 if (elf_section_data (sec
)->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
6926 return sym
->st_value
+ addend
;
6928 return _bfd_merged_section_offset (abfd
, psec
,
6929 elf_section_data (sec
)->sec_info
,
6930 sym
->st_value
+ addend
, (bfd_vma
) 0);
6934 _bfd_elf_section_offset (abfd
, info
, sec
, offset
)
6936 struct bfd_link_info
*info
;
6940 struct bfd_elf_section_data
*sec_data
;
6942 sec_data
= elf_section_data (sec
);
6943 switch (sec_data
->sec_info_type
)
6945 case ELF_INFO_TYPE_STABS
:
6946 return _bfd_stab_section_offset
6947 (abfd
, &elf_hash_table (info
)->merge_info
, sec
, &sec_data
->sec_info
,
6949 case ELF_INFO_TYPE_EH_FRAME
:
6950 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);