1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 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, bfd_boolean
));
45 static bfd_boolean map_sections_to_segments
47 static int elf_sort_sections
48 PARAMS ((const PTR
, const PTR
));
49 static bfd_boolean assign_file_positions_for_segments
51 static bfd_boolean assign_file_positions_except_relocs
53 static bfd_boolean prep_headers
55 static bfd_boolean swap_out_syms
56 PARAMS ((bfd
*, struct bfd_strtab_hash
**, int));
57 static bfd_boolean copy_private_bfd_data
58 PARAMS ((bfd
*, bfd
*));
60 PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
61 static const char *group_signature
62 PARAMS ((bfd
*, Elf_Internal_Shdr
*));
63 static bfd_boolean setup_group
64 PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
65 static void merge_sections_remove_hook
66 PARAMS ((bfd
*, asection
*));
67 static void elf_fake_sections
68 PARAMS ((bfd
*, asection
*, PTR
));
69 static bfd_boolean assign_section_numbers
71 static INLINE
int sym_is_global
72 PARAMS ((bfd
*, asymbol
*));
73 static bfd_boolean elf_map_symbols
75 static bfd_size_type get_program_header_size
77 static bfd_boolean elfcore_read_notes
78 PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
79 static bfd_boolean elf_find_function
80 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
82 static int elfcore_make_pid
84 static bfd_boolean elfcore_maybe_make_sect
85 PARAMS ((bfd
*, char *, asection
*));
86 static bfd_boolean elfcore_make_note_pseudosection
87 PARAMS ((bfd
*, char *, Elf_Internal_Note
*));
88 static bfd_boolean elfcore_grok_prfpreg
89 PARAMS ((bfd
*, Elf_Internal_Note
*));
90 static bfd_boolean elfcore_grok_prxfpreg
91 PARAMS ((bfd
*, Elf_Internal_Note
*));
92 static bfd_boolean elfcore_grok_note
93 PARAMS ((bfd
*, Elf_Internal_Note
*));
94 static bfd_boolean elfcore_netbsd_get_lwpid
95 PARAMS ((Elf_Internal_Note
*, int *));
96 static bfd_boolean elfcore_grok_netbsd_procinfo
97 PARAMS ((bfd
*, Elf_Internal_Note
*));
98 static bfd_boolean elfcore_grok_netbsd_note
99 PARAMS ((bfd
*, Elf_Internal_Note
*));
101 /* Swap version information in and out. The version information is
102 currently size independent. If that ever changes, this code will
103 need to move into elfcode.h. */
105 /* Swap in a Verdef structure. */
108 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
110 const Elf_External_Verdef
*src
;
111 Elf_Internal_Verdef
*dst
;
113 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
114 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
115 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
116 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
117 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
118 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
119 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
122 /* Swap out a Verdef structure. */
125 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
127 const Elf_Internal_Verdef
*src
;
128 Elf_External_Verdef
*dst
;
130 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
131 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
132 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
133 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
134 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
135 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
136 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
139 /* Swap in a Verdaux structure. */
142 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
144 const Elf_External_Verdaux
*src
;
145 Elf_Internal_Verdaux
*dst
;
147 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
148 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
151 /* Swap out a Verdaux structure. */
154 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
156 const Elf_Internal_Verdaux
*src
;
157 Elf_External_Verdaux
*dst
;
159 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
160 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
163 /* Swap in a Verneed structure. */
166 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
168 const Elf_External_Verneed
*src
;
169 Elf_Internal_Verneed
*dst
;
171 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
172 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
173 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
174 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
175 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
178 /* Swap out a Verneed structure. */
181 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
183 const Elf_Internal_Verneed
*src
;
184 Elf_External_Verneed
*dst
;
186 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
187 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
188 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
189 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
190 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
193 /* Swap in a Vernaux structure. */
196 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
198 const Elf_External_Vernaux
*src
;
199 Elf_Internal_Vernaux
*dst
;
201 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
202 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
203 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
204 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
205 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
208 /* Swap out a Vernaux structure. */
211 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
213 const Elf_Internal_Vernaux
*src
;
214 Elf_External_Vernaux
*dst
;
216 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
217 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
218 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
219 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
220 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
223 /* Swap in a Versym structure. */
226 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
228 const Elf_External_Versym
*src
;
229 Elf_Internal_Versym
*dst
;
231 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
234 /* Swap out a Versym structure. */
237 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
239 const Elf_Internal_Versym
*src
;
240 Elf_External_Versym
*dst
;
242 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
245 /* Standard ELF hash function. Do not change this function; you will
246 cause invalid hash tables to be generated. */
249 bfd_elf_hash (namearg
)
252 const unsigned char *name
= (const unsigned char *) namearg
;
257 while ((ch
= *name
++) != '\0')
260 if ((g
= (h
& 0xf0000000)) != 0)
263 /* The ELF ABI says `h &= ~g', but this is equivalent in
264 this case and on some machines one insn instead of two. */
271 /* Read a specified number of bytes at a specified offset in an ELF
272 file, into a newly allocated buffer, and return a pointer to the
276 elf_read (abfd
, offset
, size
)
283 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
285 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
287 if (bfd_bread ((PTR
) buf
, size
, abfd
) != size
)
289 if (bfd_get_error () != bfd_error_system_call
)
290 bfd_set_error (bfd_error_file_truncated
);
297 bfd_elf_mkobject (abfd
)
300 /* This just does initialization. */
301 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
302 bfd_size_type amt
= sizeof (struct elf_obj_tdata
);
303 elf_tdata (abfd
) = (struct elf_obj_tdata
*) bfd_zalloc (abfd
, amt
);
304 if (elf_tdata (abfd
) == 0)
306 /* Since everything is done at close time, do we need any
313 bfd_elf_mkcorefile (abfd
)
316 /* I think this can be done just like an object file. */
317 return bfd_elf_mkobject (abfd
);
321 bfd_elf_get_str_section (abfd
, shindex
)
323 unsigned int shindex
;
325 Elf_Internal_Shdr
**i_shdrp
;
326 char *shstrtab
= NULL
;
328 bfd_size_type shstrtabsize
;
330 i_shdrp
= elf_elfsections (abfd
);
331 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
334 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
335 if (shstrtab
== NULL
)
337 /* No cached one, attempt to read, and cache what we read. */
338 offset
= i_shdrp
[shindex
]->sh_offset
;
339 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
340 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
341 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
347 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
349 unsigned int shindex
;
350 unsigned int strindex
;
352 Elf_Internal_Shdr
*hdr
;
357 hdr
= elf_elfsections (abfd
)[shindex
];
359 if (hdr
->contents
== NULL
360 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
363 if (strindex
>= hdr
->sh_size
)
365 (*_bfd_error_handler
)
366 (_("%s: invalid string offset %u >= %lu for section `%s'"),
367 bfd_archive_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
368 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
369 && strindex
== hdr
->sh_name
)
371 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
375 return ((char *) hdr
->contents
) + strindex
;
378 /* Read and convert symbols to internal format.
379 SYMCOUNT specifies the number of symbols to read, starting from
380 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
381 are non-NULL, they are used to store the internal symbols, external
382 symbols, and symbol section index extensions, respectively. */
385 bfd_elf_get_elf_syms (ibfd
, symtab_hdr
, symcount
, symoffset
,
386 intsym_buf
, extsym_buf
, extshndx_buf
)
388 Elf_Internal_Shdr
*symtab_hdr
;
391 Elf_Internal_Sym
*intsym_buf
;
393 Elf_External_Sym_Shndx
*extshndx_buf
;
395 Elf_Internal_Shdr
*shndx_hdr
;
397 const bfd_byte
*esym
;
398 Elf_External_Sym_Shndx
*alloc_extshndx
;
399 Elf_External_Sym_Shndx
*shndx
;
400 Elf_Internal_Sym
*isym
;
401 Elf_Internal_Sym
*isymend
;
402 struct elf_backend_data
*bed
;
410 /* Normal syms might have section extension entries. */
412 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
413 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
415 /* Read the symbols. */
417 alloc_extshndx
= NULL
;
418 bed
= get_elf_backend_data (ibfd
);
419 extsym_size
= bed
->s
->sizeof_sym
;
420 amt
= symcount
* extsym_size
;
421 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
422 if (extsym_buf
== NULL
)
424 alloc_ext
= bfd_malloc (amt
);
425 extsym_buf
= alloc_ext
;
427 if (extsym_buf
== NULL
428 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
429 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
435 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
439 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
440 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
441 if (extshndx_buf
== NULL
)
443 alloc_extshndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
444 extshndx_buf
= alloc_extshndx
;
446 if (extshndx_buf
== NULL
447 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
448 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
455 if (intsym_buf
== NULL
)
457 bfd_size_type amt
= symcount
* sizeof (Elf_Internal_Sym
);
458 intsym_buf
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
459 if (intsym_buf
== NULL
)
463 /* Convert the symbols to internal form. */
464 isymend
= intsym_buf
+ symcount
;
465 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
467 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
468 (*bed
->s
->swap_symbol_in
) (ibfd
, esym
, (const PTR
) shndx
, isym
);
471 if (alloc_ext
!= NULL
)
473 if (alloc_extshndx
!= NULL
)
474 free (alloc_extshndx
);
479 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
480 sections. The first element is the flags, the rest are section
483 typedef union elf_internal_group
{
484 Elf_Internal_Shdr
*shdr
;
486 } Elf_Internal_Group
;
488 /* Return the name of the group signature symbol. Why isn't the
489 signature just a string? */
492 group_signature (abfd
, ghdr
)
494 Elf_Internal_Shdr
*ghdr
;
496 Elf_Internal_Shdr
*hdr
;
497 unsigned char esym
[sizeof (Elf64_External_Sym
)];
498 Elf_External_Sym_Shndx eshndx
;
499 Elf_Internal_Sym isym
;
501 unsigned int shindex
;
503 /* First we need to ensure the symbol table is available. */
504 if (! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
507 /* Go read the symbol. */
508 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
509 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
510 &isym
, esym
, &eshndx
) == NULL
)
513 /* Look up the symbol name. */
514 iname
= isym
.st_name
;
515 shindex
= hdr
->sh_link
;
516 if (iname
== 0 && ELF_ST_TYPE (isym
.st_info
) == STT_SECTION
)
518 iname
= elf_elfsections (abfd
)[isym
.st_shndx
]->sh_name
;
519 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
522 return bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
525 /* Set next_in_group list pointer, and group name for NEWSECT. */
528 setup_group (abfd
, hdr
, newsect
)
530 Elf_Internal_Shdr
*hdr
;
533 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
535 /* If num_group is zero, read in all SHT_GROUP sections. The count
536 is set to -1 if there are no SHT_GROUP sections. */
539 unsigned int i
, shnum
;
541 /* First count the number of groups. If we have a SHT_GROUP
542 section with just a flag word (ie. sh_size is 4), ignore it. */
543 shnum
= elf_numsections (abfd
);
545 for (i
= 0; i
< shnum
; i
++)
547 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
548 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
553 num_group
= (unsigned) -1;
554 elf_tdata (abfd
)->num_group
= num_group
;
558 /* We keep a list of elf section headers for group sections,
559 so we can find them quickly. */
560 bfd_size_type amt
= num_group
* sizeof (Elf_Internal_Shdr
*);
561 elf_tdata (abfd
)->group_sect_ptr
= bfd_alloc (abfd
, amt
);
562 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
566 for (i
= 0; i
< shnum
; i
++)
568 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
569 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
572 Elf_Internal_Group
*dest
;
574 /* Add to list of sections. */
575 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
578 /* Read the raw contents. */
579 BFD_ASSERT (sizeof (*dest
) >= 4);
580 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
581 shdr
->contents
= bfd_alloc (abfd
, amt
);
582 if (shdr
->contents
== NULL
583 || bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
584 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
588 /* Translate raw contents, a flag word followed by an
589 array of elf section indices all in target byte order,
590 to the flag word followed by an array of elf section
592 src
= shdr
->contents
+ shdr
->sh_size
;
593 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
600 idx
= H_GET_32 (abfd
, src
);
601 if (src
== shdr
->contents
)
604 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
605 shdr
->bfd_section
->flags
606 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
611 ((*_bfd_error_handler
)
612 (_("%s: invalid SHT_GROUP entry"),
613 bfd_archive_filename (abfd
)));
616 dest
->shdr
= elf_elfsections (abfd
)[idx
];
623 if (num_group
!= (unsigned) -1)
627 for (i
= 0; i
< num_group
; i
++)
629 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
630 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
631 unsigned int n_elt
= shdr
->sh_size
/ 4;
633 /* Look through this group's sections to see if current
634 section is a member. */
636 if ((++idx
)->shdr
== hdr
)
640 /* We are a member of this group. Go looking through
641 other members to see if any others are linked via
643 idx
= (Elf_Internal_Group
*) shdr
->contents
;
644 n_elt
= shdr
->sh_size
/ 4;
646 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
647 && elf_next_in_group (s
) != NULL
)
651 /* Snarf the group name from other member, and
652 insert current section in circular list. */
653 elf_group_name (newsect
) = elf_group_name (s
);
654 elf_next_in_group (newsect
) = elf_next_in_group (s
);
655 elf_next_in_group (s
) = newsect
;
661 gname
= group_signature (abfd
, shdr
);
664 elf_group_name (newsect
) = gname
;
666 /* Start a circular list with one element. */
667 elf_next_in_group (newsect
) = newsect
;
670 /* If the group section has been created, point to the
672 if (shdr
->bfd_section
!= NULL
)
673 elf_next_in_group (shdr
->bfd_section
) = newsect
;
681 if (elf_group_name (newsect
) == NULL
)
683 (*_bfd_error_handler
) (_("%s: no group info for section %s"),
684 bfd_archive_filename (abfd
), newsect
->name
);
690 bfd_elf_discard_group (abfd
, group
)
691 bfd
*abfd ATTRIBUTE_UNUSED
;
694 asection
*first
= elf_next_in_group (group
);
699 s
->output_section
= bfd_abs_section_ptr
;
700 s
= elf_next_in_group (s
);
701 /* These lists are circular. */
708 /* Make a BFD section from an ELF section. We store a pointer to the
709 BFD section in the bfd_section field of the header. */
712 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
714 Elf_Internal_Shdr
*hdr
;
719 struct elf_backend_data
*bed
;
721 if (hdr
->bfd_section
!= NULL
)
723 BFD_ASSERT (strcmp (name
,
724 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
728 newsect
= bfd_make_section_anyway (abfd
, name
);
732 newsect
->filepos
= hdr
->sh_offset
;
734 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
735 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
736 || ! bfd_set_section_alignment (abfd
, newsect
,
737 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
740 flags
= SEC_NO_FLAGS
;
741 if (hdr
->sh_type
!= SHT_NOBITS
)
742 flags
|= SEC_HAS_CONTENTS
;
743 if (hdr
->sh_type
== SHT_GROUP
)
744 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
745 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
748 if (hdr
->sh_type
!= SHT_NOBITS
)
751 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
752 flags
|= SEC_READONLY
;
753 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
755 else if ((flags
& SEC_LOAD
) != 0)
757 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
760 newsect
->entsize
= hdr
->sh_entsize
;
761 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
762 flags
|= SEC_STRINGS
;
764 if (hdr
->sh_flags
& SHF_GROUP
)
765 if (!setup_group (abfd
, hdr
, newsect
))
767 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
768 flags
|= SEC_THREAD_LOCAL
;
770 /* The debugging sections appear to be recognized only by name, not
773 static const char *debug_sec_names
[] =
782 for (i
= ARRAY_SIZE (debug_sec_names
); i
--;)
783 if (strncmp (name
, debug_sec_names
[i
], strlen (debug_sec_names
[i
])) == 0)
787 flags
|= SEC_DEBUGGING
;
790 /* As a GNU extension, if the name begins with .gnu.linkonce, we
791 only link a single copy of the section. This is used to support
792 g++. g++ will emit each template expansion in its own section.
793 The symbols will be defined as weak, so that multiple definitions
794 are permitted. The GNU linker extension is to actually discard
795 all but one of the sections. */
796 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
797 && elf_next_in_group (newsect
) == NULL
)
798 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
800 bed
= get_elf_backend_data (abfd
);
801 if (bed
->elf_backend_section_flags
)
802 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
805 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
808 if ((flags
& SEC_ALLOC
) != 0)
810 Elf_Internal_Phdr
*phdr
;
813 /* Look through the phdrs to see if we need to adjust the lma.
814 If all the p_paddr fields are zero, we ignore them, since
815 some ELF linkers produce such output. */
816 phdr
= elf_tdata (abfd
)->phdr
;
817 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
819 if (phdr
->p_paddr
!= 0)
822 if (i
< elf_elfheader (abfd
)->e_phnum
)
824 phdr
= elf_tdata (abfd
)->phdr
;
825 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
827 /* This section is part of this segment if its file
828 offset plus size lies within the segment's memory
829 span and, if the section is loaded, the extent of the
830 loaded data lies within the extent of the segment.
832 Note - we used to check the p_paddr field as well, and
833 refuse to set the LMA if it was 0. This is wrong
834 though, as a perfectly valid initialised segment can
835 have a p_paddr of zero. Some architectures, eg ARM,
836 place special significance on the address 0 and
837 executables need to be able to have a segment which
838 covers this address. */
839 if (phdr
->p_type
== PT_LOAD
840 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
841 && (hdr
->sh_offset
+ hdr
->sh_size
842 <= phdr
->p_offset
+ phdr
->p_memsz
)
843 && ((flags
& SEC_LOAD
) == 0
844 || (hdr
->sh_offset
+ hdr
->sh_size
845 <= phdr
->p_offset
+ phdr
->p_filesz
)))
847 if ((flags
& SEC_LOAD
) == 0)
848 newsect
->lma
= (phdr
->p_paddr
849 + hdr
->sh_addr
- phdr
->p_vaddr
);
851 /* We used to use the same adjustment for SEC_LOAD
852 sections, but that doesn't work if the segment
853 is packed with code from multiple VMAs.
854 Instead we calculate the section LMA based on
855 the segment LMA. It is assumed that the
856 segment will contain sections with contiguous
857 LMAs, even if the VMAs are not. */
858 newsect
->lma
= (phdr
->p_paddr
859 + hdr
->sh_offset
- phdr
->p_offset
);
861 /* With contiguous segments, we can't tell from file
862 offsets whether a section with zero size should
863 be placed at the end of one segment or the
864 beginning of the next. Decide based on vaddr. */
865 if (hdr
->sh_addr
>= phdr
->p_vaddr
866 && (hdr
->sh_addr
+ hdr
->sh_size
867 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
874 hdr
->bfd_section
= newsect
;
875 elf_section_data (newsect
)->this_hdr
= *hdr
;
885 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
888 Helper functions for GDB to locate the string tables.
889 Since BFD hides string tables from callers, GDB needs to use an
890 internal hook to find them. Sun's .stabstr, in particular,
891 isn't even pointed to by the .stab section, so ordinary
892 mechanisms wouldn't work to find it, even if we had some.
895 struct elf_internal_shdr
*
896 bfd_elf_find_section (abfd
, name
)
900 Elf_Internal_Shdr
**i_shdrp
;
905 i_shdrp
= elf_elfsections (abfd
);
908 shstrtab
= bfd_elf_get_str_section (abfd
,
909 elf_elfheader (abfd
)->e_shstrndx
);
910 if (shstrtab
!= NULL
)
912 max
= elf_numsections (abfd
);
913 for (i
= 1; i
< max
; i
++)
914 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
921 const char *const bfd_elf_section_type_names
[] = {
922 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
923 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
924 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
927 /* ELF relocs are against symbols. If we are producing relocateable
928 output, and the reloc is against an external symbol, and nothing
929 has given us any additional addend, the resulting reloc will also
930 be against the same symbol. In such a case, we don't want to
931 change anything about the way the reloc is handled, since it will
932 all be done at final link time. Rather than put special case code
933 into bfd_perform_relocation, all the reloc types use this howto
934 function. It just short circuits the reloc if producing
935 relocateable output against an external symbol. */
937 bfd_reloc_status_type
938 bfd_elf_generic_reloc (abfd
,
945 bfd
*abfd ATTRIBUTE_UNUSED
;
946 arelent
*reloc_entry
;
948 PTR data ATTRIBUTE_UNUSED
;
949 asection
*input_section
;
951 char **error_message ATTRIBUTE_UNUSED
;
953 if (output_bfd
!= (bfd
*) NULL
954 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
955 && (! reloc_entry
->howto
->partial_inplace
956 || reloc_entry
->addend
== 0))
958 reloc_entry
->address
+= input_section
->output_offset
;
962 return bfd_reloc_continue
;
965 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
968 merge_sections_remove_hook (abfd
, sec
)
969 bfd
*abfd ATTRIBUTE_UNUSED
;
972 struct bfd_elf_section_data
*sec_data
;
974 sec_data
= elf_section_data (sec
);
975 BFD_ASSERT (sec_data
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
976 sec_data
->sec_info_type
= ELF_INFO_TYPE_NONE
;
979 /* Finish SHF_MERGE section merging. */
982 _bfd_elf_merge_sections (abfd
, info
)
984 struct bfd_link_info
*info
;
986 if (!is_elf_hash_table (info
))
988 if (elf_hash_table (info
)->merge_info
)
989 _bfd_merge_sections (abfd
, elf_hash_table (info
)->merge_info
,
990 merge_sections_remove_hook
);
995 _bfd_elf_link_just_syms (sec
, info
)
997 struct bfd_link_info
*info
;
999 sec
->output_section
= bfd_abs_section_ptr
;
1000 sec
->output_offset
= sec
->vma
;
1001 if (!is_elf_hash_table (info
))
1004 elf_section_data (sec
)->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
1007 /* Copy the program header and other data from one object module to
1011 _bfd_elf_copy_private_bfd_data (ibfd
, obfd
)
1015 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1016 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1019 BFD_ASSERT (!elf_flags_init (obfd
)
1020 || (elf_elfheader (obfd
)->e_flags
1021 == elf_elfheader (ibfd
)->e_flags
));
1023 elf_gp (obfd
) = elf_gp (ibfd
);
1024 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1025 elf_flags_init (obfd
) = TRUE
;
1029 /* Print out the program headers. */
1032 _bfd_elf_print_private_bfd_data (abfd
, farg
)
1036 FILE *f
= (FILE *) farg
;
1037 Elf_Internal_Phdr
*p
;
1039 bfd_byte
*dynbuf
= NULL
;
1041 p
= elf_tdata (abfd
)->phdr
;
1046 fprintf (f
, _("\nProgram Header:\n"));
1047 c
= elf_elfheader (abfd
)->e_phnum
;
1048 for (i
= 0; i
< c
; i
++, p
++)
1055 case PT_NULL
: pt
= "NULL"; break;
1056 case PT_LOAD
: pt
= "LOAD"; break;
1057 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1058 case PT_INTERP
: pt
= "INTERP"; break;
1059 case PT_NOTE
: pt
= "NOTE"; break;
1060 case PT_SHLIB
: pt
= "SHLIB"; break;
1061 case PT_PHDR
: pt
= "PHDR"; break;
1062 case PT_TLS
: pt
= "TLS"; break;
1063 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1064 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
1066 fprintf (f
, "%8s off 0x", pt
);
1067 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1068 fprintf (f
, " vaddr 0x");
1069 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1070 fprintf (f
, " paddr 0x");
1071 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1072 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1073 fprintf (f
, " filesz 0x");
1074 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1075 fprintf (f
, " memsz 0x");
1076 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1077 fprintf (f
, " flags %c%c%c",
1078 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1079 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1080 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1081 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1082 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1087 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1091 unsigned long shlink
;
1092 bfd_byte
*extdyn
, *extdynend
;
1094 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1096 fprintf (f
, _("\nDynamic Section:\n"));
1098 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1101 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1105 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1108 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1110 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1111 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1114 extdynend
= extdyn
+ s
->_raw_size
;
1115 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1117 Elf_Internal_Dyn dyn
;
1120 bfd_boolean stringp
;
1122 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1124 if (dyn
.d_tag
== DT_NULL
)
1131 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1135 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1136 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1137 case DT_PLTGOT
: name
= "PLTGOT"; break;
1138 case DT_HASH
: name
= "HASH"; break;
1139 case DT_STRTAB
: name
= "STRTAB"; break;
1140 case DT_SYMTAB
: name
= "SYMTAB"; break;
1141 case DT_RELA
: name
= "RELA"; break;
1142 case DT_RELASZ
: name
= "RELASZ"; break;
1143 case DT_RELAENT
: name
= "RELAENT"; break;
1144 case DT_STRSZ
: name
= "STRSZ"; break;
1145 case DT_SYMENT
: name
= "SYMENT"; break;
1146 case DT_INIT
: name
= "INIT"; break;
1147 case DT_FINI
: name
= "FINI"; break;
1148 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1149 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1150 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1151 case DT_REL
: name
= "REL"; break;
1152 case DT_RELSZ
: name
= "RELSZ"; break;
1153 case DT_RELENT
: name
= "RELENT"; break;
1154 case DT_PLTREL
: name
= "PLTREL"; break;
1155 case DT_DEBUG
: name
= "DEBUG"; break;
1156 case DT_TEXTREL
: name
= "TEXTREL"; break;
1157 case DT_JMPREL
: name
= "JMPREL"; break;
1158 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1159 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1160 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1161 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1162 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1163 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1164 case DT_FLAGS
: name
= "FLAGS"; break;
1165 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1166 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1167 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1168 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1169 case DT_MOVEENT
: name
= "MOVEENT"; break;
1170 case DT_MOVESZ
: name
= "MOVESZ"; break;
1171 case DT_FEATURE
: name
= "FEATURE"; break;
1172 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1173 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1174 case DT_SYMINENT
: name
= "SYMINENT"; break;
1175 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1176 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1177 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1178 case DT_PLTPAD
: name
= "PLTPAD"; break;
1179 case DT_MOVETAB
: name
= "MOVETAB"; break;
1180 case DT_SYMINFO
: name
= "SYMINFO"; break;
1181 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1182 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1183 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1184 case DT_VERSYM
: name
= "VERSYM"; break;
1185 case DT_VERDEF
: name
= "VERDEF"; break;
1186 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1187 case DT_VERNEED
: name
= "VERNEED"; break;
1188 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1189 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1190 case DT_USED
: name
= "USED"; break;
1191 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1194 fprintf (f
, " %-11s ", name
);
1196 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1200 unsigned int tagv
= dyn
.d_un
.d_val
;
1202 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1205 fprintf (f
, "%s", string
);
1214 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1215 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1217 if (! _bfd_elf_slurp_version_tables (abfd
))
1221 if (elf_dynverdef (abfd
) != 0)
1223 Elf_Internal_Verdef
*t
;
1225 fprintf (f
, _("\nVersion definitions:\n"));
1226 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1228 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1229 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1230 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1232 Elf_Internal_Verdaux
*a
;
1235 for (a
= t
->vd_auxptr
->vda_nextptr
;
1238 fprintf (f
, "%s ", a
->vda_nodename
);
1244 if (elf_dynverref (abfd
) != 0)
1246 Elf_Internal_Verneed
*t
;
1248 fprintf (f
, _("\nVersion References:\n"));
1249 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1251 Elf_Internal_Vernaux
*a
;
1253 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1254 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1255 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1256 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1268 /* Display ELF-specific fields of a symbol. */
1271 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
1275 bfd_print_symbol_type how
;
1277 FILE *file
= (FILE *) filep
;
1280 case bfd_print_symbol_name
:
1281 fprintf (file
, "%s", symbol
->name
);
1283 case bfd_print_symbol_more
:
1284 fprintf (file
, "elf ");
1285 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1286 fprintf (file
, " %lx", (long) symbol
->flags
);
1288 case bfd_print_symbol_all
:
1290 const char *section_name
;
1291 const char *name
= NULL
;
1292 struct elf_backend_data
*bed
;
1293 unsigned char st_other
;
1296 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1298 bed
= get_elf_backend_data (abfd
);
1299 if (bed
->elf_backend_print_symbol_all
)
1300 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1304 name
= symbol
->name
;
1305 bfd_print_symbol_vandf (abfd
, (PTR
) file
, symbol
);
1308 fprintf (file
, " %s\t", section_name
);
1309 /* Print the "other" value for a symbol. For common symbols,
1310 we've already printed the size; now print the alignment.
1311 For other symbols, we have no specified alignment, and
1312 we've printed the address; now print the size. */
1313 if (bfd_is_com_section (symbol
->section
))
1314 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1316 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1317 bfd_fprintf_vma (abfd
, file
, val
);
1319 /* If we have version information, print it. */
1320 if (elf_tdata (abfd
)->dynversym_section
!= 0
1321 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1322 || elf_tdata (abfd
)->dynverref_section
!= 0))
1324 unsigned int vernum
;
1325 const char *version_string
;
1327 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1330 version_string
= "";
1331 else if (vernum
== 1)
1332 version_string
= "Base";
1333 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1335 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1338 Elf_Internal_Verneed
*t
;
1340 version_string
= "";
1341 for (t
= elf_tdata (abfd
)->verref
;
1345 Elf_Internal_Vernaux
*a
;
1347 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1349 if (a
->vna_other
== vernum
)
1351 version_string
= a
->vna_nodename
;
1358 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1359 fprintf (file
, " %-11s", version_string
);
1364 fprintf (file
, " (%s)", version_string
);
1365 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1370 /* If the st_other field is not zero, print it. */
1371 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1376 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1377 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1378 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1380 /* Some other non-defined flags are also present, so print
1382 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1385 fprintf (file
, " %s", name
);
1391 /* Create an entry in an ELF linker hash table. */
1393 struct bfd_hash_entry
*
1394 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
1395 struct bfd_hash_entry
*entry
;
1396 struct bfd_hash_table
*table
;
1399 /* Allocate the structure if it has not already been allocated by a
1403 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1408 /* Call the allocation method of the superclass. */
1409 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1412 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1413 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1415 /* Set local fields. */
1418 ret
->dynstr_index
= 0;
1419 ret
->elf_hash_value
= 0;
1420 ret
->weakdef
= NULL
;
1421 ret
->linker_section_pointer
= NULL
;
1422 ret
->verinfo
.verdef
= NULL
;
1423 ret
->vtable_entries_size
= 0;
1424 ret
->vtable_entries_used
= NULL
;
1425 ret
->vtable_parent
= NULL
;
1426 ret
->got
.refcount
= htab
->init_refcount
;
1427 ret
->plt
.refcount
= htab
->init_refcount
;
1429 ret
->type
= STT_NOTYPE
;
1431 /* Assume that we have been called by a non-ELF symbol reader.
1432 This flag is then reset by the code which reads an ELF input
1433 file. This ensures that a symbol created by a non-ELF symbol
1434 reader will have the flag set correctly. */
1435 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
1441 /* Copy data from an indirect symbol to its direct symbol, hiding the
1442 old indirect symbol. Also used for copying flags to a weakdef. */
1445 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
)
1446 struct elf_backend_data
*bed
;
1447 struct elf_link_hash_entry
*dir
, *ind
;
1450 bfd_signed_vma lowest_valid
= bed
->can_refcount
;
1452 /* Copy down any references that we may have already seen to the
1453 symbol which just became indirect. */
1455 dir
->elf_link_hash_flags
|=
1456 (ind
->elf_link_hash_flags
1457 & (ELF_LINK_HASH_REF_DYNAMIC
1458 | ELF_LINK_HASH_REF_REGULAR
1459 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1460 | ELF_LINK_NON_GOT_REF
));
1462 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1465 /* Copy over the global and procedure linkage table refcount entries.
1466 These may have been already set up by a check_relocs routine. */
1467 tmp
= dir
->got
.refcount
;
1468 if (tmp
< lowest_valid
)
1470 dir
->got
.refcount
= ind
->got
.refcount
;
1471 ind
->got
.refcount
= tmp
;
1474 BFD_ASSERT (ind
->got
.refcount
< lowest_valid
);
1476 tmp
= dir
->plt
.refcount
;
1477 if (tmp
< lowest_valid
)
1479 dir
->plt
.refcount
= ind
->plt
.refcount
;
1480 ind
->plt
.refcount
= tmp
;
1483 BFD_ASSERT (ind
->plt
.refcount
< lowest_valid
);
1485 if (dir
->dynindx
== -1)
1487 dir
->dynindx
= ind
->dynindx
;
1488 dir
->dynstr_index
= ind
->dynstr_index
;
1490 ind
->dynstr_index
= 0;
1493 BFD_ASSERT (ind
->dynindx
== -1);
1497 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
)
1498 struct bfd_link_info
*info
;
1499 struct elf_link_hash_entry
*h
;
1500 bfd_boolean force_local
;
1502 h
->plt
.offset
= (bfd_vma
) -1;
1503 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1506 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
1507 if (h
->dynindx
!= -1)
1510 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1516 /* Initialize an ELF linker hash table. */
1519 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
1520 struct elf_link_hash_table
*table
;
1522 struct bfd_hash_entry
*(*newfunc
)
1523 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*,
1528 table
->dynamic_sections_created
= FALSE
;
1529 table
->dynobj
= NULL
;
1530 /* Make sure can_refcount is extended to the width and signedness of
1531 init_refcount before we subtract one from it. */
1532 table
->init_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
1533 --table
->init_refcount
;
1534 /* The first dynamic symbol is a dummy. */
1535 table
->dynsymcount
= 1;
1536 table
->dynstr
= NULL
;
1537 table
->bucketcount
= 0;
1538 table
->needed
= NULL
;
1540 table
->stab_info
= NULL
;
1541 table
->merge_info
= NULL
;
1542 memset (&table
->eh_info
, 0, sizeof (table
->eh_info
));
1543 table
->dynlocal
= NULL
;
1544 table
->runpath
= NULL
;
1545 table
->tls_segment
= NULL
;
1546 table
->loaded
= NULL
;
1548 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
1549 table
->root
.type
= bfd_link_elf_hash_table
;
1554 /* Create an ELF linker hash table. */
1556 struct bfd_link_hash_table
*
1557 _bfd_elf_link_hash_table_create (abfd
)
1560 struct elf_link_hash_table
*ret
;
1561 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1563 ret
= (struct elf_link_hash_table
*) bfd_malloc (amt
);
1564 if (ret
== (struct elf_link_hash_table
*) NULL
)
1567 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1576 /* This is a hook for the ELF emulation code in the generic linker to
1577 tell the backend linker what file name to use for the DT_NEEDED
1578 entry for a dynamic object. The generic linker passes name as an
1579 empty string to indicate that no DT_NEEDED entry should be made. */
1582 bfd_elf_set_dt_needed_name (abfd
, name
)
1586 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1587 && bfd_get_format (abfd
) == bfd_object
)
1588 elf_dt_name (abfd
) = name
;
1592 bfd_elf_set_dt_needed_soname (abfd
, name
)
1596 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1597 && bfd_get_format (abfd
) == bfd_object
)
1598 elf_dt_soname (abfd
) = name
;
1601 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1602 the linker ELF emulation code. */
1604 struct bfd_link_needed_list
*
1605 bfd_elf_get_needed_list (abfd
, info
)
1606 bfd
*abfd ATTRIBUTE_UNUSED
;
1607 struct bfd_link_info
*info
;
1609 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1611 return elf_hash_table (info
)->needed
;
1614 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1615 hook for the linker ELF emulation code. */
1617 struct bfd_link_needed_list
*
1618 bfd_elf_get_runpath_list (abfd
, info
)
1619 bfd
*abfd ATTRIBUTE_UNUSED
;
1620 struct bfd_link_info
*info
;
1622 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
1624 return elf_hash_table (info
)->runpath
;
1627 /* Get the name actually used for a dynamic object for a link. This
1628 is the SONAME entry if there is one. Otherwise, it is the string
1629 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1632 bfd_elf_get_dt_soname (abfd
)
1635 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1636 && bfd_get_format (abfd
) == bfd_object
)
1637 return elf_dt_name (abfd
);
1641 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1642 the ELF linker emulation code. */
1645 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
1647 struct bfd_link_needed_list
**pneeded
;
1650 bfd_byte
*dynbuf
= NULL
;
1652 unsigned long shlink
;
1653 bfd_byte
*extdyn
, *extdynend
;
1655 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1659 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1660 || bfd_get_format (abfd
) != bfd_object
)
1663 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1664 if (s
== NULL
|| s
->_raw_size
== 0)
1667 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1671 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1675 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1679 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1681 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1682 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1685 extdynend
= extdyn
+ s
->_raw_size
;
1686 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1688 Elf_Internal_Dyn dyn
;
1690 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1692 if (dyn
.d_tag
== DT_NULL
)
1695 if (dyn
.d_tag
== DT_NEEDED
)
1698 struct bfd_link_needed_list
*l
;
1699 unsigned int tagv
= dyn
.d_un
.d_val
;
1702 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1707 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, amt
);
1728 /* Allocate an ELF string table--force the first byte to be zero. */
1730 struct bfd_strtab_hash
*
1731 _bfd_elf_stringtab_init ()
1733 struct bfd_strtab_hash
*ret
;
1735 ret
= _bfd_stringtab_init ();
1740 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1741 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1742 if (loc
== (bfd_size_type
) -1)
1744 _bfd_stringtab_free (ret
);
1751 /* ELF .o/exec file reading */
1753 /* Create a new bfd section from an ELF section header. */
1756 bfd_section_from_shdr (abfd
, shindex
)
1758 unsigned int shindex
;
1760 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1761 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1762 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1765 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1767 switch (hdr
->sh_type
)
1770 /* Inactive section. Throw it away. */
1773 case SHT_PROGBITS
: /* Normal section with contents. */
1774 case SHT_NOBITS
: /* .bss section. */
1775 case SHT_HASH
: /* .hash section. */
1776 case SHT_NOTE
: /* .note section. */
1777 case SHT_INIT_ARRAY
: /* .init_array section. */
1778 case SHT_FINI_ARRAY
: /* .fini_array section. */
1779 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1780 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1782 case SHT_DYNAMIC
: /* Dynamic linking information. */
1783 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1785 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1787 Elf_Internal_Shdr
*dynsymhdr
;
1789 /* The shared libraries distributed with hpux11 have a bogus
1790 sh_link field for the ".dynamic" section. Find the
1791 string table for the ".dynsym" section instead. */
1792 if (elf_dynsymtab (abfd
) != 0)
1794 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1795 hdr
->sh_link
= dynsymhdr
->sh_link
;
1799 unsigned int i
, num_sec
;
1801 num_sec
= elf_numsections (abfd
);
1802 for (i
= 1; i
< num_sec
; i
++)
1804 dynsymhdr
= elf_elfsections (abfd
)[i
];
1805 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1807 hdr
->sh_link
= dynsymhdr
->sh_link
;
1815 case SHT_SYMTAB
: /* A symbol table */
1816 if (elf_onesymtab (abfd
) == shindex
)
1819 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1820 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1821 elf_onesymtab (abfd
) = shindex
;
1822 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1823 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1824 abfd
->flags
|= HAS_SYMS
;
1826 /* Sometimes a shared object will map in the symbol table. If
1827 SHF_ALLOC is set, and this is a shared object, then we also
1828 treat this section as a BFD section. We can not base the
1829 decision purely on SHF_ALLOC, because that flag is sometimes
1830 set in a relocateable object file, which would confuse the
1832 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1833 && (abfd
->flags
& DYNAMIC
) != 0
1834 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1839 case SHT_DYNSYM
: /* A dynamic symbol table */
1840 if (elf_dynsymtab (abfd
) == shindex
)
1843 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1844 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1845 elf_dynsymtab (abfd
) = shindex
;
1846 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1847 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1848 abfd
->flags
|= HAS_SYMS
;
1850 /* Besides being a symbol table, we also treat this as a regular
1851 section, so that objcopy can handle it. */
1852 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1854 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1855 if (elf_symtab_shndx (abfd
) == shindex
)
1858 /* Get the associated symbol table. */
1859 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
)
1860 || hdr
->sh_link
!= elf_onesymtab (abfd
))
1863 elf_symtab_shndx (abfd
) = shindex
;
1864 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1865 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1868 case SHT_STRTAB
: /* A string table */
1869 if (hdr
->bfd_section
!= NULL
)
1871 if (ehdr
->e_shstrndx
== shindex
)
1873 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1874 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1878 unsigned int i
, num_sec
;
1880 num_sec
= elf_numsections (abfd
);
1881 for (i
= 1; i
< num_sec
; i
++)
1883 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1884 if (hdr2
->sh_link
== shindex
)
1886 if (! bfd_section_from_shdr (abfd
, i
))
1888 if (elf_onesymtab (abfd
) == i
)
1890 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1891 elf_elfsections (abfd
)[shindex
] =
1892 &elf_tdata (abfd
)->strtab_hdr
;
1895 if (elf_dynsymtab (abfd
) == i
)
1897 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1898 elf_elfsections (abfd
)[shindex
] = hdr
=
1899 &elf_tdata (abfd
)->dynstrtab_hdr
;
1900 /* We also treat this as a regular section, so
1901 that objcopy can handle it. */
1904 #if 0 /* Not handling other string tables specially right now. */
1905 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1906 /* We have a strtab for some random other section. */
1907 newsect
= (asection
*) hdr2
->bfd_section
;
1910 hdr
->bfd_section
= newsect
;
1911 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1913 elf_elfsections (abfd
)[shindex
] = hdr2
;
1919 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1923 /* *These* do a lot of work -- but build no sections! */
1925 asection
*target_sect
;
1926 Elf_Internal_Shdr
*hdr2
;
1927 unsigned int num_sec
= elf_numsections (abfd
);
1929 /* Check for a bogus link to avoid crashing. */
1930 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1931 || hdr
->sh_link
>= num_sec
)
1933 ((*_bfd_error_handler
)
1934 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1935 bfd_archive_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1936 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1939 /* For some incomprehensible reason Oracle distributes
1940 libraries for Solaris in which some of the objects have
1941 bogus sh_link fields. It would be nice if we could just
1942 reject them, but, unfortunately, some people need to use
1943 them. We scan through the section headers; if we find only
1944 one suitable symbol table, we clobber the sh_link to point
1945 to it. I hope this doesn't break anything. */
1946 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1947 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1953 for (scan
= 1; scan
< num_sec
; scan
++)
1955 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1956 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1967 hdr
->sh_link
= found
;
1970 /* Get the symbol table. */
1971 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1972 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1975 /* If this reloc section does not use the main symbol table we
1976 don't treat it as a reloc section. BFD can't adequately
1977 represent such a section, so at least for now, we don't
1978 try. We just present it as a normal section. We also
1979 can't use it as a reloc section if it points to the null
1981 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1982 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1984 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1986 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1987 if (target_sect
== NULL
)
1990 if ((target_sect
->flags
& SEC_RELOC
) == 0
1991 || target_sect
->reloc_count
== 0)
1992 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1996 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1997 amt
= sizeof (*hdr2
);
1998 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
1999 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
2002 elf_elfsections (abfd
)[shindex
] = hdr2
;
2003 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2004 target_sect
->flags
|= SEC_RELOC
;
2005 target_sect
->relocation
= NULL
;
2006 target_sect
->rel_filepos
= hdr
->sh_offset
;
2007 /* In the section to which the relocations apply, mark whether
2008 its relocations are of the REL or RELA variety. */
2009 if (hdr
->sh_size
!= 0)
2010 elf_section_data (target_sect
)->use_rela_p
2011 = (hdr
->sh_type
== SHT_RELA
);
2012 abfd
->flags
|= HAS_RELOC
;
2017 case SHT_GNU_verdef
:
2018 elf_dynverdef (abfd
) = shindex
;
2019 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2020 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
2023 case SHT_GNU_versym
:
2024 elf_dynversym (abfd
) = shindex
;
2025 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2026 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
2029 case SHT_GNU_verneed
:
2030 elf_dynverref (abfd
) = shindex
;
2031 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2032 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
2039 /* We need a BFD section for objcopy and relocatable linking,
2040 and it's handy to have the signature available as the section
2042 name
= group_signature (abfd
, hdr
);
2045 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2047 if (hdr
->contents
!= NULL
)
2049 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2050 unsigned int n_elt
= hdr
->sh_size
/ 4;
2053 if (idx
->flags
& GRP_COMDAT
)
2054 hdr
->bfd_section
->flags
2055 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2057 while (--n_elt
!= 0)
2058 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
2059 && elf_next_in_group (s
) != NULL
)
2061 elf_next_in_group (hdr
->bfd_section
) = s
;
2068 /* Check for any processor-specific section types. */
2070 if (bed
->elf_backend_section_from_shdr
)
2071 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
2079 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2080 Return SEC for sections that have no elf section, and NULL on error. */
2083 bfd_section_from_r_symndx (abfd
, cache
, sec
, r_symndx
)
2085 struct sym_sec_cache
*cache
;
2087 unsigned long r_symndx
;
2089 Elf_Internal_Shdr
*symtab_hdr
;
2090 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2091 Elf_External_Sym_Shndx eshndx
;
2092 Elf_Internal_Sym isym
;
2093 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2095 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
2096 return cache
->sec
[ent
];
2098 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2099 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2100 &isym
, esym
, &eshndx
) == NULL
)
2103 if (cache
->abfd
!= abfd
)
2105 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2108 cache
->indx
[ent
] = r_symndx
;
2109 cache
->sec
[ent
] = sec
;
2110 if (isym
.st_shndx
< SHN_LORESERVE
|| isym
.st_shndx
> SHN_HIRESERVE
)
2113 s
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
2115 cache
->sec
[ent
] = s
;
2117 return cache
->sec
[ent
];
2120 /* Given an ELF section number, retrieve the corresponding BFD
2124 bfd_section_from_elf_index (abfd
, index
)
2128 if (index
>= elf_numsections (abfd
))
2130 return elf_elfsections (abfd
)[index
]->bfd_section
;
2134 _bfd_elf_new_section_hook (abfd
, sec
)
2138 struct bfd_elf_section_data
*sdata
;
2140 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2143 bfd_size_type amt
= sizeof (*sdata
);
2144 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, amt
);
2147 sec
->used_by_bfd
= (PTR
) sdata
;
2150 /* Indicate whether or not this section should use RELA relocations. */
2152 = get_elf_backend_data (abfd
)->default_use_rela_p
;
2157 /* Create a new bfd section from an ELF program header.
2159 Since program segments have no names, we generate a synthetic name
2160 of the form segment<NUM>, where NUM is generally the index in the
2161 program header table. For segments that are split (see below) we
2162 generate the names segment<NUM>a and segment<NUM>b.
2164 Note that some program segments may have a file size that is different than
2165 (less than) the memory size. All this means is that at execution the
2166 system must allocate the amount of memory specified by the memory size,
2167 but only initialize it with the first "file size" bytes read from the
2168 file. This would occur for example, with program segments consisting
2169 of combined data+bss.
2171 To handle the above situation, this routine generates TWO bfd sections
2172 for the single program segment. The first has the length specified by
2173 the file size of the segment, and the second has the length specified
2174 by the difference between the two sizes. In effect, the segment is split
2175 into it's initialized and uninitialized parts.
2180 _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
)
2182 Elf_Internal_Phdr
*hdr
;
2184 const char *typename
;
2192 split
= ((hdr
->p_memsz
> 0)
2193 && (hdr
->p_filesz
> 0)
2194 && (hdr
->p_memsz
> hdr
->p_filesz
));
2195 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2196 len
= strlen (namebuf
) + 1;
2197 name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
2200 memcpy (name
, namebuf
, len
);
2201 newsect
= bfd_make_section (abfd
, name
);
2202 if (newsect
== NULL
)
2204 newsect
->vma
= hdr
->p_vaddr
;
2205 newsect
->lma
= hdr
->p_paddr
;
2206 newsect
->_raw_size
= hdr
->p_filesz
;
2207 newsect
->filepos
= hdr
->p_offset
;
2208 newsect
->flags
|= SEC_HAS_CONTENTS
;
2209 if (hdr
->p_type
== PT_LOAD
)
2211 newsect
->flags
|= SEC_ALLOC
;
2212 newsect
->flags
|= SEC_LOAD
;
2213 if (hdr
->p_flags
& PF_X
)
2215 /* FIXME: all we known is that it has execute PERMISSION,
2217 newsect
->flags
|= SEC_CODE
;
2220 if (!(hdr
->p_flags
& PF_W
))
2222 newsect
->flags
|= SEC_READONLY
;
2227 sprintf (namebuf
, "%s%db", typename
, index
);
2228 len
= strlen (namebuf
) + 1;
2229 name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
2232 memcpy (name
, namebuf
, len
);
2233 newsect
= bfd_make_section (abfd
, name
);
2234 if (newsect
== NULL
)
2236 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2237 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2238 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
2239 if (hdr
->p_type
== PT_LOAD
)
2241 newsect
->flags
|= SEC_ALLOC
;
2242 if (hdr
->p_flags
& PF_X
)
2243 newsect
->flags
|= SEC_CODE
;
2245 if (!(hdr
->p_flags
& PF_W
))
2246 newsect
->flags
|= SEC_READONLY
;
2253 bfd_section_from_phdr (abfd
, hdr
, index
)
2255 Elf_Internal_Phdr
*hdr
;
2258 struct elf_backend_data
*bed
;
2260 switch (hdr
->p_type
)
2263 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2266 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2269 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2272 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2275 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2277 if (! elfcore_read_notes (abfd
, (file_ptr
) hdr
->p_offset
, hdr
->p_filesz
))
2282 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2285 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2288 /* Check for any processor-specific program segment types.
2289 If no handler for them, default to making "segment" sections. */
2290 bed
= get_elf_backend_data (abfd
);
2291 if (bed
->elf_backend_section_from_phdr
)
2292 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
2294 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
2298 /* Initialize REL_HDR, the section-header for new section, containing
2299 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2300 relocations; otherwise, we use REL relocations. */
2303 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
2305 Elf_Internal_Shdr
*rel_hdr
;
2307 bfd_boolean use_rela_p
;
2310 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2311 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2313 name
= bfd_alloc (abfd
, amt
);
2316 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2318 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2320 if (rel_hdr
->sh_name
== (unsigned int) -1)
2322 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2323 rel_hdr
->sh_entsize
= (use_rela_p
2324 ? bed
->s
->sizeof_rela
2325 : bed
->s
->sizeof_rel
);
2326 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
2327 rel_hdr
->sh_flags
= 0;
2328 rel_hdr
->sh_addr
= 0;
2329 rel_hdr
->sh_size
= 0;
2330 rel_hdr
->sh_offset
= 0;
2335 /* Set up an ELF internal section header for a section. */
2338 elf_fake_sections (abfd
, asect
, failedptrarg
)
2343 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2344 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2345 Elf_Internal_Shdr
*this_hdr
;
2349 /* We already failed; just get out of the bfd_map_over_sections
2354 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2356 this_hdr
->sh_name
= (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2357 asect
->name
, FALSE
);
2358 if (this_hdr
->sh_name
== (unsigned long) -1)
2364 this_hdr
->sh_flags
= 0;
2366 if ((asect
->flags
& SEC_ALLOC
) != 0
2367 || asect
->user_set_vma
)
2368 this_hdr
->sh_addr
= asect
->vma
;
2370 this_hdr
->sh_addr
= 0;
2372 this_hdr
->sh_offset
= 0;
2373 this_hdr
->sh_size
= asect
->_raw_size
;
2374 this_hdr
->sh_link
= 0;
2375 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2376 /* The sh_entsize and sh_info fields may have been set already by
2377 copy_private_section_data. */
2379 this_hdr
->bfd_section
= asect
;
2380 this_hdr
->contents
= NULL
;
2382 /* FIXME: This should not be based on section names. */
2383 if (strcmp (asect
->name
, ".dynstr") == 0)
2384 this_hdr
->sh_type
= SHT_STRTAB
;
2385 else if (strcmp (asect
->name
, ".hash") == 0)
2387 this_hdr
->sh_type
= SHT_HASH
;
2388 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2390 else if (strcmp (asect
->name
, ".dynsym") == 0)
2392 this_hdr
->sh_type
= SHT_DYNSYM
;
2393 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2395 else if (strcmp (asect
->name
, ".dynamic") == 0)
2397 this_hdr
->sh_type
= SHT_DYNAMIC
;
2398 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2400 else if (strncmp (asect
->name
, ".rela", 5) == 0
2401 && get_elf_backend_data (abfd
)->may_use_rela_p
)
2403 this_hdr
->sh_type
= SHT_RELA
;
2404 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2406 else if (strncmp (asect
->name
, ".rel", 4) == 0
2407 && get_elf_backend_data (abfd
)->may_use_rel_p
)
2409 this_hdr
->sh_type
= SHT_REL
;
2410 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2412 else if (strcmp (asect
->name
, ".init_array") == 0)
2413 this_hdr
->sh_type
= SHT_INIT_ARRAY
;
2414 else if (strcmp (asect
->name
, ".fini_array") == 0)
2415 this_hdr
->sh_type
= SHT_FINI_ARRAY
;
2416 else if (strcmp (asect
->name
, ".preinit_array") == 0)
2417 this_hdr
->sh_type
= SHT_PREINIT_ARRAY
;
2418 else if (strncmp (asect
->name
, ".note", 5) == 0)
2419 this_hdr
->sh_type
= SHT_NOTE
;
2420 else if (strncmp (asect
->name
, ".stab", 5) == 0
2421 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
2422 this_hdr
->sh_type
= SHT_STRTAB
;
2423 else if (strcmp (asect
->name
, ".gnu.version") == 0)
2425 this_hdr
->sh_type
= SHT_GNU_versym
;
2426 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2428 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
2430 this_hdr
->sh_type
= SHT_GNU_verdef
;
2431 this_hdr
->sh_entsize
= 0;
2432 /* objcopy or strip will copy over sh_info, but may not set
2433 cverdefs. The linker will set cverdefs, but sh_info will be
2435 if (this_hdr
->sh_info
== 0)
2436 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2438 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2439 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2441 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
2443 this_hdr
->sh_type
= SHT_GNU_verneed
;
2444 this_hdr
->sh_entsize
= 0;
2445 /* objcopy or strip will copy over sh_info, but may not set
2446 cverrefs. The linker will set cverrefs, but sh_info will be
2448 if (this_hdr
->sh_info
== 0)
2449 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2451 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2452 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2454 else if ((asect
->flags
& SEC_GROUP
) != 0)
2456 this_hdr
->sh_type
= SHT_GROUP
;
2457 this_hdr
->sh_entsize
= 4;
2459 else if ((asect
->flags
& SEC_ALLOC
) != 0
2460 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2461 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2462 this_hdr
->sh_type
= SHT_NOBITS
;
2464 this_hdr
->sh_type
= SHT_PROGBITS
;
2466 if ((asect
->flags
& SEC_ALLOC
) != 0)
2467 this_hdr
->sh_flags
|= SHF_ALLOC
;
2468 if ((asect
->flags
& SEC_READONLY
) == 0)
2469 this_hdr
->sh_flags
|= SHF_WRITE
;
2470 if ((asect
->flags
& SEC_CODE
) != 0)
2471 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2472 if ((asect
->flags
& SEC_MERGE
) != 0)
2474 this_hdr
->sh_flags
|= SHF_MERGE
;
2475 this_hdr
->sh_entsize
= asect
->entsize
;
2476 if ((asect
->flags
& SEC_STRINGS
) != 0)
2477 this_hdr
->sh_flags
|= SHF_STRINGS
;
2479 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2480 this_hdr
->sh_flags
|= SHF_GROUP
;
2481 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2483 this_hdr
->sh_flags
|= SHF_TLS
;
2484 if (asect
->_raw_size
== 0 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2486 struct bfd_link_order
*o
;
2488 this_hdr
->sh_size
= 0;
2489 for (o
= asect
->link_order_head
; o
!= NULL
; o
= o
->next
)
2490 if (this_hdr
->sh_size
< o
->offset
+ o
->size
)
2491 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2492 if (this_hdr
->sh_size
)
2493 this_hdr
->sh_type
= SHT_NOBITS
;
2497 /* Check for processor-specific section types. */
2498 if (bed
->elf_backend_fake_sections
2499 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2502 /* If the section has relocs, set up a section header for the
2503 SHT_REL[A] section. If two relocation sections are required for
2504 this section, it is up to the processor-specific back-end to
2505 create the other. */
2506 if ((asect
->flags
& SEC_RELOC
) != 0
2507 && !_bfd_elf_init_reloc_shdr (abfd
,
2508 &elf_section_data (asect
)->rel_hdr
,
2510 elf_section_data (asect
)->use_rela_p
))
2514 /* Fill in the contents of a SHT_GROUP section. */
2517 bfd_elf_set_group_contents (abfd
, sec
, failedptrarg
)
2522 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2523 unsigned long symindx
;
2524 asection
*elt
, *first
;
2526 struct bfd_link_order
*l
;
2529 if (elf_section_data (sec
)->this_hdr
.sh_type
!= SHT_GROUP
2534 if (elf_group_id (sec
) != NULL
)
2535 symindx
= elf_group_id (sec
)->udata
.i
;
2539 /* If called from the assembler, swap_out_syms will have set up
2540 elf_section_syms; If called for "ld -r", use target_index. */
2541 if (elf_section_syms (abfd
) != NULL
)
2542 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2544 symindx
= sec
->target_index
;
2546 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2548 /* The contents won't be allocated for "ld -r" or objcopy. */
2550 if (sec
->contents
== NULL
)
2553 sec
->contents
= bfd_alloc (abfd
, sec
->_raw_size
);
2555 /* Arrange for the section to be written out. */
2556 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2557 if (sec
->contents
== NULL
)
2564 loc
= sec
->contents
+ sec
->_raw_size
;
2566 /* Get the pointer to the first section in the group that gas
2567 squirreled away here. objcopy arranges for this to be set to the
2568 start of the input section group. */
2569 first
= elt
= elf_next_in_group (sec
);
2571 /* First element is a flag word. Rest of section is elf section
2572 indices for all the sections of the group. Write them backwards
2573 just to keep the group in the same order as given in .section
2574 directives, not that it matters. */
2583 s
= s
->output_section
;
2586 idx
= elf_section_data (s
)->this_idx
;
2587 H_PUT_32 (abfd
, idx
, loc
);
2588 elt
= elf_next_in_group (elt
);
2593 /* If this is a relocatable link, then the above did nothing because
2594 SEC is the output section. Look through the input sections
2596 for (l
= sec
->link_order_head
; l
!= NULL
; l
= l
->next
)
2597 if (l
->type
== bfd_indirect_link_order
2598 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2603 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2604 elt
= elf_next_in_group (elt
);
2605 /* During a relocatable link, the lists are circular. */
2607 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2609 /* With ld -r, merging SHT_GROUP sections results in wasted space
2610 due to allowing for the flag word on each input. We may well
2611 duplicate entries too. */
2612 while ((loc
-= 4) > sec
->contents
)
2613 H_PUT_32 (abfd
, 0, loc
);
2615 if (loc
!= sec
->contents
)
2618 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2621 /* Assign all ELF section numbers. The dummy first section is handled here
2622 too. The link/info pointers for the standard section types are filled
2623 in here too, while we're at it. */
2626 assign_section_numbers (abfd
)
2629 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2631 unsigned int section_number
, secn
;
2632 Elf_Internal_Shdr
**i_shdrp
;
2637 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2639 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2641 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2643 if (section_number
== SHN_LORESERVE
)
2644 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2645 d
->this_idx
= section_number
++;
2646 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2647 if ((sec
->flags
& SEC_RELOC
) == 0)
2651 if (section_number
== SHN_LORESERVE
)
2652 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2653 d
->rel_idx
= section_number
++;
2654 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2659 if (section_number
== SHN_LORESERVE
)
2660 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2661 d
->rel_idx2
= section_number
++;
2662 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2668 if (section_number
== SHN_LORESERVE
)
2669 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2670 t
->shstrtab_section
= section_number
++;
2671 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2672 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2674 if (bfd_get_symcount (abfd
) > 0)
2676 if (section_number
== SHN_LORESERVE
)
2677 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2678 t
->symtab_section
= section_number
++;
2679 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2680 if (section_number
> SHN_LORESERVE
- 2)
2682 if (section_number
== SHN_LORESERVE
)
2683 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2684 t
->symtab_shndx_section
= section_number
++;
2685 t
->symtab_shndx_hdr
.sh_name
2686 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2687 ".symtab_shndx", FALSE
);
2688 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2691 if (section_number
== SHN_LORESERVE
)
2692 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2693 t
->strtab_section
= section_number
++;
2694 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2697 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2698 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2700 elf_numsections (abfd
) = section_number
;
2701 elf_elfheader (abfd
)->e_shnum
= section_number
;
2702 if (section_number
> SHN_LORESERVE
)
2703 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2705 /* Set up the list of section header pointers, in agreement with the
2707 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2708 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc (abfd
, amt
);
2709 if (i_shdrp
== NULL
)
2712 amt
= sizeof (Elf_Internal_Shdr
);
2713 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
, amt
);
2714 if (i_shdrp
[0] == NULL
)
2716 bfd_release (abfd
, i_shdrp
);
2720 elf_elfsections (abfd
) = i_shdrp
;
2722 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2723 if (bfd_get_symcount (abfd
) > 0)
2725 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2726 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2728 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2729 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2731 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2732 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2734 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2736 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2740 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2741 if (d
->rel_idx
!= 0)
2742 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2743 if (d
->rel_idx2
!= 0)
2744 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2746 /* Fill in the sh_link and sh_info fields while we're at it. */
2748 /* sh_link of a reloc section is the section index of the symbol
2749 table. sh_info is the section index of the section to which
2750 the relocation entries apply. */
2751 if (d
->rel_idx
!= 0)
2753 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2754 d
->rel_hdr
.sh_info
= d
->this_idx
;
2756 if (d
->rel_idx2
!= 0)
2758 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2759 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2762 switch (d
->this_hdr
.sh_type
)
2766 /* A reloc section which we are treating as a normal BFD
2767 section. sh_link is the section index of the symbol
2768 table. sh_info is the section index of the section to
2769 which the relocation entries apply. We assume that an
2770 allocated reloc section uses the dynamic symbol table.
2771 FIXME: How can we be sure? */
2772 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2774 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2776 /* We look up the section the relocs apply to by name. */
2778 if (d
->this_hdr
.sh_type
== SHT_REL
)
2782 s
= bfd_get_section_by_name (abfd
, name
);
2784 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2788 /* We assume that a section named .stab*str is a stabs
2789 string section. We look for a section with the same name
2790 but without the trailing ``str'', and set its sh_link
2791 field to point to this section. */
2792 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
2793 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2798 len
= strlen (sec
->name
);
2799 alc
= (char *) bfd_malloc ((bfd_size_type
) (len
- 2));
2802 memcpy (alc
, sec
->name
, len
- 3);
2803 alc
[len
- 3] = '\0';
2804 s
= bfd_get_section_by_name (abfd
, alc
);
2808 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2810 /* This is a .stab section. */
2811 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
2812 elf_section_data (s
)->this_hdr
.sh_entsize
2813 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2820 case SHT_GNU_verneed
:
2821 case SHT_GNU_verdef
:
2822 /* sh_link is the section header index of the string table
2823 used for the dynamic entries, or the symbol table, or the
2825 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2827 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2831 case SHT_GNU_versym
:
2832 /* sh_link is the section header index of the symbol table
2833 this hash table or version table is for. */
2834 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2836 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2840 d
->this_hdr
.sh_link
= t
->symtab_section
;
2844 for (secn
= 1; secn
< section_number
; ++secn
)
2845 if (i_shdrp
[secn
] == NULL
)
2846 i_shdrp
[secn
] = i_shdrp
[0];
2848 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
2849 i_shdrp
[secn
]->sh_name
);
2853 /* Map symbol from it's internal number to the external number, moving
2854 all local symbols to be at the head of the list. */
2857 sym_is_global (abfd
, sym
)
2861 /* If the backend has a special mapping, use it. */
2862 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2863 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
2866 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2867 || bfd_is_und_section (bfd_get_section (sym
))
2868 || bfd_is_com_section (bfd_get_section (sym
)));
2872 elf_map_symbols (abfd
)
2875 unsigned int symcount
= bfd_get_symcount (abfd
);
2876 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2877 asymbol
**sect_syms
;
2878 unsigned int num_locals
= 0;
2879 unsigned int num_globals
= 0;
2880 unsigned int num_locals2
= 0;
2881 unsigned int num_globals2
= 0;
2889 fprintf (stderr
, "elf_map_symbols\n");
2893 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2895 if (max_index
< asect
->index
)
2896 max_index
= asect
->index
;
2900 amt
= max_index
* sizeof (asymbol
*);
2901 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
2902 if (sect_syms
== NULL
)
2904 elf_section_syms (abfd
) = sect_syms
;
2905 elf_num_section_syms (abfd
) = max_index
;
2907 /* Init sect_syms entries for any section symbols we have already
2908 decided to output. */
2909 for (idx
= 0; idx
< symcount
; idx
++)
2911 asymbol
*sym
= syms
[idx
];
2913 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2920 if (sec
->owner
!= NULL
)
2922 if (sec
->owner
!= abfd
)
2924 if (sec
->output_offset
!= 0)
2927 sec
= sec
->output_section
;
2929 /* Empty sections in the input files may have had a
2930 section symbol created for them. (See the comment
2931 near the end of _bfd_generic_link_output_symbols in
2932 linker.c). If the linker script discards such
2933 sections then we will reach this point. Since we know
2934 that we cannot avoid this case, we detect it and skip
2935 the abort and the assignment to the sect_syms array.
2936 To reproduce this particular case try running the
2937 linker testsuite test ld-scripts/weak.exp for an ELF
2938 port that uses the generic linker. */
2939 if (sec
->owner
== NULL
)
2942 BFD_ASSERT (sec
->owner
== abfd
);
2944 sect_syms
[sec
->index
] = syms
[idx
];
2949 /* Classify all of the symbols. */
2950 for (idx
= 0; idx
< symcount
; idx
++)
2952 if (!sym_is_global (abfd
, syms
[idx
]))
2958 /* We will be adding a section symbol for each BFD section. Most normal
2959 sections will already have a section symbol in outsymbols, but
2960 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2961 at least in that case. */
2962 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2964 if (sect_syms
[asect
->index
] == NULL
)
2966 if (!sym_is_global (abfd
, asect
->symbol
))
2973 /* Now sort the symbols so the local symbols are first. */
2974 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
2975 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
2977 if (new_syms
== NULL
)
2980 for (idx
= 0; idx
< symcount
; idx
++)
2982 asymbol
*sym
= syms
[idx
];
2985 if (!sym_is_global (abfd
, sym
))
2988 i
= num_locals
+ num_globals2
++;
2990 sym
->udata
.i
= i
+ 1;
2992 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2994 if (sect_syms
[asect
->index
] == NULL
)
2996 asymbol
*sym
= asect
->symbol
;
2999 sect_syms
[asect
->index
] = sym
;
3000 if (!sym_is_global (abfd
, sym
))
3003 i
= num_locals
+ num_globals2
++;
3005 sym
->udata
.i
= i
+ 1;
3009 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3011 elf_num_locals (abfd
) = num_locals
;
3012 elf_num_globals (abfd
) = num_globals
;
3016 /* Align to the maximum file alignment that could be required for any
3017 ELF data structure. */
3019 static INLINE file_ptr align_file_position
3020 PARAMS ((file_ptr
, int));
3021 static INLINE file_ptr
3022 align_file_position (off
, align
)
3026 return (off
+ align
- 1) & ~(align
- 1);
3029 /* Assign a file position to a section, optionally aligning to the
3030 required section alignment. */
3033 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
3034 Elf_Internal_Shdr
*i_shdrp
;
3042 al
= i_shdrp
->sh_addralign
;
3044 offset
= BFD_ALIGN (offset
, al
);
3046 i_shdrp
->sh_offset
= offset
;
3047 if (i_shdrp
->bfd_section
!= NULL
)
3048 i_shdrp
->bfd_section
->filepos
= offset
;
3049 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3050 offset
+= i_shdrp
->sh_size
;
3054 /* Compute the file positions we are going to put the sections at, and
3055 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3056 is not NULL, this is being called by the ELF backend linker. */
3059 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
3061 struct bfd_link_info
*link_info
;
3063 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3065 struct bfd_strtab_hash
*strtab
;
3066 Elf_Internal_Shdr
*shstrtab_hdr
;
3068 if (abfd
->output_has_begun
)
3071 /* Do any elf backend specific processing first. */
3072 if (bed
->elf_backend_begin_write_processing
)
3073 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3075 if (! prep_headers (abfd
))
3078 /* Post process the headers if necessary. */
3079 if (bed
->elf_backend_post_process_headers
)
3080 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3083 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3087 if (!assign_section_numbers (abfd
))
3090 /* The backend linker builds symbol table information itself. */
3091 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3093 /* Non-zero if doing a relocatable link. */
3094 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3096 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3100 if (link_info
== NULL
)
3102 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3107 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3108 /* sh_name was set in prep_headers. */
3109 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3110 shstrtab_hdr
->sh_flags
= 0;
3111 shstrtab_hdr
->sh_addr
= 0;
3112 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3113 shstrtab_hdr
->sh_entsize
= 0;
3114 shstrtab_hdr
->sh_link
= 0;
3115 shstrtab_hdr
->sh_info
= 0;
3116 /* sh_offset is set in assign_file_positions_except_relocs. */
3117 shstrtab_hdr
->sh_addralign
= 1;
3119 if (!assign_file_positions_except_relocs (abfd
))
3122 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3125 Elf_Internal_Shdr
*hdr
;
3127 off
= elf_tdata (abfd
)->next_file_pos
;
3129 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3130 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3132 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3133 if (hdr
->sh_size
!= 0)
3134 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3136 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3137 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3139 elf_tdata (abfd
)->next_file_pos
= off
;
3141 /* Now that we know where the .strtab section goes, write it
3143 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3144 || ! _bfd_stringtab_emit (abfd
, strtab
))
3146 _bfd_stringtab_free (strtab
);
3149 abfd
->output_has_begun
= TRUE
;
3154 /* Create a mapping from a set of sections to a program segment. */
3156 static INLINE
struct elf_segment_map
*
3157 make_mapping (abfd
, sections
, from
, to
, phdr
)
3159 asection
**sections
;
3164 struct elf_segment_map
*m
;
3169 amt
= sizeof (struct elf_segment_map
);
3170 amt
+= (to
- from
- 1) * sizeof (asection
*);
3171 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3175 m
->p_type
= PT_LOAD
;
3176 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3177 m
->sections
[i
- from
] = *hdrpp
;
3178 m
->count
= to
- from
;
3180 if (from
== 0 && phdr
)
3182 /* Include the headers in the first PT_LOAD segment. */
3183 m
->includes_filehdr
= 1;
3184 m
->includes_phdrs
= 1;
3190 /* Set up a mapping from BFD sections to program segments. */
3193 map_sections_to_segments (abfd
)
3196 asection
**sections
= NULL
;
3200 struct elf_segment_map
*mfirst
;
3201 struct elf_segment_map
**pm
;
3202 struct elf_segment_map
*m
;
3204 unsigned int phdr_index
;
3205 bfd_vma maxpagesize
;
3207 bfd_boolean phdr_in_segment
= TRUE
;
3208 bfd_boolean writable
;
3210 asection
*first_tls
= NULL
;
3211 asection
*dynsec
, *eh_frame_hdr
;
3214 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3217 if (bfd_count_sections (abfd
) == 0)
3220 /* Select the allocated sections, and sort them. */
3222 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
3223 sections
= (asection
**) bfd_malloc (amt
);
3224 if (sections
== NULL
)
3228 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3230 if ((s
->flags
& SEC_ALLOC
) != 0)
3236 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3239 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3241 /* Build the mapping. */
3246 /* If we have a .interp section, then create a PT_PHDR segment for
3247 the program headers and a PT_INTERP segment for the .interp
3249 s
= bfd_get_section_by_name (abfd
, ".interp");
3250 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3252 amt
= sizeof (struct elf_segment_map
);
3253 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3257 m
->p_type
= PT_PHDR
;
3258 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3259 m
->p_flags
= PF_R
| PF_X
;
3260 m
->p_flags_valid
= 1;
3261 m
->includes_phdrs
= 1;
3266 amt
= sizeof (struct elf_segment_map
);
3267 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3271 m
->p_type
= PT_INTERP
;
3279 /* Look through the sections. We put sections in the same program
3280 segment when the start of the second section can be placed within
3281 a few bytes of the end of the first section. */
3284 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3286 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3288 && (dynsec
->flags
& SEC_LOAD
) == 0)
3291 /* Deal with -Ttext or something similar such that the first section
3292 is not adjacent to the program headers. This is an
3293 approximation, since at this point we don't know exactly how many
3294 program headers we will need. */
3297 bfd_size_type phdr_size
;
3299 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3301 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3302 if ((abfd
->flags
& D_PAGED
) == 0
3303 || sections
[0]->lma
< phdr_size
3304 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3305 phdr_in_segment
= FALSE
;
3308 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3311 bfd_boolean new_segment
;
3315 /* See if this section and the last one will fit in the same
3318 if (last_hdr
== NULL
)
3320 /* If we don't have a segment yet, then we don't need a new
3321 one (we build the last one after this loop). */
3322 new_segment
= FALSE
;
3324 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3326 /* If this section has a different relation between the
3327 virtual address and the load address, then we need a new
3331 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3332 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3334 /* If putting this section in this segment would force us to
3335 skip a page in the segment, then we need a new segment. */
3338 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
3339 && (hdr
->flags
& SEC_LOAD
) != 0)
3341 /* We don't want to put a loadable section after a
3342 nonloadable section in the same segment. */
3345 else if ((abfd
->flags
& D_PAGED
) == 0)
3347 /* If the file is not demand paged, which means that we
3348 don't require the sections to be correctly aligned in the
3349 file, then there is no other reason for a new segment. */
3350 new_segment
= FALSE
;
3353 && (hdr
->flags
& SEC_READONLY
) == 0
3354 && (((last_hdr
->lma
+ last_hdr
->_raw_size
- 1)
3355 & ~(maxpagesize
- 1))
3356 != (hdr
->lma
& ~(maxpagesize
- 1))))
3358 /* We don't want to put a writable section in a read only
3359 segment, unless they are on the same page in memory
3360 anyhow. We already know that the last section does not
3361 bring us past the current section on the page, so the
3362 only case in which the new section is not on the same
3363 page as the previous section is when the previous section
3364 ends precisely on a page boundary. */
3369 /* Otherwise, we can use the same segment. */
3370 new_segment
= FALSE
;
3375 if ((hdr
->flags
& SEC_READONLY
) == 0)
3381 /* We need a new program segment. We must create a new program
3382 header holding all the sections from phdr_index until hdr. */
3384 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3391 if ((hdr
->flags
& SEC_READONLY
) == 0)
3398 phdr_in_segment
= FALSE
;
3401 /* Create a final PT_LOAD program segment. */
3402 if (last_hdr
!= NULL
)
3404 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3412 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3415 amt
= sizeof (struct elf_segment_map
);
3416 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3420 m
->p_type
= PT_DYNAMIC
;
3422 m
->sections
[0] = dynsec
;
3428 /* For each loadable .note section, add a PT_NOTE segment. We don't
3429 use bfd_get_section_by_name, because if we link together
3430 nonloadable .note sections and loadable .note sections, we will
3431 generate two .note sections in the output file. FIXME: Using
3432 names for section types is bogus anyhow. */
3433 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3435 if ((s
->flags
& SEC_LOAD
) != 0
3436 && strncmp (s
->name
, ".note", 5) == 0)
3438 amt
= sizeof (struct elf_segment_map
);
3439 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3443 m
->p_type
= PT_NOTE
;
3450 if (s
->flags
& SEC_THREAD_LOCAL
)
3458 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3463 amt
= sizeof (struct elf_segment_map
);
3464 amt
+= (tls_count
- 1) * sizeof (asection
*);
3465 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3470 m
->count
= tls_count
;
3471 /* Mandated PF_R. */
3473 m
->p_flags_valid
= 1;
3474 for (i
= 0; i
< tls_count
; ++i
)
3476 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3477 m
->sections
[i
] = first_tls
;
3478 first_tls
= first_tls
->next
;
3485 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3487 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3488 if (eh_frame_hdr
!= NULL
3489 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3491 amt
= sizeof (struct elf_segment_map
);
3492 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3496 m
->p_type
= PT_GNU_EH_FRAME
;
3498 m
->sections
[0] = eh_frame_hdr
->output_section
;
3507 elf_tdata (abfd
)->segment_map
= mfirst
;
3511 if (sections
!= NULL
)
3516 /* Sort sections by address. */
3519 elf_sort_sections (arg1
, arg2
)
3523 const asection
*sec1
= *(const asection
**) arg1
;
3524 const asection
*sec2
= *(const asection
**) arg2
;
3525 bfd_size_type size1
, size2
;
3527 /* Sort by LMA first, since this is the address used to
3528 place the section into a segment. */
3529 if (sec1
->lma
< sec2
->lma
)
3531 else if (sec1
->lma
> sec2
->lma
)
3534 /* Then sort by VMA. Normally the LMA and the VMA will be
3535 the same, and this will do nothing. */
3536 if (sec1
->vma
< sec2
->vma
)
3538 else if (sec1
->vma
> sec2
->vma
)
3541 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3543 #define TOEND(x) (((x)->flags & (SEC_LOAD|SEC_THREAD_LOCAL)) == 0)
3549 /* If the indicies are the same, do not return 0
3550 here, but continue to try the next comparison. */
3551 if (sec1
->target_index
- sec2
->target_index
!= 0)
3552 return sec1
->target_index
- sec2
->target_index
;
3557 else if (TOEND (sec2
))
3562 /* Sort by size, to put zero sized sections
3563 before others at the same address. */
3565 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->_raw_size
: 0;
3566 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->_raw_size
: 0;
3573 return sec1
->target_index
- sec2
->target_index
;
3576 /* Assign file positions to the sections based on the mapping from
3577 sections to segments. This function also sets up some fields in
3578 the file header, and writes out the program headers. */
3581 assign_file_positions_for_segments (abfd
)
3584 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3586 struct elf_segment_map
*m
;
3588 Elf_Internal_Phdr
*phdrs
;
3590 bfd_vma filehdr_vaddr
, filehdr_paddr
;
3591 bfd_vma phdrs_vaddr
, phdrs_paddr
;
3592 Elf_Internal_Phdr
*p
;
3595 if (elf_tdata (abfd
)->segment_map
== NULL
)
3597 if (! map_sections_to_segments (abfd
))
3602 /* The placement algorithm assumes that non allocated sections are
3603 not in PT_LOAD segments. We ensure this here by removing such
3604 sections from the segment map. */
3605 for (m
= elf_tdata (abfd
)->segment_map
;
3609 unsigned int new_count
;
3612 if (m
->p_type
!= PT_LOAD
)
3616 for (i
= 0; i
< m
->count
; i
++)
3618 if ((m
->sections
[i
]->flags
& SEC_ALLOC
) != 0)
3621 m
->sections
[new_count
] = m
->sections
[i
];
3627 if (new_count
!= m
->count
)
3628 m
->count
= new_count
;
3632 if (bed
->elf_backend_modify_segment_map
)
3634 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
3639 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3642 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
3643 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
3644 elf_elfheader (abfd
)->e_phnum
= count
;
3649 /* If we already counted the number of program segments, make sure
3650 that we allocated enough space. This happens when SIZEOF_HEADERS
3651 is used in a linker script. */
3652 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
3653 if (alloc
!= 0 && count
> alloc
)
3655 ((*_bfd_error_handler
)
3656 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3657 bfd_get_filename (abfd
), alloc
, count
));
3658 bfd_set_error (bfd_error_bad_value
);
3665 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
3666 phdrs
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
3670 off
= bed
->s
->sizeof_ehdr
;
3671 off
+= alloc
* bed
->s
->sizeof_phdr
;
3678 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3685 /* If elf_segment_map is not from map_sections_to_segments, the
3686 sections may not be correctly ordered. NOTE: sorting should
3687 not be done to the PT_NOTE section of a corefile, which may
3688 contain several pseudo-sections artificially created by bfd.
3689 Sorting these pseudo-sections breaks things badly. */
3691 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
3692 && m
->p_type
== PT_NOTE
))
3693 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
3696 p
->p_type
= m
->p_type
;
3697 p
->p_flags
= m
->p_flags
;
3699 if (p
->p_type
== PT_LOAD
3701 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
3703 if ((abfd
->flags
& D_PAGED
) != 0)
3704 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
3707 bfd_size_type align
;
3710 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3712 bfd_size_type secalign
;
3714 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
3715 if (secalign
> align
)
3719 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
3726 p
->p_vaddr
= m
->sections
[0]->vma
;
3728 if (m
->p_paddr_valid
)
3729 p
->p_paddr
= m
->p_paddr
;
3730 else if (m
->count
== 0)
3733 p
->p_paddr
= m
->sections
[0]->lma
;
3735 if (p
->p_type
== PT_LOAD
3736 && (abfd
->flags
& D_PAGED
) != 0)
3737 p
->p_align
= bed
->maxpagesize
;
3738 else if (m
->count
== 0)
3739 p
->p_align
= bed
->s
->file_align
;
3747 if (m
->includes_filehdr
)
3749 if (! m
->p_flags_valid
)
3752 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3753 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3756 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3758 if (p
->p_vaddr
< (bfd_vma
) off
)
3760 (*_bfd_error_handler
)
3761 (_("%s: Not enough room for program headers, try linking with -N"),
3762 bfd_get_filename (abfd
));
3763 bfd_set_error (bfd_error_bad_value
);
3768 if (! m
->p_paddr_valid
)
3771 if (p
->p_type
== PT_LOAD
)
3773 filehdr_vaddr
= p
->p_vaddr
;
3774 filehdr_paddr
= p
->p_paddr
;
3778 if (m
->includes_phdrs
)
3780 if (! m
->p_flags_valid
)
3783 if (m
->includes_filehdr
)
3785 if (p
->p_type
== PT_LOAD
)
3787 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3788 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3793 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3797 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3798 p
->p_vaddr
-= off
- p
->p_offset
;
3799 if (! m
->p_paddr_valid
)
3800 p
->p_paddr
-= off
- p
->p_offset
;
3803 if (p
->p_type
== PT_LOAD
)
3805 phdrs_vaddr
= p
->p_vaddr
;
3806 phdrs_paddr
= p
->p_paddr
;
3809 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3812 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3813 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3816 if (p
->p_type
== PT_LOAD
3817 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3819 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3825 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3826 p
->p_filesz
+= adjust
;
3827 p
->p_memsz
+= adjust
;
3833 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3837 bfd_size_type align
;
3841 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3843 /* The section may have artificial alignment forced by a
3844 link script. Notice this case by the gap between the
3845 cumulative phdr lma and the section's lma. */
3846 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3848 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3850 p
->p_memsz
+= adjust
;
3851 if (p
->p_type
== PT_LOAD
3852 || (p
->p_type
== PT_NOTE
3853 && bfd_get_format (abfd
) == bfd_core
))
3858 if ((flags
& SEC_LOAD
) != 0
3859 || (flags
& SEC_THREAD_LOCAL
) != 0)
3860 p
->p_filesz
+= adjust
;
3863 if (p
->p_type
== PT_LOAD
)
3865 bfd_signed_vma adjust
;
3867 if ((flags
& SEC_LOAD
) != 0)
3869 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3873 else if ((flags
& SEC_ALLOC
) != 0)
3875 /* The section VMA must equal the file position
3876 modulo the page size. FIXME: I'm not sure if
3877 this adjustment is really necessary. We used to
3878 not have the SEC_LOAD case just above, and then
3879 this was necessary, but now I'm not sure. */
3880 if ((abfd
->flags
& D_PAGED
) != 0)
3881 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
3883 adjust
= (sec
->vma
- voff
) % align
;
3892 (* _bfd_error_handler
) (_("\
3893 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3894 bfd_section_name (abfd
, sec
),
3899 p
->p_memsz
+= adjust
;
3902 if ((flags
& SEC_LOAD
) != 0)
3903 p
->p_filesz
+= adjust
;
3908 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3909 used in a linker script we may have a section with
3910 SEC_LOAD clear but which is supposed to have
3912 if ((flags
& SEC_LOAD
) != 0
3913 || (flags
& SEC_HAS_CONTENTS
) != 0)
3914 off
+= sec
->_raw_size
;
3916 if ((flags
& SEC_ALLOC
) != 0
3917 && ((flags
& SEC_LOAD
) != 0
3918 || (flags
& SEC_THREAD_LOCAL
) == 0))
3919 voff
+= sec
->_raw_size
;
3922 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
3924 /* The actual "note" segment has i == 0.
3925 This is the one that actually contains everything. */
3929 p
->p_filesz
= sec
->_raw_size
;
3930 off
+= sec
->_raw_size
;
3935 /* Fake sections -- don't need to be written. */
3938 flags
= sec
->flags
= 0;
3945 if ((sec
->flags
& SEC_LOAD
) != 0
3946 || (sec
->flags
& SEC_THREAD_LOCAL
) == 0
3947 || p
->p_type
== PT_TLS
)
3948 p
->p_memsz
+= sec
->_raw_size
;
3950 if ((flags
& SEC_LOAD
) != 0)
3951 p
->p_filesz
+= sec
->_raw_size
;
3953 if (p
->p_type
== PT_TLS
3954 && sec
->_raw_size
== 0
3955 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
3957 struct bfd_link_order
*o
;
3958 bfd_vma tbss_size
= 0;
3960 for (o
= sec
->link_order_head
; o
!= NULL
; o
= o
->next
)
3961 if (tbss_size
< o
->offset
+ o
->size
)
3962 tbss_size
= o
->offset
+ o
->size
;
3964 p
->p_memsz
+= tbss_size
;
3967 if (align
> p
->p_align
3968 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
3972 if (! m
->p_flags_valid
)
3975 if ((flags
& SEC_CODE
) != 0)
3977 if ((flags
& SEC_READONLY
) == 0)
3983 /* Now that we have set the section file positions, we can set up
3984 the file positions for the non PT_LOAD segments. */
3985 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3989 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
3991 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
3992 p
->p_offset
= m
->sections
[0]->filepos
;
3996 if (m
->includes_filehdr
)
3998 p
->p_vaddr
= filehdr_vaddr
;
3999 if (! m
->p_paddr_valid
)
4000 p
->p_paddr
= filehdr_paddr
;
4002 else if (m
->includes_phdrs
)
4004 p
->p_vaddr
= phdrs_vaddr
;
4005 if (! m
->p_paddr_valid
)
4006 p
->p_paddr
= phdrs_paddr
;
4011 /* Clear out any program headers we allocated but did not use. */
4012 for (; count
< alloc
; count
++, p
++)
4014 memset (p
, 0, sizeof *p
);
4015 p
->p_type
= PT_NULL
;
4018 elf_tdata (abfd
)->phdr
= phdrs
;
4020 elf_tdata (abfd
)->next_file_pos
= off
;
4022 /* Write out the program headers. */
4023 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4024 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
4030 /* Get the size of the program header.
4032 If this is called by the linker before any of the section VMA's are set, it
4033 can't calculate the correct value for a strange memory layout. This only
4034 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4035 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4036 data segment (exclusive of .interp and .dynamic).
4038 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4039 will be two segments. */
4041 static bfd_size_type
4042 get_program_header_size (abfd
)
4047 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4049 /* We can't return a different result each time we're called. */
4050 if (elf_tdata (abfd
)->program_header_size
!= 0)
4051 return elf_tdata (abfd
)->program_header_size
;
4053 if (elf_tdata (abfd
)->segment_map
!= NULL
)
4055 struct elf_segment_map
*m
;
4058 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4060 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4061 return elf_tdata (abfd
)->program_header_size
;
4064 /* Assume we will need exactly two PT_LOAD segments: one for text
4065 and one for data. */
4068 s
= bfd_get_section_by_name (abfd
, ".interp");
4069 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4071 /* If we have a loadable interpreter section, we need a
4072 PT_INTERP segment. In this case, assume we also need a
4073 PT_PHDR segment, although that may not be true for all
4078 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4080 /* We need a PT_DYNAMIC segment. */
4084 if (elf_tdata (abfd
)->eh_frame_hdr
)
4086 /* We need a PT_GNU_EH_FRAME segment. */
4090 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4092 if ((s
->flags
& SEC_LOAD
) != 0
4093 && strncmp (s
->name
, ".note", 5) == 0)
4095 /* We need a PT_NOTE segment. */
4100 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4102 if (s
->flags
& SEC_THREAD_LOCAL
)
4104 /* We need a PT_TLS segment. */
4110 /* Let the backend count up any program headers it might need. */
4111 if (bed
->elf_backend_additional_program_headers
)
4115 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
4121 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4122 return elf_tdata (abfd
)->program_header_size
;
4125 /* Work out the file positions of all the sections. This is called by
4126 _bfd_elf_compute_section_file_positions. All the section sizes and
4127 VMAs must be known before this is called.
4129 We do not consider reloc sections at this point, unless they form
4130 part of the loadable image. Reloc sections are assigned file
4131 positions in assign_file_positions_for_relocs, which is called by
4132 write_object_contents and final_link.
4134 We also don't set the positions of the .symtab and .strtab here. */
4137 assign_file_positions_except_relocs (abfd
)
4140 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
4141 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
4142 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4143 unsigned int num_sec
= elf_numsections (abfd
);
4145 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4147 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4148 && bfd_get_format (abfd
) != bfd_core
)
4150 Elf_Internal_Shdr
**hdrpp
;
4153 /* Start after the ELF header. */
4154 off
= i_ehdrp
->e_ehsize
;
4156 /* We are not creating an executable, which means that we are
4157 not creating a program header, and that the actual order of
4158 the sections in the file is unimportant. */
4159 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4161 Elf_Internal_Shdr
*hdr
;
4164 if (hdr
->sh_type
== SHT_REL
4165 || hdr
->sh_type
== SHT_RELA
4166 || i
== tdata
->symtab_section
4167 || i
== tdata
->symtab_shndx_section
4168 || i
== tdata
->strtab_section
)
4170 hdr
->sh_offset
= -1;
4173 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4175 if (i
== SHN_LORESERVE
- 1)
4177 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4178 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4185 Elf_Internal_Shdr
**hdrpp
;
4187 /* Assign file positions for the loaded sections based on the
4188 assignment of sections to segments. */
4189 if (! assign_file_positions_for_segments (abfd
))
4192 /* Assign file positions for the other sections. */
4194 off
= elf_tdata (abfd
)->next_file_pos
;
4195 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4197 Elf_Internal_Shdr
*hdr
;
4200 if (hdr
->bfd_section
!= NULL
4201 && hdr
->bfd_section
->filepos
!= 0)
4202 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
4203 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4205 ((*_bfd_error_handler
)
4206 (_("%s: warning: allocated section `%s' not in segment"),
4207 bfd_get_filename (abfd
),
4208 (hdr
->bfd_section
== NULL
4210 : hdr
->bfd_section
->name
)));
4211 if ((abfd
->flags
& D_PAGED
) != 0)
4212 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
4214 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
4215 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4218 else if (hdr
->sh_type
== SHT_REL
4219 || hdr
->sh_type
== SHT_RELA
4220 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4221 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4222 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4223 hdr
->sh_offset
= -1;
4225 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4227 if (i
== SHN_LORESERVE
- 1)
4229 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4230 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4235 /* Place the section headers. */
4236 off
= align_file_position (off
, bed
->s
->file_align
);
4237 i_ehdrp
->e_shoff
= off
;
4238 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4240 elf_tdata (abfd
)->next_file_pos
= off
;
4249 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4250 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4251 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4252 struct elf_strtab_hash
*shstrtab
;
4253 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4255 i_ehdrp
= elf_elfheader (abfd
);
4256 i_shdrp
= elf_elfsections (abfd
);
4258 shstrtab
= _bfd_elf_strtab_init ();
4259 if (shstrtab
== NULL
)
4262 elf_shstrtab (abfd
) = shstrtab
;
4264 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4265 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4266 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4267 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4269 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4270 i_ehdrp
->e_ident
[EI_DATA
] =
4271 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4272 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4274 if ((abfd
->flags
& DYNAMIC
) != 0)
4275 i_ehdrp
->e_type
= ET_DYN
;
4276 else if ((abfd
->flags
& EXEC_P
) != 0)
4277 i_ehdrp
->e_type
= ET_EXEC
;
4278 else if (bfd_get_format (abfd
) == bfd_core
)
4279 i_ehdrp
->e_type
= ET_CORE
;
4281 i_ehdrp
->e_type
= ET_REL
;
4283 switch (bfd_get_arch (abfd
))
4285 case bfd_arch_unknown
:
4286 i_ehdrp
->e_machine
= EM_NONE
;
4289 /* There used to be a long list of cases here, each one setting
4290 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4291 in the corresponding bfd definition. To avoid duplication,
4292 the switch was removed. Machines that need special handling
4293 can generally do it in elf_backend_final_write_processing(),
4294 unless they need the information earlier than the final write.
4295 Such need can generally be supplied by replacing the tests for
4296 e_machine with the conditions used to determine it. */
4298 if (get_elf_backend_data (abfd
) != NULL
)
4299 i_ehdrp
->e_machine
= get_elf_backend_data (abfd
)->elf_machine_code
;
4301 i_ehdrp
->e_machine
= EM_NONE
;
4304 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4305 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4307 /* No program header, for now. */
4308 i_ehdrp
->e_phoff
= 0;
4309 i_ehdrp
->e_phentsize
= 0;
4310 i_ehdrp
->e_phnum
= 0;
4312 /* Each bfd section is section header entry. */
4313 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4314 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4316 /* If we're building an executable, we'll need a program header table. */
4317 if (abfd
->flags
& EXEC_P
)
4319 /* It all happens later. */
4321 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
4323 /* elf_build_phdrs() returns a (NULL-terminated) array of
4324 Elf_Internal_Phdrs. */
4325 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
4326 i_ehdrp
->e_phoff
= outbase
;
4327 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
4332 i_ehdrp
->e_phentsize
= 0;
4334 i_ehdrp
->e_phoff
= 0;
4337 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4338 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4339 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4340 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4341 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4342 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4343 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4344 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4345 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4351 /* Assign file positions for all the reloc sections which are not part
4352 of the loadable file image. */
4355 _bfd_elf_assign_file_positions_for_relocs (abfd
)
4359 unsigned int i
, num_sec
;
4360 Elf_Internal_Shdr
**shdrpp
;
4362 off
= elf_tdata (abfd
)->next_file_pos
;
4364 num_sec
= elf_numsections (abfd
);
4365 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4367 Elf_Internal_Shdr
*shdrp
;
4370 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4371 && shdrp
->sh_offset
== -1)
4372 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4375 elf_tdata (abfd
)->next_file_pos
= off
;
4379 _bfd_elf_write_object_contents (abfd
)
4382 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4383 Elf_Internal_Ehdr
*i_ehdrp
;
4384 Elf_Internal_Shdr
**i_shdrp
;
4386 unsigned int count
, num_sec
;
4388 if (! abfd
->output_has_begun
4389 && ! _bfd_elf_compute_section_file_positions
4390 (abfd
, (struct bfd_link_info
*) NULL
))
4393 i_shdrp
= elf_elfsections (abfd
);
4394 i_ehdrp
= elf_elfheader (abfd
);
4397 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4401 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4403 /* After writing the headers, we need to write the sections too... */
4404 num_sec
= elf_numsections (abfd
);
4405 for (count
= 1; count
< num_sec
; count
++)
4407 if (bed
->elf_backend_section_processing
)
4408 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4409 if (i_shdrp
[count
]->contents
)
4411 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4413 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4414 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4417 if (count
== SHN_LORESERVE
- 1)
4418 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4421 /* Write out the section header names. */
4422 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4423 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4426 if (bed
->elf_backend_final_write_processing
)
4427 (*bed
->elf_backend_final_write_processing
) (abfd
,
4428 elf_tdata (abfd
)->linker
);
4430 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4434 _bfd_elf_write_corefile_contents (abfd
)
4437 /* Hopefully this can be done just like an object file. */
4438 return _bfd_elf_write_object_contents (abfd
);
4441 /* Given a section, search the header to find them. */
4444 _bfd_elf_section_from_bfd_section (abfd
, asect
)
4448 struct elf_backend_data
*bed
;
4451 if (elf_section_data (asect
) != NULL
4452 && elf_section_data (asect
)->this_idx
!= 0)
4453 return elf_section_data (asect
)->this_idx
;
4455 if (bfd_is_abs_section (asect
))
4457 else if (bfd_is_com_section (asect
))
4459 else if (bfd_is_und_section (asect
))
4463 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4464 int maxindex
= elf_numsections (abfd
);
4466 for (index
= 1; index
< maxindex
; index
++)
4468 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4470 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4476 bed
= get_elf_backend_data (abfd
);
4477 if (bed
->elf_backend_section_from_bfd_section
)
4481 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4486 bfd_set_error (bfd_error_nonrepresentable_section
);
4491 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4495 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
4497 asymbol
**asym_ptr_ptr
;
4499 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4501 flagword flags
= asym_ptr
->flags
;
4503 /* When gas creates relocations against local labels, it creates its
4504 own symbol for the section, but does put the symbol into the
4505 symbol chain, so udata is 0. When the linker is generating
4506 relocatable output, this section symbol may be for one of the
4507 input sections rather than the output section. */
4508 if (asym_ptr
->udata
.i
== 0
4509 && (flags
& BSF_SECTION_SYM
)
4510 && asym_ptr
->section
)
4514 if (asym_ptr
->section
->output_section
!= NULL
)
4515 indx
= asym_ptr
->section
->output_section
->index
;
4517 indx
= asym_ptr
->section
->index
;
4518 if (indx
< elf_num_section_syms (abfd
)
4519 && elf_section_syms (abfd
)[indx
] != NULL
)
4520 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4523 idx
= asym_ptr
->udata
.i
;
4527 /* This case can occur when using --strip-symbol on a symbol
4528 which is used in a relocation entry. */
4529 (*_bfd_error_handler
)
4530 (_("%s: symbol `%s' required but not present"),
4531 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4532 bfd_set_error (bfd_error_no_symbols
);
4539 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4540 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4541 elf_symbol_flags (flags
));
4549 /* Copy private BFD data. This copies any program header information. */
4552 copy_private_bfd_data (ibfd
, obfd
)
4556 Elf_Internal_Ehdr
*iehdr
;
4557 struct elf_segment_map
*map
;
4558 struct elf_segment_map
*map_first
;
4559 struct elf_segment_map
**pointer_to_map
;
4560 Elf_Internal_Phdr
*segment
;
4563 unsigned int num_segments
;
4564 bfd_boolean phdr_included
= FALSE
;
4565 bfd_vma maxpagesize
;
4566 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
4567 unsigned int phdr_adjust_num
= 0;
4568 struct elf_backend_data
*bed
;
4570 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4571 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4574 if (elf_tdata (ibfd
)->phdr
== NULL
)
4577 bed
= get_elf_backend_data (ibfd
);
4578 iehdr
= elf_elfheader (ibfd
);
4581 pointer_to_map
= &map_first
;
4583 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4584 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4586 /* Returns the end address of the segment + 1. */
4587 #define SEGMENT_END(segment, start) \
4588 (start + (segment->p_memsz > segment->p_filesz \
4589 ? segment->p_memsz : segment->p_filesz))
4591 #define SECTION_SIZE(section, segment) \
4592 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4593 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
4594 ? section->_raw_size : 0)
4596 /* Returns TRUE if the given section is contained within
4597 the given segment. VMA addresses are compared. */
4598 #define IS_CONTAINED_BY_VMA(section, segment) \
4599 (section->vma >= segment->p_vaddr \
4600 && (section->vma + SECTION_SIZE (section, segment) \
4601 <= (SEGMENT_END (segment, segment->p_vaddr))))
4603 /* Returns TRUE if the given section is contained within
4604 the given segment. LMA addresses are compared. */
4605 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4606 (section->lma >= base \
4607 && (section->lma + SECTION_SIZE (section, segment) \
4608 <= SEGMENT_END (segment, base)))
4610 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4611 #define IS_COREFILE_NOTE(p, s) \
4612 (p->p_type == PT_NOTE \
4613 && bfd_get_format (ibfd) == bfd_core \
4614 && s->vma == 0 && s->lma == 0 \
4615 && (bfd_vma) s->filepos >= p->p_offset \
4616 && ((bfd_vma) s->filepos + s->_raw_size \
4617 <= p->p_offset + p->p_filesz))
4619 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4620 linker, which generates a PT_INTERP section with p_vaddr and
4621 p_memsz set to 0. */
4622 #define IS_SOLARIS_PT_INTERP(p, s) \
4624 && p->p_paddr == 0 \
4625 && p->p_memsz == 0 \
4626 && p->p_filesz > 0 \
4627 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4628 && s->_raw_size > 0 \
4629 && (bfd_vma) s->filepos >= p->p_offset \
4630 && ((bfd_vma) s->filepos + s->_raw_size \
4631 <= p->p_offset + p->p_filesz))
4633 /* Decide if the given section should be included in the given segment.
4634 A section will be included if:
4635 1. It is within the address space of the segment -- we use the LMA
4636 if that is set for the segment and the VMA otherwise,
4637 2. It is an allocated segment,
4638 3. There is an output section associated with it,
4639 4. The section has not already been allocated to a previous segment.
4640 5. PT_TLS segment includes only SHF_TLS sections.
4641 6. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
4642 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4643 ((((segment->p_paddr \
4644 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4645 : IS_CONTAINED_BY_VMA (section, segment)) \
4646 && (section->flags & SEC_ALLOC) != 0) \
4647 || IS_COREFILE_NOTE (segment, section)) \
4648 && section->output_section != NULL \
4649 && (segment->p_type != PT_TLS \
4650 || (section->flags & SEC_THREAD_LOCAL)) \
4651 && (segment->p_type == PT_LOAD \
4652 || segment->p_type == PT_TLS \
4653 || (section->flags & SEC_THREAD_LOCAL) == 0) \
4654 && ! section->segment_mark)
4656 /* Returns TRUE iff seg1 starts after the end of seg2. */
4657 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4658 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4660 /* Returns TRUE iff seg1 and seg2 overlap. */
4661 #define SEGMENT_OVERLAPS(seg1, seg2) \
4662 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) \
4663 || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4665 /* Initialise the segment mark field. */
4666 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4667 section
->segment_mark
= FALSE
;
4669 /* Scan through the segments specified in the program header
4670 of the input BFD. For this first scan we look for overlaps
4671 in the loadable segments. These can be created by weird
4672 parameters to objcopy. Also, fix some solaris weirdness. */
4673 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4678 Elf_Internal_Phdr
*segment2
;
4680 if (segment
->p_type
== PT_INTERP
)
4681 for (section
= ibfd
->sections
; section
; section
= section
->next
)
4682 if (IS_SOLARIS_PT_INTERP (segment
, section
))
4684 /* Mininal change so that the normal section to segment
4685 assigment code will work. */
4686 segment
->p_vaddr
= section
->vma
;
4690 if (segment
->p_type
!= PT_LOAD
)
4693 /* Determine if this segment overlaps any previous segments. */
4694 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4696 bfd_signed_vma extra_length
;
4698 if (segment2
->p_type
!= PT_LOAD
4699 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4702 /* Merge the two segments together. */
4703 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4705 /* Extend SEGMENT2 to include SEGMENT and then delete
4708 SEGMENT_END (segment
, segment
->p_vaddr
)
4709 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4711 if (extra_length
> 0)
4713 segment2
->p_memsz
+= extra_length
;
4714 segment2
->p_filesz
+= extra_length
;
4717 segment
->p_type
= PT_NULL
;
4719 /* Since we have deleted P we must restart the outer loop. */
4721 segment
= elf_tdata (ibfd
)->phdr
;
4726 /* Extend SEGMENT to include SEGMENT2 and then delete
4729 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4730 - SEGMENT_END (segment
, segment
->p_vaddr
);
4732 if (extra_length
> 0)
4734 segment
->p_memsz
+= extra_length
;
4735 segment
->p_filesz
+= extra_length
;
4738 segment2
->p_type
= PT_NULL
;
4743 /* The second scan attempts to assign sections to segments. */
4744 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4748 unsigned int section_count
;
4749 asection
** sections
;
4750 asection
* output_section
;
4752 bfd_vma matching_lma
;
4753 bfd_vma suggested_lma
;
4757 if (segment
->p_type
== PT_NULL
)
4760 /* Compute how many sections might be placed into this segment. */
4762 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4763 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
4766 /* Allocate a segment map big enough to contain all of the
4767 sections we have selected. */
4768 amt
= sizeof (struct elf_segment_map
);
4769 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4770 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
4774 /* Initialise the fields of the segment map. Default to
4775 using the physical address of the segment in the input BFD. */
4777 map
->p_type
= segment
->p_type
;
4778 map
->p_flags
= segment
->p_flags
;
4779 map
->p_flags_valid
= 1;
4780 map
->p_paddr
= segment
->p_paddr
;
4781 map
->p_paddr_valid
= 1;
4783 /* Determine if this segment contains the ELF file header
4784 and if it contains the program headers themselves. */
4785 map
->includes_filehdr
= (segment
->p_offset
== 0
4786 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4788 map
->includes_phdrs
= 0;
4790 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4792 map
->includes_phdrs
=
4793 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4794 && (segment
->p_offset
+ segment
->p_filesz
4795 >= ((bfd_vma
) iehdr
->e_phoff
4796 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4798 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4799 phdr_included
= TRUE
;
4802 if (section_count
== 0)
4804 /* Special segments, such as the PT_PHDR segment, may contain
4805 no sections, but ordinary, loadable segments should contain
4806 something. They are allowed by the ELF spec however, so only
4807 a warning is produced. */
4808 if (segment
->p_type
== PT_LOAD
)
4809 (*_bfd_error_handler
)
4810 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4811 bfd_archive_filename (ibfd
));
4814 *pointer_to_map
= map
;
4815 pointer_to_map
= &map
->next
;
4820 /* Now scan the sections in the input BFD again and attempt
4821 to add their corresponding output sections to the segment map.
4822 The problem here is how to handle an output section which has
4823 been moved (ie had its LMA changed). There are four possibilities:
4825 1. None of the sections have been moved.
4826 In this case we can continue to use the segment LMA from the
4829 2. All of the sections have been moved by the same amount.
4830 In this case we can change the segment's LMA to match the LMA
4831 of the first section.
4833 3. Some of the sections have been moved, others have not.
4834 In this case those sections which have not been moved can be
4835 placed in the current segment which will have to have its size,
4836 and possibly its LMA changed, and a new segment or segments will
4837 have to be created to contain the other sections.
4839 4. The sections have been moved, but not be the same amount.
4840 In this case we can change the segment's LMA to match the LMA
4841 of the first section and we will have to create a new segment
4842 or segments to contain the other sections.
4844 In order to save time, we allocate an array to hold the section
4845 pointers that we are interested in. As these sections get assigned
4846 to a segment, they are removed from this array. */
4848 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4849 to work around this long long bug. */
4850 amt
= section_count
* sizeof (asection
*);
4851 sections
= (asection
**) bfd_malloc (amt
);
4852 if (sections
== NULL
)
4855 /* Step One: Scan for segment vs section LMA conflicts.
4856 Also add the sections to the section array allocated above.
4857 Also add the sections to the current segment. In the common
4858 case, where the sections have not been moved, this means that
4859 we have completely filled the segment, and there is nothing
4865 for (j
= 0, section
= ibfd
->sections
;
4867 section
= section
->next
)
4869 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
4871 output_section
= section
->output_section
;
4873 sections
[j
++] = section
;
4875 /* The Solaris native linker always sets p_paddr to 0.
4876 We try to catch that case here, and set it to the
4877 correct value. Note - some backends require that
4878 p_paddr be left as zero. */
4879 if (segment
->p_paddr
== 0
4880 && segment
->p_vaddr
!= 0
4881 && (! bed
->want_p_paddr_set_to_zero
)
4883 && output_section
->lma
!= 0
4884 && (output_section
->vma
== (segment
->p_vaddr
4885 + (map
->includes_filehdr
4888 + (map
->includes_phdrs
4890 * iehdr
->e_phentsize
)
4892 map
->p_paddr
= segment
->p_vaddr
;
4894 /* Match up the physical address of the segment with the
4895 LMA address of the output section. */
4896 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4897 || IS_COREFILE_NOTE (segment
, section
)
4898 || (bed
->want_p_paddr_set_to_zero
&&
4899 IS_CONTAINED_BY_VMA (output_section
, segment
))
4902 if (matching_lma
== 0)
4903 matching_lma
= output_section
->lma
;
4905 /* We assume that if the section fits within the segment
4906 then it does not overlap any other section within that
4908 map
->sections
[isec
++] = output_section
;
4910 else if (suggested_lma
== 0)
4911 suggested_lma
= output_section
->lma
;
4915 BFD_ASSERT (j
== section_count
);
4917 /* Step Two: Adjust the physical address of the current segment,
4919 if (isec
== section_count
)
4921 /* All of the sections fitted within the segment as currently
4922 specified. This is the default case. Add the segment to
4923 the list of built segments and carry on to process the next
4924 program header in the input BFD. */
4925 map
->count
= section_count
;
4926 *pointer_to_map
= map
;
4927 pointer_to_map
= &map
->next
;
4934 if (matching_lma
!= 0)
4936 /* At least one section fits inside the current segment.
4937 Keep it, but modify its physical address to match the
4938 LMA of the first section that fitted. */
4939 map
->p_paddr
= matching_lma
;
4943 /* None of the sections fitted inside the current segment.
4944 Change the current segment's physical address to match
4945 the LMA of the first section. */
4946 map
->p_paddr
= suggested_lma
;
4949 /* Offset the segment physical address from the lma
4950 to allow for space taken up by elf headers. */
4951 if (map
->includes_filehdr
)
4952 map
->p_paddr
-= iehdr
->e_ehsize
;
4954 if (map
->includes_phdrs
)
4956 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
4958 /* iehdr->e_phnum is just an estimate of the number
4959 of program headers that we will need. Make a note
4960 here of the number we used and the segment we chose
4961 to hold these headers, so that we can adjust the
4962 offset when we know the correct value. */
4963 phdr_adjust_num
= iehdr
->e_phnum
;
4964 phdr_adjust_seg
= map
;
4968 /* Step Three: Loop over the sections again, this time assigning
4969 those that fit to the current segment and removing them from the
4970 sections array; but making sure not to leave large gaps. Once all
4971 possible sections have been assigned to the current segment it is
4972 added to the list of built segments and if sections still remain
4973 to be assigned, a new segment is constructed before repeating
4981 /* Fill the current segment with sections that fit. */
4982 for (j
= 0; j
< section_count
; j
++)
4984 section
= sections
[j
];
4986 if (section
== NULL
)
4989 output_section
= section
->output_section
;
4991 BFD_ASSERT (output_section
!= NULL
);
4993 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4994 || IS_COREFILE_NOTE (segment
, section
))
4996 if (map
->count
== 0)
4998 /* If the first section in a segment does not start at
4999 the beginning of the segment, then something is
5001 if (output_section
->lma
!=
5003 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5004 + (map
->includes_phdrs
5005 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5011 asection
* prev_sec
;
5013 prev_sec
= map
->sections
[map
->count
- 1];
5015 /* If the gap between the end of the previous section
5016 and the start of this section is more than
5017 maxpagesize then we need to start a new segment. */
5018 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
,
5020 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5021 || ((prev_sec
->lma
+ prev_sec
->_raw_size
)
5022 > output_section
->lma
))
5024 if (suggested_lma
== 0)
5025 suggested_lma
= output_section
->lma
;
5031 map
->sections
[map
->count
++] = output_section
;
5034 section
->segment_mark
= TRUE
;
5036 else if (suggested_lma
== 0)
5037 suggested_lma
= output_section
->lma
;
5040 BFD_ASSERT (map
->count
> 0);
5042 /* Add the current segment to the list of built segments. */
5043 *pointer_to_map
= map
;
5044 pointer_to_map
= &map
->next
;
5046 if (isec
< section_count
)
5048 /* We still have not allocated all of the sections to
5049 segments. Create a new segment here, initialise it
5050 and carry on looping. */
5051 amt
= sizeof (struct elf_segment_map
);
5052 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5053 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
5057 /* Initialise the fields of the segment map. Set the physical
5058 physical address to the LMA of the first section that has
5059 not yet been assigned. */
5061 map
->p_type
= segment
->p_type
;
5062 map
->p_flags
= segment
->p_flags
;
5063 map
->p_flags_valid
= 1;
5064 map
->p_paddr
= suggested_lma
;
5065 map
->p_paddr_valid
= 1;
5066 map
->includes_filehdr
= 0;
5067 map
->includes_phdrs
= 0;
5070 while (isec
< section_count
);
5075 /* The Solaris linker creates program headers in which all the
5076 p_paddr fields are zero. When we try to objcopy or strip such a
5077 file, we get confused. Check for this case, and if we find it
5078 reset the p_paddr_valid fields. */
5079 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5080 if (map
->p_paddr
!= 0)
5084 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5085 map
->p_paddr_valid
= 0;
5088 elf_tdata (obfd
)->segment_map
= map_first
;
5090 /* If we had to estimate the number of program headers that were
5091 going to be needed, then check our estimate now and adjust
5092 the offset if necessary. */
5093 if (phdr_adjust_seg
!= NULL
)
5097 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5100 if (count
> phdr_adjust_num
)
5101 phdr_adjust_seg
->p_paddr
5102 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5106 /* Final Step: Sort the segments into ascending order of physical
5108 if (map_first
!= NULL
)
5110 struct elf_segment_map
*prev
;
5113 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
5115 /* Yes I know - its a bubble sort.... */
5116 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
5118 /* Swap map and map->next. */
5119 prev
->next
= map
->next
;
5120 map
->next
= map
->next
->next
;
5121 prev
->next
->next
= map
;
5132 #undef IS_CONTAINED_BY_VMA
5133 #undef IS_CONTAINED_BY_LMA
5134 #undef IS_COREFILE_NOTE
5135 #undef IS_SOLARIS_PT_INTERP
5136 #undef INCLUDE_SECTION_IN_SEGMENT
5137 #undef SEGMENT_AFTER_SEGMENT
5138 #undef SEGMENT_OVERLAPS
5142 /* Copy private section information. This copies over the entsize
5143 field, and sometimes the info field. */
5146 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
5152 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5154 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5155 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5158 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
5162 /* Only set up the segments if there are no more SEC_ALLOC
5163 sections. FIXME: This won't do the right thing if objcopy is
5164 used to remove the last SEC_ALLOC section, since objcopy
5165 won't call this routine in that case. */
5166 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
5167 if ((s
->flags
& SEC_ALLOC
) != 0)
5171 if (! copy_private_bfd_data (ibfd
, obfd
))
5176 ihdr
= &elf_section_data (isec
)->this_hdr
;
5177 ohdr
= &elf_section_data (osec
)->this_hdr
;
5179 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
5181 if (ihdr
->sh_type
== SHT_SYMTAB
5182 || ihdr
->sh_type
== SHT_DYNSYM
5183 || ihdr
->sh_type
== SHT_GNU_verneed
5184 || ihdr
->sh_type
== SHT_GNU_verdef
)
5185 ohdr
->sh_info
= ihdr
->sh_info
;
5187 /* Set things up for objcopy. The output SHT_GROUP section will
5188 have its elf_next_in_group pointing back to the input group
5190 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5191 elf_group_name (osec
) = elf_group_name (isec
);
5193 elf_section_data (osec
)->use_rela_p
5194 = elf_section_data (isec
)->use_rela_p
;
5199 /* Copy private symbol information. If this symbol is in a section
5200 which we did not map into a BFD section, try to map the section
5201 index correctly. We use special macro definitions for the mapped
5202 section indices; these definitions are interpreted by the
5203 swap_out_syms function. */
5205 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5206 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5207 #define MAP_STRTAB (SHN_HIOS + 3)
5208 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5209 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5212 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
5218 elf_symbol_type
*isym
, *osym
;
5220 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5221 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5224 isym
= elf_symbol_from (ibfd
, isymarg
);
5225 osym
= elf_symbol_from (obfd
, osymarg
);
5229 && bfd_is_abs_section (isym
->symbol
.section
))
5233 shndx
= isym
->internal_elf_sym
.st_shndx
;
5234 if (shndx
== elf_onesymtab (ibfd
))
5235 shndx
= MAP_ONESYMTAB
;
5236 else if (shndx
== elf_dynsymtab (ibfd
))
5237 shndx
= MAP_DYNSYMTAB
;
5238 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
5240 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
5241 shndx
= MAP_SHSTRTAB
;
5242 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
5243 shndx
= MAP_SYM_SHNDX
;
5244 osym
->internal_elf_sym
.st_shndx
= shndx
;
5250 /* Swap out the symbols. */
5253 swap_out_syms (abfd
, sttp
, relocatable_p
)
5255 struct bfd_strtab_hash
**sttp
;
5258 struct elf_backend_data
*bed
;
5261 struct bfd_strtab_hash
*stt
;
5262 Elf_Internal_Shdr
*symtab_hdr
;
5263 Elf_Internal_Shdr
*symtab_shndx_hdr
;
5264 Elf_Internal_Shdr
*symstrtab_hdr
;
5265 char *outbound_syms
;
5266 char *outbound_shndx
;
5270 if (!elf_map_symbols (abfd
))
5273 /* Dump out the symtabs. */
5274 stt
= _bfd_elf_stringtab_init ();
5278 bed
= get_elf_backend_data (abfd
);
5279 symcount
= bfd_get_symcount (abfd
);
5280 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5281 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5282 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
5283 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
5284 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
5285 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
5287 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5288 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5290 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
5291 outbound_syms
= bfd_alloc (abfd
, amt
);
5292 if (outbound_syms
== NULL
)
5294 symtab_hdr
->contents
= (PTR
) outbound_syms
;
5296 outbound_shndx
= NULL
;
5297 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
5298 if (symtab_shndx_hdr
->sh_name
!= 0)
5300 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
5301 outbound_shndx
= bfd_zalloc (abfd
, amt
);
5302 if (outbound_shndx
== NULL
)
5304 symtab_shndx_hdr
->contents
= outbound_shndx
;
5305 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
5306 symtab_shndx_hdr
->sh_size
= amt
;
5307 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
5308 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
5311 /* now generate the data (for "contents") */
5313 /* Fill in zeroth symbol and swap it out. */
5314 Elf_Internal_Sym sym
;
5320 sym
.st_shndx
= SHN_UNDEF
;
5321 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5322 outbound_syms
+= bed
->s
->sizeof_sym
;
5323 if (outbound_shndx
!= NULL
)
5324 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5327 syms
= bfd_get_outsymbols (abfd
);
5328 for (idx
= 0; idx
< symcount
; idx
++)
5330 Elf_Internal_Sym sym
;
5331 bfd_vma value
= syms
[idx
]->value
;
5332 elf_symbol_type
*type_ptr
;
5333 flagword flags
= syms
[idx
]->flags
;
5336 if ((flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
5338 /* Local section symbols have no name. */
5343 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
5346 if (sym
.st_name
== (unsigned long) -1)
5350 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
5352 if ((flags
& BSF_SECTION_SYM
) == 0
5353 && bfd_is_com_section (syms
[idx
]->section
))
5355 /* ELF common symbols put the alignment into the `value' field,
5356 and the size into the `size' field. This is backwards from
5357 how BFD handles it, so reverse it here. */
5358 sym
.st_size
= value
;
5359 if (type_ptr
== NULL
5360 || type_ptr
->internal_elf_sym
.st_value
== 0)
5361 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
5363 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
5364 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
5365 (abfd
, syms
[idx
]->section
);
5369 asection
*sec
= syms
[idx
]->section
;
5372 if (sec
->output_section
)
5374 value
+= sec
->output_offset
;
5375 sec
= sec
->output_section
;
5377 /* Don't add in the section vma for relocatable output. */
5378 if (! relocatable_p
)
5380 sym
.st_value
= value
;
5381 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
5383 if (bfd_is_abs_section (sec
)
5385 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
5387 /* This symbol is in a real ELF section which we did
5388 not create as a BFD section. Undo the mapping done
5389 by copy_private_symbol_data. */
5390 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
5394 shndx
= elf_onesymtab (abfd
);
5397 shndx
= elf_dynsymtab (abfd
);
5400 shndx
= elf_tdata (abfd
)->strtab_section
;
5403 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5406 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5414 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5420 /* Writing this would be a hell of a lot easier if
5421 we had some decent documentation on bfd, and
5422 knew what to expect of the library, and what to
5423 demand of applications. For example, it
5424 appears that `objcopy' might not set the
5425 section of a symbol to be a section that is
5426 actually in the output file. */
5427 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5428 BFD_ASSERT (sec2
!= 0);
5429 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5430 BFD_ASSERT (shndx
!= -1);
5434 sym
.st_shndx
= shndx
;
5437 if ((flags
& BSF_THREAD_LOCAL
) != 0)
5439 else if ((flags
& BSF_FUNCTION
) != 0)
5441 else if ((flags
& BSF_OBJECT
) != 0)
5446 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
5449 /* Processor-specific types */
5450 if (type_ptr
!= NULL
5451 && bed
->elf_backend_get_symbol_type
)
5452 type
= ((*bed
->elf_backend_get_symbol_type
)
5453 (&type_ptr
->internal_elf_sym
, type
));
5455 if (flags
& BSF_SECTION_SYM
)
5457 if (flags
& BSF_GLOBAL
)
5458 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5460 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5462 else if (bfd_is_com_section (syms
[idx
]->section
))
5463 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5464 else if (bfd_is_und_section (syms
[idx
]->section
))
5465 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5469 else if (flags
& BSF_FILE
)
5470 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5473 int bind
= STB_LOCAL
;
5475 if (flags
& BSF_LOCAL
)
5477 else if (flags
& BSF_WEAK
)
5479 else if (flags
& BSF_GLOBAL
)
5482 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5485 if (type_ptr
!= NULL
)
5486 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5490 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5491 outbound_syms
+= bed
->s
->sizeof_sym
;
5492 if (outbound_shndx
!= NULL
)
5493 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5497 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5498 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5500 symstrtab_hdr
->sh_flags
= 0;
5501 symstrtab_hdr
->sh_addr
= 0;
5502 symstrtab_hdr
->sh_entsize
= 0;
5503 symstrtab_hdr
->sh_link
= 0;
5504 symstrtab_hdr
->sh_info
= 0;
5505 symstrtab_hdr
->sh_addralign
= 1;
5510 /* Return the number of bytes required to hold the symtab vector.
5512 Note that we base it on the count plus 1, since we will null terminate
5513 the vector allocated based on this size. However, the ELF symbol table
5514 always has a dummy entry as symbol #0, so it ends up even. */
5517 _bfd_elf_get_symtab_upper_bound (abfd
)
5522 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5524 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5525 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5527 symtab_size
-= sizeof (asymbol
*);
5533 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
5538 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5540 if (elf_dynsymtab (abfd
) == 0)
5542 bfd_set_error (bfd_error_invalid_operation
);
5546 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5547 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5549 symtab_size
-= sizeof (asymbol
*);
5555 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
5556 bfd
*abfd ATTRIBUTE_UNUSED
;
5559 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5562 /* Canonicalize the relocs. */
5565 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5573 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5575 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
5578 tblptr
= section
->relocation
;
5579 for (i
= 0; i
< section
->reloc_count
; i
++)
5580 *relptr
++ = tblptr
++;
5584 return section
->reloc_count
;
5588 _bfd_elf_get_symtab (abfd
, alocation
)
5590 asymbol
**alocation
;
5592 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5593 long symcount
= bed
->s
->slurp_symbol_table (abfd
, alocation
, FALSE
);
5596 bfd_get_symcount (abfd
) = symcount
;
5601 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
5603 asymbol
**alocation
;
5605 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5606 long symcount
= bed
->s
->slurp_symbol_table (abfd
, alocation
, TRUE
);
5609 bfd_get_dynamic_symcount (abfd
) = symcount
;
5613 /* Return the size required for the dynamic reloc entries. Any
5614 section that was actually installed in the BFD, and has type
5615 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5616 considered to be a dynamic reloc section. */
5619 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
5625 if (elf_dynsymtab (abfd
) == 0)
5627 bfd_set_error (bfd_error_invalid_operation
);
5631 ret
= sizeof (arelent
*);
5632 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5633 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5634 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5635 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5636 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5637 * sizeof (arelent
*));
5642 /* Canonicalize the dynamic relocation entries. Note that we return
5643 the dynamic relocations as a single block, although they are
5644 actually associated with particular sections; the interface, which
5645 was designed for SunOS style shared libraries, expects that there
5646 is only one set of dynamic relocs. Any section that was actually
5647 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5648 the dynamic symbol table, is considered to be a dynamic reloc
5652 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
5657 bfd_boolean (*slurp_relocs
)
5658 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_boolean
));
5662 if (elf_dynsymtab (abfd
) == 0)
5664 bfd_set_error (bfd_error_invalid_operation
);
5668 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5670 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5672 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5673 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5674 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5679 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
5681 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5683 for (i
= 0; i
< count
; i
++)
5694 /* Read in the version information. */
5697 _bfd_elf_slurp_version_tables (abfd
)
5700 bfd_byte
*contents
= NULL
;
5703 if (elf_dynverdef (abfd
) != 0)
5705 Elf_Internal_Shdr
*hdr
;
5706 Elf_External_Verdef
*everdef
;
5707 Elf_Internal_Verdef
*iverdef
;
5708 Elf_Internal_Verdef
*iverdefarr
;
5709 Elf_Internal_Verdef iverdefmem
;
5711 unsigned int maxidx
;
5713 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5715 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5716 if (contents
== NULL
)
5718 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5719 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5722 /* We know the number of entries in the section but not the maximum
5723 index. Therefore we have to run through all entries and find
5725 everdef
= (Elf_External_Verdef
*) contents
;
5727 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5729 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5731 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5732 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5734 everdef
= ((Elf_External_Verdef
*)
5735 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5738 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5739 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
5740 if (elf_tdata (abfd
)->verdef
== NULL
)
5743 elf_tdata (abfd
)->cverdefs
= maxidx
;
5745 everdef
= (Elf_External_Verdef
*) contents
;
5746 iverdefarr
= elf_tdata (abfd
)->verdef
;
5747 for (i
= 0; i
< hdr
->sh_info
; i
++)
5749 Elf_External_Verdaux
*everdaux
;
5750 Elf_Internal_Verdaux
*iverdaux
;
5753 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5755 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5756 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5758 iverdef
->vd_bfd
= abfd
;
5760 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5761 iverdef
->vd_auxptr
= (Elf_Internal_Verdaux
*) bfd_alloc (abfd
, amt
);
5762 if (iverdef
->vd_auxptr
== NULL
)
5765 everdaux
= ((Elf_External_Verdaux
*)
5766 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5767 iverdaux
= iverdef
->vd_auxptr
;
5768 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5770 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5772 iverdaux
->vda_nodename
=
5773 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5774 iverdaux
->vda_name
);
5775 if (iverdaux
->vda_nodename
== NULL
)
5778 if (j
+ 1 < iverdef
->vd_cnt
)
5779 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5781 iverdaux
->vda_nextptr
= NULL
;
5783 everdaux
= ((Elf_External_Verdaux
*)
5784 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5787 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5789 if (i
+ 1 < hdr
->sh_info
)
5790 iverdef
->vd_nextdef
= iverdef
+ 1;
5792 iverdef
->vd_nextdef
= NULL
;
5794 everdef
= ((Elf_External_Verdef
*)
5795 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5802 if (elf_dynverref (abfd
) != 0)
5804 Elf_Internal_Shdr
*hdr
;
5805 Elf_External_Verneed
*everneed
;
5806 Elf_Internal_Verneed
*iverneed
;
5809 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5811 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5812 elf_tdata (abfd
)->verref
=
5813 (Elf_Internal_Verneed
*) bfd_zalloc (abfd
, amt
);
5814 if (elf_tdata (abfd
)->verref
== NULL
)
5817 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5819 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
5820 if (contents
== NULL
)
5822 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5823 || bfd_bread ((PTR
) contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5826 everneed
= (Elf_External_Verneed
*) contents
;
5827 iverneed
= elf_tdata (abfd
)->verref
;
5828 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
5830 Elf_External_Vernaux
*evernaux
;
5831 Elf_Internal_Vernaux
*ivernaux
;
5834 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
5836 iverneed
->vn_bfd
= abfd
;
5838 iverneed
->vn_filename
=
5839 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5841 if (iverneed
->vn_filename
== NULL
)
5844 amt
= iverneed
->vn_cnt
;
5845 amt
*= sizeof (Elf_Internal_Vernaux
);
5846 iverneed
->vn_auxptr
= (Elf_Internal_Vernaux
*) bfd_alloc (abfd
, amt
);
5848 evernaux
= ((Elf_External_Vernaux
*)
5849 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
5850 ivernaux
= iverneed
->vn_auxptr
;
5851 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
5853 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
5855 ivernaux
->vna_nodename
=
5856 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5857 ivernaux
->vna_name
);
5858 if (ivernaux
->vna_nodename
== NULL
)
5861 if (j
+ 1 < iverneed
->vn_cnt
)
5862 ivernaux
->vna_nextptr
= ivernaux
+ 1;
5864 ivernaux
->vna_nextptr
= NULL
;
5866 evernaux
= ((Elf_External_Vernaux
*)
5867 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
5870 if (i
+ 1 < hdr
->sh_info
)
5871 iverneed
->vn_nextref
= iverneed
+ 1;
5873 iverneed
->vn_nextref
= NULL
;
5875 everneed
= ((Elf_External_Verneed
*)
5876 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
5886 if (contents
== NULL
)
5892 _bfd_elf_make_empty_symbol (abfd
)
5895 elf_symbol_type
*newsym
;
5896 bfd_size_type amt
= sizeof (elf_symbol_type
);
5898 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
5903 newsym
->symbol
.the_bfd
= abfd
;
5904 return &newsym
->symbol
;
5909 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
5910 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5914 bfd_symbol_info (symbol
, ret
);
5917 /* Return whether a symbol name implies a local symbol. Most targets
5918 use this function for the is_local_label_name entry point, but some
5922 _bfd_elf_is_local_label_name (abfd
, name
)
5923 bfd
*abfd ATTRIBUTE_UNUSED
;
5926 /* Normal local symbols start with ``.L''. */
5927 if (name
[0] == '.' && name
[1] == 'L')
5930 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5931 DWARF debugging symbols starting with ``..''. */
5932 if (name
[0] == '.' && name
[1] == '.')
5935 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5936 emitting DWARF debugging output. I suspect this is actually a
5937 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5938 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5939 underscore to be emitted on some ELF targets). For ease of use,
5940 we treat such symbols as local. */
5941 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
5948 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
5949 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
5950 asymbol
*symbol ATTRIBUTE_UNUSED
;
5957 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
5959 enum bfd_architecture arch
;
5960 unsigned long machine
;
5962 /* If this isn't the right architecture for this backend, and this
5963 isn't the generic backend, fail. */
5964 if (arch
!= get_elf_backend_data (abfd
)->arch
5965 && arch
!= bfd_arch_unknown
5966 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
5969 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5972 /* Find the function to a particular section and offset,
5973 for error reporting. */
5976 elf_find_function (abfd
, section
, symbols
, offset
,
5977 filename_ptr
, functionname_ptr
)
5978 bfd
*abfd ATTRIBUTE_UNUSED
;
5982 const char **filename_ptr
;
5983 const char **functionname_ptr
;
5985 const char *filename
;
5994 for (p
= symbols
; *p
!= NULL
; p
++)
5998 q
= (elf_symbol_type
*) *p
;
6000 if (bfd_get_section (&q
->symbol
) != section
)
6003 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
6008 filename
= bfd_asymbol_name (&q
->symbol
);
6012 if (q
->symbol
.section
== section
6013 && q
->symbol
.value
>= low_func
6014 && q
->symbol
.value
<= offset
)
6016 func
= (asymbol
*) q
;
6017 low_func
= q
->symbol
.value
;
6027 *filename_ptr
= filename
;
6028 if (functionname_ptr
)
6029 *functionname_ptr
= bfd_asymbol_name (func
);
6034 /* Find the nearest line to a particular section and offset,
6035 for error reporting. */
6038 _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
6039 filename_ptr
, functionname_ptr
, line_ptr
)
6044 const char **filename_ptr
;
6045 const char **functionname_ptr
;
6046 unsigned int *line_ptr
;
6050 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
6051 filename_ptr
, functionname_ptr
,
6054 if (!*functionname_ptr
)
6055 elf_find_function (abfd
, section
, symbols
, offset
,
6056 *filename_ptr
? NULL
: filename_ptr
,
6062 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
6063 filename_ptr
, functionname_ptr
,
6065 &elf_tdata (abfd
)->dwarf2_find_line_info
))
6067 if (!*functionname_ptr
)
6068 elf_find_function (abfd
, section
, symbols
, offset
,
6069 *filename_ptr
? NULL
: filename_ptr
,
6075 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
6076 &found
, filename_ptr
,
6077 functionname_ptr
, line_ptr
,
6078 &elf_tdata (abfd
)->line_info
))
6080 if (found
&& (*functionname_ptr
|| *line_ptr
))
6083 if (symbols
== NULL
)
6086 if (! elf_find_function (abfd
, section
, symbols
, offset
,
6087 filename_ptr
, functionname_ptr
))
6095 _bfd_elf_sizeof_headers (abfd
, reloc
)
6101 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
6103 ret
+= get_program_header_size (abfd
);
6108 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
6113 bfd_size_type count
;
6115 Elf_Internal_Shdr
*hdr
;
6118 if (! abfd
->output_has_begun
6119 && ! (_bfd_elf_compute_section_file_positions
6120 (abfd
, (struct bfd_link_info
*) NULL
)))
6123 hdr
= &elf_section_data (section
)->this_hdr
;
6124 pos
= hdr
->sh_offset
+ offset
;
6125 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6126 || bfd_bwrite (location
, count
, abfd
) != count
)
6133 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
6134 bfd
*abfd ATTRIBUTE_UNUSED
;
6135 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
6136 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
6141 /* Try to convert a non-ELF reloc into an ELF one. */
6144 _bfd_elf_validate_reloc (abfd
, areloc
)
6148 /* Check whether we really have an ELF howto. */
6150 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
6152 bfd_reloc_code_real_type code
;
6153 reloc_howto_type
*howto
;
6155 /* Alien reloc: Try to determine its type to replace it with an
6156 equivalent ELF reloc. */
6158 if (areloc
->howto
->pc_relative
)
6160 switch (areloc
->howto
->bitsize
)
6163 code
= BFD_RELOC_8_PCREL
;
6166 code
= BFD_RELOC_12_PCREL
;
6169 code
= BFD_RELOC_16_PCREL
;
6172 code
= BFD_RELOC_24_PCREL
;
6175 code
= BFD_RELOC_32_PCREL
;
6178 code
= BFD_RELOC_64_PCREL
;
6184 howto
= bfd_reloc_type_lookup (abfd
, code
);
6186 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
6188 if (howto
->pcrel_offset
)
6189 areloc
->addend
+= areloc
->address
;
6191 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
6196 switch (areloc
->howto
->bitsize
)
6202 code
= BFD_RELOC_14
;
6205 code
= BFD_RELOC_16
;
6208 code
= BFD_RELOC_26
;
6211 code
= BFD_RELOC_32
;
6214 code
= BFD_RELOC_64
;
6220 howto
= bfd_reloc_type_lookup (abfd
, code
);
6224 areloc
->howto
= howto
;
6232 (*_bfd_error_handler
)
6233 (_("%s: unsupported relocation type %s"),
6234 bfd_archive_filename (abfd
), areloc
->howto
->name
);
6235 bfd_set_error (bfd_error_bad_value
);
6240 _bfd_elf_close_and_cleanup (abfd
)
6243 if (bfd_get_format (abfd
) == bfd_object
)
6245 if (elf_shstrtab (abfd
) != NULL
)
6246 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
6249 return _bfd_generic_close_and_cleanup (abfd
);
6252 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6253 in the relocation's offset. Thus we cannot allow any sort of sanity
6254 range-checking to interfere. There is nothing else to do in processing
6257 bfd_reloc_status_type
6258 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
6259 bfd
*abfd ATTRIBUTE_UNUSED
;
6260 arelent
*re ATTRIBUTE_UNUSED
;
6261 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
6262 PTR data ATTRIBUTE_UNUSED
;
6263 asection
*is ATTRIBUTE_UNUSED
;
6264 bfd
*obfd ATTRIBUTE_UNUSED
;
6265 char **errmsg ATTRIBUTE_UNUSED
;
6267 return bfd_reloc_ok
;
6270 /* Elf core file support. Much of this only works on native
6271 toolchains, since we rely on knowing the
6272 machine-dependent procfs structure in order to pick
6273 out details about the corefile. */
6275 #ifdef HAVE_SYS_PROCFS_H
6276 # include <sys/procfs.h>
6279 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6282 elfcore_make_pid (abfd
)
6285 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
6286 + (elf_tdata (abfd
)->core_pid
));
6289 /* If there isn't a section called NAME, make one, using
6290 data from SECT. Note, this function will generate a
6291 reference to NAME, so you shouldn't deallocate or
6295 elfcore_maybe_make_sect (abfd
, name
, sect
)
6302 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
6305 sect2
= bfd_make_section (abfd
, name
);
6309 sect2
->_raw_size
= sect
->_raw_size
;
6310 sect2
->filepos
= sect
->filepos
;
6311 sect2
->flags
= sect
->flags
;
6312 sect2
->alignment_power
= sect
->alignment_power
;
6316 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6317 actually creates up to two pseudosections:
6318 - For the single-threaded case, a section named NAME, unless
6319 such a section already exists.
6320 - For the multi-threaded case, a section named "NAME/PID", where
6321 PID is elfcore_make_pid (abfd).
6322 Both pseudosections have identical contents. */
6324 _bfd_elfcore_make_pseudosection (abfd
, name
, size
, filepos
)
6331 char *threaded_name
;
6335 /* Build the section name. */
6337 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
6338 len
= strlen (buf
) + 1;
6339 threaded_name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
6340 if (threaded_name
== NULL
)
6342 memcpy (threaded_name
, buf
, len
);
6344 sect
= bfd_make_section (abfd
, threaded_name
);
6347 sect
->_raw_size
= size
;
6348 sect
->filepos
= filepos
;
6349 sect
->flags
= SEC_HAS_CONTENTS
;
6350 sect
->alignment_power
= 2;
6352 return elfcore_maybe_make_sect (abfd
, name
, sect
);
6355 /* prstatus_t exists on:
6357 linux 2.[01] + glibc
6361 #if defined (HAVE_PRSTATUS_T)
6362 static bfd_boolean elfcore_grok_prstatus
6363 PARAMS ((bfd
*, Elf_Internal_Note
*));
6366 elfcore_grok_prstatus (abfd
, note
)
6368 Elf_Internal_Note
*note
;
6373 if (note
->descsz
== sizeof (prstatus_t
))
6377 raw_size
= sizeof (prstat
.pr_reg
);
6378 offset
= offsetof (prstatus_t
, pr_reg
);
6379 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6381 /* Do not overwrite the core signal if it
6382 has already been set by another thread. */
6383 if (elf_tdata (abfd
)->core_signal
== 0)
6384 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6385 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6387 /* pr_who exists on:
6390 pr_who doesn't exist on:
6393 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6394 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6397 #if defined (HAVE_PRSTATUS32_T)
6398 else if (note
->descsz
== sizeof (prstatus32_t
))
6400 /* 64-bit host, 32-bit corefile */
6401 prstatus32_t prstat
;
6403 raw_size
= sizeof (prstat
.pr_reg
);
6404 offset
= offsetof (prstatus32_t
, pr_reg
);
6405 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6407 /* Do not overwrite the core signal if it
6408 has already been set by another thread. */
6409 if (elf_tdata (abfd
)->core_signal
== 0)
6410 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6411 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6413 /* pr_who exists on:
6416 pr_who doesn't exist on:
6419 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6420 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6423 #endif /* HAVE_PRSTATUS32_T */
6426 /* Fail - we don't know how to handle any other
6427 note size (ie. data object type). */
6431 /* Make a ".reg/999" section and a ".reg" section. */
6432 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6433 raw_size
, note
->descpos
+ offset
);
6435 #endif /* defined (HAVE_PRSTATUS_T) */
6437 /* Create a pseudosection containing the exact contents of NOTE. */
6439 elfcore_make_note_pseudosection (abfd
, name
, note
)
6442 Elf_Internal_Note
*note
;
6444 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6445 note
->descsz
, note
->descpos
);
6448 /* There isn't a consistent prfpregset_t across platforms,
6449 but it doesn't matter, because we don't have to pick this
6450 data structure apart. */
6453 elfcore_grok_prfpreg (abfd
, note
)
6455 Elf_Internal_Note
*note
;
6457 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6460 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6461 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6465 elfcore_grok_prxfpreg (abfd
, note
)
6467 Elf_Internal_Note
*note
;
6469 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6472 #if defined (HAVE_PRPSINFO_T)
6473 typedef prpsinfo_t elfcore_psinfo_t
;
6474 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6475 typedef prpsinfo32_t elfcore_psinfo32_t
;
6479 #if defined (HAVE_PSINFO_T)
6480 typedef psinfo_t elfcore_psinfo_t
;
6481 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6482 typedef psinfo32_t elfcore_psinfo32_t
;
6486 /* return a malloc'ed copy of a string at START which is at
6487 most MAX bytes long, possibly without a terminating '\0'.
6488 the copy will always have a terminating '\0'. */
6491 _bfd_elfcore_strndup (abfd
, start
, max
)
6497 char *end
= memchr (start
, '\0', max
);
6505 dups
= bfd_alloc (abfd
, (bfd_size_type
) len
+ 1);
6509 memcpy (dups
, start
, len
);
6515 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6516 static bfd_boolean elfcore_grok_psinfo
6517 PARAMS ((bfd
*, Elf_Internal_Note
*));
6520 elfcore_grok_psinfo (abfd
, note
)
6522 Elf_Internal_Note
*note
;
6524 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6526 elfcore_psinfo_t psinfo
;
6528 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6530 elf_tdata (abfd
)->core_program
6531 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6532 sizeof (psinfo
.pr_fname
));
6534 elf_tdata (abfd
)->core_command
6535 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6536 sizeof (psinfo
.pr_psargs
));
6538 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6539 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6541 /* 64-bit host, 32-bit corefile */
6542 elfcore_psinfo32_t psinfo
;
6544 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6546 elf_tdata (abfd
)->core_program
6547 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6548 sizeof (psinfo
.pr_fname
));
6550 elf_tdata (abfd
)->core_command
6551 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6552 sizeof (psinfo
.pr_psargs
));
6558 /* Fail - we don't know how to handle any other
6559 note size (ie. data object type). */
6563 /* Note that for some reason, a spurious space is tacked
6564 onto the end of the args in some (at least one anyway)
6565 implementations, so strip it off if it exists. */
6568 char *command
= elf_tdata (abfd
)->core_command
;
6569 int n
= strlen (command
);
6571 if (0 < n
&& command
[n
- 1] == ' ')
6572 command
[n
- 1] = '\0';
6577 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6579 #if defined (HAVE_PSTATUS_T)
6580 static bfd_boolean elfcore_grok_pstatus
6581 PARAMS ((bfd
*, Elf_Internal_Note
*));
6584 elfcore_grok_pstatus (abfd
, note
)
6586 Elf_Internal_Note
*note
;
6588 if (note
->descsz
== sizeof (pstatus_t
)
6589 #if defined (HAVE_PXSTATUS_T)
6590 || note
->descsz
== sizeof (pxstatus_t
)
6596 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6598 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6600 #if defined (HAVE_PSTATUS32_T)
6601 else if (note
->descsz
== sizeof (pstatus32_t
))
6603 /* 64-bit host, 32-bit corefile */
6606 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6608 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6611 /* Could grab some more details from the "representative"
6612 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6613 NT_LWPSTATUS note, presumably. */
6617 #endif /* defined (HAVE_PSTATUS_T) */
6619 #if defined (HAVE_LWPSTATUS_T)
6620 static bfd_boolean elfcore_grok_lwpstatus
6621 PARAMS ((bfd
*, Elf_Internal_Note
*));
6624 elfcore_grok_lwpstatus (abfd
, note
)
6626 Elf_Internal_Note
*note
;
6628 lwpstatus_t lwpstat
;
6634 if (note
->descsz
!= sizeof (lwpstat
)
6635 #if defined (HAVE_LWPXSTATUS_T)
6636 && note
->descsz
!= sizeof (lwpxstatus_t
)
6641 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6643 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6644 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6646 /* Make a ".reg/999" section. */
6648 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6649 len
= strlen (buf
) + 1;
6650 name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
6653 memcpy (name
, buf
, len
);
6655 sect
= bfd_make_section (abfd
, name
);
6659 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6660 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6661 sect
->filepos
= note
->descpos
6662 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6665 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6666 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
6667 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6670 sect
->flags
= SEC_HAS_CONTENTS
;
6671 sect
->alignment_power
= 2;
6673 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6676 /* Make a ".reg2/999" section */
6678 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6679 len
= strlen (buf
) + 1;
6680 name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
6683 memcpy (name
, buf
, len
);
6685 sect
= bfd_make_section (abfd
, name
);
6689 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6690 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6691 sect
->filepos
= note
->descpos
6692 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6695 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6696 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
6697 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6700 sect
->flags
= SEC_HAS_CONTENTS
;
6701 sect
->alignment_power
= 2;
6703 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6705 #endif /* defined (HAVE_LWPSTATUS_T) */
6707 #if defined (HAVE_WIN32_PSTATUS_T)
6709 elfcore_grok_win32pstatus (abfd
, note
)
6711 Elf_Internal_Note
*note
;
6717 win32_pstatus_t pstatus
;
6719 if (note
->descsz
< sizeof (pstatus
))
6722 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6724 switch (pstatus
.data_type
)
6726 case NOTE_INFO_PROCESS
:
6727 /* FIXME: need to add ->core_command. */
6728 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6729 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6732 case NOTE_INFO_THREAD
:
6733 /* Make a ".reg/999" section. */
6734 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6736 len
= strlen (buf
) + 1;
6737 name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
6741 memcpy (name
, buf
, len
);
6743 sect
= bfd_make_section (abfd
, name
);
6747 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6748 sect
->filepos
= (note
->descpos
6749 + offsetof (struct win32_pstatus
,
6750 data
.thread_info
.thread_context
));
6751 sect
->flags
= SEC_HAS_CONTENTS
;
6752 sect
->alignment_power
= 2;
6754 if (pstatus
.data
.thread_info
.is_active_thread
)
6755 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6759 case NOTE_INFO_MODULE
:
6760 /* Make a ".module/xxxxxxxx" section. */
6761 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6763 len
= strlen (buf
) + 1;
6764 name
= bfd_alloc (abfd
, (bfd_size_type
) len
);
6768 memcpy (name
, buf
, len
);
6770 sect
= bfd_make_section (abfd
, name
);
6775 sect
->_raw_size
= note
->descsz
;
6776 sect
->filepos
= note
->descpos
;
6777 sect
->flags
= SEC_HAS_CONTENTS
;
6778 sect
->alignment_power
= 2;
6787 #endif /* HAVE_WIN32_PSTATUS_T */
6790 elfcore_grok_note (abfd
, note
)
6792 Elf_Internal_Note
*note
;
6794 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6802 if (bed
->elf_backend_grok_prstatus
)
6803 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6805 #if defined (HAVE_PRSTATUS_T)
6806 return elfcore_grok_prstatus (abfd
, note
);
6811 #if defined (HAVE_PSTATUS_T)
6813 return elfcore_grok_pstatus (abfd
, note
);
6816 #if defined (HAVE_LWPSTATUS_T)
6818 return elfcore_grok_lwpstatus (abfd
, note
);
6821 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6822 return elfcore_grok_prfpreg (abfd
, note
);
6824 #if defined (HAVE_WIN32_PSTATUS_T)
6825 case NT_WIN32PSTATUS
:
6826 return elfcore_grok_win32pstatus (abfd
, note
);
6829 case NT_PRXFPREG
: /* Linux SSE extension */
6830 if (note
->namesz
== 6
6831 && strcmp (note
->namedata
, "LINUX") == 0)
6832 return elfcore_grok_prxfpreg (abfd
, note
);
6838 if (bed
->elf_backend_grok_psinfo
)
6839 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6841 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6842 return elfcore_grok_psinfo (abfd
, note
);
6850 elfcore_netbsd_get_lwpid (note
, lwpidp
)
6851 Elf_Internal_Note
*note
;
6856 cp
= strchr (note
->namedata
, '@');
6859 *lwpidp
= atoi(cp
+ 1);
6866 elfcore_grok_netbsd_procinfo (abfd
, note
)
6868 Elf_Internal_Note
*note
;
6871 /* Signal number at offset 0x08. */
6872 elf_tdata (abfd
)->core_signal
6873 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
6875 /* Process ID at offset 0x50. */
6876 elf_tdata (abfd
)->core_pid
6877 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
6879 /* Command name at 0x7c (max 32 bytes, including nul). */
6880 elf_tdata (abfd
)->core_command
6881 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
6887 elfcore_grok_netbsd_note (abfd
, note
)
6889 Elf_Internal_Note
*note
;
6893 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
6894 elf_tdata (abfd
)->core_lwpid
= lwp
;
6896 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
6898 /* NetBSD-specific core "procinfo". Note that we expect to
6899 find this note before any of the others, which is fine,
6900 since the kernel writes this note out first when it
6901 creates a core file. */
6903 return elfcore_grok_netbsd_procinfo (abfd
, note
);
6906 /* As of Jan 2002 there are no other machine-independent notes
6907 defined for NetBSD core files. If the note type is less
6908 than the start of the machine-dependent note types, we don't
6911 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
6915 switch (bfd_get_arch (abfd
))
6917 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6918 PT_GETFPREGS == mach+2. */
6920 case bfd_arch_alpha
:
6921 case bfd_arch_sparc
:
6924 case NT_NETBSDCORE_FIRSTMACH
+0:
6925 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6927 case NT_NETBSDCORE_FIRSTMACH
+2:
6928 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6934 /* On all other arch's, PT_GETREGS == mach+1 and
6935 PT_GETFPREGS == mach+3. */
6940 case NT_NETBSDCORE_FIRSTMACH
+1:
6941 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6943 case NT_NETBSDCORE_FIRSTMACH
+3:
6944 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6953 /* Function: elfcore_write_note
6960 size of data for note
6963 End of buffer containing note. */
6966 elfcore_write_note (abfd
, buf
, bufsiz
, name
, type
, input
, size
)
6975 Elf_External_Note
*xnp
;
6985 struct elf_backend_data
*bed
;
6987 namesz
= strlen (name
) + 1;
6988 bed
= get_elf_backend_data (abfd
);
6989 pad
= -namesz
& (bed
->s
->file_align
- 1);
6992 newspace
= sizeof (Elf_External_Note
) - 1 + namesz
+ pad
+ size
;
6994 p
= realloc (buf
, *bufsiz
+ newspace
);
6996 *bufsiz
+= newspace
;
6997 xnp
= (Elf_External_Note
*) dest
;
6998 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
6999 H_PUT_32 (abfd
, size
, xnp
->descsz
);
7000 H_PUT_32 (abfd
, type
, xnp
->type
);
7004 memcpy (dest
, name
, namesz
);
7012 memcpy (dest
, input
, size
);
7016 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7018 elfcore_write_prpsinfo (abfd
, buf
, bufsiz
, fname
, psargs
)
7026 char *note_name
= "CORE";
7028 #if defined (HAVE_PSINFO_T)
7030 note_type
= NT_PSINFO
;
7033 note_type
= NT_PRPSINFO
;
7036 memset (&data
, 0, sizeof (data
));
7037 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
7038 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
7039 return elfcore_write_note (abfd
, buf
, bufsiz
,
7040 note_name
, note_type
, &data
, sizeof (data
));
7042 #endif /* PSINFO_T or PRPSINFO_T */
7044 #if defined (HAVE_PRSTATUS_T)
7046 elfcore_write_prstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
7055 char *note_name
= "CORE";
7057 memset (&prstat
, 0, sizeof (prstat
));
7058 prstat
.pr_pid
= pid
;
7059 prstat
.pr_cursig
= cursig
;
7060 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
7061 return elfcore_write_note (abfd
, buf
, bufsiz
,
7062 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
7064 #endif /* HAVE_PRSTATUS_T */
7066 #if defined (HAVE_LWPSTATUS_T)
7068 elfcore_write_lwpstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
7076 lwpstatus_t lwpstat
;
7077 char *note_name
= "CORE";
7079 memset (&lwpstat
, 0, sizeof (lwpstat
));
7080 lwpstat
.pr_lwpid
= pid
>> 16;
7081 lwpstat
.pr_cursig
= cursig
;
7082 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7083 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
7084 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7086 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
7087 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
7089 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
7090 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
7093 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7094 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
7096 #endif /* HAVE_LWPSTATUS_T */
7098 #if defined (HAVE_PSTATUS_T)
7100 elfcore_write_pstatus (abfd
, buf
, bufsiz
, pid
, cursig
, gregs
)
7109 char *note_name
= "CORE";
7111 memset (&pstat
, 0, sizeof (pstat
));
7112 pstat
.pr_pid
= pid
& 0xffff;
7113 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7114 NT_PSTATUS
, &pstat
, sizeof (pstat
));
7117 #endif /* HAVE_PSTATUS_T */
7120 elfcore_write_prfpreg (abfd
, buf
, bufsiz
, fpregs
, size
)
7127 char *note_name
= "CORE";
7128 return elfcore_write_note (abfd
, buf
, bufsiz
,
7129 note_name
, NT_FPREGSET
, fpregs
, size
);
7133 elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, xfpregs
, size
)
7140 char *note_name
= "LINUX";
7141 return elfcore_write_note (abfd
, buf
, bufsiz
,
7142 note_name
, NT_PRXFPREG
, xfpregs
, size
);
7146 elfcore_read_notes (abfd
, offset
, size
)
7157 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
7160 buf
= bfd_malloc (size
);
7164 if (bfd_bread (buf
, size
, abfd
) != size
)
7172 while (p
< buf
+ size
)
7174 /* FIXME: bad alignment assumption. */
7175 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
7176 Elf_Internal_Note in
;
7178 in
.type
= H_GET_32 (abfd
, xnp
->type
);
7180 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
7181 in
.namedata
= xnp
->name
;
7183 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
7184 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
7185 in
.descpos
= offset
+ (in
.descdata
- buf
);
7187 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
7189 if (! elfcore_grok_netbsd_note (abfd
, &in
))
7194 if (! elfcore_grok_note (abfd
, &in
))
7198 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
7205 /* Providing external access to the ELF program header table. */
7207 /* Return an upper bound on the number of bytes required to store a
7208 copy of ABFD's program header table entries. Return -1 if an error
7209 occurs; bfd_get_error will return an appropriate code. */
7212 bfd_get_elf_phdr_upper_bound (abfd
)
7215 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7217 bfd_set_error (bfd_error_wrong_format
);
7221 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
7224 /* Copy ABFD's program header table entries to *PHDRS. The entries
7225 will be stored as an array of Elf_Internal_Phdr structures, as
7226 defined in include/elf/internal.h. To find out how large the
7227 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7229 Return the number of program header table entries read, or -1 if an
7230 error occurs; bfd_get_error will return an appropriate code. */
7233 bfd_get_elf_phdrs (abfd
, phdrs
)
7239 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7241 bfd_set_error (bfd_error_wrong_format
);
7245 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
7246 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
7247 num_phdrs
* sizeof (Elf_Internal_Phdr
));
7253 _bfd_elf_sprintf_vma (abfd
, buf
, value
)
7254 bfd
*abfd ATTRIBUTE_UNUSED
;
7259 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7261 i_ehdrp
= elf_elfheader (abfd
);
7262 if (i_ehdrp
== NULL
)
7263 sprintf_vma (buf
, value
);
7266 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7268 #if BFD_HOST_64BIT_LONG
7269 sprintf (buf
, "%016lx", value
);
7271 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
7272 _bfd_int64_low (value
));
7276 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
7279 sprintf_vma (buf
, value
);
7284 _bfd_elf_fprintf_vma (abfd
, stream
, value
)
7285 bfd
*abfd ATTRIBUTE_UNUSED
;
7290 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7292 i_ehdrp
= elf_elfheader (abfd
);
7293 if (i_ehdrp
== NULL
)
7294 fprintf_vma ((FILE *) stream
, value
);
7297 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7299 #if BFD_HOST_64BIT_LONG
7300 fprintf ((FILE *) stream
, "%016lx", value
);
7302 fprintf ((FILE *) stream
, "%08lx%08lx",
7303 _bfd_int64_high (value
), _bfd_int64_low (value
));
7307 fprintf ((FILE *) stream
, "%08lx",
7308 (unsigned long) (value
& 0xffffffff));
7311 fprintf_vma ((FILE *) stream
, value
);
7315 enum elf_reloc_type_class
7316 _bfd_elf_reloc_type_class (rela
)
7317 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
;
7319 return reloc_class_normal
;
7322 /* For RELA architectures, return the relocation value for a
7323 relocation against a local symbol. */
7326 _bfd_elf_rela_local_sym (abfd
, sym
, sec
, rel
)
7328 Elf_Internal_Sym
*sym
;
7330 Elf_Internal_Rela
*rel
;
7334 relocation
= (sec
->output_section
->vma
7335 + sec
->output_offset
7337 if ((sec
->flags
& SEC_MERGE
)
7338 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
7339 && elf_section_data (sec
)->sec_info_type
== ELF_INFO_TYPE_MERGE
)
7345 _bfd_merged_section_offset (abfd
, &msec
,
7346 elf_section_data (sec
)->sec_info
,
7347 sym
->st_value
+ rel
->r_addend
,
7350 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
7356 _bfd_elf_rel_local_sym (abfd
, sym
, psec
, addend
)
7358 Elf_Internal_Sym
*sym
;
7362 asection
*sec
= *psec
;
7364 if (elf_section_data (sec
)->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
7365 return sym
->st_value
+ addend
;
7367 return _bfd_merged_section_offset (abfd
, psec
,
7368 elf_section_data (sec
)->sec_info
,
7369 sym
->st_value
+ addend
, (bfd_vma
) 0);
7373 _bfd_elf_section_offset (abfd
, info
, sec
, offset
)
7375 struct bfd_link_info
*info
;
7379 struct bfd_elf_section_data
*sec_data
;
7381 sec_data
= elf_section_data (sec
);
7382 switch (sec_data
->sec_info_type
)
7384 case ELF_INFO_TYPE_STABS
:
7385 return _bfd_stab_section_offset (abfd
,
7386 &elf_hash_table (info
)->merge_info
,
7387 sec
, &sec_data
->sec_info
, offset
);
7388 case ELF_INFO_TYPE_EH_FRAME
:
7389 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);